diff --git a/.binstar.yml b/.binstar.yml
deleted file mode 100644
index 7b507b4f90049..0000000000000
--- a/.binstar.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-package: pandas
-user: jreback
-
-install:
-  - conda config --add channels pandas
-
-before_script:
-  - python -V
-
-platform:
-  - linux-64
-  #- linux-32
-  - osx-64
-  #- win-32
-  - win-64
-engine:
-  - python=2.7
-  - python=3.4
-script:
-  - conda build conda.recipe --quiet
-
-iotimeout: 600
-
-build_targets: conda
-
-notifications:
-  email:
-    recipients: ['jeff@reback.net']
diff --git a/.devcontainer.json b/.devcontainer.json
new file mode 100644
index 0000000000000..315a1ff647012
--- /dev/null
+++ b/.devcontainer.json
@@ -0,0 +1,28 @@
+// For format details, see https://aka.ms/vscode-remote/devcontainer.json or the definition README at
+// https://github.com/microsoft/vscode-dev-containers/tree/master/containers/python-3-miniconda
+{
+	"name": "pandas",
+	"context": ".",
+	"dockerFile": "Dockerfile",
+
+	// Use 'settings' to set *default* container specific settings.json values on container create.
+	// You can edit these settings after create using File > Preferences > Settings > Remote.
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"python.condaPath": "/opt/conda/bin/conda",
+		"python.pythonPath": "/opt/conda/bin/python",
+		"python.formatting.provider": "black",
+		"python.linting.enabled": true,
+		"python.linting.flake8Enabled": true,
+		"python.linting.pylintEnabled": false,
+		"python.linting.mypyEnabled": true,
+		"python.testing.pytestEnabled": true,
+		"python.testing.cwd": "pandas/tests"
+	},
+
+	// Add the IDs of extensions you want installed when the container is created in the array below.
+	"extensions": [
+		"ms-python.python",
+		"ms-vscode.cpptools"
+	]
+}
diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md
index a1fbece3284ec..7dd2e04249492 100644
--- a/.github/CODE_OF_CONDUCT.md
+++ b/.github/CODE_OF_CONDUCT.md
@@ -54,10 +54,10 @@ incident.
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
 version 1.3.0, available at
-[http://contributor-covenant.org/version/1/3/0/][version],
+[https://www.contributor-covenant.org/version/1/3/0/][version],
 and the [Swift Code of Conduct][swift].
 
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/3/0/
+[homepage]: https://www.contributor-covenant.org
+[version]: https://www.contributor-covenant.org/version/1/3/0/
 [swift]: https://swift.org/community/#code-of-conduct
 
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 2e6e980242197..bc31d362118b5 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -16,7 +16,7 @@ If you notice a bug in the code or documentation, or have suggestions for how we
 
 ## Contributing to the Codebase
 
-The code is hosted on [GitHub](https://www.github.com/pandas-dev/pandas), so you will need to use [Git](http://git-scm.com/) to clone the project and make changes to the codebase. Once you have obtained a copy of the code, you should create a development environment that is separate from your existing Python environment so that you can make and test changes without compromising your own work environment. For more information, please refer to the "[Working with the code](https://github.com/pandas-dev/pandas/blob/master/doc/source/development/contributing.rst#working-with-the-code)" section.
+The code is hosted on [GitHub](https://www.github.com/pandas-dev/pandas), so you will need to use [Git](https://git-scm.com/) to clone the project and make changes to the codebase. Once you have obtained a copy of the code, you should create a development environment that is separate from your existing Python environment so that you can make and test changes without compromising your own work environment. For more information, please refer to the "[Working with the code](https://github.com/pandas-dev/pandas/blob/master/doc/source/development/contributing.rst#working-with-the-code)" section.
 
 Before submitting your changes for review, make sure to check that your changes do not break any tests. You can find more information about our test suites in the "[Test-driven development/code writing](https://github.com/pandas-dev/pandas/blob/master/doc/source/development/contributing.rst#test-driven-development-code-writing)" section. We also have guidelines regarding coding style that will be enforced during testing, which can be found in the "[Code standards](https://github.com/pandas-dev/pandas/blob/master/doc/source/development/contributing.rst#code-standards)" section.
 
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 944ce9b4fb1f6..27dfded808b95 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +1,3 @@
 custom: https://pandas.pydata.org/donate.html
+github: [numfocus]
 tidelift: pypi/pandas
diff --git a/.github/workflows/assign.yml b/.github/workflows/assign.yml
new file mode 100644
index 0000000000000..a6d3f1f383751
--- /dev/null
+++ b/.github/workflows/assign.yml
@@ -0,0 +1,14 @@
+name: Assign
+on:
+  issue_comment:
+    types: created
+
+jobs:
+  one:
+    runs-on: ubuntu-latest
+    steps:
+    - if: github.event.comment.body == 'take'
+      name:
+      run: |
+        echo "Assigning issue ${{ github.event.issue.number }} to ${{ github.event.comment.user.login }}"
+        curl -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" -d '{"assignees": ["${{ github.event.comment.user.login }}"]}' https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000000000..d87fa5203bd52
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,159 @@
+name: CI
+
+on:
+  push:
+    branches: master
+  pull_request:
+    branches: master
+
+env:
+  ENV_FILE: environment.yml
+
+jobs:
+  checks:
+    name: Checks
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Setting conda path
+      run: echo "::add-path::${HOME}/miniconda3/bin"
+
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Looking for unwanted patterns
+      run: ci/code_checks.sh patterns
+      if: always()
+
+    - name: Setup environment and build pandas
+      run: ci/setup_env.sh
+      if: always()
+
+    - name: Linting
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh lint
+      if: always()
+
+    - name: Dependencies consistency
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh dependencies
+      if: always()
+
+    - name: Checks on imported code
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh code
+      if: always()
+
+    - name: Running doctests
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh doctests
+      if: always()
+
+    - name: Docstring validation
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh docstrings
+      if: always()
+
+    - name: Typing validation
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh typing
+      if: always()
+
+    - name: Testing docstring validation script
+      run: |
+        source activate pandas-dev
+        pytest --capture=no --strict scripts
+      if: always()
+
+    - name: Running benchmarks
+      run: |
+        source activate pandas-dev
+        cd asv_bench
+        asv check -E existing
+        git remote add upstream https://github.com/pandas-dev/pandas.git
+        git fetch upstream
+        if git diff upstream/master --name-only | grep -q "^asv_bench/"; then
+            asv machine --yes
+            asv dev | sed "/failed$/ s/^/##[error]/" | tee benchmarks.log
+            if grep "failed" benchmarks.log > /dev/null ; then
+                exit 1
+            fi
+        else
+            echo "Benchmarks did not run, no changes detected"
+        fi
+      if: always()
+
+    - name: Publish benchmarks artifact
+      uses: actions/upload-artifact@master
+      with:
+        name: Benchmarks log
+        path: asv_bench/benchmarks.log
+      if: failure()
+
+  web_and_docs:
+    name: Web and docs
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Setting conda path
+      run: echo "::set-env name=PATH::${HOME}/miniconda3/bin:${PATH}"
+
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Setup environment and build pandas
+      run: ci/setup_env.sh
+
+    - name: Build website
+      run: |
+        source activate pandas-dev
+        python web/pandas_web.py web/pandas --target-path=web/build
+
+    - name: Build documentation
+      run: |
+        source activate pandas-dev
+        doc/make.py --warnings-are-errors | tee sphinx.log ; exit ${PIPESTATUS[0]}
+
+    # This can be removed when the ipython directive fails when there are errors,
+    # including the `tee sphinx.log` in te previous step (https://github.com/ipython/ipython/issues/11547)
+    - name: Check ipython directive errors
+      run: "! grep -B1 \"^<<<-------------------------------------------------------------------------$\" sphinx.log"
+
+    - name: Merge website and docs
+      run: |
+        mkdir -p pandas_web/docs
+        cp -r web/build/* pandas_web/
+        cp -r doc/build/html/* pandas_web/docs/
+      if: github.event_name == 'push'
+
+    - name: Install Rclone
+      run: sudo apt install rclone -y
+      if: github.event_name == 'push'
+
+    - name: Set up Rclone
+      run: |
+        RCLONE_CONFIG_PATH=$HOME/.config/rclone/rclone.conf
+        mkdir -p `dirname $RCLONE_CONFIG_PATH`
+        echo "[ovh_cloud_pandas_web]" > $RCLONE_CONFIG_PATH
+        echo "type = swift" >> $RCLONE_CONFIG_PATH
+        echo "env_auth = false" >> $RCLONE_CONFIG_PATH
+        echo "auth_version = 3" >> $RCLONE_CONFIG_PATH
+        echo "auth = https://auth.cloud.ovh.net/v3/" >> $RCLONE_CONFIG_PATH
+        echo "endpoint_type = public" >> $RCLONE_CONFIG_PATH
+        echo "tenant_domain = default" >> $RCLONE_CONFIG_PATH
+        echo "tenant = 2977553886518025" >> $RCLONE_CONFIG_PATH
+        echo "domain = default" >> $RCLONE_CONFIG_PATH
+        echo "user = w4KGs3pmDxpd" >> $RCLONE_CONFIG_PATH
+        echo "key = ${{ secrets.ovh_object_store_key }}" >> $RCLONE_CONFIG_PATH
+        echo "region = BHS" >> $RCLONE_CONFIG_PATH
+      if: github.event_name == 'push'
+
+    - name: Sync web
+      run: rclone sync pandas_web ovh_cloud_pandas_web:dev
+      if: github.event_name == 'push'
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index b79f0f71dac23..139b9e31df46c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/python/black
-    rev: stable
+    rev: 19.10b0
     hooks:
     -   id: black
         language_version: python3.7
@@ -9,9 +9,22 @@ repos:
     hooks:
     -   id: flake8
         language: python_venv
-        additional_dependencies: [flake8-comprehensions]
+        additional_dependencies: [flake8-comprehensions>=3.1.0]
 -   repo: https://github.com/pre-commit/mirrors-isort
-    rev: v4.3.20
+    rev: v4.3.21
     hooks:
     -   id: isort
         language: python_venv
+        exclude: ^pandas/__init__\.py$|^pandas/core/api\.py$
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.730
+    hooks:
+     -  id: mypy
+        args:
+          # As long as a some files are excluded from check-untyped-defs
+          # we have to exclude it from the pre-commit hook as the configuration
+          # is based on modules but the hook runs on files.
+          - --no-check-untyped-defs
+          - --follow-imports
+          - skip
+        files: pandas/
diff --git a/.travis.yml b/.travis.yml
index 79fecc41bec0d..2c8533d02ddc1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,5 @@
 language: python
-python: 3.5
+python: 3.7
 
 # To turn off cached cython files and compiler cache
 # set NOCACHE-true
@@ -7,10 +7,10 @@ python: 3.5
 # travis cache --delete inside the project directory from the travis command line client
 # The cache directories will be deleted if anything in ci/ changes in a commit
 cache:
- ccache: true
- directories:
-  - $HOME/.cache # cython cache
-  - $HOME/.ccache # compiler cache
+  ccache: true
+  directories:
+    - $HOME/.cache # cython cache
+    - $HOME/.ccache # compiler cache
 
 env:
   global:
@@ -20,37 +20,39 @@ env:
     - secure: "EkWLZhbrp/mXJOx38CHjs7BnjXafsqHtwxPQrqWy457VDFWhIY1DMnIR/lOWG+a20Qv52sCsFtiZEmMfUjf0pLGXOqurdxbYBGJ7/ikFLk9yV2rDwiArUlVM9bWFnFxHvdz9zewBH55WurrY4ShZWyV+x2dWjjceWG5VpWeI6sA="
 
 git:
-    # for cloning
-    depth: false
+  # for cloning
+  depth: false
 
 matrix:
-    fast_finish: true
-    exclude:
-      # Exclude the default Python 3.5 build
-      - python: 3.5
+  fast_finish: true
 
-    include:
-    - dist: trusty
-      env:
-        - JOB="3.7" ENV_FILE="ci/deps/travis-37.yaml" PATTERN="(not slow and not network)"
+  include:
+    - env:
+        - JOB="3.8" ENV_FILE="ci/deps/travis-38.yaml" PATTERN="(not slow and not network and not clipboard)"
 
-    - dist: trusty
-      env:
-        - JOB="3.6, locale" ENV_FILE="ci/deps/travis-36-locale.yaml" PATTERN="((not slow and not network) or (single and db))" LOCALE_OVERRIDE="zh_CN.UTF-8"
+    - env:
+        - JOB="3.7" ENV_FILE="ci/deps/travis-37.yaml" PATTERN="(not slow and not network and not clipboard)"
 
-    - dist: trusty
-      env:
-        - JOB="3.6, coverage" ENV_FILE="ci/deps/travis-36-cov.yaml" PATTERN="((not slow and not network) or (single and db))" PANDAS_TESTING_MODE="deprecate" COVERAGE=true
+    - env:
+        - JOB="3.6, locale" ENV_FILE="ci/deps/travis-36-locale.yaml" PATTERN="((not slow and not network and not clipboard) or (single and db))" LOCALE_OVERRIDE="zh_CN.UTF-8" SQL="1"
+      services:
+        - mysql
+        - postgresql
 
-    # In allow_failures
-    - dist: trusty
-      env:
-        - JOB="3.6, slow" ENV_FILE="ci/deps/travis-36-slow.yaml" PATTERN="slow"
+    - env:
+        # Enabling Deprecations when running tests
+        # PANDAS_TESTING_MODE="deprecate" causes DeprecationWarning messages to be displayed in the logs
+        # See pandas/_testing.py for more details.
+        - JOB="3.6, coverage" ENV_FILE="ci/deps/travis-36-cov.yaml" PATTERN="((not slow and not network and not clipboard) or (single and db))" PANDAS_TESTING_MODE="deprecate" COVERAGE=true SQL="1"
+      services:
+        - mysql
+        - postgresql
 
-    allow_failures:
-      - dist: trusty
-        env:
-          - JOB="3.6, slow" ENV_FILE="ci/deps/travis-36-slow.yaml" PATTERN="slow"
+    - env:
+        - JOB="3.6, slow" ENV_FILE="ci/deps/travis-36-slow.yaml" PATTERN="slow" SQL="1"
+      services:
+        - mysql
+        - postgresql
 
 before_install:
   - echo "before_install"
@@ -78,21 +80,14 @@ install:
   - ci/submit_cython_cache.sh
   - echo "install done"
 
-before_script:
-  # display server (for clipboard functionality) needs to be started here,
-  # does not work if done in install:setup_env.sh (GH-26103)
-  - export DISPLAY=":99.0"
-  - echo "sh -e /etc/init.d/xvfb start"
-  - sh -e /etc/init.d/xvfb start
-  - sleep 3
-
 script:
   - echo "script start"
+  - echo "$JOB"
   - source activate pandas-dev
   - ci/run_tests.sh
 
 after_script:
   - echo "after_script start"
   - source activate pandas-dev && pushd /tmp && python -c "import pandas; pandas.show_versions();" && popd
-  - ci/print_skipped.py 
+  - ci/print_skipped.py
   - echo "after_script done"
diff --git a/AUTHORS.md b/AUTHORS.md
index dcaaea101f4c8..f576e333f9448 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -14,7 +14,7 @@ About the Copyright Holders
     The PyData Development Team is the collection of developers of the PyData
     project. This includes all of the PyData sub-projects, including pandas. The
     core team that coordinates development on GitHub can be found here:
-    http://github.com/pydata.
+    https://github.com/pydata.
 
 Full credits for pandas contributors can be found in the documentation.
 
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000..b8aff5d671dcf
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,47 @@
+FROM continuumio/miniconda3
+
+# if you forked pandas, you can pass in your own GitHub username to use your fork
+# i.e. gh_username=myname
+ARG gh_username=pandas-dev
+ARG pandas_home="/home/pandas"
+
+# Avoid warnings by switching to noninteractive
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Configure apt and install packages
+RUN apt-get update \
+    && apt-get -y install --no-install-recommends apt-utils dialog 2>&1 \
+    #
+    # Verify git, process tools, lsb-release (common in install instructions for CLIs) installed
+    && apt-get -y install git iproute2 procps iproute2 lsb-release \
+    #
+    # Install C compilers (gcc not enough, so just went with build-essential which admittedly might be overkill),
+    # needed to build pandas C extensions
+    && apt-get -y install build-essential \
+    #
+    # cleanup
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf /var/lib/apt/lists/*
+
+# Switch back to dialog for any ad-hoc use of apt-get
+ENV DEBIAN_FRONTEND=dialog
+
+# Clone pandas repo
+RUN mkdir "$pandas_home" \
+    && git clone "https://github.com/$gh_username/pandas.git" "$pandas_home" \
+    && cd "$pandas_home" \
+    && git remote add upstream "https://github.com/pandas-dev/pandas.git" \
+    && git pull upstream master
+
+# Because it is surprisingly difficult to activate a conda environment inside a DockerFile
+# (from personal experience and per https://github.com/ContinuumIO/docker-images/issues/89),
+# we just update the base/root one from the 'environment.yml' file instead of creating a new one.
+#
+# Set up environment
+RUN conda env update -n base -f "$pandas_home/environment.yml"
+
+# Build C extensions and pandas
+RUN cd "$pandas_home" \
+    && python setup.py build_ext --inplace -j 4 \
+    && python -m pip install -e .
diff --git a/LICENSE b/LICENSE
index 924de26253bf4..76954a5a339ab 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,8 +1,10 @@
 BSD 3-Clause License
 
-Copyright (c) 2008-2012, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
+Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
 All rights reserved.
 
+Copyright (c) 2011-2020, Open source contributors.
+
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
diff --git a/LICENSES/MSGPACK_LICENSE b/LICENSES/MSGPACK_LICENSE
deleted file mode 100644
index ae1b0f2f32f06..0000000000000
--- a/LICENSES/MSGPACK_LICENSE
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright (C) 2008-2011 INADA Naoki <songofacandy@gmail.com>
-
-   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.
\ No newline at end of file
diff --git a/LICENSES/MSGPACK_NUMPY_LICENSE b/LICENSES/MSGPACK_NUMPY_LICENSE
deleted file mode 100644
index e570011efac73..0000000000000
--- a/LICENSES/MSGPACK_NUMPY_LICENSE
+++ /dev/null
@@ -1,33 +0,0 @@
-.. -*- rst -*-
-
-License
-=======
-
-Copyright (c) 2013, Lev Givon.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-* Neither the name of Lev Givon nor the names of any
-  contributors may be used to endorse or promote products derived
-  from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MANIFEST.in b/MANIFEST.in
index d82e64d0a68b8..cf6a1835433a4 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -15,16 +15,19 @@ graft pandas
 global-exclude *.bz2
 global-exclude *.csv
 global-exclude *.dta
+global-exclude *.feather
 global-exclude *.gz
 global-exclude *.h5
 global-exclude *.html
 global-exclude *.json
-global-exclude *.msgpack
 global-exclude *.pickle
 global-exclude *.png
 global-exclude *.pyc
 global-exclude *.pyd
+global-exclude *.ods
+global-exclude *.odt
 global-exclude *.sas7bdat
+global-exclude *.sav
 global-exclude *.so
 global-exclude *.xls
 global-exclude *.xlsm
diff --git a/Makefile b/Makefile
index 27a2c3682de9c..f26689ab65ba5 100644
--- a/Makefile
+++ b/Makefile
@@ -15,7 +15,7 @@ lint-diff:
 	git diff upstream/master --name-only -- "*.py" | xargs flake8
 
 black:
-	black . --exclude '(asv_bench/env|\.egg|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|_build|buck-out|build|dist|setup.py)'
+	black .
 
 develop: build
 	python -m pip install --no-build-isolation -e .
diff --git a/README.md b/README.md
index d5e71fc4740cf..5342eda4390eb 100644
--- a/README.md
+++ b/README.md
@@ -1,86 +1,20 @@
 <div align="center">
-  <img src="https://github.com/pandas-dev/pandas/blob/master/doc/logo/pandas_logo.png"><br>
+  <img src="https://dev.pandas.io/static/img/pandas.svg"><br>
 </div>
 
 -----------------
 
 # pandas: powerful Python data analysis toolkit
-
-<table>
-<tr>
-  <td>Latest Release</td>
-  <td>
-    <a href="https://pypi.org/project/pandas/">
-    <img src="https://img.shields.io/pypi/v/pandas.svg" alt="latest release" />
-    </a>
-  </td>
-</tr>
-  <td></td>
-  <td>
-    <a href="https://anaconda.org/anaconda/pandas/">
-    <img src="https://anaconda.org/conda-forge/pandas/badges/version.svg" alt="latest release" />
-    </a>
-</td>
-</tr>
-<tr>
-  <td>Package Status</td>
-  <td>
-		<a href="https://pypi.org/project/pandas/">
-		<img src="https://img.shields.io/pypi/status/pandas.svg" alt="status" />
-		</a>
-  </td>
-</tr>
-<tr>
-  <td>License</td>
-  <td>
-    <a href="https://github.com/pandas-dev/pandas/blob/master/LICENSE">
-    <img src="https://img.shields.io/pypi/l/pandas.svg" alt="license" />
-    </a>
-</td>
-</tr>
-<tr>
-  <td>Build Status</td>
-  <td>
-    <a href="https://travis-ci.org/pandas-dev/pandas">
-    <img src="https://travis-ci.org/pandas-dev/pandas.svg?branch=master" alt="travis build status" />
-    </a>
-  </td>
-</tr>
-<tr>
-  <td></td>
-  <td>
-    <a href="https://dev.azure.com/pandas-dev/pandas/_build/latest?definitionId=1&branch=master">
-      <img src="https://dev.azure.com/pandas-dev/pandas/_apis/build/status/pandas-dev.pandas?branch=master" alt="Azure Pipelines build status" />
-    </a>
-  </td>
-</tr>
-<tr>
-  <td>Coverage</td>
-  <td>
-    <a href="https://codecov.io/gh/pandas-dev/pandas">
-    <img src="https://codecov.io/github/pandas-dev/pandas/coverage.svg?branch=master" alt="coverage" />
-    </a>
-  </td>
-</tr>
-<tr>
-  <td>Downloads</td>
-  <td>
-    <a href="https://pandas.pydata.org">
-    <img src="https://anaconda.org/conda-forge/pandas/badges/downloads.svg" alt="conda-forge downloads" />
-    </a>
-  </td>
-</tr>
-<tr>
-	<td>Gitter</td>
-	<td>
-		<a href="https://gitter.im/pydata/pandas">
-		<img src="https://badges.gitter.im/Join%20Chat.svg" />
-		</a>
-	</td>
-</tr>
-</table>
-
-
+[![PyPI Latest Release](https://img.shields.io/pypi/v/pandas.svg)](https://pypi.org/project/pandas/)
+[![Conda Latest Release](https://anaconda.org/conda-forge/pandas/badges/version.svg)](https://anaconda.org/anaconda/pandas/)
+[![Package Status](https://img.shields.io/pypi/status/pandas.svg)](https://pypi.org/project/pandas/)
+[![License](https://img.shields.io/pypi/l/pandas.svg)](https://github.com/pandas-dev/pandas/blob/master/LICENSE)
+[![Travis Build Status](https://travis-ci.org/pandas-dev/pandas.svg?branch=master)](https://travis-ci.org/pandas-dev/pandas)
+[![Azure Build Status](https://dev.azure.com/pandas-dev/pandas/_apis/build/status/pandas-dev.pandas?branch=master)](https://dev.azure.com/pandas-dev/pandas/_build/latest?definitionId=1&branch=master)
+[![Coverage](https://codecov.io/github/pandas-dev/pandas/coverage.svg?branch=master)](https://codecov.io/gh/pandas-dev/pandas)
+[![Downloads](https://anaconda.org/conda-forge/pandas/badges/downloads.svg)](https://pandas.pydata.org)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/pydata/pandas)
+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
 
 ## What is it?
 
@@ -124,7 +58,7 @@ Here are just a few of the things that pandas does well:
     and saving/loading data from the ultrafast [**HDF5 format**][hdfstore]
   - [**Time series**][timeseries]-specific functionality: date range
     generation and frequency conversion, moving window statistics,
-    moving window linear regressions, date shifting and lagging, etc.
+    date shifting and lagging.
 
 
    [missing-data]: https://pandas.pydata.org/pandas-docs/stable/missing_data.html#working-with-missing-data
@@ -164,12 +98,11 @@ pip install pandas
 ```
 
 ## Dependencies
-- [NumPy](https://www.numpy.org): 1.13.3 or higher
-- [python-dateutil](https://labix.org/python-dateutil): 2.5.0 or higher
-- [pytz](https://pythonhosted.org/pytz): 2015.4 or higher
+- [NumPy](https://www.numpy.org)
+- [python-dateutil](https://labix.org/python-dateutil)
+- [pytz](https://pythonhosted.org/pytz)
 
-See the [full installation instructions](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies)
-for recommended and optional dependencies.
+See the [full installation instructions](https://pandas.pydata.org/pandas-docs/stable/install.html#dependencies) for minimum supported versions of required, recommended and optional dependencies.
 
 ## Installation from sources
 To install pandas from source you need Cython in addition to the normal
@@ -190,7 +123,7 @@ or for installing in [development mode](https://pip.pypa.io/en/latest/reference/
 
 
 ```sh
-python -m pip install --no-build-isolation -e .
+python -m pip install -e . --no-build-isolation --no-use-pep517
 ```
 
 If you have `make`, you can also use `make develop` to run the same command.
@@ -225,7 +158,7 @@ Most development discussion is taking place on github in this repo. Further, the
 
 All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome.
 
-A detailed overview on how to contribute can be found in the **[contributing guide](https://dev.pandas.io/contributing.html)**. There is also an [overview](.github/CONTRIBUTING.md) on GitHub.
+A detailed overview on how to contribute can be found in the **[contributing guide](https://dev.pandas.io/docs/contributing.html)**. There is also an [overview](.github/CONTRIBUTING.md) on GitHub.
 
 If you are simply looking to start working with the pandas codebase, navigate to the [GitHub "issues" tab](https://github.com/pandas-dev/pandas/issues) and start looking through interesting issues. There are a number of issues listed under [Docs](https://github.com/pandas-dev/pandas/issues?labels=Docs&sort=updated&state=open) and [good first issue](https://github.com/pandas-dev/pandas/issues?labels=good+first+issue&sort=updated&state=open) where you could start out.
 
diff --git a/RELEASE.md b/RELEASE.md
index efd075dabcba9..42cb82dfcf020 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -2,5 +2,5 @@ Release Notes
 =============
 
 The list of changes to Pandas between each release can be found
-[here](http://pandas.pydata.org/pandas-docs/stable/whatsnew.html). For full
-details, see the commit logs at http://github.com/pandas-dev/pandas.
+[here](https://pandas.pydata.org/pandas-docs/stable/whatsnew/index.html). For full
+details, see the commit logs at https://github.com/pandas-dev/pandas.
diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json
index c04bbf53a86a6..7886b63e9983e 100644
--- a/asv_bench/asv.conf.json
+++ b/asv_bench/asv.conf.json
@@ -7,7 +7,7 @@
     "project": "pandas",
 
     // The project's homepage
-    "project_url": "http://pandas.pydata.org/",
+    "project_url": "https://pandas.pydata.org/",
 
     // The URL of the source code repository for the project being
     // benchmarked
@@ -43,6 +43,7 @@
         "matplotlib": [],
         "sqlalchemy": [],
         "scipy": [],
+        "numba": [],
         "numexpr": [],
         "pytables": [null, ""],  // platform dependent, see excludes below
         "tables": [null, ""],
@@ -122,5 +123,8 @@
         ".*": "0409521665"
     },
     "regression_thresholds": {
-    }
+    },
+    "build_command":
+    ["python setup.py build -j4",
+     "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"],
 }
diff --git a/asv_bench/benchmarks/algorithms.py b/asv_bench/benchmarks/algorithms.py
index 7d97f2c740acb..0f3b3838de1b2 100644
--- a/asv_bench/benchmarks/algorithms.py
+++ b/asv_bench/benchmarks/algorithms.py
@@ -5,7 +5,8 @@
 from pandas._libs import lib
 
 import pandas as pd
-from pandas.util import testing as tm
+
+from .pandas_vb_common import tm
 
 for imp in ["pandas.util", "pandas.tools.hashing"]:
     try:
diff --git a/asv_bench/benchmarks/array.py b/asv_bench/benchmarks/array.py
new file mode 100644
index 0000000000000..8cbf8c8592661
--- /dev/null
+++ b/asv_bench/benchmarks/array.py
@@ -0,0 +1,23 @@
+import numpy as np
+
+import pandas as pd
+
+
+class BooleanArray:
+    def setup(self):
+        self.values_bool = np.array([True, False, True, False])
+        self.values_float = np.array([1.0, 0.0, 1.0, 0.0])
+        self.values_integer = np.array([1, 0, 1, 0])
+        self.values_integer_like = [1, 0, 1, 0]
+
+    def time_from_bool_array(self):
+        pd.array(self.values_bool, dtype="boolean")
+
+    def time_from_integer_array(self):
+        pd.array(self.values_integer, dtype="boolean")
+
+    def time_from_integer_like(self):
+        pd.array(self.values_integer_like, dtype="boolean")
+
+    def time_from_float_array(self):
+        pd.array(self.values_float, dtype="boolean")
diff --git a/asv_bench/benchmarks/attrs_caching.py b/asv_bench/benchmarks/attrs_caching.py
index 501e27b9078ec..9c7b107b478d4 100644
--- a/asv_bench/benchmarks/attrs_caching.py
+++ b/asv_bench/benchmarks/attrs_caching.py
@@ -1,5 +1,6 @@
 import numpy as np
 
+import pandas as pd
 from pandas import DataFrame
 
 try:
@@ -7,6 +8,11 @@
 except ImportError:
     from pandas.util.decorators import cache_readonly
 
+try:
+    from pandas.core.construction import extract_array
+except ImportError:
+    extract_array = None
+
 
 class DataFrameAttributes:
     def setup(self):
@@ -20,6 +26,33 @@ def time_set_index(self):
         self.df.index = self.cur_index
 
 
+class SeriesArrayAttribute:
+
+    params = [["numeric", "object", "category", "datetime64", "datetime64tz"]]
+    param_names = ["dtype"]
+
+    def setup(self, dtype):
+        if dtype == "numeric":
+            self.series = pd.Series([1, 2, 3])
+        elif dtype == "object":
+            self.series = pd.Series(["a", "b", "c"], dtype=object)
+        elif dtype == "category":
+            self.series = pd.Series(["a", "b", "c"], dtype="category")
+        elif dtype == "datetime64":
+            self.series = pd.Series(pd.date_range("2013", periods=3))
+        elif dtype == "datetime64tz":
+            self.series = pd.Series(pd.date_range("2013", periods=3, tz="UTC"))
+
+    def time_array(self, dtype):
+        self.series.array
+
+    def time_extract_array(self, dtype):
+        extract_array(self.series)
+
+    def time_extract_array_numpy(self, dtype):
+        extract_array(self.series, extract_numpy=True)
+
+
 class CacheReadonly:
     def setup(self):
         class Foo:
diff --git a/asv_bench/benchmarks/binary_ops.py b/asv_bench/benchmarks/binary_ops.py
index 58e0db67d6025..64e067d25a454 100644
--- a/asv_bench/benchmarks/binary_ops.py
+++ b/asv_bench/benchmarks/binary_ops.py
@@ -1,3 +1,5 @@
+import operator
+
 import numpy as np
 
 from pandas import DataFrame, Series, date_range
@@ -9,6 +11,36 @@
     import pandas.computation.expressions as expr
 
 
+class IntFrameWithScalar:
+    params = [
+        [np.float64, np.int64],
+        [2, 3.0, np.int32(4), np.float64(5)],
+        [
+            operator.add,
+            operator.sub,
+            operator.mul,
+            operator.truediv,
+            operator.floordiv,
+            operator.pow,
+            operator.mod,
+            operator.eq,
+            operator.ne,
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+        ],
+    ]
+    param_names = ["dtype", "scalar", "op"]
+
+    def setup(self, dtype, scalar, op):
+        arr = np.random.randn(20000, 100)
+        self.df = DataFrame(arr.astype(dtype))
+
+    def time_frame_op_with_scalar(self, dtype, scalar, op):
+        op(self.df, scalar)
+
+
 class Ops:
 
     params = [[True, False], ["default", 1]]
diff --git a/asv_bench/benchmarks/boolean.py b/asv_bench/benchmarks/boolean.py
new file mode 100644
index 0000000000000..71c422c641775
--- /dev/null
+++ b/asv_bench/benchmarks/boolean.py
@@ -0,0 +1,32 @@
+import numpy as np
+
+import pandas as pd
+
+
+class TimeLogicalOps:
+    def setup(self):
+        N = 10_000
+        left, right, lmask, rmask = np.random.randint(0, 2, size=(4, N)).astype("bool")
+        self.left = pd.arrays.BooleanArray(left, lmask)
+        self.right = pd.arrays.BooleanArray(right, rmask)
+
+    def time_or_scalar(self):
+        self.left | True
+        self.left | False
+
+    def time_or_array(self):
+        self.left | self.right
+
+    def time_and_scalar(self):
+        self.left & True
+        self.left & False
+
+    def time_and_array(self):
+        self.left & self.right
+
+    def time_xor_scalar(self):
+        self.left ^ True
+        self.left ^ False
+
+    def time_xor_array(self):
+        self.left ^ self.right
diff --git a/asv_bench/benchmarks/categoricals.py b/asv_bench/benchmarks/categoricals.py
index 559aa7050a640..1dcd52ac074a6 100644
--- a/asv_bench/benchmarks/categoricals.py
+++ b/asv_bench/benchmarks/categoricals.py
@@ -3,7 +3,8 @@
 import numpy as np
 
 import pandas as pd
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 try:
     from pandas.api.types import union_categoricals
@@ -14,21 +15,6 @@
         pass
 
 
-class Concat:
-    def setup(self):
-        N = 10 ** 5
-        self.s = pd.Series(list("aabbcd") * N).astype("category")
-
-        self.a = pd.Categorical(list("aabbcd") * N)
-        self.b = pd.Categorical(list("bbcdjk") * N)
-
-    def time_concat(self):
-        pd.concat([self.s, self.s])
-
-    def time_union(self):
-        union_categoricals([self.a, self.b])
-
-
 class Constructor:
     def setup(self):
         N = 10 ** 5
@@ -77,6 +63,33 @@ def time_existing_series(self):
         pd.Categorical(self.series)
 
 
+class CategoricalOps:
+    params = ["__lt__", "__le__", "__eq__", "__ne__", "__ge__", "__gt__"]
+    param_names = ["op"]
+
+    def setup(self, op):
+        N = 10 ** 5
+        self.cat = pd.Categorical(list("aabbcd") * N, ordered=True)
+
+    def time_categorical_op(self, op):
+        getattr(self.cat, op)("b")
+
+
+class Concat:
+    def setup(self):
+        N = 10 ** 5
+        self.s = pd.Series(list("aabbcd") * N).astype("category")
+
+        self.a = pd.Categorical(list("aabbcd") * N)
+        self.b = pd.Categorical(list("bbcdjk") * N)
+
+    def time_concat(self):
+        pd.concat([self.s, self.s])
+
+    def time_union(self):
+        union_categoricals([self.a, self.b])
+
+
 class ValueCounts:
 
     params = [True, False]
@@ -84,7 +97,7 @@ class ValueCounts:
 
     def setup(self, dropna):
         n = 5 * 10 ** 5
-        arr = ["s{:04d}".format(i) for i in np.random.randint(0, n // 10, size=n)]
+        arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
     def time_value_counts(self, dropna):
@@ -102,7 +115,7 @@ def time_rendering(self):
 class SetCategories:
     def setup(self):
         n = 5 * 10 ** 5
-        arr = ["s{:04d}".format(i) for i in np.random.randint(0, n // 10, size=n)]
+        arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
     def time_set_categories(self):
@@ -112,7 +125,7 @@ def time_set_categories(self):
 class RemoveCategories:
     def setup(self):
         n = 5 * 10 ** 5
-        arr = ["s{:04d}".format(i) for i in np.random.randint(0, n // 10, size=n)]
+        arr = [f"s{i:04d}" for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype("category")
 
     def time_remove_categories(self):
@@ -164,9 +177,9 @@ def setup(self, dtype):
         np.random.seed(1234)
         n = 5 * 10 ** 5
         sample_size = 100
-        arr = [i for i in np.random.randint(0, n // 10, size=n)]
+        arr = list(np.random.randint(0, n // 10, size=n))
         if dtype == "object":
-            arr = ["s{:04d}".format(i) for i in arr]
+            arr = [f"s{i:04d}" for i in arr]
         self.sample = np.random.choice(arr, sample_size)
         self.series = pd.Series(arr).astype("category")
 
@@ -225,7 +238,7 @@ def setup(self, index):
         elif index == "non_monotonic":
             self.data = pd.Categorical.from_codes([0, 1, 2] * N, categories=categories)
         else:
-            raise ValueError("Invalid index param: {}".format(index))
+            raise ValueError(f"Invalid index param: {index}")
 
         self.scalar = 10000
         self.list = list(range(10000))
@@ -282,4 +295,18 @@ def time_sort_values(self):
         self.index.sort_values(ascending=False)
 
 
+class SearchSorted:
+    def setup(self):
+        N = 10 ** 5
+        self.ci = tm.makeCategoricalIndex(N).sort_values()
+        self.c = self.ci.values
+        self.key = self.ci.categories[1]
+
+    def time_categorical_index_contains(self):
+        self.ci.searchsorted(self.key)
+
+    def time_categorical_contains(self):
+        self.c.searchsorted(self.key)
+
+
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/ctors.py b/asv_bench/benchmarks/ctors.py
index ec3dd7a48a89f..7c43485f5ef45 100644
--- a/asv_bench/benchmarks/ctors.py
+++ b/asv_bench/benchmarks/ctors.py
@@ -1,7 +1,8 @@
 import numpy as np
 
 from pandas import DatetimeIndex, Index, MultiIndex, Series, Timestamp
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 def no_change(arr):
@@ -67,7 +68,7 @@ class SeriesConstructors:
     def setup(self, data_fmt, with_index, dtype):
         if data_fmt in (gen_of_str, gen_of_tuples) and with_index:
             raise NotImplementedError(
-                "Series constructors do not support " "using generators with indexes"
+                "Series constructors do not support using generators with indexes"
             )
         N = 10 ** 4
         if dtype == "float":
diff --git a/asv_bench/benchmarks/dtypes.py b/asv_bench/benchmarks/dtypes.py
index 24cc1c6f9fa70..bd17b710b108d 100644
--- a/asv_bench/benchmarks/dtypes.py
+++ b/asv_bench/benchmarks/dtypes.py
@@ -5,6 +5,7 @@
 from .pandas_vb_common import (
     datetime_dtypes,
     extension_dtypes,
+    lib,
     numeric_dtypes,
     string_dtypes,
 )
@@ -40,4 +41,25 @@ def time_pandas_dtype_invalid(self, dtype):
             pass
 
 
+class InferDtypes:
+    param_names = ["dtype"]
+    data_dict = {
+        "np-object": np.array([1] * 100000, dtype="O"),
+        "py-object": [1] * 100000,
+        "np-null": np.array([1] * 50000 + [np.nan] * 50000),
+        "py-null": [1] * 50000 + [None] * 50000,
+        "np-int": np.array([1] * 100000, dtype=int),
+        "np-floating": np.array([1.0] * 100000, dtype=float),
+        "empty": [],
+        "bytes": [b"a"] * 100000,
+    }
+    params = list(data_dict.keys())
+
+    def time_infer_skipna(self, dtype):
+        lib.infer_dtype(self.data_dict[dtype], skipna=True)
+
+    def time_infer(self, dtype):
+        lib.infer_dtype(self.data_dict[dtype], skipna=False)
+
+
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/eval.py b/asv_bench/benchmarks/eval.py
index 06a181875aaa8..cbab9fdc9c0ba 100644
--- a/asv_bench/benchmarks/eval.py
+++ b/asv_bench/benchmarks/eval.py
@@ -27,7 +27,7 @@ def time_add(self, engine, threads):
 
     def time_and(self, engine, threads):
         pd.eval(
-            "(self.df > 0) & (self.df2 > 0) & " "(self.df3 > 0) & (self.df4 > 0)",
+            "(self.df > 0) & (self.df2 > 0) & (self.df3 > 0) & (self.df4 > 0)",
             engine=engine,
         )
 
diff --git a/asv_bench/benchmarks/frame_ctor.py b/asv_bench/benchmarks/frame_ctor.py
index 3944e0bc523d8..2b24bab85bc57 100644
--- a/asv_bench/benchmarks/frame_ctor.py
+++ b/asv_bench/benchmarks/frame_ctor.py
@@ -1,7 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 try:
     from pandas.tseries.offsets import Nano, Hour
@@ -99,10 +100,22 @@ class FromLists:
     def setup(self):
         N = 1000
         M = 100
-        self.data = [[j for j in range(M)] for i in range(N)]
+        self.data = [list(range(M)) for i in range(N)]
 
     def time_frame_from_lists(self):
         self.df = DataFrame(self.data)
 
 
+class FromRange:
+
+    goal_time = 0.2
+
+    def setup(self):
+        N = 1_000_000
+        self.data = range(N)
+
+    def time_frame_from_range(self):
+        self.df = DataFrame(self.data)
+
+
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index 05f98c66faa2b..2187668c96ca4 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -4,7 +4,8 @@
 import numpy as np
 
 from pandas import DataFrame, MultiIndex, NaT, Series, date_range, isnull, period_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 class GetNumericData:
@@ -321,10 +322,9 @@ class Dropna:
 
     def setup(self, how, axis):
         self.df = DataFrame(np.random.randn(10000, 1000))
-        with warnings.catch_warnings(record=True):
-            self.df.ix[50:1000, 20:50] = np.nan
-            self.df.ix[2000:3000] = np.nan
-            self.df.ix[:, 60:70] = np.nan
+        self.df.iloc[50:1000, 20:50] = np.nan
+        self.df.iloc[2000:3000] = np.nan
+        self.df.iloc[:, 60:70] = np.nan
         self.df_mixed = self.df.copy()
         self.df_mixed["foo"] = "bar"
 
@@ -342,10 +342,9 @@ class Count:
 
     def setup(self, axis):
         self.df = DataFrame(np.random.randn(10000, 1000))
-        with warnings.catch_warnings(record=True):
-            self.df.ix[50:1000, 20:50] = np.nan
-            self.df.ix[2000:3000] = np.nan
-            self.df.ix[:, 60:70] = np.nan
+        self.df.iloc[50:1000, 20:50] = np.nan
+        self.df.iloc[2000:3000] = np.nan
+        self.df.iloc[:, 60:70] = np.nan
         self.df_mixed = self.df.copy()
         self.df_mixed["foo"] = "bar"
 
@@ -565,7 +564,7 @@ def setup(self):
 
     def time_frame_get_dtype_counts(self):
         with warnings.catch_warnings(record=True):
-            self.df.get_dtype_counts()
+            self.df._data.get_dtype_counts()
 
     def time_info(self):
         self.df.info()
@@ -609,4 +608,15 @@ def time_dataframe_describe(self):
         self.df.describe()
 
 
+class SelectDtypes:
+    params = [100, 1000]
+    param_names = ["n"]
+
+    def setup(self, n):
+        self.df = DataFrame(np.random.randn(10, n))
+
+    def time_select_dtypes(self, n):
+        self.df.select_dtypes(include="int")
+
+
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/gil.py b/asv_bench/benchmarks/gil.py
index d57492dd37268..e266d871f5bc6 100644
--- a/asv_bench/benchmarks/gil.py
+++ b/asv_bench/benchmarks/gil.py
@@ -2,7 +2,8 @@
 
 from pandas import DataFrame, Series, date_range, factorize, read_csv
 from pandas.core.algorithms import take_1d
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 try:
     from pandas import (
@@ -24,7 +25,7 @@
 except ImportError:
     from pandas import algos
 try:
-    from pandas.util.testing import test_parallel
+    from pandas._testing import test_parallel
 
     have_real_test_parallel = True
 except ImportError:
@@ -37,7 +38,7 @@ def wrapper(fname):
         return wrapper
 
 
-from .pandas_vb_common import BaseIO  # noqa: E402 isort:skip
+from .pandas_vb_common import BaseIO  # isort:skip
 
 
 class ParallelGroupbyMethods:
@@ -250,13 +251,11 @@ def setup(self, dtype):
                 np.random.randn(rows, cols), index=date_range("1/1/2000", periods=rows)
             ),
             "object": DataFrame(
-                "foo",
-                index=range(rows),
-                columns=["object%03d".format(i) for i in range(5)],
+                "foo", index=range(rows), columns=["object%03d" for _ in range(5)]
             ),
         }
 
-        self.fname = "__test_{}__.csv".format(dtype)
+        self.fname = f"__test_{dtype}__.csv"
         df = data[dtype]
         df.to_csv(self.fname)
 
diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index d51c53e2264f1..28e0dcc5d9b13 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -13,7 +13,8 @@
     date_range,
     period_range,
 )
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 method_blacklist = {
     "object": {
diff --git a/asv_bench/benchmarks/index_object.py b/asv_bench/benchmarks/index_object.py
index a94960d494707..103141545504b 100644
--- a/asv_bench/benchmarks/index_object.py
+++ b/asv_bench/benchmarks/index_object.py
@@ -7,11 +7,13 @@
     Float64Index,
     Index,
     IntervalIndex,
+    MultiIndex,
     RangeIndex,
     Series,
     date_range,
 )
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 class SetOperations:
@@ -111,6 +113,18 @@ def time_get_loc_dec(self):
         self.idx_dec.get_loc(100000)
 
 
+class IndexEquals:
+    def setup(self):
+        idx_large_fast = RangeIndex(100000)
+        idx_small_slow = date_range(start="1/1/2012", periods=1)
+        self.mi_large_slow = MultiIndex.from_product([idx_large_fast, idx_small_slow])
+
+        self.idx_non_object = RangeIndex(1)
+
+    def time_non_object_equals_multiindex(self):
+        self.idx_non_object.equals(self.mi_large_slow)
+
+
 class IndexAppend:
     def setup(self):
 
@@ -146,7 +160,7 @@ class Indexing:
 
     def setup(self, dtype):
         N = 10 ** 6
-        self.idx = getattr(tm, "make{}Index".format(dtype))(N)
+        self.idx = getattr(tm, f"make{dtype}Index")(N)
         self.array_mask = (np.arange(N) % 3) == 0
         self.series_mask = Series(self.array_mask)
         self.sorted = self.idx.sort_values()
diff --git a/asv_bench/benchmarks/indexing.py b/asv_bench/benchmarks/indexing.py
index ac35139c1954a..087fe3916845b 100644
--- a/asv_bench/benchmarks/indexing.py
+++ b/asv_bench/benchmarks/indexing.py
@@ -17,7 +17,8 @@
     option_context,
     period_range,
 )
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 class NumericSeriesIndexing:
@@ -67,22 +68,6 @@ def time_iloc_scalar(self, index, index_structure):
     def time_iloc_slice(self, index, index_structure):
         self.data.iloc[:800000]
 
-    def time_ix_array(self, index, index_structure):
-        with warnings.catch_warnings(record=True):
-            self.data.ix[self.array]
-
-    def time_ix_list_like(self, index, index_structure):
-        with warnings.catch_warnings(record=True):
-            self.data.ix[[800000]]
-
-    def time_ix_scalar(self, index, index_structure):
-        with warnings.catch_warnings(record=True):
-            self.data.ix[800000]
-
-    def time_ix_slice(self, index, index_structure):
-        with warnings.catch_warnings(record=True):
-            self.data.ix[:800000]
-
     def time_loc_array(self, index, index_structure):
         self.data.loc[self.array]
 
@@ -147,10 +132,7 @@ def setup(self):
         self.col_scalar = columns[10]
         self.bool_indexer = self.df[self.col_scalar] > 0
         self.bool_obj_indexer = self.bool_indexer.astype(object)
-
-    def time_ix(self):
-        with warnings.catch_warnings(record=True):
-            self.df.ix[self.idx_scalar, self.col_scalar]
+        self.boolean_indexer = (self.df[self.col_scalar] > 0).astype("boolean")
 
     def time_loc(self):
         self.df.loc[self.idx_scalar, self.col_scalar]
@@ -164,6 +146,9 @@ def time_boolean_rows(self):
     def time_boolean_rows_object(self):
         self.df[self.bool_obj_indexer]
 
+    def time_boolean_rows_boolean(self):
+        self.df[self.boolean_indexer]
+
 
 class DataFrameNumericIndexing:
     def setup(self):
@@ -228,14 +213,6 @@ def setup(self):
         self.idx = IndexSlice[20000:30000, 20:30, 35:45, 30000:40000]
         self.mdt = self.mdt.set_index(["A", "B", "C", "D"]).sort_index()
 
-    def time_series_ix(self):
-        with warnings.catch_warnings(record=True):
-            self.s.ix[999]
-
-    def time_frame_ix(self):
-        with warnings.catch_warnings(record=True):
-            self.df.ix[999]
-
     def time_index_slice(self):
         self.mdt.loc[self.idx, :]
 
@@ -310,10 +287,6 @@ def setup_cache(self):
     def time_lookup_iloc(self, s):
         s.iloc
 
-    def time_lookup_ix(self, s):
-        with warnings.catch_warnings(record=True):
-            s.ix
-
     def time_lookup_loc(self, s):
         s.loc
 
diff --git a/asv_bench/benchmarks/inference.py b/asv_bench/benchmarks/inference.py
index e85b3bd2c7687..1a8d5ede52512 100644
--- a/asv_bench/benchmarks/inference.py
+++ b/asv_bench/benchmarks/inference.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, Series, to_numeric
-import pandas.util.testing as tm
 
-from .pandas_vb_common import lib, numeric_dtypes
+from .pandas_vb_common import lib, numeric_dtypes, tm
 
 
 class NumericInferOps:
diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index 9b8599b0a1b64..9bcd125f56bbb 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -5,9 +5,8 @@
 import numpy as np
 
 from pandas import Categorical, DataFrame, date_range, read_csv, to_datetime
-import pandas.util.testing as tm
 
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
 
 
 class ToCSV(BaseIO):
@@ -132,7 +131,7 @@ class ReadCSVConcatDatetimeBadDateValue(StringIORewind):
     param_names = ["bad_date_value"]
 
     def setup(self, bad_date_value):
-        self.StringIO_input = StringIO(("%s,\n" % bad_date_value) * 50000)
+        self.StringIO_input = StringIO((f"{bad_date_value},\n") * 50000)
 
     def time_read_csv(self, bad_date_value):
         read_csv(
@@ -202,7 +201,7 @@ def setup(self, sep, thousands):
         data = np.random.randn(N, K) * np.random.randint(100, 10000, (N, K))
         df = DataFrame(data)
         if thousands is not None:
-            fmt = ":{}".format(thousands)
+            fmt = f":{thousands}"
             fmt = "{" + fmt + "}"
             df = df.applymap(lambda x: fmt.format(x))
         df.to_csv(self.fname, sep=sep)
@@ -231,7 +230,7 @@ def setup(self, sep, decimal, float_precision):
         floats = [
             "".join(random.choice(string.digits) for _ in range(28)) for _ in range(15)
         ]
-        rows = sep.join(["0{}".format(decimal) + "{}"] * 3) + "\n"
+        rows = sep.join([f"0{decimal}" + "{}"] * 3) + "\n"
         data = rows * 5
         data = data.format(*floats) * 200  # 1000 x 3 strings csv
         self.StringIO_input = StringIO(data)
@@ -309,9 +308,7 @@ class ReadCSVCachedParseDates(StringIORewind):
     param_names = ["do_cache"]
 
     def setup(self, do_cache):
-        data = (
-            "\n".join("10/{}".format(year) for year in range(2000, 2100)) + "\n"
-        ) * 10
+        data = ("\n".join(f"10/{year}" for year in range(2000, 2100)) + "\n") * 10
         self.StringIO_input = StringIO(data)
 
     def time_read_csv_cached(self, do_cache):
@@ -336,7 +333,7 @@ class ReadCSVMemoryGrowth(BaseIO):
     def setup(self):
         with open(self.fname, "w") as f:
             for i in range(self.num_rows):
-                f.write("{i}\n".format(i=i))
+                f.write(f"{i}\n")
 
     def mem_parser_chunks(self):
         # see gh-24805.
diff --git a/asv_bench/benchmarks/io/excel.py b/asv_bench/benchmarks/io/excel.py
index c97cf768e27d9..80af2cff41769 100644
--- a/asv_bench/benchmarks/io/excel.py
+++ b/asv_bench/benchmarks/io/excel.py
@@ -6,7 +6,8 @@
 from odf.text import P
 
 from pandas import DataFrame, ExcelWriter, date_range, read_excel
-import pandas.util.testing as tm
+
+from ..pandas_vb_common import tm
 
 
 def _generate_dataframe():
@@ -14,7 +15,7 @@ def _generate_dataframe():
     C = 5
     df = DataFrame(
         np.random.randn(N, C),
-        columns=["float{}".format(i) for i in range(C)],
+        columns=[f"float{i}" for i in range(C)],
         index=date_range("20000101", periods=N, freq="H"),
     )
     df["object"] = tm.makeStringIndex(N)
diff --git a/asv_bench/benchmarks/io/hdf.py b/asv_bench/benchmarks/io/hdf.py
index 8ec04a2087f1b..4ca399a293a4b 100644
--- a/asv_bench/benchmarks/io/hdf.py
+++ b/asv_bench/benchmarks/io/hdf.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, HDFStore, date_range, read_hdf
-import pandas.util.testing as tm
 
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
 
 
 class HDFStoreDataFrame(BaseIO):
@@ -88,11 +87,11 @@ def time_write_store_table_dc(self):
 
     def time_query_store_table_wide(self):
         self.store.select(
-            "table_wide", where="index > self.start_wide and " "index < self.stop_wide"
+            "table_wide", where="index > self.start_wide and index < self.stop_wide"
         )
 
     def time_query_store_table(self):
-        self.store.select("table", where="index > self.start and " "index < self.stop")
+        self.store.select("table", where="index > self.start and index < self.stop")
 
     def time_store_repr(self):
         repr(self.store)
@@ -115,7 +114,7 @@ def setup(self, format):
         C = 5
         self.df = DataFrame(
             np.random.randn(N, C),
-            columns=["float{}".format(i) for i in range(C)],
+            columns=[f"float{i}" for i in range(C)],
             index=date_range("20000101", periods=N, freq="H"),
         )
         self.df["object"] = tm.makeStringIndex(N)
diff --git a/asv_bench/benchmarks/io/json.py b/asv_bench/benchmarks/io/json.py
index 5c1d39776b91c..f478bf2aee0ba 100644
--- a/asv_bench/benchmarks/io/json.py
+++ b/asv_bench/benchmarks/io/json.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, concat, date_range, read_json, timedelta_range
-import pandas.util.testing as tm
 
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
 
 
 class ReadJSON(BaseIO):
@@ -20,7 +19,7 @@ def setup(self, orient, index):
         }
         df = DataFrame(
             np.random.randn(N, 5),
-            columns=["float_{}".format(i) for i in range(5)],
+            columns=[f"float_{i}" for i in range(5)],
             index=indexes[index],
         )
         df.to_json(self.fname, orient=orient)
@@ -43,7 +42,7 @@ def setup(self, index):
         }
         df = DataFrame(
             np.random.randn(N, 5),
-            columns=["float_{}".format(i) for i in range(5)],
+            columns=[f"float_{i}" for i in range(5)],
             index=indexes[index],
         )
         df.to_json(self.fname, orient="records", lines=True)
@@ -132,6 +131,30 @@ def peakmem_to_json_wide(self, orient, frame):
         df.to_json(self.fname, orient=orient)
 
 
+class ToJSONISO(BaseIO):
+    fname = "__test__.json"
+    params = [["split", "columns", "index", "values", "records"]]
+    param_names = ["orient"]
+
+    def setup(self, orient):
+        N = 10 ** 5
+        index = date_range("20000101", periods=N, freq="H")
+        timedeltas = timedelta_range(start=1, periods=N, freq="s")
+        datetimes = date_range(start=1, periods=N, freq="s")
+        self.df = DataFrame(
+            {
+                "td_1": timedeltas,
+                "td_2": timedeltas,
+                "ts_1": datetimes,
+                "ts_2": datetimes,
+            },
+            index=index,
+        )
+
+    def time_iso_format(self, orient):
+        self.df.to_json(orient=orient, date_format="iso")
+
+
 class ToJSONLines(BaseIO):
 
     fname = "__test__.json"
diff --git a/asv_bench/benchmarks/io/msgpack.py b/asv_bench/benchmarks/io/msgpack.py
deleted file mode 100644
index f5038602539ab..0000000000000
--- a/asv_bench/benchmarks/io/msgpack.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import warnings
-
-import numpy as np
-
-from pandas import DataFrame, date_range, read_msgpack
-import pandas.util.testing as tm
-
-from ..pandas_vb_common import BaseIO
-
-
-class MSGPack(BaseIO):
-    def setup(self):
-        self.fname = "__test__.msg"
-        N = 100000
-        C = 5
-        self.df = DataFrame(
-            np.random.randn(N, C),
-            columns=["float{}".format(i) for i in range(C)],
-            index=date_range("20000101", periods=N, freq="H"),
-        )
-        self.df["object"] = tm.makeStringIndex(N)
-        with warnings.catch_warnings(record=True):
-            self.df.to_msgpack(self.fname)
-
-    def time_read_msgpack(self):
-        read_msgpack(self.fname)
-
-    def time_write_msgpack(self):
-        self.df.to_msgpack(self.fname)
-
-
-from ..pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/io/pickle.py b/asv_bench/benchmarks/io/pickle.py
index 647e9d27dec9d..4ca9a82ae4827 100644
--- a/asv_bench/benchmarks/io/pickle.py
+++ b/asv_bench/benchmarks/io/pickle.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, date_range, read_pickle
-import pandas.util.testing as tm
 
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
 
 
 class Pickle(BaseIO):
@@ -13,7 +12,7 @@ def setup(self):
         C = 5
         self.df = DataFrame(
             np.random.randn(N, C),
-            columns=["float{}".format(i) for i in range(C)],
+            columns=[f"float{i}" for i in range(C)],
             index=date_range("20000101", periods=N, freq="H"),
         )
         self.df["object"] = tm.makeStringIndex(N)
diff --git a/asv_bench/benchmarks/io/sas.py b/asv_bench/benchmarks/io/sas.py
index 7ce8ef8c12639..369b79641dbc4 100644
--- a/asv_bench/benchmarks/io/sas.py
+++ b/asv_bench/benchmarks/io/sas.py
@@ -9,7 +9,7 @@ class SAS:
     param_names = ["format"]
 
     def setup(self, format):
-        # Read files that are located in 'pandas/io/tests/sas/data'
+        # Read files that are located in 'pandas/tests/io/sas/data'
         files = {"sas7bdat": "test1.sas7bdat", "xport": "paxraw_d_short.xpt"}
         file = files[format]
         paths = [
@@ -26,5 +26,5 @@ def setup(self, format):
         ]
         self.f = os.path.join(*paths)
 
-    def time_read_msgpack(self, format):
+    def time_read_sas(self, format):
         read_sas(self.f, format=format)
diff --git a/asv_bench/benchmarks/io/sql.py b/asv_bench/benchmarks/io/sql.py
index fe84c869717e3..b71bb832280b9 100644
--- a/asv_bench/benchmarks/io/sql.py
+++ b/asv_bench/benchmarks/io/sql.py
@@ -4,7 +4,8 @@
 from sqlalchemy import create_engine
 
 from pandas import DataFrame, date_range, read_sql_query, read_sql_table
-import pandas.util.testing as tm
+
+from ..pandas_vb_common import tm
 
 
 class SQL:
@@ -19,7 +20,7 @@ def setup(self, connection):
             "sqlite": sqlite3.connect(":memory:"),
         }
         self.table_name = "test_type"
-        self.query_all = "SELECT * FROM {}".format(self.table_name)
+        self.query_all = f"SELECT * FROM {self.table_name}"
         self.con = con[connection]
         self.df = DataFrame(
             {
@@ -58,7 +59,7 @@ def setup(self, connection, dtype):
             "sqlite": sqlite3.connect(":memory:"),
         }
         self.table_name = "test_type"
-        self.query_col = "SELECT {} FROM {}".format(dtype, self.table_name)
+        self.query_col = f"SELECT {dtype} FROM {self.table_name}"
         self.con = con[connection]
         self.df = DataFrame(
             {
diff --git a/asv_bench/benchmarks/io/stata.py b/asv_bench/benchmarks/io/stata.py
index 28829785d72e9..9faafa82ff46e 100644
--- a/asv_bench/benchmarks/io/stata.py
+++ b/asv_bench/benchmarks/io/stata.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, date_range, read_stata
-import pandas.util.testing as tm
 
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
 
 
 class Stata(BaseIO):
@@ -17,7 +16,7 @@ def setup(self, convert_dates):
         C = self.C = 5
         self.df = DataFrame(
             np.random.randn(N, C),
-            columns=["float{}".format(i) for i in range(C)],
+            columns=[f"float{i}" for i in range(C)],
             index=date_range("20000101", periods=N, freq="H"),
         )
         self.df["object"] = tm.makeStringIndex(self.N)
@@ -47,7 +46,7 @@ def setup(self, convert_dates):
         for i in range(10):
             missing_data = np.random.randn(self.N)
             missing_data[missing_data < 0] = np.nan
-            self.df["missing_{0}".format(i)] = missing_data
+            self.df[f"missing_{i}"] = missing_data
         self.df.to_stata(self.fname, self.convert_dates)
 
 
diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py
index 6aa82a43a4d6a..1333b3a0f0560 100644
--- a/asv_bench/benchmarks/join_merge.py
+++ b/asv_bench/benchmarks/join_merge.py
@@ -3,7 +3,8 @@
 import numpy as np
 
 from pandas import DataFrame, MultiIndex, Series, concat, date_range, merge, merge_asof
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 try:
     from pandas import merge_ordered
@@ -273,10 +274,10 @@ def time_merge_ordered(self):
 
 
 class MergeAsof:
-    params = [["backward", "forward", "nearest"]]
-    param_names = ["direction"]
+    params = [["backward", "forward", "nearest"], [None, 5]]
+    param_names = ["direction", "tolerance"]
 
-    def setup(self, direction):
+    def setup(self, direction, tolerance):
         one_count = 200000
         two_count = 1000000
 
@@ -303,6 +304,9 @@ def setup(self, direction):
         df1["time32"] = np.int32(df1.time)
         df2["time32"] = np.int32(df2.time)
 
+        df1["timeu64"] = np.uint64(df1.time)
+        df2["timeu64"] = np.uint64(df2.time)
+
         self.df1a = df1[["time", "value1"]]
         self.df2a = df2[["time", "value2"]]
         self.df1b = df1[["time", "key", "value1"]]
@@ -313,22 +317,52 @@ def setup(self, direction):
         self.df2d = df2[["time32", "value2"]]
         self.df1e = df1[["time", "key", "key2", "value1"]]
         self.df2e = df2[["time", "key", "key2", "value2"]]
+        self.df1f = df1[["timeu64", "value1"]]
+        self.df2f = df2[["timeu64", "value2"]]
 
-    def time_on_int(self, direction):
-        merge_asof(self.df1a, self.df2a, on="time", direction=direction)
+    def time_on_int(self, direction, tolerance):
+        merge_asof(
+            self.df1a, self.df2a, on="time", direction=direction, tolerance=tolerance
+        )
 
-    def time_on_int32(self, direction):
-        merge_asof(self.df1d, self.df2d, on="time32", direction=direction)
+    def time_on_int32(self, direction, tolerance):
+        merge_asof(
+            self.df1d, self.df2d, on="time32", direction=direction, tolerance=tolerance
+        )
 
-    def time_by_object(self, direction):
-        merge_asof(self.df1b, self.df2b, on="time", by="key", direction=direction)
+    def time_on_uint64(self, direction, tolerance):
+        merge_asof(
+            self.df1f, self.df2f, on="timeu64", direction=direction, tolerance=tolerance
+        )
+
+    def time_by_object(self, direction, tolerance):
+        merge_asof(
+            self.df1b,
+            self.df2b,
+            on="time",
+            by="key",
+            direction=direction,
+            tolerance=tolerance,
+        )
 
-    def time_by_int(self, direction):
-        merge_asof(self.df1c, self.df2c, on="time", by="key2", direction=direction)
+    def time_by_int(self, direction, tolerance):
+        merge_asof(
+            self.df1c,
+            self.df2c,
+            on="time",
+            by="key2",
+            direction=direction,
+            tolerance=tolerance,
+        )
 
-    def time_multiby(self, direction):
+    def time_multiby(self, direction, tolerance):
         merge_asof(
-            self.df1e, self.df2e, on="time", by=["key", "key2"], direction=direction
+            self.df1e,
+            self.df2e,
+            on="time",
+            by=["key", "key2"],
+            direction=direction,
+            tolerance=tolerance,
         )
 
 
diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index 3f4fd7ad911c1..0e188c58012fa 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -2,8 +2,9 @@
 
 import numpy as np
 
-from pandas import DataFrame, MultiIndex, date_range
-import pandas.util.testing as tm
+from pandas import DataFrame, MultiIndex, RangeIndex, date_range
+
+from .pandas_vb_common import tm
 
 
 class GetLoc:
@@ -147,4 +148,16 @@ def time_categorical_level(self):
         self.df.set_index(["a", "b"])
 
 
+class Equals:
+    def setup(self):
+        idx_large_fast = RangeIndex(100000)
+        idx_small_slow = date_range(start="1/1/2012", periods=1)
+        self.mi_large_slow = MultiIndex.from_product([idx_large_fast, idx_small_slow])
+
+        self.idx_non_object = RangeIndex(1)
+
+    def time_equals_non_object_index(self):
+        self.mi_large_slow.equals(self.idx_non_object)
+
+
 from .pandas_vb_common import setup  # noqa: F401 isort:skip
diff --git a/asv_bench/benchmarks/offset.py b/asv_bench/benchmarks/offset.py
index d822646e712ae..77ce1b2763bce 100644
--- a/asv_bench/benchmarks/offset.py
+++ b/asv_bench/benchmarks/offset.py
@@ -1,12 +1,9 @@
-from datetime import datetime
 import warnings
 
-import numpy as np
-
 import pandas as pd
 
 try:
-    import pandas.tseries.holiday  # noqa
+    import pandas.tseries.holiday
 except ImportError:
     pass
 
@@ -54,24 +51,6 @@ def time_apply_index(self, offset):
         offset.apply_index(self.rng)
 
 
-class OnOffset:
-
-    params = offsets
-    param_names = ["offset"]
-
-    def setup(self, offset):
-        self.dates = [
-            datetime(2016, m, d)
-            for m in [10, 11, 12]
-            for d in [1, 2, 3, 28, 29, 30, 31]
-            if not (m == 11 and d == 31)
-        ]
-
-    def time_on_offset(self, offset):
-        for date in self.dates:
-            offset.onOffset(date)
-
-
 class OffsetSeriesArithmetic:
 
     params = offsets
@@ -99,31 +78,3 @@ def setup(self, offset):
     def time_add_offset(self, offset):
         with warnings.catch_warnings(record=True):
             self.data + offset
-
-
-class OffestDatetimeArithmetic:
-
-    params = offsets
-    param_names = ["offset"]
-
-    def setup(self, offset):
-        self.date = datetime(2011, 1, 1)
-        self.dt64 = np.datetime64("2011-01-01 09:00Z")
-
-    def time_apply(self, offset):
-        offset.apply(self.date)
-
-    def time_apply_np_dt64(self, offset):
-        offset.apply(self.dt64)
-
-    def time_add(self, offset):
-        self.date + offset
-
-    def time_add_10(self, offset):
-        self.date + (10 * offset)
-
-    def time_subtract(self, offset):
-        self.date - offset
-
-    def time_subtract_10(self, offset):
-        self.date - (10 * offset)
diff --git a/asv_bench/benchmarks/pandas_vb_common.py b/asv_bench/benchmarks/pandas_vb_common.py
index 1faf13329110d..fd1770df8e5d3 100644
--- a/asv_bench/benchmarks/pandas_vb_common.py
+++ b/asv_bench/benchmarks/pandas_vb_common.py
@@ -13,6 +13,13 @@
     except (ImportError, TypeError, ValueError):
         pass
 
+# Compatibility import for the testing module
+try:
+    import pandas._testing as tm  # noqa
+except ImportError:
+    import pandas.util.testing as tm  # noqa
+
+
 numeric_dtypes = [
     np.int64,
     np.int32,
@@ -49,7 +56,7 @@
 def setup(*args, **kwargs):
     # This function just needs to be imported into each benchmark file to
     # set up the random seed before each function.
-    # http://asv.readthedocs.io/en/latest/writing_benchmarks.html
+    # https://asv.readthedocs.io/en/latest/writing_benchmarks.html
     np.random.seed(1234)
 
 
diff --git a/asv_bench/benchmarks/period.py b/asv_bench/benchmarks/period.py
index 7303240a25f29..b52aa2e55af35 100644
--- a/asv_bench/benchmarks/period.py
+++ b/asv_bench/benchmarks/period.py
@@ -1,71 +1,12 @@
+"""
+Period benchmarks with non-tslibs dependencies.  See
+benchmarks.tslibs.period for benchmarks that rely only on tslibs.
+"""
 from pandas import DataFrame, Period, PeriodIndex, Series, date_range, period_range
 
 from pandas.tseries.frequencies import to_offset
 
 
-class PeriodProperties:
-
-    params = (
-        ["M", "min"],
-        [
-            "year",
-            "month",
-            "day",
-            "hour",
-            "minute",
-            "second",
-            "is_leap_year",
-            "quarter",
-            "qyear",
-            "week",
-            "daysinmonth",
-            "dayofweek",
-            "dayofyear",
-            "start_time",
-            "end_time",
-        ],
-    )
-    param_names = ["freq", "attr"]
-
-    def setup(self, freq, attr):
-        self.per = Period("2012-06-01", freq=freq)
-
-    def time_property(self, freq, attr):
-        getattr(self.per, attr)
-
-
-class PeriodUnaryMethods:
-
-    params = ["M", "min"]
-    param_names = ["freq"]
-
-    def setup(self, freq):
-        self.per = Period("2012-06-01", freq=freq)
-
-    def time_to_timestamp(self, freq):
-        self.per.to_timestamp()
-
-    def time_now(self, freq):
-        self.per.now(freq)
-
-    def time_asfreq(self, freq):
-        self.per.asfreq("A")
-
-
-class PeriodConstructor:
-    params = [["D"], [True, False]]
-    param_names = ["freq", "is_offset"]
-
-    def setup(self, freq, is_offset):
-        if is_offset:
-            self.freq = to_offset(freq)
-        else:
-            self.freq = freq
-
-    def time_period_constructor(self, freq, is_offset):
-        Period("2012-06-01", freq=freq)
-
-
 class PeriodIndexConstructor:
 
     params = [["D"], [True, False]]
diff --git a/asv_bench/benchmarks/reindex.py b/asv_bench/benchmarks/reindex.py
index cd450f801c805..03394e6fe08cb 100644
--- a/asv_bench/benchmarks/reindex.py
+++ b/asv_bench/benchmarks/reindex.py
@@ -1,9 +1,8 @@
 import numpy as np
 
 from pandas import DataFrame, Index, MultiIndex, Series, date_range, period_range
-import pandas.util.testing as tm
 
-from .pandas_vb_common import lib
+from .pandas_vb_common import lib, tm
 
 
 class Reindex:
diff --git a/asv_bench/benchmarks/reshape.py b/asv_bench/benchmarks/reshape.py
index 441f4b380656e..21081ee23a773 100644
--- a/asv_bench/benchmarks/reshape.py
+++ b/asv_bench/benchmarks/reshape.py
@@ -161,6 +161,9 @@ def time_pivot_table_categorical_observed(self):
             observed=True,
         )
 
+    def time_pivot_table_margins_only_column(self):
+        self.df.pivot_table(columns=["key2", "key3"], margins=True)
+
 
 class Crosstab:
     def setup(self):
diff --git a/asv_bench/benchmarks/rolling.py b/asv_bench/benchmarks/rolling.py
index b42fa553b495c..f7e1e395a76bc 100644
--- a/asv_bench/benchmarks/rolling.py
+++ b/asv_bench/benchmarks/rolling.py
@@ -25,6 +25,46 @@ def peakmem_rolling(self, constructor, window, dtype, method):
         getattr(self.roll, method)()
 
 
+class Apply:
+    params = (
+        ["DataFrame", "Series"],
+        [3, 300],
+        ["int", "float"],
+        [sum, np.sum, lambda x: np.sum(x) + 5],
+        [True, False],
+    )
+    param_names = ["constructor", "window", "dtype", "function", "raw"]
+
+    def setup(self, constructor, window, dtype, function, raw):
+        N = 10 ** 3
+        arr = (100 * np.random.random(N)).astype(dtype)
+        self.roll = getattr(pd, constructor)(arr).rolling(window)
+
+    def time_rolling(self, constructor, window, dtype, function, raw):
+        self.roll.apply(function, raw=raw)
+
+
+class Engine:
+    params = (
+        ["DataFrame", "Series"],
+        ["int", "float"],
+        [np.sum, lambda x: np.sum(x) + 5],
+        ["cython", "numba"],
+    )
+    param_names = ["constructor", "dtype", "function", "engine"]
+
+    def setup(self, constructor, dtype, function, engine):
+        N = 10 ** 3
+        arr = (100 * np.random.random(N)).astype(dtype)
+        self.data = getattr(pd, constructor)(arr)
+
+    def time_rolling_apply(self, constructor, dtype, function, engine):
+        self.data.rolling(10).apply(function, raw=True, engine=engine)
+
+    def time_expanding_apply(self, constructor, dtype, function, engine):
+        self.data.expanding().apply(function, raw=True, engine=engine)
+
+
 class ExpandingMethods:
 
     params = (
diff --git a/asv_bench/benchmarks/series_methods.py b/asv_bench/benchmarks/series_methods.py
index a3f1d92545c3f..57c625ced8a43 100644
--- a/asv_bench/benchmarks/series_methods.py
+++ b/asv_bench/benchmarks/series_methods.py
@@ -3,7 +3,8 @@
 import numpy as np
 
 from pandas import NaT, Series, date_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 class SeriesConstructor:
diff --git a/asv_bench/benchmarks/stat_ops.py b/asv_bench/benchmarks/stat_ops.py
index ed5ebfa61594e..ec67394e55a1e 100644
--- a/asv_bench/benchmarks/stat_ops.py
+++ b/asv_bench/benchmarks/stat_ops.py
@@ -7,20 +7,14 @@
 
 class FrameOps:
 
-    params = [ops, ["float", "int"], [0, 1], [True, False]]
-    param_names = ["op", "dtype", "axis", "use_bottleneck"]
+    params = [ops, ["float", "int"], [0, 1]]
+    param_names = ["op", "dtype", "axis"]
 
-    def setup(self, op, dtype, axis, use_bottleneck):
+    def setup(self, op, dtype, axis):
         df = pd.DataFrame(np.random.randn(100000, 4)).astype(dtype)
-        try:
-            pd.options.compute.use_bottleneck = use_bottleneck
-        except TypeError:
-            from pandas.core import nanops
-
-            nanops._USE_BOTTLENECK = use_bottleneck
         self.df_func = getattr(df, op)
 
-    def time_op(self, op, dtype, axis, use_bottleneck):
+    def time_op(self, op, dtype, axis):
         self.df_func(axis=axis)
 
 
@@ -46,20 +40,14 @@ def time_op(self, level, op):
 
 class SeriesOps:
 
-    params = [ops, ["float", "int"], [True, False]]
-    param_names = ["op", "dtype", "use_bottleneck"]
+    params = [ops, ["float", "int"]]
+    param_names = ["op", "dtype"]
 
-    def setup(self, op, dtype, use_bottleneck):
+    def setup(self, op, dtype):
         s = pd.Series(np.random.randn(100000)).astype(dtype)
-        try:
-            pd.options.compute.use_bottleneck = use_bottleneck
-        except TypeError:
-            from pandas.core import nanops
-
-            nanops._USE_BOTTLENECK = use_bottleneck
         self.s_func = getattr(s, op)
 
-    def time_op(self, op, dtype, use_bottleneck):
+    def time_op(self, op, dtype):
         self.s_func()
 
 
@@ -101,61 +89,49 @@ def time_average_old(self, constructor, pct):
 
 class Correlation:
 
-    params = [["spearman", "kendall", "pearson"], [True, False]]
-    param_names = ["method", "use_bottleneck"]
+    params = [["spearman", "kendall", "pearson"]]
+    param_names = ["method"]
 
-    def setup(self, method, use_bottleneck):
-        try:
-            pd.options.compute.use_bottleneck = use_bottleneck
-        except TypeError:
-            from pandas.core import nanops
+    def setup(self, method):
+        self.df = pd.DataFrame(np.random.randn(500, 15))
+        self.df2 = pd.DataFrame(np.random.randn(500, 15))
+        self.df_wide = pd.DataFrame(np.random.randn(500, 100))
+        self.df_wide_nans = self.df_wide.where(np.random.random((500, 100)) < 0.9)
+        self.s = pd.Series(np.random.randn(500))
+        self.s2 = pd.Series(np.random.randn(500))
 
-            nanops._USE_BOTTLENECK = use_bottleneck
-        self.df = pd.DataFrame(np.random.randn(1000, 30))
-        self.df2 = pd.DataFrame(np.random.randn(1000, 30))
-        self.df_wide = pd.DataFrame(np.random.randn(1000, 200))
-        self.df_wide_nans = self.df_wide.where(np.random.random((1000, 200)) < 0.9)
-        self.s = pd.Series(np.random.randn(1000))
-        self.s2 = pd.Series(np.random.randn(1000))
-
-    def time_corr(self, method, use_bottleneck):
+    def time_corr(self, method):
         self.df.corr(method=method)
 
-    def time_corr_wide(self, method, use_bottleneck):
+    def time_corr_wide(self, method):
         self.df_wide.corr(method=method)
 
-    def time_corr_wide_nans(self, method, use_bottleneck):
+    def time_corr_wide_nans(self, method):
         self.df_wide_nans.corr(method=method)
 
-    def peakmem_corr_wide(self, method, use_bottleneck):
+    def peakmem_corr_wide(self, method):
         self.df_wide.corr(method=method)
 
-    def time_corr_series(self, method, use_bottleneck):
+    def time_corr_series(self, method):
         self.s.corr(self.s2, method=method)
 
-    def time_corrwith_cols(self, method, use_bottleneck):
+    def time_corrwith_cols(self, method):
         self.df.corrwith(self.df2, method=method)
 
-    def time_corrwith_rows(self, method, use_bottleneck):
+    def time_corrwith_rows(self, method):
         self.df.corrwith(self.df2, axis=1, method=method)
 
 
 class Covariance:
 
-    params = [[True, False]]
-    param_names = ["use_bottleneck"]
-
-    def setup(self, use_bottleneck):
-        try:
-            pd.options.compute.use_bottleneck = use_bottleneck
-        except TypeError:
-            from pandas.core import nanops
+    params = []
+    param_names = []
 
-            nanops._USE_BOTTLENECK = use_bottleneck
+    def setup(self):
         self.s = pd.Series(np.random.randn(100000))
         self.s2 = pd.Series(np.random.randn(100000))
 
-    def time_cov_series(self, use_bottleneck):
+    def time_cov_series(self):
         self.s.cov(self.s2)
 
 
diff --git a/asv_bench/benchmarks/strings.py b/asv_bench/benchmarks/strings.py
index f30b2482615bd..d7fb2775376c0 100644
--- a/asv_bench/benchmarks/strings.py
+++ b/asv_bench/benchmarks/strings.py
@@ -3,7 +3,8 @@
 import numpy as np
 
 from pandas import DataFrame, Series
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
 
 
 class Methods:
diff --git a/asv_bench/benchmarks/timedelta.py b/asv_bench/benchmarks/timedelta.py
index 36a9db529f98f..37418d752f833 100644
--- a/asv_bench/benchmarks/timedelta.py
+++ b/asv_bench/benchmarks/timedelta.py
@@ -1,49 +1,11 @@
-import datetime
+"""
+Timedelta benchmarks with non-tslibs dependencies.  See
+benchmarks.tslibs.timedelta for benchmarks that rely only on tslibs.
+"""
 
 import numpy as np
 
-from pandas import (
-    DataFrame,
-    Series,
-    Timedelta,
-    Timestamp,
-    timedelta_range,
-    to_timedelta,
-)
-
-
-class TimedeltaConstructor:
-    def time_from_int(self):
-        Timedelta(123456789)
-
-    def time_from_unit(self):
-        Timedelta(1, unit="d")
-
-    def time_from_components(self):
-        Timedelta(
-            days=1,
-            hours=2,
-            minutes=3,
-            seconds=4,
-            milliseconds=5,
-            microseconds=6,
-            nanoseconds=7,
-        )
-
-    def time_from_datetime_timedelta(self):
-        Timedelta(datetime.timedelta(days=1, seconds=1))
-
-    def time_from_np_timedelta(self):
-        Timedelta(np.timedelta64(1, "ms"))
-
-    def time_from_string(self):
-        Timedelta("1 days")
-
-    def time_from_iso_format(self):
-        Timedelta("P4DT12H30M5S")
-
-    def time_from_missing(self):
-        Timedelta("nat")
+from pandas import DataFrame, Series, Timestamp, timedelta_range, to_timedelta
 
 
 class ToTimedelta:
@@ -52,8 +14,8 @@ def setup(self):
         self.str_days = []
         self.str_seconds = []
         for i in self.ints:
-            self.str_days.append("{0} days".format(i))
-            self.str_seconds.append("00:00:{0:02d}".format(i))
+            self.str_days.append(f"{i} days")
+            self.str_seconds.append(f"00:00:{i:02d}")
 
     def time_convert_int(self):
         to_timedelta(self.ints, unit="s")
@@ -72,7 +34,7 @@ class ToTimedeltaErrors:
 
     def setup(self, errors):
         ints = np.random.randint(0, 60, size=10000)
-        self.arr = ["{0} days".format(i) for i in ints]
+        self.arr = [f"{i} days" for i in ints]
         self.arr[-1] = "apple"
 
     def time_convert(self, errors):
@@ -88,24 +50,6 @@ def time_add_td_ts(self):
         self.td + self.ts
 
 
-class TimedeltaProperties:
-    def setup_cache(self):
-        td = Timedelta(days=365, minutes=35, seconds=25, milliseconds=35)
-        return td
-
-    def time_timedelta_days(self, td):
-        td.days
-
-    def time_timedelta_seconds(self, td):
-        td.seconds
-
-    def time_timedelta_microseconds(self, td):
-        td.microseconds
-
-    def time_timedelta_nanoseconds(self, td):
-        td.nanoseconds
-
-
 class DatetimeAccessor:
     def setup_cache(self):
         N = 100000
diff --git a/asv_bench/benchmarks/timeseries.py b/asv_bench/benchmarks/timeseries.py
index 498774034d642..ba0b51922fd31 100644
--- a/asv_bench/benchmarks/timeseries.py
+++ b/asv_bench/benchmarks/timeseries.py
@@ -113,7 +113,7 @@ class InferFreq:
     def setup(self, freq):
         if freq is None:
             self.idx = date_range(start="1/1/1700", freq="D", periods=10000)
-            self.idx.freq = None
+            self.idx._data._freq = None
         else:
             self.idx = date_range(start="1/1/1700", freq=freq, periods=10000)
 
diff --git a/asv_bench/benchmarks/tslibs/__init__.py b/asv_bench/benchmarks/tslibs/__init__.py
new file mode 100644
index 0000000000000..815cf55b291cd
--- /dev/null
+++ b/asv_bench/benchmarks/tslibs/__init__.py
@@ -0,0 +1,7 @@
+"""
+Benchmarks in this directory should depend only on tslibs, tseries.offsets,
+and to_offset.
+
+i.e. any code changes that do not touch those files should not need to
+run these benchmarks.
+"""
diff --git a/asv_bench/benchmarks/tslibs/offsets.py b/asv_bench/benchmarks/tslibs/offsets.py
new file mode 100644
index 0000000000000..fc1efe63307b2
--- /dev/null
+++ b/asv_bench/benchmarks/tslibs/offsets.py
@@ -0,0 +1,90 @@
+"""
+offsets benchmarks that rely only on tslibs.  See benchmarks.offset for
+offsets benchmarks that rely on other parts of pandas.
+"""
+from datetime import datetime
+
+import numpy as np
+
+from pandas import offsets
+
+try:
+    import pandas.tseries.holiday  # noqa
+except ImportError:
+    pass
+
+hcal = pandas.tseries.holiday.USFederalHolidayCalendar()
+# These offsets currently raise a NotImplimentedError with .apply_index()
+non_apply = [
+    offsets.Day(),
+    offsets.BYearEnd(),
+    offsets.BYearBegin(),
+    offsets.BQuarterEnd(),
+    offsets.BQuarterBegin(),
+    offsets.BMonthEnd(),
+    offsets.BMonthBegin(),
+    offsets.CustomBusinessDay(),
+    offsets.CustomBusinessDay(calendar=hcal),
+    offsets.CustomBusinessMonthBegin(calendar=hcal),
+    offsets.CustomBusinessMonthEnd(calendar=hcal),
+    offsets.CustomBusinessMonthEnd(calendar=hcal),
+]
+other_offsets = [
+    offsets.YearEnd(),
+    offsets.YearBegin(),
+    offsets.QuarterEnd(),
+    offsets.QuarterBegin(),
+    offsets.MonthEnd(),
+    offsets.MonthBegin(),
+    offsets.DateOffset(months=2, days=2),
+    offsets.BusinessDay(),
+    offsets.SemiMonthEnd(),
+    offsets.SemiMonthBegin(),
+]
+offset_objs = non_apply + other_offsets
+
+
+class OnOffset:
+
+    params = offset_objs
+    param_names = ["offset"]
+
+    def setup(self, offset):
+        self.dates = [
+            datetime(2016, m, d)
+            for m in [10, 11, 12]
+            for d in [1, 2, 3, 28, 29, 30, 31]
+            if not (m == 11 and d == 31)
+        ]
+
+    def time_on_offset(self, offset):
+        for date in self.dates:
+            offset.is_on_offset(date)
+
+
+class OffestDatetimeArithmetic:
+
+    params = offset_objs
+    param_names = ["offset"]
+
+    def setup(self, offset):
+        self.date = datetime(2011, 1, 1)
+        self.dt64 = np.datetime64("2011-01-01 09:00Z")
+
+    def time_apply(self, offset):
+        offset.apply(self.date)
+
+    def time_apply_np_dt64(self, offset):
+        offset.apply(self.dt64)
+
+    def time_add(self, offset):
+        self.date + offset
+
+    def time_add_10(self, offset):
+        self.date + (10 * offset)
+
+    def time_subtract(self, offset):
+        self.date - offset
+
+    def time_subtract_10(self, offset):
+        self.date - (10 * offset)
diff --git a/asv_bench/benchmarks/tslibs/period.py b/asv_bench/benchmarks/tslibs/period.py
new file mode 100644
index 0000000000000..9156c4aa90ea0
--- /dev/null
+++ b/asv_bench/benchmarks/tslibs/period.py
@@ -0,0 +1,70 @@
+"""
+Period benchmarks that rely only on tslibs.  See benchmarks.period for
+Period benchmarks that rely on other parts fo pandas.
+"""
+from pandas import Period
+
+from pandas.tseries.frequencies import to_offset
+
+
+class PeriodProperties:
+
+    params = (
+        ["M", "min"],
+        [
+            "year",
+            "month",
+            "day",
+            "hour",
+            "minute",
+            "second",
+            "is_leap_year",
+            "quarter",
+            "qyear",
+            "week",
+            "daysinmonth",
+            "dayofweek",
+            "dayofyear",
+            "start_time",
+            "end_time",
+        ],
+    )
+    param_names = ["freq", "attr"]
+
+    def setup(self, freq, attr):
+        self.per = Period("2012-06-01", freq=freq)
+
+    def time_property(self, freq, attr):
+        getattr(self.per, attr)
+
+
+class PeriodUnaryMethods:
+
+    params = ["M", "min"]
+    param_names = ["freq"]
+
+    def setup(self, freq):
+        self.per = Period("2012-06-01", freq=freq)
+
+    def time_to_timestamp(self, freq):
+        self.per.to_timestamp()
+
+    def time_now(self, freq):
+        self.per.now(freq)
+
+    def time_asfreq(self, freq):
+        self.per.asfreq("A")
+
+
+class PeriodConstructor:
+    params = [["D"], [True, False]]
+    param_names = ["freq", "is_offset"]
+
+    def setup(self, freq, is_offset):
+        if is_offset:
+            self.freq = to_offset(freq)
+        else:
+            self.freq = freq
+
+    def time_period_constructor(self, freq, is_offset):
+        Period("2012-06-01", freq=freq)
diff --git a/asv_bench/benchmarks/tslibs/timedelta.py b/asv_bench/benchmarks/tslibs/timedelta.py
new file mode 100644
index 0000000000000..6ed273281569b
--- /dev/null
+++ b/asv_bench/benchmarks/tslibs/timedelta.py
@@ -0,0 +1,69 @@
+"""
+Timedelta benchmarks that rely only on tslibs.  See benchmarks.timedeltas for
+Timedelta benchmarks that rely on other parts fo pandas.
+"""
+import datetime
+
+import numpy as np
+
+from pandas import Timedelta
+
+
+class TimedeltaConstructor:
+    def setup(self):
+        self.nptimedelta64 = np.timedelta64(3600)
+        self.dttimedelta = datetime.timedelta(seconds=3600)
+        self.td = Timedelta(3600, unit="s")
+
+    def time_from_int(self):
+        Timedelta(123456789)
+
+    def time_from_unit(self):
+        Timedelta(1, unit="d")
+
+    def time_from_components(self):
+        Timedelta(
+            days=1,
+            hours=2,
+            minutes=3,
+            seconds=4,
+            milliseconds=5,
+            microseconds=6,
+            nanoseconds=7,
+        )
+
+    def time_from_datetime_timedelta(self):
+        Timedelta(self.dttimedelta)
+
+    def time_from_np_timedelta(self):
+        Timedelta(self.nptimedelta64)
+
+    def time_from_string(self):
+        Timedelta("1 days")
+
+    def time_from_iso_format(self):
+        Timedelta("P4DT12H30M5S")
+
+    def time_from_missing(self):
+        Timedelta("nat")
+
+    def time_from_pd_timedelta(self):
+        Timedelta(self.td)
+
+
+class TimedeltaProperties:
+    def setup_cache(self):
+        td = Timedelta(days=365, minutes=35, seconds=25, milliseconds=35)
+        return td
+
+    def time_timedelta_days(self, td):
+        td.days
+
+    def time_timedelta_seconds(self, td):
+        td.seconds
+
+    def time_timedelta_microseconds(self, td):
+        td.microseconds
+
+    def time_timedelta_nanoseconds(self, td):
+        td.nanoseconds
diff --git a/asv_bench/benchmarks/timestamp.py b/asv_bench/benchmarks/tslibs/timestamp.py
similarity index 84%
rename from asv_bench/benchmarks/timestamp.py
rename to asv_bench/benchmarks/tslibs/timestamp.py
index 8ebb2d8d2f35d..3ef9b814dd79e 100644
--- a/asv_bench/benchmarks/timestamp.py
+++ b/asv_bench/benchmarks/tslibs/timestamp.py
@@ -1,12 +1,19 @@
 import datetime
 
 import dateutil
+import numpy as np
 import pytz
 
 from pandas import Timestamp
 
 
 class TimestampConstruction:
+    def setup(self):
+        self.npdatetime64 = np.datetime64("2020-01-01 00:00:00")
+        self.dttime_unaware = datetime.datetime(2020, 1, 1, 0, 0, 0)
+        self.dttime_aware = datetime.datetime(2020, 1, 1, 0, 0, 0, 0, pytz.UTC)
+        self.ts = Timestamp("2020-01-01 00:00:00")
+
     def time_parse_iso8601_no_tz(self):
         Timestamp("2017-08-25 08:16:14")
 
@@ -28,6 +35,18 @@ def time_fromordinal(self):
     def time_fromtimestamp(self):
         Timestamp.fromtimestamp(1515448538)
 
+    def time_from_npdatetime64(self):
+        Timestamp(self.npdatetime64)
+
+    def time_from_datetime_unaware(self):
+        Timestamp(self.dttime_unaware)
+
+    def time_from_datetime_aware(self):
+        Timestamp(self.dttime_aware)
+
+    def time_from_pd_timestamp(self):
+        Timestamp(self.ts)
+
 
 class TimestampProperties:
     _tzs = [None, pytz.timezone("Europe/Amsterdam"), pytz.UTC, dateutil.tz.tzutc()]
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 263a87176a9c9..d992c64073476 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -4,7 +4,7 @@ jobs:
 - template: ci/azure/posix.yml
   parameters:
     name: macOS
-    vmImage: xcode9-macos10.13
+    vmImage: macOS-10.14
 
 - template: ci/azure/posix.yml
   parameters:
@@ -16,108 +16,25 @@ jobs:
     name: Windows
     vmImage: vs2017-win2016
 
-- job: 'Checks'
+- job: 'Web_and_Docs'
   pool:
     vmImage: ubuntu-16.04
   timeoutInMinutes: 90
   steps:
   - script: |
-      echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
       echo '##vso[task.setvariable variable=ENV_FILE]environment.yml'
-      echo '##vso[task.setvariable variable=AZURE]true'
+      echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
     displayName: 'Setting environment variables'
 
-  # Do not require a conda environment
-  - script: ci/code_checks.sh patterns
-    displayName: 'Looking for unwanted patterns'
-    condition: true
-
   - script: |
       sudo apt-get install -y libc6-dev-i386
       ci/setup_env.sh
     displayName: 'Setup environment and build pandas'
-    condition: true
-
-  # Do not require pandas
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh lint
-    displayName: 'Linting'
-    condition: true
-
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh dependencies
-    displayName: 'Dependencies consistency'
-    condition: true
-
-  # Require pandas
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh code
-    displayName: 'Checks on imported code'
-    condition: true
-
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh doctests
-    displayName: 'Running doctests'
-    condition: true
-
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh docstrings
-    displayName: 'Docstring validation'
-    condition: true
-
-  - script: |
-      source activate pandas-dev
-      ci/code_checks.sh typing
-    displayName: 'Typing validation'
-    condition: true
 
   - script: |
       source activate pandas-dev
-      pytest --capture=no --strict scripts
-    displayName: 'Testing docstring validation script'
-    condition: true
-
-  - script: |
-      source activate pandas-dev
-      cd asv_bench
-      asv check -E existing
-      git remote add upstream https://github.com/pandas-dev/pandas.git
-      git fetch upstream
-      if git diff upstream/master --name-only | grep -q "^asv_bench/"; then
-          asv machine --yes
-          ASV_OUTPUT="$(asv dev)"
-          if [[ $(echo "$ASV_OUTPUT" | grep "failed") ]]; then
-              echo "##vso[task.logissue type=error]Benchmarks run with errors"
-              echo "$ASV_OUTPUT"
-              exit 1
-          else
-              echo "Benchmarks run without errors"
-          fi
-      else
-          echo "Benchmarks did not run, no changes detected"
-      fi
-    displayName: 'Running benchmarks'
-    condition: true
-
-- job: 'Docs'
-  pool:
-    vmImage: ubuntu-16.04
-  timeoutInMinutes: 90
-  steps:
-  - script: |
-      echo '##vso[task.setvariable variable=ENV_FILE]environment.yml'
-      echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
-    displayName: 'Setting environment variables'
-
-  - script: |
-      sudo apt-get install -y libc6-dev-i386
-      ci/setup_env.sh
-    displayName: 'Setup environment and build pandas'
+      python web/pandas_web.py web/pandas --target-path=web/build
+    displayName: 'Build website'
 
   - script: |
       source activate pandas-dev
@@ -128,15 +45,21 @@ jobs:
     displayName: 'Build documentation'
 
   - script: |
-      cd doc/build/html
+      mkdir -p to_deploy/docs
+      cp -r web/build/* to_deploy/
+      cp -r doc/build/html/* to_deploy/docs/
+    displayName: 'Merge website and docs'
+
+  - script: |
+      cd to_deploy
       git init
       touch .nojekyll
       echo "dev.pandas.io" > CNAME
       printf "User-agent: *\nDisallow: /" > robots.txt
       git add --all .
       git config user.email "pandas-dev@python.org"
-      git config user.name "pandas-docs-bot"
-      git commit -m "pandas documentation in master"
+      git config user.name "pandas-bot"
+      git commit -m "pandas web and documentation in master"
     displayName: 'Create git repo for docs build'
     condition : |
       and(not(eq(variables['Build.Reason'], 'PullRequest')),
@@ -160,10 +83,10 @@ jobs:
           eq(variables['Build.SourceBranch'], 'refs/heads/master'))
 
   - script: |
-      cd doc/build/html
+      cd to_deploy
       git remote add origin git@github.com:pandas-dev/pandas-dev.github.io.git
       git push -f origin master
-    displayName: 'Publish docs to GitHub pages'
+    displayName: 'Publish web and docs to GitHub pages'
     condition : |
       and(not(eq(variables['Build.Reason'], 'PullRequest')),
           eq(variables['Build.SourceBranch'], 'refs/heads/master'))
diff --git a/ci/azure/posix.yml b/ci/azure/posix.yml
index 6093df46ffb60..c9a2e4eefd19d 100644
--- a/ci/azure/posix.yml
+++ b/ci/azure/posix.yml
@@ -9,41 +9,48 @@ jobs:
   strategy:
     matrix:
       ${{ if eq(parameters.name, 'macOS') }}:
-        py35_macos:
-          ENV_FILE: ci/deps/azure-macos-35.yaml
-          CONDA_PY: "35"
+        py36_macos:
+          ENV_FILE: ci/deps/azure-macos-36.yaml
+          CONDA_PY: "36"
           PATTERN: "not slow and not network"
 
       ${{ if eq(parameters.name, 'Linux') }}:
-        py35_compat:
-          ENV_FILE: ci/deps/azure-35-compat.yaml
-          CONDA_PY: "35"
-          PATTERN: "not slow and not network"
+        py36_minimum_versions:
+          ENV_FILE: ci/deps/azure-36-minimum_versions.yaml
+          CONDA_PY: "36"
+          PATTERN: "not slow and not network and not clipboard"
 
         py36_locale_slow_old_np:
-          ENV_FILE: ci/deps/azure-36-locale.yaml
+          ENV_FILE: ci/deps/azure-36-locale_slow.yaml
           CONDA_PY: "36"
           PATTERN: "slow"
-          LOCALE_OVERRIDE: "zh_CN.UTF-8"
+          # pandas does not use the language (zh_CN), but should support diferent encodings (utf8)
+          # we should test with encodings different than utf8, but doesn't seem like Ubuntu supports any
+          LANG: "zh_CN.utf8"
+          LC_ALL: "zh_CN.utf8"
           EXTRA_APT: "language-pack-zh-hans"
 
-        py36_locale_slow:
-          ENV_FILE: ci/deps/azure-36-locale_slow.yaml
+        py36_locale:
+          ENV_FILE: ci/deps/azure-36-locale.yaml
           CONDA_PY: "36"
           PATTERN: "not slow and not network"
-          LOCALE_OVERRIDE: "it_IT.UTF-8"
+          LANG: "it_IT.utf8"
+          LC_ALL: "it_IT.utf8"
+          EXTRA_APT: "language-pack-it xsel"
 
         py36_32bit:
           ENV_FILE: ci/deps/azure-36-32bit.yaml
           CONDA_PY: "36"
-          PATTERN: "not slow and not network"
+          PATTERN: "not slow and not network and not clipboard"
           BITS32: "yes"
 
         py37_locale:
           ENV_FILE: ci/deps/azure-37-locale.yaml
           CONDA_PY: "37"
           PATTERN: "not slow and not network"
-          LOCALE_OVERRIDE: "zh_CN.UTF-8"
+          LANG: "zh_CN.utf8"
+          LC_ALL: "zh_CN.utf8"
+          EXTRA_APT: "language-pack-zh-hans xsel"
 
         py37_np_dev:
           ENV_FILE: ci/deps/azure-37-numpydev.yaml
@@ -55,45 +62,34 @@ jobs:
 
   steps:
     - script: |
-        if [ "$(uname)" == "Linux" ]; then sudo apt-get install -y libc6-dev-i386 $EXTRA_APT; fi
-        echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
-        echo "Creating Environment"
-        ci/setup_env.sh
+        if [ "$(uname)" == "Linux" ]; then
+          sudo apt-get update
+          sudo apt-get install -y libc6-dev-i386 $EXTRA_APT
+        fi
+      displayName: 'Install extra packages'
+
+    - script: echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'
+      displayName: 'Set conda path'
+
+    - script: ci/setup_env.sh
       displayName: 'Setup environment and build pandas'
+
     - script: |
         source activate pandas-dev
         ci/run_tests.sh
       displayName: 'Test'
+
     - script: source activate pandas-dev && pushd /tmp && python -c "import pandas; pandas.show_versions();" && popd
+      displayName: 'Build versions'
+
     - task: PublishTestResults@2
+      condition: succeededOrFailed()
       inputs:
-        testResultsFiles: 'test-data-*.xml'
+        failTaskOnFailedTests: true
+        testResultsFiles: 'test-data.xml'
         testRunTitle: ${{ format('{0}-$(CONDA_PY)', parameters.name) }}
-    - powershell: |
-        $junitXml = "test-data-single.xml"
-        $(Get-Content $junitXml | Out-String) -match 'failures="(.*?)"'
-        if ($matches[1] -eq 0)
-        {
-          Write-Host "No test failures in test-data-single"
-        }
-        else
-        {
-          # note that this will produce $LASTEXITCODE=1
-          Write-Error "$($matches[1]) tests failed"
-        }
+      displayName: 'Publish test results'
 
-        $junitXmlMulti = "test-data-multiple.xml"
-        $(Get-Content $junitXmlMulti | Out-String) -match 'failures="(.*?)"'
-        if ($matches[1] -eq 0)
-        {
-          Write-Host "No test failures in test-data-multi"
-        }
-        else
-        {
-          # note that this will produce $LASTEXITCODE=1
-          Write-Error "$($matches[1]) tests failed"
-        }
-      displayName: 'Check for test failures'
     - script: |
         source activate pandas-dev
         python ci/print_skipped.py
diff --git a/ci/azure/windows.yml b/ci/azure/windows.yml
index dfa82819b9826..187a5db99802f 100644
--- a/ci/azure/windows.yml
+++ b/ci/azure/windows.yml
@@ -11,49 +11,47 @@ jobs:
       py36_np15:
         ENV_FILE: ci/deps/azure-windows-36.yaml
         CONDA_PY: "36"
+        PATTERN: "not slow and not network"
 
       py37_np141:
         ENV_FILE: ci/deps/azure-windows-37.yaml
         CONDA_PY: "37"
+        PATTERN: "not slow and not network"
 
   steps:
     - powershell: |
         Write-Host "##vso[task.prependpath]$env:CONDA\Scripts"
         Write-Host "##vso[task.prependpath]$HOME/miniconda3/bin"
       displayName: 'Add conda to PATH'
+
     - script: conda update -q -n base conda
-      displayName: Update conda
-    - script: |
-        call activate
+      displayName: 'Update conda'
+
+    - bash: |
         conda env create -q --file ci\\deps\\azure-windows-$(CONDA_PY).yaml
       displayName: 'Create anaconda environment'
-    - script: |
-        call activate pandas-dev
-        call conda list
-        ci\\incremental\\build.cmd
+
+    - bash: |
+        source activate pandas-dev
+        conda list
+        python setup.py build_ext -q -i -j 4
+        python -m pip install --no-build-isolation -e .
       displayName: 'Build'
-    - script: |
-        call activate pandas-dev
-        pytest -m "not slow and not network" --junitxml=test-data.xml pandas -n 2 -r sxX --strict --durations=10 %*
+
+    - bash: |
+        source activate pandas-dev
+        ci/run_tests.sh
       displayName: 'Test'
+
     - task: PublishTestResults@2
+      condition: succeededOrFailed()
       inputs:
+        failTaskOnFailedTests: true
         testResultsFiles: 'test-data.xml'
-        testRunTitle: 'Windows-$(CONDA_PY)'
-    - powershell: |
-        $junitXml = "test-data.xml"
-        $(Get-Content $junitXml | Out-String) -match 'failures="(.*?)"'
-        if ($matches[1] -eq 0)
-        {
-          Write-Host "No test failures in test-data"
-        }
-        else
-        {
-          # note that this will produce $LASTEXITCODE=1
-          Write-Error "$($matches[1]) tests failed"
-        }
-      displayName: 'Check for test failures'
-    - script: |
+        testRunTitle: ${{ format('{0}-$(CONDA_PY)', parameters.name) }}
+      displayName: 'Publish test results'
+
+    - bash: |
         source activate pandas-dev
         python ci/print_skipped.py
       displayName: 'Print skipped tests'
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index f839d86318e2e..fdc9fef5d7f77 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -34,17 +34,13 @@ function invgrep {
     #
     # This is useful for the CI, as we want to fail if one of the patterns
     # that we want to avoid is found by grep.
-    if [[ "$AZURE" == "true" ]]; then
-        set -o pipefail
-        grep -n "$@" | awk -F ":" '{print "##vso[task.logissue type=error;sourcepath=" $1 ";linenumber=" $2 ";] Found unwanted pattern: " $3}'
-    else
-        grep "$@"
-    fi
-    return $((! $?))
+    grep -n "$@" | sed "s/^/$INVGREP_PREPEND/" | sed "s/$/$INVGREP_APPEND/" ; EXIT_STATUS=${PIPESTATUS[0]}
+    return $((! $EXIT_STATUS))
 }
 
-if [[ "$AZURE" == "true" ]]; then
-    FLAKE8_FORMAT="##vso[task.logissue type=error;sourcepath=%(path)s;linenumber=%(row)s;columnnumber=%(col)s;code=%(code)s;]%(text)s"
+if [[ "$GITHUB_ACTIONS" == "true" ]]; then
+    FLAKE8_FORMAT="##[error]%(path)s:%(row)s:%(col)s:%(code)s:%(text)s"
+    INVGREP_PREPEND="##[error]"
 else
     FLAKE8_FORMAT="default"
 fi
@@ -56,7 +52,7 @@ if [[ -z "$CHECK" || "$CHECK" == "lint" ]]; then
     black --version
 
     MSG='Checking black formatting' ; echo $MSG
-	black . --check --exclude '(asv_bench/env|\.egg|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|_build|buck-out|build|dist|setup.py)'
+    black . --check
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
     # `setup.cfg` contains the list of error codes that are being ignored in flake8
@@ -98,18 +94,31 @@ if [[ -z "$CHECK" || "$CHECK" == "lint" ]]; then
 
     # We don't lint all C files because we don't want to lint any that are built
     # from Cython files nor do we want to lint C files that we didn't modify for
-    # this particular codebase (e.g. src/headers, src/klib, src/msgpack). However,
+    # this particular codebase (e.g. src/headers, src/klib). However,
     # we can lint all header files since they aren't "generated" like C files are.
     MSG='Linting .c and .h' ; echo $MSG
-    cpplint --quiet --extensions=c,h --headers=h --recursive --filter=-readability/casting,-runtime/int,-build/include_subdir pandas/_libs/src/*.h pandas/_libs/src/parser pandas/_libs/ujson pandas/_libs/tslibs/src/datetime pandas/io/msgpack pandas/_libs/*.cpp pandas/util
+    cpplint --quiet --extensions=c,h --headers=h --recursive --filter=-readability/casting,-runtime/int,-build/include_subdir pandas/_libs/src/*.h pandas/_libs/src/parser pandas/_libs/ujson pandas/_libs/tslibs/src/datetime pandas/_libs/*.cpp
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of not concatenated strings' ; echo $MSG
+    if [[ "$GITHUB_ACTIONS" == "true" ]]; then
+        $BASE_DIR/scripts/validate_string_concatenation.py --format="[error]{source_path}:{line_number}:{msg}" .
+    else
+        $BASE_DIR/scripts/validate_string_concatenation.py .
+    fi
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
     echo "isort --version-number"
     isort --version-number
 
     # Imports - Check formatting using isort see setup.cfg for settings
-    MSG='Check import format using isort ' ; echo $MSG
-    isort --recursive --check-only pandas asv_bench
+    MSG='Check import format using isort' ; echo $MSG
+    ISORT_CMD="isort --quiet --recursive --check-only pandas asv_bench"
+    if [[ "$GITHUB_ACTIONS" == "true" ]]; then
+        eval $ISORT_CMD | awk '{print "##[error]" $0}'; RET=$(($RET + ${PIPESTATUS[0]}))
+    else
+        eval $ISORT_CMD
+    fi
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
 fi
@@ -120,9 +129,24 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
     # Check for imports from pandas.core.common instead of `import pandas.core.common as com`
     # Check for imports from collections.abc instead of `from collections import abc`
     MSG='Check for non-standard imports' ; echo $MSG
-    invgrep -R --include="*.py*" -E "from pandas.core.common import " pandas
-    invgrep -R --include="*.py*" -E "from collections.abc import " pandas
-    # invgrep -R --include="*.py*" -E "from numpy import nan " pandas  # GH#24822 not yet implemented since the offending imports have not all been removed
+    invgrep -R --include="*.py*" -E "from pandas.core.common import" pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+    invgrep -R --include="*.py*" -E "from pandas.core import common" pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+    invgrep -R --include="*.py*" -E "from collections.abc import" pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+    invgrep -R --include="*.py*" -E "from numpy import nan" pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    # Checks for test suite
+    # Check for imports from pandas._testing instead of `import pandas._testing as tm`
+    invgrep -R --include="*.py*" -E "from pandas._testing import" pandas/tests
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+    invgrep -R --include="*.py*" -E "from pandas.util import testing as tm" pandas/tests
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of exec' ; echo $MSG
+    invgrep -R --include="*.py*" -E "[^a-zA-Z0-9_]exec\(" pandas
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
     MSG='Check for pytest warns' ; echo $MSG
@@ -167,10 +191,6 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
     invgrep -R --include="*.py" --include="*.pyx" --include="*.rst" -E "\.\. (autosummary|contents|currentmodule|deprecated|function|image|important|include|ipython|literalinclude|math|module|note|raw|seealso|toctree|versionadded|versionchanged|warning):[^:]" ./pandas ./doc/source
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
-    MSG='Check that the deprecated `assert_raises_regex` is not used (`pytest.raises(match=pattern)` should be used instead)' ; echo $MSG
-    invgrep -R --exclude=*.pyc --exclude=testing.py --exclude=test_util.py assert_raises_regex pandas
-    RET=$(($RET + $?)) ; echo $MSG "DONE"
-
     # Check for the following code in testing: `unittest.mock`, `mock.Mock()` or `mock.patch`
     MSG='Check that unittest.mock is not used (pytest builtin monkeypatch fixture should be used instead)' ; echo $MSG
     invgrep -r -E --include '*.py' '(unittest(\.| import )mock|mock\.Mock\(\)|mock\.patch)' pandas/tests/
@@ -184,15 +204,31 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
     invgrep -R --include="*.rst" ".. ipython ::" doc/source
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
-    MSG='Check that no file in the repo contains tailing whitespaces' ; echo $MSG
-    set -o pipefail
-    if [[ "$AZURE" == "true" ]]; then
-        # we exclude all c/cpp files as the c/cpp files of pandas code base are tested when Linting .c and .h files
-        ! grep -n '--exclude=*.'{svg,c,cpp,html} --exclude-dir=env -RI "\s$" * | awk -F ":" '{print "##vso[task.logissue type=error;sourcepath=" $1 ";linenumber=" $2 ";] Tailing whitespaces found: " $3}'
-    else
-        ! grep -n '--exclude=*.'{svg,c,cpp,html} --exclude-dir=env -RI "\s$" * | awk -F ":" '{print $1 ":" $2 ":Tailing whitespaces found: " $3}'
-    fi
+    MSG='Check for extra blank lines after the class definition' ; echo $MSG
+    invgrep -R --include="*.py" --include="*.pyx" -E 'class.*:\n\n( )+"""' .
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of {foo!r} instead of {repr(foo)}' ; echo $MSG
+    invgrep -R --include=*.{py,pyx} '!r}' pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of comment-based annotation syntax' ; echo $MSG
+    invgrep -R --include="*.py" -P '# type: (?!ignore)' pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of foo.__class__ instead of type(foo)' ; echo $MSG
+    invgrep -R --include=*.{py,pyx} '\.__class__' pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for use of xrange instead of range' ; echo $MSG
+    invgrep -R --include=*.{py,pyx} 'xrange' pandas
     RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check that no file in the repo contains trailing whitespaces' ; echo $MSG
+    INVGREP_APPEND=" <- trailing whitespaces found"
+    invgrep -RI --exclude=\*.{svg,c,cpp,html,js} --exclude-dir=env "\s$" *
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+    unset INVGREP_APPEND
 fi
 
 ### CODE ###
@@ -204,7 +240,7 @@ import sys
 import pandas
 
 blacklist = {'bs4', 'gcsfs', 'html5lib', 'http', 'ipython', 'jinja2', 'hypothesis',
-             'lxml', 'numexpr', 'openpyxl', 'py', 'pytest', 's3fs', 'scipy',
+             'lxml', 'matplotlib', 'numexpr', 'openpyxl', 'py', 'pytest', 's3fs', 'scipy',
              'tables', 'urllib.request', 'xlrd', 'xlsxwriter', 'xlwt'}
 
 # GH#28227 for some of these check for top-level modules, while others are
@@ -262,13 +298,28 @@ if [[ -z "$CHECK" || "$CHECK" == "doctests" ]]; then
         -k"-from_arrays -from_breaks -from_intervals -from_tuples -set_closed -to_tuples -interval_range"
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
+    MSG='Doctests arrays'; echo $MSG
+    pytest -q --doctest-modules \
+        pandas/core/arrays/string_.py \
+        pandas/core/arrays/integer.py \
+        pandas/core/arrays/boolean.py
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Doctests dtypes'; echo $MSG
+    pytest -q --doctest-modules pandas/core/dtypes/
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Doctests arrays/boolean.py' ; echo $MSG
+    pytest -q --doctest-modules pandas/core/arrays/boolean.py
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
 fi
 
 ### DOCSTRINGS ###
 if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
 
-    MSG='Validate docstrings (GL03, GL04, GL05, GL06, GL07, GL09, GL10, SS04, SS05, PR03, PR04, PR05, PR10, EX04, RT01, RT04, RT05, SA05)' ; echo $MSG
-    $BASE_DIR/scripts/validate_docstrings.py --format=azure --errors=GL03,GL04,GL05,GL06,GL07,GL09,GL10,SS04,SS05,PR03,PR04,PR05,PR10,EX04,RT01,RT04,RT05,SA05
+    MSG='Validate docstrings (GL03, GL04, GL05, GL06, GL07, GL09, GL10, SS04, SS05, PR03, PR04, PR05, PR10, EX04, RT01, RT04, RT05, SA02, SA03, SA05)' ; echo $MSG
+    $BASE_DIR/scripts/validate_docstrings.py --format=actions --errors=GL03,GL04,GL05,GL06,GL07,GL09,GL10,SS04,SS05,PR03,PR04,PR05,PR10,EX04,RT01,RT04,RT05,SA02,SA03,SA05
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
 fi
diff --git a/ci/deps/azure-36-32bit.yaml b/ci/deps/azure-36-32bit.yaml
index 321cc203961d5..cf3fca307481f 100644
--- a/ci/deps/azure-36-32bit.yaml
+++ b/ci/deps/azure-36-32bit.yaml
@@ -3,20 +3,24 @@ channels:
   - defaults
   - conda-forge
 dependencies:
-  - gcc_linux-32
+  - python=3.6.*
+
+  # tools
+  ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - attrs=19.1.0
   - gcc_linux-32
   - gxx_linux-32
   - numpy=1.14.*
   - python-dateutil
-  - python=3.6.*
   - pytz=2017.2
-  # universal
-  - pytest>=4.0.2,<5.0.0
-  - pytest-xdist
-  - pytest-mock
-  - pytest-azurepipelines
-  - hypothesis>=3.58.0
+
+  # see comment above
   - pip
   - pip:
-    # Anaconda doesn't build a new enough Cython
     - cython>=0.29.13
+    - pytest>=5.0.1
diff --git a/ci/deps/azure-36-locale.yaml b/ci/deps/azure-36-locale.yaml
index 76868f598f11b..810554632a507 100644
--- a/ci/deps/azure-36-locale.yaml
+++ b/ci/deps/azure-36-locale.yaml
@@ -3,28 +3,38 @@ channels:
   - defaults
   - conda-forge
 dependencies:
-  - beautifulsoup4==4.6.0
-  - bottleneck=1.2.*
-  - cython=0.29.13
+  - python=3.6.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - pytest-asyncio
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - beautifulsoup4
+  - gcsfs
+  - html5lib
+  - ipython
+  - jinja2
   - lxml
-  - matplotlib=2.2.2
-  - numpy=1.14.*
-  - openpyxl=2.4.8
+  - matplotlib=3.0.*
+  - nomkl
+  - numexpr
+  - numpy=1.15.*
+  - openpyxl
+  # lowest supported version of pyarrow (putting it here instead of in
+  # azure-36-minimum_versions because it needs numpy >= 1.14)
+  - pyarrow=0.13
+  - pytables
   - python-dateutil
-  - python-blosc
-  - python=3.6.*
-  - pytz=2017.2
+  - pytz
+  - s3fs
   - scipy
-  - sqlalchemy=1.1.4
-  - xlrd=1.1.0
-  - xlsxwriter=0.9.8
-  - xlwt=1.2.0
-  # universal
-  - pytest>=5.0.0
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - pytest-azurepipelines
-  - hypothesis>=3.58.0
-  - pip
-  - pip:
-    - html5lib==1.0b2
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - moto
diff --git a/ci/deps/azure-36-locale_slow.yaml b/ci/deps/azure-36-locale_slow.yaml
index 21205375204dc..48ac50c001715 100644
--- a/ci/deps/azure-36-locale_slow.yaml
+++ b/ci/deps/azure-36-locale_slow.yaml
@@ -3,34 +3,30 @@ channels:
   - defaults
   - conda-forge
 dependencies:
-  - beautifulsoup4
+  - python=3.6.*
+
+  # tools
   - cython>=0.29.13
-  - gcsfs
-  - html5lib
-  - ipython
-  - jinja2
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - beautifulsoup4=4.6.0
+  - bottleneck=1.2.*
   - lxml
-  - matplotlib=3.0.*
-  - nomkl
-  - numexpr
-  - numpy=1.15.*
-  - openpyxl
-  - pytables
+  - matplotlib=2.2.2
+  - numpy=1.14.*
+  - openpyxl=2.5.7
   - python-dateutil
-  - python=3.6.*
-  - pytz
-  - s3fs
+  - python-blosc
+  - pytz=2017.2
   - scipy
-  - xarray
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  # universal
-  - pytest>=4.0.2
-  - pytest-xdist
-  - pytest-mock
-  - pytest-azurepipelines
-  - moto
+  - sqlalchemy=1.1.4
+  - xlrd=1.1.0
+  - xlsxwriter=0.9.8
+  - xlwt=1.2.0
   - pip
   - pip:
-    - hypothesis>=3.58.0
+    - html5lib==1.0b2
diff --git a/ci/deps/azure-35-compat.yaml b/ci/deps/azure-36-minimum_versions.yaml
similarity index 58%
rename from ci/deps/azure-35-compat.yaml
rename to ci/deps/azure-36-minimum_versions.yaml
index dd54001984ec7..de7e011d9c7ca 100644
--- a/ci/deps/azure-35-compat.yaml
+++ b/ci/deps/azure-36-minimum_versions.yaml
@@ -3,28 +3,29 @@ channels:
   - defaults
   - conda-forge
 dependencies:
+  - python=3.6.1
+
+  # tools
+  - cython=0.29.13
+  - pytest=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+  - psutil
+
+  # pandas dependencies
   - beautifulsoup4=4.6.0
   - bottleneck=1.2.1
   - jinja2=2.8
+  - numba=0.46.0
   - numexpr=2.6.2
   - numpy=1.13.3
-  - openpyxl=2.4.8
+  - openpyxl=2.5.7
   - pytables=3.4.2
   - python-dateutil=2.6.1
-  - python=3.5.3
   - pytz=2017.2
   - scipy=0.19.0
   - xlrd=1.1.0
   - xlsxwriter=0.9.8
   - xlwt=1.2.0
-  # universal
-  - hypothesis>=3.58.0
-  - pytest-xdist
-  - pytest-mock
-  - pytest-azurepipelines
-  - pip
-  - pip:
-    # for python 3.5, pytest>=4.0.2, cython>=0.29.13 is not available in conda
-    - cython>=0.29.13
-    - pytest==4.5.0
-    - html5lib==1.0b2
+  - html5lib=1.0.1
diff --git a/ci/deps/azure-37-locale.yaml b/ci/deps/azure-37-locale.yaml
index 24464adb74f5b..dc51597a33209 100644
--- a/ci/deps/azure-37-locale.yaml
+++ b/ci/deps/azure-37-locale.yaml
@@ -1,10 +1,19 @@
 name: pandas-dev
 channels:
-  - defaults
   - conda-forge
 dependencies:
-  - beautifulsoup4
+  - python=3.7.*
+
+  # tools
   - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - pytest-asyncio
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - beautifulsoup4
   - html5lib
   - ipython
   - jinja2
@@ -17,7 +26,6 @@ dependencies:
   - openpyxl
   - pytables
   - python-dateutil
-  - python=3.7.*
   - pytz
   - s3fs
   - scipy
@@ -25,11 +33,7 @@ dependencies:
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - pytest>=5.0.1
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - pytest-azurepipelines
+  - pyarrow>=0.15
   - pip
   - pip:
-    - hypothesis>=3.58.0
+    - pyxlsb
diff --git a/ci/deps/azure-37-numpydev.yaml b/ci/deps/azure-37-numpydev.yaml
index 0fb06fd43724c..a04bdc2448bce 100644
--- a/ci/deps/azure-37-numpydev.yaml
+++ b/ci/deps/azure-37-numpydev.yaml
@@ -3,14 +3,16 @@ channels:
   - defaults
 dependencies:
   - python=3.7.*
-  - pytz
-  - Cython>=0.29.13
-  # universal
-  # pytest < 5 until defaults has pytest-xdist>=1.29.0
-  - pytest>=4.0.2,<5.0
-  - pytest-xdist
-  - pytest-mock
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
   - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - pytz
   - pip
   - pip:
     - "git+git://github.com/dateutil/dateutil.git"
@@ -18,5 +20,3 @@ dependencies:
     - "--pre"
     - "numpy"
     - "scipy"
-    # https://github.com/pandas-dev/pandas/issues/27421
-    - pytest-azurepipelines<1.0.0
diff --git a/ci/deps/azure-macos-35.yaml b/ci/deps/azure-macos-35.yaml
deleted file mode 100644
index 4e0f09904b695..0000000000000
--- a/ci/deps/azure-macos-35.yaml
+++ /dev/null
@@ -1,35 +0,0 @@
-name: pandas-dev
-channels:
-  - defaults
-dependencies:
-  - beautifulsoup4
-  - bottleneck
-  - html5lib
-  - jinja2
-  - lxml
-  - matplotlib=2.2.3
-  - nomkl
-  - numexpr
-  - numpy=1.13.3
-  - openpyxl
-  - pyarrow
-  - pytables
-  - python=3.5.*
-  - python-dateutil==2.6.1
-  - pytz
-  - xarray
-  - xlrd
-  - xlsxwriter
-  - xlwt
-  - pip
-  - pip:
-    # Anaconda / conda-forge don't build for 3.5
-    - cython>=0.29.13
-    - pyreadstat
-    # universal
-    - pytest>=5.0.1
-    - pytest-xdist>=1.29.0
-    - pytest-mock
-    - hypothesis>=3.58.0
-    # https://github.com/pandas-dev/pandas/issues/27421
-    - pytest-azurepipelines<1.0.0
diff --git a/ci/deps/azure-macos-36.yaml b/ci/deps/azure-macos-36.yaml
new file mode 100644
index 0000000000000..90980133b31c1
--- /dev/null
+++ b/ci/deps/azure-macos-36.yaml
@@ -0,0 +1,36 @@
+name: pandas-dev
+channels:
+  - defaults
+dependencies:
+  - python=3.6.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
+  - beautifulsoup4
+  - bottleneck
+  - html5lib
+  - jinja2
+  - lxml
+  - matplotlib=2.2.3
+  - nomkl
+  - numexpr
+  - numpy=1.14
+  - openpyxl
+  - pyarrow>=0.13.0
+  - pytables
+  - python-dateutil==2.6.1
+  - pytz
+  - xarray
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - pip
+  - pip:
+    - pyreadstat
+    - pyxlsb
diff --git a/ci/deps/azure-windows-36.yaml b/ci/deps/azure-windows-36.yaml
index 88b38aaef237c..663c55492e69e 100644
--- a/ci/deps/azure-windows-36.yaml
+++ b/ci/deps/azure-windows-36.yaml
@@ -3,26 +3,30 @@ channels:
   - conda-forge
   - defaults
 dependencies:
+  - python=3.6.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
   - blosc
   - bottleneck
-  - fastparquet>=0.2.1
+  - fastparquet>=0.3.2
   - matplotlib=3.0.2
+  - numba
   - numexpr
   - numpy=1.15.*
   - openpyxl
-  - pyarrow
+  - jinja2
+  - pyarrow>=0.13.0
   - pytables
   - python-dateutil
-  - python=3.6.*
   - pytz
   - scipy
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - cython>=0.29.13
-  - pytest>=5.0.1
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - pytest-azurepipelines
-  - hypothesis>=3.58.0
diff --git a/ci/deps/azure-windows-37.yaml b/ci/deps/azure-windows-37.yaml
index 7680ed9fd9c92..6b3ad6f560292 100644
--- a/ci/deps/azure-windows-37.yaml
+++ b/ci/deps/azure-windows-37.yaml
@@ -3,6 +3,16 @@ channels:
   - defaults
   - conda-forge
 dependencies:
+  - python=3.7.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-azurepipelines
+
+  # pandas dependencies
   - beautifulsoup4
   - bottleneck
   - gcsfs
@@ -14,8 +24,8 @@ dependencies:
   - numexpr
   - numpy=1.14.*
   - openpyxl
+  - pyarrow=0.14
   - pytables
-  - python=3.7.*
   - python-dateutil
   - pytz
   - s3fs
@@ -24,11 +34,7 @@ dependencies:
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - cython>=0.29.13
-  - pytest>=5.0.0
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - pytest-azurepipelines
-  - hypothesis>=3.58.0
   - pyreadstat
+  - pip
+  - pip:
+    - pyxlsb
diff --git a/ci/deps/travis-36-cov.yaml b/ci/deps/travis-36-cov.yaml
index b2a74fceaf0fa..6883301a63a9b 100644
--- a/ci/deps/travis-36-cov.yaml
+++ b/ci/deps/travis-36-cov.yaml
@@ -3,11 +3,21 @@ channels:
   - defaults
   - conda-forge
 dependencies:
+  - python=3.6.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+  - pytest-cov  # this is only needed in the coverage build
+
+  # pandas dependencies
   - beautifulsoup4
   - botocore>=1.11
   - cython>=0.29.13
   - dask
-  - fastparquet>=0.2.1
+  - fastparquet>=0.3.2
   - gcsfs
   - geopandas
   - html5lib
@@ -19,15 +29,11 @@ dependencies:
   - odfpy
   - openpyxl
   - pandas-gbq
-  # https://github.com/pydata/pandas-gbq/issues/271
-  - google-cloud-bigquery<=1.11
   - psycopg2
-  # pyarrow segfaults on load: https://github.com/pandas-dev/pandas/issues/26716
-  # - pyarrow=0.9.0
+  - pyarrow>=0.13.0
   - pymysql
   - pytables
   - python-snappy
-  - python=3.6.*
   - pytz
   - s3fs
   - scikit-learn
@@ -38,15 +44,10 @@ dependencies:
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - pytest>=5.0.1
-  - pytest-xdist>=1.29.0
-  - pytest-cov
-  - pytest-mock
-  - hypothesis>=3.58.0
   - pip
   - pip:
     - brotlipy
     - coverage
     - pandas-datareader
     - python-dateutil
+    - pyxlsb
diff --git a/ci/deps/travis-36-locale.yaml b/ci/deps/travis-36-locale.yaml
index 44795766d7c31..d0bc046575953 100644
--- a/ci/deps/travis-36-locale.yaml
+++ b/ci/deps/travis-36-locale.yaml
@@ -3,11 +3,19 @@ channels:
   - defaults
   - conda-forge
 dependencies:
+  - python=3.6.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+
+  # pandas dependencies
   - beautifulsoup4
   - blosc=1.14.3
   - python-blosc
-  - cython>=0.29.13
-  - fastparquet=0.2.1
+  - fastparquet=0.3.2
   - gcsfs=0.2.2
   - html5lib
   - ipython
@@ -24,19 +32,11 @@ dependencies:
   - pymysql=0.7.11
   - pytables
   - python-dateutil
-  - python=3.6.*
   - pytz
-  - s3fs=0.0.8
+  - s3fs=0.3.0
   - scipy
   - sqlalchemy=1.1.4
   - xarray=0.10
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - pytest>=5.0.1
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - pip
-  - pip:
-    - hypothesis>=3.58.0
diff --git a/ci/deps/travis-36-slow.yaml b/ci/deps/travis-36-slow.yaml
index e9c5dadbc924a..1dfd90d0904ac 100644
--- a/ci/deps/travis-36-slow.yaml
+++ b/ci/deps/travis-36-slow.yaml
@@ -3,8 +3,16 @@ channels:
   - defaults
   - conda-forge
 dependencies:
-  - beautifulsoup4
+  - python=3.6.*
+
+  # tools
   - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+
+  # pandas dependencies
+  - beautifulsoup4
   - html5lib
   - lxml
   - matplotlib
@@ -16,7 +24,6 @@ dependencies:
   - pymysql
   - pytables
   - python-dateutil
-  - python=3.6.*
   - pytz
   - s3fs
   - scipy
@@ -24,9 +31,4 @@ dependencies:
   - xlrd
   - xlsxwriter
   - xlwt
-  # universal
-  - pytest>=5.0.0
-  - pytest-xdist>=1.29.0
-  - pytest-mock
   - moto
-  - hypothesis>=3.58.0
diff --git a/ci/deps/travis-37.yaml b/ci/deps/travis-37.yaml
index 903636f2fe060..682b1016ff3a2 100644
--- a/ci/deps/travis-37.yaml
+++ b/ci/deps/travis-37.yaml
@@ -2,23 +2,25 @@ name: pandas-dev
 channels:
   - defaults
   - conda-forge
-  - c3i_test
 dependencies:
   - python=3.7.*
-  - botocore>=1.11
+
+  # tools
   - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+
+  # pandas dependencies
+  - botocore>=1.11
   - numpy
   - python-dateutil
   - nomkl
   - pyarrow
   - pytz
-  # universal
-  - pytest>=5.0.0
-  - pytest-xdist>=1.29.0
-  - pytest-mock
-  - hypothesis>=3.58.0
   - s3fs
-  - pip
+  - tabulate
   - pyreadstat
+  - pip
   - pip:
     - moto
diff --git a/ci/deps/travis-38.yaml b/ci/deps/travis-38.yaml
new file mode 100644
index 0000000000000..a627b7edc175f
--- /dev/null
+++ b/ci/deps/travis-38.yaml
@@ -0,0 +1,20 @@
+name: pandas-dev
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python=3.8.*
+
+  # tools
+  - cython>=0.29.13
+  - pytest>=5.0.1
+  - pytest-xdist>=1.21
+  - hypothesis>=3.58.0
+
+  # pandas dependencies
+  - numpy
+  - python-dateutil
+  - nomkl
+  - pytz
+  - pip
+  - tabulate==0.8.3
diff --git a/ci/incremental/build.cmd b/ci/incremental/build.cmd
deleted file mode 100644
index b61b59e287299..0000000000000
--- a/ci/incremental/build.cmd
+++ /dev/null
@@ -1,9 +0,0 @@
-@rem https://github.com/numba/numba/blob/master/buildscripts/incremental/build.cmd
-
-@rem Build extensions
-python setup.py build_ext -q -i
-
-@rem Install pandas
-python -m pip install --no-build-isolation -e .
-
-if %errorlevel% neq 0 exit /b %errorlevel%
diff --git a/ci/print_skipped.py b/ci/print_skipped.py
index 6bc1dcfcd320d..60e2f047235e6 100755
--- a/ci/print_skipped.py
+++ b/ci/print_skipped.py
@@ -1,52 +1,38 @@
-#!/usr/bin/env python
-
-import math
+#!/usr/bin/env python3
 import os
-import sys
 import xml.etree.ElementTree as et
 
 
-def parse_results(filename):
+def main(filename):
+    if not os.path.isfile(filename):
+        raise RuntimeError(f"Could not find junit file {repr(filename)}")
+
     tree = et.parse(filename)
     root = tree.getroot()
-    skipped = []
-
     current_class = ""
-    i = 1
-    assert i - 1 == len(skipped)
-    for el in root.findall("testcase"):
+    for el in root.iter("testcase"):
         cn = el.attrib["classname"]
         for sk in el.findall("skipped"):
             old_class = current_class
             current_class = cn
-            name = "{classname}.{name}".format(
-                classname=current_class, name=el.attrib["name"]
-            )
-            msg = sk.attrib["message"]
-            out = ""
             if old_class != current_class:
-                ndigits = int(math.log(i, 10) + 1)
-
-                # 4 for : + space + # + space
-                out += "-" * (len(name + msg) + 4 + ndigits) + "\n"
-            out += "#{i} {name}: {msg}".format(i=i, name=name, msg=msg)
-            skipped.append(out)
-            i += 1
-            assert i - 1 == len(skipped)
-    assert i - 1 == len(skipped)
-    # assert len(skipped) == int(root.attrib['skip'])
-    return "\n".join(skipped)
-
-
-def main():
-    test_files = ["test-data-single.xml", "test-data-multiple.xml", "test-data.xml"]
-
-    print("SKIPPED TESTS:")
-    for fn in test_files:
-        if os.path.isfile(fn):
-            print(parse_results(fn))
-    return 0
+                yield None
+            yield {
+                "class_name": current_class,
+                "test_name": el.attrib["name"],
+                "message": sk.attrib["message"],
+            }
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    print("SKIPPED TESTS:")
+    i = 1
+    for test_data in main("test-data.xml"):
+        if test_data is None:
+            print("-" * 80)
+        else:
+            print(
+                f"#{i} {test_data['class_name']}."
+                f"{test_data['test_name']}: {test_data['message']}"
+            )
+            i += 1
diff --git a/ci/run_tests.sh b/ci/run_tests.sh
index 27d3fcb4cf563..0cb1f4aabf352 100755
--- a/ci/run_tests.sh
+++ b/ci/run_tests.sh
@@ -1,59 +1,32 @@
-#!/bin/bash
+#!/bin/bash -e
 
-set -e
-
-if [ "$DOC" ]; then
-    echo "We are not running pytest as this is a doc-build"
-    exit 0
-fi
-
-# Workaround for pytest-xdist flaky collection order
+# Workaround for pytest-xdist (it collects different tests in the workers if PYTHONHASHSEED is not set)
 # https://github.com/pytest-dev/pytest/issues/920
 # https://github.com/pytest-dev/pytest/issues/1075
 export PYTHONHASHSEED=$(python -c 'import random; print(random.randint(1, 4294967295))')
 
-if [ -n "$LOCALE_OVERRIDE" ]; then
-    export LC_ALL="$LOCALE_OVERRIDE"
-    export LANG="$LOCALE_OVERRIDE"
-    PANDAS_LOCALE=`python -c 'import pandas; pandas.get_option("display.encoding")'`
-    if [[ "$LOCALE_OVERIDE" != "$PANDAS_LOCALE" ]]; then
-        echo "pandas could not detect the locale. System locale: $LOCALE_OVERRIDE, pandas detected: $PANDAS_LOCALE"
-        # TODO Not really aborting the tests until https://github.com/pandas-dev/pandas/issues/23923 is fixed
-        # exit 1
-    fi
-fi
 if [[ "not network" == *"$PATTERN"* ]]; then
     export http_proxy=http://1.2.3.4 https_proxy=http://1.2.3.4;
 fi
 
-
-if [ -n "$PATTERN" ]; then
-    PATTERN=" and $PATTERN"
+if [ "$COVERAGE" ]; then
+    COVERAGE_FNAME="/tmp/test_coverage.xml"
+    COVERAGE="-s --cov=pandas --cov-report=xml:$COVERAGE_FNAME"
 fi
 
-for TYPE in single multiple
-do
-    if [ "$COVERAGE" ]; then
-        COVERAGE_FNAME="/tmp/coc-$TYPE.xml"
-        COVERAGE="-s --cov=pandas --cov-report=xml:$COVERAGE_FNAME"
-    fi
+# If no X server is found, we use xvfb to emulate it
+if [[ $(uname) == "Linux" && -z $DISPLAY ]]; then
+    export DISPLAY=":0"
+    XVFB="xvfb-run "
+fi
 
-    TYPE_PATTERN=$TYPE
-    NUM_JOBS=1
-    if [[ "$TYPE_PATTERN" == "multiple" ]]; then
-        TYPE_PATTERN="not single"
-        NUM_JOBS=2
-    fi
+PYTEST_CMD="${XVFB}pytest -m \"$PATTERN\" -n auto --dist=loadfile -s --strict --durations=10 --junitxml=test-data.xml $TEST_ARGS $COVERAGE pandas"
 
-    PYTEST_CMD="pytest -m \"$TYPE_PATTERN$PATTERN\" -n $NUM_JOBS -s --strict --durations=10 --junitxml=test-data-$TYPE.xml $TEST_ARGS $COVERAGE pandas"
-    echo $PYTEST_CMD
-    # if no tests are found (the case of "single and slow"), pytest exits with code 5, and would make the script fail, if not for the below code
-    sh -c "$PYTEST_CMD; ret=\$?; [ \$ret = 5 ] && exit 0 || exit \$ret"
+echo $PYTEST_CMD
+sh -c "$PYTEST_CMD"
 
-    # 2019-08-21 disabling because this is hitting HTTP 400 errors GH#27602
-    # if [[ "$COVERAGE" && $? == 0 && "$TRAVIS_BRANCH" == "master" ]]; then
-    #    echo "uploading coverage for $TYPE tests"
-    #    echo "bash <(curl -s https://codecov.io/bash) -Z -c -F $TYPE -f $COVERAGE_FNAME"
-    #          bash <(curl -s https://codecov.io/bash) -Z -c -F $TYPE -f $COVERAGE_FNAME
-    # fi
-done
+if [[ "$COVERAGE" && $? == 0 && "$TRAVIS_BRANCH" == "master" ]]; then
+    echo "uploading coverage"
+    echo "bash <(curl -s https://codecov.io/bash) -Z -c -f $COVERAGE_FNAME"
+          bash <(curl -s https://codecov.io/bash) -Z -c -f $COVERAGE_FNAME
+fi
diff --git a/ci/setup_env.sh b/ci/setup_env.sh
index 382491a947488..e5bee09fe2f79 100755
--- a/ci/setup_env.sh
+++ b/ci/setup_env.sh
@@ -1,16 +1,15 @@
 #!/bin/bash -e
 
-
 # edit the locale file if needed
-if [ -n "$LOCALE_OVERRIDE" ]; then
+if [[ "$(uname)" == "Linux" && -n "$LC_ALL" ]]; then
     echo "Adding locale to the first line of pandas/__init__.py"
     rm -f pandas/__init__.pyc
-    SEDC="3iimport locale\nlocale.setlocale(locale.LC_ALL, '$LOCALE_OVERRIDE')\n"
+    SEDC="3iimport locale\nlocale.setlocale(locale.LC_ALL, '$LC_ALL')\n"
     sed -i "$SEDC" pandas/__init__.py
+
     echo "[head -4 pandas/__init__.py]"
     head -4 pandas/__init__.py
     echo
-    sudo locale-gen "$LOCALE_OVERRIDE"
 fi
 
 MINICONDA_DIR="$HOME/miniconda3"
@@ -51,6 +50,7 @@ echo
 echo "update conda"
 conda config --set ssl_verify false
 conda config --set quiet true --set always_yes true --set changeps1 false
+conda install pip  # create conda to create a historical artifact for pip & setuptools
 conda update -n base conda
 
 echo "conda info -a"
@@ -109,6 +109,16 @@ echo "w/o removing anything else"
 conda remove pandas -y --force || true
 pip uninstall -y pandas || true
 
+echo
+echo "remove postgres if has been installed with conda"
+echo "we use the one from the CI"
+conda remove postgresql -y --force || true
+
+echo
+echo "remove qt"
+echo "causes problems with the clipboard, we use xsel for that"
+conda remove qt -y --force || true
+
 echo
 echo "conda list pandas"
 conda list pandas
@@ -116,10 +126,10 @@ conda list pandas
 # Make sure any error below is reported as such
 
 echo "[Build extensions]"
-python setup.py build_ext -q -i
+python setup.py build_ext -q -i -j2
 
-# XXX: Some of our environments end up with old verisons of pip (10.x)
-# Adding a new enough verison of pip to the requirements explodes the
+# XXX: Some of our environments end up with old versions of pip (10.x)
+# Adding a new enough version of pip to the requirements explodes the
 # solve time. Just using pip to update itself.
 # - py35_macos
 # - py35_compat
@@ -135,7 +145,8 @@ echo "conda list"
 conda list
 
 # Install DB for Linux
-if [ "${TRAVIS_OS_NAME}" == "linux" ]; then
+
+if [[ -n ${SQL:0} ]]; then
   echo "installing dbs"
   mysql -e 'create database pandas_nosetest;'
   psql -c 'create database pandas_nosetest;' -U postgres
diff --git a/conda.recipe/meta.yaml b/conda.recipe/meta.yaml
index f92090fecccf3..47f63c11d0567 100644
--- a/conda.recipe/meta.yaml
+++ b/conda.recipe/meta.yaml
@@ -36,5 +36,5 @@ test:
 
 
 about:
-  home: http://pandas.pydata.org
+  home: https://pandas.pydata.org
   license: BSD
diff --git a/doc/.gitignore b/doc/.gitignore
new file mode 100644
index 0000000000000..e23892d6100e8
--- /dev/null
+++ b/doc/.gitignore
@@ -0,0 +1,4 @@
+data/
+timeseries.csv
+timeseries.parquet
+timeseries_wide.parquet
diff --git a/doc/cheatsheet/README.txt b/doc/cheatsheet/README.txt
index 0eae39f318d23..c57da38b31777 100644
--- a/doc/cheatsheet/README.txt
+++ b/doc/cheatsheet/README.txt
@@ -5,4 +5,4 @@ and pick "PDF" as the format.
 This cheat sheet was inspired by the RStudio Data Wrangling Cheatsheet[1], written by Irv Lustig, Princeton Consultants[2].
 
 [1]: https://www.rstudio.com/wp-content/uploads/2015/02/data-wrangling-cheatsheet.pdf
-[2]: http://www.princetonoptimization.com/
+[2]: https://www.princetonoptimization.com/
diff --git a/doc/logo/pandas_logo.png b/doc/logo/pandas_logo.png
deleted file mode 100644
index 065ee4e4856a6..0000000000000
Binary files a/doc/logo/pandas_logo.png and /dev/null differ
diff --git a/doc/logo/pandas_logo.py b/doc/logo/pandas_logo.py
deleted file mode 100644
index 89410e3847bef..0000000000000
--- a/doc/logo/pandas_logo.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# script to generate the pandas logo
-
-from matplotlib import pyplot as plt, rcParams
-import numpy as np
-
-rcParams["mathtext.fontset"] = "cm"
-
-
-def fnx():
-    return np.random.randint(5, 50, 10)
-
-
-fig = plt.figure(figsize=(6, 1.25))
-
-ax = fig.add_axes((0.45, 0.1, 0.16, 0.8))
-bar_data = [2.1, -00.8, 1.1, 2.5, -2.1, -0.5, -2.0, 1.5]
-ax.set_ylim(-3, 3)
-ax.set_xticks([])
-ax.set_yticks([])
-ax.bar(np.arange(len(bar_data)), bar_data)
-
-ax = fig.add_axes((0.63, 0.1, 0.16, 0.8))
-for i in range(4):
-    ax.plot(np.random.rand(8))
-ax.set_xticks([])
-ax.set_yticks([])
-
-ax = fig.add_axes((0.63 + 0.18, 0.1, 0.16, 0.8))
-y = np.row_stack((fnx(), fnx(), fnx()))
-x = np.arange(10)
-y1, y2, y3 = fnx(), fnx(), fnx()
-ax.stackplot(x, y1, y2, y3)
-ax.set_xticks([])
-ax.set_yticks([])
-
-plt.figtext(0.05, 0.5, "pandas", size=40)
-
-plt.figtext(
-    0.05,
-    0.2,
-    r"$y_{it} = \beta^{\prime} x_{it} + \mu_{i} + \epsilon_{it}$",
-    size=16,
-    color="#5a89a4",
-)
-
-fig.savefig("pandas_logo.svg")
-fig.savefig("pandas_logo.png")
diff --git a/doc/logo/pandas_logo.svg b/doc/logo/pandas_logo.svg
deleted file mode 100644
index b165f9635bf51..0000000000000
--- a/doc/logo/pandas_logo.svg
+++ /dev/null
@@ -1,879 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
-  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<!-- Created with matplotlib (http://matplotlib.org/) -->
-<svg height="90pt" version="1.1" viewBox="0 0 432 90" width="432pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
- <defs>
-  <style type="text/css">
-*{stroke-linecap:butt;stroke-linejoin:round;}
-  </style>
- </defs>
- <g id="figure_1">
-  <g id="patch_1">
-   <path d="M 0 90 
-L 432 90 
-L 432 0 
-L 0 0 
-z
-" style="fill:#ffffff;"/>
-  </g>
-  <g id="axes_1">
-   <g id="patch_2">
-    <path d="M 194.4 81 
-L 263.52 81 
-L 263.52 9 
-L 194.4 9 
-z
-" style="fill:#ffffff;"/>
-   </g>
-   <g id="patch_3">
-    <path clip-path="url(#p65e1c8b035)" d="M 197.541818 45 
-L 203.986573 45 
-L 203.986573 19.8 
-L 197.541818 19.8 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_4">
-    <path clip-path="url(#p65e1c8b035)" d="M 205.597762 54.6 
-L 212.042517 54.6 
-L 212.042517 45 
-L 205.597762 45 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_5">
-    <path clip-path="url(#p65e1c8b035)" d="M 213.653706 45 
-L 220.098462 45 
-L 220.098462 31.8 
-L 213.653706 31.8 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_6">
-    <path clip-path="url(#p65e1c8b035)" d="M 221.70965 45 
-L 228.154406 45 
-L 228.154406 15 
-L 221.70965 15 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_7">
-    <path clip-path="url(#p65e1c8b035)" d="M 229.765594 70.2 
-L 236.21035 70.2 
-L 236.21035 45 
-L 229.765594 45 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_8">
-    <path clip-path="url(#p65e1c8b035)" d="M 237.821538 51 
-L 244.266294 51 
-L 244.266294 45 
-L 237.821538 45 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_9">
-    <path clip-path="url(#p65e1c8b035)" d="M 245.877483 69 
-L 252.322238 69 
-L 252.322238 45 
-L 245.877483 45 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_10">
-    <path clip-path="url(#p65e1c8b035)" d="M 253.933427 45 
-L 260.378182 45 
-L 260.378182 27 
-L 253.933427 27 
-z
-" style="fill:#1f77b4;"/>
-   </g>
-   <g id="patch_11">
-    <path d="M 194.4 81 
-L 194.4 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_12">
-    <path d="M 263.52 81 
-L 263.52 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_13">
-    <path d="M 194.4 81 
-L 263.52 81 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_14">
-    <path d="M 194.4 9 
-L 263.52 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="matplotlib.axis_1"/>
-   <g id="matplotlib.axis_2"/>
-  </g>
-  <g id="axes_2">
-   <g id="patch_15">
-    <path d="M 272.16 81 
-L 341.28 81 
-L 341.28 9 
-L 272.16 9 
-z
-" style="fill:#ffffff;"/>
-   </g>
-   <g id="line2d_1">
-    <path clip-path="url(#p4dc94feb3b)" d="M 275.301818 28.25879 
-L 284.278442 12.272727 
-L 293.255065 77.727273 
-L 302.231688 74.001976 
-L 311.208312 75.463299 
-L 320.184935 22.132305 
-L 329.161558 55.957655 
-L 338.138182 61.29857 
-" style="fill:none;stroke:#1f77b4;stroke-linecap:square;stroke-width:1.5;"/>
-   </g>
-   <g id="line2d_2">
-    <path clip-path="url(#p4dc94feb3b)" d="M 275.301818 61.597884 
-L 284.278442 64.880819 
-L 293.255065 72.804377 
-L 302.231688 45.091884 
-L 311.208312 52.559951 
-L 320.184935 68.827589 
-L 329.161558 20.701624 
-L 338.138182 33.377345 
-" style="fill:none;stroke:#ff7f0e;stroke-linecap:square;stroke-width:1.5;"/>
-   </g>
-   <g id="line2d_3">
-    <path clip-path="url(#p4dc94feb3b)" d="M 275.301818 61.030555 
-L 284.278442 53.336965 
-L 293.255065 70.575237 
-L 302.231688 25.312123 
-L 311.208312 59.636378 
-L 320.184935 15.516067 
-L 329.161558 18.278268 
-L 338.138182 15.705298 
-" style="fill:none;stroke:#2ca02c;stroke-linecap:square;stroke-width:1.5;"/>
-   </g>
-   <g id="line2d_4">
-    <path clip-path="url(#p4dc94feb3b)" d="M 275.301818 24.671958 
-L 284.278442 24.751621 
-L 293.255065 54.365292 
-L 302.231688 22.746952 
-L 311.208312 43.129804 
-L 320.184935 56.792715 
-L 329.161558 36.348113 
-L 338.138182 22.434164 
-" style="fill:none;stroke:#d62728;stroke-linecap:square;stroke-width:1.5;"/>
-   </g>
-   <g id="patch_16">
-    <path d="M 272.16 81 
-L 272.16 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_17">
-    <path d="M 341.28 81 
-L 341.28 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_18">
-    <path d="M 272.16 81 
-L 341.28 81 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_19">
-    <path d="M 272.16 9 
-L 341.28 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="matplotlib.axis_3"/>
-   <g id="matplotlib.axis_4"/>
-  </g>
-  <g id="axes_3">
-   <g id="patch_20">
-    <path d="M 349.92 81 
-L 419.04 81 
-L 419.04 9 
-L 349.92 9 
-z
-" style="fill:#ffffff;"/>
-   </g>
-   <g id="PolyCollection_1">
-    <defs>
-     <path d="M 353.061818 -31.491429 
-L 353.061818 -9 
-L 360.043636 -9 
-L 367.025455 -9 
-L 374.007273 -9 
-L 380.989091 -9 
-L 387.970909 -9 
-L 394.952727 -9 
-L 401.934545 -9 
-L 408.916364 -9 
-L 415.898182 -9 
-L 415.898182 -22.165714 
-L 415.898182 -22.165714 
-L 408.916364 -29.297143 
-L 401.934545 -15.034286 
-L 394.952727 -25.457143 
-L 387.970909 -19.422857 
-L 380.989091 -29.297143 
-L 374.007273 -24.908571 
-L 367.025455 -35.88 
-L 360.043636 -17.777143 
-L 353.061818 -31.491429 
-z
-" id="m81de97919c"/>
-    </defs>
-    <g clip-path="url(#pfceed726e3)">
-     <use style="fill:#1f77b4;" x="0" xlink:href="#m81de97919c" y="90"/>
-    </g>
-   </g>
-   <g id="PolyCollection_2">
-    <defs>
-     <path d="M 353.061818 -56.725714 
-L 353.061818 -31.491429 
-L 360.043636 -17.777143 
-L 367.025455 -35.88 
-L 374.007273 -24.908571 
-L 380.989091 -29.297143 
-L 387.970909 -19.422857 
-L 394.952727 -25.457143 
-L 401.934545 -15.034286 
-L 408.916364 -29.297143 
-L 415.898182 -22.165714 
-L 415.898182 -41.365714 
-L 415.898182 -41.365714 
-L 408.916364 -44.657143 
-L 401.934545 -36.977143 
-L 394.952727 -32.04 
-L 387.970909 -32.588571 
-L 380.989091 -47.4 
-L 374.007273 -37.525714 
-L 367.025455 -41.365714 
-L 360.043636 -34.782857 
-L 353.061818 -56.725714 
-z
-" id="maaf380e772"/>
-    </defs>
-    <g clip-path="url(#pfceed726e3)">
-     <use style="fill:#ff7f0e;" x="0" xlink:href="#maaf380e772" y="90"/>
-    </g>
-   </g>
-   <g id="PolyCollection_3">
-    <defs>
-     <path d="M 353.061818 -77.571429 
-L 353.061818 -56.725714 
-L 360.043636 -34.782857 
-L 367.025455 -41.365714 
-L 374.007273 -37.525714 
-L 380.989091 -47.4 
-L 387.970909 -32.588571 
-L 394.952727 -32.04 
-L 401.934545 -36.977143 
-L 408.916364 -44.657143 
-L 415.898182 -41.365714 
-L 415.898182 -58.92 
-L 415.898182 -58.92 
-L 408.916364 -64.405714 
-L 401.934545 -49.594286 
-L 394.952727 -40.817143 
-L 387.970909 -39.171429 
-L 380.989091 -50.691429 
-L 374.007273 -49.594286 
-L 367.025455 -57.822857 
-L 360.043636 -56.177143 
-L 353.061818 -77.571429 
-z
-" id="m31c02dcfcb"/>
-    </defs>
-    <g clip-path="url(#pfceed726e3)">
-     <use style="fill:#2ca02c;" x="0" xlink:href="#m31c02dcfcb" y="90"/>
-    </g>
-   </g>
-   <g id="patch_21">
-    <path d="M 349.92 81 
-L 349.92 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_22">
-    <path d="M 419.04 81 
-L 419.04 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_23">
-    <path d="M 349.92 81 
-L 419.04 81 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="patch_24">
-    <path d="M 349.92 9 
-L 419.04 9 
-" style="fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;"/>
-   </g>
-   <g id="matplotlib.axis_5"/>
-   <g id="matplotlib.axis_6"/>
-  </g>
-  <g id="text_1">
-   <!-- pandas -->
-   <defs>
-    <path d="M 18.109375 8.203125 
-L 18.109375 -20.796875 
-L 9.078125 -20.796875 
-L 9.078125 54.6875 
-L 18.109375 54.6875 
-L 18.109375 46.390625 
-Q 20.953125 51.265625 25.265625 53.625 
-Q 29.59375 56 35.59375 56 
-Q 45.5625 56 51.78125 48.09375 
-Q 58.015625 40.1875 58.015625 27.296875 
-Q 58.015625 14.40625 51.78125 6.484375 
-Q 45.5625 -1.421875 35.59375 -1.421875 
-Q 29.59375 -1.421875 25.265625 0.953125 
-Q 20.953125 3.328125 18.109375 8.203125 
-M 48.6875 27.296875 
-Q 48.6875 37.203125 44.609375 42.84375 
-Q 40.53125 48.484375 33.40625 48.484375 
-Q 26.265625 48.484375 22.1875 42.84375 
-Q 18.109375 37.203125 18.109375 27.296875 
-Q 18.109375 17.390625 22.1875 11.75 
-Q 26.265625 6.109375 33.40625 6.109375 
-Q 40.53125 6.109375 44.609375 11.75 
-Q 48.6875 17.390625 48.6875 27.296875 
-" id="DejaVuSans-70"/>
-    <path d="M 34.28125 27.484375 
-Q 23.390625 27.484375 19.1875 25 
-Q 14.984375 22.515625 14.984375 16.5 
-Q 14.984375 11.71875 18.140625 8.90625 
-Q 21.296875 6.109375 26.703125 6.109375 
-Q 34.1875 6.109375 38.703125 11.40625 
-Q 43.21875 16.703125 43.21875 25.484375 
-L 43.21875 27.484375 
-z
-M 52.203125 31.203125 
-L 52.203125 0 
-L 43.21875 0 
-L 43.21875 8.296875 
-Q 40.140625 3.328125 35.546875 0.953125 
-Q 30.953125 -1.421875 24.3125 -1.421875 
-Q 15.921875 -1.421875 10.953125 3.296875 
-Q 6 8.015625 6 15.921875 
-Q 6 25.140625 12.171875 29.828125 
-Q 18.359375 34.515625 30.609375 34.515625 
-L 43.21875 34.515625 
-L 43.21875 35.40625 
-Q 43.21875 41.609375 39.140625 45 
-Q 35.0625 48.390625 27.6875 48.390625 
-Q 23 48.390625 18.546875 47.265625 
-Q 14.109375 46.140625 10.015625 43.890625 
-L 10.015625 52.203125 
-Q 14.9375 54.109375 19.578125 55.046875 
-Q 24.21875 56 28.609375 56 
-Q 40.484375 56 46.34375 49.84375 
-Q 52.203125 43.703125 52.203125 31.203125 
-" id="DejaVuSans-61"/>
-    <path d="M 54.890625 33.015625 
-L 54.890625 0 
-L 45.90625 0 
-L 45.90625 32.71875 
-Q 45.90625 40.484375 42.875 44.328125 
-Q 39.84375 48.1875 33.796875 48.1875 
-Q 26.515625 48.1875 22.3125 43.546875 
-Q 18.109375 38.921875 18.109375 30.90625 
-L 18.109375 0 
-L 9.078125 0 
-L 9.078125 54.6875 
-L 18.109375 54.6875 
-L 18.109375 46.1875 
-Q 21.34375 51.125 25.703125 53.5625 
-Q 30.078125 56 35.796875 56 
-Q 45.21875 56 50.046875 50.171875 
-Q 54.890625 44.34375 54.890625 33.015625 
-" id="DejaVuSans-6e"/>
-    <path d="M 45.40625 46.390625 
-L 45.40625 75.984375 
-L 54.390625 75.984375 
-L 54.390625 0 
-L 45.40625 0 
-L 45.40625 8.203125 
-Q 42.578125 3.328125 38.25 0.953125 
-Q 33.9375 -1.421875 27.875 -1.421875 
-Q 17.96875 -1.421875 11.734375 6.484375 
-Q 5.515625 14.40625 5.515625 27.296875 
-Q 5.515625 40.1875 11.734375 48.09375 
-Q 17.96875 56 27.875 56 
-Q 33.9375 56 38.25 53.625 
-Q 42.578125 51.265625 45.40625 46.390625 
-M 14.796875 27.296875 
-Q 14.796875 17.390625 18.875 11.75 
-Q 22.953125 6.109375 30.078125 6.109375 
-Q 37.203125 6.109375 41.296875 11.75 
-Q 45.40625 17.390625 45.40625 27.296875 
-Q 45.40625 37.203125 41.296875 42.84375 
-Q 37.203125 48.484375 30.078125 48.484375 
-Q 22.953125 48.484375 18.875 42.84375 
-Q 14.796875 37.203125 14.796875 27.296875 
-" id="DejaVuSans-64"/>
-    <path d="M 44.28125 53.078125 
-L 44.28125 44.578125 
-Q 40.484375 46.53125 36.375 47.5 
-Q 32.28125 48.484375 27.875 48.484375 
-Q 21.1875 48.484375 17.84375 46.4375 
-Q 14.5 44.390625 14.5 40.28125 
-Q 14.5 37.15625 16.890625 35.375 
-Q 19.28125 33.59375 26.515625 31.984375 
-L 29.59375 31.296875 
-Q 39.15625 29.25 43.1875 25.515625 
-Q 47.21875 21.78125 47.21875 15.09375 
-Q 47.21875 7.46875 41.1875 3.015625 
-Q 35.15625 -1.421875 24.609375 -1.421875 
-Q 20.21875 -1.421875 15.453125 -0.5625 
-Q 10.6875 0.296875 5.421875 2 
-L 5.421875 11.28125 
-Q 10.40625 8.6875 15.234375 7.390625 
-Q 20.0625 6.109375 24.8125 6.109375 
-Q 31.15625 6.109375 34.5625 8.28125 
-Q 37.984375 10.453125 37.984375 14.40625 
-Q 37.984375 18.0625 35.515625 20.015625 
-Q 33.0625 21.96875 24.703125 23.78125 
-L 21.578125 24.515625 
-Q 13.234375 26.265625 9.515625 29.90625 
-Q 5.8125 33.546875 5.8125 39.890625 
-Q 5.8125 47.609375 11.28125 51.796875 
-Q 16.75 56 26.8125 56 
-Q 31.78125 56 36.171875 55.265625 
-Q 40.578125 54.546875 44.28125 53.078125 
-" id="DejaVuSans-73"/>
-   </defs>
-   <g transform="translate(21.6 45)scale(0.4 -0.4)">
-    <use xlink:href="#DejaVuSans-70"/>
-    <use x="63.476562" xlink:href="#DejaVuSans-61"/>
-    <use x="124.755859" xlink:href="#DejaVuSans-6e"/>
-    <use x="188.134766" xlink:href="#DejaVuSans-64"/>
-    <use x="251.611328" xlink:href="#DejaVuSans-61"/>
-    <use x="312.890625" xlink:href="#DejaVuSans-73"/>
-   </g>
-  </g>
-  <g id="text_2">
-   <!-- $y_{it} = \beta^{\prime} x_{it} + \mu_{i} + \epsilon_{it}$ -->
-   <defs>
-    <path d="M 8.40625 -14.3125 
-Q 10.5 -17.921875 15.71875 -17.921875 
-Q 20.453125 -17.921875 23.921875 -14.59375 
-Q 27.390625 -11.28125 29.515625 -6.5625 
-Q 31.640625 -1.859375 32.8125 3.078125 
-Q 28.375 -1.125 23.1875 -1.125 
-Q 19.234375 -1.125 16.453125 0.234375 
-Q 13.671875 1.609375 12.125 4.3125 
-Q 10.59375 7.03125 10.59375 10.890625 
-Q 10.59375 14.15625 11.46875 17.59375 
-Q 12.359375 21.046875 13.9375 25.265625 
-Q 15.53125 29.5 16.703125 32.625 
-Q 18.015625 36.28125 18.015625 38.625 
-Q 18.015625 41.609375 15.828125 41.609375 
-Q 11.859375 41.609375 9.296875 37.53125 
-Q 6.734375 33.453125 5.515625 28.421875 
-Q 5.328125 27.78125 4.6875 27.78125 
-L 3.515625 27.78125 
-Q 2.6875 27.78125 2.6875 28.71875 
-L 2.6875 29 
-Q 4.296875 34.96875 7.609375 39.578125 
-Q 10.9375 44.1875 16.015625 44.1875 
-Q 19.578125 44.1875 22.046875 41.84375 
-Q 24.515625 39.5 24.515625 35.890625 
-Q 24.515625 34.03125 23.6875 31.984375 
-Q 23.25 30.765625 21.6875 26.65625 
-Q 20.125 22.5625 19.28125 19.875 
-Q 18.453125 17.1875 17.921875 14.59375 
-Q 17.390625 12.015625 17.390625 9.421875 
-Q 17.390625 6.109375 18.796875 3.8125 
-Q 20.21875 1.515625 23.296875 1.515625 
-Q 29.5 1.515625 34.421875 9.078125 
-L 42 39.890625 
-Q 42.328125 41.21875 43.546875 42.15625 
-Q 44.78125 43.109375 46.1875 43.109375 
-Q 47.40625 43.109375 48.3125 42.328125 
-Q 49.21875 41.546875 49.21875 40.28125 
-Q 49.21875 39.703125 49.125 39.5 
-L 39.203125 -0.296875 
-Q 37.890625 -5.421875 34.375 -10.109375 
-Q 30.859375 -14.796875 25.90625 -17.65625 
-Q 20.953125 -20.515625 15.578125 -20.515625 
-Q 12.984375 -20.515625 10.4375 -19.5 
-Q 7.90625 -18.5 6.34375 -16.5 
-Q 4.78125 -14.5 4.78125 -11.8125 
-Q 4.78125 -9.078125 6.390625 -7.078125 
-Q 8.015625 -5.078125 10.6875 -5.078125 
-Q 12.3125 -5.078125 13.40625 -6.078125 
-Q 14.5 -7.078125 14.5 -8.6875 
-Q 14.5 -10.984375 12.78125 -12.6875 
-Q 11.078125 -14.40625 8.796875 -14.40625 
-Q 8.6875 -14.359375 8.59375 -14.328125 
-Q 8.5 -14.3125 8.40625 -14.3125 
-" id="Cmmi10-79"/>
-    <path d="M 7.8125 7.171875 
-Q 7.8125 9.03125 8.59375 11.078125 
-L 16.703125 32.625 
-Q 18.015625 36.28125 18.015625 38.625 
-Q 18.015625 41.609375 15.828125 41.609375 
-Q 11.859375 41.609375 9.296875 37.53125 
-Q 6.734375 33.453125 5.515625 28.421875 
-Q 5.328125 27.78125 4.6875 27.78125 
-L 3.515625 27.78125 
-Q 2.6875 27.78125 2.6875 28.71875 
-L 2.6875 29 
-Q 4.296875 34.96875 7.609375 39.578125 
-Q 10.9375 44.1875 16.015625 44.1875 
-Q 19.578125 44.1875 22.046875 41.84375 
-Q 24.515625 39.5 24.515625 35.890625 
-Q 24.515625 34.03125 23.6875 31.984375 
-L 15.578125 10.5 
-Q 14.203125 7.171875 14.203125 4.5 
-Q 14.203125 1.515625 16.5 1.515625 
-Q 20.40625 1.515625 23.015625 5.6875 
-Q 25.640625 9.859375 26.703125 14.703125 
-Q 26.90625 15.28125 27.484375 15.28125 
-L 28.71875 15.28125 
-Q 29.109375 15.28125 29.34375 15.015625 
-Q 29.59375 14.75 29.59375 14.40625 
-Q 29.59375 14.3125 29.5 14.109375 
-Q 28.125 8.453125 24.734375 3.65625 
-Q 21.34375 -1.125 16.3125 -1.125 
-Q 12.796875 -1.125 10.296875 1.296875 
-Q 7.8125 3.71875 7.8125 7.171875 
-M 19.09375 60.59375 
-Q 19.09375 62.703125 20.84375 64.40625 
-Q 22.609375 66.109375 24.703125 66.109375 
-Q 26.421875 66.109375 27.515625 65.0625 
-Q 28.609375 64.015625 28.609375 62.40625 
-Q 28.609375 60.15625 26.828125 58.46875 
-Q 25.046875 56.78125 22.90625 56.78125 
-Q 21.296875 56.78125 20.1875 57.875 
-Q 19.09375 58.984375 19.09375 60.59375 
-" id="Cmmi10-69"/>
-    <path d="M 6.203125 8.109375 
-Q 6.203125 9.578125 6.5 10.890625 
-L 13.71875 39.59375 
-L 3.21875 39.59375 
-Q 2.203125 39.59375 2.203125 40.921875 
-Q 2.59375 43.109375 3.515625 43.109375 
-L 14.59375 43.109375 
-L 18.609375 59.421875 
-Q 19 60.75 20.171875 61.671875 
-Q 21.34375 62.59375 22.796875 62.59375 
-Q 24.078125 62.59375 24.921875 61.828125 
-Q 25.78125 61.078125 25.78125 59.8125 
-Q 25.78125 59.515625 25.75 59.34375 
-Q 25.734375 59.1875 25.6875 58.984375 
-L 21.6875 43.109375 
-L 31.984375 43.109375 
-Q 33.015625 43.109375 33.015625 41.796875 
-Q 32.953125 41.546875 32.8125 40.953125 
-Q 32.671875 40.375 32.421875 39.984375 
-Q 32.171875 39.59375 31.6875 39.59375 
-L 20.796875 39.59375 
-L 13.625 10.6875 
-Q 12.890625 7.859375 12.890625 5.8125 
-Q 12.890625 1.515625 15.828125 1.515625 
-Q 20.21875 1.515625 23.609375 5.640625 
-Q 27 9.765625 28.8125 14.703125 
-Q 29.203125 15.28125 29.59375 15.28125 
-L 30.8125 15.28125 
-Q 31.203125 15.28125 31.4375 15.015625 
-Q 31.6875 14.75 31.6875 14.40625 
-Q 31.6875 14.203125 31.59375 14.109375 
-Q 29.390625 8.0625 25.1875 3.46875 
-Q 21 -1.125 15.578125 -1.125 
-Q 11.625 -1.125 8.90625 1.453125 
-Q 6.203125 4.046875 6.203125 8.109375 
-" id="Cmmi10-74"/>
-    <path d="M 7.515625 13.28125 
-Q 6.6875 13.28125 6.140625 13.90625 
-Q 5.609375 14.546875 5.609375 15.28125 
-Q 5.609375 16.109375 6.140625 16.6875 
-Q 6.6875 17.28125 7.515625 17.28125 
-L 70.3125 17.28125 
-Q 71.046875 17.28125 71.578125 16.6875 
-Q 72.125 16.109375 72.125 15.28125 
-Q 72.125 14.546875 71.578125 13.90625 
-Q 71.046875 13.28125 70.3125 13.28125 
-z
-M 7.515625 32.71875 
-Q 6.6875 32.71875 6.140625 33.296875 
-Q 5.609375 33.890625 5.609375 34.71875 
-Q 5.609375 35.453125 6.140625 36.078125 
-Q 6.6875 36.71875 7.515625 36.71875 
-L 70.3125 36.71875 
-Q 71.046875 36.71875 71.578125 36.078125 
-Q 72.125 35.453125 72.125 34.71875 
-Q 72.125 33.890625 71.578125 33.296875 
-Q 71.046875 32.71875 70.3125 32.71875 
-z
-" id="Cmr10-3d"/>
-    <path d="M 2.6875 -19.390625 
-Q 2.390625 -19.390625 2.140625 -19.046875 
-Q 1.90625 -18.703125 1.90625 -18.40625 
-L 17.28125 43.40625 
-Q 18.609375 48.390625 21.140625 53.078125 
-Q 23.6875 57.765625 27.515625 61.796875 
-Q 31.34375 65.828125 35.9375 68.171875 
-Q 40.53125 70.515625 45.703125 70.515625 
-Q 49.421875 70.515625 52.421875 68.875 
-Q 55.421875 67.234375 57.15625 64.28125 
-Q 58.890625 61.328125 58.890625 57.625 
-Q 58.890625 54.046875 57.515625 50.796875 
-Q 56.15625 47.5625 53.703125 44.75 
-Q 51.265625 41.9375 48.484375 40.1875 
-Q 50.09375 39.15625 51.359375 37.5625 
-Q 52.640625 35.984375 53.421875 34.25 
-Q 54.203125 32.515625 54.640625 30.390625 
-Q 55.078125 28.265625 55.078125 26.421875 
-Q 55.078125 21.296875 52.875 16.3125 
-Q 50.6875 11.328125 46.890625 7.265625 
-Q 43.109375 3.21875 38.21875 0.84375 
-Q 33.34375 -1.515625 28.21875 -1.515625 
-Q 22.609375 -1.515625 18.109375 1.5625 
-Q 13.625 4.640625 11.921875 9.90625 
-L 4.6875 -18.796875 
-Q 4.6875 -19.390625 3.90625 -19.390625 
-z
-M 28.421875 1.21875 
-Q 32.90625 1.21875 36.546875 4.171875 
-Q 40.1875 7.125 42.546875 11.59375 
-Q 44.921875 16.0625 46.15625 21.0625 
-Q 47.40625 26.078125 47.40625 30.171875 
-Q 47.40625 35.25 44.484375 38.1875 
-Q 41.0625 36.921875 37.796875 36.921875 
-Q 29.890625 36.921875 29.890625 39.59375 
-Q 29.890625 43.109375 38.921875 43.109375 
-Q 42.140625 43.109375 44.828125 42.09375 
-Q 46.96875 43.75 48.71875 46.96875 
-Q 50.484375 50.203125 51.390625 53.71875 
-Q 52.296875 57.234375 52.296875 60.296875 
-Q 52.296875 63.578125 50.5625 65.75 
-Q 48.828125 67.921875 45.515625 67.921875 
-Q 39.40625 67.921875 34.15625 64.15625 
-Q 28.90625 60.40625 25.296875 54.65625 
-Q 21.6875 48.921875 20.125 42.828125 
-L 14.59375 20.703125 
-Q 14.0625 18.40625 13.921875 15.578125 
-Q 13.921875 9.328125 18.015625 5.265625 
-Q 22.125 1.21875 28.421875 1.21875 
-M 32.90625 39.890625 
-Q 34.421875 39.5 37.890625 39.5 
-Q 39.59375 39.5 41.3125 40.09375 
-Q 41.21875 40.1875 40.921875 40.1875 
-Q 39.84375 40.484375 38.625 40.484375 
-Q 34.078125 40.484375 32.90625 39.890625 
-" id="Cmmi10-af"/>
-    <path d="M 3.515625 5.421875 
-Q 2.875 5.609375 2.875 6.390625 
-L 15.09375 51.8125 
-Q 15.671875 53.65625 17.078125 54.78125 
-Q 18.5 55.90625 20.3125 55.90625 
-Q 22.65625 55.90625 24.4375 54.359375 
-Q 26.21875 52.828125 26.21875 50.484375 
-Q 26.21875 49.46875 25.6875 48.1875 
-L 7.625 4.984375 
-Q 7.28125 4.296875 6.6875 4.296875 
-Q 6.15625 4.296875 5 4.78125 
-Q 3.859375 5.28125 3.515625 5.421875 
-" id="Cmsy10-30"/>
-    <path d="M 7.8125 2.875 
-Q 9.578125 1.515625 12.796875 1.515625 
-Q 15.921875 1.515625 18.3125 4.515625 
-Q 20.703125 7.515625 21.578125 11.078125 
-L 26.125 28.8125 
-Q 27.203125 33.640625 27.203125 35.40625 
-Q 27.203125 37.890625 25.8125 39.75 
-Q 24.421875 41.609375 21.921875 41.609375 
-Q 18.75 41.609375 15.96875 39.625 
-Q 13.1875 37.640625 11.28125 34.59375 
-Q 9.375 31.546875 8.59375 28.421875 
-Q 8.40625 27.78125 7.8125 27.78125 
-L 6.59375 27.78125 
-Q 5.8125 27.78125 5.8125 28.71875 
-L 5.8125 29 
-Q 6.78125 32.71875 9.125 36.25 
-Q 11.46875 39.796875 14.859375 41.984375 
-Q 18.265625 44.1875 22.125 44.1875 
-Q 25.78125 44.1875 28.734375 42.234375 
-Q 31.6875 40.28125 32.90625 36.921875 
-Q 34.625 39.984375 37.28125 42.078125 
-Q 39.9375 44.1875 43.109375 44.1875 
-Q 45.265625 44.1875 47.5 43.421875 
-Q 49.75 42.671875 51.171875 41.109375 
-Q 52.59375 39.546875 52.59375 37.203125 
-Q 52.59375 34.671875 50.953125 32.828125 
-Q 49.3125 31 46.78125 31 
-Q 45.171875 31 44.09375 32.03125 
-Q 43.015625 33.0625 43.015625 34.625 
-Q 43.015625 36.71875 44.453125 38.296875 
-Q 45.90625 39.890625 47.90625 40.1875 
-Q 46.09375 41.609375 42.921875 41.609375 
-Q 39.703125 41.609375 37.328125 38.625 
-Q 34.96875 35.640625 33.984375 31.984375 
-L 29.59375 14.3125 
-Q 28.515625 10.296875 28.515625 7.71875 
-Q 28.515625 5.171875 29.953125 3.34375 
-Q 31.390625 1.515625 33.796875 1.515625 
-Q 38.484375 1.515625 42.15625 5.640625 
-Q 45.84375 9.765625 47.015625 14.703125 
-Q 47.21875 15.28125 47.796875 15.28125 
-L 49.03125 15.28125 
-Q 49.421875 15.28125 49.65625 15.015625 
-Q 49.90625 14.75 49.90625 14.40625 
-Q 49.90625 14.3125 49.8125 14.109375 
-Q 48.390625 8.15625 43.84375 3.515625 
-Q 39.3125 -1.125 33.59375 -1.125 
-Q 29.9375 -1.125 26.984375 0.84375 
-Q 24.03125 2.828125 22.796875 6.203125 
-Q 21.234375 3.265625 18.46875 1.0625 
-Q 15.71875 -1.125 12.59375 -1.125 
-Q 10.453125 -1.125 8.171875 -0.359375 
-Q 5.90625 0.390625 4.484375 1.953125 
-Q 3.078125 3.515625 3.078125 5.90625 
-Q 3.078125 8.25 4.703125 10.171875 
-Q 6.34375 12.109375 8.796875 12.109375 
-Q 10.453125 12.109375 11.578125 11.109375 
-Q 12.703125 10.109375 12.703125 8.5 
-Q 12.703125 6.390625 11.296875 4.828125 
-Q 9.90625 3.265625 7.8125 2.875 
-" id="Cmmi10-78"/>
-    <path d="M 7.515625 23 
-Q 6.6875 23 6.140625 23.625 
-Q 5.609375 24.265625 5.609375 25 
-Q 5.609375 25.734375 6.140625 26.359375 
-Q 6.6875 27 7.515625 27 
-L 36.921875 27 
-L 36.921875 56.5 
-Q 36.921875 57.28125 37.5 57.78125 
-Q 38.09375 58.296875 38.921875 58.296875 
-Q 39.65625 58.296875 40.28125 57.78125 
-Q 40.921875 57.28125 40.921875 56.5 
-L 40.921875 27 
-L 70.3125 27 
-Q 71.046875 27 71.578125 26.359375 
-Q 72.125 25.734375 72.125 25 
-Q 72.125 24.265625 71.578125 23.625 
-Q 71.046875 23 70.3125 23 
-L 40.921875 23 
-L 40.921875 -6.5 
-Q 40.921875 -7.28125 40.28125 -7.78125 
-Q 39.65625 -8.296875 38.921875 -8.296875 
-Q 38.09375 -8.296875 37.5 -7.78125 
-Q 36.921875 -7.28125 36.921875 -6.5 
-L 36.921875 23 
-z
-" id="Cmr10-2b"/>
-    <path d="M 2.78125 -18.796875 
-Q 2.78125 -18.21875 2.875 -18.015625 
-L 17.578125 41.015625 
-Q 18.015625 42.4375 19.15625 43.3125 
-Q 20.3125 44.1875 21.78125 44.1875 
-Q 23.046875 44.1875 23.921875 43.421875 
-Q 24.8125 42.671875 24.8125 41.40625 
-Q 24.8125 41.109375 24.78125 40.9375 
-Q 24.75 40.765625 24.703125 40.578125 
-L 18.796875 17.1875 
-Q 17.828125 13.03125 17.828125 10.015625 
-Q 17.828125 6.296875 19.578125 3.90625 
-Q 21.34375 1.515625 24.90625 1.515625 
-Q 32.171875 1.515625 37.703125 10.59375 
-Q 37.75 10.6875 37.765625 10.734375 
-Q 37.796875 10.796875 37.796875 10.890625 
-L 45.015625 39.890625 
-Q 45.359375 41.21875 46.578125 42.15625 
-Q 47.796875 43.109375 49.21875 43.109375 
-Q 50.390625 43.109375 51.296875 42.328125 
-Q 52.203125 41.546875 52.203125 40.28125 
-Q 52.203125 39.703125 52.09375 39.5 
-L 44.921875 10.6875 
-Q 44.1875 7.859375 44.1875 5.8125 
-Q 44.1875 1.515625 47.125 1.515625 
-Q 50.25 1.515625 51.828125 5.375 
-Q 53.421875 9.234375 54.59375 14.703125 
-Q 54.78125 15.28125 55.421875 15.28125 
-L 56.59375 15.28125 
-Q 56.984375 15.28125 57.25 14.96875 
-Q 57.515625 14.65625 57.515625 14.3125 
-Q 55.765625 7.328125 53.6875 3.09375 
-Q 51.609375 -1.125 46.921875 -1.125 
-Q 43.609375 -1.125 41.046875 0.78125 
-Q 38.484375 2.6875 37.703125 5.90625 
-Q 35.203125 2.78125 31.859375 0.828125 
-Q 28.515625 -1.125 24.8125 -1.125 
-Q 18.5625 -1.125 14.984375 1.8125 
-L 9.90625 -18.40625 
-Q 9.625 -19.828125 8.453125 -20.703125 
-Q 7.28125 -21.578125 5.8125 -21.578125 
-Q 4.59375 -21.578125 3.6875 -20.8125 
-Q 2.78125 -20.0625 2.78125 -18.796875 
-" id="Cmmi10-b9"/>
-    <path d="M 12.3125 14.109375 
-Q 12.3125 10.75 13.53125 7.859375 
-Q 14.75 4.984375 17.203125 3.25 
-Q 19.671875 1.515625 23 1.515625 
-Q 25.25 1.515625 27.78125 2.484375 
-Q 30.328125 3.46875 32.5 4.640625 
-Q 34.671875 5.8125 34.71875 5.8125 
-Q 35.25 5.8125 35.5625 5.203125 
-Q 35.890625 4.59375 35.890625 4 
-Q 35.890625 3.46875 35.59375 3.328125 
-Q 29.34375 -1.125 22.90625 -1.125 
-Q 17.625 -1.125 13.375 1.34375 
-Q 9.125 3.8125 6.8125 8.203125 
-Q 4.5 12.59375 4.5 17.828125 
-Q 4.5 23 6.59375 27.65625 
-Q 8.6875 32.328125 12.390625 35.796875 
-Q 16.109375 39.265625 20.796875 41.1875 
-Q 25.484375 43.109375 30.609375 43.109375 
-L 36.28125 43.109375 
-Q 37.796875 43.109375 37.796875 41.609375 
-Q 37.796875 40.765625 37.234375 40.171875 
-Q 36.671875 39.59375 35.890625 39.59375 
-L 30.421875 39.59375 
-Q 26.421875 39.59375 23.171875 37.828125 
-Q 19.921875 36.078125 17.71875 32.953125 
-Q 15.53125 29.828125 14.3125 25.875 
-L 31.984375 25.875 
-Q 32.671875 25.875 33.078125 25.453125 
-Q 33.5 25.046875 33.5 24.421875 
-Q 33.5 23.578125 32.953125 22.984375 
-Q 32.421875 22.40625 31.59375 22.40625 
-L 13.375 22.40625 
-Q 12.3125 17.234375 12.3125 14.109375 
-" id="Cmmi10-b2"/>
-   </defs>
-   <g style="fill:#5a89a4;" transform="translate(21.6 72)scale(0.16 -0.16)">
-    <use transform="translate(0 0.601562)" xlink:href="#Cmmi10-79"/>
-    <use transform="translate(49.023438 -16.404687)scale(0.7)" xlink:href="#Cmmi10-69"/>
-    <use transform="translate(73.120117 -16.404687)scale(0.7)" xlink:href="#Cmmi10-74"/>
-    <use transform="translate(122.314844 0.601562)" xlink:href="#Cmr10-3d"/>
-    <use transform="translate(217.558984 0.601562)" xlink:href="#Cmmi10-af"/>
-    <use transform="translate(285.885312 38.865625)scale(0.7)" xlink:href="#Cmsy10-30"/>
-    <use transform="translate(311.50582 0.601562)" xlink:href="#Cmmi10-78"/>
-    <use transform="translate(368.585898 -16.404687)scale(0.7)" xlink:href="#Cmmi10-69"/>
-    <use transform="translate(392.682578 -16.404687)scale(0.7)" xlink:href="#Cmmi10-74"/>
-    <use transform="translate(441.877305 0.601562)" xlink:href="#Cmr10-2b"/>
-    <use transform="translate(537.121445 0.601562)" xlink:href="#Cmmi10-b9"/>
-    <use transform="translate(597.326523 -16.404687)scale(0.7)" xlink:href="#Cmmi10-69"/>
-    <use transform="translate(645.359141 0.601562)" xlink:href="#Cmr10-2b"/>
-    <use transform="translate(740.603281 0.601562)" xlink:href="#Cmmi10-b2"/>
-    <use transform="translate(781.081797 -16.404687)scale(0.7)" xlink:href="#Cmmi10-69"/>
-    <use transform="translate(805.178477 -16.404687)scale(0.7)" xlink:href="#Cmmi10-74"/>
-   </g>
-  </g>
- </g>
- <defs>
-  <clipPath id="p65e1c8b035">
-   <rect height="72" width="69.12" x="194.4" y="9"/>
-  </clipPath>
-  <clipPath id="p4dc94feb3b">
-   <rect height="72" width="69.12" x="272.16" y="9"/>
-  </clipPath>
-  <clipPath id="pfceed726e3">
-   <rect height="72" width="69.12" x="349.92" y="9"/>
-  </clipPath>
- </defs>
-</svg>
diff --git a/doc/make.py b/doc/make.py
index cbb1fa6a5324a..024a748cd28ca 100755
--- a/doc/make.py
+++ b/doc/make.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
 Python script for building documentation.
 
@@ -60,7 +60,7 @@ def __init__(
         if single_doc and single_doc.endswith(".rst"):
             self.single_doc_html = os.path.splitext(single_doc)[0] + ".html"
         elif single_doc:
-            self.single_doc_html = "reference/api/pandas.{}.html".format(single_doc)
+            self.single_doc_html = f"reference/api/pandas.{single_doc}.html"
 
     def _process_single_doc(self, single_doc):
         """
@@ -76,7 +76,7 @@ def _process_single_doc(self, single_doc):
             if os.path.exists(os.path.join(SOURCE_PATH, single_doc)):
                 return single_doc
             else:
-                raise FileNotFoundError("File {} not found".format(single_doc))
+                raise FileNotFoundError(f"File {single_doc} not found")
 
         elif single_doc.startswith("pandas."):
             try:
@@ -84,17 +84,15 @@ def _process_single_doc(self, single_doc):
                 for name in single_doc.split("."):
                     obj = getattr(obj, name)
             except AttributeError:
-                raise ImportError("Could not import {}".format(single_doc))
+                raise ImportError(f"Could not import {single_doc}")
             else:
                 return single_doc[len("pandas.") :]
         else:
             raise ValueError(
-                (
-                    "--single={} not understood. Value should be a "
-                    "valid path to a .rst or .ipynb file, or a "
-                    "valid pandas object (e.g. categorical.rst or "
-                    "pandas.DataFrame.head)"
-                ).format(single_doc)
+                f"--single={single_doc} not understood. "
+                "Value should be a valid path to a .rst or .ipynb file, "
+                "or a valid pandas object "
+                "(e.g. categorical.rst or pandas.DataFrame.head)"
             )
 
     @staticmethod
@@ -113,7 +111,7 @@ def _run_os(*args):
         """
         subprocess.check_call(args, stdout=sys.stdout, stderr=sys.stderr)
 
-    def _sphinx_build(self, kind):
+    def _sphinx_build(self, kind: str):
         """
         Call sphinx to build documentation.
 
@@ -128,7 +126,7 @@ def _sphinx_build(self, kind):
         >>> DocBuilder(num_jobs=4)._sphinx_build('html')
         """
         if kind not in ("html", "latex"):
-            raise ValueError("kind must be html or latex, " "not {}".format(kind))
+            raise ValueError(f"kind must be html or latex, not {kind}")
 
         cmd = ["sphinx-build", "-b", kind]
         if self.num_jobs:
@@ -136,7 +134,7 @@ def _sphinx_build(self, kind):
         if self.warnings_are_errors:
             cmd += ["-W", "--keep-going"]
         if self.verbosity:
-            cmd.append("-{}".format("v" * self.verbosity))
+            cmd.append(f"-{'v' * self.verbosity}")
         cmd += [
             "-d",
             os.path.join(BUILD_PATH, "doctrees"),
@@ -156,7 +154,7 @@ def _get_page_title(self, page):
         """
         Open the rst file `page` and extract its title.
         """
-        fname = os.path.join(SOURCE_PATH, "{}.rst".format(page))
+        fname = os.path.join(SOURCE_PATH, f"{page}.rst")
         option_parser = docutils.frontend.OptionParser(
             components=(docutils.parsers.rst.Parser,)
         )
@@ -184,18 +182,6 @@ def _add_redirects(self):
         Create in the build directory an html file with a redirect,
         for every row in REDIRECTS_FILE.
         """
-        html = """
-        <html>
-            <head>
-                <meta http-equiv="refresh" content="0;URL={url}"/>
-            </head>
-            <body>
-                <p>
-                    The page has been moved to <a href="{url}">{title}</a>
-                </p>
-            </body>
-        <html>
-        """
         with open(REDIRECTS_FILE) as mapping_fd:
             reader = csv.reader(mapping_fd)
             for row in reader:
@@ -214,15 +200,23 @@ def _add_redirects(self):
 
                 if os.path.exists(path):
                     raise RuntimeError(
-                        ("Redirection would overwrite an existing file: " "{}").format(
-                            path
-                        )
+                        f"Redirection would overwrite an existing file: {path}"
                     )
 
                 with open(path, "w") as moved_page_fd:
-                    moved_page_fd.write(
-                        html.format(url="{}.html".format(row[1]), title=title)
-                    )
+                    html = f"""\
+<html>
+    <head>
+        <meta http-equiv="refresh" content="0;URL={row[1]}.html"/>
+    </head>
+    <body>
+        <p>
+            The page has been moved to <a href="{row[1]}.html">{title}</a>
+        </p>
+    </body>
+<html>"""
+
+                    moved_page_fd.write(html)
 
     def html(self):
         """
@@ -290,15 +284,14 @@ def zip_html(self):
 def main():
     cmds = [method for method in dir(DocBuilder) if not method.startswith("_")]
 
+    joined = ",".join(cmds)
     argparser = argparse.ArgumentParser(
-        description="pandas documentation builder",
-        epilog="Commands: {}".format(",".join(cmds)),
+        description="pandas documentation builder", epilog=f"Commands: {joined}",
     )
+
+    joined = ", ".join(cmds)
     argparser.add_argument(
-        "command",
-        nargs="?",
-        default="html",
-        help="command to run: {}".format(", ".join(cmds)),
+        "command", nargs="?", default="html", help=f"command to run: {joined}",
     )
     argparser.add_argument(
         "--num-jobs", type=int, default=0, help="number of jobs used by sphinx-build"
@@ -312,10 +305,9 @@ def main():
         type=str,
         default=None,
         help=(
-            'filename (relative to the "source" folder)'
-            " of section or method name to compile, e.g. "
-            '"development/contributing.rst",'
-            ' "ecosystem.rst", "pandas.DataFrame.join"'
+            "filename (relative to the 'source' folder) of section or method name to "
+            "compile, e.g. 'development/contributing.rst', "
+            "'ecosystem.rst', 'pandas.DataFrame.join'"
         ),
     )
     argparser.add_argument(
@@ -340,11 +332,8 @@ def main():
     args = argparser.parse_args()
 
     if args.command not in cmds:
-        raise ValueError(
-            "Unknown command {}. Available options: {}".format(
-                args.command, ", ".join(cmds)
-            )
-        )
+        joined = ", ".join(cmds)
+        raise ValueError(f"Unknown command {args.command}. Available options: {joined}")
 
     # Below we update both os.environ and sys.path. The former is used by
     # external libraries (namely Sphinx) to compile this module and resolve
diff --git a/doc/redirects.csv b/doc/redirects.csv
index a7886779c97d5..ef93955c14fe6 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -6,6 +6,7 @@ whatsnew,whatsnew/index
 release,whatsnew/index
 
 # getting started
+install,getting_started/install
 10min,getting_started/10min
 basics,getting_started/basics
 comparison_with_r,getting_started/comparison/comparison_with_r
@@ -45,7 +46,10 @@ developer,development/developer
 extending,development/extending
 internals,development/internals
 
-# api
+# api moved function
+reference/api/pandas.io.json.json_normalize,pandas.json_normalize
+
+# api rename
 api,reference/index
 generated/pandas.api.extensions.ExtensionArray.argsort,../reference/api/pandas.api.extensions.ExtensionArray.argsort
 generated/pandas.api.extensions.ExtensionArray.astype,../reference/api/pandas.api.extensions.ExtensionArray.astype
@@ -267,21 +271,21 @@ generated/pandas.core.window.Expanding.skew,../reference/api/pandas.core.window.
 generated/pandas.core.window.Expanding.std,../reference/api/pandas.core.window.Expanding.std
 generated/pandas.core.window.Expanding.sum,../reference/api/pandas.core.window.Expanding.sum
 generated/pandas.core.window.Expanding.var,../reference/api/pandas.core.window.Expanding.var
-generated/pandas.core.window.Rolling.aggregate,../reference/api/pandas.core.window.Rolling.aggregate
-generated/pandas.core.window.Rolling.apply,../reference/api/pandas.core.window.Rolling.apply
-generated/pandas.core.window.Rolling.corr,../reference/api/pandas.core.window.Rolling.corr
-generated/pandas.core.window.Rolling.count,../reference/api/pandas.core.window.Rolling.count
-generated/pandas.core.window.Rolling.cov,../reference/api/pandas.core.window.Rolling.cov
-generated/pandas.core.window.Rolling.kurt,../reference/api/pandas.core.window.Rolling.kurt
-generated/pandas.core.window.Rolling.max,../reference/api/pandas.core.window.Rolling.max
-generated/pandas.core.window.Rolling.mean,../reference/api/pandas.core.window.Rolling.mean
-generated/pandas.core.window.Rolling.median,../reference/api/pandas.core.window.Rolling.median
-generated/pandas.core.window.Rolling.min,../reference/api/pandas.core.window.Rolling.min
-generated/pandas.core.window.Rolling.quantile,../reference/api/pandas.core.window.Rolling.quantile
-generated/pandas.core.window.Rolling.skew,../reference/api/pandas.core.window.Rolling.skew
-generated/pandas.core.window.Rolling.std,../reference/api/pandas.core.window.Rolling.std
-generated/pandas.core.window.Rolling.sum,../reference/api/pandas.core.window.Rolling.sum
-generated/pandas.core.window.Rolling.var,../reference/api/pandas.core.window.Rolling.var
+generated/pandas.core.window.Rolling.aggregate,../reference/api/pandas.core.window.rolling.Rolling.aggregate
+generated/pandas.core.window.Rolling.apply,../reference/api/pandas.core.window.rolling.Rolling.apply
+generated/pandas.core.window.Rolling.corr,../reference/api/pandas.core.window.rolling.Rolling.corr
+generated/pandas.core.window.Rolling.count,../reference/api/pandas.core.window.rolling.Rolling.count
+generated/pandas.core.window.Rolling.cov,../reference/api/pandas.core.window.rolling.Rolling.cov
+generated/pandas.core.window.Rolling.kurt,../reference/api/pandas.core.window.rolling.Rolling.kurt
+generated/pandas.core.window.Rolling.max,../reference/api/pandas.core.window.rolling.Rolling.max
+generated/pandas.core.window.Rolling.mean,../reference/api/pandas.core.window.rolling.Rolling.mean
+generated/pandas.core.window.Rolling.median,../reference/api/pandas.core.window.rolling.Rolling.median
+generated/pandas.core.window.Rolling.min,../reference/api/pandas.core.window.rolling.Rolling.min
+generated/pandas.core.window.Rolling.quantile,../reference/api/pandas.core.window.rolling.Rolling.quantile
+generated/pandas.core.window.Rolling.skew,../reference/api/pandas.core.window.rolling.Rolling.skew
+generated/pandas.core.window.Rolling.std,../reference/api/pandas.core.window.rolling.Rolling.std
+generated/pandas.core.window.Rolling.sum,../reference/api/pandas.core.window.rolling.Rolling.sum
+generated/pandas.core.window.Rolling.var,../reference/api/pandas.core.window.rolling.Rolling.var
 generated/pandas.core.window.Window.mean,../reference/api/pandas.core.window.Window.mean
 generated/pandas.core.window.Window.sum,../reference/api/pandas.core.window.Window.sum
 generated/pandas.crosstab,../reference/api/pandas.crosstab
@@ -318,7 +322,6 @@ generated/pandas.DataFrame.clip_upper,../reference/api/pandas.DataFrame.clip_upp
 generated/pandas.DataFrame.columns,../reference/api/pandas.DataFrame.columns
 generated/pandas.DataFrame.combine_first,../reference/api/pandas.DataFrame.combine_first
 generated/pandas.DataFrame.combine,../reference/api/pandas.DataFrame.combine
-generated/pandas.DataFrame.compound,../reference/api/pandas.DataFrame.compound
 generated/pandas.DataFrame.convert_objects,../reference/api/pandas.DataFrame.convert_objects
 generated/pandas.DataFrame.copy,../reference/api/pandas.DataFrame.copy
 generated/pandas.DataFrame.corr,../reference/api/pandas.DataFrame.corr
@@ -356,13 +359,9 @@ generated/pandas.DataFrame.from_csv,../reference/api/pandas.DataFrame.from_csv
 generated/pandas.DataFrame.from_dict,../reference/api/pandas.DataFrame.from_dict
 generated/pandas.DataFrame.from_items,../reference/api/pandas.DataFrame.from_items
 generated/pandas.DataFrame.from_records,../reference/api/pandas.DataFrame.from_records
-generated/pandas.DataFrame.ftypes,../reference/api/pandas.DataFrame.ftypes
 generated/pandas.DataFrame.ge,../reference/api/pandas.DataFrame.ge
-generated/pandas.DataFrame.get_dtype_counts,../reference/api/pandas.DataFrame.get_dtype_counts
-generated/pandas.DataFrame.get_ftype_counts,../reference/api/pandas.DataFrame.get_ftype_counts
 generated/pandas.DataFrame.get,../reference/api/pandas.DataFrame.get
 generated/pandas.DataFrame.get_value,../reference/api/pandas.DataFrame.get_value
-generated/pandas.DataFrame.get_values,../reference/api/pandas.DataFrame.get_values
 generated/pandas.DataFrame.groupby,../reference/api/pandas.DataFrame.groupby
 generated/pandas.DataFrame.gt,../reference/api/pandas.DataFrame.gt
 generated/pandas.DataFrame.head,../reference/api/pandas.DataFrame.head
@@ -487,7 +486,6 @@ generated/pandas.DataFrame.T,../reference/api/pandas.DataFrame.T
 generated/pandas.DataFrame.timetuple,../reference/api/pandas.DataFrame.timetuple
 generated/pandas.DataFrame.to_clipboard,../reference/api/pandas.DataFrame.to_clipboard
 generated/pandas.DataFrame.to_csv,../reference/api/pandas.DataFrame.to_csv
-generated/pandas.DataFrame.to_dense,../reference/api/pandas.DataFrame.to_dense
 generated/pandas.DataFrame.to_dict,../reference/api/pandas.DataFrame.to_dict
 generated/pandas.DataFrame.to_excel,../reference/api/pandas.DataFrame.to_excel
 generated/pandas.DataFrame.to_feather,../reference/api/pandas.DataFrame.to_feather
@@ -496,14 +494,12 @@ generated/pandas.DataFrame.to_hdf,../reference/api/pandas.DataFrame.to_hdf
 generated/pandas.DataFrame.to,../reference/api/pandas.DataFrame.to
 generated/pandas.DataFrame.to_json,../reference/api/pandas.DataFrame.to_json
 generated/pandas.DataFrame.to_latex,../reference/api/pandas.DataFrame.to_latex
-generated/pandas.DataFrame.to_msgpack,../reference/api/pandas.DataFrame.to_msgpack
 generated/pandas.DataFrame.to_numpy,../reference/api/pandas.DataFrame.to_numpy
 generated/pandas.DataFrame.to_panel,../reference/api/pandas.DataFrame.to_panel
 generated/pandas.DataFrame.to_parquet,../reference/api/pandas.DataFrame.to_parquet
 generated/pandas.DataFrame.to_period,../reference/api/pandas.DataFrame.to_period
 generated/pandas.DataFrame.to_pickle,../reference/api/pandas.DataFrame.to_pickle
 generated/pandas.DataFrame.to_records,../reference/api/pandas.DataFrame.to_records
-generated/pandas.DataFrame.to_sparse,../reference/api/pandas.DataFrame.to_sparse
 generated/pandas.DataFrame.to_sql,../reference/api/pandas.DataFrame.to_sql
 generated/pandas.DataFrame.to_stata,../reference/api/pandas.DataFrame.to_stata
 generated/pandas.DataFrame.to_string,../reference/api/pandas.DataFrame.to_string
@@ -624,8 +620,6 @@ generated/pandas.Index.asi8,../reference/api/pandas.Index.asi8
 generated/pandas.Index.asof,../reference/api/pandas.Index.asof
 generated/pandas.Index.asof_locs,../reference/api/pandas.Index.asof_locs
 generated/pandas.Index.astype,../reference/api/pandas.Index.astype
-generated/pandas.Index.base,../reference/api/pandas.Index.base
-generated/pandas.Index.contains,../reference/api/pandas.Index.contains
 generated/pandas.Index.copy,../reference/api/pandas.Index.copy
 generated/pandas.Index.data,../reference/api/pandas.Index.data
 generated/pandas.Index.delete,../reference/api/pandas.Index.delete
@@ -635,15 +629,12 @@ generated/pandas.Index.drop,../reference/api/pandas.Index.drop
 generated/pandas.Index.droplevel,../reference/api/pandas.Index.droplevel
 generated/pandas.Index.dropna,../reference/api/pandas.Index.dropna
 generated/pandas.Index.dtype,../reference/api/pandas.Index.dtype
-generated/pandas.Index.dtype_str,../reference/api/pandas.Index.dtype_str
 generated/pandas.Index.duplicated,../reference/api/pandas.Index.duplicated
 generated/pandas.Index.empty,../reference/api/pandas.Index.empty
 generated/pandas.Index.equals,../reference/api/pandas.Index.equals
 generated/pandas.Index.factorize,../reference/api/pandas.Index.factorize
 generated/pandas.Index.fillna,../reference/api/pandas.Index.fillna
-generated/pandas.Index.flags,../reference/api/pandas.Index.flags
 generated/pandas.Index.format,../reference/api/pandas.Index.format
-generated/pandas.Index.get_duplicates,../reference/api/pandas.Index.get_duplicates
 generated/pandas.Index.get_indexer_for,../reference/api/pandas.Index.get_indexer_for
 generated/pandas.Index.get_indexer,../reference/api/pandas.Index.get_indexer
 generated/pandas.Index.get_indexer_non_unique,../reference/api/pandas.Index.get_indexer_non_unique
@@ -651,7 +642,6 @@ generated/pandas.Index.get_level_values,../reference/api/pandas.Index.get_level_
 generated/pandas.Index.get_loc,../reference/api/pandas.Index.get_loc
 generated/pandas.Index.get_slice_bound,../reference/api/pandas.Index.get_slice_bound
 generated/pandas.Index.get_value,../reference/api/pandas.Index.get_value
-generated/pandas.Index.get_values,../reference/api/pandas.Index.get_values
 generated/pandas.Index.groupby,../reference/api/pandas.Index.groupby
 generated/pandas.Index.has_duplicates,../reference/api/pandas.Index.has_duplicates
 generated/pandas.Index.hasnans,../reference/api/pandas.Index.hasnans
@@ -681,7 +671,6 @@ generated/pandas.Index.is_object,../reference/api/pandas.Index.is_object
 generated/pandas.Index.is_type_compatible,../reference/api/pandas.Index.is_type_compatible
 generated/pandas.Index.is_unique,../reference/api/pandas.Index.is_unique
 generated/pandas.Index.item,../reference/api/pandas.Index.item
-generated/pandas.Index.itemsize,../reference/api/pandas.Index.itemsize
 generated/pandas.Index.join,../reference/api/pandas.Index.join
 generated/pandas.Index.map,../reference/api/pandas.Index.map
 generated/pandas.Index.max,../reference/api/pandas.Index.max
@@ -713,7 +702,6 @@ generated/pandas.Index.sort,../reference/api/pandas.Index.sort
 generated/pandas.Index.sortlevel,../reference/api/pandas.Index.sortlevel
 generated/pandas.Index.sort_values,../reference/api/pandas.Index.sort_values
 generated/pandas.Index.str,../reference/api/pandas.Index.str
-generated/pandas.Index.strides,../reference/api/pandas.Index.strides
 generated/pandas.Index.summary,../reference/api/pandas.Index.summary
 generated/pandas.Index.symmetric_difference,../reference/api/pandas.Index.symmetric_difference
 generated/pandas.Index.take,../reference/api/pandas.Index.take
@@ -792,8 +780,7 @@ generated/pandas.io.formats.style.Styler.to_excel,../reference/api/pandas.io.for
 generated/pandas.io.formats.style.Styler.use,../reference/api/pandas.io.formats.style.Styler.use
 generated/pandas.io.formats.style.Styler.where,../reference/api/pandas.io.formats.style.Styler.where
 generated/pandas.io.json.build_table_schema,../reference/api/pandas.io.json.build_table_schema
-generated/pandas.io.json.json_normalize,../reference/api/pandas.io.json.json_normalize
-generated/pandas.io.stata.StataReader.data,../reference/api/pandas.io.stata.StataReader.data
+generated/pandas.io.json.json_normalize,../reference/api/pandas.json_normalize
 generated/pandas.io.stata.StataReader.data_label,../reference/api/pandas.io.stata.StataReader.data_label
 generated/pandas.io.stata.StataReader.value_labels,../reference/api/pandas.io.stata.StataReader.value_labels
 generated/pandas.io.stata.StataReader.variable_labels,../reference/api/pandas.io.stata.StataReader.variable_labels
@@ -828,180 +815,9 @@ generated/pandas.MultiIndex.sortlevel,../reference/api/pandas.MultiIndex.sortlev
 generated/pandas.MultiIndex.swaplevel,../reference/api/pandas.MultiIndex.swaplevel
 generated/pandas.MultiIndex.to_flat_index,../reference/api/pandas.MultiIndex.to_flat_index
 generated/pandas.MultiIndex.to_frame,../reference/api/pandas.MultiIndex.to_frame
-generated/pandas.MultiIndex.to_hierarchical,../reference/api/pandas.MultiIndex.to_hierarchical
 generated/pandas.notna,../reference/api/pandas.notna
 generated/pandas.notnull,../reference/api/pandas.notnull
 generated/pandas.option_context,../reference/api/pandas.option_context
-generated/pandas.Panel.abs,../reference/api/pandas.Panel.abs
-generated/pandas.Panel.add,../reference/api/pandas.Panel.add
-generated/pandas.Panel.add_prefix,../reference/api/pandas.Panel.add_prefix
-generated/pandas.Panel.add_suffix,../reference/api/pandas.Panel.add_suffix
-generated/pandas.Panel.agg,../reference/api/pandas.Panel.agg
-generated/pandas.Panel.aggregate,../reference/api/pandas.Panel.aggregate
-generated/pandas.Panel.align,../reference/api/pandas.Panel.align
-generated/pandas.Panel.all,../reference/api/pandas.Panel.all
-generated/pandas.Panel.any,../reference/api/pandas.Panel.any
-generated/pandas.Panel.apply,../reference/api/pandas.Panel.apply
-generated/pandas.Panel.as_blocks,../reference/api/pandas.Panel.as_blocks
-generated/pandas.Panel.asfreq,../reference/api/pandas.Panel.asfreq
-generated/pandas.Panel.as_matrix,../reference/api/pandas.Panel.as_matrix
-generated/pandas.Panel.asof,../reference/api/pandas.Panel.asof
-generated/pandas.Panel.astype,../reference/api/pandas.Panel.astype
-generated/pandas.Panel.at,../reference/api/pandas.Panel.at
-generated/pandas.Panel.at_time,../reference/api/pandas.Panel.at_time
-generated/pandas.Panel.axes,../reference/api/pandas.Panel.axes
-generated/pandas.Panel.between_time,../reference/api/pandas.Panel.between_time
-generated/pandas.Panel.bfill,../reference/api/pandas.Panel.bfill
-generated/pandas.Panel.blocks,../reference/api/pandas.Panel.blocks
-generated/pandas.Panel.bool,../reference/api/pandas.Panel.bool
-generated/pandas.Panel.clip,../reference/api/pandas.Panel.clip
-generated/pandas.Panel.clip_lower,../reference/api/pandas.Panel.clip_lower
-generated/pandas.Panel.clip_upper,../reference/api/pandas.Panel.clip_upper
-generated/pandas.Panel.compound,../reference/api/pandas.Panel.compound
-generated/pandas.Panel.conform,../reference/api/pandas.Panel.conform
-generated/pandas.Panel.convert_objects,../reference/api/pandas.Panel.convert_objects
-generated/pandas.Panel.copy,../reference/api/pandas.Panel.copy
-generated/pandas.Panel.count,../reference/api/pandas.Panel.count
-generated/pandas.Panel.cummax,../reference/api/pandas.Panel.cummax
-generated/pandas.Panel.cummin,../reference/api/pandas.Panel.cummin
-generated/pandas.Panel.cumprod,../reference/api/pandas.Panel.cumprod
-generated/pandas.Panel.cumsum,../reference/api/pandas.Panel.cumsum
-generated/pandas.Panel.describe,../reference/api/pandas.Panel.describe
-generated/pandas.Panel.div,../reference/api/pandas.Panel.div
-generated/pandas.Panel.divide,../reference/api/pandas.Panel.divide
-generated/pandas.Panel.drop,../reference/api/pandas.Panel.drop
-generated/pandas.Panel.droplevel,../reference/api/pandas.Panel.droplevel
-generated/pandas.Panel.dropna,../reference/api/pandas.Panel.dropna
-generated/pandas.Panel.dtypes,../reference/api/pandas.Panel.dtypes
-generated/pandas.Panel.empty,../reference/api/pandas.Panel.empty
-generated/pandas.Panel.eq,../reference/api/pandas.Panel.eq
-generated/pandas.Panel.equals,../reference/api/pandas.Panel.equals
-generated/pandas.Panel.ffill,../reference/api/pandas.Panel.ffill
-generated/pandas.Panel.fillna,../reference/api/pandas.Panel.fillna
-generated/pandas.Panel.filter,../reference/api/pandas.Panel.filter
-generated/pandas.Panel.first,../reference/api/pandas.Panel.first
-generated/pandas.Panel.first_valid_index,../reference/api/pandas.Panel.first_valid_index
-generated/pandas.Panel.floordiv,../reference/api/pandas.Panel.floordiv
-generated/pandas.Panel.from_dict,../reference/api/pandas.Panel.from_dict
-generated/pandas.Panel.fromDict,../reference/api/pandas.Panel.fromDict
-generated/pandas.Panel.ftypes,../reference/api/pandas.Panel.ftypes
-generated/pandas.Panel.ge,../reference/api/pandas.Panel.ge
-generated/pandas.Panel.get_dtype_counts,../reference/api/pandas.Panel.get_dtype_counts
-generated/pandas.Panel.get_ftype_counts,../reference/api/pandas.Panel.get_ftype_counts
-generated/pandas.Panel.get,../reference/api/pandas.Panel.get
-generated/pandas.Panel.get_value,../reference/api/pandas.Panel.get_value
-generated/pandas.Panel.get_values,../reference/api/pandas.Panel.get_values
-generated/pandas.Panel.groupby,../reference/api/pandas.Panel.groupby
-generated/pandas.Panel.gt,../reference/api/pandas.Panel.gt
-generated/pandas.Panel.head,../reference/api/pandas.Panel.head
-generated/pandas.Panel,../reference/api/pandas.Panel
-generated/pandas.Panel.iat,../reference/api/pandas.Panel.iat
-generated/pandas.Panel.iloc,../reference/api/pandas.Panel.iloc
-generated/pandas.Panel.infer_objects,../reference/api/pandas.Panel.infer_objects
-generated/pandas.Panel.interpolate,../reference/api/pandas.Panel.interpolate
-generated/pandas.Panel.is_copy,../reference/api/pandas.Panel.is_copy
-generated/pandas.Panel.isna,../reference/api/pandas.Panel.isna
-generated/pandas.Panel.isnull,../reference/api/pandas.Panel.isnull
-generated/pandas.Panel.items,../reference/api/pandas.Panel.items
-generated/pandas.Panel.__iter__,../reference/api/pandas.Panel.__iter__
-generated/pandas.Panel.iteritems,../reference/api/pandas.Panel.iteritems
-generated/pandas.Panel.ix,../reference/api/pandas.Panel.ix
-generated/pandas.Panel.join,../reference/api/pandas.Panel.join
-generated/pandas.Panel.keys,../reference/api/pandas.Panel.keys
-generated/pandas.Panel.kurt,../reference/api/pandas.Panel.kurt
-generated/pandas.Panel.kurtosis,../reference/api/pandas.Panel.kurtosis
-generated/pandas.Panel.last,../reference/api/pandas.Panel.last
-generated/pandas.Panel.last_valid_index,../reference/api/pandas.Panel.last_valid_index
-generated/pandas.Panel.le,../reference/api/pandas.Panel.le
-generated/pandas.Panel.loc,../reference/api/pandas.Panel.loc
-generated/pandas.Panel.lt,../reference/api/pandas.Panel.lt
-generated/pandas.Panel.mad,../reference/api/pandas.Panel.mad
-generated/pandas.Panel.major_axis,../reference/api/pandas.Panel.major_axis
-generated/pandas.Panel.major_xs,../reference/api/pandas.Panel.major_xs
-generated/pandas.Panel.mask,../reference/api/pandas.Panel.mask
-generated/pandas.Panel.max,../reference/api/pandas.Panel.max
-generated/pandas.Panel.mean,../reference/api/pandas.Panel.mean
-generated/pandas.Panel.median,../reference/api/pandas.Panel.median
-generated/pandas.Panel.min,../reference/api/pandas.Panel.min
-generated/pandas.Panel.minor_axis,../reference/api/pandas.Panel.minor_axis
-generated/pandas.Panel.minor_xs,../reference/api/pandas.Panel.minor_xs
-generated/pandas.Panel.mod,../reference/api/pandas.Panel.mod
-generated/pandas.Panel.mul,../reference/api/pandas.Panel.mul
-generated/pandas.Panel.multiply,../reference/api/pandas.Panel.multiply
-generated/pandas.Panel.ndim,../reference/api/pandas.Panel.ndim
-generated/pandas.Panel.ne,../reference/api/pandas.Panel.ne
-generated/pandas.Panel.notna,../reference/api/pandas.Panel.notna
-generated/pandas.Panel.notnull,../reference/api/pandas.Panel.notnull
-generated/pandas.Panel.pct_change,../reference/api/pandas.Panel.pct_change
-generated/pandas.Panel.pipe,../reference/api/pandas.Panel.pipe
-generated/pandas.Panel.pop,../reference/api/pandas.Panel.pop
-generated/pandas.Panel.pow,../reference/api/pandas.Panel.pow
-generated/pandas.Panel.prod,../reference/api/pandas.Panel.prod
-generated/pandas.Panel.product,../reference/api/pandas.Panel.product
-generated/pandas.Panel.radd,../reference/api/pandas.Panel.radd
-generated/pandas.Panel.rank,../reference/api/pandas.Panel.rank
-generated/pandas.Panel.rdiv,../reference/api/pandas.Panel.rdiv
-generated/pandas.Panel.reindex_axis,../reference/api/pandas.Panel.reindex_axis
-generated/pandas.Panel.reindex,../reference/api/pandas.Panel.reindex
-generated/pandas.Panel.reindex_like,../reference/api/pandas.Panel.reindex_like
-generated/pandas.Panel.rename_axis,../reference/api/pandas.Panel.rename_axis
-generated/pandas.Panel.rename,../reference/api/pandas.Panel.rename
-generated/pandas.Panel.replace,../reference/api/pandas.Panel.replace
-generated/pandas.Panel.resample,../reference/api/pandas.Panel.resample
-generated/pandas.Panel.rfloordiv,../reference/api/pandas.Panel.rfloordiv
-generated/pandas.Panel.rmod,../reference/api/pandas.Panel.rmod
-generated/pandas.Panel.rmul,../reference/api/pandas.Panel.rmul
-generated/pandas.Panel.round,../reference/api/pandas.Panel.round
-generated/pandas.Panel.rpow,../reference/api/pandas.Panel.rpow
-generated/pandas.Panel.rsub,../reference/api/pandas.Panel.rsub
-generated/pandas.Panel.rtruediv,../reference/api/pandas.Panel.rtruediv
-generated/pandas.Panel.sample,../reference/api/pandas.Panel.sample
-generated/pandas.Panel.select,../reference/api/pandas.Panel.select
-generated/pandas.Panel.sem,../reference/api/pandas.Panel.sem
-generated/pandas.Panel.set_axis,../reference/api/pandas.Panel.set_axis
-generated/pandas.Panel.set_value,../reference/api/pandas.Panel.set_value
-generated/pandas.Panel.shape,../reference/api/pandas.Panel.shape
-generated/pandas.Panel.shift,../reference/api/pandas.Panel.shift
-generated/pandas.Panel.size,../reference/api/pandas.Panel.size
-generated/pandas.Panel.skew,../reference/api/pandas.Panel.skew
-generated/pandas.Panel.slice_shift,../reference/api/pandas.Panel.slice_shift
-generated/pandas.Panel.sort_index,../reference/api/pandas.Panel.sort_index
-generated/pandas.Panel.sort_values,../reference/api/pandas.Panel.sort_values
-generated/pandas.Panel.squeeze,../reference/api/pandas.Panel.squeeze
-generated/pandas.Panel.std,../reference/api/pandas.Panel.std
-generated/pandas.Panel.sub,../reference/api/pandas.Panel.sub
-generated/pandas.Panel.subtract,../reference/api/pandas.Panel.subtract
-generated/pandas.Panel.sum,../reference/api/pandas.Panel.sum
-generated/pandas.Panel.swapaxes,../reference/api/pandas.Panel.swapaxes
-generated/pandas.Panel.swaplevel,../reference/api/pandas.Panel.swaplevel
-generated/pandas.Panel.tail,../reference/api/pandas.Panel.tail
-generated/pandas.Panel.take,../reference/api/pandas.Panel.take
-generated/pandas.Panel.timetuple,../reference/api/pandas.Panel.timetuple
-generated/pandas.Panel.to_clipboard,../reference/api/pandas.Panel.to_clipboard
-generated/pandas.Panel.to_csv,../reference/api/pandas.Panel.to_csv
-generated/pandas.Panel.to_dense,../reference/api/pandas.Panel.to_dense
-generated/pandas.Panel.to_excel,../reference/api/pandas.Panel.to_excel
-generated/pandas.Panel.to_frame,../reference/api/pandas.Panel.to_frame
-generated/pandas.Panel.to_hdf,../reference/api/pandas.Panel.to_hdf
-generated/pandas.Panel.to_json,../reference/api/pandas.Panel.to_json
-generated/pandas.Panel.to_latex,../reference/api/pandas.Panel.to_latex
-generated/pandas.Panel.to_msgpack,../reference/api/pandas.Panel.to_msgpack
-generated/pandas.Panel.to_pickle,../reference/api/pandas.Panel.to_pickle
-generated/pandas.Panel.to_sparse,../reference/api/pandas.Panel.to_sparse
-generated/pandas.Panel.to_sql,../reference/api/pandas.Panel.to_sql
-generated/pandas.Panel.to_xarray,../reference/api/pandas.Panel.to_xarray
-generated/pandas.Panel.transform,../reference/api/pandas.Panel.transform
-generated/pandas.Panel.transpose,../reference/api/pandas.Panel.transpose
-generated/pandas.Panel.truediv,../reference/api/pandas.Panel.truediv
-generated/pandas.Panel.truncate,../reference/api/pandas.Panel.truncate
-generated/pandas.Panel.tshift,../reference/api/pandas.Panel.tshift
-generated/pandas.Panel.tz_convert,../reference/api/pandas.Panel.tz_convert
-generated/pandas.Panel.tz_localize,../reference/api/pandas.Panel.tz_localize
-generated/pandas.Panel.update,../reference/api/pandas.Panel.update
-generated/pandas.Panel.values,../reference/api/pandas.Panel.values
-generated/pandas.Panel.var,../reference/api/pandas.Panel.var
-generated/pandas.Panel.where,../reference/api/pandas.Panel.where
-generated/pandas.Panel.xs,../reference/api/pandas.Panel.xs
 generated/pandas.Period.asfreq,../reference/api/pandas.Period.asfreq
 generated/pandas.Period.day,../reference/api/pandas.Period.day
 generated/pandas.Period.dayofweek,../reference/api/pandas.Period.dayofweek
@@ -1075,7 +891,6 @@ generated/pandas.read_gbq,../reference/api/pandas.read_gbq
 generated/pandas.read_hdf,../reference/api/pandas.read_hdf
 generated/pandas.read,../reference/api/pandas.read
 generated/pandas.read_json,../reference/api/pandas.read_json
-generated/pandas.read_msgpack,../reference/api/pandas.read_msgpack
 generated/pandas.read_parquet,../reference/api/pandas.read_parquet
 generated/pandas.read_pickle,../reference/api/pandas.read_pickle
 generated/pandas.read_sas,../reference/api/pandas.read_sas
@@ -1111,7 +926,6 @@ generated/pandas.Series.at,../reference/api/pandas.Series.at
 generated/pandas.Series.at_time,../reference/api/pandas.Series.at_time
 generated/pandas.Series.autocorr,../reference/api/pandas.Series.autocorr
 generated/pandas.Series.axes,../reference/api/pandas.Series.axes
-generated/pandas.Series.base,../reference/api/pandas.Series.base
 generated/pandas.Series.between,../reference/api/pandas.Series.between
 generated/pandas.Series.between_time,../reference/api/pandas.Series.between_time
 generated/pandas.Series.bfill,../reference/api/pandas.Series.bfill
@@ -1134,7 +948,6 @@ generated/pandas.Series.clip_lower,../reference/api/pandas.Series.clip_lower
 generated/pandas.Series.clip_upper,../reference/api/pandas.Series.clip_upper
 generated/pandas.Series.combine_first,../reference/api/pandas.Series.combine_first
 generated/pandas.Series.combine,../reference/api/pandas.Series.combine
-generated/pandas.Series.compound,../reference/api/pandas.Series.compound
 generated/pandas.Series.compress,../reference/api/pandas.Series.compress
 generated/pandas.Series.convert_objects,../reference/api/pandas.Series.convert_objects
 generated/pandas.Series.copy,../reference/api/pandas.Series.copy
@@ -1220,18 +1033,12 @@ generated/pandas.Series.fillna,../reference/api/pandas.Series.fillna
 generated/pandas.Series.filter,../reference/api/pandas.Series.filter
 generated/pandas.Series.first,../reference/api/pandas.Series.first
 generated/pandas.Series.first_valid_index,../reference/api/pandas.Series.first_valid_index
-generated/pandas.Series.flags,../reference/api/pandas.Series.flags
 generated/pandas.Series.floordiv,../reference/api/pandas.Series.floordiv
 generated/pandas.Series.from_array,../reference/api/pandas.Series.from_array
 generated/pandas.Series.from_csv,../reference/api/pandas.Series.from_csv
-generated/pandas.Series.ftype,../reference/api/pandas.Series.ftype
-generated/pandas.Series.ftypes,../reference/api/pandas.Series.ftypes
 generated/pandas.Series.ge,../reference/api/pandas.Series.ge
-generated/pandas.Series.get_dtype_counts,../reference/api/pandas.Series.get_dtype_counts
-generated/pandas.Series.get_ftype_counts,../reference/api/pandas.Series.get_ftype_counts
 generated/pandas.Series.get,../reference/api/pandas.Series.get
 generated/pandas.Series.get_value,../reference/api/pandas.Series.get_value
-generated/pandas.Series.get_values,../reference/api/pandas.Series.get_values
 generated/pandas.Series.groupby,../reference/api/pandas.Series.groupby
 generated/pandas.Series.gt,../reference/api/pandas.Series.gt
 generated/pandas.Series.hasnans,../reference/api/pandas.Series.hasnans
@@ -1256,7 +1063,6 @@ generated/pandas.Series.isnull,../reference/api/pandas.Series.isnull
 generated/pandas.Series.is_unique,../reference/api/pandas.Series.is_unique
 generated/pandas.Series.item,../reference/api/pandas.Series.item
 generated/pandas.Series.items,../reference/api/pandas.Series.items
-generated/pandas.Series.itemsize,../reference/api/pandas.Series.itemsize
 generated/pandas.Series.__iter__,../reference/api/pandas.Series.__iter__
 generated/pandas.Series.iteritems,../reference/api/pandas.Series.iteritems
 generated/pandas.Series.ix,../reference/api/pandas.Series.ix
@@ -1307,7 +1113,6 @@ generated/pandas.Series.pow,../reference/api/pandas.Series.pow
 generated/pandas.Series.prod,../reference/api/pandas.Series.prod
 generated/pandas.Series.product,../reference/api/pandas.Series.product
 generated/pandas.Series.ptp,../reference/api/pandas.Series.ptp
-generated/pandas.Series.put,../reference/api/pandas.Series.put
 generated/pandas.Series.quantile,../reference/api/pandas.Series.quantile
 generated/pandas.Series.radd,../reference/api/pandas.Series.radd
 generated/pandas.Series.rank,../reference/api/pandas.Series.rank
@@ -1369,7 +1174,6 @@ generated/pandas.Series.str.find,../reference/api/pandas.Series.str.find
 generated/pandas.Series.str.get_dummies,../reference/api/pandas.Series.str.get_dummies
 generated/pandas.Series.str.get,../reference/api/pandas.Series.str.get
 generated/pandas.Series.str,../reference/api/pandas.Series.str
-generated/pandas.Series.strides,../reference/api/pandas.Series.strides
 generated/pandas.Series.str.index,../reference/api/pandas.Series.str.index
 generated/pandas.Series.str.isalnum,../reference/api/pandas.Series.str.isalnum
 generated/pandas.Series.str.isalpha,../reference/api/pandas.Series.str.isalpha
@@ -1419,7 +1223,6 @@ generated/pandas.Series.T,../reference/api/pandas.Series.T
 generated/pandas.Series.timetuple,../reference/api/pandas.Series.timetuple
 generated/pandas.Series.to_clipboard,../reference/api/pandas.Series.to_clipboard
 generated/pandas.Series.to_csv,../reference/api/pandas.Series.to_csv
-generated/pandas.Series.to_dense,../reference/api/pandas.Series.to_dense
 generated/pandas.Series.to_dict,../reference/api/pandas.Series.to_dict
 generated/pandas.Series.to_excel,../reference/api/pandas.Series.to_excel
 generated/pandas.Series.to_frame,../reference/api/pandas.Series.to_frame
@@ -1428,11 +1231,9 @@ generated/pandas.Series.to_json,../reference/api/pandas.Series.to_json
 generated/pandas.Series.to_latex,../reference/api/pandas.Series.to_latex
 generated/pandas.Series.to_list,../reference/api/pandas.Series.to_list
 generated/pandas.Series.tolist,../reference/api/pandas.Series.tolist
-generated/pandas.Series.to_msgpack,../reference/api/pandas.Series.to_msgpack
 generated/pandas.Series.to_numpy,../reference/api/pandas.Series.to_numpy
 generated/pandas.Series.to_period,../reference/api/pandas.Series.to_period
 generated/pandas.Series.to_pickle,../reference/api/pandas.Series.to_pickle
-generated/pandas.Series.to_sparse,../reference/api/pandas.Series.to_sparse
 generated/pandas.Series.to_sql,../reference/api/pandas.Series.to_sql
 generated/pandas.Series.to_string,../reference/api/pandas.Series.to_string
 generated/pandas.Series.to_timestamp,../reference/api/pandas.Series.to_timestamp
@@ -1579,3 +1380,6 @@ generated/pandas.unique,../reference/api/pandas.unique
 generated/pandas.util.hash_array,../reference/api/pandas.util.hash_array
 generated/pandas.util.hash_pandas_object,../reference/api/pandas.util.hash_pandas_object
 generated/pandas.wide_to_long,../reference/api/pandas.wide_to_long
+
+# Cached searches
+reference/api/pandas.DataFrame.from_csv,pandas.read_csv
diff --git a/doc/source/_static/css/pandas.css b/doc/source/_static/css/pandas.css
new file mode 100644
index 0000000000000..43cd631890330
--- /dev/null
+++ b/doc/source/_static/css/pandas.css
@@ -0,0 +1,36 @@
+/* Getting started index page */
+
+.intro-card {
+  background: #fff;
+  border-radius: 0;
+  padding: 30px 10px 10px 10px;
+  margin: 10px 0px;
+}
+
+.intro-card .card-text {
+  margin: 20px 0px;
+  /*min-height: 150px; */
+}
+
+.custom-button {
+  background-color: #dcdcdc;
+  border: none;
+  color: #484848;
+  text-align: center;
+  text-decoration: none;
+  display: inline-block;
+  font-size: 0.9rem;
+  border-radius: 0.5rem;
+  max-width: 220px;
+  padding: 0.5rem 0rem;
+}
+
+.custom-button a {
+  color: #484848;
+}
+
+.custom-button p {
+  margin-top: 0;
+  margin-bottom: 0rem;
+  color: #484848;
+}
diff --git a/doc/source/_static/favicon.ico b/doc/source/_static/favicon.ico
deleted file mode 100644
index d15c4803b62e6..0000000000000
Binary files a/doc/source/_static/favicon.ico and /dev/null differ
diff --git a/doc/source/_static/index_api.svg b/doc/source/_static/index_api.svg
new file mode 100644
index 0000000000000..70bf0d3504b1a
--- /dev/null
+++ b/doc/source/_static/index_api.svg
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="99.058548mm"
+   height="89.967583mm"
+   viewBox="0 0 99.058554 89.967582"
+   version="1.1"
+   id="svg1040"
+   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+   sodipodi:docname="index_api.svg">
+  <defs
+     id="defs1034" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.35"
+     inkscape:cx="533.74914"
+     inkscape:cy="10.90433"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:window-width="930"
+     inkscape:window-height="472"
+     inkscape:window-x="2349"
+     inkscape:window-y="267"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata1037">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(195.19933,-1.0492759)">
+    <g
+       id="g1008"
+       transform="matrix(1.094977,0,0,1.094977,-521.5523,-198.34055)">
+      <path
+         inkscape:connector-curvature="0"
+         id="path899"
+         d="M 324.96812,187.09499 H 303.0455 v 72.1639 h 22.67969"
+         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path899-3"
+         d="m 361.58921,187.09499 h 21.92262 v 72.1639 h -22.67969"
+         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+      <g
+         transform="translate(415.87139,46.162126)"
+         id="g944">
+        <circle
+           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           id="path918"
+           cx="-84.40152"
+           cy="189.84375"
+           r="2.2293637" />
+        <circle
+           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           id="path918-5"
+           cx="-72.949402"
+           cy="189.84375"
+           r="2.2293637" />
+        <circle
+           style="fill:#150458;fill-opacity:1;stroke:#150458;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           id="path918-6"
+           cx="-61.497284"
+           cy="189.84375"
+           r="2.2293637" />
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/doc/source/_static/index_contribute.svg b/doc/source/_static/index_contribute.svg
new file mode 100644
index 0000000000000..e86c3e9fd0b3e
--- /dev/null
+++ b/doc/source/_static/index_contribute.svg
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="89.624855mm"
+   height="89.96759mm"
+   viewBox="0 0 89.62486 89.96759"
+   version="1.1"
+   id="svg1040"
+   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+   sodipodi:docname="index_contribute.svg">
+  <defs
+     id="defs1034" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.35"
+     inkscape:cx="683.11893"
+     inkscape:cy="-59.078181"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:window-width="930"
+     inkscape:window-height="472"
+     inkscape:window-x="2349"
+     inkscape:window-y="267"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata1037">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(234.72009,17.466935)">
+    <g
+       id="g875"
+       transform="matrix(0.99300176,0,0,0.99300176,-133.24106,-172.58804)">
+      <path
+         sodipodi:nodetypes="ccc"
+         inkscape:connector-curvature="0"
+         id="path869"
+         d="m -97.139881,161.26069 47.247024,40.25446 -47.247024,40.25446"
+         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path871"
+         d="m -49.514879,241.81547 h 32.505951"
+         style="fill:none;stroke:#150458;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+    </g>
+  </g>
+</svg>
diff --git a/doc/source/_static/index_getting_started.svg b/doc/source/_static/index_getting_started.svg
new file mode 100644
index 0000000000000..d00e462427193
--- /dev/null
+++ b/doc/source/_static/index_getting_started.svg
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="101.09389mm"
+   height="89.96759mm"
+   viewBox="0 0 101.09389 89.96759"
+   version="1.1"
+   id="svg1040"
+   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+   sodipodi:docname="index_getting_started.svg">
+  <defs
+     id="defs1034" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.35"
+     inkscape:cx="-93.242129"
+     inkscape:cy="-189.9825"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:window-width="1875"
+     inkscape:window-height="1056"
+     inkscape:window-x="1965"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1" />
+  <metadata
+     id="metadata1037">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(2.9219487,-8.5995374)">
+    <path
+       style="fill:#150458;fill-opacity:1;stroke-width:0.20233451"
+       d="M 37.270955,98.335591 C 33.358064,97.07991 31.237736,92.52319 32.964256,89.08022 c 0.18139,-0.361738 4.757999,-5.096629 10.17021,-10.521968 l 9.84041,-9.864254 -4.03738,-4.041175 -4.037391,-4.041172 -4.96415,4.916665 c -3.61569,3.581096 -5.238959,5.04997 -5.975818,5.407377 l -1.011682,0.490718 H 17.267525 1.5866055 L 0.65034544,70.96512 C -2.2506745,69.535833 -3.5952145,66.18561 -2.5925745,62.884631 c 0.53525,-1.762217 1.61699004,-3.050074 3.22528014,-3.839847 l 1.15623996,-0.56778 13.2591094,-0.05613 13.259111,-0.05613 11.5262,-11.527539 11.526199,-11.527528 H 40.622647 c -12.145542,0 -12.189222,-0.0046 -13.752801,-1.445851 -2.229871,-2.055423 -2.162799,-5.970551 0.135998,-7.938238 1.475193,-1.262712 1.111351,-1.238469 18.588522,-1.238469 12.899229,0 16.035311,0.05193 16.692589,0.276494 0.641832,0.219264 2.590731,2.051402 9.416301,8.852134 l 8.606941,8.575638 h 6.848168 c 4.837422,0 7.092281,0.07311 7.679571,0.249094 0.48064,0.144008 1.22985,0.634863 1.77578,1.163429 2.383085,2.307333 1.968685,6.539886 -0.804989,8.221882 -0.571871,0.346781 -1.38284,0.687226 -1.80217,0.756523 -0.41933,0.06928 -4.2741,0.127016 -8.56615,0.128238 -6.56998,0.0016 -7.977492,-0.04901 -8.902732,-0.321921 -0.975569,-0.287742 -1.400468,-0.622236 -3.783999,-2.978832 l -2.685021,-2.654679 -5.05411,5.051071 -5.0541,5.051081 3.926292,3.947202 c 2.365399,2.378001 4.114289,4.309171 4.399158,4.857713 0.39266,0.75606 0.47311,1.219412 0.474321,2.731516 0.003,3.083647 0.620779,2.331942 -13.598011,16.531349 -10.273768,10.259761 -12.679778,12.563171 -13.500979,12.92519 -1.267042,0.55857 -3.156169,0.681342 -4.390271,0.285321 z m 40.130741,-65.45839 c -2.212909,-0.579748 -3.782711,-1.498393 -5.51275,-3.226063 -2.522111,-2.518633 -3.633121,-5.181304 -3.633121,-8.707194 0,-3.530699 1.11238,-6.197124 3.631161,-8.704043 4.866751,-4.8438383 12.324781,-4.8550953 17.211791,-0.026 3.908758,3.862461 4.818578,9.377999 2.372188,14.380771 -0.846209,1.730481 -3.39493,4.326384 -5.143839,5.239072 -2.69708,1.407492 -6.042829,1.798628 -8.92543,1.043434 z"
+       id="path1000"
+       inkscape:connector-curvature="0" />
+  </g>
+</svg>
diff --git a/doc/source/_static/index_user_guide.svg b/doc/source/_static/index_user_guide.svg
new file mode 100644
index 0000000000000..a567103af5918
--- /dev/null
+++ b/doc/source/_static/index_user_guide.svg
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="123.72241mm"
+   height="89.96759mm"
+   viewBox="0 0 123.72242 89.96759"
+   version="1.1"
+   id="svg1040"
+   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+   sodipodi:docname="index_userguide.svg">
+  <defs
+     id="defs1034" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.35"
+     inkscape:cx="332.26618"
+     inkscape:cy="83.744004"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:window-width="930"
+     inkscape:window-height="472"
+     inkscape:window-x="2349"
+     inkscape:window-y="267"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata1037">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(141.8903,-20.32143)">
+    <path
+       style="fill:#150458;fill-opacity:1;stroke-width:0.20483544"
+       d="m -139.53374,110.1657 c -0.80428,-0.24884 -1.71513,-1.11296 -2.07107,-1.96486 -0.23905,-0.57214 -0.28453,-6.28104 -0.28453,-35.720988 0,-38.274546 -0.079,-35.840728 1.19849,-36.91568 0.58869,-0.495345 4.63766,-2.187548 8.47998,-3.544073 l 1.58749,-0.560453 v -3.309822 c 0,-3.025538 0.0396,-3.388179 0.46086,-4.222122 0.68808,-1.362003 1.38671,-1.714455 4.60319,-2.322195 4.12797,-0.779966 5.13304,-0.912766 8.81544,-1.16476 11.80964,-0.808168 22.80911,2.509277 30.965439,9.3392 1.750401,1.465747 3.840861,3.5635 5.0903,5.108065 l 0.659122,0.814805 0.659109,-0.814805 c 1.249431,-1.544565 3.33988,-3.642318 5.09029,-5.108065 8.156331,-6.829923 19.155791,-10.147368 30.965441,-9.3392 3.682389,0.251994 4.68748,0.384794 8.81544,1.16476 3.21647,0.60774 3.91511,0.960192 4.60318,2.322195 0.4213,0.833943 0.46087,1.196584 0.46087,4.222122 v 3.309822 l 1.58748,0.560453 c 4.10165,1.448077 7.98852,3.072753 8.5259,3.563743 1.22643,1.120567 1.15258,-1.245868 1.15258,36.927177 0,34.567591 -0.005,35.083151 -0.40663,35.903991 -0.22365,0.45804 -0.73729,1.05665 -1.14143,1.33024 -1.22281,0.82783 -2.17721,0.70485 -5.86813,-0.7561 -9.19595,-3.63998 -18.956011,-6.38443 -26.791332,-7.53353 -3.02827,-0.44412 -9.26189,-0.61543 -11.77821,-0.3237 -5.19357,0.60212 -8.736108,2.05527 -11.700039,4.79936 -0.684501,0.63371 -1.466141,1.23646 -1.736979,1.33942 -0.63859,0.2428 -4.236521,0.2428 -4.875112,0 -0.27083,-0.10296 -1.05247,-0.70571 -1.73696,-1.33942 -2.96395,-2.74409 -6.50648,-4.19724 -11.700058,-4.79936 -2.516312,-0.29173 -8.749941,-0.12042 -11.778201,0.3237 -7.78194,1.14127 -17.39965,3.83907 -26.73341,7.49883 -3.38325,1.32658 -4.15525,1.50926 -5.11851,1.21125 z m 4.2107,-5.34052 c 5.86759,-2.29858 14.40398,-4.922695 20.2018,-6.210065 6.31584,-1.402418 8.5236,-1.646248 14.91592,-1.647338 4.68699,-7.94e-4 6.013661,0.0632 7.257809,0.3497 0.837332,0.19286 1.561052,0.312028 1.60828,0.264819 0.147111,-0.147119 -1.803289,-1.307431 -4.154879,-2.471801 -8.12511,-4.023029 -18.27311,-4.986568 -29.0861,-2.761718 -1.09536,0.22538 -2.32708,0.40827 -2.73715,0.406418 -1.12787,-0.005 -2.3054,-0.76382 -2.84516,-1.8332 l -0.46086,-0.913098 V 62.99179 35.97471 l -0.56331,0.138329 c -0.30981,0.07608 -1.89985,0.665075 -3.5334,1.308881 -2.27551,0.896801 -2.96414,1.252878 -2.94452,1.522563 0.014,0.193604 0.0372,15.284513 0.0512,33.535345 0.014,18.250839 0.0538,33.183322 0.0884,33.183322 0.0346,0 1.02543,-0.3771 2.20198,-0.83801 z m 113.006991,-32.697216 -0.0518,-33.535203 -3.17495,-1.272156 c -1.74623,-0.699685 -3.33627,-1.278755 -3.53341,-1.286819 -0.33966,-0.01389 -0.35847,1.401778 -0.35847,26.980216 v 26.994863 l -0.46087,0.913112 c -0.53976,1.06939 -1.71729,1.828088 -2.84515,1.833189 -0.41008,0.0021 -1.6418,-0.181031 -2.73716,-0.406421 -11.888201,-2.446089 -22.84337,-1.046438 -31.491022,4.02332 -1.68175,0.985941 -2.216748,1.467501 -1.36534,1.228942 1.575181,-0.441362 4.990592,-0.73864 8.524862,-0.742011 5.954408,-0.005 11.43046,0.791951 19.10874,2.78333 3.9516,1.024874 12.1555,3.687454 15.6699,5.085704 1.23926,0.49306 2.36869,0.90517 2.50985,0.9158 0.20489,0.0155 0.2462,-6.745894 0.20483,-33.515866 z m -59.76135,-2.233777 V 40.065438 l -0.95972,-1.357442 c -1.380522,-1.952627 -5.376262,-5.847994 -7.64336,-7.45136 -3.778692,-2.672401 -9.063392,-4.943324 -13.672511,-5.875304 -3.19731,-0.646503 -5.23069,-0.833103 -9.05886,-0.831312 -4.37716,0.0021 -7.70223,0.349169 -11.83461,1.235469 l -1.07538,0.230645 v 31.242342 c 0,26.565778 0.0426,31.226011 0.28429,31.133261 0.15637,-0.06 1.42379,-0.297169 2.81648,-0.527026 12.37657,-2.042634 23.21658,-0.346861 32.521639,5.087596 2.10018,1.226558 5.20202,3.618878 6.880942,5.30692 0.788609,0.792909 1.502978,1.446609 1.587468,1.452679 0.0845,0.006 0.153622,-13.411893 0.153622,-29.817719 z m 5.80221,28.3766 c 6.21476,-6.141601 15.08488,-10.061509 25.025529,-11.05933 4.262419,-0.427849 11.579921,-0.0054 16.017661,0.924912 0.75932,0.15916 1.45259,0.244888 1.54058,0.190498 0.088,-0.05434 0.16003,-14.060382 0.16003,-31.124436 V 26.176883 l -0.52136,-0.198219 c -0.66893,-0.254325 -4.77649,-0.95482 -7.159981,-1.221048 -2.41372,-0.269605 -8.559851,-0.266589 -10.759229,0.0052 -6.458111,0.798299 -12.584091,3.083792 -17.405651,6.49374 -2.267091,1.603366 -6.262831,5.498733 -7.64336,7.45136 l -0.959721,1.357438 v 29.828747 c 0,16.405812 0.0532,29.828746 0.11802,29.828746 0.065,0 0.77928,-0.65347 1.587482,-1.452149 z"
+       id="path845"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="csscccscsssscsssssscscsccsccsccscsscccccccscccccccccsccscscscccscccsccssccsscccscccccsccccsccscsccsscc" />
+  </g>
+</svg>
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 1da1948e45268..c12c148d0f10d 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -10,6 +10,7 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
+from datetime import datetime
 import importlib
 import inspect
 import logging
@@ -120,6 +121,9 @@
 plot_pre_code = """import numpy as np
 import pandas as pd"""
 
+# nbsphinx do not use requirejs (breaks bootstrap)
+nbsphinx_requirejs_path = ""
+
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["../_templates"]
 
@@ -134,7 +138,7 @@
 
 # General information about the project.
 project = "pandas"
-copyright = "2008-2014, the pandas development team"
+copyright = f"2008-{datetime.now().year}, the pandas development team"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -191,7 +195,7 @@
 
 # The theme to use for HTML and HTML Help pages.  Major themes that come with
 # Sphinx are currently 'default' and 'sphinxdoc'.
-html_theme = "nature_with_gtoc"
+html_theme = "pandas_sphinx_theme"
 
 # The style sheet to use for HTML and HTML Help pages. A file of that name
 # must exist either in Sphinx' static/ path, or in one of the custom paths
@@ -201,10 +205,15 @@
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-# html_theme_options = {}
+html_theme_options = {
+    "external_links": [],
+    "github_url": "https://github.com/pandas-dev/pandas",
+    "twitter_url": "https://twitter.com/pandas_dev",
+    "google_analytics_id": "UA-27880019-2",
+}
 
 # Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ["themes"]
+# html_theme_path = ["themes"]
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
@@ -215,17 +224,21 @@
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-# html_logo = None
+html_logo = "../../web/pandas/static/img/pandas.svg"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ["_static"]
 
+html_css_files = [
+    "css/pandas.css",
+]
+
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = os.path.join(html_static_path[0], "favicon.ico")
+html_favicon = "../../web/pandas/static/img/favicon.ico"
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
@@ -293,12 +306,7 @@
 
     for method in methods:
         # ... and each of its public methods
-        moved_api_pages.append(
-            (
-                "{old}.{method}".format(old=old, method=method),
-                "{new}.{method}".format(new=new, method=method),
-            )
-        )
+        moved_api_pages.append((f"{old}.{method}", f"{new}.{method}",))
 
 if pattern is None:
     html_additional_pages = {
@@ -306,7 +314,7 @@
     }
 
 
-header = """\
+header = f"""\
 .. currentmodule:: pandas
 
 .. ipython:: python
@@ -320,10 +328,8 @@
    pd.options.display.max_rows = 15
 
    import os
-   os.chdir(r'{}')
-""".format(
-    os.path.dirname(os.path.dirname(__file__))
-)
+   os.chdir(r'{os.path.dirname(os.path.dirname(__file__))}')
+"""
 
 
 html_context = {
@@ -375,7 +381,7 @@
         "index",
         "pandas.tex",
         "pandas: powerful Python data analysis toolkit",
-        r"Wes McKinney\n\& PyData Development Team",
+        "Wes McKinney and the Pandas Development Team",
         "manual",
     )
 ]
@@ -407,7 +413,7 @@
         "py": ("https://pylib.readthedocs.io/en/latest/", None),
         "python": ("https://docs.python.org/3/", None),
         "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None),
-        "statsmodels": ("http://www.statsmodels.org/devel/", None),
+        "statsmodels": ("https://www.statsmodels.org/devel/", None),
     }
 
 # extlinks alias
@@ -572,7 +578,7 @@ def _add_deprecation_prefixes(self, items):
         for item in items:
             display_name, sig, summary, real_name = item
             if self._is_deprecated(real_name):
-                summary = "(DEPRECATED) %s" % summary
+                summary = f"(DEPRECATED) {summary}"
             yield display_name, sig, summary, real_name
 
     def get_items(self, names):
@@ -605,11 +611,7 @@ def linkcode_resolve(domain, info):
             return None
 
     try:
-        # inspect.unwrap() was added in Python version 3.4
-        if sys.version_info >= (3, 5):
-            fn = inspect.getsourcefile(inspect.unwrap(obj))
-        else:
-            fn = inspect.getsourcefile(obj)
+        fn = inspect.getsourcefile(inspect.unwrap(obj))
     except TypeError:
         fn = None
     if not fn:
@@ -621,19 +623,18 @@ def linkcode_resolve(domain, info):
         lineno = None
 
     if lineno:
-        linespec = "#L{:d}-L{:d}".format(lineno, lineno + len(source) - 1)
+        linespec = f"#L{lineno}-L{lineno + len(source) - 1}"
     else:
         linespec = ""
 
     fn = os.path.relpath(fn, start=os.path.dirname(pandas.__file__))
 
     if "+" in pandas.__version__:
-        return "http://github.com/pandas-dev/pandas/blob/master/pandas/" "{}{}".format(
-            fn, linespec
-        )
+        return f"https://github.com/pandas-dev/pandas/blob/master/pandas/{fn}{linespec}"
     else:
-        return "http://github.com/pandas-dev/pandas/blob/" "v{}/pandas/{}{}".format(
-            pandas.__version__, fn, linespec
+        return (
+            f"https://github.com/pandas-dev/pandas/blob/"
+            f"v{pandas.__version__}/pandas/{fn}{linespec}"
         )
 
 
@@ -699,7 +700,7 @@ def rstjinja(app, docname, source):
     """
     Render our pages as a jinja template for fancy templating goodness.
     """
-    # http://ericholscher.com/blog/2016/jul/25/integrating-jinja-rst-sphinx/
+    # https://www.ericholscher.com/blog/2016/jul/25/integrating-jinja-rst-sphinx/
     # Make sure we're outputting HTML
     if app.builder.format != "html":
         return
diff --git a/doc/source/development/code_style.rst b/doc/source/development/code_style.rst
new file mode 100644
index 0000000000000..bcddc033a61f5
--- /dev/null
+++ b/doc/source/development/code_style.rst
@@ -0,0 +1,155 @@
+.. _code_style:
+
+{{ header }}
+
+=======================
+pandas code style guide
+=======================
+
+.. contents:: Table of contents:
+   :local:
+
+Patterns
+========
+
+foo.__class__
+-------------
+
+*pandas* uses 'type(foo)' instead 'foo.__class__' as it is making the code more
+readable.
+
+For example:
+
+**Good:**
+
+.. code-block:: python
+
+    foo = "bar"
+    type(foo)
+
+**Bad:**
+
+.. code-block:: python
+
+    foo = "bar"
+    foo.__class__
+
+
+String formatting
+=================
+
+Concatenated strings
+--------------------
+
+f-strings
+~~~~~~~~~
+
+*pandas* uses f-strings formatting instead of '%' and '.format()' string formatters.
+
+The convention of using f-strings on a string that is concatenated over serveral lines,
+is to prefix only the lines containing the value needs to be interpeted.
+
+For example:
+
+**Good:**
+
+.. code-block:: python
+
+    foo = "old_function"
+    bar = "new_function"
+
+    my_warning_message = (
+        f"Warning, {foo} is deprecated, "
+        "please use the new and way better "
+        f"{bar}"
+    )
+
+**Bad:**
+
+.. code-block:: python
+
+    foo = "old_function"
+    bar = "new_function"
+
+    my_warning_message = (
+        f"Warning, {foo} is deprecated, "
+        f"please use the new and way better "
+        f"{bar}"
+    )
+
+White spaces
+~~~~~~~~~~~~
+
+Putting the white space only at the end of the previous line, so
+there is no whitespace at the beggining of the concatenated string.
+
+For example:
+
+**Good:**
+
+.. code-block:: python
+
+    example_string = (
+        "Some long concatenated string, "
+        "with good placement of the "
+        "whitespaces"
+    )
+
+**Bad:**
+
+.. code-block:: python
+
+    example_string = (
+        "Some long concatenated string,"
+        " with bad placement of the"
+        " whitespaces"
+    )
+
+Representation function (aka 'repr()')
+--------------------------------------
+
+*pandas* uses 'repr()' instead of '%r' and '!r'.
+
+The use of 'repr()' will only happend when the value is not an obvious string.
+
+For example:
+
+**Good:**
+
+.. code-block:: python
+
+    value = str
+    f"Unknown received value, got: {repr(value)}"
+
+**Good:**
+
+.. code-block:: python
+
+    value = str
+    f"Unknown received type, got: '{type(value).__name__}'"
+
+
+Imports (aim for absolute)
+==========================
+
+In Python 3, absolute imports are recommended. In absolute import doing something
+like ``import string`` will import the string module rather than ``string.py``
+in the same directory. As much as possible, you should try to write out
+absolute imports that show the whole import chain from top-level pandas.
+
+Explicit relative imports are also supported in Python 3 but it is not
+recommended to use them. Implicit relative imports should never be used
+and are removed in Python 3.
+
+For example:
+
+::
+
+    # preferred
+    import pandas.core.common as com
+
+    # not preferred
+    from .common import test_base
+
+    # wrong
+    from common import test_base
diff --git a/doc/source/development/contributing.rst b/doc/source/development/contributing.rst
index 3cdf9b83e96f3..f904781178656 100644
--- a/doc/source/development/contributing.rst
+++ b/doc/source/development/contributing.rst
@@ -24,6 +24,27 @@ and `good first issue
 where you could start out. Once you've found an interesting issue, you can
 return here to get your development environment setup.
 
+When you start working on an issue, it's a good idea to assign the issue to yourself,
+so nobody else duplicates the work on it. GitHub restricts assigning issues to maintainers
+of the project only. In most projects, and until recently in pandas, contributors added a
+comment letting others know they are working on an issue. While this is ok, you need to
+check each issue individually, and it's not possible to find the unassigned ones.
+
+For this reason, we implemented a workaround consisting of adding a comment with the exact
+text `take`. When you do it, a GitHub action will automatically assign you the issue
+(this will take seconds, and may require refreshing the page to see it).
+By doing this, it's possible to filter the list of issues and find only the unassigned ones.
+
+So, a good way to find an issue to start contributing to pandas is to check the list of
+`unassigned good first issues <https://github.com/pandas-dev/pandas/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+no%3Aassignee>`_
+and assign yourself one you like by writing a comment with the exact text `take`.
+
+If for whatever reason you are not able to continue working with the issue, please try to
+unassign it, so other people know it's available again. You can check the list of
+assigned issues, since people may not be working in them anymore. If you want to work on one
+that is assigned, feel free to kindly ask the current assignee if you can take it
+(please allow at least a week of inactivity before considering work in the issue discontinued).
+
 Feel free to ask questions on the `mailing list
 <https://groups.google.com/forum/?fromgroups#!forum/pydata>`_ or on `Gitter`_.
 
@@ -35,7 +56,7 @@ Bug reports and enhancement requests
 Bug reports are an important part of making *pandas* more stable. Having a complete bug report
 will allow others to reproduce the bug and provide insight into fixing. See
 `this stackoverflow article <https://stackoverflow.com/help/mcve>`_ and
-`this blogpost <http://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports>`_
+`this blogpost <https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports>`_
 for tips on writing a good bug report.
 
 Trying the bug-producing code out on the *master* branch is often a worthwhile exercise
@@ -46,7 +67,7 @@ Bug reports must:
 
 #. Include a short, self-contained Python snippet reproducing the problem.
    You can format the code nicely by using `GitHub Flavored Markdown
-   <http://github.github.com/github-flavored-markdown/>`_::
+   <https://github.github.com/github-flavored-markdown/>`_::
 
       ```python
       >>> from pandas import DataFrame
@@ -83,19 +104,19 @@ feel free to ask for help.
 
 The code is hosted on `GitHub <https://www.github.com/pandas-dev/pandas>`_. To
 contribute you will need to sign up for a `free GitHub account
-<https://github.com/signup/free>`_. We use `Git <http://git-scm.com/>`_ for
+<https://github.com/signup/free>`_. We use `Git <https://git-scm.com/>`_ for
 version control to allow many people to work together on the project.
 
 Some great resources for learning Git:
 
-* the `GitHub help pages <http://help.github.com/>`_.
-* the `NumPy's documentation <http://docs.scipy.org/doc/numpy/dev/index.html>`_.
-* Matthew Brett's `Pydagogue <http://matthew-brett.github.com/pydagogue/>`_.
+* the `GitHub help pages <https://help.github.com/>`_.
+* the `NumPy's documentation <https://docs.scipy.org/doc/numpy/dev/index.html>`_.
+* Matthew Brett's `Pydagogue <https://matthew-brett.github.com/pydagogue/>`_.
 
 Getting started with Git
 ------------------------
 
-`GitHub has instructions <http://help.github.com/set-up-git-redirect>`__ for installing git,
+`GitHub has instructions <https://help.github.com/set-up-git-redirect>`__ for installing git,
 setting up your SSH key, and configuring git.  All these steps need to be completed before
 you can work seamlessly between your local repository and GitHub.
 
@@ -125,6 +146,17 @@ requires a C compiler and Python environment. If you're making documentation
 changes, you can skip to :ref:`contributing.documentation` but you won't be able
 to build the documentation locally before pushing your changes.
 
+Using a Docker Container
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Instead of manually setting up a development environment, you can use Docker to
+automatically create the environment with just several commands. Pandas provides a `DockerFile`
+in the root directory to build a Docker image with a full pandas development environment.
+
+Even easier, you can use the DockerFile to launch a remote session with Visual Studio Code,
+a popular free IDE, using the `.devcontainer.json` file.
+See https://code.visualstudio.com/docs/remote/containers for details.
+
 .. _contributing.dev_c:
 
 Installing a C compiler
@@ -172,7 +204,7 @@ installed (or you wish to install a newer version) you can install a compiler
     yum groupinstall "Development Tools"
 
 For other Linux distributions, consult your favourite search engine for
-commpiler installation instructions.
+compiler installation instructions.
 
 Let us know if you have any difficulties by opening an issue or reaching out on
 `Gitter`_.
@@ -208,7 +240,7 @@ We'll now kick off a three-step process:
 
    # Build and install pandas
    python setup.py build_ext --inplace -j 4
-   python -m pip install -e . --no-build-isolation
+   python -m pip install -e . --no-build-isolation --no-use-pep517
 
 At this point you should be able to import pandas from your locally built version::
 
@@ -228,7 +260,7 @@ To return to your root environment::
 
       conda deactivate
 
-See the full conda docs `here <http://conda.pydata.org/docs>`__.
+See the full conda docs `here <https://conda.pydata.org/docs>`__.
 
 .. _contributing.pip:
 
@@ -236,14 +268,17 @@ Creating a Python environment (pip)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If you aren't using conda for your development environment, follow these instructions.
-You'll need to have at least python3.5 installed on your system.
+You'll need to have at least Python 3.6.1 installed on your system.
 
-.. code-block:: none
+**Unix**/**Mac OS**
+
+.. code-block:: bash
 
    # Create a virtual environment
    # Use an ENV_DIR of your choice. We'll use ~/virtualenvs/pandas-dev
    # Any parent directories should already exist
    python3 -m venv ~/virtualenvs/pandas-dev
+
    # Activate the virtualenv
    . ~/virtualenvs/pandas-dev/bin/activate
 
@@ -251,8 +286,34 @@ You'll need to have at least python3.5 installed on your system.
    python -m pip install -r requirements-dev.txt
 
    # Build and install pandas
-   python setup.py build_ext --inplace -j 4
-   python -m pip install -e . --no-build-isolation
+   python setup.py build_ext --inplace -j 0
+   python -m pip install -e . --no-build-isolation --no-use-pep517
+
+**Windows**
+
+Below is a brief overview on how to set-up a virtual environment with Powershell
+under Windows. For details please refer to the
+`official virtualenv user guide <https://virtualenv.pypa.io/en/stable/userguide/#activate-script>`__
+
+Use an ENV_DIR of your choice. We'll use ~\virtualenvs\pandas-dev where
+'~' is the folder pointed to by either $env:USERPROFILE (Powershell) or
+%USERPROFILE% (cmd.exe) environment variable. Any parent directories
+should already exist.
+
+.. code-block:: powershell
+
+   # Create a virtual environment
+   python -m venv $env:USERPROFILE\virtualenvs\pandas-dev
+
+   # Activate the virtualenv. Use activate.bat for cmd.exe
+   ~\virtualenvs\pandas-dev\Scripts\Activate.ps1
+
+   # Install the build dependencies
+   python -m pip install -r requirements-dev.txt
+
+   # Build and install pandas
+   python setup.py build_ext --inplace -j 0
+   python -m pip install -e . --no-build-isolation --no-use-pep517
 
 Creating a branch
 -----------------
@@ -304,9 +365,9 @@ About the *pandas* documentation
 --------------------------------
 
 The documentation is written in **reStructuredText**, which is almost like writing
-in plain English, and built using `Sphinx <http://sphinx.pocoo.org/>`__. The
+in plain English, and built using `Sphinx <https://www.sphinx-doc.org/en/master/>`__. The
 Sphinx Documentation has an excellent `introduction to reST
-<http://sphinx.pocoo.org/rest.html>`__. Review the Sphinx docs to perform more
+<https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html>`__. Review the Sphinx docs to perform more
 complex changes to the documentation as well.
 
 Some other important things to know about the docs:
@@ -329,7 +390,7 @@ Some other important things to know about the docs:
      contributing_docstring.rst
 
 * The tutorials make heavy use of the `ipython directive
-  <http://matplotlib.org/sampledoc/ipython_directive.html>`_ sphinx extension.
+  <https://matplotlib.org/sampledoc/ipython_directive.html>`_ sphinx extension.
   This directive lets you put code in the documentation which will be run
   during the doc build. For example::
 
@@ -349,7 +410,7 @@ Some other important things to know about the docs:
   doc build. This approach means that code examples will always be up to date,
   but it does make the doc building a bit more complex.
 
-* Our API documentation in ``doc/source/api.rst`` houses the auto-generated
+* Our API documentation files in ``doc/source/reference`` house the auto-generated
   documentation from the docstrings. For classes, there are a few subtleties
   around controlling which methods and attributes have pages auto-generated.
 
@@ -367,7 +428,8 @@ Some other important things to know about the docs:
      ``Methods`` section in the class docstring. See ``CategoricalIndex`` for an
      example.
 
-  Every method should be included in a ``toctree`` in ``api.rst``, else Sphinx
+  Every method should be included in a ``toctree`` in one of the documentation files in
+  ``doc/source/reference``, else Sphinx
   will emit a warning.
 
 .. note::
@@ -375,7 +437,7 @@ Some other important things to know about the docs:
     The ``.rst`` files are used to automatically generate Markdown and HTML versions
     of the docs. For this reason, please do not edit ``CONTRIBUTING.md`` directly,
     but instead make any changes to ``doc/source/development/contributing.rst``. Then, to
-    generate ``CONTRIBUTING.md``, use `pandoc <http://johnmacfarlane.net/pandoc/>`_
+    generate ``CONTRIBUTING.md``, use `pandoc <https://johnmacfarlane.net/pandoc/>`_
     with the following command::
 
       pandoc doc/source/development/contributing.rst -t markdown_github > CONTRIBUTING.md
@@ -383,11 +445,11 @@ Some other important things to know about the docs:
 The utility script ``scripts/validate_docstrings.py`` can be used to get a csv
 summary of the API documentation. And also validate common errors in the docstring
 of a specific class, function or method. The summary also compares the list of
-methods documented in ``doc/source/api.rst`` (which is used to generate
-the `API Reference <http://pandas.pydata.org/pandas-docs/stable/api.html>`_ page)
+methods documented in the files in ``doc/source/reference`` (which is used to generate
+the `API Reference <https://pandas.pydata.org/pandas-docs/stable/api.html>`_ page)
 and the actual public methods.
-This will identify methods documented in ``doc/source/api.rst`` that are not actually
-class methods, and existing methods that are not documented in ``doc/source/api.rst``.
+This will identify methods documented in ``doc/source/reference`` that are not actually
+class methods, and existing methods that are not documented in ``doc/source/reference``.
 
 
 Updating a *pandas* docstring
@@ -453,7 +515,7 @@ reducing the turn-around time for checking your changes.
     python make.py --no-api
 
     # compile the docs with only a single section, relative to the "source" folder.
-    # For example, compiling only this guide (docs/source/development/contributing.rst)
+    # For example, compiling only this guide (doc/source/development/contributing.rst)
     python make.py clean
     python make.py --single development/contributing.rst
 
@@ -519,8 +581,7 @@ do not make sudden changes to the code that could have the potential to break
 a lot of user code as a result, that is, we need it to be as *backwards compatible*
 as possible to avoid mass breakages.
 
-Additional standards are outlined on the `code style wiki
-page <https://github.com/pandas-dev/pandas/wiki/Code-Style-and-Conventions>`_.
+Additional standards are outlined on the `pandas code style guide <code_style>`_
 
 Optional dependencies
 ---------------------
@@ -560,8 +621,8 @@ You can also run this command on an entire directory if necessary::
    cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir --recursive modified-c-directory
 
 To make your commits compliant with this standard, you can install the
-`ClangFormat <http://clang.llvm.org/docs/ClangFormat.html>`_ tool, which can be
-downloaded `here <http://llvm.org/builds/>`__. To configure, in your home directory,
+`ClangFormat <https://clang.llvm.org/docs/ClangFormat.html>`_ tool, which can be
+downloaded `here <https://llvm.org/builds/>`__. To configure, in your home directory,
 run the following command::
 
     clang-format style=google -dump-config  > .clang-format
@@ -586,10 +647,12 @@ many errors as possible, but it may not correct *all* of them. Thus, it is
 recommended that you run ``cpplint`` to double check and make any other style
 fixes manually.
 
+.. _contributing.code-formatting:
+
 Python (PEP8 / black)
 ~~~~~~~~~~~~~~~~~~~~~
 
-*pandas* follows the `PEP8 <http://www.python.org/dev/peps/pep-0008/>`_ standard
+*pandas* follows the `PEP8 <https://www.python.org/dev/peps/pep-0008/>`_ standard
 and uses `Black <https://black.readthedocs.io/en/stable/>`_ and
 `Flake8 <http://flake8.pycqa.org/en/latest/>`_ to ensure a consistent code
 format throughout the project.
@@ -604,26 +667,19 @@ submitting code to run the check yourself::
 to auto-format your code. Additionally, many editors have plugins that will
 apply ``black`` as you edit files.
 
-Optionally, you may wish to setup `pre-commit hooks <https://pre-commit.com/>`_
-to automatically run ``black`` and ``flake8`` when you make a git commit. This
-can be done by installing ``pre-commit``::
-
-   pip install pre-commit
+You should use a ``black`` version >= 19.10b0 as previous versions are not compatible
+with the pandas codebase.
 
-and then running::
-
-   pre-commit install
+If you wish to run these checks automatically, we encourage you to use
+:ref:`pre-commits <contributing.pre-commit>` instead.
 
-from the root of the pandas repository. Now ``black`` and ``flake8`` will be run
-each time you commit changes. You can skip these checks with
-``git commit --no-verify``.
-
-This command will catch any stylistic errors in your changes specifically, but
+One caveat about ``git diff upstream/master -u -- "*.py" | flake8 --diff``: this
+command will catch any stylistic errors in your changes specifically, but
 be beware it may not catch all of them. For example, if you delete the only
 usage of an imported function, it is stylistically incorrect to import an
 unused function. However, style-checking the diff will not catch this because
 the actual import is not part of the diff. Thus, for completeness, you should
-run this command, though it will take longer::
+run this command, though it may take longer::
 
    git diff upstream/master --name-only -- "*.py" | xargs -r flake8
 
@@ -641,6 +697,8 @@ behaviour as follows::
 This will get all the files being changed by the PR (and ending with ``.py``),
 and run ``flake8`` on them, one after the other.
 
+Note that these commands can be run analogously with ``black``.
+
 .. _contributing.import-formatting:
 
 Import formatting
@@ -663,7 +721,6 @@ A summary of our current import sections ( in order ):
 
 Imports are alphabetically sorted within these sections.
 
-
 As part of :ref:`Continuous Integration <contributing.ci>` checks we run::
 
     isort --recursive --check-only pandas
@@ -687,8 +744,37 @@ to automatically format imports correctly. This will modify your local copy of t
 
 The `--recursive` flag can be passed to sort all files in a directory.
 
+Alternatively, you can run a command similar to what was suggested for ``black`` and ``flake8`` :ref:`right above <contributing.code-formatting>`::
+
+    git diff upstream/master --name-only -- "*.py" | xargs -r isort
+
+Where similar caveats apply if you are on OSX or Windows.
+
 You can then verify the changes look ok, then git :ref:`commit <contributing.commit-code>` and :ref:`push <contributing.push-code>`.
 
+.. _contributing.pre-commit:
+
+Pre-Commit
+~~~~~~~~~~
+
+You can run many of these styling checks manually as we have described above. However,
+we encourage you to use `pre-commit hooks <https://pre-commit.com/>`_ instead
+to automatically run ``black``, ``flake8``, ``isort`` when you make a git commit. This
+can be done by installing ``pre-commit``::
+
+    pip install pre-commit
+
+and then running::
+
+    pre-commit install
+
+from the root of the pandas repository. Now all of the styling checks will be
+run each time you commit changes without your needing to run each one manually.
+In addition, using this pre-commit hook will also allow you to more easily
+remain up-to-date with our code checks as they change.
+
+Note that if needed, you can skip these checks with ``git commit --no-verify``.
+
 Backwards compatibility
 ~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -750,7 +836,7 @@ Types imports should follow the ``from typing import ...`` convention. So rather
 
    import typing
 
-   primes = []  # type: typing.List[int]
+   primes: typing.List[int] = []
 
 You should write
 
@@ -758,19 +844,19 @@ You should write
 
    from typing import List, Optional, Union
 
-   primes = []  # type: List[int]
+   primes: List[int] = []
 
 ``Optional`` should be used where applicable, so instead of
 
 .. code-block:: python
 
-   maybe_primes = []  # type: List[Union[int, None]]
+   maybe_primes: List[Union[int, None]] = []
 
 You should write
 
 .. code-block:: python
 
-   maybe_primes = []  # type: List[Optional[int]]
+   maybe_primes: List[Optional[int]] = []
 
 In some cases in the code base classes may define class variables that shadow builtins. This causes an issue as described in `Mypy 1775 <https://github.com/python/mypy/issues/1775#issuecomment-310969854>`_. The defensive solution here is to create an unambiguous alias of the builtin and use that without your annotation. For example, if you come across a definition like
 
@@ -786,7 +872,7 @@ The appropriate way to annotate this would be as follows
    str_type = str
 
    class SomeClass2:
-       str = None  # type: str_type
+       str: str_type = None
 
 In some cases you may be tempted to use ``cast`` from the typing module when you know better than the analyzer. This occurs particularly when using custom inference functions. For example
 
@@ -817,29 +903,6 @@ The limitation here is that while a human can reasonably understand that ``is_nu
 
 With custom types and inference this is not always possible so exceptions are made, but every effort should be exhausted to avoid ``cast`` before going down such paths.
 
-Syntax Requirements
-~~~~~~~~~~~~~~~~~~~
-
-Because *pandas* still supports Python 3.5, :pep:`526` does not apply and variables **must** be annotated with type comments. Specifically, this is a valid annotation within pandas:
-
-.. code-block:: python
-
-   primes = []  # type: List[int]
-
-Whereas this is **NOT** allowed:
-
-.. code-block:: python
-
-   primes: List[int] = []  # not supported in Python 3.5!
-
-Note that function signatures can always be annotated per :pep:`3107`:
-
-.. code-block:: python
-
-   def sum_of_primes(primes: List[int] = []) -> int:
-       ...
-
-
 Pandas-specific Types
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -909,13 +972,13 @@ Adding tests is one of the most common requests after code is pushed to *pandas*
 it is worth getting in the habit of writing tests ahead of time so this is never an issue.
 
 Like many packages, *pandas* uses `pytest
-<http://docs.pytest.org/en/latest/>`_ and the convenient
+<https://docs.pytest.org/en/latest/>`_ and the convenient
 extensions in `numpy.testing
-<http://docs.scipy.org/doc/numpy/reference/routines.testing.html>`_.
+<https://docs.scipy.org/doc/numpy/reference/routines.testing.html>`_.
 
 .. note::
 
-   The earliest supported pytest version is 4.0.2.
+   The earliest supported pytest version is 5.0.1.
 
 Writing tests
 ~~~~~~~~~~~~~
@@ -926,7 +989,7 @@ inspiration.  If your test requires working with files or
 network connectivity, there is more information on the `testing page
 <https://github.com/pandas-dev/pandas/wiki/Testing>`_ of the wiki.
 
-The ``pandas.util.testing`` module has many special ``assert`` functions that
+The ``pandas._testing`` module has many special ``assert`` functions that
 make it easier to make statements about whether Series or DataFrame objects are
 equivalent. The easiest way to verify that your code is correct is to
 explicitly construct the result you expect, then compare the actual result to
@@ -949,17 +1012,20 @@ the expected correct result::
 
         assert_frame_equal(pivoted, expected)
 
+Please remember to add the Github Issue Number as a comment to a new test.
+E.g. "# brief comment, see GH#28907"
+
 Transitioning to ``pytest``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-*pandas* existing test structure is *mostly* classed based, meaning that you will typically find tests wrapped in a class.
+*pandas* existing test structure is *mostly* class-based, meaning that you will typically find tests wrapped in a class.
 
 .. code-block:: python
 
     class TestReallyCoolFeature:
         pass
 
-Going forward, we are moving to a more *functional* style using the `pytest <http://docs.pytest.org/en/latest/>`__ framework, which offers a richer testing
+Going forward, we are moving to a more *functional* style using the `pytest <https://docs.pytest.org/en/latest/>`__ framework, which offers a richer testing
 framework that will facilitate testing and developing. Thus, instead of writing test classes, we will write test functions like this:
 
 .. code-block:: python
@@ -1109,7 +1175,7 @@ If your change involves checking that a warning is actually emitted, use
 
 .. code-block:: python
 
-   import pandas.util.testing as tm
+   import pandas._testing as tm
 
 
    df = pd.DataFrame()
@@ -1192,9 +1258,7 @@ On Windows, one can type::
 This can significantly reduce the time it takes to locally run tests before
 submitting a pull request.
 
-For more, see the `pytest <http://docs.pytest.org/en/latest/>`_ documentation.
-
-    .. versionadded:: 0.20.0
+For more, see the `pytest <https://docs.pytest.org/en/latest/>`_ documentation.
 
 Furthermore one can run
 
@@ -1265,7 +1329,7 @@ environment by::
 
 or, to use a specific Python interpreter,::
 
-    asv run -e -E existing:python3.5
+    asv run -e -E existing:python3.6
 
 This will display stderr from the benchmarks, and use your local
 ``python`` that comes from your ``$PATH``.
@@ -1332,6 +1396,7 @@ some common prefixes along with general guidelines for when to use them:
 * TST: Additions/updates to tests
 * BLD: Updates to the build process/scripts
 * PERF: Performance improvement
+* TYP: Type annotations
 * CLN: Code cleanup
 
 The following defines how a commit message should be structured.  Please reference the
@@ -1472,3 +1537,19 @@ The branch will still exist on GitHub, so to delete it there do::
     git push origin --delete shiny-new-feature
 
 .. _Gitter: https://gitter.im/pydata/pandas
+
+
+Tips for a successful Pull Request
+==================================
+
+If you have made it to the `Review your code`_ phase, one of the core contributors may
+take a look. Please note however that a handful of people are responsible for reviewing
+all of the contributions, which can often lead to bottlenecks.
+
+To improve the chances of your pull request being reviewed, you should:
+
+- **Reference an open issue** for non-trivial changes to clarify the PR's purpose
+- **Ensure you have appropriate tests**. These should be the first part of any PR
+- **Keep your pull requests as simple as possible**. Larger PRs take longer to review
+- **Ensure that CI is in a green state**. Reviewers may not even look otherwise
+- **Keep** `Updating your pull request`_, either by request or every few days
diff --git a/doc/source/development/contributing_docstring.rst b/doc/source/development/contributing_docstring.rst
index 34bc5f44eb0c0..649dd37b497b2 100644
--- a/doc/source/development/contributing_docstring.rst
+++ b/doc/source/development/contributing_docstring.rst
@@ -22,39 +22,39 @@ Next example gives an idea on how a docstring looks like:
 .. code-block:: python
 
     def add(num1, num2):
-    """
-    Add up two integer numbers.
-
-    This function simply wraps the `+` operator, and does not
-    do anything interesting, except for illustrating what is
-    the docstring of a very simple function.
-
-    Parameters
-    ----------
-    num1 : int
-        First number to add
-    num2 : int
-        Second number to add
-
-    Returns
-    -------
-    int
-        The sum of `num1` and `num2`
-
-    See Also
-    --------
-    subtract : Subtract one integer from another
-
-    Examples
-    --------
-    >>> add(2, 2)
-    4
-    >>> add(25, 0)
-    25
-    >>> add(10, -10)
-    0
-    """
-    return num1 + num2
+        """
+        Add up two integer numbers.
+
+        This function simply wraps the `+` operator, and does not
+        do anything interesting, except for illustrating what is
+        the docstring of a very simple function.
+
+        Parameters
+        ----------
+        num1 : int
+            First number to add
+        num2 : int
+            Second number to add
+
+        Returns
+        -------
+        int
+            The sum of `num1` and `num2`
+
+        See Also
+        --------
+        subtract : Subtract one integer from another
+
+        Examples
+        --------
+        >>> add(2, 2)
+        4
+        >>> add(25, 0)
+        25
+        >>> add(10, -10)
+        0
+        """
+        return num1 + num2
 
 Some standards exist about docstrings, so they are easier to read, and they can
 be exported to other formats such as html or pdf.
@@ -77,8 +77,8 @@ language that allows encoding styles in plain text files. Documentation
 about reStructuredText can be found in:
 
 * `Sphinx reStructuredText primer <https://www.sphinx-doc.org/en/stable/rest.html>`_
-* `Quick reStructuredText reference <http://docutils.sourceforge.net/docs/user/rst/quickref.html>`_
-* `Full reStructuredText specification <http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html>`_
+* `Quick reStructuredText reference <https://docutils.sourceforge.io/docs/user/rst/quickref.html>`_
+* `Full reStructuredText specification <https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html>`_
 
 Pandas has some helpers for sharing docstrings between related classes, see
 :ref:`docstring.sharing`.
@@ -399,7 +399,7 @@ DataFrame:
 * DataFrame
 * pandas.Index
 * pandas.Categorical
-* pandas.SparseArray
+* pandas.arrays.SparseArray
 
 If the exact type is not relevant, but must be compatible with a numpy
 array, array-like can be specified. If Any type that can be iterated is
diff --git a/doc/source/development/developer.rst b/doc/source/development/developer.rst
index 923ef005d5926..33646e5d74757 100644
--- a/doc/source/development/developer.rst
+++ b/doc/source/development/developer.rst
@@ -125,7 +125,6 @@ The ``metadata`` field is ``None`` except for:
   in ``BYTE_ARRAY`` Parquet columns. The encoding can be one of:
 
     * ``'pickle'``
-    * ``'msgpack'``
     * ``'bson'``
     * ``'json'``
 
diff --git a/doc/source/development/extending.rst b/doc/source/development/extending.rst
index e341dcb8318bc..270f20e8118bc 100644
--- a/doc/source/development/extending.rst
+++ b/doc/source/development/extending.rst
@@ -251,6 +251,48 @@ To use a test, subclass it:
 See https://github.com/pandas-dev/pandas/blob/master/pandas/tests/extension/base/__init__.py
 for a list of all the tests available.
 
+.. _extending.extension.arrow:
+
+Compatibility with Apache Arrow
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+An ``ExtensionArray`` can support conversion to / from ``pyarrow`` arrays
+(and thus support for example serialization to the Parquet file format)
+by implementing two methods: ``ExtensionArray.__arrow_array__`` and
+``ExtensionDtype.__from_arrow__``.
+
+The ``ExtensionArray.__arrow_array__`` ensures that ``pyarrow`` knowns how
+to convert the specific extension array into a ``pyarrow.Array`` (also when
+included as a column in a pandas DataFrame):
+
+.. code-block:: python
+
+    class MyExtensionArray(ExtensionArray):
+        ...
+
+        def __arrow_array__(self, type=None):
+            # convert the underlying array values to a pyarrow Array
+            import pyarrow
+            return pyarrow.array(..., type=type)
+
+The ``ExtensionDtype.__from_arrow__`` method then controls the conversion
+back from pyarrow to a pandas ExtensionArray. This method receives a pyarrow
+``Array`` or ``ChunkedArray`` as only argument and is expected to return the
+appropriate pandas ``ExtensionArray`` for this dtype and the passed values:
+
+.. code-block:: none
+
+    class ExtensionDtype:
+        ...
+
+        def __from_arrow__(self, array: pyarrow.Array/ChunkedArray) -> ExtensionArray:
+            ...
+
+See more in the `Arrow documentation <https://arrow.apache.org/docs/python/extending_types.html>`__.
+
+Those methods have been implemented for the nullable integer and string extension
+dtypes included in pandas, and ensure roundtrip to pyarrow and the Parquet file format.
+
 .. _extension dtype dtypes: https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/dtypes.py
 .. _extension dtype source: https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/base.py
 .. _extension array source: https://github.com/pandas-dev/pandas/blob/master/pandas/core/arrays/base.py
@@ -264,7 +306,7 @@ Subclassing pandas data structures
 
   1. Extensible method chains with :ref:`pipe <basics.pipe>`
 
-  2. Use *composition*. See `here <http://en.wikipedia.org/wiki/Composition_over_inheritance>`_.
+  2. Use *composition*. See `here <https://en.wikipedia.org/wiki/Composition_over_inheritance>`_.
 
   3. Extending by :ref:`registering an accessor <extending.register-accessors>`
 
diff --git a/doc/source/development/index.rst b/doc/source/development/index.rst
index c7710ff19f078..f8a6bb6deb52d 100644
--- a/doc/source/development/index.rst
+++ b/doc/source/development/index.rst
@@ -13,7 +13,11 @@ Development
     :maxdepth: 2
 
     contributing
+    code_style
+    maintaining
     internals
     extending
     developer
+    policies
     roadmap
+    meeting
diff --git a/doc/source/development/maintaining.rst b/doc/source/development/maintaining.rst
new file mode 100644
index 0000000000000..e65b66fc243c5
--- /dev/null
+++ b/doc/source/development/maintaining.rst
@@ -0,0 +1,193 @@
+.. _maintaining:
+
+******************
+Pandas Maintenance
+******************
+
+This guide is for pandas' maintainers. It may also be interesting to contributors
+looking to understand the pandas development process and what steps are necessary
+to become a maintainer.
+
+The main contributing guide is available at :ref:`contributing`.
+
+Roles
+-----
+
+Pandas uses two levels of permissions: **triage** and **core** team members.
+
+Triage members can label and close issues and pull requests.
+
+Core team members can label and close issues and pull request, and can merge
+pull requests.
+
+GitHub publishes the full `list of permissions`_.
+
+Tasks
+-----
+
+Pandas is largely a volunteer project, so these tasks shouldn't be read as
+"expectations" of triage and maintainers. Rather, they're general descriptions
+of what it means to be a maintainer.
+
+* Triage newly filed issues (see :ref:`maintaining.triage`)
+* Review newly opened pull requests
+* Respond to updates on existing issues and pull requests
+* Drive discussion and decisions on stalled issues and pull requests
+* Provide experience / wisdom on API design questions to ensure consistency and maintainability
+* Project organization (run / attend developer meetings, represent pandas)
+
+https://matthewrocklin.com/blog/2019/05/18/maintainer may be interesting background
+reading.
+
+.. _maintaining.triage:
+
+Issue Triage
+------------
+
+
+Here's a typical workflow for triaging a newly opened issue.
+
+1. **Thank the reporter for opening an issue**
+
+   The issue tracker is many people's first interaction with the pandas project itself,
+   beyond just using the library. As such, we want it to be a welcoming, pleasant
+   experience.
+
+2. **Is the necessary information provided?**
+
+   Ideally reporters would fill out the issue template, but many don't.
+   If crucial information (like the version of pandas they used), is missing
+   feel free to ask for that and label the issue with "Needs info". The
+   report should follow the guidelines in :ref:`contributing.bug_reports`.
+   You may want to link to that if they didn't follow the template.
+
+   Make sure that the title accurately reflects the issue. Edit it yourself
+   if it's not clear.
+
+3. **Is this a duplicate issue?**
+
+   We have many open issues. If a new issue is clearly a duplicate, label the
+   new issue as "Duplicate" assign the milestone "No Action", and close the issue
+   with a link to the original issue. Make sure to still thank the reporter, and
+   encourage them to chime in on the original issue, and perhaps try to fix it.
+
+   If the new issue provides relevant information, such as a better or slightly
+   different example, add it to the original issue as a comment or an edit to
+   the original post.
+
+4. **Is the issue minimal and reproducible**?
+
+   For bug reports, we ask that the reporter provide a minimal reproducible
+   example. See https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports
+   for a good explanation. If the example is not reproducible, or if it's
+   *clearly* not minimal, feel free to ask the reporter if they can provide
+   and example or simplify the provided one. Do acknowledge that writing
+   minimal reproducible examples is hard work. If the reporter is struggling,
+   you can try to write one yourself and we'll edit the original post to include it.
+
+   If a reproducible example can't be provided, add the "Needs info" label.
+
+   If a reproducible example is provided, but you see a simplification,
+   edit the original post with your simpler reproducible example.
+
+5. **Is this a clearly defined feature request?**
+
+   Generally, pandas prefers to discuss and design new features in issues, before
+   a pull request is made. Encourage the submitter to include a proposed API
+   for the new feature. Having them write a full docstring is a good way to
+   pin down specifics.
+
+   We'll need a discussion from several pandas maintainers before deciding whether
+   the proposal is in scope for pandas.
+
+6. **Is this a usage question?**
+
+   We prefer that usage questions are asked on StackOverflow with the pandas
+   tag. https://stackoverflow.com/questions/tagged/pandas
+
+   If it's easy to answer, feel free to link to the relevant documentation section,
+   let them know that in the future this kind of question should be on
+   StackOverflow, and close the issue.
+
+7. **What labels and milestones should I add?**
+
+   Apply the relevant labels. This is a bit of an art, and comes with experience.
+   Look at similar issues to get a feel for how things are labeled.
+
+   If the issue is clearly defined and the fix seems relatively straightforward,
+   label the issue as "Good first issue".
+
+   Typically, new issues will be assigned the "Contributions welcome" milestone,
+   unless it's know that this issue should be addressed in a specific release (say
+   because it's a large regression).
+
+.. _maintaining.closing:
+
+Closing Issues
+--------------
+
+Be delicate here: many people interpret closing an issue as us saying that the
+conversation is over. It's typically best to give the reporter some time to
+respond or self-close their issue if it's determined that the behavior is not a bug,
+or the feature is out of scope. Sometimes reporters just go away though, and
+we'll close the issue after the conversation has died.
+
+Reviewing Pull Requests
+-----------------------
+
+Anybody can review a pull request: regular contributors, triagers, or core-team
+members. Here are some guidelines to check.
+
+* Tests should be in a sensible location.
+* New public APIs should be included somewhere in ``doc/source/reference/``.
+* New / changed API should use the ``versionadded`` or ``versionchanged`` directives in the docstring.
+* User-facing changes should have a whatsnew in the appropriate file.
+* Regression tests should reference the original GitHub issue number like ``# GH-1234``.
+
+Cleaning up old Issues
+----------------------
+
+Every open issue in pandas has a cost. Open issues make finding duplicates harder,
+and can make it harder to know what needs to be done in pandas. That said, closing
+issues isn't a goal on its own. Our goal is to make pandas the best it can be,
+and that's best done by ensuring that the quality of our open issues is high.
+
+Occasionally, bugs are fixed but the issue isn't linked to in the Pull Request.
+In these cases, comment that "This has been fixed, but could use a test." and
+label the issue as "Good First Issue" and "Needs Test".
+
+If an older issue doesn't follow our issue template, edit the original post to
+include a minimal example, the actual output, and the expected output. Uniformity
+in issue reports is valuable.
+
+If an older issue lacks a reproducible example, label it as "Needs Info" and
+ask them to provide one (or write one yourself if possible). If one isn't
+provide reasonably soon, close it according to the policies in :ref:`maintaining.closing`.
+
+Cleaning up old Pull Requests
+-----------------------------
+
+Occasionally, contributors are unable to finish off a pull request.
+If some time has passed (two weeks, say) since the last review requesting changes,
+gently ask if they're still interested in working on this. If another two weeks or
+so passes with no response, thank them for their work and close the pull request.
+Comment on the original issue that "There's a stalled PR at #1234 that may be
+helpful.", and perhaps label the issue as "Good first issue" if the PR was relatively
+close to being accepted.
+
+Additionally, core-team members can push to contributors branches. This can be
+helpful for pushing an important PR across the line, or for fixing a small
+merge conflict.
+
+Becoming a pandas maintainer
+----------------------------
+
+The full process is outlined in our `governance documents`_. In summary,
+we're happy to give triage permissions to anyone who shows interest by
+being helpful on the issue tracker.
+
+The current list of core-team members is at
+https://github.com/pandas-dev/pandas-governance/blob/master/people.md
+
+.. _governance documents: https://github.com/pandas-dev/pandas-governance
+.. _list of permissions: https://help.github.com/en/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization
\ No newline at end of file
diff --git a/doc/source/development/meeting.rst b/doc/source/development/meeting.rst
new file mode 100644
index 0000000000000..1d19408692cda
--- /dev/null
+++ b/doc/source/development/meeting.rst
@@ -0,0 +1,32 @@
+.. _meeting:
+
+==================
+Developer Meetings
+==================
+
+We hold regular developer meetings on the second Wednesday
+of each month at 18:00 UTC. These meetings and their minutes are open to
+the public. All are welcome to join.
+
+Minutes
+-------
+
+The minutes of past meetings are available in `this Google Document <https://docs.google.com/document/d/1tGbTiYORHiSPgVMXawiweGJlBw5dOkVJLY-licoBmBU/edit?usp=sharing>`__.
+
+Calendar
+--------
+
+This calendar shows all the developer meetings.
+
+.. raw:: html
+
+   <iframe src="https://calendar.google.com/calendar/embed?src=pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com" style="border: 0" width="800" height="600" frameborder="0" scrolling="no"></iframe>
+
+You can subscribe to this calendar with the following links:
+
+* `iCal <https://calendar.google.com/calendar/ical/pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com/public/basic.ics>`__
+* `Google calendar <https://calendar.google.com/calendar/embed?src=pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com>`__
+
+Additionally, we'll sometimes have one-off meetings on specific topics.
+These will be published on the same calendar.
+
diff --git a/doc/source/development/policies.rst b/doc/source/development/policies.rst
new file mode 100644
index 0000000000000..224948738341e
--- /dev/null
+++ b/doc/source/development/policies.rst
@@ -0,0 +1,57 @@
+.. _develop.policies:
+
+********
+Policies
+********
+
+.. _policies.version:
+
+Version Policy
+~~~~~~~~~~~~~~
+
+.. versionchanged:: 1.0.0
+
+Pandas uses a loose variant of semantic versioning (`SemVer`_) to govern
+deprecations, API compatibility, and version numbering.
+
+A pandas release number is made up of ``MAJOR.MINOR.PATCH``.
+
+API breaking changes should only occur in **major** releases. Theses changes
+will be documented, with clear guidance on what is changing, why it's changing,
+and how to migrate existing code to the new behavior.
+
+Whenever possible, a deprecation path will be provided rather than an outright
+breaking change.
+
+Pandas will introduce deprecations in **minor** releases. These deprecations
+will preserve the existing behavior while emitting a warning that provide
+guidance on:
+
+* How to achieve similar behavior if an alternative is available
+* The pandas version in which the deprecation will be enforced.
+
+We will not introduce new deprecations in patch releases.
+
+Deprecations will only be enforced in **major** releases. For example, if a
+behavior is deprecated in pandas 1.2.0, it will continue to work, with a
+warning, for all releases in the 1.x series. The behavior will change and the
+deprecation removed in the next next major release (2.0.0).
+
+.. note::
+
+   Pandas will sometimes make *behavior changing* bug fixes, as part of
+   minor or patch releases. Whether or not a change is a bug fix or an
+   API-breaking change is a judgement call. We'll do our best, and we
+   invite you to participate in development discussion on the issue
+   tracker or mailing list.
+
+These policies do not apply to features marked as **experimental** in the documentation.
+Pandas may change the behavior of experimental features at any time.
+
+Python Support
+~~~~~~~~~~~~~~
+
+Pandas will only drop support for specific Python versions (e.g. 3.6.x, 3.7.x) in
+pandas **major** releases.
+
+.. _SemVer: https://semver.org
diff --git a/doc/source/development/roadmap.rst b/doc/source/development/roadmap.rst
index 00598830e2fe9..fafe63d80249c 100644
--- a/doc/source/development/roadmap.rst
+++ b/doc/source/development/roadmap.rst
@@ -129,20 +129,6 @@ Some specific goals include
 * Improve the overall organization of the documentation and specific subsections
   of the documentation to make navigation and finding content easier.
 
-Package docstring validation
-----------------------------
-
-To improve the quality and consistency of pandas docstrings, we've developed
-tooling to check docstrings in a variety of ways.
-https://github.com/pandas-dev/pandas/blob/master/scripts/validate_docstrings.py
-contains the checks.
-
-Like many other projects, pandas uses the
-`numpydoc <https://numpydoc.readthedocs.io/en/latest/>`__ style for writing
-docstrings. With the collaboration of the numpydoc maintainers, we'd like to
-move the checks to a package other than pandas so that other projects can easily
-use them as well.
-
 Performance monitoring
 ----------------------
 
diff --git a/doc/source/ecosystem.rst b/doc/source/ecosystem.rst
index aaf2040156a45..fb06ee122ae88 100644
--- a/doc/source/ecosystem.rst
+++ b/doc/source/ecosystem.rst
@@ -1,3 +1,5 @@
+:orphan:
+
 .. _ecosystem:
 
 {{ header }}
@@ -39,6 +41,16 @@ Pyjanitor provides a clean API for cleaning data, using method chaining.
 Engarde is a lightweight library used to explicitly state assumptions about your datasets
 and check that they're *actually* true.
 
+`pandas-path <https://github.com/drivendataorg/pandas-path/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since Python 3.4, `pathlib <https://docs.python.org/3/library/pathlib.html>`_ has been
+included in the Python standard library. Path objects provide a simple
+and delightful way to interact with the file system. The pandas-path package enables the
+Path API for pandas through a custom accessor ``.path``. Getting just the filenames from
+a series of full file paths is as simple as ``my_files.path.name``. Other convenient operations like
+joining paths, replacing file extensions, and checking if files exist are also available.
+
 .. _ecosystem.stats:
 
 Statistics and machine learning
@@ -110,16 +122,14 @@ also goes beyond matplotlib and pandas with the option to perform statistical
 estimation while plotting, aggregating across observations and visualizing the
 fit of statistical models to emphasize patterns in a dataset.
 
-`yhat/ggpy <https://github.com/yhat/ggpy>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`plotnine <https://github.com/has2k1/plotnine/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Hadley Wickham's `ggplot2 <https://ggplot2.tidyverse.org/>`__ is a foundational exploratory visualization package for the R language.
 Based on `"The Grammar of Graphics" <https://www.cs.uic.edu/~wilkinson/TheGrammarOfGraphics/GOG.html>`__ it
 provides a powerful, declarative and extremely general way to generate bespoke plots of any kind of data.
-It's really quite incredible. Various implementations to other languages are available,
-but a faithful implementation for Python users has long been missing. Although still young
-(as of Jan-2014), the `yhat/ggpy <https://github.com/yhat/ggpy>`__ project has been
-progressing quickly in that direction.
+Various implementations to other languages are available.
+A good implementation for Python users is `has2k1/plotnine <https://github.com/has2k1/plotnine/>`__.
 
 `IPython Vega <https://github.com/vega/ipyvega>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -242,8 +252,8 @@ Pandas DataFrames with timeseries indexes.
 `pydatastream <https://github.com/vfilimonov/pydatastream>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 PyDatastream is a Python interface to the
-`Thomson Dataworks Enterprise (DWE/Datastream) <http://dataworks.thomson.com/Dataworks/Enterprise/1.0/>`__
-SOAP API to return indexed Pandas DataFrames with financial data.
+`Refinitiv Datastream (DWS) <https://www.refinitiv.com/en/products/datastream-macroeconomic-analysis>`__
+REST API to return indexed Pandas DataFrames with financial data.
 This package requires valid credentials for this API (non free).
 
 `pandaSDMX <https://pandasdmx.readthedocs.io>`__
@@ -293,8 +303,8 @@ dimensional arrays, rather than the tabular data for which pandas excels.
 Out-of-core
 -------------
 
-`Blaze <http://blaze.pydata.org/>`__
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+`Blaze <https://blaze.pydata.org/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Blaze provides a standard API for doing computations with various
 in-memory and on-disk backends: NumPy, Pandas, SQLAlchemy, MongoDB, PyTables,
@@ -325,6 +335,21 @@ PyTables, h5py, and pymongo to move data between non pandas formats. Its graph
 based approach is also extensible by end users for custom formats that may be
 too specific for the core of odo.
 
+`Pandarallel <https://github.com/nalepae/pandarallel>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pandarallel provides a simple way to parallelize your pandas operations on all your CPUs by changing only one line of code.
+If also displays progress bars.
+
+.. code:: python
+
+    from pandarallel import pandarallel
+
+    pandarallel.initialize(progress_bar=True)
+
+    # df.apply(func)
+    df.parallel_apply(func)
+
 `Ray <https://ray.readthedocs.io/en/latest/pandas_on_ray.html>`__
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -369,13 +394,16 @@ A directory of projects providing
 :ref:`extension accessors <extending.register-accessors>`. This is for users to
 discover new accessors and for library authors to coordinate on the namespace.
 
-============== ========== =========================
-Library        Accessor   Classes
-============== ========== =========================
-`cyberpandas`_ ``ip``     ``Series``
-`pdvega`_      ``vgplot`` ``Series``, ``DataFrame``
-============== ========== =========================
+=============== ========== ========================= ===============================================================
+Library         Accessor   Classes                   Description
+=============== ========== ========================= ===============================================================
+`cyberpandas`_  ``ip``     ``Series``                Provides common operations for working with IP addresses.
+`pdvega`_       ``vgplot`` ``Series``, ``DataFrame`` Provides plotting functions from the Altair_ library.
+`pandas_path`_  ``path``   ``Index``, ``Series``     Provides `pathlib.Path`_ functions for Series.
+=============== ========== ========================= ===============================================================
 
 .. _cyberpandas: https://cyberpandas.readthedocs.io/en/latest
 .. _pdvega: https://altair-viz.github.io/pdvega/
-
+.. _Altair: https://altair-viz.github.io/
+.. _pandas_path: https://github.com/drivendataorg/pandas-path/
+.. _pathlib.Path: https://docs.python.org/3/library/pathlib.html
\ No newline at end of file
diff --git a/doc/source/getting_started/10min.rst b/doc/source/getting_started/10min.rst
index 41520795bde62..a635b5656bd2d 100644
--- a/doc/source/getting_started/10min.rst
+++ b/doc/source/getting_started/10min.rst
@@ -70,17 +70,17 @@ will be completed:
    df2.abs                df2.boxplot
    df2.add                df2.C
    df2.add_prefix         df2.clip
-   df2.add_suffix         df2.clip_lower
-   df2.align              df2.clip_upper
-   df2.all                df2.columns
+   df2.add_suffix         df2.columns
+   df2.align              df2.copy
+   df2.all                df2.count
    df2.any                df2.combine
-   df2.append             df2.combine_first
-   df2.apply              df2.compound
-   df2.applymap           df2.consolidate
-   df2.D
+   df2.append             df2.D
+   df2.apply              df2.describe
+   df2.applymap           df2.diff
+   df2.B                  df2.duplicated
 
 As you can see, the columns ``A``, ``B``, ``C``, and ``D`` are automatically
-tab completed. ``E`` is there as well; the rest of the attributes have been
+tab completed. ``E`` and ``F`` are there as well; the rest of the attributes have been
 truncated for brevity.
 
 Viewing data
@@ -697,8 +697,9 @@ Plotting
 
 See the :ref:`Plotting <visualization>` docs.
 
+We use the standard convention for referencing the matplotlib API:
+
 .. ipython:: python
-   :suppress:
 
    import matplotlib.pyplot as plt
    plt.close('all')
diff --git a/doc/source/getting_started/basics.rst b/doc/source/getting_started/basics.rst
index 802ffadf2a81e..277080006cb3c 100644
--- a/doc/source/getting_started/basics.rst
+++ b/doc/source/getting_started/basics.rst
@@ -172,8 +172,6 @@ You are highly encouraged to install both libraries. See the section
 
 These are both enabled to be used by default, you can control this by setting the options:
 
-.. versionadded:: 0.20.0
-
 .. code-block:: python
 
    pd.set_option('compute.use_bottleneck', False)
@@ -755,28 +753,51 @@ on an entire ``DataFrame`` or ``Series``, row- or column-wise, or elementwise.
 Tablewise function application
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-``DataFrames`` and ``Series`` can of course just be passed into functions.
+``DataFrames`` and ``Series`` can be passed into functions.
 However, if the function needs to be called in a chain, consider using the :meth:`~DataFrame.pipe` method.
-Compare the following
 
-.. code-block:: python
+First some setup:
 
-   # f, g, and h are functions taking and returning ``DataFrames``
-   >>> f(g(h(df), arg1=1), arg2=2, arg3=3)
+.. ipython:: python
 
-with the equivalent
+    def extract_city_name(df):
+        """
+        Chicago, IL -> Chicago for city_name column
+        """
+        df['city_name'] = df['city_and_code'].str.split(",").str.get(0)
+        return df
 
-.. code-block:: python
+    def add_country_name(df, country_name=None):
+        """
+        Chicago -> Chicago-US for city_name column
+        """
+        col = 'city_name'
+        df['city_and_country'] = df[col] + country_name
+        return df
+
+    df_p = pd.DataFrame({'city_and_code': ['Chicago, IL']})
+
+
+``extract_city_name`` and ``add_country_name`` are functions taking and returning ``DataFrames``.
+
+Now compare the following:
+
+.. ipython:: python
 
-   >>> (df.pipe(h)
-   ...    .pipe(g, arg1=1)
-   ...    .pipe(f, arg2=2, arg3=3))
+    add_country_name(extract_city_name(df_p), country_name='US')
+
+Is equivalent to:
+
+.. ipython:: python
+
+    (df_p.pipe(extract_city_name)
+         .pipe(add_country_name, country_name="US"))
 
 Pandas encourages the second style, which is known as method chaining.
 ``pipe`` makes it easy to use your own or another library's functions
 in method chains, alongside pandas' methods.
 
-In the example above, the functions ``f``, ``g``, and ``h`` each expected the ``DataFrame`` as the first positional argument.
+In the example above, the functions ``extract_city_name`` and ``add_country_name`` each expected a ``DataFrame`` as the first positional argument.
 What if the function you wish to apply takes its data as, say, the second argument?
 In this case, provide ``pipe`` with a tuple of ``(callable, data_keyword)``.
 ``.pipe`` will route the ``DataFrame`` to the argument specified in the tuple.
@@ -891,8 +912,6 @@ functionality.
 Aggregation API
 ~~~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 The aggregation API allows one to express possibly multiple aggregation operations in a single concise way.
 This API is similar across pandas objects, see :ref:`groupby API <groupby.aggregate>`, the
 :ref:`window functions API <stats.aggregate>`, and the :ref:`resample API <timeseries.aggregate>`.
@@ -986,7 +1005,7 @@ not noted for a particular column will be ``NaN``:
 
    tsdf.agg({'A': ['mean', 'min'], 'B': 'sum'})
 
-.. _basics.aggregation.mixed_dtypes:
+.. _basics.aggregation.mixed_string:
 
 Mixed dtypes
 ++++++++++++
@@ -1030,8 +1049,6 @@ to the built in :ref:`describe function <basics.describe>`.
 Transform API
 ~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 The :meth:`~DataFrame.transform` method returns an object that is indexed the same (same size)
 as the original. This API allows you to provide *multiple* operations at the same
 time rather than one-by-one. Its API is quite similar to the ``.agg`` API.
@@ -1704,7 +1721,8 @@ built-in string methods. For example:
 
  .. ipython:: python
 
-  s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
+  s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'],
+                dtype="string")
   s.str.lower()
 
 Powerful pattern-matching methods are provided as well, but note that
@@ -1712,6 +1730,12 @@ pattern-matching generally uses `regular expressions
 <https://docs.python.org/3/library/re.html>`__ by default (and in some cases
 always uses them).
 
+.. note::
+
+   Prior to pandas 1.0, string methods were only available on ``object`` -dtype
+   ``Series``. Pandas 1.0 added the :class:`StringDtype` which is dedicated
+   to strings. See :ref:`text.types` for more.
+
 Please see :ref:`Vectorized String Methods <text.string_methods>` for a complete
 description.
 
@@ -1913,21 +1937,43 @@ See :ref:`extending.extension-types` for how to write your own extension that
 works with pandas. See :ref:`ecosystem.extensions` for a list of third-party
 libraries that have implemented an extension.
 
-The following table lists all of pandas extension types. See the respective
+The following table lists all of pandas extension types. For methods requiring ``dtype``
+arguments, strings can be specified as indicated. See the respective
 documentation sections for more on each type.
 
-=================== ========================= ================== ============================= =============================
-Kind of Data        Data Type                 Scalar             Array                         Documentation
-=================== ========================= ================== ============================= =============================
-tz-aware datetime   :class:`DatetimeTZDtype`  :class:`Timestamp` :class:`arrays.DatetimeArray` :ref:`timeseries.timezone`
-Categorical         :class:`CategoricalDtype` (none)             :class:`Categorical`          :ref:`categorical`
-period (time spans) :class:`PeriodDtype`      :class:`Period`    :class:`arrays.PeriodArray`   :ref:`timeseries.periods`
-sparse              :class:`SparseDtype`      (none)             :class:`arrays.SparseArray`   :ref:`sparse`
-intervals           :class:`IntervalDtype`    :class:`Interval`  :class:`arrays.IntervalArray` :ref:`advanced.intervalindex`
-nullable integer    :class:`Int64Dtype`, ...  (none)             :class:`arrays.IntegerArray`  :ref:`integer_na`
-=================== ========================= ================== ============================= =============================
-
-Pandas uses the ``object`` dtype for storing strings.
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| Kind of Data      | Data Type                 | Scalar             | Array                         | String Aliases                          | Documentation                 |
++===================+===========================+====================+===============================+=========================================+===============================+
+| tz-aware datetime | :class:`DatetimeTZDtype`  | :class:`Timestamp` | :class:`arrays.DatetimeArray` | ``'datetime64[ns, <tz>]'``              | :ref:`timeseries.timezone`    |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| Categorical       | :class:`CategoricalDtype` | (none)             | :class:`Categorical`          | ``'category'``                          | :ref:`categorical`            |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| period            | :class:`PeriodDtype`      | :class:`Period`    | :class:`arrays.PeriodArray`   | ``'period[<freq>]'``,                   | :ref:`timeseries.periods`     |
+| (time spans)      |                           |                    |                               | ``'Period[<freq>]'``                    |                               |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| sparse            | :class:`SparseDtype`      | (none)             | :class:`arrays.SparseArray`   | ``'Sparse'``, ``'Sparse[int]'``,        | :ref:`sparse`                 |
+|                   |                           |                    |                               | ``'Sparse[float]'``                     |                               |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| intervals         | :class:`IntervalDtype`    | :class:`Interval`  | :class:`arrays.IntervalArray` | ``'interval'``, ``'Interval'``,         | :ref:`advanced.intervalindex` |
+|                   |                           |                    |                               | ``'Interval[<numpy_dtype>]'``,          |                               |
+|                   |                           |                    |                               | ``'Interval[datetime64[ns, <tz>]]'``,   |                               |
+|                   |                           |                    |                               | ``'Interval[timedelta64[<freq>]]'``     |                               |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| nullable integer  + :class:`Int64Dtype`, ...  | (none)             | :class:`arrays.IntegerArray`  | ``'Int8'``, ``'Int16'``, ``'Int32'``,   | :ref:`integer_na`             |
+|                   |                           |                    |                               | ``'Int64'``, ``'UInt8'``, ``'UInt16'``, |                               |
+|                   |                           |                    |                               | ``'UInt32'``, ``'UInt64'``              |                               |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| Strings           | :class:`StringDtype`      | :class:`str`       | :class:`arrays.StringArray`   | ``'string'``                            | :ref:`text`                   |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+| Boolean (with NA) | :class:`BooleanDtype`     | :class:`bool`      | :class:`arrays.BooleanArray`  | ``'boolean'``                           | :ref:`api.arrays.bool`        |
++-------------------+---------------------------+--------------------+-------------------------------+-----------------------------------------+-------------------------------+
+
+Pandas has two ways to store strings.
+
+1. ``object`` dtype, which can hold any Python object, including strings.
+2. :class:`StringDtype`, which is dedicated to strings.
+
+Generally, we recommend using :class:`StringDtype`. See :ref:`text.types` for more.
 
 Finally, arbitrary objects may be stored using the ``object`` dtype, but should
 be avoided to the extent possible (for performance and interoperability with
@@ -1975,7 +2021,7 @@ The number of columns of each type in a ``DataFrame`` can be found by calling
 
 Numeric dtypes will propagate and can coexist in DataFrames.
 If a dtype is passed (either directly via the ``dtype`` keyword, a passed ``ndarray``,
-or a passed ``Series``, then it will be preserved in DataFrame operations. Furthermore,
+or a passed ``Series``), then it will be preserved in DataFrame operations. Furthermore,
 different numeric dtypes will **NOT** be combined. The following example will give you a taste.
 
 .. ipython:: python
diff --git a/doc/source/getting_started/comparison/comparison_with_r.rst b/doc/source/getting_started/comparison/comparison_with_r.rst
index f67f46fc2b29b..e1a4cfe49b7d1 100644
--- a/doc/source/getting_started/comparison/comparison_with_r.rst
+++ b/doc/source/getting_started/comparison/comparison_with_r.rst
@@ -6,9 +6,9 @@ Comparison with R / R libraries
 *******************************
 
 Since ``pandas`` aims to provide a lot of the data manipulation and analysis
-functionality that people use `R <http://www.r-project.org/>`__ for, this page
+functionality that people use `R <https://www.r-project.org/>`__ for, this page
 was started to provide a more detailed look at the `R language
-<http://en.wikipedia.org/wiki/R_(programming_language)>`__ and its many third
+<https://en.wikipedia.org/wiki/R_(programming_language)>`__ and its many third
 party libraries as they relate to ``pandas``. In comparisons with R and CRAN
 libraries, we care about the following things:
 
@@ -517,37 +517,37 @@ For more details and examples see :ref:`categorical introduction <categorical>`
 
 
 .. |c| replace:: ``c``
-.. _c: http://stat.ethz.ch/R-manual/R-patched/library/base/html/c.html
+.. _c: https://stat.ethz.ch/R-manual/R-patched/library/base/html/c.html
 
 .. |aggregate| replace:: ``aggregate``
-.. _aggregate: http://finzi.psych.upenn.edu/R/library/stats/html/aggregate.html
+.. _aggregate: https://stat.ethz.ch/R-manual/R-patched/library/stats/html/aggregate.html
 
 .. |match| replace:: ``match`` / ``%in%``
-.. _match: http://finzi.psych.upenn.edu/R/library/base/html/match.html
+.. _match: https://stat.ethz.ch/R-manual/R-patched/library/base/html/match.html
 
 .. |tapply| replace:: ``tapply``
-.. _tapply: http://finzi.psych.upenn.edu/R/library/base/html/tapply.html
+.. _tapply: https://stat.ethz.ch/R-manual/R-patched/library/base/html/tapply.html
 
 .. |with| replace:: ``with``
-.. _with: http://finzi.psych.upenn.edu/R/library/base/html/with.html
+.. _with: https://stat.ethz.ch/R-manual/R-patched/library/base/html/with.html
 
 .. |subset| replace:: ``subset``
-.. _subset: http://finzi.psych.upenn.edu/R/library/base/html/subset.html
+.. _subset: https://stat.ethz.ch/R-manual/R-patched/library/base/html/subset.html
 
 .. |ddply| replace:: ``ddply``
-.. _ddply: http://www.inside-r.org/packages/cran/plyr/docs/ddply
+.. _ddply: https://cran.r-project.org/web/packages/plyr/plyr.pdf#Rfn.ddply.1
 
 .. |meltarray| replace:: ``melt.array``
-.. _meltarray: http://www.inside-r.org/packages/cran/reshape2/docs/melt.array
+.. _meltarray: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.array.1
 
 .. |meltlist| replace:: ``melt.list``
-.. meltlist: http://www.inside-r.org/packages/cran/reshape2/docs/melt.list
+.. meltlist: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.list.1
 
 .. |meltdf| replace:: ``melt.data.frame``
-.. meltdf: http://www.inside-r.org/packages/cran/reshape2/docs/melt.data.frame
+.. meltdf: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.melt.data.frame.1
 
 .. |cast| replace:: ``cast``
-.. cast: http://www.inside-r.org/packages/cran/reshape2/docs/cast
+.. cast: https://cran.r-project.org/web/packages/reshape2/reshape2.pdf#Rfn.cast.1
 
 .. |factor| replace:: ``factor``
 .. _factor: https://stat.ethz.ch/R-manual/R-devel/library/base/html/factor.html
diff --git a/doc/source/getting_started/comparison/comparison_with_sas.rst b/doc/source/getting_started/comparison/comparison_with_sas.rst
index 69bb700c97b15..4e284fe7b5968 100644
--- a/doc/source/getting_started/comparison/comparison_with_sas.rst
+++ b/doc/source/getting_started/comparison/comparison_with_sas.rst
@@ -629,7 +629,7 @@ for more details and examples.
 
 .. ipython:: python
 
-   tips_summed = tips.groupby(['sex', 'smoker'])['total_bill', 'tip'].sum()
+   tips_summed = tips.groupby(['sex', 'smoker'])[['total_bill', 'tip']].sum()
    tips_summed.head()
 
 
diff --git a/doc/source/getting_started/comparison/comparison_with_stata.rst b/doc/source/getting_started/comparison/comparison_with_stata.rst
index db687386329bb..decf12db77af2 100644
--- a/doc/source/getting_started/comparison/comparison_with_stata.rst
+++ b/doc/source/getting_started/comparison/comparison_with_stata.rst
@@ -617,7 +617,7 @@ for more details and examples.
 
 .. ipython:: python
 
-   tips_summed = tips.groupby(['sex', 'smoker'])['total_bill', 'tip'].sum()
+   tips_summed = tips.groupby(['sex', 'smoker'])[['total_bill', 'tip']].sum()
    tips_summed.head()
 
 
@@ -673,6 +673,6 @@ Disk vs memory
 Pandas and Stata both operate exclusively in memory. This means that the size of
 data able to be loaded in pandas is limited by your machine's memory.
 If out of core processing is needed, one possibility is the
-`dask.dataframe <http://dask.pydata.org/en/latest/dataframe.html>`_
+`dask.dataframe <https://dask.pydata.org/en/latest/dataframe.html>`_
 library, which provides a subset of pandas functionality for an
 on-disk ``DataFrame``.
diff --git a/doc/source/getting_started/dsintro.rst b/doc/source/getting_started/dsintro.rst
index 9e18951fe3f4c..5d7c9e405cfc2 100644
--- a/doc/source/getting_started/dsintro.rst
+++ b/doc/source/getting_started/dsintro.rst
@@ -136,7 +136,7 @@ Like a NumPy array, a pandas Series has a :attr:`~Series.dtype`.
 
 This is often a NumPy dtype. However, pandas and 3rd-party libraries
 extend NumPy's type system in a few places, in which case the dtype would
-be a :class:`~pandas.api.extensions.ExtensionDtype`. Some examples within
+be an :class:`~pandas.api.extensions.ExtensionDtype`. Some examples within
 pandas are :ref:`categorical` and :ref:`integer_na`. See :ref:`basics.dtypes`
 for more.
 
@@ -564,53 +564,6 @@ to a column created earlier in the same :meth:`~DataFrame.assign`.
 In the second expression, ``x['C']`` will refer to the newly created column,
 that's equal to ``dfa['A'] + dfa['B']``.
 
-To write code compatible with all versions of Python, split the assignment in two.
-
-.. ipython:: python
-
-   dependent = pd.DataFrame({"A": [1, 1, 1]})
-   (dependent.assign(A=lambda x: x['A'] + 1)
-             .assign(B=lambda x: x['A'] + 2))
-
-.. warning::
-
-   Dependent assignment may subtly change the behavior of your code between
-   Python 3.6 and older versions of Python.
-
-   If you wish to write code that supports versions of python before and after 3.6,
-   you'll need to take care when passing ``assign`` expressions that
-
-   * Update an existing column
-   * Refer to the newly updated column in the same ``assign``
-
-   For example, we'll update column "A" and then refer to it when creating "B".
-
-   .. code-block:: python
-
-      >>> dependent = pd.DataFrame({"A": [1, 1, 1]})
-      >>> dependent.assign(A=lambda x: x["A"] + 1, B=lambda x: x["A"] + 2)
-
-   For Python 3.5 and earlier the expression creating ``B`` refers to the
-   "old" value of ``A``, ``[1, 1, 1]``. The output is then
-
-   .. code-block:: console
-
-         A  B
-      0  2  3
-      1  2  3
-      2  2  3
-
-   For Python 3.6 and later, the expression creating ``A`` refers to the
-   "new" value of ``A``, ``[2, 2, 2]``, which results in
-
-   .. code-block:: console
-
-         A  B
-      0  2  4
-      1  2  4
-      2  2  4
-
-
 
 Indexing / selection
 ~~~~~~~~~~~~~~~~~~~~
@@ -656,7 +609,7 @@ union of the column and row labels.
 
 When doing an operation between DataFrame and Series, the default behavior is
 to align the Series **index** on the DataFrame **columns**, thus `broadcasting
-<http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`__
+<https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`__
 row-wise. For example:
 
 .. ipython:: python
@@ -723,11 +676,11 @@ similar to an ndarray:
    # only show the first 5 rows
    df[:5].T
 
+.. _dsintro.numpy_interop:
+
 DataFrame interoperability with NumPy functions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. _dsintro.numpy_interop:
-
 Elementwise NumPy ufuncs (log, exp, sqrt, ...) and various other NumPy functions
 can be used with no issues on Series and DataFrame, assuming the data within
 are numeric:
@@ -788,7 +741,7 @@ implementation takes precedence and a Series is returned.
    np.maximum(ser, idx)
 
 NumPy ufuncs are safe to apply to :class:`Series` backed by non-ndarray arrays,
-for example :class:`SparseArray` (see :ref:`sparse.calculation`). If possible,
+for example :class:`arrays.SparseArray` (see :ref:`sparse.calculation`). If possible,
 the ufunc is applied without converting the underlying data to an ndarray.
 
 Console display
diff --git a/doc/source/getting_started/index.rst b/doc/source/getting_started/index.rst
index eead28830f861..34bb4f930f175 100644
--- a/doc/source/getting_started/index.rst
+++ b/doc/source/getting_started/index.rst
@@ -12,6 +12,7 @@ Getting started
 .. toctree::
     :maxdepth: 2
 
+    install
     overview
     10min
     basics
diff --git a/doc/source/install.rst b/doc/source/getting_started/install.rst
similarity index 69%
rename from doc/source/install.rst
rename to doc/source/getting_started/install.rst
index fc99b458fa0af..bc1be527696a5 100644
--- a/doc/source/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -7,18 +7,18 @@ Installation
 ============
 
 The easiest way to install pandas is to install it
-as part of the `Anaconda <http://docs.continuum.io/anaconda/>`__ distribution, a
+as part of the `Anaconda <https://docs.continuum.io/anaconda/>`__ distribution, a
 cross platform distribution for data analysis and scientific computing.
 This is the recommended installation method for most users.
 
 Instructions for installing from source,
 `PyPI <https://pypi.org/project/pandas>`__, `ActivePython <https://www.activestate.com/activepython/downloads>`__, various Linux distributions, or a
-`development version <http://github.com/pandas-dev/pandas>`__ are also provided.
+`development version <https://github.com/pandas-dev/pandas>`__ are also provided.
 
 Python version support
 ----------------------
 
-Officially Python 3.5.3 and above, 3.6, and 3.7.
+Officially Python 3.6.1 and above, 3.7, and 3.8.
 
 Installing pandas
 -----------------
@@ -28,28 +28,28 @@ Installing pandas
 Installing with Anaconda
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-Installing pandas and the rest of the `NumPy <http://www.numpy.org/>`__ and
-`SciPy <http://www.scipy.org/>`__ stack can be a little
+Installing pandas and the rest of the `NumPy <https://www.numpy.org/>`__ and
+`SciPy <https://www.scipy.org/>`__ stack can be a little
 difficult for inexperienced users.
 
 The simplest way to install not only pandas, but Python and the most popular
-packages that make up the `SciPy <http://www.scipy.org/>`__ stack
-(`IPython <http://ipython.org/>`__, `NumPy <http://www.numpy.org/>`__,
-`Matplotlib <http://matplotlib.org/>`__, ...) is with
-`Anaconda <http://docs.continuum.io/anaconda/>`__, a cross-platform
+packages that make up the `SciPy <https://www.scipy.org/>`__ stack
+(`IPython <https://ipython.org/>`__, `NumPy <https://www.numpy.org/>`__,
+`Matplotlib <https://matplotlib.org/>`__, ...) is with
+`Anaconda <https://docs.continuum.io/anaconda/>`__, a cross-platform
 (Linux, Mac OS X, Windows) Python distribution for data analytics and
 scientific computing.
 
 After running the installer, the user will have access to pandas and the
-rest of the `SciPy <http://www.scipy.org/>`__ stack without needing to install
+rest of the `SciPy <https://www.scipy.org/>`__ stack without needing to install
 anything else, and without needing to wait for any software to be compiled.
 
-Installation instructions for `Anaconda <http://docs.continuum.io/anaconda/>`__
-`can be found here <http://docs.continuum.io/anaconda/install.html>`__.
+Installation instructions for `Anaconda <https://docs.continuum.io/anaconda/>`__
+`can be found here <https://docs.continuum.io/anaconda/install.html>`__.
 
 A full list of the packages available as part of the
-`Anaconda <http://docs.continuum.io/anaconda/>`__ distribution
-`can be found here <http://docs.continuum.io/anaconda/pkg-docs.html>`__.
+`Anaconda <https://docs.continuum.io/anaconda/>`__ distribution
+`can be found here <https://docs.continuum.io/anaconda/packages/pkg-docs/>`__.
 
 Another advantage to installing Anaconda is that you don't need
 admin rights to install it. Anaconda can install in the user's home directory,
@@ -62,28 +62,28 @@ Installing with Miniconda
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The previous section outlined how to get pandas installed as part of the
-`Anaconda <http://docs.continuum.io/anaconda/>`__ distribution.
+`Anaconda <https://docs.continuum.io/anaconda/>`__ distribution.
 However this approach means you will install well over one hundred packages
 and involves downloading the installer which is a few hundred megabytes in size.
 
 If you want to have more control on which packages, or have a limited internet
 bandwidth, then installing pandas with
-`Miniconda <http://conda.pydata.org/miniconda.html>`__ may be a better solution.
+`Miniconda <https://conda.pydata.org/miniconda.html>`__ may be a better solution.
 
-`Conda <http://conda.pydata.org/docs/>`__ is the package manager that the
-`Anaconda <http://docs.continuum.io/anaconda/>`__ distribution is built upon.
+`Conda <https://conda.pydata.org/docs/>`__ is the package manager that the
+`Anaconda <https://docs.continuum.io/anaconda/>`__ distribution is built upon.
 It is a package manager that is both cross-platform and language agnostic
 (it can play a similar role to a pip and virtualenv combination).
 
-`Miniconda <http://conda.pydata.org/miniconda.html>`__ allows you to create a
+`Miniconda <https://conda.pydata.org/miniconda.html>`__ allows you to create a
 minimal self contained Python installation, and then use the
-`Conda <http://conda.pydata.org/docs/>`__ command to install additional packages.
+`Conda <https://conda.pydata.org/docs/>`__ command to install additional packages.
 
-First you will need `Conda <http://conda.pydata.org/docs/>`__ to be installed and
+First you will need `Conda <https://conda.pydata.org/docs/>`__ to be installed and
 downloading and running the `Miniconda
-<http://conda.pydata.org/miniconda.html>`__
+<https://conda.pydata.org/miniconda.html>`__
 will do this for you. The installer
-`can be found here <http://conda.pydata.org/miniconda.html>`__
+`can be found here <https://conda.pydata.org/miniconda.html>`__
 
 The next step is to create a new conda environment. A conda environment is like a
 virtualenv that allows you to specify a specific version of Python and set of libraries.
@@ -113,7 +113,7 @@ To install other packages, IPython for example::
 
     conda install ipython
 
-To install the full `Anaconda <http://docs.continuum.io/anaconda/>`__
+To install the full `Anaconda <https://docs.continuum.io/anaconda/>`__
 distribution::
 
     conda install anaconda
@@ -140,23 +140,22 @@ Installing with ActivePython
 Installation instructions for
 `ActivePython <https://www.activestate.com/activepython>`__ can be found
 `here <https://www.activestate.com/activepython/downloads>`__. Versions
-2.7 and 3.5 include pandas.
+2.7, 3.5 and 3.6 include pandas.
 
 Installing using your Linux distribution's package manager.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The commands in this table will install pandas for Python 3 from your distribution.
-To install pandas for Python 2, you may need to use the ``python-pandas`` package.
 
 .. csv-table::
     :header: "Distribution", "Status", "Download / Repository Link", "Install method"
     :widths: 10, 10, 20, 50
 
 
-    Debian, stable, `official Debian repository <http://packages.debian.org/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
+    Debian, stable, `official Debian repository <https://packages.debian.org/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
     Debian & Ubuntu, unstable (latest packages), `NeuroDebian <http://neuro.debian.net/index.html#how-to-use-this-repository>`__ , ``sudo apt-get install python3-pandas``
-    Ubuntu, stable, `official Ubuntu repository <http://packages.ubuntu.com/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
-    OpenSuse, stable, `OpenSuse Repository  <http://software.opensuse.org/package/python-pandas?search_term=pandas>`__ , ``zypper in python3-pandas``
+    Ubuntu, stable, `official Ubuntu repository <https://packages.ubuntu.com/search?keywords=pandas&searchon=names&suite=all&section=all>`__ , ``sudo apt-get install python3-pandas``
+    OpenSuse, stable, `OpenSuse Repository  <https://software.opensuse.org/package/python-pandas?search_term=pandas>`__ , ``zypper in python3-pandas``
     Fedora, stable, `official Fedora repository  <https://admin.fedoraproject.org/pkgdb/package/rpms/python-pandas/>`__ , ``dnf install python3-pandas``
     Centos/RHEL, stable, `EPEL repository <https://admin.fedoraproject.org/pkgdb/package/rpms/python-pandas/>`__ , ``yum install python3-pandas``
 
@@ -164,6 +163,23 @@ To install pandas for Python 2, you may need to use the ``python-pandas`` packag
 to get the newest version of pandas, it's recommended to install using the ``pip`` or ``conda``
 methods described above.
 
+Handling ImportErrors
+~~~~~~~~~~~~~~~~~~~~~~
+
+If you encounter an ImportError, it usually means that Python couldn't find pandas in the list of available
+libraries. Python internally has a list of directories it searches through, to find packages. You can
+obtain these directories with::
+
+            import sys
+            sys.path
+
+One way you could be encountering this error is if you have multiple Python installations on your system
+and you don't have pandas installed in the Python installation you're currently using.
+In Linux/Mac you can run ``which python`` on your terminal and it will tell you which Python installation you're
+using. If it's something like "/usr/bin/python", you're using the Python from the system, which is not recommended.
+
+It is highly recommended to use ``conda``, for quick installation and for package and dependency updates.
+You can find simple installation instructions for pandas in this document: `installation instructions </getting_started.html>`.
 
 Installing from source
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -177,7 +193,7 @@ pandas is equipped with an exhaustive set of unit tests, covering about 97% of
 the code base as of this writing. To run it on your machine to verify that
 everything is working (and that you have all of the dependencies, soft and hard,
 installed), make sure you have `pytest
-<http://docs.pytest.org/en/latest/>`__ >= 4.0.2 and `Hypothesis
+<https://docs.pytest.org/en/latest/>`__ >= 5.0.1 and `Hypothesis
 <https://hypothesis.readthedocs.io/>`__ >= 3.58, then run:
 
 ::
@@ -204,9 +220,9 @@ Dependencies
 Package                                                          Minimum supported version
 ================================================================ ==========================
 `setuptools <https://setuptools.readthedocs.io/en/latest/>`__    24.2.0
-`NumPy <http://www.numpy.org>`__                                 1.13.3
+`NumPy <https://www.numpy.org>`__                                1.13.3
 `python-dateutil <https://dateutil.readthedocs.io/en/stable/>`__ 2.6.1
-`pytz <http://pytz.sourceforge.net/>`__                          2017.2
+`pytz <https://pypi.org/project/pytz/>`__                        2017.2
 ================================================================ ==========================
 
 .. _install.recommended_dependencies:
@@ -218,7 +234,7 @@ Recommended dependencies
   ``numexpr`` uses multiple cores as well as smart chunking and caching to achieve large speedups.
   If installed, must be Version 2.6.2 or higher.
 
-* `bottleneck <https://github.com/kwgoodman/bottleneck>`__: for accelerating certain types of ``nan``
+* `bottleneck <https://github.com/pydata/bottleneck>`__: for accelerating certain types of ``nan``
   evaluations. ``bottleneck`` uses specialized cython routines to achieve large speedups. If installed,
   must be Version 1.2.1 or higher.
 
@@ -234,7 +250,8 @@ Optional dependencies
 ~~~~~~~~~~~~~~~~~~~~~
 
 Pandas has many optional dependencies that are only used for specific methods.
-For example, :func:`pandas.read_hdf` requires the ``pytables`` package. If the
+For example, :func:`pandas.read_hdf` requires the ``pytables`` package, while
+:meth:`DataFrame.to_markdown` requires the ``tabulate`` package. If the
 optional dependency is not installed, pandas will raise an ``ImportError`` when
 the method requiring that dependency is called.
 
@@ -249,27 +266,30 @@ PyTables                  3.4.2              HDF5-based reading / writing
 SQLAlchemy                1.1.4              SQL support for databases other than sqlite
 SciPy                     0.19.0             Miscellaneous statistical functions
 XLsxWriter                0.9.8              Excel writing
-blosc                                        Compression for msgpack
-fastparquet               0.2.1              Parquet reading / writing
+blosc                                        Compression for HDF5
+fastparquet               0.3.2              Parquet reading / writing
 gcsfs                     0.2.2              Google Cloud Storage access
 html5lib                                     HTML parser for read_html (see :ref:`note <optional_html>`)
 lxml                      3.8.0              HTML parser for read_html (see :ref:`note <optional_html>`)
 matplotlib                2.2.2              Visualization
-openpyxl                  2.4.8              Reading / writing for xlsx files
+numba                     0.46.0             Alternative execution engine for rolling operations
+openpyxl                  2.5.7              Reading / writing for xlsx files
 pandas-gbq                0.8.0              Google Big Query access
 psycopg2                                     PostgreSQL engine for sqlalchemy
-pyarrow                   0.9.0              Parquet and feather reading / writing
+pyarrow                   0.12.0             Parquet, ORC (requires 0.13.0), and feather reading / writing
 pymysql                   0.7.11             MySQL engine for sqlalchemy
 pyreadstat                                   SPSS files (.sav) reading
 pytables                  3.4.2              HDF5 reading / writing
+pyxlsb                    1.0.6              Reading for xlsb files
 qtpy                                         Clipboard I/O
-s3fs                      0.0.8              Amazon S3 access
+s3fs                      0.3.0              Amazon S3 access
+tabulate                  0.8.3              Printing in Markdown-friendly format (see `tabulate`_)
 xarray                    0.8.2              pandas-like API for N-dimensional data
 xclip                                        Clipboard I/O on linux
 xlrd                      1.1.0              Excel reading
 xlwt                      1.2.0              Excel writing
 xsel                                         Clipboard I/O on linux
-zlib                                         Compression for msgpack
+zlib                                         Compression for HDF5
 ========================= ================== =============================================================
 
 .. _optional_html:
@@ -299,5 +319,6 @@ top-level :func:`~pandas.read_html` function:
       usage of the above three libraries.
 
 .. _html5lib: https://github.com/html5lib/html5lib-python
-.. _BeautifulSoup4: http://www.crummy.com/software/BeautifulSoup
-.. _lxml: http://lxml.de
+.. _BeautifulSoup4: https://www.crummy.com/software/BeautifulSoup
+.. _lxml: https://lxml.de
+.. _tabulate: https://github.com/astanin/python-tabulate
diff --git a/doc/source/getting_started/overview.rst b/doc/source/getting_started/overview.rst
index ec76c60f24257..d8a40c5406dee 100644
--- a/doc/source/getting_started/overview.rst
+++ b/doc/source/getting_started/overview.rst
@@ -57,8 +57,7 @@ Here are just a few of the things that pandas does well:
     Excel files, databases, and saving / loading data from the ultrafast **HDF5
     format**
   - **Time series**-specific functionality: date range generation and frequency
-    conversion, moving window statistics, moving window linear regressions,
-    date shifting and lagging, etc.
+    conversion, moving window statistics, date shifting and lagging.
 
 Many of these principles are here to address the shortcomings frequently
 experienced using other languages / scientific research environments. For data
diff --git a/doc/source/getting_started/tutorials.rst b/doc/source/getting_started/tutorials.rst
index 212f3636d0a98..434d791474807 100644
--- a/doc/source/getting_started/tutorials.rst
+++ b/doc/source/getting_started/tutorials.rst
@@ -15,7 +15,7 @@ pandas' own :ref:`10 Minutes to pandas<10min>`.
 
 More complex recipes are in the :ref:`Cookbook<cookbook>`.
 
-A handy pandas `cheat sheet <http://pandas.pydata.org/Pandas_Cheat_Sheet.pdf>`_.
+A handy pandas `cheat sheet <https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf>`_.
 
 Community guides
 ================
@@ -23,12 +23,12 @@ Community guides
 pandas Cookbook by Julia Evans
 ------------------------------
 
-The goal of this 2015 cookbook (by `Julia Evans <http://jvns.ca>`_) is to
+The goal of this 2015 cookbook (by `Julia Evans <https://jvns.ca>`_) is to
 give you some concrete examples for getting started with pandas. These
 are examples with real-world data, and all the bugs and weirdness that
 entails.
 For the table of contents, see the `pandas-cookbook GitHub
-repository <http://github.com/jvns/pandas-cookbook>`_.
+repository <https://github.com/jvns/pandas-cookbook>`_.
 
 Learn Pandas by Hernan Rojas
 ----------------------------
@@ -38,10 +38,10 @@ A set of lesson for new pandas users: https://bitbucket.org/hrojas/learn-pandas
 Practical data analysis with Python
 -----------------------------------
 
-This `guide <http://wavedatalab.github.io/datawithpython>`_ is an introduction to the data analysis process using the Python data ecosystem and an interesting open dataset.
-There are four sections covering selected topics as `munging data <http://wavedatalab.github.io/datawithpython/munge.html>`__,
-`aggregating data <http://wavedatalab.github.io/datawithpython/aggregate.html>`_, `visualizing data <http://wavedatalab.github.io/datawithpython/visualize.html>`_
-and `time series <http://wavedatalab.github.io/datawithpython/timeseries.html>`_.
+This `guide <https://wavedatalab.github.io/datawithpython>`_ is an introduction to the data analysis process using the Python data ecosystem and an interesting open dataset.
+There are four sections covering selected topics as `munging data <https://wavedatalab.github.io/datawithpython/munge.html>`__,
+`aggregating data <https://wavedatalab.github.io/datawithpython/aggregate.html>`_, `visualizing data <https://wavedatalab.github.io/datawithpython/visualize.html>`_
+and `time series <https://wavedatalab.github.io/datawithpython/timeseries.html>`_.
 
 .. _tutorial-exercises-new-users:
 
@@ -61,13 +61,13 @@ Tutorial series written in 2016 by
 The source may be found in the GitHub repository
 `TomAugspurger/effective-pandas <https://github.com/TomAugspurger/effective-pandas>`_.
 
-* `Modern Pandas <http://tomaugspurger.github.io/modern-1-intro.html>`_
-* `Method Chaining <http://tomaugspurger.github.io/method-chaining.html>`_
-* `Indexes <http://tomaugspurger.github.io/modern-3-indexes.html>`_
-* `Performance <http://tomaugspurger.github.io/modern-4-performance.html>`_
-* `Tidy Data <http://tomaugspurger.github.io/modern-5-tidy.html>`_
-* `Visualization <http://tomaugspurger.github.io/modern-6-visualization.html>`_
-* `Timeseries <http://tomaugspurger.github.io/modern-7-timeseries.html>`_
+* `Modern Pandas <https://tomaugspurger.github.io/modern-1-intro.html>`_
+* `Method Chaining <https://tomaugspurger.github.io/method-chaining.html>`_
+* `Indexes <https://tomaugspurger.github.io/modern-3-indexes.html>`_
+* `Performance <https://tomaugspurger.github.io/modern-4-performance.html>`_
+* `Tidy Data <https://tomaugspurger.github.io/modern-5-tidy.html>`_
+* `Visualization <https://tomaugspurger.github.io/modern-6-visualization.html>`_
+* `Timeseries <https://tomaugspurger.github.io/modern-7-timeseries.html>`_
 
 Excel charts with pandas, vincent and xlsxwriter
 ------------------------------------------------
@@ -89,21 +89,21 @@ Video tutorials
 * `Data analysis in Python with pandas <https://www.youtube.com/playlist?list=PL5-da3qGB5ICCsgW1MxlZ0Hq8LL5U3u9y>`_
   (2016-2018)
   `GitHub repo <https://github.com/justmarkham/pandas-videos>`__ and
-  `Jupyter Notebook <http://nbviewer.jupyter.org/github/justmarkham/pandas-videos/blob/master/pandas.ipynb>`__
+  `Jupyter Notebook <https://nbviewer.jupyter.org/github/justmarkham/pandas-videos/blob/master/pandas.ipynb>`__
 * `Best practices with pandas <https://www.youtube.com/playlist?list=PL5-da3qGB5IBITZj_dYSFqnd_15JgqwA6>`_
   (2018)
   `GitHub repo <https://github.com/justmarkham/pycon-2018-tutorial>`__ and
-  `Jupyter Notebook <http://nbviewer.jupyter.org/github/justmarkham/pycon-2018-tutorial/blob/master/tutorial.ipynb>`__
+  `Jupyter Notebook <https://nbviewer.jupyter.org/github/justmarkham/pycon-2018-tutorial/blob/master/tutorial.ipynb>`__
 
 
 Various tutorials
 -----------------
 
-* `Wes McKinney's (pandas BDFL) blog <http://blog.wesmckinney.com/>`_
+* `Wes McKinney's (pandas BDFL) blog <https://wesmckinney.com/archives.html>`_
 * `Statistical analysis made easy in Python with SciPy and pandas DataFrames, by Randal Olson <http://www.randalolson.com/2012/08/06/statistical-analysis-made-easy-in-python/>`_
-* `Statistical Data Analysis in Python, tutorial videos, by Christopher Fonnesbeck from SciPy 2013 <http://conference.scipy.org/scipy2013/tutorial_detail.php?id=109>`_
-* `Financial analysis in Python, by Thomas Wiecki <http://nbviewer.ipython.org/github/twiecki/financial-analysis-python-tutorial/blob/master/1.%20Pandas%20Basics.ipynb>`_
+* `Statistical Data Analysis in Python, tutorial videos, by Christopher Fonnesbeck from SciPy 2013 <https://conference.scipy.org/scipy2013/tutorial_detail.php?id=109>`_
+* `Financial analysis in Python, by Thomas Wiecki <https://nbviewer.ipython.org/github/twiecki/financial-analysis-python-tutorial/blob/master/1.%20Pandas%20Basics.ipynb>`_
 * `Intro to pandas data structures, by Greg Reda <http://www.gregreda.com/2013/10/26/intro-to-pandas-data-structures/>`_
-* `Pandas and Python: Top 10, by Manish Amde <http://manishamde.github.io/blog/2013/03/07/pandas-and-python-top-10/>`_
-* `Pandas DataFrames Tutorial, by Karlijn Willems <http://www.datacamp.com/community/tutorials/pandas-tutorial-dataframe-python>`_
+* `Pandas and Python: Top 10, by Manish Amde <https://manishamde.github.io/blog/2013/03/07/pandas-and-python-top-10/>`_
+* `Pandas DataFrames Tutorial, by Karlijn Willems <https://www.datacamp.com/community/tutorials/pandas-tutorial-dataframe-python>`_
 * `A concise tutorial with real life examples <https://tutswiki.com/pandas-cookbook/chapter1>`_
diff --git a/doc/source/index.rst.template b/doc/source/index.rst.template
index f5669626aa2b3..5690bb2e4a875 100644
--- a/doc/source/index.rst.template
+++ b/doc/source/index.rst.template
@@ -1,10 +1,12 @@
+:notoc:
+
 .. pandas documentation master file, created by
 
 .. module:: pandas
 
-*********************************************
-pandas: powerful Python data analysis toolkit
-*********************************************
+********************
+pandas documentation
+********************
 
 **Date**: |today| **Version**: |version|
 
@@ -21,7 +23,83 @@ pandas: powerful Python data analysis toolkit
 easy-to-use data structures and data analysis tools for the `Python <https://www.python.org/>`__
 programming language.
 
-See the :ref:`overview` for more detail about what's in the library.
+.. raw:: html
+
+    <div class="container">
+        <div class="row">
+            <div class="col-lg-6 col-md-6 col-sm-6 col-xs-12 d-flex">
+                <div class="card text-center intro-card shadow">
+                <img src="_static/index_getting_started.svg" class="card-img-top" alt="getting started with pandas action icon" height="52">
+                <div class="card-body flex-fill">
+                    <h5 class="card-title">Getting started</h5>
+                    <p class="card-text">New to <em>pandas</em>? Check out the getting started guides. They
+                    contain an introduction to <em>pandas'</em> main concepts and links to additional tutorials.</p>
+
+.. container:: custom-button
+
+    :ref:`To the getting started guides<getting_started>`
+
+.. raw:: html
+
+                </div>
+                </div>
+            </div>
+            <div class="col-lg-6 col-md-6 col-sm-6 col-xs-12 d-flex">
+                <div class="card text-center intro-card shadow">
+                <img src="_static/index_user_guide.svg" class="card-img-top" alt="pandas user guide action icon" height="52">
+                <div class="card-body flex-fill">
+                    <h5 class="card-title">User guide</h5>
+                    <p class="card-text">The user guide provides in-depth information on the
+                    key concepts of pandas with useful background information and explanation.</p>
+
+.. container:: custom-button
+
+    :ref:`To the user guide<user_guide>`
+
+.. raw:: html
+
+                </div>
+                </div>
+            </div>
+            <div class="col-lg-6 col-md-6 col-sm-6 col-xs-12 d-flex">
+                <div class="card text-center intro-card shadow">
+                <img src="_static/index_api.svg" class="card-img-top" alt="api of pandas action icon" height="52">
+                <div class="card-body flex-fill">
+                    <h5 class="card-title">API reference</h5>
+                    <p class="card-text">The reference guide contains a detailed description of
+                    the pandas API. The reference describes how the methods work and which parameters can
+                    be used. It assumes that you have an understanding of the key concepts.</p>
+
+.. container:: custom-button
+
+    :ref:`To the reference guide<api>`
+
+.. raw:: html
+
+                </div>
+                </div>
+            </div>
+            <div class="col-lg-6 col-md-6 col-sm-6 col-xs-12 d-flex">
+                <div class="card text-center intro-card shadow">
+                <img src="_static/index_contribute.svg" class="card-img-top" alt="contribute to pandas action icon" height="52">
+                <div class="card-body flex-fill">
+                    <h5 class="card-title">Developer guide</h5>
+                    <p class="card-text">Saw a typo in the documentation? Want to improve
+                    existing functionalities? The contributing guidelines will guide
+                    you through the process of improving pandas.</p>
+
+.. container:: custom-button
+
+    :ref:`To the development guide<development>`
+
+.. raw:: html
+
+                </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
 
 {% if single_doc and single_doc.endswith('.rst') -%}
 .. toctree::
@@ -39,11 +117,9 @@ See the :ref:`overview` for more detail about what's in the library.
     :hidden:
 {% endif %}
 {% if not single_doc %}
-    What's New in 1.0.0 <whatsnew/v1.0.0>
-    install
+    What's New in 1.1.0 <whatsnew/v1.1.0>
     getting_started/index
     user_guide/index
-    ecosystem
     {% endif -%}
     {% if include_api -%}
     reference/index
@@ -52,65 +128,3 @@ See the :ref:`overview` for more detail about what's in the library.
     development/index
     whatsnew/index
 {% endif %}
-
-* :doc:`whatsnew/v1.0.0`
-* :doc:`install`
-* :doc:`getting_started/index`
-
-  * :doc:`getting_started/overview`
-  * :doc:`getting_started/10min`
-  * :doc:`getting_started/basics`
-  * :doc:`getting_started/dsintro`
-  * :doc:`getting_started/comparison/index`
-  * :doc:`getting_started/tutorials`
-
-* :doc:`user_guide/index`
-
-  * :doc:`user_guide/io`
-  * :doc:`user_guide/indexing`
-  * :doc:`user_guide/advanced`
-  * :doc:`user_guide/merging`
-  * :doc:`user_guide/reshaping`
-  * :doc:`user_guide/text`
-  * :doc:`user_guide/missing_data`
-  * :doc:`user_guide/categorical`
-  * :doc:`user_guide/integer_na`
-  * :doc:`user_guide/visualization`
-  * :doc:`user_guide/computation`
-  * :doc:`user_guide/groupby`
-  * :doc:`user_guide/timeseries`
-  * :doc:`user_guide/timedeltas`
-  * :doc:`user_guide/style`
-  * :doc:`user_guide/options`
-  * :doc:`user_guide/enhancingperf`
-  * :doc:`user_guide/sparse`
-  * :doc:`user_guide/gotchas`
-  * :doc:`user_guide/cookbook`
-
-* :doc:`ecosystem`
-* :doc:`reference/index`
-
-  * :doc:`reference/io`
-  * :doc:`reference/general_functions`
-  * :doc:`reference/series`
-  * :doc:`reference/frame`
-  * :doc:`reference/arrays`
-  * :doc:`reference/panel`
-  * :doc:`reference/indexing`
-  * :doc:`reference/offset_frequency`
-  * :doc:`reference/window`
-  * :doc:`reference/groupby`
-  * :doc:`reference/resampling`
-  * :doc:`reference/style`
-  * :doc:`reference/plotting`
-  * :doc:`reference/general_utility_functions`
-  * :doc:`reference/extensions`
-
-* :doc:`development/index`
-
-  * :doc:`development/contributing`
-  * :doc:`development/internals`
-  * :doc:`development/extending`
-  * :doc:`development/developer`
-
-* :doc:`whatsnew/index`
diff --git a/doc/source/reference/arrays.rst b/doc/source/reference/arrays.rst
index 7f464bf952bfb..c71350ecd73b3 100644
--- a/doc/source/reference/arrays.rst
+++ b/doc/source/reference/arrays.rst
@@ -12,7 +12,8 @@ For most data types, pandas uses NumPy arrays as the concrete
 objects contained with a :class:`Index`, :class:`Series`, or
 :class:`DataFrame`.
 
-For some data types, pandas extends NumPy's type system.
+For some data types, pandas extends NumPy's type system. String aliases for these types
+can be found at :ref:`basics.dtypes`.
 
 =================== ========================= ================== =============================
 Kind of Data        Pandas Data Type          Scalar             Array
@@ -24,6 +25,8 @@ Intervals           :class:`IntervalDtype`    :class:`Interval`  :ref:`api.array
 Nullable Integer    :class:`Int64Dtype`, ...  (none)             :ref:`api.arrays.integer_na`
 Categorical         :class:`CategoricalDtype` (none)             :ref:`api.arrays.categorical`
 Sparse              :class:`SparseDtype`      (none)             :ref:`api.arrays.sparse`
+Strings             :class:`StringDtype`      :class:`str`       :ref:`api.arrays.string`
+Boolean (with NA)   :class:`BooleanDtype`     :class:`bool`      :ref:`api.arrays.bool`
 =================== ========================= ================== =============================
 
 Pandas and third-party libraries can extend NumPy's type system (see :ref:`extending.extension-types`).
@@ -441,13 +444,13 @@ Sparse data
 -----------
 
 Data where a single value is repeated many times (e.g. ``0`` or ``NaN``) may
-be stored efficiently as a :class:`SparseArray`.
+be stored efficiently as a :class:`arrays.SparseArray`.
 
 .. autosummary::
    :toctree: api/
    :template: autosummary/class_without_autosummary.rst
 
-   SparseArray
+   arrays.SparseArray
 
 .. autosummary::
    :toctree: api/
@@ -460,6 +463,51 @@ and methods if the :class:`Series` contains sparse values. See
 :ref:`api.series.sparse` for more.
 
 
+.. _api.arrays.string:
+
+Text data
+---------
+
+When working with text data, where each valid element is a string or missing,
+we recommend using :class:`StringDtype` (with the alias ``"string"``).
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   arrays.StringArray
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   StringDtype
+
+The ``Series.str`` accessor is available for ``Series`` backed by a :class:`arrays.StringArray`.
+See :ref:`api.series.str` for more.
+
+
+.. _api.arrays.bool:
+
+Boolean data with missing values
+--------------------------------
+
+The boolean dtype (with the alias ``"boolean"``) provides support for storing
+boolean data (True, False values) with missing values, which is not possible
+with a bool :class:`numpy.ndarray`.
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   arrays.BooleanArray
+
+.. autosummary::
+   :toctree: api/
+   :template: autosummary/class_without_autosummary.rst
+
+   BooleanDtype
+
 
 .. Dtype attributes which are manually listed in their docstrings: including
 .. it here to make sure a docstring page is built for them
@@ -471,4 +519,4 @@ and methods if the :class:`Series` contains sparse values. See
       DatetimeTZDtype.unit
       DatetimeTZDtype.tz
       PeriodDtype.freq
-      IntervalDtype.subtype
\ No newline at end of file
+      IntervalDtype.subtype
diff --git a/doc/source/reference/extensions.rst b/doc/source/reference/extensions.rst
index 4b1a99da7cd4c..78fdfbfd28144 100644
--- a/doc/source/reference/extensions.rst
+++ b/doc/source/reference/extensions.rst
@@ -59,3 +59,16 @@ objects.
       api.extensions.ExtensionArray.nbytes
       api.extensions.ExtensionArray.ndim
       api.extensions.ExtensionArray.shape
+
+Additionally, we have some utility methods for ensuring your object
+behaves correctly.
+
+.. autosummary::
+  :toctree: api/
+
+  api.indexers.check_array_indexer
+
+
+The sentinel ``pandas.api.extensions.no_default`` is used as the default
+value in some methods. Use an ``is`` comparison to check if the user
+provides a non-default value.
diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst
index b1c6172fb1261..c7b1cc1c832be 100644
--- a/doc/source/reference/frame.rst
+++ b/doc/source/reference/frame.rst
@@ -28,19 +28,15 @@ Attributes and underlying data
    :toctree: api/
 
    DataFrame.dtypes
-   DataFrame.ftypes
-   DataFrame.get_dtype_counts
-   DataFrame.get_ftype_counts
+   DataFrame.info
    DataFrame.select_dtypes
    DataFrame.values
-   DataFrame.get_values
    DataFrame.axes
    DataFrame.ndim
    DataFrame.size
    DataFrame.shape
    DataFrame.memory_usage
    DataFrame.empty
-   DataFrame.is_copy
 
 Conversion
 ~~~~~~~~~~
@@ -48,6 +44,7 @@ Conversion
    :toctree: api/
 
    DataFrame.astype
+   DataFrame.convert_dtypes
    DataFrame.infer_objects
    DataFrame.copy
    DataFrame.isna
@@ -142,9 +139,6 @@ Computations / descriptive stats
    DataFrame.all
    DataFrame.any
    DataFrame.clip
-   DataFrame.clip_lower
-   DataFrame.clip_upper
-   DataFrame.compound
    DataFrame.corr
    DataFrame.corrwith
    DataFrame.count
@@ -274,6 +268,21 @@ Time series-related
    DataFrame.tz_convert
    DataFrame.tz_localize
 
+.. _api.frame.metadata:
+
+Metadata
+~~~~~~~~
+
+:attr:`DataFrame.attrs` is a dictionary for storing global metadata for this DataFrame.
+
+.. warning:: ``DataFrame.attrs`` is considered experimental and may change without warning.
+
+.. autosummary::
+   :toctree: api/
+
+   DataFrame.attrs
+
+
 .. _api.dataframe.plotting:
 
 Plotting
@@ -338,9 +347,7 @@ Serialization / IO / conversion
    :toctree: api/
 
    DataFrame.from_dict
-   DataFrame.from_items
    DataFrame.from_records
-   DataFrame.info
    DataFrame.to_parquet
    DataFrame.to_pickle
    DataFrame.to_csv
@@ -353,18 +360,9 @@ Serialization / IO / conversion
    DataFrame.to_feather
    DataFrame.to_latex
    DataFrame.to_stata
-   DataFrame.to_msgpack
    DataFrame.to_gbq
    DataFrame.to_records
-   DataFrame.to_sparse
-   DataFrame.to_dense
    DataFrame.to_string
    DataFrame.to_clipboard
+   DataFrame.to_markdown
    DataFrame.style
-
-Sparse
-~~~~~~
-.. autosummary::
-   :toctree: api/
-
-   SparseDataFrame.to_coo
diff --git a/doc/source/reference/general_utility_functions.rst b/doc/source/reference/general_utility_functions.rst
index 9c69770c0f1b7..0d9e0b0f4c668 100644
--- a/doc/source/reference/general_utility_functions.rst
+++ b/doc/source/reference/general_utility_functions.rst
@@ -18,6 +18,8 @@ Working with options
    set_option
    option_context
 
+.. _api.general.testing:
+
 Testing functions
 -----------------
 .. autosummary::
@@ -26,6 +28,7 @@ Testing functions
    testing.assert_frame_equal
    testing.assert_series_equal
    testing.assert_index_equal
+   testing.assert_extension_array_equal
 
 Exceptions and warnings
 -----------------------
@@ -97,13 +100,11 @@ Scalar introspection
     api.types.is_bool
     api.types.is_categorical
     api.types.is_complex
-    api.types.is_datetimetz
     api.types.is_float
     api.types.is_hashable
     api.types.is_integer
     api.types.is_interval
     api.types.is_number
-    api.types.is_period
     api.types.is_re
     api.types.is_re_compilable
     api.types.is_scalar
diff --git a/doc/source/reference/index.rst b/doc/source/reference/index.rst
index 12ca318c815d3..9d5649c37e92f 100644
--- a/doc/source/reference/index.rst
+++ b/doc/source/reference/index.rst
@@ -49,7 +49,6 @@ public functions related to data types in pandas.
 
         api/pandas.DataFrame.blocks
         api/pandas.DataFrame.as_matrix
-        api/pandas.DataFrame.ix
         api/pandas.Index.asi8
         api/pandas.Index.data
         api/pandas.Index.flags
@@ -60,7 +59,6 @@ public functions related to data types in pandas.
         api/pandas.Series.asobject
         api/pandas.Series.blocks
         api/pandas.Series.from_array
-        api/pandas.Series.ix
         api/pandas.Series.imag
         api/pandas.Series.real
 
diff --git a/doc/source/reference/indexing.rst b/doc/source/reference/indexing.rst
index 576f734d517aa..ab6ea5aea6c61 100644
--- a/doc/source/reference/indexing.rst
+++ b/doc/source/reference/indexing.rst
@@ -32,7 +32,6 @@ Properties
    Index.has_duplicates
    Index.hasnans
    Index.dtype
-   Index.dtype_str
    Index.inferred_type
    Index.is_all_dates
    Index.shape
@@ -42,9 +41,6 @@ Properties
    Index.ndim
    Index.size
    Index.empty
-   Index.strides
-   Index.itemsize
-   Index.base
    Index.T
    Index.memory_usage
 
@@ -93,7 +89,6 @@ Compatibility with MultiIndex
    :toctree: api/
 
    Index.set_names
-   Index.is_lexsorted_for_tuple
    Index.droplevel
 
 Missing values
@@ -156,8 +151,6 @@ Selecting
 
    Index.asof
    Index.asof_locs
-   Index.contains
-   Index.get_duplicates
    Index.get_indexer
    Index.get_indexer_for
    Index.get_indexer_non_unique
@@ -165,8 +158,6 @@ Selecting
    Index.get_loc
    Index.get_slice_bound
    Index.get_value
-   Index.get_values
-   Index.set_value
    Index.isin
    Index.slice_indexer
    Index.slice_locs
@@ -307,7 +298,6 @@ MultiIndex components
 
    MultiIndex.set_levels
    MultiIndex.set_codes
-   MultiIndex.to_hierarchical
    MultiIndex.to_flat_index
    MultiIndex.to_frame
    MultiIndex.is_lexsorted
@@ -323,6 +313,7 @@ MultiIndex selecting
    :toctree: api/
 
    MultiIndex.get_loc
+   MultiIndex.get_locs
    MultiIndex.get_loc_level
    MultiIndex.get_indexer
    MultiIndex.get_level_values
diff --git a/doc/source/reference/io.rst b/doc/source/reference/io.rst
index 91f4942d03b0d..0037d4a4410c3 100644
--- a/doc/source/reference/io.rst
+++ b/doc/source/reference/io.rst
@@ -22,7 +22,6 @@ Flat file
    read_table
    read_csv
    read_fwf
-   read_msgpack
 
 Clipboard
 ~~~~~~~~~
@@ -51,13 +50,13 @@ JSON
    :toctree: api/
 
    read_json
+   json_normalize
 
 .. currentmodule:: pandas.io.json
 
 .. autosummary::
    :toctree: api/
 
-   json_normalize
    build_table_schema
 
 .. currentmodule:: pandas
@@ -98,6 +97,13 @@ Parquet
 
    read_parquet
 
+ORC
+~~~
+.. autosummary::
+   :toctree: api/
+
+   read_orc
+
 SAS
 ~~~
 .. autosummary::
@@ -140,7 +146,6 @@ STATA
 .. autosummary::
    :toctree: api/
 
-   StataReader.data
    StataReader.data_label
    StataReader.value_labels
    StataReader.variable_labels
diff --git a/doc/source/reference/offset_frequency.rst b/doc/source/reference/offset_frequency.rst
index 4a58055f1c955..fc1c6d6bd6d47 100644
--- a/doc/source/reference/offset_frequency.rst
+++ b/doc/source/reference/offset_frequency.rst
@@ -35,6 +35,8 @@ Methods
     DateOffset.copy
     DateOffset.isAnchored
     DateOffset.onOffset
+    DateOffset.is_anchored
+    DateOffset.is_on_offset
 
 BusinessDay
 -----------
@@ -65,6 +67,8 @@ Methods
     BusinessDay.copy
     BusinessDay.isAnchored
     BusinessDay.onOffset
+    BusinessDay.is_anchored
+    BusinessDay.is_on_offset
 
 BusinessHour
 ------------
@@ -94,6 +98,8 @@ Methods
     BusinessHour.copy
     BusinessHour.isAnchored
     BusinessHour.onOffset
+    BusinessHour.is_anchored
+    BusinessHour.is_on_offset
 
 CustomBusinessDay
 -----------------
@@ -123,6 +129,8 @@ Methods
     CustomBusinessDay.copy
     CustomBusinessDay.isAnchored
     CustomBusinessDay.onOffset
+    CustomBusinessDay.is_anchored
+    CustomBusinessDay.is_on_offset
 
 CustomBusinessHour
 ------------------
@@ -152,6 +160,8 @@ Methods
     CustomBusinessHour.copy
     CustomBusinessHour.isAnchored
     CustomBusinessHour.onOffset
+    CustomBusinessHour.is_anchored
+    CustomBusinessHour.is_on_offset
 
 MonthOffset
 -----------
@@ -182,6 +192,8 @@ Methods
     MonthOffset.copy
     MonthOffset.isAnchored
     MonthOffset.onOffset
+    MonthOffset.is_anchored
+    MonthOffset.is_on_offset
 
 MonthEnd
 --------
@@ -212,6 +224,8 @@ Methods
     MonthEnd.copy
     MonthEnd.isAnchored
     MonthEnd.onOffset
+    MonthEnd.is_anchored
+    MonthEnd.is_on_offset
 
 MonthBegin
 ----------
@@ -242,6 +256,8 @@ Methods
     MonthBegin.copy
     MonthBegin.isAnchored
     MonthBegin.onOffset
+    MonthBegin.is_anchored
+    MonthBegin.is_on_offset
 
 BusinessMonthEnd
 ----------------
@@ -272,6 +288,8 @@ Methods
     BusinessMonthEnd.copy
     BusinessMonthEnd.isAnchored
     BusinessMonthEnd.onOffset
+    BusinessMonthEnd.is_anchored
+    BusinessMonthEnd.is_on_offset
 
 BusinessMonthBegin
 ------------------
@@ -302,6 +320,8 @@ Methods
     BusinessMonthBegin.copy
     BusinessMonthBegin.isAnchored
     BusinessMonthBegin.onOffset
+    BusinessMonthBegin.is_anchored
+    BusinessMonthBegin.is_on_offset
 
 CustomBusinessMonthEnd
 ----------------------
@@ -332,6 +352,8 @@ Methods
     CustomBusinessMonthEnd.copy
     CustomBusinessMonthEnd.isAnchored
     CustomBusinessMonthEnd.onOffset
+    CustomBusinessMonthEnd.is_anchored
+    CustomBusinessMonthEnd.is_on_offset
 
 CustomBusinessMonthBegin
 ------------------------
@@ -362,6 +384,8 @@ Methods
     CustomBusinessMonthBegin.copy
     CustomBusinessMonthBegin.isAnchored
     CustomBusinessMonthBegin.onOffset
+    CustomBusinessMonthBegin.is_anchored
+    CustomBusinessMonthBegin.is_on_offset
 
 SemiMonthOffset
 ---------------
@@ -392,6 +416,8 @@ Methods
     SemiMonthOffset.copy
     SemiMonthOffset.isAnchored
     SemiMonthOffset.onOffset
+    SemiMonthOffset.is_anchored
+    SemiMonthOffset.is_on_offset
 
 SemiMonthEnd
 ------------
@@ -422,6 +448,8 @@ Methods
     SemiMonthEnd.copy
     SemiMonthEnd.isAnchored
     SemiMonthEnd.onOffset
+    SemiMonthEnd.is_anchored
+    SemiMonthEnd.is_on_offset
 
 SemiMonthBegin
 --------------
@@ -452,6 +480,8 @@ Methods
     SemiMonthBegin.copy
     SemiMonthBegin.isAnchored
     SemiMonthBegin.onOffset
+    SemiMonthBegin.is_anchored
+    SemiMonthBegin.is_on_offset
 
 Week
 ----
@@ -482,6 +512,8 @@ Methods
     Week.copy
     Week.isAnchored
     Week.onOffset
+    Week.is_anchored
+    Week.is_on_offset
 
 WeekOfMonth
 -----------
@@ -511,6 +543,8 @@ Methods
     WeekOfMonth.copy
     WeekOfMonth.isAnchored
     WeekOfMonth.onOffset
+    WeekOfMonth.is_anchored
+    WeekOfMonth.is_on_offset
 
 LastWeekOfMonth
 ---------------
@@ -540,6 +574,8 @@ Methods
     LastWeekOfMonth.copy
     LastWeekOfMonth.isAnchored
     LastWeekOfMonth.onOffset
+    LastWeekOfMonth.is_anchored
+    LastWeekOfMonth.is_on_offset
 
 QuarterOffset
 -------------
@@ -570,6 +606,8 @@ Methods
     QuarterOffset.copy
     QuarterOffset.isAnchored
     QuarterOffset.onOffset
+    QuarterOffset.is_anchored
+    QuarterOffset.is_on_offset
 
 BQuarterEnd
 -----------
@@ -600,6 +638,8 @@ Methods
     BQuarterEnd.copy
     BQuarterEnd.isAnchored
     BQuarterEnd.onOffset
+    BQuarterEnd.is_anchored
+    BQuarterEnd.is_on_offset
 
 BQuarterBegin
 -------------
@@ -630,6 +670,8 @@ Methods
     BQuarterBegin.copy
     BQuarterBegin.isAnchored
     BQuarterBegin.onOffset
+    BQuarterBegin.is_anchored
+    BQuarterBegin.is_on_offset
 
 QuarterEnd
 ----------
@@ -660,6 +702,8 @@ Methods
     QuarterEnd.copy
     QuarterEnd.isAnchored
     QuarterEnd.onOffset
+    QuarterEnd.is_anchored
+    QuarterEnd.is_on_offset
 
 QuarterBegin
 ------------
@@ -690,6 +734,8 @@ Methods
     QuarterBegin.copy
     QuarterBegin.isAnchored
     QuarterBegin.onOffset
+    QuarterBegin.is_anchored
+    QuarterBegin.is_on_offset
 
 YearOffset
 ----------
@@ -720,6 +766,8 @@ Methods
     YearOffset.copy
     YearOffset.isAnchored
     YearOffset.onOffset
+    YearOffset.is_anchored
+    YearOffset.is_on_offset
 
 BYearEnd
 --------
@@ -750,6 +798,8 @@ Methods
     BYearEnd.copy
     BYearEnd.isAnchored
     BYearEnd.onOffset
+    BYearEnd.is_anchored
+    BYearEnd.is_on_offset
 
 BYearBegin
 ----------
@@ -780,6 +830,8 @@ Methods
     BYearBegin.copy
     BYearBegin.isAnchored
     BYearBegin.onOffset
+    BYearBegin.is_anchored
+    BYearBegin.is_on_offset
 
 YearEnd
 -------
@@ -810,6 +862,8 @@ Methods
     YearEnd.copy
     YearEnd.isAnchored
     YearEnd.onOffset
+    YearEnd.is_anchored
+    YearEnd.is_on_offset
 
 YearBegin
 ---------
@@ -840,6 +894,8 @@ Methods
     YearBegin.copy
     YearBegin.isAnchored
     YearBegin.onOffset
+    YearBegin.is_anchored
+    YearBegin.is_on_offset
 
 FY5253
 ------
@@ -871,6 +927,8 @@ Methods
     FY5253.get_year_end
     FY5253.isAnchored
     FY5253.onOffset
+    FY5253.is_anchored
+    FY5253.is_on_offset
 
 FY5253Quarter
 -------------
@@ -901,6 +959,8 @@ Methods
     FY5253Quarter.get_weeks
     FY5253Quarter.isAnchored
     FY5253Quarter.onOffset
+    FY5253Quarter.is_anchored
+    FY5253Quarter.is_on_offset
     FY5253Quarter.year_has_extra_week
 
 Easter
@@ -931,6 +991,8 @@ Methods
     Easter.copy
     Easter.isAnchored
     Easter.onOffset
+    Easter.is_anchored
+    Easter.is_on_offset
 
 Tick
 ----
@@ -960,6 +1022,8 @@ Methods
     Tick.copy
     Tick.isAnchored
     Tick.onOffset
+    Tick.is_anchored
+    Tick.is_on_offset
 
 Day
 ---
@@ -989,6 +1053,8 @@ Methods
     Day.copy
     Day.isAnchored
     Day.onOffset
+    Day.is_anchored
+    Day.is_on_offset
 
 Hour
 ----
@@ -1018,6 +1084,8 @@ Methods
     Hour.copy
     Hour.isAnchored
     Hour.onOffset
+    Hour.is_anchored
+    Hour.is_on_offset
 
 Minute
 ------
@@ -1047,6 +1115,8 @@ Methods
     Minute.copy
     Minute.isAnchored
     Minute.onOffset
+    Minute.is_anchored
+    Minute.is_on_offset
 
 Second
 ------
@@ -1076,6 +1146,8 @@ Methods
     Second.copy
     Second.isAnchored
     Second.onOffset
+    Second.is_anchored
+    Second.is_on_offset
 
 Milli
 -----
@@ -1105,6 +1177,8 @@ Methods
     Milli.copy
     Milli.isAnchored
     Milli.onOffset
+    Milli.is_anchored
+    Milli.is_on_offset
 
 Micro
 -----
@@ -1134,6 +1208,8 @@ Methods
     Micro.copy
     Micro.isAnchored
     Micro.onOffset
+    Micro.is_anchored
+    Micro.is_on_offset
 
 Nano
 ----
@@ -1163,6 +1239,8 @@ Methods
     Nano.copy
     Nano.isAnchored
     Nano.onOffset
+    Nano.is_anchored
+    Nano.is_on_offset
 
 BDay
 ----
@@ -1195,6 +1273,8 @@ Methods
     BDay.copy
     BDay.isAnchored
     BDay.onOffset
+    BDay.is_anchored
+    BDay.is_on_offset
     BDay.rollback
     BDay.rollforward
 
@@ -1228,6 +1308,8 @@ Methods
     BMonthEnd.copy
     BMonthEnd.isAnchored
     BMonthEnd.onOffset
+    BMonthEnd.is_anchored
+    BMonthEnd.is_on_offset
     BMonthEnd.rollback
     BMonthEnd.rollforward
 
@@ -1261,6 +1343,8 @@ Methods
     BMonthBegin.copy
     BMonthBegin.isAnchored
     BMonthBegin.onOffset
+    BMonthBegin.is_anchored
+    BMonthBegin.is_on_offset
     BMonthBegin.rollback
     BMonthBegin.rollforward
 
@@ -1298,6 +1382,8 @@ Methods
     CBMonthEnd.copy
     CBMonthEnd.isAnchored
     CBMonthEnd.onOffset
+    CBMonthEnd.is_anchored
+    CBMonthEnd.is_on_offset
     CBMonthEnd.rollback
     CBMonthEnd.rollforward
 
@@ -1335,6 +1421,8 @@ Methods
     CBMonthBegin.copy
     CBMonthBegin.isAnchored
     CBMonthBegin.onOffset
+    CBMonthBegin.is_anchored
+    CBMonthBegin.is_on_offset
     CBMonthBegin.rollback
     CBMonthBegin.rollforward
 
@@ -1369,6 +1457,8 @@ Methods
     CDay.copy
     CDay.isAnchored
     CDay.onOffset
+    CDay.is_anchored
+    CDay.is_on_offset
     CDay.rollback
     CDay.rollforward
 
diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst
index 7ba625c141f24..1a69fa076dbf0 100644
--- a/doc/source/reference/series.rst
+++ b/doc/source/reference/series.rst
@@ -29,25 +29,16 @@ Attributes
    Series.array
    Series.values
    Series.dtype
-   Series.ftype
    Series.shape
    Series.nbytes
    Series.ndim
    Series.size
-   Series.strides
-   Series.itemsize
-   Series.base
    Series.T
    Series.memory_usage
    Series.hasnans
-   Series.flags
    Series.empty
    Series.dtypes
-   Series.ftypes
-   Series.data
-   Series.is_copy
    Series.name
-   Series.put
 
 Conversion
 ----------
@@ -55,6 +46,7 @@ Conversion
    :toctree: api/
 
    Series.astype
+   Series.convert_dtypes
    Series.infer_objects
    Series.copy
    Series.bool
@@ -62,7 +54,6 @@ Conversion
    Series.to_period
    Series.to_timestamp
    Series.to_list
-   Series.get_values
    Series.__array__
 
 Indexing, iteration
@@ -148,8 +139,6 @@ Computations / descriptive stats
    Series.autocorr
    Series.between
    Series.clip
-   Series.clip_lower
-   Series.clip_upper
    Series.corr
    Series.count
    Series.cov
@@ -186,7 +175,6 @@ Computations / descriptive stats
    Series.is_monotonic_increasing
    Series.is_monotonic_decreasing
    Series.value_counts
-   Series.compound
 
 Reindexing / selection / label manipulation
 -------------------------------------------
@@ -531,6 +519,21 @@ Sparse-dtype specific methods and attributes are provided under the
    Series.sparse.to_coo
 
 
+.. _api.series.metadata:
+
+Metadata
+~~~~~~~~
+
+:attr:`Series.attrs` is a dictionary for storing global metadata for this Series.
+
+.. warning:: ``Series.attrs`` is considered experimental and may change without warning.
+
+.. autosummary::
+   :toctree: api/
+
+   Series.attrs
+
+
 Plotting
 --------
 ``Series.plot`` is both a callable method and a namespace attribute for
@@ -574,20 +577,8 @@ Serialization / IO / conversion
    Series.to_xarray
    Series.to_hdf
    Series.to_sql
-   Series.to_msgpack
    Series.to_json
-   Series.to_sparse
-   Series.to_dense
    Series.to_string
    Series.to_clipboard
    Series.to_latex
-
-
-Sparse
-------
-
-.. autosummary::
-   :toctree: api/
-
-   SparseSeries.to_coo
-   SparseSeries.from_coo
+   Series.to_markdown
diff --git a/doc/source/reference/style.rst b/doc/source/reference/style.rst
index 3d155535e2585..24a47336b0522 100644
--- a/doc/source/reference/style.rst
+++ b/doc/source/reference/style.rst
@@ -41,6 +41,7 @@ Style application
    Styler.set_caption
    Styler.set_properties
    Styler.set_uuid
+   Styler.set_na_rep
    Styler.clear
    Styler.pipe
 
diff --git a/doc/source/reference/window.rst b/doc/source/reference/window.rst
index 2f6addf607877..3db1aa12a4275 100644
--- a/doc/source/reference/window.rst
+++ b/doc/source/reference/window.rst
@@ -34,6 +34,8 @@ Standard moving window functions
    Rolling.quantile
    Window.mean
    Window.sum
+   Window.var
+   Window.std
 
 .. _api.functions_expanding:
 
@@ -72,3 +74,14 @@ Exponentially-weighted moving window functions
    EWM.var
    EWM.corr
    EWM.cov
+
+Window Indexer
+--------------
+.. currentmodule:: pandas
+
+Base class for defining custom window boundaries.
+
+.. autosummary::
+   :toctree: api/
+
+   api.indexers.BaseIndexer
diff --git a/doc/source/user_guide/advanced.rst b/doc/source/user_guide/advanced.rst
index 62a9b6396404a..d6f5c0c758b60 100644
--- a/doc/source/user_guide/advanced.rst
+++ b/doc/source/user_guide/advanced.rst
@@ -206,8 +206,6 @@ highly performant. If you want to see only the used levels, you can use the
 To reconstruct the ``MultiIndex`` with only the used levels, the
 :meth:`~MultiIndex.remove_unused_levels` method may be used.
 
-.. versionadded:: 0.20.0
-
 .. ipython:: python
 
    new_mi = df[['foo', 'qux']].columns.remove_unused_levels()
@@ -556,6 +554,27 @@ index.
 Both ``rename`` and ``rename_axis`` support specifying a dictionary,
 ``Series`` or a mapping function to map labels/names to new values.
 
+When working with an ``Index`` object directly, rather than via a ``DataFrame``,
+:meth:`Index.set_names` can be used to change the names.
+
+.. ipython:: python
+
+   mi = pd.MultiIndex.from_product([[1, 2], ['a', 'b']], names=['x', 'y'])
+   mi.names
+
+   mi2 = mi.rename("new name", level=0)
+   mi2
+
+
+You cannot set the names of the MultiIndex via a level.
+
+.. ipython:: python
+   :okexcept:
+
+   mi.levels[0].name = "name via level"
+
+Use :meth:`Index.set_names` instead.
+
 Sorting a ``MultiIndex``
 ------------------------
 
@@ -783,27 +802,41 @@ values **not** in the categories, similarly to how you can reindex **any** panda
 
 .. ipython:: python
 
-   df2.reindex(['a', 'e'])
-   df2.reindex(['a', 'e']).index
-   df2.reindex(pd.Categorical(['a', 'e'], categories=list('abcde')))
-   df2.reindex(pd.Categorical(['a', 'e'], categories=list('abcde'))).index
+   df3 = pd.DataFrame({'A': np.arange(3),
+                       'B': pd.Series(list('abc')).astype('category')})
+   df3 = df3.set_index('B')
+   df3
+
+.. ipython:: python
+
+   df3.reindex(['a', 'e'])
+   df3.reindex(['a', 'e']).index
+   df3.reindex(pd.Categorical(['a', 'e'], categories=list('abe')))
+   df3.reindex(pd.Categorical(['a', 'e'], categories=list('abe'))).index
 
 .. warning::
 
    Reshaping and Comparison operations on a ``CategoricalIndex`` must have the same categories
    or a ``TypeError`` will be raised.
 
-   .. code-block:: ipython
+   .. ipython:: python
 
-    In [9]: df3 = pd.DataFrame({'A': np.arange(6), 'B': pd.Series(list('aabbca')).astype('category')})
+      df4 = pd.DataFrame({'A': np.arange(2),
+                          'B': list('ba')})
+      df4['B'] = df4['B'].astype(CategoricalDtype(list('ab')))
+      df4 = df4.set_index('B')
+      df4.index
 
-    In [11]: df3 = df3.set_index('B')
+      df5 = pd.DataFrame({'A': np.arange(2),
+                          'B': list('bc')})
+      df5['B'] = df5['B'].astype(CategoricalDtype(list('bc')))
+      df5 = df5.set_index('B')
+      df5.index
 
-    In [11]: df3.index
-    Out[11]: CategoricalIndex(['a', 'a', 'b', 'b', 'c', 'a'], categories=['a', 'b', 'c'], ordered=False, name='B', dtype='category')
+   .. code-block:: ipython
 
-    In [12]: pd.concat([df2, df3])
-    TypeError: categories must match existing categories when appending
+      In [1]: pd.concat([df4, df5])
+      TypeError: categories must match existing categories when appending
 
 .. _indexing.rangeindex:
 
@@ -914,8 +947,6 @@ If you need integer based selection, you should use ``iloc``:
 IntervalIndex
 ~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 :class:`IntervalIndex` together with its own dtype, :class:`~pandas.api.types.IntervalDtype`
 as well as the :class:`Interval` scalar type,  allow first-class support in pandas
 for interval notation.
diff --git a/doc/source/user_guide/boolean.rst b/doc/source/user_guide/boolean.rst
new file mode 100644
index 0000000000000..4f0ad0e8ceaeb
--- /dev/null
+++ b/doc/source/user_guide/boolean.rst
@@ -0,0 +1,102 @@
+.. currentmodule:: pandas
+
+.. ipython:: python
+   :suppress:
+
+   import pandas as pd
+   import numpy as np
+
+.. _boolean:
+
+**************************
+Nullable Boolean data type
+**************************
+
+.. versionadded:: 1.0.0
+
+
+.. _boolean.indexing:
+
+Indexing with NA values
+-----------------------
+
+pandas does not allow indexing with NA values. Attempting to do so
+will raise a ``ValueError``.
+
+.. ipython:: python
+   :okexcept:
+
+   s = pd.Series([1, 2, 3])
+   mask = pd.array([True, False, pd.NA], dtype="boolean")
+   s[mask]
+
+The missing values will need to be explicitly filled with True or False prior
+to using the array as a mask.
+
+.. ipython:: python
+
+   s[mask.fillna(False)]
+
+.. _boolean.kleene:
+
+Kleene Logical Operations
+-------------------------
+
+:class:`arrays.BooleanArray` implements `Kleene Logic`_ (sometimes called three-value logic) for
+logical operations like ``&`` (and), ``|`` (or) and ``^`` (exclusive-or).
+
+This table demonstrates the results for every combination. These operations are symmetrical,
+so flipping the left- and right-hand side makes no difference in the result.
+
+================= =========
+Expression        Result
+================= =========
+``True & True``   ``True``
+``True & False``  ``False``
+``True & NA``     ``NA``
+``False & False`` ``False``
+``False & NA``    ``False``
+``NA & NA``       ``NA``
+``True | True``   ``True``
+``True | False``  ``True``
+``True | NA``     ``True``
+``False | False`` ``False``
+``False | NA``    ``NA``
+``NA | NA``       ``NA``
+``True ^ True``   ``False``
+``True ^ False``  ``True``
+``True ^ NA``     ``NA``
+``False ^ False`` ``False``
+``False ^ NA``    ``NA``
+``NA ^ NA``       ``NA``
+================= =========
+
+When an ``NA`` is present in an operation, the output value is ``NA`` only if
+the result cannot be determined solely based on the other input. For example,
+``True | NA`` is ``True``, because both ``True | True`` and ``True | False``
+are ``True``. In that case, we don't actually need to consider the value
+of the ``NA``.
+
+On the other hand, ``True & NA`` is ``NA``. The result depends on whether
+the ``NA`` really is ``True`` or ``False``, since ``True & True`` is ``True``,
+but ``True & False`` is ``False``, so we can't determine the output.
+
+
+This differs from how ``np.nan`` behaves in logical operations. Pandas treated
+``np.nan`` is *always false in the output*.
+
+In ``or``
+
+.. ipython:: python
+
+   pd.Series([True, False, np.nan], dtype="object") | True
+   pd.Series([True, False, np.nan], dtype="boolean") | True
+
+In ``and``
+
+.. ipython:: python
+
+   pd.Series([True, False, np.nan], dtype="object") & True
+   pd.Series([True, False, np.nan], dtype="boolean") & True
+
+.. _Kleene Logic: https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
diff --git a/doc/source/user_guide/categorical.rst b/doc/source/user_guide/categorical.rst
index 8ca96ba0daa5e..a55326db748fd 100644
--- a/doc/source/user_guide/categorical.rst
+++ b/doc/source/user_guide/categorical.rst
@@ -797,37 +797,52 @@ Assigning a ``Categorical`` to parts of a column of other types will use the val
     df.dtypes
 
 .. _categorical.merge:
+.. _categorical.concat:
 
-Merging
-~~~~~~~
+Merging / Concatenation
+~~~~~~~~~~~~~~~~~~~~~~~
 
-You can concat two ``DataFrames`` containing categorical data together,
-but the categories of these categoricals need to be the same:
+By default, combining ``Series`` or ``DataFrames`` which contain the same
+categories results in ``category`` dtype, otherwise results will depend on the
+dtype of the underlying categories. Merges that result in non-categorical
+dtypes will likely have higher memory usage. Use ``.astype`` or
+``union_categoricals`` to ensure ``category`` results.
 
 .. ipython:: python
 
-    cat = pd.Series(["a", "b"], dtype="category")
-    vals = [1, 2]
-    df = pd.DataFrame({"cats": cat, "vals": vals})
-    res = pd.concat([df, df])
-    res
-    res.dtypes
+   from pandas.api.types import union_categoricals
 
-In this case the categories are not the same, and therefore an error is raised:
+   # same categories
+   s1 = pd.Series(['a', 'b'], dtype='category')
+   s2 = pd.Series(['a', 'b', 'a'], dtype='category')
+   pd.concat([s1, s2])
 
-.. ipython:: python
+   # different categories
+   s3 = pd.Series(['b', 'c'], dtype='category')
+   pd.concat([s1, s3])
 
-    df_different = df.copy()
-    df_different["cats"].cat.categories = ["c", "d"]
-    try:
-        pd.concat([df, df_different])
-    except ValueError as e:
-        print("ValueError:", str(e))
+   # Output dtype is inferred based on categories values
+   int_cats = pd.Series([1, 2], dtype="category")
+   float_cats = pd.Series([3.0, 4.0], dtype="category")
+   pd.concat([int_cats, float_cats])
+
+   pd.concat([s1, s3]).astype('category')
+   union_categoricals([s1.array, s3.array])
 
-The same applies to ``df.append(df_different)``.
+The following table summarizes the results of merging ``Categoricals``:
 
-See also the section on :ref:`merge dtypes<merging.dtypes>` for notes about preserving merge dtypes and performance.
++-------------------+------------------------+----------------------+-----------------------------+
+| arg1              | arg2                   |      identical       | result                      |
++===================+========================+======================+=============================+
+| category          | category               | True                 | category                    |
++-------------------+------------------------+----------------------+-----------------------------+
+| category (object) | category (object)      | False                | object (dtype is inferred)  |
++-------------------+------------------------+----------------------+-----------------------------+
+| category (int)    | category (float)       | False                | float (dtype is inferred)   |
++-------------------+------------------------+----------------------+-----------------------------+
 
+See also the section on :ref:`merge dtypes<merging.dtypes>` for notes about
+preserving merge dtypes and performance.
 
 .. _categorical.union:
 
@@ -874,8 +889,6 @@ The below raises ``TypeError`` because the categories are ordered and not identi
    Out[3]:
    TypeError: to union ordered Categoricals, all categories must be the same
 
-.. versionadded:: 0.20.0
-
 Ordered categoricals with different categories or orderings can be combined by
 using the ``ignore_ordered=True`` argument.
 
@@ -920,46 +933,6 @@ the resulting array will always be a plain ``Categorical``:
       # "b" is coded to 0 throughout, same as c1, different from c2
       c.codes
 
-.. _categorical.concat:
-
-Concatenation
-~~~~~~~~~~~~~
-
-This section describes concatenations specific to ``category`` dtype. See :ref:`Concatenating objects<merging.concat>` for general description.
-
-By default, ``Series`` or ``DataFrame`` concatenation which contains the same categories
-results in ``category`` dtype, otherwise results in ``object`` dtype.
-Use ``.astype`` or ``union_categoricals`` to get ``category`` result.
-
-.. ipython:: python
-
-   # same categories
-   s1 = pd.Series(['a', 'b'], dtype='category')
-   s2 = pd.Series(['a', 'b', 'a'], dtype='category')
-   pd.concat([s1, s2])
-
-   # different categories
-   s3 = pd.Series(['b', 'c'], dtype='category')
-   pd.concat([s1, s3])
-
-   pd.concat([s1, s3]).astype('category')
-   union_categoricals([s1.array, s3.array])
-
-
-Following table summarizes the results of ``Categoricals`` related concatenations.
-
-+----------+--------------------------------------------------------+----------------------------+
-| arg1     | arg2                                                   | result                     |
-+==========+========================================================+============================+
-| category | category (identical categories)                        | category                   |
-+----------+--------------------------------------------------------+----------------------------+
-| category | category (different categories, both not ordered)      | object (dtype is inferred) |
-+----------+--------------------------------------------------------+----------------------------+
-| category | category (different categories, either one is ordered) | object (dtype is inferred) |
-+----------+--------------------------------------------------------+----------------------------+
-| category | not category                                           | object (dtype is inferred) |
-+----------+--------------------------------------------------------+----------------------------+
-
 
 Getting data in/out
 -------------------
diff --git a/doc/source/user_guide/computation.rst b/doc/source/user_guide/computation.rst
index 4beac5e035efc..9951642ca98a4 100644
--- a/doc/source/user_guide/computation.rst
+++ b/doc/source/user_guide/computation.rst
@@ -58,7 +58,7 @@ series in the DataFrame, also excluding NA/null values.
     is not guaranteed to be positive semi-definite. This could lead to
     estimated correlations having absolute values which are greater than one,
     and/or a non-invertible covariance matrix. See `Estimation of covariance
-    matrices <http://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_matrices>`_
+    matrices <https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_matrices>`_
     for more details.
 
 .. ipython:: python
@@ -321,6 +321,11 @@ We provide a number of common statistical functions:
     :meth:`~Rolling.cov`, Unbiased covariance (binary)
     :meth:`~Rolling.corr`, Correlation (binary)
 
+.. _stats.rolling_apply:
+
+Rolling Apply
+~~~~~~~~~~~~~
+
 The :meth:`~Rolling.apply` function takes an extra ``func`` argument and performs
 generic rolling computations. The ``func`` argument should be a single function
 that produces a single value from an ndarray input. Suppose we wanted to
@@ -334,6 +339,49 @@ compute the mean absolute deviation on a rolling basis:
    @savefig rolling_apply_ex.png
    s.rolling(window=60).apply(mad, raw=True).plot(style='k')
 
+.. versionadded:: 1.0
+
+Additionally, :meth:`~Rolling.apply` can leverage `Numba <https://numba.pydata.org/>`__
+if installed as an optional dependency. The apply aggregation can be executed using Numba by specifying
+``engine='numba'`` and ``engine_kwargs`` arguments (``raw`` must also be set to ``True``).
+Numba will be applied in potentially two routines:
+
+1. If ``func`` is a standard Python function, the engine will `JIT <https://numba.pydata.org/numba-doc/latest/user/overview.html>`__
+the passed function. ``func`` can also be a JITed function in which case the engine will not JIT the function again.
+
+2. The engine will JIT the for loop where the apply function is applied to each window.
+
+The ``engine_kwargs`` argument is a dictionary of keyword arguments that will be passed into the
+`numba.jit decorator <https://numba.pydata.org/numba-doc/latest/reference/jit-compilation.html#numba.jit>`__.
+These keyword arguments will be applied to *both* the passed function (if a standard Python function)
+and the apply for loop over each window. Currently only ``nogil``, ``nopython``, and ``parallel`` are supported,
+and their default values are set to ``False``, ``True`` and ``False`` respectively.
+
+.. note::
+
+   In terms of performance, **the first time a function is run using the Numba engine will be slow**
+   as Numba will have some function compilation overhead. However, ``rolling`` objects will cache
+   the function and subsequent calls will be fast. In general, the Numba engine is performant with
+   a larger amount of data points (e.g. 1+ million).
+
+.. code-block:: ipython
+
+   In [1]: data = pd.Series(range(1_000_000))
+
+   In [2]: roll = data.rolling(10)
+
+   In [3]: def f(x):
+      ...:     return np.sum(x) + 5
+   # Run the first time, compilation time will affect performance
+   In [4]: %timeit -r 1 -n 1 roll.apply(f, engine='numba', raw=True)  # noqa: E225
+   1.23 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
+   # Function is cached and performance will improve
+   In [5]: %timeit roll.apply(f, engine='numba', raw=True)
+   188 ms ± 1.93 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+
+   In [6]: %timeit roll.apply(f, engine='cython', raw=True)
+   3.92 s ± 59 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
 .. _stats.rolling_window:
 
 Rolling windows
@@ -466,13 +514,69 @@ default of the index) in a DataFrame.
    dft
    dft.rolling('2s', on='foo').sum()
 
+.. _stats.custom_rolling_window:
+
+Custom window rolling
+~~~~~~~~~~~~~~~~~~~~~
+
+.. versionadded:: 1.0
+
+In addition to accepting an integer or offset as a ``window`` argument, ``rolling`` also accepts
+a ``BaseIndexer`` subclass that allows a user to define a custom method for calculating window bounds.
+The ``BaseIndexer`` subclass will need to define a ``get_window_bounds`` method that returns
+a tuple of two arrays, the first being the starting indices of the windows and second being the
+ending indices of the windows. Additionally, ``num_values``, ``min_periods``, ``center``, ``closed``
+and will automatically be passed to ``get_window_bounds`` and the defined method must
+always accept these arguments.
+
+For example, if we have the following ``DataFrame``:
+
+.. ipython:: python
+
+   use_expanding = [True, False, True, False, True]
+   use_expanding
+   df = pd.DataFrame({'values': range(5)})
+   df
+
+and we want to use an expanding window where ``use_expanding`` is ``True`` otherwise a window of size
+1, we can create the following ``BaseIndexer``:
+
+.. code-block:: ipython
+
+   In [2]: from pandas.api.indexers import BaseIndexer
+   ...:
+   ...: class CustomIndexer(BaseIndexer):
+   ...:
+   ...:    def get_window_bounds(self, num_values, min_periods, center, closed):
+   ...:        start = np.empty(num_values, dtype=np.int64)
+   ...:        end = np.empty(num_values, dtype=np.int64)
+   ...:        for i in range(num_values):
+   ...:            if self.use_expanding[i]:
+   ...:                start[i] = 0
+   ...:                end[i] = i + 1
+   ...:            else:
+   ...:                start[i] = i
+   ...:                end[i] = i + self.window_size
+   ...:        return start, end
+   ...:
+
+   In [3]: indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+
+   In [4]: df.rolling(indexer).sum()
+   Out[4]:
+       values
+   0     0.0
+   1     1.0
+   2     3.0
+   3     3.0
+   4    10.0
+
+
 .. _stats.rolling_window.endpoints:
 
 Rolling window endpoints
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 The inclusion of the interval endpoints in rolling window calculations can be specified with the ``closed``
 parameter:
 
@@ -960,5 +1064,5 @@ are scaled by debiasing factors
 
 (For :math:`w_i = 1`, this reduces to the usual :math:`N / (N - 1)` factor,
 with :math:`N = t + 1`.)
-See `Weighted Sample Variance <http://en.wikipedia.org/wiki/Weighted_arithmetic_mean#Weighted_sample_variance>`__
+See `Weighted Sample Variance <https://en.wikipedia.org/wiki/Weighted_arithmetic_mean#Weighted_sample_variance>`__
 on Wikipedia for further details.
diff --git a/doc/source/user_guide/cookbook.rst b/doc/source/user_guide/cookbook.rst
index c9d3bc3a28c70..4afdb14e5c39e 100644
--- a/doc/source/user_guide/cookbook.rst
+++ b/doc/source/user_guide/cookbook.rst
@@ -406,10 +406,10 @@ Levels
 ******
 
 `Prepending a level to a multiindex
-<http://stackoverflow.com/questions/14744068/prepend-a-level-to-a-pandas-multiindex>`__
+<https://stackoverflow.com/questions/14744068/prepend-a-level-to-a-pandas-multiindex>`__
 
 `Flatten Hierarchical columns
-<http://stackoverflow.com/questions/14507794/python-pandas-how-to-flatten-a-hierarchical-index-in-columns>`__
+<https://stackoverflow.com/questions/14507794/python-pandas-how-to-flatten-a-hierarchical-index-in-columns>`__
 
 .. _cookbook.missing_data:
 
@@ -430,13 +430,13 @@ Fill forward a reversed timeseries
    df.reindex(df.index[::-1]).ffill()
 
 `cumsum reset at NaN values
-<http://stackoverflow.com/questions/18196811/cumsum-reset-at-nan>`__
+<https://stackoverflow.com/questions/18196811/cumsum-reset-at-nan>`__
 
 Replace
 *******
 
 `Using replace with backrefs
-<http://stackoverflow.com/questions/16818871/extracting-value-and-creating-new-column-out-of-it>`__
+<https://stackoverflow.com/questions/16818871/extracting-value-and-creating-new-column-out-of-it>`__
 
 .. _cookbook.grouping:
 
@@ -446,7 +446,7 @@ Grouping
 The :ref:`grouping <groupby>` docs.
 
 `Basic grouping with apply
-<http://stackoverflow.com/questions/15322632/python-pandas-df-groupy-agg-column-reference-in-agg>`__
+<https://stackoverflow.com/questions/15322632/python-pandas-df-groupy-agg-column-reference-in-agg>`__
 
 Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to all the columns
 
@@ -462,7 +462,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    df.groupby('animal').apply(lambda subf: subf['size'][subf['weight'].idxmax()])
 
 `Using get_group
-<http://stackoverflow.com/questions/14734533/how-to-access-pandas-groupby-dataframe-by-key>`__
+<https://stackoverflow.com/questions/14734533/how-to-access-pandas-groupby-dataframe-by-key>`__
 
 .. ipython:: python
 
@@ -470,7 +470,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    gb.get_group('cat')
 
 `Apply to different items in a group
-<http://stackoverflow.com/questions/15262134/apply-different-functions-to-different-items-in-group-object-python-pandas>`__
+<https://stackoverflow.com/questions/15262134/apply-different-functions-to-different-items-in-group-object-python-pandas>`__
 
 .. ipython:: python
 
@@ -486,7 +486,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    expected_df
 
 `Expanding apply
-<http://stackoverflow.com/questions/14542145/reductions-down-a-column-in-pandas>`__
+<https://stackoverflow.com/questions/14542145/reductions-down-a-column-in-pandas>`__
 
 .. ipython:: python
 
@@ -502,7 +502,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
 
 
 `Replacing some values with mean of the rest of a group
-<http://stackoverflow.com/questions/14760757/replacing-values-with-groupby-means>`__
+<https://stackoverflow.com/questions/14760757/replacing-values-with-groupby-means>`__
 
 .. ipython:: python
 
@@ -516,7 +516,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    gb.transform(replace)
 
 `Sort groups by aggregated data
-<http://stackoverflow.com/questions/14941366/pandas-sort-by-group-aggregate-and-column>`__
+<https://stackoverflow.com/questions/14941366/pandas-sort-by-group-aggregate-and-column>`__
 
 .. ipython:: python
 
@@ -533,7 +533,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    sorted_df
 
 `Create multiple aggregated columns
-<http://stackoverflow.com/questions/14897100/create-multiple-columns-in-pandas-aggregation-function>`__
+<https://stackoverflow.com/questions/14897100/create-multiple-columns-in-pandas-aggregation-function>`__
 
 .. ipython:: python
 
@@ -550,7 +550,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    ts
 
 `Create a value counts column and reassign back to the DataFrame
-<http://stackoverflow.com/questions/17709270/i-want-to-create-a-column-of-value-counts-in-my-pandas-dataframe>`__
+<https://stackoverflow.com/questions/17709270/i-want-to-create-a-column-of-value-counts-in-my-pandas-dataframe>`__
 
 .. ipython:: python
 
@@ -561,7 +561,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    df
 
 `Shift groups of the values in a column based on the index
-<http://stackoverflow.com/q/23198053/190597>`__
+<https://stackoverflow.com/q/23198053/190597>`__
 
 .. ipython:: python
 
@@ -575,7 +575,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    df
 
 `Select row with maximum value from each group
-<http://stackoverflow.com/q/26701849/190597>`__
+<https://stackoverflow.com/q/26701849/190597>`__
 
 .. ipython:: python
 
@@ -587,7 +587,7 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
    df_count
 
 `Grouping like Python's itertools.groupby
-<http://stackoverflow.com/q/29142487/846892>`__
+<https://stackoverflow.com/q/29142487/846892>`__
 
 .. ipython:: python
 
@@ -599,19 +599,19 @@ Expanding data
 **************
 
 `Alignment and to-date
-<http://stackoverflow.com/questions/15489011/python-time-series-alignment-and-to-date-functions>`__
+<https://stackoverflow.com/questions/15489011/python-time-series-alignment-and-to-date-functions>`__
 
 `Rolling Computation window based on values instead of counts
-<http://stackoverflow.com/questions/14300768/pandas-rolling-computation-with-window-based-on-values-instead-of-counts>`__
+<https://stackoverflow.com/questions/14300768/pandas-rolling-computation-with-window-based-on-values-instead-of-counts>`__
 
 `Rolling Mean by Time Interval
-<http://stackoverflow.com/questions/15771472/pandas-rolling-mean-by-time-interval>`__
+<https://stackoverflow.com/questions/15771472/pandas-rolling-mean-by-time-interval>`__
 
 Splitting
 *********
 
 `Splitting a frame
-<http://stackoverflow.com/questions/13353233/best-way-to-split-a-dataframe-given-an-edge/15449992#15449992>`__
+<https://stackoverflow.com/questions/13353233/best-way-to-split-a-dataframe-given-an-edge/15449992#15449992>`__
 
 Create a list of dataframes, split using a delineation based on logic included in rows.
 
@@ -635,7 +635,7 @@ Pivot
 The :ref:`Pivot <reshaping.pivot>` docs.
 
 `Partial sums and subtotals
-<http://stackoverflow.com/questions/15570099/pandas-pivot-tables-row-subtotals/15574875#15574875>`__
+<https://stackoverflow.com/questions/15570099/pandas-pivot-tables-row-subtotals/15574875#15574875>`__
 
 .. ipython:: python
 
@@ -649,7 +649,7 @@ The :ref:`Pivot <reshaping.pivot>` docs.
    table.stack('City')
 
 `Frequency table like plyr in R
-<http://stackoverflow.com/questions/15589354/frequency-tables-in-pandas-like-plyr-in-r>`__
+<https://stackoverflow.com/questions/15589354/frequency-tables-in-pandas-like-plyr-in-r>`__
 
 .. ipython:: python
 
@@ -675,7 +675,7 @@ The :ref:`Pivot <reshaping.pivot>` docs.
                                'Grade': lambda x: sum(x) / len(x)})
 
 `Plot pandas DataFrame with year over year data
-<http://stackoverflow.com/questions/30379789/plot-pandas-data-frame-with-year-over-year-data>`__
+<https://stackoverflow.com/questions/30379789/plot-pandas-data-frame-with-year-over-year-data>`__
 
 To create year and month cross tabulation:
 
@@ -691,7 +691,7 @@ Apply
 *****
 
 `Rolling apply to organize - Turning embedded lists into a MultiIndex frame
-<http://stackoverflow.com/questions/17349981/converting-pandas-dataframe-with-categorical-values-into-binary-values>`__
+<https://stackoverflow.com/questions/17349981/converting-pandas-dataframe-with-categorical-values-into-binary-values>`__
 
 .. ipython:: python
 
@@ -707,7 +707,7 @@ Apply
    df_orgz
 
 `Rolling apply with a DataFrame returning a Series
-<http://stackoverflow.com/questions/19121854/using-rolling-apply-on-a-dataframe-object>`__
+<https://stackoverflow.com/questions/19121854/using-rolling-apply-on-a-dataframe-object>`__
 
 Rolling Apply to multiple columns where function calculates a Series before a Scalar from the Series is returned
 
@@ -727,7 +727,7 @@ Rolling Apply to multiple columns where function calculates a Series before a Sc
    s
 
 `Rolling apply with a DataFrame returning a Scalar
-<http://stackoverflow.com/questions/21040766/python-pandas-rolling-apply-two-column-input-into-function/21045831#21045831>`__
+<https://stackoverflow.com/questions/21040766/python-pandas-rolling-apply-two-column-input-into-function/21045831#21045831>`__
 
 Rolling Apply to multiple columns where function returns a Scalar (Volume Weighted Average Price)
 
@@ -753,26 +753,26 @@ Timeseries
 ----------
 
 `Between times
-<http://stackoverflow.com/questions/14539992/pandas-drop-rows-outside-of-time-range>`__
+<https://stackoverflow.com/questions/14539992/pandas-drop-rows-outside-of-time-range>`__
 
 `Using indexer between time
-<http://stackoverflow.com/questions/17559885/pandas-dataframe-mask-based-on-index>`__
+<https://stackoverflow.com/questions/17559885/pandas-dataframe-mask-based-on-index>`__
 
 `Constructing a datetime range that excludes weekends and includes only certain times
-<http://stackoverflow.com/questions/24010830/pandas-generate-sequential-timestamp-with-jump/24014440#24014440?>`__
+<https://stackoverflow.com/questions/24010830/pandas-generate-sequential-timestamp-with-jump/24014440#24014440?>`__
 
 `Vectorized Lookup
-<http://stackoverflow.com/questions/13893227/vectorized-look-up-of-values-in-pandas-dataframe>`__
+<https://stackoverflow.com/questions/13893227/vectorized-look-up-of-values-in-pandas-dataframe>`__
 
 `Aggregation and plotting time series
 <http://nipunbatra.github.io/2015/06/timeseries/>`__
 
 Turn a matrix with hours in columns and days in rows into a continuous row sequence in the form of a time series.
 `How to rearrange a Python pandas DataFrame?
-<http://stackoverflow.com/questions/15432659/how-to-rearrange-a-python-pandas-dataframe>`__
+<https://stackoverflow.com/questions/15432659/how-to-rearrange-a-python-pandas-dataframe>`__
 
 `Dealing with duplicates when reindexing a timeseries to a specified frequency
-<http://stackoverflow.com/questions/22244383/pandas-df-refill-adding-two-columns-of-different-shape>`__
+<https://stackoverflow.com/questions/22244383/pandas-df-refill-adding-two-columns-of-different-shape>`__
 
 Calculate the first day of the month for each entry in a DatetimeIndex
 
@@ -795,7 +795,7 @@ The :ref:`Resample <timeseries.resampling>` docs.
 <https://stackoverflow.com/questions/33637312/pandas-grouper-by-frequency-with-completeness-requirement>`__
 
 `Valid frequency arguments to Grouper
-<http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__
+<https://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__
 
 `Grouping using a MultiIndex
 <https://stackoverflow.com/questions/41483763/pandas-timegrouper-on-multiindex>`__
@@ -804,15 +804,15 @@ The :ref:`Resample <timeseries.resampling>` docs.
 <https://github.com/pandas-dev/pandas/issues/3791>`__
 
 `Resampling with custom periods
-<http://stackoverflow.com/questions/15408156/resampling-with-custom-periods>`__
+<https://stackoverflow.com/questions/15408156/resampling-with-custom-periods>`__
 
 `Resample intraday frame without adding new days
-<http://stackoverflow.com/questions/14898574/resample-intrday-pandas-dataframe-without-add-new-days>`__
+<https://stackoverflow.com/questions/14898574/resample-intrday-pandas-dataframe-without-add-new-days>`__
 
 `Resample minute data
-<http://stackoverflow.com/questions/14861023/resampling-minute-data>`__
+<https://stackoverflow.com/questions/14861023/resampling-minute-data>`__
 
-`Resample with groupby <http://stackoverflow.com/q/18677271/564538>`__
+`Resample with groupby <https://stackoverflow.com/q/18677271/564538>`__
 
 .. _cookbook.merge:
 
@@ -822,7 +822,7 @@ Merge
 The :ref:`Concat <merging.concatenation>` docs. The :ref:`Join <merging.join>` docs.
 
 `Append two dataframes with overlapping index (emulate R rbind)
-<http://stackoverflow.com/questions/14988480/pandas-version-of-rbind>`__
+<https://stackoverflow.com/questions/14988480/pandas-version-of-rbind>`__
 
 .. ipython:: python
 
@@ -855,16 +855,16 @@ Depending on df construction, ``ignore_index`` may be needed
             suffixes=('_L', '_R'))
 
 `How to set the index and join
-<http://stackoverflow.com/questions/14341805/pandas-merge-pd-merge-how-to-set-the-index-and-join>`__
+<https://stackoverflow.com/questions/14341805/pandas-merge-pd-merge-how-to-set-the-index-and-join>`__
 
 `KDB like asof join
-<http://stackoverflow.com/questions/12322289/kdb-like-asof-join-for-timeseries-data-in-pandas/12336039#12336039>`__
+<https://stackoverflow.com/questions/12322289/kdb-like-asof-join-for-timeseries-data-in-pandas/12336039#12336039>`__
 
 `Join with a criteria based on the values
-<http://stackoverflow.com/questions/15581829/how-to-perform-an-inner-or-outer-join-of-dataframes-with-pandas-on-non-simplisti>`__
+<https://stackoverflow.com/questions/15581829/how-to-perform-an-inner-or-outer-join-of-dataframes-with-pandas-on-non-simplisti>`__
 
 `Using searchsorted to merge based on values inside a range
-<http://stackoverflow.com/questions/25125626/pandas-merge-with-logic/2512764>`__
+<https://stackoverflow.com/questions/25125626/pandas-merge-with-logic/2512764>`__
 
 .. _cookbook.plotting:
 
@@ -874,31 +874,31 @@ Plotting
 The :ref:`Plotting <visualization>` docs.
 
 `Make Matplotlib look like R
-<http://stackoverflow.com/questions/14349055/making-matplotlib-graphs-look-like-r-by-default>`__
+<https://stackoverflow.com/questions/14349055/making-matplotlib-graphs-look-like-r-by-default>`__
 
 `Setting x-axis major and minor labels
-<http://stackoverflow.com/questions/12945971/pandas-timeseries-plot-setting-x-axis-major-and-minor-ticks-and-labels>`__
+<https://stackoverflow.com/questions/12945971/pandas-timeseries-plot-setting-x-axis-major-and-minor-ticks-and-labels>`__
 
 `Plotting multiple charts in an ipython notebook
-<http://stackoverflow.com/questions/16392921/make-more-than-one-chart-in-same-ipython-notebook-cell>`__
+<https://stackoverflow.com/questions/16392921/make-more-than-one-chart-in-same-ipython-notebook-cell>`__
 
 `Creating a multi-line plot
-<http://stackoverflow.com/questions/16568964/make-a-multiline-plot-from-csv-file-in-matplotlib>`__
+<https://stackoverflow.com/questions/16568964/make-a-multiline-plot-from-csv-file-in-matplotlib>`__
 
 `Plotting a heatmap
-<http://stackoverflow.com/questions/17050202/plot-timeseries-of-histograms-in-python>`__
+<https://stackoverflow.com/questions/17050202/plot-timeseries-of-histograms-in-python>`__
 
 `Annotate a time-series plot
-<http://stackoverflow.com/questions/11067368/annotate-time-series-plot-in-matplotlib>`__
+<https://stackoverflow.com/questions/11067368/annotate-time-series-plot-in-matplotlib>`__
 
 `Annotate a time-series plot #2
-<http://stackoverflow.com/questions/17891493/annotating-points-from-a-pandas-dataframe-in-matplotlib-plot>`__
+<https://stackoverflow.com/questions/17891493/annotating-points-from-a-pandas-dataframe-in-matplotlib-plot>`__
 
 `Generate Embedded plots in excel files using Pandas, Vincent and xlsxwriter
 <https://pandas-xlsxwriter-charts.readthedocs.io/>`__
 
 `Boxplot for each quartile of a stratifying variable
-<http://stackoverflow.com/questions/23232989/boxplot-stratified-by-column-in-python-pandas>`__
+<https://stackoverflow.com/questions/23232989/boxplot-stratified-by-column-in-python-pandas>`__
 
 .. ipython:: python
 
@@ -918,7 +918,7 @@ Data In/Out
 -----------
 
 `Performance comparison of SQL vs HDF5
-<http://stackoverflow.com/questions/16628329/hdf5-and-sqlite-concurrency-compression-i-o-performance>`__
+<https://stackoverflow.com/questions/16628329/hdf5-and-sqlite-concurrency-compression-i-o-performance>`__
 
 .. _cookbook.csv:
 
@@ -927,31 +927,31 @@ CSV
 
 The :ref:`CSV <io.read_csv_table>` docs
 
-`read_csv in action <http://wesmckinney.com/blog/update-on-upcoming-pandas-v0-10-new-file-parser-other-performance-wins/>`__
+`read_csv in action <https://wesmckinney.com/blog/update-on-upcoming-pandas-v0-10-new-file-parser-other-performance-wins/>`__
 
 `appending to a csv
-<http://stackoverflow.com/questions/17134942/pandas-dataframe-output-end-of-csv>`__
+<https://stackoverflow.com/questions/17134942/pandas-dataframe-output-end-of-csv>`__
 
 `Reading a csv chunk-by-chunk
-<http://stackoverflow.com/questions/11622652/large-persistent-dataframe-in-pandas/12193309#12193309>`__
+<https://stackoverflow.com/questions/11622652/large-persistent-dataframe-in-pandas/12193309#12193309>`__
 
 `Reading only certain rows of a csv chunk-by-chunk
-<http://stackoverflow.com/questions/19674212/pandas-data-frame-select-rows-and-clear-memory>`__
+<https://stackoverflow.com/questions/19674212/pandas-data-frame-select-rows-and-clear-memory>`__
 
 `Reading the first few lines of a frame
-<http://stackoverflow.com/questions/15008970/way-to-read-first-few-lines-for-pandas-dataframe>`__
+<https://stackoverflow.com/questions/15008970/way-to-read-first-few-lines-for-pandas-dataframe>`__
 
 Reading a file that is compressed but not by ``gzip/bz2`` (the native compressed formats which ``read_csv`` understands).
 This example shows a ``WinZipped`` file, but is a general application of opening the file within a context manager and
 using that handle to read.
 `See here
-<http://stackoverflow.com/questions/17789907/pandas-convert-winzipped-csv-file-to-data-frame>`__
+<https://stackoverflow.com/questions/17789907/pandas-convert-winzipped-csv-file-to-data-frame>`__
 
 `Inferring dtypes from a file
-<http://stackoverflow.com/questions/15555005/get-inferred-dataframe-types-iteratively-using-chunksize>`__
+<https://stackoverflow.com/questions/15555005/get-inferred-dataframe-types-iteratively-using-chunksize>`__
 
 `Dealing with bad lines
-<http://github.com/pandas-dev/pandas/issues/2886>`__
+<https://github.com/pandas-dev/pandas/issues/2886>`__
 
 `Dealing with bad lines II
 <http://nipunbatra.github.io/2013/06/reading-unclean-data-csv-using-pandas/>`__
@@ -960,7 +960,7 @@ using that handle to read.
 <http://nipunbatra.github.io/2013/06/pandas-reading-csv-with-unix-timestamps-and-converting-to-local-timezone/>`__
 
 `Write a multi-row index CSV without writing duplicates
-<http://stackoverflow.com/questions/17349574/pandas-write-multiindex-rows-with-to-csv>`__
+<https://stackoverflow.com/questions/17349574/pandas-write-multiindex-rows-with-to-csv>`__
 
 .. _cookbook.csv.multiple_files:
 
@@ -1069,7 +1069,7 @@ SQL
 The :ref:`SQL <io.sql>` docs
 
 `Reading from databases with SQL
-<http://stackoverflow.com/questions/10065051/python-pandas-and-databases-like-mysql>`__
+<https://stackoverflow.com/questions/10065051/python-pandas-and-databases-like-mysql>`__
 
 .. _cookbook.excel:
 
@@ -1079,10 +1079,10 @@ Excel
 The :ref:`Excel <io.excel>` docs
 
 `Reading from a filelike handle
-<http://stackoverflow.com/questions/15588713/sheets-of-excel-workbook-from-a-url-into-a-pandas-dataframe>`__
+<https://stackoverflow.com/questions/15588713/sheets-of-excel-workbook-from-a-url-into-a-pandas-dataframe>`__
 
 `Modifying formatting in XlsxWriter output
-<http://pbpython.com/improve-pandas-excel-output.html>`__
+<https://pbpython.com/improve-pandas-excel-output.html>`__
 
 .. _cookbook.html:
 
@@ -1090,7 +1090,7 @@ HTML
 ****
 
 `Reading HTML tables from a server that cannot handle the default request
-header <http://stackoverflow.com/a/18939272/564538>`__
+header <https://stackoverflow.com/a/18939272/564538>`__
 
 .. _cookbook.hdf:
 
@@ -1100,54 +1100,54 @@ HDFStore
 The :ref:`HDFStores <io.hdf5>` docs
 
 `Simple queries with a Timestamp Index
-<http://stackoverflow.com/questions/13926089/selecting-columns-from-pandas-hdfstore-table>`__
+<https://stackoverflow.com/questions/13926089/selecting-columns-from-pandas-hdfstore-table>`__
 
 `Managing heterogeneous data using a linked multiple table hierarchy
-<http://github.com/pandas-dev/pandas/issues/3032>`__
+<https://github.com/pandas-dev/pandas/issues/3032>`__
 
 `Merging on-disk tables with millions of rows
-<http://stackoverflow.com/questions/14614512/merging-two-tables-with-millions-of-rows-in-python/14617925#14617925>`__
+<https://stackoverflow.com/questions/14614512/merging-two-tables-with-millions-of-rows-in-python/14617925#14617925>`__
 
 `Avoiding inconsistencies when writing to a store from multiple processes/threads
-<http://stackoverflow.com/a/29014295/2858145>`__
+<https://stackoverflow.com/a/29014295/2858145>`__
 
 De-duplicating a large store by chunks, essentially a recursive reduction operation. Shows a function for taking in data from
 csv file and creating a store by chunks, with date parsing as well.
 `See here
-<http://stackoverflow.com/questions/16110252/need-to-compare-very-large-files-around-1-5gb-in-python/16110391#16110391>`__
+<https://stackoverflow.com/questions/16110252/need-to-compare-very-large-files-around-1-5gb-in-python/16110391#16110391>`__
 
 `Creating a store chunk-by-chunk from a csv file
-<http://stackoverflow.com/questions/20428355/appending-column-to-frame-of-hdf-file-in-pandas/20428786#20428786>`__
+<https://stackoverflow.com/questions/20428355/appending-column-to-frame-of-hdf-file-in-pandas/20428786#20428786>`__
 
 `Appending to a store, while creating a unique index
-<http://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural/16999397#16999397>`__
+<https://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural/16999397#16999397>`__
 
 `Large Data work flows
-<http://stackoverflow.com/questions/14262433/large-data-work-flows-using-pandas>`__
+<https://stackoverflow.com/questions/14262433/large-data-work-flows-using-pandas>`__
 
 `Reading in a sequence of files, then providing a global unique index to a store while appending
-<http://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural>`__
+<https://stackoverflow.com/questions/16997048/how-does-one-append-large-amounts-of-data-to-a-pandas-hdfstore-and-get-a-natural>`__
 
 `Groupby on a HDFStore with low group density
-<http://stackoverflow.com/questions/15798209/pandas-group-by-query-on-large-data-in-hdfstore>`__
+<https://stackoverflow.com/questions/15798209/pandas-group-by-query-on-large-data-in-hdfstore>`__
 
 `Groupby on a HDFStore with high group density
-<http://stackoverflow.com/questions/25459982/trouble-with-grouby-on-millions-of-keys-on-a-chunked-file-in-python-pandas/25471765#25471765>`__
+<https://stackoverflow.com/questions/25459982/trouble-with-grouby-on-millions-of-keys-on-a-chunked-file-in-python-pandas/25471765#25471765>`__
 
 `Hierarchical queries on a HDFStore
-<http://stackoverflow.com/questions/22777284/improve-query-performance-from-a-large-hdfstore-table-with-pandas/22820780#22820780>`__
+<https://stackoverflow.com/questions/22777284/improve-query-performance-from-a-large-hdfstore-table-with-pandas/22820780#22820780>`__
 
 `Counting with a HDFStore
-<http://stackoverflow.com/questions/20497897/converting-dict-of-dicts-into-pandas-dataframe-memory-issues>`__
+<https://stackoverflow.com/questions/20497897/converting-dict-of-dicts-into-pandas-dataframe-memory-issues>`__
 
 `Troubleshoot HDFStore exceptions
-<http://stackoverflow.com/questions/15488809/how-to-trouble-shoot-hdfstore-exception-cannot-find-the-correct-atom-type>`__
+<https://stackoverflow.com/questions/15488809/how-to-trouble-shoot-hdfstore-exception-cannot-find-the-correct-atom-type>`__
 
 `Setting min_itemsize with strings
-<http://stackoverflow.com/questions/15988871/hdfstore-appendstring-dataframe-fails-when-string-column-contents-are-longer>`__
+<https://stackoverflow.com/questions/15988871/hdfstore-appendstring-dataframe-fails-when-string-column-contents-are-longer>`__
 
 `Using ptrepack to create a completely-sorted-index on a store
-<http://stackoverflow.com/questions/17893370/ptrepack-sortby-needs-full-index>`__
+<https://stackoverflow.com/questions/17893370/ptrepack-sortby-needs-full-index>`__
 
 Storing Attributes to a group node
 
@@ -1229,14 +1229,14 @@ in the frame:
    The offsets of the structure elements may be different depending on the
    architecture of the machine on which the file was created. Using a raw
    binary file format like this for general data storage is not recommended, as
-   it is not cross platform. We recommended either HDF5 or msgpack, both of
+   it is not cross platform. We recommended either HDF5 or parquet, both of
    which are supported by pandas' IO facilities.
 
 Computation
 -----------
 
 `Numerical integration (sample-based) of a time series
-<http://nbviewer.ipython.org/5720498>`__
+<https://nbviewer.ipython.org/5720498>`__
 
 Correlation
 ***********
@@ -1284,7 +1284,7 @@ Timedeltas
 The :ref:`Timedeltas <timedeltas.timedeltas>` docs.
 
 `Using timedeltas
-<http://github.com/pandas-dev/pandas/pull/2899>`__
+<https://github.com/pandas-dev/pandas/pull/2899>`__
 
 .. ipython:: python
 
@@ -1305,7 +1305,7 @@ The :ref:`Timedeltas <timedeltas.timedeltas>` docs.
    datetime.timedelta(minutes=5) + s
 
 `Adding and subtracting deltas and dates
-<http://stackoverflow.com/questions/16385785/add-days-to-dates-in-dataframe>`__
+<https://stackoverflow.com/questions/16385785/add-days-to-dates-in-dataframe>`__
 
 .. ipython:: python
 
@@ -1322,7 +1322,7 @@ The :ref:`Timedeltas <timedeltas.timedeltas>` docs.
    df.dtypes
 
 `Another example
-<http://stackoverflow.com/questions/15683588/iterating-through-a-pandas-dataframe>`__
+<https://stackoverflow.com/questions/15683588/iterating-through-a-pandas-dataframe>`__
 
 Values can be set to NaT using np.nan, similar to datetime
 
diff --git a/doc/source/user_guide/enhancingperf.rst b/doc/source/user_guide/enhancingperf.rst
index 2df5b9d82dcc3..1d84d05fda079 100644
--- a/doc/source/user_guide/enhancingperf.rst
+++ b/doc/source/user_guide/enhancingperf.rst
@@ -20,7 +20,7 @@ Cython (writing C extensions for pandas)
 
 For many use cases writing pandas in pure Python and NumPy is sufficient. In some
 computationally heavy applications however, it can be possible to achieve sizable
-speed-ups by offloading work to `cython <http://cython.org/>`__.
+speed-ups by offloading work to `cython <https://cython.org/>`__.
 
 This tutorial assumes you have refactored as much as possible in Python, for example
 by trying to remove for-loops and making use of NumPy vectorization. It's always worth
@@ -69,7 +69,7 @@ We achieve our result by using ``apply`` (row-wise):
 
 But clearly this isn't fast enough for us. Let's take a look and see where the
 time is spent during this operation (limited to the most time consuming
-four calls) using the `prun ipython magic function <http://ipython.org/ipython-doc/stable/api/generated/IPython.core.magics.execution.html#IPython.core.magics.execution.ExecutionMagics.prun>`__:
+four calls) using the `prun ipython magic function <https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-prun>`__:
 
 .. ipython:: python
 
@@ -78,11 +78,6 @@ four calls) using the `prun ipython magic function <http://ipython.org/ipython-d
 By far the majority of time is spend inside either ``integrate_f`` or ``f``,
 hence we'll concentrate our efforts cythonizing these two functions.
 
-.. note::
-
-  In Python 2 replacing the ``range`` with its generator counterpart (``xrange``)
-  would mean the ``range`` line would vanish. In Python 3 ``range`` is already a generator.
-
 .. _enhancingperf.plain:
 
 Plain Cython
@@ -298,7 +293,7 @@ advanced Cython techniques:
 Even faster, with the caveat that a bug in our Cython code (an off-by-one error,
 for example) might cause a segfault because memory access isn't checked.
 For more about ``boundscheck`` and ``wraparound``, see the Cython docs on
-`compiler directives <http://cython.readthedocs.io/en/latest/src/reference/compilation.html?highlight=wraparound#compiler-directives>`__.
+`compiler directives <https://cython.readthedocs.io/en/latest/src/reference/compilation.html?highlight=wraparound#compiler-directives>`__.
 
 .. _enhancingperf.numba:
 
@@ -423,9 +418,9 @@ prefer that Numba throw an error if it cannot compile a function in a way that
 speeds up your code, pass Numba the argument
 ``nopython=True`` (e.g.  ``@numba.jit(nopython=True)``). For more on
 troubleshooting Numba modes, see the `Numba troubleshooting page
-<http://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#the-compiled-code-is-too-slow>`__.
+<https://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#the-compiled-code-is-too-slow>`__.
 
-Read more in the `Numba docs <http://numba.pydata.org/>`__.
+Read more in the `Numba docs <https://numba.pydata.org/>`__.
 
 .. _enhancingperf.eval:
 
diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index 141d1708d882d..8cd229070e365 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -311,8 +311,6 @@ Grouping with multiple levels is supported.
    s
    s.groupby(level=['first', 'second']).sum()
 
-.. versionadded:: 0.20
-
 Index level names may be supplied as keys.
 
 .. ipython:: python
@@ -353,8 +351,6 @@ Index levels may also be specified by name.
 
    df.groupby([pd.Grouper(level='second'), 'A']).sum()
 
-.. versionadded:: 0.20
-
 Index level names may be specified as keys directly to ``groupby``.
 
 .. ipython:: python
@@ -1274,8 +1270,6 @@ To see the order in which each row appears within its group, use the
 Enumerate groups
 ~~~~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.2
-
 To see the ordering of the groups (as opposed to the order of rows
 within a group given by ``cumcount``) you can use
 :meth:`~pandas.core.groupby.DataFrameGroupBy.ngroup`.
diff --git a/doc/source/user_guide/index.rst b/doc/source/user_guide/index.rst
index 05df83decbd7e..30b1c0b4eac0d 100644
--- a/doc/source/user_guide/index.rst
+++ b/doc/source/user_guide/index.rst
@@ -30,6 +30,7 @@ Further information on any specific method can be obtained in the
     missing_data
     categorical
     integer_na
+    boolean
     visualization
     computation
     groupby
@@ -38,6 +39,7 @@ Further information on any specific method can be obtained in the
     style
     options
     enhancingperf
+    scale
     sparse
     gotchas
     cookbook
diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index cf55ce0c9a6d4..a8cdf4a61073d 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -374,7 +374,7 @@ For getting values with a boolean array:
    df1.loc['a'] > 0
    df1.loc[:, df1.loc['a'] > 0]
 
-For getting a value explicitly (equivalent to deprecated ``df.get_value('a','A')``):
+For getting a value explicitly:
 
 .. ipython:: python
 
@@ -668,7 +668,7 @@ Current behavior
    KeyError in the future, you can use .reindex() as an alternative.
 
    See the documentation here:
-   http://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
+   https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
 
    Out[4]:
    1    2.0
diff --git a/doc/source/user_guide/integer_na.rst b/doc/source/user_guide/integer_na.rst
index 97b9c2f95dc50..a45d7a4fa1547 100644
--- a/doc/source/user_guide/integer_na.rst
+++ b/doc/source/user_guide/integer_na.rst
@@ -15,6 +15,10 @@ Nullable integer data type
    IntegerArray is currently experimental. Its API or implementation may
    change without warning.
 
+.. versionchanged:: 1.0.0
+
+   Now uses :attr:`pandas.NA` as the missing value rather
+   than :attr:`numpy.nan`.
 
 In :ref:`missing_data`, we saw that pandas primarily uses ``NaN`` to represent
 missing data. Because ``NaN`` is a float, this forces an array of integers with
@@ -23,14 +27,16 @@ much. But if your integer column is, say, an identifier, casting to float can
 be problematic. Some integers cannot even be represented as floating point
 numbers.
 
+Construction
+------------
+
 Pandas can represent integer data with possibly missing values using
 :class:`arrays.IntegerArray`. This is an :ref:`extension types <extending.extension-types>`
-implemented within pandas. It is not the default dtype for integers, and will not be inferred;
-you must explicitly pass the dtype into :meth:`array` or :class:`Series`:
+implemented within pandas.
 
 .. ipython:: python
 
-   arr = pd.array([1, 2, np.nan], dtype=pd.Int64Dtype())
+   arr = pd.array([1, 2, None], dtype=pd.Int64Dtype())
    arr
 
 Or the string alias ``"Int64"`` (note the capital ``"I"``, to differentiate from
@@ -40,6 +46,12 @@ NumPy's ``'int64'`` dtype:
 
    pd.array([1, 2, np.nan], dtype="Int64")
 
+All NA-like values are replaced with :attr:`pandas.NA`.
+
+.. ipython:: python
+
+   pd.array([1, 2, np.nan, None, pd.NA], dtype="Int64")
+
 This array can be stored in a :class:`DataFrame` or :class:`Series` like any
 NumPy array.
 
@@ -50,24 +62,46 @@ NumPy array.
 You can also pass the list-like object to the :class:`Series` constructor
 with the dtype.
 
-.. ipython:: python
+.. warning::
 
-   s = pd.Series([1, 2, np.nan], dtype="Int64")
-   s
+   Currently :meth:`pandas.array` and :meth:`pandas.Series` use different
+   rules for dtype inference. :meth:`pandas.array` will infer a nullable-
+   integer dtype
 
-By default (if you don't specify ``dtype``), NumPy is used, and you'll end
-up with a ``float64`` dtype Series:
+   .. ipython:: python
 
-.. ipython:: python
+      pd.array([1, None])
+      pd.array([1, 2])
+
+   For backwards-compatibility, :class:`Series` infers these as either
+   integer or float dtype
+
+   .. ipython:: python
+
+      pd.Series([1, None])
+      pd.Series([1, 2])
 
-   pd.Series([1, 2, np.nan])
+   We recommend explicitly providing the dtype to avoid confusion.
+
+   .. ipython:: python
+
+      pd.array([1, None], dtype="Int64")
+      pd.Series([1, None], dtype="Int64")
+
+   In the future, we may provide an option for :class:`Series` to infer a
+   nullable-integer dtype.
+
+Operations
+----------
 
 Operations involving an integer array will behave similar to NumPy arrays.
-Missing values will be propagated, and and the data will be coerced to another
+Missing values will be propagated, and the data will be coerced to another
 dtype if needed.
 
 .. ipython:: python
 
+   s = pd.Series([1, 2, None], dtype="Int64")
+
    # arithmetic
    s + 1
 
@@ -105,3 +139,15 @@ Reduction and groupby operations such as 'sum' work as well.
 
    df.sum()
    df.groupby('B').A.sum()
+
+Scalar NA Value
+---------------
+
+:class:`arrays.IntegerArray` uses :attr:`pandas.NA` as its scalar
+missing value. Slicing a single element that's missing will return
+:attr:`pandas.NA`
+
+.. ipython:: python
+
+   a = pd.array([1, None], dtype="Int64")
+   a[1]
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index f6b0c55d39f65..bd19b35e8d9e8 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -3,15 +3,6 @@
 .. currentmodule:: pandas
 
 
-{{ header }}
-
-.. ipython:: python
-   :suppress:
-
-   clipdf = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': ['p', 'q', 'r']},
-                         index=['x', 'y', 'z'])
-
-
 ===============================
 IO tools (text, CSV, HDF5, ...)
 ===============================
@@ -32,25 +23,25 @@ The pandas I/O API is a set of top level ``reader`` functions accessed like
     text;`JSON <https://www.json.org/>`__;:ref:`read_json<io.json_reader>`;:ref:`to_json<io.json_writer>`
     text;`HTML <https://en.wikipedia.org/wiki/HTML>`__;:ref:`read_html<io.read_html>`;:ref:`to_html<io.html>`
     text; Local clipboard;:ref:`read_clipboard<io.clipboard>`;:ref:`to_clipboard<io.clipboard>`
-    binary;`MS Excel <https://en.wikipedia.org/wiki/Microsoft_Excel>`__;:ref:`read_excel<io.excel_reader>`;:ref:`to_excel<io.excel_writer>`
+    ;`MS Excel <https://en.wikipedia.org/wiki/Microsoft_Excel>`__;:ref:`read_excel<io.excel_reader>`;:ref:`to_excel<io.excel_writer>`
     binary;`OpenDocument <http://www.opendocumentformat.org>`__;:ref:`read_excel<io.ods>`;
     binary;`HDF5 Format <https://support.hdfgroup.org/HDF5/whatishdf5.html>`__;:ref:`read_hdf<io.hdf5>`;:ref:`to_hdf<io.hdf5>`
     binary;`Feather Format <https://github.com/wesm/feather>`__;:ref:`read_feather<io.feather>`;:ref:`to_feather<io.feather>`
     binary;`Parquet Format <https://parquet.apache.org/>`__;:ref:`read_parquet<io.parquet>`;:ref:`to_parquet<io.parquet>`
+    binary;`ORC Format <//https://orc.apache.org/>`__;:ref:`read_orc<io.orc>`;
     binary;`Msgpack <https://msgpack.org/index.html>`__;:ref:`read_msgpack<io.msgpack>`;:ref:`to_msgpack<io.msgpack>`
     binary;`Stata <https://en.wikipedia.org/wiki/Stata>`__;:ref:`read_stata<io.stata_reader>`;:ref:`to_stata<io.stata_writer>`
     binary;`SAS <https://en.wikipedia.org/wiki/SAS_(software)>`__;:ref:`read_sas<io.sas_reader>`;
     binary;`SPSS <https://en.wikipedia.org/wiki/SPSS>`__;:ref:`read_spss<io.spss_reader>`;
     binary;`Python Pickle Format <https://docs.python.org/3/library/pickle.html>`__;:ref:`read_pickle<io.pickle>`;:ref:`to_pickle<io.pickle>`
     SQL;`SQL <https://en.wikipedia.org/wiki/SQL>`__;:ref:`read_sql<io.sql>`;:ref:`to_sql<io.sql>`
-    SQL;`Google Big Query <https://en.wikipedia.org/wiki/BigQuery>`__;:ref:`read_gbq<io.bigquery>`;:ref:`to_gbq<io.bigquery>`
+    SQL;`Google BigQuery <https://en.wikipedia.org/wiki/BigQuery>`__;:ref:`read_gbq<io.bigquery>`;:ref:`to_gbq<io.bigquery>`
 
 :ref:`Here <io.perf>` is an informal performance comparison for some of these IO methods.
 
 .. note::
    For examples that use the ``StringIO`` class, make sure you import it
-   according to your Python version, i.e. ``from StringIO import StringIO`` for
-   Python 2 and ``from io import StringIO`` for Python 3.
+   with ``from io import StringIO`` for Python 3.
 
 .. _io.read_csv_table:
 
@@ -137,7 +128,8 @@ usecols : list-like or callable, default ``None``
 
   .. ipython:: python
 
-     from io import StringIO, BytesIO
+     import pandas as pd
+     from io import StringIO
      data = ('col1,col2,col3\n'
              'a,b,1\n'
              'a,b,2\n'
@@ -163,9 +155,6 @@ dtype : Type name or dict of column -> type, default ``None``
   (unsupported with ``engine='python'``). Use `str` or `object` together
   with suitable ``na_values`` settings to preserve and
   not interpret dtype.
-
-  .. versionadded:: 0.20.0 support for the Python parser.
-
 engine : {``'c'``, ``'python'``}
   Parser engine to use. The C engine is faster while the Python engine is
   currently more feature-complete.
@@ -363,6 +352,7 @@ columns:
 
 .. ipython:: python
 
+    import numpy as np
     data = ('a,b,c,d\n'
             '1,2,3,4\n'
             '5,6,7,8\n'
@@ -417,10 +407,6 @@ However, if you wanted for all the data to be coerced, no matter the type, then
 using the ``converters`` argument of :func:`~pandas.read_csv` would certainly be
 worth trying.
 
-  .. versionadded:: 0.20.0 support for the Python parser.
-
-     The ``dtype`` option is supported by the 'python' engine.
-
 .. note::
    In some cases, reading in abnormal data with columns containing mixed dtypes
    will result in an inconsistent dataset. If you rely on pandas to infer the
@@ -447,7 +433,6 @@ worth trying.
    :suppress:
 
    import os
-
    os.remove('foo.csv')
 
 .. _io.categorical:
@@ -616,8 +601,6 @@ Filtering columns (``usecols``)
 The ``usecols`` argument allows you to select any subset of the columns in a
 file, either using the column names, position numbers or a callable:
 
-.. versionadded:: 0.20.0 support for callable `usecols` arguments
-
 .. ipython:: python
 
     data = 'a,b,c,d\n1,2,3,foo\n4,5,6,bar\n7,8,9,baz'
@@ -757,6 +740,7 @@ result in byte strings being decoded to unicode in the result:
 
 .. ipython:: python
 
+   from io import BytesIO
    data = (b'word,length\n'
            b'Tr\xc3\xa4umen,7\n'
            b'Gr\xc3\xbc\xc3\x9fe,5')
@@ -927,16 +911,6 @@ data columns:
    significantly faster, ~20x has been observed.
 
 
-.. note::
-
-   When passing a dict as the `parse_dates` argument, the order of
-   the columns prepended is not guaranteed, because `dict` objects do not impose
-   an ordering on their keys. On Python 2.7+ you may use `collections.OrderedDict`
-   instead of a regular `dict` if this matters to you. Because of this, when using a
-   dict for 'parse_dates' in conjunction with the `index_col` argument, it's best to
-   specify `index_col` as a column label rather then as an index on the resulting frame.
-
-
 Date parsing functions
 ++++++++++++++++++++++
 
@@ -1168,7 +1142,7 @@ To completely override the default values that are recognized as missing, specif
 .. _io.navaluesconst:
 
 The default ``NaN`` recognized values are ``['-1.#IND', '1.#QNAN', '1.#IND', '-1.#QNAN', '#N/A N/A', '#N/A', 'N/A',
-'n/a', 'NA', '#NA', 'NULL', 'null', 'NaN', '-NaN', 'nan', '-nan', '']``.
+'n/a', 'NA', '<NA>', '#NA', 'NULL', 'null', 'NaN', '-NaN', 'nan', '-nan', '']``.
 
 Let us consider some examples:
 
@@ -1447,8 +1421,6 @@ is whitespace).
    df = pd.read_fwf('bar.csv', header=None, index_col=0)
    df
 
-.. versionadded:: 0.20.0
-
 ``read_fwf`` supports the ``dtype`` parameter for specifying the types of
 parsed columns to be different from the inferred type.
 
@@ -1536,7 +1508,7 @@ rows will skip the intervening rows.
 
 .. ipython:: python
 
-   from pandas.util.testing import makeCustomDataframe as mkdf
+   from pandas._testing import makeCustomDataframe as mkdf
    df = mkdf(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
    df.to_csv('mi.csv')
    print(open('mi.csv').read())
@@ -2083,6 +2055,8 @@ The Numpy parameter
 +++++++++++++++++++
 
 .. note::
+  This param has been deprecated as of version 1.0.0 and will raise a ``FutureWarning``.
+
   This supports numeric data only. Index and columns labels may be non-numeric, e.g. strings, dates etc.
 
 If ``numpy=True`` is passed to ``read_json`` an attempt will be made to sniff
@@ -2105,6 +2079,7 @@ data:
    %timeit pd.read_json(jsonfloats)
 
 .. ipython:: python
+   :okwarning:
 
    %timeit pd.read_json(jsonfloats, numpy=True)
 
@@ -2119,6 +2094,7 @@ The speedup is less noticeable for smaller datasets:
    %timeit pd.read_json(jsonfloats)
 
 .. ipython:: python
+   :okwarning:
 
    %timeit pd.read_json(jsonfloats, numpy=True)
 
@@ -2153,27 +2129,26 @@ into a flat table.
 
 .. ipython:: python
 
-   from pandas.io.json import json_normalize
    data = [{'id': 1, 'name': {'first': 'Coleen', 'last': 'Volk'}},
            {'name': {'given': 'Mose', 'family': 'Regner'}},
            {'id': 2, 'name': 'Faye Raker'}]
-   json_normalize(data)
+   pd.json_normalize(data)
 
 .. ipython:: python
 
    data = [{'state': 'Florida',
             'shortname': 'FL',
             'info': {'governor': 'Rick Scott'},
-            'counties': [{'name': 'Dade', 'population': 12345},
-                         {'name': 'Broward', 'population': 40000},
-                         {'name': 'Palm Beach', 'population': 60000}]},
+            'county': [{'name': 'Dade', 'population': 12345},
+                       {'name': 'Broward', 'population': 40000},
+                       {'name': 'Palm Beach', 'population': 60000}]},
            {'state': 'Ohio',
             'shortname': 'OH',
             'info': {'governor': 'John Kasich'},
-            'counties': [{'name': 'Summit', 'population': 1234},
-                         {'name': 'Cuyahoga', 'population': 1337}]}]
+            'county': [{'name': 'Summit', 'population': 1234},
+                       {'name': 'Cuyahoga', 'population': 1337}]}]
 
-   json_normalize(data, 'counties', ['state', 'shortname', ['info', 'governor']])
+   pd.json_normalize(data, 'county', ['state', 'shortname', ['info', 'governor']])
 
 The max_level parameter provides more control over which level to end normalization.
 With max_level=1 the following snippet normalizes until 1st nesting level of the provided dict.
@@ -2186,7 +2161,7 @@ With max_level=1 the following snippet normalizes until 1st nesting level of the
                                       'Name': 'Name001'}},
              'Image': {'a': 'b'}
              }]
-    json_normalize(data, max_level=1)
+    pd.json_normalize(data, max_level=1)
 
 .. _io.jsonl:
 
@@ -2221,8 +2196,6 @@ For line-delimited json files, pandas can also return an iterator which reads in
 Table schema
 ''''''''''''
 
-.. versionadded:: 0.20.0
-
 `Table Schema`_ is a spec for describing tabular datasets as a JSON
 object. The JSON includes information on the field names, types, and
 other attributes. You can use the orient ``table`` to build
@@ -2469,7 +2442,7 @@ Specify a number of rows to skip:
 
    dfs = pd.read_html(url, skiprows=0)
 
-Specify a number of rows to skip using a list (``xrange`` (Python 2 only) works
+Specify a number of rows to skip using a list (``range`` works
 as well):
 
 .. code-block:: python
@@ -2649,7 +2622,7 @@ that contain URLs.
 
    url_df = pd.DataFrame({
        'name': ['Python', 'Pandas'],
-       'url': ['https://www.python.org/', 'http://pandas.pydata.org']})
+       'url': ['https://www.python.org/', 'https://pandas.pydata.org']})
    print(url_df.to_html(render_links=True))
 
 .. ipython:: python
@@ -2784,7 +2757,8 @@ Excel files
 
 The :func:`~pandas.read_excel` method can read Excel 2003 (``.xls``)
 files using the ``xlrd`` Python module.  Excel 2007+ (``.xlsx``) files
-can be read using either ``xlrd`` or ``openpyxl``.
+can be read using either ``xlrd`` or ``openpyxl``. Binary Excel (``.xlsb``)
+files can be read using ``pyxlsb``.
 The :meth:`~DataFrame.to_excel` instance method is used for
 saving a ``DataFrame`` to Excel.  Generally the semantics are
 similar to working with :ref:`csv<io.read_csv_table>` data.
@@ -3071,8 +3045,6 @@ missing data to recover integer dtype:
 Dtype specifications
 ++++++++++++++++++++
 
-.. versionadded:: 0.20
-
 As an alternative to converters, the type for an entire column can
 be specified using the `dtype` keyword, which takes a dictionary
 mapping column names to types.  To interpret data with
@@ -3141,11 +3113,7 @@ Pandas supports writing Excel files to buffer-like objects such as ``StringIO``
 
 .. code-block:: python
 
-   # Safe import for either Python 2.x or 3.x
-   try:
-       from io import BytesIO
-   except ImportError:
-       from cStringIO import StringIO as BytesIO
+   from io import BytesIO
 
    bio = BytesIO()
 
@@ -3247,6 +3215,30 @@ OpenDocument spreadsheets match what can be done for `Excel files`_ using
    Currently pandas only supports *reading* OpenDocument spreadsheets. Writing
    is not implemented.
 
+.. _io.xlsb:
+
+Binary Excel (.xlsb) files
+--------------------------
+
+.. versionadded:: 1.0.0
+
+The :func:`~pandas.read_excel` method can also read binary Excel files
+using the ``pyxlsb`` module. The semantics and features for reading
+binary Excel files mostly match what can be done for `Excel files`_ using
+``engine='pyxlsb'``. ``pyxlsb`` does not recognize datetime types
+in files and will return floats instead.
+
+.. code-block:: python
+
+   # Returns a DataFrame
+   pd.read_excel('path_to_file.xlsb', engine='pyxlsb')
+
+.. note::
+
+   Currently pandas only supports *reading* binary Excel files. Writing
+   is not implemented.
+
+
 .. _io.clipboard:
 
 Clipboard
@@ -3345,8 +3337,6 @@ any pickled pandas object (or any other pickled object) from file:
 Compressed pickle files
 '''''''''''''''''''''''
 
-.. versionadded:: 0.20.0
-
 :func:`read_pickle`, :meth:`DataFrame.to_pickle` and :meth:`Series.to_pickle` can read
 and write compressed pickle files. The compression types of ``gzip``, ``bz2``, ``xz`` are supported for reading and writing.
 The ``zip`` file format only supports reading and must contain only one data file
@@ -3405,87 +3395,19 @@ The default is to 'infer':
 msgpack
 -------
 
-pandas supports the ``msgpack`` format for
-object serialization. This is a lightweight portable binary format, similar
-to binary JSON, that is highly space efficient, and provides good performance
-both on the writing (serialization), and reading (deserialization).
-
-.. warning::
-
-   The msgpack format is deprecated as of 0.25 and will be removed in a future version.
-   It is recommended to use pyarrow for on-the-wire transmission of pandas objects.
-
-.. warning::
-
-   :func:`read_msgpack` is only guaranteed backwards compatible back to pandas version 0.20.3
-
-.. ipython:: python
-   :okwarning:
-
-   df = pd.DataFrame(np.random.rand(5, 2), columns=list('AB'))
-   df.to_msgpack('foo.msg')
-   pd.read_msgpack('foo.msg')
-   s = pd.Series(np.random.rand(5), index=pd.date_range('20130101', periods=5))
-
-You can pass a list of objects and you will receive them back on deserialization.
-
-.. ipython:: python
-   :okwarning:
-
-   pd.to_msgpack('foo.msg', df, 'foo', np.array([1, 2, 3]), s)
-   pd.read_msgpack('foo.msg')
-
-You can pass ``iterator=True`` to iterate over the unpacked results:
-
-.. ipython:: python
-   :okwarning:
-
-   for o in pd.read_msgpack('foo.msg', iterator=True):
-       print(o)
-
-You can pass ``append=True`` to the writer to append to an existing pack:
-
-.. ipython:: python
-   :okwarning:
-
-   df.to_msgpack('foo.msg', append=True)
-   pd.read_msgpack('foo.msg')
-
-Unlike other io methods, ``to_msgpack`` is available on both a per-object basis,
-``df.to_msgpack()`` and using the top-level ``pd.to_msgpack(...)`` where you
-can pack arbitrary collections of Python lists, dicts, scalars, while intermixing
-pandas objects.
-
-.. ipython:: python
-   :okwarning:
-
-   pd.to_msgpack('foo2.msg', {'dict': [{'df': df}, {'string': 'foo'},
-                                       {'scalar': 1.}, {'s': s}]})
-   pd.read_msgpack('foo2.msg')
-
-.. ipython:: python
-   :suppress:
-   :okexcept:
-
-   os.remove('foo.msg')
-   os.remove('foo2.msg')
+pandas support for ``msgpack`` has been removed in version 1.0.0.  It is recommended to use pyarrow for on-the-wire transmission of pandas objects.
 
-Read/write API
-''''''''''''''
+Example pyarrow usage:
 
-Msgpacks can also be read from and written to strings.
-
-.. ipython:: python
-   :okwarning:
-
-   df.to_msgpack()
-
-Furthermore you can concatenate the strings to produce a list of the original objects.
+.. code-block:: python
 
-.. ipython:: python
-   :okwarning:
+    >>> import pandas as pd
+    >>> import pyarrow as pa
+    >>> df = pd.DataFrame({'A': [1, 2, 3]})
+    >>> context = pa.default_serialization_context()
+    >>> df_bytestring = context.serialize(df).to_buffer().to_pybytes()
 
-   pd.read_msgpack(df.to_msgpack() + s.to_msgpack())
+For documentation on pyarrow, see `here <https://arrow.apache.org/docs/python/index.html>`__.
 
 .. _io.hdf5:
 
@@ -3811,6 +3733,8 @@ storing/selecting from homogeneous index ``DataFrames``.
         # the levels are automatically included as data columns
         store.select('df_mi', 'foo=bar')
 
+.. note::
+   The ``index`` keyword is reserved and cannot be use as a level name.
 
 .. _io.hdf5-query:
 
@@ -3829,6 +3753,7 @@ A query is specified using the ``Term`` class under the hood, as a boolean expre
 
 * ``index`` and ``columns`` are supported indexers of ``DataFrames``.
 * if ``data_columns`` are specified, these can be used as additional indexers.
+* level name in a MultiIndex, with default name  ``level_0``, ``level_1``, … if not provided.
 
 Valid comparison operators are:
 
@@ -3947,7 +3872,7 @@ space. These are in terms of the total number of rows in a table.
 
 .. _io.hdf5-timedelta:
 
-Using timedelta64[ns]
+Query timedelta64[ns]
 +++++++++++++++++++++
 
 You can store and query using the ``timedelta64[ns]`` type. Terms can be
@@ -3966,6 +3891,37 @@ specified in the format: ``<float>(<unit>)``, where float may be signed (and fra
    store.append('dftd', dftd, data_columns=True)
    store.select('dftd', "C<'-3.5D'")
 
+.. _io.query_multi:
+
+Query MultiIndex
+++++++++++++++++
+
+Selecting from a ``MultiIndex`` can be achieved by using the name of the level.
+
+.. ipython:: python
+
+   df_mi.index.names
+   store.select('df_mi', "foo=baz and bar=two")
+
+If the ``MultiIndex`` levels names are ``None``, the levels are automatically made available via
+the ``level_n`` keyword with ``n`` the level of the ``MultiIndex`` you want to select from.
+
+.. ipython:: python
+
+   index = pd.MultiIndex(
+       levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
+       codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
+   )
+   df_mi_2 = pd.DataFrame(np.random.randn(10, 3),
+                          index=index, columns=["A", "B", "C"])
+   df_mi_2
+
+   store.append("df_mi_2", df_mi_2)
+
+   # the levels are automatically included as data columns with keyword level_n
+   store.select("df_mi_2", "level_0=foo and level_1=two")
+
+
 Indexing
 ++++++++
 
@@ -4274,48 +4230,49 @@ Compression
 all kinds of stores, not just tables. Two parameters are used to
 control compression: ``complevel`` and ``complib``.
 
-``complevel`` specifies if and how hard data is to be compressed.
-              ``complevel=0`` and ``complevel=None`` disables
-              compression and ``0<complevel<10`` enables compression.
-
-``complib`` specifies which compression library to use. If nothing is
-            specified the default library ``zlib`` is used. A
-            compression library usually optimizes for either good
-            compression rates or speed and the results will depend on
-            the type of data. Which type of
-            compression to choose depends on your specific needs and
-            data. The list of supported compression libraries:
-
-             - `zlib <https://zlib.net/>`_: The default compression library. A classic in terms of compression, achieves good compression rates but is somewhat slow.
-             - `lzo <https://www.oberhumer.com/opensource/lzo/>`_: Fast compression and decompression.
-             - `bzip2 <http://bzip.org/>`_: Good compression rates.
-             - `blosc <http://www.blosc.org/>`_: Fast compression and decompression.
-
-             .. versionadded:: 0.20.2
-
-                Support for alternative blosc compressors:
-
-                - `blosc:blosclz <http://www.blosc.org/>`_ This is the
-                  default compressor for ``blosc``
-                - `blosc:lz4
-                  <https://fastcompression.blogspot.dk/p/lz4.html>`_:
-                  A compact, very popular and fast compressor.
-                - `blosc:lz4hc
-                  <https://fastcompression.blogspot.dk/p/lz4.html>`_:
-                  A tweaked version of LZ4, produces better
-                  compression ratios at the expense of speed.
-                - `blosc:snappy <https://google.github.io/snappy/>`_:
-                  A popular compressor used in many places.
-                - `blosc:zlib <https://zlib.net/>`_: A classic;
-                  somewhat slower than the previous ones, but
-                  achieving better compression ratios.
-                - `blosc:zstd <https://facebook.github.io/zstd/>`_: An
-                  extremely well balanced codec; it provides the best
-                  compression ratios among the others above, and at
-                  reasonably fast speed.
-
-             If ``complib`` is defined as something other than the
-             listed libraries a ``ValueError`` exception is issued.
+* ``complevel`` specifies if and how hard data is to be compressed.
+  ``complevel=0`` and ``complevel=None`` disables compression and
+  ``0<complevel<10`` enables compression.
+
+* ``complib`` specifies which compression library to use.
+  If nothing is  specified the default library ``zlib`` is used. A
+  compression library usually optimizes for either good compression rates
+  or speed and the results will depend on the type of data. Which type of
+  compression to choose depends on your specific needs and data. The list
+  of supported compression libraries:
+
+  - `zlib <https://zlib.net/>`_: The default compression library.
+    A classic in terms of compression, achieves good compression
+    rates but is somewhat slow.
+  - `lzo <https://www.oberhumer.com/opensource/lzo/>`_: Fast
+    compression and decompression.
+  - `bzip2 <http://bzip.org/>`_: Good compression rates.
+  - `blosc <https://www.blosc.org/>`_: Fast compression and
+    decompression.
+
+    Support for alternative blosc compressors:
+
+    - `blosc:blosclz <https://www.blosc.org/>`_ This is the
+      default compressor for ``blosc``
+    - `blosc:lz4
+      <https://fastcompression.blogspot.dk/p/lz4.html>`_:
+      A compact, very popular and fast compressor.
+    - `blosc:lz4hc
+      <https://fastcompression.blogspot.dk/p/lz4.html>`_:
+      A tweaked version of LZ4, produces better
+      compression ratios at the expense of speed.
+    - `blosc:snappy <https://google.github.io/snappy/>`_:
+      A popular compressor used in many places.
+    - `blosc:zlib <https://zlib.net/>`_: A classic;
+      somewhat slower than the previous ones, but
+      achieving better compression ratios.
+    - `blosc:zstd <https://facebook.github.io/zstd/>`_: An
+      extremely well balanced codec; it provides the best
+      compression ratios among the others above, and at
+      reasonably fast speed.
+
+  If ``complib`` is defined as something other than the listed libraries a
+  ``ValueError`` exception is issued.
 
 .. note::
 
@@ -4619,8 +4576,6 @@ Performance
 Feather
 -------
 
-.. versionadded:: 0.20.0
-
 Feather provides binary columnar serialization for data frames. It is designed to make reading and writing data
 frames efficient, and to make sharing data across data analysis languages easy.
 
@@ -4641,6 +4596,14 @@ Several caveats.
 
 See the `Full Documentation <https://github.com/wesm/feather>`__.
 
+.. ipython:: python
+   :suppress:
+
+   import warnings
+   # This can be removed once building with pyarrow >=0.15.0
+   warnings.filterwarnings("ignore", "The Sparse", FutureWarning)
+
+
 .. ipython:: python
 
    df = pd.DataFrame({'a': list('abc'),
@@ -4659,14 +4622,12 @@ See the `Full Documentation <https://github.com/wesm/feather>`__.
 Write to a feather file.
 
 .. ipython:: python
-   :okwarning:
 
    df.to_feather('example.feather')
 
 Read from a feather file.
 
 .. ipython:: python
-   :okwarning:
 
    result = pd.read_feather('example.feather')
    result
@@ -4702,9 +4663,13 @@ Several caveats.
   indexes. This extra column can cause problems for non-Pandas consumers that are not expecting it. You can
   force including or omitting indexes with the ``index`` argument, regardless of the underlying engine.
 * Index level names, if specified, must be strings.
-* Categorical dtypes can be serialized to parquet, but will de-serialize as ``object`` dtype.
-* Non supported types include ``Period`` and actual Python object types. These will raise a helpful error message
-  on an attempt at serialization.
+* In the ``pyarrow`` engine, categorical dtypes for non-string types can be serialized to parquet, but will de-serialize as their primitive dtype.
+* The ``pyarrow`` engine preserves the ``ordered`` flag of categorical dtypes with string types. ``fastparquet`` does not preserve the ``ordered`` flag.
+* Non supported types include ``Interval`` and actual Python object types. These will raise a helpful error message
+  on an attempt at serialization. ``Period`` type is supported with pyarrow >= 0.16.0.
+* The ``pyarrow`` engine preserves extension data types such as the nullable integer and string data
+  type (requiring pyarrow >= 0.16.0, and requiring the extension type to implement the needed protocols,
+  see the :ref:`extension types documentation <extending.extension.arrow>`).
 
 You can specify an ``engine`` to direct the serialization. This can be one of ``pyarrow``, or ``fastparquet``, or ``auto``.
 If the engine is NOT specified, then the ``pd.options.io.parquet.engine`` option is checked; if this is also ``auto``,
@@ -4726,7 +4691,9 @@ See the documentation for `pyarrow <https://arrow.apache.org/docs/python/>`__ an
                       'd': np.arange(4.0, 7.0, dtype='float64'),
                       'e': [True, False, True],
                       'f': pd.date_range('20130101', periods=3),
-                      'g': pd.date_range('20130101', periods=3, tz='US/Eastern')})
+                      'g': pd.date_range('20130101', periods=3, tz='US/Eastern'),
+                      'h': pd.Categorical(list('abc')),
+                      'i': pd.Categorical(list('abc'), ordered=True)})
 
    df
    df.dtypes
@@ -4742,7 +4709,6 @@ Write to a parquet file.
 Read from a parquet file.
 
 .. ipython:: python
-   :okwarning:
 
    result = pd.read_parquet('example_fp.parquet', engine='fastparquet')
    result = pd.read_parquet('example_pa.parquet', engine='pyarrow')
@@ -4752,7 +4718,6 @@ Read from a parquet file.
 Read only certain columns of a parquet file.
 
 .. ipython:: python
-   :okwarning:
 
    result = pd.read_parquet('example_fp.parquet',
                             engine='fastparquet', columns=['a', 'b'])
@@ -4775,7 +4740,6 @@ Serializing a ``DataFrame`` to parquet may include the implicit index as one or
 more columns in the output file. Thus, this code:
 
 .. ipython:: python
-   :okwarning:
 
     df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
     df.to_parquet('test.parquet', engine='pyarrow')
@@ -4792,7 +4756,6 @@ If you want to omit a dataframe's indexes when writing, pass ``index=False`` to
 :func:`~pandas.DataFrame.to_parquet`:
 
 .. ipython:: python
-   :okwarning:
 
     df.to_parquet('test.parquet', index=False)
 
@@ -4817,13 +4780,12 @@ Partitioning Parquet files
 Parquet supports partitioning of data based on the values of one or more columns.
 
 .. ipython:: python
-    :okwarning:
 
     df = pd.DataFrame({'a': [0, 0, 1, 1], 'b': [0, 1, 0, 1]})
-    df.to_parquet(fname='test', engine='pyarrow',
+    df.to_parquet(path='test', engine='pyarrow',
                   partition_cols=['a'], compression=None)
 
-The `fname` specifies the parent directory to which data will be saved.
+The `path` specifies the parent directory to which data will be saved.
 The `partition_cols` are the column names by which the dataset will be partitioned.
 Columns are partitioned in the order they are given. The partition splits are
 determined by the unique values in the partition columns.
@@ -4845,9 +4807,20 @@ The above example creates a partitioned dataset that may look like:
    from shutil import rmtree
    try:
        rmtree('test')
-   except Exception:
+   except OSError:
        pass
 
+.. _io.orc:
+
+ORC
+---
+
+.. versionadded:: 1.0.0
+
+Similar to the :ref:`parquet <io.parquet>` format, the `ORC Format <//https://orc.apache.org/>`__ is a binary columnar serialization
+for data frames. It is designed to make reading data frames efficient. Pandas provides *only* a reader for the
+ORC format, :func:`~pandas.read_orc`. This requires the `pyarrow <https://arrow.apache.org/docs/python/>`__ library.
+
 .. _io.sql:
 
 SQL queries
@@ -4874,7 +4847,6 @@ See also some :ref:`cookbook examples <cookbook.sql>` for some advanced strategi
 The key functions are:
 
 .. autosummary::
-    :toctree: ../reference/api/
 
     read_sql_table
     read_sql_query
@@ -5034,7 +5006,7 @@ Possible values are:
   like *Presto* and *Redshift*, but has worse performance for
   traditional SQL backend if the table contains many columns.
   For more information check the SQLAlchemy `documention
-  <http://docs.sqlalchemy.org/en/latest/core/dml.html#sqlalchemy.sql.expression.Insert.values.params.*args>`__.
+  <https://docs.sqlalchemy.org/en/latest/core/dml.html#sqlalchemy.sql.expression.Insert.values.params.*args>`__.
 - callable with signature ``(pd_table, conn, keys, data_iter)``:
   This can be used to implement a more performant insertion method based on
   specific backend dialect features.
@@ -5564,7 +5536,7 @@ Performance considerations
 --------------------------
 
 This is an informal comparison of various IO methods, using pandas
-0.20.3. Timings are machine dependent and small differences should be
+0.24.2. Timings are machine dependent and small differences should be
 ignored.
 
 .. code-block:: ipython
@@ -5585,11 +5557,18 @@ Given the next test set:
 
 .. code-block:: python
 
-   from numpy.random import randn
+
+
+   import numpy as np
+
+   import os
 
    sz = 1000000
-   df = pd.DataFrame({'A': randn(sz), 'B': [1] * sz})
+   df = pd.DataFrame({'A': np.random.randn(sz), 'B': [1] * sz})
 
+   sz = 1000000
+   np.random.seed(42)
+   df = pd.DataFrame({'A': np.random.randn(sz), 'B': [1] * sz})
 
    def test_sql_write(df):
        if os.path.exists('test.sql'):
@@ -5598,151 +5577,149 @@ Given the next test set:
        df.to_sql(name='test_table', con=sql_db)
        sql_db.close()
 
-
    def test_sql_read():
        sql_db = sqlite3.connect('test.sql')
        pd.read_sql_query("select * from test_table", sql_db)
        sql_db.close()
 
-
    def test_hdf_fixed_write(df):
        df.to_hdf('test_fixed.hdf', 'test', mode='w')
 
-
    def test_hdf_fixed_read():
        pd.read_hdf('test_fixed.hdf', 'test')
 
-
    def test_hdf_fixed_write_compress(df):
        df.to_hdf('test_fixed_compress.hdf', 'test', mode='w', complib='blosc')
 
-
    def test_hdf_fixed_read_compress():
        pd.read_hdf('test_fixed_compress.hdf', 'test')
 
-
    def test_hdf_table_write(df):
        df.to_hdf('test_table.hdf', 'test', mode='w', format='table')
 
-
    def test_hdf_table_read():
        pd.read_hdf('test_table.hdf', 'test')
 
-
    def test_hdf_table_write_compress(df):
        df.to_hdf('test_table_compress.hdf', 'test', mode='w',
                  complib='blosc', format='table')
 
-
    def test_hdf_table_read_compress():
        pd.read_hdf('test_table_compress.hdf', 'test')
 
-
    def test_csv_write(df):
        df.to_csv('test.csv', mode='w')
 
-
    def test_csv_read():
        pd.read_csv('test.csv', index_col=0)
 
-
    def test_feather_write(df):
        df.to_feather('test.feather')
 
-
    def test_feather_read():
        pd.read_feather('test.feather')
 
-
    def test_pickle_write(df):
        df.to_pickle('test.pkl')
 
-
    def test_pickle_read():
        pd.read_pickle('test.pkl')
 
-
    def test_pickle_write_compress(df):
        df.to_pickle('test.pkl.compress', compression='xz')
 
-
    def test_pickle_read_compress():
        pd.read_pickle('test.pkl.compress', compression='xz')
 
-When writing, the top-three functions in terms of speed are are
-``test_pickle_write``, ``test_feather_write`` and ``test_hdf_fixed_write_compress``.
+   def test_parquet_write(df):
+       df.to_parquet('test.parquet')
+
+   def test_parquet_read():
+       pd.read_parquet('test.parquet')
+
+When writing, the top-three functions in terms of speed are ``test_feather_write``, ``test_hdf_fixed_write`` and ``test_hdf_fixed_write_compress``.
 
 .. code-block:: ipython
 
-   In [14]: %timeit test_sql_write(df)
-   2.37 s ± 36.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [4]: %timeit test_sql_write(df)
+   3.29 s ± 43.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [15]: %timeit test_hdf_fixed_write(df)
-   194 ms ± 65.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [5]: %timeit test_hdf_fixed_write(df)
+   19.4 ms ± 560 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [26]: %timeit test_hdf_fixed_write_compress(df)
-   119 ms ± 2.15 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [6]: %timeit test_hdf_fixed_write_compress(df)
+   19.6 ms ± 308 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [16]: %timeit test_hdf_table_write(df)
-   623 ms ± 125 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [7]: %timeit test_hdf_table_write(df)
+   449 ms ± 5.61 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [27]: %timeit test_hdf_table_write_compress(df)
-   563 ms ± 23.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [8]: %timeit test_hdf_table_write_compress(df)
+   448 ms ± 11.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [17]: %timeit test_csv_write(df)
-   3.13 s ± 49.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [9]: %timeit test_csv_write(df)
+   3.66 s ± 26.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [30]: %timeit test_feather_write(df)
-   103 ms ± 5.88 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [10]: %timeit test_feather_write(df)
+   9.75 ms ± 117 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
 
-   In [31]: %timeit test_pickle_write(df)
-   109 ms ± 3.72 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [11]: %timeit test_pickle_write(df)
+   30.1 ms ± 229 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [32]: %timeit test_pickle_write_compress(df)
-   3.33 s ± 55.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [12]: %timeit test_pickle_write_compress(df)
+   4.29 s ± 15.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+   In [13]: %timeit test_parquet_write(df)
+   67.6 ms ± 706 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
 When reading, the top three are ``test_feather_read``, ``test_pickle_read`` and
 ``test_hdf_fixed_read``.
 
+
 .. code-block:: ipython
 
-   In [18]: %timeit test_sql_read()
-   1.35 s ± 14.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [14]: %timeit test_sql_read()
+   1.77 s ± 17.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+   In [15]: %timeit test_hdf_fixed_read()
+   19.4 ms ± 436 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
+
+   In [16]: %timeit test_hdf_fixed_read_compress()
+   19.5 ms ± 222 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [19]: %timeit test_hdf_fixed_read()
-   14.3 ms ± 438 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+   In [17]: %timeit test_hdf_table_read()
+   38.6 ms ± 857 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [28]: %timeit test_hdf_fixed_read_compress()
-   23.5 ms ± 672 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [18]: %timeit test_hdf_table_read_compress()
+   38.8 ms ± 1.49 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [20]: %timeit test_hdf_table_read()
-   35.4 ms ± 314 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [19]: %timeit test_csv_read()
+   452 ms ± 9.04 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [29]: %timeit test_hdf_table_read_compress()
-   42.6 ms ± 2.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
+   In [20]: %timeit test_feather_read()
+   12.4 ms ± 99.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
 
-   In [22]: %timeit test_csv_read()
-   516 ms ± 27.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+   In [21]: %timeit test_pickle_read()
+   18.4 ms ± 191 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
 
-   In [33]: %timeit test_feather_read()
-   4.06 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+   In [22]: %timeit test_pickle_read_compress()
+   915 ms ± 7.48 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
-   In [34]: %timeit test_pickle_read()
-   6.5 ms ± 172 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+   In [23]: %timeit test_parquet_read()
+   24.4 ms ± 146 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
 
-   In [35]: %timeit test_pickle_read_compress()
-   588 ms ± 3.57 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
+For this test case ``test.pkl.compress``, ``test.parquet`` and ``test.feather`` took the least space on disk.
 Space on disk (in bytes)
 
 .. code-block:: none
 
-    34816000 Aug 21 18:00 test.sql
-    24009240 Aug 21 18:00 test_fixed.hdf
-     7919610 Aug 21 18:00 test_fixed_compress.hdf
-    24458892 Aug 21 18:00 test_table.hdf
-     8657116 Aug 21 18:00 test_table_compress.hdf
-    28520770 Aug 21 18:00 test.csv
-    16000248 Aug 21 18:00 test.feather
-    16000848 Aug 21 18:00 test.pkl
-     7554108 Aug 21 18:00 test.pkl.compress
+    29519500 Oct 10 06:45 test.csv
+    16000248 Oct 10 06:45 test.feather
+    8281983  Oct 10 06:49 test.parquet
+    16000857 Oct 10 06:47 test.pkl
+    7552144  Oct 10 06:48 test.pkl.compress
+    34816000 Oct 10 06:42 test.sql
+    24009288 Oct 10 06:43 test_fixed.hdf
+    24009288 Oct 10 06:43 test_fixed_compress.hdf
+    24458940 Oct 10 06:44 test_table.hdf
+    24458940 Oct 10 06:44 test_table_compress.hdf
diff --git a/doc/source/user_guide/merging.rst b/doc/source/user_guide/merging.rst
index 4c0d3b75a4f79..8fdcd8d281a41 100644
--- a/doc/source/user_guide/merging.rst
+++ b/doc/source/user_guide/merging.rst
@@ -843,8 +843,6 @@ resulting dtype will be upcast.
    pd.merge(left, right, how='outer', on='key')
    pd.merge(left, right, how='outer', on='key').dtypes
 
-.. versionadded:: 0.20.0
-
 Merging will preserve ``category`` dtypes of the mergands. See also the section on :ref:`categoricals <categorical.merge>`.
 
 The left frame.
@@ -883,7 +881,7 @@ The merged result:
 .. note::
 
    The category dtypes must be *exactly* the same, meaning the same categories and the ordered attribute.
-   Otherwise the result will coerce to ``object`` dtype.
+   Otherwise the result will coerce to the categories' dtype.
 
 .. note::
 
diff --git a/doc/source/user_guide/missing_data.rst b/doc/source/user_guide/missing_data.rst
index 6c36a6470f841..2e68a0598bb71 100644
--- a/doc/source/user_guide/missing_data.rst
+++ b/doc/source/user_guide/missing_data.rst
@@ -12,10 +12,10 @@ pandas.
 .. note::
 
     The choice of using ``NaN`` internally to denote missing data was largely
-    for simplicity and performance reasons. It differs from the MaskedArray
-    approach of, for example, :mod:`scikits.timeseries`. We are hopeful that
-    NumPy will soon be able to provide a native NA type solution (similar to R)
-    performant enough to be used in pandas.
+    for simplicity and performance reasons.
+    Starting from pandas 1.0, some optional data types start experimenting
+    with a native ``NA`` scalar using a mask-based approach. See
+    :ref:`here <missing_data.NA>` for more.
 
 See the :ref:`cookbook<cookbook.missing_data>` for some advanced strategies.
 
@@ -110,7 +110,7 @@ pandas objects provide compatibility between ``NaT`` and ``NaN``.
 .. _missing.inserting:
 
 Inserting missing data
-----------------------
+~~~~~~~~~~~~~~~~~~~~~~
 
 You can insert missing values by simply assigning to containers. The
 actual missing value used will be chosen based on the dtype.
@@ -135,9 +135,10 @@ For object containers, pandas will use the value given:
    s.loc[1] = np.nan
    s
 
+.. _missing_data.calculations:
 
 Calculations with missing data
-------------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Missing values propagate naturally through arithmetic operations between pandas
 objects.
@@ -189,7 +190,7 @@ The sum of an empty or all-NA Series or column of a DataFrame is 0.
 
    pd.Series([np.nan]).sum()
 
-   pd.Series([]).sum()
+   pd.Series([], dtype="float64").sum()
 
 The product of an empty or all-NA Series or column of a DataFrame is 1.
 
@@ -197,7 +198,7 @@ The product of an empty or all-NA Series or column of a DataFrame is 1.
 
    pd.Series([np.nan]).prod()
 
-   pd.Series([]).prod()
+   pd.Series([], dtype="float64").prod()
 
 
 NA values in GroupBy
@@ -466,9 +467,9 @@ at the new values.
    interp_s = ser.reindex(new_index).interpolate(method='pchip')
    interp_s[49:51]
 
-.. _scipy: http://www.scipy.org
-.. _documentation: http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation
-.. _guide: http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html
+.. _scipy: https://www.scipy.org
+.. _documentation: https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation
+.. _guide: https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html
 
 .. _missing_data.interp_limits:
 
@@ -771,3 +772,200 @@ the ``dtype="Int64"``.
    s
 
 See :ref:`integer_na` for more.
+
+
+.. _missing_data.NA:
+
+Experimental ``NA`` scalar to denote missing values
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. warning::
+
+   Experimental: the behaviour of ``pd.NA`` can still change without warning.
+
+.. versionadded:: 1.0.0
+
+Starting from pandas 1.0, an experimental ``pd.NA`` value (singleton) is
+available to represent scalar missing values. At this moment, it is used in
+the nullable :doc:`integer <integer_na>`, boolean and
+:ref:`dedicated string <text.types>` data types as the missing value indicator.
+
+The goal of ``pd.NA`` is provide a "missing" indicator that can be used
+consistently across data types (instead of ``np.nan``, ``None`` or ``pd.NaT``
+depending on the data type).
+
+For example, when having missing values in a Series with the nullable integer
+dtype, it will use ``pd.NA``:
+
+.. ipython:: python
+
+    s = pd.Series([1, 2, None], dtype="Int64")
+    s
+    s[2]
+    s[2] is pd.NA
+
+Currently, pandas does not yet use those data types by default (when creating
+a DataFrame or Series, or when reading in data), so you need to specify
+the dtype explicitly.  An easy way to convert to those dtypes is explained
+:ref:`here <missing_data.NA.conversion>`.
+
+Propagation in arithmetic and comparison operations
+---------------------------------------------------
+
+In general, missing values *propagate* in operations involving ``pd.NA``. When
+one of the operands is unknown, the outcome of the operation is also unknown.
+
+For example, ``pd.NA`` propagates in arithmetic operations, similarly to
+``np.nan``:
+
+.. ipython:: python
+
+   pd.NA + 1
+   "a" * pd.NA
+
+There are a few special cases when the result is known, even when one of the
+operands is ``NA``.
+
+.. ipython:: python
+
+   pd.NA ** 0
+   1 ** pd.NA
+
+In equality and comparison operations, ``pd.NA`` also propagates. This deviates
+from the behaviour of ``np.nan``, where comparisons with ``np.nan`` always
+return ``False``.
+
+.. ipython:: python
+
+   pd.NA == 1
+   pd.NA == pd.NA
+   pd.NA < 2.5
+
+To check if a value is equal to ``pd.NA``, the :func:`isna` function can be
+used:
+
+.. ipython:: python
+
+   pd.isna(pd.NA)
+
+An exception on this basic propagation rule are *reductions* (such as the
+mean or the minimum), where pandas defaults to skipping missing values. See
+:ref:`above <missing_data.calculations>` for more.
+
+Logical operations
+------------------
+
+For logical operations, ``pd.NA`` follows the rules of the
+`three-valued logic <https://en.wikipedia.org/wiki/Three-valued_logic>`__ (or
+*Kleene logic*, similarly to R, SQL and Julia). This logic means to only
+propagate missing values when it is logically required.
+
+For example, for the logical "or" operation (``|``), if one of the operands
+is ``True``, we already know the result will be ``True``, regardless of the
+other value (so regardless the missing value would be ``True`` or ``False``).
+In this case, ``pd.NA`` does not propagate:
+
+.. ipython:: python
+
+   True | False
+   True | pd.NA
+   pd.NA | True
+
+On the other hand, if one of the operands is ``False``, the result depends
+on the value of the other operand. Therefore, in this case ``pd.NA``
+propagates:
+
+.. ipython:: python
+
+   False | True
+   False | False
+   False | pd.NA
+
+The behaviour of the logical "and" operation (``&``) can be derived using
+similar logic (where now ``pd.NA`` will not propagate if one of the operands
+is already ``False``):
+
+.. ipython:: python
+
+   False & True
+   False & False
+   False & pd.NA
+
+.. ipython:: python
+
+   True & True
+   True & False
+   True & pd.NA
+
+
+``NA`` in a boolean context
+---------------------------
+
+Since the actual value of an NA is unknown, it is ambiguous to convert NA
+to a boolean value. The following raises an error:
+
+.. ipython:: python
+   :okexcept:
+
+   bool(pd.NA)
+
+This also means that ``pd.NA`` cannot be used in a context where it is
+evaluated to a boolean, such as ``if condition: ...`` where ``condition`` can
+potentially be ``pd.NA``. In such cases, :func:`isna` can be used to check
+for ``pd.NA`` or ``condition`` being ``pd.NA`` can be avoided, for example by
+filling missing values beforehand.
+
+A similar situation occurs when using Series or DataFrame objects in ``if``
+statements, see :ref:`gotchas.truth`.
+
+NumPy ufuncs
+------------
+
+:attr:`pandas.NA` implements NumPy's ``__array_ufunc__`` protocol. Most ufuncs
+work with ``NA``, and generally return ``NA``:
+
+.. ipython:: python
+
+   np.log(pd.NA)
+   np.add(pd.NA, 1)
+
+.. warning::
+
+   Currently, ufuncs involving an ndarray and ``NA`` will return an
+   object-dtype filled with NA values.
+
+   .. ipython:: python
+
+      a = np.array([1, 2, 3])
+      np.greater(a, pd.NA)
+
+   The return type here may change to return a different array type
+   in the future.
+
+See :ref:`dsintro.numpy_interop` for more on ufuncs.
+
+.. _missing_data.NA.conversion:
+
+Conversion
+----------
+
+If you have a DataFrame or Series using traditional types that have missing data
+represented using ``np.nan``, there are convenience methods
+:meth:`~Series.convert_dtypes` in Series and :meth:`~DataFrame.convert_dtypes`
+in DataFrame that can convert data to use the newer dtypes for integers, strings and
+booleans listed :ref:`here <basics.dtypes>`. This is especially helpful after reading
+in data sets when letting the readers such as :meth:`read_csv` and :meth:`read_excel`
+infer default dtypes.
+
+In this example, while the dtypes of all columns are changed, we show the results for
+the first 10 columns.
+
+.. ipython:: python
+
+   bb = pd.read_csv('data/baseball.csv', index_col='id')
+   bb[bb.columns[:10]].dtypes
+
+.. ipython:: python
+
+   bbn = bb.convert_dtypes()
+   bbn[bbn.columns[:10]].dtypes
diff --git a/doc/source/user_guide/options.rst b/doc/source/user_guide/options.rst
index 1f1dff417e68f..5817efb31814e 100644
--- a/doc/source/user_guide/options.rst
+++ b/doc/source/user_guide/options.rst
@@ -353,7 +353,7 @@ display.max_colwidth                    50           The maximum width in charac
                                                      a column in the repr of a pandas
                                                      data structure. When the column overflows,
                                                      a "..." placeholder is embedded in
-                                                     the output.
+                                                     the output. 'None' value means unlimited.
 display.max_info_columns                100          max_info_columns is used in DataFrame.info
                                                      method to decide if per column information
                                                      will be printed.
@@ -561,8 +561,6 @@ However, setting this option incorrectly for your terminal will cause these char
 Table schema display
 --------------------
 
-.. versionadded:: 0.20.0
-
 ``DataFrame`` and ``Series`` will publish a Table Schema representation
 by default. False by default, this can be enabled globally with the
 ``display.html.table_schema`` option:
diff --git a/doc/source/user_guide/reshaping.rst b/doc/source/user_guide/reshaping.rst
index dd6d3062a8f0a..b28354cd8b5f2 100644
--- a/doc/source/user_guide/reshaping.rst
+++ b/doc/source/user_guide/reshaping.rst
@@ -14,7 +14,7 @@ Reshaping by pivoting DataFrame objects
 .. ipython:: python
    :suppress:
 
-   import pandas.util.testing as tm
+   import pandas._testing as tm
    tm.N = 3
 
    def unpivot(frame):
@@ -38,7 +38,7 @@ For the curious here is how the above ``DataFrame`` was created:
 
 .. code-block:: python
 
-   import pandas.util.testing as tm
+   import pandas._testing as tm
 
    tm.N = 3
 
@@ -539,8 +539,6 @@ Alternatively we can specify custom bin-edges:
    c = pd.cut(ages, bins=[0, 18, 35, 70])
    c
 
-.. versionadded:: 0.20.0
-
 If the ``bins`` keyword is an ``IntervalIndex``, then these will be
 used to bin the passed data.::
 
@@ -728,14 +726,14 @@ Suppose we wanted to pivot ``df`` such that the ``col`` values are columns,
 ``row`` values are the index, and the mean of ``val0`` are the values? In
 particular, the resulting DataFrame should look like:
 
-.. note::
+.. code-block:: text
 
-   col   col0   col1   col2   col3  col4
-   row
-   row0  0.77  0.605    NaN  0.860  0.65
-   row2  0.13    NaN  0.395  0.500  0.25
-   row3   NaN  0.310    NaN  0.545   NaN
-   row4   NaN  0.100  0.395  0.760  0.24
+    col   col0   col1   col2   col3  col4
+    row
+    row0  0.77  0.605    NaN  0.860  0.65
+    row2  0.13    NaN  0.395  0.500  0.25
+    row3   NaN  0.310    NaN  0.545   NaN
+    row4   NaN  0.100  0.395  0.760  0.24
 
 This solution uses :func:`~pandas.pivot_table`. Also note that
 ``aggfunc='mean'`` is the default. It is included here to be explicit.
diff --git a/doc/source/user_guide/scale.rst b/doc/source/user_guide/scale.rst
new file mode 100644
index 0000000000000..43bb4966ec5bf
--- /dev/null
+++ b/doc/source/user_guide/scale.rst
@@ -0,0 +1,374 @@
+.. _scale:
+
+*************************
+Scaling to large datasets
+*************************
+
+Pandas provides data structures for in-memory analytics, which makes using pandas
+to analyze datasets that are larger than memory datasets somewhat tricky. Even datasets
+that are a sizable fraction of memory become unwieldy, as some pandas operations need
+to make intermediate copies.
+
+This document provides a few recommendations for scaling your analysis to larger datasets.
+It's a complement to :ref:`enhancingperf`, which focuses on speeding up analysis
+for datasets that fit in memory.
+
+But first, it's worth considering *not using pandas*. Pandas isn't the right
+tool for all situations. If you're working with very large datasets and a tool
+like PostgreSQL fits your needs, then you should probably be using that.
+Assuming you want or need the expressiveness and power of pandas, let's carry on.
+
+.. ipython:: python
+
+   import pandas as pd
+   import numpy as np
+
+.. ipython:: python
+   :suppress:
+
+   from pandas._testing import _make_timeseries
+
+   # Make a random in-memory dataset
+   ts = _make_timeseries(freq="30S", seed=0)
+   ts.to_csv("timeseries.csv")
+   ts.to_parquet("timeseries.parquet")
+
+
+Load less data
+--------------
+
+.. ipython:: python
+   :suppress:
+
+   # make a similar dataset with many columns
+   timeseries = [
+       _make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
+       for i in range(10)
+   ]
+   ts_wide = pd.concat(timeseries, axis=1)
+   ts_wide.to_parquet("timeseries_wide.parquet")
+
+Suppose our raw dataset on disk has many columns::
+
+                        id_0    name_0       x_0       y_0  id_1   name_1       x_1  ...  name_8       x_8       y_8  id_9   name_9       x_9       y_9
+   timestamp                                                                         ...
+   2000-01-01 00:00:00  1015   Michael -0.399453  0.095427   994    Frank -0.176842  ...     Dan -0.315310  0.713892  1025   Victor -0.135779  0.346801
+   2000-01-01 00:01:00   969  Patricia  0.650773 -0.874275  1003    Laura  0.459153  ...  Ursula  0.913244 -0.630308  1047    Wendy -0.886285  0.035852
+   2000-01-01 00:02:00  1016    Victor -0.721465 -0.584710  1046  Michael  0.524994  ...     Ray -0.656593  0.692568  1064   Yvonne  0.070426  0.432047
+   2000-01-01 00:03:00   939     Alice -0.746004 -0.908008   996   Ingrid -0.414523  ...   Jerry -0.958994  0.608210   978    Wendy  0.855949 -0.648988
+   2000-01-01 00:04:00  1017       Dan  0.919451 -0.803504  1048    Jerry -0.569235  ...   Frank -0.577022 -0.409088   994      Bob -0.270132  0.335176
+   ...                   ...       ...       ...       ...   ...      ...       ...  ...     ...       ...       ...   ...      ...       ...       ...
+   2000-12-30 23:56:00   999       Tim  0.162578  0.512817   973    Kevin -0.403352  ...     Tim -0.380415  0.008097  1041  Charlie  0.191477 -0.599519
+   2000-12-30 23:57:00   970     Laura -0.433586 -0.600289   958   Oliver -0.966577  ...   Zelda  0.971274  0.402032  1038   Ursula  0.574016 -0.930992
+   2000-12-30 23:58:00  1065     Edith  0.232211 -0.454540   971      Tim  0.158484  ...   Alice -0.222079 -0.919274  1022      Dan  0.031345 -0.657755
+   2000-12-30 23:59:00  1019    Ingrid  0.322208 -0.615974   981   Hannah  0.607517  ...   Sarah -0.424440 -0.117274   990   George -0.375530  0.563312
+   2000-12-31 00:00:00   937    Ursula -0.906523  0.943178  1018    Alice -0.564513  ...   Jerry  0.236837  0.807650   985   Oliver  0.777642  0.783392
+
+   [525601 rows x 40 columns]
+
+
+To load the columns we want, we have two options.
+Option 1 loads in all the data and then filters to what we need.
+
+.. ipython:: python
+
+   columns = ['id_0', 'name_0', 'x_0', 'y_0']
+
+   pd.read_parquet("timeseries_wide.parquet")[columns]
+
+Option 2 only loads the columns we request.
+
+.. ipython:: python
+
+   pd.read_parquet("timeseries_wide.parquet", columns=columns)
+
+If we were to measure the memory usage of the two calls, we'd see that specifying
+``columns`` uses about 1/10th the memory in this case.
+
+With :func:`pandas.read_csv`, you can specify ``usecols`` to limit the columns
+read into memory. Not all file formats that can be read by pandas provide an option
+to read a subset of columns.
+
+Use efficient datatypes
+-----------------------
+
+The default pandas data types are not the most memory efficient. This is
+especially true for text data columns with relatively few unique values (commonly
+referred to as "low-cardinality" data). By using more efficient data types, you
+can store larger datasets in memory.
+
+.. ipython:: python
+
+   ts = pd.read_parquet("timeseries.parquet")
+   ts
+
+Now, let's inspect the data types and memory usage to see where we should focus our
+attention.
+
+.. ipython:: python
+
+   ts.dtypes
+
+.. ipython:: python
+
+   ts.memory_usage(deep=True)  # memory usage in bytes
+
+
+The ``name`` column is taking up much more memory than any other. It has just a
+few unique values, so it's a good candidate for converting to a
+:class:`Categorical`. With a Categorical, we store each unique name once and use
+space-efficient integers to know which specific name is used in each row.
+
+
+.. ipython:: python
+
+   ts2 = ts.copy()
+   ts2['name'] = ts2['name'].astype('category')
+   ts2.memory_usage(deep=True)
+
+We can go a bit further and downcast the numeric columns to their smallest types
+using :func:`pandas.to_numeric`.
+
+.. ipython:: python
+
+   ts2['id'] = pd.to_numeric(ts2['id'], downcast='unsigned')
+   ts2[['x', 'y']] = ts2[['x', 'y']].apply(pd.to_numeric, downcast='float')
+   ts2.dtypes
+
+.. ipython:: python
+
+   ts2.memory_usage(deep=True)
+
+.. ipython:: python
+
+   reduction = (ts2.memory_usage(deep=True).sum()
+                / ts.memory_usage(deep=True).sum())
+   print(f"{reduction:0.2f}")
+
+In all, we've reduced the in-memory footprint of this dataset to 1/5 of its
+original size.
+
+See :ref:`categorical` for more on ``Categorical`` and :ref:`basics.dtypes`
+for an overview of all of pandas' dtypes.
+
+Use chunking
+------------
+
+Some workloads can be achieved with chunking: splitting a large problem like "convert this
+directory of CSVs to parquet" into a bunch of small problems ("convert this individual CSV
+file into a Parquet file. Now repeat that for each file in this directory."). As long as each chunk
+fits in memory, you can work with datasets that are much larger than memory.
+
+.. note::
+
+   Chunking works well when the operation you're performing requires zero or minimal
+   coordination between chunks. For more complicated workflows, you're better off
+   :ref:`using another library <scale.other_libraries>`.
+
+Suppose we have an even larger "logical dataset" on disk that's a directory of parquet
+files. Each file in the directory represents a different year of the entire dataset.
+
+.. ipython:: python
+   :suppress:
+
+   import pathlib
+
+   N = 12
+   starts = [f'20{i:>02d}-01-01' for i in range(N)]
+   ends = [f'20{i:>02d}-12-13' for i in range(N)]
+
+   pathlib.Path("data/timeseries").mkdir(exist_ok=True)
+
+   for i, (start, end) in enumerate(zip(starts, ends)):
+       ts = _make_timeseries(start=start, end=end, freq='1T', seed=i)
+       ts.to_parquet(f"data/timeseries/ts-{i:0>2d}.parquet")
+
+
+::
+
+   data
+   └── timeseries
+       ├── ts-00.parquet
+       ├── ts-01.parquet
+       ├── ts-02.parquet
+       ├── ts-03.parquet
+       ├── ts-04.parquet
+       ├── ts-05.parquet
+       ├── ts-06.parquet
+       ├── ts-07.parquet
+       ├── ts-08.parquet
+       ├── ts-09.parquet
+       ├── ts-10.parquet
+       └── ts-11.parquet
+
+Now we'll implement an out-of-core ``value_counts``. The peak memory usage of this
+workflow is the single largest chunk, plus a small series storing the unique value
+counts up to this point. As long as each individual file fits in memory, this will
+work for arbitrary-sized datasets.
+
+.. ipython:: python
+
+   %%time
+   files = pathlib.Path("data/timeseries/").glob("ts*.parquet")
+   counts = pd.Series(dtype=int)
+   for path in files:
+       # Only one dataframe is in memory at a time...
+       df = pd.read_parquet(path)
+       # ... plus a small Series `counts`, which is updated.
+       counts = counts.add(df['name'].value_counts(), fill_value=0)
+   counts.astype(int)
+
+Some readers, like :meth:`pandas.read_csv`, offer parameters to control the
+``chunksize`` when reading a single file.
+
+Manually chunking is an OK option for workflows that don't
+require too sophisticated of operations. Some operations, like ``groupby``, are
+much harder to do chunkwise. In these cases, you may be better switching to a
+different library that implements these out-of-core algorithms for you.
+
+.. _scale.other_libraries:
+
+Use other libraries
+-------------------
+
+Pandas is just one library offering a DataFrame API. Because of its popularity,
+pandas' API has become something of a standard that other libraries implement.
+The pandas documentation maintains a list of libraries implementing a DataFrame API
+in :ref:`our ecosystem page <ecosystem.out-of-core>`.
+
+For example, `Dask`_, a parallel computing library, has `dask.dataframe`_, a
+pandas-like API for working with larger than memory datasets in parallel. Dask
+can use multiple threads or processes on a single machine, or a cluster of
+machines to process data in parallel.
+
+
+We'll import ``dask.dataframe`` and notice that the API feels similar to pandas.
+We can use Dask's ``read_parquet`` function, but provide a globstring of files to read in.
+
+.. ipython:: python
+
+   import dask.dataframe as dd
+
+   ddf = dd.read_parquet("data/timeseries/ts*.parquet", engine="pyarrow")
+   ddf
+
+Inspecting the ``ddf`` object, we see a few things
+
+* There are familiar attributes like ``.columns`` and ``.dtypes``
+* There are familiar methods like ``.groupby``, ``.sum``, etc.
+* There are new attributes like ``.npartitions`` and ``.divisions``
+
+The partitions and divisions are how Dask parallizes computation. A **Dask**
+DataFrame is made up of many **Pandas** DataFrames. A single method call on a
+Dask DataFrame ends up making many pandas method calls, and Dask knows how to
+coordinate everything to get the result.
+
+.. ipython:: python
+
+   ddf.columns
+   ddf.dtypes
+   ddf.npartitions
+
+One major difference: the ``dask.dataframe`` API is *lazy*. If you look at the
+repr above, you'll notice that the values aren't actually printed out; just the
+column names and dtypes. That's because Dask hasn't actually read the data yet.
+Rather than executing immediately, doing operations build up a **task graph**.
+
+.. ipython:: python
+
+   ddf
+   ddf['name']
+   ddf['name'].value_counts()
+
+Each of these calls is instant because the result isn't being computed yet.
+We're just building up a list of computation to do when someone needs the
+result. Dask knows that the return type of a ``pandas.Series.value_counts``
+is a pandas Series with a certain dtype and a certain name. So the Dask version
+returns a Dask Series with the same dtype and the same name.
+
+To get the actual result you can call ``.compute()``.
+
+.. ipython:: python
+
+   %time ddf['name'].value_counts().compute()
+
+At that point, you get back the same thing you'd get with pandas, in this case
+a concrete pandas Series with the count of each ``name``.
+
+Calling ``.compute`` causes the full task graph to be executed. This includes
+reading the data, selecting the columns, and doing the ``value_counts``. The
+execution is done *in parallel* where possible, and Dask tries to keep the
+overall memory footprint small. You can work with datasets that are much larger
+than memory, as long as each partition (a regular pandas DataFrame) fits in memory.
+
+By default, ``dask.dataframe`` operations use a threadpool to do operations in
+parallel. We can also connect to a cluster to distribute the work on many
+machines. In this case we'll connect to a local "cluster" made up of several
+processes on this single machine.
+
+.. code-block:: python
+
+   >>> from dask.distributed import Client, LocalCluster
+
+   >>> cluster = LocalCluster()
+   >>> client = Client(cluster)
+   >>> client
+   <Client: 'tcp://127.0.0.1:53349' processes=4 threads=8, memory=17.18 GB>
+
+Once this ``client`` is created, all of Dask's computation will take place on
+the cluster (which is just processes in this case).
+
+Dask implements the most used parts of the pandas API. For example, we can do
+a familiar groupby aggregation.
+
+.. ipython:: python
+
+   %time ddf.groupby('name')[['x', 'y']].mean().compute().head()
+
+The grouping and aggregation is done out-of-core and in parallel.
+
+When Dask knows the ``divisions`` of a dataset, certain optimizations are
+possible. When reading parquet datasets written by dask, the divisions will be
+known automatically. In this case, since we created the parquet files manually,
+we need to supply the divisions manually.
+
+.. ipython:: python
+
+   N = 12
+   starts = [f'20{i:>02d}-01-01' for i in range(N)]
+   ends = [f'20{i:>02d}-12-13' for i in range(N)]
+
+   divisions = tuple(pd.to_datetime(starts)) + (pd.Timestamp(ends[-1]),)
+   ddf.divisions = divisions
+   ddf
+
+Now we can do things like fast random access with ``.loc``.
+
+.. ipython:: python
+
+   ddf.loc['2002-01-01 12:01':'2002-01-01 12:05'].compute()
+
+Dask knows to just look in the 3rd partition for selecting values in `2002`. It
+doesn't need to look at any other data.
+
+Many workflows involve a large amount of data and processing it in a way that
+reduces the size to something that fits in memory. In this case, we'll resample
+to daily frequency and take the mean. Once we've taken the mean, we know the
+results will fit in memory, so we can safely call ``compute`` without running
+out of memory. At that point it's just a regular pandas object.
+
+.. ipython:: python
+   :okwarning:
+
+   @savefig dask_resample.png
+   ddf[['x', 'y']].resample("1D").mean().cumsum().compute().plot()
+
+These Dask examples have all be done using multiple processes on a single
+machine. Dask can be `deployed on a cluster
+<https://docs.dask.org/en/latest/setup.html>`_ to scale up to even larger
+datasets.
+
+You see more dask examples at https://examples.dask.org.
+
+.. _Dask: https://dask.org
+.. _dask.dataframe: https://docs.dask.org/en/latest/dataframe.html
diff --git a/doc/source/user_guide/sparse.rst b/doc/source/user_guide/sparse.rst
index 98fd30f67d05b..8588fac4a18d0 100644
--- a/doc/source/user_guide/sparse.rst
+++ b/doc/source/user_guide/sparse.rst
@@ -6,12 +6,6 @@
 Sparse data structures
 **********************
 
-.. note::
-
-   ``SparseSeries`` and ``SparseDataFrame`` have been deprecated. Their purpose
-   is served equally well by a :class:`Series` or :class:`DataFrame` with
-   sparse values. See :ref:`sparse.migration` for tips on migrating.
-
 Pandas provides data structures for efficiently storing sparse data.
 These are not necessarily sparse in the typical "mostly 0". Rather, you can view these
 objects as being "compressed" where any data matching a specific value (``NaN`` / missing value, though any value
@@ -21,7 +15,7 @@ can be chosen, including 0) is omitted. The compressed values are not actually s
 
    arr = np.random.randn(10)
    arr[2:-2] = np.nan
-   ts = pd.Series(pd.SparseArray(arr))
+   ts = pd.Series(pd.arrays.SparseArray(arr))
    ts
 
 Notice the dtype, ``Sparse[float64, nan]``. The ``nan`` means that elements in the
@@ -57,7 +51,7 @@ identical to their dense counterparts.
 SparseArray
 -----------
 
-:class:`SparseArray` is a :class:`~pandas.api.extensions.ExtensionArray`
+:class:`arrays.SparseArray` is a :class:`~pandas.api.extensions.ExtensionArray`
 for storing an array of sparse values (see :ref:`basics.dtypes` for more
 on extension arrays). It is a 1-dimensional ndarray-like object storing
 only values distinct from the ``fill_value``:
@@ -67,7 +61,7 @@ only values distinct from the ``fill_value``:
    arr = np.random.randn(10)
    arr[2:5] = np.nan
    arr[7:8] = np.nan
-   sparr = pd.SparseArray(arr)
+   sparr = pd.arrays.SparseArray(arr)
    sparr
 
 A sparse array can be converted to a regular (dense) ndarray with :meth:`numpy.asarray`
@@ -150,7 +144,7 @@ to ``SparseArray`` and get a ``SparseArray`` as a result.
 
 .. ipython:: python
 
-   arr = pd.SparseArray([1., np.nan, np.nan, -2., np.nan])
+   arr = pd.arrays.SparseArray([1., np.nan, np.nan, -2., np.nan])
    np.abs(arr)
 
 
@@ -159,7 +153,7 @@ the correct dense result.
 
 .. ipython:: python
 
-   arr = pd.SparseArray([1., -1, -1, -2., -1], fill_value=-1)
+   arr = pd.arrays.SparseArray([1., -1, -1, -2., -1], fill_value=-1)
    np.abs(arr)
    np.abs(arr).to_dense()
 
@@ -168,6 +162,11 @@ the correct dense result.
 Migrating
 ---------
 
+.. note::
+
+   ``SparseSeries`` and ``SparseDataFrame`` were removed in pandas 1.0.0. This migration
+   guide is present to aid in migrating from previous versions.
+
 In older versions of pandas, the ``SparseSeries`` and ``SparseDataFrame`` classes (documented below)
 were the preferred way to work with sparse data. With the advent of extension arrays, these subclasses
 are no longer needed. Their purpose is better served by using a regular Series or DataFrame with
@@ -195,7 +194,7 @@ From an array-like, use the regular :class:`Series` or
 .. ipython:: python
 
    # New way
-   pd.DataFrame({"A": pd.SparseArray([0, 1])})
+   pd.DataFrame({"A": pd.arrays.SparseArray([0, 1])})
 
 From a SciPy sparse matrix, use :meth:`DataFrame.sparse.from_spmatrix`,
 
@@ -257,10 +256,10 @@ Instead, you'll need to ensure that the values being assigned are sparse
 
 .. ipython:: python
 
-   df = pd.DataFrame({"A": pd.SparseArray([0, 1])})
+   df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1])})
    df['B'] = [0, 0]  # remains dense
    df['B'].dtype
-   df['B'] = pd.SparseArray([0, 0])
+   df['B'] = pd.arrays.SparseArray([0, 0])
    df['B'].dtype
 
 The ``SparseDataFrame.default_kind`` and ``SparseDataFrame.default_fill_value`` attributes
@@ -366,12 +365,3 @@ row and columns coordinates of the matrix. Note that this will consume a signifi
 
    ss_dense = pd.Series.sparse.from_coo(A, dense_index=True)
    ss_dense
-
-
-.. _sparse.subclasses:
-
-Sparse subclasses
------------------
-
-The :class:`SparseSeries` and :class:`SparseDataFrame` classes are deprecated. Visit their
-API pages for usage.
diff --git a/doc/source/user_guide/style.ipynb b/doc/source/user_guide/style.ipynb
index 006f928c037bd..1f2f8818c8458 100644
--- a/doc/source/user_guide/style.ipynb
+++ b/doc/source/user_guide/style.ipynb
@@ -6,7 +6,7 @@
    "source": [
     "# Styling\n",
     "\n",
-    "This document is written as a Jupyter Notebook, and can be viewed or downloaded [here](http://nbviewer.ipython.org/github/pandas-dev/pandas/blob/master/doc/source/style.ipynb).\n",
+    "This document is written as a Jupyter Notebook, and can be viewed or downloaded [here](https://nbviewer.ipython.org/github/pandas-dev/pandas/blob/master/doc/source/user_guide/style.ipynb).\n",
     "\n",
     "You can apply **conditional formatting**, the visual styling of a DataFrame\n",
     "depending on the data within, by using the ``DataFrame.style`` property.\n",
@@ -67,6 +67,7 @@
     "df = pd.DataFrame({'A': np.linspace(1, 10, 10)})\n",
     "df = pd.concat([df, pd.DataFrame(np.random.randn(10, 4), columns=list('BCDE'))],\n",
     "               axis=1)\n",
+    "df.iloc[3, 3] = np.nan\n",
     "df.iloc[0, 2] = np.nan"
    ]
   },
@@ -402,6 +403,38 @@
     "df.style.format({\"B\": lambda x: \"±{:.2f}\".format(abs(x))})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can format the text displayed for missing values by `na_rep`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.style.format(\"{:.2%}\", na_rep=\"-\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These formatting techniques can be used in combination with styling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.style.highlight_max().format(None, na_rep=\"-\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -429,7 +462,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can create \"heatmaps\" with the `background_gradient` method. These require matplotlib, and we'll use [Seaborn](http://stanford.edu/~mwaskom/software/seaborn/) to get a nice colormap."
+    "You can create \"heatmaps\" with the `background_gradient` method. These require matplotlib, and we'll use [Seaborn](https://stanford.edu/~mwaskom/software/seaborn/) to get a nice colormap."
    ]
   },
   {
@@ -644,7 +677,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Notice that you're able share the styles even though they're data aware. The styles are re-evaluated on the new DataFrame they've been `use`d upon."
+    "Notice that you're able to share the styles even though they're data aware. The styles are re-evaluated on the new DataFrame they've been `use`d upon."
    ]
   },
   {
@@ -659,6 +692,7 @@
     "- precision\n",
     "- captions\n",
     "- table-wide styles\n",
+    "- missing values representation\n",
     "- hiding the index or columns\n",
     "\n",
     "Each of these can be specified in two ways:\n",
@@ -800,6 +834,32 @@
     "We hope to collect some useful ones either in pandas, or preferable in a new package that [builds on top](#Extensibility) the tools here."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Missing values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can control the default missing values representation for the entire table through `set_na_rep` method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "(df.style\n",
+    "   .set_na_rep(\"FAIL\")\n",
+    "   .format(None, na_rep=\"PASS\", subset=[\"D\"])\n",
+    "   .highlight_null(\"yellow\"))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1003,7 +1063,7 @@
     "- Provide an API that is pleasing to use interactively and is \"good enough\" for many tasks\n",
     "- Provide the foundations for dedicated libraries to build on\n",
     "\n",
-    "If you build a great library on top of this, let us know and we'll [link](http://pandas.pydata.org/pandas-docs/stable/ecosystem.html) to it.\n",
+    "If you build a great library on top of this, let us know and we'll [link](https://pandas.pydata.org/pandas-docs/stable/ecosystem.html) to it.\n",
     "\n",
     "### Subclassing\n",
     "\n",
diff --git a/doc/source/user_guide/text.rst b/doc/source/user_guide/text.rst
index acb5810e5252a..88c86ac212f11 100644
--- a/doc/source/user_guide/text.rst
+++ b/doc/source/user_guide/text.rst
@@ -6,8 +6,116 @@
 Working with text data
 ======================
 
+.. _text.types:
+
+Text Data Types
+---------------
+
+.. versionadded:: 1.0.0
+
+There are two ways to store text data in pandas:
+
+1. ``object`` -dtype NumPy array.
+2. :class:`StringDtype` extension type.
+
+We recommend using :class:`StringDtype` to store text data.
+
+Prior to pandas 1.0, ``object`` dtype was the only option. This was unfortunate
+for many reasons:
+
+1. You can accidentally store a *mixture* of strings and non-strings in an
+   ``object`` dtype array. It's better to have a dedicated dtype.
+2. ``object`` dtype breaks dtype-specific operations like :meth:`DataFrame.select_dtypes`.
+   There isn't a clear way to select *just* text while excluding non-text
+   but still object-dtype columns.
+3. When reading code, the contents of an ``object`` dtype array is less clear
+   than ``'string'``.
+
+Currently, the performance of ``object`` dtype arrays of strings and
+:class:`arrays.StringArray` are about the same. We expect future enhancements
+to significantly increase the performance and lower the memory overhead of
+:class:`~arrays.StringArray`.
+
+.. warning::
+
+   ``StringArray`` is currently considered experimental. The implementation
+   and parts of the API may change without warning.
+
+For backwards-compatibility, ``object`` dtype remains the default type we
+infer a list of strings to
+
+.. ipython:: python
+
+   pd.Series(['a', 'b', 'c'])
+
+To explicitly request ``string`` dtype, specify the ``dtype``
+
+.. ipython:: python
+
+   pd.Series(['a', 'b', 'c'], dtype="string")
+   pd.Series(['a', 'b', 'c'], dtype=pd.StringDtype())
+
+Or ``astype`` after the ``Series`` or ``DataFrame`` is created
+
+.. ipython:: python
+
+   s = pd.Series(['a', 'b', 'c'])
+   s
+   s.astype("string")
+
+.. _text.differences:
+
+Behavior differences
+^^^^^^^^^^^^^^^^^^^^
+
+These are places where the behavior of ``StringDtype`` objects differ from
+``object`` dtype
+
+l. For ``StringDtype``, :ref:`string accessor methods<api.series.str>`
+   that return **numeric** output will always return a nullable integer dtype,
+   rather than either int or float dtype, depending on the presence of NA values.
+   Methods returning **boolean** output will return a nullable boolean dtype.
+
+   .. ipython:: python
+
+      s = pd.Series(["a", None, "b"], dtype="string")
+      s
+      s.str.count("a")
+      s.dropna().str.count("a")
+
+   Both outputs are ``Int64`` dtype. Compare that with object-dtype
+
+   .. ipython:: python
+
+      s2 = pd.Series(["a", None, "b"], dtype="object")
+      s2.str.count("a")
+      s2.dropna().str.count("a")
+
+   When NA values are present, the output dtype is float64. Similarly for
+   methods returning boolean values.
+
+   .. ipython:: python
+
+      s.str.isdigit()
+      s.str.match("a")
+
+2. Some string methods, like :meth:`Series.str.decode` are not available
+   on ``StringArray`` because ``StringArray`` only holds strings, not
+   bytes.
+3. In comparison operations, :class:`arrays.StringArray` and ``Series`` backed
+   by a ``StringArray`` will return an object with :class:`BooleanDtype`,
+   rather than a ``bool`` dtype object. Missing values in a ``StringArray``
+   will propagate in comparison operations, rather than always comparing
+   unequal like :attr:`numpy.nan`.
+
+Everything else that follows in the rest of this document applies equally to
+``string`` and ``object`` dtype.
+
 .. _text.string_methods:
 
+String Methods
+--------------
+
 Series and Index are equipped with a set of string processing methods
 that make it easy to operate on each element of the array. Perhaps most
 importantly, these methods exclude missing/NA values automatically. These are
@@ -16,7 +124,8 @@ the equivalent (scalar) built-in string methods:
 
 .. ipython:: python
 
-   s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
+   s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'],
+                 dtype="string")
    s.str.lower()
    s.str.upper()
    s.str.len()
@@ -90,7 +199,7 @@ Methods like ``split`` return a Series of lists:
 
 .. ipython:: python
 
-   s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])
+   s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'], dtype="string")
    s2.str.split('_')
 
 Elements in the split lists can be accessed using ``get`` or ``[]`` notation:
@@ -106,6 +215,9 @@ It is easy to expand this to return a DataFrame using ``expand``.
 
    s2.str.split('_', expand=True)
 
+When original ``Series`` has :class:`StringDtype`, the output columns will all
+be :class:`StringDtype` as well.
+
 It is also possible to limit the number of splits:
 
 .. ipython:: python
@@ -125,7 +237,8 @@ i.e., from the end of the string to the beginning of the string:
 .. ipython:: python
 
    s3 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca',
-                  '', np.nan, 'CABA', 'dog', 'cat'])
+                   '', np.nan, 'CABA', 'dog', 'cat'],
+                  dtype="string")
    s3
    s3.str.replace('^.a|dog', 'XX-XX ', case=False)
 
@@ -136,7 +249,7 @@ following code will cause trouble because of the regular expression meaning of
 .. ipython:: python
 
    # Consider the following badly formatted financial data
-   dollars = pd.Series(['12', '-$10', '$10,000'])
+   dollars = pd.Series(['12', '-$10', '$10,000'], dtype="string")
 
    # This does what you'd naively expect:
    dollars.str.replace('$', '')
@@ -160,8 +273,6 @@ and ``repl`` must be strings:
     dollars.str.replace(r'-\$', '-')
     dollars.str.replace('-$', '-', regex=False)
 
-.. versionadded:: 0.20.0
-
 The ``replace`` method can also take a callable as replacement. It is called
 on every ``pat`` using :func:`re.sub`. The callable should expect one
 positional argument (a regex object) and return a string.
@@ -174,7 +285,8 @@ positional argument (a regex object) and return a string.
    def repl(m):
        return m.group(0)[::-1]
 
-   pd.Series(['foo 123', 'bar baz', np.nan]).str.replace(pat, repl)
+   pd.Series(['foo 123', 'bar baz', np.nan],
+             dtype="string").str.replace(pat, repl)
 
    # Using regex groups
    pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"
@@ -182,9 +294,8 @@ positional argument (a regex object) and return a string.
    def repl(m):
        return m.group('two').swapcase()
 
-   pd.Series(['Foo Bar Baz', np.nan]).str.replace(pat, repl)
-
-.. versionadded:: 0.20.0
+   pd.Series(['Foo Bar Baz', np.nan],
+             dtype="string").str.replace(pat, repl)
 
 The ``replace`` method also accepts a compiled regular expression object
 from :func:`re.compile` as a pattern. All flags should be included in the
@@ -221,7 +332,7 @@ The content of a ``Series`` (or ``Index``) can be concatenated:
 
 .. ipython:: python
 
-    s = pd.Series(['a', 'b', 'c', 'd'])
+    s = pd.Series(['a', 'b', 'c', 'd'], dtype="string")
     s.str.cat(sep=',')
 
 If not specified, the keyword ``sep`` for the separator defaults to the empty string, ``sep=''``:
@@ -234,7 +345,7 @@ By default, missing values are ignored. Using ``na_rep``, they can be given a re
 
 .. ipython:: python
 
-    t = pd.Series(['a', 'b', np.nan, 'd'])
+    t = pd.Series(['a', 'b', np.nan, 'd'], dtype="string")
     t.str.cat(sep=',')
     t.str.cat(sep=',', na_rep='-')
 
@@ -279,7 +390,8 @@ the ``join``-keyword.
 .. ipython:: python
    :okwarning:
 
-   u = pd.Series(['b', 'd', 'a', 'c'], index=[1, 3, 0, 2])
+   u = pd.Series(['b', 'd', 'a', 'c'], index=[1, 3, 0, 2],
+                 dtype="string")
    s
    u
    s.str.cat(u)
@@ -295,7 +407,8 @@ In particular, alignment also means that the different lengths do not need to co
 
 .. ipython:: python
 
-    v = pd.Series(['z', 'a', 'b', 'd', 'e'], index=[-1, 0, 1, 3, 4])
+    v = pd.Series(['z', 'a', 'b', 'd', 'e'], index=[-1, 0, 1, 3, 4],
+                  dtype="string")
     s
     v
     s.str.cat(v, join='left', na_rep='-')
@@ -351,7 +464,8 @@ of the string, the result will be a ``NaN``.
 .. ipython:: python
 
    s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan,
-                  'CABA', 'dog', 'cat'])
+                  'CABA', 'dog', 'cat'],
+                 dtype="string")
 
    s.str[0]
    s.str[1]
@@ -382,7 +496,8 @@ DataFrame with one column per group.
 
 .. ipython:: python
 
-   pd.Series(['a1', 'b2', 'c3']).str.extract(r'([ab])(\d)', expand=False)
+   pd.Series(['a1', 'b2', 'c3'],
+             dtype="string").str.extract(r'([ab])(\d)', expand=False)
 
 Elements that do not match return a row filled with ``NaN``. Thus, a
 Series of messy strings can be "converted" into a like-indexed Series
@@ -395,14 +510,16 @@ Named groups like
 
 .. ipython:: python
 
-   pd.Series(['a1', 'b2', 'c3']).str.extract(r'(?P<letter>[ab])(?P<digit>\d)',
-                                             expand=False)
+   pd.Series(['a1', 'b2', 'c3'],
+             dtype="string").str.extract(r'(?P<letter>[ab])(?P<digit>\d)',
+                                         expand=False)
 
 and optional groups like
 
 .. ipython:: python
 
-   pd.Series(['a1', 'b2', '3']).str.extract(r'([ab])?(\d)', expand=False)
+   pd.Series(['a1', 'b2', '3'],
+             dtype="string").str.extract(r'([ab])?(\d)', expand=False)
 
 can also be used. Note that any capture group names in the regular
 expression will be used for column names; otherwise capture group
@@ -413,20 +530,23 @@ with one column if ``expand=True``.
 
 .. ipython:: python
 
-   pd.Series(['a1', 'b2', 'c3']).str.extract(r'[ab](\d)', expand=True)
+   pd.Series(['a1', 'b2', 'c3'],
+             dtype="string").str.extract(r'[ab](\d)', expand=True)
 
 It returns a Series if ``expand=False``.
 
 .. ipython:: python
 
-   pd.Series(['a1', 'b2', 'c3']).str.extract(r'[ab](\d)', expand=False)
+   pd.Series(['a1', 'b2', 'c3'],
+             dtype="string").str.extract(r'[ab](\d)', expand=False)
 
 Calling on an ``Index`` with a regex with exactly one capture group
 returns a ``DataFrame`` with one column if ``expand=True``.
 
 .. ipython:: python
 
-   s = pd.Series(["a1", "b2", "c3"], ["A11", "B22", "C33"])
+   s = pd.Series(["a1", "b2", "c3"], ["A11", "B22", "C33"],
+                 dtype="string")
    s
    s.index.str.extract("(?P<letter>[a-zA-Z])", expand=True)
 
@@ -471,7 +591,8 @@ Unlike ``extract`` (which returns only the first match),
 
 .. ipython:: python
 
-   s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
+   s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"],
+                 dtype="string")
    s
    two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'
    s.str.extract(two_groups, expand=True)
@@ -489,7 +610,7 @@ When each subject string in the Series has exactly one match,
 
 .. ipython:: python
 
-   s = pd.Series(['a3', 'b3', 'c2'])
+   s = pd.Series(['a3', 'b3', 'c2'], dtype="string")
    s
 
 then ``extractall(pat).xs(0, level='match')`` gives the same result as
@@ -510,7 +631,7 @@ same result as a ``Series.str.extractall`` with a default index (starts from 0).
 
    pd.Index(["a1a2", "b1", "c1"]).str.extractall(two_groups)
 
-   pd.Series(["a1a2", "b1", "c1"]).str.extractall(two_groups)
+   pd.Series(["a1a2", "b1", "c1"], dtype="string").str.extractall(two_groups)
 
 
 Testing for Strings that match or contain a pattern
@@ -521,13 +642,15 @@ You can check whether elements contain a pattern:
 .. ipython:: python
 
    pattern = r'[0-9][a-z]'
-   pd.Series(['1', '2', '3a', '3b', '03c']).str.contains(pattern)
+   pd.Series(['1', '2', '3a', '3b', '03c'],
+             dtype="string").str.contains(pattern)
 
 Or whether elements match a pattern:
 
 .. ipython:: python
 
-   pd.Series(['1', '2', '3a', '3b', '03c']).str.match(pattern)
+   pd.Series(['1', '2', '3a', '3b', '03c'],
+             dtype="string").str.match(pattern)
 
 The distinction between ``match`` and ``contains`` is strictness: ``match``
 relies on strict ``re.match``, while ``contains`` relies on ``re.search``.
@@ -537,7 +660,8 @@ an extra ``na`` argument so missing values can be considered True or False:
 
 .. ipython:: python
 
-   s4 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
+   s4 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'],
+                  dtype="string")
    s4.str.contains('A', na=False)
 
 .. _text.indicator:
@@ -550,7 +674,7 @@ For example if they are separated by a ``'|'``:
 
 .. ipython:: python
 
-    s = pd.Series(['a', 'a|b', np.nan, 'a|c'])
+    s = pd.Series(['a', 'a|b', np.nan, 'a|c'], dtype="string")
     s.str.get_dummies(sep='|')
 
 String ``Index`` also supports ``get_dummies`` which returns a ``MultiIndex``.
diff --git a/doc/source/user_guide/timedeltas.rst b/doc/source/user_guide/timedeltas.rst
index 3e46140d79b8e..3439a0a4c13c7 100644
--- a/doc/source/user_guide/timedeltas.rst
+++ b/doc/source/user_guide/timedeltas.rst
@@ -327,8 +327,6 @@ similarly to the ``Series``. These are the *displayed* values of the ``Timedelta
 You can convert a ``Timedelta`` to an `ISO 8601 Duration`_ string with the
 ``.isoformat`` method
 
-.. versionadded:: 0.20.0
-
 .. ipython:: python
 
     pd.Timedelta(days=6, minutes=50, seconds=3,
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index 0894edd69c2ae..3fdab0fd26643 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -376,8 +376,6 @@ We subtract the epoch (midnight at January 1, 1970 UTC) and then floor divide by
 Using the ``origin`` Parameter
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 Using the ``origin`` parameter, one can specify an alternative starting point for creation
 of a ``DatetimeIndex``. For example, to use 1960-01-01 as the starting date:
 
@@ -774,7 +772,6 @@ There are several time/date properties that one can access from ``Timestamp`` or
     week,"The week ordinal of the year"
     dayofweek,"The number of the day of the week with Monday=0, Sunday=6"
     weekday,"The number of the day of the week with Monday=0, Sunday=6"
-    weekday_name,"The name of the day in a week (ex: Friday)"
     quarter,"Quarter of the date: Jan-Mar = 1, Apr-Jun = 2, etc."
     days_in_month,"The number of days in the month of the datetime"
     is_month_start,"Logical indicating if first day of month (defined by frequency)"
@@ -1593,10 +1590,10 @@ labels.
 
         s = pd.date_range('2000-01-01', '2000-01-05').to_series()
         s.iloc[2] = pd.NaT
-        s.dt.weekday_name
+        s.dt.day_name()
 
         # default: label='left', closed='left'
-        s.resample('B').last().dt.weekday_name
+        s.resample('B').last().dt.day_name()
 
     Notice how the value for Sunday got pulled back to the previous Friday.
     To get the behavior where the value for Sunday is pushed to Monday, use
@@ -1604,7 +1601,7 @@ labels.
 
     .. ipython:: python
 
-        s.resample('B', label='right', closed='right').last().dt.weekday_name
+        s.resample('B', label='right', closed='right').last().dt.day_name()
 
 The ``axis`` parameter can be set to 0 or 1 and allows you to resample the
 specified axis for a ``DataFrame``.
@@ -1954,6 +1951,10 @@ The ``period`` dtype can be used in ``.astype(...)``. It allows one to change th
 PeriodIndex partial string indexing
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+PeriodIndex now supports partial string slicing with non-monotonic indexes.
+
+.. versionadded:: 1.1.0
+
 You can pass in dates and strings to ``Series`` and ``DataFrame`` with ``PeriodIndex``, in the same manner as ``DatetimeIndex``. For details, refer to :ref:`DatetimeIndex Partial String Indexing <timeseries.partialindexing>`.
 
 .. ipython:: python
@@ -1984,6 +1985,7 @@ As with ``DatetimeIndex``, the endpoints will be included in the result. The exa
 
    dfp['2013-01-01 10H':'2013-01-01 11H']
 
+
 Frequency conversion and resampling with PeriodIndex
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The frequency of ``Period`` and ``PeriodIndex`` can be converted via the ``asfreq``
diff --git a/doc/source/user_guide/visualization.rst b/doc/source/user_guide/visualization.rst
index fa16b2f216610..756dd06aced7f 100644
--- a/doc/source/user_guide/visualization.rst
+++ b/doc/source/user_guide/visualization.rst
@@ -264,7 +264,7 @@ horizontal and cumulative histograms can be drawn by
    plt.close('all')
 
 See the :meth:`hist <matplotlib.axes.Axes.hist>` method and the
-`matplotlib hist documentation <http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hist>`__ for more.
+`matplotlib hist documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hist>`__ for more.
 
 
 The existing interface ``DataFrame.hist`` to plot histogram still can be used.
@@ -370,7 +370,7 @@ For example, horizontal and custom-positioned boxplot can be drawn by
 
 
 See the :meth:`boxplot <matplotlib.axes.Axes.boxplot>` method and the
-`matplotlib boxplot documentation <http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.boxplot>`__ for more.
+`matplotlib boxplot documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.boxplot>`__ for more.
 
 
 The existing interface ``DataFrame.boxplot`` to plot boxplot still can be used.
@@ -591,7 +591,7 @@ bubble chart using a column of the ``DataFrame`` as the bubble size.
    plt.close('all')
 
 See the :meth:`scatter <matplotlib.axes.Axes.scatter>` method and the
-`matplotlib scatter documentation <http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter>`__ for more.
+`matplotlib scatter documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter>`__ for more.
 
 .. _visualization.hexbin:
 
@@ -651,7 +651,7 @@ given by column ``z``. The bins are aggregated with NumPy's ``max`` function.
    plt.close('all')
 
 See the :meth:`hexbin <matplotlib.axes.Axes.hexbin>` method and the
-`matplotlib hexbin documentation <http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hexbin>`__ for more.
+`matplotlib hexbin documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hexbin>`__ for more.
 
 .. _visualization.pie:
 
@@ -749,7 +749,7 @@ If you pass values whose sum total is less than 1.0, matplotlib draws a semicirc
    @savefig series_pie_plot_semi.png
    series.plot.pie(figsize=(6, 6))
 
-See the `matplotlib pie documentation <http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.pie>`__ for more.
+See the `matplotlib pie documentation <https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.pie>`__ for more.
 
 .. ipython:: python
     :suppress:
@@ -1190,6 +1190,21 @@ with "(right)" in the legend. To turn off the automatic marking, use the
 
    plt.close('all')
 
+.. _plotting.formatters:
+
+Custom formatters for timeseries plots
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. versionchanged:: 1.0.0
+
+Pandas provides custom formatters for timeseries plots. These change the
+formatting of the axis labels for dates and times. By default,
+the custom formatters are applied only to plots created by pandas with
+:meth:`DataFrame.plot` or :meth:`Series.plot`. To have them apply to all
+plots, including those made by matplotlib, set the option
+``pd.options.plotting.matplotlib.register_converters = True`` or use
+:meth:`pandas.plotting.register_matplotlib_converters`.
+
 Suppressing tick resolution adjustment
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1247,14 +1262,12 @@ in ``pandas.plotting.plot_params`` can be used in a `with statement`:
 Automatic date tick adjustment
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. versionadded:: 0.20.0
-
 ``TimedeltaIndex`` now uses the native matplotlib
 tick locator methods, it is useful to call the automatic
 date tick adjustment from matplotlib for figures whose ticklabels overlap.
 
 See the :meth:`autofmt_xdate <matplotlib.figure.autofmt_xdate>` method and the
-`matplotlib documentation <http://matplotlib.org/users/recipes.html#fixing-common-date-annoyances>`__ for more.
+`matplotlib documentation <https://matplotlib.org/users/recipes.html#fixing-common-date-annoyances>`__ for more.
 
 Subplots
 ~~~~~~~~
@@ -1463,7 +1476,7 @@ as seen in the example below.
 There also exists a helper function ``pandas.plotting.table``, which creates a
 table from :class:`DataFrame` or :class:`Series`, and adds it to an
 ``matplotlib.Axes`` instance. This function can accept keywords which the
-matplotlib `table <http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.table>`__ has.
+matplotlib `table <https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.table>`__ has.
 
 .. ipython:: python
 
@@ -1481,7 +1494,7 @@ matplotlib `table <http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.
 
    plt.close('all')
 
-**Note**: You can get table instances on the axes using ``axes.tables`` property for further decorations. See the `matplotlib table documentation <http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.table>`__ for more.
+**Note**: You can get table instances on the axes using ``axes.tables`` property for further decorations. See the `matplotlib table documentation <https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.table>`__ for more.
 
 .. _visualization.colormaps:
 
@@ -1491,7 +1504,7 @@ Colormaps
 A potential issue when plotting a large number of columns is that it can be
 difficult to distinguish some series due to repetition in the default colors. To
 remedy this, ``DataFrame`` plotting supports the use of the ``colormap`` argument,
-which accepts either a Matplotlib `colormap <http://matplotlib.org/api/cm_api.html>`__
+which accepts either a Matplotlib `colormap <https://matplotlib.org/api/cm_api.html>`__
 or a string that is a name of a colormap registered with Matplotlib. A
 visualization of the default matplotlib colormaps is available `here
 <https://matplotlib.org/examples/color/colormaps_reference.html>`__.
@@ -1628,3 +1641,46 @@ when plotting a large number of points.
    :suppress:
 
     plt.close('all')
+
+Plotting backends
+-----------------
+
+Starting in version 0.25, pandas can be extended with third-party plotting backends. The
+main idea is letting users select a plotting backend different than the provided
+one based on Matplotlib.
+
+This can be done by passsing 'backend.module' as the argument ``backend`` in ``plot``
+function. For example:
+
+.. code-block:: python
+
+    >>> Series([1, 2, 3]).plot(backend='backend.module')
+
+Alternatively, you can also set this option globally, do you don't need to specify
+the keyword in each ``plot`` call. For example:
+
+.. code-block:: python
+
+    >>> pd.set_option('plotting.backend', 'backend.module')
+    >>> pd.Series([1, 2, 3]).plot()
+
+Or:
+
+.. code-block:: python
+
+    >>> pd.options.plotting.backend = 'backend.module'
+    >>> pd.Series([1, 2, 3]).plot()
+
+This would be more or less equivalent to:
+
+.. code-block:: python
+
+    >>> import backend.module
+    >>> backend.module.plot(pd.Series([1, 2, 3]))
+
+The backend module can then use other visualization tools (Bokeh, Altair, hvplot,...)
+to generate the plots. Some libraries implementing a backend for pandas are listed
+on the ecosystem :ref:`ecosystem.visualization` page.
+
+Developers guide can be found at
+https://dev.pandas.io/docs/development/extending.html#plotting-backends
\ No newline at end of file
diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index fe80cc8bb959a..68aabfe76d8de 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -7,9 +7,17 @@ Release Notes
 *************
 
 This is the list of changes to pandas between each release. For full details,
-see the commit logs at http://github.com/pandas-dev/pandas. For install and
+see the commit logs at https://github.com/pandas-dev/pandas. For install and
 upgrade instructions, see :ref:`install`.
 
+Version 1.1
+-----------
+
+.. toctree::
+   :maxdepth: 2
+
+   v1.1.0
+
 Version 1.0
 -----------
 
@@ -17,6 +25,8 @@ Version 1.0
    :maxdepth: 2
 
    v1.0.0
+   v1.0.1
+   v1.0.2
 
 Version 0.25
 ------------
@@ -24,6 +34,7 @@ Version 0.25
 .. toctree::
    :maxdepth: 2
 
+   v0.25.3
    v0.25.2
    v0.25.1
    v0.25.0
diff --git a/doc/source/whatsnew/v0.12.0.rst b/doc/source/whatsnew/v0.12.0.rst
index 0a74d67486715..823e177f3e05e 100644
--- a/doc/source/whatsnew/v0.12.0.rst
+++ b/doc/source/whatsnew/v0.12.0.rst
@@ -236,7 +236,7 @@ I/O enhancements
 
       .. ipython:: python
 
-         from pandas.util.testing import makeCustomDataframe as mkdf
+         from pandas._testing import makeCustomDataframe as mkdf
          df = mkdf(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
          df.to_csv('mi.csv')
          print(open('mi.csv').read())
@@ -417,6 +417,7 @@ Bug fixes
     original ``Series`` or ``NaN``. For example,
 
     .. ipython:: python
+        :okwarning:
 
         strs = 'go', 'bow', 'joe', 'slow'
         ds = pd.Series(strs)
diff --git a/doc/source/whatsnew/v0.13.0.rst b/doc/source/whatsnew/v0.13.0.rst
index ab48594ddadab..de5e1986744fe 100644
--- a/doc/source/whatsnew/v0.13.0.rst
+++ b/doc/source/whatsnew/v0.13.0.rst
@@ -214,7 +214,7 @@ These were announced changes in 0.12 or prior that are taking effect as of 0.13.
 - Remove deprecated ``read_clipboard/to_clipboard/ExcelFile/ExcelWriter`` from ``pandas.io.parsers`` (:issue:`3717`)
   These are available as functions in the main pandas namespace (e.g. ``pd.read_clipboard``)
 - default for ``tupleize_cols`` is now ``False`` for both ``to_csv`` and ``read_csv``. Fair warning in 0.12 (:issue:`3604`)
-- default for `display.max_seq_len` is now 100 rather then `None`. This activates
+- default for `display.max_seq_len` is now 100 rather than `None`. This activates
   truncated display ("...") of long sequences in various places. (:issue:`3391`)
 
 Deprecations
@@ -828,8 +828,7 @@ Experimental
 
      Since this is an EXPERIMENTAL LIBRARY, the storage format may not be stable until a future release.
 
-  .. ipython:: python
-     :okwarning:
+  .. code-block:: python
 
      df = pd.DataFrame(np.random.rand(5, 2), columns=list('AB'))
      df.to_msgpack('foo.msg')
@@ -841,8 +840,7 @@ Experimental
 
   You can pass ``iterator=True`` to iterator over the unpacked results
 
-  .. ipython:: python
-     :okwarning:
+  .. code-block:: python
 
      for o in pd.read_msgpack('foo.msg', iterator=True):
          print(o)
diff --git a/doc/source/whatsnew/v0.13.1.rst b/doc/source/whatsnew/v0.13.1.rst
index 6242c40d44bf8..4f9ab761334e7 100644
--- a/doc/source/whatsnew/v0.13.1.rst
+++ b/doc/source/whatsnew/v0.13.1.rst
@@ -224,7 +224,7 @@ Enhancements
 
   .. code-block:: ipython
 
-      In [28]: import pandas.util.testing as tm
+      In [28]: import pandas._testing as tm
 
       In [29]: panel = tm.makePanel(5)
 
diff --git a/doc/source/whatsnew/v0.15.0.rst b/doc/source/whatsnew/v0.15.0.rst
index c27ada6ef3b58..95e354e425143 100644
--- a/doc/source/whatsnew/v0.15.0.rst
+++ b/doc/source/whatsnew/v0.15.0.rst
@@ -312,14 +312,13 @@ Timezone handling improvements
   previously this resulted in ``Exception`` or ``TypeError`` (:issue:`7812`)
 
   .. ipython:: python
-     :okwarning:
 
      ts = pd.Timestamp('2014-08-01 09:00', tz='US/Eastern')
      ts
      ts.tz_localize(None)
 
-     didx = pd.DatetimeIndex(start='2014-08-01 09:00', freq='H',
-                             periods=10, tz='US/Eastern')
+     didx = pd.date_range(start='2014-08-01 09:00', freq='H',
+                          periods=10, tz='US/Eastern')
      didx
      didx.tz_localize(None)
 
@@ -853,7 +852,7 @@ Other notable API changes:
      A value is trying to be set on a copy of a slice from a DataFrame.
      Try using .loc[row_indexer,col_indexer] = value instead
 
-     See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
+     See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
 
 - ``merge``, ``DataFrame.merge``, and ``ordered_merge`` now return the same type
   as the ``left`` argument (:issue:`7737`).
diff --git a/doc/source/whatsnew/v0.15.2.rst b/doc/source/whatsnew/v0.15.2.rst
index b58eabaed6127..292351c709940 100644
--- a/doc/source/whatsnew/v0.15.2.rst
+++ b/doc/source/whatsnew/v0.15.2.rst
@@ -172,7 +172,7 @@ Other enhancements:
      4   True   True   True  True
 
 - Added support for ``utcfromtimestamp()``, ``fromtimestamp()``, and ``combine()`` on `Timestamp` class (:issue:`5351`).
-- Added Google Analytics (`pandas.io.ga`) basic documentation (:issue:`8835`). See `here <http://pandas.pydata.org/pandas-docs/version/0.15.2/remote_data.html#remote-data-ga>`__.
+- Added Google Analytics (`pandas.io.ga`) basic documentation (:issue:`8835`). See `here <https://pandas.pydata.org/pandas-docs/version/0.15.2/remote_data.html#remote-data-ga>`__.
 - ``Timedelta`` arithmetic returns ``NotImplemented`` in unknown cases, allowing extensions by custom classes (:issue:`8813`).
 - ``Timedelta`` now supports arithmetic with ``numpy.ndarray`` objects of the appropriate dtype (numpy 1.8 or newer only) (:issue:`8884`).
 - Added ``Timedelta.to_timedelta64()`` method to the public API (:issue:`8884`).
diff --git a/doc/source/whatsnew/v0.16.0.rst b/doc/source/whatsnew/v0.16.0.rst
index 42b3b9332ca98..855d0b8695bb1 100644
--- a/doc/source/whatsnew/v0.16.0.rst
+++ b/doc/source/whatsnew/v0.16.0.rst
@@ -91,8 +91,7 @@ Interaction with scipy.sparse
 
 Added :meth:`SparseSeries.to_coo` and :meth:`SparseSeries.from_coo` methods (:issue:`8048`) for converting to and from ``scipy.sparse.coo_matrix`` instances (see :ref:`here <sparse.scipysparse>`). For example, given a SparseSeries with MultiIndex we can convert to a `scipy.sparse.coo_matrix` by specifying the row and column labels as index levels:
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])
    s.index = pd.MultiIndex.from_tuples([(1, 2, 'a', 0),
@@ -121,8 +120,7 @@ Added :meth:`SparseSeries.to_coo` and :meth:`SparseSeries.from_coo` methods (:is
 The from_coo method is a convenience method for creating a ``SparseSeries``
 from a ``scipy.sparse.coo_matrix``:
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    from scipy import sparse
    A = sparse.coo_matrix(([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])),
@@ -530,7 +528,7 @@ Deprecations
   `seaborn <http://stanford.edu/~mwaskom/software/seaborn/>`_ for similar
   but more refined functionality (:issue:`3445`).
   The documentation includes some examples how to convert your existing code
-  from ``rplot`` to seaborn `here <http://pandas.pydata.org/pandas-docs/version/0.18.1/visualization.html#trellis-plotting-interface>`__.
+  from ``rplot`` to seaborn `here <https://pandas.pydata.org/pandas-docs/version/0.18.1/visualization.html#trellis-plotting-interface>`__.
 
 - The ``pandas.sandbox.qtpandas`` interface is deprecated and will be removed in a future version.
   We refer users to the external package `pandas-qt <https://github.com/datalyze-solutions/pandas-qt>`_. (:issue:`9615`)
diff --git a/doc/source/whatsnew/v0.18.0.rst b/doc/source/whatsnew/v0.18.0.rst
index a7174c6325f86..d3f96d4185d65 100644
--- a/doc/source/whatsnew/v0.18.0.rst
+++ b/doc/source/whatsnew/v0.18.0.rst
@@ -1279,7 +1279,7 @@ Bug Fixes
 
 - Removed ``millisecond`` property of ``DatetimeIndex``. This would always raise a ``ValueError`` (:issue:`12019`).
 - Bug in ``Series`` constructor with read-only data (:issue:`11502`)
-- Removed ``pandas.util.testing.choice()``.  Should use ``np.random.choice()``, instead. (:issue:`12386`)
+- Removed ``pandas._testing.choice()``.  Should use ``np.random.choice()``, instead. (:issue:`12386`)
 - Bug in ``.loc`` setitem indexer preventing the use of a TZ-aware DatetimeIndex (:issue:`12050`)
 - Bug in ``.style`` indexes and MultiIndexes not appearing (:issue:`11655`)
 - Bug in ``to_msgpack`` and ``from_msgpack`` which did not correctly serialize or deserialize ``NaT`` (:issue:`12307`).
diff --git a/doc/source/whatsnew/v0.18.1.rst b/doc/source/whatsnew/v0.18.1.rst
index 7e06e5050c5f0..f786ce513f6fe 100644
--- a/doc/source/whatsnew/v0.18.1.rst
+++ b/doc/source/whatsnew/v0.18.1.rst
@@ -393,8 +393,7 @@ used in the ``pandas`` implementation (:issue:`12644`, :issue:`12638`, :issue:`1
 
 An example of this signature augmentation is illustrated below:
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    sp = pd.SparseDataFrame([1, 2, 3])
    sp
@@ -409,8 +408,7 @@ Previous behaviour:
 
 New behaviour:
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    np.cumsum(sp, axis=0)
 
diff --git a/doc/source/whatsnew/v0.19.0.rst b/doc/source/whatsnew/v0.19.0.rst
index 1dad8769a6b39..6eb509a258430 100644
--- a/doc/source/whatsnew/v0.19.0.rst
+++ b/doc/source/whatsnew/v0.19.0.rst
@@ -707,6 +707,7 @@ A ``Series`` will now correctly promote its dtype for assignment with incompat v
 
 
 .. ipython:: python
+   :okwarning:
 
    s = pd.Series()
 
@@ -1224,6 +1225,7 @@ Previously, sparse data were ``float64`` dtype by default, even if all inputs we
 As of v0.19.0, sparse data keeps the input dtype, and uses more appropriate ``fill_value`` defaults (``0`` for ``int64`` dtype, ``False`` for ``bool`` dtype).
 
 .. ipython:: python
+   :okwarning:
 
    pd.SparseArray([1, 2, 0, 0], dtype=np.int64)
    pd.SparseArray([True, False, False, False])
@@ -1235,8 +1237,7 @@ Operators now preserve dtypes
 
 - Sparse data structure now can preserve ``dtype`` after arithmetic ops (:issue:`13848`)
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    s = pd.SparseSeries([0, 2, 0, 1], fill_value=0, dtype=np.int64)
    s.dtype
@@ -1245,8 +1246,7 @@ Operators now preserve dtypes
 
 - Sparse data structure now support ``astype`` to convert internal ``dtype`` (:issue:`13900`)
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    s = pd.SparseSeries([1., 0., 2., 0.], fill_value=0)
    s
diff --git a/doc/source/whatsnew/v0.20.0.rst b/doc/source/whatsnew/v0.20.0.rst
index 62604dd3edd2d..ceb1c7f27231b 100644
--- a/doc/source/whatsnew/v0.20.0.rst
+++ b/doc/source/whatsnew/v0.20.0.rst
@@ -33,7 +33,7 @@ Check the :ref:`API Changes <whatsnew_0200.api_breaking>` and :ref:`deprecations
 
 .. note::
 
-   This is a combined release for 0.20.0 and and 0.20.1.
+   This is a combined release for 0.20.0 and 0.20.1.
    Version 0.20.1 contains one additional change for backwards-compatibility with downstream projects using pandas' ``utils`` routines. (:issue:`16250`)
 
 .. contents:: What's new in v0.20.0
@@ -338,8 +338,7 @@ See the :ref:`documentation <sparse.scipysparse>` for more information. (:issue:
 
 All sparse formats are supported, but matrices that are not in :mod:`COOrdinate <scipy.sparse>` format will be converted, copying data as needed.
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    from scipy.sparse import csr_matrix
    arr = np.random.random(size=(1000, 5))
@@ -351,7 +350,7 @@ All sparse formats are supported, but matrices that are not in :mod:`COOrdinate
 
 To convert a ``SparseDataFrame`` back to sparse SciPy matrix in COO format, you can use:
 
-.. ipython:: python
+.. code-block:: python
 
    sdf.to_coo()
 
@@ -1361,7 +1360,7 @@ provides a :meth:`~Panel.to_xarray` method to automate this conversion (:issue:`
 
 .. code-block:: ipython
 
-    In [133]: import pandas.util.testing as tm
+    In [133]: import pandas._testing as tm
 
     In [134]: p = tm.makePanel()
 
diff --git a/doc/source/whatsnew/v0.21.0.rst b/doc/source/whatsnew/v0.21.0.rst
index 34b610e8af0b3..71969c4de6b02 100644
--- a/doc/source/whatsnew/v0.21.0.rst
+++ b/doc/source/whatsnew/v0.21.0.rst
@@ -20,7 +20,7 @@ Highlights include:
 - Integration with `Apache Parquet <https://parquet.apache.org/>`__, including a new top-level :func:`read_parquet` function and :meth:`DataFrame.to_parquet` method, see :ref:`here <whatsnew_0210.enhancements.parquet>`.
 - New user-facing :class:`pandas.api.types.CategoricalDtype` for specifying
   categoricals independent of the data, see :ref:`here <whatsnew_0210.enhancements.categorical_dtype>`.
-- The behavior of ``sum`` and ``prod`` on all-NaN Series/DataFrames is now consistent and no longer depends on whether `bottleneck <http://berkeleyanalytics.com/bottleneck>`__ is installed, and ``sum`` and ``prod`` on empty Series now return NaN instead of 0, see :ref:`here <whatsnew_0210.api_breaking.bottleneck>`.
+- The behavior of ``sum`` and ``prod`` on all-NaN Series/DataFrames is now consistent and no longer depends on whether `bottleneck <https://bottleneck.readthedocs.io>`__ is installed, and ``sum`` and ``prod`` on empty Series now return NaN instead of 0, see :ref:`here <whatsnew_0210.api_breaking.bottleneck>`.
 - Compatibility fixes for pypy, see :ref:`here <whatsnew_0210.pypy>`.
 - Additions to the ``drop``, ``reindex`` and ``rename`` API to make them more consistent, see :ref:`here <whatsnew_0210.enhancements.drop_api>`.
 - Addition of the new methods ``DataFrame.infer_objects`` (see :ref:`here <whatsnew_0210.enhancements.infer_objects>`) and ``GroupBy.pipe`` (see :ref:`here <whatsnew_0210.enhancements.GroupBy_pipe>`).
@@ -390,7 +390,7 @@ Sum/Prod of all-NaN or empty Series/DataFrames is now consistently NaN
 
 
 The behavior of ``sum`` and ``prod`` on all-NaN Series/DataFrames no longer depends on
-whether `bottleneck <http://berkeleyanalytics.com/bottleneck>`__ is installed, and return value of ``sum`` and ``prod`` on an empty Series has changed (:issue:`9422`, :issue:`15507`).
+whether `bottleneck <https://bottleneck.readthedocs.io>`__ is installed, and return value of ``sum`` and ``prod`` on an empty Series has changed (:issue:`9422`, :issue:`15507`).
 
 Calling ``sum`` or ``prod`` on an empty or all-``NaN`` ``Series``, or columns of a ``DataFrame``, will result in ``NaN``. See the :ref:`docs <missing_data.numeric_sum>`.
 
@@ -428,6 +428,7 @@ Note that this also changes the sum of an empty ``Series``. Previously this alwa
 but for consistency with the all-NaN case, this was changed to return NaN as well:
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([]).sum()
 
@@ -469,7 +470,7 @@ Current behavior
    KeyError in the future, you can use .reindex() as an alternative.
 
    See the documentation here:
-   http://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
+   https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike
 
    Out[4]:
    1    2.0
@@ -926,7 +927,7 @@ Other API changes
 - :class:`pandas.HDFStore`'s string representation is now faster and less detailed. For the previous behavior, use ``pandas.HDFStore.info()``. (:issue:`16503`).
 - Compression defaults in HDF stores now follow pytables standards. Default is no compression and if ``complib`` is missing and ``complevel`` > 0 ``zlib`` is used (:issue:`15943`)
 - ``Index.get_indexer_non_unique()`` now returns a ndarray indexer rather than an ``Index``; this is consistent with ``Index.get_indexer()`` (:issue:`16819`)
-- Removed the ``@slow`` decorator from ``pandas.util.testing``, which caused issues for some downstream packages' test suites. Use ``@pytest.mark.slow`` instead, which achieves the same thing (:issue:`16850`)
+- Removed the ``@slow`` decorator from ``pandas._testing``, which caused issues for some downstream packages' test suites. Use ``@pytest.mark.slow`` instead, which achieves the same thing (:issue:`16850`)
 - Moved definition of ``MergeError`` to the ``pandas.errors`` module.
 - The signature of :func:`Series.set_axis` and :func:`DataFrame.set_axis` has been changed from ``set_axis(axis, labels)`` to ``set_axis(labels, axis=0)``, for consistency with the rest of the API. The old signature is deprecated and will show a ``FutureWarning`` (:issue:`14636`)
 - :func:`Series.argmin` and :func:`Series.argmax` will now raise a ``TypeError`` when used with ``object`` dtypes, instead of a ``ValueError`` (:issue:`13595`)
diff --git a/doc/source/whatsnew/v0.22.0.rst b/doc/source/whatsnew/v0.22.0.rst
index ea36b35d61740..75949a90d09a6 100644
--- a/doc/source/whatsnew/v0.22.0.rst
+++ b/doc/source/whatsnew/v0.22.0.rst
@@ -55,6 +55,7 @@ The default sum for empty or all-*NA* ``Series`` is now ``0``.
 *pandas 0.22.0*
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([]).sum()
    pd.Series([np.nan]).sum()
@@ -67,6 +68,7 @@ pandas 0.20.3 without bottleneck, or pandas 0.21.x), use the ``min_count``
 keyword.
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([]).sum(min_count=1)
 
@@ -85,6 +87,7 @@ required for a non-NA sum or product.
 returning ``1`` instead.
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([]).prod()
    pd.Series([np.nan]).prod()
diff --git a/doc/source/whatsnew/v0.23.0.rst b/doc/source/whatsnew/v0.23.0.rst
index f4c283ea742f7..b9e1b5060d1da 100644
--- a/doc/source/whatsnew/v0.23.0.rst
+++ b/doc/source/whatsnew/v0.23.0.rst
@@ -648,7 +648,7 @@ provides a :meth:`~Panel.to_xarray` method to automate this conversion (:issue:`
 
 .. code-block:: ipython
 
-    In [75]: import pandas.util.testing as tm
+    In [75]: import pandas._testing as tm
 
     In [76]: p = tm.makePanel()
 
diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index d9f41d2a75116..85de0150a5a28 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -353,7 +353,7 @@ Example:
 
     mi = pd.MultiIndex.from_product([list('AB'), list('CD'), list('EF')],
                                     names=['AB', 'CD', 'EF'])
-    df = pd.DataFrame([i for i in range(len(mi))], index=mi, columns=['N'])
+    df = pd.DataFrame(list(range(len(mi))), index=mi, columns=['N'])
     df
     df.rename_axis(index={'CD': 'New'})
 
@@ -1933,4 +1933,4 @@ Other
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v0.23.4..HEAD
+.. contributors:: v0.23.4..v0.24.0
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index fe1e2d7826d62..b18d022349001 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -170,7 +170,7 @@ which level to end normalization (:issue:`23843`):
 
 The repr now looks like this:
 
-.. ipython:: python
+.. code-block:: ipython
 
     from pandas.io.json import json_normalize
     data = [{
@@ -354,6 +354,7 @@ When passed DataFrames whose values are sparse, :func:`concat` will now return a
 :class:`Series` or :class:`DataFrame` with sparse values, rather than a :class:`SparseDataFrame` (:issue:`25702`).
 
 .. ipython:: python
+   :okwarning:
 
    df = pd.DataFrame({"A": pd.SparseArray([0, 1])})
 
@@ -797,7 +798,7 @@ The columns were lexicographically sorted previously,
 
 The column order now matches the insertion-order of the keys in the ``dict``,
 considering all the records from top to bottom. As a consequence, the column
-order of the resulting DataFrame has changed compared to previous pandas verisons.
+order of the resulting DataFrame has changed compared to previous pandas versions.
 
 .. ipython:: python
 
@@ -828,7 +829,7 @@ If installed, we now require:
 | pytest (dev)    | 4.0.2           |          |
 +-----------------+-----------------+----------+
 
-For `optional libraries <https://dev.pandas.io/install.html#dependencies>`_ the general recommendation is to use the latest version.
+For `optional libraries <https://dev.pandas.io/docs/install.html#dependencies>`_ the general recommendation is to use the latest version.
 The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
 Optional libraries below the lowest tested version may still work, but are not considered supported.
 
@@ -886,7 +887,7 @@ Other API changes
 - Using an unsupported version of Beautiful Soup 4 will now raise an ``ImportError`` instead of a ``ValueError`` (:issue:`27063`)
 - :meth:`Series.to_excel` and :meth:`DataFrame.to_excel` will now raise a ``ValueError`` when saving timezone aware data. (:issue:`27008`, :issue:`7056`)
 - :meth:`ExtensionArray.argsort` places NA values at the end of the sorted array. (:issue:`21801`)
-- :meth:`DataFrame.to_hdf` and :meth:`Series.to_hdf` will now raise a ``NotImplementedError`` when saving a :class:`MultiIndex` with extention data types for a ``fixed`` format. (:issue:`7775`)
+- :meth:`DataFrame.to_hdf` and :meth:`Series.to_hdf` will now raise a ``NotImplementedError`` when saving a :class:`MultiIndex` with extension data types for a ``fixed`` format. (:issue:`7775`)
 - Passing duplicate ``names`` in :meth:`read_csv` will now raise a ``ValueError`` (:issue:`17346`)
 
 .. _whatsnew_0250.deprecations:
@@ -902,8 +903,7 @@ by a ``Series`` or ``DataFrame`` with sparse values.
 
 **Previous way**
 
-.. ipython:: python
-   :okwarning:
+.. code-block:: python
 
    df = pd.SparseDataFrame({"A": [0, 0, 1, 2]})
    df.dtypes
@@ -911,6 +911,7 @@ by a ``Series`` or ``DataFrame`` with sparse values.
 **New way**
 
 .. ipython:: python
+   :okwarning:
 
    df = pd.DataFrame({"A": pd.SparseArray([0, 0, 1, 2])})
    df.dtypes
@@ -1107,7 +1108,7 @@ Indexing
 
 - Improved exception message when calling :meth:`DataFrame.iloc` with a list of non-numeric objects (:issue:`25753`).
 - Improved exception message when calling ``.iloc`` or ``.loc`` with a boolean indexer with different length (:issue:`26658`).
-- Bug in ``KeyError`` exception message when indexing a :class:`MultiIndex` with a non-existant key not displaying the original key (:issue:`27250`).
+- Bug in ``KeyError`` exception message when indexing a :class:`MultiIndex` with a non-existent key not displaying the original key (:issue:`27250`).
 - Bug in ``.iloc`` and ``.loc`` with a boolean indexer not raising an ``IndexError`` when too few items are passed (:issue:`26658`).
 - Bug in :meth:`DataFrame.loc` and :meth:`Series.loc` where ``KeyError`` was not raised for a ``MultiIndex`` when the key was less than or equal to the number of levels in the :class:`MultiIndex` (:issue:`14885`).
 - Bug in which :meth:`DataFrame.append` produced an erroneous warning indicating that a ``KeyError`` will be thrown in the future when the data to be appended contains new columns (:issue:`22252`).
@@ -1268,4 +1269,4 @@ Other
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v0.24.x..HEAD
+.. contributors:: v0.24.2..v0.25.0
diff --git a/doc/source/whatsnew/v0.25.1.rst b/doc/source/whatsnew/v0.25.1.rst
index 63dd56f4a3793..944021ca0fcae 100644
--- a/doc/source/whatsnew/v0.25.1.rst
+++ b/doc/source/whatsnew/v0.25.1.rst
@@ -9,7 +9,7 @@ including other versions of pandas.
 I/O and LZMA
 ~~~~~~~~~~~~
 
-Some users may unknowingly have an incomplete Python installation lacking the `lzma` module from the standard library. In this case, `import pandas` failed due to an `ImportError` (:issue: `27575`).
+Some users may unknowingly have an incomplete Python installation lacking the `lzma` module from the standard library. In this case, `import pandas` failed due to an `ImportError` (:issue:`27575`).
 Pandas will now warn, rather than raising an `ImportError` if the `lzma` module is not present. Any subsequent attempt to use `lzma` methods will raise a `RuntimeError`.
 A possible fix for the lack of the `lzma` module is to ensure you have the necessary libraries and then re-install Python.
 For example, on MacOS installing Python with `pyenv` may lead to an incomplete Python installation due to unmet system dependencies at compilation time (like `xz`). Compilation will succeed, but Python might fail at run time. The issue can be solved by installing the necessary dependencies and then re-installing Python.
@@ -116,4 +116,4 @@ Other
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v0.25.0..HEAD
+.. contributors:: v0.25.0..v0.25.1
diff --git a/doc/source/whatsnew/v0.25.2.rst b/doc/source/whatsnew/v0.25.2.rst
index de411ef63680a..c0c68ce4b1f44 100644
--- a/doc/source/whatsnew/v0.25.2.rst
+++ b/doc/source/whatsnew/v0.25.2.rst
@@ -1,110 +1,49 @@
 .. _whatsnew_0252:
 
-What's new in 0.25.2 (October XX, 2019)
+What's new in 0.25.2 (October 15, 2019)
 ---------------------------------------
 
 These are the changes in pandas 0.25.2. See :ref:`release` for a full changelog
 including other versions of pandas.
 
+.. note::
+
+    Pandas 0.25.2 adds compatibility for Python 3.8 (:issue:`28147`).
+
 .. _whatsnew_0252.bug_fixes:
 
 Bug fixes
 ~~~~~~~~~
 
-Categorical
-^^^^^^^^^^^
-
--
-
-Datetimelike
-^^^^^^^^^^^^
-
--
--
--
-
-Timezones
-^^^^^^^^^
-
--
-
-Numeric
-^^^^^^^
-
--
--
--
--
-
-Conversion
-^^^^^^^^^^
-
--
-
-Interval
-^^^^^^^^
-
--
-
 Indexing
 ^^^^^^^^
 
--
--
--
-
-Missing
-^^^^^^^
-
--
+- Fix regression in :meth:`DataFrame.reindex` not following the ``limit`` argument (:issue:`28631`).
+- Fix regression in :meth:`RangeIndex.get_indexer` for decreasing :class:`RangeIndex` where target values may be improperly identified as missing/present (:issue:`28678`)
 
 I/O
 ^^^
 
-- Fix regression in notebook display where <th> tags not used for :attr:`DataFrame.index` (:issue:`28204`).
+- Fix regression in notebook display where ``<th>`` tags were missing for :attr:`DataFrame.index` values (:issue:`28204`).
 - Regression in :meth:`~DataFrame.to_csv` where writing a :class:`Series` or :class:`DataFrame` indexed by an :class:`IntervalIndex` would incorrectly raise a ``TypeError`` (:issue:`28210`)
--
--
-
-Plotting
-^^^^^^^^
-
--
--
--
+- Fix :meth:`~DataFrame.to_csv` with ``ExtensionArray`` with list-like values (:issue:`28840`).
 
 Groupby/resample/rolling
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Bug incorrectly raising an ``IndexError`` when passing a list of quantiles to :meth:`pandas.core.groupby.DataFrameGroupBy.quantile` (:issue:`28113`).
 - Bug in :meth:`pandas.core.groupby.GroupBy.shift`, :meth:`pandas.core.groupby.GroupBy.bfill` and :meth:`pandas.core.groupby.GroupBy.ffill` where timezone information would be dropped (:issue:`19995`, :issue:`27992`)
--
--
--
-
-Reshaping
-^^^^^^^^^
-
--
--
--
--
--
-
-Sparse
-^^^^^^
-
--
 
 Other
 ^^^^^
 
 - Compatibility with Python 3.8 in :meth:`DataFrame.query` (:issue:`27261`)
--
+- Fix to ensure that tab-completion in an IPython console does not raise
+  warnings for deprecated attributes (:issue:`27900`).
 
 .. _whatsnew_0.252.contributors:
 
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v0.25.1..HEAD
+.. contributors:: v0.25.1..v0.25.2
diff --git a/doc/source/whatsnew/v0.25.3.rst b/doc/source/whatsnew/v0.25.3.rst
new file mode 100644
index 0000000000000..f7f54198a0f82
--- /dev/null
+++ b/doc/source/whatsnew/v0.25.3.rst
@@ -0,0 +1,22 @@
+.. _whatsnew_0253:
+
+What's new in 0.25.3 (October 31, 2019)
+---------------------------------------
+
+These are the changes in pandas 0.25.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+.. _whatsnew_0253.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+Groupby/resample/rolling
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+- Bug in :meth:`DataFrameGroupBy.quantile` where NA values in the grouping could cause segfaults or incorrect results (:issue:`28882`)
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v0.25.2..v0.25.3
diff --git a/doc/source/whatsnew/v0.8.0.rst b/doc/source/whatsnew/v0.8.0.rst
index 664325ac063c0..072d1bae2a2b9 100644
--- a/doc/source/whatsnew/v0.8.0.rst
+++ b/doc/source/whatsnew/v0.8.0.rst
@@ -156,8 +156,7 @@ Other new features
 New plotting methods
 ~~~~~~~~~~~~~~~~~~~~
 
-.. ipython:: python
-   :suppress:
+.. code-block:: python
 
    import pandas as pd
    fx = pd.read_pickle('data/fx_prices')
@@ -165,7 +164,7 @@ New plotting methods
 
 ``Series.plot`` now supports a ``secondary_y`` option:
 
-.. ipython:: python
+.. code-block:: python
 
    plt.figure()
 
diff --git a/doc/source/whatsnew/v0.8.1.rst b/doc/source/whatsnew/v0.8.1.rst
index aaf1778bf637d..1e6b9746c85a5 100644
--- a/doc/source/whatsnew/v0.8.1.rst
+++ b/doc/source/whatsnew/v0.8.1.rst
@@ -29,7 +29,7 @@ Performance improvements
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
   - Improved implementation of rolling min and max (thanks to `Bottleneck
-    <http://berkeleyanalytics.com/bottleneck/>`__ !)
+    <https://bottleneck.readthedocs.io>`__ !)
   - Add accelerated ``'median'`` GroupBy option (:issue:`1358`)
   - Significantly improve the performance of parsing ISO8601-format date
     strings with ``DatetimeIndex`` or ``to_datetime`` (:issue:`1571`)
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
old mode 100644
new mode 100755
index 5b9e3a7dbad06..6597b764581a4
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -1,47 +1,311 @@
-.. _whatsnew_1000:
+.. _whatsnew_100:
 
-What's new in 1.0.0 (??)
-------------------------
+What's new in 1.0.0 (January 29, 2020)
+--------------------------------------
 
-.. warning::
+These are the changes in pandas 1.0.0. See :ref:`release` for a full changelog
+including other versions of pandas.
 
-   Starting with the 0.25.x series of releases, pandas only supports Python 3.5.3 and higher.
-   See `Dropping Python 2.7 <https://pandas.pydata.org/pandas-docs/version/0.24/install.html#install-dropping-27>`_ for more details.
+.. note::
 
-.. warning::
+    The pandas 1.0 release removed a lot of functionality that was deprecated
+    in previous releases (see :ref:`below <whatsnew_100.prior_deprecations>`
+    for an overview). It is recommended to first upgrade to pandas 0.25 and to
+    ensure your code is working without warnings, before upgrading to pandas
+    1.0.
 
-   The minimum supported Python version will be bumped to 3.6 in a future release.
 
-{{ header }}
+New Deprecation Policy
+~~~~~~~~~~~~~~~~~~~~~~
 
-These are the changes in pandas 1.0.0. See :ref:`release` for a full changelog
-including other versions of pandas.
+Starting with Pandas 1.0.0, pandas will adopt a variant of `SemVer`_ to
+version releases. Briefly,
+
+* Deprecations will be introduced in minor releases (e.g. 1.1.0, 1.2.0, 2.1.0, ...)
+* Deprecations will be enforced in major releases (e.g. 1.0.0, 2.0.0, 3.0.0, ...)
+* API-breaking changes will be made only in major releases (except for experimental features)
+
+See :ref:`policies.version` for more.
 
+.. _2019 Pandas User Survey: http://dev.pandas.io/pandas-blog/2019-pandas-user-survey.html
+.. _SemVer: https://semver.org
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
 
 Enhancements
 ~~~~~~~~~~~~
 
+.. _whatsnew_100.numba_rolling_apply:
+
+Using Numba in ``rolling.apply`` and ``expanding.apply``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We've added an ``engine`` keyword to :meth:`~core.window.rolling.Rolling.apply` and :meth:`~core.window.expanding.Expanding.apply`
+that allows the user to execute the routine using `Numba <https://numba.pydata.org/>`__ instead of Cython.
+Using the Numba engine can yield significant performance gains if the apply function can operate on numpy arrays and
+the data set is larger (1 million rows or greater). For more details, see
+:ref:`rolling apply documentation <stats.rolling_apply>` (:issue:`28987`, :issue:`30936`)
+
+.. _whatsnew_100.custom_window:
+
+Defining custom windows for rolling operations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We've added a :func:`pandas.api.indexers.BaseIndexer` class that allows users to define how
+window bounds are created during ``rolling`` operations. Users can define their own ``get_window_bounds``
+method on a :func:`pandas.api.indexers.BaseIndexer` subclass that will generate the start and end
+indices used for each window during the rolling aggregation. For more details and example usage, see
+the :ref:`custom window rolling documentation <stats.custom_rolling_window>`
+
+.. _whatsnew_100.to_markdown:
+
+Converting to Markdown
+^^^^^^^^^^^^^^^^^^^^^^
+
+We've added :meth:`~DataFrame.to_markdown` for creating a markdown table (:issue:`11052`)
+
+.. ipython:: python
+
+   df = pd.DataFrame({"A": [1, 2, 3], "B": [1, 2, 3]}, index=['a', 'a', 'b'])
+   print(df.to_markdown())
+
+Experimental new features
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _whatsnew_100.NA:
+
+Experimental ``NA`` scalar to denote missing values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A new ``pd.NA`` value (singleton) is introduced to represent scalar missing
+values. Up to now, pandas used several values to represent missing data: ``np.nan`` is used for this for float data, ``np.nan`` or
+``None`` for object-dtype data and ``pd.NaT`` for datetime-like data. The
+goal of ``pd.NA`` is to provide a "missing" indicator that can be used
+consistently across data types. ``pd.NA`` is currently used by the nullable integer and boolean
+data types and the new string data type (:issue:`28095`).
+
+.. warning::
+
+   Experimental: the behaviour of ``pd.NA`` can still change without warning.
+
+For example, creating a Series using the nullable integer dtype:
+
+.. ipython:: python
+
+    s = pd.Series([1, 2, None], dtype="Int64")
+    s
+    s[2]
+
+Compared to ``np.nan``, ``pd.NA`` behaves differently in certain operations.
+In addition to arithmetic operations, ``pd.NA`` also propagates as "missing"
+or "unknown" in comparison operations:
+
+.. ipython:: python
+
+    np.nan > 1
+    pd.NA > 1
+
+For logical operations, ``pd.NA`` follows the rules of the
+`three-valued logic <https://en.wikipedia.org/wiki/Three-valued_logic>`__ (or
+*Kleene logic*). For example:
+
+.. ipython:: python
+
+    pd.NA | True
 
-.. _whatsnew_1000.enhancements.other:
+For more, see :ref:`NA section <missing_data.NA>` in the user guide on missing
+data.
+
+
+.. _whatsnew_100.string:
+
+Dedicated string data type
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We've added :class:`StringDtype`, an extension type dedicated to string data.
+Previously, strings were typically stored in object-dtype NumPy arrays. (:issue:`29975`)
+
+.. warning::
+
+   ``StringDtype`` is currently considered experimental. The implementation
+   and parts of the API may change without warning.
+
+The ``'string'`` extension type solves several issues with object-dtype NumPy arrays:
+
+1. You can accidentally store a *mixture* of strings and non-strings in an
+   ``object`` dtype array. A ``StringArray`` can only store strings.
+2. ``object`` dtype breaks dtype-specific operations like :meth:`DataFrame.select_dtypes`.
+   There isn't a clear way to select *just* text while excluding non-text,
+   but still object-dtype columns.
+3. When reading code, the contents of an ``object`` dtype array is less clear
+   than ``string``.
+
+
+.. ipython:: python
+
+   pd.Series(['abc', None, 'def'], dtype=pd.StringDtype())
+
+You can use the alias ``"string"`` as well.
+
+.. ipython:: python
+
+   s = pd.Series(['abc', None, 'def'], dtype="string")
+   s
+
+The usual string accessor methods work. Where appropriate, the return type
+of the Series or columns of a DataFrame will also have string dtype.
+
+.. ipython:: python
+
+   s.str.upper()
+   s.str.split('b', expand=True).dtypes
+
+String accessor methods returning integers will return a value with :class:`Int64Dtype`
+
+.. ipython:: python
+
+   s.str.count("a")
+
+We recommend explicitly using the ``string`` data type when working with strings.
+See :ref:`text.types` for more.
+
+.. _whatsnew_100.boolean:
+
+Boolean data type with missing values support
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We've added :class:`BooleanDtype` / :class:`~arrays.BooleanArray`, an extension
+type dedicated to boolean data that can hold missing values. The default
+``bool`` data type based on a bool-dtype NumPy array, the column can only hold
+``True`` or ``False``, and not missing values. This new :class:`~arrays.BooleanArray`
+can store missing values as well by keeping track of this in a separate mask.
+(:issue:`29555`, :issue:`30095`, :issue:`31131`)
+
+.. ipython:: python
+
+   pd.Series([True, False, None], dtype=pd.BooleanDtype())
+
+You can use the alias ``"boolean"`` as well.
+
+.. ipython:: python
+
+   s = pd.Series([True, False, None], dtype="boolean")
+   s
+
+.. _whatsnew_100.convert_dtypes:
+
+``convert_dtypes`` method to ease use of supported extension dtypes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In order to encourage use of the extension dtypes ``StringDtype``,
+``BooleanDtype``, ``Int64Dtype``, ``Int32Dtype``, etc., that support ``pd.NA``, the
+methods :meth:`DataFrame.convert_dtypes` and :meth:`Series.convert_dtypes`
+have been introduced. (:issue:`29752`) (:issue:`30929`)
+
+Example:
+
+.. ipython:: python
+
+   df = pd.DataFrame({'x': ['abc', None, 'def'],
+                      'y': [1, 2, np.nan],
+                      'z': [True, False, True]})
+   df
+   df.dtypes
+
+.. ipython:: python
+
+   converted = df.convert_dtypes()
+   converted
+   converted.dtypes
+
+This is especially useful after reading in data using readers such as :func:`read_csv`
+and :func:`read_excel`.
+See :ref:`here <missing_data.NA.conversion>` for a description.
+
+
+.. _whatsnew_100.enhancements.other:
 
 Other enhancements
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 
+- :meth:`DataFrame.to_string` added the ``max_colwidth`` parameter to control when wide columns are truncated (:issue:`9784`)
+- Added the ``na_value`` argument to :meth:`Series.to_numpy`, :meth:`Index.to_numpy` and :meth:`DataFrame.to_numpy` to control the value used for missing data (:issue:`30322`)
+- :meth:`MultiIndex.from_product` infers level names from inputs if not explicitly provided (:issue:`27292`)
 - :meth:`DataFrame.to_latex` now accepts ``caption`` and ``label`` arguments (:issue:`25436`)
-- The :ref:`integer dtype <integer_na>` with support for missing values can now be converted to
-  ``pyarrow`` (>= 0.15.0), which means that it is supported in writing to the Parquet file format
-  when using the ``pyarrow`` engine. It is currently not yet supported when converting back to
-  pandas (so it will become an integer or float dtype depending on the presence of missing data).
-  (:issue:`28368`)
--
-
-.. _whatsnew_1000.api_breaking:
+- DataFrames with :ref:`nullable integer <integer_na>`, the :ref:`new string dtype <text.types>`
+  and period data type can now be converted to ``pyarrow`` (>=0.15.0), which means that it is
+  supported in writing to the Parquet file format when using the ``pyarrow`` engine (:issue:`28368`).
+  Full roundtrip to parquet (writing and reading back in with :meth:`~DataFrame.to_parquet` / :func:`read_parquet`)
+  is supported starting with pyarrow >= 0.16 (:issue:`20612`).
+- :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue:`30270`)
+- :meth:`DataFrame.to_json` now accepts an ``indent`` integer argument to enable pretty printing of JSON output (:issue:`12004`)
+- :meth:`read_stata` can read Stata 119 dta files. (:issue:`28250`)
+- Implemented :meth:`pandas.core.window.Window.var` and :meth:`pandas.core.window.Window.std` functions (:issue:`26597`)
+- Added ``encoding`` argument to :meth:`DataFrame.to_string` for non-ascii text (:issue:`28766`)
+- Added ``encoding`` argument to :func:`DataFrame.to_html` for non-ascii text (:issue:`28663`)
+- :meth:`Styler.background_gradient` now accepts ``vmin`` and ``vmax`` arguments (:issue:`12145`)
+- :meth:`Styler.format` added the ``na_rep`` parameter to help format the missing values (:issue:`21527`, :issue:`28358`)
+- :func:`read_excel` now can read binary Excel (``.xlsb``) files by passing ``engine='pyxlsb'``. For more details and example usage, see the :ref:`Binary Excel files documentation <io.xlsb>`. Closes :issue:`8540`.
+- The ``partition_cols`` argument in :meth:`DataFrame.to_parquet` now accepts a string (:issue:`27117`)
+- :func:`pandas.read_json` now parses ``NaN``, ``Infinity`` and ``-Infinity`` (:issue:`12213`)
+- DataFrame constructor preserve `ExtensionArray` dtype with `ExtensionArray` (:issue:`11363`)
+- :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` have gained ``ignore_index`` keyword to be able to reset index after sorting (:issue:`30114`)
+- :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` have gained ``ignore_index`` keyword to reset index (:issue:`30114`)
+- :meth:`DataFrame.drop_duplicates` has gained ``ignore_index`` keyword to reset index (:issue:`30114`)
+- Added new writer for exporting Stata dta files in versions 118 and 119, ``StataWriterUTF8``.  These files formats support exporting strings containing Unicode characters. Format 119 supports data sets with more than 32,767 variables (:issue:`23573`, :issue:`30959`)
+- :meth:`Series.map` now accepts ``collections.abc.Mapping`` subclasses as a mapper (:issue:`29733`)
+- Added an experimental :attr:`~DataFrame.attrs` for storing global metadata about a dataset (:issue:`29062`)
+- :meth:`Timestamp.fromisocalendar` is now compatible with python 3.8 and above (:issue:`28115`)
+- :meth:`DataFrame.to_pickle` and :func:`read_pickle` now accept URL (:issue:`30163`)
+
+
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_100.api_breaking:
 
 Backwards incompatible API changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-- :class:`pandas.core.groupby.GroupBy.transform` now raises on invalid operation names (:issue:`27489`).
-- :class:`pandas.core.arrays.IntervalArray` adopts a new ``__repr__`` in accordance with other array classes (:issue:`25022`)
+.. _whatsnew_100.api_breaking.MultiIndex._names:
+
+Avoid using names from ``MultiIndex.levels``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As part of a larger refactor to :class:`MultiIndex` the level names are now
+stored separately from the levels (:issue:`27242`). We recommend using
+:attr:`MultiIndex.names` to access the names, and :meth:`Index.set_names`
+to update the names.
+
+For backwards compatibility, you can still *access* the names via the levels.
+
+.. ipython:: python
+
+   mi = pd.MultiIndex.from_product([[1, 2], ['a', 'b']], names=['x', 'y'])
+   mi.levels[0].name
+
+However, it is no longer possible to *update* the names of the ``MultiIndex``
+via the level.
+
+.. ipython:: python
+   :okexcept:
+
+   mi.levels[0].name = "new name"
+   mi.names
+
+To update, use ``MultiIndex.set_names``, which returns a new ``MultiIndex``.
+
+.. ipython:: python
+
+   mi2 = mi.set_names("new name", level=0)
+   mi2.names
+
+New repr for :class:`~pandas.arrays.IntervalArray`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:class:`pandas.arrays.IntervalArray` adopts a new ``__repr__`` in accordance with other array classes (:issue:`25022`)
 
 *pandas 0.25.x*
 
@@ -53,54 +317,707 @@ Backwards incompatible API changes
                  closed='right',
                  dtype='interval[int64]')
 
-
 *pandas 1.0.0*
 
 .. ipython:: python
 
    pd.arrays.IntervalArray.from_tuples([(0, 1), (2, 3)])
 
+``DataFrame.rename`` now only accepts one positional argument
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`DataFrame.rename` would previously accept positional arguments that would lead
+to ambiguous or undefined behavior. From pandas 1.0, only the very first argument, which
+maps labels to their new names along the default axis, is allowed to be passed by position
+(:issue:`29136`).
+
+.. ipython:: python
+   :suppress:
+
+   df = pd.DataFrame([[1]])
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> df = pd.DataFrame([[1]])
+   >>> df.rename({0: 1}, {0: 2})
+   FutureWarning: ...Use named arguments to resolve ambiguity...
+      2
+   1  1
+
+*pandas 1.0.0*
+
+.. code-block:: python
+
+   >>> df.rename({0: 1}, {0: 2})
+   Traceback (most recent call last):
+   ...
+   TypeError: rename() takes from 1 to 2 positional arguments but 3 were given
+
+Note that errors will now be raised when conflicting or potentially ambiguous arguments are provided.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> df.rename({0: 1}, index={0: 2})
+      0
+   1  1
+
+   >>> df.rename(mapper={0: 1}, index={0: 2})
+      0
+   2  1
+
+*pandas 1.0.0*
+
+.. code-block:: python
+
+   >>> df.rename({0: 1}, index={0: 2})
+   Traceback (most recent call last):
+   ...
+   TypeError: Cannot specify both 'mapper' and any of 'index' or 'columns'
+
+   >>> df.rename(mapper={0: 1}, index={0: 2})
+   Traceback (most recent call last):
+   ...
+   TypeError: Cannot specify both 'mapper' and any of 'index' or 'columns'
+
+You can still change the axis along which the first positional argument is applied by
+supplying the ``axis`` keyword argument.
+
+.. ipython:: python
+
+   df.rename({0: 1})
+   df.rename({0: 1}, axis=1)
+
+If you would like to update both the index and column labels, be sure to use the respective
+keywords.
+
+.. ipython:: python
+
+   df.rename(index={0: 1}, columns={0: 2})
+
+Extended verbose info output for :class:`~pandas.DataFrame`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`DataFrame.info` now shows line numbers for the columns summary (:issue:`17304`)
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> df = pd.DataFrame({"int_col": [1, 2, 3],
+   ...                    "text_col": ["a", "b", "c"],
+   ...                    "float_col": [0.0, 0.1, 0.2]})
+   >>> df.info(verbose=True)
+   <class 'pandas.core.frame.DataFrame'>
+   RangeIndex: 3 entries, 0 to 2
+   Data columns (total 3 columns):
+   int_col      3 non-null int64
+   text_col     3 non-null object
+   float_col    3 non-null float64
+   dtypes: float64(1), int64(1), object(1)
+   memory usage: 152.0+ bytes
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   df = pd.DataFrame({"int_col": [1, 2, 3],
+                      "text_col": ["a", "b", "c"],
+                      "float_col": [0.0, 0.1, 0.2]})
+   df.info(verbose=True)
+
+:meth:`pandas.array` inference changes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`pandas.array` now infers pandas' new extension types in several cases (:issue:`29791`):
+
+1. String data (including missing values) now returns a :class:`arrays.StringArray`.
+2. Integer data (including missing values) now returns a :class:`arrays.IntegerArray`.
+3. Boolean data (including missing values) now returns the new :class:`arrays.BooleanArray`
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> pd.array(["a", None])
+   <PandasArray>
+   ['a', None]
+   Length: 2, dtype: object
+
+   >>> pd.array([1, None])
+   <PandasArray>
+   [1, None]
+   Length: 2, dtype: object
+
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   pd.array(["a", None])
+   pd.array([1, None])
 
-.. _whatsnew_1000.api.other:
+As a reminder, you can specify the ``dtype`` to disable all inference.
+
+:class:`arrays.IntegerArray` now uses :attr:`pandas.NA`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:class:`arrays.IntegerArray` now uses :attr:`pandas.NA` rather than
+:attr:`numpy.nan` as its missing value marker (:issue:`29964`).
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> a = pd.array([1, 2, None], dtype="Int64")
+   >>> a
+   <IntegerArray>
+   [1, 2, NaN]
+   Length: 3, dtype: Int64
+
+   >>> a[2]
+   nan
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   a = pd.array([1, 2, None], dtype="Int64")
+   a
+   a[2]
+
+This has a few API-breaking consequences.
+
+**Converting to a NumPy ndarray**
+
+When converting to a NumPy array missing values will be ``pd.NA``, which cannot
+be converted to a float. So calling ``np.asarray(integer_array, dtype="float")``
+will now raise.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+    >>> np.asarray(a, dtype="float")
+    array([ 1.,  2., nan])
+
+*pandas 1.0.0*
+
+.. ipython:: python
+   :okexcept:
+
+   np.asarray(a, dtype="float")
+
+Use :meth:`arrays.IntegerArray.to_numpy` with an explicit ``na_value`` instead.
+
+.. ipython:: python
+
+   a.to_numpy(dtype="float", na_value=np.nan)
+
+**Reductions can return ``pd.NA``**
+
+When performing a reduction such as a sum with ``skipna=False``, the result
+will now be ``pd.NA`` instead of ``np.nan`` in presence of missing values
+(:issue:`30958`).
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+    >>> pd.Series(a).sum(skipna=False)
+    nan
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   pd.Series(a).sum(skipna=False)
+
+**value_counts returns a nullable integer dtype**
+
+:meth:`Series.value_counts` with a nullable integer dtype now returns a nullable
+integer dtype for the values.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> pd.Series([2, 1, 1, None], dtype="Int64").value_counts().dtype
+   dtype('int64')
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   pd.Series([2, 1, 1, None], dtype="Int64").value_counts().dtype
+
+See :ref:`missing_data.NA` for more on the differences between :attr:`pandas.NA`
+and :attr:`numpy.nan`.
+
+:class:`arrays.IntegerArray` comparisons return :class:`arrays.BooleanArray`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Comparison operations on a :class:`arrays.IntegerArray` now returns a
+:class:`arrays.BooleanArray` rather than a NumPy array (:issue:`29964`).
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> a = pd.array([1, 2, None], dtype="Int64")
+   >>> a
+   <IntegerArray>
+   [1, 2, NaN]
+   Length: 3, dtype: Int64
+
+   >>> a > 1
+   array([False,  True, False])
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   a = pd.array([1, 2, None], dtype="Int64")
+   a > 1
+
+Note that missing values now propagate, rather than always comparing unequal
+like :attr:`numpy.nan`. See :ref:`missing_data.NA` for more.
+
+By default :meth:`Categorical.min` now returns the minimum instead of np.nan
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When :class:`Categorical` contains ``np.nan``,
+:meth:`Categorical.min` no longer return ``np.nan`` by default (skipna=True) (:issue:`25303`)
+
+*pandas 0.25.x*
+
+.. code-block:: ipython
+
+   In [1]: pd.Categorical([1, 2, np.nan], ordered=True).min()
+   Out[1]: nan
+
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   pd.Categorical([1, 2, np.nan], ordered=True).min()
+
+
+Default dtype of empty :class:`pandas.Series`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Initialising an empty :class:`pandas.Series` without specifying a dtype will raise a `DeprecationWarning` now
+(:issue:`17261`). The default dtype will change from ``float64`` to ``object`` in future releases so that it is
+consistent with the behaviour of :class:`DataFrame` and :class:`Index`.
+
+*pandas 1.0.0*
+
+.. code-block:: ipython
+
+   In [1]: pd.Series()
+   Out[2]:
+   DeprecationWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.
+   Series([], dtype: float64)
+
+Result dtype inference changes for resample operations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The rules for the result dtype in :meth:`DataFrame.resample` aggregations have changed for extension types (:issue:`31359`).
+Previously, pandas would attempt to convert the result back to the original dtype, falling back to the usual
+inference rules if that was not possible. Now, pandas will only return a result of the original dtype if the
+scalar values in the result are instances of the extension dtype's scalar type.
+
+.. ipython:: python
+
+   df = pd.DataFrame({"A": ['a', 'b']}, dtype='category',
+                     index=pd.date_range('2000', periods=2))
+   df
+
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> df.resample("2D").agg(lambda x: 'a').A.dtype
+   CategoricalDtype(categories=['a', 'b'], ordered=False)
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   df.resample("2D").agg(lambda x: 'a').A.dtype
+
+This fixes an inconsistency between ``resample`` and ``groupby``.
+This also fixes a potential bug, where the **values** of the result might change
+depending on how the results are cast back to the original dtype.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+   >>> df.resample("2D").agg(lambda x: 'c')
+
+        A
+   0  NaN
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+   df.resample("2D").agg(lambda x: 'c')
+
+
+.. _whatsnew_100.api_breaking.python:
+
+Increased minimum version for Python
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Pandas 1.0.0 supports Python 3.6.1 and higher (:issue:`29212`).
+
+.. _whatsnew_100.api_breaking.deps:
+
+Increased minimum versions for dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Some minimum supported versions of dependencies were updated (:issue:`29766`, :issue:`29723`).
+If installed, we now require:
+
++-----------------+-----------------+----------+---------+
+| Package         | Minimum Version | Required | Changed |
++=================+=================+==========+=========+
+| numpy           | 1.13.3          |    X     |         |
++-----------------+-----------------+----------+---------+
+| pytz            | 2015.4          |    X     |         |
++-----------------+-----------------+----------+---------+
+| python-dateutil | 2.6.1           |    X     |         |
++-----------------+-----------------+----------+---------+
+| bottleneck      | 1.2.1           |          |         |
++-----------------+-----------------+----------+---------+
+| numexpr         | 2.6.2           |          |         |
++-----------------+-----------------+----------+---------+
+| pytest (dev)    | 4.0.2           |          |         |
++-----------------+-----------------+----------+---------+
+
+For `optional libraries <https://dev.pandas.io/docs/install.html#dependencies>`_ the general recommendation is to use the latest version.
+The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
+Optional libraries below the lowest tested version may still work, but are not considered supported.
+
++-----------------+-----------------+---------+
+| Package         | Minimum Version | Changed |
++=================+=================+=========+
+| beautifulsoup4  | 4.6.0           |         |
++-----------------+-----------------+---------+
+| fastparquet     | 0.3.2           |    X    |
++-----------------+-----------------+---------+
+| gcsfs           | 0.2.2           |         |
++-----------------+-----------------+---------+
+| lxml            | 3.8.0           |         |
++-----------------+-----------------+---------+
+| matplotlib      | 2.2.2           |         |
++-----------------+-----------------+---------+
+| numba           | 0.46.0          |    X    |
++-----------------+-----------------+---------+
+| openpyxl        | 2.5.7           |    X    |
++-----------------+-----------------+---------+
+| pyarrow         | 0.13.0          |    X    |
++-----------------+-----------------+---------+
+| pymysql         | 0.7.1           |         |
++-----------------+-----------------+---------+
+| pytables        | 3.4.2           |         |
++-----------------+-----------------+---------+
+| s3fs            | 0.3.0           |    X    |
++-----------------+-----------------+---------+
+| scipy           | 0.19.0          |         |
++-----------------+-----------------+---------+
+| sqlalchemy      | 1.1.4           |         |
++-----------------+-----------------+---------+
+| xarray          | 0.8.2           |         |
++-----------------+-----------------+---------+
+| xlrd            | 1.1.0           |         |
++-----------------+-----------------+---------+
+| xlsxwriter      | 0.9.8           |         |
++-----------------+-----------------+---------+
+| xlwt            | 1.2.0           |         |
++-----------------+-----------------+---------+
+
+See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
+
+Build Changes
+^^^^^^^^^^^^^
+
+Pandas has added a `pyproject.toml <https://www.python.org/dev/peps/pep-0517/>`_ file and will no longer include
+cythonized files in the source distribution uploaded to PyPI (:issue:`28341`, :issue:`20775`). If you're installing
+a built distribution (wheel) or via conda, this shouldn't have any effect on you. If you're building pandas from
+source, you should no longer need to install Cython into your build environment before calling ``pip install pandas``.
+
+
+.. _whatsnew_100.api.other:
 
 Other API changes
 ^^^^^^^^^^^^^^^^^
 
+- :class:`core.groupby.GroupBy.transform` now raises on invalid operation names (:issue:`27489`)
 - :meth:`pandas.api.types.infer_dtype` will now return "integer-na" for integer and ``np.nan`` mix (:issue:`27283`)
--
--
+- :meth:`MultiIndex.from_arrays` will no longer infer names from arrays if ``names=None`` is explicitly provided (:issue:`27292`)
+- In order to improve tab-completion, Pandas does not include most deprecated attributes when introspecting a pandas object using ``dir`` (e.g. ``dir(df)``).
+  To see which attributes are excluded, see an object's ``_deprecations`` attribute, for example ``pd.DataFrame._deprecations`` (:issue:`28805`).
+- The returned dtype of :func:`unique` now matches the input dtype. (:issue:`27874`)
+- Changed the default configuration value for ``options.matplotlib.register_converters`` from ``True`` to ``"auto"`` (:issue:`18720`).
+  Now, pandas custom formatters will only be applied to plots created by pandas, through :meth:`~DataFrame.plot`.
+  Previously, pandas' formatters would be applied to all plots created *after* a :meth:`~DataFrame.plot`.
+  See :ref:`units registration <whatsnew_100.matplotlib_units>` for more.
+- :meth:`Series.dropna` has dropped its ``**kwargs`` argument in favor of a single ``how`` parameter.
+  Supplying anything else than ``how`` to ``**kwargs`` raised a ``TypeError`` previously (:issue:`29388`)
+- When testing pandas, the new minimum required version of pytest is 5.0.1 (:issue:`29664`)
+- :meth:`Series.str.__iter__` was deprecated and will be removed in future releases (:issue:`28277`).
+- Added ``<NA>`` to the list of default NA values for :meth:`read_csv` (:issue:`30821`)
+
+.. _whatsnew_100.api.documentation:
+
+Documentation Improvements
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- Added new section on :ref:`scale` (:issue:`28315`).
+- Added sub-section on :ref:`io.query_multi` for HDF5 datasets (:issue:`28791`).
+
+.. ---------------------------------------------------------------------------
 
-.. _whatsnew_1000.deprecations:
+.. _whatsnew_100.deprecations:
 
 Deprecations
 ~~~~~~~~~~~~
 
--
--
+- :meth:`Series.item` and :meth:`Index.item` have been _undeprecated_ (:issue:`29250`)
+- ``Index.set_value`` has been deprecated. For a given index ``idx``, array ``arr``,
+  value in ``idx`` of ``idx_val`` and a new value of ``val``, ``idx.set_value(arr, idx_val, val)``
+  is equivalent to ``arr[idx.get_loc(idx_val)] = val``, which should be used instead (:issue:`28621`).
+- :func:`is_extension_type` is deprecated, :func:`is_extension_array_dtype` should be used instead (:issue:`29457`)
+- :func:`eval` keyword argument "truediv" is deprecated and will be removed in a future version (:issue:`29812`)
+- :meth:`DateOffset.isAnchored` and :meth:`DatetOffset.onOffset` are deprecated and will be removed in a future version, use :meth:`DateOffset.is_anchored` and :meth:`DateOffset.is_on_offset` instead (:issue:`30340`)
+- ``pandas.tseries.frequencies.get_offset`` is deprecated and will be removed in a future version, use ``pandas.tseries.frequencies.to_offset`` instead (:issue:`4205`)
+- :meth:`Categorical.take_nd` and :meth:`CategoricalIndex.take_nd` are deprecated, use :meth:`Categorical.take` and :meth:`CategoricalIndex.take` instead (:issue:`27745`)
+- The parameter ``numeric_only`` of :meth:`Categorical.min` and :meth:`Categorical.max` is deprecated and replaced with ``skipna`` (:issue:`25303`)
+- The parameter ``label`` in :func:`lreshape` has been deprecated and will be removed in a future version (:issue:`29742`)
+- ``pandas.core.index`` has been deprecated and will be removed in a future version, the public classes are available in the top-level namespace (:issue:`19711`)
+- :func:`pandas.json_normalize` is now exposed in the top-level namespace.
+  Usage of ``json_normalize`` as ``pandas.io.json.json_normalize`` is now deprecated and
+  it is recommended to use ``json_normalize`` as :func:`pandas.json_normalize` instead (:issue:`27586`).
+- The ``numpy`` argument of :meth:`pandas.read_json` is deprecated (:issue:`28512`).
+- :meth:`DataFrame.to_stata`, :meth:`DataFrame.to_feather`, and :meth:`DataFrame.to_parquet` argument "fname" is deprecated, use "path" instead (:issue:`23574`)
+- The deprecated internal attributes ``_start``, ``_stop`` and ``_step`` of :class:`RangeIndex` now raise a ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`26581`)
+- The ``pandas.util.testing`` module has been deprecated. Use the public API in ``pandas.testing`` documented at :ref:`api.general.testing` (:issue:`16232`).
+- ``pandas.SparseArray`` has been deprecated.  Use ``pandas.arrays.SparseArray`` (:class:`arrays.SparseArray`) instead. (:issue:`30642`)
+- The parameter ``is_copy`` of :meth:`Series.take` and :meth:`DataFrame.take` has been deprecated and will be removed in a future version. (:issue:`27357`)
+- Support for multi-dimensional indexing (e.g. ``index[:, None]``) on a :class:`Index` is deprecated and will be removed in a future version, convert to a numpy array before indexing instead (:issue:`30588`)
+- The ``pandas.np`` submodule is now deprecated. Import numpy directly instead (:issue:`30296`)
+- The ``pandas.datetime`` class is now deprecated. Import from ``datetime`` instead (:issue:`30610`)
+- :class:`~DataFrame.diff` will raise a ``TypeError`` rather than implicitly losing the dtype of extension types in the future. Convert to the correct dtype before calling ``diff`` instead (:issue:`31025`)
+
+**Selecting Columns from a Grouped DataFrame**
+
+When selecting columns from a :class:`DataFrameGroupBy` object, passing individual keys (or a tuple of keys) inside single brackets is deprecated,
+a list of items should be used instead. (:issue:`23566`) For example:
+
+.. code-block:: ipython
+
+    df = pd.DataFrame({
+        "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
+        "B": np.random.randn(8),
+        "C": np.random.randn(8),
+    })
+    g = df.groupby('A')
+
+    # single key, returns SeriesGroupBy
+    g['B']
+
+    # tuple of single key, returns SeriesGroupBy
+    g[('B',)]
+
+    # tuple of multiple keys, returns DataFrameGroupBy, raises FutureWarning
+    g[('B', 'C')]
+
+    # multiple keys passed directly, returns DataFrameGroupBy, raises FutureWarning
+    # (implicitly converts the passed strings into a single tuple)
+    g['B', 'C']
+
+    # proper way, returns DataFrameGroupBy
+    g[['B', 'C']]
+
+.. ---------------------------------------------------------------------------
 
-.. _whatsnew_1000.prior_deprecations:
+.. _whatsnew_100.prior_deprecations:
 
 Removal of prior version deprecations/changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Removed the previously deprecated :meth:`Series.get_value`, :meth:`Series.set_value`, :meth:`DataFrame.get_value`, :meth:`DataFrame.set_value` (:issue:`17739`)
-- Changed the the default value of `inplace` in :meth:`DataFrame.set_index` and :meth:`Series.set_axis`. It now defaults to False (:issue:`27600`)
+
+**Removed SparseSeries and SparseDataFrame**
+
+``SparseSeries``, ``SparseDataFrame`` and the ``DataFrame.to_sparse`` method
+have been removed (:issue:`28425`). We recommend using a ``Series`` or
+``DataFrame`` with sparse values instead. See :ref:`sparse.migration` for help
+with migrating existing code.
+
+.. _whatsnew_100.matplotlib_units:
+
+**Matplotlib unit registration**
+
+Previously, pandas would register converters with matplotlib as a side effect of importing pandas (:issue:`18720`).
+This changed the output of plots made via matplotlib plots after pandas was imported, even if you were using
+matplotlib directly rather than :meth:`~DataFrame.plot`.
+
+To use pandas formatters with a matplotlib plot, specify
+
+.. code-block:: python
+
+   >>> import pandas as pd
+   >>> pd.options.plotting.matplotlib.register_converters = True
+
+Note that plots created by :meth:`DataFrame.plot` and :meth:`Series.plot` *do* register the converters
+automatically. The only behavior change is when plotting a date-like object via ``matplotlib.pyplot.plot``
+or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
+
+**Other removals**
+
+- Removed the previously deprecated keyword "index" from :func:`read_stata`, :class:`StataReader`, and :meth:`StataReader.read`, use "index_col" instead (:issue:`17328`)
+- Removed ``StataReader.data`` method, use :meth:`StataReader.read` instead (:issue:`9493`)
+- Removed ``pandas.plotting._matplotlib.tsplot``, use :meth:`Series.plot` instead (:issue:`19980`)
+- ``pandas.tseries.converter.register`` has been moved to :func:`pandas.plotting.register_matplotlib_converters` (:issue:`18307`)
+- :meth:`Series.plot` no longer accepts positional arguments, pass keyword arguments instead (:issue:`30003`)
+- :meth:`DataFrame.hist` and :meth:`Series.hist` no longer allows ``figsize="default"``, specify figure size by passinig a tuple instead (:issue:`30003`)
+- Floordiv of integer-dtyped array by :class:`Timedelta` now raises ``TypeError`` (:issue:`21036`)
+- :class:`TimedeltaIndex` and :class:`DatetimeIndex` no longer accept non-nanosecond dtype strings like "timedelta64" or "datetime64", use "timedelta64[ns]" and "datetime64[ns]" instead (:issue:`24806`)
+- Changed the default "skipna" argument in :func:`pandas.api.types.infer_dtype` from ``False`` to ``True`` (:issue:`24050`)
+- Removed ``Series.ix`` and ``DataFrame.ix`` (:issue:`26438`)
+- Removed ``Index.summary`` (:issue:`18217`)
+- Removed the previously deprecated keyword "fastpath" from the :class:`Index` constructor (:issue:`23110`)
+- Removed ``Series.get_value``, ``Series.set_value``, ``DataFrame.get_value``, ``DataFrame.set_value`` (:issue:`17739`)
+- Removed ``Series.compound`` and ``DataFrame.compound`` (:issue:`26405`)
+- Changed the default "inplace" argument in :meth:`DataFrame.set_index` and :meth:`Series.set_axis` from ``None`` to ``False`` (:issue:`27600`)
+- Removed ``Series.cat.categorical``, ``Series.cat.index``, ``Series.cat.name`` (:issue:`24751`)
+- Removed the previously deprecated keyword "box" from :func:`to_datetime` and :func:`to_timedelta`; in addition these now always returns :class:`DatetimeIndex`, :class:`TimedeltaIndex`, :class:`Index`, :class:`Series`, or :class:`DataFrame` (:issue:`24486`)
+- :func:`to_timedelta`, :class:`Timedelta`, and :class:`TimedeltaIndex` no longer allow "M", "y", or "Y" for the "unit" argument (:issue:`23264`)
+- Removed the previously deprecated keyword "time_rule" from (non-public) ``offsets.generate_range``, which has been moved to :func:`core.arrays._ranges.generate_range` (:issue:`24157`)
+- :meth:`DataFrame.loc` or :meth:`Series.loc` with listlike indexers and missing labels will no longer reindex (:issue:`17295`)
+- :meth:`DataFrame.to_excel` and :meth:`Series.to_excel` with non-existent columns will no longer reindex (:issue:`17295`)
+- Removed the previously deprecated keyword "join_axes" from :func:`concat`; use ``reindex_like`` on the result instead (:issue:`22318`)
+- Removed the previously deprecated keyword "by" from :meth:`DataFrame.sort_index`, use :meth:`DataFrame.sort_values` instead (:issue:`10726`)
+- Removed support for nested renaming in :meth:`DataFrame.aggregate`, :meth:`Series.aggregate`, :meth:`core.groupby.DataFrameGroupBy.aggregate`, :meth:`core.groupby.SeriesGroupBy.aggregate`, :meth:`core.window.rolling.Rolling.aggregate` (:issue:`18529`)
+- Passing ``datetime64`` data to :class:`TimedeltaIndex` or ``timedelta64`` data to ``DatetimeIndex`` now raises ``TypeError`` (:issue:`23539`, :issue:`23937`)
+- Passing ``int64`` values to :class:`DatetimeIndex` and a timezone now interprets the values as nanosecond timestamps in UTC, not wall times in the given timezone (:issue:`24559`)
+- A tuple passed to :meth:`DataFrame.groupby` is now exclusively treated as a single key (:issue:`18314`)
+- Removed ``Index.contains``, use ``key in index`` instead (:issue:`30103`)
+- Addition and subtraction of ``int`` or integer-arrays is no longer allowed in :class:`Timestamp`, :class:`DatetimeIndex`, :class:`TimedeltaIndex`, use ``obj + n * obj.freq`` instead of ``obj + n`` (:issue:`22535`)
+- Removed ``Series.ptp`` (:issue:`21614`)
+- Removed ``Series.from_array`` (:issue:`18258`)
+- Removed ``DataFrame.from_items`` (:issue:`18458`)
+- Removed ``DataFrame.as_matrix``, ``Series.as_matrix`` (:issue:`18458`)
+- Removed ``Series.asobject`` (:issue:`18477`)
+- Removed ``DataFrame.as_blocks``, ``Series.as_blocks``, ``DataFrame.blocks``, ``Series.blocks`` (:issue:`17656`)
 - :meth:`pandas.Series.str.cat` now defaults to aligning ``others``, using ``join='left'`` (:issue:`27611`)
 - :meth:`pandas.Series.str.cat` does not accept list-likes *within* list-likes anymore (:issue:`27611`)
-- Removed the previously deprecated :meth:`ExtensionArray._formatting_values`. Use :attr:`ExtensionArray._formatter` instead. (:issue:`23601`)
-- Removed the previously deprecated ``IntervalIndex.from_intervals`` in favor of the :class:`IntervalIndex` constructor (:issue:`19263`)
+- :meth:`Series.where` with ``Categorical`` dtype (or :meth:`DataFrame.where` with ``Categorical`` column) no longer allows setting new categories (:issue:`24114`)
+- Removed the previously deprecated keywords "start", "end", and "periods" from the :class:`DatetimeIndex`, :class:`TimedeltaIndex`, and :class:`PeriodIndex` constructors; use :func:`date_range`, :func:`timedelta_range`, and :func:`period_range` instead (:issue:`23919`)
+- Removed the previously deprecated keyword "verify_integrity" from the :class:`DatetimeIndex` and :class:`TimedeltaIndex` constructors (:issue:`23919`)
+- Removed the previously deprecated keyword "fastpath" from ``pandas.core.internals.blocks.make_block`` (:issue:`19265`)
+- Removed the previously deprecated keyword "dtype" from :meth:`Block.make_block_same_class` (:issue:`19434`)
+- Removed ``ExtensionArray._formatting_values``. Use :attr:`ExtensionArray._formatter` instead. (:issue:`23601`)
+- Removed ``MultiIndex.to_hierarchical`` (:issue:`21613`)
+- Removed ``MultiIndex.labels``, use :attr:`MultiIndex.codes` instead (:issue:`23752`)
+- Removed the previously deprecated keyword "labels" from the :class:`MultiIndex` constructor, use "codes" instead (:issue:`23752`)
+- Removed ``MultiIndex.set_labels``, use :meth:`MultiIndex.set_codes` instead (:issue:`23752`)
+- Removed the previously deprecated keyword "labels" from :meth:`MultiIndex.set_codes`, :meth:`MultiIndex.copy`, :meth:`MultiIndex.drop`, use "codes" instead (:issue:`23752`)
+- Removed support for legacy HDF5 formats (:issue:`29787`)
+- Passing a dtype alias (e.g. 'datetime64[ns, UTC]') to :class:`DatetimeTZDtype` is no longer allowed, use :meth:`DatetimeTZDtype.construct_from_string` instead (:issue:`23990`)
+- Removed the previously deprecated keyword "skip_footer" from :func:`read_excel`; use "skipfooter" instead (:issue:`18836`)
+- :func:`read_excel` no longer allows an integer value for the parameter ``usecols``, instead pass a list of integers from 0 to ``usecols`` inclusive (:issue:`23635`)
+- Removed the previously deprecated keyword "convert_datetime64" from :meth:`DataFrame.to_records` (:issue:`18902`)
+- Removed ``IntervalIndex.from_intervals`` in favor of the :class:`IntervalIndex` constructor (:issue:`19263`)
+- Changed the default "keep_tz" argument in :meth:`DatetimeIndex.to_series` from ``None`` to ``True`` (:issue:`23739`)
+- Removed ``api.types.is_period`` and ``api.types.is_datetimetz`` (:issue:`23917`)
+- Ability to read pickles containing :class:`Categorical` instances created with pre-0.16 version of pandas has been removed (:issue:`27538`)
+- Removed ``pandas.tseries.plotting.tsplot`` (:issue:`18627`)
+- Removed the previously deprecated keywords "reduce" and "broadcast" from :meth:`DataFrame.apply` (:issue:`18577`)
+- Removed the previously deprecated ``assert_raises_regex`` function in ``pandas._testing`` (:issue:`29174`)
+- Removed the previously deprecated ``FrozenNDArray`` class in ``pandas.core.indexes.frozen`` (:issue:`29335`)
+- Removed the previously deprecated keyword "nthreads" from :func:`read_feather`, use "use_threads" instead (:issue:`23053`)
+- Removed ``Index.is_lexsorted_for_tuple`` (:issue:`29305`)
+- Removed support for nested renaming in :meth:`DataFrame.aggregate`, :meth:`Series.aggregate`, :meth:`core.groupby.DataFrameGroupBy.aggregate`, :meth:`core.groupby.SeriesGroupBy.aggregate`, :meth:`core.window.rolling.Rolling.aggregate` (:issue:`29608`)
+- Removed ``Series.valid``; use :meth:`Series.dropna` instead (:issue:`18800`)
+- Removed ``DataFrame.is_copy``, ``Series.is_copy`` (:issue:`18812`)
+- Removed ``DataFrame.get_ftype_counts``, ``Series.get_ftype_counts`` (:issue:`18243`)
+- Removed ``DataFrame.ftypes``, ``Series.ftypes``, ``Series.ftype`` (:issue:`26744`)
+- Removed ``Index.get_duplicates``, use ``idx[idx.duplicated()].unique()`` instead (:issue:`20239`)
+- Removed ``Series.clip_upper``, ``Series.clip_lower``, ``DataFrame.clip_upper``, ``DataFrame.clip_lower`` (:issue:`24203`)
+- Removed the ability to alter :attr:`DatetimeIndex.freq`, :attr:`TimedeltaIndex.freq`, or :attr:`PeriodIndex.freq` (:issue:`20772`)
+- Removed ``DatetimeIndex.offset`` (:issue:`20730`)
+- Removed ``DatetimeIndex.asobject``, ``TimedeltaIndex.asobject``, ``PeriodIndex.asobject``, use ``astype(object)`` instead (:issue:`29801`)
+- Removed the previously deprecated keyword "order" from :func:`factorize` (:issue:`19751`)
+- Removed the previously deprecated keyword "encoding" from :func:`read_stata` and :meth:`DataFrame.to_stata` (:issue:`21400`)
+- Changed the default "sort" argument in :func:`concat` from ``None`` to ``False`` (:issue:`20613`)
+- Removed the previously deprecated keyword "raise_conflict" from :meth:`DataFrame.update`, use "errors" instead (:issue:`23585`)
+- Removed the previously deprecated keyword "n" from :meth:`DatetimeIndex.shift`, :meth:`TimedeltaIndex.shift`, :meth:`PeriodIndex.shift`, use "periods" instead (:issue:`22458`)
+- Removed the previously deprecated keywords "how", "fill_method", and "limit" from :meth:`DataFrame.resample` (:issue:`30139`)
+- Passing an integer to :meth:`Series.fillna` or :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtype now raises ``TypeError`` (:issue:`24694`)
+- Passing multiple axes to :meth:`DataFrame.dropna` is no longer supported (:issue:`20995`)
+- Removed ``Series.nonzero``, use ``to_numpy().nonzero()`` instead (:issue:`24048`)
+- Passing floating dtype ``codes`` to :meth:`Categorical.from_codes` is no longer supported, pass ``codes.astype(np.int64)`` instead (:issue:`21775`)
+- Removed the previously deprecated keyword "pat" from :meth:`Series.str.partition` and :meth:`Series.str.rpartition`, use "sep" instead (:issue:`23767`)
+- Removed ``Series.put`` (:issue:`27106`)
+- Removed ``Series.real``, ``Series.imag`` (:issue:`27106`)
+- Removed ``Series.to_dense``, ``DataFrame.to_dense`` (:issue:`26684`)
+- Removed ``Index.dtype_str``, use ``str(index.dtype)`` instead (:issue:`27106`)
+- :meth:`Categorical.ravel` returns a :class:`Categorical` instead of a ``ndarray`` (:issue:`27199`)
+- The 'outer' method on Numpy ufuncs, e.g. ``np.subtract.outer`` operating on :class:`Series` objects is no longer supported, and will raise ``NotImplementedError`` (:issue:`27198`)
+- Removed ``Series.get_dtype_counts`` and ``DataFrame.get_dtype_counts`` (:issue:`27145`)
+- Changed the default "fill_value" argument in :meth:`Categorical.take` from ``True`` to ``False`` (:issue:`20841`)
+- Changed the default value for the `raw` argument in :func:`Series.rolling().apply() <pandas.core.window.Rolling.apply>`, :func:`DataFrame.rolling().apply() <pandas.core.window.Rolling.apply>`, :func:`Series.expanding().apply() <pandas.core.window.Expanding.apply>`, and :func:`DataFrame.expanding().apply() <pandas.core.window.Expanding.apply>` from ``None`` to ``False`` (:issue:`20584`)
+- Removed deprecated behavior of :meth:`Series.argmin` and :meth:`Series.argmax`, use :meth:`Series.idxmin` and :meth:`Series.idxmax` for the old behavior (:issue:`16955`)
+- Passing a tz-aware ``datetime.datetime`` or :class:`Timestamp` into the :class:`Timestamp` constructor with the ``tz`` argument now raises a ``ValueError`` (:issue:`23621`)
+- Removed ``Series.base``, ``Index.base``, ``Categorical.base``, ``Series.flags``, ``Index.flags``, ``PeriodArray.flags``, ``Series.strides``, ``Index.strides``, ``Series.itemsize``, ``Index.itemsize``, ``Series.data``, ``Index.data`` (:issue:`20721`)
+- Changed :meth:`Timedelta.resolution` to match the behavior of the standard library ``datetime.timedelta.resolution``, for the old behavior, use :meth:`Timedelta.resolution_string` (:issue:`26839`)
+- Removed ``Timestamp.weekday_name``, ``DatetimeIndex.weekday_name``, and ``Series.dt.weekday_name`` (:issue:`18164`)
+- Removed the previously deprecated keyword "errors" in :meth:`Timestamp.tz_localize`, :meth:`DatetimeIndex.tz_localize`, and :meth:`Series.tz_localize` (:issue:`22644`)
+- Changed the default "ordered" argument in :class:`CategoricalDtype` from ``None`` to ``False`` (:issue:`26336`)
+- :meth:`Series.set_axis` and :meth:`DataFrame.set_axis` now require "labels" as the first argument and "axis" as an optional named parameter (:issue:`30089`)
+- Removed ``to_msgpack``, ``read_msgpack``, ``DataFrame.to_msgpack``, ``Series.to_msgpack`` (:issue:`27103`)
+- Removed ``Series.compress`` (:issue:`21930`)
+- Removed the previously deprecated keyword "fill_value" from :meth:`Categorical.fillna`, use "value" instead (:issue:`19269`)
+- Removed the previously deprecated keyword "data" from :func:`andrews_curves`, use "frame" instead (:issue:`6956`)
+- Removed the previously deprecated keyword "data" from :func:`parallel_coordinates`, use "frame" instead (:issue:`6956`)
+- Removed the previously deprecated keyword "colors" from :func:`parallel_coordinates`, use "color" instead (:issue:`6956`)
+- Removed the previously deprecated keywords "verbose" and "private_key" from :func:`read_gbq` (:issue:`30200`)
+- Calling ``np.array`` and ``np.asarray`` on tz-aware :class:`Series` and :class:`DatetimeIndex` will now return an object array of tz-aware :class:`Timestamp` (:issue:`24596`)
+-
+
+.. ---------------------------------------------------------------------------
 
-.. _whatsnew_1000.performance:
+.. _whatsnew_100.performance:
 
 Performance improvements
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
+- Performance improvement in :class:`DataFrame` arithmetic and comparison operations with scalars (:issue:`24990`, :issue:`29853`)
 - Performance improvement in indexing with a non-unique :class:`IntervalIndex` (:issue:`27489`)
-- Performance improvement in `MultiIndex.is_monotonic` (:issue:`27495`)
+- Performance improvement in :attr:`MultiIndex.is_monotonic` (:issue:`27495`)
 - Performance improvement in :func:`cut` when ``bins`` is an :class:`IntervalIndex` (:issue:`27668`)
+- Performance improvement when initializing a :class:`DataFrame` using a ``range`` (:issue:`30171`)
 - Performance improvement in :meth:`DataFrame.corr` when ``method`` is ``"spearman"`` (:issue:`28139`)
 - Performance improvement in :meth:`DataFrame.replace` when provided a list of values to replace (:issue:`28099`)
+- Performance improvement in :meth:`DataFrame.select_dtypes` by using vectorization instead of iterating over a loop (:issue:`28317`)
+- Performance improvement in :meth:`Categorical.searchsorted` and  :meth:`CategoricalIndex.searchsorted` (:issue:`28795`)
+- Performance improvement when comparing a :class:`Categorical` with a scalar and the scalar is not found in the categories (:issue:`29750`)
+- Performance improvement when checking if values in a :class:`Categorical` are equal, equal or larger or larger than a given scalar.
+  The improvement is not present if checking if the :class:`Categorical` is less than or less than or equal than the scalar (:issue:`29820`)
+- Performance improvement in :meth:`Index.equals` and  :meth:`MultiIndex.equals` (:issue:`29134`)
+- Performance improvement in :func:`~pandas.api.types.infer_dtype` when ``skipna`` is ``True`` (:issue:`28814`)
 
-.. _whatsnew_1000.bug_fixes:
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_100.bug_fixes:
 
 Bug fixes
 ~~~~~~~~~
@@ -109,9 +1026,24 @@ Bug fixes
 Categorical
 ^^^^^^^^^^^
 
-- Added test to assert the :func:`fillna` raises the correct ValueError message when the value isn't a value from categories (:issue:`13628`)
--
--
+- Added test to assert the :func:`fillna` raises the correct ``ValueError`` message when the value isn't a value from categories (:issue:`13628`)
+- Bug in :meth:`Categorical.astype` where ``NaN`` values were handled incorrectly when casting to int (:issue:`28406`)
+- :meth:`DataFrame.reindex` with a :class:`CategoricalIndex` would fail when the targets contained duplicates, and wouldn't fail if the source contained duplicates (:issue:`28107`)
+- Bug in :meth:`Categorical.astype` not allowing for casting to extension dtypes (:issue:`28668`)
+- Bug where :func:`merge` was unable to join on categorical and extension dtype columns (:issue:`28668`)
+- :meth:`Categorical.searchsorted` and :meth:`CategoricalIndex.searchsorted` now work on unordered categoricals also (:issue:`21667`)
+- Added test to assert roundtripping to parquet with :func:`DataFrame.to_parquet` or :func:`read_parquet` will preserve Categorical dtypes for string types (:issue:`27955`)
+- Changed the error message in :meth:`Categorical.remove_categories` to always show the invalid removals as a set (:issue:`28669`)
+- Using date accessors on a categorical dtyped :class:`Series` of datetimes was not returning an object of the
+  same type as if one used the :meth:`.str.` / :meth:`.dt.` on a :class:`Series` of that type. E.g. when accessing :meth:`Series.dt.tz_localize` on a
+  :class:`Categorical` with duplicate entries, the accessor was skipping duplicates (:issue:`27952`)
+- Bug in :meth:`DataFrame.replace` and :meth:`Series.replace` that would give incorrect results on categorical data (:issue:`26988`)
+- Bug where calling :meth:`Categorical.min` or :meth:`Categorical.max` on an empty Categorical would raise a numpy exception (:issue:`30227`)
+- The following methods now also correctly output values for unobserved categories when called through ``groupby(..., observed=False)`` (:issue:`17605`)
+  * :meth:`core.groupby.SeriesGroupBy.count`
+  * :meth:`core.groupby.SeriesGroupBy.size`
+  * :meth:`core.groupby.SeriesGroupBy.nunique`
+  * :meth:`core.groupby.SeriesGroupBy.nth`
 
 
 Datetimelike
@@ -120,16 +1052,35 @@ Datetimelike
 - Bug in :meth:`Series.dt` property lookups when the underlying data is read-only (:issue:`27529`)
 - Bug in ``HDFStore.__getitem__`` incorrectly reading tz attribute created in Python 2 (:issue:`26443`)
 - Bug in :func:`to_datetime` where passing arrays of malformed ``str`` with errors="coerce" could incorrectly lead to raising ``ValueError`` (:issue:`28299`)
-- Bug in :meth:`pandas.core.groupby.SeriesGroupBy.nunique` where ``NaT`` values were interfering with the count of unique values (:issue:`27951`)
+- Bug in :meth:`core.groupby.SeriesGroupBy.nunique` where ``NaT`` values were interfering with the count of unique values (:issue:`27951`)
 - Bug in :class:`Timestamp` subtraction when subtracting a :class:`Timestamp` from a ``np.datetime64`` object incorrectly raising ``TypeError`` (:issue:`28286`)
 - Addition and subtraction of integer or integer-dtype arrays with :class:`Timestamp` will now raise ``NullFrequencyError`` instead of ``ValueError`` (:issue:`28268`)
 - Bug in :class:`Series` and :class:`DataFrame` with integer dtype failing to raise ``TypeError`` when adding or subtracting a ``np.datetime64`` object (:issue:`28080`)
--
-
+- Bug in :meth:`Series.astype`, :meth:`Index.astype`, and :meth:`DataFrame.astype` failing to handle ``NaT`` when casting to an integer dtype (:issue:`28492`)
+- Bug in :class:`Week` with ``weekday`` incorrectly raising ``AttributeError`` instead of ``TypeError`` when adding or subtracting an invalid type (:issue:`28530`)
+- Bug in :class:`DataFrame` arithmetic operations when operating with a :class:`Series` with dtype `'timedelta64[ns]'` (:issue:`28049`)
+- Bug in :func:`core.groupby.generic.SeriesGroupBy.apply` raising ``ValueError`` when a column in the original DataFrame is a datetime and the column labels are not standard integers (:issue:`28247`)
+- Bug in :func:`pandas._config.localization.get_locales` where the ``locales -a`` encodes the locales list as windows-1252 (:issue:`23638`, :issue:`24760`, :issue:`27368`)
+- Bug in :meth:`Series.var` failing to raise ``TypeError`` when called with ``timedelta64[ns]`` dtype (:issue:`28289`)
+- Bug in :meth:`DatetimeIndex.strftime` and :meth:`Series.dt.strftime` where ``NaT`` was converted to the string ``'NaT'`` instead of ``np.nan`` (:issue:`29578`)
+- Bug in masking datetime-like arrays with a boolean mask of an incorrect length not raising an ``IndexError`` (:issue:`30308`)
+- Bug in :attr:`Timestamp.resolution` being a property instead of a class attribute (:issue:`29910`)
+- Bug in :func:`pandas.to_datetime` when called with ``None`` raising ``TypeError`` instead of returning ``NaT`` (:issue:`30011`)
+- Bug in :func:`pandas.to_datetime` failing for `deques` when using ``cache=True`` (the default) (:issue:`29403`)
+- Bug in :meth:`Series.item` with ``datetime64`` or ``timedelta64`` dtype, :meth:`DatetimeIndex.item`, and :meth:`TimedeltaIndex.item` returning an integer instead of a :class:`Timestamp` or :class:`Timedelta` (:issue:`30175`)
+- Bug in :class:`DatetimeIndex` addition when adding a non-optimized :class:`DateOffset` incorrectly dropping timezone information (:issue:`30336`)
+- Bug in :meth:`DataFrame.drop` where attempting to drop non-existent values from a DatetimeIndex would yield a confusing error message (:issue:`30399`)
+- Bug in :meth:`DataFrame.append` would remove the timezone-awareness of new data (:issue:`30238`)
+- Bug in :meth:`Series.cummin` and :meth:`Series.cummax` with timezone-aware dtype incorrectly dropping its timezone (:issue:`15553`)
+- Bug in :class:`DatetimeArray`, :class:`TimedeltaArray`, and :class:`PeriodArray` where inplace addition and subtraction did not actually operate inplace (:issue:`24115`)
+- Bug in :func:`pandas.to_datetime` when called with ``Series`` storing ``IntegerArray`` raising ``TypeError`` instead of returning ``Series`` (:issue:`30050`)
+- Bug in :func:`date_range` with custom business hours as ``freq`` and given number of ``periods`` (:issue:`30593`)
+- Bug in :class:`PeriodIndex` comparisons with incorrectly casting integers to :class:`Period` objects, inconsistent with the :class:`Period` comparison behavior (:issue:`30722`)
+- Bug in :meth:`DatetimeIndex.insert` raising a ``ValueError`` instead of a ``TypeError`` when trying to insert a timezone-aware :class:`Timestamp` into a timezone-naive :class:`DatetimeIndex`, or vice-versa (:issue:`30806`)
 
 Timedelta
 ^^^^^^^^^
-
+- Bug in subtracting a :class:`TimedeltaIndex` or :class:`TimedeltaArray` from a ``np.datetime64`` object (:issue:`29558`)
 -
 -
 
@@ -143,8 +1094,21 @@ Timezones
 Numeric
 ^^^^^^^
 - Bug in :meth:`DataFrame.quantile` with zero-column :class:`DataFrame` incorrectly raising (:issue:`23925`)
--
--
+- :class:`DataFrame` flex inequality comparisons methods (:meth:`DataFrame.lt`, :meth:`DataFrame.le`, :meth:`DataFrame.gt`, :meth:`DataFrame.ge`) with object-dtype and ``complex`` entries failing to raise ``TypeError`` like their :class:`Series` counterparts (:issue:`28079`)
+- Bug in :class:`DataFrame` logical operations (`&`, `|`, `^`) not matching :class:`Series` behavior by filling NA values (:issue:`28741`)
+- Bug in :meth:`DataFrame.interpolate` where specifying axis by name references variable before it is assigned (:issue:`29142`)
+- Bug in :meth:`Series.var` not computing the right value with a nullable integer dtype series not passing through ddof argument (:issue:`29128`)
+- Improved error message when using `frac` > 1 and `replace` = False (:issue:`27451`)
+- Bug in numeric indexes resulted in it being possible to instantiate an :class:`Int64Index`, :class:`UInt64Index`, or :class:`Float64Index` with an invalid dtype (e.g. datetime-like) (:issue:`29539`)
+- Bug in :class:`UInt64Index` precision loss while constructing from a list with values in the ``np.uint64`` range (:issue:`29526`)
+- Bug in :class:`NumericIndex` construction that caused indexing to fail when integers in the ``np.uint64`` range were used (:issue:`28023`)
+- Bug in :class:`NumericIndex` construction that caused :class:`UInt64Index` to be casted to :class:`Float64Index` when integers in the ``np.uint64`` range were used to index a :class:`DataFrame` (:issue:`28279`)
+- Bug in :meth:`Series.interpolate` when using method=`index` with an unsorted index, would previously return incorrect results. (:issue:`21037`)
+- Bug in :meth:`DataFrame.round` where a :class:`DataFrame` with a :class:`CategoricalIndex` of :class:`IntervalIndex` columns would incorrectly raise a ``TypeError`` (:issue:`30063`)
+- Bug in :meth:`Series.pct_change` and :meth:`DataFrame.pct_change` when there are duplicated indices (:issue:`30463`)
+- Bug in :class:`DataFrame` cumulative operations (e.g. cumsum, cummax) incorrect casting to object-dtype (:issue:`19296`)
+- Bug in :class:`~DataFrame.diff` losing the dtype for extension types (:issue:`30889`)
+- Bug in :class:`DataFrame.diff` raising an ``IndexError`` when one of the columns was a nullable integer dtype (:issue:`30967`)
 
 Conversion
 ^^^^^^^^^^
@@ -155,22 +1119,35 @@ Conversion
 Strings
 ^^^^^^^
 
--
+- Calling :meth:`Series.str.isalnum` (and other "ismethods") on an empty ``Series`` would return an ``object`` dtype instead of ``bool`` (:issue:`29624`)
 -
 
 
 Interval
 ^^^^^^^^
 
--
--
+- Bug in :meth:`IntervalIndex.get_indexer` where a :class:`Categorical` or :class:`CategoricalIndex` ``target`` would incorrectly raise a ``TypeError`` (:issue:`30063`)
+- Bug in ``pandas.core.dtypes.cast.infer_dtype_from_scalar`` where passing ``pandas_dtype=True`` did not infer :class:`IntervalDtype` (:issue:`30337`)
+- Bug in :class:`Series` constructor where constructing a ``Series`` from a ``list`` of :class:`Interval` objects resulted in ``object`` dtype instead of :class:`IntervalDtype` (:issue:`23563`)
+- Bug in :class:`IntervalDtype` where the ``kind`` attribute was incorrectly set as ``None`` instead of ``"O"`` (:issue:`30568`)
+- Bug in :class:`IntervalIndex`, :class:`~arrays.IntervalArray`, and :class:`Series` with interval data where equality comparisons were incorrect (:issue:`24112`)
 
 Indexing
 ^^^^^^^^
 
 - Bug in assignment using a reverse slicer (:issue:`26939`)
+- Bug in :meth:`DataFrame.explode` would duplicate frame in the presence of duplicates in the index (:issue:`28010`)
 - Bug in reindexing a :meth:`PeriodIndex` with another type of index that contained a `Period` (:issue:`28323`) (:issue:`28337`)
 - Fix assignment of column via `.loc` with numpy non-ns datetime type (:issue:`27395`)
+- Bug in :meth:`Float64Index.astype` where ``np.inf`` was not handled properly when casting to an integer dtype (:issue:`28475`)
+- :meth:`Index.union` could fail when the left contained duplicates (:issue:`28257`)
+- Bug when indexing with ``.loc`` where the index was a :class:`CategoricalIndex` with non-string categories didn't work (:issue:`17569`, :issue:`30225`)
+- :meth:`Index.get_indexer_non_unique` could fail with ``TypeError`` in some cases, such as when searching for ints in a string index (:issue:`28257`)
+- Bug in :meth:`Float64Index.get_loc` incorrectly raising ``TypeError`` instead of ``KeyError`` (:issue:`29189`)
+- Bug in :meth:`DataFrame.loc` with incorrect dtype when setting Categorical value in 1-row DataFrame (:issue:`25495`)
+- :meth:`MultiIndex.get_loc` can't find missing values when input includes missing values (:issue:`19132`)
+- Bug in :meth:`Series.__setitem__` incorrectly assigning values with boolean indexer when the length of new data matches the number of ``True`` values and new data is not a ``Series`` or an ``np.array`` (:issue:`30567`)
+- Bug in indexing with a :class:`PeriodIndex` incorrectly accepting integers representing years, use e.g. ``ser.loc["2007"]`` instead of ``ser.loc[2007]`` (:issue:`30763`)
 
 Missing
 ^^^^^^^
@@ -181,7 +1158,8 @@ Missing
 MultiIndex
 ^^^^^^^^^^
 
--
+- Constructor for :class:`MultiIndex` verifies that the given ``sortorder`` is compatible with the actual ``lexsort_depth``  if ``verify_integrity`` parameter is ``True`` (the default) (:issue:`28735`)
+- Series and MultiIndex `.drop` with `MultiIndex` raise exception if labels not in given in level (:issue:`8594`)
 -
 
 I/O
@@ -191,60 +1169,125 @@ I/O
 - Bug in :meth:`DataFrame.to_json` where using a Tuple as a column or index value and using ``orient="columns"`` or ``orient="index"`` would produce invalid JSON (:issue:`20500`)
 - Improve infinity parsing. :meth:`read_csv` now interprets ``Infinity``, ``+Infinity``, ``-Infinity`` as floating point values (:issue:`10065`)
 - Bug in :meth:`DataFrame.to_csv` where values were truncated when the length of ``na_rep`` was shorter than the text input data. (:issue:`25099`)
+- Bug in :func:`DataFrame.to_string` where values were truncated using display options instead of outputting the full content (:issue:`9784`)
+- Bug in :meth:`DataFrame.to_json` where a datetime column label would not be written out in ISO format with ``orient="table"`` (:issue:`28130`)
+- Bug in :func:`DataFrame.to_parquet` where writing to GCS would fail with `engine='fastparquet'` if the file did not already exist (:issue:`28326`)
+- Bug in :func:`read_hdf` closing stores that it didn't open when Exceptions are raised (:issue:`28699`)
+- Bug in :meth:`DataFrame.read_json` where using ``orient="index"`` would not maintain the order (:issue:`28557`)
+- Bug in :meth:`DataFrame.to_html` where the length of the ``formatters`` argument was not verified (:issue:`28469`)
+- Bug in :meth:`DataFrame.read_excel` with ``engine='ods'`` when ``sheet_name`` argument references a non-existent sheet (:issue:`27676`)
+- Bug in :meth:`pandas.io.formats.style.Styler` formatting for floating values not displaying decimals correctly (:issue:`13257`)
+- Bug in :meth:`DataFrame.to_html` when using ``formatters=<list>`` and ``max_cols`` together. (:issue:`25955`)
+- Bug in :meth:`Styler.background_gradient` not able to work with dtype ``Int64`` (:issue:`28869`)
+- Bug in :meth:`DataFrame.to_clipboard` which did not work reliably in ipython (:issue:`22707`)
+- Bug in :func:`read_json` where default encoding was not set to ``utf-8`` (:issue:`29565`)
+- Bug in :class:`PythonParser` where str and bytes were being mixed when dealing with the decimal field (:issue:`29650`)
+- :meth:`read_gbq` now accepts ``progress_bar_type`` to display progress bar while the data downloads. (:issue:`29857`)
+- Bug in :func:`pandas.io.json.json_normalize` where a missing value in the location specified by `record_path` would raise a ``TypeError`` (:issue:`30148`)
+- :func:`read_excel` now accepts binary data (:issue:`15914`)
+- Bug in :meth:`read_csv` in which encoding handling was limited to just the string `utf-16` for the C engine (:issue:`24130`)
 
 Plotting
 ^^^^^^^^
 
 - Bug in :meth:`Series.plot` not able to plot boolean values (:issue:`23719`)
--
 - Bug in :meth:`DataFrame.plot` not able to plot when no rows (:issue:`27758`)
 - Bug in :meth:`DataFrame.plot` producing incorrect legend markers when plotting multiple series on the same axis (:issue:`18222`)
 - Bug in :meth:`DataFrame.plot` when ``kind='box'`` and data contains datetime or timedelta data. These types are now automatically dropped (:issue:`22799`)
 - Bug in :meth:`DataFrame.plot.line` and :meth:`DataFrame.plot.area` produce wrong xlim in x-axis (:issue:`27686`, :issue:`25160`, :issue:`24784`)
+- Bug where :meth:`DataFrame.boxplot` would not accept a ``color`` parameter like :meth:`DataFrame.plot.box` (:issue:`26214`)
+- Bug in the ``xticks`` argument being ignored for :meth:`DataFrame.plot.bar` (:issue:`14119`)
 - :func:`set_option` now validates that the plot backend provided to ``'plotting.backend'`` implements the backend when the option is set, rather than when a plot is created (:issue:`28163`)
+- :meth:`DataFrame.plot` now allow a ``backend`` keyword argument to allow changing between backends in one session (:issue:`28619`).
+- Bug in color validation incorrectly raising for non-color styles (:issue:`29122`).
+- Allow :meth:`DataFrame.plot.scatter` to plot ``objects`` and ``datetime`` type data (:issue:`18755`, :issue:`30391`)
+- Bug in :meth:`DataFrame.hist`, ``xrot=0`` does not work with ``by`` and subplots (:issue:`30288`).
 
 Groupby/resample/rolling
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
--
-- Bug in :meth:`DataFrame.rolling` not allowing for rolling over datetimes when ``axis=1`` (:issue: `28192`)
+- Bug in :meth:`core.groupby.DataFrameGroupBy.apply` only showing output from a single group when function returns an :class:`Index` (:issue:`28652`)
+- Bug in :meth:`DataFrame.groupby` with multiple groups where an ``IndexError`` would be raised if any group contained all NA values (:issue:`20519`)
+- Bug in :meth:`pandas.core.resample.Resampler.size` and :meth:`pandas.core.resample.Resampler.count` returning wrong dtype when used with an empty :class:`Series` or :class:`DataFrame` (:issue:`28427`)
+- Bug in :meth:`DataFrame.rolling` not allowing for rolling over datetimes when ``axis=1`` (:issue:`28192`)
+- Bug in :meth:`DataFrame.rolling` not allowing rolling over multi-index levels (:issue:`15584`).
+- Bug in :meth:`DataFrame.rolling` not allowing rolling on monotonic decreasing time indexes (:issue:`19248`).
 - Bug in :meth:`DataFrame.groupby` not offering selection by column name when ``axis=1`` (:issue:`27614`)
-- Bug in :meth:`DataFrameGroupby.agg` not able to use lambda function with named aggregation (:issue:`27519`)
+- Bug in :meth:`core.groupby.DataFrameGroupby.agg` not able to use lambda function with named aggregation (:issue:`27519`)
+- Bug in :meth:`DataFrame.groupby` losing column name information when grouping by a categorical column (:issue:`28787`)
+- Remove error raised due to duplicated input functions in named aggregation in :meth:`DataFrame.groupby` and :meth:`Series.groupby`. Previously error will be raised if the same function is applied on the same column and now it is allowed if new assigned names are different. (:issue:`28426`)
+- :meth:`core.groupby.SeriesGroupBy.value_counts` will be able to handle the case even when the :class:`Grouper` makes empty groups (:issue:`28479`)
+- Bug in :meth:`core.window.rolling.Rolling.quantile` ignoring ``interpolation`` keyword argument when used within a groupby (:issue:`28779`)
+- Bug in :meth:`DataFrame.groupby` where ``any``, ``all``, ``nunique`` and transform functions would incorrectly handle duplicate column labels (:issue:`21668`)
+- Bug in :meth:`core.groupby.DataFrameGroupBy.agg` with timezone-aware datetime64 column incorrectly casting results to the original dtype (:issue:`29641`)
+- Bug in :meth:`DataFrame.groupby` when using axis=1 and having a single level columns index (:issue:`30208`)
+- Bug in :meth:`DataFrame.groupby` when using nunique on axis=1 (:issue:`30253`)
+- Bug in :meth:`GroupBy.quantile` with multiple list-like q value and integer column names (:issue:`30289`)
+- Bug in :meth:`GroupBy.pct_change` and :meth:`core.groupby.SeriesGroupBy.pct_change` causes ``TypeError`` when ``fill_method`` is ``None`` (:issue:`30463`)
+- Bug in :meth:`Rolling.count` and :meth:`Expanding.count` argument where ``min_periods`` was ignored (:issue:`26996`)
 
 Reshaping
 ^^^^^^^^^
 
-- Bug in :meth:`DataFrame.stack` not handling non-unique indexes correctly when creating MultiIndex (:issue: `28301`)
--
+- Bug in :meth:`DataFrame.apply` that caused incorrect output with empty :class:`DataFrame` (:issue:`28202`, :issue:`21959`)
+- Bug in :meth:`DataFrame.stack` not handling non-unique indexes correctly when creating MultiIndex (:issue:`28301`)
+- Bug in :meth:`pivot_table` not returning correct type ``float`` when ``margins=True`` and ``aggfunc='mean'`` (:issue:`24893`)
+- Bug :func:`merge_asof` could not use :class:`datetime.timedelta` for ``tolerance`` kwarg (:issue:`28098`)
+- Bug in :func:`merge`, did not append suffixes correctly with MultiIndex (:issue:`28518`)
+- :func:`qcut` and :func:`cut` now handle boolean input (:issue:`20303`)
+- Fix to ensure all int dtypes can be used in :func:`merge_asof` when using a tolerance value. Previously every non-int64 type would raise an erroneous ``MergeError`` (:issue:`28870`).
+- Better error message in :func:`get_dummies` when `columns` isn't a list-like value (:issue:`28383`)
+- Bug in :meth:`Index.join` that caused infinite recursion error for mismatched ``MultiIndex`` name orders. (:issue:`25760`, :issue:`28956`)
+- Bug :meth:`Series.pct_change` where supplying an anchored frequency would throw a ``ValueError`` (:issue:`28664`)
+- Bug where :meth:`DataFrame.equals` returned True incorrectly in some cases when two DataFrames had the same columns in different orders (:issue:`28839`)
+- Bug in :meth:`DataFrame.replace` that caused non-numeric replacer's dtype not respected (:issue:`26632`)
+- Bug in :func:`melt` where supplying mixed strings and numeric values for ``id_vars`` or ``value_vars`` would incorrectly raise a ``ValueError`` (:issue:`29718`)
+- Dtypes are now preserved when transposing a ``DataFrame`` where each column is the same extension dtype (:issue:`30091`)
+- Bug in :func:`merge_asof` merging on a tz-aware ``left_index`` and ``right_on`` a tz-aware column (:issue:`29864`)
+- Improved error message and docstring in :func:`cut` and :func:`qcut` when `labels=True` (:issue:`13318`)
+- Bug in missing `fill_na` parameter to :meth:`DataFrame.unstack` with list of levels (:issue:`30740`)
 
 Sparse
 ^^^^^^
 - Bug in :class:`SparseDataFrame` arithmetic operations incorrectly casting inputs to float (:issue:`28107`)
--
--
-
-
-Build Changes
-^^^^^^^^^^^^^
-- Fixed pyqt development dependency issue because of different pyqt package name in conda and PyPI (:issue:`26838`)
-- Added a `pyproject.toml <https://www.python.org/dev/peps/pep-0517/>`_ file (:issue:`20775`)
-
+- Bug in ``DataFrame.sparse`` returning a ``Series`` when there was a column named ``sparse`` rather than the accessor (:issue:`30758`)
+- Fixed :meth:`operator.xor` with a boolean-dtype ``SparseArray``. Now returns a sparse result, rather than object dtype (:issue:`31025`)
 
 ExtensionArray
 ^^^^^^^^^^^^^^
 
--
--
-
+- Bug in :class:`arrays.PandasArray` when setting a scalar string (:issue:`28118`, :issue:`28150`).
+- Bug where nullable integers could not be compared to strings (:issue:`28930`)
+- Bug where :class:`DataFrame` constructor raised ``ValueError`` with list-like data and ``dtype`` specified (:issue:`30280`)
 
 Other
 ^^^^^
 - Trying to set the ``display.precision``, ``display.max_rows`` or ``display.max_columns`` using :meth:`set_option` to anything but a ``None`` or a positive int will raise a ``ValueError`` (:issue:`23348`)
 - Using :meth:`DataFrame.replace` with overlapping keys in a nested dictionary will no longer raise, now matching the behavior of a flat dictionary (:issue:`27660`)
 - :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` now support dicts as ``compression`` argument with key ``'method'`` being the compression method and others as additional compression options when the compression method is ``'zip'``. (:issue:`26023`)
+- Bug in :meth:`Series.diff` where a boolean series would incorrectly raise a ``TypeError`` (:issue:`17294`)
 - :meth:`Series.append` will no longer raise a ``TypeError`` when passed a tuple of ``Series`` (:issue:`28410`)
-
-.. _whatsnew_1000.contributors:
+- Fix corrupted error message when calling ``pandas.libs._json.encode()`` on a 0d array (:issue:`18878`)
+- Backtick quoting in :meth:`DataFrame.query` and :meth:`DataFrame.eval` can now also be used to use invalid identifiers like names that start with a digit, are python keywords, or are using single character operators. (:issue:`27017`)
+- Bug in ``pd.core.util.hashing.hash_pandas_object`` where arrays containing tuples were incorrectly treated as non-hashable (:issue:`28969`)
+- Bug in :meth:`DataFrame.append` that raised ``IndexError`` when appending with empty list (:issue:`28769`)
+- Fix :class:`AbstractHolidayCalendar` to return correct results for
+  years after 2030 (now goes up to 2200) (:issue:`27790`)
+- Fixed :class:`~arrays.IntegerArray` returning ``inf`` rather than ``NaN`` for operations dividing by ``0`` (:issue:`27398`)
+- Fixed ``pow`` operations for :class:`~arrays.IntegerArray` when the other value is ``0`` or ``1`` (:issue:`29997`)
+- Bug in :meth:`Series.count` raises if use_inf_as_na is enabled (:issue:`29478`)
+- Bug in :class:`Index` where a non-hashable name could be set without raising ``TypeError`` (:issue:`29069`)
+- Bug in :class:`DataFrame` constructor when passing a 2D ``ndarray`` and an extension dtype (:issue:`12513`)
+- Bug in :meth:`DataFrame.to_csv` when supplied a series with a ``dtype="string"`` and a ``na_rep``, the ``na_rep`` was being truncated to 2 characters. (:issue:`29975`)
+- Bug where :meth:`DataFrame.itertuples` would incorrectly determine whether or not namedtuples could be used for dataframes of 255 columns (:issue:`28282`)
+- Handle nested NumPy ``object`` arrays in :func:`testing.assert_series_equal` for ExtensionArray implementations (:issue:`30841`)
+- Bug in :class:`Index` constructor incorrectly allowing 2-dimensional input arrays (:issue:`13601`, :issue:`27125`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_100.contributors:
 
 Contributors
 ~~~~~~~~~~~~
+
+.. contributors:: v0.25.3..v1.0.0
diff --git a/doc/source/whatsnew/v1.0.1.rst b/doc/source/whatsnew/v1.0.1.rst
new file mode 100644
index 0000000000000..ef3bb8161d13f
--- /dev/null
+++ b/doc/source/whatsnew/v1.0.1.rst
@@ -0,0 +1,79 @@
+.. _whatsnew_101:
+
+What's new in 1.0.1 (February 5, 2020)
+--------------------------------------
+
+These are the changes in pandas 1.0.1. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_101.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+
+- Fixed regression in :class:`DataFrame` setting values with a slice (e.g. ``df[-4:] = 1``) indexing by label instead of position (:issue:`31469`)
+- Fixed regression when indexing a ``Series`` or ``DataFrame`` indexed by ``DatetimeIndex`` with a slice containg a :class:`datetime.date` (:issue:`31501`)
+- Fixed regression in ``DataFrame.__setitem__`` raising an ``AttributeError`` with a :class:`MultiIndex` and a non-monotonic indexer (:issue:`31449`)
+- Fixed regression in :class:`Series` multiplication when multiplying a numeric :class:`Series` with >10000 elements with a timedelta-like scalar (:issue:`31457`)
+- Fixed regression in ``.groupby().agg()`` raising an ``AssertionError`` for some reductions like ``min`` on object-dtype columns (:issue:`31522`)
+- Fixed regression in ``.groupby()`` aggregations with categorical dtype using Cythonized reduction functions (e.g. ``first``) (:issue:`31450`)
+- Fixed regression in :meth:`GroupBy.apply` if called with a function which returned a non-pandas non-scalar object (e.g. a list or numpy array) (:issue:`31441`)
+- Fixed regression in :meth:`DataFrame.groupby` whereby taking the minimum or maximum of a column with period dtype would raise a ``TypeError``. (:issue:`31471`)
+- Fixed regression in :meth:`DataFrame.groupby` with an empty DataFrame grouping by a level of a MultiIndex (:issue:`31670`).
+- Fixed regression in :meth:`DataFrame.apply` with object dtype and non-reducing function (:issue:`31505`)
+- Fixed regression in :meth:`to_datetime` when parsing non-nanosecond resolution datetimes (:issue:`31491`)
+- Fixed regression in :meth:`~DataFrame.to_csv` where specifying an ``na_rep`` might truncate the values written (:issue:`31447`)
+- Fixed regression in :class:`Categorical` construction with ``numpy.str_`` categories (:issue:`31499`)
+- Fixed regression in :meth:`DataFrame.loc` and :meth:`DataFrame.iloc` when selecting a row containing a single ``datetime64`` or ``timedelta64`` column (:issue:`31649`)
+- Fixed regression where setting :attr:`pd.options.display.max_colwidth` was not accepting negative integer. In addition, this behavior has been deprecated in favor of using ``None`` (:issue:`31532`)
+- Fixed regression in objTOJSON.c fix return-type warning (:issue:`31463`)
+- Fixed regression in :meth:`qcut` when passed a nullable integer. (:issue:`31389`)
+- Fixed regression in assigning to a :class:`Series` using a nullable integer dtype (:issue:`31446`)
+- Fixed performance regression when indexing a ``DataFrame`` or ``Series`` with a :class:`MultiIndex` for the index using a list of labels (:issue:`31648`)
+- Fixed regression in :meth:`read_csv` used in file like object ``RawIOBase`` is not recognize ``encoding`` option (:issue:`31575`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_101.deprecations:
+
+Deprecations
+~~~~~~~~~~~~
+
+- Support for negative integer for :attr:`pd.options.display.max_colwidth` is deprecated in favor of using ``None`` (:issue:`31532`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_101.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+**Datetimelike**
+
+- Fixed bug in :meth:`to_datetime` raising when ``cache=True`` and out-of-bound values are present (:issue:`31491`)
+
+**Numeric**
+
+- Bug in dtypes being lost in ``DataFrame.__invert__`` (``~`` operator) with mixed dtypes (:issue:`31183`)
+  and for extension-array backed ``Series`` and ``DataFrame`` (:issue:`23087`)
+
+**Plotting**
+
+- Plotting tz-aware timeseries no longer gives UserWarning (:issue:`31205`)
+
+**Interval**
+
+- Bug in :meth:`Series.shift` with ``interval`` dtype raising a ``TypeError`` when shifting an interval array of integers or datetimes (:issue:`34195`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_101.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.0.0..v1.0.1|HEAD
diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
new file mode 100644
index 0000000000000..f4bb8c580fb08
--- /dev/null
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -0,0 +1,42 @@
+.. _whatsnew_102:
+
+What's new in 1.0.2 (February ??, 2020)
+---------------------------------------
+
+These are the changes in pandas 1.0.2. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_102.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+
+- Fixed regression in :meth:`DataFrame.to_excel` when ``columns`` kwarg is passed (:issue:`31677`)
+- Fixed regression in :meth:`Series.align` when ``other`` is a DataFrame and ``method`` is not None (:issue:`31785`)
+- Fixed regression in :meth:`pandas.core.groupby.RollingGroupby.apply` where the ``raw`` parameter was ignored (:issue:`31754`)
+- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.Rolling.corr>` when using a time offset (:issue:`31789`)
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_102.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+**I/O**
+
+- Using ``pd.NA`` with :meth:`DataFrame.to_json` now correctly outputs a null value instead of an empty object (:issue:`31615`)
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_102.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.0.1..v1.0.2|HEAD
\ No newline at end of file
diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
new file mode 100644
index 0000000000000..381578ad13bdd
--- /dev/null
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -0,0 +1,244 @@
+.. _whatsnew_110:
+
+What's new in 1.1.0 (??)
+------------------------
+
+These are the changes in pandas 1.1.0. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+Enhancements
+~~~~~~~~~~~~
+
+.. _whatsnew_110.period_index_partial_string_slicing:
+
+Nonmonotonic PeriodIndex Partial String Slicing
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:class:`PeriodIndex` now supports partial string slicing for non-monotonic indexes, mirroring :class:`DatetimeIndex` behavior (:issue:`31096`)
+
+For example:
+
+.. ipython:: python
+
+   dti = pd.date_range("2014-01-01", periods=30, freq="30D")
+   pi = dti.to_period("D")
+   ser_monotonic = pd.Series(np.arange(30), index=pi)
+   shuffler = list(range(0, 30, 2)) + list(range(1, 31, 2))
+   ser = ser_monotonic[shuffler]
+   ser
+
+.. ipython:: python
+
+   ser["2014"]
+   ser.loc["May 2015"]
+
+.. _whatsnew_110.enhancements.other:
+
+Other enhancements
+^^^^^^^^^^^^^^^^^^
+
+- :class:`Styler` may now render CSS more efficiently where multiple cells have the same styling (:issue:`30876`)
+- When writing directly to a sqlite connection :func:`to_sql` now supports the ``multi`` method (:issue:`29921`)
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_110.api.other:
+
+Other API changes
+^^^^^^^^^^^^^^^^^
+
+- :meth:`Series.describe` will now show distribution percentiles for ``datetime`` dtypes, statistics ``first`` and ``last``
+  will now be ``min`` and ``max`` to match with numeric dtypes in :meth:`DataFrame.describe` (:issue:`30164`)
+- :meth:`Groupby.groups` now returns an abbreviated representation when called on large dataframes (:issue:`1135`)
+
+Backwards incompatible API changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+- :meth:`DataFrame.swaplevels` now raises a  ``TypeError`` if the axis is not a :class:`MultiIndex`.
+  Previously a ``AttributeError`` was raised (:issue:`31126`)
+- :meth:`DataFrameGroupby.mean` and :meth:`SeriesGroupby.mean` (and similarly for :meth:`~DataFrameGroupby.median`, :meth:`~DataFrameGroupby.std`` and :meth:`~DataFrameGroupby.var``)
+  now raise a  ``TypeError`` if a not-accepted keyword argument is passed into it.
+  Previously a ``UnsupportedFunctionCall`` was raised (``AssertionError`` if ``min_count`` passed into :meth:`~DataFrameGroupby.median``) (:issue:`31485`)
+- :meth:`DataFrame.at` and :meth:`Series.at` will raise a ``TypeError`` instead of a ``ValueError`` if an incompatible key is passed, and ``KeyError`` if a missing key is passed, matching the behavior of ``.loc[]`` (:issue:`31722`)
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_110.deprecations:
+
+Deprecations
+~~~~~~~~~~~~
+- Lookups on a :class:`Series` with a single-item list containing a slice (e.g. ``ser[[slice(0, 4)]]``) are deprecated, will raise in a future version.  Either convert the list to tuple, or pass the slice directly instead (:issue:`31333`)
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+
+.. _whatsnew_110.performance:
+
+Performance improvements
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Performance improvement in :class:`Timedelta` constructor (:issue:`30543`)
+- Performance improvement in :class:`Timestamp` constructor (:issue:`30543`)
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_110.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+
+Categorical
+^^^^^^^^^^^
+
+-
+-
+
+Datetimelike
+^^^^^^^^^^^^
+
+- Bug in :class:`Timestamp` where constructing :class:`Timestamp` from ambiguous epoch time and calling constructor again changed :meth:`Timestamp.value` property (:issue:`24329`)
+- :meth:`DatetimeArray.searchsorted`, :meth:`TimedeltaArray.searchsorted`, :meth:`PeriodArray.searchsorted` not recognizing non-pandas scalars and incorrectly raising ``ValueError`` instead of ``TypeError`` (:issue:`30950`)
+- Bug in :class:`Timestamp` where constructing :class:`Timestamp` with dateutil timezone less than 128 nanoseconds before daylight saving time switch from winter to summer would result in nonexistent time (:issue:`31043`)
+- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
+- Bug in :meth:`Period.to_timestamp`, :meth:`Period.start_time` with microsecond frequency returning a timestamp one nanosecond earlier than the correct time (:issue:`31475`)
+
+Timedelta
+^^^^^^^^^
+
+- Bug in constructing a :class:`Timedelta` with a high precision integer that would round the :class:`Timedelta` components (:issue:`31354`)
+-
+
+Timezones
+^^^^^^^^^
+
+-
+-
+
+
+Numeric
+^^^^^^^
+- Bug in :meth:`DataFrame.floordiv` with ``axis=0`` not treating division-by-zero like :meth:`Series.floordiv` (:issue:`31271`)
+-
+-
+
+Conversion
+^^^^^^^^^^
+- Bug in :class:`Series` construction from NumPy array with big-endian ``datetime64`` dtype (:issue:`29684`)
+-
+-
+
+Strings
+^^^^^^^
+
+-
+-
+
+
+Interval
+^^^^^^^^
+
+-
+-
+
+Indexing
+^^^^^^^^
+- Bug in slicing on a :class:`DatetimeIndex` with a partial-timestamp dropping high-resolution indices near the end of a year, quarter, or month (:issue:`31064`)
+- Bug in :meth:`PeriodIndex.get_loc` treating higher-resolution strings differently from :meth:`PeriodIndex.get_value` (:issue:`31172`)
+- Bug in :meth:`Series.at` and :meth:`DataFrame.at` not matching ``.loc`` behavior when looking up an integer in a :class:`Float64Index` (:issue:`31329`)
+- Bug in :meth:`PeriodIndex.is_monotonic` incorrectly returning ``True`` when containing leading ``NaT`` entries (:issue:`31437`)
+- Bug in :meth:`DatetimeIndex.get_loc` raising ``KeyError`` with converted-integer key instead of the user-passed key (:issue:`31425`)
+- Bug in :meth:`Series.xs` incorrectly returning ``Timestamp`` instead of ``datetime64`` in some object-dtype cases (:issue:`31630`)
+
+Missing
+^^^^^^^
+
+-
+-
+
+MultiIndex
+^^^^^^^^^^
+- Bug in :meth:`Dataframe.loc` when used with a :class:`MultiIndex`. The returned values were not in the same order as the given inputs (:issue:`22797`)
+
+.. ipython:: python
+
+        df = pd.DataFrame(np.arange(4),
+                          index=[["a", "a", "b", "b"], [1, 2, 1, 2]])
+        # Rows are now ordered as the requested keys
+        df.loc[(['b', 'a'], [2, 1]), :]
+-
+
+I/O
+^^^
+- Bug in :meth:`read_json` where integer overflow was occuring when json contains big number strings. (:issue:`30320`)
+- `read_csv` will now raise a ``ValueError`` when the arguments `header` and `prefix` both are not `None`. (:issue:`27394`)
+- Bug in :meth:`DataFrame.to_json` was raising ``NotFoundError`` when ``path_or_buf`` was an S3 URI (:issue:`28375`)
+- Bug in :meth:`DataFrame.to_parquet` overwriting pyarrow's default for
+  ``coerce_timestamps``; following pyarrow's default allows writing nanosecond
+  timestamps with ``version="2.0"`` (:issue:`31652`).
+- Bug in :class:`HDFStore` that caused it to set to ``int64`` the dtype of a ``datetime64`` column when reading a DataFrame in Python 3 from fixed format written in Python 2 (:issue:`31750`)
+
+Plotting
+^^^^^^^^
+
+- :func:`.plot` for line/bar now accepts color by dictonary (:issue:`8193`).
+-
+- Bug in :meth:`DataFrame.boxplot` and :meth:`DataFrame.plot.boxplot` lost color attributes of ``medianprops``, ``whiskerprops``, ``capprops`` and ``medianprops`` (:issue:`30346`)
+
+
+Groupby/resample/rolling
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+- Bug in :meth:`GroupBy.apply` raises ``ValueError`` when the ``by`` axis is not sorted and has duplicates and the applied ``func`` does not mutate passed in objects (:issue:`30667`)
+- Bug in :meth:`DataFrameGroupby.transform` produces incorrect result with transformation functions (:issue:`30918`)
+
+Reshaping
+^^^^^^^^^
+
+- Bug effecting all numeric and boolean reduction methods not returning subclassed data type. (:issue:`25596`)
+- Bug in :meth:`DataFrame.pivot_table` when only MultiIndexed columns is set (:issue:`17038`)
+- Bug in :meth:`DataFrame.unstack` and :meth:`Series.unstack` can take tuple names in MultiIndexed data (:issue:`19966`)
+- Bug in :meth:`DataFrame.pivot_table` when ``margin`` is ``True`` and only ``column`` is defined (:issue:`31016`)
+- Fix incorrect error message in :meth:`DataFrame.pivot` when ``columns`` is set to ``None``. (:issue:`30924`)
+- Bug in :func:`crosstab` when inputs are two Series and have tuple names, the output will keep dummy MultiIndex as columns. (:issue:`18321`)
+- :meth:`DataFrame.pivot` can now take lists for ``index`` and ``columns`` arguments (:issue:`21425`)
+- Bug in :func:`concat` where the resulting indices are not copied when ``copy=True`` (:issue:`29879`)
+
+
+Sparse
+^^^^^^
+
+-
+-
+
+ExtensionArray
+^^^^^^^^^^^^^^
+
+-
+-
+
+
+Other
+^^^^^
+- Appending a dictionary to a :class:`DataFrame` without passing ``ignore_index=True`` will raise ``TypeError: Can only append a dict if ignore_index=True``
+  instead of ``TypeError: Can only append a Series if ignore_index=True or if the Series has a name`` (:issue:`30871`)
+- Set operations on an object-dtype :class:`Index` now always return object-dtype results (:issue:`31401`)
+- Bug in :meth:`AbstractHolidayCalendar.holidays` when no rules were defined (:issue:`31415`)
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_110.contributors:
+
+Contributors
+~~~~~~~~~~~~
diff --git a/doc/sphinxext/announce.py b/doc/sphinxext/announce.py
index 1a5ab99b5a94f..e4859157f73de 100755
--- a/doc/sphinxext/announce.py
+++ b/doc/sphinxext/announce.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- encoding:utf-8 -*-
 """
 Script to generate contributor and pull request lists
@@ -57,6 +57,16 @@ def get_authors(revision_range):
     pat = "^.*\\t(.*)$"
     lst_release, cur_release = [r.strip() for r in revision_range.split("..")]
 
+    if "|" in cur_release:
+        # e.g. v1.0.1|HEAD
+        maybe_tag, head = cur_release.split("|")
+        assert head == "HEAD"
+        if maybe_tag in this_repo.tags:
+            cur_release = maybe_tag
+        else:
+            cur_release = head
+        revision_range = f"{lst_release}..{cur_release}"
+
     # authors, in current release and previous to current release.
     cur = set(re.findall(pat, this_repo.git.shortlog("-s", revision_range), re.M))
     pre = set(re.findall(pat, this_repo.git.shortlog("-s", lst_release), re.M))
@@ -113,13 +123,13 @@ def build_string(revision_range, heading="Contributors"):
     components["authors"] = "* " + "\n* ".join(components["authors"])
 
     tpl = textwrap.dedent(
-        """\
-    {heading}
-    {uline}
+        f"""\
+    {components['heading']}
+    {components['uline']}
 
-    {author_message}
-    {authors}"""
-    ).format(**components)
+    {components['author_message']}
+    {components['authors']}"""
+    )
     return tpl
 
 
diff --git a/doc/sphinxext/contributors.py b/doc/sphinxext/contributors.py
index 1a064f71792e9..c2b21e40cadad 100644
--- a/doc/sphinxext/contributors.py
+++ b/doc/sphinxext/contributors.py
@@ -6,7 +6,13 @@
 
 This will be replaced with a message indicating the number of
 code contributors and commits, and then list each contributor
-individually.
+individually. For development versions (before a tag is available)
+use::
+
+    .. contributors:: v0.23.0..v0.23.1|HEAD
+
+While the v0.23.1 tag does not exist, that will use the HEAD of the
+branch as the end of the revision range.
 """
 from announce import build_components
 from docutils import nodes
@@ -27,7 +33,7 @@ def run(self):
         except git.GitCommandError as exc:
             return [
                 self.state.document.reporter.warning(
-                    "Cannot find contributors for range '{}': {}".format(range_, exc),
+                    f"Cannot find contributors for range {repr(range_)}: {exc}",
                     line=self.lineno,
                 )
             ]
diff --git a/environment.yml b/environment.yml
index 5bf66961e071a..5f1184e921119 100644
--- a/environment.yml
+++ b/environment.yml
@@ -1,11 +1,10 @@
 name: pandas-dev
 channels:
-  - defaults
   - conda-forge
 dependencies:
   # required
   - numpy>=1.15
-  - python=3
+  - python=3.7
   - python-dateutil>=2.6.1
   - pytz
 
@@ -16,35 +15,48 @@ dependencies:
   - cython>=0.29.13
 
   # code checks
-  - black
+  - black=19.10b0
   - cpplint
   - flake8
-  - flake8-comprehensions  # used by flake8, linting of unnecessary comprehensions
+  - flake8-comprehensions>=3.1.0  # used by flake8, linting of unnecessary comprehensions
   - flake8-rst>=0.6.0,<=0.7.0  # linting of code blocks in rst files
   - isort  # check that imports are in the right order
-  - mypy
+  - mypy=0.730
   - pycodestyle  # used by flake8
 
   # documentation
   - gitpython  # obtain contributors from git for whatsnew
-  # some styling is broken with sphinx >= 2 (https://github.com/pandas-dev/pandas/issues/26058)
-  - sphinx=1.8.5
-  - numpydoc>=0.9.0
+  - sphinx
 
   # documentation (jupyter notebooks)
   - nbconvert>=5.4.1
   - nbsphinx
   - pandoc
 
+  # Dask and its dependencies (that dont install with dask)
+  - dask-core
+  - toolz>=0.7.3
+  - fsspec>=0.5.1
+  - partd>=0.3.10
+  - cloudpickle>=0.2.1
+
+  # web (jinja2 is also needed, but it's also an optional pandas dependency)
+  - markdown
+  - feedparser
+  - pyyaml
+  - requests
+
   # testing
   - boto3
   - botocore>=1.11
   - hypothesis>=3.82
   - moto  # mock S3
-  - pytest>=4.0.2
+  - pytest>=5.0.1
   - pytest-cov
-  - pytest-mock
-  - pytest-xdist
+  - pytest-xdist>=1.21
+  - pytest-asyncio
+
+  # downstream tests
   - seaborn
   - statsmodels
 
@@ -58,27 +70,38 @@ dependencies:
   - blosc
   - bottleneck>=1.2.1
   - ipykernel
-  - ipython>=5.6.0
+  - ipython>=7.11.1
   - jinja2  # pandas.Styler
   - matplotlib>=2.2.2  # pandas.plotting, Series.plot, DataFrame.plot
   - numexpr>=2.6.8
   - scipy>=1.1
+  - numba>=0.46.0
 
   # optional for io
-  - beautifulsoup4>=4.6.0  # pandas.read_html
-  - fastparquet>=0.2.1  # pandas.read_parquet, DataFrame.to_parquet
-  - html5lib  # pandas.read_html
-  - lxml  # pandas.read_html
-  - openpyxl  # pandas.read_excel, DataFrame.to_excel, pandas.ExcelWriter, pandas.ExcelFile
-  - pyarrow>=0.9.0  # pandas.read_paquet, DataFrame.to_parquet, pandas.read_feather, DataFrame.to_feather
+  # ---------------
+  # pd.read_html
+  - beautifulsoup4>=4.6.0
+  - html5lib
+  - lxml
+
+  # pd.read_excel, DataFrame.to_excel, pd.ExcelWriter, pd.ExcelFile
+  - openpyxl<=3.0.1
+  - xlrd
+  - xlsxwriter
+  - xlwt
+  - odfpy
+
+  - fastparquet>=0.3.2  # pandas.read_parquet, DataFrame.to_parquet
+  - pyarrow>=0.13.1  # pandas.read_parquet, DataFrame.to_parquet, pandas.read_feather, DataFrame.to_feather
+  - python-snappy  # required by pyarrow
+
   - pyqt>=5.9.2  # pandas.read_clipboard
   - pytables>=3.4.2  # pandas.read_hdf, DataFrame.to_hdf
-  - python-snappy  # required by pyarrow
   - s3fs  # pandas.read_csv... when using 's3://...' path
   - sqlalchemy  # pandas.read_sql, DataFrame.to_sql
   - xarray  # DataFrame.to_xarray
-  - xlrd  # pandas.read_excel, DataFrame.to_excel, pandas.ExcelWriter, pandas.ExcelFile
-  - xlsxwriter  # pandas.read_excel, DataFrame.to_excel, pandas.ExcelWriter, pandas.ExcelFile
-  - xlwt  # pandas.read_excel, DataFrame.to_excel, pandas.ExcelWriter, pandas.ExcelFile
-  - odfpy  # pandas.read_excel
   - pyreadstat  # pandas.read_spss
+  - tabulate>=0.8.3  # DataFrame.to_markdown
+  - pip:
+    - git+https://github.com/pandas-dev/pandas-sphinx-theme.git@master
+    - git+https://github.com/numpy/numpydoc
diff --git a/pandas/__init__.py b/pandas/__init__.py
index 6351b508fb0e5..d526531b159b2 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -10,7 +10,7 @@
     try:
         __import__(dependency)
     except ImportError as e:
-        missing_dependencies.append("{0}: {1}".format(dependency, str(e)))
+        missing_dependencies.append(f"{dependency}: {e}")
 
 if missing_dependencies:
     raise ImportError(
@@ -24,6 +24,7 @@
     _np_version_under1p15,
     _np_version_under1p16,
     _np_version_under1p17,
+    _np_version_under1p18,
 )
 
 try:
@@ -32,14 +33,11 @@
     # hack but overkill to use re
     module = str(e).replace("cannot import name ", "")
     raise ImportError(
-        "C extension: {0} not built. If you want to import "
+        f"C extension: {module} not built. If you want to import "
         "pandas from the source directory, you may need to run "
-        "'python setup.py build_ext --inplace --force' to build "
-        "the C extensions first.".format(module)
+        "'python setup.py build_ext --inplace --force' to build the C extensions first."
     )
 
-from datetime import datetime
-
 from pandas._config import (
     get_option,
     set_option,
@@ -66,7 +64,10 @@
     PeriodDtype,
     IntervalDtype,
     DatetimeTZDtype,
+    StringDtype,
+    BooleanDtype,
     # missing
+    NA,
     isna,
     isnull,
     notna,
@@ -101,7 +102,6 @@
     to_datetime,
     to_timedelta,
     # misc
-    np,
     Grouper,
     factorize,
     unique,
@@ -114,12 +114,7 @@
     DataFrame,
 )
 
-from pandas.core.sparse.api import (
-    SparseArray,
-    SparseDataFrame,
-    SparseSeries,
-    SparseDtype,
-)
+from pandas.core.arrays.sparse import SparseDtype
 
 from pandas.tseries.api import infer_freq
 from pandas.tseries import offsets
@@ -142,6 +137,7 @@
     qcut,
 )
 
+import pandas.api
 from pandas.util._print_versions import show_versions
 
 from pandas.io.api import (
@@ -149,9 +145,6 @@
     ExcelFile,
     ExcelWriter,
     read_excel,
-    # packers
-    read_msgpack,
-    to_msgpack,
     # parsers
     read_csv,
     read_fwf,
@@ -169,6 +162,7 @@
     # misc
     read_clipboard,
     read_parquet,
+    read_orc,
     read_feather,
     read_gbq,
     read_html,
@@ -178,6 +172,8 @@
     read_spss,
 )
 
+from pandas.io.json import _json_normalize as json_normalize
+
 from pandas.util._tester import test
 import pandas.testing
 import pandas.arrays
@@ -190,19 +186,18 @@
 __git_version__ = v.get("full-revisionid")
 del get_versions, v
 
-
 # GH 27101
 # TODO: remove Panel compat in 1.0
 if pandas.compat.PY37:
 
     def __getattr__(name):
+        import warnings
+
         if name == "Panel":
-            import warnings
 
             warnings.warn(
                 "The Panel class is removed from pandas. Accessing it "
-                "from the top-level namespace will also be removed in "
-                "the next version",
+                "from the top-level namespace will also be removed in the next version",
                 FutureWarning,
                 stacklevel=2,
             )
@@ -211,7 +206,57 @@ class Panel:
                 pass
 
             return Panel
-        raise AttributeError("module 'pandas' has no attribute '{}'".format(name))
+
+        elif name == "datetime":
+            warnings.warn(
+                "The pandas.datetime class is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Import from datetime module instead.",
+                FutureWarning,
+                stacklevel=2,
+            )
+
+            from datetime import datetime as dt
+
+            return dt
+
+        elif name == "np":
+
+            warnings.warn(
+                "The pandas.np module is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Import numpy directly instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            import numpy as np
+
+            return np
+
+        elif name in {"SparseSeries", "SparseDataFrame"}:
+            warnings.warn(
+                f"The {name} class is removed from pandas. Accessing it from "
+                "the top-level namespace will also be removed in the next version",
+                FutureWarning,
+                stacklevel=2,
+            )
+
+            return type(name, (), {})
+
+        elif name == "SparseArray":
+
+            warnings.warn(
+                "The pandas.SparseArray class is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Use pandas.arrays.SparseArray instead.",
+                FutureWarning,
+                stacklevel=2,
+            )
+            from pandas.core.arrays.sparse import SparseArray as _SparseArray
+
+            return _SparseArray
+
+        raise AttributeError(f"module 'pandas' has no attribute '{name}'")
 
 
 else:
@@ -219,6 +264,102 @@ class Panel:
     class Panel:
         pass
 
+    class SparseDataFrame:
+        pass
+
+    class SparseSeries:
+        pass
+
+    class __numpy:
+        def __init__(self):
+            import numpy as np
+            import warnings
+
+            self.np = np
+            self.warnings = warnings
+
+        def __getattr__(self, item):
+            self.warnings.warn(
+                "The pandas.np module is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Import numpy directly instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+
+            try:
+                return getattr(self.np, item)
+            except AttributeError:
+                raise AttributeError(f"module numpy has no attribute {item}")
+
+    np = __numpy()
+
+    class __Datetime(type):
+
+        from datetime import datetime as dt
+
+        datetime = dt
+
+        def __getattr__(cls, item):
+            cls.emit_warning()
+
+            try:
+                return getattr(cls.datetime, item)
+            except AttributeError:
+                raise AttributeError(f"module datetime has no attribute {item}")
+
+        def __instancecheck__(cls, other):
+            return isinstance(other, cls.datetime)
+
+    class __DatetimeSub(metaclass=__Datetime):
+        def emit_warning(dummy=0):
+            import warnings
+
+            warnings.warn(
+                "The pandas.datetime class is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Import from datetime instead.",
+                FutureWarning,
+                stacklevel=3,
+            )
+
+        def __new__(cls, *args, **kwargs):
+            cls.emit_warning()
+            from datetime import datetime as dt
+
+            return dt(*args, **kwargs)
+
+    datetime = __DatetimeSub
+
+    class __SparseArray(type):
+
+        from pandas.core.arrays.sparse import SparseArray as sa
+
+        SparseArray = sa
+
+        def __instancecheck__(cls, other):
+            return isinstance(other, cls.SparseArray)
+
+    class __SparseArraySub(metaclass=__SparseArray):
+        def emit_warning(dummy=0):
+            import warnings
+
+            warnings.warn(
+                "The pandas.SparseArray class is deprecated "
+                "and will be removed from pandas in a future version. "
+                "Use pandas.arrays.SparseArray instead.",
+                FutureWarning,
+                stacklevel=3,
+            )
+
+        def __new__(cls, *args, **kwargs):
+            cls.emit_warning()
+            from pandas.core.arrays.sparse import SparseArray as sa
+
+            return sa(*args, **kwargs)
+
+    SparseArray = __SparseArraySub
+
 
 # module level doc-string
 __doc__ = """
@@ -258,6 +399,5 @@ class Panel:
     Excel files, databases, and saving/loading data from the ultrafast HDF5
     format.
   - Time series-specific functionality: date range generation and frequency
-    conversion, moving window statistics, moving window linear regressions,
-    date shifting and lagging, etc.
+    conversion, moving window statistics, date shifting and lagging.
 """
diff --git a/pandas/_config/config.py b/pandas/_config/config.py
index 890db5b41907e..8b6116d3abd60 100644
--- a/pandas/_config/config.py
+++ b/pandas/_config/config.py
@@ -51,23 +51,34 @@
 from collections import namedtuple
 from contextlib import contextmanager
 import re
-from typing import Dict, List
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    cast,
+)
 import warnings
 
 DeprecatedOption = namedtuple("DeprecatedOption", "key msg rkey removal_ver")
 RegisteredOption = namedtuple("RegisteredOption", "key defval doc validator cb")
 
-# holds deprecated option metdata
-_deprecated_options = {}  # type: Dict[str, DeprecatedOption]
+# holds deprecated option metadata
+_deprecated_options: Dict[str, DeprecatedOption] = {}
 
-# holds registered option metdata
-_registered_options = {}  # type: Dict[str, RegisteredOption]
+# holds registered option metadata
+_registered_options: Dict[str, RegisteredOption] = {}
 
 # holds the current values for registered options
-_global_config = {}  # type: Dict[str, str]
+_global_config: Dict[str, Any] = {}
 
 # keys which have a special meaning
-_reserved_keys = ["all"]  # type: List[str]
+_reserved_keys: List[str] = ["all"]
 
 
 class OptionError(AttributeError, KeyError):
@@ -80,12 +91,12 @@ class OptionError(AttributeError, KeyError):
 # User API
 
 
-def _get_single_key(pat, silent):
+def _get_single_key(pat: str, silent: bool) -> str:
     keys = _select_options(pat)
     if len(keys) == 0:
         if not silent:
             _warn_if_deprecated(pat)
-        raise OptionError("No such keys(s): {pat!r}".format(pat=pat))
+        raise OptionError(f"No such keys(s): {repr(pat)}")
     if len(keys) > 1:
         raise OptionError("Pattern matched multiple keys")
     key = keys[0]
@@ -98,7 +109,7 @@ def _get_single_key(pat, silent):
     return key
 
 
-def _get_option(pat, silent=False):
+def _get_option(pat: str, silent: bool = False):
     key = _get_single_key(pat, silent)
 
     # walk the nested dict
@@ -106,7 +117,7 @@ def _get_option(pat, silent=False):
     return root[k]
 
 
-def _set_option(*args, **kwargs):
+def _set_option(*args, **kwargs) -> None:
     # must at least 1 arg deal with constraints later
     nargs = len(args)
     if not nargs or nargs % 2 != 0:
@@ -116,8 +127,8 @@ def _set_option(*args, **kwargs):
     silent = kwargs.pop("silent", False)
 
     if kwargs:
-        msg = '_set_option() got an unexpected keyword argument "{kwarg}"'
-        raise TypeError(msg.format(list(kwargs.keys())[0]))
+        kwarg = list(kwargs.keys())[0]
+        raise TypeError(f'_set_option() got an unexpected keyword argument "{kwarg}"')
 
     for k, v in zip(args[::2], args[1::2]):
         key = _get_single_key(k, silent)
@@ -138,15 +149,13 @@ def _set_option(*args, **kwargs):
                 o.cb(key)
 
 
-def _describe_option(pat="", _print_desc=True):
+def _describe_option(pat: str = "", _print_desc: bool = True):
 
     keys = _select_options(pat)
     if len(keys) == 0:
         raise OptionError("No such keys(s)")
 
-    s = ""
-    for k in keys:  # filter by pat
-        s += _build_option_description(k)
+    s = "\n".join([_build_option_description(k) for k in keys])
 
     if _print_desc:
         print(s)
@@ -154,7 +163,7 @@ def _describe_option(pat="", _print_desc=True):
         return s
 
 
-def _reset_option(pat, silent=False):
+def _reset_option(pat: str, silent: bool = False) -> None:
 
     keys = _select_options(pat)
 
@@ -165,15 +174,14 @@ def _reset_option(pat, silent=False):
         raise ValueError(
             "You must specify at least 4 characters when "
             "resetting multiple keys, use the special keyword "
-            '"all" to reset all the options to their default '
-            "value"
+            '"all" to reset all the options to their default value'
         )
 
     for k in keys:
         _set_option(k, _registered_options[k].defval, silent=silent)
 
 
-def get_default_val(pat):
+def get_default_val(pat: str):
     key = _get_single_key(pat, silent=True)
     return _get_registered_option(key).defval
 
@@ -181,11 +189,11 @@ def get_default_val(pat):
 class DictWrapper:
     """ provide attribute-style access to a nested dict"""
 
-    def __init__(self, d, prefix=""):
+    def __init__(self, d: Dict[str, Any], prefix: str = ""):
         object.__setattr__(self, "d", d)
         object.__setattr__(self, "prefix", prefix)
 
-    def __setattr__(self, key, val):
+    def __setattr__(self, key: str, val: Any) -> None:
         prefix = object.__getattribute__(self, "prefix")
         if prefix:
             prefix += "."
@@ -197,7 +205,7 @@ def __setattr__(self, key, val):
         else:
             raise OptionError("You can only set the value of existing options")
 
-    def __getattr__(self, key):
+    def __getattr__(self, key: str):
         prefix = object.__getattribute__(self, "prefix")
         if prefix:
             prefix += "."
@@ -211,7 +219,7 @@ def __getattr__(self, key):
         else:
             return _get_option(prefix)
 
-    def __dir__(self):
+    def __dir__(self) -> Iterable[str]:
         return list(self.d.keys())
 
 
@@ -412,23 +420,31 @@ def __exit__(self, *args):
                 _set_option(pat, val, silent=True)
 
 
-def register_option(key, defval, doc="", validator=None, cb=None):
-    """Register an option in the package-wide pandas config object
+def register_option(
+    key: str,
+    defval: object,
+    doc: str = "",
+    validator: Optional[Callable[[Any], Any]] = None,
+    cb: Optional[Callable[[str], Any]] = None,
+) -> None:
+    """
+    Register an option in the package-wide pandas config object
 
     Parameters
     ----------
-    key       - a fully-qualified key, e.g. "x.y.option - z".
-    defval    - the default value of the option
-    doc       - a string description of the option
-    validator - a function of a single argument, should raise `ValueError` if
-                called with a value which is not a legal value for the option.
-    cb        - a function of a single argument "key", which is called
-                immediately after an option value is set/reset. key is
-                the full name of the option.
-
-    Returns
-    -------
-    Nothing.
+    key : str
+        Fully-qualified key, e.g. "x.y.option - z".
+    defval : object
+        Default value of the option.
+    doc : str
+        Description of the option.
+    validator : Callable, optional
+        Function of a single argument, should raise `ValueError` if
+        called with a value which is not a legal value for the option.
+    cb
+        a function of a single argument "key", which is called
+        immediately after an option value is set/reset. key is
+        the full name of the option.
 
     Raises
     ------
@@ -441,11 +457,9 @@ def register_option(key, defval, doc="", validator=None, cb=None):
     key = key.lower()
 
     if key in _registered_options:
-        msg = "Option '{key}' has already been registered"
-        raise OptionError(msg.format(key=key))
+        raise OptionError(f"Option '{key}' has already been registered")
     if key in _reserved_keys:
-        msg = "Option '{key}' is a reserved key"
-        raise OptionError(msg.format(key=key))
+        raise OptionError(f"Option '{key}' is a reserved key")
 
     # the default value should be legal
     if validator:
@@ -455,13 +469,16 @@ def register_option(key, defval, doc="", validator=None, cb=None):
     path = key.split(".")
 
     for k in path:
-        if not bool(re.match("^" + tokenize.Name + "$", k)):
-            raise ValueError("{k} is not a valid identifier".format(k=k))
+        # NOTE: tokenize.Name is not a public constant
+        # error: Module has no attribute "Name"  [attr-defined]
+        if not re.match("^" + tokenize.Name + "$", k):  # type: ignore
+            raise ValueError(f"{k} is not a valid identifier")
         if keyword.iskeyword(k):
-            raise ValueError("{k} is a python keyword".format(k=k))
+            raise ValueError(f"{k} is a python keyword")
 
     cursor = _global_config
     msg = "Path prefix to option '{option}' is already an option"
+
     for i, p in enumerate(path[:-1]):
         if not isinstance(cursor, dict):
             raise OptionError(msg.format(option=".".join(path[:i])))
@@ -480,7 +497,9 @@ def register_option(key, defval, doc="", validator=None, cb=None):
     )
 
 
-def deprecate_option(key, msg=None, rkey=None, removal_ver=None):
+def deprecate_option(
+    key: str, msg: Optional[str] = None, rkey: Optional[str] = None, removal_ver=None
+) -> None:
     """
     Mark option `key` as deprecated, if code attempts to access this option,
     a warning will be produced, using `msg` if given, or a default message
@@ -493,37 +512,31 @@ def deprecate_option(key, msg=None, rkey=None, removal_ver=None):
 
     Parameters
     ----------
-    key - the name of the option to be deprecated. must be a fully-qualified
-          option name (e.g "x.y.z.rkey").
-
-    msg - (Optional) a warning message to output when the key is referenced.
-          if no message is given a default message will be emitted.
-
-    rkey - (Optional) the name of an option to reroute access to.
-           If specified, any referenced `key` will be re-routed to `rkey`
-           including set/get/reset.
-           rkey must be a fully-qualified option name (e.g "x.y.z.rkey").
-           used by the default message if no `msg` is specified.
-
-    removal_ver - (Optional) specifies the version in which this option will
-                  be removed. used by the default message if no `msg`
-                  is specified.
-
-    Returns
-    -------
-    Nothing
+    key : str
+        Name of the option to be deprecated.
+        must be a fully-qualified option name (e.g "x.y.z.rkey").
+    msg : str, optional
+        Warning message to output when the key is referenced.
+        if no message is given a default message will be emitted.
+    rkey : str, optional
+        Name of an option to reroute access to.
+        If specified, any referenced `key` will be
+        re-routed to `rkey` including set/get/reset.
+        rkey must be a fully-qualified option name (e.g "x.y.z.rkey").
+        used by the default message if no `msg` is specified.
+    removal_ver : optional
+        Specifies the version in which this option will
+        be removed. used by the default message if no `msg` is specified.
 
     Raises
     ------
-    OptionError - if key has already been deprecated.
-
+    OptionError
+        If the specified key has already been deprecated.
     """
-
     key = key.lower()
 
     if key in _deprecated_options:
-        msg = "Option '{key}' has already been defined as deprecated."
-        raise OptionError(msg.format(key=key))
+        raise OptionError(f"Option '{key}' has already been defined as deprecated.")
 
     _deprecated_options[key] = DeprecatedOption(key, msg, rkey, removal_ver)
 
@@ -532,7 +545,7 @@ def deprecate_option(key, msg=None, rkey=None, removal_ver=None):
 # functions internal to the module
 
 
-def _select_options(pat):
+def _select_options(pat: str) -> List[str]:
     """returns a list of keys matching `pat`
 
     if pat=="all", returns all registered options
@@ -550,7 +563,7 @@ def _select_options(pat):
     return [k for k in keys if re.search(pat, k, re.I)]
 
 
-def _get_root(key):
+def _get_root(key: str) -> Tuple[Dict[str, Any], str]:
     path = key.split(".")
     cursor = _global_config
     for p in path[:-1]:
@@ -558,14 +571,14 @@ def _get_root(key):
     return cursor, path[-1]
 
 
-def _is_deprecated(key):
+def _is_deprecated(key: str) -> bool:
     """ Returns True if the given option has been deprecated """
 
     key = key.lower()
     return key in _deprecated_options
 
 
-def _get_deprecated_option(key):
+def _get_deprecated_option(key: str):
     """
     Retrieves the metadata for a deprecated option, if `key` is deprecated.
 
@@ -582,7 +595,7 @@ def _get_deprecated_option(key):
         return d
 
 
-def _get_registered_option(key):
+def _get_registered_option(key: str):
     """
     Retrieves the option metadata if `key` is a registered option.
 
@@ -593,7 +606,7 @@ def _get_registered_option(key):
     return _registered_options.get(key)
 
 
-def _translate_key(key):
+def _translate_key(key: str) -> str:
     """
     if key id deprecated and a replacement key defined, will return the
     replacement key, otherwise returns `key` as - is
@@ -606,7 +619,7 @@ def _translate_key(key):
         return key
 
 
-def _warn_if_deprecated(key):
+def _warn_if_deprecated(key: str) -> bool:
     """
     Checks if `key` is a deprecated option and if so, prints a warning.
 
@@ -621,11 +634,11 @@ def _warn_if_deprecated(key):
             print(d.msg)
             warnings.warn(d.msg, FutureWarning)
         else:
-            msg = "'{key}' is deprecated".format(key=key)
+            msg = f"'{key}' is deprecated"
             if d.removal_ver:
-                msg += " and will be removed in {version}".format(version=d.removal_ver)
+                msg += f" and will be removed in {d.removal_ver}"
             if d.rkey:
-                msg += ", please use '{rkey}' instead.".format(rkey=d.rkey)
+                msg += f", please use '{d.rkey}' instead."
             else:
                 msg += ", please refrain from using it."
 
@@ -634,13 +647,13 @@ def _warn_if_deprecated(key):
     return False
 
 
-def _build_option_description(k):
+def _build_option_description(k: str) -> str:
     """ Builds a formatted description of a registered option and prints it """
 
     o = _get_registered_option(k)
     d = _get_deprecated_option(k)
 
-    s = "{k} ".format(k=k)
+    s = f"{k} "
 
     if o.doc:
         s += "\n".join(o.doc.strip().split("\n"))
@@ -648,25 +661,24 @@ def _build_option_description(k):
         s += "No description available."
 
     if o:
-        s += "\n    [default: {default}] [currently: {current}]".format(
-            default=o.defval, current=_get_option(k, True)
-        )
+        s += f"\n    [default: {o.defval}] [currently: {_get_option(k, True)}]"
 
     if d:
+        rkey = d.rkey if d.rkey else ""
         s += "\n    (Deprecated"
-        s += ", use `{rkey}` instead.".format(rkey=d.rkey if d.rkey else "")
+        s += f", use `{rkey}` instead."
         s += ")"
 
     return s
 
 
-def pp_options_list(keys, width=80, _print=False):
+def pp_options_list(keys: Iterable[str], width=80, _print: bool = False):
     """ Builds a concise listing of available options, grouped by prefix """
 
     from textwrap import wrap
     from itertools import groupby
 
-    def pp(name, ks):
+    def pp(name: str, ks: Iterable[str]) -> List[str]:
         pfx = "- " + name + ".[" if name else ""
         ls = wrap(
             ", ".join(ks),
@@ -679,7 +691,7 @@ def pp(name, ks):
             ls[-1] = ls[-1] + "]"
         return ls
 
-    ls = []
+    ls: List[str] = []
     singles = [x for x in sorted(keys) if x.find(".") < 0]
     if singles:
         ls += pp("", singles)
@@ -698,6 +710,9 @@ def pp(name, ks):
 #
 # helpers
 
+FuncType = Callable[..., Any]
+F = TypeVar("F", bound=FuncType)
+
 
 @contextmanager
 def config_prefix(prefix):
@@ -729,12 +744,12 @@ def config_prefix(prefix):
 
     global register_option, get_option, set_option, reset_option
 
-    def wrap(func):
-        def inner(key, *args, **kwds):
-            pkey = "{prefix}.{key}".format(prefix=prefix, key=key)
+    def wrap(func: F) -> F:
+        def inner(key: str, *args, **kwds):
+            pkey = f"{prefix}.{key}"
             return func(pkey, *args, **kwds)
 
-        return inner
+        return cast(F, inner)
 
     _register_option = register_option
     _get_option = get_option
@@ -752,7 +767,7 @@ def inner(key, *args, **kwds):
 # arg in register_option
 
 
-def is_type_factory(_type):
+def is_type_factory(_type: Type[Any]) -> Callable[[Any], None]:
     """
 
     Parameters
@@ -766,15 +781,14 @@ def is_type_factory(_type):
 
     """
 
-    def inner(x):
+    def inner(x) -> None:
         if type(x) != _type:
-            msg = "Value must have type '{typ!s}'"
-            raise ValueError(msg.format(typ=_type))
+            raise ValueError(f"Value must have type '{_type}'")
 
     return inner
 
 
-def is_instance_factory(_type):
+def is_instance_factory(_type) -> Callable[[Any], None]:
     """
 
     Parameters
@@ -792,36 +806,35 @@ def is_instance_factory(_type):
         _type = tuple(_type)
         type_repr = "|".join(map(str, _type))
     else:
-        type_repr = "'{typ}'".format(typ=_type)
+        type_repr = f"'{_type}'"
 
-    def inner(x):
+    def inner(x) -> None:
         if not isinstance(x, _type):
-            msg = "Value must be an instance of {type_repr}"
-            raise ValueError(msg.format(type_repr=type_repr))
+            raise ValueError(f"Value must be an instance of {type_repr}")
 
     return inner
 
 
-def is_one_of_factory(legal_values):
+def is_one_of_factory(legal_values) -> Callable[[Any], None]:
 
     callables = [c for c in legal_values if callable(c)]
     legal_values = [c for c in legal_values if not callable(c)]
 
-    def inner(x):
+    def inner(x) -> None:
         if x not in legal_values:
 
             if not any(c(x) for c in callables):
                 uvals = [str(lval) for lval in legal_values]
                 pp_values = "|".join(uvals)
-                msg = "Value must be one of {pp_values}"
+                msg = f"Value must be one of {pp_values}"
                 if len(callables):
                     msg += " or a callable"
-                raise ValueError(msg.format(pp_values=pp_values))
+                raise ValueError(msg)
 
     return inner
 
 
-def is_nonnegative_int(value):
+def is_nonnegative_int(value: Optional[int]) -> None:
     """
     Verify that value is None or a positive int.
 
@@ -856,7 +869,7 @@ def is_nonnegative_int(value):
 is_text = is_instance_factory((str, bytes))
 
 
-def is_callable(obj):
+def is_callable(obj) -> bool:
     """
 
     Parameters
diff --git a/pandas/_config/display.py b/pandas/_config/display.py
index 067b7c503baab..ef319f4447565 100644
--- a/pandas/_config/display.py
+++ b/pandas/_config/display.py
@@ -1,6 +1,7 @@
 """
 Unopinionated display configuration.
 """
+
 import locale
 import sys
 
@@ -11,7 +12,7 @@
 _initial_defencoding = None
 
 
-def detect_console_encoding():
+def detect_console_encoding() -> str:
     """
     Try to find the most capable encoding supported by the console.
     slightly modified from the way IPython handles the same issue.
diff --git a/pandas/_config/localization.py b/pandas/_config/localization.py
index 9f750d8447c6a..0d68e78372d8a 100644
--- a/pandas/_config/localization.py
+++ b/pandas/_config/localization.py
@@ -12,7 +12,7 @@
 
 
 @contextmanager
-def set_locale(new_locale, lc_var=locale.LC_ALL):
+def set_locale(new_locale, lc_var: int = locale.LC_ALL):
     """
     Context manager for temporarily setting a locale.
 
@@ -44,7 +44,7 @@ def set_locale(new_locale, lc_var=locale.LC_ALL):
         locale.setlocale(lc_var, current_locale)
 
 
-def can_set_locale(lc, lc_var=locale.LC_ALL):
+def can_set_locale(lc: str, lc_var: int = locale.LC_ALL) -> bool:
     """
     Check to see if we can set a locale, and subsequently get the locale,
     without raising an Exception.
@@ -58,7 +58,7 @@ def can_set_locale(lc, lc_var=locale.LC_ALL):
 
     Returns
     -------
-    is_valid : bool
+    bool
         Whether the passed locale can be set
     """
 
@@ -145,7 +145,15 @@ def get_locales(prefix=None, normalize=True, locale_getter=_default_locale_gette
         raw_locales = raw_locales.split(b"\n")
         out_locales = []
         for x in raw_locales:
-            out_locales.append(str(x, encoding=options.display.encoding))
+            try:
+                out_locales.append(str(x, encoding=options.display.encoding))
+            except UnicodeError:
+                # 'locale -a' is used to populated 'raw_locales' and on
+                # Redhat 7 Linux (and maybe others) prints locale names
+                # using windows-1252 encoding.  Bug only triggered by
+                # a few special characters and when there is an
+                # extensive list of installed locales.
+                out_locales.append(str(x, encoding="windows-1252"))
 
     except TypeError:
         pass
@@ -153,6 +161,6 @@ def get_locales(prefix=None, normalize=True, locale_getter=_default_locale_gette
     if prefix is None:
         return _valid_locales(out_locales, normalize)
 
-    pattern = re.compile("{prefix}.*".format(prefix=prefix))
+    pattern = re.compile(f"{prefix}.*")
     found = pattern.findall("\n".join(out_locales))
     return _valid_locales(found, normalize)
diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx
index 0f91f612994c7..dd1f38ce3a842 100644
--- a/pandas/_libs/algos.pyx
+++ b/pandas/_libs/algos.pyx
@@ -49,8 +49,9 @@ cdef inline bint are_diff(object left, object right):
 
 
 class Infinity:
-    """ provide a positive Infinity comparison method for ranking """
-
+    """
+    Provide a positive Infinity comparison method for ranking.
+    """
     __lt__ = lambda self, other: False
     __le__ = lambda self, other: isinstance(other, Infinity)
     __eq__ = lambda self, other: isinstance(other, Infinity)
@@ -61,8 +62,9 @@ class Infinity:
 
 
 class NegInfinity:
-    """ provide a negative Infinity comparison method for ranking """
-
+    """
+    Provide a negative Infinity comparison method for ranking.
+    """
     __lt__ = lambda self, other: (not isinstance(other, NegInfinity) and
                                   not missing.checknull(other))
     __le__ = lambda self, other: not missing.checknull(other)
@@ -84,8 +86,8 @@ cpdef ndarray[int64_t, ndim=1] unique_deltas(const int64_t[:] arr):
 
     Returns
     -------
-    result : ndarray[int64_t]
-        result is sorted
+    ndarray[int64_t]
+        An ordered ndarray[int64_t]
     """
     cdef:
         Py_ssize_t i, n = len(arr)
@@ -150,20 +152,27 @@ def is_lexsorted(list_of_arrays: list) -> bint:
 @cython.wraparound(False)
 def groupsort_indexer(const int64_t[:] index, Py_ssize_t ngroups):
     """
-    compute a 1-d indexer that is an ordering of the passed index,
-    ordered by the groups. This is a reverse of the label
-    factorization process.
+    Compute a 1-d indexer.
+
+    The indexer is an ordering of the passed index,
+    ordered by the groups.
 
     Parameters
     ----------
     index: int64 ndarray
-        mappings from group -> position
+        Mappings from group -> position.
     ngroups: int64
-        number of groups
+        Number of groups.
 
-    return a tuple of (1-d indexer ordered by groups, group counts)
-    """
+    Returns
+    -------
+    tuple
+        1-d indexer ordered by groups, group counts.
 
+    Notes
+    -----
+    This is a reverse of the label factorization process.
+    """
     cdef:
         Py_ssize_t i, loc, label, n
         ndarray[int64_t] counts, where, result
@@ -311,7 +320,7 @@ def nancorr_spearman(const float64_t[:, :] mat, Py_ssize_t minp=1):
     ranked_mat = np.empty((N, K), dtype=np.float64)
 
     for i in range(K):
-        ranked_mat[:, i] = rank_1d_float64(mat[:, i])
+        ranked_mat[:, i] = rank_1d(mat[:, i])
 
     for xi in range(K):
         for yi in range(xi + 1):
@@ -337,8 +346,8 @@ def nancorr_spearman(const float64_t[:, :] mat, Py_ssize_t minp=1):
                         j += 1
 
                 if not all_ranks:
-                    maskedx = rank_1d_float64(maskedx)
-                    maskedy = rank_1d_float64(maskedy)
+                    maskedx = rank_1d(maskedx)
+                    maskedy = rank_1d(maskedy)
 
                 mean = (nobs + 1) / 2.
 
@@ -379,13 +388,39 @@ ctypedef fused algos_t:
     uint8_t
 
 
+def _validate_limit(nobs: int, limit=None) -> int:
+    """
+    Check that the `limit` argument is a positive integer.
+
+    Parameters
+    ----------
+    nobs : int
+    limit : object
+
+    Returns
+    -------
+    int
+        The limit.
+    """
+    if limit is None:
+        lim = nobs
+    else:
+        if not util.is_integer_object(limit):
+            raise ValueError('Limit must be an integer')
+        if limit < 1:
+            raise ValueError('Limit must be greater than 0')
+        lim = limit
+
+    return lim
+
+
 @cython.boundscheck(False)
 @cython.wraparound(False)
 def pad(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
     cdef:
         Py_ssize_t i, j, nleft, nright
         ndarray[int64_t, ndim=1] indexer
-        algos_t cur, next
+        algos_t cur, next_val
         int lim, fill_count = 0
 
     nleft = len(old)
@@ -393,14 +428,7 @@ def pad(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
     indexer = np.empty(nright, dtype=np.int64)
     indexer[:] = -1
 
-    if limit is None:
-        lim = nright
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(nright, limit)
 
     if nleft == 0 or nright == 0 or new[nright - 1] < old[0]:
         return indexer
@@ -426,9 +454,9 @@ def pad(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
                 j += 1
             break
 
-        next = old[i + 1]
+        next_val = old[i + 1]
 
-        while j < nright and cur <= new[j] < next:
+        while j < nright and cur <= new[j] < next_val:
             if new[j] == cur:
                 indexer[j] = i
             elif fill_count < lim:
@@ -438,16 +466,14 @@ def pad(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
 
         fill_count = 0
         i += 1
-        cur = next
+        cur = next_val
 
     return indexer
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def pad_inplace(algos_t[:] values,
-                const uint8_t[:] mask,
-                limit=None):
+def pad_inplace(algos_t[:] values, const uint8_t[:] mask, limit=None):
     cdef:
         Py_ssize_t i, N
         algos_t val
@@ -459,14 +485,7 @@ def pad_inplace(algos_t[:] values,
     if N == 0:
         return
 
-    if limit is None:
-        lim = N
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(N, limit)
 
     val = values[0]
     for i in range(N):
@@ -482,9 +501,7 @@ def pad_inplace(algos_t[:] values,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def pad_2d_inplace(algos_t[:, :] values,
-                   const uint8_t[:, :] mask,
-                   limit=None):
+def pad_2d_inplace(algos_t[:, :] values, const uint8_t[:, :] mask, limit=None):
     cdef:
         Py_ssize_t i, j, N, K
         algos_t val
@@ -496,14 +513,7 @@ def pad_2d_inplace(algos_t[:, :] values,
     if N == 0:
         return
 
-    if limit is None:
-        lim = N
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(N, limit)
 
     for j in range(K):
         fill_count = 0
@@ -559,14 +569,7 @@ def backfill(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
     indexer = np.empty(nright, dtype=np.int64)
     indexer[:] = -1
 
-    if limit is None:
-        lim = nright
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(nright, limit)
 
     if nleft == 0 or nright == 0 or new[0] > old[nleft - 1]:
         return indexer
@@ -612,9 +615,7 @@ def backfill(ndarray[algos_t] old, ndarray[algos_t] new, limit=None):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def backfill_inplace(algos_t[:] values,
-                     const uint8_t[:] mask,
-                     limit=None):
+def backfill_inplace(algos_t[:] values, const uint8_t[:] mask, limit=None):
     cdef:
         Py_ssize_t i, N
         algos_t val
@@ -626,14 +627,7 @@ def backfill_inplace(algos_t[:] values,
     if N == 0:
         return
 
-    if limit is None:
-        lim = N
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(N, limit)
 
     val = values[N - 1]
     for i in range(N - 1, -1, -1):
@@ -663,14 +657,7 @@ def backfill_2d_inplace(algos_t[:, :] values,
     if N == 0:
         return
 
-    if limit is None:
-        lim = N
-    else:
-        if not util.is_integer_object(limit):
-            raise ValueError('Limit must be an integer')
-        if limit < 1:
-            raise ValueError('Limit must be greater than 0')
-        lim = limit
+    lim = _validate_limit(N, limit)
 
     for j in range(K):
         fill_count = 0
@@ -692,7 +679,10 @@ def is_monotonic(ndarray[algos_t, ndim=1] arr, bint timelike):
     """
     Returns
     -------
-    is_monotonic_inc, is_monotonic_dec, is_unique
+    tuple
+        is_monotonic_inc : bool
+        is_monotonic_dec : bool
+        is_unique : bool
     """
     cdef:
         Py_ssize_t i, n
@@ -771,7 +761,474 @@ def is_monotonic(ndarray[algos_t, ndim=1] arr, bint timelike):
     return is_monotonic_inc, is_monotonic_dec, is_strict_monotonic
 
 
+# ----------------------------------------------------------------------
+# rank_1d, rank_2d
+# ----------------------------------------------------------------------
+
+ctypedef fused rank_t:
+    object
+    float64_t
+    uint64_t
+    int64_t
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def rank_1d(rank_t[:] in_arr, ties_method='average',
+            ascending=True, na_option='keep', pct=False):
+    """
+    Fast NaN-friendly version of ``scipy.stats.rankdata``.
+    """
+    cdef:
+        Py_ssize_t i, j, n, dups = 0, total_tie_count = 0, non_na_idx = 0
+
+        ndarray[rank_t] sorted_data, values
+
+        ndarray[float64_t] ranks
+        ndarray[int64_t] argsorted
+        ndarray[uint8_t, cast=True] sorted_mask
+
+        rank_t val, nan_value
+
+        float64_t sum_ranks = 0
+        int tiebreak = 0
+        bint keep_na = 0
+        bint isnan, condition
+        float64_t count = 0.0
+
+    tiebreak = tiebreakers[ties_method]
+
+    if rank_t is float64_t:
+        values = np.asarray(in_arr).copy()
+    elif rank_t is object:
+        values = np.array(in_arr, copy=True)
+
+        if values.dtype != np.object_:
+            values = values.astype('O')
+    else:
+        values = np.asarray(in_arr)
+
+    keep_na = na_option == 'keep'
+
+    if rank_t is object:
+        mask = missing.isnaobj(values)
+    elif rank_t is float64_t:
+        mask = np.isnan(values)
+    elif rank_t is int64_t:
+        mask = values == NPY_NAT
+
+        # create copy in case of NPY_NAT
+        # values are mutated inplace
+        if mask.any():
+            values = values.copy()
+
+    # double sort first by mask and then by values to ensure nan values are
+    # either at the beginning or the end. mask/(~mask) controls padding at
+    # tail or the head
+    if rank_t is not uint64_t:
+        if ascending ^ (na_option == 'top'):
+            if rank_t is object:
+                nan_value = Infinity()
+            elif rank_t is float64_t:
+                nan_value = np.inf
+            elif rank_t is int64_t:
+                nan_value = np.iinfo(np.int64).max
+
+            order = (values, mask)
+        else:
+            if rank_t is object:
+                nan_value = NegInfinity()
+            elif rank_t is float64_t:
+                nan_value = -np.inf
+            elif rank_t is int64_t:
+                nan_value = np.iinfo(np.int64).min
+
+            order = (values, ~mask)
+        np.putmask(values, mask, nan_value)
+    else:
+        mask = np.zeros(shape=len(values), dtype=bool)
+        order = (values, mask)
+
+    n = len(values)
+    ranks = np.empty(n, dtype='f8')
+
+    if rank_t is object:
+        _as = np.lexsort(keys=order)
+    else:
+        if tiebreak == TIEBREAK_FIRST:
+            # need to use a stable sort here
+            _as = np.lexsort(keys=order)
+            if not ascending:
+                tiebreak = TIEBREAK_FIRST_DESCENDING
+        else:
+            _as = np.lexsort(keys=order)
+
+    if not ascending:
+        _as = _as[::-1]
+
+    sorted_data = values.take(_as)
+    sorted_mask = mask.take(_as)
+    _indices = np.diff(sorted_mask.astype(int)).nonzero()[0]
+    non_na_idx = _indices[0] if len(_indices) > 0 else -1
+    argsorted = _as.astype('i8')
+
+    if rank_t is object:
+        # TODO: de-duplicate once cython supports conditional nogil
+        for i in range(n):
+            sum_ranks += i + 1
+            dups += 1
+
+            val = sorted_data[i]
+
+            if rank_t is not uint64_t:
+                isnan = sorted_mask[i]
+                if isnan and keep_na:
+                    ranks[argsorted[i]] = NaN
+                    continue
+
+            count += 1.0
+
+            if rank_t is object:
+                condition = (
+                    i == n - 1 or
+                    are_diff(sorted_data[i + 1], val) or
+                    i == non_na_idx
+                )
+            else:
+                condition = (
+                    i == n - 1 or
+                    sorted_data[i + 1] != val or
+                    i == non_na_idx
+                )
+
+            if condition:
+
+                if tiebreak == TIEBREAK_AVERAGE:
+                    for j in range(i - dups + 1, i + 1):
+                        ranks[argsorted[j]] = sum_ranks / dups
+                elif tiebreak == TIEBREAK_MIN:
+                    for j in range(i - dups + 1, i + 1):
+                        ranks[argsorted[j]] = i - dups + 2
+                elif tiebreak == TIEBREAK_MAX:
+                    for j in range(i - dups + 1, i + 1):
+                        ranks[argsorted[j]] = i + 1
+                elif tiebreak == TIEBREAK_FIRST:
+                    if rank_t is object:
+                        raise ValueError('first not supported for non-numeric data')
+                    else:
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = j + 1
+                elif tiebreak == TIEBREAK_FIRST_DESCENDING:
+                    for j in range(i - dups + 1, i + 1):
+                        ranks[argsorted[j]] = 2 * i - j - dups + 2
+                elif tiebreak == TIEBREAK_DENSE:
+                    total_tie_count += 1
+                    for j in range(i - dups + 1, i + 1):
+                        ranks[argsorted[j]] = total_tie_count
+                sum_ranks = dups = 0
+
+    else:
+        with nogil:
+            # TODO: why does the 2d version not have a nogil block?
+            for i in range(n):
+                sum_ranks += i + 1
+                dups += 1
+
+                val = sorted_data[i]
+
+                if rank_t is not uint64_t:
+                    isnan = sorted_mask[i]
+                    if isnan and keep_na:
+                        ranks[argsorted[i]] = NaN
+                        continue
+
+                count += 1.0
+
+                if rank_t is object:
+                    condition = (
+                        i == n - 1 or
+                        are_diff(sorted_data[i + 1], val) or
+                        i == non_na_idx
+                    )
+                else:
+                    condition = (
+                        i == n - 1 or
+                        sorted_data[i + 1] != val or
+                        i == non_na_idx
+                    )
+
+                if condition:
+
+                    if tiebreak == TIEBREAK_AVERAGE:
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = sum_ranks / dups
+                    elif tiebreak == TIEBREAK_MIN:
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = i - dups + 2
+                    elif tiebreak == TIEBREAK_MAX:
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = i + 1
+                    elif tiebreak == TIEBREAK_FIRST:
+                        if rank_t is object:
+                            raise ValueError('first not supported for non-numeric data')
+                        else:
+                            for j in range(i - dups + 1, i + 1):
+                                ranks[argsorted[j]] = j + 1
+                    elif tiebreak == TIEBREAK_FIRST_DESCENDING:
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = 2 * i - j - dups + 2
+                    elif tiebreak == TIEBREAK_DENSE:
+                        total_tie_count += 1
+                        for j in range(i - dups + 1, i + 1):
+                            ranks[argsorted[j]] = total_tie_count
+                    sum_ranks = dups = 0
+
+    if pct:
+        if tiebreak == TIEBREAK_DENSE:
+            return ranks / total_tie_count
+        else:
+            return ranks / count
+    else:
+        return ranks
+
+
+def rank_2d(rank_t[:, :] in_arr, axis=0, ties_method='average',
+            ascending=True, na_option='keep', pct=False):
+    """
+    Fast NaN-friendly version of ``scipy.stats.rankdata``.
+    """
+    cdef:
+        Py_ssize_t i, j, z, k, n, dups = 0, total_tie_count = 0
+
+        Py_ssize_t infs
+
+        ndarray[float64_t, ndim=2] ranks
+        ndarray[rank_t, ndim=2] values
+
+        ndarray[int64_t, ndim=2] argsorted
+
+        rank_t val, nan_value
+
+        float64_t sum_ranks = 0
+        int tiebreak = 0
+        bint keep_na = 0
+        float64_t count = 0.0
+        bint condition, skip_condition
+
+    tiebreak = tiebreakers[ties_method]
+
+    keep_na = na_option == 'keep'
+
+    if axis == 0:
+        values = np.asarray(in_arr).T.copy()
+    else:
+        values = np.asarray(in_arr).copy()
+
+    if rank_t is object:
+        if values.dtype != np.object_:
+            values = values.astype('O')
+
+    if rank_t is not uint64_t:
+        if ascending ^ (na_option == 'top'):
+            if rank_t is object:
+                nan_value = Infinity()
+            elif rank_t is float64_t:
+                nan_value = np.inf
+            elif rank_t is int64_t:
+                nan_value = np.iinfo(np.int64).max
+
+        else:
+            if rank_t is object:
+                nan_value = NegInfinity()
+            elif rank_t is float64_t:
+                nan_value = -np.inf
+            elif rank_t is int64_t:
+                nan_value = NPY_NAT
+
+        if rank_t is object:
+            mask = missing.isnaobj2d(values)
+        elif rank_t is float64_t:
+            mask = np.isnan(values)
+        elif rank_t is int64_t:
+            mask = values == NPY_NAT
+
+        np.putmask(values, mask, nan_value)
+
+    n, k = (<object>values).shape
+    ranks = np.empty((n, k), dtype='f8')
+
+    if rank_t is object:
+        try:
+            _as = values.argsort(1)
+        except TypeError:
+            values = in_arr
+            for i in range(len(values)):
+                ranks[i] = rank_1d(in_arr[i], ties_method=ties_method,
+                                   ascending=ascending, pct=pct)
+            if axis == 0:
+                return ranks.T
+            else:
+                return ranks
+    else:
+        if tiebreak == TIEBREAK_FIRST:
+            # need to use a stable sort here
+            _as = values.argsort(axis=1, kind='mergesort')
+            if not ascending:
+                tiebreak = TIEBREAK_FIRST_DESCENDING
+        else:
+            _as = values.argsort(1)
+
+    if not ascending:
+        _as = _as[:, ::-1]
+
+    values = _take_2d(values, _as)
+    argsorted = _as.astype('i8')
+
+    for i in range(n):
+        if rank_t is object:
+            dups = sum_ranks = infs = 0
+        else:
+            dups = sum_ranks = 0
+
+        total_tie_count = 0
+        count = 0.0
+        for j in range(k):
+            if rank_t is not object:
+                sum_ranks += j + 1
+                dups += 1
+
+            val = values[i, j]
+
+            if rank_t is not uint64_t:
+                if rank_t is object:
+                    skip_condition = (val is nan_value) and keep_na
+                else:
+                    skip_condition = (val == nan_value) and keep_na
+                if skip_condition:
+                    ranks[i, argsorted[i, j]] = NaN
+
+                    if rank_t is object:
+                        infs += 1
+
+                    continue
+
+            count += 1.0
+
+            if rank_t is object:
+                sum_ranks += (j - infs) + 1
+                dups += 1
+
+            if rank_t is object:
+                condition = j == k - 1 or are_diff(values[i, j + 1], val)
+            else:
+                condition = j == k - 1 or values[i, j + 1] != val
+
+            if condition:
+                if tiebreak == TIEBREAK_AVERAGE:
+                    for z in range(j - dups + 1, j + 1):
+                        ranks[i, argsorted[i, z]] = sum_ranks / dups
+                elif tiebreak == TIEBREAK_MIN:
+                    for z in range(j - dups + 1, j + 1):
+                        ranks[i, argsorted[i, z]] = j - dups + 2
+                elif tiebreak == TIEBREAK_MAX:
+                    for z in range(j - dups + 1, j + 1):
+                        ranks[i, argsorted[i, z]] = j + 1
+                elif tiebreak == TIEBREAK_FIRST:
+                    if rank_t is object:
+                        raise ValueError('first not supported for non-numeric data')
+                    else:
+                        for z in range(j - dups + 1, j + 1):
+                            ranks[i, argsorted[i, z]] = z + 1
+                elif tiebreak == TIEBREAK_FIRST_DESCENDING:
+                    for z in range(j - dups + 1, j + 1):
+                        ranks[i, argsorted[i, z]] = 2 * j - z - dups + 2
+                elif tiebreak == TIEBREAK_DENSE:
+                    total_tie_count += 1
+                    for z in range(j - dups + 1, j + 1):
+                        ranks[i, argsorted[i, z]] = total_tie_count
+                sum_ranks = dups = 0
+        if pct:
+            if tiebreak == TIEBREAK_DENSE:
+                ranks[i, :] /= total_tie_count
+            else:
+                ranks[i, :] /= count
+    if axis == 0:
+        return ranks.T
+    else:
+        return ranks
+
+
+ctypedef fused diff_t:
+    float64_t
+    float32_t
+    int8_t
+    int16_t
+    int32_t
+    int64_t
+
+ctypedef fused out_t:
+    float32_t
+    float64_t
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def diff_2d(ndarray[diff_t, ndim=2] arr,
+            ndarray[out_t, ndim=2] out,
+            Py_ssize_t periods, int axis):
+    cdef:
+        Py_ssize_t i, j, sx, sy, start, stop
+        bint f_contig = arr.flags.f_contiguous
+
+    # Disable for unsupported dtype combinations,
+    #  see https://github.com/cython/cython/issues/2646
+    if (out_t is float32_t
+            and not (diff_t is float32_t or diff_t is int8_t or diff_t is int16_t)):
+        raise NotImplementedError
+    elif (out_t is float64_t
+          and (diff_t is float32_t or diff_t is int8_t or diff_t is int16_t)):
+        raise NotImplementedError
+    else:
+        # We put this inside an indented else block to avoid cython build
+        #  warnings about unreachable code
+        sx, sy = (<object>arr).shape
+        with nogil:
+            if f_contig:
+                if axis == 0:
+                    if periods >= 0:
+                        start, stop = periods, sx
+                    else:
+                        start, stop = 0, sx + periods
+                    for j in range(sy):
+                        for i in range(start, stop):
+                            out[i, j] = arr[i, j] - arr[i - periods, j]
+                else:
+                    if periods >= 0:
+                        start, stop = periods, sy
+                    else:
+                        start, stop = 0, sy + periods
+                    for j in range(start, stop):
+                        for i in range(sx):
+                            out[i, j] = arr[i, j] - arr[i, j - periods]
+            else:
+                if axis == 0:
+                    if periods >= 0:
+                        start, stop = periods, sx
+                    else:
+                        start, stop = 0, sx + periods
+                    for i in range(start, stop):
+                        for j in range(sy):
+                            out[i, j] = arr[i, j] - arr[i - periods, j]
+                else:
+                    if periods >= 0:
+                        start, stop = periods, sy
+                    else:
+                        start, stop = 0, sy + periods
+                    for i in range(sx):
+                        for j in range(start, stop):
+                            out[i, j] = arr[i, j] - arr[i, j - periods]
+
+
 # generated from template
 include "algos_common_helper.pxi"
-include "algos_rank_helper.pxi"
 include "algos_take_helper.pxi"
diff --git a/pandas/_libs/algos_common_helper.pxi.in b/pandas/_libs/algos_common_helper.pxi.in
index 91599fa223b57..5bfc594602dd8 100644
--- a/pandas/_libs/algos_common_helper.pxi.in
+++ b/pandas/_libs/algos_common_helper.pxi.in
@@ -4,74 +4,6 @@ Template for each `dtype` helper function using 1-d template
 WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 """
 
-{{py:
-
-# name, c_type, dest_type
-dtypes = [('float64', 'float64_t', 'float64_t'),
-          ('float32', 'float32_t', 'float32_t'),
-          ('int8',  'int8_t',  'float32_t'),
-          ('int16', 'int16_t', 'float32_t'),
-          ('int32', 'int32_t', 'float64_t'),
-          ('int64', 'int64_t', 'float64_t')]
-
-def get_dispatch(dtypes):
-
-    for name, c_type, dest_type, in dtypes:
-        dest_name = dest_type[:-2]  # i.e. strip "_t"
-        yield name, c_type, dest_type, dest_name
-
-}}
-
-{{for name, c_type, dest_type, dest_name
-      in get_dispatch(dtypes)}}
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def diff_2d_{{name}}(ndarray[{{c_type}}, ndim=2] arr,
-                     ndarray[{{dest_type}}, ndim=2] out,
-                     Py_ssize_t periods, int axis):
-    cdef:
-        Py_ssize_t i, j, sx, sy
-
-    sx, sy = (<object>arr).shape
-    if arr.flags.f_contiguous:
-        if axis == 0:
-            if periods >= 0:
-                start, stop = periods, sx
-            else:
-                start, stop = 0, sx + periods
-            for j in range(sy):
-                for i in range(start, stop):
-                    out[i, j] = arr[i, j] - arr[i - periods, j]
-        else:
-            if periods >= 0:
-                start, stop = periods, sy
-            else:
-                start, stop = 0, sy + periods
-            for j in range(start, stop):
-                for i in range(sx):
-                    out[i, j] = arr[i, j] - arr[i, j - periods]
-    else:
-        if axis == 0:
-            if periods >= 0:
-                start, stop = periods, sx
-            else:
-                start, stop = 0, sx + periods
-            for i in range(start, stop):
-                for j in range(sy):
-                    out[i, j] = arr[i, j] - arr[i - periods, j]
-        else:
-            if periods >= 0:
-                start, stop = periods, sy
-            else:
-                start, stop = 0, sy + periods
-            for i in range(sx):
-                for j in range(start, stop):
-                    out[i, j] = arr[i, j] - arr[i, j - periods]
-
-{{endfor}}
-
 # ----------------------------------------------------------------------
 # ensure_dtype
 # ----------------------------------------------------------------------
diff --git a/pandas/_libs/algos_rank_helper.pxi.in b/pandas/_libs/algos_rank_helper.pxi.in
deleted file mode 100644
index 5dac94394c7ed..0000000000000
--- a/pandas/_libs/algos_rank_helper.pxi.in
+++ /dev/null
@@ -1,368 +0,0 @@
-"""
-Template for each `dtype` helper function for rank
-
-WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
-"""
-
-# ----------------------------------------------------------------------
-# rank_1d, rank_2d
-# ----------------------------------------------------------------------
-
-{{py:
-
-# dtype ctype pos_nan_value neg_nan_value
-dtypes = [('object', 'object', 'Infinity()', 'NegInfinity()'),
-          ('float64', 'float64_t', 'np.inf', '-np.inf'),
-          ('uint64', 'uint64_t', '', ''),
-          ('int64', 'int64_t', 'np.iinfo(np.int64).max',
-           'np.iinfo(np.int64).min')]
-
-}}
-
-{{for dtype, ctype, pos_nan_value, neg_nan_value in dtypes}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def rank_1d_{{dtype}}(object in_arr, ties_method='average',
-                      ascending=True, na_option='keep', pct=False):
-    """
-    Fast NaN-friendly version of scipy.stats.rankdata
-    """
-
-    cdef:
-        Py_ssize_t i, j, n, dups = 0, total_tie_count = 0, non_na_idx = 0
-
-        {{if dtype == 'object'}}
-        ndarray sorted_data, values
-        {{else}}
-        ndarray[{{ctype}}] sorted_data, values
-        {{endif}}
-
-        ndarray[float64_t] ranks
-        ndarray[int64_t] argsorted
-        ndarray[uint8_t, cast=True] sorted_mask
-
-        {{if dtype == 'uint64'}}
-        {{ctype}} val
-        {{else}}
-        {{ctype}} val, nan_value
-        {{endif}}
-
-        float64_t sum_ranks = 0
-        int tiebreak = 0
-        bint keep_na = 0
-        bint isnan
-        float64_t count = 0.0
-    tiebreak = tiebreakers[ties_method]
-
-    {{if dtype == 'float64'}}
-    values = np.asarray(in_arr).copy()
-    {{elif dtype == 'object'}}
-    values = np.array(in_arr, copy=True)
-
-    if values.dtype != np.object_:
-        values = values.astype('O')
-    {{else}}
-    values = np.asarray(in_arr)
-    {{endif}}
-
-    keep_na = na_option == 'keep'
-
-    {{if dtype == 'object'}}
-    mask = missing.isnaobj(values)
-    {{elif dtype == 'float64'}}
-    mask = np.isnan(values)
-    {{elif dtype == 'int64'}}
-    mask = values == NPY_NAT
-
-    # create copy in case of NPY_NAT
-    # values are mutated inplace
-    if mask.any():
-        values = values.copy()
-    {{endif}}
-
-    # double sort first by mask and then by values to ensure nan values are
-    # either at the beginning or the end. mask/(~mask) controls padding at
-    # tail or the head
-    {{if dtype != 'uint64'}}
-    if ascending ^ (na_option == 'top'):
-        nan_value = {{pos_nan_value}}
-        order = (values, mask)
-    else:
-        nan_value = {{neg_nan_value}}
-        order = (values, ~mask)
-    np.putmask(values, mask, nan_value)
-    {{else}}
-    mask = np.zeros(shape=len(values), dtype=bool)
-    order = (values, mask)
-    {{endif}}
-
-    n = len(values)
-    ranks = np.empty(n, dtype='f8')
-
-    {{if dtype == 'object'}}
-    _as = np.lexsort(keys=order)
-    {{else}}
-    if tiebreak == TIEBREAK_FIRST:
-        # need to use a stable sort here
-        _as = np.lexsort(keys=order)
-        if not ascending:
-            tiebreak = TIEBREAK_FIRST_DESCENDING
-    else:
-        _as = np.lexsort(keys=order)
-    {{endif}}
-
-    if not ascending:
-        _as = _as[::-1]
-
-    sorted_data = values.take(_as)
-    sorted_mask = mask.take(_as)
-    _indices = np.diff(sorted_mask.astype(int)).nonzero()[0]
-    non_na_idx = _indices[0] if len(_indices) > 0 else -1
-    argsorted = _as.astype('i8')
-
-    {{if dtype == 'object'}}
-    if True:
-    {{else}}
-    with nogil:
-    {{endif}}
-        # TODO: why does the 2d version not have a nogil block?
-        for i in range(n):
-            sum_ranks += i + 1
-            dups += 1
-
-            {{if dtype == 'object'}}
-            val = util.get_value_at(sorted_data, i)
-            {{else}}
-            val = sorted_data[i]
-            {{endif}}
-
-            {{if dtype != 'uint64'}}
-            isnan = sorted_mask[i]
-            if isnan and keep_na:
-                ranks[argsorted[i]] = NaN
-                continue
-            {{endif}}
-
-            count += 1.0
-
-            {{if dtype == 'object'}}
-            if (i == n - 1 or
-                    are_diff(util.get_value_at(sorted_data, i + 1), val) or
-                    i == non_na_idx):
-            {{else}}
-            if (i == n - 1 or sorted_data[i + 1] != val or i == non_na_idx):
-            {{endif}}
-
-                if tiebreak == TIEBREAK_AVERAGE:
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = sum_ranks / dups
-                elif tiebreak == TIEBREAK_MIN:
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = i - dups + 2
-                elif tiebreak == TIEBREAK_MAX:
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = i + 1
-                elif tiebreak == TIEBREAK_FIRST:
-                    {{if dtype == 'object'}}
-                    raise ValueError('first not supported for '
-                                     'non-numeric data')
-                    {{else}}
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = j + 1
-                    {{endif}}
-                elif tiebreak == TIEBREAK_FIRST_DESCENDING:
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = 2 * i - j - dups + 2
-                elif tiebreak == TIEBREAK_DENSE:
-                    total_tie_count += 1
-                    for j in range(i - dups + 1, i + 1):
-                        ranks[argsorted[j]] = total_tie_count
-                sum_ranks = dups = 0
-    if pct:
-        if tiebreak == TIEBREAK_DENSE:
-            return ranks / total_tie_count
-        else:
-            return ranks / count
-    else:
-        return ranks
-
-
-def rank_2d_{{dtype}}(object in_arr, axis=0, ties_method='average',
-                      ascending=True, na_option='keep', pct=False):
-    """
-    Fast NaN-friendly version of scipy.stats.rankdata
-    """
-
-    cdef:
-        Py_ssize_t i, j, z, k, n, dups = 0, total_tie_count = 0
-
-        {{if dtype == 'object'}}
-        Py_ssize_t infs
-        {{endif}}
-
-        ndarray[float64_t, ndim=2] ranks
-        {{if dtype == 'int64' or dtype == 'uint64'}}
-        ndarray[{{ctype}}, ndim=2, cast=True] values
-        {{else}}
-        ndarray[{{ctype}}, ndim=2] values
-        {{endif}}
-
-        ndarray[int64_t, ndim=2] argsorted
-
-        {{if dtype == 'uint64'}}
-        {{ctype}} val
-        {{else}}
-        {{ctype}} val, nan_value
-        {{endif}}
-
-        float64_t sum_ranks = 0
-        int tiebreak = 0
-        bint keep_na = 0
-        float64_t count = 0.0
-
-    tiebreak = tiebreakers[ties_method]
-
-    keep_na = na_option == 'keep'
-
-    in_arr = np.asarray(in_arr)
-
-    if axis == 0:
-        values = in_arr.T.copy()
-    else:
-        values = in_arr.copy()
-
-    {{if dtype == 'object'}}
-    if values.dtype != np.object_:
-        values = values.astype('O')
-    {{endif}}
-
-    {{if dtype != 'uint64'}}
-    if ascending ^ (na_option == 'top'):
-        nan_value = {{pos_nan_value}}
-    else:
-        nan_value = {{neg_nan_value}}
-
-    {{if dtype == 'object'}}
-    mask = missing.isnaobj2d(values)
-    {{elif dtype == 'float64'}}
-    mask = np.isnan(values)
-    {{elif dtype == 'int64'}}
-    mask = values == NPY_NAT
-    {{endif}}
-
-    np.putmask(values, mask, nan_value)
-    {{endif}}
-
-    n, k = (<object>values).shape
-    ranks = np.empty((n, k), dtype='f8')
-
-    {{if dtype == 'object'}}
-    try:
-        _as = values.argsort(1)
-    except TypeError:
-        values = in_arr
-        for i in range(len(values)):
-            ranks[i] = rank_1d_object(in_arr[i], ties_method=ties_method,
-                                      ascending=ascending, pct=pct)
-        if axis == 0:
-            return ranks.T
-        else:
-            return ranks
-    {{else}}
-    if tiebreak == TIEBREAK_FIRST:
-        # need to use a stable sort here
-        _as = values.argsort(axis=1, kind='mergesort')
-        if not ascending:
-            tiebreak = TIEBREAK_FIRST_DESCENDING
-    else:
-        _as = values.argsort(1)
-    {{endif}}
-
-    if not ascending:
-        _as = _as[:, ::-1]
-
-    values = _take_2d_{{dtype}}(values, _as)
-    argsorted = _as.astype('i8')
-
-    for i in range(n):
-        {{if dtype == 'object'}}
-        dups = sum_ranks = infs = 0
-        {{else}}
-        dups = sum_ranks = 0
-        {{endif}}
-
-        total_tie_count = 0
-        count = 0.0
-        for j in range(k):
-            {{if dtype != 'object'}}
-            sum_ranks += j + 1
-            dups += 1
-            {{endif}}
-
-            val = values[i, j]
-
-            {{if dtype != 'uint64'}}
-            {{if dtype == 'object'}}
-            if (val is nan_value) and keep_na:
-            {{else}}
-            if (val == nan_value) and keep_na:
-            {{endif}}
-                ranks[i, argsorted[i, j]] = NaN
-
-                {{if dtype == 'object'}}
-                infs += 1
-                {{endif}}
-
-                continue
-            {{endif}}
-
-            count += 1.0
-
-            {{if dtype == 'object'}}
-            sum_ranks += (j - infs) + 1
-            dups += 1
-            {{endif}}
-
-            {{if dtype == 'object'}}
-            if j == k - 1 or are_diff(values[i, j + 1], val):
-            {{else}}
-            if j == k - 1 or values[i, j + 1] != val:
-            {{endif}}
-                if tiebreak == TIEBREAK_AVERAGE:
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = sum_ranks / dups
-                elif tiebreak == TIEBREAK_MIN:
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = j - dups + 2
-                elif tiebreak == TIEBREAK_MAX:
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = j + 1
-                elif tiebreak == TIEBREAK_FIRST:
-                    {{if dtype == 'object'}}
-                    raise ValueError('first not supported '
-                                     'for non-numeric data')
-                    {{else}}
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = z + 1
-                    {{endif}}
-                elif tiebreak == TIEBREAK_FIRST_DESCENDING:
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = 2 * j - z - dups + 2
-                elif tiebreak == TIEBREAK_DENSE:
-                    total_tie_count += 1
-                    for z in range(j - dups + 1, j + 1):
-                        ranks[i, argsorted[i, z]] = total_tie_count
-                sum_ranks = dups = 0
-        if pct:
-            if tiebreak == TIEBREAK_DENSE:
-                ranks[i, :] /= total_tie_count
-            else:
-                ranks[i, :] /= count
-    if axis == 0:
-        return ranks.T
-    else:
-        return ranks
-
-{{endfor}}
diff --git a/pandas/_libs/algos_take_helper.pxi.in b/pandas/_libs/algos_take_helper.pxi.in
index 3a3adc71875ed..995fabbedcb5d 100644
--- a/pandas/_libs/algos_take_helper.pxi.in
+++ b/pandas/_libs/algos_take_helper.pxi.in
@@ -10,69 +10,119 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 
 {{py:
 
-# name, dest, c_type_in, c_type_out, preval, postval, can_copy, nogil
+# c_type_in, c_type_out
 dtypes = [
-    ('bool', 'bool', 'uint8_t', 'uint8_t', '', '', True, True),
-    ('bool', 'object', 'uint8_t', 'object',
-     'True if ', ' > 0 else False', False, False),
-    ('int8', 'int8', 'int8_t', 'int8_t', '', '', True, False),
-    ('int8', 'int32', 'int8_t', 'int32_t', '', '', False, True),
-    ('int8', 'int64', 'int8_t', 'int64_t', '', '', False, True),
-    ('int8', 'float64', 'int8_t', 'float64_t', '', '', False, True),
-    ('int16', 'int16', 'int16_t', 'int16_t', '', '', True, True),
-    ('int16', 'int32', 'int16_t', 'int32_t', '', '', False, True),
-    ('int16', 'int64', 'int16_t', 'int64_t', '', '', False, True),
-    ('int16', 'float64', 'int16_t', 'float64_t', '', '', False, True),
-    ('int32', 'int32', 'int32_t', 'int32_t', '', '', True, True),
-    ('int32', 'int64', 'int32_t', 'int64_t', '', '', False, True),
-    ('int32', 'float64', 'int32_t', 'float64_t', '', '', False, True),
-    ('int64', 'int64', 'int64_t', 'int64_t', '', '', True, True),
-    ('int64', 'float64', 'int64_t', 'float64_t', '', '', False, True),
-    ('float32', 'float32', 'float32_t', 'float32_t', '', '', True, True),
-    ('float32', 'float64', 'float32_t', 'float64_t', '', '', False, True),
-    ('float64', 'float64', 'float64_t', 'float64_t', '', '', True, True),
-    ('object', 'object', 'object', 'object', '', '', False, False)]
+    ('uint8_t', 'uint8_t'),
+    ('uint8_t', 'object'),
+    ('int8_t', 'int8_t'),
+    ('int8_t', 'int32_t'),
+    ('int8_t', 'int64_t'),
+    ('int8_t', 'float64_t'),
+    ('int16_t', 'int16_t'),
+    ('int16_t', 'int32_t'),
+    ('int16_t', 'int64_t'),
+    ('int16_t', 'float64_t'),
+    ('int32_t', 'int32_t'),
+    ('int32_t', 'int64_t'),
+    ('int32_t', 'float64_t'),
+    ('int64_t', 'int64_t'),
+    ('int64_t', 'float64_t'),
+    ('float32_t', 'float32_t'),
+    ('float32_t', 'float64_t'),
+    ('float64_t', 'float64_t'),
+    ('object', 'object'),
+]
 
 
 def get_dispatch(dtypes):
 
-    inner_take_1d_template = """
+    for (c_type_in, c_type_out) in dtypes:
+
+        def get_name(dtype_name):
+            if dtype_name == "object":
+                return "object"
+            if dtype_name == "uint8_t":
+                return "bool"
+            return dtype_name[:-2]
+
+        name = get_name(c_type_in)
+        dest = get_name(c_type_out)
+
+        args = dict(name=name, dest=dest, c_type_in=c_type_in,
+                    c_type_out=c_type_out)
+
+        yield (name, dest, c_type_in, c_type_out)
+
+}}
+
+
+{{for name, dest, c_type_in, c_type_out in get_dispatch(dtypes)}}
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+{{if c_type_in != "object"}}
+def take_1d_{{name}}_{{dest}}(const {{c_type_in}}[:] values,
+{{else}}
+def take_1d_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=1] values,
+{{endif}}
+                              const int64_t[:] indexer,
+                              {{c_type_out}}[:] out,
+                              fill_value=np.nan):
+
     cdef:
         Py_ssize_t i, n, idx
-        %(c_type_out)s fv
+        {{c_type_out}} fv
 
     n = indexer.shape[0]
 
     fv = fill_value
 
-    %(nogil_str)s
-    %(tab)sfor i in range(n):
-    %(tab)s    idx = indexer[i]
-    %(tab)s    if idx == -1:
-    %(tab)s        out[i] = fv
-    %(tab)s    else:
-    %(tab)s        out[i] = %(preval)svalues[idx]%(postval)s
-"""
+    {{if c_type_out != "object"}}
+    with nogil:
+    {{else}}
+    if True:
+    {{endif}}
+        for i in range(n):
+            idx = indexer[i]
+            if idx == -1:
+                out[i] = fv
+            else:
+                {{if c_type_in == "uint8_t" and c_type_out == "object"}}
+                out[i] = True if values[idx] > 0 else False
+                {{else}}
+                out[i] = values[idx]
+                {{endif}}
 
-    inner_take_2d_axis0_template = """\
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+{{if c_type_in != "object"}}
+def take_2d_axis0_{{name}}_{{dest}}(const {{c_type_in}}[:, :] values,
+{{else}}
+def take_2d_axis0_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
+{{endif}}
+                                    ndarray[int64_t] indexer,
+                                    {{c_type_out}}[:, :] out,
+                                    fill_value=np.nan):
     cdef:
         Py_ssize_t i, j, k, n, idx
-        %(c_type_out)s fv
+        {{c_type_out}} fv
 
     n = len(indexer)
     k = values.shape[1]
 
     fv = fill_value
 
-    IF %(can_copy)s:
+    IF {{True if c_type_in == c_type_out != "object" else False}}:
         cdef:
-            %(c_type_out)s *v
-            %(c_type_out)s *o
+            const {{c_type_out}} *v
+            {{c_type_out}} *o
 
-        #GH3130
+        # GH#3130
         if (values.strides[1] == out.strides[1] and
-            values.strides[1] == sizeof(%(c_type_out)s) and
-            sizeof(%(c_type_out)s) * n >= 256):
+            values.strides[1] == sizeof({{c_type_out}}) and
+            sizeof({{c_type_out}}) * n >= 256):
 
             for i in range(n):
                 idx = indexer[i]
@@ -82,7 +132,7 @@ def get_dispatch(dtypes):
                 else:
                     v = &values[idx, 0]
                     o = &out[i, 0]
-                    memmove(o, v, <size_t>(sizeof(%(c_type_out)s) * k))
+                    memmove(o, v, <size_t>(sizeof({{c_type_out}}) * k))
             return
 
     for i in range(n):
@@ -92,13 +142,27 @@ def get_dispatch(dtypes):
                 out[i, j] = fv
         else:
             for j in range(k):
-                out[i, j] = %(preval)svalues[idx, j]%(postval)s
-"""
+                {{if c_type_in == "uint8_t" and c_type_out == "object"}}
+                out[i, j] = True if values[idx, j] > 0 else False
+                {{else}}
+                out[i, j] = values[idx, j]
+                {{endif}}
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+{{if c_type_in != "object"}}
+def take_2d_axis1_{{name}}_{{dest}}(const {{c_type_in}}[:, :] values,
+{{else}}
+def take_2d_axis1_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
+{{endif}}
+                                    ndarray[int64_t] indexer,
+                                    {{c_type_out}}[:, :] out,
+                                    fill_value=np.nan):
 
-    inner_take_2d_axis1_template = """\
     cdef:
         Py_ssize_t i, j, k, n, idx
-        %(c_type_out)s fv
+        {{c_type_out}} fv
 
     n = len(values)
     k = len(indexer)
@@ -114,120 +178,11 @@ def get_dispatch(dtypes):
             if idx == -1:
                 out[i, j] = fv
             else:
-                out[i, j] = %(preval)svalues[i, idx]%(postval)s
-"""
-
-    for (name, dest, c_type_in, c_type_out, preval, postval,
-         can_copy, nogil) in dtypes:
-        if nogil:
-            nogil_str = "with nogil:"
-            tab = '    '
-        else:
-            nogil_str = ''
-            tab = ''
-
-        args = dict(name=name, dest=dest, c_type_in=c_type_in,
-                    c_type_out=c_type_out, preval=preval, postval=postval,
-                    can_copy=can_copy, nogil_str=nogil_str, tab=tab)
-
-        inner_take_1d = inner_take_1d_template % args
-        inner_take_2d_axis0 = inner_take_2d_axis0_template % args
-        inner_take_2d_axis1 = inner_take_2d_axis1_template % args
-
-        yield (name, dest, c_type_in, c_type_out, preval, postval, can_copy,
-               inner_take_1d, inner_take_2d_axis0, inner_take_2d_axis1)
-
-}}
-
-
-{{for name, dest, c_type_in, c_type_out, preval, postval, can_copy,
-      inner_take_1d, inner_take_2d_axis0, inner_take_2d_axis1
-      in get_dispatch(dtypes)}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline take_1d_{{name}}_{{dest}}_memview({{c_type_in}}[:] values,
-                                              const int64_t[:] indexer,
-                                              {{c_type_out}}[:] out,
-                                              fill_value=np.nan):
-
-
-{{inner_take_1d}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def take_1d_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=1] values,
-                              const int64_t[:] indexer,
-                              {{c_type_out}}[:] out,
-                              fill_value=np.nan):
-
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_1d_{{name}}_{{dest}}_memview(values, indexer, out,
-                                          fill_value=fill_value)
-        return
-
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_1d}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline take_2d_axis0_{{name}}_{{dest}}_memview({{c_type_in}}[:, :] values,
-                                                    const int64_t[:] indexer,
-                                                    {{c_type_out}}[:, :] out,
-                                                    fill_value=np.nan):
-{{inner_take_2d_axis0}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def take_2d_axis0_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
-                                    ndarray[int64_t] indexer,
-                                    {{c_type_out}}[:, :] out,
-                                    fill_value=np.nan):
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_2d_axis0_{{name}}_{{dest}}_memview(values, indexer, out,
-                                                fill_value=fill_value)
-        return
-
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_2d_axis0}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-cdef inline take_2d_axis1_{{name}}_{{dest}}_memview({{c_type_in}}[:, :] values,
-                                                    const int64_t[:] indexer,
-                                                    {{c_type_out}}[:, :] out,
-                                                    fill_value=np.nan):
-{{inner_take_2d_axis1}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def take_2d_axis1_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
-                                    ndarray[int64_t] indexer,
-                                    {{c_type_out}}[:, :] out,
-                                    fill_value=np.nan):
-
-    if values.flags.writeable:
-        # We can call the memoryview version of the code
-        take_2d_axis1_{{name}}_{{dest}}_memview(values, indexer, out,
-                                                fill_value=fill_value)
-        return
-
-    # We cannot use the memoryview version on readonly-buffers due to
-    # a limitation of Cython's typed memoryviews. Instead we can use
-    # the slightly slower Cython ndarray type directly.
-{{inner_take_2d_axis1}}
+                {{if c_type_in == "uint8_t" and c_type_out == "object"}}
+                out[i, j] = True if values[i, idx] > 0 else False
+                {{else}}
+                out[i, j] = values[i, idx]
+                {{endif}}
 
 
 @cython.wraparound(False)
@@ -256,7 +211,11 @@ def take_2d_multi_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
                 if idx1[j] == -1:
                     out[i, j] = fv
                 else:
-                    out[i, j] = {{preval}}values[idx, idx1[j]]{{postval}}
+                    {{if c_type_in == "uint8_t" and c_type_out == "object"}}
+                    out[i, j] = True if values[idx, idx1[j]] > 0 else False
+                    {{else}}
+                    out[i, j] = values[idx, idx1[j]]
+                    {{endif}}
 
 {{endfor}}
 
@@ -276,7 +235,6 @@ cdef _take_2d(ndarray[take_t, ndim=2] values, object idx):
         Py_ssize_t i, j, N, K
         ndarray[Py_ssize_t, ndim=2, cast=True] indexer = idx
         ndarray[take_t, ndim=2] result
-        object val
 
     N, K = (<object>values).shape
 
@@ -290,9 +248,3 @@ cdef _take_2d(ndarray[take_t, ndim=2] values, object idx):
         for j in range(K):
             result[i, j] = values[i, indexer[i, j]]
     return result
-
-
-_take_2d_object = _take_2d[object]
-_take_2d_float64 = _take_2d[float64_t]
-_take_2d_int64 = _take_2d[int64_t]
-_take_2d_uint64 = _take_2d[uint64_t]
diff --git a/pandas/_libs/groupby.pxd b/pandas/_libs/groupby.pxd
deleted file mode 100644
index 70ad8a62871e9..0000000000000
--- a/pandas/_libs/groupby.pxd
+++ /dev/null
@@ -1,6 +0,0 @@
-cdef enum InterpolationEnumType:
-    INTERPOLATION_LINEAR,
-    INTERPOLATION_LOWER,
-    INTERPOLATION_HIGHER,
-    INTERPOLATION_NEAREST,
-    INTERPOLATION_MIDPOINT
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index 3069bbbf34bb7..edc44f1c94589 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -8,9 +8,11 @@ import numpy as np
 cimport numpy as cnp
 from numpy cimport (ndarray,
                     int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t,
-                    uint32_t, uint64_t, float32_t, float64_t)
+                    uint32_t, uint64_t, float32_t, float64_t, complex64_t, complex128_t)
 cnp.import_array()
 
+cdef extern from "numpy/npy_math.h":
+    float64_t NAN "NPY_NAN"
 
 from pandas._libs.util cimport numeric, get_nat
 
@@ -21,9 +23,17 @@ from pandas._libs.algos import (take_2d_axis1_float64_float64,
                                 groupsort_indexer, tiebreakers)
 
 cdef int64_t NPY_NAT = get_nat()
+_int64_max = np.iinfo(np.int64).max
 
 cdef float64_t NaN = <float64_t>np.NaN
 
+cdef enum InterpolationEnumType:
+    INTERPOLATION_LINEAR,
+    INTERPOLATION_LOWER,
+    INTERPOLATION_HIGHER,
+    INTERPOLATION_NEAREST,
+    INTERPOLATION_MIDPOINT
+
 
 cdef inline float64_t median_linear(float64_t* a, int n) nogil:
     cdef:
@@ -143,7 +153,8 @@ def group_cumprod_float64(float64_t[:, :] out,
                           int ngroups,
                           bint is_datetimelike,
                           bint skipna=True):
-    """Cumulative product of columns of `values`, in row groups `labels`.
+    """
+    Cumulative product of columns of `values`, in row groups `labels`.
 
     Parameters
     ----------
@@ -164,7 +175,6 @@ def group_cumprod_float64(float64_t[:, :] out,
     -----
     This method modifies the `out` parameter, rather than returning an object.
     """
-
     cdef:
         Py_ssize_t i, j, N, K, size
         float64_t val
@@ -200,7 +210,8 @@ def group_cumsum(numeric[:, :] out,
                  int ngroups,
                  is_datetimelike,
                  bint skipna=True):
-    """Cumulative sum of columns of `values`, in row groups `labels`.
+    """
+    Cumulative sum of columns of `values`, in row groups `labels`.
 
     Parameters
     ----------
@@ -221,7 +232,6 @@ def group_cumsum(numeric[:, :] out,
     -----
     This method modifies the `out` parameter, rather than returning an object.
     """
-
     cdef:
         Py_ssize_t i, j, N, K, size
         numeric val
@@ -311,7 +321,8 @@ def group_shift_indexer(int64_t[:] out, const int64_t[:] labels,
 def group_fillna_indexer(ndarray[int64_t] out, ndarray[int64_t] labels,
                          ndarray[uint8_t] mask, object direction,
                          int64_t limit):
-    """Indexes how to fill values forwards or backwards within a group
+    """
+    Indexes how to fill values forwards or backwards within a group.
 
     Parameters
     ----------
@@ -372,7 +383,8 @@ def group_any_all(uint8_t[:] out,
                   const uint8_t[:] mask,
                   object val_test,
                   bint skipna):
-    """Aggregated boolean values to show truthfulness of group elements
+    """
+    Aggregated boolean values to show truthfulness of group elements.
 
     Parameters
     ----------
@@ -420,16 +432,23 @@ def group_any_all(uint8_t[:] out,
             if values[i] == flag_val:
                 out[lab] = flag_val
 
+
 # ----------------------------------------------------------------------
 # group_add, group_prod, group_var, group_mean, group_ohlc
 # ----------------------------------------------------------------------
 
+ctypedef fused complexfloating_t:
+    float64_t
+    float32_t
+    complex64_t
+    complex128_t
+
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def _group_add(floating[:, :] out,
+def _group_add(complexfloating_t[:, :] out,
                int64_t[:] counts,
-               floating[:, :] values,
+               complexfloating_t[:, :] values,
                const int64_t[:] labels,
                Py_ssize_t min_count=0):
     """
@@ -437,13 +456,14 @@ def _group_add(floating[:, :] out,
     """
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        floating val, count
-        floating[:, :] sumx, nobs
+        complexfloating_t val, count
+        complexfloating_t[:, :] sumx
+        int64_t[:, :] nobs
 
     if len(values) != len(labels):
-        raise AssertionError("len(index) != len(labels)")
+        raise ValueError("len(index) != len(labels)")
 
-    nobs = np.zeros_like(out)
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
     sumx = np.zeros_like(out)
 
     N, K = (<object>values).shape
@@ -461,7 +481,12 @@ def _group_add(floating[:, :] out,
                 # not nan
                 if val == val:
                     nobs[lab, j] += 1
-                    sumx[lab, j] += val
+                    if (complexfloating_t is complex64_t or
+                            complexfloating_t is complex128_t):
+                        # clang errors if we use += with these dtypes
+                        sumx[lab, j] = sumx[lab, j] + val
+                    else:
+                        sumx[lab, j] += val
 
         for i in range(ncounts):
             for j in range(K):
@@ -471,8 +496,10 @@ def _group_add(floating[:, :] out,
                     out[i, j] = sumx[i, j]
 
 
-group_add_float32 = _group_add['float']
-group_add_float64 = _group_add['double']
+group_add_float32 = _group_add['float32_t']
+group_add_float64 = _group_add['float64_t']
+group_add_complex64 = _group_add['float complex']
+group_add_complex128 = _group_add['double complex']
 
 
 @cython.wraparound(False)
@@ -488,12 +515,13 @@ def _group_prod(floating[:, :] out,
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
         floating val, count
-        floating[:, :] prodx, nobs
+        floating[:, :] prodx
+        int64_t[:, :] nobs
 
     if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
+        raise ValueError("len(index) != len(labels)")
 
-    nobs = np.zeros_like(out)
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
     prodx = np.ones_like(out)
 
     N, K = (<object>values).shape
@@ -536,14 +564,15 @@ def _group_var(floating[:, :] out,
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
         floating val, ct, oldmean
-        floating[:, :] nobs, mean
+        floating[:, :] mean
+        int64_t[:, :] nobs
 
     assert min_count == -1, "'min_count' only used in add and prod"
 
     if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
+        raise ValueError("len(index) != len(labels)")
 
-    nobs = np.zeros_like(out)
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
     mean = np.zeros_like(out)
 
     N, K = (<object>values).shape
@@ -591,14 +620,15 @@ def _group_mean(floating[:, :] out,
     cdef:
         Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
         floating val, count
-        floating[:, :] sumx, nobs
+        floating[:, :] sumx
+        int64_t[:, :] nobs
 
     assert min_count == -1, "'min_count' only used in add and prod"
 
     if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
+        raise ValueError("len(index) != len(labels)")
 
-    nobs = np.zeros_like(out)
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
     sumx = np.zeros_like(out)
 
     N, K = (<object>values).shape
@@ -656,8 +686,7 @@ def _group_ohlc(floating[:, :] out,
         raise ValueError('Output array must have 4 columns')
 
     if K > 1:
-        raise NotImplementedError("Argument 'values' must have only "
-                                  "one dimension")
+        raise NotImplementedError("Argument 'values' must have only one dimension")
     out[:] = np.nan
 
     with nogil:
@@ -721,8 +750,7 @@ def group_quantile(ndarray[float64_t] out,
     assert values.shape[0] == N
 
     if not (0 <= q <= 1):
-        raise ValueError("'q' must be between 0 and 1. Got"
-                         " '{}' instead".format(q))
+        raise ValueError(f"'q' must be between 0 and 1. Got '{q}' instead")
 
     inter_methods = {
         'linear': INTERPOLATION_LINEAR,
@@ -741,6 +769,9 @@ def group_quantile(ndarray[float64_t] out,
     with nogil:
         for i in range(N):
             lab = labels[i]
+            if lab == -1:  # NA group label
+                continue
+
             counts[lab] += 1
             if not mask[i]:
                 non_na_counts[lab] += 1
@@ -759,7 +790,7 @@ def group_quantile(ndarray[float64_t] out,
                 out[i] = NaN
             else:
                 # Calculate where to retrieve the desired value
-                # Casting to int will intentionaly truncate result
+                # Casting to int will intentionally truncate result
                 idx = grp_start + <int64_t>(q * <float64_t>(non_na_sz - 1))
 
                 val = values[sort_arr[idx]]
@@ -788,5 +819,676 @@ def group_quantile(ndarray[float64_t] out,
             grp_start += grp_sz
 
 
-# generated from template
-include "groupby_helper.pxi"
+# ----------------------------------------------------------------------
+# group_nth, group_last, group_rank
+# ----------------------------------------------------------------------
+
+ctypedef fused rank_t:
+    float64_t
+    float32_t
+    int64_t
+    uint64_t
+    object
+
+
+cdef inline bint _treat_as_na(rank_t val, bint is_datetimelike) nogil:
+    if rank_t is object:
+        # Should never be used, but we need to avoid the `val != val` below
+        #  or else cython will raise about gil acquisition.
+        raise NotImplementedError
+
+    elif rank_t is int64_t:
+        return is_datetimelike and val == NPY_NAT
+    elif rank_t is uint64_t:
+        # There is no NA value for uint64
+        return False
+    else:
+        return val != val
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def group_last(rank_t[:, :] out,
+               int64_t[:] counts,
+               rank_t[:, :] values,
+               const int64_t[:] labels,
+               Py_ssize_t min_count=-1):
+    """
+    Only aggregates on axis=0
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
+        rank_t val
+        ndarray[rank_t, ndim=2] resx
+        ndarray[int64_t, ndim=2] nobs
+        bint runtime_error = False
+
+    assert min_count == -1, "'min_count' only used in add and prod"
+
+    if not len(values) == len(labels):
+        raise AssertionError("len(index) != len(labels)")
+
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
+    if rank_t is object:
+        resx = np.empty((<object>out).shape, dtype=object)
+    else:
+        resx = np.empty_like(out)
+
+    N, K = (<object>values).shape
+
+    if rank_t is object:
+        # TODO: De-duplicate once conditional-nogil is available
+        for i in range(N):
+            lab = labels[i]
+            if lab < 0:
+                continue
+
+            counts[lab] += 1
+            for j in range(K):
+                val = values[i, j]
+
+                if val == val:
+                    # NB: use _treat_as_na here once
+                    #  conditional-nogil is available.
+                    nobs[lab, j] += 1
+                    resx[lab, j] = val
+
+        for i in range(ncounts):
+            for j in range(K):
+                if nobs[i, j] == 0:
+                    out[i, j] = NAN
+                else:
+                    out[i, j] = resx[i, j]
+    else:
+        with nogil:
+            for i in range(N):
+                lab = labels[i]
+                if lab < 0:
+                    continue
+
+                counts[lab] += 1
+                for j in range(K):
+                    val = values[i, j]
+
+                    if not _treat_as_na(val, True):
+                        # TODO: Sure we always want is_datetimelike=True?
+                        nobs[lab, j] += 1
+                        resx[lab, j] = val
+
+            for i in range(ncounts):
+                for j in range(K):
+                    if nobs[i, j] == 0:
+                        if rank_t is int64_t:
+                            out[i, j] = NPY_NAT
+                        elif rank_t is uint64_t:
+                            runtime_error = True
+                            break
+                        else:
+                            out[i, j] = NAN
+
+                    else:
+                        out[i, j] = resx[i, j]
+
+    if runtime_error:
+        # We cannot raise directly above because that is within a nogil
+        #  block.
+        raise RuntimeError("empty group with uint64_t")
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def group_nth(rank_t[:, :] out,
+              int64_t[:] counts,
+              rank_t[:, :] values,
+              const int64_t[:] labels, int64_t rank=1,
+              Py_ssize_t min_count=-1):
+    """
+    Only aggregates on axis=0
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
+        rank_t val
+        ndarray[rank_t, ndim=2] resx
+        ndarray[int64_t, ndim=2] nobs
+        bint runtime_error = False
+
+    assert min_count == -1, "'min_count' only used in add and prod"
+
+    if not len(values) == len(labels):
+        raise AssertionError("len(index) != len(labels)")
+
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
+    if rank_t is object:
+        resx = np.empty((<object>out).shape, dtype=object)
+    else:
+        resx = np.empty_like(out)
+
+    N, K = (<object>values).shape
+
+    if rank_t is object:
+        # TODO: De-duplicate once conditional-nogil is available
+        for i in range(N):
+            lab = labels[i]
+            if lab < 0:
+                continue
+
+            counts[lab] += 1
+            for j in range(K):
+                val = values[i, j]
+
+                if val == val:
+                    # NB: use _treat_as_na here once
+                    #  conditional-nogil is available.
+                    nobs[lab, j] += 1
+                    if nobs[lab, j] == rank:
+                        resx[lab, j] = val
+
+        for i in range(ncounts):
+            for j in range(K):
+                if nobs[i, j] == 0:
+                    out[i, j] = NAN
+                else:
+                    out[i, j] = resx[i, j]
+
+    else:
+        with nogil:
+            for i in range(N):
+                lab = labels[i]
+                if lab < 0:
+                    continue
+
+                counts[lab] += 1
+                for j in range(K):
+                    val = values[i, j]
+
+                    if not _treat_as_na(val, True):
+                        # TODO: Sure we always want is_datetimelike=True?
+                        nobs[lab, j] += 1
+                        if nobs[lab, j] == rank:
+                            resx[lab, j] = val
+
+            for i in range(ncounts):
+                for j in range(K):
+                    if nobs[i, j] == 0:
+                        if rank_t is int64_t:
+                            out[i, j] = NPY_NAT
+                        elif rank_t is uint64_t:
+                            runtime_error = True
+                            break
+                        else:
+                            out[i, j] = NAN
+                    else:
+                        out[i, j] = resx[i, j]
+
+    if runtime_error:
+        # We cannot raise directly above because that is within a nogil
+        #  block.
+        raise RuntimeError("empty group with uint64_t")
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def group_rank(float64_t[:, :] out,
+               rank_t[:, :] values,
+               const int64_t[:] labels,
+               int ngroups,
+               bint is_datetimelike, object ties_method="average",
+               bint ascending=True, bint pct=False, object na_option="keep"):
+    """
+    Provides the rank of values within each group.
+
+    Parameters
+    ----------
+    out : array of float64_t values which this method will write its results to
+    values : array of rank_t values to be ranked
+    labels : array containing unique label for each group, with its ordering
+        matching up to the corresponding record in `values`
+    ngroups : int
+        This parameter is not used, is needed to match signatures of other
+        groupby functions.
+    is_datetimelike : bool, default False
+        unused in this method but provided for call compatibility with other
+        Cython transformations
+    ties_method : {'average', 'min', 'max', 'first', 'dense'}, default
+        'average'
+        * average: average rank of group
+        * min: lowest rank in group
+        * max: highest rank in group
+        * first: ranks assigned in order they appear in the array
+        * dense: like 'min', but rank always increases by 1 between groups
+    ascending : boolean, default True
+        False for ranks by high (1) to low (N)
+        na_option : {'keep', 'top', 'bottom'}, default 'keep'
+    pct : boolean, default False
+        Compute percentage rank of data within each group
+    na_option : {'keep', 'top', 'bottom'}, default 'keep'
+        * keep: leave NA values where they are
+        * top: smallest rank if ascending
+        * bottom: smallest rank if descending
+
+    Notes
+    -----
+    This method modifies the `out` parameter rather than returning an object
+    """
+    cdef:
+        TiebreakEnumType tiebreak
+        Py_ssize_t i, j, N, K, grp_start=0, dups=0, sum_ranks=0
+        Py_ssize_t grp_vals_seen=1, grp_na_count=0, grp_tie_count=0
+        ndarray[int64_t] _as
+        ndarray[float64_t, ndim=2] grp_sizes
+        ndarray[rank_t] masked_vals
+        ndarray[uint8_t] mask
+        bint keep_na
+        rank_t nan_fill_val
+
+    if rank_t is object:
+        raise NotImplementedError("Cant do nogil")
+
+    tiebreak = tiebreakers[ties_method]
+    keep_na = na_option == 'keep'
+    N, K = (<object>values).shape
+    grp_sizes = np.ones_like(out)
+
+    # Copy values into new array in order to fill missing data
+    # with mask, without obfuscating location of missing data
+    # in values array
+    masked_vals = np.array(values[:, 0], copy=True)
+    if rank_t is int64_t:
+        mask = (masked_vals == NPY_NAT).astype(np.uint8)
+    else:
+        mask = np.isnan(masked_vals).astype(np.uint8)
+
+    if ascending ^ (na_option == 'top'):
+        if rank_t is int64_t:
+            nan_fill_val = np.iinfo(np.int64).max
+        elif rank_t is uint64_t:
+            nan_fill_val = np.iinfo(np.uint64).max
+        else:
+            nan_fill_val = np.inf
+        order = (masked_vals, mask, labels)
+    else:
+        if rank_t is int64_t:
+            nan_fill_val = np.iinfo(np.int64).min
+        elif rank_t is uint64_t:
+            nan_fill_val = 0
+        else:
+            nan_fill_val = -np.inf
+
+        order = (masked_vals, ~mask, labels)
+    np.putmask(masked_vals, mask, nan_fill_val)
+
+    # lexsort using labels, then mask, then actual values
+    # each label corresponds to a different group value,
+    # the mask helps you differentiate missing values before
+    # performing sort on the actual values
+    _as = np.lexsort(order).astype(np.int64, copy=False)
+
+    if not ascending:
+        _as = _as[::-1]
+
+    with nogil:
+        # Loop over the length of the value array
+        # each incremental i value can be looked up in the _as array
+        # that we sorted previously, which gives us the location of
+        # that sorted value for retrieval back from the original
+        # values / masked_vals arrays
+        for i in range(N):
+            # dups and sum_ranks will be incremented each loop where
+            # the value / group remains the same, and should be reset
+            # when either of those change
+            # Used to calculate tiebreakers
+            dups += 1
+            sum_ranks += i - grp_start + 1
+
+            # Update out only when there is a transition of values or labels.
+            # When a new value or group is encountered, go back #dups steps(
+            # the number of occurrence of current value) and assign the ranks
+            # based on the starting index of the current group (grp_start)
+            # and the current index
+            if (i == N - 1 or
+                    (masked_vals[_as[i]] != masked_vals[_as[i+1]]) or
+                    (mask[_as[i]] ^ mask[_as[i+1]]) or
+                    (labels[_as[i]] != labels[_as[i+1]])):
+                # if keep_na, check for missing values and assign back
+                # to the result where appropriate
+                if keep_na and mask[_as[i]]:
+                    for j in range(i - dups + 1, i + 1):
+                        out[_as[j], 0] = NaN
+                        grp_na_count = dups
+                elif tiebreak == TIEBREAK_AVERAGE:
+                    for j in range(i - dups + 1, i + 1):
+                        out[_as[j], 0] = sum_ranks / <float64_t>dups
+                elif tiebreak == TIEBREAK_MIN:
+                    for j in range(i - dups + 1, i + 1):
+                        out[_as[j], 0] = i - grp_start - dups + 2
+                elif tiebreak == TIEBREAK_MAX:
+                    for j in range(i - dups + 1, i + 1):
+                        out[_as[j], 0] = i - grp_start + 1
+                elif tiebreak == TIEBREAK_FIRST:
+                    for j in range(i - dups + 1, i + 1):
+                        if ascending:
+                            out[_as[j], 0] = j + 1 - grp_start
+                        else:
+                            out[_as[j], 0] = 2 * i - j - dups + 2 - grp_start
+                elif tiebreak == TIEBREAK_DENSE:
+                    for j in range(i - dups + 1, i + 1):
+                        out[_as[j], 0] = grp_vals_seen
+
+                # look forward to the next value (using the sorting in _as)
+                # if the value does not equal the current value then we need to
+                # reset the dups and sum_ranks, knowing that a new value is
+                # coming up. the conditional also needs to handle nan equality
+                # and the end of iteration
+                if (i == N - 1 or
+                        (masked_vals[_as[i]] != masked_vals[_as[i+1]]) or
+                        (mask[_as[i]] ^ mask[_as[i+1]])):
+                    dups = sum_ranks = 0
+                    grp_vals_seen += 1
+                    grp_tie_count += 1
+
+                # Similar to the previous conditional, check now if we are
+                # moving to a new group. If so, keep track of the index where
+                # the new group occurs, so the tiebreaker calculations can
+                # decrement that from their position. fill in the size of each
+                # group encountered (used by pct calculations later). also be
+                # sure to reset any of the items helping to calculate dups
+                if i == N - 1 or labels[_as[i]] != labels[_as[i+1]]:
+                    if tiebreak != TIEBREAK_DENSE:
+                        for j in range(grp_start, i + 1):
+                            grp_sizes[_as[j], 0] = (i - grp_start + 1 -
+                                                    grp_na_count)
+                    else:
+                        for j in range(grp_start, i + 1):
+                            grp_sizes[_as[j], 0] = (grp_tie_count -
+                                                    (grp_na_count > 0))
+                    dups = sum_ranks = 0
+                    grp_na_count = 0
+                    grp_tie_count = 0
+                    grp_start = i + 1
+                    grp_vals_seen = 1
+
+        if pct:
+            for i in range(N):
+                # We don't include NaN values in percentage
+                # rankings, so we assign them percentages of NaN.
+                if out[i, 0] != out[i, 0] or out[i, 0] == NAN:
+                    out[i, 0] = NAN
+                elif grp_sizes[i, 0] != 0:
+                    out[i, 0] = out[i, 0] / grp_sizes[i, 0]
+
+
+# ----------------------------------------------------------------------
+# group_min, group_max
+# ----------------------------------------------------------------------
+
+# TODO: consider implementing for more dtypes
+ctypedef fused groupby_t:
+    float64_t
+    float32_t
+    int64_t
+    uint64_t
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def group_max(groupby_t[:, :] out,
+              int64_t[:] counts,
+              groupby_t[:, :] values,
+              const int64_t[:] labels,
+              Py_ssize_t min_count=-1):
+    """
+    Only aggregates on axis=0
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
+        groupby_t val, count, nan_val
+        ndarray[groupby_t, ndim=2] maxx
+        bint runtime_error = False
+        int64_t[:, :] nobs
+
+    assert min_count == -1, "'min_count' only used in add and prod"
+
+    if not len(values) == len(labels):
+        raise AssertionError("len(index) != len(labels)")
+
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
+
+    maxx = np.empty_like(out)
+    if groupby_t is int64_t:
+        # Note: evaluated at compile-time
+        maxx[:] = -_int64_max
+        nan_val = NPY_NAT
+    elif groupby_t is uint64_t:
+        # NB: We do not define nan_val because there is no such thing
+        #  for uint64_t.  We carefully avoid having to reference it in this
+        #  case.
+        maxx[:] = 0
+    else:
+        maxx[:] = -np.inf
+        nan_val = NAN
+
+    N, K = (<object>values).shape
+
+    with nogil:
+        for i in range(N):
+            lab = labels[i]
+            if lab < 0:
+                continue
+
+            counts[lab] += 1
+            for j in range(K):
+                val = values[i, j]
+
+                if not _treat_as_na(val, True):
+                    # TODO: Sure we always want is_datetimelike=True?
+                    nobs[lab, j] += 1
+                    if val > maxx[lab, j]:
+                        maxx[lab, j] = val
+
+        for i in range(ncounts):
+            for j in range(K):
+                if nobs[i, j] == 0:
+                    if groupby_t is uint64_t:
+                        runtime_error = True
+                        break
+                    else:
+                        out[i, j] = nan_val
+                else:
+                    out[i, j] = maxx[i, j]
+
+    if runtime_error:
+        # We cannot raise directly above because that is within a nogil
+        #  block.
+        raise RuntimeError("empty group with uint64_t")
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def group_min(groupby_t[:, :] out,
+              int64_t[:] counts,
+              groupby_t[:, :] values,
+              const int64_t[:] labels,
+              Py_ssize_t min_count=-1):
+    """
+    Only aggregates on axis=0
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
+        groupby_t val, count, nan_val
+        ndarray[groupby_t, ndim=2] minx
+        bint runtime_error = False
+        int64_t[:, :] nobs
+
+    assert min_count == -1, "'min_count' only used in add and prod"
+
+    if not len(values) == len(labels):
+        raise AssertionError("len(index) != len(labels)")
+
+    nobs = np.zeros((<object>out).shape, dtype=np.int64)
+
+    minx = np.empty_like(out)
+    if groupby_t is int64_t:
+        minx[:] = _int64_max
+        nan_val = NPY_NAT
+    elif groupby_t is uint64_t:
+        # NB: We do not define nan_val because there is no such thing
+        #  for uint64_t.  We carefully avoid having to reference it in this
+        #  case.
+        minx[:] = np.iinfo(np.uint64).max
+    else:
+        minx[:] = np.inf
+        nan_val = NAN
+
+    N, K = (<object>values).shape
+
+    with nogil:
+        for i in range(N):
+            lab = labels[i]
+            if lab < 0:
+                continue
+
+            counts[lab] += 1
+            for j in range(K):
+                val = values[i, j]
+
+                if not _treat_as_na(val, True):
+                    # TODO: Sure we always want is_datetimelike=True?
+                    nobs[lab, j] += 1
+                    if val < minx[lab, j]:
+                        minx[lab, j] = val
+
+        for i in range(ncounts):
+            for j in range(K):
+                if nobs[i, j] == 0:
+                    if groupby_t is uint64_t:
+                        runtime_error = True
+                        break
+                    else:
+                        out[i, j] = nan_val
+                else:
+                    out[i, j] = minx[i, j]
+
+    if runtime_error:
+        # We cannot raise directly above because that is within a nogil
+        #  block.
+        raise RuntimeError("empty group with uint64_t")
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def group_cummin(groupby_t[:, :] out,
+                 groupby_t[:, :] values,
+                 const int64_t[:] labels,
+                 int ngroups,
+                 bint is_datetimelike):
+    """
+    Cumulative minimum of columns of `values`, in row groups `labels`.
+
+    Parameters
+    ----------
+    out : array
+        Array to store cummin in.
+    values : array
+        Values to take cummin of.
+    labels : int64 array
+        Labels to group by.
+    ngroups : int
+        Number of groups, larger than all entries of `labels`.
+    is_datetimelike : bool
+        True if `values` contains datetime-like entries.
+
+    Notes
+    -----
+    This method modifies the `out` parameter, rather than returning an object.
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, size
+        groupby_t val, mval
+        ndarray[groupby_t, ndim=2] accum
+        int64_t lab
+
+    N, K = (<object>values).shape
+    accum = np.empty((ngroups, K), dtype=np.asarray(values).dtype)
+    if groupby_t is int64_t:
+        accum[:] = _int64_max
+    elif groupby_t is uint64_t:
+        accum[:] = np.iinfo(np.uint64).max
+    else:
+        accum[:] = np.inf
+
+    with nogil:
+        for i in range(N):
+            lab = labels[i]
+
+            if lab < 0:
+                continue
+            for j in range(K):
+                val = values[i, j]
+
+                if _treat_as_na(val, is_datetimelike):
+                    out[i, j] = val
+                else:
+                    mval = accum[lab, j]
+                    if val < mval:
+                        accum[lab, j] = mval = val
+                    out[i, j] = mval
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def group_cummax(groupby_t[:, :] out,
+                 groupby_t[:, :] values,
+                 const int64_t[:] labels,
+                 int ngroups,
+                 bint is_datetimelike):
+    """
+    Cumulative maximum of columns of `values`, in row groups `labels`.
+
+    Parameters
+    ----------
+    out : array
+        Array to store cummax in.
+    values : array
+        Values to take cummax of.
+    labels : int64 array
+        Labels to group by.
+    ngroups : int
+        Number of groups, larger than all entries of `labels`.
+    is_datetimelike : bool
+        True if `values` contains datetime-like entries.
+
+    Notes
+    -----
+    This method modifies the `out` parameter, rather than returning an object.
+    """
+    cdef:
+        Py_ssize_t i, j, N, K, size
+        groupby_t val, mval
+        ndarray[groupby_t, ndim=2] accum
+        int64_t lab
+
+    N, K = (<object>values).shape
+    accum = np.empty((ngroups, K), dtype=np.asarray(values).dtype)
+    if groupby_t is int64_t:
+        accum[:] = -_int64_max
+    elif groupby_t is uint64_t:
+        accum[:] = 0
+    else:
+        accum[:] = -np.inf
+
+    with nogil:
+        for i in range(N):
+            lab = labels[i]
+
+            if lab < 0:
+                continue
+            for j in range(K):
+                val = values[i, j]
+
+                if _treat_as_na(val, is_datetimelike):
+                    out[i, j] = val
+                else:
+                    mval = accum[lab, j]
+                    if val > mval:
+                        accum[lab, j] = mval = val
+                    out[i, j] = mval
diff --git a/pandas/_libs/groupby_helper.pxi.in b/pandas/_libs/groupby_helper.pxi.in
deleted file mode 100644
index 000689f634545..0000000000000
--- a/pandas/_libs/groupby_helper.pxi.in
+++ /dev/null
@@ -1,608 +0,0 @@
-"""
-Template for each `dtype` helper function using groupby
-
-WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
-"""
-
-cdef extern from "numpy/npy_math.h":
-    float64_t NAN "NPY_NAN"
-_int64_max = np.iinfo(np.int64).max
-
-# ----------------------------------------------------------------------
-# group_nth, group_last, group_rank
-# ----------------------------------------------------------------------
-
-{{py:
-
-# name, c_type, nan_val
-dtypes = [('float64', 'float64_t', 'NAN'),
-          ('float32', 'float32_t', 'NAN'),
-          ('int64', 'int64_t', 'NPY_NAT'),
-          ('object', 'object', 'NAN')]
-
-def get_dispatch(dtypes):
-
-    for name, c_type, nan_val in dtypes:
-
-        yield name, c_type, nan_val
-}}
-
-
-{{for name, c_type, nan_val in get_dispatch(dtypes)}}
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def group_last_{{name}}({{c_type}}[:, :] out,
-                        int64_t[:] counts,
-                        {{c_type}}[:, :] values,
-                        const int64_t[:] labels,
-                        Py_ssize_t min_count=-1):
-    """
-    Only aggregates on axis=0
-    """
-    cdef:
-        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        {{c_type}} val
-        ndarray[{{c_type}}, ndim=2] resx
-        ndarray[int64_t, ndim=2] nobs
-
-    assert min_count == -1, "'min_count' only used in add and prod"
-
-    if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
-
-    nobs = np.zeros((<object>out).shape, dtype=np.int64)
-    {{if name == 'object'}}
-    resx = np.empty((<object>out).shape, dtype=object)
-    {{else}}
-    resx = np.empty_like(out)
-    {{endif}}
-
-    N, K = (<object>values).shape
-
-    {{if name == "object"}}
-    if True:  # make templating happy
-    {{else}}
-    with nogil:
-    {{endif}}
-        for i in range(N):
-            lab = labels[i]
-            if lab < 0:
-                continue
-
-            counts[lab] += 1
-            for j in range(K):
-                val = values[i, j]
-
-                # not nan
-                if (
-                {{if not name.startswith("int")}}
-                val == val and
-                {{endif}}
-                val != {{nan_val}}):
-                    nobs[lab, j] += 1
-                    resx[lab, j] = val
-
-        for i in range(ncounts):
-            for j in range(K):
-                if nobs[i, j] == 0:
-                    out[i, j] = {{nan_val}}
-                else:
-                    out[i, j] = resx[i, j]
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def group_nth_{{name}}({{c_type}}[:, :] out,
-                       int64_t[:] counts,
-                       {{c_type}}[:, :] values,
-                       const int64_t[:] labels, int64_t rank,
-                       Py_ssize_t min_count=-1):
-    """
-    Only aggregates on axis=0
-    """
-    cdef:
-        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        {{c_type}} val
-        ndarray[{{c_type}}, ndim=2] resx
-        ndarray[int64_t, ndim=2] nobs
-
-    assert min_count == -1, "'min_count' only used in add and prod"
-
-    if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
-
-    nobs = np.zeros((<object>out).shape, dtype=np.int64)
-    {{if name=='object'}}
-    resx = np.empty((<object>out).shape, dtype=object)
-    {{else}}
-    resx = np.empty_like(out)
-    {{endif}}
-
-    N, K = (<object>values).shape
-
-    {{if name == "object"}}
-    if True:  # make templating happy
-    {{else}}
-    with nogil:
-    {{endif}}
-        for i in range(N):
-            lab = labels[i]
-            if lab < 0:
-                continue
-
-            counts[lab] += 1
-            for j in range(K):
-                val = values[i, j]
-
-                # not nan
-                if (
-                {{if not name.startswith("int")}}
-                val == val and
-                {{endif}}
-                val != {{nan_val}}):
-                    nobs[lab, j] += 1
-                    if nobs[lab, j] == rank:
-                        resx[lab, j] = val
-
-        for i in range(ncounts):
-            for j in range(K):
-                if nobs[i, j] == 0:
-                    out[i, j] = {{nan_val}}
-                else:
-                    out[i, j] = resx[i, j]
-
-
-{{if name != 'object'}}
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def group_rank_{{name}}(float64_t[:, :] out,
-                        {{c_type}}[:, :] values,
-                        const int64_t[:] labels,
-                        bint is_datetimelike, object ties_method,
-                        bint ascending, bint pct, object na_option):
-    """
-    Provides the rank of values within each group.
-
-    Parameters
-    ----------
-    out : array of float64_t values which this method will write its results to
-    values : array of {{c_type}} values to be ranked
-    labels : array containing unique label for each group, with its ordering
-        matching up to the corresponding record in `values`
-    is_datetimelike : bool, default False
-        unused in this method but provided for call compatibility with other
-        Cython transformations
-    ties_method : {'average', 'min', 'max', 'first', 'dense'}, default
-        'average'
-        * average: average rank of group
-        * min: lowest rank in group
-        * max: highest rank in group
-        * first: ranks assigned in order they appear in the array
-        * dense: like 'min', but rank always increases by 1 between groups
-    ascending : boolean, default True
-        False for ranks by high (1) to low (N)
-        na_option : {'keep', 'top', 'bottom'}, default 'keep'
-    pct : boolean, default False
-        Compute percentage rank of data within each group
-    na_option : {'keep', 'top', 'bottom'}, default 'keep'
-        * keep: leave NA values where they are
-        * top: smallest rank if ascending
-        * bottom: smallest rank if descending
-
-    Notes
-    -----
-    This method modifies the `out` parameter rather than returning an object
-    """
-    cdef:
-        TiebreakEnumType tiebreak
-        Py_ssize_t i, j, N, K, grp_start=0, dups=0, sum_ranks=0
-        Py_ssize_t grp_vals_seen=1, grp_na_count=0, grp_tie_count=0
-        ndarray[int64_t] _as
-        ndarray[float64_t, ndim=2] grp_sizes
-        ndarray[{{c_type}}] masked_vals
-        ndarray[uint8_t] mask
-        bint keep_na
-        {{c_type}} nan_fill_val
-
-    tiebreak = tiebreakers[ties_method]
-    keep_na = na_option == 'keep'
-    N, K = (<object>values).shape
-    grp_sizes = np.ones_like(out)
-
-    # Copy values into new array in order to fill missing data
-    # with mask, without obfuscating location of missing data
-    # in values array
-    masked_vals = np.array(values[:, 0], copy=True)
-    {{if name == 'int64'}}
-    mask = (masked_vals == {{nan_val}}).astype(np.uint8)
-    {{else}}
-    mask = np.isnan(masked_vals).astype(np.uint8)
-    {{endif}}
-
-    if ascending ^ (na_option == 'top'):
-        {{if name == 'int64'}}
-        nan_fill_val = np.iinfo(np.int64).max
-        {{else}}
-        nan_fill_val = np.inf
-        {{endif}}
-        order = (masked_vals, mask, labels)
-    else:
-        {{if name == 'int64'}}
-        nan_fill_val = np.iinfo(np.int64).min
-        {{else}}
-        nan_fill_val = -np.inf
-        {{endif}}
-        order = (masked_vals, ~mask, labels)
-    np.putmask(masked_vals, mask, nan_fill_val)
-
-    # lexsort using labels, then mask, then actual values
-    # each label corresponds to a different group value,
-    # the mask helps you differentiate missing values before
-    # performing sort on the actual values
-    _as = np.lexsort(order).astype(np.int64, copy=False)
-
-    if not ascending:
-        _as = _as[::-1]
-
-    with nogil:
-        # Loop over the length of the value array
-        # each incremental i value can be looked up in the _as array
-        # that we sorted previously, which gives us the location of
-        # that sorted value for retrieval back from the original
-        # values / masked_vals arrays
-        for i in range(N):
-            # dups and sum_ranks will be incremented each loop where
-            # the value / group remains the same, and should be reset
-            # when either of those change
-            # Used to calculate tiebreakers
-            dups += 1
-            sum_ranks += i - grp_start + 1
-
-            # Update out only when there is a transition of values or labels.
-            # When a new value or group is encountered, go back #dups steps(
-            # the number of occurrence of current value) and assign the ranks
-            # based on the the starting index of the current group (grp_start)
-            # and the current index
-            if (i == N - 1 or
-                    (masked_vals[_as[i]] != masked_vals[_as[i+1]]) or
-                    (mask[_as[i]] ^ mask[_as[i+1]]) or
-                    (labels[_as[i]] != labels[_as[i+1]])):
-                # if keep_na, check for missing values and assign back
-                # to the result where appropriate
-                if keep_na and mask[_as[i]]:
-                    for j in range(i - dups + 1, i + 1):
-                        out[_as[j], 0] = NaN
-                        grp_na_count = dups
-                elif tiebreak == TIEBREAK_AVERAGE:
-                    for j in range(i - dups + 1, i + 1):
-                        out[_as[j], 0] = sum_ranks / <float64_t>dups
-                elif tiebreak == TIEBREAK_MIN:
-                    for j in range(i - dups + 1, i + 1):
-                        out[_as[j], 0] = i - grp_start - dups + 2
-                elif tiebreak == TIEBREAK_MAX:
-                    for j in range(i - dups + 1, i + 1):
-                        out[_as[j], 0] = i - grp_start + 1
-                elif tiebreak == TIEBREAK_FIRST:
-                    for j in range(i - dups + 1, i + 1):
-                        if ascending:
-                            out[_as[j], 0] = j + 1 - grp_start
-                        else:
-                            out[_as[j], 0] = 2 * i - j - dups + 2 - grp_start
-                elif tiebreak == TIEBREAK_DENSE:
-                    for j in range(i - dups + 1, i + 1):
-                        out[_as[j], 0] = grp_vals_seen
-
-                # look forward to the next value (using the sorting in _as)
-                # if the value does not equal the current value then we need to
-                # reset the dups and sum_ranks, knowing that a new value is
-                # coming up. the conditional also needs to handle nan equality
-                # and the end of iteration
-                if (i == N - 1 or
-                        (masked_vals[_as[i]] != masked_vals[_as[i+1]]) or
-                        (mask[_as[i]] ^ mask[_as[i+1]])):
-                    dups = sum_ranks = 0
-                    grp_vals_seen += 1
-                    grp_tie_count += 1
-
-                # Similar to the previous conditional, check now if we are
-                # moving to a new group. If so, keep track of the index where
-                # the new group occurs, so the tiebreaker calculations can
-                # decrement that from their position. fill in the size of each
-                # group encountered (used by pct calculations later). also be
-                # sure to reset any of the items helping to calculate dups
-                if i == N - 1 or labels[_as[i]] != labels[_as[i+1]]:
-                    if tiebreak != TIEBREAK_DENSE:
-                        for j in range(grp_start, i + 1):
-                            grp_sizes[_as[j], 0] = (i - grp_start + 1 -
-                                                    grp_na_count)
-                    else:
-                        for j in range(grp_start, i + 1):
-                            grp_sizes[_as[j], 0] = (grp_tie_count -
-                                                    (grp_na_count > 0))
-                    dups = sum_ranks = 0
-                    grp_na_count = 0
-                    grp_tie_count = 0
-                    grp_start = i + 1
-                    grp_vals_seen = 1
-
-        if pct:
-            for i in range(N):
-                # We don't include NaN values in percentage
-                # rankings, so we assign them percentages of NaN.
-                if out[i, 0] != out[i, 0] or out[i, 0] == NAN:
-                    out[i, 0] = NAN
-                elif grp_sizes[i, 0] != 0:
-                    out[i, 0] = out[i, 0] / grp_sizes[i, 0]
-{{endif}}
-{{endfor}}
-
-
-# ----------------------------------------------------------------------
-# group_min, group_max
-# ----------------------------------------------------------------------
-
-# TODO: consider implementing for more dtypes
-ctypedef fused groupby_t:
-    float64_t
-    float32_t
-    int64_t
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def group_max(groupby_t[:, :] out,
-              int64_t[:] counts,
-              groupby_t[:, :] values,
-              const int64_t[:] labels,
-              Py_ssize_t min_count=-1):
-    """
-    Only aggregates on axis=0
-    """
-    cdef:
-        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        groupby_t val, count, nan_val
-        ndarray[groupby_t, ndim=2] maxx, nobs
-
-    assert min_count == -1, "'min_count' only used in add and prod"
-
-    if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
-
-    nobs = np.zeros_like(out)
-
-    maxx = np.empty_like(out)
-    if groupby_t is int64_t:
-        # Note: evaluated at compile-time
-        maxx[:] = -_int64_max
-        nan_val = NPY_NAT
-    else:
-        maxx[:] = -np.inf
-        nan_val = NAN
-
-    N, K = (<object>values).shape
-
-    with nogil:
-        for i in range(N):
-            lab = labels[i]
-            if lab < 0:
-                continue
-
-            counts[lab] += 1
-            for j in range(K):
-                val = values[i, j]
-
-                # not nan
-                if groupby_t is int64_t:
-                    if val != nan_val:
-                        nobs[lab, j] += 1
-                        if val > maxx[lab, j]:
-                            maxx[lab, j] = val
-                else:
-                    if val == val and val != nan_val:
-                        nobs[lab, j] += 1
-                        if val > maxx[lab, j]:
-                            maxx[lab, j] = val
-
-        for i in range(ncounts):
-            for j in range(K):
-                if nobs[i, j] == 0:
-                    out[i, j] = nan_val
-                else:
-                    out[i, j] = maxx[i, j]
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def group_min(groupby_t[:, :] out,
-              int64_t[:] counts,
-              groupby_t[:, :] values,
-              const int64_t[:] labels,
-              Py_ssize_t min_count=-1):
-    """
-    Only aggregates on axis=0
-    """
-    cdef:
-        Py_ssize_t i, j, N, K, lab, ncounts = len(counts)
-        groupby_t val, count, nan_val
-        ndarray[groupby_t, ndim=2] minx, nobs
-
-    assert min_count == -1, "'min_count' only used in add and prod"
-
-    if not len(values) == len(labels):
-        raise AssertionError("len(index) != len(labels)")
-
-    nobs = np.zeros_like(out)
-
-    minx = np.empty_like(out)
-    if groupby_t is int64_t:
-        minx[:] = _int64_max
-        nan_val = NPY_NAT
-    else:
-        minx[:] = np.inf
-        nan_val = NAN
-
-    N, K = (<object>values).shape
-
-    with nogil:
-        for i in range(N):
-            lab = labels[i]
-            if lab < 0:
-                continue
-
-            counts[lab] += 1
-            for j in range(K):
-                val = values[i, j]
-
-                # not nan
-                if groupby_t is int64_t:
-                    if val != nan_val:
-                        nobs[lab, j] += 1
-                        if val < minx[lab, j]:
-                            minx[lab, j] = val
-                else:
-                    if val == val and val != nan_val:
-                        nobs[lab, j] += 1
-                        if val < minx[lab, j]:
-                            minx[lab, j] = val
-
-        for i in range(ncounts):
-            for j in range(K):
-                if nobs[i, j] == 0:
-                    out[i, j] = nan_val
-                else:
-                    out[i, j] = minx[i, j]
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def group_cummin(groupby_t[:, :] out,
-                 groupby_t[:, :] values,
-                 const int64_t[:] labels,
-                 int ngroups,
-                 bint is_datetimelike):
-    """Cumulative minimum of columns of `values`, in row groups `labels`.
-
-    Parameters
-    ----------
-    out : array
-        Array to store cummin in.
-    values : array
-        Values to take cummin of.
-    labels : int64 array
-        Labels to group by.
-    ngroups : int
-        Number of groups, larger than all entries of `labels`.
-    is_datetimelike : bool
-        True if `values` contains datetime-like entries.
-
-    Notes
-    -----
-    This method modifies the `out` parameter, rather than returning an object.
-    """
-
-    cdef:
-        Py_ssize_t i, j, N, K, size
-        groupby_t val, mval
-        ndarray[groupby_t, ndim=2] accum
-        int64_t lab
-
-    N, K = (<object>values).shape
-    accum = np.empty((ngroups, K), dtype=np.asarray(values).dtype)
-    if groupby_t is int64_t:
-        accum[:] = _int64_max
-    else:
-        accum[:] = np.inf
-
-    with nogil:
-        for i in range(N):
-            lab = labels[i]
-
-            if lab < 0:
-                continue
-            for j in range(K):
-                val = values[i, j]
-
-                # val = nan
-                if groupby_t is int64_t:
-                    if is_datetimelike and val == NPY_NAT:
-                        out[i, j] = NPY_NAT
-                    else:
-                        mval = accum[lab, j]
-                        if val < mval:
-                            accum[lab, j] = mval = val
-                        out[i, j] = mval
-                else:
-                    if val == val:
-                        mval = accum[lab, j]
-                        if val < mval:
-                            accum[lab, j] = mval = val
-                        out[i, j] = mval
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def group_cummax(groupby_t[:, :] out,
-                 groupby_t[:, :] values,
-                 const int64_t[:] labels,
-		 int ngroups,
-                 bint is_datetimelike):
-    """Cumulative maximum of columns of `values`, in row groups `labels`.
-
-    Parameters
-    ----------
-    out : array
-        Array to store cummax in.
-    values : array
-        Values to take cummax of.
-    labels : int64 array
-        Labels to group by.
-    ngroups : int
-        Number of groups, larger than all entries of `labels`.
-    is_datetimelike : bool
-        True if `values` contains datetime-like entries.
-
-    Notes
-    -----
-    This method modifies the `out` parameter, rather than returning an object.
-    """
-
-    cdef:
-        Py_ssize_t i, j, N, K, size
-        groupby_t val, mval
-        ndarray[groupby_t, ndim=2] accum
-        int64_t lab
-
-    N, K = (<object>values).shape
-    accum = np.empty((ngroups, K), dtype=np.asarray(values).dtype)
-    if groupby_t is int64_t:
-        accum[:] = -_int64_max
-    else:
-        accum[:] = -np.inf
-
-    with nogil:
-        for i in range(N):
-            lab = labels[i]
-
-            if lab < 0:
-                continue
-            for j in range(K):
-                val = values[i, j]
-
-                if groupby_t is int64_t:
-                    if is_datetimelike and val == NPY_NAT:
-                        out[i, j] = NPY_NAT
-                    else:
-                        mval = accum[lab, j]
-                        if val > mval:
-                            accum[lab, j] = mval = val
-                        out[i, j] = mval
-                else:
-                    if val == val:
-                        mval = accum[lab, j]
-                        if val > mval:
-                            accum[lab, j] = mval = val
-                        out[i, j] = mval
diff --git a/pandas/_libs/hashing.pyx b/pandas/_libs/hashing.pyx
index c0aa661266d29..878da670b2f68 100644
--- a/pandas/_libs/hashing.pyx
+++ b/pandas/_libs/hashing.pyx
@@ -25,13 +25,17 @@ def hash_object_array(object[:] arr, object key, object encoding='utf8'):
 
     Returns
     -------
-    1-d uint64 ndarray of hashes
+    1-d uint64 ndarray of hashes.
+
+    Raises
+    ------
+    TypeError
+        If the array contains mixed types.
 
     Notes
     -----
-    allowed values must be strings, or nulls
-    mixed array types will raise TypeError
-
+    Allowed values must be strings, or nulls
+    mixed array types will raise TypeError.
     """
     cdef:
         Py_ssize_t i, l, n
@@ -47,8 +51,9 @@ def hash_object_array(object[:] arr, object key, object encoding='utf8'):
     k = <bytes>key.encode(encoding)
     kb = <uint8_t *>k
     if len(k) != 16:
-        raise ValueError("key should be a 16-byte string encoded, "
-                         "got {key} (len {klen})".format(key=k, klen=len(k)))
+        raise ValueError(
+            f"key should be a 16-byte string encoded, got {k} (len {len(k)})"
+        )
 
     n = len(arr)
 
@@ -60,22 +65,29 @@ def hash_object_array(object[:] arr, object key, object encoding='utf8'):
         val = arr[i]
         if isinstance(val, bytes):
             data = <bytes>val
-        elif isinstance(val, unicode):
+        elif isinstance(val, str):
             data = <bytes>val.encode(encoding)
         elif val is None or is_nan(val):
             # null, stringify and encode
             data = <bytes>str(val).encode(encoding)
 
+        elif isinstance(val, tuple):
+            # GH#28969 we could have a tuple, but need to ensure that
+            #  the tuple entries are themselves hashable before converting
+            #  to str
+            hash(val)
+            data = <bytes>str(val).encode(encoding)
         else:
-            raise TypeError("{val} of type {typ} is not a valid type "
-                            "for hashing, must be string or null"
-                            .format(val=val, typ=type(val)))
+            raise TypeError(
+                f"{val} of type {type(val)} is not a valid type for hashing, "
+                "must be string or null"
+            )
 
         l = len(data)
         lens[i] = l
         cdata = data
 
-        # keep the references alive thru the end of the
+        # keep the references alive through the end of the
         # function
         datas.append(data)
         vecs[i] = cdata
diff --git a/pandas/_libs/hashtable.pxd b/pandas/_libs/hashtable.pxd
index 51ec4ba43159c..0499eabf708af 100644
--- a/pandas/_libs/hashtable.pxd
+++ b/pandas/_libs/hashtable.pxd
@@ -36,8 +36,8 @@ cdef class PyObjectHashTable(HashTable):
 cdef class StringHashTable(HashTable):
     cdef kh_str_t *table
 
-    cpdef get_item(self, object val)
-    cpdef set_item(self, object key, Py_ssize_t val)
+    cpdef get_item(self, str val)
+    cpdef set_item(self, str key, Py_ssize_t val)
 
 cdef struct Int64VectorData:
     int64_t *data
diff --git a/pandas/_libs/hashtable.pyx b/pandas/_libs/hashtable.pyx
index 8179822b9e10c..884db9ee931d4 100644
--- a/pandas/_libs/hashtable.pyx
+++ b/pandas/_libs/hashtable.pyx
@@ -1,7 +1,7 @@
 cimport cython
 
 from cpython.ref cimport PyObject, Py_INCREF
-from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free
+from cpython.mem cimport PyMem_Malloc, PyMem_Free
 
 from libc.stdlib cimport malloc, free
 
@@ -13,26 +13,45 @@ cnp.import_array()
 cdef extern from "numpy/npy_math.h":
     float64_t NAN "NPY_NAN"
 
-
 from pandas._libs.khash cimport (
     khiter_t,
-
-    kh_str_t, kh_init_str, kh_put_str, kh_exist_str,
-    kh_get_str, kh_destroy_str, kh_resize_str,
-
-    kh_put_strbox, kh_get_strbox, kh_init_strbox,
-
-    kh_int64_t, kh_init_int64, kh_resize_int64, kh_destroy_int64,
-    kh_get_int64, kh_exist_int64, kh_put_int64,
-
-    kh_float64_t, kh_exist_float64, kh_put_float64, kh_init_float64,
-    kh_get_float64, kh_destroy_float64, kh_resize_float64,
-
-    kh_resize_uint64, kh_exist_uint64, kh_destroy_uint64, kh_put_uint64,
-    kh_get_uint64, kh_init_uint64,
-
-    kh_destroy_pymap, kh_exist_pymap, kh_init_pymap, kh_get_pymap,
-    kh_put_pymap, kh_resize_pymap)
+    kh_str_t,
+    kh_init_str,
+    kh_put_str,
+    kh_exist_str,
+    kh_get_str,
+    kh_destroy_str,
+    kh_resize_str,
+    kh_put_strbox,
+    kh_get_strbox,
+    kh_init_strbox,
+    kh_int64_t,
+    kh_init_int64,
+    kh_resize_int64,
+    kh_destroy_int64,
+    kh_get_int64,
+    kh_exist_int64,
+    kh_put_int64,
+    kh_float64_t,
+    kh_exist_float64,
+    kh_put_float64,
+    kh_init_float64,
+    kh_get_float64,
+    kh_destroy_float64,
+    kh_resize_float64,
+    kh_resize_uint64,
+    kh_exist_uint64,
+    kh_destroy_uint64,
+    kh_put_uint64,
+    kh_get_uint64,
+    kh_init_uint64,
+    kh_destroy_pymap,
+    kh_exist_pymap,
+    kh_init_pymap,
+    kh_get_pymap,
+    kh_put_pymap,
+    kh_resize_pymap,
+)
 
 
 cimport pandas._libs.util as util
@@ -63,8 +82,9 @@ cdef class Factorizer:
     def get_count(self):
         return self.count
 
-    def factorize(self, ndarray[object] values, sort=False, na_sentinel=-1,
-                  na_value=None):
+    def factorize(
+        self, ndarray[object] values, sort=False, na_sentinel=-1, na_value=None
+    ):
         """
         Factorize values with nans replaced by na_sentinel
         >>> factorize(np.array([1,2,np.nan], dtype='O'), na_sentinel=20)
@@ -142,7 +162,7 @@ cdef class Int64Factorizer:
 @cython.boundscheck(False)
 def unique_label_indices(const int64_t[:] labels):
     """
-    indices of the first occurrences of the unique labels
+    Indices of the first occurrences of the unique labels
     *excluding* -1. equivalent to:
         np.unique(labels, return_index=True)[1]
     """
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index 17f1d011af01b..6671375f628e7 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -13,7 +13,7 @@ from pandas._libs.tslibs.util cimport get_c_string
 
 {{py:
 
-# name, dtype, arg
+# name, dtype, c_type
 # the generated StringVector is not actually used
 # but is included for completeness (rather ObjectVector is used
 # for uniques in hashtables)
@@ -24,13 +24,13 @@ dtypes = [('Float64', 'float64', 'float64_t'),
           ('UInt64', 'uint64', 'uint64_t')]
 }}
 
-{{for name, dtype, arg in dtypes}}
+{{for name, dtype, c_type in dtypes}}
 
 
 {{if dtype != 'int64'}}
 
 ctypedef struct {{name}}VectorData:
-    {{arg}} *data
+    {{c_type}} *data
     Py_ssize_t n, m
 
 {{endif}}
@@ -39,7 +39,7 @@ ctypedef struct {{name}}VectorData:
 @cython.wraparound(False)
 @cython.boundscheck(False)
 cdef inline void append_data_{{dtype}}({{name}}VectorData *data,
-                                       {{arg}} x) nogil:
+                                       {{c_type}} x) nogil:
 
     data.data[data.n] = x
     data.n += 1
@@ -61,14 +61,14 @@ cdef inline bint needs_resize(vector_data *data) nogil:
 
 {{py:
 
-# name, dtype, arg, idtype
-dtypes = [('Float64', 'float64', 'float64_t', 'np.float64'),
-          ('UInt64', 'uint64', 'uint64_t', 'np.uint64'),
-          ('Int64', 'int64', 'int64_t', 'np.int64')]
+# name, dtype, c_type
+dtypes = [('Float64', 'float64', 'float64_t'),
+          ('UInt64', 'uint64', 'uint64_t'),
+          ('Int64', 'int64', 'int64_t')]
 
 }}
 
-{{for name, dtype, arg, idtype in dtypes}}
+{{for name, dtype, c_type in dtypes}}
 
 cdef class {{name}}Vector:
 
@@ -87,20 +87,20 @@ cdef class {{name}}Vector:
         self.external_view_exists = False
         self.data.n = 0
         self.data.m = _INIT_VEC_CAP
-        self.ao = np.empty(self.data.m, dtype={{idtype}})
-        self.data.data = <{{arg}}*>self.ao.data
+        self.ao = np.empty(self.data.m, dtype=np.{{dtype}})
+        self.data.data = <{{c_type}}*>self.ao.data
 
     cdef resize(self):
         self.data.m = max(self.data.m * 4, _INIT_VEC_CAP)
         self.ao.resize(self.data.m, refcheck=False)
-        self.data.data = <{{arg}}*>self.ao.data
+        self.data.data = <{{c_type}}*>self.ao.data
 
     def __dealloc__(self):
         if self.data is not NULL:
             PyMem_Free(self.data)
             self.data = NULL
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.data.n
 
     cpdef to_array(self):
@@ -113,7 +113,7 @@ cdef class {{name}}Vector:
         self.external_view_exists = True
         return self.ao
 
-    cdef inline void append(self, {{arg}} x):
+    cdef inline void append(self, {{c_type}} x):
 
         if needs_resize(self.data):
             if self.external_view_exists:
@@ -123,7 +123,7 @@ cdef class {{name}}Vector:
 
         append_data_{{dtype}}(self.data, x)
 
-    cdef extend(self, const {{arg}}[:] x):
+    cdef extend(self, const {{c_type}}[:] x):
         for i in range(len(x)):
             self.append(x[i])
 
@@ -168,7 +168,7 @@ cdef class StringVector:
             PyMem_Free(self.data)
             self.data = NULL
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.data.n
 
     def to_array(self):
@@ -212,7 +212,7 @@ cdef class ObjectVector:
         self.ao = np.empty(_INIT_VEC_CAP, dtype=object)
         self.data = <PyObject**>self.ao.data
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.n
 
     cdef inline append(self, object obj):
@@ -270,7 +270,7 @@ cdef class {{name}}HashTable(HashTable):
             size_hint = min(size_hint, _SIZE_HINT_LIMIT)
             kh_resize_{{dtype}}(self.table, size_hint)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.table.size
 
     def __dealloc__(self):
@@ -279,7 +279,8 @@ cdef class {{name}}HashTable(HashTable):
             self.table = NULL
 
     def __contains__(self, object key):
-        cdef khiter_t k
+        cdef:
+            khiter_t k
         k = kh_get_{{dtype}}(self.table, key)
         return k != self.table.n_buckets
 
@@ -290,7 +291,8 @@ cdef class {{name}}HashTable(HashTable):
                                        sizeof(uint32_t))  # flags
 
     cpdef get_item(self, {{dtype}}_t val):
-        cdef khiter_t k
+        cdef:
+            khiter_t k
         k = kh_get_{{dtype}}(self.table, val)
         if k != self.table.n_buckets:
             return self.table.vals[k]
@@ -597,7 +599,7 @@ cdef class StringHashTable(HashTable):
                                        sizeof(Py_ssize_t) + # vals
                                        sizeof(uint32_t)) # flags
 
-    cpdef get_item(self, object val):
+    cpdef get_item(self, str val):
         cdef:
             khiter_t k
             const char *v
@@ -609,16 +611,16 @@ cdef class StringHashTable(HashTable):
         else:
             raise KeyError(val)
 
-    cpdef set_item(self, object key, Py_ssize_t val):
+    cpdef set_item(self, str key, Py_ssize_t val):
         cdef:
             khiter_t k
             int ret = 0
             const char *v
 
-        v = get_c_string(val)
+        v = get_c_string(key)
 
         k = kh_put_str(self.table, v, &ret)
-        self.table.keys[k] = key
+        self.table.keys[k] = v
         if kh_exist_str(self.table, k):
             self.table.vals[k] = val
         else:
@@ -667,8 +669,10 @@ cdef class StringHashTable(HashTable):
         for i in range(n):
             val = values[i]
 
-            if isinstance(val, (str, unicode)):
-                v = get_c_string(val)
+            if isinstance(val, str):
+                # GH#31499 if we have a np.str_ get_c_string wont recognize
+                #  it as a str, even though isinstance does.
+                v = get_c_string(<str>val)
             else:
                 v = get_c_string(self.na_string_sentinel)
             vecs[i] = v
@@ -700,8 +704,10 @@ cdef class StringHashTable(HashTable):
         for i in range(n):
             val = values[i]
 
-            if isinstance(val, (str, unicode)):
-                v = get_c_string(val)
+            if isinstance(val, str):
+                # GH#31499 if we have a np.str_ get_c_string wont recognize
+                #  it as a str, even though isinstance does.
+                v = get_c_string(<str>val)
             else:
                 v = get_c_string(self.na_string_sentinel)
             vecs[i] = v
@@ -774,7 +780,7 @@ cdef class StringHashTable(HashTable):
             val = values[i]
 
             if (ignore_na
-                and (not isinstance(val, (str, unicode))
+                and (not isinstance(val, str)
                      or (use_na_value and val == na_value))):
                 # if missing values do not count as unique values (i.e. if
                 # ignore_na is True), we can skip the actual value, and
@@ -782,7 +788,7 @@ cdef class StringHashTable(HashTable):
                 labels[i] = na_sentinel
             else:
                 # if ignore_na is False, we also stringify NaN/None/etc.
-                v = get_c_string(val)
+                v = get_c_string(<str>val)
                 vecs[i] = v
 
         # compute
@@ -895,11 +901,12 @@ cdef class PyObjectHashTable(HashTable):
             kh_destroy_pymap(self.table)
             self.table = NULL
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.table.size
 
     def __contains__(self, object key):
-        cdef khiter_t k
+        cdef:
+            khiter_t k
         hash(key)
 
         k = kh_get_pymap(self.table, <PyObject*>key)
@@ -912,7 +919,8 @@ cdef class PyObjectHashTable(HashTable):
                                        sizeof(uint32_t))  # flags
 
     cpdef get_item(self, object val):
-        cdef khiter_t k
+        cdef:
+            khiter_t k
 
         k = kh_get_pymap(self.table, <PyObject*>val)
         if k != self.table.n_buckets:
diff --git a/pandas/_libs/hashtable_func_helper.pxi.in b/pandas/_libs/hashtable_func_helper.pxi.in
index e400ec0e608f0..f8f3858b803a5 100644
--- a/pandas/_libs/hashtable_func_helper.pxi.in
+++ b/pandas/_libs/hashtable_func_helper.pxi.in
@@ -4,13 +4,9 @@ Template for each `dtype` helper function for hashtable
 WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 """
 
-# ----------------------------------------------------------------------
-# VectorData
-# ----------------------------------------------------------------------
-
 {{py:
 
-# dtype, ttype
+# dtype, ttype, c_type
 dtypes = [('float64', 'float64', 'float64_t'),
           ('uint64', 'uint64', 'uint64_t'),
           ('object', 'pymap', 'object'),
@@ -18,7 +14,7 @@ dtypes = [('float64', 'float64', 'float64_t'),
 
 }}
 
-{{for dtype, ttype, scalar in dtypes}}
+{{for dtype, ttype, c_type in dtypes}}
 
 
 @cython.wraparound(False)
@@ -34,7 +30,7 @@ cdef build_count_table_{{dtype}}({{dtype}}_t[:] values,
         khiter_t k
         Py_ssize_t i, n = len(values)
 
-        {{scalar}} val
+        {{c_type}} val
 
         int ret = 0
 
@@ -77,7 +73,7 @@ cdef build_count_table_{{dtype}}({{dtype}}_t[:] values,
 {{if dtype == 'object'}}
 cpdef value_count_{{dtype}}(ndarray[{{dtype}}] values, bint dropna):
 {{else}}
-cpdef value_count_{{dtype}}({{scalar}}[:] values, bint dropna):
+cpdef value_count_{{dtype}}({{c_type}}[:] values, bint dropna):
 {{endif}}
     cdef:
         Py_ssize_t i = 0
@@ -127,13 +123,9 @@ cpdef value_count_{{dtype}}({{scalar}}[:] values, bint dropna):
 @cython.wraparound(False)
 @cython.boundscheck(False)
 {{if dtype == 'object'}}
-
-
 def duplicated_{{dtype}}(ndarray[{{dtype}}] values, object keep='first'):
 {{else}}
-
-
-def duplicated_{{dtype}}({{scalar}}[:] values, object keep='first'):
+def duplicated_{{dtype}}({{c_type}}[:] values, object keep='first'):
 {{endif}}
     cdef:
         int ret = 0
@@ -151,12 +143,14 @@ def duplicated_{{dtype}}({{scalar}}[:] values, object keep='first'):
 
     if keep == 'last':
         {{if dtype == 'object'}}
-        for i from n > i >= 0:
+        for i in range(n - 1, -1, -1):
+            # equivalent: range(n)[::-1], which cython doesn't like in nogil
             kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
             out[i] = ret == 0
         {{else}}
         with nogil:
-            for i from n > i >= 0:
+            for i in range(n - 1, -1, -1):
+                # equivalent: range(n)[::-1], which cython doesn't like in nogil
                 kh_put_{{ttype}}(table, values[i], &ret)
                 out[i] = ret == 0
         {{endif}}
@@ -210,15 +204,10 @@ def duplicated_{{dtype}}({{scalar}}[:] values, object keep='first'):
 @cython.wraparound(False)
 @cython.boundscheck(False)
 {{if dtype == 'object'}}
-
-
-def ismember_{{dtype}}(ndarray[{{scalar}}] arr, ndarray[{{scalar}}] values):
+def ismember_{{dtype}}(ndarray[{{c_type}}] arr, ndarray[{{c_type}}] values):
 {{else}}
-
-
-def ismember_{{dtype}}({{scalar}}[:] arr, {{scalar}}[:] values):
+def ismember_{{dtype}}({{c_type}}[:] arr, {{c_type}}[:] values):
 {{endif}}
-
     """
     Return boolean of values in arr on an
     element by-element basis
@@ -236,7 +225,7 @@ def ismember_{{dtype}}({{scalar}}[:] arr, {{scalar}}[:] values):
         Py_ssize_t i, n, k
         int ret = 0
         ndarray[uint8_t] result
-        {{scalar}} val
+        {{c_type}} val
         kh_{{ttype}}_t *table = kh_init_{{ttype}}()
 
     # construct the table
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 979dad6db0838..6141e2b78e9f4 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -1,55 +1,38 @@
-from datetime import datetime, timedelta, date
 import warnings
 
-import cython
-
 import numpy as np
 cimport numpy as cnp
 from numpy cimport (ndarray, intp_t,
                     float64_t, float32_t,
                     int64_t, int32_t, int16_t, int8_t,
-                    uint64_t, uint32_t, uint16_t, uint8_t,
-                    # Note: NPY_DATETIME, NPY_TIMEDELTA are only available
-                    # for cimport in cython>=0.27.3
-                    NPY_DATETIME, NPY_TIMEDELTA)
+                    uint64_t, uint32_t, uint16_t, uint8_t
+)
 cnp.import_array()
 
 
 cimport pandas._libs.util as util
 
-from pandas._libs.tslibs.conversion cimport maybe_datetimelike_to_i8
+from pandas._libs.tslibs import Period
+from pandas._libs.tslibs.nattype cimport c_NaT as NaT
+from pandas._libs.tslibs.c_timestamp cimport _Timestamp
 
 from pandas._libs.hashtable cimport HashTable
 
 from pandas._libs import algos, hashtable as _hash
-from pandas._libs.tslibs import Timestamp, Timedelta, period as periodlib
+from pandas._libs.tslibs import Timedelta, period as periodlib
 from pandas._libs.missing import checknull
 
-cdef int64_t NPY_NAT = util.get_nat()
-
 
 cdef inline bint is_definitely_invalid_key(object val):
-    if isinstance(val, tuple):
-        try:
-            hash(val)
-        except TypeError:
-            return True
-
-    # we have a _data, means we are a NDFrame
-    return (isinstance(val, slice) or util.is_array(val)
-            or isinstance(val, list) or hasattr(val, '_data'))
-
-
-cpdef get_value_at(ndarray arr, object loc, object tz=None):
-    if arr.descr.type_num == NPY_DATETIME:
-        return Timestamp(util.get_value_at(arr, loc), tz=tz)
-    elif arr.descr.type_num == NPY_TIMEDELTA:
-        return Timedelta(util.get_value_at(arr, loc))
-    return util.get_value_at(arr, loc)
+    try:
+        hash(val)
+    except TypeError:
+        return True
+    return False
 
 
 # Don't populate hash tables in monotonic indexes larger than this
-_SIZE_CUTOFF = 1000000
+_SIZE_CUTOFF = 1_000_000
 
 
 cdef class IndexEngine:
@@ -69,41 +52,18 @@ cdef class IndexEngine:
         self.over_size_threshold = n >= _SIZE_CUTOFF
         self.clear_mapping()
 
-    def __contains__(self, object val):
+    def __contains__(self, val: object) -> bool:
+        # We assume before we get here:
+        #  - val is hashable
         self._ensure_mapping_populated()
-        hash(val)
         return val in self.mapping
 
-    cpdef get_value(self, ndarray arr, object key, object tz=None):
-        """
-        arr : 1-dimensional ndarray
-        """
-        cdef:
-            object loc
-            void* data_ptr
-
-        loc = self.get_loc(key)
-        if isinstance(loc, slice) or util.is_array(loc):
-            return arr[loc]
-        else:
-            return get_value_at(arr, loc, tz=tz)
-
-    cpdef set_value(self, ndarray arr, object key, object value):
-        """
-        arr : 1-dimensional ndarray
-        """
+    cpdef get_loc(self, object val):
         cdef:
-            object loc
-            void* data_ptr
-
-        loc = self.get_loc(key)
-        value = convert_scalar(arr, value)
+            Py_ssize_t loc
 
-        arr[loc] = value
-
-    cpdef get_loc(self, object val):
         if is_definitely_invalid_key(val):
-            raise TypeError("'{val}' is an invalid key".format(val=val))
+            raise TypeError(f"'{val}' is an invalid key")
 
         if self.over_size_threshold and self.is_monotonic_increasing:
             if not self.is_unique:
@@ -114,7 +74,7 @@ cdef class IndexEngine:
             loc = _bin_search(values, val)  # .searchsorted(val, side='left')
             if loc >= len(values):
                 raise KeyError(val)
-            if util.get_value_at(values, loc) != val:
+            if values[loc] != val:
                 raise KeyError(val)
             return loc
 
@@ -135,8 +95,12 @@ cdef class IndexEngine:
 
         if self.is_monotonic_increasing:
             values = self._get_index_values()
-            left = values.searchsorted(val, side='left')
-            right = values.searchsorted(val, side='right')
+            try:
+                left = values.searchsorted(val, side='left')
+                right = values.searchsorted(val, side='right')
+            except TypeError:
+                # e.g. GH#29189 get_loc(None) with a Float64Index
+                raise KeyError(val)
 
             diff = right - left
             if diff == 0:
@@ -155,6 +119,15 @@ cdef class IndexEngine:
             int count
 
         indexer = self._get_index_values() == val
+        return self._unpack_bool_indexer(indexer, val)
+
+    cdef _unpack_bool_indexer(self,
+                              ndarray[uint8_t, ndim=1, cast=True] indexer,
+                              object val):
+        cdef:
+            ndarray[intp_t, ndim=1] found
+            int count
+
         found = np.where(indexer)[0]
         count = len(found)
 
@@ -165,17 +138,17 @@ cdef class IndexEngine:
 
         raise KeyError(val)
 
-    def sizeof(self, deep=False):
+    def sizeof(self, deep: bool = False) -> int:
         """ return the sizeof our mapping """
         if not self.is_mapping_populated:
             return 0
         return self.mapping.sizeof(deep=deep)
 
-    def __sizeof__(self):
+    def __sizeof__(self) -> int:
         return self.sizeof()
 
     @property
-    def is_unique(self):
+    def is_unique(self) -> bool:
         if self.need_unique_check:
             self._do_unique_check()
 
@@ -187,21 +160,22 @@ cdef class IndexEngine:
         self._ensure_mapping_populated()
 
     @property
-    def is_monotonic_increasing(self):
+    def is_monotonic_increasing(self) -> bool:
         if self.need_monotonic_check:
             self._do_monotonic_check()
 
         return self.monotonic_inc == 1
 
     @property
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         if self.need_monotonic_check:
             self._do_monotonic_check()
 
         return self.monotonic_dec == 1
 
     cdef inline _do_monotonic_check(self):
-        cdef object is_unique
+        cdef:
+            bint is_unique
         try:
             values = self._get_index_values()
             self.monotonic_inc, self.monotonic_dec, is_unique = \
@@ -221,23 +195,23 @@ cdef class IndexEngine:
     cdef _get_index_values(self):
         return self.vgetter()
 
-    def _call_monotonic(self, values):
+    cdef _call_monotonic(self, values):
         return algos.is_monotonic(values, timelike=False)
 
-    def get_backfill_indexer(self, other, limit=None):
+    def get_backfill_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         return algos.backfill(self._get_index_values(), other, limit=limit)
 
-    def get_pad_indexer(self, other, limit=None):
+    def get_pad_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         return algos.pad(self._get_index_values(), other, limit=limit)
 
-    cdef _make_hash_table(self, n):
+    cdef _make_hash_table(self, Py_ssize_t n):
         raise NotImplementedError
 
     cdef _check_type(self, object val):
         hash(val)
 
     @property
-    def is_mapping_populated(self):
+    def is_mapping_populated(self) -> bool:
         return self.mapping is not None
 
     cdef inline _ensure_mapping_populated(self):
@@ -256,7 +230,7 @@ cdef class IndexEngine:
 
         self.need_unique_check = 0
 
-    cpdef _call_map_locations(self, values):
+    cdef void _call_map_locations(self, values):
         self.mapping.map_locations(values)
 
     def clear_mapping(self):
@@ -273,15 +247,16 @@ cdef class IndexEngine:
         return self.mapping.lookup(values)
 
     def get_indexer_non_unique(self, targets):
-        """ return an indexer suitable for takng from a non unique index
-            return the labels in the same order ast the target
-            and a missing indexer into the targets (which correspond
-            to the -1 indices in the results """
-
+        """
+        Return an indexer suitable for taking from a non unique index
+        return the labels in the same order ast the target
+        and a missing indexer into the targets (which correspond
+        to the -1 indices in the results
+        """
         cdef:
             ndarray values, x
             ndarray[int64_t] result, missing
-            set stargets
+            set stargets, remaining_stargets
             dict d = {}
             object val
             int count = 0, count_missing = 0
@@ -292,8 +267,8 @@ cdef class IndexEngine:
         stargets = set(targets)
         n = len(values)
         n_t = len(targets)
-        if n > 10000:
-            n_alloc = 10000
+        if n > 10_000:
+            n_alloc = 10_000
         else:
             n_alloc = n
 
@@ -304,12 +279,20 @@ cdef class IndexEngine:
         if stargets and len(stargets) < 5 and self.is_monotonic_increasing:
             # if there are few enough stargets and the index is monotonically
             # increasing, then use binary search for each starget
+            remaining_stargets = set()
             for starget in stargets:
-                start = values.searchsorted(starget, side='left')
-                end = values.searchsorted(starget, side='right')
-                if start != end:
-                    d[starget] = list(range(start, end))
-        else:
+                try:
+                    start = values.searchsorted(starget, side='left')
+                    end = values.searchsorted(starget, side='right')
+                except TypeError:  # e.g. if we tried to search for string in int array
+                    remaining_stargets.add(starget)
+                else:
+                    if start != end:
+                        d[starget] = list(range(start, end))
+
+            stargets = remaining_stargets
+
+        if stargets:
             # otherwise, map by iterating through all items in the index
             for i in range(n):
                 val = values[i]
@@ -327,7 +310,7 @@ cdef class IndexEngine:
 
                     # realloc if needed
                     if count >= n_alloc:
-                        n_alloc += 10000
+                        n_alloc += 10_000
                         result = np.resize(result, n_alloc)
 
                     result[count] = j
@@ -337,7 +320,7 @@ cdef class IndexEngine:
             else:
 
                 if count >= n_alloc:
-                    n_alloc += 10000
+                    n_alloc += 10_000
                     result = np.resize(result, n_alloc)
                 result[count] = -1
                 count += 1
@@ -352,22 +335,22 @@ cdef Py_ssize_t _bin_search(ndarray values, object val) except -1:
         Py_ssize_t mid = 0, lo = 0, hi = len(values) - 1
         object pval
 
-    if hi == 0 or (hi > 0 and val > util.get_value_at(values, hi)):
+    if hi == 0 or (hi > 0 and val > values[hi]):
         return len(values)
 
     while lo < hi:
         mid = (lo + hi) // 2
-        pval = util.get_value_at(values, mid)
+        pval = values[mid]
         if val < pval:
             hi = mid
         elif val > pval:
             lo = mid + 1
         else:
-            while mid > 0 and val == util.get_value_at(values, mid - 1):
+            while mid > 0 and val == values[mid - 1]:
                 mid -= 1
             return mid
 
-    if val <= util.get_value_at(values, mid):
+    if val <= values[mid]:
         return mid
     else:
         return mid + 1
@@ -375,9 +358,9 @@ cdef Py_ssize_t _bin_search(ndarray values, object val) except -1:
 
 cdef class ObjectEngine(IndexEngine):
     """
-    Index Engine for use with object-dtype Index, namely the base class Index
+    Index Engine for use with object-dtype Index, namely the base class Index.
     """
-    cdef _make_hash_table(self, n):
+    cdef _make_hash_table(self, Py_ssize_t n):
         return _hash.PyObjectHashTable(n)
 
 
@@ -386,69 +369,70 @@ cdef class DatetimeEngine(Int64Engine):
     cdef _get_box_dtype(self):
         return 'M8[ns]'
 
-    def __contains__(self, object val):
+    cdef int64_t _unbox_scalar(self, scalar) except? -1:
+        # NB: caller is responsible for ensuring tzawareness compat
+        #  before we get here
+        if not (isinstance(scalar, _Timestamp) or scalar is NaT):
+            raise TypeError(scalar)
+        return scalar.value
+
+    def __contains__(self, val: object) -> bool:
+        # We assume before we get here:
+        #  - val is hashable
+        cdef:
+            int64_t loc, conv
+
+        conv = self._unbox_scalar(val)
         if self.over_size_threshold and self.is_monotonic_increasing:
             if not self.is_unique:
-                return self._get_loc_duplicates(val)
+                return self._get_loc_duplicates(conv)
             values = self._get_index_values()
-            conv = maybe_datetimelike_to_i8(val)
             loc = values.searchsorted(conv, side='left')
-            return util.get_value_at(values, loc) == conv
+            return values[loc] == conv
 
         self._ensure_mapping_populated()
-        return maybe_datetimelike_to_i8(val) in self.mapping
+        return conv in self.mapping
 
     cdef _get_index_values(self):
         return self.vgetter().view('i8')
 
-    def _call_monotonic(self, values):
+    cdef _call_monotonic(self, values):
         return algos.is_monotonic(values, timelike=True)
 
     cpdef get_loc(self, object val):
+        # NB: the caller is responsible for ensuring that we are called
+        #  with either a Timestamp or NaT (Timedelta or NaT for TimedeltaEngine)
+
+        cdef:
+            int64_t loc
         if is_definitely_invalid_key(val):
-            raise TypeError
+            raise TypeError(f"'{val}' is an invalid key")
+
+        try:
+            conv = self._unbox_scalar(val)
+        except TypeError:
+            raise KeyError(val)
 
         # Welcome to the spaghetti factory
         if self.over_size_threshold and self.is_monotonic_increasing:
             if not self.is_unique:
-                val = maybe_datetimelike_to_i8(val)
-                return self._get_loc_duplicates(val)
+                return self._get_loc_duplicates(conv)
             values = self._get_index_values()
 
-            try:
-                conv = maybe_datetimelike_to_i8(val)
-                loc = values.searchsorted(conv, side='left')
-            except TypeError:
-                self._date_check_type(val)
-                raise KeyError(val)
+            loc = values.searchsorted(conv, side='left')
 
-            if loc == len(values) or util.get_value_at(values, loc) != conv:
+            if loc == len(values) or values[loc] != conv:
                 raise KeyError(val)
             return loc
 
         self._ensure_mapping_populated()
         if not self.unique:
-            val = maybe_datetimelike_to_i8(val)
-            return self._get_loc_duplicates(val)
+            return self._get_loc_duplicates(conv)
 
         try:
-            return self.mapping.get_item(val.value)
+            return self.mapping.get_item(conv)
         except KeyError:
             raise KeyError(val)
-        except AttributeError:
-            pass
-
-        try:
-            val = maybe_datetimelike_to_i8(val)
-            return self.mapping.get_item(val)
-        except (TypeError, ValueError):
-            self._date_check_type(val)
-            raise KeyError(val)
-
-    cdef inline _date_check_type(self, object val):
-        hash(val)
-        if not util.is_integer_object(val):
-            raise KeyError(val)
 
     def get_indexer(self, values):
         self._ensure_mapping_populated()
@@ -457,13 +441,13 @@ cdef class DatetimeEngine(Int64Engine):
         values = np.asarray(values).view('i8')
         return self.mapping.lookup(values)
 
-    def get_pad_indexer(self, other, limit=None):
+    def get_pad_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         if other.dtype != self._get_box_dtype():
             return np.repeat(-1, len(other)).astype('i4')
         other = np.asarray(other).view('i8')
         return algos.pad(self._get_index_values(), other, limit=limit)
 
-    def get_backfill_indexer(self, other, limit=None):
+    def get_backfill_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         if other.dtype != self._get_box_dtype():
             return np.repeat(-1, len(other)).astype('i4')
         other = np.asarray(other).view('i8')
@@ -475,20 +459,45 @@ cdef class TimedeltaEngine(DatetimeEngine):
     cdef _get_box_dtype(self):
         return 'm8[ns]'
 
+    cdef int64_t _unbox_scalar(self, scalar) except? -1:
+        if not (isinstance(scalar, Timedelta) or scalar is NaT):
+            raise TypeError(scalar)
+        return scalar.value
+
 
 cdef class PeriodEngine(Int64Engine):
 
-    cdef _get_index_values(self):
-        return super(PeriodEngine, self).vgetter()
+    cdef int64_t _unbox_scalar(self, scalar) except? -1:
+        if scalar is NaT:
+            return scalar.value
+        if isinstance(scalar, Period):
+            # NB: we assume that we have the correct freq here.
+            # TODO: potential optimize by checking for _Period?
+            return scalar.ordinal
+        raise TypeError(scalar)
+
+    cpdef get_loc(self, object val):
+        # NB: the caller is responsible for ensuring that we are called
+        #  with either a Period or NaT
+        cdef:
+            int64_t conv
 
-    cpdef _call_map_locations(self, values):
-        super(PeriodEngine, self)._call_map_locations(values.view('i8'))
+        try:
+            conv = self._unbox_scalar(val)
+        except TypeError:
+            raise KeyError(val)
 
-    def _call_monotonic(self, values):
-        return super(PeriodEngine, self)._call_monotonic(values.view('i8'))
+        return Int64Engine.get_loc(self, conv)
+
+    cdef _get_index_values(self):
+        return super(PeriodEngine, self).vgetter().view("i8")
+
+    cdef _call_monotonic(self, values):
+        return algos.is_monotonic(values, timelike=True)
 
     def get_indexer(self, values):
-        cdef ndarray[int64_t, ndim=1] ordinals
+        cdef:
+            ndarray[int64_t, ndim=1] ordinals
 
         super(PeriodEngine, self)._ensure_mapping_populated()
 
@@ -497,14 +506,14 @@ cdef class PeriodEngine(Int64Engine):
 
         return self.mapping.lookup(ordinals)
 
-    def get_pad_indexer(self, other, limit=None):
+    def get_pad_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         freq = super(PeriodEngine, self).vgetter().freq
         ordinal = periodlib.extract_ordinals(other, freq)
 
         return algos.pad(self._get_index_values(),
                          np.asarray(ordinal), limit=limit)
 
-    def get_backfill_indexer(self, other, limit=None):
+    def get_backfill_indexer(self, other: np.ndarray, limit=None) -> np.ndarray:
         freq = super(PeriodEngine, self).vgetter().freq
         ordinal = periodlib.extract_ordinals(other, freq)
 
@@ -519,53 +528,6 @@ cdef class PeriodEngine(Int64Engine):
         return super(PeriodEngine, self).get_indexer_non_unique(ordinal_array)
 
 
-cpdef convert_scalar(ndarray arr, object value):
-    # we don't turn integers
-    # into datetimes/timedeltas
-
-    # we don't turn bools into int/float/complex
-
-    if arr.descr.type_num == NPY_DATETIME:
-        if util.is_array(value):
-            pass
-        elif isinstance(value, (datetime, np.datetime64, date)):
-            return Timestamp(value).value
-        elif util.is_timedelta64_object(value):
-            # exclude np.timedelta64("NaT") from value != value below
-            pass
-        elif value is None or value != value:
-            return NPY_NAT
-        elif isinstance(value, str):
-            return Timestamp(value).value
-        raise ValueError("cannot set a Timestamp with a non-timestamp")
-
-    elif arr.descr.type_num == NPY_TIMEDELTA:
-        if util.is_array(value):
-            pass
-        elif isinstance(value, timedelta) or util.is_timedelta64_object(value):
-            return Timedelta(value).value
-        elif util.is_datetime64_object(value):
-            # exclude np.datetime64("NaT") which would otherwise be picked up
-            #  by the `value != value check below
-            pass
-        elif value is None or value != value:
-            return NPY_NAT
-        elif isinstance(value, str):
-            return Timedelta(value).value
-        raise ValueError("cannot set a Timedelta with a non-timedelta")
-
-    if (issubclass(arr.dtype.type, (np.integer, np.floating, np.complex)) and
-            not issubclass(arr.dtype.type, np.bool_)):
-        if util.is_bool_object(value):
-            raise ValueError('Cannot assign bool to float/integer series')
-
-    if issubclass(arr.dtype.type, (np.integer, np.bool_)):
-        if util.is_float_object(value) and value != value:
-            raise ValueError('Cannot assign nan to integer series')
-
-    return value
-
-
 cdef class BaseMultiIndexCodesEngine:
     """
     Base class for MultiIndexUIntEngine and MultiIndexPyIntEngine, which
@@ -599,13 +561,12 @@ cdef class BaseMultiIndexCodesEngine:
         Parameters
         ----------
         levels : list-like of numpy arrays
-            Levels of the MultiIndex
+            Levels of the MultiIndex.
         labels : list-like of numpy arrays of integer dtype
-            Labels of the MultiIndex
+            Labels of the MultiIndex.
         offsets : numpy array of uint64 dtype
-            Pre-calculated offsets, one for each level of the index
+            Pre-calculated offsets, one for each level of the index.
         """
-
         self.levels = levels
         self.offsets = offsets
 
@@ -623,7 +584,10 @@ cdef class BaseMultiIndexCodesEngine:
         # integers representing labels: we will use its get_loc and get_indexer
         self._base.__init__(self, lambda: lab_ints, len(lab_ints))
 
-    def _extract_level_codes(self, object target, object method=None):
+    def _codes_to_ints(self, codes):
+        raise NotImplementedError("Implemented by subclass")
+
+    def _extract_level_codes(self, object target):
         """
         Map the requested list of (tuple) keys to their integer representations
         for searching in the underlying integer index.
@@ -638,7 +602,6 @@ cdef class BaseMultiIndexCodesEngine:
         int_keys : 1-dimensional array of dtype uint64 or object
             Integers representing one combination each
         """
-
         level_codes = [lev.get_indexer(codes) + 1 for lev, codes
                        in zip(self.levels, zip(*target))]
         return self._codes_to_ints(np.array(level_codes, dtype='uint64').T)
@@ -655,7 +618,7 @@ cdef class BaseMultiIndexCodesEngine:
             # Index._get_fill_indexer), sort (integer representations of) keys:
             order = np.argsort(lab_ints)
             lab_ints = lab_ints[order]
-            indexer = (getattr(self._base, 'get_{}_indexer'.format(method))
+            indexer = (getattr(self._base, f'get_{method}_indexer')
                        (self, lab_ints, limit=limit))
             indexer = indexer[order]
         else:
@@ -665,7 +628,7 @@ cdef class BaseMultiIndexCodesEngine:
 
     def get_loc(self, object key):
         if is_definitely_invalid_key(key):
-            raise TypeError("'{key}' is an invalid key".format(key=key))
+            raise TypeError(f"'{key}' is an invalid key")
         if not isinstance(key, tuple):
             raise KeyError(key)
         try:
@@ -688,7 +651,9 @@ cdef class BaseMultiIndexCodesEngine:
 
         return indexer
 
-    def __contains__(self, object val):
+    def __contains__(self, val: object) -> bool:
+        # We assume before we get here:
+        #  - val is hashable
         # Default __contains__ looks in the underlying mapping, which in this
         # case only contains integer representations.
         try:
diff --git a/pandas/_libs/index_class_helper.pxi.in b/pandas/_libs/index_class_helper.pxi.in
index 4db048eeb0383..c7b67667bda17 100644
--- a/pandas/_libs/index_class_helper.pxi.in
+++ b/pandas/_libs/index_class_helper.pxi.in
@@ -10,26 +10,28 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 
 {{py:
 
-# name, dtype, ctype, hashtable_name, hashtable_dtype
-dtypes = [('Float64', 'float64', 'float64_t', 'Float64', 'float64'),
-          ('Float32', 'float32', 'float32_t', 'Float64', 'float64'),
-          ('Int64', 'int64', 'int64_t', 'Int64', 'int64'),
-          ('Int32', 'int32', 'int32_t', 'Int64', 'int64'),
-          ('Int16', 'int16', 'int16_t', 'Int64', 'int64'),
-          ('Int8', 'int8', 'int8_t', 'Int64', 'int64'),
-          ('UInt64', 'uint64', 'uint64_t', 'UInt64', 'uint64'),
-          ('UInt32', 'uint32', 'uint32_t', 'UInt64', 'uint64'),
-          ('UInt16', 'uint16', 'uint16_t', 'UInt64', 'uint64'),
-          ('UInt8', 'uint8', 'uint8_t', 'UInt64', 'uint64'),
+# name, dtype, hashtable_name
+dtypes = [('Float64', 'float64', 'Float64'),
+          ('Float32', 'float32', 'Float64'),
+          ('Int64', 'int64', 'Int64'),
+          ('Int32', 'int32', 'Int64'),
+          ('Int16', 'int16', 'Int64'),
+          ('Int8', 'int8', 'Int64'),
+          ('UInt64', 'uint64', 'UInt64'),
+          ('UInt32', 'uint32', 'UInt64'),
+          ('UInt16', 'uint16', 'UInt64'),
+          ('UInt8', 'uint8', 'UInt64'),
           ]
 }}
 
-{{for name, dtype, ctype, hashtable_name, hashtable_dtype in dtypes}}
+{{for name, dtype, hashtable_name in dtypes}}
 
 
 cdef class {{name}}Engine(IndexEngine):
+    # constructor-caller is responsible for ensuring that vgetter()
+    #  returns an ndarray with dtype {{dtype}}_t
 
-    cdef _make_hash_table(self, n):
+    cdef _make_hash_table(self, Py_ssize_t n):
         return _hash.{{hashtable_name}}HashTable(n)
 
     {{if name not in {'Float64', 'Float32'} }}
@@ -38,28 +40,21 @@ cdef class {{name}}Engine(IndexEngine):
             raise KeyError(val)
     {{endif}}
 
-    cpdef _call_map_locations(self, values):
+    cdef void _call_map_locations(self, values):
         # self.mapping is of type {{hashtable_name}}HashTable,
         # so convert dtype of values
-        self.mapping.map_locations(algos.ensure_{{hashtable_dtype}}(values))
-
-    cdef _get_index_values(self):
-        return algos.ensure_{{dtype}}(self.vgetter())
+        self.mapping.map_locations(algos.ensure_{{hashtable_name.lower()}}(values))
 
     cdef _maybe_get_bool_indexer(self, object val):
         cdef:
             ndarray[uint8_t, ndim=1, cast=True] indexer
             ndarray[intp_t, ndim=1] found
-            ndarray[{{ctype}}] values
+            ndarray[{{dtype}}_t, ndim=1] values
             int count = 0
 
-        {{if name not in {'Float64', 'Float32'} }}
-        if not util.is_integer_object(val):
-            raise KeyError(val)
-        {{endif}}
+        self._check_type(val)
 
-        # A view is needed for some subclasses, such as PeriodEngine:
-        values = self._get_index_values().view('{{dtype}}')
+        values = self._get_index_values()
         try:
             with warnings.catch_warnings():
                 # e.g. if values is float64 and `val` is a str, suppress warning
@@ -70,14 +65,6 @@ cdef class {{name}}Engine(IndexEngine):
             #  when trying to cast it to ndarray
             raise KeyError(val)
 
-        found = np.where(indexer)[0]
-        count = len(found)
-
-        if count > 1:
-            return indexer
-        if count == 1:
-            return int(found[0])
-
-        raise KeyError(val)
+        return self._unpack_bool_indexer(indexer, val)
 
 {{endfor}}
diff --git a/pandas/_libs/indexing.pyx b/pandas/_libs/indexing.pyx
index 308e914b7b5b7..cdccdb504571c 100644
--- a/pandas/_libs/indexing.pyx
+++ b/pandas/_libs/indexing.pyx
@@ -11,14 +11,14 @@ cdef class _NDFrameIndexerBase:
         self._ndim = None
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         # Delay `ndim` instantiation until required as reading it
         # from `obj` isn't entirely cheap.
         ndim = self._ndim
         if ndim is None:
             ndim = self._ndim = self.obj.ndim
             if ndim > 2:
-                msg = ("NDFrameIndexer does not support NDFrame objects with"
-                       " ndim > 2")
-                raise ValueError(msg)
+                raise ValueError(
+                    "NDFrameIndexer does not support NDFrame objects with ndim > 2"
+                )
         return ndim
diff --git a/pandas/_libs/internals.pyx b/pandas/_libs/internals.pyx
index b7fd490532514..8bbbc6db94842 100644
--- a/pandas/_libs/internals.pyx
+++ b/pandas/_libs/internals.pyx
@@ -1,7 +1,7 @@
 import cython
 from cython import Py_ssize_t
 
-from cpython.object cimport PyObject
+from cpython.slice cimport PySlice_GetIndicesEx
 
 cdef extern from "Python.h":
     Py_ssize_t PY_SSIZE_T_MAX
@@ -9,13 +9,6 @@ cdef extern from "Python.h":
 import numpy as np
 from numpy cimport int64_t
 
-cdef extern from "compat_helper.h":
-    cdef int slice_get_indices(PyObject* s, Py_ssize_t length,
-                               Py_ssize_t *start, Py_ssize_t *stop,
-                               Py_ssize_t *step,
-                               Py_ssize_t *slicelength) except -1
-
-
 from pandas._libs.algos import ensure_int64
 
 
@@ -53,7 +46,7 @@ cdef class BlockPlacement:
             self._as_array = arr
             self._has_array = True
 
-    def __str__(self):
+    def __str__(self) -> str:
         cdef:
             slice s = self._ensure_has_slice()
         if s is not None:
@@ -61,12 +54,12 @@ cdef class BlockPlacement:
         else:
             v = self._as_array
 
-        return '%s(%r)' % (self.__class__.__name__, v)
+        return f'{type(self).__name__}({v})'
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self)
 
-    def __len__(self):
+    def __len__(self) -> int:
         cdef:
             slice s = self._ensure_has_slice()
         if s is not None:
@@ -85,7 +78,7 @@ cdef class BlockPlacement:
             return iter(self._as_array)
 
     @property
-    def as_slice(self):
+    def as_slice(self) -> slice:
         cdef:
             slice s = self._ensure_has_slice()
         if s is None:
@@ -103,7 +96,7 @@ cdef class BlockPlacement:
             return self._as_array
 
     def isin(self, arr):
-        from pandas.core.index import Int64Index
+        from pandas.core.indexes.api import Int64Index
         return Int64Index(self.as_array, copy=False).isin(arr)
 
     @property
@@ -118,7 +111,7 @@ cdef class BlockPlacement:
         return self._as_array
 
     @property
-    def is_slice_like(self):
+    def is_slice_like(self) -> bool:
         cdef:
             slice s = self._ensure_has_slice()
         return s is not None
@@ -250,7 +243,6 @@ cpdef Py_ssize_t slice_len(
     - if ``s.step < 0``, ``s.start`` is not ``None``
 
     Otherwise, the result is unreliable.
-
     """
     cdef:
         Py_ssize_t start, stop, step, length
@@ -258,8 +250,8 @@ cpdef Py_ssize_t slice_len(
     if slc is None:
         raise TypeError("slc must be slice")
 
-    slice_get_indices(<PyObject *>slc, objlen,
-                      &start, &stop, &step, &length)
+    PySlice_GetIndicesEx(slc, objlen,
+                         &start, &stop, &step, &length)
 
     return length
 
@@ -270,7 +262,6 @@ cdef slice_get_indices_ex(slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX):
 
     If `objlen` is not specified, slice must be bounded, otherwise the result
     will be wrong.
-
     """
     cdef:
         Py_ssize_t start, stop, step, length
@@ -278,13 +269,13 @@ cdef slice_get_indices_ex(slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX):
     if slc is None:
         raise TypeError("slc should be a slice")
 
-    slice_get_indices(<PyObject *>slc, objlen,
-                      &start, &stop, &step, &length)
+    PySlice_GetIndicesEx(slc, objlen,
+                         &start, &stop, &step, &length)
 
     return start, stop, step, length
 
 
-def slice_getitem(slice slc not None, ind):
+cdef slice_getitem(slice slc, ind):
     cdef:
         Py_ssize_t s_start, s_stop, s_step, s_len
         Py_ssize_t ind_start, ind_stop, ind_step, ind_len
@@ -319,7 +310,7 @@ def slice_getitem(slice slc not None, ind):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef slice indexer_as_slice(int64_t[:] vals):
+cdef slice indexer_as_slice(int64_t[:] vals):
     cdef:
         Py_ssize_t i, n, start, stop
         int64_t d
@@ -372,7 +363,6 @@ def get_blkno_indexers(int64_t[:] blknos, bint group=True):
     Returns
     -------
     iter : iterator of (int, slice or array)
-
     """
     # There's blkno in this function's name because it's used in block &
     # blockno handling.
@@ -441,24 +431,19 @@ def get_blkno_indexers(int64_t[:] blknos, bint group=True):
                 yield blkno, result
 
 
-def get_blkno_placements(blknos, blk_count, group=True):
+def get_blkno_placements(blknos, group: bool = True):
     """
-
     Parameters
     ----------
     blknos : array of int64
-    blk_count : int
-    group : bool
+    group : bool, default True
 
     Returns
     -------
     iterator
         yield (BlockPlacement, blkno)
-
     """
-
     blknos = ensure_int64(blknos)
 
-    # FIXME: blk_count is unused, but it may avoid the use of dicts in cython
     for blkno, indexer in get_blkno_indexers(blknos, group):
         yield blkno, BlockPlacement(indexer)
diff --git a/pandas/_libs/interval.pyx b/pandas/_libs/interval.pyx
index 3c7ec70fb1f88..1166768472449 100644
--- a/pandas/_libs/interval.pyx
+++ b/pandas/_libs/interval.pyx
@@ -18,7 +18,7 @@ cnp.import_array()
 
 cimport pandas._libs.util as util
 
-from pandas._libs.hashtable cimport Int64Vector, Int64VectorData
+from pandas._libs.hashtable cimport Int64Vector
 from pandas._libs.tslibs.util cimport is_integer_object, is_float_object
 
 from pandas._libs.tslibs import Timestamp
@@ -41,8 +41,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            ``True`` if the Interval is closed on the left-side, else
-            ``False``.
+            True if the Interval is closed on the left-side.
         """
         return self.closed in ('left', 'both')
 
@@ -56,8 +55,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            ``True`` if the Interval is closed on the left-side, else
-            ``False``.
+            True if the Interval is closed on the left-side.
         """
         return self.closed in ('right', 'both')
 
@@ -71,8 +69,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            ``True`` if the Interval is closed on the left-side, else
-            ``False``.
+            True if the Interval is closed on the left-side.
         """
         return not self.closed_left
 
@@ -86,15 +83,14 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            ``True`` if the Interval is closed on the left-side, else
-            ``False``.
+            True if the Interval is closed on the left-side.
         """
         return not self.closed_right
 
     @property
     def mid(self):
         """
-        Return the midpoint of the Interval
+        Return the midpoint of the Interval.
         """
         try:
             return 0.5 * (self.left + self.right)
@@ -104,7 +100,9 @@ cdef class IntervalMixin:
 
     @property
     def length(self):
-        """Return the length of the Interval"""
+        """
+        Return the length of the Interval.
+        """
         return self.right - self.left
 
     @property
@@ -177,8 +175,8 @@ cdef class IntervalMixin:
             When `other` is not closed exactly the same as self.
         """
         if self.closed != other.closed:
-            msg = "'{}.closed' is '{}', expected '{}'."
-            raise ValueError(msg.format(name, other.closed, self.closed))
+            raise ValueError(f"'{name}.closed' is {repr(other.closed)}, "
+                             f"expected {repr(self.closed)}.")
 
 
 cdef _interval_like(other):
@@ -191,8 +189,6 @@ cdef class Interval(IntervalMixin):
     """
     Immutable object implementing an Interval, a bounded slice-like interval.
 
-    .. versionadded:: 0.20.0
-
     Parameters
     ----------
     left : orderable scalar
@@ -285,15 +281,19 @@ cdef class Interval(IntervalMixin):
     _typ = "interval"
 
     cdef readonly object left
-    """Left bound for the interval"""
+    """
+    Left bound for the interval.
+    """
 
     cdef readonly object right
-    """Right bound for the interval"""
+    """
+    Right bound for the interval.
+    """
 
     cdef readonly str closed
     """
     Whether the interval is closed on the left-side, right-side, both or
-    neither
+    neither.
     """
 
     def __init__(self, left, right, str closed='right'):
@@ -304,17 +304,14 @@ cdef class Interval(IntervalMixin):
         self._validate_endpoint(right)
 
         if closed not in _VALID_CLOSED:
-            msg = "invalid option for 'closed': {closed}".format(closed=closed)
-            raise ValueError(msg)
+            raise ValueError(f"invalid option for 'closed': {closed}")
         if not left <= right:
-            raise ValueError('left side of interval must be <= right side')
+            raise ValueError("left side of interval must be <= right side")
         if (isinstance(left, Timestamp) and
                 not tz_compare(left.tzinfo, right.tzinfo)):
             # GH 18538
-            msg = ("left and right must have the same time zone, got "
-                   "'{left_tz}' and '{right_tz}'")
-            raise ValueError(msg.format(left_tz=left.tzinfo,
-                                        right_tz=right.tzinfo))
+            raise ValueError("left and right must have the same time zone, got "
+                             f"{repr(left.tzinfo)}' and {repr(right.tzinfo)}")
         self.left = left
         self.right = right
         self.closed = closed
@@ -323,16 +320,15 @@ cdef class Interval(IntervalMixin):
         # GH 23013
         if not (is_integer_object(endpoint) or is_float_object(endpoint) or
                 isinstance(endpoint, (Timestamp, Timedelta))):
-            msg = ("Only numeric, Timestamp and Timedelta endpoints "
-                   "are allowed when constructing an Interval.")
-            raise ValueError(msg)
+            raise ValueError("Only numeric, Timestamp and Timedelta endpoints "
+                             "are allowed when constructing an Interval.")
 
     def __hash__(self):
         return hash((self.left, self.right, self.closed))
 
-    def __contains__(self, key):
+    def __contains__(self, key) -> bool:
         if _interval_like(key):
-            raise TypeError('__contains__ not defined for two intervals')
+            raise TypeError("__contains__ not defined for two intervals")
         return ((self.left < key if self.open_left else self.left <= key) and
                 (key < self.right if self.open_right else key <= self.right))
 
@@ -355,8 +351,7 @@ cdef class Interval(IntervalMixin):
             name = type(self).__name__
             other = type(other).__name__
             op_str = {Py_LT: '<', Py_LE: '<=', Py_GT: '>', Py_GE: '>='}[op]
-            raise TypeError('unorderable types: {name}() {op} {other}()'
-                            .format(name=name, op=op_str, other=other))
+            raise TypeError(f"unorderable types: {name}() {op_str} {other}()")
 
     def __reduce__(self):
         args = (self.left, self.right, self.closed)
@@ -373,21 +368,19 @@ cdef class Interval(IntervalMixin):
 
         return left, right
 
-    def __repr__(self):
+    def __repr__(self) -> str:
 
         left, right = self._repr_base()
         name = type(self).__name__
-        repr_str = '{name}({left!r}, {right!r}, closed={closed!r})'.format(
-            name=name, left=left, right=right, closed=self.closed)
+        repr_str = f'{name}({repr(left)}, {repr(right)}, closed={repr(self.closed)})'
         return repr_str
 
-    def __str__(self):
+    def __str__(self) -> str:
 
         left, right = self._repr_base()
         start_symbol = '[' if self.closed_left else '('
         end_symbol = ']' if self.closed_right else ')'
-        return '{start}{left}, {right}{end}'.format(
-            start=start_symbol, left=left, right=right, end=end_symbol)
+        return f'{start_symbol}{left}, {right}{end_symbol}'
 
     def __add__(self, y):
         if isinstance(y, numbers.Number):
@@ -437,12 +430,12 @@ cdef class Interval(IntervalMixin):
         Parameters
         ----------
         other : Interval
-            The interval to check against for an overlap.
+            Interval to check against for an overlap.
 
         Returns
         -------
         bool
-            ``True`` if the two intervals overlap, else ``False``.
+            True if the two intervals overlap.
 
         See Also
         --------
@@ -473,8 +466,8 @@ cdef class Interval(IntervalMixin):
         False
         """
         if not isinstance(other, Interval):
-            msg = '`other` must be an Interval, got {other}'
-            raise TypeError(msg.format(other=type(other).__name__))
+            raise TypeError("`other` must be an Interval, "
+                            f"got {type(other).__name__}")
 
         # equality is okay if both endpoints are closed (overlap at a point)
         op1 = le if (self.closed_left and other.closed_right) else lt
@@ -494,20 +487,19 @@ def intervals_to_interval_bounds(ndarray intervals,
     Parameters
     ----------
     intervals : ndarray
-        object array of Intervals / nulls
+        Object array of Intervals / nulls.
 
-    validate_closed: boolean, default True
-        boolean indicating if all intervals must be closed on the same side.
+    validate_closed: bool, default True
+        Boolean indicating if all intervals must be closed on the same side.
         Mismatching closed will raise if True, else return None for closed.
 
     Returns
     -------
-    tuples (left: ndarray object array,
-            right: ndarray object array,
-            closed: str)
-
+    tuple of tuples
+        left : (ndarray, object, array)
+        right : (ndarray, object, array)
+        closed: str
     """
-
     cdef:
         object closed = None, interval
         int64_t n = len(intervals)
@@ -525,8 +517,8 @@ def intervals_to_interval_bounds(ndarray intervals,
             continue
 
         if not isinstance(interval, Interval):
-            raise TypeError("type {typ} with value {iv} is not an interval"
-                            .format(typ=type(interval), iv=interval))
+            raise TypeError(f"type {type(interval)} with value "
+                            f"{interval} is not an interval")
 
         left[i] = interval.left
         right[i] = interval.right
@@ -536,8 +528,7 @@ def intervals_to_interval_bounds(ndarray intervals,
         elif closed != interval.closed:
             closed = None
             if validate_closed:
-                msg = 'intervals must all be closed on the same side'
-                raise ValueError(msg)
+                raise ValueError("intervals must all be closed on the same side")
 
     return left, right, closed
 
diff --git a/pandas/_libs/intervaltree.pxi.in b/pandas/_libs/intervaltree.pxi.in
index ac713a928973f..a8728050f8071 100644
--- a/pandas/_libs/intervaltree.pxi.in
+++ b/pandas/_libs/intervaltree.pxi.in
@@ -6,12 +6,17 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 
 from pandas._libs.algos import is_monotonic
 
-ctypedef fused scalar_t:
-    float64_t
-    float32_t
+ctypedef fused int_scalar_t:
     int64_t
-    int32_t
+    float64_t
+
+ctypedef fused uint_scalar_t:
     uint64_t
+    float64_t
+
+ctypedef fused scalar_t:
+    int_scalar_t
+    uint_scalar_t
 
 # ----------------------------------------------------------------------
 # IntervalTree
@@ -21,13 +26,13 @@ cdef class IntervalTree(IntervalMixin):
     """A centered interval tree
 
     Based off the algorithm described on Wikipedia:
-    http://en.wikipedia.org/wiki/Interval_tree
+    https://en.wikipedia.org/wiki/Interval_tree
 
     we are emulating the IndexEngine interface
     """
-    cdef:
-        readonly object left, right, root, dtype
-        readonly str closed
+    cdef readonly:
+        object left, right, root, dtype
+        str closed
         object _is_overlapping, _left_sorter, _right_sorter
 
     def __init__(self, left, right, closed='right', leaf_size=100):
@@ -114,43 +119,6 @@ cdef class IntervalTree(IntervalMixin):
         sort_order = np.lexsort(values)
         return is_monotonic(sort_order, False)[0]
 
-    def get_loc(self, scalar_t key):
-        """Return all positions corresponding to intervals that overlap with
-        the given scalar key
-        """
-        result = Int64Vector()
-        self.root.query(result, key)
-        if not result.data.n:
-            raise KeyError(key)
-        return result.to_array().astype('intp')
-
-    def _get_partial_overlap(self, key_left, key_right, side):
-        """Return all positions corresponding to intervals with the given side
-        falling between the left and right bounds of an interval query
-        """
-        if side == 'left':
-            values = self.left
-            sorter = self.left_sorter
-        else:
-            values = self.right
-            sorter = self.right_sorter
-        key = [key_left, key_right]
-        i, j = values.searchsorted(key, sorter=sorter)
-        return sorter[i:j]
-
-    def get_loc_interval(self, key_left, key_right):
-        """Lookup the intervals enclosed in the given interval bounds
-
-        The given interval is presumed to have closed bounds.
-        """
-        import pandas as pd
-        left_overlap = self._get_partial_overlap(key_left, key_right, 'left')
-        right_overlap = self._get_partial_overlap(key_left, key_right, 'right')
-        enclosing = self.get_loc(0.5 * (key_left + key_right))
-        combined = np.concatenate([left_overlap, right_overlap, enclosing])
-        uniques = pd.unique(combined)
-        return uniques.astype('intp')
-
     def get_indexer(self, scalar_t[:] target):
         """Return the positions corresponding to unique intervals that overlap
         with the given array of scalar targets.
@@ -158,14 +126,19 @@ cdef class IntervalTree(IntervalMixin):
 
         # TODO: write get_indexer_intervals
         cdef:
-            size_t old_len
+            Py_ssize_t old_len
             Py_ssize_t i
             Int64Vector result
 
         result = Int64Vector()
         old_len = 0
         for i in range(len(target)):
-            self.root.query(result, target[i])
+            try:
+                self.root.query(result, target[i])
+            except OverflowError:
+                # overflow -> no match, which is already handled below
+                pass
+
             if result.data.n == old_len:
                 result.append(-1)
             elif result.data.n > old_len + 1:
@@ -179,7 +152,7 @@ cdef class IntervalTree(IntervalMixin):
         the given array of scalar targets. Non-unique positions are repeated.
         """
         cdef:
-            size_t old_len
+            Py_ssize_t old_len
             Py_ssize_t i
             Int64Vector result, missing
 
@@ -187,7 +160,12 @@ cdef class IntervalTree(IntervalMixin):
         missing = Int64Vector()
         old_len = 0
         for i in range(len(target)):
-            self.root.query(result, target[i])
+            try:
+                self.root.query(result, target[i])
+            except OverflowError:
+                # overflow -> no match, which is already handled below
+                pass
+
             if result.data.n == old_len:
                 result.append(-1)
                 missing.append(i)
@@ -195,7 +173,7 @@ cdef class IntervalTree(IntervalMixin):
         return (result.to_array().astype('intp'),
                 missing.to_array().astype('intp'))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return ('<IntervalTree[{dtype},{closed}]: '
                 '{n_elements} elements>'.format(
                     dtype=self.dtype, closed=self.closed,
@@ -231,7 +209,7 @@ cdef sort_values_and_indices(all_values, all_indices, subset):
 {{py:
 
 nodes = []
-for dtype in ['float32', 'float64', 'int32', 'int64', 'uint64']:
+for dtype in ['float64', 'int64', 'uint64']:
     for closed, cmp_left, cmp_right in [
         ('left', '<=', '<'),
         ('right', '<', '<='),
@@ -239,19 +217,26 @@ for dtype in ['float32', 'float64', 'int32', 'int64', 'uint64']:
         ('neither', '<', '<')]:
         cmp_left_converse = '<' if cmp_left == '<=' else '<='
         cmp_right_converse = '<' if cmp_right == '<=' else '<='
+        if dtype.startswith('int'):
+            fused_prefix = 'int_'
+        elif dtype.startswith('uint'):
+            fused_prefix = 'uint_'
+        elif dtype.startswith('float'):
+            fused_prefix = ''
         nodes.append((dtype, dtype.title(),
                       closed, closed.title(),
                       cmp_left,
                       cmp_right,
                       cmp_left_converse,
-                      cmp_right_converse))
+                      cmp_right_converse,
+                      fused_prefix))
 
 }}
 
 NODE_CLASSES = {}
 
 {{for dtype, dtype_title, closed, closed_title, cmp_left, cmp_right,
-      cmp_left_converse, cmp_right_converse in nodes}}
+      cmp_left_converse, cmp_right_converse, fused_prefix in nodes}}
 
 cdef class {{dtype_title}}Closed{{closed_title}}IntervalNode:
     """Non-terminal node for an IntervalTree
@@ -259,14 +244,14 @@ cdef class {{dtype_title}}Closed{{closed_title}}IntervalNode:
     Categorizes intervals by those that fall to the left, those that fall to
     the right, and those that overlap with the pivot.
     """
-    cdef:
+    cdef readonly:
         {{dtype_title}}Closed{{closed_title}}IntervalNode left_node, right_node
         {{dtype}}_t[:] center_left_values, center_right_values, left, right
         int64_t[:] center_left_indices, center_right_indices, indices
         {{dtype}}_t min_left, max_right
-        readonly {{dtype}}_t pivot
-        readonly int64_t n_elements, n_center, leaf_size
-        readonly bint is_leaf_node
+        {{dtype}}_t pivot
+        int64_t n_elements, n_center, leaf_size
+        bint is_leaf_node
 
     def __init__(self,
                  ndarray[{{dtype}}_t, ndim=1] left,
@@ -354,7 +339,7 @@ cdef class {{dtype_title}}Closed{{closed_title}}IntervalNode:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.initializedcheck(False)
-    cpdef query(self, Int64Vector result, scalar_t point):
+    cpdef query(self, Int64Vector result, {{fused_prefix}}scalar_t point):
         """Recursively query this node and its sub-nodes for intervals that
         overlap with the query point.
         """
@@ -394,7 +379,7 @@ cdef class {{dtype_title}}Closed{{closed_title}}IntervalNode:
             else:
                 result.extend(self.center_left_indices)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.is_leaf_node:
             return ('<{{dtype_title}}Closed{{closed_title}}IntervalNode: '
                     '%s elements (terminal)>' % self.n_elements)
diff --git a/pandas/_libs/join.pyx b/pandas/_libs/join.pyx
index 238bfd0be0aa7..093c53790cd35 100644
--- a/pandas/_libs/join.pyx
+++ b/pandas/_libs/join.pyx
@@ -13,6 +13,7 @@ from pandas._libs.algos import (
 )
 
 
+@cython.boundscheck(False)
 def inner_join(const int64_t[:] left, const int64_t[:] right,
                Py_ssize_t max_groups):
     cdef:
@@ -20,24 +21,22 @@ def inner_join(const int64_t[:] left, const int64_t[:] right,
         ndarray[int64_t] left_count, right_count, left_sorter, right_sorter
         ndarray[int64_t] left_indexer, right_indexer
         int64_t lc, rc
+        Py_ssize_t loc, left_pos = 0, right_pos = 0, position = 0
+        Py_ssize_t offset
 
     # NA group in location 0
 
     left_sorter, left_count = groupsort_indexer(left, max_groups)
     right_sorter, right_count = groupsort_indexer(right, max_groups)
 
-    # First pass, determine size of result set, do not use the NA group
-    for i in range(1, max_groups + 1):
-        lc = left_count[i]
-        rc = right_count[i]
+    with nogil:
+        # First pass, determine size of result set, do not use the NA group
+        for i in range(1, max_groups + 1):
+            lc = left_count[i]
+            rc = right_count[i]
 
-        if rc > 0 and lc > 0:
-            count += lc * rc
-
-    # group 0 is the NA group
-    cdef:
-        Py_ssize_t loc, left_pos = 0, right_pos = 0, position = 0
-        Py_ssize_t offset
+            if rc > 0 and lc > 0:
+                count += lc * rc
 
     # exclude the NA group
     left_pos = left_count[0]
@@ -46,24 +45,26 @@ def inner_join(const int64_t[:] left, const int64_t[:] right,
     left_indexer = np.empty(count, dtype=np.int64)
     right_indexer = np.empty(count, dtype=np.int64)
 
-    for i in range(1, max_groups + 1):
-        lc = left_count[i]
-        rc = right_count[i]
-
-        if rc > 0 and lc > 0:
-            for j in range(lc):
-                offset = position + j * rc
-                for k in range(rc):
-                    left_indexer[offset + k] = left_pos + j
-                    right_indexer[offset + k] = right_pos + k
-            position += lc * rc
-        left_pos += lc
-        right_pos += rc
+    with nogil:
+        for i in range(1, max_groups + 1):
+            lc = left_count[i]
+            rc = right_count[i]
+
+            if rc > 0 and lc > 0:
+                for j in range(lc):
+                    offset = position + j * rc
+                    for k in range(rc):
+                        left_indexer[offset + k] = left_pos + j
+                        right_indexer[offset + k] = right_pos + k
+                position += lc * rc
+            left_pos += lc
+            right_pos += rc
 
     return (_get_result_indexer(left_sorter, left_indexer),
             _get_result_indexer(right_sorter, right_indexer))
 
 
+@cython.boundscheck(False)
 def left_outer_join(const int64_t[:] left, const int64_t[:] right,
                     Py_ssize_t max_groups, sort=True):
     cdef:
@@ -72,23 +73,21 @@ def left_outer_join(const int64_t[:] left, const int64_t[:] right,
         ndarray rev
         ndarray[int64_t] left_indexer, right_indexer
         int64_t lc, rc
+        Py_ssize_t loc, left_pos = 0, right_pos = 0, position = 0
+        Py_ssize_t offset
 
     # NA group in location 0
 
     left_sorter, left_count = groupsort_indexer(left, max_groups)
     right_sorter, right_count = groupsort_indexer(right, max_groups)
 
-    # First pass, determine size of result set, do not use the NA group
-    for i in range(1, max_groups + 1):
-        if right_count[i] > 0:
-            count += left_count[i] * right_count[i]
-        else:
-            count += left_count[i]
-
-    # group 0 is the NA group
-    cdef:
-        Py_ssize_t loc, left_pos = 0, right_pos = 0, position = 0
-        Py_ssize_t offset
+    with nogil:
+        # First pass, determine size of result set, do not use the NA group
+        for i in range(1, max_groups + 1):
+            if right_count[i] > 0:
+                count += left_count[i] * right_count[i]
+            else:
+                count += left_count[i]
 
     # exclude the NA group
     left_pos = left_count[0]
@@ -97,24 +96,25 @@ def left_outer_join(const int64_t[:] left, const int64_t[:] right,
     left_indexer = np.empty(count, dtype=np.int64)
     right_indexer = np.empty(count, dtype=np.int64)
 
-    for i in range(1, max_groups + 1):
-        lc = left_count[i]
-        rc = right_count[i]
+    with nogil:
+        for i in range(1, max_groups + 1):
+            lc = left_count[i]
+            rc = right_count[i]
 
-        if rc == 0:
-            for j in range(lc):
-                left_indexer[position + j] = left_pos + j
-                right_indexer[position + j] = -1
-            position += lc
-        else:
-            for j in range(lc):
-                offset = position + j * rc
-                for k in range(rc):
-                    left_indexer[offset + k] = left_pos + j
-                    right_indexer[offset + k] = right_pos + k
-            position += lc * rc
-        left_pos += lc
-        right_pos += rc
+            if rc == 0:
+                for j in range(lc):
+                    left_indexer[position + j] = left_pos + j
+                    right_indexer[position + j] = -1
+                position += lc
+            else:
+                for j in range(lc):
+                    offset = position + j * rc
+                    for k in range(rc):
+                        left_indexer[offset + k] = left_pos + j
+                        right_indexer[offset + k] = right_pos + k
+                position += lc * rc
+            left_pos += lc
+            right_pos += rc
 
     left_indexer = _get_result_indexer(left_sorter, left_indexer)
     right_indexer = _get_result_indexer(right_sorter, right_indexer)
@@ -137,6 +137,7 @@ def left_outer_join(const int64_t[:] left, const int64_t[:] right,
     return left_indexer, right_indexer
 
 
+@cython.boundscheck(False)
 def full_outer_join(const int64_t[:] left, const int64_t[:] right,
                     Py_ssize_t max_groups):
     cdef:
@@ -144,26 +145,24 @@ def full_outer_join(const int64_t[:] left, const int64_t[:] right,
         ndarray[int64_t] left_count, right_count, left_sorter, right_sorter
         ndarray[int64_t] left_indexer, right_indexer
         int64_t lc, rc
+        int64_t left_pos = 0, right_pos = 0
+        Py_ssize_t offset, position = 0
 
     # NA group in location 0
 
     left_sorter, left_count = groupsort_indexer(left, max_groups)
     right_sorter, right_count = groupsort_indexer(right, max_groups)
 
-    # First pass, determine size of result set, do not use the NA group
-    for i in range(1, max_groups + 1):
-        lc = left_count[i]
-        rc = right_count[i]
-
-        if rc > 0 and lc > 0:
-            count += lc * rc
-        else:
-            count += lc + rc
+    with nogil:
+        # First pass, determine size of result set, do not use the NA group
+        for i in range(1, max_groups + 1):
+            lc = left_count[i]
+            rc = right_count[i]
 
-    # group 0 is the NA group
-    cdef:
-        int64_t left_pos = 0, right_pos = 0
-        Py_ssize_t offset, position = 0
+            if rc > 0 and lc > 0:
+                count += lc * rc
+            else:
+                count += lc + rc
 
     # exclude the NA group
     left_pos = left_count[0]
@@ -172,29 +171,30 @@ def full_outer_join(const int64_t[:] left, const int64_t[:] right,
     left_indexer = np.empty(count, dtype=np.int64)
     right_indexer = np.empty(count, dtype=np.int64)
 
-    for i in range(1, max_groups + 1):
-        lc = left_count[i]
-        rc = right_count[i]
-
-        if rc == 0:
-            for j in range(lc):
-                left_indexer[position + j] = left_pos + j
-                right_indexer[position + j] = -1
-            position += lc
-        elif lc == 0:
-            for j in range(rc):
-                left_indexer[position + j] = -1
-                right_indexer[position + j] = right_pos + j
-            position += rc
-        else:
-            for j in range(lc):
-                offset = position + j * rc
-                for k in range(rc):
-                    left_indexer[offset + k] = left_pos + j
-                    right_indexer[offset + k] = right_pos + k
-            position += lc * rc
-        left_pos += lc
-        right_pos += rc
+    with nogil:
+        for i in range(1, max_groups + 1):
+            lc = left_count[i]
+            rc = right_count[i]
+
+            if rc == 0:
+                for j in range(lc):
+                    left_indexer[position + j] = left_pos + j
+                    right_indexer[position + j] = -1
+                position += lc
+            elif lc == 0:
+                for j in range(rc):
+                    left_indexer[position + j] = -1
+                    right_indexer[position + j] = right_pos + j
+                position += rc
+            else:
+                for j in range(lc):
+                    offset = position + j * rc
+                    for k in range(rc):
+                        left_indexer[offset + k] = left_pos + j
+                        right_indexer[offset + k] = right_pos + k
+                position += lc * rc
+            left_pos += lc
+            right_pos += rc
 
     return (_get_result_indexer(left_sorter, left_indexer),
             _get_result_indexer(right_sorter, right_indexer))
@@ -296,19 +296,11 @@ def left_join_indexer_unique(join_t[:] left, join_t[:] right):
     return indexer
 
 
-left_join_indexer_unique_float64 = left_join_indexer_unique["float64_t"]
-left_join_indexer_unique_float32 = left_join_indexer_unique["float32_t"]
-left_join_indexer_unique_object = left_join_indexer_unique["object"]
-left_join_indexer_unique_int32 = left_join_indexer_unique["int32_t"]
-left_join_indexer_unique_int64 = left_join_indexer_unique["int64_t"]
-left_join_indexer_unique_uint64 = left_join_indexer_unique["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def left_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     """
-    Two-pass algorithm for monotonic indexes. Handles many-to-one merges
+    Two-pass algorithm for monotonic indexes. Handles many-to-one merges.
     """
     cdef:
         Py_ssize_t i, j, k, nright, nleft, count
@@ -407,19 +399,11 @@ def left_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-left_join_indexer_float64 = left_join_indexer["float64_t"]
-left_join_indexer_float32 = left_join_indexer["float32_t"]
-left_join_indexer_object = left_join_indexer["object"]
-left_join_indexer_int32 = left_join_indexer["int32_t"]
-left_join_indexer_int64 = left_join_indexer["int64_t"]
-left_join_indexer_uint64 = left_join_indexer["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def inner_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     """
-    Two-pass algorithm for monotonic indexes. Handles many-to-one merges
+    Two-pass algorithm for monotonic indexes. Handles many-to-one merges.
     """
     cdef:
         Py_ssize_t i, j, k, nright, nleft, count
@@ -508,14 +492,6 @@ def inner_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-inner_join_indexer_float64 = inner_join_indexer["float64_t"]
-inner_join_indexer_float32 = inner_join_indexer["float32_t"]
-inner_join_indexer_object = inner_join_indexer["object"]
-inner_join_indexer_int32 = inner_join_indexer["int32_t"]
-inner_join_indexer_int64 = inner_join_indexer["int64_t"]
-inner_join_indexer_uint64 = inner_join_indexer["uint64_t"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def outer_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
@@ -645,14 +621,6 @@ def outer_join_indexer(ndarray[join_t] left, ndarray[join_t] right):
     return result, lindexer, rindexer
 
 
-outer_join_indexer_float64 = outer_join_indexer["float64_t"]
-outer_join_indexer_float32 = outer_join_indexer["float32_t"]
-outer_join_indexer_object = outer_join_indexer["object"]
-outer_join_indexer_int32 = outer_join_indexer["int32_t"]
-outer_join_indexer_int64 = outer_join_indexer["int64_t"]
-outer_join_indexer_uint64 = outer_join_indexer["uint64_t"]
-
-
 # ----------------------------------------------------------------------
 # asof_join_by
 # ----------------------------------------------------------------------
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 594de703258a4..9702eb4615909 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -4,17 +4,16 @@ from fractions import Fraction
 from numbers import Number
 
 import sys
-import warnings
 
 import cython
 from cython import Py_ssize_t
 
-from cpython.list cimport PyList_New
-from cpython.object cimport (PyObject_Str, PyObject_RichCompareBool, Py_EQ,
-                             Py_SIZE)
+from cpython.object cimport PyObject_RichCompareBool, Py_EQ
 from cpython.ref cimport Py_INCREF
 from cpython.tuple cimport PyTuple_SET_ITEM, PyTuple_New
-from cpython.unicode cimport PyUnicode_Join
+from cpython.iterator cimport PyIter_Check
+from cpython.sequence cimport PySequence_Check
+from cpython.number cimport PyNumber_Check
 
 from cpython.datetime cimport (PyDateTime_Check, PyDate_Check,
                                PyTime_Check, PyDelta_Check,
@@ -23,7 +22,7 @@ PyDateTime_IMPORT
 
 import numpy as np
 cimport numpy as cnp
-from numpy cimport (ndarray, PyArray_GETITEM,
+from numpy cimport (ndarray, PyArray_Check, PyArray_GETITEM,
                     PyArray_ITER_DATA, PyArray_ITER_NEXT, PyArray_IterNew,
                     flatiter, NPY_OBJECT,
                     int64_t, float32_t, float64_t,
@@ -55,14 +54,13 @@ cimport pandas._libs.util as util
 from pandas._libs.util cimport is_nan, UINT64_MAX, INT64_MAX, INT64_MIN
 
 from pandas._libs.tslib import array_to_datetime
-from pandas._libs.tslibs.nattype cimport NPY_NAT
-from pandas._libs.tslibs.nattype import NaT
+from pandas._libs.tslibs.nattype cimport NPY_NAT, c_NaT as NaT
 from pandas._libs.tslibs.conversion cimport convert_to_tsobject
 from pandas._libs.tslibs.timedeltas cimport convert_to_timedelta64
 from pandas._libs.tslibs.timezones cimport get_timezone, tz_compare
 
 from pandas._libs.missing cimport (
-    checknull, isnaobj, is_null_datetime64, is_null_timedelta64, is_null_period
+    checknull, isnaobj, is_null_datetime64, is_null_timedelta64, is_null_period, C_NA
 )
 
 
@@ -77,7 +75,9 @@ cdef:
 
 
 def values_from_object(obj: object):
-    """ return my values or the object if we are say an ndarray """
+    """
+    Return my values or the object if we are say an ndarray.
+    """
     func: object
 
     if getattr(obj, '_typ', '') == 'dataframe':
@@ -93,8 +93,11 @@ def values_from_object(obj: object):
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def memory_usage_of_objects(arr: object[:]) -> int64_t:
-    """ return the memory usage of an object array in bytes,
-    does not include the actual bytes of the pointers """
+    """
+    Return the memory usage of an object array in bytes.
+
+    Does not include the actual bytes of the pointers
+    """
     i: Py_ssize_t
     n: Py_ssize_t
     size: int64_t
@@ -111,8 +114,6 @@ def memory_usage_of_objects(arr: object[:]) -> int64_t:
 
 def is_scalar(val: object) -> bool:
     """
-    Return True if given value is scalar.
-
     Parameters
     ----------
     val : object
@@ -129,17 +130,17 @@ def is_scalar(val: object) -> bool:
         - Interval
         - DateOffset
         - Fraction
-        - Number
+        - Number.
 
     Returns
     -------
     bool
-        Return True if given object is scalar, False otherwise
+        Return True if given object is scalar.
 
     Examples
     --------
-    >>> dt = pd.datetime.datetime(2018, 10, 3)
-    >>> pd.is_scalar(dt)
+    >>> dt = datetime.datetime(2018, 10, 3)
+    >>> pd.api.types.is_scalar(dt)
     True
 
     >>> pd.api.types.is_scalar([2, 3])
@@ -158,21 +159,63 @@ def is_scalar(val: object) -> bool:
     True
     """
 
-    return (cnp.PyArray_IsAnyScalar(val)
+    # Start with C-optimized checks
+    if (cnp.PyArray_IsAnyScalar(val)
             # PyArray_IsAnyScalar is always False for bytearrays on Py3
             or PyDate_Check(val)
             or PyDelta_Check(val)
             or PyTime_Check(val)
             # We differ from numpy, which claims that None is not scalar;
             # see np.isscalar
-            or val is None
-            or isinstance(val, (Fraction, Number))
+            or val is C_NA
+            or val is None):
+        return True
+
+    # Next use C-optimized checks to exclude common non-scalars before falling
+    #  back to non-optimized checks.
+    if PySequence_Check(val):
+        # e.g. list, tuple
+        # includes np.ndarray, Series which PyNumber_Check can return True for
+        return False
+
+    # Note: PyNumber_Check check includes Decimal, Fraction, numbers.Number
+    return (PyNumber_Check(val)
             or util.is_period_object(val)
-            or is_decimal(val)
             or is_interval(val)
             or util.is_offset_object(val))
 
 
+def is_iterator(obj: object) -> bool:
+    """
+    Check if the object is an iterator.
+
+    This is intended for generators, not list-like objects.
+
+    Parameters
+    ----------
+    obj : The object to check
+
+    Returns
+    -------
+    is_iter : bool
+        Whether `obj` is an iterator.
+
+    Examples
+    --------
+    >>> is_iterator((x for x in []))
+    True
+    >>> is_iterator([1, 2, 3])
+    False
+    >>> is_iterator(datetime(2017, 1, 1))
+    False
+    >>> is_iterator("foo")
+    False
+    >>> is_iterator(1)
+    False
+    """
+    return PyIter_Check(obj)
+
+
 def item_from_zerodim(val: object) -> object:
     """
     If the value is a zerodim array, return the item it contains.
@@ -183,7 +226,7 @@ def item_from_zerodim(val: object) -> object:
 
     Returns
     -------
-    result : object
+    object
 
     Examples
     --------
@@ -195,7 +238,6 @@ def item_from_zerodim(val: object) -> object:
     1
     >>> item_from_zerodim(np.array([1]))
     array([1])
-
     """
     if cnp.PyArray_IsZeroDim(val):
         return cnp.PyArray_ToScalar(cnp.PyArray_DATA(val), val)
@@ -211,13 +253,13 @@ def fast_unique_multiple(list arrays, sort: bool=True):
     Parameters
     ----------
     list : array-like
-        A list of array-like objects
-    sort : boolean
-        Whether or not to sort the resulting unique list
+        List of array-like objects.
+    sort : bool
+        Whether or not to sort the resulting unique list.
 
     Returns
     -------
-    unique_list : list of unique values
+    list of unique values
     """
     cdef:
         ndarray[object] buf
@@ -282,13 +324,13 @@ def fast_unique_multiple_list_gen(object gen, bint sort=True):
     Parameters
     ----------
     gen : generator object
-        A generator of lists from which the unique list is created
-    sort : boolean
-        Whether or not to sort the resulting unique list
+        Generator of lists from which the unique list is created.
+    sort : bool
+        Whether or not to sort the resulting unique list.
 
     Returns
     -------
-    unique_list : list of unique values
+    list of unique values
     """
     cdef:
         list buf
@@ -341,7 +383,7 @@ def dicts_to_array(dicts: list, columns: list):
 
 def fast_zip(list ndarrays):
     """
-    For zipping multiple ndarrays into an ndarray of tuples
+    For zipping multiple ndarrays into an ndarray of tuples.
     """
     cdef:
         Py_ssize_t i, j, k, n
@@ -370,7 +412,7 @@ def fast_zip(list ndarrays):
         arr = ndarrays[j]
         it = <flatiter>PyArray_IterNew(arr)
         if len(arr) != n:
-            raise ValueError('all arrays must be same length')
+            raise ValueError("all arrays must be same length")
 
         for i in range(n):
             val = PyArray_GETITEM(arr, PyArray_ITER_DATA(it))
@@ -390,9 +432,7 @@ def get_reverse_indexer(const int64_t[:] indexer, Py_ssize_t length):
         indexer_inv[indexer[x]] = x
 
     .. note:: If indexer is not unique, only first occurrence is accounted.
-
     """
-
     cdef:
         Py_ssize_t i, n = len(indexer)
         ndarray[int64_t] rev_indexer
@@ -513,8 +553,10 @@ def maybe_booleans_to_slice(ndarray[uint8_t] mask):
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def array_equivalent_object(left: object[:], right: object[:]) -> bool:
-    """ perform an element by element comparion on 1-d object arrays
-        taking into account nan positions """
+    """
+    Perform an element by element comparison on 1-d object arrays
+    taking into account nan positions.
+    """
     cdef:
         Py_ssize_t i, n = left.shape[0]
         object x, y
@@ -525,9 +567,21 @@ def array_equivalent_object(left: object[:], right: object[:]) -> bool:
 
         # we are either not equal or both nan
         # I think None == None will be true here
-        if not (PyObject_RichCompareBool(x, y, Py_EQ) or
-                (x is None or is_nan(x)) and (y is None or is_nan(y))):
-            return False
+        try:
+            if PyArray_Check(x) and PyArray_Check(y):
+                if not array_equivalent_object(x, y):
+                    return False
+            elif not (PyObject_RichCompareBool(x, y, Py_EQ) or
+                      (x is None or is_nan(x)) and (y is None or is_nan(y))):
+                return False
+        except TypeError as err:
+            # Avoid raising TypeError on tzawareness mismatch
+            # TODO: This try/except can be removed if/when Timestamp
+            #  comparisons are change dto match datetime, see GH#28507
+            if "tz-naive and tz-aware" in str(err):
+                return False
+            raise
+
     return True
 
 
@@ -568,7 +622,7 @@ def astype_str(arr: ndarray, skipna: bool=False) -> ndarray[object]:
 
     Returns
     -------
-    casted_arr : ndarray
+    ndarray
         A new array with the input array's elements casted.
     """
     cdef:
@@ -591,7 +645,7 @@ def astype_str(arr: ndarray, skipna: bool=False) -> ndarray[object]:
 @cython.boundscheck(False)
 def clean_index_list(obj: list):
     """
-    Utility used in pandas.core.index.ensure_index
+    Utility used in ``pandas.core.indexes.api.ensure_index``.
     """
     cdef:
         Py_ssize_t i, n = len(obj)
@@ -610,7 +664,7 @@ def clean_index_list(obj: list):
 
     # don't force numpy coerce with nan's
     inferred = infer_dtype(obj, skipna=False)
-    if inferred in ['string', 'bytes', 'unicode', 'mixed', 'mixed-integer']:
+    if inferred in ['string', 'bytes', 'mixed', 'mixed-integer']:
         return np.asarray(obj, dtype=object), 0
     elif inferred in ['integer']:
         # TODO: we infer an integer but it *could* be a uint64
@@ -633,7 +687,7 @@ def clean_index_list(obj: list):
 def generate_bins_dt64(ndarray[int64_t] values, const int64_t[:] binner,
                        object closed='left', bint hasnans=0):
     """
-    Int64 (datetime64) version of generic python version in groupby.py
+    Int64 (datetime64) version of generic python version in ``groupby.py``.
     """
     cdef:
         Py_ssize_t lenidx, lenbin, i, j, bc, vc
@@ -693,10 +747,9 @@ def generate_bins_dt64(ndarray[int64_t] values, const int64_t[:] binner,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def get_level_sorter(const int64_t[:] label,
-                     const int64_t[:] starts):
+def get_level_sorter(const int64_t[:] label, const int64_t[:] starts):
     """
-    argsort for a single level of a multi-index, keeping the order of higher
+    Argsort for a single level of a multi-index, keeping the order of higher
     levels unchanged. `starts` points to starts of same-key indices w.r.t
     to leading levels; equivalent to:
         np.hstack([label[starts[i]:starts[i+1]].argsort(kind='mergesort')
@@ -774,8 +827,16 @@ def generate_slices(const int64_t[:] labels, Py_ssize_t ngroups):
     return starts, ends
 
 
-def indices_fast(object index, const int64_t[:] labels, list keys,
+def indices_fast(ndarray index, const int64_t[:] labels, list keys,
                  list sorted_labels):
+    """
+    Parameters
+    ----------
+    index : ndarray
+    labels : ndarray[int64]
+    keys : list
+    sorted_labels : list[ndarray[int64]]
+    """
     cdef:
         Py_ssize_t i, j, k, lab, cur, start, n = len(labels)
         dict result = {}
@@ -795,8 +856,7 @@ def indices_fast(object index, const int64_t[:] labels, list keys,
             if lab != -1:
                 tup = PyTuple_New(k)
                 for j in range(k):
-                    val = util.get_value_at(keys[j],
-                                            sorted_labels[j][i - 1])
+                    val = keys[j][sorted_labels[j][i - 1]]
                     PyTuple_SET_ITEM(tup, j, val)
                     Py_INCREF(val)
 
@@ -806,8 +866,7 @@ def indices_fast(object index, const int64_t[:] labels, list keys,
 
     tup = PyTuple_New(k)
     for j in range(k):
-        val = util.get_value_at(keys[j],
-                                sorted_labels[j][n - 1])
+        val = keys[j][sorted_labels[j][n - 1]]
         PyTuple_SET_ITEM(tup, j, val)
         Py_INCREF(val)
     result[tup] = index[start:]
@@ -818,18 +877,38 @@ def indices_fast(object index, const int64_t[:] labels, list keys,
 # core.common import for fast inference checks
 
 def is_float(obj: object) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     return util.is_float_object(obj)
 
 
 def is_integer(obj: object) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     return util.is_integer_object(obj)
 
 
 def is_bool(obj: object) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     return util.is_bool_object(obj)
 
 
 def is_complex(obj: object) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     return util.is_complex_object(obj)
 
 
@@ -842,11 +921,17 @@ cpdef bint is_interval(object obj):
 
 
 def is_period(val: object) -> bool:
-    """ Return a boolean if this is a Period object """
+    """
+    Return a boolean if this is a Period object.
+
+    Returns
+    -------
+    bool
+    """
     return util.is_period_object(val)
 
 
-def is_list_like(obj: object, allow_sets: bool = True):
+def is_list_like(obj: object, allow_sets: bool = True) -> bool:
     """
     Check if the object is list-like.
 
@@ -857,15 +942,16 @@ def is_list_like(obj: object, allow_sets: bool = True):
 
     Parameters
     ----------
-    obj : The object to check
-    allow_sets : boolean, default True
-        If this parameter is False, sets will not be considered list-like
+    obj : object
+        Object to check.
+    allow_sets : bool, default True
+        If this parameter is False, sets will not be considered list-like.
 
         .. versionadded:: 0.24.0
 
     Returns
     -------
-    is_list_like : bool
+    bool
         Whether `obj` has list-like properties.
 
     Examples
@@ -960,6 +1046,7 @@ cdef class Seen:
         bint nat_             # seen nat
         bint bool_            # seen_bool
         bint null_            # seen_null
+        bint nan_             # seen_np.nan
         bint uint_            # seen_uint (unsigned integer)
         bint sint_            # seen_sint (signed integer)
         bint float_           # seen_float
@@ -984,6 +1071,7 @@ cdef class Seen:
         self.nat_ = 0
         self.bool_ = 0
         self.null_ = 0
+        self.nan_ = 0
         self.uint_ = 0
         self.sint_ = 0
         self.float_ = 0
@@ -1014,15 +1102,16 @@ cdef class Seen:
 
         Returns
         -------
-        return_values : bool
+        bool
             Whether or not we should return the original input array to avoid
             data truncation.
 
         Raises
         ------
-        ValueError : uint64 elements were detected, and at least one of the
-                     two conflict cases was also detected. However, we are
-                     trying to force conversion to a numeric dtype.
+        ValueError
+            uint64 elements were detected, and at least one of the
+            two conflict cases was also detected. However, we are
+            trying to force conversion to a numeric dtype.
         """
         return (self.uint_ and (self.null_ or self.sint_)
                 and not self.coerce_numeric)
@@ -1071,7 +1160,9 @@ cdef class Seen:
 
 
 cdef _try_infer_map(v):
-    """ if its in our map, just return the dtype """
+    """
+    If its in our map, just return the dtype.
+    """
     cdef:
         object attr, val
     for attr in ['name', 'kind', 'base']:
@@ -1081,7 +1172,7 @@ cdef _try_infer_map(v):
     return None
 
 
-def infer_dtype(value: object, skipna: object=None) -> str:
+def infer_dtype(value: object, skipna: bool = True) -> str:
     """
     Efficiently infer the type of a passed val, or list-like
     array of values. Return a string describing the type.
@@ -1089,18 +1180,18 @@ def infer_dtype(value: object, skipna: object=None) -> str:
     Parameters
     ----------
     value : scalar, list, ndarray, or pandas type
-    skipna : bool, default False
+    skipna : bool, default True
         Ignore NaN values when inferring the type.
 
         .. versionadded:: 0.21.0
 
     Returns
     -------
-    string describing the common type of the input data.
+    str
+        Describing the common type of the input data.
     Results can include:
 
     - string
-    - unicode
     - bytes
     - floating
     - integer
@@ -1121,7 +1212,8 @@ def infer_dtype(value: object, skipna: object=None) -> str:
 
     Raises
     ------
-    TypeError if ndarray-like but cannot infer the dtype
+    TypeError
+        If ndarray-like but cannot infer the dtype
 
     Notes
     -----
@@ -1187,12 +1279,6 @@ def infer_dtype(value: object, skipna: object=None) -> str:
         bint seen_pdnat = False
         bint seen_val = False
 
-    if skipna is None:
-        msg = ('A future version of pandas will default to `skipna=True`. To '
-               'silence this warning, pass `skipna=True|False` explicitly.')
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        skipna = False
-
     if util.is_array(value):
         values = value
     elif hasattr(value, 'dtype'):
@@ -1208,8 +1294,7 @@ def infer_dtype(value: object, skipna: object=None) -> str:
                 return value
 
             # its ndarray like but we can't handle
-            raise ValueError("cannot infer type for {typ}"
-                             .format(typ=type(value)))
+            raise ValueError(f"cannot infer type for {type(value)}")
 
     else:
         if not isinstance(value, list):
@@ -1221,9 +1306,6 @@ def infer_dtype(value: object, skipna: object=None) -> str:
     # make contiguous
     values = values.ravel()
 
-    if skipna:
-        values = values[~isnaobj(values)]
-
     val = _try_infer_map(values)
     if val is not None:
         return val
@@ -1231,6 +1313,9 @@ def infer_dtype(value: object, skipna: object=None) -> str:
     if values.dtype != np.object_:
         values = values.astype('O')
 
+    if skipna:
+        values = values[~isnaobj(values)]
+
     n = len(values)
     if n == 0:
         return 'empty'
@@ -1251,90 +1336,90 @@ def infer_dtype(value: object, skipna: object=None) -> str:
 
     # if all values are nan/NaT
     if seen_val is False and seen_pdnat is True:
-        return 'datetime'
+        return "datetime"
         # float/object nan is handled in latter logic
 
     if util.is_datetime64_object(val):
         if is_datetime64_array(values):
-            return 'datetime64'
+            return "datetime64"
 
     elif is_timedelta(val):
         if is_timedelta_or_timedelta64_array(values):
-            return 'timedelta'
+            return "timedelta"
 
     elif util.is_integer_object(val):
         # ordering matters here; this check must come after the is_timedelta
         #  check otherwise numpy timedelta64 objects would come through here
 
         if is_integer_array(values):
-            return 'integer'
+            return "integer"
         elif is_integer_float_array(values):
             if is_integer_na_array(values):
-                return 'integer-na'
+                return "integer-na"
             else:
-                return 'mixed-integer-float'
-        return 'mixed-integer'
+                return "mixed-integer-float"
+        return "mixed-integer"
 
     elif PyDateTime_Check(val):
         if is_datetime_array(values):
-            return 'datetime'
+            return "datetime"
 
     elif PyDate_Check(val):
         if is_date_array(values, skipna=skipna):
-            return 'date'
+            return "date"
 
     elif PyTime_Check(val):
         if is_time_array(values, skipna=skipna):
-            return 'time'
+            return "time"
 
     elif is_decimal(val):
-        return 'decimal'
+        return "decimal"
 
     elif is_complex(val):
-        return 'complex'
+        return "complex"
 
     elif util.is_float_object(val):
         if is_float_array(values):
-            return 'floating'
+            return "floating"
         elif is_integer_float_array(values):
             if is_integer_na_array(values):
-                return 'integer-na'
+                return "integer-na"
             else:
-                return 'mixed-integer-float'
+                return "mixed-integer-float"
 
     elif util.is_bool_object(val):
         if is_bool_array(values, skipna=skipna):
-            return 'boolean'
+            return "boolean"
 
     elif isinstance(val, str):
         if is_string_array(values, skipna=skipna):
-            return 'string'
+            return "string"
 
     elif isinstance(val, bytes):
         if is_bytes_array(values, skipna=skipna):
-            return 'bytes'
+            return "bytes"
 
     elif util.is_period_object(val):
         if is_period_array(values):
-            return 'period'
+            return "period"
 
     elif is_interval(val):
         if is_interval_array(values):
-            return 'interval'
+            return "interval"
 
     for i in range(n):
         val = values[i]
         if (util.is_integer_object(val) and
                 not util.is_timedelta64_object(val) and
                 not util.is_datetime64_object(val)):
-            return 'mixed-integer'
+            return "mixed-integer"
 
-    return 'mixed'
+    return "mixed"
 
 
 def infer_datetimelike_array(arr: object) -> object:
     """
-    infer if we have a datetime or timedelta array
+    Infer if we have a datetime or timedelta array.
     - date: we have *only* date and maybe strings, nulls
     - datetime: we have *only* datetimes and maybe strings, nulls
     - timedelta: we have *only* timedeltas and maybe strings, nulls
@@ -1349,9 +1434,8 @@ def infer_datetimelike_array(arr: object) -> object:
 
     Returns
     -------
-    string: {datetime, timedelta, date, nat, mixed}
+    str: {datetime, timedelta, date, nat, mixed}
     """
-
     cdef:
         Py_ssize_t i, n = len(arr)
         bint seen_timedelta = 0, seen_date = 0, seen_datetime = 0
@@ -1394,16 +1478,16 @@ def infer_datetimelike_array(arr: object) -> object:
             # timedelta, or timedelta64
             seen_timedelta = 1
         else:
-            return 'mixed'
+            return "mixed"
 
     if seen_date and not (seen_datetime or seen_timedelta):
-        return 'date'
+        return "date"
     elif seen_datetime and not seen_timedelta:
-        return 'datetime'
+        return "datetime"
     elif seen_timedelta and not seen_datetime:
-        return 'timedelta'
+        return "timedelta"
     elif seen_nat:
-        return 'nat'
+        return "nat"
 
     # short-circuit by trying to
     # actually convert these strings
@@ -1411,8 +1495,8 @@ def infer_datetimelike_array(arr: object) -> object:
     # convert *every* string array
     if len(objs):
         try:
-            array_to_datetime(objs, errors='raise')
-            return 'datetime'
+            array_to_datetime(objs, errors="raise")
+            return "datetime"
         except (ValueError, TypeError):
             pass
 
@@ -1486,12 +1570,11 @@ cdef class Validator:
         return self.is_valid(value) or self.is_valid_null(value)
 
     cdef bint is_value_typed(self, object value) except -1:
-        raise NotImplementedError(
-            '{typ} child class must define is_value_typed'
-            .format(typ=type(self).__name__))
+        raise NotImplementedError(f"{type(self).__name__} child class "
+                                  "must define is_value_typed")
 
     cdef bint is_valid_null(self, object value) except -1:
-        return value is None or util.is_nan(value)
+        return value is None or value is C_NA or util.is_nan(value)
 
     cdef bint is_array_typed(self) except -1:
         return False
@@ -1585,6 +1668,10 @@ cdef class StringValidator(Validator):
     cdef inline bint is_array_typed(self) except -1:
         return issubclass(self.dtype.type, np.str_)
 
+    cdef bint is_valid_null(self, object value) except -1:
+        # We deliberately exclude None / NaN here since StringArray uses NA
+        return value is C_NA
+
 
 cpdef bint is_string_array(ndarray values, bint skipna=False):
     cdef:
@@ -1624,9 +1711,8 @@ cdef class TemporalValidator(Validator):
         return self.is_value_typed(value) or self.is_valid_null(value)
 
     cdef bint is_valid_null(self, object value) except -1:
-        raise NotImplementedError(
-            '{typ} child class must define is_valid_null'
-            .format(typ=type(self).__name__))
+        raise NotImplementedError(f"{type(self).__name__} child class "
+                                  "must define is_valid_null")
 
     cdef inline bint is_valid_skipna(self, object value) except -1:
         cdef:
@@ -1666,6 +1752,7 @@ cpdef bint is_datetime64_array(ndarray values):
     return validator.validate(values)
 
 
+# TODO: only non-here use is in test
 def is_datetime_with_singletz_array(values: ndarray) -> bool:
     """
     Check values have the same tzinfo attribute.
@@ -1709,8 +1796,11 @@ cdef class AnyTimedeltaValidator(TimedeltaValidator):
         return is_timedelta(value)
 
 
+# TODO: only non-here use is in test
 cpdef bint is_timedelta_or_timedelta64_array(ndarray values):
-    """ infer with timedeltas and/or nat/none """
+    """
+    Infer with timedeltas and/or nat/none.
+    """
     cdef:
         AnyTimedeltaValidator validator = AnyTimedeltaValidator(len(values),
                                                                 skipna=True)
@@ -1795,9 +1885,8 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
 
     Returns
     -------
-    numeric_array : array of converted object values to numerical ones
+    Array of converted object values to numerical ones.
     """
-
     if len(values) == 0:
         return np.array([], dtype='i8')
 
@@ -1867,7 +1956,7 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
                 seen.saw_null()
                 floats[i] = complexes[i] = NaN
             else:
-                raise ValueError('Empty string encountered')
+                raise ValueError("Empty string encountered")
         elif util.is_complex_object(val):
             complexes[i] = val
             seen.complex_ = True
@@ -1911,10 +2000,10 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
                     seen.float_ = seen.float_ or (seen.uint_ and seen.sint_)
                 else:
                     seen.float_ = True
-            except (TypeError, ValueError) as e:
+            except (TypeError, ValueError) as err:
                 if not seen.coerce_numeric:
-                    raise type(e)(str(e) + " at position {pos}".format(pos=i))
-                elif "uint64" in str(e):  # Exception from check functions.
+                    raise type(err)(f"{err} at position {i}")
+                elif "uint64" in str(err):  # Exception from check functions.
                     raise
 
                 seen.saw_null()
@@ -1943,9 +2032,34 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
 @cython.wraparound(False)
 def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
                           bint safe=0, bint convert_datetime=0,
-                          bint convert_timedelta=0):
+                          bint convert_timedelta=0,
+                          bint convert_to_nullable_integer=0):
     """
     Type inference function-- convert object array to proper dtype
+
+    Parameters
+    ----------
+    values : ndarray
+        Array of object elements to convert.
+    try_float : bool, default False
+        If an array-like object contains only float or NaN values is
+        encountered, whether to convert and return an array of float dtype.
+    safe : bool, default False
+        Whether to upcast numeric type (e.g. int cast to float). If set to
+        True, no upcasting will be performed.
+    convert_datetime : bool, default False
+        If an array-like object contains only datetime values or NaT is
+        encountered, whether to convert and return an array of M8[ns] dtype.
+    convert_timedelta : bool, default False
+        If an array-like object contains only timedelta values or NaT is
+        encountered, whether to convert and return an array of m8[ns] dtype.
+    convert_to_nullable_integer : bool, default False
+        If an array-like object contains only interger values (and NaN) is
+        encountered, whether to convert and return an IntegerArray.
+
+    Returns
+    -------
+    Array of converted object values to more specific dtypes if applicable.
     """
     cdef:
         Py_ssize_t i, n
@@ -1967,6 +2081,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
     ints = np.empty(n, dtype='i8')
     uints = np.empty(n, dtype='u8')
     bools = np.empty(n, dtype=np.uint8)
+    mask = np.full(n, False)
 
     if convert_datetime:
         datetimes = np.empty(n, dtype='M8[ns]')
@@ -1984,6 +2099,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
         if val is None:
             seen.null_ = 1
             floats[i] = complexes[i] = fnan
+            mask[i] = True
         elif val is NaT:
             seen.nat_ = 1
             if convert_datetime:
@@ -1993,6 +2109,10 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
             if not (convert_datetime or convert_timedelta):
                 seen.object_ = 1
                 break
+        elif val is np.nan:
+            seen.nan_ = 1
+            mask[i] = True
+            floats[i] = complexes[i] = val
         elif util.is_bool_object(val):
             seen.bool_ = 1
             bools[i] = val
@@ -2058,7 +2178,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
                 floats[i] = float(val)
                 complexes[i] = complex(val)
                 seen.float_ = 1
-            except Exception:
+            except (ValueError, TypeError):
                 seen.object_ = 1
                 break
         else:
@@ -2074,11 +2194,19 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
 
     if not seen.object_:
         if not safe:
-            if seen.null_:
+            if seen.null_ or seen.nan_:
                 if seen.is_float_or_complex:
                     if seen.complex_:
                         return complexes
-                    elif seen.float_ or seen.int_:
+                    elif seen.float_:
+                        return floats
+                    elif seen.int_:
+                        if convert_to_nullable_integer:
+                            from pandas.core.arrays import IntegerArray
+                            return IntegerArray(ints, mask)
+                        else:
+                            return floats
+                    elif seen.nan_:
                         return floats
             else:
                 if not seen.bool_:
@@ -2117,7 +2245,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
                     if seen.complex_:
                         if not seen.int_:
                             return complexes
-                    elif seen.float_:
+                    elif seen.float_ or seen.nan_:
                         if not seen.int_:
                             return floats
             else:
@@ -2141,7 +2269,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
                         if seen.complex_:
                             if not seen.int_:
                                 return complexes
-                        elif seen.float_:
+                        elif seen.float_ or seen.nan_:
                             if not seen.int_:
                                 return floats
                         elif seen.int_:
@@ -2155,32 +2283,48 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
     return objects
 
 
+# Note: no_default is exported to the public API in pandas.api.extensions
+no_default = object()  #: Sentinel indicating the default value.
+
+
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def map_infer_mask(ndarray arr, object f, const uint8_t[:] mask,
-                   bint convert=1):
+def map_infer_mask(ndarray arr, object f, const uint8_t[:] mask, bint convert=1,
+                   object na_value=no_default, object dtype=object):
     """
-    Substitute for np.vectorize with pandas-friendly dtype inference
+    Substitute for np.vectorize with pandas-friendly dtype inference.
 
     Parameters
     ----------
     arr : ndarray
     f : function
+    mask : ndarray
+        uint8 dtype ndarray indicating values not to apply `f` to.
+    convert : bool, default True
+        Whether to call `maybe_convert_objects` on the resulting ndarray
+    na_value : Any, optional
+        The result value to use for masked values. By default, the
+        input value is used
+    dtype : numpy.dtype
+        The numpy dtype to use for the result ndarray.
 
     Returns
     -------
-    mapped : ndarray
+    ndarray
     """
     cdef:
         Py_ssize_t i, n
-        ndarray[object] result
+        ndarray result
         object val
 
     n = len(arr)
-    result = np.empty(n, dtype=object)
+    result = np.empty(n, dtype=dtype)
     for i in range(n):
         if mask[i]:
-            val = arr[i]
+            if na_value is no_default:
+                val = arr[i]
+            else:
+                val = na_value
         else:
             val = f(arr[i])
 
@@ -2205,7 +2349,7 @@ def map_infer_mask(ndarray arr, object f, const uint8_t[:] mask,
 @cython.wraparound(False)
 def map_infer(ndarray arr, object f, bint convert=1):
     """
-    Substitute for np.vectorize with pandas-friendly dtype inference
+    Substitute for np.vectorize with pandas-friendly dtype inference.
 
     Parameters
     ----------
@@ -2214,7 +2358,7 @@ def map_infer(ndarray arr, object f, bint convert=1):
 
     Returns
     -------
-    mapped : ndarray
+    ndarray
     """
     cdef:
         Py_ssize_t i, n
@@ -2250,16 +2394,16 @@ def to_object_array(rows: object, int min_width=0):
     Parameters
     ----------
     rows : 2-d array (N, K)
-        A list of lists to be converted into an array
+        List of lists to be converted into an array.
     min_width : int
-        The minimum width of the object array. If a list
+        Minimum width of the object array. If a list
         in `rows` contains fewer than `width` elements,
         the remaining elements in the corresponding row
         will all be `NaN`.
 
     Returns
     -------
-    obj_array : numpy array of the object dtype
+    numpy array of the object dtype.
     """
     cdef:
         Py_ssize_t i, j, n, k, tmp
@@ -2311,11 +2455,11 @@ def to_object_array_tuples(rows: object):
     Parameters
     ----------
     rows : 2-d array (N, K)
-        A list of tuples to be converted into an array.
+        List of tuples to be converted into an array.
 
     Returns
     -------
-    obj_array : numpy array of the object dtype
+    numpy array of the object dtype.
     """
     cdef:
         Py_ssize_t i, j, n, k, tmp
@@ -2338,7 +2482,8 @@ def to_object_array_tuples(rows: object):
             row = rows[i]
             for j in range(len(row)):
                 result[i, j] = row[j]
-    except Exception:
+    except TypeError:
+        # e.g. "Expected tuple, got list"
         # upcast any subclasses to tuple
         for i in range(n):
             row = (rows[i],) if checknull(rows[i]) else tuple(rows[i])
diff --git a/pandas/_libs/missing.pxd b/pandas/_libs/missing.pxd
index d0dd306680ae8..d4303ac28b9a5 100644
--- a/pandas/_libs/missing.pxd
+++ b/pandas/_libs/missing.pxd
@@ -9,3 +9,8 @@ cpdef ndarray[uint8_t] isnaobj(ndarray arr)
 cdef bint is_null_datetime64(v)
 cdef bint is_null_timedelta64(v)
 cdef bint is_null_period(v)
+
+cdef class C_NAType:
+    pass
+
+cdef C_NAType C_NA
diff --git a/pandas/_libs/missing.pyx b/pandas/_libs/missing.pyx
index 052b081988c9e..4d17a6f883c1c 100644
--- a/pandas/_libs/missing.pyx
+++ b/pandas/_libs/missing.pyx
@@ -1,6 +1,8 @@
 import cython
 from cython import Py_ssize_t
 
+import numbers
+
 import numpy as np
 cimport numpy as cnp
 from numpy cimport ndarray, int64_t, uint8_t, float64_t
@@ -12,6 +14,9 @@ from pandas._libs.tslibs.np_datetime cimport (
     get_timedelta64_value, get_datetime64_value)
 from pandas._libs.tslibs.nattype cimport (
     checknull_with_nat, c_NaT as NaT, is_null_datetimelike)
+from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op
+
+from pandas.compat import is_platform_32bit
 
 
 cdef:
@@ -20,6 +25,8 @@ cdef:
 
     int64_t NPY_NAT = util.get_nat()
 
+    bint is_32bit = is_platform_32bit()
+
 
 cpdef bint checknull(object val):
     """
@@ -44,7 +51,7 @@ cpdef bint checknull(object val):
     The difference between `checknull` and `checknull_old` is that `checknull`
     does *not* consider INF or NEGINF to be NA.
     """
-    return is_null_datetimelike(val, inat_is_null=False)
+    return val is C_NA or is_null_datetimelike(val, inat_is_null=False)
 
 
 cpdef bint checknull_old(object val):
@@ -121,7 +128,7 @@ cpdef ndarray[uint8_t] isnaobj(ndarray arr):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def isnaobj_old(ndarray arr):
+def isnaobj_old(arr: ndarray) -> ndarray:
     """
     Return boolean mask denoting which elements of a 1-D array are na-like,
     defined as being any of:
@@ -156,7 +163,7 @@ def isnaobj_old(ndarray arr):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def isnaobj2d(ndarray arr):
+def isnaobj2d(arr: ndarray) -> ndarray:
     """
     Return boolean mask denoting which elements of a 2-D array are na-like,
     according to the criteria defined in `checknull`:
@@ -198,7 +205,7 @@ def isnaobj2d(ndarray arr):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def isnaobj2d_old(ndarray arr):
+def isnaobj2d_old(arr: ndarray) -> ndarray:
     """
     Return boolean mask denoting which elements of a 2-D array are na-like,
     according to the criteria defined in `checknull_old`:
@@ -278,3 +285,201 @@ cdef inline bint is_null_period(v):
     # determine if we have a null for a Period (or integer versions),
     # excluding np.datetime64('nat') and np.timedelta64('nat')
     return checknull_with_nat(v)
+
+
+# -----------------------------------------------------------------------------
+# Implementation of NA singleton
+
+
+def _create_binary_propagating_op(name, is_divmod=False):
+
+    def method(self, other):
+        if (other is C_NA or isinstance(other, str)
+                or isinstance(other, (numbers.Number, np.bool_))
+                or isinstance(other, np.ndarray) and not other.shape):
+            # Need the other.shape clause to handle NumPy scalars,
+            # since we do a setitem on `out` below, which
+            # won't work for NumPy scalars.
+            if is_divmod:
+                return NA, NA
+            else:
+                return NA
+
+        elif isinstance(other, np.ndarray):
+            out = np.empty(other.shape, dtype=object)
+            out[:] = NA
+
+            if is_divmod:
+                return out, out.copy()
+            else:
+                return out
+
+        return NotImplemented
+
+    method.__name__ = name
+    return method
+
+
+def _create_unary_propagating_op(name):
+    def method(self):
+        return NA
+
+    method.__name__ = name
+    return method
+
+
+cdef class C_NAType:
+    pass
+
+
+class NAType(C_NAType):
+    """
+    NA ("not available") missing value indicator.
+
+    .. warning::
+
+       Experimental: the behaviour of NA can still change without warning.
+
+    .. versionadded:: 1.0.0
+
+    The NA singleton is a missing value indicator defined by pandas. It is
+    used in certain new extension dtypes (currently the "string" dtype).
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if NAType._instance is None:
+            NAType._instance = C_NAType.__new__(cls, *args, **kwargs)
+        return NAType._instance
+
+    def __repr__(self) -> str:
+        return "<NA>"
+
+    def __bool__(self):
+        raise TypeError("boolean value of NA is ambiguous")
+
+    def __hash__(self):
+        # GH 30013: Ensure hash is large enough to avoid hash collisions with integers
+        exponent = 31 if is_32bit else 61
+        return 2 ** exponent - 1
+
+    # Binary arithmetic and comparison ops -> propagate
+
+    __add__ = _create_binary_propagating_op("__add__")
+    __radd__ = _create_binary_propagating_op("__radd__")
+    __sub__ = _create_binary_propagating_op("__sub__")
+    __rsub__ = _create_binary_propagating_op("__rsub__")
+    __mul__ = _create_binary_propagating_op("__mul__")
+    __rmul__ = _create_binary_propagating_op("__rmul__")
+    __matmul__ = _create_binary_propagating_op("__matmul__")
+    __rmatmul__ = _create_binary_propagating_op("__rmatmul__")
+    __truediv__ = _create_binary_propagating_op("__truediv__")
+    __rtruediv__ = _create_binary_propagating_op("__rtruediv__")
+    __floordiv__ = _create_binary_propagating_op("__floordiv__")
+    __rfloordiv__ = _create_binary_propagating_op("__rfloordiv__")
+    __mod__ = _create_binary_propagating_op("__mod__")
+    __rmod__ = _create_binary_propagating_op("__rmod__")
+    __divmod__ = _create_binary_propagating_op("__divmod__", is_divmod=True)
+    __rdivmod__ = _create_binary_propagating_op("__rdivmod__", is_divmod=True)
+    # __lshift__ and __rshift__ are not implemented
+
+    __eq__ = _create_binary_propagating_op("__eq__")
+    __ne__ = _create_binary_propagating_op("__ne__")
+    __le__ = _create_binary_propagating_op("__le__")
+    __lt__ = _create_binary_propagating_op("__lt__")
+    __gt__ = _create_binary_propagating_op("__gt__")
+    __ge__ = _create_binary_propagating_op("__ge__")
+
+    # Unary ops
+
+    __neg__ = _create_unary_propagating_op("__neg__")
+    __pos__ = _create_unary_propagating_op("__pos__")
+    __abs__ = _create_unary_propagating_op("__abs__")
+    __invert__ = _create_unary_propagating_op("__invert__")
+
+    # pow has special
+    def __pow__(self, other):
+        if other is C_NA:
+            return NA
+        elif isinstance(other, (numbers.Number, np.bool_)):
+            if other == 0:
+                # returning positive is correct for +/- 0.
+                return type(other)(1)
+            else:
+                return NA
+        elif isinstance(other, np.ndarray):
+            return np.where(other == 0, other.dtype.type(1), NA)
+
+        return NotImplemented
+
+    def __rpow__(self, other):
+        if other is C_NA:
+            return NA
+        elif isinstance(other, (numbers.Number, np.bool_)):
+            if other == 1:
+                return other
+            else:
+                return NA
+        elif isinstance(other, np.ndarray):
+            return np.where(other == 1, other, NA)
+
+        return NotImplemented
+
+    # Logical ops using Kleene logic
+
+    def __and__(self, other):
+        if other is False:
+            return False
+        elif other is True or other is C_NA:
+            return NA
+        else:
+            return NotImplemented
+
+    __rand__ = __and__
+
+    def __or__(self, other):
+        if other is True:
+            return True
+        elif other is False or other is C_NA:
+            return NA
+        else:
+            return NotImplemented
+
+    __ror__ = __or__
+
+    def __xor__(self, other):
+        if other is False or other is True or other is C_NA:
+            return NA
+        return NotImplemented
+
+    __rxor__ = __xor__
+
+    __array_priority__ = 1000
+    _HANDLED_TYPES = (np.ndarray, numbers.Number, str, np.bool_)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        types = self._HANDLED_TYPES + (NAType,)
+        for x in inputs:
+            if not isinstance(x, types):
+                return NotImplemented
+
+        if method != "__call__":
+            raise ValueError(f"ufunc method '{method}' not supported for NA")
+        result = maybe_dispatch_ufunc_to_dunder_op(
+            self, ufunc, method, *inputs, **kwargs
+        )
+        if result is NotImplemented:
+            # For a NumPy ufunc that's not a binop, like np.logaddexp
+            index = [i for i, x in enumerate(inputs) if x is NA][0]
+            result = np.broadcast_arrays(*inputs)[index]
+            if result.ndim == 0:
+                result = result.item()
+            if ufunc.nout > 1:
+                result = (NA,) * ufunc.nout
+
+        return result
+
+
+C_NA = NAType()   # C-visible
+NA = C_NA         # Python-visible
diff --git a/pandas/_libs/ops.pyx b/pandas/_libs/ops.pyx
index bdafcd646a4c8..abe1484e3763d 100644
--- a/pandas/_libs/ops.pyx
+++ b/pandas/_libs/ops.pyx
@@ -123,8 +123,7 @@ def vec_compare(object[:] left, object[:] right, object op):
         int flag
 
     if n != <Py_ssize_t>len(right):
-        raise ValueError('Arrays were different lengths: {n} vs {nright}'
-                         .format(n=n, nright=len(right)))
+        raise ValueError(f'Arrays were different lengths: {n} vs {len(right)}')
 
     if op is operator.lt:
         flag = Py_LT
@@ -224,8 +223,7 @@ def vec_binop(object[:] left, object[:] right, object op):
         object[:] result
 
     if n != <Py_ssize_t>len(right):
-        raise ValueError('Arrays were different lengths: {n} vs {nright}'
-                         .format(n=n, nright=len(right)))
+        raise ValueError(f'Arrays were different lengths: {n} vs {len(right)}')
 
     result = np.empty(n, dtype=object)
 
diff --git a/pandas/_libs/ops_dispatch.pyx b/pandas/_libs/ops_dispatch.pyx
new file mode 100644
index 0000000000000..f6ecef2038cf3
--- /dev/null
+++ b/pandas/_libs/ops_dispatch.pyx
@@ -0,0 +1,94 @@
+DISPATCHED_UFUNCS = {
+    "add",
+    "sub",
+    "mul",
+    "pow",
+    "mod",
+    "floordiv",
+    "truediv",
+    "divmod",
+    "eq",
+    "ne",
+    "lt",
+    "gt",
+    "le",
+    "ge",
+    "remainder",
+    "matmul",
+    "or",
+    "xor",
+    "and",
+}
+UFUNC_ALIASES = {
+    "subtract": "sub",
+    "multiply": "mul",
+    "floor_divide": "floordiv",
+    "true_divide": "truediv",
+    "power": "pow",
+    "remainder": "mod",
+    "divide": "div",
+    "equal": "eq",
+    "not_equal": "ne",
+    "less": "lt",
+    "less_equal": "le",
+    "greater": "gt",
+    "greater_equal": "ge",
+    "bitwise_or": "or",
+    "bitwise_and": "and",
+    "bitwise_xor": "xor",
+}
+
+# For op(., Array) -> Array.__r{op}__
+REVERSED_NAMES = {
+    "lt": "__gt__",
+    "le": "__ge__",
+    "gt": "__lt__",
+    "ge": "__le__",
+    "eq": "__eq__",
+    "ne": "__ne__",
+}
+
+
+def maybe_dispatch_ufunc_to_dunder_op(
+    object self, object ufunc, str method, *inputs, **kwargs
+):
+    """
+    Dispatch a ufunc to the equivalent dunder method.
+
+    Parameters
+    ----------
+    self : ArrayLike
+        The array whose dunder method we dispatch to
+    ufunc : Callable
+        A NumPy ufunc
+    method : {'reduce', 'accumulate', 'reduceat', 'outer', 'at', '__call__'}
+    inputs : ArrayLike
+        The input arrays.
+    kwargs : Any
+        The additional keyword arguments, e.g. ``out``.
+
+    Returns
+    -------
+    result : Any
+        The result of applying the ufunc
+    """
+    # special has the ufuncs we dispatch to the dunder op on
+
+    op_name = ufunc.__name__
+    op_name = UFUNC_ALIASES.get(op_name, op_name)
+
+    def not_implemented(*args, **kwargs):
+        return NotImplemented
+
+    if (method == "__call__"
+            and op_name in DISPATCHED_UFUNCS
+            and kwargs.get("out") is None):
+        if isinstance(inputs[0], type(self)):
+            name = f"__{op_name}__"
+            return getattr(self, name, not_implemented)(inputs[1])
+        else:
+            name = REVERSED_NAMES.get(op_name, f"__r{op_name}__")
+            result = getattr(self, name, not_implemented)(inputs[0])
+            return result
+    else:
+        return NotImplemented
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index f5a42d7aef3ba..3077f73a8d1a4 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -2,6 +2,7 @@
 # See LICENSE for the license
 import bz2
 import gzip
+import io
 import os
 import sys
 import time
@@ -63,11 +64,6 @@ from pandas.errors import (ParserError, DtypeWarning,
 
 lzma = _import_lzma()
 
-# Import CParserError as alias of ParserError for backwards compatibility.
-# Ultimately, we want to remove this import. See gh-12665 and gh-14479.
-CParserError = ParserError
-
-
 cdef:
     float64_t INF = <float64_t>np.inf
     float64_t NEGINF = -INF
@@ -176,12 +172,9 @@ cdef extern from "parser/tokenizer.h":
         int64_t skip_first_N_rows
         int64_t skipfooter
         # pick one, depending on whether the converter requires GIL
-        float64_t (*double_converter_nogil)(const char *, char **,
-                                            char, char, char,
-                                            int, int *, int *) nogil
-        float64_t (*double_converter_withgil)(const char *, char **,
-                                              char, char, char,
-                                              int, int *, int *)
+        float64_t (*double_converter)(const char *, char **,
+                                      char, char, char,
+                                      int, int *, int *) nogil
 
         #  error handling
         char *warn_msg
@@ -278,7 +271,7 @@ cdef class TextReader:
         object true_values, false_values
         object handle
         bint na_filter, keep_default_na, verbose, has_usecols, has_mi_columns
-        int64_t parser_start
+        uint64_t parser_start
         list clocks
         char *c_encoding
         kh_str_starts_t *false_set
@@ -474,16 +467,11 @@ cdef class TextReader:
 
         if float_precision == "round_trip":
             # see gh-15140
-            #
-            # Our current roundtrip implementation requires the GIL.
-            self.parser.double_converter_nogil = NULL
-            self.parser.double_converter_withgil = round_trip
+            self.parser.double_converter = round_trip
         elif float_precision == "high":
-            self.parser.double_converter_withgil = NULL
-            self.parser.double_converter_nogil = precise_xstrtod
+            self.parser.double_converter = precise_xstrtod
         else:
-            self.parser.double_converter_withgil = NULL
-            self.parser.double_converter_nogil = xstrtod
+            self.parser.double_converter = xstrtod
 
         if isinstance(dtype, dict):
             dtype = {k: pandas_dtype(dtype[k])
@@ -589,8 +577,7 @@ cdef class TextReader:
 
         if not isinstance(quote_char, (str, bytes)) and quote_char is not None:
             dtype = type(quote_char).__name__
-            raise TypeError('"quotechar" must be string, '
-                            'not {dtype}'.format(dtype=dtype))
+            raise TypeError(f'"quotechar" must be string, not {dtype}')
 
         if quote_char is None or quote_char == '':
             if quoting != QUOTE_NONE:
@@ -637,25 +624,24 @@ cdef class TextReader:
                     source = zip_file.open(file_name)
 
                 elif len(zip_names) == 0:
-                    raise ValueError('Zero files found in compressed '
-                                     'zip file %s', source)
+                    raise ValueError(f'Zero files found in compressed '
+                                     f'zip file {source}')
                 else:
-                    raise ValueError('Multiple files found in compressed '
-                                     'zip file %s', str(zip_names))
+                    raise ValueError(f'Multiple files found in compressed '
+                                     f'zip file {zip_names}')
             elif self.compression == 'xz':
                 if isinstance(source, str):
                     source = _get_lzma_file(lzma)(source, 'rb')
                 else:
                     source = _get_lzma_file(lzma)(filename=source)
             else:
-                raise ValueError('Unrecognized compression type: %s' %
-                                 self.compression)
-
-            if b'utf-16' in (self.encoding or b''):
-                # we need to read utf-16 through UTF8Recoder.
-                # if source is utf-16, convert source to utf-8 by UTF8Recoder.
-                source = icom.UTF8Recoder(source,
-                                          self.encoding.decode('utf-8'))
+                raise ValueError(f'Unrecognized compression type: '
+                                 f'{self.compression}')
+
+            if self.encoding and isinstance(source, (io.BufferedIOBase, io.RawIOBase)):
+                source = io.TextIOWrapper(
+                    source, self.encoding.decode('utf-8'), newline='')
+
                 self.encoding = b'utf-8'
                 self.c_encoding = <char*>self.encoding
 
@@ -663,7 +649,7 @@ cdef class TextReader:
 
         if isinstance(source, str):
             encoding = sys.getfilesystemencoding() or "utf-8"
-
+            usource = source
             source = source.encode(encoding)
 
             if self.memory_map:
@@ -683,10 +669,11 @@ cdef class TextReader:
 
             if ptr == NULL:
                 if not os.path.exists(source):
+
                     raise FileNotFoundError(
                         ENOENT,
-                        'File {source} does not exist'.format(source=source),
-                        source)
+                        f'File {usource} does not exist',
+                        usource)
                 raise IOError('Initializing from file failed')
 
             self.parser.source = ptr
@@ -703,18 +690,18 @@ cdef class TextReader:
             self.parser.cb_io = &buffer_rd_bytes
             self.parser.cb_cleanup = &del_rd_source
         else:
-            raise IOError('Expected file path name or file-like object,'
-                          ' got %s type' % type(source))
+            raise IOError(f'Expected file path name or file-like object, '
+                          f'got {type(source)} type')
 
     cdef _get_header(self):
         # header is now a list of lists, so field_count should use header[0]
 
         cdef:
-            Py_ssize_t i, start, field_count, passed_count, unnamed_count  # noqa
+            Py_ssize_t i, start, field_count, passed_count, unnamed_count
             char *word
             object name, old_name
             int status
-            int64_t hr, data_line
+            uint64_t hr, data_line
             char *errors = "strict"
             StringPath path = _string_path(self.c_encoding)
 
@@ -741,11 +728,11 @@ cdef class TextReader:
                           self.parser.lines < hr):
                     msg = self.orig_header
                     if isinstance(msg, list):
-                        msg = "[%s], len of %d," % (
-                            ','.join(str(m) for m in msg), len(msg))
+                        joined = ','.join(str(m) for m in msg)
+                        msg = f"[{joined}], len of {len(msg)},"
                     raise ParserError(
-                        'Passed header=%s but only %d lines in file'
-                        % (msg, self.parser.lines))
+                        f'Passed header={msg} but only '
+                        f'{self.parser.lines} lines in file')
 
                 else:
                     field_count = self.parser.line_fields[hr]
@@ -768,10 +755,9 @@ cdef class TextReader:
 
                     if name == '':
                         if self.has_mi_columns:
-                            name = ('Unnamed: {i}_level_{lvl}'
-                                    .format(i=i, lvl=level))
+                            name = f'Unnamed: {i}_level_{level}'
                         else:
-                            name = 'Unnamed: {i}'.format(i=i)
+                            name = f'Unnamed: {i}'
                         unnamed_count += 1
 
                     count = counts.get(name, 0)
@@ -779,7 +765,7 @@ cdef class TextReader:
                     if not self.has_mi_columns and self.mangle_dupe_cols:
                         while count > 0:
                             counts[name] = count + 1
-                            name = '%s.%d' % (name, count)
+                            name = f'{name}.{count}'
                             count = counts.get(name, 0)
 
                     if old_name == '':
@@ -845,11 +831,6 @@ cdef class TextReader:
 
             passed_count = len(header[0])
 
-            # if passed_count > field_count:
-            #     raise ParserError('Column names have %d fields, '
-            #                        'data has %d fields'
-            #                        % (passed_count, field_count))
-
             if (self.has_usecols and self.allow_leading_cols and
                     not callable(self.usecols)):
                 nuse = len(self.usecols)
@@ -990,7 +971,7 @@ cdef class TextReader:
     cdef _end_clock(self, what):
         if self.verbose:
             elapsed = time.time() - self.clocks.pop(-1)
-            print('%s took: %.2f ms' % (what, elapsed * 1000))
+            print(f'{what} took: {elapsed * 1000:.2f} ms')
 
     def set_noconvert(self, i):
         self.noconvert.add(i)
@@ -1015,22 +996,22 @@ cdef class TextReader:
         else:
             end = min(start + rows, self.parser.lines)
 
+        # FIXME: dont leave commented-out
         # # skip footer
         # if footer > 0:
         #     end -= footer
 
         num_cols = -1
-        for i in range(self.parser.lines):
+        # Py_ssize_t cast prevents build warning
+        for i in range(<Py_ssize_t>self.parser.lines):
             num_cols = (num_cols < self.parser.line_fields[i]) * \
                 self.parser.line_fields[i] + \
                 (num_cols >= self.parser.line_fields[i]) * num_cols
 
         if self.table_width - self.leading_cols > num_cols:
-            raise ParserError(
-                "Too many columns specified: expected {expected} and "
-                "found {found}"
-                .format(expected=self.table_width - self.leading_cols,
-                        found=num_cols))
+            raise ParserError(f"Too many columns specified: expected "
+                              f"{self.table_width - self.leading_cols} "
+                              f"and found {num_cols}")
 
         results = {}
         nused = 0
@@ -1073,9 +1054,9 @@ cdef class TextReader:
 
             if conv:
                 if col_dtype is not None:
-                    warnings.warn(("Both a converter and dtype were specified "
-                                   "for column {0} - only the converter will "
-                                   "be used").format(name), ParserWarning,
+                    warnings.warn((f"Both a converter and dtype were specified "
+                                   f"for column {name} - only the converter will "
+                                   f"be used"), ParserWarning,
                                   stacklevel=5)
                 results[i] = _apply_converter(conv, self.parser, i, start, end,
                                               self.c_encoding)
@@ -1116,7 +1097,7 @@ cdef class TextReader:
                 col_res = _maybe_upcast(col_res)
 
             if col_res is None:
-                raise ParserError('Unable to parse column {i}'.format(i=i))
+                raise ParserError(f'Unable to parse column {i}')
 
             results[i] = col_res
 
@@ -1176,12 +1157,9 @@ cdef class TextReader:
                 col_res = col_res.astype(col_dtype)
                 if (col_res != col_res_orig).any():
                     raise ValueError(
-                        "cannot safely convert passed user dtype of "
-                        "{col_dtype} for {col_res} dtyped data in "
-                        "column {column}".format(
-                            col_dtype=col_dtype,
-                            col_res=col_res_orig.dtype.name,
-                            column=i))
+                        f"cannot safely convert passed user dtype of "
+                        f"{col_dtype} for {col_res_orig.dtype.name} dtyped data in "
+                        f"column {i}")
 
         return col_res, na_count
 
@@ -1214,9 +1192,9 @@ cdef class TextReader:
                                                               dtype=dtype)
             except NotImplementedError:
                 raise NotImplementedError(
-                    "Extension Array: {ea} must implement "
-                    "_from_sequence_of_strings in order "
-                    "to be used in parser methods".format(ea=array_type))
+                    f"Extension Array: {array_type} must implement "
+                    f"_from_sequence_of_strings in order "
+                    f"to be used in parser methods")
 
             return result, na_count
 
@@ -1226,8 +1204,7 @@ cdef class TextReader:
                                               end, na_filter, na_hashset)
                 if user_dtype and na_count is not None:
                     if na_count > 0:
-                        raise ValueError("Integer column has NA values in "
-                                         "column {column}".format(column=i))
+                        raise ValueError(f"Integer column has NA values in column {i}")
             except OverflowError:
                 result = _try_uint64(self.parser, i, start, end,
                                      na_filter, na_hashset)
@@ -1251,8 +1228,7 @@ cdef class TextReader:
                                               self.true_set, self.false_set)
             if user_dtype and na_count is not None:
                 if na_count > 0:
-                    raise ValueError("Bool column has NA values in "
-                                     "column {column}".format(column=i))
+                    raise ValueError(f"Bool column has NA values in column {i}")
             return result, na_count
 
         elif dtype.kind == 'S':
@@ -1268,8 +1244,7 @@ cdef class TextReader:
         elif dtype.kind == 'U':
             width = dtype.itemsize
             if width > 0:
-                raise TypeError("the dtype {dtype} is not "
-                                "supported for parsing".format(dtype=dtype))
+                raise TypeError(f"the dtype {dtype} is not supported for parsing")
 
             # unicode variable width
             return self._string_convert(i, start, end, na_filter,
@@ -1278,12 +1253,11 @@ cdef class TextReader:
             return self._string_convert(i, start, end, na_filter,
                                         na_hashset)
         elif is_datetime64_dtype(dtype):
-            raise TypeError("the dtype {dtype} is not supported "
-                            "for parsing, pass this column "
-                            "using parse_dates instead".format(dtype=dtype))
+            raise TypeError(f"the dtype {dtype} is not supported "
+                            f"for parsing, pass this column "
+                            f"using parse_dates instead")
         else:
-            raise TypeError("the dtype {dtype} is not "
-                            "supported for parsing".format(dtype=dtype))
+            raise TypeError(f"the dtype {dtype} is not supported for parsing")
 
     cdef _string_convert(self, Py_ssize_t i, int64_t start, int64_t end,
                          bint na_filter, kh_str_starts_t *na_hashset):
@@ -1385,7 +1359,27 @@ def _ensure_encoded(list lst):
 # common NA values
 # no longer excluding inf representations
 # '1.#INF','-1.#INF', '1.#INF000000',
-_NA_VALUES = _ensure_encoded(list(icom._NA_VALUES))
+STR_NA_VALUES = {
+    "-1.#IND",
+    "1.#QNAN",
+    "1.#IND",
+    "-1.#QNAN",
+    "#N/A N/A",
+    "#N/A",
+    "N/A",
+    "n/a",
+    "NA",
+    "<NA>",
+    "#NA",
+    "NULL",
+    "null",
+    "NaN",
+    "-NaN",
+    "nan",
+    "-nan",
+    "",
+}
+_NA_VALUES = _ensure_encoded(list(STR_NA_VALUES))
 
 
 def _maybe_upcast(arr):
@@ -1420,59 +1414,6 @@ cdef inline StringPath _string_path(char *encoding):
 # Type conversions / inference support code
 
 
-cdef _string_box_factorize(parser_t *parser, int64_t col,
-                           int64_t line_start, int64_t line_end,
-                           bint na_filter, kh_str_starts_t *na_hashset):
-    cdef:
-        int error, na_count = 0
-        Py_ssize_t i, lines
-        coliter_t it
-        const char *word = NULL
-        ndarray[object] result
-
-        int ret = 0
-        kh_strbox_t *table
-
-        object pyval
-
-        object NA = na_values[np.object_]
-        khiter_t k
-
-    table = kh_init_strbox()
-    lines = line_end - line_start
-    result = np.empty(lines, dtype=np.object_)
-    coliter_setup(&it, parser, col, line_start)
-
-    for i in range(lines):
-        COLITER_NEXT(it, word)
-
-        if na_filter:
-            if kh_get_str_starts_item(na_hashset, word):
-                # in the hash table
-                na_count += 1
-                result[i] = NA
-                continue
-
-        k = kh_get_strbox(table, word)
-
-        # in the hash table
-        if k != table.n_buckets:
-            # this increments the refcount, but need to test
-            pyval = <object>table.vals[k]
-        else:
-            # box it. new ref?
-            pyval = PyBytes_FromString(word)
-
-            k = kh_put_strbox(table, word, &ret)
-            table.vals[k] = <PyObject*>pyval
-
-        result[i] = pyval
-
-    kh_destroy_strbox(table)
-
-    return result, na_count
-
-
 cdef _string_box_utf8(parser_t *parser, int64_t col,
                       int64_t line_start, int64_t line_end,
                       bint na_filter, kh_str_starts_t *na_hashset):
@@ -1660,7 +1601,7 @@ cdef _to_fw_string(parser_t *parser, int64_t col, int64_t line_start,
         char *data
         ndarray result
 
-    result = np.empty(line_end - line_start, dtype='|S%d' % width)
+    result = np.empty(line_end - line_start, dtype=f'|S{width}')
     data = <char*>result.data
 
     with nogil:
@@ -1715,22 +1656,12 @@ cdef _try_double(parser_t *parser, int64_t col,
     result = np.empty(lines, dtype=np.float64)
     data = <float64_t *>result.data
     na_fset = kset_float64_from_list(na_flist)
-    if parser.double_converter_nogil != NULL:  # if it can run without the GIL
-        with nogil:
-            error = _try_double_nogil(parser, parser.double_converter_nogil,
-                                      col, line_start, line_end,
-                                      na_filter, na_hashset, use_na_flist,
-                                      na_fset, NA, data, &na_count)
-    else:
-        assert parser.double_converter_withgil != NULL
-        error = _try_double_nogil(parser,
-                                  <float64_t (*)(const char *, char **,
-                                                 char, char, char,
-                                                 int, int *, int *)
-                                  nogil>parser.double_converter_withgil,
+    with nogil:
+        error = _try_double_nogil(parser, parser.double_converter,
                                   col, line_start, line_end,
                                   na_filter, na_hashset, use_na_flist,
                                   na_fset, NA, data, &na_count)
+
     kh_destroy_float64(na_fset)
     if error != 0:
         return None, None
@@ -2130,7 +2061,7 @@ cdef raise_parser_error(object base, parser_t *parser):
                 Py_XDECREF(type)
                 raise old_exc
 
-    message = '{base}. C error: '.format(base=base)
+    message = f'{base}. C error: '
     if parser.error_msg != NULL:
         message += parser.error_msg.decode('utf-8')
     else:
@@ -2174,8 +2105,8 @@ def _concatenate_chunks(list chunks):
     if warning_columns:
         warning_names = ','.join(warning_columns)
         warning_message = " ".join([
-            "Columns (%s) have mixed types." % warning_names,
-            "Specify dtype option on import or set low_memory=False."
+            f"Columns ({warning_names}) have mixed types."
+            f"Specify dtype option on import or set low_memory=False."
           ])
         warnings.warn(warning_message, DtypeWarning, stacklevel=8)
     return result
@@ -2249,7 +2180,7 @@ cdef _apply_converter(object f, parser_t *parser, int64_t col,
 def _maybe_encode(values):
     if values is None:
         return []
-    return [x.encode('utf-8') if isinstance(x, unicode) else x for x in values]
+    return [x.encode('utf-8') if isinstance(x, str) else x for x in values]
 
 
 def sanitize_objects(ndarray[object] values, set na_values,
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index 361c21c18c4da..b27072aa66708 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -1,3 +1,4 @@
+from copy import copy
 from distutils.version import LooseVersion
 
 from cython import Py_ssize_t
@@ -15,25 +16,15 @@ from numpy cimport (ndarray,
 cnp.import_array()
 
 cimport pandas._libs.util as util
-from pandas._libs.lib import maybe_convert_objects, values_from_object
+from pandas._libs.lib import maybe_convert_objects, is_scalar
 
 
-cdef _get_result_array(object obj, Py_ssize_t size, Py_ssize_t cnt):
+cdef _check_result_array(object obj, Py_ssize_t cnt):
 
     if (util.is_array(obj) or
             (isinstance(obj, list) and len(obj) == cnt) or
             getattr(obj, 'shape', None) == (cnt,)):
-        raise ValueError('function does not reduce')
-
-    return np.empty(size, dtype='O')
-
-
-cdef bint _is_sparse_array(object obj):
-    # TODO can be removed one SparseArray.values is removed (GH26421)
-    if hasattr(obj, '_subtyp'):
-        if obj._subtyp == 'sparse_array':
-            return True
-    return False
+        raise ValueError('Function does not reduce')
 
 
 cdef class Reducer:
@@ -43,11 +34,11 @@ cdef class Reducer:
     """
     cdef:
         Py_ssize_t increment, chunksize, nresults
-        object arr, dummy, f, labels, typ, ityp, index
+        object dummy, f, labels, typ, ityp, index
+        ndarray arr
 
-    def __init__(self, object arr, object f, axis=1, dummy=None,
-                 labels=None):
-        n, k = arr.shape
+    def __init__(self, ndarray arr, object f, axis=1, dummy=None, labels=None):
+        n, k = (<object>arr).shape
 
         if axis == 0:
             if not arr.flags.f_contiguous:
@@ -70,8 +61,9 @@ cdef class Reducer:
         self.dummy, self.typ, self.index, self.ityp = self._check_dummy(
             dummy=dummy)
 
-    def _check_dummy(self, dummy=None):
-        cdef object index=None, typ=None, ityp=None
+    cdef _check_dummy(self, dummy=None):
+        cdef:
+            object index = None, typ = None, ityp = None
 
         if dummy is None:
             dummy = np.empty(self.chunksize, dtype=self.arr.dtype)
@@ -82,18 +74,15 @@ cdef class Reducer:
 
         else:
 
-            # we passed a series-like
-            if hasattr(dummy, 'values'):
-
-                typ = type(dummy)
-                index = getattr(dummy, 'index', None)
-                dummy = dummy.values
+            # we passed a Series
+            typ = type(dummy)
+            index = dummy.index
+            dummy = dummy.values
 
             if dummy.dtype != self.arr.dtype:
                 raise ValueError('Dummy array must be same dtype')
             if len(dummy) != self.chunksize:
-                raise ValueError('Dummy array must be length %d' %
-                                 self.chunksize)
+                raise ValueError(f'Dummy array must be length {self.chunksize}')
 
         return dummy, typ, index, ityp
 
@@ -101,51 +90,37 @@ cdef class Reducer:
         cdef:
             char* dummy_buf
             ndarray arr, result, chunk
-            Py_ssize_t i, incr
+            Py_ssize_t i
             flatiter it
-            bint has_labels
-            object res, name, labels, index
-            object cached_typ=None
+            object res, name, labels
+            object cached_typ = None
 
         arr = self.arr
         chunk = self.dummy
         dummy_buf = chunk.data
         chunk.data = arr.data
         labels = self.labels
-        has_labels = labels is not None
-        has_index = self.index is not None
-        incr = self.increment
+
+        result = np.empty(self.nresults, dtype='O')
+        it = <flatiter>PyArray_IterNew(result)
 
         try:
             for i in range(self.nresults):
 
-                if has_labels:
-                    name = util.get_value_at(labels, i)
-                else:
-                    name = None
-
                 # create the cached type
                 # each time just reassign the data
                 if i == 0:
 
                     if self.typ is not None:
-
-                        # recreate with the index if supplied
-                        if has_index:
-
-                            cached_typ = self.typ(
-                                chunk, index=self.index, name=name)
-
-                        else:
-
-                            # use the passsed typ, sans index
-                            cached_typ = self.typ(chunk, name=name)
+                        # In this case, we also have self.index
+                        name = labels[i]
+                        cached_typ = self.typ(
+                            chunk, index=self.index, name=name, dtype=arr.dtype)
 
                 # use the cached_typ if possible
                 if cached_typ is not None:
-
-                    if has_index:
-                        object.__setattr__(cached_typ, 'index', self.index)
+                    # In this case, we also have non-None labels
+                    name = labels[i]
 
                     object.__setattr__(
                         cached_typ._data._block, 'values', chunk)
@@ -154,61 +129,111 @@ cdef class Reducer:
                 else:
                     res = self.f(chunk)
 
-                if (not _is_sparse_array(res) and hasattr(res, 'values')
-                        and util.is_array(res.values)):
-                    res = res.values
+                # TODO: reason for not squeezing here?
+                res = _extract_result(res, squeeze=False)
                 if i == 0:
-                    result = _get_result_array(res,
-                                               self.nresults,
-                                               len(self.dummy))
-                    it = <flatiter>PyArray_IterNew(result)
+                    # On the first pass, we check the output shape to see
+                    #  if this looks like a reduction.
+                    _check_result_array(res, len(self.dummy))
 
                 PyArray_SETITEM(result, PyArray_ITER_DATA(it), res)
                 chunk.data = chunk.data + self.increment
                 PyArray_ITER_NEXT(it)
-        except Exception, e:
-            if hasattr(e, 'args'):
-                e.args = e.args + (i,)
-            raise
         finally:
             # so we don't free the wrong memory
             chunk.data = dummy_buf
 
-        if result.dtype == np.object_:
-            result = maybe_convert_objects(result)
-
+        result = maybe_convert_objects(result)
         return result
 
 
-cdef class SeriesBinGrouper:
+cdef class _BaseGrouper:
+    cdef _check_dummy(self, dummy):
+        # both values and index must be an ndarray!
+
+        values = dummy.values
+        # GH 23683: datetimetz types are equivalent to datetime types here
+        if (dummy.dtype != self.arr.dtype
+                and values.dtype != self.arr.dtype):
+            raise ValueError('Dummy array must be same dtype')
+        if util.is_array(values) and not values.flags.contiguous:
+            # e.g. Categorical has no `flags` attribute
+            values = values.copy()
+        index = dummy.index.values
+        if not index.flags.contiguous:
+            index = index.copy()
+
+        return values, index
+
+    cdef inline _update_cached_objs(self, object cached_typ, object cached_ityp,
+                                    Slider islider, Slider vslider):
+        if cached_typ is None:
+            cached_ityp = self.ityp(islider.buf)
+            cached_typ = self.typ(vslider.buf, index=cached_ityp, name=self.name)
+        else:
+            # See the comment in indexes/base.py about _index_data.
+            # We need this for EA-backed indexes that have a reference
+            # to a 1-d ndarray like datetime / timedelta / period.
+            object.__setattr__(cached_ityp, '_index_data', islider.buf)
+            cached_ityp._engine.clear_mapping()
+            object.__setattr__(cached_typ._data._block, 'values', vslider.buf)
+            object.__setattr__(cached_typ, '_index', cached_ityp)
+            object.__setattr__(cached_typ, 'name', self.name)
+
+        return cached_typ, cached_ityp
+
+    cdef inline object _apply_to_group(self,
+                                       object cached_typ, object cached_ityp,
+                                       Slider islider, Slider vslider,
+                                       Py_ssize_t group_size, bint initialized):
+        """
+        Call self.f on our new group, then update to the next group.
+        """
+        cached_ityp._engine.clear_mapping()
+        res = self.f(cached_typ)
+        res = _extract_result(res)
+        if not initialized:
+            # On the first pass, we check the output shape to see
+            #  if this looks like a reduction.
+            initialized = 1
+            _check_result_array(res, len(self.dummy_arr))
+
+        islider.advance(group_size)
+        vslider.advance(group_size)
+
+        return res, initialized
+
+
+cdef class SeriesBinGrouper(_BaseGrouper):
     """
     Performs grouping operation according to bin edges, rather than labels
     """
     cdef:
         Py_ssize_t nresults, ngroups
-        bint passed_dummy
 
     cdef public:
-        object arr, index, dummy_arr, dummy_index
+        ndarray arr, index, dummy_arr, dummy_index
         object values, f, bins, typ, ityp, name
 
     def __init__(self, object series, object f, object bins, object dummy):
-        n = len(series)
+
+        assert dummy is not None  # always obj[:0]
+        assert len(bins) > 0  # otherwise we get IndexError in get_result
 
         self.bins = bins
         self.f = f
 
         values = series.values
-        if not values.flags.c_contiguous:
+        if util.is_array(values) and not values.flags.c_contiguous:
+            # e.g. Categorical has no `flags` attribute
             values = values.copy('C')
         self.arr = values
         self.typ = series._constructor
         self.ityp = series.index._constructor
         self.index = series.index.values
-        self.name = getattr(series, 'name', None)
+        self.name = series.name
 
         self.dummy_arr, self.dummy_index = self._check_dummy(dummy)
-        self.passed_dummy = dummy is not None
 
         # kludge for #1688
         if len(bins) > 0 and bins[-1] == len(series):
@@ -216,24 +241,6 @@ cdef class SeriesBinGrouper:
         else:
             self.ngroups = len(bins) + 1
 
-    def _check_dummy(self, dummy=None):
-        # both values and index must be an ndarray!
-
-        if dummy is None:
-            values = np.empty(0, dtype=self.arr.dtype)
-            index = None
-        else:
-            values = dummy.values
-            if values.dtype != self.arr.dtype:
-                raise ValueError('Dummy array must be same dtype')
-            if not values.flags.contiguous:
-                values = values.copy()
-            index = dummy.index.values
-            if not index.flags.contiguous:
-                index = index.copy()
-
-        return values, index
-
     def get_result(self):
         cdef:
             ndarray arr, result
@@ -242,7 +249,7 @@ cdef class SeriesBinGrouper:
             object res
             bint initialized = 0
             Slider vslider, islider
-            object name, cached_typ=None, cached_ityp=None
+            object cached_typ = None, cached_ityp = None
 
         counts = np.zeros(self.ngroups, dtype=np.int64)
 
@@ -256,11 +263,12 @@ cdef class SeriesBinGrouper:
 
         group_size = 0
         n = len(self.arr)
-        name = self.name
 
         vslider = Slider(self.arr, self.dummy_arr)
         islider = Slider(self.index, self.dummy_index)
 
+        result = np.empty(self.ngroups, dtype='O')
+
         try:
             for i in range(self.ngroups):
                 group_size = counts[i]
@@ -268,117 +276,83 @@ cdef class SeriesBinGrouper:
                 islider.set_length(group_size)
                 vslider.set_length(group_size)
 
-                if cached_typ is None:
-                    cached_ityp = self.ityp(islider.buf)
-                    cached_typ = self.typ(vslider.buf, index=cached_ityp,
-                                          name=name)
-                else:
-                    # See the comment in indexes/base.py about _index_data.
-                    # We need this for EA-backed indexes that have a reference
-                    # to a 1-d ndarray like datetime / timedelta / period.
-                    object.__setattr__(cached_ityp, '_index_data', islider.buf)
-                    cached_ityp._engine.clear_mapping()
-                    object.__setattr__(
-                        cached_typ._data._block, 'values', vslider.buf)
-                    object.__setattr__(cached_typ, '_index', cached_ityp)
-                    object.__setattr__(cached_typ, 'name', name)
+                cached_typ, cached_ityp = self._update_cached_objs(
+                    cached_typ, cached_ityp, islider, vslider)
 
-                cached_ityp._engine.clear_mapping()
-                res = self.f(cached_typ)
-                res = _extract_result(res)
-                if not initialized:
-                    initialized = 1
-                    result = _get_result_array(res,
-                                               self.ngroups,
-                                               len(self.dummy_arr))
-                result[i] = res
+                res, initialized = self._apply_to_group(cached_typ, cached_ityp,
+                                                        islider, vslider,
+                                                        group_size, initialized)
 
-                islider.advance(group_size)
-                vslider.advance(group_size)
+                result[i] = res
 
         finally:
             # so we don't free the wrong memory
             islider.reset()
             vslider.reset()
 
-        if result.dtype == np.object_:
-            result = maybe_convert_objects(result)
-
+        result = maybe_convert_objects(result)
         return result, counts
 
 
-cdef class SeriesGrouper:
+cdef class SeriesGrouper(_BaseGrouper):
     """
     Performs generic grouping operation while avoiding ndarray construction
     overhead
     """
     cdef:
         Py_ssize_t nresults, ngroups
-        bint passed_dummy
 
     cdef public:
-        object arr, index, dummy_arr, dummy_index
+        ndarray arr, index, dummy_arr, dummy_index
         object f, labels, values, typ, ityp, name
 
     def __init__(self, object series, object f, object labels,
                  Py_ssize_t ngroups, object dummy):
-        n = len(series)
+
+        # in practice we always pass obj.iloc[:0] or equivalent
+        assert dummy is not None
+
+        if len(series) == 0:
+            # get_result would never assign `result`
+            raise ValueError("SeriesGrouper requires non-empty `series`")
 
         self.labels = labels
         self.f = f
 
         values = series.values
-        if not values.flags.c_contiguous:
+        if util.is_array(values) and not values.flags.c_contiguous:
+            # e.g. Categorical has no `flags` attribute
             values = values.copy('C')
         self.arr = values
         self.typ = series._constructor
         self.ityp = series.index._constructor
         self.index = series.index.values
-        self.name = getattr(series, 'name', None)
+        self.name = series.name
 
         self.dummy_arr, self.dummy_index = self._check_dummy(dummy)
-        self.passed_dummy = dummy is not None
         self.ngroups = ngroups
 
-    def _check_dummy(self, dummy=None):
-        # both values and index must be an ndarray!
-
-        if dummy is None:
-            values = np.empty(0, dtype=self.arr.dtype)
-            index = None
-        else:
-            values = dummy.values
-            # GH 23683: datetimetz types are equivalent to datetime types here
-            if (dummy.dtype != self.arr.dtype
-                    and values.dtype != self.arr.dtype):
-                raise ValueError('Dummy array must be same dtype')
-            if not values.flags.contiguous:
-                values = values.copy()
-            index = dummy.index.values
-            if not index.flags.contiguous:
-                index = index.copy()
-
-        return values, index
-
     def get_result(self):
         cdef:
-            ndarray arr, result
+            # Define result to avoid UnboundLocalError
+            ndarray arr, result = None
             ndarray[int64_t] labels, counts
             Py_ssize_t i, n, group_size, lab
             object res
             bint initialized = 0
             Slider vslider, islider
-            object name, cached_typ=None, cached_ityp=None
+            object cached_typ = None, cached_ityp = None
 
         labels = self.labels
         counts = np.zeros(self.ngroups, dtype=np.int64)
         group_size = 0
         n = len(self.arr)
-        name = self.name
 
         vslider = Slider(self.arr, self.dummy_arr)
         islider = Slider(self.index, self.dummy_index)
 
+        result = np.empty(self.ngroups, dtype='O')
+
         try:
             for i in range(n):
                 group_size += 1
@@ -395,32 +369,15 @@ cdef class SeriesGrouper:
                     islider.set_length(group_size)
                     vslider.set_length(group_size)
 
-                    if cached_typ is None:
-                        cached_ityp = self.ityp(islider.buf)
-                        cached_typ = self.typ(vslider.buf, index=cached_ityp,
-                                              name=name)
-                    else:
-                        object.__setattr__(cached_ityp, '_data', islider.buf)
-                        cached_ityp._engine.clear_mapping()
-                        object.__setattr__(
-                            cached_typ._data._block, 'values', vslider.buf)
-                        object.__setattr__(cached_typ, '_index', cached_ityp)
-                        object.__setattr__(cached_typ, 'name', name)
-
-                    cached_ityp._engine.clear_mapping()
-                    res = self.f(cached_typ)
-                    res = _extract_result(res)
-                    if not initialized:
-                        initialized = 1
-                        result = _get_result_array(res,
-                                                   self.ngroups,
-                                                   len(self.dummy_arr))
+                    cached_typ, cached_ityp = self._update_cached_objs(
+                        cached_typ, cached_ityp, islider, vslider)
+
+                    res, initialized = self._apply_to_group(cached_typ, cached_ityp,
+                                                            islider, vslider,
+                                                            group_size, initialized)
 
                     result[lab] = res
                     counts[lab] = group_size
-                    islider.advance(group_size)
-                    vslider.advance(group_size)
-
                     group_size = 0
 
         finally:
@@ -428,24 +385,25 @@ cdef class SeriesGrouper:
             islider.reset()
             vslider.reset()
 
-        if result.dtype == np.object_:
-            result = maybe_convert_objects(result)
+        # We check for empty series in the constructor, so should always
+        #  have result initialized by this point.
+        assert initialized, "`result` has not been initialized."
+
+        result = maybe_convert_objects(result)
 
         return result, counts
 
 
-cdef inline _extract_result(object res):
+cdef inline _extract_result(object res, bint squeeze=True):
     """ extract the result object, it might be a 0-dim ndarray
         or a len-1 0-dim, or a scalar """
-    if (not _is_sparse_array(res) and hasattr(res, 'values')
-            and util.is_array(res.values)):
+    if hasattr(res, 'values') and util.is_array(res.values):
         res = res.values
-    if not np.isscalar(res):
-        if util.is_array(res):
-            if res.ndim == 0:
-                res = res.item()
-            elif res.ndim == 1 and len(res) == 1:
-                res = res[0]
+    if util.is_array(res):
+        if res.ndim == 0:
+            res = res.item()
+        elif squeeze and res.ndim == 1 and len(res) == 1:
+            res = res[0]
     return res
 
 
@@ -458,13 +416,13 @@ cdef class Slider:
         Py_ssize_t stride, orig_len, orig_stride
         char *orig_data
 
-    def __init__(self, object values, object buf):
-        assert(values.ndim == 1)
+    def __init__(self, ndarray values, ndarray buf):
+        assert values.ndim == 1
+        assert values.dtype == buf.dtype
 
         if not values.flags.contiguous:
             values = values.copy()
 
-        assert(values.dtype == buf.dtype)
         self.values = values
         self.buf = buf
         self.stride = values.strides[0]
@@ -476,7 +434,7 @@ cdef class Slider:
         self.buf.data = self.values.data
         self.buf.strides[0] = self.stride
 
-    cpdef advance(self, Py_ssize_t k):
+    cdef advance(self, Py_ssize_t k):
         self.buf.data = <char*>self.buf.data + self.stride * k
 
     cdef move(self, int start, int end):
@@ -486,10 +444,10 @@ cdef class Slider:
         self.buf.data = self.values.data + self.stride * start
         self.buf.shape[0] = end - start
 
-    cpdef set_length(self, Py_ssize_t length):
+    cdef set_length(self, Py_ssize_t length):
         self.buf.shape[0] = length
 
-    cpdef reset(self):
+    cdef reset(self):
 
         self.buf.shape[0] = self.orig_len
         self.buf.data = self.orig_data
@@ -509,8 +467,8 @@ def apply_frame_axis0(object frame, object f, object names,
         object piece
         dict item_cache
 
-    if frame.index._has_complex_internals:
-        raise InvalidApply('Cannot modify frame index internals')
+    # We have already checked that we don't have a MultiIndex before calling
+    assert frame.index.nlevels == 1
 
     results = []
 
@@ -535,14 +493,19 @@ def apply_frame_axis0(object frame, object f, object names,
             # Need to infer if low level index slider will cause segfaults
             require_slow_apply = i == 0 and piece is chunk
             try:
-                if piece.index is chunk.index:
-                    piece = piece.copy(deep='all')
-                else:
+                if piece.index is not chunk.index:
                     mutated = True
             except AttributeError:
                 # `piece` might not have an index, could be e.g. an int
                 pass
 
+            if not is_scalar(piece):
+                # Need to copy data to avoid appending references
+                try:
+                    piece = piece.copy(deep="all")
+                except (TypeError, AttributeError):
+                    piece = copy(piece)
+
             results.append(piece)
 
             # If the data was modified inplace we need to
@@ -594,10 +557,10 @@ cdef class BlockSlider:
     def __dealloc__(self):
         free(self.base_ptrs)
 
-    cpdef move(self, int start, int end):
+    cdef move(self, int start, int end):
         cdef:
             ndarray arr
-            object index
+            Py_ssize_t i
 
         # move blocks
         for i in range(self.nblocks):
@@ -616,6 +579,7 @@ cdef class BlockSlider:
     cdef reset(self):
         cdef:
             ndarray arr
+            Py_ssize_t i
 
         # reset blocks
         for i in range(self.nblocks):
@@ -626,24 +590,28 @@ cdef class BlockSlider:
             arr.shape[1] = 0
 
 
-def compute_reduction(arr, f, axis=0, dummy=None, labels=None):
+def compute_reduction(arr: np.ndarray, f, axis: int = 0, dummy=None, labels=None):
     """
 
     Parameters
     -----------
-    arr : NDFrame object
+    arr : np.ndarray
     f : function
     axis : integer axis
     dummy : type of reduced output (series)
     labels : Index or None
     """
 
+    # We either have both dummy and labels, or neither of them
+    if (labels is None) ^ (dummy is None):
+        raise ValueError("Must pass either dummy and labels, or neither")
+
     if labels is not None:
-        if labels._has_complex_internals:
-            raise Exception('Cannot use shortcut')
+        # Caller is responsible for ensuring we don't have MultiIndex
+        assert labels.nlevels == 1
 
-        # pass as an ndarray
-        labels = values_from_object(labels)
+        # pass as an ndarray/ExtensionArray
+        labels = labels._values
 
     reducer = Reducer(arr, f, axis=axis, dummy=dummy, labels=labels)
     return reducer.get_result()
diff --git a/pandas/_libs/reshape.pyx b/pandas/_libs/reshape.pyx
index f229de002ce5c..4e831081c8e54 100644
--- a/pandas/_libs/reshape.pyx
+++ b/pandas/_libs/reshape.pyx
@@ -28,7 +28,7 @@ def unstack(reshape_t[:, :] values, uint8_t[:] mask,
             Py_ssize_t stride, Py_ssize_t length, Py_ssize_t width,
             reshape_t[:, :] new_values, uint8_t[:, :] new_mask):
     """
-    transform long sorted_values to wide new_values
+    Transform long values to wide new_values.
 
     Parameters
     ----------
@@ -83,19 +83,6 @@ def unstack(reshape_t[:, :] values, uint8_t[:] mask,
                         nulls += 1
 
 
-unstack_uint8 = unstack["uint8_t"]
-unstack_uint16 = unstack["uint16_t"]
-unstack_uint32 = unstack["uint32_t"]
-unstack_uint64 = unstack["uint64_t"]
-unstack_int8 = unstack["int8_t"]
-unstack_int16 = unstack["int16_t"]
-unstack_int32 = unstack["int32_t"]
-unstack_int64 = unstack["int64_t"]
-unstack_float32 = unstack["float32_t"]
-unstack_float64 = unstack["float64_t"]
-unstack_object = unstack["object"]
-
-
 @cython.wraparound(False)
 @cython.boundscheck(False)
 def explode(ndarray[object] values):
diff --git a/pandas/_libs/skiplist.pxd b/pandas/_libs/skiplist.pxd
deleted file mode 100644
index e827223bbe0a7..0000000000000
--- a/pandas/_libs/skiplist.pxd
+++ /dev/null
@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-# See GH#27465 for reference on related-but-unused cython code
-
-cdef extern from "src/skiplist.h":
-    ctypedef struct node_t:
-        node_t **next
-        int *width
-        double value
-        int is_nil
-        int levels
-        int ref_count
-
-    ctypedef struct skiplist_t:
-        node_t *head
-        node_t **tmp_chain
-        int *tmp_steps
-        int size
-        int maxlevels
-
-    skiplist_t* skiplist_init(int) nogil
-    void skiplist_destroy(skiplist_t*) nogil
-    double skiplist_get(skiplist_t*, int, int*) nogil
-    int skiplist_insert(skiplist_t*, double) nogil
-    int skiplist_remove(skiplist_t*, double) nogil
diff --git a/pandas/_libs/skiplist.pyx b/pandas/_libs/skiplist.pyx
deleted file mode 100644
index eb750a478415a..0000000000000
--- a/pandas/_libs/skiplist.pyx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Cython version of IndexableSkiplist, for implementing moving median
-# with O(log n) updates
-# Original author: Raymond Hettinger
-# Original license: MIT
-# Link: http://code.activestate.com/recipes/576930/
-
-# Cython version: Wes McKinney
diff --git a/pandas/_libs/sparse.pyx b/pandas/_libs/sparse.pyx
index 4906e45c884e9..3a6dd506b2428 100644
--- a/pandas/_libs/sparse.pyx
+++ b/pandas/_libs/sparse.pyx
@@ -51,13 +51,13 @@ cdef class IntIndex(SparseIndex):
         args = (self.length, self.indices)
         return IntIndex, args
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         output = 'IntIndex\n'
-        output += 'Indices: %s\n' % repr(self.indices)
+        output += f'Indices: {repr(self.indices)}\n'
         return output
 
     @property
-    def nbytes(self):
+    def nbytes(self) -> int:
         return self.indices.nbytes
 
     def check_integrity(self):
@@ -72,10 +72,9 @@ cdef class IntIndex(SparseIndex):
         """
 
         if self.npoints > self.length:
-            msg = ("Too many indices. Expected "
-                   "{exp} but found {act}").format(
-                exp=self.length, act=self.npoints)
-            raise ValueError(msg)
+            raise ValueError(
+                f"Too many indices. Expected {self.length} but found {self.npoints}"
+            )
 
         # Indices are vacuously ordered and non-negative
         # if the sequence of indices is empty.
@@ -92,7 +91,7 @@ cdef class IntIndex(SparseIndex):
         if not monotonic:
             raise ValueError("Indices must be strictly increasing")
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         if not isinstance(other, IntIndex):
             return False
 
@@ -104,7 +103,7 @@ cdef class IntIndex(SparseIndex):
         return same_length and same_indices
 
     @property
-    def ngaps(self):
+    def ngaps(self) -> int:
         return self.length - self.npoints
 
     def to_int_index(self):
@@ -341,19 +340,19 @@ cdef class BlockIndex(SparseIndex):
         args = (self.length, self.blocs, self.blengths)
         return BlockIndex, args
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         output = 'BlockIndex\n'
-        output += 'Block locations: %s\n' % repr(self.blocs)
-        output += 'Block lengths: %s' % repr(self.blengths)
+        output += f'Block locations: {repr(self.blocs)}\n'
+        output += f'Block lengths: {repr(self.blengths)}'
 
         return output
 
     @property
-    def nbytes(self):
+    def nbytes(self) -> int:
         return self.blocs.nbytes + self.blengths.nbytes
 
     @property
-    def ngaps(self):
+    def ngaps(self) -> int:
         return self.length - self.npoints
 
     cpdef check_integrity(self):
@@ -380,17 +379,16 @@ cdef class BlockIndex(SparseIndex):
 
             if i < self.nblocks - 1:
                 if blocs[i] + blengths[i] > blocs[i + 1]:
-                    raise ValueError('Block {idx} overlaps'.format(idx=i))
+                    raise ValueError(f'Block {i} overlaps')
             else:
                 if blocs[i] + blengths[i] > self.length:
-                    raise ValueError('Block {idx} extends beyond end'
-                                     .format(idx=i))
+                    raise ValueError(f'Block {i} extends beyond end')
 
             # no zero-length blocks
             if blengths[i] == 0:
-                raise ValueError('Zero-length block {idx}'.format(idx=i))
+                raise ValueError(f'Zero-length block {i}')
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         if not isinstance(other, BlockIndex):
             return False
 
@@ -597,7 +595,7 @@ cdef class BlockIndex(SparseIndex):
 
         result = np.empty(other.npoints, dtype=np.float64)
 
-        for 0 <= i < other.nblocks:
+        for i in range(other.nblocks):
             ocur = olocs[i]
             ocurlen = olens[i]
 
@@ -746,9 +744,6 @@ cdef class BlockUnion(BlockMerge):
 
         nend = xend[xi]
 
-        # print 'here xi=%d, yi=%d, mode=%d, nend=%d' % (self.xi, self.yi,
-        #                                                mode, nend)
-
         # done with y?
         if yi == ynblocks:
             self._set_current_indices(xi + 1, yi, mode)
diff --git a/pandas/_libs/sparse_op_helper.pxi.in b/pandas/_libs/sparse_op_helper.pxi.in
index 5949a3fd0ed81..996da4ca2f92b 100644
--- a/pandas/_libs/sparse_op_helper.pxi.in
+++ b/pandas/_libs/sparse_op_helper.pxi.in
@@ -84,9 +84,10 @@ def get_op(tup):
                 'ge': '{0} >= {1}',
 
                 'and': '{0} & {1}',     # logical op
-                'or': '{0} | {1}'}
+                'or': '{0} | {1}',
+                'xor': '{0} ^ {1}'}
 
-    return ops_dict[opname].format(lval, rval, dtype)
+    return ops_dict[opname].format(lval, rval)
 
 
 def get_dispatch(dtypes):
@@ -94,7 +95,7 @@ def get_dispatch(dtypes):
     ops_list = ['add', 'sub', 'mul', 'div', 'mod', 'truediv',
                 'floordiv', 'pow',
                 'eq', 'ne', 'lt', 'gt', 'le', 'ge',
-                'and', 'or']
+                'and', 'or', 'xor']
 
     for opname in ops_list:
         for dtype, arith_comp_group, logical_group in dtypes:
@@ -104,13 +105,13 @@ def get_dispatch(dtypes):
             elif opname in ('eq', 'ne', 'lt', 'gt', 'le', 'ge'):
                 # comparison op
                 rdtype = 'uint8'
-            elif opname in ('and', 'or'):
+            elif opname in ('and', 'or', 'xor'):
                 # logical op
                 rdtype = 'uint8'
             else:
                 rdtype = dtype
 
-            if opname in ('and', 'or'):
+            if opname in ('and', 'or', 'xor'):
                 if logical_group:
                     yield opname, dtype, rdtype
             else:
diff --git a/pandas/_libs/src/compat_helper.h b/pandas/_libs/src/compat_helper.h
deleted file mode 100644
index 078069fb48af2..0000000000000
--- a/pandas/_libs/src/compat_helper.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-Copyright (c) 2016, PyData Development Team
-All rights reserved.
-
-Distributed under the terms of the BSD Simplified License.
-
-The full license is in the LICENSE file, distributed with this software.
-*/
-
-#ifndef PANDAS__LIBS_SRC_COMPAT_HELPER_H_
-#define PANDAS__LIBS_SRC_COMPAT_HELPER_H_
-
-#include "Python.h"
-#include "inline_helper.h"
-
-/*
-PySlice_GetIndicesEx changes signature in PY3
-but 3.6.1 in particular changes the behavior of this function slightly
-https://bugs.python.org/issue27867
-
-
-In 3.6.1 PySlice_GetIndicesEx was changed to a macro
-inadvertently breaking ABI compat.  For now, undefing
-the macro, which restores compat.
-https://github.com/pandas-dev/pandas/issues/15961
-https://bugs.python.org/issue29943
-*/
-
-#ifndef PYPY_VERSION
-# if PY_VERSION_HEX < 0x03070000 && defined(PySlice_GetIndicesEx)
-#   undef PySlice_GetIndicesEx
-# endif  // PY_VERSION_HEX
-#endif  // PYPY_VERSION
-
-PANDAS_INLINE int slice_get_indices(PyObject *s,
-                                    Py_ssize_t length,
-                                    Py_ssize_t *start,
-                                    Py_ssize_t *stop,
-                                    Py_ssize_t *step,
-                                    Py_ssize_t *slicelength) {
-#if PY_VERSION_HEX >= 0x03000000
-  return PySlice_GetIndicesEx(s, length, start, stop,
-                              step, slicelength);
-#else
-  return PySlice_GetIndicesEx((PySliceObject *)s, length, start,
-                              stop, step, slicelength);
-#endif  // PY_VERSION_HEX
-}
-
-#endif  // PANDAS__LIBS_SRC_COMPAT_HELPER_H_
diff --git a/pandas/_libs/src/klib/khash.h b/pandas/_libs/src/klib/khash.h
index 77ec519cc24da..916838d1e9584 100644
--- a/pandas/_libs/src/klib/khash.h
+++ b/pandas/_libs/src/klib/khash.h
@@ -53,7 +53,7 @@ int main() {
 	  speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
 
 	   - https://github.com/stefanocasazza/ULib
-	   - http://nothings.org/computer/judy/
+	   - https://nothings.org/computer/judy/
 
 	* Allow to optionally use linear probing which usually has better
 	  performance for random input. Double hashing is still the default as it
@@ -498,7 +498,7 @@ PANDAS_INLINE khint_t __ac_Wang_hash(khint_t key)
  */
 #define kh_n_buckets(h) ((h)->n_buckets)
 
-/* More conenient interfaces */
+/* More convenient interfaces */
 
 /*! @function
   @abstract     Instantiate a hash set containing integer keys
diff --git a/pandas/_libs/src/msgpack/pack.h b/pandas/_libs/src/msgpack/pack.h
deleted file mode 100644
index 02379c9188424..0000000000000
--- a/pandas/_libs/src/msgpack/pack.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * MessagePack for Python packing routine
- *
- * Copyright (C) 2009 Naoki INADA
- *
- *    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.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include "sysdep.h"
-#include <limits.h>
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define inline __inline
-#endif
-
-typedef struct msgpack_packer {
-    char *buf;
-    size_t length;
-    size_t buf_size;
-    bool use_bin_type;
-} msgpack_packer;
-
-typedef struct Packer Packer;
-
-static inline int msgpack_pack_int(msgpack_packer* pk, int d);
-static inline int msgpack_pack_long(msgpack_packer* pk, long d);
-static inline int msgpack_pack_long_long(msgpack_packer* pk, long long d);
-static inline int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
-static inline int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
-static inline int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
-//static inline int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d);
-
-static inline int msgpack_pack_uint8(msgpack_packer* pk, uint8_t d);
-static inline int msgpack_pack_uint16(msgpack_packer* pk, uint16_t d);
-static inline int msgpack_pack_uint32(msgpack_packer* pk, uint32_t d);
-static inline int msgpack_pack_uint64(msgpack_packer* pk, uint64_t d);
-static inline int msgpack_pack_int8(msgpack_packer* pk, int8_t d);
-static inline int msgpack_pack_int16(msgpack_packer* pk, int16_t d);
-static inline int msgpack_pack_int32(msgpack_packer* pk, int32_t d);
-static inline int msgpack_pack_int64(msgpack_packer* pk, int64_t d);
-
-static inline int msgpack_pack_float(msgpack_packer* pk, float d);
-static inline int msgpack_pack_double(msgpack_packer* pk, double d);
-
-static inline int msgpack_pack_nil(msgpack_packer* pk);
-static inline int msgpack_pack_true(msgpack_packer* pk);
-static inline int msgpack_pack_false(msgpack_packer* pk);
-
-static inline int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
-
-static inline int msgpack_pack_map(msgpack_packer* pk, unsigned int n);
-
-static inline int msgpack_pack_raw(msgpack_packer* pk, size_t l);
-static inline int msgpack_pack_bin(msgpack_packer* pk, size_t l);
-static inline int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);
-
-static inline int msgpack_pack_ext(msgpack_packer* pk, char typecode, size_t l);
-
-static inline int msgpack_pack_write(msgpack_packer* pk, const char *data, size_t l)
-{
-    char* buf = pk->buf;
-    size_t bs = pk->buf_size;
-    size_t len = pk->length;
-
-    if (len + l > bs) {
-        bs = (len + l) * 2;
-        buf = (char*)realloc(buf, bs);
-        if (!buf) return -1;
-    }
-    memcpy(buf + len, data, l);
-    len += l;
-
-    pk->buf = buf;
-    pk->buf_size = bs;
-    pk->length = len;
-    return 0;
-}
-
-#define msgpack_pack_append_buffer(user, buf, len) \
-        return msgpack_pack_write(user, (const char*)buf, len)
-
-#include "pack_template.h"
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/pandas/_libs/src/msgpack/pack_template.h b/pandas/_libs/src/msgpack/pack_template.h
deleted file mode 100644
index 5d1088f4b7d78..0000000000000
--- a/pandas/_libs/src/msgpack/pack_template.h
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- * MessagePack packing routine template
- *
- * Copyright (C) 2008-2010 FURUHASHI Sadayuki
- *
- *    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.
- */
-
-#if defined(__LITTLE_ENDIAN__)
-#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define TAKE8_16(d) ((uint8_t*)&d)[0]
-#define TAKE8_32(d) ((uint8_t*)&d)[0]
-#define TAKE8_64(d) ((uint8_t*)&d)[0]
-#elif defined(__BIG_ENDIAN__)
-#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define TAKE8_16(d) ((uint8_t*)&d)[1]
-#define TAKE8_32(d) ((uint8_t*)&d)[3]
-#define TAKE8_64(d) ((uint8_t*)&d)[7]
-#endif
-
-#ifndef msgpack_pack_append_buffer
-#error msgpack_pack_append_buffer callback is not defined
-#endif
-
-
-/*
- * Integer
- */
-
-#define msgpack_pack_real_uint8(x, d) \
-do { \
-    if(d < (1<<7)) { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
-    } else { \
-        /* unsigned 8 */ \
-        unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
-        msgpack_pack_append_buffer(x, buf, 2); \
-    } \
-} while(0)
-
-#define msgpack_pack_real_uint16(x, d) \
-do { \
-    if(d < (1<<7)) { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
-    } else if(d < (1<<8)) { \
-        /* unsigned 8 */ \
-        unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-        msgpack_pack_append_buffer(x, buf, 2); \
-    } else { \
-        /* unsigned 16 */ \
-        unsigned char buf[3]; \
-        buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-        msgpack_pack_append_buffer(x, buf, 3); \
-    } \
-} while(0)
-
-#define msgpack_pack_real_uint32(x, d) \
-do { \
-    if(d < (1<<8)) { \
-        if(d < (1<<7)) { \
-            /* fixnum */ \
-            msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
-        } else { \
-            /* unsigned 8 */ \
-            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } \
-    } else { \
-        if(d < (1<<16)) { \
-            /* unsigned 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } else { \
-            /* unsigned 32 */ \
-            unsigned char buf[5]; \
-            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-            msgpack_pack_append_buffer(x, buf, 5); \
-        } \
-    } \
-} while(0)
-
-#define msgpack_pack_real_uint64(x, d) \
-do { \
-    if(d < (1ULL<<8)) { \
-        if(d < (1ULL<<7)) { \
-            /* fixnum */ \
-            msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
-        } else { \
-            /* unsigned 8 */ \
-            unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } \
-    } else { \
-        if(d < (1ULL<<16)) { \
-            /* unsigned 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } else if(d < (1ULL<<32)) { \
-            /* unsigned 32 */ \
-            unsigned char buf[5]; \
-            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-            msgpack_pack_append_buffer(x, buf, 5); \
-        } else { \
-            /* unsigned 64 */ \
-            unsigned char buf[9]; \
-            buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-            msgpack_pack_append_buffer(x, buf, 9); \
-        } \
-    } \
-} while(0)
-
-#define msgpack_pack_real_int8(x, d) \
-do { \
-    if(d < -(1<<5)) { \
-        /* signed 8 */ \
-        unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
-        msgpack_pack_append_buffer(x, buf, 2); \
-    } else { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
-    } \
-} while(0)
-
-#define msgpack_pack_real_int16(x, d) \
-do { \
-    if(d < -(1<<5)) { \
-        if(d < -(1<<7)) { \
-            /* signed 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } else { \
-            /* signed 8 */ \
-            unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } \
-    } else if(d < (1<<7)) { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
-    } else { \
-        if(d < (1<<8)) { \
-            /* unsigned 8 */ \
-            unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } else { \
-            /* unsigned 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } \
-    } \
-} while(0)
-
-#define msgpack_pack_real_int32(x, d) \
-do { \
-    if(d < -(1<<5)) { \
-        if(d < -(1<<15)) { \
-            /* signed 32 */ \
-            unsigned char buf[5]; \
-            buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-            msgpack_pack_append_buffer(x, buf, 5); \
-        } else if(d < -(1<<7)) { \
-            /* signed 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } else { \
-            /* signed 8 */ \
-            unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } \
-    } else if(d < (1<<7)) { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
-    } else { \
-        if(d < (1<<8)) { \
-            /* unsigned 8 */ \
-            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-            msgpack_pack_append_buffer(x, buf, 2); \
-        } else if(d < (1<<16)) { \
-            /* unsigned 16 */ \
-            unsigned char buf[3]; \
-            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-            msgpack_pack_append_buffer(x, buf, 3); \
-        } else { \
-            /* unsigned 32 */ \
-            unsigned char buf[5]; \
-            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-            msgpack_pack_append_buffer(x, buf, 5); \
-        } \
-    } \
-} while(0)
-
-#define msgpack_pack_real_int64(x, d) \
-do { \
-    if(d < -(1LL<<5)) { \
-        if(d < -(1LL<<15)) { \
-            if(d < -(1LL<<31)) { \
-                /* signed 64 */ \
-                unsigned char buf[9]; \
-                buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
-                msgpack_pack_append_buffer(x, buf, 9); \
-            } else { \
-                /* signed 32 */ \
-                unsigned char buf[5]; \
-                buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-                msgpack_pack_append_buffer(x, buf, 5); \
-            } \
-        } else { \
-            if(d < -(1<<7)) { \
-                /* signed 16 */ \
-                unsigned char buf[3]; \
-                buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-                msgpack_pack_append_buffer(x, buf, 3); \
-            } else { \
-                /* signed 8 */ \
-                unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
-                msgpack_pack_append_buffer(x, buf, 2); \
-            } \
-        } \
-    } else if(d < (1<<7)) { \
-        /* fixnum */ \
-        msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
-    } else { \
-        if(d < (1LL<<16)) { \
-            if(d < (1<<8)) { \
-                /* unsigned 8 */ \
-                unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-                msgpack_pack_append_buffer(x, buf, 2); \
-            } else { \
-                /* unsigned 16 */ \
-                unsigned char buf[3]; \
-                buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-                msgpack_pack_append_buffer(x, buf, 3); \
-            } \
-        } else { \
-            if(d < (1LL<<32)) { \
-                /* unsigned 32 */ \
-                unsigned char buf[5]; \
-                buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-                msgpack_pack_append_buffer(x, buf, 5); \
-            } else { \
-                /* unsigned 64 */ \
-                unsigned char buf[9]; \
-                buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-                msgpack_pack_append_buffer(x, buf, 9); \
-            } \
-        } \
-    } \
-} while(0)
-
-
-static inline int msgpack_pack_uint8(msgpack_packer* x, uint8_t d)
-{
-    msgpack_pack_real_uint8(x, d);
-}
-
-static inline int msgpack_pack_uint16(msgpack_packer* x, uint16_t d)
-{
-    msgpack_pack_real_uint16(x, d);
-}
-
-static inline int msgpack_pack_uint32(msgpack_packer* x, uint32_t d)
-{
-    msgpack_pack_real_uint32(x, d);
-}
-
-static inline int msgpack_pack_uint64(msgpack_packer* x, uint64_t d)
-{
-    msgpack_pack_real_uint64(x, d);
-}
-
-static inline int msgpack_pack_int8(msgpack_packer* x, int8_t d)
-{
-    msgpack_pack_real_int8(x, d);
-}
-
-static inline int msgpack_pack_int16(msgpack_packer* x, int16_t d)
-{
-    msgpack_pack_real_int16(x, d);
-}
-
-static inline int msgpack_pack_int32(msgpack_packer* x, int32_t d)
-{
-    msgpack_pack_real_int32(x, d);
-}
-
-static inline int msgpack_pack_int64(msgpack_packer* x, int64_t d)
-{
-    msgpack_pack_real_int64(x, d);
-}
-
-
-//#ifdef msgpack_pack_inline_func_cint
-
-static inline int msgpack_pack_short(msgpack_packer* x, short d)
-{
-#if defined(SIZEOF_SHORT)
-#if SIZEOF_SHORT == 2
-    msgpack_pack_real_int16(x, d);
-#elif SIZEOF_SHORT == 4
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(SHRT_MAX)
-#if SHRT_MAX == 0x7fff
-    msgpack_pack_real_int16(x, d);
-#elif SHRT_MAX == 0x7fffffff
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#else
-if(sizeof(short) == 2) {
-    msgpack_pack_real_int16(x, d);
-} else if(sizeof(short) == 4) {
-    msgpack_pack_real_int32(x, d);
-} else {
-    msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_int(msgpack_packer* x, int d)
-{
-#if defined(SIZEOF_INT)
-#if SIZEOF_INT == 2
-    msgpack_pack_real_int16(x, d);
-#elif SIZEOF_INT == 4
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(INT_MAX)
-#if INT_MAX == 0x7fff
-    msgpack_pack_real_int16(x, d);
-#elif INT_MAX == 0x7fffffff
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#else
-if(sizeof(int) == 2) {
-    msgpack_pack_real_int16(x, d);
-} else if(sizeof(int) == 4) {
-    msgpack_pack_real_int32(x, d);
-} else {
-    msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_long(msgpack_packer* x, long d)
-{
-#if defined(SIZEOF_LONG)
-#if SIZEOF_LONG == 2
-    msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG == 4
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(LONG_MAX)
-#if LONG_MAX == 0x7fffL
-    msgpack_pack_real_int16(x, d);
-#elif LONG_MAX == 0x7fffffffL
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#else
-if(sizeof(long) == 2) {
-    msgpack_pack_real_int16(x, d);
-} else if(sizeof(long) == 4) {
-    msgpack_pack_real_int32(x, d);
-} else {
-    msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_long_long(msgpack_packer* x, long long d)
-{
-#if defined(SIZEOF_LONG_LONG)
-#if SIZEOF_LONG_LONG == 2
-    msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG_LONG == 4
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(LLONG_MAX)
-#if LLONG_MAX == 0x7fffL
-    msgpack_pack_real_int16(x, d);
-#elif LLONG_MAX == 0x7fffffffL
-    msgpack_pack_real_int32(x, d);
-#else
-    msgpack_pack_real_int64(x, d);
-#endif
-
-#else
-if(sizeof(long long) == 2) {
-    msgpack_pack_real_int16(x, d);
-} else if(sizeof(long long) == 4) {
-    msgpack_pack_real_int32(x, d);
-} else {
-    msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_unsigned_short(msgpack_packer* x, unsigned short d)
-{
-#if defined(SIZEOF_SHORT)
-#if SIZEOF_SHORT == 2
-    msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_SHORT == 4
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(USHRT_MAX)
-#if USHRT_MAX == 0xffffU
-    msgpack_pack_real_uint16(x, d);
-#elif USHRT_MAX == 0xffffffffU
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#else
-if(sizeof(unsigned short) == 2) {
-    msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned short) == 4) {
-    msgpack_pack_real_uint32(x, d);
-} else {
-    msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_unsigned_int(msgpack_packer* x, unsigned int d)
-{
-#if defined(SIZEOF_INT)
-#if SIZEOF_INT == 2
-    msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_INT == 4
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(UINT_MAX)
-#if UINT_MAX == 0xffffU
-    msgpack_pack_real_uint16(x, d);
-#elif UINT_MAX == 0xffffffffU
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#else
-if(sizeof(unsigned int) == 2) {
-    msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned int) == 4) {
-    msgpack_pack_real_uint32(x, d);
-} else {
-    msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_unsigned_long(msgpack_packer* x, unsigned long d)
-{
-#if defined(SIZEOF_LONG)
-#if SIZEOF_LONG == 2
-    msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG == 4
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(ULONG_MAX)
-#if ULONG_MAX == 0xffffUL
-    msgpack_pack_real_uint16(x, d);
-#elif ULONG_MAX == 0xffffffffUL
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#else
-if(sizeof(unsigned long) == 2) {
-    msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned long) == 4) {
-    msgpack_pack_real_uint32(x, d);
-} else {
-    msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-static inline int msgpack_pack_unsigned_long_long(msgpack_packer* x, unsigned long long d)
-{
-#if defined(SIZEOF_LONG_LONG)
-#if SIZEOF_LONG_LONG == 2
-    msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG_LONG == 4
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(ULLONG_MAX)
-#if ULLONG_MAX == 0xffffUL
-    msgpack_pack_real_uint16(x, d);
-#elif ULLONG_MAX == 0xffffffffUL
-    msgpack_pack_real_uint32(x, d);
-#else
-    msgpack_pack_real_uint64(x, d);
-#endif
-
-#else
-if(sizeof(unsigned long long) == 2) {
-    msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned long long) == 4) {
-    msgpack_pack_real_uint32(x, d);
-} else {
-    msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-//#undef msgpack_pack_inline_func_cint
-//#endif
-
-
-
-/*
- * Float
- */
-
-static inline int msgpack_pack_float(msgpack_packer* x, float d)
-{
-    union { float f; uint32_t i; } mem;
-    mem.f = d;
-    unsigned char buf[5];
-    buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
-    msgpack_pack_append_buffer(x, buf, 5);
-}
-
-static inline int msgpack_pack_double(msgpack_packer* x, double d)
-{
-    union { double f; uint64_t i; } mem;
-    mem.f = d;
-    unsigned char buf[9];
-    buf[0] = 0xcb;
-#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
-    // https://github.com/msgpack/msgpack-perl/pull/1
-    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
-#endif
-    _msgpack_store64(&buf[1], mem.i);
-    msgpack_pack_append_buffer(x, buf, 9);
-}
-
-
-/*
- * Nil
- */
-
-static inline int msgpack_pack_nil(msgpack_packer* x)
-{
-    static const unsigned char d = 0xc0;
-    msgpack_pack_append_buffer(x, &d, 1);
-}
-
-
-/*
- * Boolean
- */
-
-static inline int msgpack_pack_true(msgpack_packer* x)
-{
-    static const unsigned char d = 0xc3;
-    msgpack_pack_append_buffer(x, &d, 1);
-}
-
-static inline int msgpack_pack_false(msgpack_packer* x)
-{
-    static const unsigned char d = 0xc2;
-    msgpack_pack_append_buffer(x, &d, 1);
-}
-
-
-/*
- * Array
- */
-
-static inline int msgpack_pack_array(msgpack_packer* x, unsigned int n)
-{
-    if(n < 16) {
-        unsigned char d = 0x90 | n;
-        msgpack_pack_append_buffer(x, &d, 1);
-    } else if(n < 65536) {
-        unsigned char buf[3];
-        buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
-        msgpack_pack_append_buffer(x, buf, 3);
-    } else {
-        unsigned char buf[5];
-        buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
-        msgpack_pack_append_buffer(x, buf, 5);
-    }
-}
-
-
-/*
- * Map
- */
-
-static inline int msgpack_pack_map(msgpack_packer* x, unsigned int n)
-{
-    if(n < 16) {
-        unsigned char d = 0x80 | n;
-        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-    } else if(n < 65536) {
-        unsigned char buf[3];
-        buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
-        msgpack_pack_append_buffer(x, buf, 3);
-    } else {
-        unsigned char buf[5];
-        buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
-        msgpack_pack_append_buffer(x, buf, 5);
-    }
-}
-
-
-/*
- * Raw
- */
-
-static inline int msgpack_pack_raw(msgpack_packer* x, size_t l)
-{
-    if (l < 32) {
-        unsigned char d = 0xa0 | (uint8_t)l;
-        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-    } else if (x->use_bin_type && l < 256) {  // str8 is new format introduced with bin.
-        unsigned char buf[2] = {0xd9, (uint8_t)l};
-        msgpack_pack_append_buffer(x, buf, 2);
-    } else if (l < 65536) {
-        unsigned char buf[3];
-        buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
-        msgpack_pack_append_buffer(x, buf, 3);
-    } else {
-        unsigned char buf[5];
-        buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
-        msgpack_pack_append_buffer(x, buf, 5);
-    }
-}
-
-/*
- * bin
- */
-static inline int msgpack_pack_bin(msgpack_packer *x, size_t l)
-{
-    if (!x->use_bin_type) {
-        return msgpack_pack_raw(x, l);
-    }
-    if (l < 256) {
-        unsigned char buf[2] = {0xc4, (unsigned char)l};
-        msgpack_pack_append_buffer(x, buf, 2);
-    } else if (l < 65536) {
-        unsigned char buf[3] = {0xc5};
-        _msgpack_store16(&buf[1], (uint16_t)l);
-        msgpack_pack_append_buffer(x, buf, 3);
-    } else {
-        unsigned char buf[5] = {0xc6};
-        _msgpack_store32(&buf[1], (uint32_t)l);
-        msgpack_pack_append_buffer(x, buf, 5);
-    }
-}
-
-static inline int msgpack_pack_raw_body(msgpack_packer* x, const void* b, size_t l)
-{
-    if (l > 0) msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
-    return 0;
-}
-
-/*
- * Ext
- */
-static inline int msgpack_pack_ext(msgpack_packer* x, char typecode, size_t l)
-{
-    if (l == 1) {
-        unsigned char buf[2];
-        buf[0] = 0xd4;
-        buf[1] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 2);
-    }
-    else if(l == 2) {
-        unsigned char buf[2];
-        buf[0] = 0xd5;
-        buf[1] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 2);
-    }
-    else if(l == 4) {
-        unsigned char buf[2];
-        buf[0] = 0xd6;
-        buf[1] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 2);
-    }
-    else if(l == 8) {
-        unsigned char buf[2];
-        buf[0] = 0xd7;
-        buf[1] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 2);
-    }
-    else if(l == 16) {
-        unsigned char buf[2];
-        buf[0] = 0xd8;
-        buf[1] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 2);
-    }
-    else if(l < 256) {
-        unsigned char buf[3];
-        buf[0] = 0xc7;
-        buf[1] = l;
-        buf[2] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 3);
-    } else if(l < 65536) {
-        unsigned char buf[4];
-        buf[0] = 0xc8;
-        _msgpack_store16(&buf[1], (uint16_t)l);
-        buf[3] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 4);
-    } else {
-        unsigned char buf[6];
-        buf[0] = 0xc9;
-        _msgpack_store32(&buf[1], (uint32_t)l);
-        buf[5] = (unsigned char)typecode;
-        msgpack_pack_append_buffer(x, buf, 6);
-    }
-
-}
-
-
-
-#undef msgpack_pack_append_buffer
-
-#undef TAKE8_8
-#undef TAKE8_16
-#undef TAKE8_32
-#undef TAKE8_64
-
-#undef msgpack_pack_real_uint8
-#undef msgpack_pack_real_uint16
-#undef msgpack_pack_real_uint32
-#undef msgpack_pack_real_uint64
-#undef msgpack_pack_real_int8
-#undef msgpack_pack_real_int16
-#undef msgpack_pack_real_int32
-#undef msgpack_pack_real_int64
diff --git a/pandas/_libs/src/msgpack/sysdep.h b/pandas/_libs/src/msgpack/sysdep.h
deleted file mode 100644
index ed9c1bc0b8031..0000000000000
--- a/pandas/_libs/src/msgpack/sysdep.h
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * MessagePack system dependencies
- *
- * Copyright (C) 2008-2010 FURUHASHI Sadayuki
- *
- *    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.
- */
-#ifndef MSGPACK_SYSDEP_H__
-#define MSGPACK_SYSDEP_H__
-
-#include <stdlib.h>
-#include <stddef.h>
-#if defined(_MSC_VER) && _MSC_VER < 1600
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#elif defined(_MSC_VER)  // && _MSC_VER >= 1600
-#include <stdint.h>
-#else
-#include <stdint.h>
-#include <stdbool.h>
-#endif
-
-#ifdef _WIN32
-#define _msgpack_atomic_counter_header <windows.h>
-typedef long _msgpack_atomic_counter_t;
-#define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
-#define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
-#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
-#define _msgpack_atomic_counter_header "gcc_atomic.h"
-#else
-typedef unsigned int _msgpack_atomic_counter_t;
-#define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
-#define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1)
-#endif
-
-#ifdef _WIN32
-
-#ifdef __cplusplus
-/* numeric_limits<T>::min,max */
-#ifdef max
-#undef max
-#endif
-#ifdef min
-#undef min
-#endif
-#endif
-
-#else
-#include <arpa/inet.h>  /* __BYTE_ORDER */
-#endif
-
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#elif _WIN32
-#define __LITTLE_ENDIAN__
-#endif
-#endif
-
-
-#ifdef __LITTLE_ENDIAN__
-
-#ifdef _WIN32
-#  if defined(ntohs)
-#    define _msgpack_be16(x) ntohs(x)
-#  elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#    define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
-#  else
-#    define _msgpack_be16(x) ( \
-        ((((uint16_t)x) <<  8) ) | \
-        ((((uint16_t)x) >>  8) ) )
-#  endif
-#else
-#  define _msgpack_be16(x) ntohs(x)
-#endif
-
-#ifdef _WIN32
-#  if defined(ntohl)
-#    define _msgpack_be32(x) ntohl(x)
-#  elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#    define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x))
-#  else
-#    define _msgpack_be32(x) \
-        ( ((((uint32_t)x) << 24)               ) | \
-          ((((uint32_t)x) <<  8) & 0x00ff0000U ) | \
-          ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
-          ((((uint32_t)x) >> 24)               ) )
-#  endif
-#else
-#  define _msgpack_be32(x) ntohl(x)
-#endif
-
-#if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#  define _msgpack_be64(x) (_byteswap_uint64(x))
-#elif defined(bswap_64)
-#  define _msgpack_be64(x) bswap_64(x)
-#elif defined(__DARWIN_OSSwapInt64)
-#  define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
-#else
-#define _msgpack_be64(x) \
-    ( ((((uint64_t)x) << 56)                         ) | \
-      ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
-      ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
-      ((((uint64_t)x) <<  8) & 0x000000ff00000000ULL ) | \
-      ((((uint64_t)x) >>  8) & 0x00000000ff000000ULL ) | \
-      ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
-      ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
-      ((((uint64_t)x) >> 56)                         ) )
-#endif
-
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)(from))[0]) << 8) | \
-        (((uint16_t)((uint8_t*)(from))[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)(from))[0]) << 24) | \
-        (((uint32_t)((uint8_t*)(from))[1]) << 16) | \
-        (((uint32_t)((uint8_t*)(from))[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)(from))[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)(from))[0]) << 56) | \
-        (((uint64_t)((uint8_t*)(from))[1]) << 48) | \
-        (((uint64_t)((uint8_t*)(from))[2]) << 40) | \
-        (((uint64_t)((uint8_t*)(from))[3]) << 32) | \
-        (((uint64_t)((uint8_t*)(from))[4]) << 24) | \
-        (((uint64_t)((uint8_t*)(from))[5]) << 16) | \
-        (((uint64_t)((uint8_t*)(from))[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)(from))[7])     )  ))
-
-#else
-
-#define _msgpack_be16(x) (x)
-#define _msgpack_be32(x) (x)
-#define _msgpack_be64(x) (x)
-
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)from)[0]) << 8) | \
-        (((uint16_t)((uint8_t*)from)[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)from)[0]) << 24) | \
-        (((uint32_t)((uint8_t*)from)[1]) << 16) | \
-        (((uint32_t)((uint8_t*)from)[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)from)[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)from)[0]) << 56) | \
-        (((uint64_t)((uint8_t*)from)[1]) << 48) | \
-        (((uint64_t)((uint8_t*)from)[2]) << 40) | \
-        (((uint64_t)((uint8_t*)from)[3]) << 32) | \
-        (((uint64_t)((uint8_t*)from)[4]) << 24) | \
-        (((uint64_t)((uint8_t*)from)[5]) << 16) | \
-        (((uint64_t)((uint8_t*)from)[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)from)[7])     )  ))
-#endif
-
-
-#define _msgpack_store16(to, num) \
-    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
-#define _msgpack_store32(to, num) \
-    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
-#define _msgpack_store64(to, num) \
-    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
-
-/*
-#define _msgpack_load16(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); })
-#define _msgpack_load32(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); })
-#define _msgpack_load64(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); })
-*/
-
-
-#endif /* msgpack/sysdep.h */
diff --git a/pandas/_libs/src/msgpack/unpack.h b/pandas/_libs/src/msgpack/unpack.h
deleted file mode 100644
index 591fad1ae4661..0000000000000
--- a/pandas/_libs/src/msgpack/unpack.h
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * MessagePack for Python unpacking routine
- *
- * Copyright (C) 2009 Naoki INADA
- *
- *    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.
- */
-
-#define MSGPACK_EMBED_STACK_SIZE  (1024)
-#include "unpack_define.h"
-
-typedef struct unpack_user {
-    int use_list;
-    PyObject *object_hook;
-    bool has_pairs_hook;
-    PyObject *list_hook;
-    PyObject *ext_hook;
-    const char *encoding;
-    const char *unicode_errors;
-    Py_ssize_t max_str_len, max_bin_len, max_array_len, max_map_len, max_ext_len;
-} unpack_user;
-
-typedef PyObject* msgpack_unpack_object;
-struct unpack_context;
-typedef struct unpack_context unpack_context;
-typedef int (*execute_fn)(unpack_context *ctx, const char* data, size_t len, size_t* off);
-
-static inline msgpack_unpack_object unpack_callback_root(unpack_user* u)
-{
-    return NULL;
-}
-
-static inline int unpack_callback_uint16(unpack_user* u, uint16_t d, msgpack_unpack_object* o)
-{
-    PyObject *p = PyInt_FromLong((long)d);
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-static inline int unpack_callback_uint8(unpack_user* u, uint8_t d, msgpack_unpack_object* o)
-{
-    return unpack_callback_uint16(u, d, o);
-}
-
-
-static inline int unpack_callback_uint32(unpack_user* u, uint32_t d, msgpack_unpack_object* o)
-{
-    PyObject *p = PyInt_FromSize_t((size_t)d);
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_uint64(unpack_user* u, uint64_t d, msgpack_unpack_object* o)
-{
-    PyObject *p;
-    if (d > LONG_MAX) {
-        p = PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)d);
-    } else {
-        p = PyInt_FromSize_t((size_t)d);
-    }
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_int32(unpack_user* u, int32_t d, msgpack_unpack_object* o)
-{
-    PyObject *p = PyInt_FromLong(d);
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_int16(unpack_user* u, int16_t d, msgpack_unpack_object* o)
-{
-    return unpack_callback_int32(u, d, o);
-}
-
-static inline int unpack_callback_int8(unpack_user* u, int8_t d, msgpack_unpack_object* o)
-{
-    return unpack_callback_int32(u, d, o);
-}
-
-static inline int unpack_callback_int64(unpack_user* u, int64_t d, msgpack_unpack_object* o)
-{
-    PyObject *p;
-    if (d > LONG_MAX || d < LONG_MIN) {
-        p = PyLong_FromLongLong((unsigned PY_LONG_LONG)d);
-    } else {
-        p = PyInt_FromLong((long)d);
-    }
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_double(unpack_user* u, double d, msgpack_unpack_object* o)
-{
-    PyObject *p = PyFloat_FromDouble(d);
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_float(unpack_user* u, float d, msgpack_unpack_object* o)
-{
-    return unpack_callback_double(u, d, o);
-}
-
-static inline int unpack_callback_nil(unpack_user* u, msgpack_unpack_object* o)
-{ Py_INCREF(Py_None); *o = Py_None; return 0; }
-
-static inline int unpack_callback_true(unpack_user* u, msgpack_unpack_object* o)
-{ Py_INCREF(Py_True); *o = Py_True; return 0; }
-
-static inline int unpack_callback_false(unpack_user* u, msgpack_unpack_object* o)
-{ Py_INCREF(Py_False); *o = Py_False; return 0; }
-
-static inline int unpack_callback_array(unpack_user* u, unsigned int n, msgpack_unpack_object* o)
-{
-    if (n > u->max_array_len) {
-        PyErr_Format(PyExc_ValueError, "%u exceeds max_array_len(%zd)", n, u->max_array_len);
-        return -1;
-    }
-    PyObject *p = u->use_list ? PyList_New(n) : PyTuple_New(n);
-
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_array_item(unpack_user* u, unsigned int current, msgpack_unpack_object* c, msgpack_unpack_object o)
-{
-    if (u->use_list)
-        PyList_SET_ITEM(*c, current, o);
-    else
-        PyTuple_SET_ITEM(*c, current, o);
-    return 0;
-}
-
-static inline int unpack_callback_array_end(unpack_user* u, msgpack_unpack_object* c)
-{
-    if (u->list_hook) {
-        PyObject *new_c = PyObject_CallFunctionObjArgs(u->list_hook, *c, NULL);
-        if (!new_c)
-            return -1;
-        Py_DECREF(*c);
-        *c = new_c;
-    }
-    return 0;
-}
-
-static inline int unpack_callback_map(unpack_user* u, unsigned int n, msgpack_unpack_object* o)
-{
-    if (n > u->max_map_len) {
-        PyErr_Format(PyExc_ValueError, "%u exceeds max_map_len(%zd)", n, u->max_map_len);
-        return -1;
-    }
-    PyObject *p;
-    if (u->has_pairs_hook) {
-        p = PyList_New(n); // Or use tuple?
-    }
-    else {
-        p = PyDict_New();
-    }
-    if (!p)
-        return -1;
-    *o = p;
-    return 0;
-}
-
-static inline int unpack_callback_map_item(unpack_user* u, unsigned int current, msgpack_unpack_object* c, msgpack_unpack_object k, msgpack_unpack_object v)
-{
-    if (u->has_pairs_hook) {
-        msgpack_unpack_object item = PyTuple_Pack(2, k, v);
-        if (!item)
-            return -1;
-        Py_DECREF(k);
-        Py_DECREF(v);
-        PyList_SET_ITEM(*c, current, item);
-        return 0;
-    }
-    else if (PyDict_SetItem(*c, k, v) == 0) {
-        Py_DECREF(k);
-        Py_DECREF(v);
-        return 0;
-    }
-    return -1;
-}
-
-static inline int unpack_callback_map_end(unpack_user* u, msgpack_unpack_object* c)
-{
-    if (u->object_hook) {
-        PyObject *new_c = PyObject_CallFunctionObjArgs(u->object_hook, *c, NULL);
-        if (!new_c)
-            return -1;
-
-        Py_DECREF(*c);
-        *c = new_c;
-    }
-    return 0;
-}
-
-static inline int unpack_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_unpack_object* o)
-{
-    if (l > u->max_str_len) {
-        PyErr_Format(PyExc_ValueError, "%u exceeds max_str_len(%zd)", l, u->max_str_len);
-        return -1;
-    }
-
-    PyObject *py;
-    if(u->encoding) {
-        py = PyUnicode_Decode(p, l, u->encoding, u->unicode_errors);
-    } else {
-        py = PyBytes_FromStringAndSize(p, l);
-    }
-    if (!py)
-        return -1;
-    *o = py;
-    return 0;
-}
-
-static inline int unpack_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_unpack_object* o)
-{
-    if (l > u->max_bin_len) {
-        PyErr_Format(PyExc_ValueError, "%u exceeds max_bin_len(%zd)", l, u->max_bin_len);
-        return -1;
-    }
-
-    PyObject *py = PyBytes_FromStringAndSize(p, l);
-    if (!py)
-        return -1;
-    *o = py;
-    return 0;
-}
-
-static inline int unpack_callback_ext(unpack_user* u, const char* base, const char* pos,
-                                      unsigned int length, msgpack_unpack_object* o)
-{
-    PyObject *py;
-    int8_t typecode = (int8_t)*pos++;
-    if (!u->ext_hook) {
-        PyErr_SetString(PyExc_AssertionError, "u->ext_hook cannot be NULL");
-        return -1;
-    }
-    if (length-1 > u->max_ext_len) {
-        PyErr_Format(PyExc_ValueError, "%u exceeds max_ext_len(%zd)", length, u->max_ext_len);
-        return -1;
-    }
-    // length also includes the typecode, so the actual data is length-1
-#if PY_MAJOR_VERSION == 2
-    py = PyObject_CallFunction(u->ext_hook, (char*)"(is#)", typecode, pos, (Py_ssize_t)length-1);
-#else
-    py = PyObject_CallFunction(u->ext_hook, (char*)"(iy#)", typecode, pos, (Py_ssize_t)length-1);
-#endif
-    if (!py)
-        return -1;
-    *o = py;
-    return 0;
-}
-
-#include "unpack_template.h"
diff --git a/pandas/_libs/src/msgpack/unpack_define.h b/pandas/_libs/src/msgpack/unpack_define.h
deleted file mode 100644
index 0dd708d17c3d4..0000000000000
--- a/pandas/_libs/src/msgpack/unpack_define.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2010 FURUHASHI Sadayuki
- *
- *    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.
- */
-#ifndef MSGPACK_UNPACK_DEFINE_H__
-#define MSGPACK_UNPACK_DEFINE_H__
-
-#include "msgpack/sysdep.h"
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#ifndef MSGPACK_EMBED_STACK_SIZE
-#define MSGPACK_EMBED_STACK_SIZE 32
-#endif
-
-
-// CS is first byte & 0x1f
-typedef enum {
-    CS_HEADER            = 0x00,  // nil
-
-    //CS_                = 0x01,
-    //CS_                = 0x02,  // false
-    //CS_                = 0x03,  // true
-
-    CS_BIN_8             = 0x04,
-    CS_BIN_16            = 0x05,
-    CS_BIN_32            = 0x06,
-
-    CS_EXT_8             = 0x07,
-    CS_EXT_16            = 0x08,
-    CS_EXT_32            = 0x09,
-
-    CS_FLOAT             = 0x0a,
-    CS_DOUBLE            = 0x0b,
-    CS_UINT_8            = 0x0c,
-    CS_UINT_16           = 0x0d,
-    CS_UINT_32           = 0x0e,
-    CS_UINT_64           = 0x0f,
-    CS_INT_8             = 0x10,
-    CS_INT_16            = 0x11,
-    CS_INT_32            = 0x12,
-    CS_INT_64            = 0x13,
-
-    //CS_FIXEXT1           = 0x14,
-    //CS_FIXEXT2           = 0x15,
-    //CS_FIXEXT4           = 0x16,
-    //CS_FIXEXT8           = 0x17,
-    //CS_FIXEXT16          = 0x18,
-
-    CS_RAW_8             = 0x19,
-    CS_RAW_16            = 0x1a,
-    CS_RAW_32            = 0x1b,
-    CS_ARRAY_16          = 0x1c,
-    CS_ARRAY_32          = 0x1d,
-    CS_MAP_16            = 0x1e,
-    CS_MAP_32            = 0x1f,
-
-    ACS_RAW_VALUE,
-    ACS_BIN_VALUE,
-    ACS_EXT_VALUE,
-} msgpack_unpack_state;
-
-
-typedef enum {
-    CT_ARRAY_ITEM,
-    CT_MAP_KEY,
-    CT_MAP_VALUE,
-} msgpack_container_type;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/unpack_define.h */
diff --git a/pandas/_libs/src/msgpack/unpack_template.h b/pandas/_libs/src/msgpack/unpack_template.h
deleted file mode 100644
index 402dcd48cb35a..0000000000000
--- a/pandas/_libs/src/msgpack/unpack_template.h
+++ /dev/null
@@ -1,475 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2010 FURUHASHI Sadayuki
- *
- *    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.
- */
-
-#ifndef USE_CASE_RANGE
-#ifdef __GNUC__
-#define USE_CASE_RANGE
-#endif
-#endif
-
-typedef struct unpack_stack {
-    PyObject* obj;
-    size_t size;
-    size_t count;
-    unsigned int ct;
-    PyObject* map_key;
-} unpack_stack;
-
-struct unpack_context {
-    unpack_user user;
-    unsigned int cs;
-    unsigned int trail;
-    unsigned int top;
-    /*
-    unpack_stack* stack;
-    unsigned int stack_size;
-    unpack_stack embed_stack[MSGPACK_EMBED_STACK_SIZE];
-    */
-    unpack_stack stack[MSGPACK_EMBED_STACK_SIZE];
-};
-
-
-static inline void unpack_init(unpack_context* ctx)
-{
-    ctx->cs = CS_HEADER;
-    ctx->trail = 0;
-    ctx->top = 0;
-    /*
-    ctx->stack = ctx->embed_stack;
-    ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
-    */
-    ctx->stack[0].obj = unpack_callback_root(&ctx->user);
-}
-
-/*
-static inline void unpack_destroy(unpack_context* ctx)
-{
-    if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
-        free(ctx->stack);
-    }
-}
-*/
-
-static inline PyObject* unpack_data(unpack_context* ctx)
-{
-    return (ctx)->stack[0].obj;
-}
-
-
-template <bool construct>
-static inline int unpack_execute(unpack_context* ctx, const char* data, size_t len, size_t* off)
-{
-    assert(len >= *off);
-
-    const unsigned char* p = (unsigned char*)data + *off;
-    const unsigned char* const pe = (unsigned char*)data + len;
-    const void* n = NULL;
-
-    unsigned int trail = ctx->trail;
-    unsigned int cs = ctx->cs;
-    unsigned int top = ctx->top;
-    unpack_stack* stack = ctx->stack;
-    /*
-    unsigned int stack_size = ctx->stack_size;
-    */
-    unpack_user* user = &ctx->user;
-
-    PyObject* obj = NULL;
-    unpack_stack* c = NULL;
-
-    int ret;
-
-#define construct_cb(name) \
-    construct && unpack_callback ## name
-
-#define push_simple_value(func) \
-    if(construct_cb(func)(user, &obj) < 0) { goto _failed; } \
-    goto _push
-#define push_fixed_value(func, arg) \
-    if(construct_cb(func)(user, arg, &obj) < 0) { goto _failed; } \
-    goto _push
-#define push_variable_value(func, base, pos, len) \
-    if(construct_cb(func)(user, \
-        (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
-    goto _push
-
-#define again_fixed_trail(_cs, trail_len) \
-    trail = trail_len; \
-    cs = _cs; \
-    goto _fixed_trail_again
-#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
-    trail = trail_len; \
-    if(trail == 0) { goto ifzero; } \
-    cs = _cs; \
-    goto _fixed_trail_again
-
-#define start_container(func, count_, ct_) \
-    if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
-    if(construct_cb(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
-    if((count_) == 0) { obj = stack[top].obj; \
-        if (construct_cb(func##_end)(user, &obj) < 0) { goto _failed; } \
-        goto _push; } \
-    stack[top].ct = ct_; \
-    stack[top].size  = count_; \
-    stack[top].count = 0; \
-    ++top; \
-    /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
-    /*printf("stack push %d\n", top);*/ \
-    /* FIXME \
-    if(top >= stack_size) { \
-        if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
-            size_t csize = sizeof(unpack_stack) * MSGPACK_EMBED_STACK_SIZE; \
-            size_t nsize = csize * 2; \
-            unpack_stack* tmp = (unpack_stack*)malloc(nsize); \
-            if(tmp == NULL) { goto _failed; } \
-            memcpy(tmp, ctx->stack, csize); \
-            ctx->stack = stack = tmp; \
-            ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
-        } else { \
-            size_t nsize = sizeof(unpack_stack) * ctx->stack_size * 2; \
-            unpack_stack* tmp = (unpack_stack*)realloc(ctx->stack, nsize); \
-            if(tmp == NULL) { goto _failed; } \
-            ctx->stack = stack = tmp; \
-            ctx->stack_size = stack_size = stack_size * 2; \
-        } \
-    } \
-    */ \
-    goto _header_again
-
-#define NEXT_CS(p)  ((unsigned int)*p & 0x1f)
-
-#ifdef USE_CASE_RANGE
-#define SWITCH_RANGE_BEGIN     switch(*p) {
-#define SWITCH_RANGE(FROM, TO) case FROM ... TO:
-#define SWITCH_RANGE_DEFAULT   default:
-#define SWITCH_RANGE_END       }
-#else
-#define SWITCH_RANGE_BEGIN     { if(0) {
-#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) {
-#define SWITCH_RANGE_DEFAULT   } else {
-#define SWITCH_RANGE_END       } }
-#endif
-
-    if(p == pe) { goto _out; }
-    do {
-        switch(cs) {
-        case CS_HEADER:
-            SWITCH_RANGE_BEGIN
-            SWITCH_RANGE(0x00, 0x7f)  // Positive Fixnum
-                push_fixed_value(_uint8, *(uint8_t*)p);
-            SWITCH_RANGE(0xe0, 0xff)  // Negative Fixnum
-                push_fixed_value(_int8, *(int8_t*)p);
-            SWITCH_RANGE(0xc0, 0xdf)  // Variable
-                switch(*p) {
-                case 0xc0:  // nil
-                    push_simple_value(_nil);
-                //case 0xc1:  // never used
-                case 0xc2:  // false
-                    push_simple_value(_false);
-                case 0xc3:  // true
-                    push_simple_value(_true);
-                case 0xc4:  // bin 8
-                    again_fixed_trail(NEXT_CS(p), 1);
-                case 0xc5:  // bin 16
-                    again_fixed_trail(NEXT_CS(p), 2);
-                case 0xc6:  // bin 32
-                    again_fixed_trail(NEXT_CS(p), 4);
-                case 0xc7:  // ext 8
-                    again_fixed_trail(NEXT_CS(p), 1);
-                case 0xc8:  // ext 16
-                    again_fixed_trail(NEXT_CS(p), 2);
-                case 0xc9:  // ext 32
-                    again_fixed_trail(NEXT_CS(p), 4);
-                case 0xca:  // float
-                case 0xcb:  // double
-                case 0xcc:  // unsigned int  8
-                case 0xcd:  // unsigned int 16
-                case 0xce:  // unsigned int 32
-                case 0xcf:  // unsigned int 64
-                case 0xd0:  // signed int  8
-                case 0xd1:  // signed int 16
-                case 0xd2:  // signed int 32
-                case 0xd3:  // signed int 64
-                    again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
-                case 0xd4:  // fixext 1
-                case 0xd5:  // fixext 2
-                case 0xd6:  // fixext 4
-                case 0xd7:  // fixext 8
-                    again_fixed_trail_if_zero(ACS_EXT_VALUE,
-                                              (1 << (((unsigned int)*p) & 0x03))+1,
-                                              _ext_zero);
-                case 0xd8:  // fixext 16
-                    again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero);
-                case 0xd9:  // str 8
-                    again_fixed_trail(NEXT_CS(p), 1);
-                case 0xda:  // raw 16
-                case 0xdb:  // raw 32
-                case 0xdc:  // array 16
-                case 0xdd:  // array 32
-                case 0xde:  // map 16
-                case 0xdf:  // map 32
-                    again_fixed_trail(NEXT_CS(p), 2 << (((unsigned int)*p) & 0x01));
-                default:
-                    goto _failed;
-                }
-            SWITCH_RANGE(0xa0, 0xbf)  // FixRaw
-                again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
-            SWITCH_RANGE(0x90, 0x9f)  // FixArray
-                start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
-            SWITCH_RANGE(0x80, 0x8f)  // FixMap
-                start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
-
-            SWITCH_RANGE_DEFAULT
-                goto _failed;
-            SWITCH_RANGE_END
-            // end CS_HEADER
-
-
-        _fixed_trail_again:
-            ++p;
-
-        default:
-            if((size_t)(pe - p) < trail) { goto _out; }
-            n = p;  p += trail - 1;
-            switch(cs) {
-            case CS_EXT_8:
-                again_fixed_trail_if_zero(ACS_EXT_VALUE, *(uint8_t*)n+1, _ext_zero);
-            case CS_EXT_16:
-                again_fixed_trail_if_zero(ACS_EXT_VALUE,
-                                          _msgpack_load16(uint16_t,n)+1,
-                                          _ext_zero);
-            case CS_EXT_32:
-                again_fixed_trail_if_zero(ACS_EXT_VALUE,
-                                          _msgpack_load32(uint32_t,n)+1,
-                                          _ext_zero);
-            case CS_FLOAT: {
-                    union { uint32_t i; float f; } mem;
-                    mem.i = _msgpack_load32(uint32_t,n);
-                    push_fixed_value(_float, mem.f); }
-            case CS_DOUBLE: {
-                    union { uint64_t i; double f; } mem;
-                    mem.i = _msgpack_load64(uint64_t,n);
-#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
-                    // https://github.com/msgpack/msgpack-perl/pull/1
-                    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
-#endif
-                    push_fixed_value(_double, mem.f); }
-            case CS_UINT_8:
-                push_fixed_value(_uint8, *(uint8_t*)n);
-            case CS_UINT_16:
-                push_fixed_value(_uint16, _msgpack_load16(uint16_t,n));
-            case CS_UINT_32:
-                push_fixed_value(_uint32, _msgpack_load32(uint32_t,n));
-            case CS_UINT_64:
-                push_fixed_value(_uint64, _msgpack_load64(uint64_t,n));
-
-            case CS_INT_8:
-                push_fixed_value(_int8, *(int8_t*)n);
-            case CS_INT_16:
-                push_fixed_value(_int16, _msgpack_load16(int16_t,n));
-            case CS_INT_32:
-                push_fixed_value(_int32, _msgpack_load32(int32_t,n));
-            case CS_INT_64:
-                push_fixed_value(_int64, _msgpack_load64(int64_t,n));
-
-            case CS_BIN_8:
-                again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);
-            case CS_BIN_16:
-                again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load16(uint16_t,n), _bin_zero);
-            case CS_BIN_32:
-                again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load32(uint32_t,n), _bin_zero);
-            case ACS_BIN_VALUE:
-            _bin_zero:
-                push_variable_value(_bin, data, n, trail);
-
-            case CS_RAW_8:
-                again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero);
-            case CS_RAW_16:
-                again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero);
-            case CS_RAW_32:
-                again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero);
-            case ACS_RAW_VALUE:
-            _raw_zero:
-                push_variable_value(_raw, data, n, trail);
-
-            case ACS_EXT_VALUE:
-            _ext_zero:
-                push_variable_value(_ext, data, n, trail);
-
-            case CS_ARRAY_16:
-                start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM);
-            case CS_ARRAY_32:
-                /* FIXME security guard */
-                start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM);
-
-            case CS_MAP_16:
-                start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY);
-            case CS_MAP_32:
-                /* FIXME security guard */
-                start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY);
-
-            default:
-                goto _failed;
-            }
-        }
-
-_push:
-    if(top == 0) { goto _finish; }
-    c = &stack[top-1];
-    switch(c->ct) {
-    case CT_ARRAY_ITEM:
-        if(construct_cb(_array_item)(user, c->count, &c->obj, obj) < 0) { goto _failed; }
-        if(++c->count == c->size) {
-            obj = c->obj;
-            if (construct_cb(_array_end)(user, &obj) < 0) { goto _failed; }
-            --top;
-            /*printf("stack pop %d\n", top);*/
-            goto _push;
-        }
-        goto _header_again;
-    case CT_MAP_KEY:
-        c->map_key = obj;
-        c->ct = CT_MAP_VALUE;
-        goto _header_again;
-    case CT_MAP_VALUE:
-        if(construct_cb(_map_item)(user, c->count, &c->obj, c->map_key, obj) < 0) { goto _failed; }
-        if(++c->count == c->size) {
-            obj = c->obj;
-            if (construct_cb(_map_end)(user, &obj) < 0) { goto _failed; }
-            --top;
-            /*printf("stack pop %d\n", top);*/
-            goto _push;
-        }
-        c->ct = CT_MAP_KEY;
-        goto _header_again;
-
-    default:
-        goto _failed;
-    }
-
-_header_again:
-        cs = CS_HEADER;
-        ++p;
-    } while(p != pe);
-    goto _out;
-
-
-_finish:
-    if (!construct)
-        unpack_callback_nil(user, &obj);
-    stack[0].obj = obj;
-    ++p;
-    ret = 1;
-    /*printf("-- finish --\n"); */
-    goto _end;
-
-_failed:
-    /*printf("** FAILED **\n"); */
-    ret = -1;
-    goto _end;
-
-_out:
-    ret = 0;
-    goto _end;
-
-_end:
-    ctx->cs = cs;
-    ctx->trail = trail;
-    ctx->top = top;
-    *off = p - (const unsigned char*)data;
-
-    return ret;
-#undef construct_cb
-}
-
-#undef SWITCH_RANGE_BEGIN
-#undef SWITCH_RANGE
-#undef SWITCH_RANGE_DEFAULT
-#undef SWITCH_RANGE_END
-#undef push_simple_value
-#undef push_fixed_value
-#undef push_variable_value
-#undef again_fixed_trail
-#undef again_fixed_trail_if_zero
-#undef start_container
-
-template <unsigned int fixed_offset, unsigned int var_offset>
-static inline int unpack_container_header(unpack_context* ctx, const char* data, size_t len, size_t* off)
-{
-    assert(len >= *off);
-    uint32_t size;
-    const unsigned char *const p = (unsigned char*)data + *off;
-
-#define inc_offset(inc) \
-    if (len - *off < inc) \
-        return 0; \
-    *off += inc;
-
-    switch (*p) {
-    case var_offset:
-        inc_offset(3);
-        size = _msgpack_load16(uint16_t, p + 1);
-        break;
-    case var_offset + 1:
-        inc_offset(5);
-        size = _msgpack_load32(uint32_t, p + 1);
-        break;
-#ifdef USE_CASE_RANGE
-    case fixed_offset + 0x0 ... fixed_offset + 0xf:
-#else
-    case fixed_offset + 0x0:
-    case fixed_offset + 0x1:
-    case fixed_offset + 0x2:
-    case fixed_offset + 0x3:
-    case fixed_offset + 0x4:
-    case fixed_offset + 0x5:
-    case fixed_offset + 0x6:
-    case fixed_offset + 0x7:
-    case fixed_offset + 0x8:
-    case fixed_offset + 0x9:
-    case fixed_offset + 0xa:
-    case fixed_offset + 0xb:
-    case fixed_offset + 0xc:
-    case fixed_offset + 0xd:
-    case fixed_offset + 0xe:
-    case fixed_offset + 0xf:
-#endif
-        ++*off;
-        size = ((unsigned int)*p) & 0x0f;
-        break;
-    default:
-        PyErr_SetString(PyExc_ValueError, "Unexpected type header on stream");
-        return -1;
-    }
-    unpack_callback_uint32(&ctx->user, size, &ctx->stack[0].obj);
-    return 1;
-}
-
-#undef SWITCH_RANGE_BEGIN
-#undef SWITCH_RANGE
-#undef SWITCH_RANGE_DEFAULT
-#undef SWITCH_RANGE_END
-
-static const execute_fn unpack_construct = &unpack_execute<true>;
-static const execute_fn unpack_skip = &unpack_execute<false>;
-static const execute_fn read_array_header = &unpack_container_header<0x90, 0xdc>;
-static const execute_fn read_map_header = &unpack_container_header<0x80, 0xde>;
-
-#undef NEXT_CS
-
-/* vim: set ts=4 sw=4 sts=4 expandtab  */
diff --git a/pandas/_libs/src/parse_helper.h b/pandas/_libs/src/parse_helper.h
index 0a767dd27b658..7fbe7a04d5b22 100644
--- a/pandas/_libs/src/parse_helper.h
+++ b/pandas/_libs/src/parse_helper.h
@@ -11,8 +11,6 @@ The full license is in the LICENSE file, distributed with this software.
 #define PANDAS__LIBS_SRC_PARSE_HELPER_H_
 
 #include <float.h>
-#include "inline_helper.h"
-#include "headers/portable.h"
 #include "parser/tokenizer.h"
 
 int to_double(char *item, double *p_value, char sci, char decimal,
@@ -94,12 +92,4 @@ int floatify(PyObject *str, double *result, int *maybe_int) {
     return -1;
 }
 
-PANDAS_INLINE void lowercase(char *p) {
-    for (; *p; ++p) *p = tolower_ascii(*p);
-}
-
-PANDAS_INLINE void uppercase(char *p) {
-    for (; *p; ++p) *p = toupper_ascii(*p);
-}
-
 #endif  // PANDAS__LIBS_SRC_PARSE_HELPER_H_
diff --git a/pandas/_libs/src/parser/io.c b/pandas/_libs/src/parser/io.c
index 5d73230f32955..1e3295fcb6fc7 100644
--- a/pandas/_libs/src/parser/io.c
+++ b/pandas/_libs/src/parser/io.c
@@ -9,7 +9,6 @@ The full license is in the LICENSE file, distributed with this software.
 
 #include "io.h"
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
@@ -17,7 +16,7 @@ The full license is in the LICENSE file, distributed with this software.
 #define O_BINARY 0
 #endif  // O_BINARY
 
-#if PY_VERSION_HEX >= 0x03060000 && defined(_WIN32)
+#ifdef _WIN32
 #define USE_WIN_UTF16
 #include <Windows.h>
 #endif
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index 2752fb6424022..2188ff6b0d464 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -25,19 +25,6 @@ GitHub. See Python Software Foundation License and BSD licenses for these.
 
 #include "../headers/portable.h"
 
-static void *safe_realloc(void *buffer, size_t size) {
-    void *result;
-    // OSX is weird.
-    // http://stackoverflow.com/questions/9560609/
-    // different-realloc-behaviour-in-linux-and-osx
-
-    result = realloc(buffer, size);
-    TRACE(("safe_realloc: buffer = %p, size = %zu, result = %p\n", buffer, size,
-           result))
-
-    return result;
-}
-
 void coliter_setup(coliter_t *self, parser_t *parser, int i, int start) {
     // column i, starting at 0
     self->words = parser->words;
@@ -45,18 +32,6 @@ void coliter_setup(coliter_t *self, parser_t *parser, int i, int start) {
     self->line_start = parser->line_start + start;
 }
 
-coliter_t *coliter_new(parser_t *self, int i) {
-    // column i, starting at 0
-    coliter_t *iter = (coliter_t *)malloc(sizeof(coliter_t));
-
-    if (NULL == iter) {
-        return NULL;
-    }
-
-    coliter_setup(iter, self, i, 0);
-    return iter;
-}
-
 static void free_if_not_null(void **ptr) {
     TRACE(("free_if_not_null %p\n", *ptr))
     if (*ptr != NULL) {
@@ -80,7 +55,7 @@ static void *grow_buffer(void *buffer, uint64_t length, uint64_t *capacity,
     while ((length + space >= cap) && (newbuffer != NULL)) {
         cap = cap ? cap << 1 : 2;
         buffer = newbuffer;
-        newbuffer = safe_realloc(newbuffer, elsize * cap);
+        newbuffer = realloc(newbuffer, elsize * cap);
     }
 
     if (newbuffer == NULL) {
@@ -321,8 +296,8 @@ static int make_stream_space(parser_t *self, size_t nbytes) {
             ("make_stream_space: cap != self->words_cap, nbytes = %d, "
              "self->words_cap=%d\n",
              nbytes, self->words_cap))
-        newptr = safe_realloc((void *)self->word_starts,
-                              sizeof(int64_t) * self->words_cap);
+        newptr = realloc((void *)self->word_starts,
+                         sizeof(int64_t) * self->words_cap);
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
         } else {
@@ -349,8 +324,8 @@ static int make_stream_space(parser_t *self, size_t nbytes) {
     if (cap != self->lines_cap) {
         TRACE(("make_stream_space: cap != self->lines_cap, nbytes = %d\n",
                nbytes))
-        newptr = safe_realloc((void *)self->line_fields,
-                              sizeof(int64_t) * self->lines_cap);
+        newptr = realloc((void *)self->line_fields,
+                         sizeof(int64_t) * self->lines_cap);
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
         } else {
@@ -427,7 +402,7 @@ static void append_warning(parser_t *self, const char *msg) {
         snprintf(self->warn_msg, length + 1, "%s", msg);
     } else {
         ex_length = strlen(self->warn_msg);
-        newptr = safe_realloc(self->warn_msg, ex_length + length + 1);
+        newptr = realloc(self->warn_msg, ex_length + length + 1);
         if (newptr != NULL) {
             self->warn_msg = (char *)newptr;
             snprintf(self->warn_msg + ex_length, length + 1, "%s", msg);
@@ -672,8 +647,6 @@ static int parser_buffer_bytes(parser_t *self, size_t nbytes) {
 
 #define END_LINE() END_LINE_STATE(START_RECORD)
 
-#define IS_WHITESPACE(c) ((c == ' ' || c == '\t'))
-
 #define IS_TERMINATOR(c)                            \
     (c == line_terminator)
 
@@ -692,7 +665,7 @@ static int parser_buffer_bytes(parser_t *self, size_t nbytes) {
 // applied when in a field
 #define IS_DELIMITER(c)                                   \
     ((!self->delim_whitespace && c == self->delimiter) || \
-     (self->delim_whitespace && IS_WHITESPACE(c)))
+     (self->delim_whitespace && isblank(c)))
 
 #define _TOKEN_CLEANUP()                                                \
     self->stream_len = slen;                                            \
@@ -843,7 +816,7 @@ int tokenize_bytes(parser_t *self,
                     self->state = EAT_CRNL_NOP;
                     break;
                 } else if (!self->delim_whitespace) {
-                    if (IS_WHITESPACE(c) && c != self->delimiter) {
+                    if (isblank(c) && c != self->delimiter) {
                     } else {  // backtrack
                         // use i + 1 because buf has been incremented but not i
                         do {
@@ -873,7 +846,7 @@ int tokenize_bytes(parser_t *self,
                 } else if (IS_COMMENT_CHAR(c)) {
                     self->state = EAT_COMMENT;
                     break;
-                } else if (!IS_WHITESPACE(c)) {
+                } else if (!isblank(c)) {
                     self->state = START_FIELD;
                     // fall through to subsequent state
                 } else {
@@ -917,7 +890,7 @@ int tokenize_bytes(parser_t *self,
                 } else if (IS_COMMENT_CHAR(c)) {
                     self->state = EAT_LINE_COMMENT;
                     break;
-                } else if (IS_WHITESPACE(c)) {
+                } else if (isblank(c)) {
                     if (self->delim_whitespace) {
                         if (self->skip_empty_lines) {
                             self->state = WHITESPACE_LINE;
@@ -1290,13 +1263,13 @@ int parser_trim_buffers(parser_t *self) {
     new_cap = _next_pow2(self->words_len) + 1;
     if (new_cap < self->words_cap) {
         TRACE(("parser_trim_buffers: new_cap < self->words_cap\n"));
-        newptr = safe_realloc((void *)self->words, new_cap * sizeof(char *));
+        newptr = realloc((void *)self->words, new_cap * sizeof(char *));
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
         } else {
             self->words = (char **)newptr;
         }
-        newptr = safe_realloc((void *)self->word_starts,
+        newptr = realloc((void *)self->word_starts,
                               new_cap * sizeof(int64_t));
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
@@ -1315,13 +1288,13 @@ int parser_trim_buffers(parser_t *self) {
     if (new_cap < self->stream_cap) {
         TRACE(
             ("parser_trim_buffers: new_cap < self->stream_cap, calling "
-             "safe_realloc\n"));
-        newptr = safe_realloc((void *)self->stream, new_cap);
+             "realloc\n"));
+        newptr = realloc((void *)self->stream, new_cap);
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
         } else {
             // Update the pointers in the self->words array (char **) if
-            // `safe_realloc`
+            // `realloc`
             //  moved the `self->stream` buffer. This block mirrors a similar
             //  block in
             //  `make_stream_space`.
@@ -1342,14 +1315,14 @@ int parser_trim_buffers(parser_t *self) {
     new_cap = _next_pow2(self->lines) + 1;
     if (new_cap < self->lines_cap) {
         TRACE(("parser_trim_buffers: new_cap < self->lines_cap\n"));
-        newptr = safe_realloc((void *)self->line_start,
+        newptr = realloc((void *)self->line_start,
                               new_cap * sizeof(int64_t));
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
         } else {
             self->line_start = (int64_t *)newptr;
         }
-        newptr = safe_realloc((void *)self->line_fields,
+        newptr = realloc((void *)self->line_fields,
                               new_cap * sizeof(int64_t));
         if (newptr == NULL) {
             return PARSER_OUT_OF_MEMORY;
@@ -1426,42 +1399,30 @@ int tokenize_all_rows(parser_t *self) {
     return status;
 }
 
-PANDAS_INLINE void uppercase(char *p) {
-    for (; *p; ++p) *p = toupper_ascii(*p);
-}
-
+/*
+ * Function: to_boolean
+ * --------------------
+ *
+ * Validate if item should be recognized as a boolean field.
+ *
+ * item: const char* representing parsed text
+ * val : pointer to a uint8_t of boolean representation
+ *
+ * If item is determined to be boolean, this method will set
+ * the appropriate value of val and return 0. A non-zero exit
+ * status means that item was not inferred to be boolean, and
+ * leaves the value of *val unmodified.
+ */
 int to_boolean(const char *item, uint8_t *val) {
-    char *tmp;
-    int i, status = 0;
-    size_t length0 = (strlen(item) + 1);
-    int bufsize = length0;
-
-    static const char *tstrs[1] = {"TRUE"};
-    static const char *fstrs[1] = {"FALSE"};
-
-    tmp = malloc(bufsize);
-    snprintf(tmp,  length0, "%s", item);
-    uppercase(tmp);
-
-    for (i = 0; i < 1; ++i) {
-        if (strcmp(tmp, tstrs[i]) == 0) {
-            *val = 1;
-            goto done;
-        }
-    }
-
-    for (i = 0; i < 1; ++i) {
-        if (strcmp(tmp, fstrs[i]) == 0) {
-            *val = 0;
-            goto done;
-        }
+    if (strcasecmp(item, "TRUE") == 0) {
+      *val = 1;
+      return 0;
+    } else if (strcasecmp(item, "FALSE") == 0) {
+      *val = 0;
+      return 0;
     }
 
-    status = -1;
-
-done:
-    free(tmp);
-    return status;
+    return -1;
 }
 
 // ---------------------------------------------------------------------------
@@ -1813,11 +1774,18 @@ double precise_xstrtod(const char *str, char **endptr, char decimal,
 
 double round_trip(const char *p, char **q, char decimal, char sci, char tsep,
                   int skip_trailing, int *error, int *maybe_int) {
+    // This is called from a nogil block in parsers.pyx
+    // so need to explicitly get GIL before Python calls
+    PyGILState_STATE gstate;
+    gstate = PyGILState_Ensure();
+
     double r = PyOS_string_to_double(p, q, 0);
     if (maybe_int != NULL) *maybe_int = 0;
     if (PyErr_Occurred() != NULL) *error = -1;
     else if (r == Py_HUGE_VAL) *error = (int)Py_HUGE_VAL;
     PyErr_Clear();
+
+    PyGILState_Release(gstate);
     return r;
 }
 
diff --git a/pandas/_libs/src/parser/tokenizer.h b/pandas/_libs/src/parser/tokenizer.h
index 66ef1887d6bc3..4fd2065c07100 100644
--- a/pandas/_libs/src/parser/tokenizer.h
+++ b/pandas/_libs/src/parser/tokenizer.h
@@ -15,13 +15,13 @@ See LICENSE for the license
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 
-#define ERROR_OK 0
 #define ERROR_NO_DIGITS 1
 #define ERROR_OVERFLOW 2
 #define ERROR_INVALID_CHARS 3
 
 #include "../headers/stdint.h"
 #include "../inline_helper.h"
+#include "../headers/portable.h"
 
 #include "khash.h"
 
@@ -31,10 +31,6 @@ See LICENSE for the license
 #define CALLING_READ_FAILED 2
 
 
-#if defined(_MSC_VER)
-#define strtoll _strtoi64
-#endif  // _MSC_VER
-
 /*
 
   C flat file parsing low level code for pandas / NumPy
@@ -159,11 +155,8 @@ typedef struct parser_t {
     PyObject *skipfunc;
     int64_t skip_first_N_rows;
     int64_t skip_footer;
-    // pick one, depending on whether the converter requires GIL
-    double (*double_converter_nogil)(const char *, char **,
-                                     char, char, char, int);
-    double (*double_converter_withgil)(const char *, char **,
-                                       char, char, char, int);
+    double (*double_converter)(const char *, char **,
+                               char, char, char, int, int *, int *);
 
     // error handling
     char *warn_msg;
@@ -179,7 +172,6 @@ typedef struct coliter_t {
 } coliter_t;
 
 void coliter_setup(coliter_t *self, parser_t *parser, int i, int start);
-coliter_t *coliter_new(parser_t *self, int i);
 
 #define COLITER_NEXT(iter, word)                           \
     do {                                                   \
@@ -231,6 +223,8 @@ double xstrtod(const char *p, char **q, char decimal, char sci, char tsep,
 double precise_xstrtod(const char *p, char **q, char decimal,
                        char sci, char tsep, int skip_trailing,
                        int *error, int *maybe_int);
+
+// GH-15140 - round_trip requires and acquires the GIL on its own
 double round_trip(const char *p, char **q, char decimal, char sci, char tsep,
                   int skip_trailing, int *error, int *maybe_int);
 int to_boolean(const char *item, uint8_t *val);
diff --git a/pandas/_libs/src/skiplist.h b/pandas/_libs/src/skiplist.h
index 60c1a56727777..1679ced174f29 100644
--- a/pandas/_libs/src/skiplist.h
+++ b/pandas/_libs/src/skiplist.h
@@ -10,7 +10,7 @@ Flexibly-sized, index-able skiplist data structure for maintaining a sorted
 list of values
 
 Port of Wes McKinney's Cython version of Raymond Hettinger's original pure
-Python recipe (http://rhettinger.wordpress.com/2010/02/06/lost-knowledge/)
+Python recipe (https://rhettinger.wordpress.com/2010/02/06/lost-knowledge/)
 */
 
 #ifndef PANDAS__LIBS_SRC_SKIPLIST_H_
diff --git a/pandas/_libs/src/ujson/lib/ultrajson.h b/pandas/_libs/src/ujson/lib/ultrajson.h
index ee6e7081bf00e..b40ac9856d6a6 100644
--- a/pandas/_libs/src/ujson/lib/ultrajson.h
+++ b/pandas/_libs/src/ujson/lib/ultrajson.h
@@ -30,7 +30,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -154,6 +154,8 @@ enum JSTYPES {
   JT_ARRAY,    // Array structure
   JT_OBJECT,   // Key/Value structure
   JT_INVALID,  // Internal, do not return nor expect
+  JT_POS_INF,  // Positive infinity
+  JT_NEG_INF,  // Negative infinity
 };
 
 typedef void * JSOBJ;
@@ -244,6 +246,10 @@ typedef struct __JSONObjectEncoder {
   If true, '<', '>', and '&' characters will be encoded as \u003c, \u003e, and \u0026, respectively. If false, no special encoding will be used. */
   int encodeHTMLChars;
 
+  /*
+  Configuration for spaces of indent */
+  int indent;
+
   /*
   Set to an error message if error occurred */
   const char *errorMsg;
@@ -286,6 +292,8 @@ typedef struct __JSONObjectDecoder {
   JSOBJ (*newTrue)(void *prv);
   JSOBJ (*newFalse)(void *prv);
   JSOBJ (*newNull)(void *prv);
+  JSOBJ (*newPosInf)(void *prv);
+  JSOBJ (*newNegInf)(void *prv);
   JSOBJ (*newObject)(void *prv, void *decoder);
   JSOBJ (*endObject)(void *prv, JSOBJ obj);
   JSOBJ (*newArray)(void *prv, void *decoder);
diff --git a/pandas/_libs/src/ujson/lib/ultrajsondec.c b/pandas/_libs/src/ujson/lib/ultrajsondec.c
index a847b0f5d5102..36eb170f8048f 100644
--- a/pandas/_libs/src/ujson/lib/ultrajsondec.c
+++ b/pandas/_libs/src/ujson/lib/ultrajsondec.c
@@ -33,7 +33,7 @@ Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -127,9 +127,16 @@ FASTCALL_ATTR JSOBJ FASTCALL_MSVC decode_numeric(struct DecoderState *ds) {
 
     JSUINT64 overflowLimit = LLONG_MAX;
 
-    if (*(offset) == '-') {
+    if (*(offset) == 'I') {
+      goto DECODE_INF;
+    } else if (*(offset) == 'N') {
+      goto DECODE_NAN;
+    } else if (*(offset) == '-') {
         offset++;
         intNeg = -1;
+        if (*(offset) == 'I') {
+          goto DECODE_INF;
+        }
         overflowLimit = LLONG_MIN;
     }
 
@@ -150,7 +157,7 @@ FASTCALL_ATTR JSOBJ FASTCALL_MSVC decode_numeric(struct DecoderState *ds) {
             case '7':
             case '8':
             case '9': {
-                // FIXME: Check for arithemtic overflow here
+                // FIXME: Check for arithmetic overflow here
                 // PERF: Don't do 64-bit arithmetic here unless we know we have
                 // to
                 intValue = intValue * 10ULL + (JSLONG)(chr - 48);
@@ -235,7 +242,7 @@ FASTCALL_ATTR JSOBJ FASTCALL_MSVC decode_numeric(struct DecoderState *ds) {
     }
 
 BREAK_FRC_LOOP:
-    // FIXME: Check for arithemtic overflow here
+    // FIXME: Check for arithmetic overflow here
     ds->lastType = JT_DOUBLE;
     ds->start = offset;
     return ds->dec->newDouble(
@@ -281,8 +288,50 @@ FASTCALL_ATTR JSOBJ FASTCALL_MSVC decode_numeric(struct DecoderState *ds) {
         }
     }
 
+DECODE_NAN:
+    offset++;
+    if (*(offset++) != 'a') goto SET_NAN_ERROR;
+    if (*(offset++) != 'N') goto SET_NAN_ERROR;
+
+    ds->lastType = JT_NULL;
+    ds->start = offset;
+    return ds->dec->newNull(ds->prv);
+
+SET_NAN_ERROR:
+    return SetError(ds, -1, "Unexpected character found when decoding 'NaN'");
+
+DECODE_INF:
+    offset++;
+    if (*(offset++) != 'n') goto SET_INF_ERROR;
+    if (*(offset++) != 'f') goto SET_INF_ERROR;
+    if (*(offset++) != 'i') goto SET_INF_ERROR;
+    if (*(offset++) != 'n') goto SET_INF_ERROR;
+    if (*(offset++) != 'i') goto SET_INF_ERROR;
+    if (*(offset++) != 't') goto SET_INF_ERROR;
+    if (*(offset++) != 'y') goto SET_INF_ERROR;
+
+    ds->start = offset;
+
+    if (intNeg == 1) {
+      ds->lastType = JT_POS_INF;
+      return ds->dec->newPosInf(ds->prv);
+    } else {
+      ds->lastType = JT_NEG_INF;
+      return ds->dec->newNegInf(ds->prv);
+    }
+
+SET_INF_ERROR:
+    if (intNeg == 1) {
+      const char *msg = "Unexpected character found when decoding 'Infinity'";
+      return SetError(ds, -1, msg);
+    } else {
+      const char *msg = "Unexpected character found when decoding '-Infinity'";
+      return SetError(ds, -1, msg);
+    }
+
+
 BREAK_EXP_LOOP:
-    // FIXME: Check for arithemtic overflow here
+    // FIXME: Check for arithmetic overflow here
     ds->lastType = JT_DOUBLE;
     ds->start = offset;
     return ds->dec->newDouble(
@@ -1070,6 +1119,8 @@ FASTCALL_ATTR JSOBJ FASTCALL_MSVC decode_any(struct DecoderState *ds) {
             case '7':
             case '8':
             case '9':
+            case 'I':
+            case 'N':
             case '-':
                 return decode_numeric(ds);
 
diff --git a/pandas/_libs/src/ujson/lib/ultrajsonenc.c b/pandas/_libs/src/ujson/lib/ultrajsonenc.c
index d5b379bee585b..065e3b2c60cf9 100644
--- a/pandas/_libs/src/ujson/lib/ultrajsonenc.c
+++ b/pandas/_libs/src/ujson/lib/ultrajsonenc.c
@@ -33,7 +33,7 @@ Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -728,6 +728,22 @@ FASTCALL_ATTR INLINE_PREFIX void FASTCALL_MSVC strreverse(char *begin,
     while (end > begin) aux = *end, *end-- = *begin, *begin++ = aux;
 }
 
+void Buffer_AppendIndentNewlineUnchecked(JSONObjectEncoder *enc)
+{
+  if (enc->indent > 0) Buffer_AppendCharUnchecked(enc, '\n');
+}
+
+// This function could be refactored to only accept enc as an argument,
+// but this is a straight vendor from ujson source
+void Buffer_AppendIndentUnchecked(JSONObjectEncoder *enc, JSINT32 value)
+{
+  int i;
+  if (enc->indent > 0)
+    while (value-- > 0)
+      for (i = 0; i < enc->indent; i++)
+        Buffer_AppendCharUnchecked(enc, ' ');
+}
+
 void Buffer_AppendIntUnchecked(JSONObjectEncoder *enc, JSINT32 value) {
     char *wstr;
     JSUINT32 uvalue = (value < 0) ? -value : value;
@@ -960,6 +976,7 @@ void encode(JSOBJ obj, JSONObjectEncoder *enc, const char *name,
             enc->iterBegin(obj, &tc);
 
             Buffer_AppendCharUnchecked(enc, '[');
+            Buffer_AppendIndentNewlineUnchecked (enc);
 
             while (enc->iterNext(obj, &tc)) {
                 if (count > 0) {
@@ -967,17 +984,20 @@ void encode(JSOBJ obj, JSONObjectEncoder *enc, const char *name,
 #ifndef JSON_NO_EXTRA_WHITESPACE
                     Buffer_AppendCharUnchecked(buffer, ' ');
 #endif
+                    Buffer_AppendIndentNewlineUnchecked (enc);
                 }
 
                 iterObj = enc->iterGetValue(obj, &tc);
 
                 enc->level++;
+                Buffer_AppendIndentUnchecked (enc, enc->level);
                 encode(iterObj, enc, NULL, 0);
                 count++;
             }
 
             enc->iterEnd(obj, &tc);
-            Buffer_Reserve(enc, 2);
+            Buffer_AppendIndentNewlineUnchecked (enc);
+            Buffer_AppendIndentUnchecked (enc, enc->level);
             Buffer_AppendCharUnchecked(enc, ']');
             break;
         }
@@ -987,6 +1007,7 @@ void encode(JSOBJ obj, JSONObjectEncoder *enc, const char *name,
             enc->iterBegin(obj, &tc);
 
             Buffer_AppendCharUnchecked(enc, '{');
+            Buffer_AppendIndentNewlineUnchecked (enc);
 
             while (enc->iterNext(obj, &tc)) {
                 if (count > 0) {
@@ -994,18 +1015,21 @@ void encode(JSOBJ obj, JSONObjectEncoder *enc, const char *name,
 #ifndef JSON_NO_EXTRA_WHITESPACE
                     Buffer_AppendCharUnchecked(enc, ' ');
 #endif
+                    Buffer_AppendIndentNewlineUnchecked (enc);
                 }
 
                 iterObj = enc->iterGetValue(obj, &tc);
                 objName = enc->iterGetName(obj, &tc, &szlen);
 
                 enc->level++;
+                Buffer_AppendIndentUnchecked (enc, enc->level);
                 encode(iterObj, enc, objName, szlen);
                 count++;
             }
 
             enc->iterEnd(obj, &tc);
-            Buffer_Reserve(enc, 2);
+            Buffer_AppendIndentNewlineUnchecked (enc);
+            Buffer_AppendIndentUnchecked (enc, enc->level);
             Buffer_AppendCharUnchecked(enc, '}');
             break;
         }
diff --git a/pandas/_libs/src/ujson/python/JSONtoObj.c b/pandas/_libs/src/ujson/python/JSONtoObj.c
index 7a2e5a584443a..3db10237b2688 100644
--- a/pandas/_libs/src/ujson/python/JSONtoObj.c
+++ b/pandas/_libs/src/ujson/python/JSONtoObj.c
@@ -30,7 +30,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -459,6 +459,10 @@ JSOBJ Object_newFalse(void *prv) { Py_RETURN_FALSE; }
 
 JSOBJ Object_newNull(void *prv) { Py_RETURN_NONE; }
 
+JSOBJ Object_newPosInf(void *prv) { return PyFloat_FromDouble(Py_HUGE_VAL); }
+
+JSOBJ Object_newNegInf(void *prv) { return PyFloat_FromDouble(-Py_HUGE_VAL); }
+
 JSOBJ Object_newObject(void *prv, void *decoder) { return PyDict_New(); }
 
 JSOBJ Object_endObject(void *prv, JSOBJ obj) { return obj; }
@@ -502,10 +506,11 @@ PyObject *JSONToObj(PyObject *self, PyObject *args, PyObject *kwargs) {
     JSONObjectDecoder dec = {
         Object_newString, Object_objectAddKey,  Object_arrayAddItem,
         Object_newTrue,   Object_newFalse,      Object_newNull,
-        Object_newObject, Object_endObject,     Object_newArray,
-        Object_endArray,  Object_newInteger,    Object_newLong,
-        Object_newDouble, Object_releaseObject, PyObject_Malloc,
-        PyObject_Free,    PyObject_Realloc};
+        Object_newPosInf, Object_newNegInf,     Object_newObject,
+        Object_endObject,     Object_newArray,  Object_endArray,
+        Object_newInteger,    Object_newLong,   Object_newDouble,
+        Object_releaseObject, PyObject_Malloc, PyObject_Free,
+        PyObject_Realloc};
 
     dec.preciseFloat = 0;
     dec.prv = NULL;
diff --git a/pandas/_libs/src/ujson/python/date_conversions.c b/pandas/_libs/src/ujson/python/date_conversions.c
new file mode 100644
index 0000000000000..fc4bdef8463af
--- /dev/null
+++ b/pandas/_libs/src/ujson/python/date_conversions.c
@@ -0,0 +1,118 @@
+// Conversion routines that are useful for serialization,
+// but which don't interact with JSON objects directly
+
+#include "date_conversions.h"
+#include <../../../tslibs/src/datetime/np_datetime.h>
+#include <../../../tslibs/src/datetime/np_datetime_strings.h>
+
+/*
+ * Function: scaleNanosecToUnit
+ * -----------------------------
+ *
+ * Scales an integer value representing time in nanoseconds to provided unit.
+ *
+ * Mutates the provided value directly. Returns 0 on success, non-zero on error.
+ */
+int scaleNanosecToUnit(npy_int64 *value, NPY_DATETIMEUNIT unit) {
+    switch (unit) {
+    case NPY_FR_ns:
+        break;
+    case NPY_FR_us:
+        *value /= 1000LL;
+        break;
+    case NPY_FR_ms:
+        *value /= 1000000LL;
+        break;
+    case NPY_FR_s:
+        *value /= 1000000000LL;
+        break;
+    default:
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Converts the int64_t representation of a datetime to ISO; mutates len */
+char *int64ToIso(int64_t value, NPY_DATETIMEUNIT base, size_t *len) {
+    npy_datetimestruct dts;
+    int ret_code;
+
+    pandas_datetime_to_datetimestruct(value, NPY_FR_ns, &dts);
+
+    *len = (size_t)get_datetime_iso_8601_strlen(0, base);
+    char *result = PyObject_Malloc(*len);
+
+    if (result == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    ret_code = make_iso_8601_datetime(&dts, result, *len, base);
+    if (ret_code != 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Could not convert datetime value to string");
+        PyObject_Free(result);
+    }
+
+    // Note that get_datetime_iso_8601_strlen just gives a generic size
+    // for ISO string conversion, not the actual size used
+    *len = strlen(result);
+    return result;
+}
+
+npy_datetime NpyDateTimeToEpoch(npy_datetime dt, NPY_DATETIMEUNIT base) {
+    scaleNanosecToUnit(&dt, base);
+    return dt;
+}
+
+/* Convert PyDatetime To ISO C-string. mutates len */
+char *PyDateTimeToIso(PyDateTime_Date *obj, NPY_DATETIMEUNIT base,
+                      size_t *len) {
+    npy_datetimestruct dts;
+    int ret;
+
+    ret = convert_pydatetime_to_datetimestruct(obj, &dts);
+    if (ret != 0) {
+        if (!PyErr_Occurred()) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Could not convert PyDateTime to numpy datetime");
+        }
+        return NULL;
+    }
+
+    *len = (size_t)get_datetime_iso_8601_strlen(0, base);
+    char *result = PyObject_Malloc(*len);
+    ret = make_iso_8601_datetime(&dts, result, *len, base);
+
+    if (ret != 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Could not convert datetime value to string");
+        PyObject_Free(result);
+        return NULL;
+    }
+
+    // Note that get_datetime_iso_8601_strlen just gives a generic size
+    // for ISO string conversion, not the actual size used
+    *len = strlen(result);
+    return result;
+}
+
+npy_datetime PyDateTimeToEpoch(PyDateTime_Date *dt, NPY_DATETIMEUNIT base) {
+    npy_datetimestruct dts;
+    int ret;
+
+    ret = convert_pydatetime_to_datetimestruct(dt, &dts);
+    if (ret != 0) {
+        if (!PyErr_Occurred()) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Could not convert PyDateTime to numpy datetime");
+        }
+        // TODO: is setting errMsg required?
+        //((JSONObjectEncoder *)tc->encoder)->errorMsg = "";
+        // return NULL;
+    }
+
+    npy_datetime npy_dt = npy_datetimestruct_to_datetime(NPY_FR_ns, &dts);
+    return NpyDateTimeToEpoch(npy_dt, base);
+}
diff --git a/pandas/_libs/src/ujson/python/date_conversions.h b/pandas/_libs/src/ujson/python/date_conversions.h
new file mode 100644
index 0000000000000..45455f4d6128b
--- /dev/null
+++ b/pandas/_libs/src/ujson/python/date_conversions.h
@@ -0,0 +1,31 @@
+#ifndef PANDAS__LIBS_SRC_UJSON_DATE_CONVERSIONS
+#define PANDAS__LIBS_SRC_UJSON_DATE_CONVERSIONS
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <numpy/ndarraytypes.h>
+#include "datetime.h"
+
+// Scales value inplace from nanosecond resolution to unit resolution
+int scaleNanosecToUnit(npy_int64 *value, NPY_DATETIMEUNIT unit);
+
+// Converts an int64 object representing a date to ISO format
+// up to precision `base` e.g. base="s" yields 2020-01-03T00:00:00Z
+// while base="ns" yields "2020-01-01T00:00:00.000000000Z"
+// len is mutated to save the length of the returned string
+char *int64ToIso(int64_t value, NPY_DATETIMEUNIT base, size_t *len);
+
+// TODO: this function doesn't do a lot; should augment or replace with
+// scaleNanosecToUnit
+npy_datetime NpyDateTimeToEpoch(npy_datetime dt, NPY_DATETIMEUNIT base);
+
+// Converts a Python object representing a Date / Datetime to ISO format
+// up to precision `base` e.g. base="s" yields 2020-01-03T00:00:00Z
+// while base="ns" yields "2020-01-01T00:00:00.000000000Z"
+// len is mutated to save the length of the returned string
+char *PyDateTimeToIso(PyDateTime_Date *obj, NPY_DATETIMEUNIT base, size_t *len);
+
+// Convert a Python Date/Datetime to Unix epoch with resolution base
+npy_datetime PyDateTimeToEpoch(PyDateTime_Date *dt, NPY_DATETIMEUNIT base);
+
+#endif
diff --git a/pandas/_libs/src/ujson/python/objToJSON.c b/pandas/_libs/src/ujson/python/objToJSON.c
index dc9b906c8d76c..8cfc20ffd2c1c 100644
--- a/pandas/_libs/src/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/ujson/python/objToJSON.c
@@ -31,7 +31,7 @@ Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights
 reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -45,8 +45,7 @@ Numeric decoder derived from from TCL library
 #include <numpy/ndarraytypes.h>
 #include <numpy/npy_math.h>
 #include <ultrajson.h>
-#include <../../../tslibs/src/datetime/np_datetime.h>
-#include <../../../tslibs/src/datetime/np_datetime_strings.h>
+#include "date_conversions.h"
 #include "datetime.h"
 
 static PyTypeObject *type_decimal;
@@ -54,13 +53,13 @@ static PyTypeObject *cls_dataframe;
 static PyTypeObject *cls_series;
 static PyTypeObject *cls_index;
 static PyTypeObject *cls_nat;
-PyObject *cls_timestamp;
+static PyTypeObject *cls_na;
 PyObject *cls_timedelta;
 
 npy_int64 get_nat(void) { return NPY_MIN_INT64; }
 
-typedef void *(*PFN_PyTypeToJSON)(JSOBJ obj, JSONTypeContext *ti,
-                                  void *outValue, size_t *_outLen);
+typedef char *(*PFN_PyTypeToUTF8)(JSOBJ obj, JSONTypeContext *ti,
+                                  size_t *_outLen);
 
 typedef struct __NpyArrContext {
     PyObject *array;
@@ -94,7 +93,7 @@ typedef struct __TypeContext {
     JSPFN_ITERNEXT iterNext;
     JSPFN_ITERGETNAME iterGetName;
     JSPFN_ITERGETVALUE iterGetValue;
-    PFN_PyTypeToJSON PyTypeToJSON;
+    PFN_PyTypeToUTF8 PyTypeToUTF8;
     PyObject *newObj;
     PyObject *dictObj;
     Py_ssize_t index;
@@ -129,7 +128,6 @@ typedef struct __PyObjectEncoder {
     // pass-through to encode numpy data directly
     int npyType;
     void *npyValue;
-    TypeContext basicTypeContext;
 
     int datetimeIso;
     NPY_DATETIMEUNIT datetimeUnit;
@@ -152,6 +150,7 @@ int PdBlock_iterNext(JSOBJ, JSONTypeContext *);
 void *initObjToJSON(void) {
     PyObject *mod_pandas;
     PyObject *mod_nattype;
+    PyObject *mod_natype;
     PyObject *mod_decimal = PyImport_ImportModule("decimal");
     type_decimal =
         (PyTypeObject *)PyObject_GetAttrString(mod_decimal, "Decimal");
@@ -166,7 +165,6 @@ void *initObjToJSON(void) {
         cls_index = (PyTypeObject *)PyObject_GetAttrString(mod_pandas, "Index");
         cls_series =
             (PyTypeObject *)PyObject_GetAttrString(mod_pandas, "Series");
-        cls_timestamp = PyObject_GetAttrString(mod_pandas, "Timestamp");
         cls_timedelta = PyObject_GetAttrString(mod_pandas, "Timedelta");
         Py_DECREF(mod_pandas);
     }
@@ -178,9 +176,16 @@ void *initObjToJSON(void) {
         Py_DECREF(mod_nattype);
     }
 
-    /* Initialise numpy API and use 2/3 compatible return */
+    mod_natype = PyImport_ImportModule("pandas._libs.missing");
+    if (mod_natype) {
+        cls_na = (PyTypeObject *)PyObject_GetAttrString(mod_natype, "NAType");
+        Py_DECREF(mod_natype);
+    }
+
+    /* Initialise numpy API */
     import_array();
-    return NUMPY_IMPORT_ARRAY_RETVAL;
+    // GH 31463
+    return NULL;
 }
 
 static TypeContext *createTypeContext(void) {
@@ -212,85 +217,42 @@ static TypeContext *createTypeContext(void) {
     return pc;
 }
 
-static int is_sparse_array(PyObject *obj) {
-    // TODO can be removed again once SparseArray.values is removed (GH26421)
-    if (PyObject_HasAttrString(obj, "_subtyp")) {
-        PyObject *_subtype = PyObject_GetAttrString(obj, "_subtyp");
-        PyObject *sparse_array = PyUnicode_FromString("sparse_array");
-        int ret = PyUnicode_Compare(_subtype, sparse_array);
-
-        if (ret == 0) {
-            return 1;
-        }
-    }
-    return 0;
-}
-
 static PyObject *get_values(PyObject *obj) {
     PyObject *values = NULL;
 
-    if (!is_sparse_array(obj)) {
-        values = PyObject_GetAttrString(obj, "values");
-        PRINTMARK();
-    }
-
-    if (values && !PyArray_CheckExact(values)) {
-
-        if (PyObject_HasAttrString(values, "to_numpy")) {
-            values = PyObject_CallMethod(values, "to_numpy", NULL);
-        }
-
-        if (!is_sparse_array(values) &&
-            PyObject_HasAttrString(values, "values")) {
-            PyObject *subvals = get_values(values);
-            PyErr_Clear();
-            PRINTMARK();
-            // subvals are sometimes missing a dimension
-            if (subvals) {
-                PyArrayObject *reshape = (PyArrayObject *)subvals;
-                PyObject *shape = PyObject_GetAttrString(obj, "shape");
-                PyArray_Dims dims;
-                PRINTMARK();
-
-                if (!shape || !PyArray_IntpConverter(shape, &dims)) {
-                    subvals = NULL;
-                } else {
-                    subvals = PyArray_Newshape(reshape, &dims, NPY_ANYORDER);
-                    PyDimMem_FREE(dims.ptr);
-                }
-                Py_DECREF(reshape);
-                Py_XDECREF(shape);
-            }
-            Py_DECREF(values);
-            values = subvals;
-        } else {
-            PRINTMARK();
-            Py_DECREF(values);
-            values = NULL;
-        }
-    }
+    PRINTMARK();
 
-    if (!values && PyObject_HasAttrString(obj, "_internal_get_values")) {
+    if (PyObject_HasAttrString(obj, "_internal_get_values")) {
         PRINTMARK();
         values = PyObject_CallMethod(obj, "_internal_get_values", NULL);
-        if (values && !PyArray_CheckExact(values)) {
+
+        if (values == NULL) {
+            // Clear so we can subsequently try another method
+            PyErr_Clear();
+        } else if (!PyArray_CheckExact(values)) {
+            // Didn't get a numpy array, so keep trying
             PRINTMARK();
             Py_DECREF(values);
             values = NULL;
         }
     }
 
-    if (!values && PyObject_HasAttrString(obj, "get_block_values")) {
+    if ((values == NULL) && PyObject_HasAttrString(obj, "get_block_values")) {
         PRINTMARK();
         values = PyObject_CallMethod(obj, "get_block_values", NULL);
-        if (values && !PyArray_CheckExact(values)) {
+
+        if (values == NULL) {
+            // Clear so we can subsequently try another method
+            PyErr_Clear();
+        } else if (!PyArray_CheckExact(values)) {
+            // Didn't get a numpy array, so keep trying
             PRINTMARK();
             Py_DECREF(values);
             values = NULL;
         }
     }
 
-    if (!values) {
+    if (values == NULL) {
         PyObject *typeRepr = PyObject_Repr((PyObject *)Py_TYPE(obj));
         PyObject *repr;
         PRINTMARK();
@@ -385,161 +347,39 @@ static PyObject *get_item(PyObject *obj, Py_ssize_t i) {
     return ret;
 }
 
-static void *CDouble(JSOBJ obj, JSONTypeContext *tc, void *outValue,
-                     size_t *_outLen) {
-    PRINTMARK();
-    *((double *)outValue) = GET_TC(tc)->doubleValue;
-    return NULL;
-}
-
-static void *CLong(JSOBJ obj, JSONTypeContext *tc, void *outValue,
-                   size_t *_outLen) {
-    PRINTMARK();
-    *((JSINT64 *)outValue) = GET_TC(tc)->longValue;
-    return NULL;
-}
-
-#ifdef _LP64
-static void *PyIntToINT64(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                          size_t *_outLen) {
-    PyObject *obj = (PyObject *)_obj;
-    *((JSINT64 *)outValue) = PyLong_AsLong(obj);
-    return NULL;
-}
-#else
-static void *PyIntToINT32(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                          size_t *_outLen) {
-    PyObject *obj = (PyObject *)_obj;
-    *((JSINT32 *)outValue) = PyLong_AsLong(obj);
-    return NULL;
-}
-#endif
-
-static void *PyLongToINT64(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
+static char *PyBytesToUTF8(JSOBJ _obj, JSONTypeContext *Py_UNUSED(tc),
                            size_t *_outLen) {
-    *((JSINT64 *)outValue) = GET_TC(tc)->longValue;
-    return NULL;
-}
-
-static void *NpyFloatToDOUBLE(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                              size_t *_outLen) {
-    PyObject *obj = (PyObject *)_obj;
-    PyArray_CastScalarToCtype(obj, outValue, PyArray_DescrFromType(NPY_DOUBLE));
-    return NULL;
-}
-
-static void *PyFloatToDOUBLE(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                             size_t *_outLen) {
-    PyObject *obj = (PyObject *)_obj;
-    *((double *)outValue) = PyFloat_AsDouble(obj);
-    return NULL;
-}
-
-static void *PyBytesToUTF8(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                            size_t *_outLen) {
     PyObject *obj = (PyObject *)_obj;
     *_outLen = PyBytes_GET_SIZE(obj);
     return PyBytes_AS_STRING(obj);
 }
 
-static void *PyUnicodeToUTF8(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
+static char *PyUnicodeToUTF8(JSOBJ _obj, JSONTypeContext *Py_UNUSED(tc),
                              size_t *_outLen) {
-    PyObject *obj, *newObj;
-    obj = (PyObject *)_obj;
-
-    if (PyUnicode_IS_COMPACT_ASCII(obj)) {
-        Py_ssize_t len;
-        char *data = (char *)PyUnicode_AsUTF8AndSize(obj, &len);
-        *_outLen = len;
-        return data;
-    }
-
-    newObj = PyUnicode_AsUTF8String(obj);
-
-    GET_TC(tc)->newObj = newObj;
-
-    *_outLen = PyBytes_GET_SIZE(newObj);
-    return PyBytes_AS_STRING(newObj);
+    return (char *)PyUnicode_AsUTF8AndSize(_obj, (Py_ssize_t *)_outLen);
 }
 
-static void *PandasDateTimeStructToJSON(npy_datetimestruct *dts,
-                                        JSONTypeContext *tc, void *outValue,
-                                        size_t *_outLen) {
+/* JSON callback. returns a char* and mutates the pointer to *len */
+static char *NpyDateTimeToIsoCallback(JSOBJ Py_UNUSED(unused),
+                                      JSONTypeContext *tc, size_t *len) {
     NPY_DATETIMEUNIT base = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
-
-    if (((PyObjectEncoder *)tc->encoder)->datetimeIso) {
-        PRINTMARK();
-        *_outLen = (size_t)get_datetime_iso_8601_strlen(0, base);
-        GET_TC(tc)->cStr = PyObject_Malloc(sizeof(char) * (*_outLen));
-        if (!GET_TC(tc)->cStr) {
-            PyErr_NoMemory();
-            ((JSONObjectEncoder *)tc->encoder)->errorMsg = "";
-            return NULL;
-        }
-
-        if (!make_iso_8601_datetime(dts, GET_TC(tc)->cStr, *_outLen, base)) {
-            PRINTMARK();
-            *_outLen = strlen(GET_TC(tc)->cStr);
-            return GET_TC(tc)->cStr;
-        } else {
-            PRINTMARK();
-            PyErr_SetString(PyExc_ValueError,
-                            "Could not convert datetime value to string");
-            ((JSONObjectEncoder *)tc->encoder)->errorMsg = "";
-            PyObject_Free(GET_TC(tc)->cStr);
-            return NULL;
-        }
-    } else {
-        PRINTMARK();
-        *((JSINT64 *)outValue) = npy_datetimestruct_to_datetime(base, dts);
-        return NULL;
-    }
+    return int64ToIso(GET_TC(tc)->longValue, base, len);
 }
 
-static void *NpyDateTimeScalarToJSON(JSOBJ _obj, JSONTypeContext *tc,
-                                     void *outValue, size_t *_outLen) {
-    npy_datetimestruct dts;
-    PyDatetimeScalarObject *obj = (PyDatetimeScalarObject *)_obj;
-    PRINTMARK();
-    // TODO(anyone): Does not appear to be reached in tests.
-
-    pandas_datetime_to_datetimestruct(obj->obval,
-                                      (NPY_DATETIMEUNIT)obj->obmeta.base, &dts);
-    return PandasDateTimeStructToJSON(&dts, tc, outValue, _outLen);
-}
-
-static void *PyDateTimeToJSON(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                              size_t *_outLen) {
-    npy_datetimestruct dts;
-    PyDateTime_Date *obj = (PyDateTime_Date *)_obj;
-
-    PRINTMARK();
+/* JSON callback */
+static char *PyDateTimeToIsoCallback(JSOBJ obj, JSONTypeContext *tc,
+                                     size_t *len) {
 
-    if (!convert_pydatetime_to_datetimestruct(obj, &dts)) {
-        PRINTMARK();
-        return PandasDateTimeStructToJSON(&dts, tc, outValue, _outLen);
-    } else {
-        if (!PyErr_Occurred()) {
-            PyErr_SetString(PyExc_ValueError,
-                            "Could not convert datetime value to string");
-        }
-        ((JSONObjectEncoder *)tc->encoder)->errorMsg = "";
+    if (!PyDate_Check(obj)) {
+        PyErr_SetString(PyExc_TypeError, "Expected date object");
         return NULL;
     }
-}
 
-static void *NpyDatetime64ToJSON(JSOBJ _obj, JSONTypeContext *tc,
-                                 void *outValue, size_t *_outLen) {
-    npy_datetimestruct dts;
-    PRINTMARK();
-
-    pandas_datetime_to_datetimestruct((npy_datetime)GET_TC(tc)->longValue,
-                                      NPY_FR_ns, &dts);
-    return PandasDateTimeStructToJSON(&dts, tc, outValue, _outLen);
+    NPY_DATETIMEUNIT base = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+    return PyDateTimeToIso(obj, base, len);
 }
 
-static void *PyTimeToJSON(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
-                          size_t *outLen) {
+static char *PyTimeToJSON(JSOBJ _obj, JSONTypeContext *tc, size_t *outLen) {
     PyObject *obj = (PyObject *)_obj;
     PyObject *str;
     PyObject *tmp;
@@ -563,81 +403,15 @@ static void *PyTimeToJSON(JSOBJ _obj, JSONTypeContext *tc, void *outValue,
     GET_TC(tc)->newObj = str;
 
     *outLen = PyBytes_GET_SIZE(str);
-    outValue = (void *)PyBytes_AS_STRING(str);
+    char *outValue = PyBytes_AS_STRING(str);
     return outValue;
 }
 
-static int NpyTypeToJSONType(PyObject *obj, JSONTypeContext *tc, int npyType,
-                             void *value) {
-    PyArray_VectorUnaryFunc *castfunc;
-    npy_double doubleVal;
-    npy_int64 longVal;
-
-    if (PyTypeNum_ISFLOAT(npyType)) {
-        PRINTMARK();
-        castfunc =
-            PyArray_GetCastFunc(PyArray_DescrFromType(npyType), NPY_DOUBLE);
-        if (!castfunc) {
-            PyErr_Format(PyExc_ValueError,
-                         "Cannot cast numpy dtype %d to double", npyType);
-        }
-        castfunc(value, &doubleVal, 1, NULL, NULL);
-        if (npy_isnan(doubleVal) || npy_isinf(doubleVal)) {
-            PRINTMARK();
-            return JT_NULL;
-        }
-        GET_TC(tc)->doubleValue = (double)doubleVal;
-        GET_TC(tc)->PyTypeToJSON = CDouble;
-        return JT_DOUBLE;
-    }
-
-    if (PyTypeNum_ISDATETIME(npyType)) {
-        PRINTMARK();
-        castfunc =
-            PyArray_GetCastFunc(PyArray_DescrFromType(npyType), NPY_INT64);
-        if (!castfunc) {
-            PyErr_Format(PyExc_ValueError, "Cannot cast numpy dtype %d to long",
-                         npyType);
-        }
-        castfunc(value, &longVal, 1, NULL, NULL);
-        if (longVal == get_nat()) {
-            PRINTMARK();
-            return JT_NULL;
-        }
-        GET_TC(tc)->longValue = (JSINT64)longVal;
-        GET_TC(tc)->PyTypeToJSON = NpyDatetime64ToJSON;
-        return ((PyObjectEncoder *)tc->encoder)->datetimeIso ? JT_UTF8
-                                                             : JT_LONG;
-    }
-
-    if (PyTypeNum_ISINTEGER(npyType)) {
-        PRINTMARK();
-        castfunc =
-            PyArray_GetCastFunc(PyArray_DescrFromType(npyType), NPY_INT64);
-        if (!castfunc) {
-            PyErr_Format(PyExc_ValueError, "Cannot cast numpy dtype %d to long",
-                         npyType);
-        }
-        castfunc(value, &longVal, 1, NULL, NULL);
-        GET_TC(tc)->longValue = (JSINT64)longVal;
-        GET_TC(tc)->PyTypeToJSON = CLong;
-        return JT_LONG;
-    }
-
-    if (PyTypeNum_ISBOOL(npyType)) {
-        PRINTMARK();
-        return *((npy_bool *)value) == NPY_TRUE ? JT_TRUE : JT_FALSE;
-    }
-
-    PRINTMARK();
-    return JT_INVALID;
-}
-
 //=============================================================================
 // Numpy array iteration functions
 //=============================================================================
 
-static void NpyArr_freeItemValue(JSOBJ _obj, JSONTypeContext *tc) {
+static void NpyArr_freeItemValue(JSOBJ Py_UNUSED(_obj), JSONTypeContext *tc) {
     if (GET_TC(tc)->npyarr &&
         GET_TC(tc)->itemValue != GET_TC(tc)->npyarr->array) {
         PRINTMARK();
@@ -646,7 +420,9 @@ static void NpyArr_freeItemValue(JSOBJ _obj, JSONTypeContext *tc) {
     }
 }
 
-int NpyArr_iterNextNone(JSOBJ _obj, JSONTypeContext *tc) { return 0; }
+int NpyArr_iterNextNone(JSOBJ Py_UNUSED(_obj), JSONTypeContext *Py_UNUSED(tc)) {
+    return 0;
+}
 
 void NpyArr_iterBegin(JSOBJ _obj, JSONTypeContext *tc) {
     PyArrayObject *obj;
@@ -703,7 +479,10 @@ void NpyArr_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
     }
 }
 
-void NpyArrPassThru_iterBegin(JSOBJ obj, JSONTypeContext *tc) { PRINTMARK(); }
+void NpyArrPassThru_iterBegin(JSOBJ Py_UNUSED(obj),
+                              JSONTypeContext *Py_UNUSED(tc)) {
+    PRINTMARK();
+}
 
 void NpyArrPassThru_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
     NpyArrContext *npyarr = GET_TC(tc)->npyarr;
@@ -782,12 +561,13 @@ int NpyArr_iterNext(JSOBJ _obj, JSONTypeContext *tc) {
     return 1;
 }
 
-JSOBJ NpyArr_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ NpyArr_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PRINTMARK();
     return GET_TC(tc)->itemValue;
 }
 
-char *NpyArr_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *NpyArr_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                         size_t *outLen) {
     NpyArrContext *npyarr = GET_TC(tc)->npyarr;
     npy_intp idx;
     PRINTMARK();
@@ -841,7 +621,8 @@ int PdBlock_iterNextItem(JSOBJ obj, JSONTypeContext *tc) {
     return NpyArr_iterNextItem(obj, tc);
 }
 
-char *PdBlock_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *PdBlock_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                          size_t *outLen) {
     PdBlockContext *blkCtxt = GET_TC(tc)->pdblock;
     NpyArrContext *npyarr = blkCtxt->npyCtxts[0];
     npy_intp idx;
@@ -863,7 +644,7 @@ char *PdBlock_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
     return cStr;
 }
 
-char *PdBlock_iterGetName_Transpose(JSOBJ obj, JSONTypeContext *tc,
+char *PdBlock_iterGetName_Transpose(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
                                     size_t *outLen) {
     PdBlockContext *blkCtxt = GET_TC(tc)->pdblock;
     NpyArrContext *npyarr = blkCtxt->npyCtxts[blkCtxt->colIdx];
@@ -909,7 +690,7 @@ int PdBlock_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void PdBlockPassThru_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void PdBlockPassThru_iterBegin(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PdBlockContext *blkCtxt = GET_TC(tc)->pdblock;
     PRINTMARK();
 
@@ -1141,26 +922,27 @@ int Tuple_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void Tuple_iterEnd(JSOBJ obj, JSONTypeContext *tc) {}
+void Tuple_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc)) {}
 
-JSOBJ Tuple_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Tuple_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *Tuple_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Tuple_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc),
+                        size_t *Py_UNUSED(outLen)) {
     return NULL;
 }
 
 //=============================================================================
-// Iterator iteration functions
+// Set iteration functions
 // itemValue is borrowed reference, no ref counting
 //=============================================================================
-void Iter_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void Set_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
     GET_TC(tc)->itemValue = NULL;
     GET_TC(tc)->iterator = PyObject_GetIter(obj);
 }
 
-int Iter_iterNext(JSOBJ obj, JSONTypeContext *tc) {
+int Set_iterNext(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObject *item;
 
     if (GET_TC(tc)->itemValue) {
@@ -1178,7 +960,7 @@ int Iter_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void Iter_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
+void Set_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     if (GET_TC(tc)->itemValue) {
         Py_DECREF(GET_TC(tc)->itemValue);
         GET_TC(tc)->itemValue = NULL;
@@ -1190,11 +972,12 @@ void Iter_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
     }
 }
 
-JSOBJ Iter_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Set_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *Iter_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Set_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc),
+                       size_t *Py_UNUSED(outLen)) {
     return NULL;
 }
 
@@ -1210,7 +993,7 @@ void Dir_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
     PRINTMARK();
 }
 
-void Dir_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
+void Dir_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     if (GET_TC(tc)->itemValue) {
         Py_DECREF(GET_TC(tc)->itemValue);
         GET_TC(tc)->itemValue = NULL;
@@ -1296,12 +1079,13 @@ int Dir_iterNext(JSOBJ _obj, JSONTypeContext *tc) {
     return 1;
 }
 
-JSOBJ Dir_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Dir_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PRINTMARK();
     return GET_TC(tc)->itemValue;
 }
 
-char *Dir_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Dir_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                      size_t *outLen) {
     PRINTMARK();
     *outLen = PyBytes_GET_SIZE(GET_TC(tc)->itemName);
     return PyBytes_AS_STRING(GET_TC(tc)->itemName);
@@ -1327,20 +1111,21 @@ int List_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void List_iterEnd(JSOBJ obj, JSONTypeContext *tc) {}
+void List_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc)) {}
 
-JSOBJ List_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ List_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *List_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *List_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc),
+                       size_t *Py_UNUSED(outLen)) {
     return NULL;
 }
 
 //=============================================================================
 // pandas Index iteration functions
 //=============================================================================
-void Index_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void Index_iterBegin(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     GET_TC(tc)->index = 0;
     GET_TC(tc)->cStr = PyObject_Malloc(20 * sizeof(char));
     if (!GET_TC(tc)->cStr) {
@@ -1376,13 +1161,16 @@ int Index_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void Index_iterEnd(JSOBJ obj, JSONTypeContext *tc) { PRINTMARK(); }
+void Index_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *Py_UNUSED(tc)) {
+    PRINTMARK();
+}
 
-JSOBJ Index_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Index_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *Index_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Index_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                        size_t *outLen) {
     *outLen = strlen(GET_TC(tc)->cStr);
     return GET_TC(tc)->cStr;
 }
@@ -1390,7 +1178,7 @@ char *Index_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
 //=============================================================================
 // pandas Series iteration functions
 //=============================================================================
-void Series_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void Series_iterBegin(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObjectEncoder *enc = (PyObjectEncoder *)tc->encoder;
     GET_TC(tc)->index = 0;
     GET_TC(tc)->cStr = PyObject_Malloc(20 * sizeof(char));
@@ -1431,17 +1219,18 @@ int Series_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void Series_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
+void Series_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObjectEncoder *enc = (PyObjectEncoder *)tc->encoder;
     enc->outputFormat = enc->originalOutputFormat;
     PRINTMARK();
 }
 
-JSOBJ Series_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Series_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *Series_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Series_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                         size_t *outLen) {
     *outLen = strlen(GET_TC(tc)->cStr);
     return GET_TC(tc)->cStr;
 }
@@ -1449,7 +1238,7 @@ char *Series_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
 //=============================================================================
 // pandas DataFrame iteration functions
 //=============================================================================
-void DataFrame_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void DataFrame_iterBegin(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObjectEncoder *enc = (PyObjectEncoder *)tc->encoder;
     GET_TC(tc)->index = 0;
     GET_TC(tc)->cStr = PyObject_Malloc(20 * sizeof(char));
@@ -1495,17 +1284,18 @@ int DataFrame_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void DataFrame_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
+void DataFrame_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObjectEncoder *enc = (PyObjectEncoder *)tc->encoder;
     enc->outputFormat = enc->originalOutputFormat;
     PRINTMARK();
 }
 
-JSOBJ DataFrame_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ DataFrame_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *DataFrame_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *DataFrame_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                            size_t *outLen) {
     *outLen = strlen(GET_TC(tc)->cStr);
     return GET_TC(tc)->cStr;
 }
@@ -1515,12 +1305,12 @@ char *DataFrame_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
 // itemName might converted to string (Python_Str). Do refCounting
 // itemValue is borrowed from object (which is dict). No refCounting
 //=============================================================================
-void Dict_iterBegin(JSOBJ obj, JSONTypeContext *tc) {
+void Dict_iterBegin(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     GET_TC(tc)->index = 0;
     PRINTMARK();
 }
 
-int Dict_iterNext(JSOBJ obj, JSONTypeContext *tc) {
+int Dict_iterNext(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PyObject *itemNameTmp;
 
     if (GET_TC(tc)->itemName) {
@@ -1548,7 +1338,7 @@ int Dict_iterNext(JSOBJ obj, JSONTypeContext *tc) {
     return 1;
 }
 
-void Dict_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
+void Dict_iterEnd(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     if (GET_TC(tc)->itemName) {
         Py_DECREF(GET_TC(tc)->itemName);
         GET_TC(tc)->itemName = NULL;
@@ -1557,11 +1347,12 @@ void Dict_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
     PRINTMARK();
 }
 
-JSOBJ Dict_iterGetValue(JSOBJ obj, JSONTypeContext *tc) {
+JSOBJ Dict_iterGetValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     return GET_TC(tc)->itemValue;
 }
 
-char *Dict_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
+char *Dict_iterGetName(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc,
+                       size_t *outLen) {
     *outLen = PyBytes_GET_SIZE(GET_TC(tc)->itemName);
     return PyBytes_AS_STRING(GET_TC(tc)->itemName);
 }
@@ -1598,10 +1389,12 @@ char **NpyArr_encodeLabels(PyArrayObject *labels, PyObjectEncoder *enc,
                            npy_intp num) {
     // NOTE this function steals a reference to labels.
     PyObject *item = NULL;
-    npy_intp i, stride, len;
+    size_t len;
+    npy_intp i, stride;
     char **ret;
     char *dataptr, *cLabel;
     int type_num;
+    NPY_DATETIMEUNIT base = enc->datetimeUnit;
     PRINTMARK();
 
     if (!labels) {
@@ -1639,92 +1432,87 @@ char **NpyArr_encodeLabels(PyArrayObject *labels, PyObjectEncoder *enc,
             break;
         }
 
-        // TODO: for any matches on type_num (date and timedeltas) should use a
-        // vectorized solution to convert to epoch or iso formats
-        if (enc->datetimeIso &&
-            (type_num == NPY_TIMEDELTA || PyDelta_Check(item))) {
-            PyObject *td = PyObject_CallFunction(cls_timedelta, "(O)", item);
-            if (td == NULL) {
-                Py_DECREF(item);
-                NpyArr_freeLabels(ret, num);
-                ret = 0;
-                break;
-            }
-
-            PyObject *iso = PyObject_CallMethod(td, "isoformat", NULL);
-            Py_DECREF(td);
-            if (iso == NULL) {
-                Py_DECREF(item);
-                NpyArr_freeLabels(ret, num);
-                ret = 0;
-                break;
-            }
-
-            cLabel = (char *)PyUnicode_AsUTF8(iso);
-            Py_DECREF(iso);
-            len = strlen(cLabel);
-        } else if (PyTypeNum_ISDATETIME(type_num) || PyDateTime_Check(item) ||
-                   PyDate_Check(item)) {
-            PyObject *ts = PyObject_CallFunction(cls_timestamp, "(O)", item);
-            if (ts == NULL) {
-                Py_DECREF(item);
-                NpyArr_freeLabels(ret, num);
-                ret = 0;
-                break;
+        int is_datetimelike = 0;
+        npy_int64 nanosecVal;
+        if (PyTypeNum_ISDATETIME(type_num)) {
+            is_datetimelike = 1;
+            PyArray_VectorUnaryFunc *castfunc =
+                PyArray_GetCastFunc(PyArray_DescrFromType(type_num), NPY_INT64);
+            if (!castfunc) {
+                PyErr_Format(PyExc_ValueError,
+                             "Cannot cast numpy dtype %d to long",
+                             enc->npyType);
             }
-
-            if (enc->datetimeIso) {
-                PyObject *iso = PyObject_CallMethod(ts, "isoformat", NULL);
-                Py_DECREF(ts);
-                if (iso == NULL) {
-                    Py_DECREF(item);
-                    NpyArr_freeLabels(ret, num);
-                    ret = 0;
-                    break;
+            castfunc(dataptr, &nanosecVal, 1, NULL, NULL);
+        } else if (PyDate_Check(item) || PyDelta_Check(item)) {
+            is_datetimelike = 1;
+            if (PyObject_HasAttrString(item, "value")) {
+                nanosecVal = get_long_attr(item, "value");
+            } else {
+                if (PyDelta_Check(item)) {
+                    nanosecVal = total_seconds(item) *
+                                 1000000000LL; // nanoseconds per second
+                } else {
+                    // datetime.* objects don't follow above rules
+                    nanosecVal = PyDateTimeToEpoch(item, NPY_FR_ns);
                 }
+            }
+        }
 
-                cLabel = (char *)PyUnicode_AsUTF8(iso);
-                Py_DECREF(iso);
-                len = strlen(cLabel);
+        if (is_datetimelike) {
+            if (nanosecVal == get_nat()) {
+                len = 5; // TODO: shouldn't require extra space for terminator
+                cLabel = PyObject_Malloc(len);
+                strncpy(cLabel, "null", len);
             } else {
-                npy_int64 value;
-                // TODO: refactor to not duplicate what goes on in
-                // beginTypeContext
-                if (PyObject_HasAttrString(ts, "value")) {
-                    PRINTMARK();
-                    value = get_long_attr(ts, "value");
+                if (enc->datetimeIso) {
+                    // TODO: Vectorized Timedelta function
+                    if ((type_num == NPY_TIMEDELTA) || (PyDelta_Check(item))) {
+                        PyObject *td =
+                            PyObject_CallFunction(cls_timedelta, "(O)", item);
+                        if (td == NULL) {
+                            Py_DECREF(item);
+                            NpyArr_freeLabels(ret, num);
+                            ret = 0;
+                            break;
+                        }
+
+                        PyObject *iso =
+                            PyObject_CallMethod(td, "isoformat", NULL);
+                        Py_DECREF(td);
+                        if (iso == NULL) {
+                            Py_DECREF(item);
+                            NpyArr_freeLabels(ret, num);
+                            ret = 0;
+                            break;
+                        }
+
+                        len = strlen(PyUnicode_AsUTF8(iso));
+                        cLabel = PyObject_Malloc(len + 1);
+                        memcpy(cLabel, PyUnicode_AsUTF8(iso), len + 1);
+                        Py_DECREF(iso);
+                    } else {
+                        if (type_num == NPY_DATETIME) {
+                            cLabel = int64ToIso(nanosecVal, base, &len);
+                        } else {
+                            cLabel = PyDateTimeToIso((PyDateTime_Date *)item,
+                                                     base, &len);
+                        }
+                    }
+                    if (cLabel == NULL) {
+                        Py_DECREF(item);
+                        NpyArr_freeLabels(ret, num);
+                        ret = 0;
+                        break;
+                    }
                 } else {
-                    PRINTMARK();
-                    value = total_seconds(ts) *
-                            1000000000LL; // nanoseconds per second
-                }
-                Py_DECREF(ts);
-
-                switch (enc->datetimeUnit) {
-                case NPY_FR_ns:
-                    break;
-                case NPY_FR_us:
-                    value /= 1000LL;
-                    break;
-                case NPY_FR_ms:
-                    value /= 1000000LL;
-                    break;
-                case NPY_FR_s:
-                    value /= 1000000000LL;
-                    break;
-                default:
-                    Py_DECREF(item);
-                    NpyArr_freeLabels(ret, num);
-                    ret = 0;
-                    break;
+                    cLabel = PyObject_Malloc(21); // 21 chars for int64
+                    sprintf(cLabel, "%" NPY_DATETIME_FMT,
+                            NpyDateTimeToEpoch(nanosecVal, base));
+                    len = strlen(cLabel);
                 }
-
-                char buf[21] = {0}; // 21 chars for 2**63 as string
-                cLabel = buf;
-                sprintf(buf, "%" NPY_INT64_FMT, value);
-                len = strlen(cLabel);
             }
-        } else { // Fallack to string representation
+        } else { // Fallback to string representation
             PyObject *str = PyObject_Str(item);
             if (str == NULL) {
                 Py_DECREF(item);
@@ -1743,6 +1531,10 @@ char **NpyArr_encodeLabels(PyArrayObject *labels, PyObjectEncoder *enc,
         ret[i] = PyObject_Malloc(len + 1);
         memcpy(ret[i], cLabel, len + 1);
 
+        if (is_datetimelike) {
+            PyObject_Free(cLabel);
+        }
+
         if (PyErr_Occurred()) {
             NpyArr_freeLabels(ret, num);
             ret = 0;
@@ -1784,7 +1576,7 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
     PyObjectEncoder *enc;
     double val;
     npy_int64 value;
-    int base;
+    int unit;
     PRINTMARK();
 
     tc->prv = NULL;
@@ -1797,29 +1589,6 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
     obj = (PyObject *)_obj;
     enc = (PyObjectEncoder *)tc->encoder;
 
-    if (enc->npyType >= 0) {
-        PRINTMARK();
-        tc->prv = &(enc->basicTypeContext);
-        tc->type = NpyTypeToJSONType(obj, tc, enc->npyType, enc->npyValue);
-
-        if (tc->type == JT_INVALID) {
-            if (enc->defaultHandler) {
-                enc->npyType = -1;
-                PRINTMARK();
-                Object_invokeDefaultHandler(
-                    enc->npyCtxtPassthru->getitem(enc->npyValue,
-                                                  enc->npyCtxtPassthru->array),
-                    enc);
-            } else {
-                PyErr_Format(PyExc_RuntimeError, "Unhandled numpy dtype %d",
-                             enc->npyType);
-            }
-        }
-        enc->npyCtxtPassthru = NULL;
-        enc->npyType = -1;
-        return;
-    }
-
     if (PyBool_Check(obj)) {
         PRINTMARK();
         tc->type = (obj == Py_True) ? JT_TRUE : JT_FALSE;
@@ -1837,6 +1606,44 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
     }
     tc->prv = pc;
 
+    if (PyTypeNum_ISDATETIME(enc->npyType)) {
+        PRINTMARK();
+        int64_t longVal;
+        PyArray_VectorUnaryFunc *castfunc =
+            PyArray_GetCastFunc(PyArray_DescrFromType(enc->npyType), NPY_INT64);
+        if (!castfunc) {
+            PyErr_Format(PyExc_ValueError, "Cannot cast numpy dtype %d to long",
+                         enc->npyType);
+        }
+        castfunc(enc->npyValue, &longVal, 1, NULL, NULL);
+        if (longVal == get_nat()) {
+            PRINTMARK();
+            tc->type = JT_NULL;
+        } else {
+
+            if (enc->datetimeIso) {
+                PRINTMARK();
+                pc->PyTypeToUTF8 = NpyDateTimeToIsoCallback;
+                // Currently no way to pass longVal to iso function, so use
+                // state management
+                GET_TC(tc)->longValue = longVal;
+                tc->type = JT_UTF8;
+            } else {
+                PRINTMARK();
+                NPY_DATETIMEUNIT base =
+                    ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+                GET_TC(tc)->longValue = NpyDateTimeToEpoch(longVal, base);
+                tc->type = JT_LONG;
+            }
+        }
+
+        // TODO: this prevents infinite loop with mixed-type DataFrames;
+        // refactor
+        enc->npyCtxtPassthru = NULL;
+        enc->npyType = -1;
+        return;
+    }
+
     if (PyIter_Check(obj) ||
         (PyArray_Check(obj) && !PyArray_CheckScalar(obj))) {
         PRINTMARK();
@@ -1845,7 +1652,6 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
 
     if (PyLong_Check(obj)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyLongToINT64;
         tc->type = JT_LONG;
         GET_TC(tc)->longValue = PyLong_AsLongLong(obj);
 
@@ -1863,23 +1669,23 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
         if (npy_isnan(val) || npy_isinf(val)) {
             tc->type = JT_NULL;
         } else {
-            pc->PyTypeToJSON = PyFloatToDOUBLE;
+            GET_TC(tc)->doubleValue = val;
             tc->type = JT_DOUBLE;
         }
         return;
     } else if (PyBytes_Check(obj)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyBytesToUTF8;
+        pc->PyTypeToUTF8 = PyBytesToUTF8;
         tc->type = JT_UTF8;
         return;
     } else if (PyUnicode_Check(obj)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyUnicodeToUTF8;
+        pc->PyTypeToUTF8 = PyUnicodeToUTF8;
         tc->type = JT_UTF8;
         return;
     } else if (PyObject_TypeCheck(obj, type_decimal)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyFloatToDOUBLE;
+        GET_TC(tc)->doubleValue = PyFloat_AsDouble(obj);
         tc->type = JT_DOUBLE;
         return;
     } else if (PyDateTime_Check(obj) || PyDate_Check(obj)) {
@@ -1890,18 +1696,21 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
         }
 
         PRINTMARK();
-        pc->PyTypeToJSON = PyDateTimeToJSON;
         if (enc->datetimeIso) {
             PRINTMARK();
+            pc->PyTypeToUTF8 = PyDateTimeToIsoCallback;
             tc->type = JT_UTF8;
         } else {
             PRINTMARK();
+            NPY_DATETIMEUNIT base =
+                ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+            GET_TC(tc)->longValue = PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
             tc->type = JT_LONG;
         }
         return;
     } else if (PyTime_Check(obj)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyTimeToJSON;
+        pc->PyTypeToUTF8 = PyTimeToJSON;
         tc->type = JT_UTF8;
         return;
     } else if (PyArray_IsScalar(obj, Datetime)) {
@@ -1913,8 +1722,17 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
         }
 
         PRINTMARK();
-        pc->PyTypeToJSON = NpyDateTimeScalarToJSON;
-        tc->type = enc->datetimeIso ? JT_UTF8 : JT_LONG;
+        if (enc->datetimeIso) {
+            PRINTMARK();
+            pc->PyTypeToUTF8 = PyDateTimeToIsoCallback;
+            tc->type = JT_UTF8;
+        } else {
+            PRINTMARK();
+            NPY_DATETIMEUNIT base =
+                ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+            GET_TC(tc)->longValue = PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
+            tc->type = JT_LONG;
+        }
         return;
     } else if (PyDelta_Check(obj)) {
         if (PyObject_HasAttrString(obj, "value")) {
@@ -1925,19 +1743,9 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
             value = total_seconds(obj) * 1000000000LL; // nanoseconds per second
         }
 
-        base = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
-        switch (base) {
-        case NPY_FR_ns:
-            break;
-        case NPY_FR_us:
-            value /= 1000LL;
-            break;
-        case NPY_FR_ms:
-            value /= 1000000LL;
-            break;
-        case NPY_FR_s:
-            value /= 1000000000LL;
-            break;
+        unit = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+        if (scaleNanosecToUnit(&value, unit) != 0) {
+            // TODO: Add some kind of error handling here
         }
 
         exc = PyErr_Occurred();
@@ -1956,12 +1764,10 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
         GET_TC(tc)->longValue = value;
 
         PRINTMARK();
-        pc->PyTypeToJSON = PyLongToINT64;
         tc->type = JT_LONG;
         return;
     } else if (PyArray_IsScalar(obj, Integer)) {
         PRINTMARK();
-        pc->PyTypeToJSON = PyLongToINT64;
         tc->type = JT_LONG;
         PyArray_CastScalarToCtype(obj, &(GET_TC(tc)->longValue),
                                   PyArray_DescrFromType(NPY_INT64));
@@ -1982,16 +1788,19 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
         return;
     } else if (PyArray_IsScalar(obj, Float) || PyArray_IsScalar(obj, Double)) {
         PRINTMARK();
-        pc->PyTypeToJSON = NpyFloatToDOUBLE;
+        PyArray_CastScalarToCtype(obj, &(GET_TC(tc)->doubleValue),
+                                  PyArray_DescrFromType(NPY_DOUBLE));
         tc->type = JT_DOUBLE;
         return;
     } else if (PyArray_Check(obj) && PyArray_CheckScalar(obj)) {
-        tmpObj = PyObject_Repr(obj);
         PyErr_Format(PyExc_TypeError,
-                     "%s (0d array) is not JSON serializable at the moment",
-                     PyBytes_AS_STRING(tmpObj));
-        Py_DECREF(tmpObj);
+                     "%R (0d array) is not JSON serializable at the moment",
+                     obj);
         goto INVALID;
+    } else if (PyObject_TypeCheck(obj, cls_na)) {
+        PRINTMARK();
+        tc->type = JT_NULL;
+        return;
     }
 
 ISITERABLE:
@@ -2244,11 +2053,11 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
     } else if (PyAnySet_Check(obj)) {
         PRINTMARK();
         tc->type = JT_ARRAY;
-        pc->iterBegin = Iter_iterBegin;
-        pc->iterEnd = Iter_iterEnd;
-        pc->iterNext = Iter_iterNext;
-        pc->iterGetValue = Iter_iterGetValue;
-        pc->iterGetName = Iter_iterGetName;
+        pc->iterBegin = Set_iterBegin;
+        pc->iterEnd = Set_iterEnd;
+        pc->iterNext = Set_iterNext;
+        pc->iterGetValue = Set_iterGetValue;
+        pc->iterGetName = Set_iterGetName;
         return;
     }
 
@@ -2306,7 +2115,7 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
     return;
 }
 
-void Object_endTypeContext(JSOBJ obj, JSONTypeContext *tc) {
+void Object_endTypeContext(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
     PRINTMARK();
     if (tc->prv) {
         Py_XDECREF(GET_TC(tc)->newObj);
@@ -2319,35 +2128,22 @@ void Object_endTypeContext(JSOBJ obj, JSONTypeContext *tc) {
 
         PyObject_Free(GET_TC(tc)->cStr);
         GET_TC(tc)->cStr = NULL;
-        if (tc->prv !=
-            &(((PyObjectEncoder *)tc->encoder)->basicTypeContext)) { // NOLINT
-            PyObject_Free(tc->prv);
-        }
+        PyObject_Free(tc->prv);
         tc->prv = NULL;
     }
 }
 
 const char *Object_getStringValue(JSOBJ obj, JSONTypeContext *tc,
                                   size_t *_outLen) {
-    return GET_TC(tc)->PyTypeToJSON(obj, tc, NULL, _outLen);
+    return GET_TC(tc)->PyTypeToUTF8(obj, tc, _outLen);
 }
 
-JSINT64 Object_getLongValue(JSOBJ obj, JSONTypeContext *tc) {
-    JSINT64 ret;
-    GET_TC(tc)->PyTypeToJSON(obj, tc, &ret, NULL);
-    return ret;
-}
-
-JSINT32 Object_getIntValue(JSOBJ obj, JSONTypeContext *tc) {
-    JSINT32 ret;
-    GET_TC(tc)->PyTypeToJSON(obj, tc, &ret, NULL);
-    return ret;
+JSINT64 Object_getLongValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
+    return GET_TC(tc)->longValue;
 }
 
-double Object_getDoubleValue(JSOBJ obj, JSONTypeContext *tc) {
-    double ret;
-    GET_TC(tc)->PyTypeToJSON(obj, tc, &ret, NULL);
-    return ret;
+double Object_getDoubleValue(JSOBJ Py_UNUSED(obj), JSONTypeContext *tc) {
+    return GET_TC(tc)->doubleValue;
 }
 
 static void Object_releaseObject(JSOBJ _obj) { Py_DECREF((PyObject *)_obj); }
@@ -2372,11 +2168,18 @@ char *Object_iterGetName(JSOBJ obj, JSONTypeContext *tc, size_t *outLen) {
     return GET_TC(tc)->iterGetName(obj, tc, outLen);
 }
 
-PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs) {
-    static char *kwlist[] = {
-        "obj",    "ensure_ascii", "double_precision", "encode_html_chars",
-        "orient", "date_unit",    "iso_dates",        "default_handler",
-        NULL};
+PyObject *objToJSON(PyObject *Py_UNUSED(self), PyObject *args,
+                    PyObject *kwargs) {
+    static char *kwlist[] = {"obj",
+                             "ensure_ascii",
+                             "double_precision",
+                             "encode_html_chars",
+                             "orient",
+                             "date_unit",
+                             "iso_dates",
+                             "default_handler",
+                             "indent",
+                             NULL};
 
     char buffer[65536];
     char *ret;
@@ -2389,13 +2192,14 @@ PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs) {
     char *sdateFormat = NULL;
     PyObject *oisoDates = 0;
     PyObject *odefHandler = 0;
+    int indent = 0;
 
     PyObjectEncoder pyEncoder = {{
         Object_beginTypeContext,
         Object_endTypeContext,
         Object_getStringValue,
         Object_getLongValue,
-        Object_getIntValue,
+        NULL, // getIntValue is unused
         Object_getDoubleValue,
         Object_iterBegin,
         Object_iterNext,
@@ -2410,6 +2214,7 @@ PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs) {
         idoublePrecision,
         1, // forceAscii
         0, // encodeHTMLChars
+        0, // indent
     }};
     JSONObjectEncoder *encoder = (JSONObjectEncoder *)&pyEncoder;
 
@@ -2421,23 +2226,13 @@ PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs) {
     pyEncoder.datetimeUnit = NPY_FR_ms;
     pyEncoder.outputFormat = COLUMNS;
     pyEncoder.defaultHandler = 0;
-    pyEncoder.basicTypeContext.newObj = NULL;
-    pyEncoder.basicTypeContext.dictObj = NULL;
-    pyEncoder.basicTypeContext.itemValue = NULL;
-    pyEncoder.basicTypeContext.itemName = NULL;
-    pyEncoder.basicTypeContext.attrList = NULL;
-    pyEncoder.basicTypeContext.iterator = NULL;
-    pyEncoder.basicTypeContext.cStr = NULL;
-    pyEncoder.basicTypeContext.npyarr = NULL;
-    pyEncoder.basicTypeContext.rowLabels = NULL;
-    pyEncoder.basicTypeContext.columnLabels = NULL;
 
     PRINTMARK();
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OiOssOO", kwlist, &oinput,
-                                     &oensureAscii, &idoublePrecision,
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OiOssOOi", kwlist,
+                                     &oinput, &oensureAscii, &idoublePrecision,
                                      &oencodeHTMLChars, &sOrient, &sdateFormat,
-                                     &oisoDates, &odefHandler)) {
+                                     &oisoDates, &odefHandler, &indent)) {
         return NULL;
     }
 
@@ -2503,6 +2298,8 @@ PyObject *objToJSON(PyObject *self, PyObject *args, PyObject *kwargs) {
         pyEncoder.defaultHandler = odefHandler;
     }
 
+    encoder->indent = indent;
+
     pyEncoder.originalOutputFormat = pyEncoder.outputFormat;
     PRINTMARK();
     ret = JSON_EncodeObject(oinput, encoder, buffer, sizeof(buffer));
diff --git a/pandas/_libs/src/ujson/python/ujson.c b/pandas/_libs/src/ujson/python/ujson.c
index 39320d73d0cab..a40f2709c0c61 100644
--- a/pandas/_libs/src/ujson/python/ujson.c
+++ b/pandas/_libs/src/ujson/python/ujson.c
@@ -30,7 +30,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 */
@@ -65,35 +65,15 @@ static PyMethodDef ujsonMethods[] = {
     {NULL, NULL, 0, NULL} /* Sentinel */
 };
 
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "_libjson",
-    0,            /* m_doc */
-    -1,           /* m_size */
-    ujsonMethods, /* m_methods */
-    NULL,         /* m_reload */
-    NULL,         /* m_traverse */
-    NULL,         /* m_clear */
-    NULL          /* m_free */
+static PyModuleDef moduledef = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "_libjson",
+    .m_methods = ujsonMethods
 };
 
-#define PYMODINITFUNC PyMODINIT_FUNC PyInit_json(void)
-#define PYMODULE_CREATE() PyModule_Create(&moduledef)
-#define MODINITERROR return NULL
 
-PYMODINITFUNC {
-    PyObject *module;
-    PyObject *version_string;
+PyMODINIT_FUNC PyInit_json(void) {
+  initObjToJSON();  // TODO: clean up, maybe via tp_free?
+  return PyModuleDef_Init(&moduledef);
 
-    initObjToJSON();
-    module = PYMODULE_CREATE();
-
-    if (module == NULL) {
-        MODINITERROR;
-    }
-
-    version_string = PyUnicode_FromString(UJSON_VERSION);
-    PyModule_AddObject(module, "__version__", version_string);
-
-    return module;
 }
diff --git a/pandas/_libs/src/ujson/python/version.h b/pandas/_libs/src/ujson/python/version.h
index ef6d28bf3a1f7..3f38642b6df87 100644
--- a/pandas/_libs/src/ujson/python/version.h
+++ b/pandas/_libs/src/ujson/python/version.h
@@ -30,7 +30,7 @@ Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
 Copyright (c) 2007  Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
 
 Numeric decoder derived from from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+https://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
  * Copyright (c) 1988-1993 The Regents of the University of California.
  * Copyright (c) 1994 Sun Microsystems, Inc.
 */
diff --git a/pandas/_libs/testing.pyx b/pandas/_libs/testing.pyx
index c407de4cf7465..0e57b563d4d25 100644
--- a/pandas/_libs/testing.pyx
+++ b/pandas/_libs/testing.pyx
@@ -66,7 +66,8 @@ cpdef assert_almost_equal(a, b,
                           check_less_precise=False,
                           bint check_dtype=True,
                           obj=None, lobj=None, robj=None):
-    """Check that left and right objects are almost equal.
+    """
+    Check that left and right objects are almost equal.
 
     Parameters
     ----------
@@ -89,7 +90,6 @@ cpdef assert_almost_equal(a, b,
         Specify right object name being compared, internally used to show
         appropriate assertion message
     """
-
     cdef:
         int decimal
         double diff = 0.0
@@ -108,7 +108,7 @@ cpdef assert_almost_equal(a, b,
         return assert_dict_equal(a, b)
 
     if isinstance(a, str) or isinstance(b, str):
-        assert a == b, "%r != %r" % (a, b)
+        assert a == b, f"{a} != {b}"
         return True
 
     a_is_ndarray = isinstance(a, np.ndarray)
@@ -123,36 +123,33 @@ cpdef assert_almost_equal(a, b,
     if isiterable(a):
 
         if not isiterable(b):
-            from pandas.util.testing import assert_class_equal
+            from pandas._testing import assert_class_equal
             # classes can't be the same, to raise error
             assert_class_equal(a, b, obj=obj)
 
         assert has_length(a) and has_length(b), (
-            "Can't compare objects without length, one or both is invalid: "
-            "(%r, %r)" % (a, b))
+            f"Can't compare objects without length, one or both is invalid: ({a}, {b})"
+        )
 
         if a_is_ndarray and b_is_ndarray:
             na, nb = a.size, b.size
             if a.shape != b.shape:
-                from pandas.util.testing import raise_assert_detail
+                from pandas._testing import raise_assert_detail
                 raise_assert_detail(
-                    obj, '{0} shapes are different'.format(obj),
-                    a.shape, b.shape)
+                    obj, f'{obj} shapes are different', a.shape, b.shape)
 
             if check_dtype and not is_dtype_equal(a.dtype, b.dtype):
-                from pandas.util.testing import assert_attr_equal
+                from pandas._testing import assert_attr_equal
                 assert_attr_equal('dtype', a, b, obj=obj)
 
-            try:
-                if array_equivalent(a, b, strict_nan=True):
-                    return True
-            except:
-                pass
+            if array_equivalent(a, b, strict_nan=True):
+                return True
+
         else:
             na, nb = len(a), len(b)
 
         if na != nb:
-            from pandas.util.testing import raise_assert_detail
+            from pandas._testing import raise_assert_detail
 
             # if we have a small diff set, print it
             if abs(na - nb) < 10:
@@ -160,10 +157,9 @@ cpdef assert_almost_equal(a, b,
             else:
                 r = None
 
-            raise_assert_detail(obj, '{0} length are different'.format(obj),
-                                na, nb, r)
+            raise_assert_detail(obj, f"{obj} length are different", na, nb, r)
 
-        for i in xrange(len(a)):
+        for i in range(len(a)):
             try:
                 assert_almost_equal(a[i], b[i],
                                     check_less_precise=check_less_precise)
@@ -172,25 +168,27 @@ cpdef assert_almost_equal(a, b,
                 diff += 1
 
         if is_unequal:
-            from pandas.util.testing import raise_assert_detail
-            msg = '{0} values are different ({1} %)'.format(
-                obj, np.round(diff * 100.0 / na, 5))
+            from pandas._testing import raise_assert_detail
+            msg = (f"{obj} values are different "
+                   f"({np.round(diff * 100.0 / na, 5)} %)")
             raise_assert_detail(obj, msg, lobj, robj)
 
         return True
 
     elif isiterable(b):
-        from pandas.util.testing import assert_class_equal
+        from pandas._testing import assert_class_equal
         # classes can't be the same, to raise error
         assert_class_equal(a, b, obj=obj)
 
-    if a == b:
-        # object comparison
-        return True
     if isna(a) and isna(b):
         # TODO: Should require same-dtype NA?
         # nan / None comparison
         return True
+
+    if a == b:
+        # object comparison
+        return True
+
     if is_comparable_as_number(a) and is_comparable_as_number(b):
         if array_equivalent(a, b, strict_nan=True):
             # inf comparison
@@ -208,12 +206,12 @@ cpdef assert_almost_equal(a, b,
         # case for zero
         if abs(fa) < 1e-5:
             if not decimal_almost_equal(fa, fb, decimal):
-                assert False, ('(very low values) expected %.5f but '
-                               'got %.5f, with decimal %d' % (fb, fa, decimal))
+                assert False, (f'(very low values) expected {fb:.5f} '
+                               f'but got {fa:.5f}, with decimal {decimal}')
         else:
             if not decimal_almost_equal(1, fb / fa, decimal):
-                assert False, ('expected %.5f but got %.5f, '
-                               'with decimal %d' % (fb, fa, decimal))
+                assert False, (f'expected {fb:.5f} but got {fa:.5f}, '
+                               f'with decimal {decimal}')
         return True
 
-    raise AssertionError("{0} != {1}".format(a, b))
+    raise AssertionError(f"{a} != {b}")
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 0f1657480e4b3..53e3354ca8eb6 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -120,8 +120,7 @@ def ints_to_pydatetime(const int64_t[:] arr, object tz=None, object freq=None,
     elif box == "datetime":
         func_create = create_datetime_from_ts
     else:
-        raise ValueError("box must be one of 'datetime', 'date', 'time' or"
-                         " 'timestamp'")
+        raise ValueError("box must be one of 'datetime', 'date', 'time' or 'timestamp'")
 
     if is_utc(tz) or tz is None:
         for i in range(n):
@@ -188,7 +187,7 @@ def ints_to_pydatetime(const int64_t[:] arr, object tz=None, object freq=None,
     return result
 
 
-def _test_parse_iso8601(object ts):
+def _test_parse_iso8601(ts: str):
     """
     TESTING ONLY: Parse string into Timestamp using iso8601 parser. Used
     only for testing, actual construction uses `convert_str_to_tsobject`
@@ -266,20 +265,16 @@ def format_array_from_datetime(ndarray[int64_t] values, object tz=None,
         elif basic_format:
 
             dt64_to_dtstruct(val, &dts)
-            res = '%d-%.2d-%.2d %.2d:%.2d:%.2d' % (dts.year,
-                                                   dts.month,
-                                                   dts.day,
-                                                   dts.hour,
-                                                   dts.min,
-                                                   dts.sec)
+            res = (f'{dts.year}-{dts.month:02d}-{dts.day:02d} '
+                   f'{dts.hour:02d}:{dts.min:02d}:{dts.sec:02d}')
 
             if show_ns:
                 ns = dts.ps // 1000
-                res += '.%.9d' % (ns + 1000 * dts.us)
+                res += f'.{ns + dts.us * 1000:09d}'
             elif show_us:
-                res += '.%.6d' % dts.us
+                res += f'.{dts.us:06d}'
             elif show_ms:
-                res += '.%.3d' % (dts.us /1000)
+                res += f'.{dts.us // 1000:03d}'
 
             result[i] = res
 
@@ -300,10 +295,15 @@ def format_array_from_datetime(ndarray[int64_t] values, object tz=None,
     return result
 
 
-def array_with_unit_to_datetime(ndarray values, object unit,
+def array_with_unit_to_datetime(ndarray values, ndarray mask, object unit,
                                 str errors='coerce'):
     """
-    convert the ndarray according to the unit
+    Convert the ndarray to datetime according to the time unit.
+
+    This function converts an array of objects into a numpy array of
+    datetime64[ns]. It returns the converted array
+    and also returns the timezone offset
+
     if errors:
       - raise: return converted values or raise OutOfBoundsDatetime
           if out of range on the conversion or
@@ -311,6 +311,18 @@ def array_with_unit_to_datetime(ndarray values, object unit,
       - ignore: return non-convertible values as the same unit
       - coerce: NaT for non-convertibles
 
+    Parameters
+    ----------
+    values : ndarray of object
+         Date-like objects to convert
+    mask : ndarray of bool
+         Not-a-time mask for non-nullable integer types conversion,
+         can be None
+    unit : object
+         Time unit to use during conversion
+    errors : str, default 'raise'
+         Error behavior when parsing
+
     Returns
     -------
     result : ndarray of m8 values
@@ -320,7 +332,6 @@ def array_with_unit_to_datetime(ndarray values, object unit,
         Py_ssize_t i, j, n=len(values)
         int64_t m
         ndarray[float64_t] fvalues
-        ndarray mask
         bint is_ignore = errors=='ignore'
         bint is_coerce = errors=='coerce'
         bint is_raise = errors=='raise'
@@ -333,9 +344,13 @@ def array_with_unit_to_datetime(ndarray values, object unit,
 
     if unit == 'ns':
         if issubclass(values.dtype.type, np.integer):
-            return values.astype('M8[ns]'), tz
-        # This will return a tz
-        return array_to_datetime(values.astype(object), errors=errors)
+            result = values.astype('M8[ns]')
+        else:
+            result, tz = array_to_datetime(values.astype(object), errors=errors)
+        if mask is not None:
+            iresult = result.view('i8')
+            iresult[mask] = NPY_NAT
+        return result, tz
 
     m = cast_from_unit(None, unit)
 
@@ -347,7 +362,9 @@ def array_with_unit_to_datetime(ndarray values, object unit,
         if values.dtype.kind == "i":
             # Note: this condition makes the casting="same_kind" redundant
             iresult = values.astype('i8', casting='same_kind', copy=False)
-            mask = iresult == NPY_NAT
+            # If no mask, fill mask by comparing to NPY_NAT constant
+            if mask is None:
+                mask = iresult == NPY_NAT
             iresult[mask] = 0
             fvalues = iresult.astype('f8') * m
             need_to_iterate = False
@@ -357,8 +374,8 @@ def array_with_unit_to_datetime(ndarray values, object unit,
 
             if ((fvalues < Timestamp.min.value).any()
                     or (fvalues > Timestamp.max.value).any()):
-                raise OutOfBoundsDatetime("cannot convert input with unit "
-                                          "'{unit}'".format(unit=unit))
+                raise OutOfBoundsDatetime(f"cannot convert input with unit "
+                                          f"'{unit}'")
             result = (iresult * m).astype('M8[ns]')
             iresult = result.view('i8')
             iresult[mask] = NPY_NAT
@@ -384,8 +401,8 @@ def array_with_unit_to_datetime(ndarray values, object unit,
                     except OverflowError:
                         if is_raise:
                             raise OutOfBoundsDatetime(
-                                "cannot convert input {val} with the unit "
-                                "'{unit}'".format(val=val, unit=unit))
+                                f"cannot convert input {val} with the unit "
+                                f"'{unit}'")
                         elif is_ignore:
                             raise AssertionError
                         iresult[i] = NPY_NAT
@@ -400,16 +417,16 @@ def array_with_unit_to_datetime(ndarray values, object unit,
                     except ValueError:
                         if is_raise:
                             raise ValueError(
-                                "non convertible value {val} with the unit "
-                                "'{unit}'".format(val=val, unit=unit))
+                                f"non convertible value {val} with the unit "
+                                f"'{unit}'")
                         elif is_ignore:
                             raise AssertionError
                         iresult[i] = NPY_NAT
                     except OverflowError:
                         if is_raise:
                             raise OutOfBoundsDatetime(
-                                "cannot convert input {val} with the unit "
-                                "'{unit}'".format(val=val, unit=unit))
+                                f"cannot convert input {val} with the unit "
+                                f"'{unit}'")
                         elif is_ignore:
                             raise AssertionError
                         iresult[i] = NPY_NAT
@@ -417,8 +434,8 @@ def array_with_unit_to_datetime(ndarray values, object unit,
             else:
 
                 if is_raise:
-                    raise ValueError("unit='{0}' not valid with non-numerical "
-                                     "val='{1}'".format(unit, val))
+                    raise ValueError(f"unit='{unit}' not valid with non-numerical "
+                                     f"val='{val}'")
                 if is_ignore:
                     raise AssertionError
 
@@ -600,9 +617,8 @@ cpdef array_to_datetime(ndarray[object] values, str errors='raise',
                                 iresult[i] = NPY_NAT
                                 continue
                             elif is_raise:
-                                raise ValueError("time data {val} doesn't "
-                                                 "match format specified"
-                                                 .format(val=val))
+                                raise ValueError(f"time data {val} doesn't "
+                                                 f"match format specified")
                             return values, tz_out
 
                         try:
@@ -657,8 +673,7 @@ cpdef array_to_datetime(ndarray[object] values, str errors='raise',
                     if is_coerce:
                         iresult[i] = NPY_NAT
                     else:
-                        raise TypeError("{typ} is not convertible to datetime"
-                                        .format(typ=type(val)))
+                        raise TypeError(f"{type(val)} is not convertible to datetime")
 
             except OutOfBoundsDatetime:
                 if is_coerce:
diff --git a/pandas/_libs/tslibs/c_timestamp.pyx b/pandas/_libs/tslibs/c_timestamp.pyx
index 032363d867196..2c72cec18f096 100644
--- a/pandas/_libs/tslibs/c_timestamp.pyx
+++ b/pandas/_libs/tslibs/c_timestamp.pyx
@@ -51,15 +51,19 @@ class NullFrequencyError(ValueError):
     pass
 
 
-def maybe_integer_op_deprecated(obj):
-    # GH#22535 add/sub of integers and int-arrays is deprecated
-    if obj.freq is not None:
-        warnings.warn("Addition/subtraction of integers and integer-arrays "
-                      "to {cls} is deprecated, will be removed in a future "
-                      "version.  Instead of adding/subtracting `n`, use "
-                      "`n * self.freq`"
-                      .format(cls=type(obj).__name__),
-                      FutureWarning)
+def integer_op_not_supported(obj):
+    # GH#22535 add/sub of integers and int-arrays is no longer allowed
+    # Note we return rather than raise the exception so we can raise in
+    #  the caller; mypy finds this more palatable.
+    cls = type(obj).__name__
+
+    # GH#30886 using an fstring raises SystemError
+    int_addsub_msg = (
+        "Addition/subtraction of integers and integer-arrays with {cls} is "
+        "no longer supported.  Instead of adding/subtracting `n`, "
+        "use `n * obj.freq`"
+    ).format(cls=cls)
+    return TypeError(int_addsub_msg)
 
 
 cdef class _Timestamp(datetime):
@@ -87,7 +91,7 @@ cdef class _Timestamp(datetime):
                 return PyObject_RichCompareBool(val, other, op)
 
             try:
-                ots = self.__class__(other)
+                ots = type(self)(other)
             except ValueError:
                 return self._compare_outside_nanorange(other, op)
         else:
@@ -96,7 +100,7 @@ cdef class _Timestamp(datetime):
             if ndim != -1:
                 if ndim == 0:
                     if is_datetime64_object(other):
-                        other = self.__class__(other)
+                        other = type(self)(other)
                     elif is_array(other):
                         # zero-dim array, occurs if try comparison with
                         #  datetime64 scalar on the left hand side
@@ -105,7 +109,7 @@ cdef class _Timestamp(datetime):
                         #  the numpy C api to extract it.
                         other = cnp.PyArray_ToScalar(cnp.PyArray_DATA(other),
                                                      other)
-                        other = self.__class__(other)
+                        other = type(self)(other)
                     else:
                         return NotImplemented
                 elif is_array(other):
@@ -120,11 +124,11 @@ cdef class _Timestamp(datetime):
 
     def __reduce_ex__(self, protocol):
         # python 3.6 compat
-        # http://bugs.python.org/issue28730
+        # https://bugs.python.org/issue28730
         # now __reduce_ex__ is defined and higher priority than __reduce__
         return self.__reduce__()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         stamp = self._repr_base
         zone = None
 
@@ -144,11 +148,10 @@ cdef class _Timestamp(datetime):
             # e.g. tzlocal has no `strftime`
             pass
 
-        tz = ", tz='{0}'".format(zone) if zone is not None else ""
-        freq = "" if self.freq is None else ", freq='{0}'".format(self.freqstr)
+        tz = f", tz='{zone}'" if zone is not None else ""
+        freq = "" if self.freq is None else f", freq='{self.freqstr}'"
 
-        return "Timestamp('{stamp}'{tz}{freq})".format(stamp=stamp,
-                                                       tz=tz, freq=freq)
+        return f"Timestamp('{stamp}'{tz}{freq})"
 
     cdef bint _compare_outside_nanorange(_Timestamp self, datetime other,
                                          int op) except -1:
@@ -201,7 +204,7 @@ cdef class _Timestamp(datetime):
         """
         return np.datetime64(self.value, 'ns')
 
-    def to_numpy(self, dtype=None, copy=False):
+    def to_numpy(self, dtype=None, copy=False) -> np.datetime64:
         """
         Convert the Timestamp to a NumPy datetime64.
 
@@ -227,20 +230,10 @@ cdef class _Timestamp(datetime):
 
         if is_timedelta64_object(other):
             other_int = other.astype('timedelta64[ns]').view('i8')
-            return self.__class__(self.value + other_int,
-                                  tz=self.tzinfo, freq=self.freq)
+            return type(self)(self.value + other_int, tz=self.tzinfo, freq=self.freq)
 
         elif is_integer_object(other):
-            maybe_integer_op_deprecated(self)
-
-            if self is NaT:
-                # to be compat with Period
-                return NaT
-            elif self.freq is None:
-                raise NullFrequencyError(
-                    "Cannot add integral value to Timestamp without freq.")
-            return self.__class__((self.freq * other).apply(self),
-                                  freq=self.freq)
+            raise integer_op_not_supported(self)
 
         elif PyDelta_Check(other) or hasattr(other, 'delta'):
             # delta --> offsets.Tick
@@ -254,18 +247,12 @@ cdef class _Timestamp(datetime):
                          other.seconds * 1000000 +
                          other.microseconds) * 1000
 
-            result = self.__class__(self.value + nanos,
-                                    tz=self.tzinfo, freq=self.freq)
+            result = type(self)(self.value + nanos, tz=self.tzinfo, freq=self.freq)
             return result
 
         elif is_array(other):
             if other.dtype.kind in ['i', 'u']:
-                maybe_integer_op_deprecated(self)
-                if self.freq is None:
-                    raise NullFrequencyError(
-                        "Cannot add integer-dtype array "
-                        "to Timestamp without freq.")
-                return self.freq * other + self
+                raise integer_op_not_supported(self)
 
         # index/series like
         elif hasattr(other, '_typ'):
@@ -273,7 +260,7 @@ cdef class _Timestamp(datetime):
 
         result = datetime.__add__(self, other)
         if PyDateTime_Check(result):
-            result = self.__class__(result)
+            result = type(self)(result)
             result.nanosecond = self.nanosecond
         return result
 
@@ -287,12 +274,7 @@ cdef class _Timestamp(datetime):
 
         elif is_array(other):
             if other.dtype.kind in ['i', 'u']:
-                maybe_integer_op_deprecated(self)
-                if self.freq is None:
-                    raise NullFrequencyError(
-                        "Cannot subtract integer-dtype array "
-                        "from Timestamp without freq.")
-                return self - self.freq * other
+                raise integer_op_not_supported(self)
 
         typ = getattr(other, '_typ', None)
         if typ is not None:
@@ -305,9 +287,9 @@ cdef class _Timestamp(datetime):
         if (PyDateTime_Check(self)
                 and (PyDateTime_Check(other) or is_datetime64_object(other))):
             if isinstance(self, _Timestamp):
-                other = self.__class__(other)
+                other = type(self)(other)
             else:
-                self = other.__class__(self)
+                self = type(other)(self)
 
             # validate tz's
             if not tz_compare(self.tzinfo, other.tzinfo):
@@ -369,29 +351,28 @@ cdef class _Timestamp(datetime):
         return out[0]
 
     @property
-    def _repr_base(self):
-        return '{date} {time}'.format(date=self._date_repr,
-                                      time=self._time_repr)
+    def _repr_base(self) -> str:
+        return f"{self._date_repr} {self._time_repr}"
 
     @property
-    def _date_repr(self):
+    def _date_repr(self) -> str:
         # Ideal here would be self.strftime("%Y-%m-%d"), but
         # the datetime strftime() methods require year >= 1900
-        return '%d-%.2d-%.2d' % (self.year, self.month, self.day)
+        return f'{self.year}-{self.month:02d}-{self.day:02d}'
 
     @property
-    def _time_repr(self):
-        result = '%.2d:%.2d:%.2d' % (self.hour, self.minute, self.second)
+    def _time_repr(self) -> str:
+        result = f'{self.hour:02d}:{self.minute:02d}:{self.second:02d}'
 
         if self.nanosecond != 0:
-            result += '.%.9d' % (self.nanosecond + 1000 * self.microsecond)
+            result += f'.{self.nanosecond + 1000 * self.microsecond:09d}'
         elif self.microsecond != 0:
-            result += '.%.6d' % self.microsecond
+            result += f'.{self.microsecond:06d}'
 
         return result
 
     @property
-    def _short_repr(self):
+    def _short_repr(self) -> str:
         # format a Timestamp with only _date_repr if possible
         # otherwise _repr_base
         if (self.hour == 0 and
@@ -403,7 +384,7 @@ cdef class _Timestamp(datetime):
         return self._repr_base
 
     @property
-    def asm8(self):
+    def asm8(self) -> np.datetime64:
         """
         Return numpy datetime64 format in nanoseconds.
         """
diff --git a/pandas/_libs/tslibs/ccalendar.pyx b/pandas/_libs/tslibs/ccalendar.pyx
index a82d5e3b58e5e..0588dfe20e2e2 100644
--- a/pandas/_libs/tslibs/ccalendar.pyx
+++ b/pandas/_libs/tslibs/ccalendar.pyx
@@ -58,7 +58,8 @@ HOUR_SECONDS = 3600
 @cython.wraparound(False)
 @cython.boundscheck(False)
 cpdef int32_t get_days_in_month(int year, Py_ssize_t month) nogil:
-    """Return the number of days in the given month of the given year.
+    """
+    Return the number of days in the given month of the given year.
 
     Parameters
     ----------
@@ -81,7 +82,8 @@ cpdef int32_t get_days_in_month(int year, Py_ssize_t month) nogil:
 @cython.boundscheck(False)
 @cython.cdivision
 cdef int dayofweek(int y, int m, int d) nogil:
-    """Find the day of week for the date described by the Y/M/D triple y, m, d
+    """
+    Find the day of week for the date described by the Y/M/D triple y, m, d
     using Sakamoto's method, from wikipedia.
 
     0 represents Monday.  See [1]_.
@@ -117,7 +119,8 @@ cdef int dayofweek(int y, int m, int d) nogil:
 
 
 cdef bint is_leapyear(int64_t year) nogil:
-    """Returns 1 if the given year is a leap year, 0 otherwise.
+    """
+    Returns 1 if the given year is a leap year, 0 otherwise.
 
     Parameters
     ----------
@@ -134,7 +137,8 @@ cdef bint is_leapyear(int64_t year) nogil:
 @cython.wraparound(False)
 @cython.boundscheck(False)
 cpdef int32_t get_week_of_year(int year, int month, int day) nogil:
-    """Return the ordinal week-of-year for the given day.
+    """
+    Return the ordinal week-of-year for the given day.
 
     Parameters
     ----------
@@ -178,7 +182,8 @@ cpdef int32_t get_week_of_year(int year, int month, int day) nogil:
 @cython.wraparound(False)
 @cython.boundscheck(False)
 cpdef int32_t get_day_of_year(int year, int month, int day) nogil:
-    """Return the ordinal day-of-year for the given day.
+    """
+    Return the ordinal day-of-year for the given day.
 
     Parameters
     ----------
@@ -207,8 +212,9 @@ cpdef int32_t get_day_of_year(int year, int month, int day) nogil:
     return day_of_year
 
 
-def get_locale_names(name_type: object, locale: object=None):
-    """Returns an array of localized day or month names
+def get_locale_names(name_type: str, locale: object = None):
+    """
+    Returns an array of localized day or month names.
 
     Parameters
     ----------
diff --git a/pandas/_libs/tslibs/conversion.pxd b/pandas/_libs/tslibs/conversion.pxd
index 0b77948027ad7..c74307a3d2887 100644
--- a/pandas/_libs/tslibs/conversion.pxd
+++ b/pandas/_libs/tslibs/conversion.pxd
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from cpython.datetime cimport datetime, tzinfo
+from cpython.datetime cimport datetime
 
 from numpy cimport int64_t, int32_t
 
@@ -23,8 +23,4 @@ cdef _TSObject convert_datetime_to_tsobject(datetime ts, object tz,
 
 cdef int64_t get_datetime64_nanos(object val) except? -1
 
-cpdef int64_t pydt_to_i8(object pydt) except? -1
-
-cdef maybe_datetimelike_to_i8(object val)
-
 cpdef datetime localize_pydatetime(datetime dt, object tz)
diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index 0a3f4ed3cc91d..bf38fcfb6103c 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -99,6 +99,11 @@ def ensure_datetime64ns(arr: ndarray, copy: bool=True):
 
     shape = (<object>arr).shape
 
+    if (<object>arr).dtype.byteorder == ">":
+        # GH#29684 we incorrectly get OutOfBoundsDatetime if we dont swap
+        dtype = arr.dtype
+        arr = arr.astype(dtype.newbyteorder("<"))
+
     ivalues = arr.view(np.int64).ravel()
 
     result = np.empty(shape, dtype=NS_DTYPE)
@@ -197,36 +202,11 @@ def datetime_to_datetime64(object[:] values):
                 iresult[i] = pydatetime_to_dt64(val, &dts)
                 check_dts_bounds(&dts)
         else:
-            raise TypeError('Unrecognized value type: %s' % type(val))
+            raise TypeError(f'Unrecognized value type: {type(val)}')
 
     return result, inferred_tz
 
 
-cdef inline maybe_datetimelike_to_i8(object val):
-    """
-    Try to convert to a nanosecond timestamp.  Fall back to returning the
-    input value.
-
-    Parameters
-    ----------
-    val : object
-
-    Returns
-    -------
-    val : int64 timestamp or original input
-    """
-    cdef:
-        npy_datetimestruct dts
-    try:
-        return val.value
-    except AttributeError:
-        if is_datetime64_object(val):
-            return get_datetime64_value(val)
-        elif PyDateTime_Check(val):
-            return convert_datetime_to_tsobject(val, None).value
-        return val
-
-
 # ----------------------------------------------------------------------
 # _TSObject Conversion
 
@@ -243,27 +223,6 @@ cdef class _TSObject:
         return self.value
 
 
-cpdef int64_t pydt_to_i8(object pydt) except? -1:
-    """
-    Convert to int64 representation compatible with numpy datetime64; converts
-    to UTC
-
-    Parameters
-    ----------
-    pydt : object
-
-    Returns
-    -------
-    i8value : np.int64
-    """
-    cdef:
-        _TSObject ts
-
-    ts = convert_to_tsobject(pydt, None, None, 0, 0)
-
-    return ts.value
-
-
 cdef convert_to_tsobject(object ts, object tz, object unit,
                          bint dayfirst, bint yearfirst, int32_t nanos=0):
     """
@@ -326,8 +285,8 @@ cdef convert_to_tsobject(object ts, object tz, object unit,
         raise ValueError("Cannot convert Period to Timestamp "
                          "unambiguously. Use to_timestamp")
     else:
-        raise TypeError('Cannot convert input [{}] of type {} to '
-                        'Timestamp'.format(ts, type(ts)))
+        raise TypeError(f'Cannot convert input [{ts}] of type {type(ts)} to '
+                        f'Timestamp')
 
     if tz is not None:
         localize_tso(obj, tz)
@@ -444,15 +403,15 @@ cdef _TSObject convert_str_to_tsobject(object ts, object tz, object unit,
                                        bint dayfirst=False,
                                        bint yearfirst=False):
     """
-    Convert a string-like (bytes or unicode) input `ts`, along with optional
-    timezone object `tz` to a _TSObject.
+    Convert a string input `ts`, along with optional timezone object`tz`
+    to a _TSObject.
 
     The optional arguments `dayfirst` and `yearfirst` are passed to the
     dateutil parser.
 
     Parameters
     ----------
-    ts : bytes or unicode
+    ts : str
         Value to be converted to _TSObject
     tz : tzinfo or None
         timezone for the timezone-aware output
@@ -519,7 +478,7 @@ cdef _TSObject convert_str_to_tsobject(object ts, object tz, object unit,
             try:
                 ts = parse_datetime_string(ts, dayfirst=dayfirst,
                                            yearfirst=yearfirst)
-            except Exception:
+            except (ValueError, OverflowError):
                 raise ValueError("could not convert string to Timestamp")
 
     return convert_to_tsobject(ts, tz, unit, dayfirst, yearfirst)
@@ -686,7 +645,7 @@ def normalize_date(dt: object) -> datetime:
     elif PyDate_Check(dt):
         return datetime(dt.year, dt.month, dt.day)
     else:
-        raise TypeError('Unrecognized type: %s' % type(dt))
+        raise TypeError(f'Unrecognized type: {type(dt)}')
 
 
 @cython.wraparound(False)
diff --git a/pandas/_libs/tslibs/fields.pyx b/pandas/_libs/tslibs/fields.pyx
index 2ed85595f7e3a..8bee7da6231ba 100644
--- a/pandas/_libs/tslibs/fields.pyx
+++ b/pandas/_libs/tslibs/fields.pyx
@@ -22,7 +22,7 @@ from pandas._libs.tslibs.np_datetime cimport (
 from pandas._libs.tslibs.nattype cimport NPY_NAT
 
 
-def get_time_micros(ndarray[int64_t] dtindex):
+def get_time_micros(const int64_t[:] dtindex):
     """
     Return the number of microseconds in the time component of a
     nanosecond timestamp.
@@ -90,7 +90,7 @@ def build_field_sarray(const int64_t[:] dtindex):
 def get_date_name_field(const int64_t[:] dtindex, object field, object locale=None):
     """
     Given a int64-based datetime index, return array of strings of date
-    name based on requested field (e.g. weekday_name)
+    name based on requested field (e.g. day_name)
     """
     cdef:
         Py_ssize_t i, count = len(dtindex)
@@ -100,7 +100,7 @@ def get_date_name_field(const int64_t[:] dtindex, object field, object locale=No
 
     out = np.empty(count, dtype=object)
 
-    if field == 'day_name' or field == 'weekday_name':
+    if field == 'day_name':
         if locale is None:
             names = np.array(DAYS_FULL, dtype=np.object_)
         else:
@@ -130,7 +130,7 @@ def get_date_name_field(const int64_t[:] dtindex, object field, object locale=No
             out[i] = names[dts.month].capitalize()
 
     else:
-        raise ValueError("Field {field} not supported".format(field=field))
+        raise ValueError(f"Field {field} not supported")
 
     return out
 
@@ -165,8 +165,7 @@ def get_start_end_field(const int64_t[:] dtindex, object field,
 
     if freqstr:
         if freqstr == 'C':
-            raise ValueError("Custom business days is not supported by {field}"
-                             .format(field=field))
+            raise ValueError(f"Custom business days is not supported by {field}")
         is_business = freqstr[0] == 'B'
 
         # YearBegin(), BYearBegin() use month = starting month of year.
@@ -373,7 +372,7 @@ def get_start_end_field(const int64_t[:] dtindex, object field,
                     out[i] = 1
 
     else:
-        raise ValueError("Field {field} not supported".format(field=field))
+        raise ValueError(f"Field {field} not supported")
 
     return out.view(bool)
 
@@ -537,7 +536,7 @@ def get_date_field(const int64_t[:] dtindex, object field):
     elif field == 'is_leap_year':
         return isleapyear_arr(get_date_field(dtindex, 'Y'))
 
-    raise ValueError("Field %s not supported" % field)
+    raise ValueError(f"Field {field} not supported")
 
 
 @cython.wraparound(False)
@@ -653,7 +652,7 @@ def get_timedelta_field(const int64_t[:] tdindex, object field):
                 out[i] = tds.nanoseconds
         return out
 
-    raise ValueError("Field %s not supported" % field)
+    raise ValueError(f"Field {field} not supported")
 
 
 cpdef isleapyear_arr(ndarray years):
diff --git a/pandas/_libs/tslibs/frequencies.pxd b/pandas/_libs/tslibs/frequencies.pxd
index 4e7949e55c836..6ec67ce250505 100644
--- a/pandas/_libs/tslibs/frequencies.pxd
+++ b/pandas/_libs/tslibs/frequencies.pxd
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-cpdef object get_rule_month(object source, object default=*)
+cpdef str get_rule_month(object source, str default=*)
 
 cpdef get_freq_code(freqstr)
 cpdef object get_freq(object freq)
diff --git a/pandas/_libs/tslibs/frequencies.pyx b/pandas/_libs/tslibs/frequencies.pyx
index b29c841896072..d60f5cfd3f8c1 100644
--- a/pandas/_libs/tslibs/frequencies.pyx
+++ b/pandas/_libs/tslibs/frequencies.pyx
@@ -197,7 +197,7 @@ cpdef _base_and_stride(str freqstr):
     groups = opattern.match(freqstr)
 
     if not groups:
-        raise ValueError("Could not evaluate {freq}".format(freq=freqstr))
+        raise ValueError(f"Could not evaluate {freqstr}")
 
     stride = groups.group(1)
 
@@ -485,18 +485,18 @@ cdef bint _is_weekly(str rule):
 
 # ----------------------------------------------------------------------
 
-cpdef object get_rule_month(object source, object default='DEC'):
+cpdef str get_rule_month(object source, str default="DEC"):
     """
     Return starting month of given freq, default is December.
 
     Parameters
     ----------
     source : object
-    default : object (default "DEC")
+    default : str, default "DEC"
 
     Returns
     -------
-    rule_month: object (usually string)
+    rule_month: str
 
     Examples
     --------
diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index 8a5fee97de8e4..9f6f401a1a5f5 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -2,9 +2,12 @@ from cpython.object cimport (
     PyObject_RichCompare,
     Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE)
 
-from cpython.datetime cimport (datetime,
+from cpython.datetime cimport (datetime, timedelta,
                                PyDateTime_Check, PyDelta_Check,
                                PyDateTime_IMPORT)
+
+from cpython.version cimport PY_MINOR_VERSION
+
 PyDateTime_IMPORT
 
 import numpy as np
@@ -19,6 +22,7 @@ from pandas._libs.tslibs.util cimport (
     get_nat, is_integer_object, is_float_object, is_datetime64_object,
     is_timedelta64_object)
 
+
 # ----------------------------------------------------------------------
 # Constants
 nat_strings = {'NaT', 'nat', 'NAT', 'nan', 'NaN', 'NAN'}
@@ -95,10 +99,6 @@ cdef class _NaT(datetime):
     # higher than np.ndarray and np.matrix
     __array_priority__ = 100
 
-    def __hash__(_NaT self):
-        # py3k needs this defined here
-        return hash(self.value)
-
     def __richcmp__(_NaT self, object other, int op):
         cdef:
             int ndim = getattr(other, 'ndim', -1)
@@ -115,8 +115,8 @@ cdef class _NaT(datetime):
             if is_datetime64_object(other):
                 return _nat_scalar_rules[op]
             else:
-                raise TypeError('Cannot compare type %r with type %r' %
-                                (type(self).__name__, type(other).__name__))
+                raise TypeError(f'Cannot compare type {type(self).__name__} '
+                                f'with type {type(other).__name__}')
 
         # Note: instead of passing "other, self, _reverse_ops[op]", we observe
         # that `_nat_scalar_rules` is invariant under `_reverse_ops`,
@@ -150,8 +150,7 @@ cdef class _NaT(datetime):
                 result = np.empty(other.shape, dtype="datetime64[ns]")
                 result.fill("NaT")
                 return result
-            raise TypeError("Cannot add NaT to ndarray with dtype {dtype}"
-                            .format(dtype=other.dtype))
+            raise TypeError(f"Cannot add NaT to ndarray with dtype {other.dtype}")
 
         return NotImplemented
 
@@ -203,9 +202,8 @@ cdef class _NaT(datetime):
                 result.fill("NaT")
                 return result
 
-            raise TypeError(
-                "Cannot subtract NaT from ndarray with dtype {dtype}"
-                .format(dtype=other.dtype))
+            raise TypeError(f"Cannot subtract NaT from ndarray with "
+                            f"dtype {other.dtype}")
 
         return NotImplemented
 
@@ -230,16 +228,16 @@ cdef class _NaT(datetime):
         return NotImplemented
 
     @property
-    def asm8(self):
+    def asm8(self) -> np.datetime64:
         return np.datetime64(NPY_NAT, 'ns')
 
-    def to_datetime64(self):
+    def to_datetime64(self) -> np.datetime64:
         """
         Return a numpy.datetime64 object with 'ns' precision.
         """
         return np.datetime64('NaT', 'ns')
 
-    def to_numpy(self, dtype=None, copy=False):
+    def to_numpy(self, dtype=None, copy=False) -> np.datetime64:
         """
         Convert the Timestamp to a NumPy datetime64.
 
@@ -259,13 +257,13 @@ cdef class _NaT(datetime):
         """
         return self.to_datetime64()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return 'NaT'
 
-    def __str__(self):
+    def __str__(self) -> str:
         return 'NaT'
 
-    def isoformat(self, sep='T'):
+    def isoformat(self, sep='T') -> str:
         # This allows Timestamp(ts.isoformat()) to always correctly roundtrip.
         return 'NaT'
 
@@ -278,13 +276,6 @@ cdef class _NaT(datetime):
     def __long__(self):
         return NPY_NAT
 
-    def total_seconds(self):
-        """
-        Total duration of timedelta in seconds (to ns precision).
-        """
-        # GH#10939
-        return np.nan
-
     @property
     def is_leap_year(self):
         return False
@@ -328,7 +319,7 @@ class NaTType(_NaT):
 
     def __reduce_ex__(self, protocol):
         # python 3.6 compat
-        # http://bugs.python.org/issue28730
+        # https://bugs.python.org/issue28730
         # now __reduce_ex__ is defined and higher priority than __reduce__
         return self.__reduce__()
 
@@ -370,7 +361,6 @@ class NaTType(_NaT):
     days_in_month = property(fget=lambda self: np.nan)
     daysinmonth = property(fget=lambda self: np.nan)
     dayofweek = property(fget=lambda self: np.nan)
-    weekday_name = property(fget=lambda self: np.nan)
 
     # inject Timedelta properties
     days = property(fget=lambda self: np.nan)
@@ -389,6 +379,7 @@ class NaTType(_NaT):
     # nan methods
     weekday = _make_nan_func('weekday', datetime.weekday.__doc__)
     isoweekday = _make_nan_func('isoweekday', datetime.isoweekday.__doc__)
+    total_seconds = _make_nan_func('total_seconds', timedelta.total_seconds.__doc__)
     month_name = _make_nan_func('month_name',  # noqa:E128
         """
         Return the month name of the Timestamp with specified locale.
@@ -396,7 +387,7 @@ class NaTType(_NaT):
         Parameters
         ----------
         locale : string, default None (English locale)
-            locale determining the language in which to return the month name
+            Locale determining the language in which to return the month name.
 
         Returns
         -------
@@ -411,7 +402,7 @@ class NaTType(_NaT):
         Parameters
         ----------
         locale : string, default None (English locale)
-            locale determining the language in which to return the day name
+            Locale determining the language in which to return the day name.
 
         Returns
         -------
@@ -434,6 +425,10 @@ class NaTType(_NaT):
     tzname = _make_error_func('tzname', datetime)
     utcoffset = _make_error_func('utcoffset', datetime)
 
+    # "fromisocalendar" was introduced in 3.8
+    if PY_MINOR_VERSION >= 8:
+        fromisocalendar = _make_error_func('fromisocalendar', datetime)
+
     # ----------------------------------------------------------------------
     # The remaining methods have docstrings copy/pasted from the analogous
     # Timestamp methods.
@@ -464,7 +459,7 @@ class NaTType(_NaT):
         """
         Timestamp.combine(date, time)
 
-        date, time -> datetime with same date and time fields
+        date, time -> datetime with same date and time fields.
         """
     )
     utcnow = _make_error_func('utcnow',  # noqa:E128
@@ -503,17 +498,17 @@ class NaTType(_NaT):
         """
         Timestamp.fromordinal(ordinal, freq=None, tz=None)
 
-        passed an ordinal, translate and convert to a ts
-        note: by definition there cannot be any tz info on the ordinal itself
+        Passed an ordinal, translate and convert to a ts.
+        Note: by definition there cannot be any tz info on the ordinal itself.
 
         Parameters
         ----------
         ordinal : int
-            date corresponding to a proleptic Gregorian ordinal
+            Date corresponding to a proleptic Gregorian ordinal.
         freq : str, DateOffset
-            Offset which Timestamp will have
+            Offset to apply to the Timestamp.
         tz : str, pytz.timezone, dateutil.tz.tzfile or None
-            Time zone for time which Timestamp will have.
+            Time zone for the Timestamp.
         """)
 
     # _nat_methods
@@ -534,7 +529,7 @@ class NaTType(_NaT):
         Parameters
         ----------
         tz : str or timezone object, default None
-            Timezone to localize to
+            Timezone to localize to.
         """)
     today = _make_nat_func('today',  # noqa:E128
         """
@@ -547,35 +542,38 @@ class NaTType(_NaT):
         Parameters
         ----------
         tz : str or timezone object, default None
-            Timezone to localize to
+            Timezone to localize to.
         """)
     round = _make_nat_func('round',  # noqa:E128
         """
-        Round the Timestamp to the specified resolution
+        Round the Timestamp to the specified resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the rounding resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the rounding resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
@@ -589,71 +587,77 @@ default 'raise'
         """)
     floor = _make_nat_func('floor',  # noqa:E128
         """
-        return a new Timestamp floored to this resolution
+        return a new Timestamp floored to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the flooring resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the flooring resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
         Raises
         ------
-        ValueError if the freq cannot be converted
+        ValueError if the freq cannot be converted.
         """)
     ceil = _make_nat_func('ceil',  # noqa:E128
         """
-        return a new Timestamp ceiled to this resolution
+        return a new Timestamp ceiled to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the ceiling resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the ceiling resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
         Raises
         ------
-        ValueError if the freq cannot be converted
+        ValueError if the freq cannot be converted.
         """)
 
     tz_convert = _make_nat_func('tz_convert',  # noqa:E128
@@ -694,35 +698,30 @@ default 'raise'
             `ambiguous` parameter dictates how ambiguous times should be
             handled.
 
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
         nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
 default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            The behavior is as follows:
 
-            .. versionadded:: 0.24.0
-
-        errors : 'raise', 'coerce', default None
-            - 'raise' will raise a NonExistentTimeError if a timestamp is not
-               valid in the specified timezone (e.g. due to a transition from
-               or to DST time). Use ``nonexistent='raise'`` instead.
-            - 'coerce' will return NaT if the timestamp can not be converted
-              into the specified timezone. Use ``nonexistent='NaT'`` instead.
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
-              .. deprecated:: 0.24.0
+            .. versionadded:: 0.24.0
 
         Returns
         -------
@@ -735,7 +734,7 @@ default 'raise'
         """)
     replace = _make_nat_func('replace',  # noqa:E128
         """
-        implements datetime.replace, handles nanoseconds
+        implements datetime.replace, handles nanoseconds.
 
         Parameters
         ----------
diff --git a/pandas/_libs/tslibs/np_datetime.pxd b/pandas/_libs/tslibs/np_datetime.pxd
index 020bcdf0a7b15..ebedee79405e5 100644
--- a/pandas/_libs/tslibs/np_datetime.pxd
+++ b/pandas/_libs/tslibs/np_datetime.pxd
@@ -72,6 +72,6 @@ cdef npy_datetime get_datetime64_value(object obj) nogil
 cdef npy_timedelta get_timedelta64_value(object obj) nogil
 cdef NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil
 
-cdef int _string_to_dts(object val, npy_datetimestruct* dts,
+cdef int _string_to_dts(str val, npy_datetimestruct* dts,
                         int* out_local, int* out_tzoffset,
                         bint want_exc) except? -1
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index e76f84265a327..b59a1101e0bf7 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -112,11 +112,9 @@ cdef inline check_dts_bounds(npy_datetimestruct *dts):
         error = True
 
     if error:
-        fmt = '%d-%.2d-%.2d %.2d:%.2d:%.2d' % (dts.year, dts.month,
-                                               dts.day, dts.hour,
-                                               dts.min, dts.sec)
-        raise OutOfBoundsDatetime(
-            'Out of bounds nanosecond timestamp: {fmt}'.format(fmt=fmt))
+        fmt = (f'{dts.year}-{dts.month:02d}-{dts.day:02d} '
+               f'{dts.hour:02d}:{dts.min:02d}:{dts.sec:02d}')
+        raise OutOfBoundsDatetime(f'Out of bounds nanosecond timestamp: {fmt}')
 
 
 # ----------------------------------------------------------------------
@@ -169,7 +167,7 @@ cdef inline int64_t pydate_to_dt64(date val, npy_datetimestruct *dts):
     return dtstruct_to_dt64(dts)
 
 
-cdef inline int _string_to_dts(object val, npy_datetimestruct* dts,
+cdef inline int _string_to_dts(str val, npy_datetimestruct* dts,
                                int* out_local, int* out_tzoffset,
                                bint want_exc) except? -1:
     cdef:
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index aaefab6ee7ff6..48a3886c20a3a 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -1,6 +1,7 @@
 import cython
 
 import time
+from typing import Any
 from cpython.datetime cimport (PyDateTime_IMPORT,
                                PyDateTime_Check,
                                PyDelta_Check,
@@ -21,7 +22,10 @@ from pandas._libs.tslibs.util cimport is_integer_object
 
 from pandas._libs.tslibs.ccalendar import MONTHS, DAYS
 from pandas._libs.tslibs.ccalendar cimport get_days_in_month, dayofweek
-from pandas._libs.tslibs.conversion cimport pydt_to_i8, localize_pydatetime
+from pandas._libs.tslibs.conversion cimport (
+    convert_datetime_to_tsobject,
+    localize_pydatetime,
+)
 from pandas._libs.tslibs.nattype cimport NPY_NAT
 from pandas._libs.tslibs.np_datetime cimport (
     npy_datetimestruct, dtstruct_to_dt64, dt64_to_dtstruct)
@@ -66,16 +70,16 @@ need_suffix = ['QS', 'BQ', 'BQS', 'YS', 'AS', 'BY', 'BA', 'BYS', 'BAS']
 
 for __prefix in need_suffix:
     for _m in MONTHS:
-        key = '%s-%s' % (__prefix, _m)
+        key = f'{__prefix}-{_m}'
         _offset_to_period_map[key] = _offset_to_period_map[__prefix]
 
 for __prefix in ['A', 'Q']:
     for _m in MONTHS:
-        _alias = '%s-%s' % (__prefix, _m)
+        _alias = f'{__prefix}-{_m}'
         _offset_to_period_map[_alias] = _alias
 
 for _d in DAYS:
-    _offset_to_period_map['W-%s' % _d] = 'W-%s' % _d
+    _offset_to_period_map[f'W-{_d}'] = f'W-{_d}'
 
 
 # ---------------------------------------------------------------------
@@ -215,7 +219,7 @@ def _get_calendar(weekmask, holidays, calendar):
         holidays = holidays + calendar.holidays().tolist()
     except AttributeError:
         pass
-    holidays = [_to_dt64(dt, dtype='datetime64[D]') for dt in holidays]
+    holidays = [_to_dt64D(dt) for dt in holidays]
     holidays = tuple(sorted(holidays))
 
     kwargs = {'weekmask': weekmask}
@@ -226,19 +230,22 @@ def _get_calendar(weekmask, holidays, calendar):
     return busdaycalendar, holidays
 
 
-def _to_dt64(dt, dtype='datetime64'):
+def _to_dt64D(dt):
     # Currently
     # > np.datetime64(dt.datetime(2013,5,1),dtype='datetime64[D]')
     # numpy.datetime64('2013-05-01T02:00:00.000000+0200')
     # Thus astype is needed to cast datetime to datetime64[D]
     if getattr(dt, 'tzinfo', None) is not None:
-        i8 = pydt_to_i8(dt)
+        # Get the nanosecond timestamp,
+        #  equiv `Timestamp(dt).value` or `dt.timestamp() * 10**9`
+        nanos = getattr(dt, "nanosecond", 0)
+        i8 = convert_datetime_to_tsobject(dt, tz=None, nanos=nanos).value
         dt = tz_convert_single(i8, UTC, dt.tzinfo)
         dt = np.int64(dt).astype('datetime64[ns]')
     else:
         dt = np.datetime64(dt)
-    if dt.dtype.name != dtype:
-        dt = dt.astype(dtype)
+    if dt.dtype.name != "datetime64[D]":
+        dt = dt.astype("datetime64[D]")
     return dt
 
 
@@ -328,7 +335,7 @@ class _BaseOffset:
     def __setattr__(self, name, value):
         raise AttributeError("DateOffset objects are immutable.")
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             try:
                 # GH#23524 if to_offset fails, we are dealing with an
@@ -363,7 +370,7 @@ class _BaseOffset:
         attrs = [(k, v) for k, v in all_paras.items()
                  if (k not in exclude) and (k[0] != '_')]
         attrs = sorted(set(attrs))
-        params = tuple([str(self.__class__)] + attrs)
+        params = tuple([str(type(self))] + attrs)
         return params
 
     @property
@@ -422,7 +429,7 @@ class _BaseOffset:
         # that allows us to use methods that can go in a `cdef class`
         return self * 1
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         className = getattr(self, '_outputName', type(self).__name__)
 
         if abs(self.n) != 1:
@@ -432,9 +439,9 @@ class _BaseOffset:
 
         n_str = ""
         if self.n != 1:
-            n_str = "%s * " % self.n
+            n_str = f"{self.n} * "
 
-        out = '<%s' % n_str + className + plural + self._repr_attrs() + '>'
+        out = f'<{n_str}{className}{plural}{self._repr_attrs()}>'
         return out
 
     def _get_offset_day(self, datetime other):
@@ -460,16 +467,13 @@ class _BaseOffset:
         ValueError if n != int(n)
         """
         if util.is_timedelta64_object(n):
-            raise TypeError('`n` argument must be an integer, '
-                            'got {ntype}'.format(ntype=type(n)))
+            raise TypeError(f'`n` argument must be an integer, got {type(n)}')
         try:
             nint = int(n)
         except (ValueError, TypeError):
-            raise TypeError('`n` argument must be an integer, '
-                            'got {ntype}'.format(ntype=type(n)))
+            raise TypeError(f'`n` argument must be an integer, got {type(n)}')
         if n != nint:
-            raise ValueError('`n` argument must be an integer, '
-                             'got {n}'.format(n=n))
+            raise ValueError(f'`n` argument must be an integer, got {n}')
         return nint
 
     def __setstate__(self, state):
@@ -935,7 +939,7 @@ def shift_month(stamp: datetime, months: int,
 
 cpdef int get_day_of_month(datetime other, day_opt) except? -1:
     """
-    Find the day in `other`'s month that satisfies a DateOffset's onOffset
+    Find the day in `other`'s month that satisfies a DateOffset's is_on_offset
     policy, as described by the `day_opt` argument.
 
     Parameters
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index d099a77a77044..ebdf7a1e29216 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -3,7 +3,6 @@ Parsing functions for datetime and datetime-like strings.
 """
 import re
 import time
-from io import StringIO
 
 from libc.string cimport strchr
 
@@ -11,9 +10,8 @@ import cython
 from cython import Py_ssize_t
 
 from cpython.object cimport PyObject_Str
-from cpython.unicode cimport PyUnicode_Join
 
-from cpython.datetime cimport datetime, datetime_new, import_datetime
+from cpython.datetime cimport datetime, datetime_new, import_datetime, tzinfo
 from cpython.version cimport PY_VERSION_HEX
 import_datetime()
 
@@ -37,6 +35,7 @@ from pandas._config import get_option
 from pandas._libs.tslibs.ccalendar import MONTH_NUMBERS
 from pandas._libs.tslibs.nattype import nat_strings, NaT
 from pandas._libs.tslibs.util cimport is_array, get_c_string_buf_and_size
+from pandas._libs.tslibs.frequencies cimport get_rule_month
 
 cdef extern from "../src/headers/portable.h":
     int getdigit_ascii(char c, int default) nogil
@@ -86,16 +85,15 @@ cdef inline int _parse_4digit(const char* s):
     return result
 
 
-cdef inline object _parse_delimited_date(object date_string, bint dayfirst):
+cdef inline object _parse_delimited_date(str date_string, bint dayfirst):
     """
     Parse special cases of dates: MM/DD/YYYY, DD/MM/YYYY, MM/YYYY.
+
     At the beginning function tries to parse date in MM/DD/YYYY format, but
     if month > 12 - in DD/MM/YYYY (`dayfirst == False`).
     With `dayfirst == True` function makes an attempt to parse date in
-    DD/MM/YYYY, if an attemp is wrong - in DD/MM/YYYY
+    DD/MM/YYYY, if an attempt is wrong - in DD/MM/YYYY
 
-    Note
-    ----
     For MM/DD/YYYY, DD/MM/YYYY: delimiter can be a space or one of /-.
     For MM/YYYY: delimiter can be a space or one of /-
     If `date_string` can't be converted to date, then function returns
@@ -104,11 +102,13 @@ cdef inline object _parse_delimited_date(object date_string, bint dayfirst):
     Parameters
     ----------
     date_string : str
-    dayfirst : bint
+    dayfirst : bool
 
     Returns:
     --------
-    datetime, resolution
+    datetime or None
+    str or None
+        Describing resolution of the parsed string.
     """
     cdef:
         const char* buf
@@ -153,21 +153,22 @@ cdef inline object _parse_delimited_date(object date_string, bint dayfirst):
             return datetime_new(year, month, day, 0, 0, 0, 0, None), reso
         return datetime(year, month, day, 0, 0, 0, 0, None), reso
 
-    raise DateParseError("Invalid date specified ({}/{})".format(month, day))
+    raise DateParseError(f"Invalid date specified ({month}/{day})")
 
 
-cdef inline bint does_string_look_like_time(object parse_string):
+cdef inline bint does_string_look_like_time(str parse_string):
     """
     Checks whether given string is a time: it has to start either from
     H:MM or from HH:MM, and hour and minute values must be valid.
 
     Parameters
     ----------
-    date_string : str
+    parse_string : str
 
     Returns:
     --------
-    whether given string is a time
+    bool
+        Whether given string is potentially a time.
     """
     cdef:
         const char* buf
@@ -188,9 +189,10 @@ cdef inline bint does_string_look_like_time(object parse_string):
     return 0 <= hour <= 23 and 0 <= minute <= 59
 
 
-def parse_datetime_string(date_string, freq=None, dayfirst=False,
+def parse_datetime_string(date_string: str, freq=None, dayfirst=False,
                           yearfirst=False, **kwargs):
-    """parse datetime string, only returns datetime.
+    """
+    Parse datetime string, only returns datetime.
     Also cares special handling matching time patterns.
 
     Returns
@@ -215,7 +217,7 @@ def parse_datetime_string(date_string, freq=None, dayfirst=False,
         return dt
 
     try:
-        dt, _, _ = _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
+        dt, _ = _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
         return dt
     except DateParseError:
         raise
@@ -233,7 +235,7 @@ def parse_datetime_string(date_string, freq=None, dayfirst=False,
     return dt
 
 
-def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
+def parse_time_string(arg: str, freq=None, dayfirst=None, yearfirst=None):
     """
     Try hard to parse datetime string, leveraging dateutil plus some extra
     goodies like quarter recognition.
@@ -252,10 +254,8 @@ def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
     -------
     datetime, datetime/dateutil.parser._result, str
     """
-    if not isinstance(arg, (str, unicode)):
-        # Note: cython recognizes `unicode` in both py2/py3, optimizes
-        # this check into a C call.
-        return arg
+    if not isinstance(arg, str):
+        raise TypeError("parse_time_string argument must be str")
 
     if getattr(freq, "_typ", None) == "dateoffset":
         freq = freq.rule_code
@@ -272,16 +272,16 @@ def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
     return res
 
 
-cdef parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
+cdef parse_datetime_string_with_reso(str date_string, freq=None, dayfirst=False,
                                      yearfirst=False):
-    """parse datetime string, only returns datetime
+    """
+    Parse datetime string and try to identify its resolution.
 
     Returns
     -------
-    parsed : datetime
-    parsed2 : datetime/dateutil.parser._result
-    reso : str
-        inferred resolution
+    datetime
+    str
+        Inferred resolution of the parsed string.
 
     Raises
     ------
@@ -296,7 +296,7 @@ cdef parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
 
     parsed, reso = _parse_delimited_date(date_string, dayfirst)
     if parsed is not None:
-        return parsed, parsed, reso
+        return parsed, reso
 
     try:
         return _parse_dateabbr_string(date_string, _DEFAULT_DATETIME, freq)
@@ -309,26 +309,27 @@ cdef parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
         parsed, reso = dateutil_parse(date_string, _DEFAULT_DATETIME,
                                       dayfirst=dayfirst, yearfirst=yearfirst,
                                       ignoretz=False, tzinfos=None)
-    except Exception as e:
+    except (ValueError, OverflowError) as err:
         # TODO: allow raise of errors within instead
-        raise DateParseError(e)
+        raise DateParseError(err)
     if parsed is None:
-        raise DateParseError("Could not parse {dstr}".format(dstr=date_string))
-    return parsed, parsed, reso
+        raise DateParseError(f"Could not parse {date_string}")
+    return parsed, reso
 
 
-cpdef bint _does_string_look_like_datetime(object py_string):
+cpdef bint _does_string_look_like_datetime(str py_string):
     """
     Checks whether given string is a datetime: it has to start with '0' or
     be greater than 1000.
 
     Parameters
     ----------
-    py_string: object
+    py_string: str
 
     Returns
     -------
-    whether given string is a datetime
+    bool
+        Whether given string is potentially a datetime.
     """
     cdef:
         const char *buf
@@ -370,13 +371,10 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
         int year, quarter = -1, month, mnum, date_len
 
     # special handling for possibilities eg, 2Q2005, 2Q05, 2005Q1, 05Q1
-    assert isinstance(date_string, (str, unicode))
-
-    # len(date_string) == 0
-    # should be NaT???
+    assert isinstance(date_string, str)
 
     if date_string in nat_strings:
-        return NaT, NaT, ''
+        return NaT, ''
 
     date_string = date_string.upper()
     date_len = len(date_string)
@@ -385,7 +383,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
         # parse year only like 2000
         try:
             ret = default.replace(year=int(date_string))
-            return ret, ret, 'year'
+            return ret, 'year'
         except ValueError:
             pass
 
@@ -422,18 +420,18 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
                     raise ValueError
 
             if not (1 <= quarter <= 4):
-                msg = ('Incorrect quarterly string is given, quarter must be '
-                       'between 1 and 4: {dstr}')
-                raise DateParseError(msg.format(dstr=date_string))
+                raise DateParseError(f'Incorrect quarterly string is given, '
+                                     f'quarter must be '
+                                     f'between 1 and 4: {date_string}')
 
             if freq is not None:
                 # hack attack, #1228
                 try:
-                    mnum = MONTH_NUMBERS[_get_rule_month(freq)] + 1
+                    mnum = MONTH_NUMBERS[get_rule_month(freq)] + 1
                 except (KeyError, ValueError):
-                    msg = ('Unable to retrieve month information from given '
-                           'freq: {freq}'.format(freq=freq))
-                    raise DateParseError(msg)
+                    raise DateParseError(f'Unable to retrieve month '
+                                         f'information from given '
+                                         f'freq: {freq}')
 
                 month = (mnum + (quarter - 1) * 3) % 12 + 1
                 if month > mnum:
@@ -442,7 +440,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
                 month = (quarter - 1) * 3 + 1
 
             ret = default.replace(year=year, month=month)
-            return ret, ret, 'quarter'
+            return ret, 'quarter'
 
     except DateParseError:
         raise
@@ -455,39 +453,33 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
         month = int(date_string[4:6])
         try:
             ret = default.replace(year=year, month=month)
-            return ret, ret, 'month'
+            return ret, 'month'
         except ValueError:
             pass
 
     for pat in ['%Y-%m', '%b %Y', '%b-%Y']:
         try:
             ret = datetime.strptime(date_string, pat)
-            return ret, ret, 'month'
+            return ret, 'month'
         except ValueError:
             pass
 
-    raise ValueError('Unable to parse {0}'.format(date_string))
+    raise ValueError(f'Unable to parse {date_string}')
 
 
-cdef dateutil_parse(object timestr, object default, ignoretz=False,
+cdef dateutil_parse(str timestr, object default, ignoretz=False,
                     tzinfos=None, dayfirst=None, yearfirst=None):
     """ lifted from dateutil to get resolution"""
 
     cdef:
-        object fobj, res, attr, ret, tzdata
+        object res, attr, ret, tzdata
         object reso = None
         dict repl = {}
 
-    fobj = StringIO(str(timestr))
-    res = DEFAULTPARSER._parse(fobj, dayfirst=dayfirst, yearfirst=yearfirst)
-
-    # dateutil 2.2 compat
-    if isinstance(res, tuple):  # PyTuple_Check
-        res, _ = res
+    res, _ = DEFAULTPARSER._parse(timestr, dayfirst=dayfirst, yearfirst=yearfirst)
 
     if res is None:
-        msg = "Unknown datetime string format, unable to parse: {timestr}"
-        raise ValueError(msg.format(timestr=timestr))
+        raise ValueError(f"Unknown datetime string format, unable to parse: {timestr}")
 
     for attr in ["year", "month", "day", "hour",
                  "minute", "second", "microsecond"]:
@@ -497,8 +489,7 @@ cdef dateutil_parse(object timestr, object default, ignoretz=False,
             reso = attr
 
     if reso is None:
-        msg = "Unable to parse datetime string: {timestr}"
-        raise ValueError(msg.format(timestr=timestr))
+        raise ValueError(f"Unable to parse datetime string: {timestr}")
 
     if reso == 'microsecond':
         if repl['microsecond'] == 0:
@@ -511,20 +502,22 @@ cdef dateutil_parse(object timestr, object default, ignoretz=False,
         ret = ret + relativedelta.relativedelta(weekday=res.weekday)
     if not ignoretz:
         if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
+            # Note: as of 1.0 this is not reached because
+            #  we never pass tzinfos, see GH#22234
             if callable(tzinfos):
                 tzdata = tzinfos(res.tzname, res.tzoffset)
             else:
                 tzdata = tzinfos.get(res.tzname)
-            if isinstance(tzdata, datetime.tzinfo):
-                tzinfo = tzdata
-            elif isinstance(tzdata, (str, unicode)):
-                tzinfo = _dateutil_tzstr(tzdata)
+            if isinstance(tzdata, tzinfo):
+                new_tzinfo = tzdata
+            elif isinstance(tzdata, str):
+                new_tzinfo = _dateutil_tzstr(tzdata)
             elif isinstance(tzdata, int):
-                tzinfo = tzoffset(res.tzname, tzdata)
+                new_tzinfo = tzoffset(res.tzname, tzdata)
             else:
                 raise ValueError("offset must be tzinfo subclass, "
                                  "tz string, or int offset")
-            ret = ret.replace(tzinfo=tzinfo)
+            ret = ret.replace(tzinfo=new_tzinfo)
         elif res.tzname and res.tzname in time.tzname:
             ret = ret.replace(tzinfo=_dateutil_tzlocal())
         elif res.tzoffset == 0:
@@ -534,27 +527,6 @@ cdef dateutil_parse(object timestr, object default, ignoretz=False,
     return ret, reso
 
 
-cdef object _get_rule_month(object source, object default='DEC'):
-    """
-    Return starting month of given freq, default is December.
-
-    Example
-    -------
-    >>> _get_rule_month('D')
-    'DEC'
-
-    >>> _get_rule_month('A-JAN')
-    'JAN'
-    """
-    if hasattr(source, 'freqstr'):
-        source = source.freqstr
-    source = source.upper()
-    if '-' not in source:
-        return default
-    else:
-        return source.split('-')[1]
-
-
 # ----------------------------------------------------------------------
 # Parsing for type-inference
 
@@ -583,7 +555,7 @@ def try_parse_dates(object[:] values, parser=None,
                 else:
                     result[i] = parse_date(values[i])
         except Exception:
-            # failed
+            # Since parser is user-defined, we can't guess what it might raise
             return values
     else:
         parse_date = parser
@@ -712,7 +684,7 @@ class _timelex:
         elif getattr(instream, 'read', None) is None:
             raise TypeError(
                 'Parser must be a string or character stream, not '
-                '{itype}'.format(itype=instream.__class__.__name__))
+                f'{type(instream).__name__}')
         else:
             self.stream = instream.read()
 
@@ -732,7 +704,7 @@ class _timelex:
         stream = self.stream.replace('\x00', '')
 
         # TODO: Change \s --> \s+ (this doesn't match existing behavior)
-        # TODO: change the punctuation block to punc+ (doesnt match existing)
+        # TODO: change the punctuation block to punc+ (does not match existing)
         # TODO: can we merge the two digit patterns?
         tokens = re.findall('\s|'
                             '(?<![\.\d])\d+\.\d+(?![\.\d])'
@@ -943,14 +915,14 @@ def _concat_date_cols(tuple date_cols, bint keep_trivial_numbers=True):
 
     Parameters
     ----------
-    date_cols : tuple of numpy arrays
+    date_cols : tuple[ndarray]
     keep_trivial_numbers : bool, default True
         if True and len(date_cols) == 1, then
         conversion (to string from integer/float zero) is not performed
 
     Returns
     -------
-    arr_of_rows : ndarray (dtype=object)
+    arr_of_rows : ndarray[object]
 
     Examples
     --------
@@ -989,12 +961,12 @@ def _concat_date_cols(tuple date_cols, bint keep_trivial_numbers=True):
                                                       keep_trivial_numbers)
             PyArray_ITER_NEXT(it)
     else:
-        # create fixed size list - more effecient memory allocation
+        # create fixed size list - more efficient memory allocation
         list_to_join = [None] * col_count
         iters = np.zeros(col_count, dtype=object)
 
         # create memoryview of iters ndarray, that will contain some
-        # flatiter's for each array in `date_cols` - more effecient indexing
+        # flatiter's for each array in `date_cols` - more efficient indexing
         iters_view = iters
         for col_idx, array in enumerate(date_cols):
             iters_view[col_idx] = PyArray_IterNew(array)
@@ -1008,6 +980,6 @@ def _concat_date_cols(tuple date_cols, bint keep_trivial_numbers=True):
                 item = PyArray_GETITEM(array, PyArray_ITER_DATA(it))
                 list_to_join[col_idx] = convert_to_unicode(item, False)
                 PyArray_ITER_NEXT(it)
-            result_view[row_idx] = PyUnicode_Join(' ', list_to_join)
+            result_view[row_idx] = " ".join(list_to_join)
 
     return result
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index 697e97e518b13..9419f0eba39aa 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -22,7 +22,7 @@ PyDateTime_IMPORT
 from pandas._libs.tslibs.np_datetime cimport (
     npy_datetimestruct, dtstruct_to_dt64, dt64_to_dtstruct,
     pandas_datetime_to_datetimestruct, check_dts_bounds,
-    NPY_DATETIMEUNIT, NPY_FR_D)
+    NPY_DATETIMEUNIT, NPY_FR_D, NPY_FR_us)
 
 cdef extern from "src/datetime/np_datetime.h":
     int64_t npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT fr,
@@ -272,6 +272,8 @@ cdef int64_t DtoB_weekday(int64_t unix_date) nogil:
 
 cdef int64_t DtoB(npy_datetimestruct *dts, int roll_back,
                   int64_t unix_date) nogil:
+    # calculate the current week (counting from 1970-01-01) treating
+    # sunday as last day of a week
     cdef:
         int day_of_week = dayofweek(dts.year, dts.month, dts.day)
 
@@ -473,9 +475,6 @@ cdef int DtoQ_yq(int64_t ordinal, asfreq_info *af_info, int *year) nogil:
         int quarter
 
     pandas_datetime_to_datetimestruct(ordinal, NPY_FR_D, &dts)
-    # TODO: Another version of this function used
-    # date_info_from_days_and_time(&dts, unix_date, 0)
-    # instead of pandas_datetime_to_datetimestruct; is one more performant?
     if af_info.to_end != 12:
         dts.month -= af_info.to_end
         if dts.month <= 0:
@@ -509,14 +508,18 @@ cdef int64_t asfreq_DTtoM(int64_t ordinal, asfreq_info *af_info) nogil:
 
 cdef int64_t asfreq_DTtoW(int64_t ordinal, asfreq_info *af_info) nogil:
     ordinal = downsample_daytime(ordinal, af_info)
-    return (ordinal + 3 - af_info.to_end) // 7 + 1
+    return unix_date_to_week(ordinal, af_info.to_end)
+
+
+cdef int64_t unix_date_to_week(int64_t unix_date, int to_end) nogil:
+    return (unix_date + 3 - to_end) // 7 + 1
 
 
 # --------------------------------------------------------------------
 # Conversion _from_ BusinessDay Freq
 
 cdef int64_t asfreq_BtoDT(int64_t ordinal, asfreq_info *af_info) nogil:
-    ordinal = ((ordinal + 3) // 5) * 7 + (ordinal + 3) % 5 -3
+    ordinal = ((ordinal + 3) // 5) * 7 + (ordinal + 3) % 5 - 3
     return upsample_daytime(ordinal, af_info)
 
 
@@ -753,14 +756,7 @@ cdef int64_t get_period_ordinal(npy_datetimestruct *dts, int freq) nogil:
         if fmonth == 0:
             fmonth = 12
 
-        mdiff = dts.month - fmonth
-        # TODO: Aren't the next two conditions equivalent to
-        # unconditional incrementing?
-        if mdiff < 0:
-            mdiff += 12
-        if dts.month >= fmonth:
-            mdiff += 12
-
+        mdiff = dts.month - fmonth + 12
         return (dts.year - 1970) * 4 + (mdiff - 1) // 3
 
     elif freq == FR_MTH:
@@ -797,23 +793,10 @@ cdef int64_t get_period_ordinal(npy_datetimestruct *dts, int freq) nogil:
         return unix_date
 
     elif freq == FR_BUS:
-        # calculate the current week (counting from 1970-01-01) treating
-        # sunday as last day of a week
-        weeks = (unix_date + 3) // 7
-        # calculate the current weekday (in range 1 .. 7)
-        delta = (unix_date + 3) % 7 + 1
-        # return the number of business days in full weeks plus the business
-        # days in the last - possible partial - week
-        if delta <= 5:
-            return (5 * weeks) + delta - 4
-        else:
-            return (5 * weeks) + (5 + 1) - 4
+        return DtoB(dts, 0, unix_date)
 
     elif freq_group == FR_WK:
-        day_adj = freq - FR_WK
-        return (unix_date + 3 - day_adj) // 7 + 1
-
-    # raise ValueError
+        return unix_date_to_week(unix_date, freq - FR_WK)
 
 
 cdef void get_date_info(int64_t ordinal, int freq,
@@ -983,7 +966,7 @@ cdef inline int month_to_quarter(int month) nogil:
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def dt64arr_to_periodarr(int64_t[:] dtarr, int freq, tz=None):
+def dt64arr_to_periodarr(const int64_t[:] dtarr, int freq, tz=None):
     """
     Convert array of datetime64 values (passed in as 'i8' dtype) to a set of
     periods corresponding to desired frequency, per period convention.
@@ -1186,17 +1169,25 @@ cdef int64_t period_ordinal_to_dt64(int64_t ordinal, int freq) except? -1:
     if ordinal == NPY_NAT:
         return NPY_NAT
 
-    get_date_info(ordinal, freq, &dts)
+    if freq == 11000:
+        # Microsecond, avoid get_date_info to prevent floating point errors
+        pandas_datetime_to_datetimestruct(ordinal, NPY_FR_us, &dts)
+    else:
+        get_date_info(ordinal, freq, &dts)
+
     check_dts_bounds(&dts)
     return dtstruct_to_dt64(&dts)
 
 
-def period_format(int64_t value, int freq, object fmt=None):
+cdef str period_format(int64_t value, int freq, object fmt=None):
     cdef:
         int freq_group
 
     if value == NPY_NAT:
-        return repr(NaT)
+        return "NaT"
+
+    if isinstance(fmt, str):
+        fmt = fmt.encode("utf-8")
 
     if fmt is None:
         freq_group = get_freq_group(freq)
@@ -1209,8 +1200,7 @@ def period_format(int64_t value, int freq, object fmt=None):
         elif freq_group == 4000:  # WK
             left = period_asfreq(value, freq, 6000, 0)
             right = period_asfreq(value, freq, 6000, 1)
-            return '%s/%s' % (period_format(left, 6000),
-                              period_format(right, 6000))
+            return f"{period_format(left, 6000)}/{period_format(right, 6000)}"
         elif (freq_group == 5000      # BUS
               or freq_group == 6000):  # DAY
             fmt = b'%Y-%m-%d'
@@ -1227,7 +1217,7 @@ def period_format(int64_t value, int freq, object fmt=None):
         elif freq_group == 12000:  # NANOSEC
             fmt = b'%Y-%m-%d %H:%M:%S.%n'
         else:
-            raise ValueError('Unknown freq: {freq}'.format(freq=freq))
+            raise ValueError(f"Unknown freq: {freq}")
 
     return _period_strftime(value, freq, fmt)
 
@@ -1242,24 +1232,22 @@ cdef list extra_fmts = [(b"%q", b"^`AB`^"),
 cdef list str_extra_fmts = ["^`AB`^", "^`CD`^", "^`EF`^",
                             "^`GH`^", "^`IJ`^", "^`KL`^"]
 
-cdef object _period_strftime(int64_t value, int freq, object fmt):
+cdef str _period_strftime(int64_t value, int freq, bytes fmt):
     cdef:
         Py_ssize_t i
         npy_datetimestruct dts
         char *formatted
-        object pat, repl, result
+        bytes pat, brepl
         list found_pat = [False] * len(extra_fmts)
         int year, quarter
-
-    if isinstance(fmt, unicode):
-        fmt = fmt.encode('utf-8')
+        str result, repl
 
     get_date_info(value, freq, &dts)
     for i in range(len(extra_fmts)):
         pat = extra_fmts[i][0]
-        repl = extra_fmts[i][1]
+        brepl = extra_fmts[i][1]
         if pat in fmt:
-            fmt = fmt.replace(pat, repl)
+            fmt = fmt.replace(pat, brepl)
             found_pat[i] = True
 
     formatted = c_strftime(&dts, <char*>fmt)
@@ -1273,17 +1261,17 @@ cdef object _period_strftime(int64_t value, int freq, object fmt):
                 raise ValueError('Unable to get quarter and year')
 
             if i == 0:
-                repl = '%d' % quarter
+                repl = str(quarter)
             elif i == 1:  # %f, 2-digit year
-                repl = '%.2d' % (year % 100)
+                repl = f"{(year % 100):02d}"
             elif i == 2:
-                repl = '%d' % year
+                repl = str(year)
             elif i == 3:
-                repl = '%03d' % (value % 1000)
+                repl = f"{(value % 1_000):03d}"
             elif i == 4:
-                repl = '%06d' % (value % 1000000)
+                repl = f"{(value % 1_000_000):06d}"
             elif i == 5:
-                repl = '%09d' % (value % 1000000000)
+                repl = f"{(value % 1_000_000_000):09d}"
 
             result = result.replace(str_extra_fmts[i], repl)
 
@@ -1383,7 +1371,7 @@ cdef int pdays_in_month(int64_t ordinal, int freq):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def get_period_field_arr(int code, int64_t[:] arr, int freq):
+def get_period_field_arr(int code, const int64_t[:] arr, int freq):
     cdef:
         Py_ssize_t i, sz
         int64_t[:] out
@@ -1391,7 +1379,7 @@ def get_period_field_arr(int code, int64_t[:] arr, int freq):
 
     func = _get_accessor_func(code)
     if func is NULL:
-        raise ValueError('Unrecognized period code: {code}'.format(code=code))
+        raise ValueError(f"Unrecognized period code: {code}")
 
     sz = len(arr)
     out = np.empty(sz, dtype=np.int64)
@@ -1496,7 +1484,7 @@ def extract_freq(ndarray[object] values):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-cdef int64_t[:] localize_dt64arr_to_period(int64_t[:] stamps,
+cdef int64_t[:] localize_dt64arr_to_period(const int64_t[:] stamps,
                                            int freq, object tz):
     cdef:
         Py_ssize_t n = len(stamps)
@@ -1578,14 +1566,13 @@ cdef class _Period:
         freq = to_offset(freq)
 
         if freq.n <= 0:
-            raise ValueError('Frequency must be positive, because it'
-                             ' represents span: {freqstr}'
-                             .format(freqstr=freq.freqstr))
+            raise ValueError("Frequency must be positive, because it "
+                             f"represents span: {freq.freqstr}")
 
         return freq
 
     @classmethod
-    def _from_ordinal(cls, ordinal, freq):
+    def _from_ordinal(cls, ordinal: int, freq) -> "Period":
         """
         Fast creation from an ordinal and freq that are already validated!
         """
@@ -1614,9 +1601,8 @@ cdef class _Period:
                 return NotImplemented
             elif op == Py_NE:
                 return NotImplemented
-            raise TypeError('Cannot compare type {cls} with type {typ}'
-                            .format(cls=type(self).__name__,
-                                    typ=type(other).__name__))
+            raise TypeError(f"Cannot compare type {type(self).__name__} "
+                            f"with type {type(other).__name__}")
 
     def __hash__(self):
         return hash((self.ordinal, self.freqstr))
@@ -1634,8 +1620,8 @@ cdef class _Period:
                 if nanos % offset_nanos == 0:
                     ordinal = self.ordinal + (nanos // offset_nanos)
                     return Period(ordinal=ordinal, freq=self.freq)
-            msg = 'Input cannot be converted to Period(freq={0})'
-            raise IncompatibleFrequency(msg.format(self.freqstr))
+            raise IncompatibleFrequency("Input cannot be converted to "
+                                        f"Period(freq={self.freqstr})")
         elif util.is_offset_object(other):
             freqstr = other.rule_code
             base = get_base_alias(freqstr)
@@ -1665,9 +1651,8 @@ cdef class _Period:
                 # GH#17983
                 sname = type(self).__name__
                 oname = type(other).__name__
-                raise TypeError("unsupported operand type(s) for +: '{self}' "
-                                "and '{other}'".format(self=sname,
-                                                       other=oname))
+                raise TypeError(f"unsupported operand type(s) for +: '{sname}' "
+                                f"and '{oname}'")
             else:  # pragma: no cover
                 return NotImplemented
         elif is_period_object(other):
@@ -1707,16 +1692,16 @@ cdef class _Period:
         else:
             return NotImplemented
 
-    def asfreq(self, freq, how='E'):
+    def asfreq(self, freq, how='E') -> "Period":
         """
-        Convert Period to desired frequency, either at the start or end of the
-        interval
+        Convert Period to desired frequency, at the start or end of the interval.
 
         Parameters
         ----------
-        freq : string
+        freq : str
+            The desired frequency.
         how : {'E', 'S', 'end', 'start'}, default 'end'
-            Start or end of the timespan
+            Start or end of the timespan.
 
         Returns
         -------
@@ -1738,7 +1723,7 @@ cdef class _Period:
         return Period(ordinal=ordinal, freq=freq)
 
     @property
-    def start_time(self):
+    def start_time(self) -> Timestamp:
         """
         Get the Timestamp for the start of the period.
 
@@ -1768,25 +1753,27 @@ cdef class _Period:
         return self.to_timestamp(how='S')
 
     @property
-    def end_time(self):
+    def end_time(self) -> Timestamp:
         # freq.n can't be negative or 0
         # ordinal = (self + self.freq.n).start_time.value - 1
         ordinal = (self + self.freq).start_time.value - 1
         return Timestamp(ordinal)
 
-    def to_timestamp(self, freq=None, how='start', tz=None):
+    def to_timestamp(self, freq=None, how='start', tz=None) -> Timestamp:
         """
-        Return the Timestamp representation of the Period at the target
-        frequency at the specified end (how) of the Period
+        Return the Timestamp representation of the Period.
+
+        Uses the target frequency specified at the part of the period specified
+        by `how`, which is either `Start` or `Finish`.
 
         Parameters
         ----------
-        freq : string or DateOffset
+        freq : str or DateOffset
             Target frequency. Default is 'D' if self.freq is week or
-            longer and 'S' otherwise
+            longer and 'S' otherwise.
         how : str, default 'S' (start)
-            'S', 'E'. Can be aliased as case insensitive
-            'Start', 'Finish', 'Begin', 'End'
+            One of 'S', 'E'. Can be aliased as case insensitive
+            'Start', 'Finish', 'Begin', 'End'.
 
         Returns
         -------
@@ -1812,17 +1799,17 @@ cdef class _Period:
         return Timestamp(dt64, tz=tz)
 
     @property
-    def year(self):
+    def year(self) -> int:
         base, mult = get_freq_code(self.freq)
         return pyear(self.ordinal, base)
 
     @property
-    def month(self):
+    def month(self) -> int:
         base, mult = get_freq_code(self.freq)
         return pmonth(self.ordinal, base)
 
     @property
-    def day(self):
+    def day(self) -> int:
         """
         Get day of the month that a Period falls on.
 
@@ -1845,7 +1832,7 @@ cdef class _Period:
         return pday(self.ordinal, base)
 
     @property
-    def hour(self):
+    def hour(self) -> int:
         """
         Get the hour of the day component of the Period.
 
@@ -1875,7 +1862,7 @@ cdef class _Period:
         return phour(self.ordinal, base)
 
     @property
-    def minute(self):
+    def minute(self) -> int:
         """
         Get minute of the hour component of the Period.
 
@@ -1899,7 +1886,7 @@ cdef class _Period:
         return pminute(self.ordinal, base)
 
     @property
-    def second(self):
+    def second(self) -> int:
         """
         Get the second component of the Period.
 
@@ -1923,12 +1910,12 @@ cdef class _Period:
         return psecond(self.ordinal, base)
 
     @property
-    def weekofyear(self):
+    def weekofyear(self) -> int:
         base, mult = get_freq_code(self.freq)
         return pweek(self.ordinal, base)
 
     @property
-    def week(self):
+    def week(self) -> int:
         """
         Get the week of the year on the given Period.
 
@@ -1958,7 +1945,7 @@ cdef class _Period:
         return self.weekofyear
 
     @property
-    def dayofweek(self):
+    def dayofweek(self) -> int:
         """
         Day of the week the period lies in, with Monday=0 and Sunday=6.
 
@@ -2009,7 +1996,7 @@ cdef class _Period:
         return pweekday(self.ordinal, base)
 
     @property
-    def weekday(self):
+    def weekday(self) -> int:
         """
         Day of the week the period lies in, with Monday=0 and Sunday=6.
 
@@ -2062,7 +2049,7 @@ cdef class _Period:
         return self.dayofweek
 
     @property
-    def dayofyear(self):
+    def dayofyear(self) -> int:
         """
         Return the day of the year.
 
@@ -2097,12 +2084,12 @@ cdef class _Period:
         return pday_of_year(self.ordinal, base)
 
     @property
-    def quarter(self):
+    def quarter(self) -> int:
         base, mult = get_freq_code(self.freq)
         return pquarter(self.ordinal, base)
 
     @property
-    def qyear(self):
+    def qyear(self) -> int:
         """
         Fiscal year the Period lies in according to its starting-quarter.
 
@@ -2146,7 +2133,7 @@ cdef class _Period:
         return pqyear(self.ordinal, base)
 
     @property
-    def days_in_month(self):
+    def days_in_month(self) -> int:
         """
         Get the total number of days in the month that this period falls on.
 
@@ -2180,7 +2167,7 @@ cdef class _Period:
         return pdays_in_month(self.ordinal, base)
 
     @property
-    def daysinmonth(self):
+    def daysinmonth(self) -> int:
         """
         Get the total number of days of the month that the Period falls in.
 
@@ -2202,7 +2189,7 @@ cdef class _Period:
         return self.days_in_month
 
     @property
-    def is_leap_year(self):
+    def is_leap_year(self) -> bool:
         return bool(is_leapyear(self.year))
 
     @classmethod
@@ -2210,21 +2197,21 @@ cdef class _Period:
         return Period(datetime.now(), freq=freq)
 
     @property
-    def freqstr(self):
+    def freqstr(self) -> str:
         return self.freq.freqstr
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         base, mult = get_freq_code(self.freq)
         formatted = period_format(self.ordinal, base)
-        return "Period('%s', '%s')" % (formatted, self.freqstr)
+        return f"Period('{formatted}', '{self.freqstr}')"
 
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Return a string representation for a particular DataFrame
         """
         base, mult = get_freq_code(self.freq)
         formatted = period_format(self.ordinal, base)
-        value = ("%s" % formatted)
+        value = str(formatted)
         return value
 
     def __setstate__(self, state):
@@ -2235,14 +2222,14 @@ cdef class _Period:
         object_state = None, self.freq, self.ordinal
         return (Period, object_state)
 
-    def strftime(self, fmt):
+    def strftime(self, fmt: str) -> str:
         """
         Returns the string representation of the :class:`Period`, depending
         on the selected ``fmt``. ``fmt`` must be a string
         containing one or several directives.  The method recognizes the same
         directives as the :func:`time.strftime` function of the standard Python
         distribution, as well as the specific additional directives ``%f``,
-        ``%F``, ``%q``. (formatting & docs originally from scikits.timeries)
+        ``%F``, ``%q``. (formatting & docs originally from scikits.timeries).
 
         +-----------+--------------------------------+-------+
         | Directive | Meaning                        | Notes |
@@ -2380,21 +2367,30 @@ cdef class _Period:
 
 class Period(_Period):
     """
-    Represents a period of time
+    Represents a period of time.
 
     Parameters
     ----------
     value : Period or str, default None
-        The time period represented (e.g., '4Q2005')
+        The time period represented (e.g., '4Q2005').
     freq : str, default None
-        One of pandas period strings or corresponding objects
+        One of pandas period strings or corresponding objects.
+    ordinal : int, default None
+        The period offset from the gregorian proleptic epoch.
     year : int, default None
+        Year value of the period.
     month : int, default 1
+        Month value of the period.
     quarter : int, default None
+        Quarter value of the period.
     day : int, default 1
+        Day value of the period.
     hour : int, default 0
+        Hour value of the period.
     minute : int, default 0
+        Minute value of the period.
     second : int, default 0
+        Second value of the period.
     """
 
     def __new__(cls, value=None, freq=None, ordinal=None,
@@ -2448,14 +2444,17 @@ class Period(_Period):
                 converted = other.asfreq(freq)
                 ordinal = converted.ordinal
 
-        elif is_null_datetimelike(value) or value in nat_strings:
+        elif is_null_datetimelike(value) or (isinstance(value, str) and
+                                             value in nat_strings):
+            # explicit str check is necessary to avoid raising incorrectly
+            #  if we have a non-hashable value.
             ordinal = NPY_NAT
 
         elif isinstance(value, str) or util.is_integer_object(value):
             if util.is_integer_object(value):
                 value = str(value)
             value = value.upper()
-            dt, _, reso = parse_time_string(value, freq)
+            dt, reso = parse_time_string(value, freq)
             if dt is NaT:
                 ordinal = NPY_NAT
 
@@ -2463,9 +2462,8 @@ class Period(_Period):
                 try:
                     freq = Resolution.get_freq(reso)
                 except KeyError:
-                    raise ValueError(
-                        "Invalid frequency or could not infer: {reso}"
-                        .format(reso=reso))
+                    raise ValueError(f"Invalid frequency or could not "
+                                     f"infer: {reso}")
 
         elif PyDateTime_Check(value):
             dt = value
diff --git a/pandas/_libs/tslibs/resolution.pyx b/pandas/_libs/tslibs/resolution.pyx
index c0b20c14e9920..1e0eb7f97ec54 100644
--- a/pandas/_libs/tslibs/resolution.pyx
+++ b/pandas/_libs/tslibs/resolution.pyx
@@ -27,7 +27,7 @@ cdef:
 
 # ----------------------------------------------------------------------
 
-cpdef resolution(int64_t[:] stamps, tz=None):
+cpdef resolution(const int64_t[:] stamps, tz=None):
     cdef:
         Py_ssize_t i, n = len(stamps)
         npy_datetimestruct dts
@@ -38,7 +38,7 @@ cpdef resolution(int64_t[:] stamps, tz=None):
     return _reso_local(stamps, tz)
 
 
-cdef _reso_local(int64_t[:] stamps, object tz):
+cdef _reso_local(const int64_t[:] stamps, object tz):
     cdef:
         Py_ssize_t i, n = len(stamps)
         int reso = RESO_DAY, curr_reso
@@ -106,7 +106,7 @@ cdef inline int _reso_stamp(npy_datetimestruct *dts):
     return RESO_DAY
 
 
-def get_freq_group(freq):
+def get_freq_group(freq) -> int:
     """
     Return frequency code group of given frequency str or offset.
 
@@ -189,7 +189,7 @@ class Resolution:
     _freq_reso_map = {v: k for k, v in _reso_freq_map.items()}
 
     @classmethod
-    def get_str(cls, reso):
+    def get_str(cls, reso: int) -> str:
         """
         Return resolution str against resolution code.
 
@@ -201,7 +201,7 @@ class Resolution:
         return cls._reso_str_map.get(reso, 'day')
 
     @classmethod
-    def get_reso(cls, resostr):
+    def get_reso(cls, resostr: str) -> int:
         """
         Return resolution str against resolution code.
 
@@ -216,7 +216,7 @@ class Resolution:
         return cls._str_reso_map.get(resostr, cls.RESO_DAY)
 
     @classmethod
-    def get_freq_group(cls, resostr):
+    def get_freq_group(cls, resostr: str) -> int:
         """
         Return frequency str against resolution str.
 
@@ -228,7 +228,7 @@ class Resolution:
         return get_freq_group(cls.get_freq(resostr))
 
     @classmethod
-    def get_freq(cls, resostr):
+    def get_freq(cls, resostr: str) -> str:
         """
         Return frequency str against resolution str.
 
@@ -240,7 +240,7 @@ class Resolution:
         return cls._reso_freq_map[resostr]
 
     @classmethod
-    def get_str_from_freq(cls, freq):
+    def get_str_from_freq(cls, freq: str) -> str:
         """
         Return resolution str against frequency str.
 
@@ -252,7 +252,7 @@ class Resolution:
         return cls._freq_reso_map.get(freq, 'day')
 
     @classmethod
-    def get_reso_from_freq(cls, freq):
+    def get_reso_from_freq(cls, freq: str) -> int:
         """
         Return resolution code against frequency str.
 
diff --git a/pandas/_libs/tslibs/strptime.pyx b/pandas/_libs/tslibs/strptime.pyx
index fbda5f178e164..5508b208de00a 100644
--- a/pandas/_libs/tslibs/strptime.pyx
+++ b/pandas/_libs/tslibs/strptime.pyx
@@ -106,11 +106,11 @@ def array_strptime(object[:] values, object fmt,
                 if bad_directive == "\\":
                     bad_directive = "%"
                 del err
-                raise ValueError("'%s' is a bad directive in format '%s'" %
-                                 (bad_directive, fmt))
+                raise ValueError(f"'{bad_directive}' is a bad directive "
+                                 f"in format '{fmt}'")
             # IndexError only occurs when the format string is "%"
             except IndexError:
-                raise ValueError("stray %% in format '%s'" % fmt)
+                raise ValueError(f"stray % in format '{fmt}'")
             _regex_cache[fmt] = format_regex
 
     result = np.empty(n, dtype='M8[ns]')
@@ -139,14 +139,13 @@ def array_strptime(object[:] values, object fmt,
                 if is_coerce:
                     iresult[i] = NPY_NAT
                     continue
-                raise ValueError("time data %r does not match "
-                                 "format %r (match)" % (val, fmt))
+                raise ValueError(f"time data '{val}' does not match "
+                                 f"format '{fmt}' (match)")
             if len(val) != found.end():
                 if is_coerce:
                     iresult[i] = NPY_NAT
                     continue
-                raise ValueError("unconverted data remains: %s" %
-                                 val[found.end():])
+                raise ValueError(f"unconverted data remains: {val[found.end():]}")
 
         # search
         else:
@@ -155,8 +154,8 @@ def array_strptime(object[:] values, object fmt,
                 if is_coerce:
                     iresult[i] = NPY_NAT
                     continue
-                raise ValueError("time data %r does not match format "
-                                 "%r (search)" % (val, fmt))
+                raise ValueError(f"time data {repr(val)} does not match format "
+                                 f"{repr(fmt)} (search)")
 
         iso_year = -1
         year = 1900
@@ -279,8 +278,8 @@ def array_strptime(object[:] values, object fmt,
                                  "the ISO year directive '%G' and a weekday "
                                  "directive '%A', '%a', '%w', or '%u'.")
             else:
-                raise ValueError("ISO week directive '%V' is incompatible with"
-                                 " the year directive '%Y'. Use the ISO year "
+                raise ValueError("ISO week directive '%V' is incompatible with "
+                                 "the year directive '%Y'. Use the ISO year "
                                  "'%G' instead.")
 
         # If we know the wk of the year and what day of that wk, we can figure
@@ -589,8 +588,8 @@ class TimeRE(dict):
         else:
             return ''
         regex = '|'.join(re.escape(stuff) for stuff in to_convert)
-        regex = '(?P<%s>%s' % (directive, regex)
-        return '%s)' % regex
+        regex = f"(?P<{directive}>{regex})"
+        return regex
 
     def pattern(self, format):
         """
@@ -609,11 +608,11 @@ class TimeRE(dict):
         format = whitespace_replacement.sub(r'\\s+', format)
         while '%' in format:
             directive_index = format.index('%') +1
-            processed_format = "%s%s%s" % (processed_format,
-                                           format[:directive_index -1],
-                                           self[format[directive_index]])
+            processed_format = (f"{processed_format}"
+                                f"{format[:directive_index -1]}"
+                                f"{self[format[directive_index]]}")
             format = format[directive_index +1:]
-        return "%s%s" % (processed_format, format)
+        return f"{processed_format}{format}"
 
     def compile(self, format):
         """Return a compiled re object for the format string."""
@@ -737,8 +736,7 @@ cdef parse_timezone_directive(str z):
         z = z[:3] + z[4:]
         if len(z) > 5:
             if z[5] != ':':
-                msg = "Inconsistent use of : in {0}"
-                raise ValueError(msg.format(z))
+                raise ValueError(f"Inconsistent use of : in {z}")
             z = z[:5] + z[6:]
     hours = int(z[1:3])
     minutes = int(z[3:5])
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 831e65d5573e9..3742506a7f8af 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1,6 +1,4 @@
 import collections
-import textwrap
-import warnings
 
 import cython
 
@@ -170,7 +168,7 @@ cdef convert_to_timedelta64(object ts, object unit):
         if ts.astype('int64') == NPY_NAT:
             return np.timedelta64(NPY_NAT)
     elif is_timedelta64_object(ts):
-        ts = ts.astype("m8[{unit}]".format(unit=unit.lower()))
+        ts = ts.astype(f"m8[{unit.lower()}]")
     elif is_integer_object(ts):
         if ts == NPY_NAT:
             return np.timedelta64(NPY_NAT)
@@ -198,8 +196,7 @@ cdef convert_to_timedelta64(object ts, object unit):
     if PyDelta_Check(ts):
         ts = np.timedelta64(delta_to_nanoseconds(ts), 'ns')
     elif not is_timedelta64_object(ts):
-        raise ValueError("Invalid type for timedelta "
-                         "scalar: {ts_type}".format(ts_type=type(ts)))
+        raise ValueError(f"Invalid type for timedelta scalar: {type(ts)}")
     return ts.astype('timedelta64[ns]')
 
 
@@ -288,7 +285,7 @@ cpdef inline object precision_from_unit(object unit):
         m = 1L
         p = 0
     else:
-        raise ValueError("cannot cast unit {unit}".format(unit=unit))
+        raise ValueError(f"cannot cast unit {unit}")
     return m, p
 
 
@@ -397,8 +394,7 @@ cdef inline int64_t parse_timedelta_string(str ts) except? -1:
                 result += timedelta_as_neg(r, neg)
                 have_hhmmss = 1
             else:
-                raise ValueError("expecting hh:mm:ss format, "
-                                 "received: {ts}".format(ts=ts))
+                raise ValueError(f"expecting hh:mm:ss format, received: {ts}")
 
             unit, number = [], []
 
@@ -511,7 +507,7 @@ cdef inline timedelta_from_spec(object number, object frac, object unit):
             unit = 'm'
         unit = parse_timedelta_unit(unit)
     except KeyError:
-        raise ValueError("invalid abbreviation: {unit}".format(unit=unit))
+        raise ValueError(f"invalid abbreviation: {unit}")
 
     n = ''.join(number) + '.' + ''.join(frac)
     return cast_from_unit(float(n), unit)
@@ -530,8 +526,7 @@ cpdef inline object parse_timedelta_unit(object unit):
     try:
         return timedelta_abbrevs[unit.lower()]
     except (KeyError, AttributeError):
-        raise ValueError("invalid unit abbreviation: {unit}"
-                         .format(unit=unit))
+        raise ValueError(f"invalid unit abbreviation: {unit}")
 
 # ----------------------------------------------------------------------
 # Timedelta ops utilities
@@ -727,8 +722,7 @@ cdef _to_py_int_float(v):
         return int(v)
     elif is_float_object(v):
         return float(v)
-    raise TypeError("Invalid type {typ}. Must be int or "
-                    "float.".format(typ=type(v)))
+    raise TypeError(f"Invalid type {type(v)}. Must be int or float.")
 
 
 # Similar to Timestamp/datetime, this is a construction requirement for
@@ -773,10 +767,9 @@ cdef class _Timedelta(timedelta):
                         elif op == Py_NE:
                             return True
                         # only allow ==, != ops
-                        raise TypeError('Cannot compare type {cls} with '
-                                        'type {other}'
-                                        .format(cls=type(self).__name__,
-                                                other=type(other).__name__))
+                        raise TypeError(f'Cannot compare type '
+                                        f'{type(self).__name__} with '
+                                        f'type {type(other).__name__}')
                 if util.is_array(other):
                     return PyObject_RichCompare(np.array([self]), other, op)
                 return PyObject_RichCompare(other, self, reverse_ops[op])
@@ -787,10 +780,8 @@ cdef class _Timedelta(timedelta):
                     return False
                 elif op == Py_NE:
                     return True
-                raise TypeError('Cannot compare type {cls} with '
-                                'type {other}'
-                                .format(cls=type(self).__name__,
-                                        other=type(other).__name__))
+                raise TypeError(f'Cannot compare type {type(self).__name__} with '
+                                f'type {type(other).__name__}')
 
         return cmp_scalar(self.value, ots.value, op)
 
@@ -841,15 +832,15 @@ cdef class _Timedelta(timedelta):
         """
         return timedelta(microseconds=int(self.value) / 1000)
 
-    def to_timedelta64(self):
+    def to_timedelta64(self) -> np.timedelta64:
         """
         Return a numpy.timedelta64 object with 'ns' precision.
         """
         return np.timedelta64(self.value, 'ns')
 
-    def to_numpy(self, dtype=None, copy=False):
+    def to_numpy(self, dtype=None, copy=False) -> np.timedelta64:
         """
-        Convert the Timestamp to a NumPy timedelta64.
+        Convert the Timedelta to a NumPy timedelta64.
 
         .. versionadded:: 0.25.0
 
@@ -867,12 +858,6 @@ cdef class _Timedelta(timedelta):
         """
         return self.to_timedelta64()
 
-    def total_seconds(self):
-        """
-        Total duration of timedelta in seconds (to ns precision).
-        """
-        return self.value / 1e9
-
     def view(self, dtype):
         """
         Array view compatibility.
@@ -920,7 +905,7 @@ cdef class _Timedelta(timedelta):
         return self.value
 
     @property
-    def asm8(self):
+    def asm8(self) -> np.timedelta64:
         """
         Return a numpy timedelta64 array scalar view.
 
@@ -955,7 +940,7 @@ cdef class _Timedelta(timedelta):
         return np.int64(self.value).view('m8[ns]')
 
     @property
-    def resolution_string(self):
+    def resolution_string(self) -> str:
         """
         Return a string representing the lowest timedelta resolution.
 
@@ -1012,56 +997,6 @@ cdef class _Timedelta(timedelta):
         else:
             return "D"
 
-    @property
-    def resolution(self):
-        """
-        Return a string representing the lowest timedelta resolution.
-
-        Each timedelta has a defined resolution that represents the lowest OR
-        most granular level of precision. Each level of resolution is
-        represented by a short string as defined below:
-
-        Resolution:     Return value
-
-        * Days:         'D'
-        * Hours:        'H'
-        * Minutes:      'T'
-        * Seconds:      'S'
-        * Milliseconds: 'L'
-        * Microseconds: 'U'
-        * Nanoseconds:  'N'
-
-        Returns
-        -------
-        str
-            Timedelta resolution.
-
-        Examples
-        --------
-        >>> td = pd.Timedelta('1 days 2 min 3 us 42 ns')
-        >>> td.resolution
-        'N'
-
-        >>> td = pd.Timedelta('1 days 2 min 3 us')
-        >>> td.resolution
-        'U'
-
-        >>> td = pd.Timedelta('2 min 3 s')
-        >>> td.resolution
-        'S'
-
-        >>> td = pd.Timedelta(36, unit='us')
-        >>> td.resolution
-        'U'
-        """
-        # See GH#21344
-        warnings.warn("Timedelta.resolution is deprecated, in a future "
-                      "version will behave like the standard library "
-                      "datetime.timedelta.resolution attribute.  "
-                      "Use Timedelta.resolution_string instead.",
-                      FutureWarning)
-        return self.resolution_string
-
     @property
     def nanoseconds(self):
         """
@@ -1095,7 +1030,7 @@ cdef class _Timedelta(timedelta):
         self._ensure_components()
         return self._ns
 
-    def _repr_base(self, format=None):
+    def _repr_base(self, format=None) -> str:
         """
 
         Parameters
@@ -1142,22 +1077,21 @@ cdef class _Timedelta(timedelta):
 
         return fmt.format(**comp_dict)
 
-    def __repr__(self):
-        return "Timedelta('{val}')".format(val=self._repr_base(format='long'))
+    def __repr__(self) -> str:
+        repr_based = self._repr_base(format='long')
+        return f"Timedelta('{repr_based}')"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self._repr_base(format='long')
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self.value != 0
 
-    def isoformat(self):
+    def isoformat(self) -> str:
         """
         Format Timedelta as ISO 8601 Duration like
         ``P[n]Y[n]M[n]DT[n]H[n]M[n]S``, where the ``[n]`` s are replaced by the
-        values. See https://en.wikipedia.org/wiki/ISO_8601#Durations
-
-        .. versionadded:: 0.20.0
+        values. See https://en.wikipedia.org/wiki/ISO_8601#Durations.
 
         Returns
         -------
@@ -1191,14 +1125,14 @@ cdef class _Timedelta(timedelta):
         'P500DT12H0MS'
         """
         components = self.components
-        seconds = '{}.{:0>3}{:0>3}{:0>3}'.format(components.seconds,
-                                                 components.milliseconds,
-                                                 components.microseconds,
-                                                 components.nanoseconds)
+        seconds = (f'{components.seconds}.'
+                   f'{components.milliseconds:0>3}'
+                   f'{components.microseconds:0>3}'
+                   f'{components.nanoseconds:0>3}')
         # Trim unnecessary 0s, 1.000000000 -> 1
         seconds = seconds.rstrip('0').rstrip('.')
-        tpl = ('P{td.days}DT{td.hours}H{td.minutes}M{seconds}S'
-               .format(td=components, seconds=seconds))
+        tpl = (f'P{components.days}DT{components.hours}'
+               f'H{components.minutes}M{seconds}S')
         return tpl
 
 
@@ -1215,14 +1149,20 @@ class Timedelta(_Timedelta):
     Parameters
     ----------
     value : Timedelta, timedelta, np.timedelta64, string, or integer
-    unit : str, optional
-        Denote the unit of the input, if input is an integer. Default 'ns'.
+    unit : str, default 'ns'
+        Denote the unit of the input, if input is an integer.
+
         Possible values:
-        {'Y', 'M', 'W', 'D', 'days', 'day', 'hours', hour', 'hr', 'h',
-        'm', 'minute', 'min', 'minutes', 'T', 'S', 'seconds', 'sec', 'second',
-        'ms', 'milliseconds', 'millisecond', 'milli', 'millis', 'L',
-        'us', 'microseconds', 'microsecond', 'micro', 'micros', 'U',
-        'ns', 'nanoseconds', 'nano', 'nanos', 'nanosecond', 'N'}
+
+        * 'Y', 'M', 'W', 'D', 'T', 'S', 'L', 'U', or 'N'
+        * 'days' or 'day'
+        * 'hours', 'hour', 'hr', or 'h'
+        * 'minutes', 'minute', 'min', or 'm'
+        * 'seconds', 'second', or 'sec'
+        * 'milliseconds', 'millisecond', 'millis', or 'milli'
+        * 'microseconds', 'microsecond', 'micros', or 'micro'
+        * 'nanoseconds', 'nanosecond', 'nanos', 'nano', or 'ns'.
+
     **kwargs
         Available kwargs: {days, seconds, microseconds,
         milliseconds, minutes, hours, weeks}.
@@ -1256,11 +1196,17 @@ class Timedelta(_Timedelta):
                                  "milliseconds, microseconds, nanoseconds]")
 
         if unit in {'Y', 'y', 'M'}:
-            warnings.warn("M and Y units are deprecated and "
-                          "will be removed in a future version.",
-                          FutureWarning, stacklevel=1)
-
-        if isinstance(value, Timedelta):
+            raise ValueError(
+                "Units 'M' and 'Y' are no longer supported, as they do not "
+                "represent unambiguous timedelta values durations."
+            )
+
+        # GH 30543 if pd.Timedelta already passed, return it
+        # check that only value is passed
+        if (isinstance(value, Timedelta) and unit is None and
+                len(kwargs) == 0):
+            return value
+        elif isinstance(value, Timedelta):
             value = value.value
         elif isinstance(value, str):
             if len(value) > 0 and value[0] == 'P':
@@ -1272,7 +1218,7 @@ class Timedelta(_Timedelta):
             value = convert_to_timedelta64(value, 'ns')
         elif is_timedelta64_object(value):
             if unit is not None:
-                value = value.astype('timedelta64[{0}]'.format(unit))
+                value = value.astype(f'timedelta64[{unit}]')
             value = value.astype('timedelta64[ns]')
         elif hasattr(value, 'delta'):
             value = np.timedelta64(delta_to_nanoseconds(value.delta), 'ns')
@@ -1284,9 +1230,8 @@ class Timedelta(_Timedelta):
             return NaT
         else:
             raise ValueError(
-                "Value must be Timedelta, string, integer, "
-                "float, timedelta or convertible, not {typ}"
-                .format(typ=type(value).__name__))
+                f"Value must be Timedelta, string, integer, "
+                f"float, timedelta or convertible, not {type(value).__name__}")
 
         if is_timedelta64_object(value):
             value = value.view('i8')
@@ -1296,7 +1241,7 @@ class Timedelta(_Timedelta):
             return NaT
 
         # make timedelta happy
-        td_base = _Timedelta.__new__(cls, microseconds=int(value) / 1000)
+        td_base = _Timedelta.__new__(cls, microseconds=int(value) // 1000)
         td_base.value = value
         td_base.is_populated = 0
         return td_base
@@ -1319,11 +1264,12 @@ class Timedelta(_Timedelta):
 
     def round(self, freq):
         """
-        Round the Timedelta to the specified resolution
+        Round the Timedelta to the specified resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the rounding resolution
+        freq : str
+            Frequency string indicating the rounding resolution.
 
         Returns
         -------
@@ -1337,21 +1283,23 @@ class Timedelta(_Timedelta):
 
     def floor(self, freq):
         """
-        return a new Timedelta floored to this resolution
+        Return a new Timedelta floored to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the flooring resolution
+        freq : str
+            Frequency string indicating the flooring resolution.
         """
         return self._round(freq, np.floor)
 
     def ceil(self, freq):
         """
-        return a new Timedelta ceiled to this resolution
+        Return a new Timedelta ceiled to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the ceiling resolution
+        freq : str
+            Frequency string indicating the ceiling resolution.
         """
         return self._round(freq, np.ceil)
 
@@ -1478,9 +1426,7 @@ class Timedelta(_Timedelta):
                 else:
                     return self.to_timedelta64() // other
 
-            raise TypeError('Invalid dtype {dtype} for '
-                            '{op}'.format(dtype=other.dtype,
-                                          op='__floordiv__'))
+            raise TypeError(f'Invalid dtype {other.dtype} for __floordiv__')
 
         elif is_integer_object(other) or is_float_object(other):
             return Timedelta(self.value // other, unit='ns')
@@ -1511,21 +1457,9 @@ class Timedelta(_Timedelta):
             if other.dtype.kind == 'm':
                 # also timedelta-like
                 return _broadcast_floordiv_td64(self.value, other, _rfloordiv)
-            elif other.dtype.kind == 'i':
-                # Backwards compatibility
-                # GH-19761
-                msg = textwrap.dedent("""\
-                Floor division between integer array and Timedelta is
-                deprecated. Use 'array // timedelta.value' instead.
-                If you want to obtain epochs from an array of timestamps,
-                you can rather use
-                '(array - pd.Timestamp("1970-01-01")) // pd.Timedelta("1s")'.
-                """)
-                warnings.warn(msg, FutureWarning)
-                return other // self.value
-            raise TypeError('Invalid dtype {dtype} for '
-                            '{op}'.format(dtype=other.dtype,
-                                          op='__floordiv__'))
+
+            # Includes integer array // Timedelta, disallowed in GH#19761
+            raise TypeError(f'Invalid dtype {other.dtype} for __floordiv__')
 
         elif is_float_object(other) and util.is_nan(other):
             # i.e. np.nan
@@ -1548,8 +1482,7 @@ class Timedelta(_Timedelta):
         if hasattr(other, 'dtype') and other.dtype.kind == 'i':
             # TODO: Remove this check with backwards-compat shim
             # for integer / Timedelta is removed.
-            raise TypeError("Invalid type {dtype} for "
-                            "{op}".format(dtype=other.dtype, op='__mod__'))
+            raise TypeError(f'Invalid dtype {other.dtype} for __mod__')
         return self.__rdivmod__(other)[1]
 
     def __divmod__(self, other):
@@ -1562,8 +1495,7 @@ class Timedelta(_Timedelta):
         if hasattr(other, 'dtype') and other.dtype.kind == 'i':
             # TODO: Remove this check with backwards-compat shim
             # for integer / Timedelta is removed.
-            raise TypeError("Invalid type {dtype} for "
-                            "{op}".format(dtype=other.dtype, op='__mod__'))
+            raise TypeError(f'Invalid dtype {other.dtype} for __mod__')
         div = other // self
         return div, other - div * self
 
@@ -1618,3 +1550,4 @@ cdef _broadcast_floordiv_td64(int64_t value, object other,
 # resolution in ns
 Timedelta.min = Timedelta(np.iinfo(np.int64).min + 1)
 Timedelta.max = Timedelta(np.iinfo(np.int64).max)
+Timedelta.resolution = Timedelta(nanoseconds=1)
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index c8c6efda30fae..b8c462abe35f1 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -1,4 +1,3 @@
-import sys
 import warnings
 
 import numpy as np
@@ -36,7 +35,6 @@ from pandas._libs.tslibs.tzconversion import (
 # Constants
 _zero_time = datetime_time(0, 0)
 _no_input = object()
-PY36 = sys.version_info >= (3, 6)
 
 # ----------------------------------------------------------------------
 
@@ -90,23 +88,23 @@ class RoundTo:
            https://en.wikipedia.org/wiki/Rounding#Round_half_to_even
     """
     @property
-    def MINUS_INFTY(self):
+    def MINUS_INFTY(self) -> int:
         return 0
 
     @property
-    def PLUS_INFTY(self):
+    def PLUS_INFTY(self) -> int:
         return 1
 
     @property
-    def NEAREST_HALF_EVEN(self):
+    def NEAREST_HALF_EVEN(self) -> int:
         return 2
 
     @property
-    def NEAREST_HALF_PLUS_INFTY(self):
+    def NEAREST_HALF_PLUS_INFTY(self) -> int:
         return 3
 
     @property
-    def NEAREST_HALF_MINUS_INFTY(self):
+    def NEAREST_HALF_MINUS_INFTY(self) -> int:
         return 4
 
 
@@ -162,8 +160,7 @@ def round_nsint64(values, mode, freq):
 
     # if/elif above should catch all rounding modes defined in enum 'RoundTo':
     # if flow of control arrives here, it is a bug
-    raise ValueError("round_nsint64 called with an unrecognized "
-                     "rounding mode")
+    raise ValueError("round_nsint64 called with an unrecognized rounding mode")
 
 
 # ----------------------------------------------------------------------
@@ -194,13 +191,10 @@ class Timestamp(_Timestamp):
         valid values are 'D', 'h', 'm', 's', 'ms', 'us', and 'ns'. For
         example, 's' means seconds and 'ms' means milliseconds.
     year, month, day : int
-        .. versionadded:: 0.19.0
     hour, minute, second, microsecond : int, optional, default 0
-        .. versionadded:: 0.19.0
     nanosecond : int, optional, default 0
         .. versionadded:: 0.23.0
     tzinfo : datetime.tzinfo, optional, default None
-        .. versionadded:: 0.19.0
 
     Notes
     -----
@@ -245,17 +239,17 @@ class Timestamp(_Timestamp):
         """
         Timestamp.fromordinal(ordinal, freq=None, tz=None)
 
-        passed an ordinal, translate and convert to a ts
-        note: by definition there cannot be any tz info on the ordinal itself
+        Passed an ordinal, translate and convert to a ts.
+        Note: by definition there cannot be any tz info on the ordinal itself.
 
         Parameters
         ----------
         ordinal : int
-            date corresponding to a proleptic Gregorian ordinal
+            Date corresponding to a proleptic Gregorian ordinal.
         freq : str, DateOffset
-            Offset which Timestamp will have
+            Offset to apply to the Timestamp.
         tz : str, pytz.timezone, dateutil.tz.tzfile or None
-            Time zone for time which Timestamp will have.
+            Time zone for the Timestamp.
         """
         return cls(datetime.fromordinal(ordinal),
                    freq=freq, tz=tz)
@@ -271,7 +265,7 @@ class Timestamp(_Timestamp):
         Parameters
         ----------
         tz : str or timezone object, default None
-            Timezone to localize to
+            Timezone to localize to.
         """
         if isinstance(tz, str):
             tz = maybe_get_tz(tz)
@@ -289,7 +283,7 @@ class Timestamp(_Timestamp):
         Parameters
         ----------
         tz : str or timezone object, default None
-            Timezone to localize to
+            Timezone to localize to.
         """
         return cls.now(tz)
 
@@ -328,23 +322,36 @@ class Timestamp(_Timestamp):
 
         Function is not implemented. Use pd.to_datetime().
         """
-        raise NotImplementedError("Timestamp.strptime() is not implmented."
-                                  "Use to_datetime() to parse date strings.")
+        raise NotImplementedError(
+            "Timestamp.strptime() is not implemented. "
+            "Use to_datetime() to parse date strings."
+        )
 
     @classmethod
     def combine(cls, date, time):
         """
         Timestamp.combine(date, time)
 
-        date, time -> datetime with same date and time fields
+        date, time -> datetime with same date and time fields.
         """
         return cls(datetime.combine(date, time))
 
-    def __new__(cls, object ts_input=_no_input,
-                object freq=None, tz=None, unit=None,
-                year=None, month=None, day=None,
-                hour=None, minute=None, second=None, microsecond=None,
-                nanosecond=None, tzinfo=None):
+    def __new__(
+        cls,
+        object ts_input=_no_input,
+        object freq=None,
+        tz=None,
+        unit=None,
+        year=None,
+        month=None,
+        day=None,
+        hour=None,
+        minute=None,
+        second=None,
+        microsecond=None,
+        nanosecond=None,
+        tzinfo=None
+    ):
         # The parameter list folds together legacy parameter names (the first
         # four) and positional and keyword parameter names from pydatetime.
         #
@@ -374,20 +381,34 @@ class Timestamp(_Timestamp):
         if tzinfo is not None:
             if not PyTZInfo_Check(tzinfo):
                 # tzinfo must be a datetime.tzinfo object, GH#17690
-                raise TypeError('tzinfo must be a datetime.tzinfo object, '
-                                'not %s' % type(tzinfo))
+                raise TypeError(
+                    f"tzinfo must be a datetime.tzinfo object, not {type(tzinfo)}"
+                )
             elif tz is not None:
                 raise ValueError('Can provide at most one of tz, tzinfo')
 
             # User passed tzinfo instead of tz; avoid silently ignoring
             tz, tzinfo = tzinfo, None
 
-        if isinstance(ts_input, str):
+        # GH 30543 if pd.Timestamp already passed, return it
+        # check that only ts_input is passed
+        # checking verbosely, because cython doesn't optimize
+        # list comprehensions (as of cython 0.29.x)
+        if (isinstance(ts_input, Timestamp) and freq is None and
+                tz is None and unit is None and year is None and
+                month is None and day is None and hour is None and
+                minute is None and second is None and
+                microsecond is None and nanosecond is None and
+                tzinfo is None):
+            return ts_input
+        elif isinstance(ts_input, str):
             # User passed a date string to parse.
             # Check that the user didn't also pass a date attribute kwarg.
             if any(arg is not None for arg in _date_attributes):
-                raise ValueError('Cannot pass a date attribute keyword '
-                                 'argument when passing a date string')
+                raise ValueError(
+                    "Cannot pass a date attribute keyword "
+                    "argument when passing a date string"
+                )
 
         elif ts_input is _no_input:
             # User passed keyword arguments.
@@ -405,9 +426,8 @@ class Timestamp(_Timestamp):
             freq = None
 
         if getattr(ts_input, 'tzinfo', None) is not None and tz is not None:
-            warnings.warn("Passing a datetime or Timestamp with tzinfo and the"
-                          " tz parameter will raise in the future. Use"
-                          " tz_convert instead.", FutureWarning)
+            raise ValueError("Cannot pass a datetime or Timestamp with tzinfo with "
+                             "the tz parameter. Use tz_convert instead.")
 
         ts = convert_to_tsobject(ts_input, tz, unit, 0, 0, nanosecond or 0)
 
@@ -441,31 +461,34 @@ class Timestamp(_Timestamp):
 
     def round(self, freq, ambiguous='raise', nonexistent='raise'):
         """
-        Round the Timestamp to the specified resolution
+        Round the Timestamp to the specified resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the rounding resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the rounding resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
@@ -483,88 +506,96 @@ default 'raise'
 
     def floor(self, freq, ambiguous='raise', nonexistent='raise'):
         """
-        return a new Timestamp floored to this resolution
+        return a new Timestamp floored to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the flooring resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the flooring resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
         Raises
         ------
-        ValueError if the freq cannot be converted
+        ValueError if the freq cannot be converted.
         """
         return self._round(freq, RoundTo.MINUS_INFTY, ambiguous, nonexistent)
 
     def ceil(self, freq, ambiguous='raise', nonexistent='raise'):
         """
-        return a new Timestamp ceiled to this resolution
+        return a new Timestamp ceiled to this resolution.
 
         Parameters
         ----------
-        freq : a freq string indicating the ceiling resolution
-        ambiguous : bool, 'NaT', default 'raise'
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+        freq : str
+            Frequency string indicating the ceiling resolution.
+        ambiguous : bool or {'raise', 'NaT'}, default 'raise'
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
             .. versionadded:: 0.24.0
-        nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
-default 'raise'
+        nonexistent : {'raise', 'shift_forward', 'shift_backward, 'NaT', \
+timedelta}, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
         Raises
         ------
-        ValueError if the freq cannot be converted
+        ValueError if the freq cannot be converted.
         """
         return self._round(freq, RoundTo.PLUS_INFTY, ambiguous, nonexistent)
 
     @property
     def tz(self):
         """
-        Alias for tzinfo
+        Alias for tzinfo.
         """
         return self.tzinfo
 
     @tz.setter
     def tz(self, value):
         # GH 3746: Prevent localizing or converting the index by setting tz
-        raise AttributeError("Cannot directly set timezone. Use tz_localize() "
-                             "or tz_convert() as appropriate")
+        raise AttributeError(
+            "Cannot directly set timezone. "
+            "Use tz_localize() or tz_convert() as appropriate"
+        )
 
     def __setstate__(self, state):
         self.value = state[0]
@@ -583,9 +614,10 @@ default 'raise'
 
         if self.tz is not None:
             # GH#21333
-            warnings.warn("Converting to Period representation will "
-                          "drop timezone information.",
-                          UserWarning)
+            warnings.warn(
+                "Converting to Period representation will drop timezone information.",
+                UserWarning,
+            )
 
         if freq is None:
             freq = self.freq
@@ -595,18 +627,18 @@ default 'raise'
     @property
     def dayofweek(self):
         """
-        Return day of whe week.
+        Return day of the week.
         """
         return self.weekday()
 
-    def day_name(self, locale=None):
+    def day_name(self, locale=None) -> str:
         """
         Return the day name of the Timestamp with specified locale.
 
         Parameters
         ----------
         locale : string, default None (English locale)
-            locale determining the language in which to return the day name
+            Locale determining the language in which to return the day name.
 
         Returns
         -------
@@ -616,14 +648,14 @@ default 'raise'
         """
         return self._get_date_name_field('day_name', locale)
 
-    def month_name(self, locale=None):
+    def month_name(self, locale=None) -> str:
         """
         Return the month name of the Timestamp with specified locale.
 
         Parameters
         ----------
         locale : string, default None (English locale)
-            locale determining the language in which to return the month name
+            Locale determining the language in which to return the month name.
 
         Returns
         -------
@@ -633,17 +665,6 @@ default 'raise'
         """
         return self._get_date_name_field('month_name', locale)
 
-    @property
-    def weekday_name(self):
-        """
-        .. deprecated:: 0.23.0
-            Use ``Timestamp.day_name()`` instead
-        """
-        warnings.warn("`weekday_name` is deprecated and will be removed in a "
-                      "future version. Use `day_name` instead",
-                      FutureWarning)
-        return self.day_name()
-
     @property
     def dayofyear(self):
         """
@@ -652,7 +673,7 @@ default 'raise'
         return ccalendar.get_day_of_year(self.year, self.month, self.day)
 
     @property
-    def week(self):
+    def week(self) -> int:
         """
         Return the week number of the year.
         """
@@ -661,7 +682,7 @@ default 'raise'
     weekofyear = week
 
     @property
-    def quarter(self):
+    def quarter(self) -> int:
         """
         Return the quarter of the year.
         """
@@ -684,7 +705,7 @@ default 'raise'
         return getattr(self.freq, 'freqstr', self.freq)
 
     @property
-    def is_month_start(self):
+    def is_month_start(self) -> bool:
         """
         Return True if date is first day of month.
         """
@@ -694,7 +715,7 @@ default 'raise'
         return self._get_start_end_field('is_month_start')
 
     @property
-    def is_month_end(self):
+    def is_month_end(self) -> bool:
         """
         Return True if date is last day of month.
         """
@@ -704,7 +725,7 @@ default 'raise'
         return self._get_start_end_field('is_month_end')
 
     @property
-    def is_quarter_start(self):
+    def is_quarter_start(self) -> bool:
         """
         Return True if date is first day of the quarter.
         """
@@ -714,7 +735,7 @@ default 'raise'
         return self._get_start_end_field('is_quarter_start')
 
     @property
-    def is_quarter_end(self):
+    def is_quarter_end(self) -> bool:
         """
         Return True if date is last day of the quarter.
         """
@@ -724,7 +745,7 @@ default 'raise'
         return self._get_start_end_field('is_quarter_end')
 
     @property
-    def is_year_start(self):
+    def is_year_start(self) -> bool:
         """
         Return True if date is first day of the year.
         """
@@ -734,7 +755,7 @@ default 'raise'
         return self._get_start_end_field('is_year_start')
 
     @property
-    def is_year_end(self):
+    def is_year_end(self) -> bool:
         """
         Return True if date is last day of the year.
         """
@@ -744,23 +765,13 @@ default 'raise'
         return self._get_start_end_field('is_year_end')
 
     @property
-    def is_leap_year(self):
+    def is_leap_year(self) -> bool:
         """
         Return True if year is a leap year.
         """
         return bool(ccalendar.is_leapyear(self.year))
 
-    @property
-    def resolution(self):
-        """
-        Return resolution describing the smallest difference between two
-        times that can be represented by Timestamp object_state
-        """
-        # GH#21336, GH#21365
-        return Timedelta(nanoseconds=1)
-
-    def tz_localize(self, tz, ambiguous='raise', nonexistent='raise',
-                    errors=None):
+    def tz_localize(self, tz, ambiguous='raise', nonexistent='raise'):
         """
         Convert naive Timestamp to local time zone, or remove
         timezone from tz-aware Timestamp.
@@ -779,35 +790,30 @@ default 'raise'
             `ambiguous` parameter dictates how ambiguous times should be
             handled.
 
-            - bool contains flags to determine if time is dst or not (note
-              that this flag is only applicable for ambiguous fall dst dates)
-            - 'NaT' will return NaT for an ambiguous time
-            - 'raise' will raise an AmbiguousTimeError for an ambiguous time
+            The behavior is as follows:
+
+            * bool contains flags to determine if time is dst or not (note
+              that this flag is only applicable for ambiguous fall dst dates).
+            * 'NaT' will return NaT for an ambiguous time.
+            * 'raise' will raise an AmbiguousTimeError for an ambiguous time.
 
         nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
 default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST.
 
-            - 'shift_forward' will shift the nonexistent time forward to the
-              closest existing time
-            - 'shift_backward' will shift the nonexistent time backward to the
-              closest existing time
-            - 'NaT' will return NaT where there are nonexistent times
-            - timedelta objects will shift nonexistent times by the timedelta
-            - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+            The behavior is as follows:
 
-            .. versionadded:: 0.24.0
-
-        errors : 'raise', 'coerce', default None
-            - 'raise' will raise a NonExistentTimeError if a timestamp is not
-               valid in the specified timezone (e.g. due to a transition from
-               or to DST time). Use ``nonexistent='raise'`` instead.
-            - 'coerce' will return NaT if the timestamp can not be converted
-              into the specified timezone. Use ``nonexistent='NaT'`` instead.
+            * 'shift_forward' will shift the nonexistent time forward to the
+              closest existing time.
+            * 'shift_backward' will shift the nonexistent time backward to the
+              closest existing time.
+            * 'NaT' will return NaT where there are nonexistent times.
+            * timedelta objects will shift nonexistent times by the timedelta.
+            * 'raise' will raise an NonExistentTimeError if there are
+              nonexistent times.
 
-              .. deprecated:: 0.24.0
+            .. versionadded:: 0.24.0
 
         Returns
         -------
@@ -821,26 +827,13 @@ default 'raise'
         if ambiguous == 'infer':
             raise ValueError('Cannot infer offset with only one time.')
 
-        if errors is not None:
-            warnings.warn("The errors argument is deprecated and will be "
-                          "removed in a future release. Use "
-                          "nonexistent='NaT' or nonexistent='raise' "
-                          "instead.", FutureWarning)
-            if errors == 'coerce':
-                nonexistent = 'NaT'
-            elif errors == 'raise':
-                nonexistent = 'raise'
-            else:
-                raise ValueError("The errors argument must be either 'coerce' "
-                                 "or 'raise'.")
-
-        nonexistent_options = ('raise', 'NaT', 'shift_forward',
-                               'shift_backward')
+        nonexistent_options = ('raise', 'NaT', 'shift_forward', 'shift_backward')
         if nonexistent not in nonexistent_options and not isinstance(
             nonexistent, timedelta):
-            raise ValueError("The nonexistent argument must be one of 'raise',"
-                             " 'NaT', 'shift_forward', 'shift_backward' or"
-                             " a timedelta object")
+            raise ValueError(
+                "The nonexistent argument must be one of 'raise', "
+                "'NaT', 'shift_forward', 'shift_backward' or a timedelta object"
+            )
 
         if self.tzinfo is None:
             # tz naive, localize
@@ -857,8 +850,9 @@ default 'raise'
                 value = tz_convert_single(self.value, UTC, self.tz)
                 return Timestamp(value, tz=tz, freq=self.freq)
             else:
-                raise TypeError('Cannot localize tz-aware Timestamp, use '
-                                'tz_convert for conversions')
+                raise TypeError(
+                    "Cannot localize tz-aware Timestamp, use tz_convert for conversions"
+                )
 
     def tz_convert(self, tz):
         """
@@ -881,19 +875,30 @@ default 'raise'
         """
         if self.tzinfo is None:
             # tz naive, use tz_localize
-            raise TypeError('Cannot convert tz-naive Timestamp, use '
-                            'tz_localize to localize')
+            raise TypeError(
+                "Cannot convert tz-naive Timestamp, use tz_localize to localize"
+            )
         else:
             # Same UTC timestamp, different time zone
             return Timestamp(self.value, tz=tz, freq=self.freq)
 
     astimezone = tz_convert
 
-    def replace(self, year=None, month=None, day=None,
-                hour=None, minute=None, second=None, microsecond=None,
-                nanosecond=None, tzinfo=object, fold=0):
-        """
-        implements datetime.replace, handles nanoseconds
+    def replace(
+        self,
+        year=None,
+        month=None,
+        day=None,
+        hour=None,
+        minute=None,
+        second=None,
+        microsecond=None,
+        nanosecond=None,
+        tzinfo=object,
+        fold=0,
+    ):
+        """
+        implements datetime.replace, handles nanoseconds.
 
         Parameters
         ----------
@@ -934,8 +939,9 @@ default 'raise'
         def validate(k, v):
             """ validate integers """
             if not is_integer_object(v):
-                raise ValueError("value must be an integer, received "
-                                 "{v} for {k}".format(v=type(v), k=k))
+                raise ValueError(
+                    f"value must be an integer, received {type(v)} for {k}"
+                )
             return v
 
         if year is not None:
@@ -969,9 +975,8 @@ default 'raise'
         else:
             kwargs = {'year': dts.year, 'month': dts.month, 'day': dts.day,
                       'hour': dts.hour, 'minute': dts.min, 'second': dts.sec,
-                      'microsecond': dts.us, 'tzinfo': _tzinfo}
-            if PY36:
-                kwargs['fold'] = fold
+                      'microsecond': dts.us, 'tzinfo': _tzinfo,
+                      'fold': fold}
             ts_input = datetime(**kwargs)
 
         ts = convert_datetime_to_tsobject(ts_input, _tzinfo)
@@ -992,13 +997,13 @@ default 'raise'
             base1, base2 = base, ""
 
         if self.microsecond != 0:
-            base1 += "%.3d" % self.nanosecond
+            base1 += f"{self.nanosecond:03d}"
         else:
-            base1 += ".%.9d" % self.nanosecond
+            base1 += f".{self.nanosecond:09d}"
 
         return base1 + base2
 
-    def _has_time_component(self):
+    def _has_time_component(self) -> bool:
         """
         Returns if the Timestamp has a time component
         in addition to the date part
@@ -1062,3 +1067,4 @@ cdef int64_t _NS_LOWER_BOUND = -9223372036854775000
 # Resolution is in nanoseconds
 Timestamp.min = Timestamp(_NS_LOWER_BOUND)
 Timestamp.max = Timestamp(_NS_UPPER_BOUND)
+Timestamp.resolution = Timedelta(nanoseconds=1)  # GH#21336, GH#21365
diff --git a/pandas/_libs/tslibs/timezones.pyx b/pandas/_libs/tslibs/timezones.pyx
index cbfbc14c35b35..35ee87e714fa8 100644
--- a/pandas/_libs/tslibs/timezones.pyx
+++ b/pandas/_libs/tslibs/timezones.pyx
@@ -226,11 +226,8 @@ cdef object get_dst_info(object tz):
         if treat_tz_as_pytz(tz):
             trans = np.array(tz._utc_transition_times, dtype='M8[ns]')
             trans = trans.view('i8')
-            try:
-                if tz._utc_transition_times[0].year == 1:
-                    trans[0] = NPY_NAT + 1
-            except Exception:
-                pass
+            if tz._utc_transition_times[0].year == 1:
+                trans[0] = NPY_NAT + 1
             deltas = unbox_utcoffsets(tz._transition_info)
             typ = 'pytz'
 
@@ -283,8 +280,8 @@ def infer_tzinfo(start, end):
     if start is not None and end is not None:
         tz = start.tzinfo
         if not tz_compare(tz, end.tzinfo):
-            msg = 'Inputs must both have the same timezone, {tz1} != {tz2}'
-            raise AssertionError(msg.format(tz1=tz, tz2=end.tzinfo))
+            raise AssertionError(f'Inputs must both have the same timezone, '
+                                 f'{tz} != {end.tzinfo}')
     elif start is not None:
         tz = start.tzinfo
     elif end is not None:
diff --git a/pandas/_libs/tslibs/tzconversion.pyx b/pandas/_libs/tslibs/tzconversion.pyx
index dd0c6fc75b06f..b368f0fde3edc 100644
--- a/pandas/_libs/tslibs/tzconversion.pyx
+++ b/pandas/_libs/tslibs/tzconversion.pyx
@@ -175,8 +175,8 @@ timedelta-like}
         if trans_idx.size == 1:
             stamp = _render_tstamp(vals[trans_idx])
             raise pytz.AmbiguousTimeError(
-                "Cannot infer dst time from %s as there "
-                "are no repeated times".format(stamp))
+                f"Cannot infer dst time from {stamp} as there "
+                f"are no repeated times")
         # Split the array into contiguous chunks (where the difference between
         # indices is 1).  These are effectively dst transitions in different
         # years which is useful for checking that there is not an ambiguous
@@ -200,8 +200,8 @@ timedelta-like}
                 switch_idx = (delta <= 0).nonzero()[0]
                 if switch_idx.size > 1:
                     raise pytz.AmbiguousTimeError(
-                        "There are %i dst switches when "
-                        "there should only be 1.".format(switch_idx.size))
+                        f"There are {switch_idx.size} dst switches when "
+                        f"there should only be 1.")
                 switch_idx = switch_idx[0] + 1
                 # Pull the only index and adjust
                 a_idx = grp[:switch_idx]
@@ -230,8 +230,8 @@ timedelta-like}
                 else:
                     stamp = _render_tstamp(val)
                     raise pytz.AmbiguousTimeError(
-                        "Cannot infer dst time from %r, try using the "
-                        "'ambiguous' argument".format(stamp))
+                        f"Cannot infer dst time from {stamp}, try using the "
+                        f"'ambiguous' argument")
         elif left != NPY_NAT:
             result[i] = left
         elif right != NPY_NAT:
@@ -246,8 +246,8 @@ timedelta-like}
                     # time
                     if -1 < shift_delta + remaining_mins < HOURS_NS:
                         raise ValueError(
-                            "The provided timedelta will relocalize on a "
-                            "nonexistent time: {}".format(nonexistent)
+                            f"The provided timedelta will relocalize on a "
+                            f"nonexistent time: {nonexistent}"
                         )
                     new_local = val + shift_delta
                 elif shift_forward:
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index 63cbd36f9cd1d..936532a81c6d6 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -218,7 +218,7 @@ cdef inline bint is_nan(object val):
     return is_complex_object(val) and val != val
 
 
-cdef inline const char* get_c_string_buf_and_size(object py_string,
+cdef inline const char* get_c_string_buf_and_size(str py_string,
                                                   Py_ssize_t *length):
     """
     Extract internal char* buffer of unicode or bytes object `py_string` with
@@ -231,7 +231,7 @@ cdef inline const char* get_c_string_buf_and_size(object py_string,
 
     Parameters
     ----------
-    py_string : object
+    py_string : str
     length : Py_ssize_t*
 
     Returns
@@ -241,12 +241,9 @@ cdef inline const char* get_c_string_buf_and_size(object py_string,
     cdef:
         const char *buf
 
-    if PyUnicode_Check(py_string):
-        buf = PyUnicode_AsUTF8AndSize(py_string, length)
-    else:
-        PyBytes_AsStringAndSize(py_string, <char**>&buf, length)
+    buf = PyUnicode_AsUTF8AndSize(py_string, length)
     return buf
 
 
-cdef inline const char* get_c_string(object py_string):
+cdef inline const char* get_c_string(str py_string):
     return get_c_string_buf_and_size(py_string, NULL)
diff --git a/pandas/_libs/util.pxd b/pandas/_libs/util.pxd
index 15fedbb20beec..828bccf7d5641 100644
--- a/pandas/_libs/util.pxd
+++ b/pandas/_libs/util.pxd
@@ -1,7 +1,5 @@
 from pandas._libs.tslibs.util cimport *
 
-from cython cimport Py_ssize_t
-
 cimport numpy as cnp
 from numpy cimport ndarray
 
@@ -51,49 +49,3 @@ cdef inline void set_array_not_contiguous(ndarray ao) nogil:
     PyArray_CLEARFLAGS(ao,
                        (NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS))
 
-
-cdef inline Py_ssize_t validate_indexer(ndarray arr, object loc) except -1:
-    """
-    Cast the given indexer `loc` to an integer.  If it is negative, i.e. a
-    python-style indexing-from-the-end indexer, translate it to a
-    from-the-front indexer.  Raise if this is not possible.
-
-    Parameters
-    ----------
-    arr : ndarray
-    loc : object
-
-    Returns
-    -------
-    idx : Py_ssize_t
-
-    Raises
-    ------
-    IndexError
-    """
-    cdef:
-        Py_ssize_t idx, size
-        int casted
-
-    if is_float_object(loc):
-        casted = int(loc)
-        if casted == loc:
-            loc = casted
-
-    idx = <Py_ssize_t>loc
-    size = cnp.PyArray_SIZE(arr)
-
-    if idx < 0 and size > 0:
-        idx += size
-    if idx >= size or size == 0 or idx < 0:
-        raise IndexError('index out of bounds')
-
-    return idx
-
-
-cdef inline object get_value_at(ndarray arr, object loc):
-    cdef:
-        Py_ssize_t i
-
-    i = validate_indexer(arr, loc)
-    return arr[i]
diff --git a/pandas/tests/io/msgpack/__init__.py b/pandas/_libs/window/__init__.py
similarity index 100%
rename from pandas/tests/io/msgpack/__init__.py
rename to pandas/_libs/window/__init__.py
diff --git a/pandas/_libs/window.pyx b/pandas/_libs/window/aggregations.pyx
similarity index 52%
rename from pandas/_libs/window.pyx
rename to pandas/_libs/window/aggregations.pyx
index 8de593ce36c86..f675818599b2c 100644
--- a/pandas/_libs/window.pyx
+++ b/pandas/_libs/window/aggregations.pyx
@@ -18,12 +18,31 @@ cdef extern from "src/headers/cmath" namespace "std":
     int signbit(float64_t) nogil
     float64_t sqrt(float64_t x) nogil
 
-cimport pandas._libs.util as util
+from pandas._libs.algos import is_monotonic
+
 from pandas._libs.util cimport numeric
 
-from pandas._libs.skiplist cimport (
-    skiplist_t, skiplist_init, skiplist_destroy, skiplist_get, skiplist_insert,
-    skiplist_remove)
+cdef extern from "../src/skiplist.h":
+    ctypedef struct node_t:
+        node_t **next
+        int *width
+        double value
+        int is_nil
+        int levels
+        int ref_count
+
+    ctypedef struct skiplist_t:
+        node_t *head
+        node_t **tmp_chain
+        int *tmp_steps
+        int size
+        int maxlevels
+
+    skiplist_t* skiplist_init(int) nogil
+    void skiplist_destroy(skiplist_t*) nogil
+    double skiplist_get(skiplist_t*, int, int*) nogil
+    int skiplist_insert(skiplist_t*, double) nogil
+    int skiplist_remove(skiplist_t*, double) nogil
 
 cdef:
     float32_t MINfloat32 = np.NINF
@@ -37,6 +56,10 @@ cdef:
 cdef inline int int_max(int a, int b): return a if a >= b else b
 cdef inline int int_min(int a, int b): return a if a <= b else b
 
+cdef inline bint is_monotonic_start_end_bounds(
+    ndarray[int64_t, ndim=1] start, ndarray[int64_t, ndim=1] end
+):
+    return is_monotonic(start, False)[0] and is_monotonic(end, False)[0]
 
 # Cython implementations of rolling sum, mean, variance, skewness,
 # other statistical moment functions
@@ -48,39 +71,6 @@ cdef inline int int_min(int a, int b): return a if a <= b else b
 #   periodically revisited to see if it's still true.
 #
 
-
-def _check_minp(win, minp, N, floor=None):
-    """
-    Parameters
-    ----------
-    win: int
-    minp: int or None
-    N: len of window
-    floor: int, optional
-        default 1
-
-    Returns
-    -------
-    minimum period
-    """
-
-    if minp is None:
-        minp = 1
-    if not util.is_integer_object(minp):
-        raise ValueError("min_periods must be an integer")
-    if minp > win:
-        raise ValueError("min_periods (%d) must be <= "
-                         "window (%d)" % (minp, win))
-    elif minp > N:
-        minp = N + 1
-    elif minp < 0:
-        raise ValueError('min_periods must be >= 0')
-    if floor is None:
-        floor = 1
-
-    return max(minp, floor)
-
-
 # original C implementation by N. Devillard.
 # This code in public domain.
 # Function :   kth_smallest()
@@ -96,280 +86,23 @@ def _check_minp(win, minp, N, floor=None):
 # Physical description: 366 p.
 #               Series: Prentice-Hall Series in Automatic Computation
 
-# ----------------------------------------------------------------------
-# The indexer objects for rolling
-# These define start/end indexers to compute offsets
-
-
-cdef class WindowIndexer:
-
-    cdef:
-        ndarray start, end
-        int64_t N, minp, win
-        bint is_variable
-
-    def get_data(self):
-        return (self.start, self.end, <int64_t>self.N,
-                <int64_t>self.win, <int64_t>self.minp,
-                self.is_variable)
-
-
-cdef class MockFixedWindowIndexer(WindowIndexer):
-    """
-
-    We are just checking parameters of the indexer,
-    and returning a consistent API with fixed/variable
-    indexers.
-
-    Parameters
-    ----------
-    values: ndarray
-        values data array
-    win: int64_t
-        window size
-    minp: int64_t
-        min number of obs in a window to consider non-NaN
-    index: object
-        index of the values
-    floor: optional
-        unit for flooring
-    left_closed: bint
-        left endpoint closedness
-    right_closed: bint
-        right endpoint closedness
-
-    """
-    def __init__(self, ndarray values, int64_t win, int64_t minp,
-                 bint left_closed, bint right_closed,
-                 object index=None, object floor=None):
-
-        assert index is None
-        self.is_variable = 0
-        self.N = len(values)
-        self.minp = _check_minp(win, minp, self.N, floor=floor)
-        self.start = np.empty(0, dtype='int64')
-        self.end = np.empty(0, dtype='int64')
-        self.win = win
-
-
-cdef class FixedWindowIndexer(WindowIndexer):
-    """
-    create a fixed length window indexer object
-    that has start & end, that point to offsets in
-    the index object; these are defined based on the win
-    arguments
-
-    Parameters
-    ----------
-    values: ndarray
-        values data array
-    win: int64_t
-        window size
-    minp: int64_t
-        min number of obs in a window to consider non-NaN
-    index: object
-        index of the values
-    floor: optional
-        unit for flooring the unit
-    left_closed: bint
-        left endpoint closedness
-    right_closed: bint
-        right endpoint closedness
-
-    """
-    def __init__(self, ndarray values, int64_t win, int64_t minp,
-                 bint left_closed, bint right_closed,
-                 object index=None, object floor=None):
-        cdef ndarray start_s, start_e, end_s, end_e
-
-        assert index is None
-        self.is_variable = 0
-        self.N = len(values)
-        self.minp = _check_minp(win, minp, self.N, floor=floor)
-
-        start_s = np.zeros(win, dtype='int64')
-        start_e = np.arange(win, self.N, dtype='int64') - win + 1
-        self.start = np.concatenate([start_s, start_e])
-
-        end_s = np.arange(win, dtype='int64') + 1
-        end_e = start_e + win
-        self.end = np.concatenate([end_s, end_e])
-        self.win = win
-
-
-cdef class VariableWindowIndexer(WindowIndexer):
-    """
-    create a variable length window indexer object
-    that has start & end, that point to offsets in
-    the index object; these are defined based on the win
-    arguments
-
-    Parameters
-    ----------
-    values: ndarray
-        values data array
-    win: int64_t
-        window size
-    minp: int64_t
-        min number of obs in a window to consider non-NaN
-    index: ndarray
-        index of the values
-    left_closed: bint
-        left endpoint closedness
-        True if the left endpoint is closed, False if open
-    right_closed: bint
-        right endpoint closedness
-        True if the right endpoint is closed, False if open
-    floor: optional
-        unit for flooring the unit
-    """
-    def __init__(self, ndarray values, int64_t win, int64_t minp,
-                 bint left_closed, bint right_closed, ndarray index,
-                 object floor=None):
-
-        self.is_variable = 1
-        self.N = len(index)
-        self.minp = _check_minp(win, minp, self.N, floor=floor)
-
-        self.start = np.empty(self.N, dtype='int64')
-        self.start.fill(-1)
-
-        self.end = np.empty(self.N, dtype='int64')
-        self.end.fill(-1)
-
-        self.build(index, win, left_closed, right_closed)
-
-        # max window size
-        self.win = (self.end - self.start).max()
-
-    def build(self, const int64_t[:] index, int64_t win, bint left_closed,
-              bint right_closed):
-
-        cdef:
-            ndarray[int64_t] start, end
-            int64_t start_bound, end_bound, N
-            Py_ssize_t i, j
-
-        start = self.start
-        end = self.end
-        N = self.N
-
-        start[0] = 0
-
-        # right endpoint is closed
-        if right_closed:
-            end[0] = 1
-        # right endpoint is open
-        else:
-            end[0] = 0
-
-        with nogil:
-
-            # start is start of slice interval (including)
-            # end is end of slice interval (not including)
-            for i in range(1, N):
-                end_bound = index[i]
-                start_bound = index[i] - win
-
-                # left endpoint is closed
-                if left_closed:
-                    start_bound -= 1
-
-                # advance the start bound until we are
-                # within the constraint
-                start[i] = i
-                for j in range(start[i - 1], i):
-                    if index[j] > start_bound:
-                        start[i] = j
-                        break
-
-                # end bound is previous end
-                # or current index
-                if index[end[i - 1]] <= end_bound:
-                    end[i] = i + 1
-                else:
-                    end[i] = end[i - 1]
-
-                # right endpoint is open
-                if not right_closed:
-                    end[i] -= 1
-
-
-def get_window_indexer(values, win, minp, index, closed,
-                       floor=None, use_mock=True):
-    """
-    return the correct window indexer for the computation
-
-    Parameters
-    ----------
-    values: 1d ndarray
-    win: integer, window size
-    minp: integer, minimum periods
-    index: 1d ndarray, optional
-        index to the values array
-    closed: string, default None
-        {'right', 'left', 'both', 'neither'}
-        window endpoint closedness. Defaults to 'right' in
-        VariableWindowIndexer and to 'both' in FixedWindowIndexer
-    floor: optional
-        unit for flooring the unit
-    use_mock: boolean, default True
-        if we are a fixed indexer, return a mock indexer
-        instead of the FixedWindow Indexer. This is a type
-        compat Indexer that allows us to use a standard
-        code path with all of the indexers.
-
-
-    Returns
-    -------
-    tuple of 1d int64 ndarrays of the offsets & data about the window
-
-    """
-
-    cdef:
-        bint left_closed = False
-        bint right_closed = False
-
-    assert closed is None or closed in ['right', 'left', 'both', 'neither']
-
-    # if windows is variable, default is 'right', otherwise default is 'both'
-    if closed is None:
-        closed = 'right' if index is not None else 'both'
-
-    if closed in ['right', 'both']:
-        right_closed = True
-
-    if closed in ['left', 'both']:
-        left_closed = True
-
-    if index is not None:
-        indexer = VariableWindowIndexer(values, win, minp, left_closed,
-                                        right_closed, index, floor)
-    elif use_mock:
-        indexer = MockFixedWindowIndexer(values, win, minp, left_closed,
-                                         right_closed, index, floor)
-    else:
-        indexer = FixedWindowIndexer(values, win, minp, left_closed,
-                                     right_closed, index, floor)
-    return indexer.get_data()
-
-
 # ----------------------------------------------------------------------
 # Rolling count
 # this is only an impl for index not None, IOW, freq aware
 
 
-def roll_count(ndarray[float64_t] values, int64_t win, int64_t minp,
-               object index, object closed):
+def roll_count(
+    ndarray[float64_t] values,
+    ndarray[int64_t] start,
+    ndarray[int64_t] end,
+    int64_t minp,
+):
     cdef:
         float64_t val, count_x = 0.0
-        int64_t s, e, nobs, N
+        int64_t s, e, nobs, N = len(values)
         Py_ssize_t i, j
-        ndarray[int64_t] start, end
         ndarray[float64_t] output
 
-    start, end, N, win, minp, _ = get_window_indexer(values, win,
-                                                     minp, index, closed)
     output = np.empty(N, dtype=float)
 
     with nogil:
@@ -413,8 +146,7 @@ def roll_count(ndarray[float64_t] values, int64_t win, int64_t minp,
 # Rolling sum
 
 
-cdef inline float64_t calc_sum(int64_t minp, int64_t nobs,
-                               float64_t sum_x) nogil:
+cdef inline float64_t calc_sum(int64_t minp, int64_t nobs, float64_t sum_x) nogil:
     cdef:
         float64_t result
 
@@ -435,8 +167,7 @@ cdef inline void add_sum(float64_t val, int64_t *nobs, float64_t *sum_x) nogil:
         sum_x[0] = sum_x[0] + val
 
 
-cdef inline void remove_sum(float64_t val,
-                            int64_t *nobs, float64_t *sum_x) nogil:
+cdef inline void remove_sum(float64_t val, int64_t *nobs, float64_t *sum_x) nogil:
     """ remove a value from the sum calc """
 
     if notnan(val):
@@ -444,80 +175,80 @@ cdef inline void remove_sum(float64_t val,
         sum_x[0] = sum_x[0] - val
 
 
-def roll_sum(ndarray[float64_t] values, int64_t win, int64_t minp,
-             object index, object closed):
+def roll_sum_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                      ndarray[int64_t] end, int64_t minp):
     cdef:
-        float64_t val, prev_x, sum_x = 0
-        int64_t s, e, range_endpoint
-        int64_t nobs = 0, i, j, N
-        bint is_variable
-        ndarray[int64_t] start, end
+        float64_t sum_x = 0
+        int64_t s, e
+        int64_t nobs = 0, i, j, N = len(values)
         ndarray[float64_t] output
+        bint is_monotonic_bounds
 
-    start, end, N, win, minp, is_variable = get_window_indexer(values, win,
-                                                               minp, index,
-                                                               closed,
-                                                               floor=0)
+    is_monotonic_bounds = is_monotonic_start_end_bounds(start, end)
     output = np.empty(N, dtype=float)
 
-    # for performance we are going to iterate
-    # fixed windows separately, makes the code more complex as we have 2 paths
-    # but is faster
+    with nogil:
 
-    if is_variable:
+        for i in range(0, N):
+            s = start[i]
+            e = end[i]
 
-        # variable window
-        with nogil:
+            if i == 0 or not is_monotonic_bounds:
 
-            for i in range(0, N):
-                s = start[i]
-                e = end[i]
+                # setup
 
-                if i == 0:
+                for j in range(s, e):
+                    add_sum(values[j], &nobs, &sum_x)
 
-                    # setup
-                    sum_x = 0.0
-                    nobs = 0
-                    for j in range(s, e):
-                        add_sum(values[j], &nobs, &sum_x)
+            else:
 
-                else:
+                # calculate deletes
+                for j in range(start[i - 1], s):
+                    remove_sum(values[j], &nobs, &sum_x)
 
-                    # calculate deletes
-                    for j in range(start[i - 1], s):
-                        remove_sum(values[j], &nobs, &sum_x)
+                # calculate adds
+                for j in range(end[i - 1], e):
+                    add_sum(values[j], &nobs, &sum_x)
 
-                    # calculate adds
-                    for j in range(end[i - 1], e):
-                        add_sum(values[j], &nobs, &sum_x)
+            output[i] = calc_sum(minp, nobs, sum_x)
 
-                output[i] = calc_sum(minp, nobs, sum_x)
+            if not is_monotonic_bounds:
+                for j in range(s, e):
+                    remove_sum(values[j], &nobs, &sum_x)
 
-    else:
+    return output
 
-        # fixed window
 
-        range_endpoint = int_max(minp, 1) - 1
+def roll_sum_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                   ndarray[int64_t] end, int64_t minp, int64_t win):
+    cdef:
+        float64_t val, prev_x, sum_x = 0
+        int64_t range_endpoint
+        int64_t nobs = 0, i, N = len(values)
+        ndarray[float64_t] output
 
-        with nogil:
+    output = np.empty(N, dtype=float)
 
-            for i in range(0, range_endpoint):
-                add_sum(values[i], &nobs, &sum_x)
-                output[i] = NaN
+    range_endpoint = int_max(minp, 1) - 1
+
+    with nogil:
+
+        for i in range(0, range_endpoint):
+            add_sum(values[i], &nobs, &sum_x)
+            output[i] = NaN
 
-            for i in range(range_endpoint, N):
-                val = values[i]
-                add_sum(val, &nobs, &sum_x)
+        for i in range(range_endpoint, N):
+            val = values[i]
+            add_sum(val, &nobs, &sum_x)
 
-                if i > win - 1:
-                    prev_x = values[i - win]
-                    remove_sum(prev_x, &nobs, &sum_x)
+            if i > win - 1:
+                prev_x = values[i - win]
+                remove_sum(prev_x, &nobs, &sum_x)
 
-                output[i] = calc_sum(minp, nobs, sum_x)
+            output[i] = calc_sum(minp, nobs, sum_x)
 
     return output
 
-
 # ----------------------------------------------------------------------
 # Rolling mean
 
@@ -565,76 +296,78 @@ cdef inline void remove_mean(float64_t val, Py_ssize_t *nobs, float64_t *sum_x,
             neg_ct[0] = neg_ct[0] - 1
 
 
-def roll_mean(ndarray[float64_t] values, int64_t win, int64_t minp,
-              object index, object closed):
+def roll_mean_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                    ndarray[int64_t] end, int64_t minp, int64_t win):
     cdef:
-        float64_t val, prev_x, result, sum_x = 0
-        int64_t s, e
-        bint is_variable
-        Py_ssize_t nobs = 0, i, j, neg_ct = 0, N
-        ndarray[int64_t] start, end
+        float64_t val, prev_x, sum_x = 0
+        Py_ssize_t nobs = 0, i, neg_ct = 0, N = len(values)
         ndarray[float64_t] output
 
-    start, end, N, win, minp, is_variable = get_window_indexer(values, win,
-                                                               minp, index,
-                                                               closed)
     output = np.empty(N, dtype=float)
 
-    # for performance we are going to iterate
-    # fixed windows separately, makes the code more complex as we have 2 paths
-    # but is faster
+    with nogil:
+        for i in range(minp - 1):
+            val = values[i]
+            add_mean(val, &nobs, &sum_x, &neg_ct)
+            output[i] = NaN
 
-    if is_variable:
+        for i in range(minp - 1, N):
+            val = values[i]
+            add_mean(val, &nobs, &sum_x, &neg_ct)
 
-        with nogil:
+            if i > win - 1:
+                prev_x = values[i - win]
+                remove_mean(prev_x, &nobs, &sum_x, &neg_ct)
 
-            for i in range(0, N):
-                s = start[i]
-                e = end[i]
+            output[i] = calc_mean(minp, nobs, neg_ct, sum_x)
 
-                if i == 0:
+    return output
 
-                    # setup
-                    sum_x = 0.0
-                    nobs = 0
-                    for j in range(s, e):
-                        val = values[j]
-                        add_mean(val, &nobs, &sum_x, &neg_ct)
 
-                else:
+def roll_mean_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                       ndarray[int64_t] end, int64_t minp):
+    cdef:
+        float64_t val, sum_x = 0
+        int64_t s, e
+        Py_ssize_t nobs = 0, i, j, neg_ct = 0, N = len(values)
+        ndarray[float64_t] output
+        bint is_monotonic_bounds
 
-                    # calculate deletes
-                    for j in range(start[i - 1], s):
-                        val = values[j]
-                        remove_mean(val, &nobs, &sum_x, &neg_ct)
+    is_monotonic_bounds = is_monotonic_start_end_bounds(start, end)
+    output = np.empty(N, dtype=float)
 
-                    # calculate adds
-                    for j in range(end[i - 1], e):
-                        val = values[j]
-                        add_mean(val, &nobs, &sum_x, &neg_ct)
+    with nogil:
 
-                output[i] = calc_mean(minp, nobs, neg_ct, sum_x)
+        for i in range(0, N):
+            s = start[i]
+            e = end[i]
 
-    else:
+            if i == 0 or not is_monotonic_bounds:
 
-        with nogil:
-            for i in range(minp - 1):
-                val = values[i]
-                add_mean(val, &nobs, &sum_x, &neg_ct)
-                output[i] = NaN
+                # setup
+                for j in range(s, e):
+                    val = values[j]
+                    add_mean(val, &nobs, &sum_x, &neg_ct)
 
-            for i in range(minp - 1, N):
-                val = values[i]
-                add_mean(val, &nobs, &sum_x, &neg_ct)
+            else:
 
-                if i > win - 1:
-                    prev_x = values[i - win]
-                    remove_mean(prev_x, &nobs, &sum_x, &neg_ct)
+                # calculate deletes
+                for j in range(start[i - 1], s):
+                    val = values[j]
+                    remove_mean(val, &nobs, &sum_x, &neg_ct)
 
-                output[i] = calc_mean(minp, nobs, neg_ct, sum_x)
+                # calculate adds
+                for j in range(end[i - 1], e):
+                    val = values[j]
+                    add_mean(val, &nobs, &sum_x, &neg_ct)
 
-    return output
+            output[i] = calc_mean(minp, nobs, neg_ct, sum_x)
 
+            if not is_monotonic_bounds:
+                for j in range(s, e):
+                    val = values[j]
+                    remove_mean(val, &nobs, &sum_x, &neg_ct)
+    return output
 
 # ----------------------------------------------------------------------
 # Rolling variance
@@ -698,8 +431,8 @@ cdef inline void remove_var(float64_t val, float64_t *nobs, float64_t *mean_x,
             ssqdm_x[0] = 0
 
 
-def roll_var(ndarray[float64_t] values, int64_t win, int64_t minp,
-             object index, object closed, int ddof=1):
+def roll_var_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                   ndarray[int64_t] end, int64_t minp, int64_t win, int ddof=1):
     """
     Numerically stable implementation using Welford's method.
     """
@@ -707,98 +440,108 @@ def roll_var(ndarray[float64_t] values, int64_t win, int64_t minp,
         float64_t mean_x = 0, ssqdm_x = 0, nobs = 0,
         float64_t val, prev, delta, mean_x_old
         int64_t s, e
-        bint is_variable
-        Py_ssize_t i, j, N
-        ndarray[int64_t] start, end
+        Py_ssize_t i, j, N = len(values)
         ndarray[float64_t] output
 
-    start, end, N, win, minp, is_variable = get_window_indexer(values, win,
-                                                               minp, index,
-                                                               closed)
     output = np.empty(N, dtype=float)
 
     # Check for windows larger than array, addresses #7297
     win = min(win, N)
 
-    # for performance we are going to iterate
-    # fixed windows separately, makes the code more complex as we
-    # have 2 paths but is faster
+    with nogil:
 
-    if is_variable:
+        # Over the first window, observations can only be added, never
+        # removed
+        for i in range(win):
+            add_var(values[i], &nobs, &mean_x, &ssqdm_x)
+            output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
 
-        with nogil:
+        # a part of Welford's method for the online variance-calculation
+        # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
 
-            for i in range(0, N):
+        # After the first window, observations can both be added and
+        # removed
+        for i in range(win, N):
+            val = values[i]
+            prev = values[i - win]
 
-                s = start[i]
-                e = end[i]
+            if notnan(val):
+                if prev == prev:
 
-                # Over the first window, observations can only be added
-                # never removed
-                if i == 0:
+                    # Adding one observation and removing another one
+                    delta = val - prev
+                    mean_x_old = mean_x
 
-                    for j in range(s, e):
-                        add_var(values[j], &nobs, &mean_x, &ssqdm_x)
+                    mean_x += delta / nobs
+                    ssqdm_x += ((nobs - 1) * val
+                                + (nobs + 1) * prev
+                                - 2 * nobs * mean_x_old) * delta / nobs
 
                 else:
+                    add_var(val, &nobs, &mean_x, &ssqdm_x)
+            elif prev == prev:
+                remove_var(prev, &nobs, &mean_x, &ssqdm_x)
 
-                    # After the first window, observations can both be added
-                    # and removed
+            output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
 
-                    # calculate adds
-                    for j in range(end[i - 1], e):
-                        add_var(values[j], &nobs, &mean_x, &ssqdm_x)
+    return output
 
-                    # calculate deletes
-                    for j in range(start[i - 1], s):
-                        remove_var(values[j], &nobs, &mean_x, &ssqdm_x)
 
-                output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
+def roll_var_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                      ndarray[int64_t] end, int64_t minp, int ddof=1):
+    """
+    Numerically stable implementation using Welford's method.
+    """
+    cdef:
+        float64_t mean_x = 0, ssqdm_x = 0, nobs = 0,
+        float64_t val, prev, delta, mean_x_old
+        int64_t s, e
+        Py_ssize_t i, j, N = len(values)
+        ndarray[float64_t] output
+        bint is_monotonic_bounds
 
-    else:
+    is_monotonic_bounds = is_monotonic_start_end_bounds(start, end)
+    output = np.empty(N, dtype=float)
 
-        with nogil:
+    with nogil:
 
-            # Over the first window, observations can only be added, never
-            # removed
-            for i in range(win):
-                add_var(values[i], &nobs, &mean_x, &ssqdm_x)
-                output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
+        for i in range(0, N):
 
-            # a part of Welford's method for the online variance-calculation
-            # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+            s = start[i]
+            e = end[i]
 
-            # After the first window, observations can both be added and
-            # removed
-            for i in range(win, N):
-                val = values[i]
-                prev = values[i - win]
+            # Over the first window, observations can only be added
+            # never removed
+            if i == 0 or not is_monotonic_bounds:
 
-                if notnan(val):
-                    if prev == prev:
+                for j in range(s, e):
+                    add_var(values[j], &nobs, &mean_x, &ssqdm_x)
 
-                        # Adding one observation and removing another one
-                        delta = val - prev
-                        mean_x_old = mean_x
+            else:
 
-                        mean_x += delta / nobs
-                        ssqdm_x += ((nobs - 1) * val
-                                    + (nobs + 1) * prev
-                                    - 2 * nobs * mean_x_old) * delta / nobs
+                # After the first window, observations can both be added
+                # and removed
 
-                    else:
-                        add_var(val, &nobs, &mean_x, &ssqdm_x)
-                elif prev == prev:
-                    remove_var(prev, &nobs, &mean_x, &ssqdm_x)
+                # calculate adds
+                for j in range(end[i - 1], e):
+                    add_var(values[j], &nobs, &mean_x, &ssqdm_x)
 
-                output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
+                # calculate deletes
+                for j in range(start[i - 1], s):
+                    remove_var(values[j], &nobs, &mean_x, &ssqdm_x)
 
-    return output
+            output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
 
+            if not is_monotonic_bounds:
+                for j in range(s, e):
+                    remove_var(values[j], &nobs, &mean_x, &ssqdm_x)
+
+    return output
 
 # ----------------------------------------------------------------------
 # Rolling skewness
 
+
 cdef inline float64_t calc_skew(int64_t minp, int64_t nobs,
                                 float64_t x, float64_t xx,
                                 float64_t xxx) nogil:
@@ -863,76 +606,87 @@ cdef inline void remove_skew(float64_t val, int64_t *nobs,
         xxx[0] = xxx[0] - val * val * val
 
 
-def roll_skew(ndarray[float64_t] values, int64_t win, int64_t minp,
-              object index, object closed):
+def roll_skew_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                    ndarray[int64_t] end, int64_t minp, int64_t win):
     cdef:
         float64_t val, prev
         float64_t x = 0, xx = 0, xxx = 0
-        int64_t nobs = 0, i, j, N
+        int64_t nobs = 0, i, j, N = len(values)
         int64_t s, e
-        bint is_variable
-        ndarray[int64_t] start, end
         ndarray[float64_t] output
 
-    start, end, N, win, minp, is_variable = get_window_indexer(values, win,
-                                                               minp, index,
-                                                               closed)
     output = np.empty(N, dtype=float)
 
-    if is_variable:
+    with nogil:
+        for i in range(minp - 1):
+            val = values[i]
+            add_skew(val, &nobs, &x, &xx, &xxx)
+            output[i] = NaN
 
-        with nogil:
+        for i in range(minp - 1, N):
+            val = values[i]
+            add_skew(val, &nobs, &x, &xx, &xxx)
 
-            for i in range(0, N):
+            if i > win - 1:
+                prev = values[i - win]
+                remove_skew(prev, &nobs, &x, &xx, &xxx)
 
-                s = start[i]
-                e = end[i]
+            output[i] = calc_skew(minp, nobs, x, xx, xxx)
 
-                # Over the first window, observations can only be added
-                # never removed
-                if i == 0:
+    return output
 
-                    for j in range(s, e):
-                        val = values[j]
-                        add_skew(val, &nobs, &x, &xx, &xxx)
 
-                else:
+def roll_skew_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                       ndarray[int64_t] end, int64_t minp):
+    cdef:
+        float64_t val, prev
+        float64_t x = 0, xx = 0, xxx = 0
+        int64_t nobs = 0, i, j, N = len(values)
+        int64_t s, e
+        ndarray[float64_t] output
+        bint is_monotonic_bounds
 
-                    # After the first window, observations can both be added
-                    # and removed
+    is_monotonic_bounds = is_monotonic_start_end_bounds(start, end)
+    output = np.empty(N, dtype=float)
 
-                    # calculate adds
-                    for j in range(end[i - 1], e):
-                        val = values[j]
-                        add_skew(val, &nobs, &x, &xx, &xxx)
+    with nogil:
 
-                    # calculate deletes
-                    for j in range(start[i - 1], s):
-                        val = values[j]
-                        remove_skew(val, &nobs, &x, &xx, &xxx)
+        for i in range(0, N):
 
-                output[i] = calc_skew(minp, nobs, x, xx, xxx)
+            s = start[i]
+            e = end[i]
 
-    else:
+            # Over the first window, observations can only be added
+            # never removed
+            if i == 0 or not is_monotonic_bounds:
 
-        with nogil:
-            for i in range(minp - 1):
-                val = values[i]
-                add_skew(val, &nobs, &x, &xx, &xxx)
-                output[i] = NaN
+                for j in range(s, e):
+                    val = values[j]
+                    add_skew(val, &nobs, &x, &xx, &xxx)
 
-            for i in range(minp - 1, N):
-                val = values[i]
-                add_skew(val, &nobs, &x, &xx, &xxx)
+            else:
 
-                if i > win - 1:
-                    prev = values[i - win]
-                    remove_skew(prev, &nobs, &x, &xx, &xxx)
+                # After the first window, observations can both be added
+                # and removed
 
-                output[i] = calc_skew(minp, nobs, x, xx, xxx)
+                # calculate adds
+                for j in range(end[i - 1], e):
+                    val = values[j]
+                    add_skew(val, &nobs, &x, &xx, &xxx)
 
-    return output
+                # calculate deletes
+                for j in range(start[i - 1], s):
+                    val = values[j]
+                    remove_skew(val, &nobs, &x, &xx, &xxx)
+
+            output[i] = calc_skew(minp, nobs, x, xx, xxx)
+
+            if not is_monotonic_bounds:
+                for j in range(s, e):
+                    val = values[j]
+                    remove_skew(val, &nobs, &x, &xx, &xxx)
 
+    return output
 
 # ----------------------------------------------------------------------
 # Rolling kurtosis
@@ -1007,69 +761,79 @@ cdef inline void remove_kurt(float64_t val, int64_t *nobs,
         xxxx[0] = xxxx[0] - val * val * val * val
 
 
-def roll_kurt(ndarray[float64_t] values, int64_t win, int64_t minp,
-              object index, object closed):
+def roll_kurt_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                    ndarray[int64_t] end, int64_t minp, int64_t win):
     cdef:
         float64_t val, prev
         float64_t x = 0, xx = 0, xxx = 0, xxxx = 0
-        int64_t nobs = 0, i, j, N
+        int64_t nobs = 0, i, j, N = len(values)
         int64_t s, e
-        bint is_variable
-        ndarray[int64_t] start, end
         ndarray[float64_t] output
 
-    start, end, N, win, minp, is_variable = get_window_indexer(values, win,
-                                                               minp, index,
-                                                               closed)
     output = np.empty(N, dtype=float)
 
-    if is_variable:
+    with nogil:
 
-        with nogil:
+        for i in range(minp - 1):
+            add_kurt(values[i], &nobs, &x, &xx, &xxx, &xxxx)
+            output[i] = NaN
 
-            for i in range(0, N):
+        for i in range(minp - 1, N):
+            add_kurt(values[i], &nobs, &x, &xx, &xxx, &xxxx)
 
-                s = start[i]
-                e = end[i]
+            if i > win - 1:
+                prev = values[i - win]
+                remove_kurt(prev, &nobs, &x, &xx, &xxx, &xxxx)
 
-                # Over the first window, observations can only be added
-                # never removed
-                if i == 0:
+            output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx)
 
-                    for j in range(s, e):
-                        add_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
+    return output
 
-                else:
 
-                    # After the first window, observations can both be added
-                    # and removed
+def roll_kurt_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                       ndarray[int64_t] end, int64_t minp):
+    cdef:
+        float64_t val, prev
+        float64_t x = 0, xx = 0, xxx = 0, xxxx = 0
+        int64_t nobs = 0, i, j, s, e, N = len(values)
+        ndarray[float64_t] output
+        bint is_monotonic_bounds
 
-                    # calculate adds
-                    for j in range(end[i - 1], e):
-                        add_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
+    is_monotonic_bounds = is_monotonic_start_end_bounds(start, end)
+    output = np.empty(N, dtype=float)
 
-                    # calculate deletes
-                    for j in range(start[i - 1], s):
-                        remove_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
+    with nogil:
 
-                output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx)
+        for i in range(0, N):
 
-    else:
+            s = start[i]
+            e = end[i]
 
-        with nogil:
+            # Over the first window, observations can only be added
+            # never removed
+            if i == 0 or not is_monotonic_bounds:
 
-            for i in range(minp - 1):
-                add_kurt(values[i], &nobs, &x, &xx, &xxx, &xxxx)
-                output[i] = NaN
+                for j in range(s, e):
+                    add_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
 
-            for i in range(minp - 1, N):
-                add_kurt(values[i], &nobs, &x, &xx, &xxx, &xxxx)
+            else:
 
-                if i > win - 1:
-                    prev = values[i - win]
-                    remove_kurt(prev, &nobs, &x, &xx, &xxx, &xxxx)
+                # After the first window, observations can both be added
+                # and removed
 
-                output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx)
+                # calculate adds
+                for j in range(end[i - 1], e):
+                    add_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
+
+                # calculate deletes
+                for j in range(start[i - 1], s):
+                    remove_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
+
+            output[i] = calc_kurt(minp, nobs, x, xx, xxx, xxxx)
+
+            if not is_monotonic_bounds:
+                for j in range(s, e):
+                    remove_kurt(values[j], &nobs, &x, &xx, &xxx, &xxxx)
 
     return output
 
@@ -1078,31 +842,26 @@ def roll_kurt(ndarray[float64_t] values, int64_t win, int64_t minp,
 # Rolling median, min, max
 
 
-def roll_median_c(ndarray[float64_t] values, int64_t win, int64_t minp,
-                  object index, object closed):
+def roll_median_c(ndarray[float64_t] values, ndarray[int64_t] start,
+                  ndarray[int64_t] end, int64_t minp, int64_t win):
     cdef:
         float64_t val, res, prev
-        bint err = 0, is_variable
+        bint err = 0
         int ret = 0
         skiplist_t *sl
         Py_ssize_t i, j
-        int64_t nobs = 0, N, s, e
+        int64_t nobs = 0, N = len(values), s, e
         int midpoint
-        ndarray[int64_t] start, end
         ndarray[float64_t] output
 
     # we use the Fixed/Variable Indexer here as the
     # actual skiplist ops outweigh any window computation costs
-    start, end, N, win, minp, is_variable = get_window_indexer(
-        values, win,
-        minp, index, closed,
-        use_mock=False)
     output = np.empty(N, dtype=float)
 
-    if win == 0:
+    if win == 0 or (end - start).max() == 0:
         output[:] = NaN
         return output
-
+    win = (end - start).max()
     sl = skiplist_init(<int>win)
     if sl == NULL:
         raise MemoryError("skiplist_init failed")
@@ -1164,7 +923,7 @@ def roll_median_c(ndarray[float64_t] values, int64_t win, int64_t minp,
 
 # Moving maximum / minimum code taken from Bottleneck under the terms
 # of its Simplified BSD license
-# https://github.com/kwgoodman/bottleneck
+# https://github.com/pydata/bottleneck
 
 
 cdef inline numeric init_mm(numeric ai, Py_ssize_t *nobs, bint is_max) nogil:
@@ -1211,76 +970,89 @@ cdef inline numeric calc_mm(int64_t minp, Py_ssize_t nobs,
     return result
 
 
-def roll_max(ndarray[numeric] values, int64_t win, int64_t minp,
-             object index, object closed):
+def roll_max_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                   ndarray[int64_t] end, int64_t minp, int64_t win):
     """
     Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
 
     Parameters
     ----------
-    values: numpy array
-    window: int, size of rolling window
-    minp: if number of observations in window
+    values : np.ndarray[np.float64]
+    window : int, size of rolling window
+    minp : if number of observations in window
           is below this, output a NaN
-    index: ndarray, optional
+    index : ndarray, optional
        index for window computation
-    closed: 'right', 'left', 'both', 'neither'
+    closed : 'right', 'left', 'both', 'neither'
             make the interval closed on the right, left,
             both or neither endpoints
     """
-    return _roll_min_max(values, win, minp, index, closed=closed, is_max=1)
+    return _roll_min_max_fixed(values, start, end, minp, win, is_max=1)
 
 
-def roll_min(ndarray[numeric] values, int64_t win, int64_t minp,
-             object index, object closed):
+def roll_max_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                      ndarray[int64_t] end, int64_t minp):
     """
     Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
 
     Parameters
     ----------
-    values: numpy array
-    window: int, size of rolling window
-    minp: if number of observations in window
+    values : np.ndarray[np.float64]
+    window : int, size of rolling window
+    minp : if number of observations in window
           is below this, output a NaN
-    index: ndarray, optional
+    index : ndarray, optional
        index for window computation
+    closed : 'right', 'left', 'both', 'neither'
+            make the interval closed on the right, left,
+            both or neither endpoints
     """
-    return _roll_min_max(values, win, minp, index, is_max=0, closed=closed)
+    return _roll_min_max_variable(values, start, end, minp, is_max=1)
 
 
-cdef _roll_min_max(ndarray[numeric] values, int64_t win, int64_t minp,
-                   object index, object closed, bint is_max):
+def roll_min_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
+                   ndarray[int64_t] end, int64_t minp, int64_t win):
     """
-    Moving min/max of 1d array of any numeric type along axis=0
-    ignoring NaNs.
+    Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
+
+    Parameters
+    ----------
+    values : np.ndarray[np.float64]
+    window : int, size of rolling window
+    minp : if number of observations in window
+          is below this, output a NaN
+    index : ndarray, optional
+       index for window computation
     """
-    cdef:
-        ndarray[int64_t] starti, endi
-        int64_t N
-        bint is_variable
+    return _roll_min_max_fixed(values, start, end, minp, win, is_max=0)
 
-    starti, endi, N, win, minp, is_variable = get_window_indexer(
-        values, win,
-        minp, index, closed)
 
-    if is_variable:
-        return _roll_min_max_variable(values, starti, endi, N, win, minp,
-                                      is_max)
-    else:
-        return _roll_min_max_fixed(values, N, win, minp, is_max)
+def roll_min_variable(ndarray[float64_t] values, ndarray[int64_t] start,
+                      ndarray[int64_t] end, int64_t minp):
+    """
+    Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
+
+    Parameters
+    ----------
+    values : np.ndarray[np.float64]
+    window : int, size of rolling window
+    minp : if number of observations in window
+          is below this, output a NaN
+    index : ndarray, optional
+       index for window computation
+    """
+    return _roll_min_max_variable(values, start, end, minp, is_max=0)
 
 
 cdef _roll_min_max_variable(ndarray[numeric] values,
                             ndarray[int64_t] starti,
                             ndarray[int64_t] endi,
-                            int64_t N,
-                            int64_t win,
                             int64_t minp,
                             bint is_max):
     cdef:
         numeric ai
         int64_t i, close_offset, curr_win_size
-        Py_ssize_t nobs = 0
+        Py_ssize_t nobs = 0, N = len(values)
         deque Q[int64_t]  # min/max always the front
         deque W[int64_t]  # track the whole window for nobs compute
         ndarray[float64_t, ndim=1] output
@@ -1296,7 +1068,7 @@ cdef _roll_min_max_variable(ndarray[numeric] values,
         # The original impl didn't deal with variable window sizes
         # So the code was optimized for that
 
-        for i from starti[0] <= i < endi[0]:
+        for i in range(starti[0], endi[0]):
             ai = init_mm(values[i], &nobs, is_max)
 
             # Discard previous entries if we find new min or max
@@ -1355,15 +1127,16 @@ cdef _roll_min_max_variable(ndarray[numeric] values,
 
 
 cdef _roll_min_max_fixed(ndarray[numeric] values,
-                         int64_t N,
-                         int64_t win,
+                         ndarray[int64_t] starti,
+                         ndarray[int64_t] endi,
                          int64_t minp,
+                         int64_t win,
                          bint is_max):
     cdef:
         numeric ai
         bint should_replace
         int64_t i, removed, window_i,
-        Py_ssize_t nobs = 0
+        Py_ssize_t nobs = 0, N = len(values)
         int64_t* death
         numeric* ring
         numeric* minvalue
@@ -1459,8 +1232,8 @@ interpolation_types = {
 }
 
 
-def roll_quantile(ndarray[float64_t, cast=True] values, int64_t win,
-                  int64_t minp, object index, object closed,
+def roll_quantile(ndarray[float64_t, cast=True] values, ndarray[int64_t] start,
+                  ndarray[int64_t] end, int64_t minp, int64_t win,
                   float64_t quantile, str interpolation):
     """
     O(N log(window)) implementation using skip list
@@ -1468,36 +1241,29 @@ def roll_quantile(ndarray[float64_t, cast=True] values, int64_t win,
     cdef:
         float64_t val, prev, midpoint, idx_with_fraction
         skiplist_t *skiplist
-        int64_t nobs = 0, i, j, s, e, N
+        int64_t nobs = 0, i, j, s, e, N = len(values)
         Py_ssize_t idx
-        bint is_variable
-        ndarray[int64_t] start, end
         ndarray[float64_t] output
         float64_t vlow, vhigh
         InterpolationType interpolation_type
         int ret = 0
 
     if quantile <= 0.0 or quantile >= 1.0:
-        raise ValueError("quantile value {0} not in [0, 1]".format(quantile))
+        raise ValueError(f"quantile value {quantile} not in [0, 1]")
 
     try:
         interpolation_type = interpolation_types[interpolation]
     except KeyError:
-        raise ValueError("Interpolation '{interp}' is not supported"
-                         .format(interp=interpolation))
+        raise ValueError(f"Interpolation '{interpolation}' is not supported")
 
     # we use the Fixed/Variable Indexer here as the
     # actual skiplist ops outweigh any window computation costs
-    start, end, N, win, minp, is_variable = get_window_indexer(
-        values, win,
-        minp, index, closed,
-        use_mock=False)
     output = np.empty(N, dtype=float)
 
-    if win == 0:
+    if win == 0 or (end - start).max() == 0:
         output[:] = NaN
         return output
-
+    win = (end - start).max()
     skiplist = skiplist_init(<int>win)
     if skiplist == NULL:
         raise MemoryError("skiplist_init failed")
@@ -1578,18 +1344,17 @@ def roll_quantile(ndarray[float64_t, cast=True] values, int64_t win,
     return output
 
 
-def roll_generic(object obj,
-                 int64_t win, int64_t minp, object index, object closed,
-                 int offset, object func, bint raw,
-                 object args, object kwargs):
+def roll_generic_fixed(object obj,
+                       ndarray[int64_t] start, ndarray[int64_t] end,
+                       int64_t minp, int64_t win,
+                       int offset, object func, bint raw,
+                       object args, object kwargs):
     cdef:
         ndarray[float64_t] output, counts, bufarr
         ndarray[float64_t, cast=True] arr
         float64_t *buf
         float64_t *oldbuf
-        int64_t nobs = 0, i, j, s, e, N
-        bint is_variable
-        ndarray[int64_t] start, end
+        int64_t nobs = 0, i, j, s, e, N = len(start)
 
     n = len(obj)
     if n == 0:
@@ -1602,36 +1367,13 @@ def roll_generic(object obj,
         if not arr.flags.c_contiguous:
             arr = arr.copy('C')
 
-    counts = roll_sum(np.concatenate([np.isfinite(arr).astype(float),
-                                      np.array([0.] * offset)]),
-                      win, minp, index, closed)[offset:]
-
-    start, end, N, win, minp, is_variable = get_window_indexer(arr, win,
-                                                               minp, index,
-                                                               closed,
-                                                               floor=0)
+    counts = roll_sum_fixed(np.concatenate([np.isfinite(arr).astype(float),
+                                            np.array([0.] * offset)]),
+                            start, end, minp, win)[offset:]
 
     output = np.empty(N, dtype=float)
 
-    if is_variable:
-        # variable window arr or series
-
-        if offset != 0:
-            raise ValueError("unable to roll_generic with a non-zero offset")
-
-        for i in range(0, N):
-            s = start[i]
-            e = end[i]
-
-            if counts[i] >= minp:
-                if raw:
-                    output[i] = func(arr[s:e], *args, **kwargs)
-                else:
-                    output[i] = func(obj.iloc[s:e], *args, **kwargs)
-            else:
-                output[i] = NaN
-
-    elif not raw:
+    if not raw:
         # series
         for i in range(N):
             if counts[i] >= minp:
@@ -1644,7 +1386,7 @@ def roll_generic(object obj,
     else:
 
         # truncated windows at the beginning, through first full-length window
-        for i from 0 <= i < (int_min(win, N) - offset):
+        for i in range((int_min(win, N) - offset)):
             if counts[i] >= minp:
                 output[i] = func(arr[0: (i + offset + 1)], *args, **kwargs)
             else:
@@ -1654,7 +1396,7 @@ def roll_generic(object obj,
         buf = <float64_t *>arr.data
         bufarr = np.empty(win, dtype=float)
         oldbuf = <float64_t *>bufarr.data
-        for i from (win - offset) <= i < (N - offset):
+        for i in range((win - offset), (N - offset)):
             buf = buf + 1
             bufarr.data = <char *>buf
             if counts[i] >= minp:
@@ -1664,7 +1406,7 @@ def roll_generic(object obj,
         bufarr.data = <char *>oldbuf
 
         # truncated windows at the end
-        for i from int_max(N - offset, 0) <= i < N:
+        for i in range(int_max(N - offset, 0), N):
             if counts[i] >= minp:
                 output[i] = func(arr[int_max(i + offset - win + 1, 0): N],
                                  *args,
@@ -1675,22 +1417,68 @@ def roll_generic(object obj,
     return output
 
 
+def roll_generic_variable(object obj,
+                          ndarray[int64_t] start, ndarray[int64_t] end,
+                          int64_t minp,
+                          int offset, object func, bint raw,
+                          object args, object kwargs):
+    cdef:
+        ndarray[float64_t] output, counts, bufarr
+        ndarray[float64_t, cast=True] arr
+        float64_t *buf
+        float64_t *oldbuf
+        int64_t nobs = 0, i, j, s, e, N = len(start)
+
+    n = len(obj)
+    if n == 0:
+        return obj
+
+    arr = np.asarray(obj)
+
+    # ndarray input
+    if raw:
+        if not arr.flags.c_contiguous:
+            arr = arr.copy('C')
+
+    counts = roll_sum_variable(np.concatenate([np.isfinite(arr).astype(float),
+                                               np.array([0.] * offset)]),
+                               start, end, minp)[offset:]
+
+    output = np.empty(N, dtype=float)
+
+    if offset != 0:
+        raise ValueError("unable to roll_generic with a non-zero offset")
+
+    for i in range(0, N):
+        s = start[i]
+        e = end[i]
+
+        if counts[i] >= minp:
+            if raw:
+                output[i] = func(arr[s:e], *args, **kwargs)
+            else:
+                output[i] = func(obj.iloc[s:e], *args, **kwargs)
+        else:
+            output[i] = NaN
+
+    return output
+
+
 # ----------------------------------------------------------------------
 # Rolling sum and mean for weighted window
 
 
-def roll_weighted_sum(float64_t[:] values, float64_t[:] weights,
-                      int minp):
+def roll_weighted_sum(float64_t[:] values, float64_t[:] weights, int minp):
     return _roll_weighted_sum_mean(values, weights, minp, avg=0)
 
 
-def roll_weighted_mean(float64_t[:] values, float64_t[:] weights,
-                       int minp):
+def roll_weighted_mean(float64_t[:] values, float64_t[:] weights, int minp):
     return _roll_weighted_sum_mean(values, weights, minp, avg=1)
 
 
-def _roll_weighted_sum_mean(float64_t[:] values, float64_t[:] weights,
-                            int minp, bint avg):
+cdef ndarray[float64_t] _roll_weighted_sum_mean(float64_t[:] values,
+                                                float64_t[:] weights,
+                                                int minp, bint avg):
     """
     Assume len(weights) << len(values)
     """
@@ -1702,54 +1490,283 @@ def _roll_weighted_sum_mean(float64_t[:] values, float64_t[:] weights,
     in_n = len(values)
     win_n = len(weights)
 
-    output = np.zeros(in_n, dtype=float)
-    counts = np.zeros(in_n, dtype=float)
+    output = np.zeros(in_n, dtype=np.float64)
+    counts = np.zeros(in_n, dtype=np.float64)
     if avg:
-        tot_wgt = np.zeros(in_n, dtype=float)
+        tot_wgt = np.zeros(in_n, dtype=np.float64)
+
+    if minp > win_n:
+        raise ValueError(f"min_periods (minp) must be <= "
+                         f"window (win)")
+    elif minp > in_n:
+        minp = in_n + 1
+    elif minp < 0:
+        raise ValueError('min_periods must be >= 0')
 
-    minp = _check_minp(len(weights), minp, in_n)
+    minp = max(minp, 1)
 
-    if avg:
-        for win_i in range(win_n):
-            val_win = weights[win_i]
-            if val_win != val_win:
-                continue
-
-            for in_i from 0 <= in_i < in_n - (win_n - win_i) + 1:
-                val_in = values[in_i]
-                if val_in == val_in:
-                    output[in_i + (win_n - win_i) - 1] += val_in * val_win
-                    counts[in_i + (win_n - win_i) - 1] += 1
-                    tot_wgt[in_i + (win_n - win_i) - 1] += val_win
-
-        for in_i in range(in_n):
-            c = counts[in_i]
-            if c < minp:
-                output[in_i] = NaN
-            else:
-                w = tot_wgt[in_i]
-                if w == 0:
+    with nogil:
+        if avg:
+            for win_i in range(win_n):
+                val_win = weights[win_i]
+                if val_win != val_win:
+                    continue
+
+                for in_i in range(in_n - (win_n - win_i) + 1):
+                    val_in = values[in_i]
+                    if val_in == val_in:
+                        output[in_i + (win_n - win_i) - 1] += val_in * val_win
+                        counts[in_i + (win_n - win_i) - 1] += 1
+                        tot_wgt[in_i + (win_n - win_i) - 1] += val_win
+
+            for in_i in range(in_n):
+                c = counts[in_i]
+                if c < minp:
                     output[in_i] = NaN
                 else:
-                    output[in_i] /= tot_wgt[in_i]
+                    w = tot_wgt[in_i]
+                    if w == 0:
+                        output[in_i] = NaN
+                    else:
+                        output[in_i] /= tot_wgt[in_i]
+
+        else:
+            for win_i in range(win_n):
+                val_win = weights[win_i]
+                if val_win != val_win:
+                    continue
+
+                for in_i in range(in_n - (win_n - win_i) + 1):
+                    val_in = values[in_i]
+
+                    if val_in == val_in:
+                        output[in_i + (win_n - win_i) - 1] += val_in * val_win
+                        counts[in_i + (win_n - win_i) - 1] += 1
+
+            for in_i in range(in_n):
+                c = counts[in_i]
+                if c < minp:
+                    output[in_i] = NaN
+
+    return np.asarray(output)
 
+
+# ----------------------------------------------------------------------
+# Rolling var for weighted window
+
+
+cdef inline float64_t calc_weighted_var(float64_t t,
+                                        float64_t sum_w,
+                                        Py_ssize_t win_n,
+                                        unsigned int ddof,
+                                        float64_t nobs,
+                                        int64_t minp) nogil:
+    """
+    Calculate weighted variance for a window using West's method.
+
+    Paper: https://dl.acm.org/citation.cfm?id=359153
+
+    Parameters
+    ----------
+    t: float64_t
+        sum of weighted squared differences
+    sum_w: float64_t
+        sum of weights
+    win_n: Py_ssize_t
+        window size
+    ddof: unsigned int
+        delta degrees of freedom
+    nobs: float64_t
+        number of observations
+    minp: int64_t
+        minimum number of observations
+
+    Returns
+    -------
+    result : float64_t
+        weighted variance of the window
+    """
+
+    cdef:
+        float64_t result
+
+    # Variance is unchanged if no observation is added or removed
+    if (nobs >= minp) and (nobs > ddof):
+
+        # pathological case
+        if nobs == 1:
+            result = 0
+        else:
+            result = t * win_n / ((win_n - ddof) * sum_w)
+            if result < 0:
+                result = 0
     else:
-        for win_i in range(win_n):
-            val_win = weights[win_i]
-            if val_win != val_win:
-                continue
+        result = NaN
+
+    return result
+
+
+cdef inline void add_weighted_var(float64_t val,
+                                  float64_t w,
+                                  float64_t *t,
+                                  float64_t *sum_w,
+                                  float64_t *mean,
+                                  float64_t *nobs) nogil:
+    """
+    Update weighted mean, sum of weights and sum of weighted squared
+    differences to include value and weight pair in weighted variance
+    calculation using West's method.
+
+    Paper: https://dl.acm.org/citation.cfm?id=359153
+
+    Parameters
+    ----------
+    val: float64_t
+        window values
+    w: float64_t
+        window weights
+    t: float64_t
+        sum of weighted squared differences
+    sum_w: float64_t
+        sum of weights
+    mean: float64_t
+        weighted mean
+    nobs: float64_t
+        number of observations
+    """
+
+    cdef:
+        float64_t temp, q, r
+
+    if isnan(val):
+        return
+
+    nobs[0] = nobs[0] + 1
+
+    q = val - mean[0]
+    temp = sum_w[0] + w
+    r = q * w / temp
 
-            for in_i from 0 <= in_i < in_n - (win_n - win_i) + 1:
-                val_in = values[in_i]
+    mean[0] = mean[0] + r
+    t[0] = t[0] + r * sum_w[0] * q
+    sum_w[0] = temp
 
-                if val_in == val_in:
-                    output[in_i + (win_n - win_i) - 1] += val_in * val_win
-                    counts[in_i + (win_n - win_i) - 1] += 1
 
-        for in_i in range(in_n):
-            c = counts[in_i]
-            if c < minp:
-                output[in_i] = NaN
+cdef inline void remove_weighted_var(float64_t val,
+                                     float64_t w,
+                                     float64_t *t,
+                                     float64_t *sum_w,
+                                     float64_t *mean,
+                                     float64_t *nobs) nogil:
+    """
+    Update weighted mean, sum of weights and sum of weighted squared
+    differences to remove value and weight pair from weighted variance
+    calculation using West's method.
+
+    Paper: https://dl.acm.org/citation.cfm?id=359153
+
+    Parameters
+    ----------
+    val: float64_t
+        window values
+    w: float64_t
+        window weights
+    t: float64_t
+        sum of weighted squared differences
+    sum_w: float64_t
+        sum of weights
+    mean: float64_t
+        weighted mean
+    nobs: float64_t
+        number of observations
+    """
+
+    cdef:
+        float64_t temp, q, r
+
+    if notnan(val):
+        nobs[0] = nobs[0] - 1
+
+        if nobs[0]:
+            q = val - mean[0]
+            temp = sum_w[0] - w
+            r = q * w / temp
+
+            mean[0] = mean[0] - r
+            t[0] = t[0] - r * sum_w[0] * q
+            sum_w[0] = temp
+
+        else:
+            t[0] = 0
+            sum_w[0] = 0
+            mean[0] = 0
+
+
+def roll_weighted_var(float64_t[:] values, float64_t[:] weights,
+                      int64_t minp, unsigned int ddof):
+    """
+    Calculates weighted rolling variance using West's online algorithm.
+
+    Paper: https://dl.acm.org/citation.cfm?id=359153
+
+    Parameters
+    ----------
+    values: float64_t[:]
+        values to roll window over
+    weights: float64_t[:]
+        array of weights whose length is window size
+    minp: int64_t
+        minimum number of observations to calculate
+        variance of a window
+    ddof: unsigned int
+         the divisor used in variance calculations
+         is the window size - ddof
+
+    Returns
+    -------
+    output: float64_t[:]
+        weighted variances of windows
+    """
+
+    cdef:
+        float64_t t = 0, sum_w = 0, mean = 0, nobs = 0
+        float64_t val, pre_val, w, pre_w
+        Py_ssize_t i, n, win_n
+        float64_t[:] output
+
+    n = len(values)
+    win_n = len(weights)
+    output = np.empty(n, dtype=float)
+
+    with nogil:
+
+        for i in range(win_n):
+            add_weighted_var(values[i], weights[i], &t,
+                             &sum_w, &mean, &nobs)
+
+            output[i] = calc_weighted_var(t, sum_w, win_n,
+                                          ddof, nobs, minp)
+
+        for i in range(win_n, n):
+            val = values[i]
+            pre_val = values[i - win_n]
+
+            w = weights[i % win_n]
+            pre_w = weights[(i - win_n) % win_n]
+
+            if notnan(val):
+                if pre_val == pre_val:
+                    remove_weighted_var(pre_val, pre_w, &t,
+                                        &sum_w, &mean, &nobs)
+
+                add_weighted_var(val, w, &t, &sum_w, &mean, &nobs)
+
+            elif pre_val == pre_val:
+                remove_weighted_var(pre_val, pre_w, &t,
+                                    &sum_w, &mean, &nobs)
+
+            output[i] = calc_weighted_var(t, sum_w, win_n,
+                                          ddof, nobs, minp)
 
     return output
 
@@ -1758,8 +1775,7 @@ def _roll_weighted_sum_mean(float64_t[:] values, float64_t[:] weights,
 # Exponentially weighted moving average
 
 
-def ewma(float64_t[:] vals, float64_t com,
-         int adjust, int ignore_na, int minp):
+def ewma(float64_t[:] vals, float64_t com, int adjust, bint ignore_na, int minp):
     """
     Compute exponentially-weighted moving average using center-of-mass.
 
@@ -1768,12 +1784,12 @@ def ewma(float64_t[:] vals, float64_t com,
     vals : ndarray (float64 type)
     com : float64
     adjust: int
-    ignore_na: int
+    ignore_na: bool
     minp: int
 
     Returns
     -------
-    y : ndarray
+    ndarray
     """
 
     cdef:
@@ -1781,6 +1797,7 @@ def ewma(float64_t[:] vals, float64_t com,
         ndarray[float64_t] output = np.empty(N, dtype=float)
         float64_t alpha, old_wt_factor, new_wt, weighted_avg, old_wt, cur
         Py_ssize_t i, nobs
+        bint is_observation
 
     if N == 0:
         return output
@@ -1797,29 +1814,30 @@ def ewma(float64_t[:] vals, float64_t com,
     output[0] = weighted_avg if (nobs >= minp) else NaN
     old_wt = 1.
 
-    for i in range(1, N):
-        cur = vals[i]
-        is_observation = (cur == cur)
-        nobs += int(is_observation)
-        if weighted_avg == weighted_avg:
-
-            if is_observation or (not ignore_na):
-
-                old_wt *= old_wt_factor
-                if is_observation:
-
-                    # avoid numerical errors on constant series
-                    if weighted_avg != cur:
-                        weighted_avg = ((old_wt * weighted_avg) +
-                                        (new_wt * cur)) / (old_wt + new_wt)
-                    if adjust:
-                        old_wt += new_wt
-                    else:
-                        old_wt = 1.
-        elif is_observation:
-            weighted_avg = cur
+    with nogil:
+        for i in range(1, N):
+            cur = vals[i]
+            is_observation = (cur == cur)
+            nobs += is_observation
+            if weighted_avg == weighted_avg:
+
+                if is_observation or (not ignore_na):
+
+                    old_wt *= old_wt_factor
+                    if is_observation:
+
+                        # avoid numerical errors on constant series
+                        if weighted_avg != cur:
+                            weighted_avg = ((old_wt * weighted_avg) +
+                                            (new_wt * cur)) / (old_wt + new_wt)
+                        if adjust:
+                            old_wt += new_wt
+                        else:
+                            old_wt = 1.
+            elif is_observation:
+                weighted_avg = cur
 
-        output[i] = weighted_avg if (nobs >= minp) else NaN
+            output[i] = weighted_avg if (nobs >= minp) else NaN
 
     return output
 
@@ -1829,7 +1847,7 @@ def ewma(float64_t[:] vals, float64_t com,
 
 
 def ewmcov(float64_t[:] input_x, float64_t[:] input_y,
-           float64_t com, int adjust, int ignore_na, int minp, int bias):
+           float64_t com, int adjust, bint ignore_na, int minp, int bias):
     """
     Compute exponentially-weighted moving variance using center-of-mass.
 
@@ -1839,25 +1857,26 @@ def ewmcov(float64_t[:] input_x, float64_t[:] input_y,
     input_y : ndarray (float64 type)
     com : float64
     adjust: int
-    ignore_na: int
+    ignore_na: bool
     minp: int
     bias: int
 
     Returns
     -------
-    y : ndarray
+    ndarray
     """
 
     cdef:
         Py_ssize_t N = len(input_x)
         float64_t alpha, old_wt_factor, new_wt, mean_x, mean_y, cov
         float64_t sum_wt, sum_wt2, old_wt, cur_x, cur_y, old_mean_x, old_mean_y
+        float64_t numerator, denominator
         Py_ssize_t i, nobs
         ndarray[float64_t] output
+        bint is_observation
 
     if <Py_ssize_t>len(input_y) != N:
-        raise ValueError("arrays are of different lengths "
-                         "({N} and {len_y})".format(N=N, len_y=len(input_y)))
+        raise ValueError(f"arrays are of different lengths ({N} and {len(input_y)})")
 
     output = np.empty(N, dtype=float)
     if N == 0:
@@ -1882,55 +1901,57 @@ def ewmcov(float64_t[:] input_x, float64_t[:] input_y,
     sum_wt2 = 1.
     old_wt = 1.
 
-    for i in range(1, N):
-        cur_x = input_x[i]
-        cur_y = input_y[i]
-        is_observation = ((cur_x == cur_x) and (cur_y == cur_y))
-        nobs += int(is_observation)
-        if mean_x == mean_x:
-            if is_observation or (not ignore_na):
-                sum_wt *= old_wt_factor
-                sum_wt2 *= (old_wt_factor * old_wt_factor)
-                old_wt *= old_wt_factor
-                if is_observation:
-                    old_mean_x = mean_x
-                    old_mean_y = mean_y
-
-                    # avoid numerical errors on constant series
-                    if mean_x != cur_x:
-                        mean_x = ((old_wt * old_mean_x) +
-                                  (new_wt * cur_x)) / (old_wt + new_wt)
-
-                    # avoid numerical errors on constant series
-                    if mean_y != cur_y:
-                        mean_y = ((old_wt * old_mean_y) +
-                                  (new_wt * cur_y)) / (old_wt + new_wt)
-                    cov = ((old_wt * (cov + ((old_mean_x - mean_x) *
-                                             (old_mean_y - mean_y)))) +
-                           (new_wt * ((cur_x - mean_x) *
-                                      (cur_y - mean_y)))) / (old_wt + new_wt)
-                    sum_wt += new_wt
-                    sum_wt2 += (new_wt * new_wt)
-                    old_wt += new_wt
-                    if not adjust:
-                        sum_wt /= old_wt
-                        sum_wt2 /= (old_wt * old_wt)
-                        old_wt = 1.
-        elif is_observation:
-            mean_x = cur_x
-            mean_y = cur_y
+    with nogil:
 
-        if nobs >= minp:
-            if not bias:
-                numerator = sum_wt * sum_wt
-                denominator = numerator - sum_wt2
-                if (denominator > 0.):
-                    output[i] = ((numerator / denominator) * cov)
+        for i in range(1, N):
+            cur_x = input_x[i]
+            cur_y = input_y[i]
+            is_observation = ((cur_x == cur_x) and (cur_y == cur_y))
+            nobs += is_observation
+            if mean_x == mean_x:
+                if is_observation or (not ignore_na):
+                    sum_wt *= old_wt_factor
+                    sum_wt2 *= (old_wt_factor * old_wt_factor)
+                    old_wt *= old_wt_factor
+                    if is_observation:
+                        old_mean_x = mean_x
+                        old_mean_y = mean_y
+
+                        # avoid numerical errors on constant series
+                        if mean_x != cur_x:
+                            mean_x = ((old_wt * old_mean_x) +
+                                      (new_wt * cur_x)) / (old_wt + new_wt)
+
+                        # avoid numerical errors on constant series
+                        if mean_y != cur_y:
+                            mean_y = ((old_wt * old_mean_y) +
+                                      (new_wt * cur_y)) / (old_wt + new_wt)
+                        cov = ((old_wt * (cov + ((old_mean_x - mean_x) *
+                                                 (old_mean_y - mean_y)))) +
+                               (new_wt * ((cur_x - mean_x) *
+                                          (cur_y - mean_y)))) / (old_wt + new_wt)
+                        sum_wt += new_wt
+                        sum_wt2 += (new_wt * new_wt)
+                        old_wt += new_wt
+                        if not adjust:
+                            sum_wt /= old_wt
+                            sum_wt2 /= (old_wt * old_wt)
+                            old_wt = 1.
+            elif is_observation:
+                mean_x = cur_x
+                mean_y = cur_y
+
+            if nobs >= minp:
+                if not bias:
+                    numerator = sum_wt * sum_wt
+                    denominator = numerator - sum_wt2
+                    if (denominator > 0.):
+                        output[i] = ((numerator / denominator) * cov)
+                    else:
+                        output[i] = NaN
                 else:
-                    output[i] = NaN
+                    output[i] = cov
             else:
-                output[i] = cov
-        else:
-            output[i] = NaN
+                output[i] = NaN
 
     return output
diff --git a/pandas/_libs/window/indexers.pyx b/pandas/_libs/window/indexers.pyx
new file mode 100644
index 0000000000000..2d01d1964c043
--- /dev/null
+++ b/pandas/_libs/window/indexers.pyx
@@ -0,0 +1,105 @@
+# cython: boundscheck=False, wraparound=False, cdivision=True
+
+import numpy as np
+from numpy cimport ndarray, int64_t
+
+# Cython routines for window indexers
+
+
+def calculate_variable_window_bounds(
+    int64_t num_values,
+    int64_t window_size,
+    object min_periods,  # unused but here to match get_window_bounds signature
+    object center,  # unused but here to match get_window_bounds signature
+    object closed,
+    const int64_t[:] index
+):
+    """
+    Calculate window boundaries for rolling windows from a time offset.
+
+    Parameters
+    ----------
+    num_values : int64
+        total number of values
+
+    window_size : int64
+        window size calculated from the offset
+
+    min_periods : object
+        ignored, exists for compatibility
+
+    center : object
+        ignored, exists for compatibility
+
+    closed : str
+        string of side of the window that should be closed
+
+    index : ndarray[int64]
+        time series index to roll over
+
+    Returns
+    -------
+    (ndarray[int64], ndarray[int64])
+    """
+    cdef:
+        bint left_closed = False
+        bint right_closed = False
+        ndarray[int64_t, ndim=1] start, end
+        int64_t start_bound, end_bound
+        Py_ssize_t i, j
+
+    # if windows is variable, default is 'right', otherwise default is 'both'
+    if closed is None:
+        closed = 'right' if index is not None else 'both'
+
+    if closed in ['right', 'both']:
+        right_closed = True
+
+    if closed in ['left', 'both']:
+        left_closed = True
+
+    start = np.empty(num_values, dtype='int64')
+    start.fill(-1)
+    end = np.empty(num_values, dtype='int64')
+    end.fill(-1)
+
+    start[0] = 0
+
+    # right endpoint is closed
+    if right_closed:
+        end[0] = 1
+    # right endpoint is open
+    else:
+        end[0] = 0
+
+    with nogil:
+
+        # start is start of slice interval (including)
+        # end is end of slice interval (not including)
+        for i in range(1, num_values):
+            end_bound = index[i]
+            start_bound = index[i] - window_size
+
+            # left endpoint is closed
+            if left_closed:
+                start_bound -= 1
+
+            # advance the start bound until we are
+            # within the constraint
+            start[i] = i
+            for j in range(start[i - 1], i):
+                if index[j] > start_bound:
+                    start[i] = j
+                    break
+
+            # end bound is previous end
+            # or current index
+            if index[end[i - 1]] <= end_bound:
+                end[i] = i + 1
+            else:
+                end[i] = end[i - 1]
+
+            # right endpoint is open
+            if not right_closed:
+                end[i] -= 1
+    return start, end
diff --git a/pandas/_libs/writers.pyx b/pandas/_libs/writers.pyx
index 1775893b9f2bf..73201e75c3c88 100644
--- a/pandas/_libs/writers.pyx
+++ b/pandas/_libs/writers.pyx
@@ -70,7 +70,7 @@ def write_csv_rows(list data, ndarray data_index,
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def convert_json_to_lines(object arr):
+def convert_json_to_lines(arr: object) -> str:
     """
     replace comma separated json with line feeds, paying special attention
     to quotes & brackets
diff --git a/pandas/_testing.py b/pandas/_testing.py
new file mode 100644
index 0000000000000..9e71524263a18
--- /dev/null
+++ b/pandas/_testing.py
@@ -0,0 +1,2781 @@
+import bz2
+from collections import Counter
+from contextlib import contextmanager
+from datetime import datetime
+from functools import wraps
+import gzip
+import os
+from shutil import rmtree
+import string
+import tempfile
+from typing import Any, Callable, List, Optional, Type, Union, cast
+import warnings
+import zipfile
+
+import numpy as np
+from numpy.random import rand, randn
+
+from pandas._config.localization import (  # noqa:F401
+    can_set_locale,
+    get_locales,
+    set_locale,
+)
+
+import pandas._libs.testing as _testing
+from pandas._typing import FilePathOrBuffer, FrameOrSeries
+from pandas.compat import _get_lzma_file, _import_lzma
+
+from pandas.core.dtypes.common import (
+    is_bool,
+    is_categorical_dtype,
+    is_datetime64_dtype,
+    is_datetime64tz_dtype,
+    is_extension_array_dtype,
+    is_interval_dtype,
+    is_list_like,
+    is_number,
+    is_period_dtype,
+    is_sequence,
+    is_timedelta64_dtype,
+    needs_i8_conversion,
+)
+from pandas.core.dtypes.missing import array_equivalent
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    bdate_range,
+)
+from pandas.core.algorithms import take_1d
+from pandas.core.arrays import (
+    DatetimeArray,
+    ExtensionArray,
+    IntervalArray,
+    PeriodArray,
+    TimedeltaArray,
+    period_array,
+)
+
+from pandas.io.common import urlopen
+from pandas.io.formats.printing import pprint_thing
+
+lzma = _import_lzma()
+
+N = 30
+K = 4
+_RAISE_NETWORK_ERROR_DEFAULT = False
+
+# set testing_mode
+_testing_mode_warnings = (DeprecationWarning, ResourceWarning)
+
+
+def set_testing_mode():
+    # set the testing mode filters
+    testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
+    if "deprecate" in testing_mode:
+        warnings.simplefilter("always", _testing_mode_warnings)
+
+
+def reset_testing_mode():
+    # reset the testing mode filters
+    testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
+    if "deprecate" in testing_mode:
+        warnings.simplefilter("ignore", _testing_mode_warnings)
+
+
+set_testing_mode()
+
+
+def reset_display_options():
+    """
+    Reset the display options for printing and representing objects.
+    """
+    pd.reset_option("^display.", silent=True)
+
+
+def round_trip_pickle(
+    obj: Any, path: Optional[FilePathOrBuffer] = None
+) -> FrameOrSeries:
+    """
+    Pickle an object and then read it again.
+
+    Parameters
+    ----------
+    obj : any object
+        The object to pickle and then re-read.
+    path : str, path object or file-like object, default None
+        The path where the pickled object is written and then read.
+
+    Returns
+    -------
+    pandas object
+        The original object that was pickled and then re-read.
+    """
+    _path = path
+    if _path is None:
+        _path = f"__{rands(10)}__.pickle"
+    with ensure_clean(_path) as temp_path:
+        pd.to_pickle(obj, temp_path)
+        return pd.read_pickle(temp_path)
+
+
+def round_trip_pathlib(writer, reader, path: Optional[str] = None):
+    """
+    Write an object to file specified by a pathlib.Path and read it back
+
+    Parameters
+    ----------
+    writer : callable bound to pandas object
+        IO writing function (e.g. DataFrame.to_csv )
+    reader : callable
+        IO reading function (e.g. pd.read_csv )
+    path : str, default None
+        The path where the object is written and then read.
+
+    Returns
+    -------
+    pandas object
+        The original object that was serialized and then re-read.
+    """
+    import pytest
+
+    Path = pytest.importorskip("pathlib").Path
+    if path is None:
+        path = "___pathlib___"
+    with ensure_clean(path) as path:
+        writer(Path(path))
+        obj = reader(Path(path))
+    return obj
+
+
+def round_trip_localpath(writer, reader, path: Optional[str] = None):
+    """
+    Write an object to file specified by a py.path LocalPath and read it back.
+
+    Parameters
+    ----------
+    writer : callable bound to pandas object
+        IO writing function (e.g. DataFrame.to_csv )
+    reader : callable
+        IO reading function (e.g. pd.read_csv )
+    path : str, default None
+        The path where the object is written and then read.
+
+    Returns
+    -------
+    pandas object
+        The original object that was serialized and then re-read.
+    """
+    import pytest
+
+    LocalPath = pytest.importorskip("py.path").local
+    if path is None:
+        path = "___localpath___"
+    with ensure_clean(path) as path:
+        writer(LocalPath(path))
+        obj = reader(LocalPath(path))
+    return obj
+
+
+@contextmanager
+def decompress_file(path, compression):
+    """
+    Open a compressed file and return a file object.
+
+    Parameters
+    ----------
+    path : str
+        The path where the file is read from.
+
+    compression : {'gzip', 'bz2', 'zip', 'xz', None}
+        Name of the decompression to use
+
+    Returns
+    -------
+    file object
+    """
+    if compression is None:
+        f = open(path, "rb")
+    elif compression == "gzip":
+        f = gzip.open(path, "rb")
+    elif compression == "bz2":
+        f = bz2.BZ2File(path, "rb")
+    elif compression == "xz":
+        f = _get_lzma_file(lzma)(path, "rb")
+    elif compression == "zip":
+        zip_file = zipfile.ZipFile(path)
+        zip_names = zip_file.namelist()
+        if len(zip_names) == 1:
+            f = zip_file.open(zip_names.pop())
+        else:
+            raise ValueError(f"ZIP file {path} error. Only one file per ZIP.")
+    else:
+        raise ValueError(f"Unrecognized compression type: {compression}")
+
+    try:
+        yield f
+    finally:
+        f.close()
+        if compression == "zip":
+            zip_file.close()
+
+
+def write_to_compressed(compression, path, data, dest="test"):
+    """
+    Write data to a compressed file.
+
+    Parameters
+    ----------
+    compression : {'gzip', 'bz2', 'zip', 'xz'}
+        The compression type to use.
+    path : str
+        The file path to write the data.
+    data : str
+        The data to write.
+    dest : str, default "test"
+        The destination file (for ZIP only)
+
+    Raises
+    ------
+    ValueError : An invalid compression value was passed in.
+    """
+    if compression == "zip":
+        import zipfile
+
+        compress_method = zipfile.ZipFile
+    elif compression == "gzip":
+        import gzip
+
+        compress_method = gzip.GzipFile
+    elif compression == "bz2":
+        import bz2
+
+        compress_method = bz2.BZ2File
+    elif compression == "xz":
+        compress_method = _get_lzma_file(lzma)
+    else:
+        raise ValueError(f"Unrecognized compression type: {compression}")
+
+    if compression == "zip":
+        mode = "w"
+        args = (dest, data)
+        method = "writestr"
+    else:
+        mode = "wb"
+        args = (data,)
+        method = "write"
+
+    with compress_method(path, mode=mode) as f:
+        getattr(f, method)(*args)
+
+
+def assert_almost_equal(
+    left,
+    right,
+    check_dtype: Union[bool, str] = "equiv",
+    check_less_precise: Union[bool, int] = False,
+    **kwargs,
+):
+    """
+    Check that the left and right objects are approximately equal.
+
+    By approximately equal, we refer to objects that are numbers or that
+    contain numbers which may be equivalent to specific levels of precision.
+
+    Parameters
+    ----------
+    left : object
+    right : object
+    check_dtype : bool or {'equiv'}, default 'equiv'
+        Check dtype if both a and b are the same type. If 'equiv' is passed in,
+        then `RangeIndex` and `Int64Index` are also considered equivalent
+        when doing type checking.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. 5 digits (False) or 3 digits (True)
+        after decimal points are compared. If int, then specify the number
+        of digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+    """
+    if isinstance(left, pd.Index):
+        assert_index_equal(
+            left,
+            right,
+            check_exact=False,
+            exact=check_dtype,
+            check_less_precise=check_less_precise,
+            **kwargs,
+        )
+
+    elif isinstance(left, pd.Series):
+        assert_series_equal(
+            left,
+            right,
+            check_exact=False,
+            check_dtype=check_dtype,
+            check_less_precise=check_less_precise,
+            **kwargs,
+        )
+
+    elif isinstance(left, pd.DataFrame):
+        assert_frame_equal(
+            left,
+            right,
+            check_exact=False,
+            check_dtype=check_dtype,
+            check_less_precise=check_less_precise,
+            **kwargs,
+        )
+
+    else:
+        # Other sequences.
+        if check_dtype:
+            if is_number(left) and is_number(right):
+                # Do not compare numeric classes, like np.float64 and float.
+                pass
+            elif is_bool(left) and is_bool(right):
+                # Do not compare bool classes, like np.bool_ and bool.
+                pass
+            else:
+                if isinstance(left, np.ndarray) or isinstance(right, np.ndarray):
+                    obj = "numpy array"
+                else:
+                    obj = "Input"
+                assert_class_equal(left, right, obj=obj)
+        _testing.assert_almost_equal(
+            left,
+            right,
+            check_dtype=check_dtype,
+            check_less_precise=check_less_precise,
+            **kwargs,
+        )
+
+
+def _check_isinstance(left, right, cls):
+    """
+    Helper method for our assert_* methods that ensures that
+    the two objects being compared have the right type before
+    proceeding with the comparison.
+
+    Parameters
+    ----------
+    left : The first object being compared.
+    right : The second object being compared.
+    cls : The class type to check against.
+
+    Raises
+    ------
+    AssertionError : Either `left` or `right` is not an instance of `cls`.
+    """
+    cls_name = cls.__name__
+
+    if not isinstance(left, cls):
+        raise AssertionError(
+            f"{cls_name} Expected type {cls}, found {type(left)} instead"
+        )
+    if not isinstance(right, cls):
+        raise AssertionError(
+            f"{cls_name} Expected type {cls}, found {type(right)} instead"
+        )
+
+
+def assert_dict_equal(left, right, compare_keys: bool = True):
+
+    _check_isinstance(left, right, dict)
+    _testing.assert_dict_equal(left, right, compare_keys=compare_keys)
+
+
+def randbool(size=(), p: float = 0.5):
+    return rand(*size) <= p
+
+
+RANDS_CHARS = np.array(list(string.ascii_letters + string.digits), dtype=(np.str_, 1))
+RANDU_CHARS = np.array(
+    list("".join(map(chr, range(1488, 1488 + 26))) + string.digits),
+    dtype=(np.unicode_, 1),
+)
+
+
+def rands_array(nchars, size, dtype="O"):
+    """
+    Generate an array of byte strings.
+    """
+    retval = (
+        np.random.choice(RANDS_CHARS, size=nchars * np.prod(size))
+        .view((np.str_, nchars))
+        .reshape(size)
+    )
+    if dtype is None:
+        return retval
+    else:
+        return retval.astype(dtype)
+
+
+def randu_array(nchars, size, dtype="O"):
+    """
+    Generate an array of unicode strings.
+    """
+    retval = (
+        np.random.choice(RANDU_CHARS, size=nchars * np.prod(size))
+        .view((np.unicode_, nchars))
+        .reshape(size)
+    )
+    if dtype is None:
+        return retval
+    else:
+        return retval.astype(dtype)
+
+
+def rands(nchars):
+    """
+    Generate one random byte string.
+
+    See `rands_array` if you want to create an array of random strings.
+
+    """
+    return "".join(np.random.choice(RANDS_CHARS, nchars))
+
+
+def randu(nchars):
+    """
+    Generate one random unicode string.
+
+    See `randu_array` if you want to create an array of random unicode strings.
+
+    """
+    return "".join(np.random.choice(RANDU_CHARS, nchars))
+
+
+def close(fignum=None):
+    from matplotlib.pyplot import get_fignums, close as _close
+
+    if fignum is None:
+        for fignum in get_fignums():
+            _close(fignum)
+    else:
+        _close(fignum)
+
+
+# -----------------------------------------------------------------------------
+# contextmanager to ensure the file cleanup
+
+
+@contextmanager
+def ensure_clean(filename=None, return_filelike=False, **kwargs):
+    """
+    Gets a temporary path and agrees to remove on close.
+
+    Parameters
+    ----------
+    filename : str (optional)
+        if None, creates a temporary file which is then removed when out of
+        scope. if passed, creates temporary file with filename as ending.
+    return_filelike : bool (default False)
+        if True, returns a file-like which is *always* cleaned. Necessary for
+        savefig and other functions which want to append extensions.
+    **kwargs
+        Additional keywords passed in for creating a temporary file.
+        :meth:`tempFile.TemporaryFile` is used when `return_filelike` is ``True``.
+        :meth:`tempfile.mkstemp` is used when `return_filelike` is ``False``.
+        Note that the `filename` parameter will be passed in as the `suffix`
+        argument to either function.
+
+    See Also
+    --------
+    tempfile.TemporaryFile
+    tempfile.mkstemp
+    """
+    filename = filename or ""
+    fd = None
+
+    kwargs["suffix"] = filename
+
+    if return_filelike:
+        f = tempfile.TemporaryFile(**kwargs)
+
+        try:
+            yield f
+        finally:
+            f.close()
+    else:
+        # Don't generate tempfile if using a path with directory specified.
+        if len(os.path.dirname(filename)):
+            raise ValueError("Can't pass a qualified name to ensure_clean()")
+
+        try:
+            fd, filename = tempfile.mkstemp(**kwargs)
+        except UnicodeEncodeError:
+            import pytest
+
+            pytest.skip("no unicode file names on this system")
+
+        try:
+            yield filename
+        finally:
+            try:
+                os.close(fd)
+            except OSError:
+                print(f"Couldn't close file descriptor: {fd} (file: {filename})")
+            try:
+                if os.path.exists(filename):
+                    os.remove(filename)
+            except OSError as e:
+                print(f"Exception on removing file: {e}")
+
+
+@contextmanager
+def ensure_clean_dir():
+    """
+    Get a temporary directory path and agrees to remove on close.
+
+    Yields
+    ------
+    Temporary directory path
+    """
+    directory_name = tempfile.mkdtemp(suffix="")
+    try:
+        yield directory_name
+    finally:
+        try:
+            rmtree(directory_name)
+        except OSError:
+            pass
+
+
+@contextmanager
+def ensure_safe_environment_variables():
+    """
+    Get a context manager to safely set environment variables
+
+    All changes will be undone on close, hence environment variables set
+    within this contextmanager will neither persist nor change global state.
+    """
+    saved_environ = dict(os.environ)
+    try:
+        yield
+    finally:
+        os.environ.clear()
+        os.environ.update(saved_environ)
+
+
+# -----------------------------------------------------------------------------
+# Comparators
+
+
+def equalContents(arr1, arr2) -> bool:
+    """
+    Checks if the set of unique elements of arr1 and arr2 are equivalent.
+    """
+    return frozenset(arr1) == frozenset(arr2)
+
+
+def assert_index_equal(
+    left: Index,
+    right: Index,
+    exact: Union[bool, str] = "equiv",
+    check_names: bool = True,
+    check_less_precise: Union[bool, int] = False,
+    check_exact: bool = True,
+    check_categorical: bool = True,
+    obj: str = "Index",
+) -> None:
+    """
+    Check that left and right Index are equal.
+
+    Parameters
+    ----------
+    left : Index
+    right : Index
+    exact : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical. If 'equiv', then RangeIndex can be substituted for
+        Int64Index as well.
+    check_names : bool, default True
+        Whether to check the names attribute.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+    check_exact : bool, default True
+        Whether to compare number exactly.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    obj : str, default 'Index'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+    """
+    __tracebackhide__ = True
+
+    def _check_types(l, r, obj="Index"):
+        if exact:
+            assert_class_equal(l, r, exact=exact, obj=obj)
+
+            # Skip exact dtype checking when `check_categorical` is False
+            if check_categorical:
+                assert_attr_equal("dtype", l, r, obj=obj)
+
+            # allow string-like to have different inferred_types
+            if l.inferred_type in ("string"):
+                assert r.inferred_type in ("string")
+            else:
+                assert_attr_equal("inferred_type", l, r, obj=obj)
+
+    def _get_ilevel_values(index, level):
+        # accept level number only
+        unique = index.levels[level]
+        level_codes = index.codes[level]
+        filled = take_1d(unique._values, level_codes, fill_value=unique._na_value)
+        values = unique._shallow_copy(filled, name=index.names[level])
+        return values
+
+    # instance validation
+    _check_isinstance(left, right, Index)
+
+    # class / dtype comparison
+    _check_types(left, right, obj=obj)
+
+    # level comparison
+    if left.nlevels != right.nlevels:
+        msg1 = f"{obj} levels are different"
+        msg2 = f"{left.nlevels}, {left}"
+        msg3 = f"{right.nlevels}, {right}"
+        raise_assert_detail(obj, msg1, msg2, msg3)
+
+    # length comparison
+    if len(left) != len(right):
+        msg1 = f"{obj} length are different"
+        msg2 = f"{len(left)}, {left}"
+        msg3 = f"{len(right)}, {right}"
+        raise_assert_detail(obj, msg1, msg2, msg3)
+
+    # MultiIndex special comparison for little-friendly error messages
+    if left.nlevels > 1:
+        left = cast(MultiIndex, left)
+        right = cast(MultiIndex, right)
+
+        for level in range(left.nlevels):
+            # cannot use get_level_values here because it can change dtype
+            llevel = _get_ilevel_values(left, level)
+            rlevel = _get_ilevel_values(right, level)
+
+            lobj = f"MultiIndex level [{level}]"
+            assert_index_equal(
+                llevel,
+                rlevel,
+                exact=exact,
+                check_names=check_names,
+                check_less_precise=check_less_precise,
+                check_exact=check_exact,
+                obj=lobj,
+            )
+            # get_level_values may change dtype
+            _check_types(left.levels[level], right.levels[level], obj=obj)
+
+    # skip exact index checking when `check_categorical` is False
+    if check_exact and check_categorical:
+        if not left.equals(right):
+            diff = np.sum((left.values != right.values).astype(int)) * 100.0 / len(left)
+            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
+            raise_assert_detail(obj, msg, left, right)
+    else:
+        _testing.assert_almost_equal(
+            left.values,
+            right.values,
+            check_less_precise=check_less_precise,
+            check_dtype=exact,
+            obj=obj,
+            lobj=left,
+            robj=right,
+        )
+
+    # metadata comparison
+    if check_names:
+        assert_attr_equal("names", left, right, obj=obj)
+    if isinstance(left, pd.PeriodIndex) or isinstance(right, pd.PeriodIndex):
+        assert_attr_equal("freq", left, right, obj=obj)
+    if isinstance(left, pd.IntervalIndex) or isinstance(right, pd.IntervalIndex):
+        assert_interval_array_equal(left.values, right.values)
+
+    if check_categorical:
+        if is_categorical_dtype(left) or is_categorical_dtype(right):
+            assert_categorical_equal(left.values, right.values, obj=f"{obj} category")
+
+
+def assert_class_equal(left, right, exact: Union[bool, str] = True, obj="Input"):
+    """
+    Checks classes are equal.
+    """
+    __tracebackhide__ = True
+
+    def repr_class(x):
+        if isinstance(x, Index):
+            # return Index as it is to include values in the error message
+            return x
+
+        try:
+            return type(x).__name__
+        except AttributeError:
+            return repr(type(x))
+
+    if exact == "equiv":
+        if type(left) != type(right):
+            # allow equivalence of Int64Index/RangeIndex
+            types = {type(left).__name__, type(right).__name__}
+            if len(types - {"Int64Index", "RangeIndex"}):
+                msg = f"{obj} classes are not equivalent"
+                raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
+    elif exact:
+        if type(left) != type(right):
+            msg = f"{obj} classes are different"
+            raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
+
+
+def assert_attr_equal(attr, left, right, obj="Attributes"):
+    """checks attributes are equal. Both objects must have attribute.
+
+    Parameters
+    ----------
+    attr : str
+        Attribute name being compared.
+    left : object
+    right : object
+    obj : str, default 'Attributes'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    __tracebackhide__ = True
+
+    left_attr = getattr(left, attr)
+    right_attr = getattr(right, attr)
+
+    if left_attr is right_attr:
+        return True
+    elif (
+        is_number(left_attr)
+        and np.isnan(left_attr)
+        and is_number(right_attr)
+        and np.isnan(right_attr)
+    ):
+        # np.nan
+        return True
+
+    try:
+        result = left_attr == right_attr
+    except TypeError:
+        # datetimetz on rhs may raise TypeError
+        result = False
+    if not isinstance(result, bool):
+        result = result.all()
+
+    if result:
+        return True
+    else:
+        msg = f'Attribute "{attr}" are different'
+        raise_assert_detail(obj, msg, left_attr, right_attr)
+
+
+def assert_is_valid_plot_return_object(objs):
+    import matplotlib.pyplot as plt
+
+    if isinstance(objs, (pd.Series, np.ndarray)):
+        for el in objs.ravel():
+            msg = (
+                "one of 'objs' is not a matplotlib Axes instance, "
+                f"type encountered {repr(type(el).__name__)}"
+            )
+            assert isinstance(el, (plt.Axes, dict)), msg
+    else:
+        msg = (
+            "objs is neither an ndarray of Artist instances nor a single "
+            "ArtistArtist instance, tuple, or dict, 'objs' is a "
+            f"{repr(type(objs).__name__)}"
+        )
+        assert isinstance(objs, (plt.Artist, tuple, dict)), msg
+
+
+def isiterable(obj):
+    return hasattr(obj, "__iter__")
+
+
+def assert_is_sorted(seq):
+    """Assert that the sequence is sorted."""
+    if isinstance(seq, (Index, Series)):
+        seq = seq.values
+    # sorting does not change precisions
+    assert_numpy_array_equal(seq, np.sort(np.array(seq)))
+
+
+def assert_categorical_equal(
+    left, right, check_dtype=True, check_category_order=True, obj="Categorical"
+):
+    """Test that Categoricals are equivalent.
+
+    Parameters
+    ----------
+    left : Categorical
+    right : Categorical
+    check_dtype : bool, default True
+        Check that integer dtype of the codes are the same
+    check_category_order : bool, default True
+        Whether the order of the categories should be compared, which
+        implies identical integer codes.  If False, only the resulting
+        values are compared.  The ordered attribute is
+        checked regardless.
+    obj : str, default 'Categorical'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    _check_isinstance(left, right, Categorical)
+
+    if check_category_order:
+        assert_index_equal(left.categories, right.categories, obj=f"{obj}.categories")
+        assert_numpy_array_equal(
+            left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes",
+        )
+    else:
+        assert_index_equal(
+            left.categories.sort_values(),
+            right.categories.sort_values(),
+            obj=f"{obj}.categories",
+        )
+        assert_index_equal(
+            left.categories.take(left.codes),
+            right.categories.take(right.codes),
+            obj=f"{obj}.values",
+        )
+
+    assert_attr_equal("ordered", left, right, obj=obj)
+
+
+def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray"):
+    """Test that two IntervalArrays are equivalent.
+
+    Parameters
+    ----------
+    left, right : IntervalArray
+        The IntervalArrays to compare.
+    exact : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical. If 'equiv', then RangeIndex can be substituted for
+        Int64Index as well.
+    obj : str, default 'IntervalArray'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    _check_isinstance(left, right, IntervalArray)
+
+    assert_index_equal(left.left, right.left, exact=exact, obj=f"{obj}.left")
+    assert_index_equal(left.right, right.right, exact=exact, obj=f"{obj}.left")
+    assert_attr_equal("closed", left, right, obj=obj)
+
+
+def assert_period_array_equal(left, right, obj="PeriodArray"):
+    _check_isinstance(left, right, PeriodArray)
+
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}.values")
+    assert_attr_equal("freq", left, right, obj=obj)
+
+
+def assert_datetime_array_equal(left, right, obj="DatetimeArray"):
+    __tracebackhide__ = True
+    _check_isinstance(left, right, DatetimeArray)
+
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
+    assert_attr_equal("freq", left, right, obj=obj)
+    assert_attr_equal("tz", left, right, obj=obj)
+
+
+def assert_timedelta_array_equal(left, right, obj="TimedeltaArray"):
+    __tracebackhide__ = True
+    _check_isinstance(left, right, TimedeltaArray)
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
+    assert_attr_equal("freq", left, right, obj=obj)
+
+
+def raise_assert_detail(obj, message, left, right, diff=None):
+    __tracebackhide__ = True
+
+    if isinstance(left, np.ndarray):
+        left = pprint_thing(left)
+    elif is_categorical_dtype(left):
+        left = repr(left)
+
+    if isinstance(right, np.ndarray):
+        right = pprint_thing(right)
+    elif is_categorical_dtype(right):
+        right = repr(right)
+
+    msg = f"""{obj} are different
+
+{message}
+[left]:  {left}
+[right]: {right}"""
+
+    if diff is not None:
+        msg += f"\n[diff]: {diff}"
+
+    raise AssertionError(msg)
+
+
+def assert_numpy_array_equal(
+    left,
+    right,
+    strict_nan=False,
+    check_dtype=True,
+    err_msg=None,
+    check_same=None,
+    obj="numpy array",
+):
+    """
+    Check that 'np.ndarray' is equivalent.
+
+    Parameters
+    ----------
+    left, right : numpy.ndarray or iterable
+        The two arrays to be compared.
+    strict_nan : bool, default False
+        If True, consider NaN and None to be different.
+    check_dtype : bool, default True
+        Check dtype if both a and b are np.ndarray.
+    err_msg : str, default None
+        If provided, used as assertion message.
+    check_same : None|'copy'|'same', default None
+        Ensure left and right refer/do not refer to the same memory area.
+    obj : str, default 'numpy array'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+    """
+    __tracebackhide__ = True
+
+    # instance validation
+    # Show a detailed error message when classes are different
+    assert_class_equal(left, right, obj=obj)
+    # both classes must be an np.ndarray
+    _check_isinstance(left, right, np.ndarray)
+
+    def _get_base(obj):
+        return obj.base if getattr(obj, "base", None) is not None else obj
+
+    left_base = _get_base(left)
+    right_base = _get_base(right)
+
+    if check_same == "same":
+        if left_base is not right_base:
+            raise AssertionError(f"{repr(left_base)} is not {repr(right_base)}")
+    elif check_same == "copy":
+        if left_base is right_base:
+            raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
+
+    def _raise(left, right, err_msg):
+        if err_msg is None:
+            if left.shape != right.shape:
+                raise_assert_detail(
+                    obj, f"{obj} shapes are different", left.shape, right.shape,
+                )
+
+            diff = 0
+            for l, r in zip(left, right):
+                # count up differences
+                if not array_equivalent(l, r, strict_nan=strict_nan):
+                    diff += 1
+
+            diff = diff * 100.0 / left.size
+            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
+            raise_assert_detail(obj, msg, left, right)
+
+        raise AssertionError(err_msg)
+
+    # compare shape and values
+    if not array_equivalent(left, right, strict_nan=strict_nan):
+        _raise(left, right, err_msg)
+
+    if check_dtype:
+        if isinstance(left, np.ndarray) and isinstance(right, np.ndarray):
+            assert_attr_equal("dtype", left, right, obj=obj)
+
+
+def assert_extension_array_equal(
+    left, right, check_dtype=True, check_less_precise=False, check_exact=False
+):
+    """Check that left and right ExtensionArrays are equal.
+
+    Parameters
+    ----------
+    left, right : ExtensionArray
+        The two arrays to compare
+    check_dtype : bool, default True
+        Whether to check if the ExtensionArray dtypes are identical.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+
+    Notes
+    -----
+    Missing values are checked separately from valid values.
+    A mask of missing values is computed for each and checked to match.
+    The remaining all-valid values are cast to object dtype and checked.
+    """
+    assert isinstance(left, ExtensionArray), "left is not an ExtensionArray"
+    assert isinstance(right, ExtensionArray), "right is not an ExtensionArray"
+    if check_dtype:
+        assert_attr_equal("dtype", left, right, obj="ExtensionArray")
+
+    if hasattr(left, "asi8") and type(right) == type(left):
+        # Avoid slow object-dtype comparisons
+        assert_numpy_array_equal(left.asi8, right.asi8)
+        return
+
+    left_na = np.asarray(left.isna())
+    right_na = np.asarray(right.isna())
+    assert_numpy_array_equal(left_na, right_na, obj="ExtensionArray NA mask")
+
+    left_valid = np.asarray(left[~left_na].astype(object))
+    right_valid = np.asarray(right[~right_na].astype(object))
+    if check_exact:
+        assert_numpy_array_equal(left_valid, right_valid, obj="ExtensionArray")
+    else:
+        _testing.assert_almost_equal(
+            left_valid,
+            right_valid,
+            check_dtype=check_dtype,
+            check_less_precise=check_less_precise,
+            obj="ExtensionArray",
+        )
+
+
+# This could be refactored to use the NDFrame.equals method
+def assert_series_equal(
+    left,
+    right,
+    check_dtype=True,
+    check_index_type="equiv",
+    check_series_type=True,
+    check_less_precise=False,
+    check_names=True,
+    check_exact=False,
+    check_datetimelike_compat=False,
+    check_categorical=True,
+    obj="Series",
+):
+    """
+    Check that left and right Series are equal.
+
+    Parameters
+    ----------
+    left : Series
+    right : Series
+    check_dtype : bool, default True
+        Whether to check the Series dtype is identical.
+    check_index_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical.
+    check_series_type : bool, default True
+        Whether to check the Series class is identical.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+    check_names : bool, default True
+        Whether to check the Series and Index names attribute.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+    check_datetimelike_compat : bool, default False
+        Compare datetime-like which is comparable ignoring dtype.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    obj : str, default 'Series'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+    """
+    __tracebackhide__ = True
+
+    # instance validation
+    _check_isinstance(left, right, Series)
+
+    if check_series_type:
+        # ToDo: There are some tests using rhs is sparse
+        # lhs is dense. Should use assert_class_equal in future
+        assert isinstance(left, type(right))
+        # assert_class_equal(left, right, obj=obj)
+
+    # length comparison
+    if len(left) != len(right):
+        msg1 = f"{len(left)}, {left.index}"
+        msg2 = f"{len(right)}, {right.index}"
+        raise_assert_detail(obj, "Series length are different", msg1, msg2)
+
+    # index comparison
+    assert_index_equal(
+        left.index,
+        right.index,
+        exact=check_index_type,
+        check_names=check_names,
+        check_less_precise=check_less_precise,
+        check_exact=check_exact,
+        check_categorical=check_categorical,
+        obj=f"{obj}.index",
+    )
+
+    if check_dtype:
+        # We want to skip exact dtype checking when `check_categorical`
+        # is False. We'll still raise if only one is a `Categorical`,
+        # regardless of `check_categorical`
+        if (
+            is_categorical_dtype(left)
+            and is_categorical_dtype(right)
+            and not check_categorical
+        ):
+            pass
+        else:
+            assert_attr_equal("dtype", left, right, obj=f"Attributes of {obj}")
+
+    if check_exact:
+        assert_numpy_array_equal(
+            left._internal_get_values(),
+            right._internal_get_values(),
+            check_dtype=check_dtype,
+            obj=str(obj),
+        )
+    elif check_datetimelike_compat:
+        # we want to check only if we have compat dtypes
+        # e.g. integer and M|m are NOT compat, but we can simply check
+        # the values in that case
+        if needs_i8_conversion(left) or needs_i8_conversion(right):
+
+            # datetimelike may have different objects (e.g. datetime.datetime
+            # vs Timestamp) but will compare equal
+            if not Index(left.values).equals(Index(right.values)):
+                msg = (
+                    f"[datetimelike_compat=True] {left.values} "
+                    f"is not equal to {right.values}."
+                )
+                raise AssertionError(msg)
+        else:
+            assert_numpy_array_equal(
+                left._internal_get_values(),
+                right._internal_get_values(),
+                check_dtype=check_dtype,
+            )
+    elif is_interval_dtype(left) or is_interval_dtype(right):
+        assert_interval_array_equal(left.array, right.array)
+    elif is_extension_array_dtype(left.dtype) and is_datetime64tz_dtype(left.dtype):
+        # .values is an ndarray, but ._values is the ExtensionArray.
+        # TODO: Use .array
+        assert is_extension_array_dtype(right.dtype)
+        assert_extension_array_equal(left._values, right._values)
+    elif (
+        is_extension_array_dtype(left)
+        and not is_categorical_dtype(left)
+        and is_extension_array_dtype(right)
+        and not is_categorical_dtype(right)
+    ):
+        assert_extension_array_equal(left.array, right.array)
+    else:
+        _testing.assert_almost_equal(
+            left._internal_get_values(),
+            right._internal_get_values(),
+            check_less_precise=check_less_precise,
+            check_dtype=check_dtype,
+            obj=str(obj),
+        )
+
+    # metadata comparison
+    if check_names:
+        assert_attr_equal("name", left, right, obj=obj)
+
+    if check_categorical:
+        if is_categorical_dtype(left) or is_categorical_dtype(right):
+            assert_categorical_equal(left.values, right.values, obj=f"{obj} category")
+
+
+# This could be refactored to use the NDFrame.equals method
+def assert_frame_equal(
+    left,
+    right,
+    check_dtype=True,
+    check_index_type="equiv",
+    check_column_type="equiv",
+    check_frame_type=True,
+    check_less_precise=False,
+    check_names=True,
+    by_blocks=False,
+    check_exact=False,
+    check_datetimelike_compat=False,
+    check_categorical=True,
+    check_like=False,
+    obj="DataFrame",
+):
+    """
+    Check that left and right DataFrame are equal.
+
+    This function is intended to compare two DataFrames and output any
+    differences. Is is mostly intended for use in unit tests.
+    Additional parameters allow varying the strictness of the
+    equality checks performed.
+
+    Parameters
+    ----------
+    left : DataFrame
+        First DataFrame to compare.
+    right : DataFrame
+        Second DataFrame to compare.
+    check_dtype : bool, default True
+        Whether to check the DataFrame dtype is identical.
+    check_index_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical.
+    check_column_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the columns class, dtype and inferred_type
+        are identical. Is passed as the ``exact`` argument of
+        :func:`assert_index_equal`.
+    check_frame_type : bool, default True
+        Whether to check the DataFrame class is identical.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+    check_names : bool, default True
+        Whether to check that the `names` attribute for both the `index`
+        and `column` attributes of the DataFrame is identical.
+    by_blocks : bool, default False
+        Specify how to compare internal data. If False, compare by columns.
+        If True, compare by blocks.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+    check_datetimelike_compat : bool, default False
+        Compare datetime-like which is comparable ignoring dtype.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    check_like : bool, default False
+        If True, ignore the order of index & columns.
+        Note: index labels must match their respective rows
+        (same as in columns) - same labels must be with the same data.
+    obj : str, default 'DataFrame'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+
+    See Also
+    --------
+    assert_series_equal : Equivalent method for asserting Series equality.
+    DataFrame.equals : Check DataFrame equality.
+
+    Examples
+    --------
+    This example shows comparing two DataFrames that are equal
+    but with columns of differing dtypes.
+
+    >>> from pandas._testing import assert_frame_equal
+    >>> df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
+    >>> df2 = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0]})
+
+    df1 equals itself.
+
+    >>> assert_frame_equal(df1, df1)
+
+    df1 differs from df2 as column 'b' is of a different type.
+
+    >>> assert_frame_equal(df1, df2)
+    Traceback (most recent call last):
+    ...
+    AssertionError: Attributes of DataFrame.iloc[:, 1] (column name="b") are different
+
+    Attribute "dtype" are different
+    [left]:  int64
+    [right]: float64
+
+    Ignore differing dtypes in columns with check_dtype.
+
+    >>> assert_frame_equal(df1, df2, check_dtype=False)
+    """
+    __tracebackhide__ = True
+
+    # instance validation
+    _check_isinstance(left, right, DataFrame)
+
+    if check_frame_type:
+        assert isinstance(left, type(right))
+        # assert_class_equal(left, right, obj=obj)
+
+    # shape comparison
+    if left.shape != right.shape:
+        raise_assert_detail(
+            obj, f"{obj} shape mismatch", f"{repr(left.shape)}", f"{repr(right.shape)}",
+        )
+
+    if check_like:
+        left, right = left.reindex_like(right), right
+
+    # index comparison
+    assert_index_equal(
+        left.index,
+        right.index,
+        exact=check_index_type,
+        check_names=check_names,
+        check_less_precise=check_less_precise,
+        check_exact=check_exact,
+        check_categorical=check_categorical,
+        obj=f"{obj}.index",
+    )
+
+    # column comparison
+    assert_index_equal(
+        left.columns,
+        right.columns,
+        exact=check_column_type,
+        check_names=check_names,
+        check_less_precise=check_less_precise,
+        check_exact=check_exact,
+        check_categorical=check_categorical,
+        obj=f"{obj}.columns",
+    )
+
+    # compare by blocks
+    if by_blocks:
+        rblocks = right._to_dict_of_blocks()
+        lblocks = left._to_dict_of_blocks()
+        for dtype in list(set(list(lblocks.keys()) + list(rblocks.keys()))):
+            assert dtype in lblocks
+            assert dtype in rblocks
+            assert_frame_equal(
+                lblocks[dtype], rblocks[dtype], check_dtype=check_dtype, obj=obj
+            )
+
+    # compare by columns
+    else:
+        for i, col in enumerate(left.columns):
+            assert col in right
+            lcol = left.iloc[:, i]
+            rcol = right.iloc[:, i]
+            assert_series_equal(
+                lcol,
+                rcol,
+                check_dtype=check_dtype,
+                check_index_type=check_index_type,
+                check_less_precise=check_less_precise,
+                check_exact=check_exact,
+                check_names=check_names,
+                check_datetimelike_compat=check_datetimelike_compat,
+                check_categorical=check_categorical,
+                obj=f'{obj}.iloc[:, {i}] (column name="{col}")',
+            )
+
+
+def assert_equal(left, right, **kwargs):
+    """
+    Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
+
+    Parameters
+    ----------
+    left, right : Index, Series, DataFrame, ExtensionArray, or np.ndarray
+        The two items to be compared.
+    **kwargs
+        All keyword arguments are passed through to the underlying assert method.
+    """
+    __tracebackhide__ = True
+
+    if isinstance(left, pd.Index):
+        assert_index_equal(left, right, **kwargs)
+    elif isinstance(left, pd.Series):
+        assert_series_equal(left, right, **kwargs)
+    elif isinstance(left, pd.DataFrame):
+        assert_frame_equal(left, right, **kwargs)
+    elif isinstance(left, IntervalArray):
+        assert_interval_array_equal(left, right, **kwargs)
+    elif isinstance(left, PeriodArray):
+        assert_period_array_equal(left, right, **kwargs)
+    elif isinstance(left, DatetimeArray):
+        assert_datetime_array_equal(left, right, **kwargs)
+    elif isinstance(left, TimedeltaArray):
+        assert_timedelta_array_equal(left, right, **kwargs)
+    elif isinstance(left, ExtensionArray):
+        assert_extension_array_equal(left, right, **kwargs)
+    elif isinstance(left, np.ndarray):
+        assert_numpy_array_equal(left, right, **kwargs)
+    elif isinstance(left, str):
+        assert kwargs == {}
+        assert left == right
+    else:
+        raise NotImplementedError(type(left))
+
+
+def box_expected(expected, box_cls, transpose=True):
+    """
+    Helper function to wrap the expected output of a test in a given box_class.
+
+    Parameters
+    ----------
+    expected : np.ndarray, Index, Series
+    box_cls : {Index, Series, DataFrame}
+
+    Returns
+    -------
+    subclass of box_cls
+    """
+    if box_cls is pd.Index:
+        expected = pd.Index(expected)
+    elif box_cls is pd.Series:
+        expected = pd.Series(expected)
+    elif box_cls is pd.DataFrame:
+        expected = pd.Series(expected).to_frame()
+        if transpose:
+            # for vector operations, we we need a DataFrame to be a single-row,
+            #  not a single-column, in order to operate against non-DataFrame
+            #  vectors of the same length.
+            expected = expected.T
+    elif box_cls is PeriodArray:
+        # the PeriodArray constructor is not as flexible as period_array
+        expected = period_array(expected)
+    elif box_cls is DatetimeArray:
+        expected = DatetimeArray(expected)
+    elif box_cls is TimedeltaArray:
+        expected = TimedeltaArray(expected)
+    elif box_cls is np.ndarray:
+        expected = np.array(expected)
+    elif box_cls is to_array:
+        expected = to_array(expected)
+    else:
+        raise NotImplementedError(box_cls)
+    return expected
+
+
+def to_array(obj):
+    # temporary implementation until we get pd.array in place
+    if is_period_dtype(obj):
+        return period_array(obj)
+    elif is_datetime64_dtype(obj) or is_datetime64tz_dtype(obj):
+        return DatetimeArray._from_sequence(obj)
+    elif is_timedelta64_dtype(obj):
+        return TimedeltaArray._from_sequence(obj)
+    else:
+        return np.array(obj)
+
+
+# -----------------------------------------------------------------------------
+# Sparse
+
+
+def assert_sp_array_equal(
+    left,
+    right,
+    check_dtype=True,
+    check_kind=True,
+    check_fill_value=True,
+    consolidate_block_indices=False,
+):
+    """Check that the left and right SparseArray are equal.
+
+    Parameters
+    ----------
+    left : SparseArray
+    right : SparseArray
+    check_dtype : bool, default True
+        Whether to check the data dtype is identical.
+    check_kind : bool, default True
+        Whether to just the kind of the sparse index for each column.
+    check_fill_value : bool, default True
+        Whether to check that left.fill_value matches right.fill_value
+    consolidate_block_indices : bool, default False
+        Whether to consolidate contiguous blocks for sparse arrays with
+        a BlockIndex. Some operations, e.g. concat, will end up with
+        block indices that could be consolidated. Setting this to true will
+        create a new BlockIndex for that array, with consolidated
+        block indices.
+    """
+
+    _check_isinstance(left, right, pd.arrays.SparseArray)
+
+    assert_numpy_array_equal(left.sp_values, right.sp_values, check_dtype=check_dtype)
+
+    # SparseIndex comparison
+    assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
+    assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
+
+    if not check_kind:
+        left_index = left.sp_index.to_block_index()
+        right_index = right.sp_index.to_block_index()
+    else:
+        left_index = left.sp_index
+        right_index = right.sp_index
+
+    if consolidate_block_indices and left.kind == "block":
+        # we'll probably remove this hack...
+        left_index = left_index.to_int_index().to_block_index()
+        right_index = right_index.to_int_index().to_block_index()
+
+    if not left_index.equals(right_index):
+        raise_assert_detail(
+            "SparseArray.index", "index are not equal", left_index, right_index
+        )
+    else:
+        # Just ensure a
+        pass
+
+    if check_fill_value:
+        assert_attr_equal("fill_value", left, right)
+    if check_dtype:
+        assert_attr_equal("dtype", left, right)
+    assert_numpy_array_equal(left.to_dense(), right.to_dense(), check_dtype=check_dtype)
+
+
+# -----------------------------------------------------------------------------
+# Others
+
+
+def assert_contains_all(iterable, dic):
+    for k in iterable:
+        assert k in dic, f"Did not contain item: {repr(k)}"
+
+
+def assert_copy(iter1, iter2, **eql_kwargs):
+    """
+    iter1, iter2: iterables that produce elements
+    comparable with assert_almost_equal
+
+    Checks that the elements are equal, but not
+    the same object. (Does not check that items
+    in sequences are also not the same object)
+    """
+    for elem1, elem2 in zip(iter1, iter2):
+        assert_almost_equal(elem1, elem2, **eql_kwargs)
+        msg = (
+            f"Expected object {repr(type(elem1))} and object {repr(type(elem2))} to be "
+            "different objects, but they were the same object."
+        )
+        assert elem1 is not elem2, msg
+
+
+def getCols(k):
+    return string.ascii_uppercase[:k]
+
+
+# make index
+def makeStringIndex(k=10, name=None):
+    return Index(rands_array(nchars=10, size=k), name=name)
+
+
+def makeUnicodeIndex(k=10, name=None):
+    return Index(randu_array(nchars=10, size=k), name=name)
+
+
+def makeCategoricalIndex(k=10, n=3, name=None, **kwargs):
+    """ make a length k index or n categories """
+    x = rands_array(nchars=4, size=n)
+    return CategoricalIndex(
+        Categorical.from_codes(np.arange(k) % n, categories=x), name=name, **kwargs
+    )
+
+
+def makeIntervalIndex(k=10, name=None, **kwargs):
+    """ make a length k IntervalIndex """
+    x = np.linspace(0, 100, num=(k + 1))
+    return IntervalIndex.from_breaks(x, name=name, **kwargs)
+
+
+def makeBoolIndex(k=10, name=None):
+    if k == 1:
+        return Index([True], name=name)
+    elif k == 2:
+        return Index([False, True], name=name)
+    return Index([False, True] + [False] * (k - 2), name=name)
+
+
+def makeIntIndex(k=10, name=None):
+    return Index(list(range(k)), name=name)
+
+
+def makeUIntIndex(k=10, name=None):
+    return Index([2 ** 63 + i for i in range(k)], name=name)
+
+
+def makeRangeIndex(k=10, name=None, **kwargs):
+    return RangeIndex(0, k, 1, name=name, **kwargs)
+
+
+def makeFloatIndex(k=10, name=None):
+    values = sorted(np.random.random_sample(k)) - np.random.random_sample(1)
+    return Index(values * (10 ** np.random.randint(0, 9)), name=name)
+
+
+def makeDateIndex(k=10, freq="B", name=None, **kwargs):
+    dt = datetime(2000, 1, 1)
+    dr = bdate_range(dt, periods=k, freq=freq, name=name)
+    return DatetimeIndex(dr, name=name, **kwargs)
+
+
+def makeTimedeltaIndex(k=10, freq="D", name=None, **kwargs):
+    return pd.timedelta_range(start="1 day", periods=k, freq=freq, name=name, **kwargs)
+
+
+def makePeriodIndex(k=10, name=None, **kwargs):
+    dt = datetime(2000, 1, 1)
+    dr = pd.period_range(start=dt, periods=k, freq="B", name=name, **kwargs)
+    return dr
+
+
+def makeMultiIndex(k=10, names=None, **kwargs):
+    return MultiIndex.from_product((("foo", "bar"), (1, 2)), names=names, **kwargs)
+
+
+_names = [
+    "Alice",
+    "Bob",
+    "Charlie",
+    "Dan",
+    "Edith",
+    "Frank",
+    "George",
+    "Hannah",
+    "Ingrid",
+    "Jerry",
+    "Kevin",
+    "Laura",
+    "Michael",
+    "Norbert",
+    "Oliver",
+    "Patricia",
+    "Quinn",
+    "Ray",
+    "Sarah",
+    "Tim",
+    "Ursula",
+    "Victor",
+    "Wendy",
+    "Xavier",
+    "Yvonne",
+    "Zelda",
+]
+
+
+def _make_timeseries(start="2000-01-01", end="2000-12-31", freq="1D", seed=None):
+    """
+    Make a DataFrame with a DatetimeIndex
+
+    Parameters
+    ----------
+    start : str or Timestamp, default "2000-01-01"
+        The start of the index. Passed to date_range with `freq`.
+    end : str or Timestamp, default "2000-12-31"
+        The end of the index. Passed to date_range with `freq`.
+    freq : str or Freq
+        The frequency to use for the DatetimeIndex
+    seed : int, optional
+        The random state seed.
+
+        * name : object dtype with string names
+        * id : int dtype with
+        * x, y : float dtype
+
+    Examples
+    --------
+    >>> _make_timeseries()
+                  id    name         x         y
+    timestamp
+    2000-01-01   982   Frank  0.031261  0.986727
+    2000-01-02  1025   Edith -0.086358 -0.032920
+    2000-01-03   982   Edith  0.473177  0.298654
+    2000-01-04  1009   Sarah  0.534344 -0.750377
+    2000-01-05   963   Zelda -0.271573  0.054424
+    ...          ...     ...       ...       ...
+    2000-12-27   980  Ingrid -0.132333 -0.422195
+    2000-12-28   972   Frank -0.376007 -0.298687
+    2000-12-29  1009  Ursula -0.865047 -0.503133
+    2000-12-30  1000  Hannah -0.063757 -0.507336
+    2000-12-31   972     Tim -0.869120  0.531685
+    """
+    index = pd.date_range(start=start, end=end, freq=freq, name="timestamp")
+    n = len(index)
+    state = np.random.RandomState(seed)
+    columns = {
+        "name": state.choice(_names, size=n),
+        "id": state.poisson(1000, size=n),
+        "x": state.rand(n) * 2 - 1,
+        "y": state.rand(n) * 2 - 1,
+    }
+    df = pd.DataFrame(columns, index=index, columns=sorted(columns))
+    if df.index[-1] == end:
+        df = df.iloc[:-1]
+    return df
+
+
+def all_index_generator(k=10):
+    """Generator which can be iterated over to get instances of all the various
+    index classes.
+
+    Parameters
+    ----------
+    k: length of each of the index instances
+    """
+    all_make_index_funcs = [
+        makeIntIndex,
+        makeFloatIndex,
+        makeStringIndex,
+        makeUnicodeIndex,
+        makeDateIndex,
+        makePeriodIndex,
+        makeTimedeltaIndex,
+        makeBoolIndex,
+        makeRangeIndex,
+        makeIntervalIndex,
+        makeCategoricalIndex,
+    ]
+    for make_index_func in all_make_index_funcs:
+        yield make_index_func(k=k)
+
+
+def index_subclass_makers_generator():
+    make_index_funcs = [
+        makeDateIndex,
+        makePeriodIndex,
+        makeTimedeltaIndex,
+        makeRangeIndex,
+        makeIntervalIndex,
+        makeCategoricalIndex,
+        makeMultiIndex,
+    ]
+    for make_index_func in make_index_funcs:
+        yield make_index_func
+
+
+def all_timeseries_index_generator(k=10):
+    """Generator which can be iterated over to get instances of all the classes
+    which represent time-series.
+
+    Parameters
+    ----------
+    k: length of each of the index instances
+    """
+    make_index_funcs = [makeDateIndex, makePeriodIndex, makeTimedeltaIndex]
+    for make_index_func in make_index_funcs:
+        yield make_index_func(k=k)
+
+
+# make series
+def makeFloatSeries(name=None):
+    index = makeStringIndex(N)
+    return Series(randn(N), index=index, name=name)
+
+
+def makeStringSeries(name=None):
+    index = makeStringIndex(N)
+    return Series(randn(N), index=index, name=name)
+
+
+def makeObjectSeries(name=None):
+    data = makeStringIndex(N)
+    data = Index(data, dtype=object)
+    index = makeStringIndex(N)
+    return Series(data, index=index, name=name)
+
+
+def getSeriesData():
+    index = makeStringIndex(N)
+    return {c: Series(randn(N), index=index) for c in getCols(K)}
+
+
+def makeTimeSeries(nper=None, freq="B", name=None):
+    if nper is None:
+        nper = N
+    return Series(randn(nper), index=makeDateIndex(nper, freq=freq), name=name)
+
+
+def makePeriodSeries(nper=None, name=None):
+    if nper is None:
+        nper = N
+    return Series(randn(nper), index=makePeriodIndex(nper), name=name)
+
+
+def getTimeSeriesData(nper=None, freq="B"):
+    return {c: makeTimeSeries(nper, freq) for c in getCols(K)}
+
+
+def getPeriodData(nper=None):
+    return {c: makePeriodSeries(nper) for c in getCols(K)}
+
+
+# make frame
+def makeTimeDataFrame(nper=None, freq="B"):
+    data = getTimeSeriesData(nper, freq)
+    return DataFrame(data)
+
+
+def makeDataFrame():
+    data = getSeriesData()
+    return DataFrame(data)
+
+
+def getMixedTypeDict():
+    index = Index(["a", "b", "c", "d", "e"])
+
+    data = {
+        "A": [0.0, 1.0, 2.0, 3.0, 4.0],
+        "B": [0.0, 1.0, 0.0, 1.0, 0.0],
+        "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
+        "D": bdate_range("1/1/2009", periods=5),
+    }
+
+    return index, data
+
+
+def makeMixedDataFrame():
+    return DataFrame(getMixedTypeDict()[1])
+
+
+def makePeriodFrame(nper=None):
+    data = getPeriodData(nper)
+    return DataFrame(data)
+
+
+def makeCustomIndex(
+    nentries, nlevels, prefix="#", names=False, ndupe_l=None, idx_type=None
+):
+    """Create an index/multindex with given dimensions, levels, names, etc'
+
+    nentries - number of entries in index
+    nlevels - number of levels (> 1 produces multindex)
+    prefix - a string prefix for labels
+    names - (Optional), bool or list of strings. if True will use default
+       names, if false will use no names, if a list is given, the name of
+       each level in the index will be taken from the list.
+    ndupe_l - (Optional), list of ints, the number of rows for which the
+       label will repeated at the corresponding level, you can specify just
+       the first few, the rest will use the default ndupe_l of 1.
+       len(ndupe_l) <= nlevels.
+    idx_type - "i"/"f"/"s"/"u"/"dt"/"p"/"td".
+       If idx_type is not None, `idx_nlevels` must be 1.
+       "i"/"f" creates an integer/float index,
+       "s"/"u" creates a string/unicode index
+       "dt" create a datetime index.
+       "td" create a datetime index.
+
+        if unspecified, string labels will be generated.
+    """
+
+    if ndupe_l is None:
+        ndupe_l = [1] * nlevels
+    assert is_sequence(ndupe_l) and len(ndupe_l) <= nlevels
+    assert names is None or names is False or names is True or len(names) is nlevels
+    assert idx_type is None or (
+        idx_type in ("i", "f", "s", "u", "dt", "p", "td") and nlevels == 1
+    )
+
+    if names is True:
+        # build default names
+        names = [prefix + str(i) for i in range(nlevels)]
+    if names is False:
+        # pass None to index constructor for no name
+        names = None
+
+    # make singleton case uniform
+    if isinstance(names, str) and nlevels == 1:
+        names = [names]
+
+    # specific 1D index type requested?
+    idx_func = dict(
+        i=makeIntIndex,
+        f=makeFloatIndex,
+        s=makeStringIndex,
+        u=makeUnicodeIndex,
+        dt=makeDateIndex,
+        td=makeTimedeltaIndex,
+        p=makePeriodIndex,
+    ).get(idx_type)
+    if idx_func:
+        idx = idx_func(nentries)
+        # but we need to fill in the name
+        if names:
+            idx.name = names[0]
+        return idx
+    elif idx_type is not None:
+        raise ValueError(
+            f"{repr(idx_type)} is not a legal value for `idx_type`, "
+            "use  'i'/'f'/'s'/'u'/'dt'/'p'/'td'."
+        )
+
+    if len(ndupe_l) < nlevels:
+        ndupe_l.extend([1] * (nlevels - len(ndupe_l)))
+    assert len(ndupe_l) == nlevels
+
+    assert all(x > 0 for x in ndupe_l)
+
+    tuples = []
+    for i in range(nlevels):
+
+        def keyfunc(x):
+            import re
+
+            numeric_tuple = re.sub(r"[^\d_]_?", "", x).split("_")
+            return [int(num) for num in numeric_tuple]
+
+        # build a list of lists to create the index from
+        div_factor = nentries // ndupe_l[i] + 1
+        cnt = Counter()
+        for j in range(div_factor):
+            label = f"{prefix}_l{i}_g{j}"
+            cnt[label] = ndupe_l[i]
+        # cute Counter trick
+        result = sorted(cnt.elements(), key=keyfunc)[:nentries]
+        tuples.append(result)
+
+    tuples = list(zip(*tuples))
+
+    # convert tuples to index
+    if nentries == 1:
+        # we have a single level of tuples, i.e. a regular Index
+        index = Index(tuples[0], name=names[0])
+    elif nlevels == 1:
+        name = None if names is None else names[0]
+        index = Index((x[0] for x in tuples), name=name)
+    else:
+        index = MultiIndex.from_tuples(tuples, names=names)
+    return index
+
+
+def makeCustomDataframe(
+    nrows,
+    ncols,
+    c_idx_names=True,
+    r_idx_names=True,
+    c_idx_nlevels=1,
+    r_idx_nlevels=1,
+    data_gen_f=None,
+    c_ndupe_l=None,
+    r_ndupe_l=None,
+    dtype=None,
+    c_idx_type=None,
+    r_idx_type=None,
+):
+    """
+   nrows,  ncols - number of data rows/cols
+   c_idx_names, idx_names  - False/True/list of strings,  yields No names ,
+        default names or uses the provided names for the levels of the
+        corresponding index. You can provide a single string when
+        c_idx_nlevels ==1.
+   c_idx_nlevels - number of levels in columns index. > 1 will yield MultiIndex
+   r_idx_nlevels - number of levels in rows index. > 1 will yield MultiIndex
+   data_gen_f - a function f(row,col) which return the data value
+        at that position, the default generator used yields values of the form
+        "RxCy" based on position.
+   c_ndupe_l, r_ndupe_l - list of integers, determines the number
+        of duplicates for each label at a given level of the corresponding
+        index. The default `None` value produces a multiplicity of 1 across
+        all levels, i.e. a unique index. Will accept a partial list of length
+        N < idx_nlevels, for just the first N levels. If ndupe doesn't divide
+        nrows/ncol, the last label might have lower multiplicity.
+   dtype - passed to the DataFrame constructor as is, in case you wish to
+        have more control in conjunction with a custom `data_gen_f`
+   r_idx_type, c_idx_type -  "i"/"f"/"s"/"u"/"dt"/"td".
+       If idx_type is not None, `idx_nlevels` must be 1.
+       "i"/"f" creates an integer/float index,
+       "s"/"u" creates a string/unicode index
+       "dt" create a datetime index.
+       "td" create a timedelta index.
+
+        if unspecified, string labels will be generated.
+
+    Examples:
+
+    # 5 row, 3 columns, default names on both, single index on both axis
+    >> makeCustomDataframe(5,3)
+
+    # make the data a random int between 1 and 100
+    >> mkdf(5,3,data_gen_f=lambda r,c:randint(1,100))
+
+    # 2-level multiindex on rows with each label duplicated
+    # twice on first level, default names on both axis, single
+    # index on both axis
+    >> a=makeCustomDataframe(5,3,r_idx_nlevels=2,r_ndupe_l=[2])
+
+    # DatetimeIndex on row, index with unicode labels on columns
+    # no names on either axis
+    >> a=makeCustomDataframe(5,3,c_idx_names=False,r_idx_names=False,
+                             r_idx_type="dt",c_idx_type="u")
+
+    # 4-level multindex on rows with names provided, 2-level multindex
+    # on columns with default labels and default names.
+    >> a=makeCustomDataframe(5,3,r_idx_nlevels=4,
+                             r_idx_names=["FEE","FI","FO","FAM"],
+                             c_idx_nlevels=2)
+
+    >> a=mkdf(5,3,r_idx_nlevels=2,c_idx_nlevels=4)
+    """
+
+    assert c_idx_nlevels > 0
+    assert r_idx_nlevels > 0
+    assert r_idx_type is None or (
+        r_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and r_idx_nlevels == 1
+    )
+    assert c_idx_type is None or (
+        c_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and c_idx_nlevels == 1
+    )
+
+    columns = makeCustomIndex(
+        ncols,
+        nlevels=c_idx_nlevels,
+        prefix="C",
+        names=c_idx_names,
+        ndupe_l=c_ndupe_l,
+        idx_type=c_idx_type,
+    )
+    index = makeCustomIndex(
+        nrows,
+        nlevels=r_idx_nlevels,
+        prefix="R",
+        names=r_idx_names,
+        ndupe_l=r_ndupe_l,
+        idx_type=r_idx_type,
+    )
+
+    # by default, generate data based on location
+    if data_gen_f is None:
+        data_gen_f = lambda r, c: f"R{r}C{c}"
+
+    data = [[data_gen_f(r, c) for c in range(ncols)] for r in range(nrows)]
+
+    return DataFrame(data, index, columns, dtype=dtype)
+
+
+def _create_missing_idx(nrows, ncols, density, random_state=None):
+    if random_state is None:
+        random_state = np.random
+    else:
+        random_state = np.random.RandomState(random_state)
+
+    # below is cribbed from scipy.sparse
+    size = int(np.round((1 - density) * nrows * ncols))
+    # generate a few more to ensure unique values
+    min_rows = 5
+    fac = 1.02
+    extra_size = min(size + min_rows, fac * size)
+
+    def _gen_unique_rand(rng, _extra_size):
+        ind = rng.rand(int(_extra_size))
+        return np.unique(np.floor(ind * nrows * ncols))[:size]
+
+    ind = _gen_unique_rand(random_state, extra_size)
+    while ind.size < size:
+        extra_size *= 1.05
+        ind = _gen_unique_rand(random_state, extra_size)
+
+    j = np.floor(ind * 1.0 / nrows).astype(int)
+    i = (ind - j * nrows).astype(int)
+    return i.tolist(), j.tolist()
+
+
+def makeMissingCustomDataframe(
+    nrows,
+    ncols,
+    density=0.9,
+    random_state=None,
+    c_idx_names=True,
+    r_idx_names=True,
+    c_idx_nlevels=1,
+    r_idx_nlevels=1,
+    data_gen_f=None,
+    c_ndupe_l=None,
+    r_ndupe_l=None,
+    dtype=None,
+    c_idx_type=None,
+    r_idx_type=None,
+):
+    """
+    Parameters
+    ----------
+    Density : float, optional
+        Float in (0, 1) that gives the percentage of non-missing numbers in
+        the DataFrame.
+    random_state : {np.random.RandomState, int}, optional
+        Random number generator or random seed.
+
+    See makeCustomDataframe for descriptions of the rest of the parameters.
+    """
+    df = makeCustomDataframe(
+        nrows,
+        ncols,
+        c_idx_names=c_idx_names,
+        r_idx_names=r_idx_names,
+        c_idx_nlevels=c_idx_nlevels,
+        r_idx_nlevels=r_idx_nlevels,
+        data_gen_f=data_gen_f,
+        c_ndupe_l=c_ndupe_l,
+        r_ndupe_l=r_ndupe_l,
+        dtype=dtype,
+        c_idx_type=c_idx_type,
+        r_idx_type=r_idx_type,
+    )
+
+    i, j = _create_missing_idx(nrows, ncols, density, random_state)
+    df.values[i, j] = np.nan
+    return df
+
+
+def makeMissingDataframe(density=0.9, random_state=None):
+    df = makeDataFrame()
+    i, j = _create_missing_idx(*df.shape, density=density, random_state=random_state)
+    df.values[i, j] = np.nan
+    return df
+
+
+def optional_args(decorator):
+    """allows a decorator to take optional positional and keyword arguments.
+    Assumes that taking a single, callable, positional argument means that
+    it is decorating a function, i.e. something like this::
+
+        @my_decorator
+        def function(): pass
+
+    Calls decorator with decorator(f, *args, **kwargs)
+    """
+
+    @wraps(decorator)
+    def wrapper(*args, **kwargs):
+        def dec(f):
+            return decorator(f, *args, **kwargs)
+
+        is_decorating = not kwargs and len(args) == 1 and callable(args[0])
+        if is_decorating:
+            f = args[0]
+            args = []
+            return dec(f)
+        else:
+            return dec
+
+    return wrapper
+
+
+# skip tests on exceptions with this message
+_network_error_messages = (
+    # 'urlopen error timed out',
+    # 'timeout: timed out',
+    # 'socket.timeout: timed out',
+    "timed out",
+    "Server Hangup",
+    "HTTP Error 503: Service Unavailable",
+    "502: Proxy Error",
+    "HTTP Error 502: internal error",
+    "HTTP Error 502",
+    "HTTP Error 503",
+    "HTTP Error 403",
+    "HTTP Error 400",
+    "Temporary failure in name resolution",
+    "Name or service not known",
+    "Connection refused",
+    "certificate verify",
+)
+
+# or this e.errno/e.reason.errno
+_network_errno_vals = (
+    101,  # Network is unreachable
+    111,  # Connection refused
+    110,  # Connection timed out
+    104,  # Connection reset Error
+    54,  # Connection reset by peer
+    60,  # urllib.error.URLError: [Errno 60] Connection timed out
+)
+
+# Both of the above shouldn't mask real issues such as 404's
+# or refused connections (changed DNS).
+# But some tests (test_data yahoo) contact incredibly flakey
+# servers.
+
+# and conditionally raise on exception types in _get_default_network_errors
+
+
+def _get_default_network_errors():
+    # Lazy import for http.client because it imports many things from the stdlib
+    import http.client
+
+    return (IOError, http.client.HTTPException, TimeoutError)
+
+
+def can_connect(url, error_classes=None):
+    """Try to connect to the given url. True if succeeds, False if IOError
+    raised
+
+    Parameters
+    ----------
+    url : basestring
+        The URL to try to connect to
+
+    Returns
+    -------
+    connectable : bool
+        Return True if no IOError (unable to connect) or URLError (bad url) was
+        raised
+    """
+
+    if error_classes is None:
+        error_classes = _get_default_network_errors()
+
+    try:
+        with urlopen(url):
+            pass
+    except error_classes:
+        return False
+    else:
+        return True
+
+
+@optional_args
+def network(
+    t,
+    url="http://www.google.com",
+    raise_on_error=_RAISE_NETWORK_ERROR_DEFAULT,
+    check_before_test=False,
+    error_classes=None,
+    skip_errnos=_network_errno_vals,
+    _skip_on_messages=_network_error_messages,
+):
+    """
+    Label a test as requiring network connection and, if an error is
+    encountered, only raise if it does not find a network connection.
+
+    In comparison to ``network``, this assumes an added contract to your test:
+    you must assert that, under normal conditions, your test will ONLY fail if
+    it does not have network connectivity.
+
+    You can call this in 3 ways: as a standard decorator, with keyword
+    arguments, or with a positional argument that is the url to check.
+
+    Parameters
+    ----------
+    t : callable
+        The test requiring network connectivity.
+    url : path
+        The url to test via ``pandas.io.common.urlopen`` to check
+        for connectivity. Defaults to 'http://www.google.com'.
+    raise_on_error : bool
+        If True, never catches errors.
+    check_before_test : bool
+        If True, checks connectivity before running the test case.
+    error_classes : tuple or Exception
+        error classes to ignore. If not in ``error_classes``, raises the error.
+        defaults to IOError. Be careful about changing the error classes here.
+    skip_errnos : iterable of int
+        Any exception that has .errno or .reason.erno set to one
+        of these values will be skipped with an appropriate
+        message.
+    _skip_on_messages: iterable of string
+        any exception e for which one of the strings is
+        a substring of str(e) will be skipped with an appropriate
+        message. Intended to suppress errors where an errno isn't available.
+
+    Notes
+    -----
+    * ``raise_on_error`` supercedes ``check_before_test``
+
+    Returns
+    -------
+    t : callable
+        The decorated test ``t``, with checks for connectivity errors.
+
+    Example
+    -------
+
+    Tests decorated with @network will fail if it's possible to make a network
+    connection to another URL (defaults to google.com)::
+
+      >>> from pandas._testing import network
+      >>> from pandas.io.common import urlopen
+      >>> @network
+      ... def test_network():
+      ...     with urlopen("rabbit://bonanza.com"):
+      ...         pass
+      Traceback
+         ...
+      URLError: <urlopen error unknown url type: rabit>
+
+      You can specify alternative URLs::
+
+        >>> @network("http://www.yahoo.com")
+        ... def test_something_with_yahoo():
+        ...    raise IOError("Failure Message")
+        >>> test_something_with_yahoo()
+        Traceback (most recent call last):
+            ...
+        IOError: Failure Message
+
+    If you set check_before_test, it will check the url first and not run the
+    test on failure::
+
+        >>> @network("failing://url.blaher", check_before_test=True)
+        ... def test_something():
+        ...     print("I ran!")
+        ...     raise ValueError("Failure")
+        >>> test_something()
+        Traceback (most recent call last):
+            ...
+
+    Errors not related to networking will always be raised.
+    """
+    from pytest import skip
+
+    if error_classes is None:
+        error_classes = _get_default_network_errors()
+
+    t.network = True
+
+    @wraps(t)
+    def wrapper(*args, **kwargs):
+        if check_before_test and not raise_on_error:
+            if not can_connect(url, error_classes):
+                skip()
+        try:
+            return t(*args, **kwargs)
+        except Exception as err:
+            errno = getattr(err, "errno", None)
+            if not errno and hasattr(errno, "reason"):
+                errno = getattr(err.reason, "errno", None)
+
+            if errno in skip_errnos:
+                skip(f"Skipping test due to known errno and error {err}")
+
+            e_str = str(err)
+
+            if any(m.lower() in e_str.lower() for m in _skip_on_messages):
+                skip(
+                    f"Skipping test because exception message is known and error {err}"
+                )
+
+            if not isinstance(err, error_classes):
+                raise
+
+            if raise_on_error or can_connect(url, error_classes):
+                raise
+            else:
+                skip(f"Skipping test due to lack of connectivity and error {err}")
+
+    return wrapper
+
+
+with_connectivity_check = network
+
+
+@contextmanager
+def assert_produces_warning(
+    expected_warning=Warning,
+    filter_level="always",
+    clear=None,
+    check_stacklevel=True,
+    raise_on_extra_warnings=True,
+):
+    """
+    Context manager for running code expected to either raise a specific
+    warning, or not raise any warnings. Verifies that the code raises the
+    expected warning, and that it does not raise any other unexpected
+    warnings. It is basically a wrapper around ``warnings.catch_warnings``.
+
+    Parameters
+    ----------
+    expected_warning : {Warning, False, None}, default Warning
+        The type of Exception raised. ``exception.Warning`` is the base
+        class for all warnings. To check that no warning is returned,
+        specify ``False`` or ``None``.
+    filter_level : str or None, default "always"
+        Specifies whether warnings are ignored, displayed, or turned
+        into errors.
+        Valid values are:
+
+        * "error" - turns matching warnings into exceptions
+        * "ignore" - discard the warning
+        * "always" - always emit a warning
+        * "default" - print the warning the first time it is generated
+          from each location
+        * "module" - print the warning the first time it is generated
+          from each module
+        * "once" - print the warning the first time it is generated
+
+    clear : str, default None
+        If not ``None`` then remove any previously raised warnings from
+        the ``__warningsregistry__`` to ensure that no warning messages are
+        suppressed by this context manager. If ``None`` is specified,
+        the ``__warningsregistry__`` keeps track of which warnings have been
+        shown, and does not show them again.
+    check_stacklevel : bool, default True
+        If True, displays the line that called the function containing
+        the warning to show were the function is called. Otherwise, the
+        line that implements the function is displayed.
+    raise_on_extra_warnings : bool, default True
+        Whether extra warnings not of the type `expected_warning` should
+        cause the test to fail.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> with assert_produces_warning():
+    ...     warnings.warn(UserWarning())
+    ...
+    >>> with assert_produces_warning(False):
+    ...     warnings.warn(RuntimeWarning())
+    ...
+    Traceback (most recent call last):
+        ...
+    AssertionError: Caused unexpected warning(s): ['RuntimeWarning'].
+    >>> with assert_produces_warning(UserWarning):
+    ...     warnings.warn(RuntimeWarning())
+    Traceback (most recent call last):
+        ...
+    AssertionError: Did not see expected warning of class 'UserWarning'.
+
+    ..warn:: This is *not* thread-safe.
+    """
+    __tracebackhide__ = True
+
+    with warnings.catch_warnings(record=True) as w:
+
+        if clear is not None:
+            # make sure that we are clearing these warnings
+            # if they have happened before
+            # to guarantee that we will catch them
+            if not is_list_like(clear):
+                clear = [clear]
+            for m in clear:
+                try:
+                    m.__warningregistry__.clear()
+                except AttributeError:
+                    # module may not have __warningregistry__
+                    pass
+
+        saw_warning = False
+        warnings.simplefilter(filter_level)
+        yield w
+        extra_warnings = []
+
+        for actual_warning in w:
+            if expected_warning and issubclass(
+                actual_warning.category, expected_warning
+            ):
+                saw_warning = True
+
+                if check_stacklevel and issubclass(
+                    actual_warning.category, (FutureWarning, DeprecationWarning)
+                ):
+                    from inspect import getframeinfo, stack
+
+                    caller = getframeinfo(stack()[2][0])
+                    msg = (
+                        "Warning not set with correct stacklevel. "
+                        f"File where warning is raised: {actual_warning.filename} != "
+                        f"{caller.filename}. Warning message: {actual_warning.message}"
+                    )
+                    assert actual_warning.filename == caller.filename, msg
+            else:
+                extra_warnings.append(
+                    (
+                        actual_warning.category.__name__,
+                        actual_warning.message,
+                        actual_warning.filename,
+                        actual_warning.lineno,
+                    )
+                )
+        if expected_warning:
+            msg = (
+                f"Did not see expected warning of class "
+                f"{repr(expected_warning.__name__)}"
+            )
+            assert saw_warning, msg
+        if raise_on_extra_warnings and extra_warnings:
+            raise AssertionError(
+                f"Caused unexpected warning(s): {repr(extra_warnings)}"
+            )
+
+
+class RNGContext:
+    """
+    Context manager to set the numpy random number generator speed. Returns
+    to the original value upon exiting the context manager.
+
+    Parameters
+    ----------
+    seed : int
+        Seed for numpy.random.seed
+
+    Examples
+    --------
+
+    with RNGContext(42):
+        np.random.randn()
+    """
+
+    def __init__(self, seed):
+        self.seed = seed
+
+    def __enter__(self):
+
+        self.start_state = np.random.get_state()
+        np.random.seed(self.seed)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+
+        np.random.set_state(self.start_state)
+
+
+@contextmanager
+def with_csv_dialect(name, **kwargs):
+    """
+    Context manager to temporarily register a CSV dialect for parsing CSV.
+
+    Parameters
+    ----------
+    name : str
+        The name of the dialect.
+    kwargs : mapping
+        The parameters for the dialect.
+
+    Raises
+    ------
+    ValueError : the name of the dialect conflicts with a builtin one.
+
+    See Also
+    --------
+    csv : Python's CSV library.
+    """
+    import csv
+
+    _BUILTIN_DIALECTS = {"excel", "excel-tab", "unix"}
+
+    if name in _BUILTIN_DIALECTS:
+        raise ValueError("Cannot override builtin dialect.")
+
+    csv.register_dialect(name, **kwargs)
+    yield
+    csv.unregister_dialect(name)
+
+
+@contextmanager
+def use_numexpr(use, min_elements=None):
+    from pandas.core.computation import expressions as expr
+
+    if min_elements is None:
+        min_elements = expr._MIN_ELEMENTS
+
+    olduse = expr._USE_NUMEXPR
+    oldmin = expr._MIN_ELEMENTS
+    expr.set_use_numexpr(use)
+    expr._MIN_ELEMENTS = min_elements
+    yield
+    expr._MIN_ELEMENTS = oldmin
+    expr.set_use_numexpr(olduse)
+
+
+def test_parallel(num_threads=2, kwargs_list=None):
+    """Decorator to run the same function multiple times in parallel.
+
+    Parameters
+    ----------
+    num_threads : int, optional
+        The number of times the function is run in parallel.
+    kwargs_list : list of dicts, optional
+        The list of kwargs to update original
+        function kwargs on different threads.
+    Notes
+    -----
+    This decorator does not pass the return value of the decorated function.
+
+    Original from scikit-image:
+
+    https://github.com/scikit-image/scikit-image/pull/1519
+
+    """
+
+    assert num_threads > 0
+    has_kwargs_list = kwargs_list is not None
+    if has_kwargs_list:
+        assert len(kwargs_list) == num_threads
+    import threading
+
+    def wrapper(func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            if has_kwargs_list:
+                update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
+            else:
+                update_kwargs = lambda i: kwargs
+            threads = []
+            for i in range(num_threads):
+                updated_kwargs = update_kwargs(i)
+                thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
+                threads.append(thread)
+            for thread in threads:
+                thread.start()
+            for thread in threads:
+                thread.join()
+
+        return inner
+
+    return wrapper
+
+
+class SubclassedSeries(Series):
+    _metadata = ["testattr", "name"]
+
+    @property
+    def _constructor(self):
+        return SubclassedSeries
+
+    @property
+    def _constructor_expanddim(self):
+        return SubclassedDataFrame
+
+
+class SubclassedDataFrame(DataFrame):
+    _metadata = ["testattr"]
+
+    @property
+    def _constructor(self):
+        return SubclassedDataFrame
+
+    @property
+    def _constructor_sliced(self):
+        return SubclassedSeries
+
+
+class SubclassedCategorical(Categorical):
+    @property
+    def _constructor(self):
+        return SubclassedCategorical
+
+
+@contextmanager
+def set_timezone(tz: str):
+    """
+    Context manager for temporarily setting a timezone.
+
+    Parameters
+    ----------
+    tz : str
+        A string representing a valid timezone.
+
+    Examples
+    --------
+
+    >>> from datetime import datetime
+    >>> from dateutil.tz import tzlocal
+    >>> tzlocal().tzname(datetime.now())
+    'IST'
+
+    >>> with set_timezone('US/Eastern'):
+    ...     tzlocal().tzname(datetime.now())
+    ...
+    'EDT'
+    """
+
+    import os
+    import time
+
+    def setTZ(tz):
+        if tz is None:
+            try:
+                del os.environ["TZ"]
+            except KeyError:
+                pass
+        else:
+            os.environ["TZ"] = tz
+            time.tzset()
+
+    orig_tz = os.environ.get("TZ")
+    setTZ(tz)
+    try:
+        yield
+    finally:
+        setTZ(orig_tz)
+
+
+def _make_skipna_wrapper(alternative, skipna_alternative=None):
+    """
+    Create a function for calling on an array.
+
+    Parameters
+    ----------
+    alternative : function
+        The function to be called on the array with no NaNs.
+        Only used when 'skipna_alternative' is None.
+    skipna_alternative : function
+        The function to be called on the original array
+
+    Returns
+    -------
+    function
+    """
+    if skipna_alternative:
+
+        def skipna_wrapper(x):
+            return skipna_alternative(x.values)
+
+    else:
+
+        def skipna_wrapper(x):
+            nona = x.dropna()
+            if len(nona) == 0:
+                return np.nan
+            return alternative(nona)
+
+    return skipna_wrapper
+
+
+def convert_rows_list_to_csv_str(rows_list: List[str]):
+    """
+    Convert list of CSV rows to single CSV-formatted string for current OS.
+
+    This method is used for creating expected value of to_csv() method.
+
+    Parameters
+    ----------
+    rows_list : List[str]
+        Each element represents the row of csv.
+
+    Returns
+    -------
+    str
+        Expected output of to_csv() in current OS.
+    """
+    sep = os.linesep
+    expected = sep.join(rows_list) + sep
+    return expected
+
+
+def external_error_raised(
+    expected_exception: Type[Exception],
+) -> Callable[[Type[Exception], None], None]:
+    """
+    Helper function to mark pytest.raises that have an external error message.
+
+    Parameters
+    ----------
+    expected_exception : Exception
+        Expected error to raise.
+
+    Returns
+    -------
+    Callable
+        Regular `pytest.raises` function with `match` equal to `None`.
+    """
+    import pytest
+
+    return pytest.raises(expected_exception, match=None)
diff --git a/pandas/_typing.py b/pandas/_typing.py
index de9fb5b944186..e2858441605f7 100644
--- a/pandas/_typing.py
+++ b/pandas/_typing.py
@@ -1,5 +1,19 @@
 from pathlib import Path
-from typing import IO, TYPE_CHECKING, AnyStr, Iterable, Optional, TypeVar, Union
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    Callable,
+    Collection,
+    Dict,
+    Hashable,
+    List,
+    Mapping,
+    Optional,
+    TypeVar,
+    Union,
+)
 
 import numpy as np
 
@@ -11,26 +25,50 @@
     from pandas.core.arrays.base import ExtensionArray  # noqa: F401
     from pandas.core.dtypes.dtypes import ExtensionDtype  # noqa: F401
     from pandas.core.indexes.base import Index  # noqa: F401
-    from pandas.core.series import Series  # noqa: F401
-    from pandas.core.sparse.series import SparseSeries  # noqa: F401
     from pandas.core.generic import NDFrame  # noqa: F401
+    from pandas import Interval  # noqa: F401
+    from pandas.core.series import Series  # noqa: F401
+    from pandas.core.frame import DataFrame  # noqa: F401
 
+# array-like
 
-AnyArrayLike = TypeVar(
-    "AnyArrayLike", "ExtensionArray", "Index", "Series", "SparseSeries", np.ndarray
-)
+AnyArrayLike = TypeVar("AnyArrayLike", "ExtensionArray", "Index", "Series", np.ndarray)
 ArrayLike = TypeVar("ArrayLike", "ExtensionArray", np.ndarray)
+
+# scalars
+
+PythonScalar = Union[str, int, float, bool]
 DatetimeLikeScalar = TypeVar("DatetimeLikeScalar", "Period", "Timestamp", "Timedelta")
+PandasScalar = Union["Period", "Timestamp", "Timedelta", "Interval"]
+Scalar = Union[PythonScalar, PandasScalar]
+
+# other
+
 Dtype = Union[str, np.dtype, "ExtensionDtype"]
+DtypeObj = Union[np.dtype, "ExtensionDtype"]
 FilePathOrBuffer = Union[str, Path, IO[AnyStr]]
 
+# FrameOrSeriesUnion  means either a DataFrame or a Series. E.g.
+# `def func(a: FrameOrSeriesUnion) -> FrameOrSeriesUnion: ...` means that if a Series
+# is passed in, either a Series or DataFrame is returned, and if a DataFrame is passed
+# in, either a DataFrame or a Series is returned.
+FrameOrSeriesUnion = Union["DataFrame", "Series"]
+
+# FrameOrSeries is stricter and ensures that the same subclass of NDFrame always is
+# used. E.g. `def func(a: FrameOrSeries) -> FrameOrSeries: ...` means that if a
+# Series is passed into a function, a Series is always returned and if a DataFrame is
+# passed in, a DataFrame is always returned.
 FrameOrSeries = TypeVar("FrameOrSeries", bound="NDFrame")
-Scalar = Union[str, int, float]
+
 Axis = Union[str, int]
+Label = Optional[Hashable]
+Level = Union[Label, int]
 Ordered = Optional[bool]
+JSONSerializable = Union[PythonScalar, List, Dict]
+Axes = Collection
 
-# use Collection after we drop support for py35
-Axes = Iterable
+# For functions like rename that convert one label to another
+Renamer = Union[Mapping[Label, Any], Callable[[Label], Label]]
 
 # to maintain type information across generic functions and parametrization
-_T = TypeVar("_T")
+T = TypeVar("T")
diff --git a/pandas/_version.py b/pandas/_version.py
index 4f5bdf59a99d5..66e756a4744c8 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -47,7 +47,7 @@ class NotThisMethod(Exception):
     pass
 
 
-HANDLERS = {}  # type: Dict[str, Dict[str, Callable]]
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
 def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
@@ -79,17 +79,17 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
-                print("unable to run {dispcmd}".format(dispcmd=dispcmd))
+                print(f"unable to run {dispcmd}")
                 print(e)
             return None
     else:
         if verbose:
-            print("unable to find command, tried %s" % (commands,))
+            print(f"unable to find command, tried {commands}")
         return None
     stdout = p.communicate()[0].strip().decode()
     if p.returncode != 0:
         if verbose:
-            print("unable to run {dispcmd} (error)".format(dispcmd=dispcmd))
+            print(f"unable to run {dispcmd} (error)")
         return None
     return stdout
 
@@ -101,10 +101,8 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     if not dirname.startswith(parentdir_prefix):
         if verbose:
             print(
-                "guessing rootdir is '{root}', but '{dirname}' "
-                "doesn't start with prefix '{parentdir_prefix}'".format(
-                    root=root, dirname=dirname, parentdir_prefix=parentdir_prefix
-                )
+                f"guessing rootdir is '{root}', but '{dirname}' "
+                f"doesn't start with prefix '{parentdir_prefix}'"
             )
         raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
     return {
@@ -163,15 +161,15 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # "stabilization", as well as "HEAD" and "master".
         tags = {r for r in refs if re.search(r"\d", r)}
         if verbose:
-            print("discarding '{}', no digits".format(",".join(refs - tags)))
+            print(f"discarding '{','.join(refs - tags)}', no digits")
     if verbose:
-        print("likely tags: {}".format(",".join(sorted(tags))))
+        print(f"likely tags: {','.join(sorted(tags))}")
     for ref in sorted(tags):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix) :]
             if verbose:
-                print("picking {r}".format(r=r))
+                print(f"picking {r}")
             return {
                 "version": r,
                 "full-revisionid": keywords["full"].strip(),
@@ -198,7 +196,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     if not os.path.exists(os.path.join(root, ".git")):
         if verbose:
-            print("no .git in {root}".format(root=root))
+            print(f"no .git in {root}")
         raise NotThisMethod("no .git directory")
 
     GITS = ["git"]
@@ -240,17 +238,13 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe)
         if not mo:
             # unparseable. Maybe git-describe is misbehaving?
-            pieces["error"] = (
-                "unable to parse git-describe output: "
-                "'{describe_out}'".format(describe_out=describe_out)
-            )
+            pieces["error"] = f"unable to parse git-describe output: '{describe_out}'"
             return pieces
 
         # tag
         full_tag = mo.group(1)
         if not full_tag.startswith(tag_prefix):
-            fmt = "tag '{full_tag}' doesn't start with prefix " "'{tag_prefix}'"
-            msg = fmt.format(full_tag=full_tag, tag_prefix=tag_prefix)
+            msg = f"tag '{full_tag}' doesn't start with prefix '{tag_prefix}'"
             if verbose:
                 print(msg)
             pieces["error"] = msg
@@ -291,12 +285,12 @@ def render_pep440(pieces):
         rendered = pieces["closest-tag"]
         if pieces["distance"] or pieces["dirty"]:
             rendered += plus_or_dot(pieces)
-            rendered += "{:d}.g{}".format(pieces["distance"], pieces["short"])
+            rendered += f"{pieces['distance']:d}.g{pieces['short']}"
             if pieces["dirty"]:
                 rendered += ".dirty"
     else:
         # exception #1
-        rendered = "0+untagged.{:d}.g{}".format(pieces["distance"], pieces["short"])
+        rendered = f"0+untagged.{pieces['distance']:d}.g{pieces['short']}"
         if pieces["dirty"]:
             rendered += ".dirty"
     return rendered
@@ -311,10 +305,10 @@ def render_pep440_pre(pieces):
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += ".post.dev%d" % pieces["distance"]
+            rendered += f".post.dev{pieces['distance']:d}"
     else:
         # exception #1
-        rendered = "0.post.dev%d" % pieces["distance"]
+        rendered = f"0.post.dev{pieces['distance']:d}"
     return rendered
 
 
@@ -330,17 +324,17 @@ def render_pep440_post(pieces):
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
         if pieces["distance"] or pieces["dirty"]:
-            rendered += ".post{:d}".format(pieces["distance"])
+            rendered += f".post{pieces['distance']:d}"
             if pieces["dirty"]:
                 rendered += ".dev0"
             rendered += plus_or_dot(pieces)
-            rendered += "g{}".format(pieces["short"])
+            rendered += f"g{pieces['short']}"
     else:
         # exception #1
-        rendered = "0.post%d" % pieces["distance"]
+        rendered = f"0.pos{pieces['distance']:d}"
         if pieces["dirty"]:
             rendered += ".dev0"
-        rendered += "+g{}".format(pieces["short"])
+        rendered += f"+g{pieces['short']}"
     return rendered
 
 
@@ -353,12 +347,12 @@ def render_pep440_old(pieces):
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
         if pieces["distance"] or pieces["dirty"]:
-            rendered += ".post%d" % pieces["distance"]
+            rendered += f".post{pieces['distance']:d}"
             if pieces["dirty"]:
                 rendered += ".dev0"
     else:
         # exception #1
-        rendered = "0.post%d" % pieces["distance"]
+        rendered = f"0.post{pieces['distance']:d}"
         if pieces["dirty"]:
             rendered += ".dev0"
     return rendered
@@ -374,7 +368,7 @@ def render_git_describe(pieces):
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += "-{:d}-g{}".format(pieces["distance"], pieces["short"])
+            rendered += f"-{pieces['distance']:d}-g{pieces['short']}"
     else:
         # exception #1
         rendered = pieces["short"]
@@ -392,7 +386,7 @@ def render_git_describe_long(pieces):
 
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
-        rendered += "-{:d}-g{}".format(pieces["distance"], pieces["short"])
+        rendered += f"-{pieces['distance']:d}-g{pieces['short']}"
     else:
         # exception #1
         rendered = pieces["short"]
@@ -426,7 +420,7 @@ def render(pieces, style):
     elif style == "git-describe-long":
         rendered = render_git_describe_long(pieces)
     else:
-        raise ValueError("unknown style '{style}'".format(style=style))
+        raise ValueError(f"unknown style '{style}'")
 
     return {
         "version": rendered,
diff --git a/pandas/api/__init__.py b/pandas/api/__init__.py
index 58422811990c4..bebbb38b4aefa 100644
--- a/pandas/api/__init__.py
+++ b/pandas/api/__init__.py
@@ -1,2 +1,2 @@
 """ public toolkit API """
-from . import extensions, types  # noqa
+from pandas.api import extensions, indexers, types  # noqa
diff --git a/pandas/api/extensions/__init__.py b/pandas/api/extensions/__init__.py
index 573d700dac43d..3019dd0e9b371 100644
--- a/pandas/api/extensions/__init__.py
+++ b/pandas/api/extensions/__init__.py
@@ -1,13 +1,27 @@
-"""Public API for extending pandas objects."""
-from pandas.core.dtypes.dtypes import (  # noqa: F401
-    ExtensionDtype,
-    register_extension_dtype,
-)
+"""
+Public API for extending pandas objects.
+"""
+
+from pandas._libs.lib import no_default
 
-from pandas.core.accessor import (  # noqa: F401
+from pandas.core.dtypes.dtypes import ExtensionDtype, register_extension_dtype
+
+from pandas.core.accessor import (
     register_dataframe_accessor,
     register_index_accessor,
     register_series_accessor,
 )
-from pandas.core.algorithms import take  # noqa: F401
-from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin  # noqa: F401
+from pandas.core.algorithms import take
+from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin
+
+__all__ = [
+    "no_default",
+    "ExtensionDtype",
+    "register_extension_dtype",
+    "register_dataframe_accessor",
+    "register_index_accessor",
+    "register_series_accessor",
+    "take",
+    "ExtensionArray",
+    "ExtensionScalarOpsMixin",
+]
diff --git a/pandas/api/indexers/__init__.py b/pandas/api/indexers/__init__.py
new file mode 100644
index 0000000000000..826297e6b498f
--- /dev/null
+++ b/pandas/api/indexers/__init__.py
@@ -0,0 +1,8 @@
+"""
+Public API for Rolling Window Indexers.
+"""
+
+from pandas.core.indexers import check_array_indexer
+from pandas.core.window.indexers import BaseIndexer
+
+__all__ = ["check_array_indexer", "BaseIndexer"]
diff --git a/pandas/api/types/__init__.py b/pandas/api/types/__init__.py
index f32e1abe28cc1..3495b493707c2 100644
--- a/pandas/api/types/__init__.py
+++ b/pandas/api/types/__init__.py
@@ -1,12 +1,23 @@
-""" public toolkit API """
+"""
+Public toolkit API.
+"""
 
-from pandas._libs.lib import infer_dtype  # noqa: F401
+from pandas._libs.lib import infer_dtype
 
 from pandas.core.dtypes.api import *  # noqa: F403, F401
-from pandas.core.dtypes.concat import union_categoricals  # noqa: F401
-from pandas.core.dtypes.dtypes import (  # noqa: F401
+from pandas.core.dtypes.concat import union_categoricals
+from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
     DatetimeTZDtype,
     IntervalDtype,
     PeriodDtype,
 )
+
+__all__ = [
+    "infer_dtype",
+    "union_categoricals",
+    "CategoricalDtype",
+    "DatetimeTZDtype",
+    "IntervalDtype",
+    "PeriodDtype",
+]
diff --git a/pandas/arrays/__init__.py b/pandas/arrays/__init__.py
index db01f2a0c674f..61832a8b6d621 100644
--- a/pandas/arrays/__init__.py
+++ b/pandas/arrays/__init__.py
@@ -4,6 +4,7 @@
 See :ref:`extending.extension-types` for more.
 """
 from pandas.core.arrays import (
+    BooleanArray,
     Categorical,
     DatetimeArray,
     IntegerArray,
@@ -11,10 +12,12 @@
     PandasArray,
     PeriodArray,
     SparseArray,
+    StringArray,
     TimedeltaArray,
 )
 
 __all__ = [
+    "BooleanArray",
     "Categorical",
     "DatetimeArray",
     "IntegerArray",
@@ -22,5 +25,6 @@
     "PandasArray",
     "PeriodArray",
     "SparseArray",
+    "StringArray",
     "TimedeltaArray",
 ]
diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index 9c778f68727c6..3547a33ea357b 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -12,8 +12,6 @@
 import sys
 import warnings
 
-PY35 = sys.version_info[:2] == (3, 5)
-PY36 = sys.version_info >= (3, 6)
 PY37 = sys.version_info >= (3, 7)
 PY38 = sys.version_info >= (3, 8)
 PYPY = platform.python_implementation() == "PyPy"
@@ -29,48 +27,82 @@
 
 def set_function_name(f, name, cls):
     """
-    Bind the name/qualname attributes of the function
+    Bind the name/qualname attributes of the function.
     """
     f.__name__ = name
-    f.__qualname__ = "{klass}.{name}".format(klass=cls.__name__, name=name)
+    f.__qualname__ = f"{cls.__name__}.{name}"
     f.__module__ = cls.__module__
     return f
 
 
-def raise_with_traceback(exc, traceback=Ellipsis):
-    """
-    Raise exception with existing traceback.
-    If traceback is not passed, uses sys.exc_info() to get traceback.
+# https://github.com/pandas-dev/pandas/pull/9123
+def is_platform_little_endian() -> bool:
     """
-    if traceback == Ellipsis:
-        _, _, traceback = sys.exc_info()
-    raise exc.with_traceback(traceback)
-
+    Checking if the running platform is little endian.
 
-# https://github.com/pandas-dev/pandas/pull/9123
-def is_platform_little_endian():
-    """ am I little endian """
+    Returns
+    -------
+    bool
+        True if the running platform is little endian.
+    """
     return sys.byteorder == "little"
 
 
-def is_platform_windows():
+def is_platform_windows() -> bool:
+    """
+    Checking if the running platform is windows.
+
+    Returns
+    -------
+    bool
+        True if the running platform is windows.
+    """
     return sys.platform == "win32" or sys.platform == "cygwin"
 
 
-def is_platform_linux():
+def is_platform_linux() -> bool:
+    """
+    Checking if the running platform is linux.
+
+    Returns
+    -------
+    bool
+        True if the running platform is linux.
+    """
     return sys.platform == "linux2"
 
 
-def is_platform_mac():
+def is_platform_mac() -> bool:
+    """
+    Checking if the running platform is mac.
+
+    Returns
+    -------
+    bool
+        True if the running platform is mac.
+    """
     return sys.platform == "darwin"
 
 
-def is_platform_32bit():
+def is_platform_32bit() -> bool:
+    """
+    Checking if the running platform is 32-bit.
+
+    Returns
+    -------
+    bool
+        True if the running platform is 32-bit.
+    """
     return struct.calcsize("P") * 8 < 64
 
 
 def _import_lzma():
-    """Attempts to import lzma, warning the user when lzma is not available.
+    """
+    Importing the `lzma` module.
+
+    Warns
+    -----
+    When the `lzma` module is not available.
     """
     try:
         import lzma
@@ -78,21 +110,30 @@ def _import_lzma():
         return lzma
     except ImportError:
         msg = (
-            "Could not import the lzma module. "
-            "Your installed Python is incomplete. "
+            "Could not import the lzma module. Your installed Python is incomplete. "
             "Attempting to use lzma compression will result in a RuntimeError."
         )
         warnings.warn(msg)
 
 
 def _get_lzma_file(lzma):
-    """Returns the lzma method LZMAFile when the module was correctly imported.
-    Otherwise, raises a RuntimeError.
+    """
+    Importing the `LZMAFile` class from the `lzma` module.
+
+    Returns
+    -------
+    class
+        The `LZMAFile` class from the `lzma` module.
+
+    Raises
+    ------
+    RuntimeError
+        If the `lzma` module was not imported correctly, or didn't exist.
     """
     if lzma is None:
         raise RuntimeError(
             "lzma module not available. "
-            "A Python re-install with the proper "
-            "dependencies might be required to solve this issue."
+            "A Python re-install with the proper dependencies, "
+            "might be required to solve this issue."
         )
     return lzma.LZMAFile
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index cd4e1b7e8aa4d..cd711bcace013 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -8,35 +8,30 @@
 VERSIONS = {
     "bs4": "4.6.0",
     "bottleneck": "1.2.1",
-    "fastparquet": "0.2.1",
+    "fastparquet": "0.3.2",
     "gcsfs": "0.2.2",
     "lxml.etree": "3.8.0",
     "matplotlib": "2.2.2",
     "numexpr": "2.6.2",
     "odfpy": "1.3.0",
-    "openpyxl": "2.4.8",
+    "openpyxl": "2.5.7",
     "pandas_gbq": "0.8.0",
-    "pyarrow": "0.9.0",
+    "pyarrow": "0.13.0",
     "pytables": "3.4.2",
-    "s3fs": "0.0.8",
+    "pytest": "5.0.1",
+    "pyxlsb": "1.0.6",
+    "s3fs": "0.3.0",
     "scipy": "0.19.0",
     "sqlalchemy": "1.1.4",
     "tables": "3.4.2",
+    "tabulate": "0.8.3",
     "xarray": "0.8.2",
     "xlrd": "1.1.0",
     "xlwt": "1.2.0",
     "xlsxwriter": "0.9.8",
+    "numba": "0.46.0",
 }
 
-message = (
-    "Missing optional dependency '{name}'. {extra} "
-    "Use pip or conda to install {name}."
-)
-version_message = (
-    "Pandas requires version '{minimum_version}' or newer of '{name}' "
-    "(version '{actual_version}' currently installed)."
-)
-
 
 def _get_version(module: types.ModuleType) -> str:
     version = getattr(module, "__version__", None)
@@ -45,7 +40,7 @@ def _get_version(module: types.ModuleType) -> str:
         version = getattr(module, "__VERSION__", None)
 
     if version is None:
-        raise ImportError("Can't determine version for {}".format(module.__name__))
+        raise ImportError(f"Can't determine version for {module.__name__}")
     return version
 
 
@@ -86,11 +81,15 @@ def import_optional_dependency(
         is False, or when the package's version is too old and `on_version`
         is ``'warn'``.
     """
+    msg = (
+        f"Missing optional dependency '{name}'. {extra} "
+        f"Use pip or conda to install {name}."
+    )
     try:
         module = importlib.import_module(name)
     except ImportError:
         if raise_on_missing:
-            raise ImportError(message.format(name=name, extra=extra)) from None
+            raise ImportError(msg) from None
         else:
             return None
 
@@ -99,8 +98,9 @@ def import_optional_dependency(
         version = _get_version(module)
         if distutils.version.LooseVersion(version) < minimum_version:
             assert on_version in {"warn", "raise", "ignore"}
-            msg = version_message.format(
-                minimum_version=minimum_version, name=name, actual_version=version
+            msg = (
+                f"Pandas requires version '{minimum_version}' or newer of '{name}' "
+                f"(version '{version}' currently installed)."
             )
             if on_version == "warn":
                 warnings.warn(msg, UserWarning)
diff --git a/pandas/compat/chainmap.py b/pandas/compat/chainmap.py
index 84824207de2a9..588bd24ddf797 100644
--- a/pandas/compat/chainmap.py
+++ b/pandas/compat/chainmap.py
@@ -1,17 +1,33 @@
-from collections import ChainMap
+from typing import ChainMap, MutableMapping, TypeVar, cast
 
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
 
-class DeepChainMap(ChainMap):
-    def __setitem__(self, key, value):
+
+class DeepChainMap(ChainMap[_KT, _VT]):
+    """Variant of ChainMap that allows direct updates to inner scopes.
+
+    Only works when all passed mapping are mutable.
+    """
+
+    def __setitem__(self, key: _KT, value: _VT) -> None:
         for mapping in self.maps:
-            if key in mapping:
-                mapping[key] = value
+            mutable_mapping = cast(MutableMapping[_KT, _VT], mapping)
+            if key in mutable_mapping:
+                mutable_mapping[key] = value
                 return
-        self.maps[0][key] = value
+        cast(MutableMapping[_KT, _VT], self.maps[0])[key] = value
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: _KT) -> None:
+        """
+        Raises
+        ------
+        KeyError
+            If `key` doesn't exist.
+        """
         for mapping in self.maps:
+            mutable_mapping = cast(MutableMapping[_KT, _VT], mapping)
             if key in mapping:
-                del mapping[key]
+                del mutable_mapping[key]
                 return
         raise KeyError(key)
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index ce56c08d3ec14..6c9ac5944e6a1 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -12,16 +12,15 @@
 _np_version_under1p15 = _nlv < LooseVersion("1.15")
 _np_version_under1p16 = _nlv < LooseVersion("1.16")
 _np_version_under1p17 = _nlv < LooseVersion("1.17")
+_np_version_under1p18 = _nlv < LooseVersion("1.18")
 _is_numpy_dev = ".dev" in str(_nlv)
 
 
 if _nlv < "1.13.3":
     raise ImportError(
-        "this version of pandas is incompatible with "
-        "numpy < 1.13.3\n"
-        "your numpy version is {0}.\n"
-        "Please upgrade numpy to >= 1.13.3 to use "
-        "this pandas version".format(_np_version)
+        "this version of pandas is incompatible with numpy < 1.13.3\n"
+        f"your numpy version is {_np_version}.\n"
+        "Please upgrade numpy to >= 1.13.3 to use this pandas version"
     )
 
 
diff --git a/pandas/compat/numpy/function.py b/pandas/compat/numpy/function.py
index c2fe7d1dd12f4..05ecccc67daef 100644
--- a/pandas/compat/numpy/function.py
+++ b/pandas/compat/numpy/function.py
@@ -33,13 +33,26 @@
 
 
 class CompatValidator:
-    def __init__(self, defaults, fname=None, method=None, max_fname_arg_count=None):
+    def __init__(
+        self,
+        defaults,
+        fname=None,
+        method: Optional[str] = None,
+        max_fname_arg_count=None,
+    ):
         self.fname = fname
         self.method = method
         self.defaults = defaults
         self.max_fname_arg_count = max_fname_arg_count
 
-    def __call__(self, args, kwargs, fname=None, max_fname_arg_count=None, method=None):
+    def __call__(
+        self,
+        args,
+        kwargs,
+        fname=None,
+        max_fname_arg_count=None,
+        method: Optional[str] = None,
+    ) -> None:
         if args or kwargs:
             fname = self.fname if fname is None else fname
             max_fname_arg_count = (
@@ -58,9 +71,7 @@ def __call__(self, args, kwargs, fname=None, max_fname_arg_count=None, method=No
                     fname, args, kwargs, max_fname_arg_count, self.defaults
                 )
             else:
-                raise ValueError(
-                    "invalid validation method '{method}'".format(method=method)
-                )
+                raise ValueError(f"invalid validation method '{method}'")
 
 
 ARGMINMAX_DEFAULTS = dict(out=None)
@@ -108,7 +119,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
     return skipna
 
 
-ARGSORT_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[Union[int, str]]]
+ARGSORT_DEFAULTS: "OrderedDict[str, Optional[Union[int, str]]]" = OrderedDict()
 ARGSORT_DEFAULTS["axis"] = -1
 ARGSORT_DEFAULTS["kind"] = "quicksort"
 ARGSORT_DEFAULTS["order"] = None
@@ -124,7 +135,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
 
 # two different signatures of argsort, this second validation
 # for when the `kind` param is supported
-ARGSORT_DEFAULTS_KIND = OrderedDict()  # type: OrderedDict[str, Optional[int]]
+ARGSORT_DEFAULTS_KIND: "OrderedDict[str, Optional[int]]" = OrderedDict()
 ARGSORT_DEFAULTS_KIND["axis"] = -1
 ARGSORT_DEFAULTS_KIND["order"] = None
 validate_argsort_kind = CompatValidator(
@@ -171,14 +182,7 @@ def validate_clip_with_axis(axis, args, kwargs):
     return axis
 
 
-COMPRESS_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Any]
-COMPRESS_DEFAULTS["axis"] = None
-COMPRESS_DEFAULTS["out"] = None
-validate_compress = CompatValidator(
-    COMPRESS_DEFAULTS, fname="compress", method="both", max_fname_arg_count=1
-)
-
-CUM_FUNC_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Any]
+CUM_FUNC_DEFAULTS: "OrderedDict[str, Any]" = OrderedDict()
 CUM_FUNC_DEFAULTS["dtype"] = None
 CUM_FUNC_DEFAULTS["out"] = None
 validate_cum_func = CompatValidator(
@@ -204,7 +208,7 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
     return skipna
 
 
-ALLANY_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[bool]]
+ALLANY_DEFAULTS: "OrderedDict[str, Optional[bool]]" = OrderedDict()
 ALLANY_DEFAULTS["dtype"] = None
 ALLANY_DEFAULTS["out"] = None
 ALLANY_DEFAULTS["keepdims"] = False
@@ -226,28 +230,28 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
     MINMAX_DEFAULTS, fname="max", method="both", max_fname_arg_count=1
 )
 
-RESHAPE_DEFAULTS = dict(order="C")  # type: Dict[str, str]
+RESHAPE_DEFAULTS: Dict[str, str] = dict(order="C")
 validate_reshape = CompatValidator(
     RESHAPE_DEFAULTS, fname="reshape", method="both", max_fname_arg_count=1
 )
 
-REPEAT_DEFAULTS = dict(axis=None)  # type: Dict[str, Any]
+REPEAT_DEFAULTS: Dict[str, Any] = dict(axis=None)
 validate_repeat = CompatValidator(
     REPEAT_DEFAULTS, fname="repeat", method="both", max_fname_arg_count=1
 )
 
-ROUND_DEFAULTS = dict(out=None)  # type: Dict[str, Any]
+ROUND_DEFAULTS: Dict[str, Any] = dict(out=None)
 validate_round = CompatValidator(
     ROUND_DEFAULTS, fname="round", method="both", max_fname_arg_count=1
 )
 
-SORT_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[Union[int, str]]]
+SORT_DEFAULTS: "OrderedDict[str, Optional[Union[int, str]]]" = OrderedDict()
 SORT_DEFAULTS["axis"] = -1
 SORT_DEFAULTS["kind"] = "quicksort"
 SORT_DEFAULTS["order"] = None
 validate_sort = CompatValidator(SORT_DEFAULTS, fname="sort", method="kwargs")
 
-STAT_FUNC_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[Any]]
+STAT_FUNC_DEFAULTS: "OrderedDict[str, Optional[Any]]" = OrderedDict()
 STAT_FUNC_DEFAULTS["dtype"] = None
 STAT_FUNC_DEFAULTS["out"] = None
 
@@ -275,13 +279,13 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
     MEDIAN_DEFAULTS, fname="median", method="both", max_fname_arg_count=1
 )
 
-STAT_DDOF_FUNC_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[bool]]
+STAT_DDOF_FUNC_DEFAULTS: "OrderedDict[str, Optional[bool]]" = OrderedDict()
 STAT_DDOF_FUNC_DEFAULTS["dtype"] = None
 STAT_DDOF_FUNC_DEFAULTS["out"] = None
 STAT_DDOF_FUNC_DEFAULTS["keepdims"] = False
 validate_stat_ddof_func = CompatValidator(STAT_DDOF_FUNC_DEFAULTS, method="kwargs")
 
-TAKE_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[str]]
+TAKE_DEFAULTS: "OrderedDict[str, Optional[str]]" = OrderedDict()
 TAKE_DEFAULTS["out"] = None
 TAKE_DEFAULTS["mode"] = "raise"
 validate_take = CompatValidator(TAKE_DEFAULTS, fname="take", method="kwargs")
@@ -309,12 +313,11 @@ def validate_take_with_convert(convert, args, kwargs):
 )
 
 
-def validate_window_func(name, args, kwargs):
+def validate_window_func(name, args, kwargs) -> None:
     numpy_args = ("axis", "dtype", "out")
     msg = (
-        "numpy operations are not "
-        "valid with window objects. "
-        "Use .{func}() directly instead ".format(func=name)
+        f"numpy operations are not valid with window objects. "
+        f"Use .{name}() directly instead "
     )
 
     if len(args) > 0:
@@ -325,12 +328,11 @@ def validate_window_func(name, args, kwargs):
             raise UnsupportedFunctionCall(msg)
 
 
-def validate_rolling_func(name, args, kwargs):
+def validate_rolling_func(name, args, kwargs) -> None:
     numpy_args = ("axis", "dtype", "out")
     msg = (
-        "numpy operations are not "
-        "valid with window objects. "
-        "Use .rolling(...).{func}() instead ".format(func=name)
+        f"numpy operations are not valid with window objects. "
+        f"Use .rolling(...).{name}() instead "
     )
 
     if len(args) > 0:
@@ -341,12 +343,11 @@ def validate_rolling_func(name, args, kwargs):
             raise UnsupportedFunctionCall(msg)
 
 
-def validate_expanding_func(name, args, kwargs):
+def validate_expanding_func(name, args, kwargs) -> None:
     numpy_args = ("axis", "dtype", "out")
     msg = (
-        "numpy operations are not "
-        "valid with window objects. "
-        "Use .expanding(...).{func}() instead ".format(func=name)
+        f"numpy operations are not valid with window objects. "
+        f"Use .expanding(...).{name}() instead "
     )
 
     if len(args) > 0:
@@ -357,7 +358,7 @@ def validate_expanding_func(name, args, kwargs):
             raise UnsupportedFunctionCall(msg)
 
 
-def validate_groupby_func(name, args, kwargs, allowed=None):
+def validate_groupby_func(name, args, kwargs, allowed=None) -> None:
     """
     'args' and 'kwargs' should be empty, except for allowed
     kwargs because all of
@@ -371,18 +372,15 @@ def validate_groupby_func(name, args, kwargs, allowed=None):
 
     if len(args) + len(kwargs) > 0:
         raise UnsupportedFunctionCall(
-            (
-                "numpy operations are not valid "
-                "with groupby. Use .groupby(...)."
-                "{func}() instead".format(func=name)
-            )
+            "numpy operations are not valid with groupby. "
+            f"Use .groupby(...).{name}() instead"
         )
 
 
 RESAMPLER_NUMPY_OPS = ("min", "max", "sum", "prod", "mean", "std", "var")
 
 
-def validate_resampler_func(method, args, kwargs):
+def validate_resampler_func(method: str, args, kwargs) -> None:
     """
     'args' and 'kwargs' should be empty because all of
     their necessary parameters are explicitly listed in
@@ -391,17 +389,14 @@ def validate_resampler_func(method, args, kwargs):
     if len(args) + len(kwargs) > 0:
         if method in RESAMPLER_NUMPY_OPS:
             raise UnsupportedFunctionCall(
-                (
-                    "numpy operations are not valid "
-                    "with resample. Use .resample(...)."
-                    "{func}() instead".format(func=method)
-                )
+                "numpy operations are not valid with resample. "
+                f"Use .resample(...).{method}() instead"
             )
         else:
             raise TypeError("too many arguments passed in")
 
 
-def validate_minmax_axis(axis):
+def validate_minmax_axis(axis: Optional[int]) -> None:
     """
     Ensure that the axis argument passed to min, max, argmin, or argmax is
     zero or None, as otherwise it will be incorrectly ignored.
@@ -418,7 +413,4 @@ def validate_minmax_axis(axis):
     if axis is None:
         return
     if axis >= ndim or (axis < 0 and ndim + axis < 0):
-        raise ValueError(
-            "`axis` must be fewer than the number of "
-            "dimensions ({ndim})".format(ndim=ndim)
-        )
+        raise ValueError(f"`axis` must be fewer than the number of dimensions ({ndim})")
diff --git a/pandas/compat/pickle_compat.py b/pandas/compat/pickle_compat.py
index 87240a9f986c3..0a1a1376bfc8d 100644
--- a/pandas/compat/pickle_compat.py
+++ b/pandas/compat/pickle_compat.py
@@ -4,10 +4,14 @@
 
 import copy
 import pickle as pkl
-import sys
+from typing import TYPE_CHECKING, Optional
+import warnings
 
 from pandas import Index
 
+if TYPE_CHECKING:
+    from pandas import Series, DataFrame
+
 
 def load_reduce(self):
     stack = self.stack
@@ -20,14 +24,14 @@ def load_reduce(self):
     try:
         stack[-1] = func(*args)
         return
-    except Exception as e:
+    except TypeError as err:
 
         # If we have a deprecated function,
         # try to replace and try again.
 
         msg = "_reconstruct: First argument must be a sub-type of ndarray"
 
-        if msg in str(e):
+        if msg in str(err):
             try:
                 cls = args[0]
                 stack[-1] = object.__new__(cls)
@@ -35,44 +39,58 @@ def load_reduce(self):
             except TypeError:
                 pass
 
-        # try to re-encode the arguments
-        if getattr(self, "encoding", None) is not None:
-            args = tuple(
-                arg.encode(self.encoding) if isinstance(arg, str) else arg
-                for arg in args
-            )
-            try:
-                stack[-1] = func(*args)
-                return
-            except TypeError:
-                pass
-
-        # unknown exception, re-raise
-        if getattr(self, "is_verbose", None):
-            print(sys.exc_info())
-            print(func, args)
         raise
 
 
+_sparse_msg = """\
+
+Loading a saved '{cls}' as a {new} with sparse values.
+'{cls}' is now removed. You should re-save this dataset in its new format.
+"""
+
+
+class _LoadSparseSeries:
+    # To load a SparseSeries as a Series[Sparse]
+
+    # https://github.com/python/mypy/issues/1020
+    # error: Incompatible return type for "__new__" (returns "Series", but must return
+    # a subtype of "_LoadSparseSeries")
+    def __new__(cls) -> "Series":  # type: ignore
+        from pandas import Series
+
+        warnings.warn(
+            _sparse_msg.format(cls="SparseSeries", new="Series"),
+            FutureWarning,
+            stacklevel=6,
+        )
+
+        return Series(dtype=object)
+
+
+class _LoadSparseFrame:
+    # To load a SparseDataFrame as a DataFrame[Sparse]
+
+    # https://github.com/python/mypy/issues/1020
+    # error: Incompatible return type for "__new__" (returns "DataFrame", but must
+    # return a subtype of "_LoadSparseFrame")
+    def __new__(cls) -> "DataFrame":  # type: ignore
+        from pandas import DataFrame
+
+        warnings.warn(
+            _sparse_msg.format(cls="SparseDataFrame", new="DataFrame"),
+            FutureWarning,
+            stacklevel=6,
+        )
+
+        return DataFrame()
+
+
 # If classes are moved, provide compat here.
 _class_locations_map = {
     ("pandas.core.sparse.array", "SparseArray"): ("pandas.core.arrays", "SparseArray"),
     # 15477
-    #
-    # TODO: When FrozenNDArray is removed, add
-    # the following lines for compat:
-    #
-    # ('pandas.core.base', 'FrozenNDArray'):
-    #     ('numpy', 'ndarray'),
-    # ('pandas.core.indexes.frozen', 'FrozenNDArray'):
-    #     ('numpy', 'ndarray'),
-    #
-    # Afterwards, remove the current entry
-    # for `pandas.core.base.FrozenNDArray`.
-    ("pandas.core.base", "FrozenNDArray"): (
-        "pandas.core.indexes.frozen",
-        "FrozenNDArray",
-    ),
+    ("pandas.core.base", "FrozenNDArray"): ("numpy", "ndarray"),
+    ("pandas.core.indexes.frozen", "FrozenNDArray"): ("numpy", "ndarray"),
     ("pandas.core.base", "FrozenList"): ("pandas.core.indexes.frozen", "FrozenList"),
     # 10890
     ("pandas.core.series", "TimeSeries"): ("pandas.core.series", "Series"),
@@ -101,12 +119,12 @@ def load_reduce(self):
         "SparseArray",
     ),
     ("pandas.sparse.series", "SparseSeries"): (
-        "pandas.core.sparse.series",
-        "SparseSeries",
+        "pandas.compat.pickle_compat",
+        "_LoadSparseSeries",
     ),
     ("pandas.sparse.frame", "SparseDataFrame"): (
         "pandas.core.sparse.frame",
-        "SparseDataFrame",
+        "_LoadSparseFrame",
     ),
     ("pandas.indexes.base", "_new_Index"): ("pandas.core.indexes.base", "_new_Index"),
     ("pandas.indexes.base", "Index"): ("pandas.core.indexes.base", "Index"),
@@ -139,13 +157,21 @@ def load_reduce(self):
         "pandas.core.indexes.numeric",
         "Float64Index",
     ),
+    ("pandas.core.sparse.series", "SparseSeries"): (
+        "pandas.compat.pickle_compat",
+        "_LoadSparseSeries",
+    ),
+    ("pandas.core.sparse.frame", "SparseDataFrame"): (
+        "pandas.compat.pickle_compat",
+        "_LoadSparseFrame",
+    ),
 }
 
 
 # our Unpickler sub-class to override methods and some dispatcher
-# functions for compat
-
+# functions for compat and uses a non-public class of the pickle module.
 
+# error: Name 'pkl._Unpickler' is not defined
 class Unpickler(pkl._Unpickler):  # type: ignore
     def find_class(self, module, name):
         # override superclass
@@ -193,8 +219,9 @@ def load_newobj_ex(self):
     pass
 
 
-def load(fh, encoding=None, is_verbose=False):
-    """load a pickle, with a provided encoding
+def load(fh, encoding: Optional[str] = None, is_verbose: bool = False):
+    """
+    Load a pickle, with a provided encoding,
 
     Parameters
     ----------
diff --git a/pandas/conftest.py b/pandas/conftest.py
index b032e14d8f7e1..7463b2b579c0c 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1,3 +1,4 @@
+from collections import abc
 from datetime import date, time, timedelta, timezone
 from decimal import Decimal
 import operator
@@ -14,8 +15,8 @@
 
 import pandas as pd
 from pandas import DataFrame
+import pandas._testing as tm
 from pandas.core import ops
-import pandas.util.testing as tm
 
 hypothesis.settings.register_profile(
     "ci",
@@ -64,46 +65,49 @@ def pytest_runtest_setup(item):
         pytest.skip("skipping high memory test since --run-high-memory was not set")
 
 
-# Configurations for all tests and all test modules
-
-
 @pytest.fixture(autouse=True)
 def configure_tests():
+    """
+    Configure settings for all tests and test modules.
+    """
     pd.set_option("chained_assignment", "raise")
 
 
-# For running doctests: make np and pd names available
-
-
 @pytest.fixture(autouse=True)
 def add_imports(doctest_namespace):
+    """
+    Make `np` and `pd` names available for doctests.
+    """
     doctest_namespace["np"] = np
     doctest_namespace["pd"] = pd
 
 
 @pytest.fixture(params=["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
 def spmatrix(request):
+    """
+    Yields scipy sparse matrix classes.
+    """
     from scipy import sparse
 
     return getattr(sparse, request.param + "_matrix")
 
 
-@pytest.fixture(params=[0, 1, "index", "columns"], ids=lambda x: "axis {!r}".format(x))
+@pytest.fixture(params=[0, 1, "index", "columns"], ids=lambda x: f"axis {repr(x)}")
 def axis(request):
     """
-     Fixture for returning the axis numbers of a DataFrame.
-     """
+    Fixture for returning the axis numbers of a DataFrame.
+    """
     return request.param
 
 
 axis_frame = axis
 
 
-@pytest.fixture(params=[0, "index"], ids=lambda x: "axis {!r}".format(x))
+@pytest.fixture(params=[0, "index"], ids=lambda x: f"axis {repr(x)}")
 def axis_series(request):
     """
-     Fixture for returning the axis numbers of a Series.
-     """
+    Fixture for returning the axis numbers of a Series.
+    """
     return request.param
 
 
@@ -163,7 +167,7 @@ def ordered_fixture(request):
 @pytest.fixture(params=_all_arithmetic_operators)
 def all_arithmetic_operators(request):
     """
-    Fixture for dunder names for common arithmetic operations
+    Fixture for dunder names for common arithmetic operations.
     """
     return request.param
 
@@ -190,7 +194,9 @@ def all_arithmetic_functions(request):
     """
     Fixture for operator and roperator arithmetic functions.
 
-    Note: This includes divmod and rdivmod, whereas all_arithmetic_operators
+    Notes
+    -----
+    This includes divmod and rdivmod, whereas all_arithmetic_operators
     does not.
     """
     return request.param
@@ -213,7 +219,7 @@ def all_arithmetic_functions(request):
 @pytest.fixture(params=_all_numeric_reductions)
 def all_numeric_reductions(request):
     """
-    Fixture for numeric reduction names
+    Fixture for numeric reduction names.
     """
     return request.param
 
@@ -224,7 +230,7 @@ def all_numeric_reductions(request):
 @pytest.fixture(params=_all_boolean_reductions)
 def all_boolean_reductions(request):
     """
-    Fixture for boolean reduction names
+    Fixture for boolean reduction names.
     """
     return request.param
 
@@ -234,6 +240,10 @@ def all_boolean_reductions(request):
 
 @pytest.fixture(params=list(_cython_table))
 def cython_table_items(request):
+    """
+    Yields a tuple of a function and its corresponding name. Correspond to
+    the list of aggregator "Cython functions" used on selected table items.
+    """
     return request.param
 
 
@@ -251,7 +261,7 @@ def _get_cython_table_params(ndframe, func_names_and_expected):
 
     Returns
     -------
-    results : list
+    list
         List of three items (DataFrame, function, expected result)
     """
     results = []
@@ -293,10 +303,24 @@ def compare_operators_no_eq_ne(request):
     return request.param
 
 
+@pytest.fixture(
+    params=["__and__", "__rand__", "__or__", "__ror__", "__xor__", "__rxor__"]
+)
+def all_logical_operators(request):
+    """
+    Fixture for dunder names for common logical operations
+
+    * |
+    * &
+    * ^
+    """
+    return request.param
+
+
 @pytest.fixture(params=[None, "gzip", "bz2", "zip", "xz"])
 def compression(request):
     """
-    Fixture for trying common compression types in compression tests
+    Fixture for trying common compression types in compression tests.
     """
     return request.param
 
@@ -305,7 +329,7 @@ def compression(request):
 def compression_only(request):
     """
     Fixture for trying common compression types in compression tests excluding
-    uncompressed case
+    uncompressed case.
     """
     return request.param
 
@@ -313,20 +337,23 @@ def compression_only(request):
 @pytest.fixture(params=[True, False])
 def writable(request):
     """
-    Fixture that an array is writable
+    Fixture that an array is writable.
     """
     return request.param
 
 
 @pytest.fixture(scope="module")
 def datetime_tz_utc():
+    """
+    Yields the UTC timezone object from the datetime module.
+    """
     return timezone.utc
 
 
 @pytest.fixture(params=["utc", "dateutil/UTC", utc, tzutc(), timezone.utc])
 def utc_fixture(request):
     """
-    Fixture to provide variants of UTC timezone strings and tzinfo objects
+    Fixture to provide variants of UTC timezone strings and tzinfo objects.
     """
     return request.param
 
@@ -334,13 +361,16 @@ def utc_fixture(request):
 @pytest.fixture(params=["inner", "outer", "left", "right"])
 def join_type(request):
     """
-    Fixture for trying all types of join operations
+    Fixture for trying all types of join operations.
     """
     return request.param
 
 
 @pytest.fixture
 def strict_data_files(pytestconfig):
+    """
+    Returns the configuration for the test setting `--strict-data-files`.
+    """
     return pytestconfig.getoption("--strict-data-files")
 
 
@@ -356,7 +386,7 @@ def datapath(strict_data_files):
 
     Returns
     -------
-    path : path including ``pandas/tests``.
+    path including ``pandas/tests``.
 
     Raises
     ------
@@ -369,11 +399,11 @@ def deco(*args):
         path = os.path.join(BASE_PATH, *args)
         if not os.path.exists(path):
             if strict_data_files:
-                msg = "Could not find file {} and --strict-data-files is set."
-                raise ValueError(msg.format(path))
+                raise ValueError(
+                    f"Could not find file {path} and --strict-data-files is set."
+                )
             else:
-                msg = "Could not find {}."
-                pytest.skip(msg.format(path))
+                pytest.skip(f"Could not find {path}.")
         return path
 
     return deco
@@ -390,7 +420,7 @@ def iris(datapath):
 @pytest.fixture(params=["nlargest", "nsmallest"])
 def nselect_method(request):
     """
-    Fixture for trying all nselect methods
+    Fixture for trying all nselect methods.
     """
     return request.param
 
@@ -398,7 +428,7 @@ def nselect_method(request):
 @pytest.fixture(params=["left", "right", "both", "neither"])
 def closed(request):
     """
-    Fixture for trying all interval closed parameters
+    Fixture for trying all interval closed parameters.
     """
     return request.param
 
@@ -406,7 +436,7 @@ def closed(request):
 @pytest.fixture(params=["left", "right", "both", "neither"])
 def other_closed(request):
     """
-    Secondary closed fixture to allow parametrizing over all pairs of closed
+    Secondary closed fixture to allow parametrizing over all pairs of closed.
     """
     return request.param
 
@@ -414,7 +444,7 @@ def other_closed(request):
 @pytest.fixture(params=[None, np.nan, pd.NaT, float("nan"), np.float("NaN")])
 def nulls_fixture(request):
     """
-    Fixture for each null type in pandas
+    Fixture for each null type in pandas.
     """
     return request.param
 
@@ -425,7 +455,7 @@ def nulls_fixture(request):
 @pytest.fixture(params=[None, np.nan, pd.NaT])
 def unique_nulls_fixture(request):
     """
-    Fixture for each null type in pandas, each null type exactly once
+    Fixture for each null type in pandas, each null type exactly once.
     """
     return request.param
 
@@ -575,7 +605,6 @@ def float_dtype(request):
     * 'float32'
     * 'float64'
     """
-
     return request.param
 
 
@@ -588,7 +617,6 @@ def complex_dtype(request):
     * 'complex64'
     * 'complex128'
     """
-
     return request.param
 
 
@@ -603,7 +631,6 @@ def sint_dtype(request):
     * 'int32'
     * 'int64'
     """
-
     return request.param
 
 
@@ -617,7 +644,6 @@ def uint_dtype(request):
     * 'uint32'
     * 'uint64'
     """
-
     return request.param
 
 
@@ -636,6 +662,23 @@ def any_int_dtype(request):
     * 'int64'
     * 'uint64'
     """
+    return request.param
+
+
+@pytest.fixture(params=ALL_EA_INT_DTYPES)
+def any_nullable_int_dtype(request):
+    """
+    Parameterized fixture for any nullable integer dtype.
+
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    """
 
     return request.param
 
@@ -658,7 +701,6 @@ def any_real_dtype(request):
     * 'float32'
     * 'float64'
     """
-
     return request.param
 
 
@@ -696,7 +738,6 @@ def any_numpy_dtype(request):
     * object
     * 'object'
     """
-
     return request.param
 
 
@@ -827,6 +868,16 @@ def tick_classes(request):
     )
 
 
+@pytest.fixture
+def datetime_series():
+    """
+    Fixture for Series of floats with DatetimeIndex
+    """
+    s = tm.makeTimeSeries()
+    s.name = "ts"
+    return s
+
+
 @pytest.fixture
 def float_frame():
     """
@@ -854,3 +905,51 @@ def float_frame():
     [30 rows x 4 columns]
     """
     return DataFrame(tm.getSeriesData())
+
+
+@pytest.fixture(params=[pd.Index, pd.Series], ids=["index", "series"])
+def index_or_series(request):
+    """
+    Fixture to parametrize over Index and Series, made necessary by a mypy
+    bug, giving an error:
+
+    List item 0 has incompatible type "Type[Series]"; expected "Type[PandasObject]"
+
+    See GH#29725
+    """
+    return request.param
+
+
+@pytest.fixture
+def dict_subclass():
+    """
+    Fixture for a dictionary subclass.
+    """
+
+    class TestSubDict(dict):
+        def __init__(self, *args, **kwargs):
+            dict.__init__(self, *args, **kwargs)
+
+    return TestSubDict
+
+
+@pytest.fixture
+def non_mapping_dict_subclass():
+    """
+    Fixture for a non-mapping dictionary subclass.
+    """
+
+    class TestNonDictMapping(abc.Mapping):
+        def __init__(self, underlying_dict):
+            self._data = underlying_dict
+
+        def __getitem__(self, key):
+            return self._data.__getitem__(key)
+
+        def __iter__(self):
+            return self._data.__iter__()
+
+        def __len__(self):
+            return self._data.__len__()
+
+    return TestNonDictMapping
diff --git a/pandas/core/accessor.py b/pandas/core/accessor.py
index 2d4ded9e2e6ba..a04e9c3e68310 100644
--- a/pandas/core/accessor.py
+++ b/pandas/core/accessor.py
@@ -4,17 +4,15 @@
 that can be mixed into or pinned onto other pandas classes.
 
 """
-from typing import Set
+from typing import FrozenSet, Set
 import warnings
 
 from pandas.util._decorators import Appender
 
 
 class DirNamesMixin:
-    _accessors = set()  # type: Set[str]
-    _deprecations = frozenset(
-        ["asobject", "base", "data", "flags", "itemsize", "strides"]
-    )
+    _accessors: Set[str] = set()
+    _deprecations: FrozenSet[str] = frozenset()
 
     def _dir_deletions(self):
         """
@@ -37,7 +35,10 @@ def _dir_additions(self):
 
     def __dir__(self):
         """
-        Provide method name lookup and completion
+        Provide method name lookup and completion.
+
+        Notes
+        -----
         Only provide 'public' methods.
         """
         rv = set(dir(type(self)))
@@ -47,31 +48,36 @@ def __dir__(self):
 
 class PandasDelegate:
     """
-    An abstract base class for delegating methods/properties.
+    Abstract base class for delegating methods/properties.
     """
 
     def _delegate_property_get(self, name, *args, **kwargs):
-        raise TypeError("You cannot access the property {name}".format(name=name))
+        raise TypeError(f"You cannot access the property {name}")
 
     def _delegate_property_set(self, name, value, *args, **kwargs):
-        raise TypeError("The property {name} cannot be set".format(name=name))
+        raise TypeError(f"The property {name} cannot be set")
 
     def _delegate_method(self, name, *args, **kwargs):
-        raise TypeError("You cannot call method {name}".format(name=name))
+        raise TypeError(f"You cannot call method {name}")
 
     @classmethod
-    def _add_delegate_accessors(cls, delegate, accessors, typ, overwrite=False):
+    def _add_delegate_accessors(
+        cls, delegate, accessors, typ: str, overwrite: bool = False
+    ):
         """
         Add accessors to cls from the delegate class.
 
         Parameters
         ----------
-        cls : the class to add the methods/properties to
-        delegate : the class to get methods/properties & doc-strings
-        accessors : string list of accessors to add
-        typ : 'property' or 'method'
-        overwrite : boolean, default False
-           overwrite the method/property in the target class if it exists.
+        cls
+            Class to add the methods/properties to.
+        delegate
+            Class to get methods/properties and doc-strings.
+        accessors : list of str
+            List of accessors to add.
+        typ : {'property', 'method'}
+        overwrite : bool, default False
+            Overwrite the method/property in the target class if it exists.
         """
 
         def _create_delegator_property(name):
@@ -109,7 +115,7 @@ def f(self, *args, **kwargs):
                 setattr(cls, name, f)
 
 
-def delegate_names(delegate, accessors, typ, overwrite=False):
+def delegate_names(delegate, accessors, typ: str, overwrite: bool = False):
     """
     Add delegated names to a class using a class decorator.  This provides
     an alternative usage to directly calling `_add_delegate_accessors`
@@ -118,12 +124,12 @@ def delegate_names(delegate, accessors, typ, overwrite=False):
     Parameters
     ----------
     delegate : object
-        the class to get methods/properties & doc-strings
+        The class to get methods/properties & doc-strings.
     accessors : Sequence[str]
-        List of accessor to add
+        List of accessor to add.
     typ : {'property', 'method'}
-    overwrite : boolean, default False
-       overwrite the method/property in the target class if it exists
+    overwrite : bool, default False
+       Overwrite the method/property in the target class if it exists.
 
     Returns
     -------
@@ -152,19 +158,25 @@ def add_delegate_accessors(cls):
 
 class CachedAccessor:
     """
-    Custom property-like object (descriptor) for caching accessors.
+    Custom property-like object.
+
+    A descriptor for caching accessors.
 
     Parameters
     ----------
     name : str
-        The namespace this will be accessed under, e.g. ``df.foo``
+        Namespace that will be accessed under, e.g. ``df.foo``.
     accessor : cls
-        The class with the extension methods. The class' __init__ method
-        should expect one of a ``Series``, ``DataFrame`` or ``Index`` as
-        the single argument ``data``
+        Class with the extension methods.
+
+    Notes
+    -----
+    For accessor, The class's __init__ method assumes that one of
+    ``Series``, ``DataFrame`` or ``Index`` as the
+    single argument ``data``.
     """
 
-    def __init__(self, name, accessor):
+    def __init__(self, name: str, accessor) -> None:
         self._name = name
         self._accessor = accessor
 
@@ -174,7 +186,7 @@ def __get__(self, obj, cls):
             return self._accessor
         accessor_obj = self._accessor(obj)
         # Replace the property with the accessor object. Inspired by:
-        # http://www.pydanny.com/cached-property.html
+        # https://www.pydanny.com/cached-property.html
         # We need to use object.__setattr__ because we overwrite __setattr__ on
         # NDFrame
         object.__setattr__(obj, self._name, accessor_obj)
@@ -185,9 +197,9 @@ def _register_accessor(name, cls):
     def decorator(accessor):
         if hasattr(cls, name):
             warnings.warn(
-                "registration of accessor {!r} under name {!r} for type "
-                "{!r} is overriding a preexisting attribute with the same "
-                "name.".format(accessor, name, cls),
+                f"registration of accessor {repr(accessor)} under name "
+                f"{repr(name)} for type {repr(cls)} is overriding a preexisting"
+                f"attribute with the same name.",
                 UserWarning,
                 stacklevel=2,
             )
diff --git a/pandas/core/aggregation.py b/pandas/core/aggregation.py
new file mode 100644
index 0000000000000..79b87f146b9a7
--- /dev/null
+++ b/pandas/core/aggregation.py
@@ -0,0 +1,198 @@
+"""
+aggregation.py contains utility functions to handle multiple named and lambda
+kwarg aggregations in groupby and DataFrame/Series aggregation
+"""
+
+from collections import defaultdict
+from functools import partial
+from typing import Any, DefaultDict, List, Sequence, Tuple
+
+from pandas.core.dtypes.common import is_dict_like, is_list_like
+
+import pandas.core.common as com
+from pandas.core.indexes.api import Index
+
+
+def is_multi_agg_with_relabel(**kwargs) -> bool:
+    """
+    Check whether kwargs passed to .agg look like multi-agg with relabeling.
+
+    Parameters
+    ----------
+    **kwargs : dict
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_multi_agg_with_relabel(a='max')
+    False
+    >>> is_multi_agg_with_relabel(a_max=('a', 'max'),
+    ...                            a_min=('a', 'min'))
+    True
+    >>> is_multi_agg_with_relabel()
+    False
+    """
+    return all(isinstance(v, tuple) and len(v) == 2 for v in kwargs.values()) and (
+        len(kwargs) > 0
+    )
+
+
+def normalize_keyword_aggregation(kwargs: dict) -> Tuple[dict, List[str], List[int]]:
+    """
+    Normalize user-provided "named aggregation" kwargs.
+    Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
+    to the old Dict[str, List[scalar]]].
+
+    Parameters
+    ----------
+    kwargs : dict
+
+    Returns
+    -------
+    aggspec : dict
+        The transformed kwargs.
+    columns : List[str]
+        The user-provided keys.
+    col_idx_order : List[int]
+        List of columns indices.
+
+    Examples
+    --------
+    >>> normalize_keyword_aggregation({'output': ('input', 'sum')})
+    ({'input': ['sum']}, ('output',), [('input', 'sum')])
+    """
+    # Normalize the aggregation functions as Mapping[column, List[func]],
+    # process normally, then fixup the names.
+    # TODO: aggspec type: typing.Dict[str, List[AggScalar]]
+    # May be hitting https://github.com/python/mypy/issues/5958
+    # saying it doesn't have an attribute __name__
+    aggspec: DefaultDict = defaultdict(list)
+    order = []
+    columns, pairs = list(zip(*kwargs.items()))
+
+    for name, (column, aggfunc) in zip(columns, pairs):
+        aggspec[column].append(aggfunc)
+        order.append((column, com.get_callable_name(aggfunc) or aggfunc))
+
+    # uniquify aggfunc name if duplicated in order list
+    uniquified_order = _make_unique_kwarg_list(order)
+
+    # GH 25719, due to aggspec will change the order of assigned columns in aggregation
+    # uniquified_aggspec will store uniquified order list and will compare it with order
+    # based on index
+    aggspec_order = [
+        (column, com.get_callable_name(aggfunc) or aggfunc)
+        for column, aggfuncs in aggspec.items()
+        for aggfunc in aggfuncs
+    ]
+    uniquified_aggspec = _make_unique_kwarg_list(aggspec_order)
+
+    # get the new indice of columns by comparison
+    col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
+    return aggspec, columns, col_idx_order
+
+
+def _make_unique_kwarg_list(
+    seq: Sequence[Tuple[Any, Any]]
+) -> Sequence[Tuple[Any, Any]]:
+    """Uniquify aggfunc name of the pairs in the order list
+
+    Examples:
+    --------
+    >>> kwarg_list = [('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')]
+    >>> _make_unique_kwarg_list(kwarg_list)
+    [('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
+    """
+    return [
+        (pair[0], "_".join([pair[1], str(seq[:i].count(pair))]))
+        if seq.count(pair) > 1
+        else pair
+        for i, pair in enumerate(seq)
+    ]
+
+
+# TODO: Can't use, because mypy doesn't like us setting __name__
+#   error: "partial[Any]" has no attribute "__name__"
+# the type is:
+#   typing.Sequence[Callable[..., ScalarResult]]
+#     -> typing.Sequence[Callable[..., ScalarResult]]:
+
+
+def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
+    """
+    Possibly mangle a list of aggfuncs.
+
+    Parameters
+    ----------
+    aggfuncs : Sequence
+
+    Returns
+    -------
+    mangled: list-like
+        A new AggSpec sequence, where lambdas have been converted
+        to have unique names.
+
+    Notes
+    -----
+    If just one aggfunc is passed, the name will not be mangled.
+    """
+    if len(aggfuncs) <= 1:
+        # don't mangle for .agg([lambda x: .])
+        return aggfuncs
+    i = 0
+    mangled_aggfuncs = []
+    for aggfunc in aggfuncs:
+        if com.get_callable_name(aggfunc) == "<lambda>":
+            aggfunc = partial(aggfunc)
+            aggfunc.__name__ = f"<lambda_{i}>"
+            i += 1
+        mangled_aggfuncs.append(aggfunc)
+
+    return mangled_aggfuncs
+
+
+def maybe_mangle_lambdas(agg_spec: Any) -> Any:
+    """
+    Make new lambdas with unique names.
+
+    Parameters
+    ----------
+    agg_spec : Any
+        An argument to GroupBy.agg.
+        Non-dict-like `agg_spec` are pass through as is.
+        For dict-like `agg_spec` a new spec is returned
+        with name-mangled lambdas.
+
+    Returns
+    -------
+    mangled : Any
+        Same type as the input.
+
+    Examples
+    --------
+    >>> maybe_mangle_lambdas('sum')
+    'sum'
+    >>> maybe_mangle_lambdas([lambda: 1, lambda: 2])  # doctest: +SKIP
+    [<function __main__.<lambda_0>,
+     <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
+    """
+    is_dict = is_dict_like(agg_spec)
+    if not (is_dict or is_list_like(agg_spec)):
+        return agg_spec
+    mangled_aggspec = type(agg_spec)()  # dict or OrderdDict
+
+    if is_dict:
+        for key, aggfuncs in agg_spec.items():
+            if is_list_like(aggfuncs) and not is_dict_like(aggfuncs):
+                mangled_aggfuncs = _managle_lambda_list(aggfuncs)
+            else:
+                mangled_aggfuncs = aggfuncs
+
+            mangled_aggspec[key] = mangled_aggfuncs
+    else:
+        mangled_aggspec = _managle_lambda_list(agg_spec)
+
+    return mangled_aggspec
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index c0ed198e200f1..886b0a3c5fec1 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -2,18 +2,20 @@
 Generic data algorithms. This module is experimental at the moment and not
 intended for public consumption
 """
+import operator
 from textwrap import dedent
-from typing import Dict
+from typing import TYPE_CHECKING, Dict, Optional, Tuple, Union
 from warnings import catch_warnings, simplefilter, warn
 
 import numpy as np
 
-from pandas._libs import algos, hashtable as htable, lib
+from pandas._libs import Timestamp, algos, hashtable as htable, lib
 from pandas._libs.tslib import iNaT
-from pandas.util._decorators import Appender, Substitution, deprecate_kwarg
+from pandas.util._decorators import Appender, Substitution
 
 from pandas.core.dtypes.cast import (
     construct_1d_object_array_from_listlike,
+    infer_dtype_from_array,
     maybe_promote,
 )
 from pandas.core.dtypes.common import (
@@ -27,8 +29,8 @@
     is_categorical_dtype,
     is_complex_dtype,
     is_datetime64_any_dtype,
+    is_datetime64_dtype,
     is_datetime64_ns_dtype,
-    is_datetimelike,
     is_extension_array_dtype,
     is_float_dtype,
     is_integer,
@@ -39,7 +41,6 @@
     is_period_dtype,
     is_scalar,
     is_signed_integer_dtype,
-    is_sparse,
     is_timedelta64_dtype,
     is_unsigned_integer_dtype,
     needs_i8_conversion,
@@ -47,11 +48,14 @@
 from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.missing import isna, na_value_for_dtype
 
-from pandas.core import common as com
-from pandas.core.construction import array
+import pandas.core.common as com
+from pandas.core.construction import array, extract_array
 from pandas.core.indexers import validate_indices
 
-_shared_docs = {}  # type: Dict[str, str]
+if TYPE_CHECKING:
+    from pandas import Series
+
+_shared_docs: Dict[str, str] = {}
 
 
 # --------------- #
@@ -78,26 +82,27 @@ def _ensure_data(values, dtype=None):
 
     Returns
     -------
-    (ndarray, pandas_dtype, algo dtype as a string)
-
+    values : ndarray
+    pandas_dtype : str or dtype
     """
 
     # we check some simple dtypes first
+    if is_object_dtype(dtype):
+        return ensure_object(np.asarray(values)), "object"
+    elif is_object_dtype(values) and dtype is None:
+        return ensure_object(np.asarray(values)), "object"
+
     try:
-        if is_object_dtype(dtype):
-            return ensure_object(np.asarray(values)), "object", "object"
         if is_bool_dtype(values) or is_bool_dtype(dtype):
             # we are actually coercing to uint64
             # until our algos support uint8 directly (see TODO)
-            return np.asarray(values).astype("uint64"), "bool", "uint64"
+            return np.asarray(values).astype("uint64"), "bool"
         elif is_signed_integer_dtype(values) or is_signed_integer_dtype(dtype):
-            return ensure_int64(values), "int64", "int64"
+            return ensure_int64(values), "int64"
         elif is_unsigned_integer_dtype(values) or is_unsigned_integer_dtype(dtype):
-            return ensure_uint64(values), "uint64", "uint64"
+            return ensure_uint64(values), "uint64"
         elif is_float_dtype(values) or is_float_dtype(dtype):
-            return ensure_float64(values), "float64", "float64"
-        elif is_object_dtype(values) and dtype is None:
-            return ensure_object(np.asarray(values)), "object", "object"
+            return ensure_float64(values), "float64"
         elif is_complex_dtype(values) or is_complex_dtype(dtype):
 
             # ignore the fact that we are casting to float
@@ -105,12 +110,12 @@ def _ensure_data(values, dtype=None):
             with catch_warnings():
                 simplefilter("ignore", np.ComplexWarning)
                 values = ensure_float64(values)
-            return values, "float64", "float64"
+            return values, "float64"
 
     except (TypeError, ValueError, OverflowError):
         # if we are trying to coerce to a dtype
-        # and it is incompat this will fall thru to here
-        return ensure_object(values), "object", "object"
+        # and it is incompat this will fall through to here
+        return ensure_object(values), "object"
 
     # datetimelike
     if (
@@ -136,14 +141,14 @@ def _ensure_data(values, dtype=None):
                 # Note: this is reached by DataFrame.rank calls GH#27027
                 asi8 = values.view("i8")
                 dtype = values.dtype
-                return asi8, dtype, "int64"
+                return asi8, dtype
 
             from pandas import DatetimeIndex
 
             values = DatetimeIndex(values)
             dtype = values.dtype
 
-        return values.asi8, dtype, "int64"
+        return values.asi8, dtype
 
     elif is_categorical_dtype(values) and (
         is_categorical_dtype(dtype) or dtype is None
@@ -156,11 +161,11 @@ def _ensure_data(values, dtype=None):
         # until our algos support int* directly (not all do)
         values = ensure_int64(values)
 
-        return values, dtype, "int64"
+        return values, dtype
 
     # we have failed, return object
     values = np.asarray(values, dtype=np.object)
-    return ensure_object(values), "object", "object"
+    return ensure_object(values), "object"
 
 
 def _reconstruct_data(values, dtype, original):
@@ -177,18 +182,22 @@ def _reconstruct_data(values, dtype, original):
     -------
     Index for extension types, otherwise ndarray casted to dtype
     """
-    from pandas import Index
 
     if is_extension_array_dtype(dtype):
         values = dtype.construct_array_type()._from_sequence(values)
     elif is_bool_dtype(dtype):
-        values = values.astype(dtype)
+        values = values.astype(dtype, copy=False)
 
         # we only support object dtypes bool Index
-        if isinstance(original, Index):
-            values = values.astype(object)
+        if isinstance(original, ABCIndexClass):
+            values = values.astype(object, copy=False)
     elif dtype is not None:
-        values = values.astype(dtype)
+        if is_datetime64_dtype(dtype):
+            dtype = "datetime64[ns]"
+        elif is_timedelta64_dtype(dtype):
+            dtype = "timedelta64[ns]"
+
+        values = values.astype(dtype, copy=False)
 
     return values
 
@@ -199,7 +208,7 @@ def _ensure_arraylike(values):
     """
     if not is_array_like(values):
         inferred = lib.infer_dtype(values, skipna=False)
-        if inferred in ["mixed", "string", "unicode"]:
+        if inferred in ["mixed", "string"]:
             if isinstance(values, tuple):
                 values = list(values)
             values = construct_1d_object_array_from_listlike(values)
@@ -209,11 +218,11 @@ def _ensure_arraylike(values):
 
 
 _hashtables = {
-    "float64": (htable.Float64HashTable, htable.Float64Vector),
-    "uint64": (htable.UInt64HashTable, htable.UInt64Vector),
-    "int64": (htable.Int64HashTable, htable.Int64Vector),
-    "string": (htable.StringHashTable, htable.ObjectVector),
-    "object": (htable.PyObjectHashTable, htable.ObjectVector),
+    "float64": htable.Float64HashTable,
+    "uint64": htable.UInt64HashTable,
+    "int64": htable.Int64HashTable,
+    "string": htable.StringHashTable,
+    "object": htable.PyObjectHashTable,
 }
 
 
@@ -225,89 +234,60 @@ def _get_hashtable_algo(values):
 
     Returns
     -------
-    tuples(hashtable class,
-           vector class,
-           values,
-           dtype,
-           ndtype)
+    htable : HashTable subclass
+    values : ndarray
     """
-    values, dtype, ndtype = _ensure_data(values)
+    values, _ = _ensure_data(values)
 
-    if ndtype == "object":
+    ndtype = _check_object_for_strings(values)
+    htable = _hashtables[ndtype]
+    return htable, values
 
-        # it's cheaper to use a String Hash Table than Object; we infer
-        # including nulls because that is the only difference between
-        # StringHashTable and ObjectHashtable
-        if lib.infer_dtype(values, skipna=False) in ["string"]:
-            ndtype = "string"
-        else:
-            ndtype = "object"
-
-    htable, table = _hashtables[ndtype]
-    return (htable, table, values, dtype, ndtype)
-
-
-def _get_data_algo(values, func_map):
 
+def _get_values_for_rank(values):
     if is_categorical_dtype(values):
         values = values._values_for_rank()
 
-    values, dtype, ndtype = _ensure_data(values)
-    if ndtype == "object":
-
-        # it's cheaper to use a String Hash Table than Object; we infer
-        # including nulls because that is the only difference between
-        # StringHashTable and ObjectHashtable
-        if lib.infer_dtype(values, skipna=False) in ["string"]:
-            ndtype = "string"
+    values, _ = _ensure_data(values)
+    return values
 
-    f = func_map.get(ndtype, func_map["object"])
 
-    return f, values
+def _get_data_algo(values):
+    values = _get_values_for_rank(values)
 
+    ndtype = _check_object_for_strings(values)
+    htable = _hashtables.get(ndtype, _hashtables["object"])
 
-# --------------- #
-# top-level algos #
-# --------------- #
+    return htable, values
 
 
-def match(to_match, values, na_sentinel=-1):
+def _check_object_for_strings(values) -> str:
     """
-    Compute locations of to_match into values
+    Check if we can use string hashtable instead of object hashtable.
 
     Parameters
     ----------
-    to_match : array-like
-        values to find positions of
-    values : array-like
-        Unique set of values
-    na_sentinel : int, default -1
-        Value to mark "not found"
-
-    Examples
-    --------
+    values : ndarray
+    ndtype : str
 
     Returns
     -------
-    match : ndarray of integers
+    str
     """
-    values = com.asarray_tuplesafe(values)
-    htable, _, values, dtype, ndtype = _get_hashtable_algo(values)
-    to_match, _, _ = _ensure_data(to_match, dtype)
-    table = htable(min(len(to_match), 1000000))
-    table.map_locations(values)
-    result = table.lookup(to_match)
-
-    if na_sentinel != -1:
+    ndtype = values.dtype.name
+    if ndtype == "object":
 
-        # replace but return a numpy array
-        # use a Series because it handles dtype conversions properly
-        from pandas import Series
+        # it's cheaper to use a String Hash Table than Object; we infer
+        # including nulls because that is the only difference between
+        # StringHashTable and ObjectHashtable
+        if lib.infer_dtype(values, skipna=False) in ["string"]:
+            ndtype = "string"
+    return ndtype
 
-        result = Series(result.ravel()).replace(-1, na_sentinel)
-        result = result.values.reshape(result.shape)
 
-    return result
+# --------------- #
+# top-level algos #
+# --------------- #
 
 
 def unique(values):
@@ -396,20 +376,20 @@ def unique(values):
         return values.unique()
 
     original = values
-    htable, _, values, dtype, ndtype = _get_hashtable_algo(values)
+    htable, values = _get_hashtable_algo(values)
 
     table = htable(len(values))
     uniques = table.unique(values)
-    uniques = _reconstruct_data(uniques, dtype, original)
+    uniques = _reconstruct_data(uniques, original.dtype, original)
     return uniques
 
 
 unique1d = unique
 
 
-def isin(comps, values):
+def isin(comps, values) -> np.ndarray:
     """
-    Compute the isin boolean array
+    Compute the isin boolean array.
 
     Parameters
     ----------
@@ -418,22 +398,18 @@ def isin(comps, values):
 
     Returns
     -------
-    boolean array same length as comps
+    ndarray[bool]
+        Same length as `comps`.
     """
-
     if not is_list_like(comps):
         raise TypeError(
-            "only list-like objects are allowed to be passed"
-            " to isin(), you passed a [{comps_type}]".format(
-                comps_type=type(comps).__name__
-            )
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a [{type(comps).__name__}]"
         )
     if not is_list_like(values):
         raise TypeError(
-            "only list-like objects are allowed to be passed"
-            " to isin(), you passed a [{values_type}]".format(
-                values_type=type(values).__name__
-            )
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a [{type(values).__name__}]"
         )
 
     if not isinstance(values, (ABCIndex, ABCSeries, np.ndarray)):
@@ -446,21 +422,21 @@ def isin(comps, values):
 
     comps = com.values_from_object(comps)
 
-    comps, dtype, _ = _ensure_data(comps)
-    values, _, _ = _ensure_data(values, dtype=dtype)
+    comps, dtype = _ensure_data(comps)
+    values, _ = _ensure_data(values, dtype=dtype)
 
     # faster for larger cases to use np.in1d
-    f = lambda x, y: htable.ismember_object(x, values)
+    f = htable.ismember_object
 
     # GH16012
     # Ensure np.in1d doesn't get object types or it *may* throw an exception
-    if len(comps) > 1000000 and not is_object_dtype(comps):
-        f = lambda x, y: np.in1d(x, y)
+    if len(comps) > 1_000_000 and not is_object_dtype(comps):
+        f = np.in1d
     elif is_integer_dtype(comps):
         try:
             values = values.astype("int64", copy=False)
             comps = comps.astype("int64", copy=False)
-            f = lambda x, y: htable.ismember_int64(x, y)
+            f = htable.ismember_int64
         except (TypeError, ValueError, OverflowError):
             values = values.astype(object)
             comps = comps.astype(object)
@@ -469,7 +445,7 @@ def isin(comps, values):
         try:
             values = values.astype("float64", copy=False)
             comps = comps.astype("float64", copy=False)
-            f = lambda x, y: htable.ismember_float64(x, y)
+            f = htable.ismember_float64
         except (TypeError, ValueError):
             values = values.astype(object)
             comps = comps.astype(object)
@@ -477,8 +453,11 @@ def isin(comps, values):
     return f(comps, values)
 
 
-def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
-    """Factorize an array-like to labels and uniques.
+def _factorize_array(
+    values, na_sentinel: int = -1, size_hint=None, na_value=None
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Factorize an array-like to codes and uniques.
 
     This doesn't do any coercion of types or unboxing before factorization.
 
@@ -496,17 +475,16 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
 
     Returns
     -------
-    labels, uniques : ndarray
+    codes : ndarray
+    uniques : ndarray
     """
-    (hash_klass, _), values = _get_data_algo(values, _hashtables)
+    hash_klass, values = _get_data_algo(values)
 
     table = hash_klass(size_hint or len(values))
-    uniques, labels = table.factorize(
-        values, na_sentinel=na_sentinel, na_value=na_value
-    )
+    uniques, codes = table.factorize(values, na_sentinel=na_sentinel, na_value=na_value)
 
-    labels = ensure_platform_int(labels)
-    return labels, uniques
+    codes = ensure_platform_int(codes)
+    return codes, uniques
 
 
 _shared_docs[
@@ -521,16 +499,16 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
 
     Parameters
     ----------
-    %(values)s%(sort)s%(order)s
+    %(values)s%(sort)s
     na_sentinel : int, default -1
         Value to mark "not found".
     %(size_hint)s\
 
     Returns
     -------
-    labels : ndarray
+    codes : ndarray
         An integer ndarray that's an indexer into `uniques`.
-        ``uniques.take(labels)`` will have the same values as `values`.
+        ``uniques.take(codes)`` will have the same values as `values`.
     uniques : ndarray, Index, or Categorical
         The unique valid values. When `values` is Categorical, `uniques`
         is a Categorical. When `values` is some other pandas object, an
@@ -552,27 +530,27 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
     ``pd.factorize(values)``. The results are identical for methods like
     :meth:`Series.factorize`.
 
-    >>> labels, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'])
-    >>> labels
+    >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'])
+    >>> codes
     array([0, 0, 1, 2, 0])
     >>> uniques
     array(['b', 'a', 'c'], dtype=object)
 
-    With ``sort=True``, the `uniques` will be sorted, and `labels` will be
+    With ``sort=True``, the `uniques` will be sorted, and `codes` will be
     shuffled so that the relationship is the maintained.
 
-    >>> labels, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True)
-    >>> labels
+    >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True)
+    >>> codes
     array([1, 1, 0, 2, 1])
     >>> uniques
     array(['a', 'b', 'c'], dtype=object)
 
-    Missing values are indicated in `labels` with `na_sentinel`
+    Missing values are indicated in `codes` with `na_sentinel`
     (``-1`` by default). Note that missing values are never
     included in `uniques`.
 
-    >>> labels, uniques = pd.factorize(['b', None, 'a', 'c', 'b'])
-    >>> labels
+    >>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b'])
+    >>> codes
     array([ 0, -1,  1,  2,  0])
     >>> uniques
     array(['b', 'a', 'c'], dtype=object)
@@ -582,8 +560,8 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
     will differ. For Categoricals, a `Categorical` is returned.
 
     >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])
-    >>> labels, uniques = pd.factorize(cat)
-    >>> labels
+    >>> codes, uniques = pd.factorize(cat)
+    >>> codes
     array([0, 0, 1])
     >>> uniques
     [a, c]
@@ -596,8 +574,8 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
     returned.
 
     >>> cat = pd.Series(['a', 'a', 'c'])
-    >>> labels, uniques = pd.factorize(cat)
-    >>> labels
+    >>> codes, uniques = pd.factorize(cat)
+    >>> codes
     array([0, 0, 1])
     >>> uniques
     Index(['a', 'c'], dtype='object')
@@ -612,18 +590,10 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
         coerced to ndarrays before factorization.
     """
     ),
-    order=dedent(
-        """\
-    order : None
-        .. deprecated:: 0.23.0
-
-           This parameter has no effect and is deprecated.
-    """
-    ),
     sort=dedent(
         """\
     sort : bool, default False
-        Sort `uniques` and shuffle `labels` to maintain the
+        Sort `uniques` and shuffle `codes` to maintain the
         relationship.
     """
     ),
@@ -635,12 +605,13 @@ def _factorize_array(values, na_sentinel=-1, size_hint=None, na_value=None):
     ),
 )
 @Appender(_shared_docs["factorize"])
-@deprecate_kwarg(old_arg_name="order", new_arg_name=None)
-def factorize(values, sort=False, order=None, na_sentinel=-1, size_hint=None):
+def factorize(
+    values, sort: bool = False, na_sentinel: int = -1, size_hint: Optional[int] = None
+) -> Tuple[np.ndarray, Union[np.ndarray, ABCIndex]]:
     # Implementation notes: This method is responsible for 3 things
     # 1.) coercing data to array-like (ndarray, Index, extension array)
-    # 2.) factorizing labels and uniques
-    # 3.) Maybe boxing the output in an Index
+    # 2.) factorizing codes and uniques
+    # 3.) Maybe boxing the uniques in an Index
     #
     # Step 2 is dispatched to extension types (like Categorical). They are
     # responsible only for factorization. All data coercion, sorting and boxing
@@ -650,30 +621,24 @@ def factorize(values, sort=False, order=None, na_sentinel=-1, size_hint=None):
     original = values
 
     if is_extension_array_dtype(values):
-        values = getattr(values, "_values", values)
-        labels, uniques = values.factorize(na_sentinel=na_sentinel)
+        values = extract_array(values)
+        codes, uniques = values.factorize(na_sentinel=na_sentinel)
         dtype = original.dtype
     else:
-        values, dtype, _ = _ensure_data(values)
+        values, dtype = _ensure_data(values)
 
-        if (
-            is_datetime64_any_dtype(original)
-            or is_timedelta64_dtype(original)
-            or is_period_dtype(original)
-        ):
+        if original.dtype.kind in ["m", "M"]:
             na_value = na_value_for_dtype(original.dtype)
         else:
             na_value = None
 
-        labels, uniques = _factorize_array(
+        codes, uniques = _factorize_array(
             values, na_sentinel=na_sentinel, size_hint=size_hint, na_value=na_value
         )
 
     if sort and len(uniques) > 0:
-        from pandas.core.sorting import safe_sort
-
-        uniques, labels = safe_sort(
-            uniques, labels, na_sentinel=na_sentinel, assume_unique=True, verify=False
+        uniques, codes = safe_sort(
+            uniques, codes, na_sentinel=na_sentinel, assume_unique=True, verify=False
         )
 
     uniques = _reconstruct_data(uniques, dtype, original)
@@ -686,44 +651,48 @@ def factorize(values, sort=False, order=None, na_sentinel=-1, size_hint=None):
 
         uniques = Index(uniques)
 
-    return labels, uniques
+    return codes, uniques
 
 
 def value_counts(
-    values, sort=True, ascending=False, normalize=False, bins=None, dropna=True
-):
+    values,
+    sort: bool = True,
+    ascending: bool = False,
+    normalize: bool = False,
+    bins=None,
+    dropna: bool = True,
+) -> "Series":
     """
     Compute a histogram of the counts of non-null values.
 
     Parameters
     ----------
     values : ndarray (1-d)
-    sort : boolean, default True
+    sort : bool, default True
         Sort by values
-    ascending : boolean, default False
+    ascending : bool, default False
         Sort in ascending order
-    normalize: boolean, default False
+    normalize: bool, default False
         If True then compute a relative histogram
     bins : integer, optional
         Rather than count values, group them into half-open bins,
         convenience for pd.cut, only works with numeric data
-    dropna : boolean, default True
+    dropna : bool, default True
         Don't include counts of NaN
 
     Returns
     -------
-    value_counts : Series
-
+    Series
     """
-    from pandas.core.series import Series, Index
+    from pandas.core.series import Series
 
     name = getattr(values, "name", None)
 
     if bins is not None:
-        try:
-            from pandas.core.reshape.tile import cut
+        from pandas.core.reshape.tile import cut
 
-            values = Series(values)
+        values = Series(values)
+        try:
             ii = cut(values, bins, include_lowest=True)
         except TypeError:
             raise TypeError("bins argument only works with numeric data.")
@@ -743,7 +712,7 @@ def value_counts(
 
     else:
 
-        if is_extension_array_dtype(values) or is_sparse(values):
+        if is_extension_array_dtype(values):
 
             # handle Categorical and sparse,
             result = Series(values)._values.value_counts(dropna=dropna)
@@ -753,8 +722,6 @@ def value_counts(
         else:
             keys, counts = _value_counts_arraylike(values, dropna)
 
-            if not isinstance(keys, Index):
-                keys = Index(keys)
             result = Series(counts, index=keys, name=name)
 
     if sort:
@@ -766,24 +733,25 @@ def value_counts(
     return result
 
 
-def _value_counts_arraylike(values, dropna):
+def _value_counts_arraylike(values, dropna: bool):
     """
     Parameters
     ----------
     values : arraylike
-    dropna : boolean
+    dropna : bool
 
     Returns
     -------
-    (uniques, counts)
-
+    uniques : np.ndarray or ExtensionArray
+    counts : np.ndarray
     """
     values = _ensure_arraylike(values)
     original = values
-    values, dtype, ndtype = _ensure_data(values)
+    values, _ = _ensure_data(values)
+    ndtype = values.dtype.name
 
-    if needs_i8_conversion(dtype):
-        # i8
+    if needs_i8_conversion(original.dtype):
+        # datetime, timedelta, or period
 
         keys, counts = htable.value_count_int64(values, dropna)
 
@@ -795,7 +763,7 @@ def _value_counts_arraylike(values, dropna):
         # ndarray like
 
         # TODO: handle uint8
-        f = getattr(htable, "value_count_{dtype}".format(dtype=ndtype))
+        f = getattr(htable, f"value_count_{ndtype}")
         keys, counts = f(values, dropna)
 
         mask = isna(values)
@@ -809,7 +777,7 @@ def _value_counts_arraylike(values, dropna):
     return keys, counts
 
 
-def duplicated(values, keep="first"):
+def duplicated(values, keep="first") -> np.ndarray:
     """
     Return boolean ndarray denoting duplicate values.
 
@@ -829,12 +797,13 @@ def duplicated(values, keep="first"):
     duplicated : ndarray
     """
 
-    values, dtype, ndtype = _ensure_data(values)
-    f = getattr(htable, "duplicated_{dtype}".format(dtype=ndtype))
+    values, _ = _ensure_data(values)
+    ndtype = values.dtype.name
+    f = getattr(htable, f"duplicated_{ndtype}")
     return f(values, keep=keep)
 
 
-def mode(values, dropna=True):
+def mode(values, dropna: bool = True) -> "Series":
     """
     Returns the mode(s) of an array.
 
@@ -862,24 +831,32 @@ def mode(values, dropna=True):
             return Series(values.values.mode(dropna=dropna), name=values.name)
         return values.mode(dropna=dropna)
 
-    if dropna and is_datetimelike(values):
+    if dropna and needs_i8_conversion(values.dtype):
         mask = values.isnull()
         values = values[~mask]
 
-    values, dtype, ndtype = _ensure_data(values)
+    values, _ = _ensure_data(values)
+    ndtype = values.dtype.name
 
-    f = getattr(htable, "mode_{dtype}".format(dtype=ndtype))
+    f = getattr(htable, f"mode_{ndtype}")
     result = f(values, dropna=dropna)
     try:
         result = np.sort(result)
-    except TypeError as e:
-        warn("Unable to sort modes: {error}".format(error=e))
+    except TypeError as err:
+        warn(f"Unable to sort modes: {err}")
 
     result = _reconstruct_data(result, original.dtype, original)
     return Series(result)
 
 
-def rank(values, axis=0, method="average", na_option="keep", ascending=True, pct=False):
+def rank(
+    values,
+    axis: int = 0,
+    method: str = "average",
+    na_option: str = "keep",
+    ascending: bool = True,
+    pct: bool = False,
+):
     """
     Rank the values along a given axis.
 
@@ -904,8 +881,8 @@ def rank(values, axis=0, method="average", na_option="keep", ascending=True, pct
         (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1).
     """
     if values.ndim == 1:
-        f, values = _get_data_algo(values, _rank1d_functions)
-        ranks = f(
+        values = _get_values_for_rank(values)
+        ranks = algos.rank_1d(
             values,
             ties_method=method,
             ascending=ascending,
@@ -913,8 +890,8 @@ def rank(values, axis=0, method="average", na_option="keep", ascending=True, pct
             pct=pct,
         )
     elif values.ndim == 2:
-        f, values = _get_data_algo(values, _rank2d_functions)
-        ranks = f(
+        values = _get_values_for_rank(values)
+        ranks = algos.rank_2d(
             values,
             axis=axis,
             ties_method=method,
@@ -1004,21 +981,6 @@ def checked_add_with_arr(arr, b, arr_mask=None, b_mask=None):
     return arr + b
 
 
-_rank1d_functions = {
-    "float64": algos.rank_1d_float64,
-    "int64": algos.rank_1d_int64,
-    "uint64": algos.rank_1d_uint64,
-    "object": algos.rank_1d_object,
-}
-
-_rank2d_functions = {
-    "float64": algos.rank_2d_float64,
-    "int64": algos.rank_2d_int64,
-    "uint64": algos.rank_2d_uint64,
-    "object": algos.rank_2d_object,
-}
-
-
 def quantile(x, q, interpolation_method="fraction"):
     """
     Compute sample quantile or quantiles of the input array. For example, q=0.5
@@ -1066,7 +1028,8 @@ def quantile(x, q, interpolation_method="fraction"):
     values = np.sort(x)
 
     def _interpolate(a, b, fraction):
-        """Returns the point at the given fraction between a and b, where
+        """
+        Returns the point at the given fraction between a and b, where
         'fraction' must be between 0 and 1.
         """
         return a + (b - a) * fraction
@@ -1108,7 +1071,7 @@ def _get_score(at):
 
 
 class SelectN:
-    def __init__(self, obj, n, keep):
+    def __init__(self, obj, n: int, keep: str):
         self.obj = obj
         self.n = n
         self.keep = keep
@@ -1123,7 +1086,7 @@ def nsmallest(self):
         return self.compute("nsmallest")
 
     @staticmethod
-    def is_valid_dtype_n_method(dtype):
+    def is_valid_dtype_n_method(dtype) -> bool:
         """
         Helper function to determine if dtype is valid for
         nsmallest/nlargest methods
@@ -1153,10 +1116,7 @@ def compute(self, method):
         n = self.n
         dtype = self.obj.dtype
         if not self.is_valid_dtype_n_method(dtype):
-            raise TypeError(
-                "Cannot use method '{method}' with "
-                "dtype {dtype}".format(method=method, dtype=dtype)
-            )
+            raise TypeError(f"Cannot use method '{method}' with dtype {dtype}")
 
         if n <= 0:
             return self.obj[[]]
@@ -1165,14 +1125,13 @@ def compute(self, method):
 
         # slow method
         if n >= len(self.obj):
-
             reverse_it = self.keep == "last" or method == "nlargest"
             ascending = method == "nsmallest"
             slc = np.s_[::-1] if reverse_it else np.s_[:]
             return dropped[slc].sort_values(ascending=ascending).head(n)
 
         # fast method
-        arr, pandas_dtype, _ = _ensure_data(dropped.values)
+        arr, pandas_dtype = _ensure_data(dropped.values)
         if method == "nlargest":
             arr = -arr
             if is_integer_dtype(pandas_dtype):
@@ -1190,7 +1149,7 @@ def compute(self, method):
         n = min(n, narr)
 
         kth_val = algos.kth_smallest(arr.copy(), n - 1)
-        ns, = np.nonzero(arr <= kth_val)
+        (ns,) = np.nonzero(arr <= kth_val)
         inds = ns[arr[ns].argsort(kind="mergesort")]
 
         if self.keep != "all":
@@ -1219,7 +1178,7 @@ class SelectNFrame(SelectN):
     nordered : DataFrame
     """
 
-    def __init__(self, obj, n, keep, columns):
+    def __init__(self, obj, n: int, keep: str, columns):
         super().__init__(obj, n, keep)
         if not is_list_like(columns) or isinstance(columns, tuple):
             columns = [columns]
@@ -1238,14 +1197,13 @@ def compute(self, method):
             dtype = frame[column].dtype
             if not self.is_valid_dtype_n_method(dtype):
                 raise TypeError(
-                    (
-                        "Column {column!r} has dtype {dtype}, cannot use method "
-                        "{method!r} with this dtype"
-                    ).format(column=column, dtype=dtype, method=method)
+                    f"Column {repr(column)} has dtype {dtype}, "
+                    f"cannot use method {repr(method)} with this dtype"
                 )
 
         def get_indexer(current_indexer, other_indexer):
-            """Helper function to concat `current_indexer` and `other_indexer`
+            """
+            Helper function to concat `current_indexer` and `other_indexer`
             depending on `method`
             """
             if method == "nsmallest":
@@ -1309,7 +1267,7 @@ def get_indexer(current_indexer, other_indexer):
         return frame.sort_values(columns, ascending=ascending, kind="mergesort")
 
 
-# ------- ## ---- #
+# ---- #
 # take #
 # ---- #
 
@@ -1358,7 +1316,7 @@ def _take_2d_multi_object(arr, indexer, out, fill_value, mask_info):
             out[i, j] = arr[u_, v]
 
 
-def _take_nd_object(arr, indexer, out, axis, fill_value, mask_info):
+def _take_nd_object(arr, indexer, out, axis: int, fill_value, mask_info):
     if mask_info is not None:
         mask, needs_masking = mask_info
     else:
@@ -1475,7 +1433,9 @@ def _take_nd_object(arr, indexer, out, axis, fill_value, mask_info):
 }
 
 
-def _get_take_nd_function(ndim, arr_dtype, out_dtype, axis=0, mask_info=None):
+def _get_take_nd_function(
+    ndim: int, arr_dtype, out_dtype, axis: int = 0, mask_info=None
+):
     if ndim <= 2:
         tup = (arr_dtype.name, out_dtype.name)
         if ndim == 1:
@@ -1500,16 +1460,16 @@ def _get_take_nd_function(ndim, arr_dtype, out_dtype, axis=0, mask_info=None):
             func = _convert_wrapper(func, out_dtype)
             return func
 
-    def func(arr, indexer, out, fill_value=np.nan):
+    def func2(arr, indexer, out, fill_value=np.nan):
         indexer = ensure_int64(indexer)
         _take_nd_object(
             arr, indexer, out, axis=axis, fill_value=fill_value, mask_info=mask_info
         )
 
-    return func
+    return func2
 
 
-def take(arr, indices, axis=0, allow_fill=False, fill_value=None):
+def take(arr, indices, axis: int = 0, allow_fill: bool = False, fill_value=None):
     """
     Take elements from an array.
 
@@ -1603,7 +1563,7 @@ def take(arr, indices, axis=0, allow_fill=False, fill_value=None):
 
 
 def take_nd(
-    arr, indexer, axis=0, out=None, fill_value=np.nan, mask_info=None, allow_fill=True
+    arr, indexer, axis: int = 0, out=None, fill_value=np.nan, allow_fill: bool = True
 ):
     """
     Specialized Cython take which sets NaN values in one pass
@@ -1623,13 +1583,9 @@ def take_nd(
     out : ndarray or None, default None
         Optional output array, must be appropriate type to hold input and
         fill_value together, if indexer has any -1 value entries; call
-        _maybe_promote to determine this type for any fill_value
+        maybe_promote to determine this type for any fill_value
     fill_value : any, default np.nan
         Fill value to replace -1 values with
-    mask_info : tuple of (ndarray, boolean)
-        If provided, value should correspond to:
-            (indexer != -1, (indexer != -1).any())
-        If not provided, it will be computed internally if necessary
     allow_fill : boolean, default True
         If False, indexer is assumed to contain no -1 values so no filling
         will be done.  This short-circuits computation of a mask.  Result is
@@ -1640,15 +1596,12 @@ def take_nd(
     subarray : array-like
         May be the same type as the input, or cast to an ndarray.
     """
+    mask_info = None
 
     if is_extension_array_dtype(arr):
         return arr.take(indexer, fill_value=fill_value, allow_fill=allow_fill)
 
-    if is_sparse(arr):
-        arr = arr.to_dense()
-    elif isinstance(arr, (ABCIndexClass, ABCSeries)):
-        arr = arr._values
-
+    arr = extract_array(arr)
     arr = np.asarray(arr)
 
     if indexer is None:
@@ -1665,12 +1618,9 @@ def take_nd(
             dtype, fill_value = maybe_promote(arr.dtype, fill_value)
             if dtype != arr.dtype and (out is None or out.dtype != dtype):
                 # check if promotion is actually required based on indexer
-                if mask_info is not None:
-                    mask, needs_masking = mask_info
-                else:
-                    mask = indexer == -1
-                    needs_masking = mask.any()
-                    mask_info = mask, needs_masking
+                mask = indexer == -1
+                needs_masking = mask.any()
+                mask_info = mask, needs_masking
                 if needs_masking:
                     if out is not None and out.dtype != dtype:
                         raise TypeError("Incompatible type for fill_value")
@@ -1694,9 +1644,9 @@ def take_nd(
     # at this point, it's guaranteed that dtype can hold both the arr values
     # and the fill_value
     if out is None:
-        out_shape = list(arr.shape)
-        out_shape[axis] = len(indexer)
-        out_shape = tuple(out_shape)
+        out_shape_ = list(arr.shape)
+        out_shape_[axis] = len(indexer)
+        out_shape = tuple(out_shape_)
         if arr.flags.f_contiguous and axis == arr.ndim - 1:
             # minor tweak that can make an order-of-magnitude difference
             # for dataframes initialized directly from 2-d ndarrays
@@ -1719,59 +1669,44 @@ def take_nd(
 take_1d = take_nd
 
 
-def take_2d_multi(
-    arr, indexer, out=None, fill_value=np.nan, mask_info=None, allow_fill=True
-):
+def take_2d_multi(arr, indexer, fill_value=np.nan):
     """
-    Specialized Cython take which sets NaN values in one pass
+    Specialized Cython take which sets NaN values in one pass.
     """
-    if indexer is None or (indexer[0] is None and indexer[1] is None):
-        row_idx = np.arange(arr.shape[0], dtype=np.int64)
-        col_idx = np.arange(arr.shape[1], dtype=np.int64)
-        indexer = row_idx, col_idx
-        dtype, fill_value = arr.dtype, arr.dtype.type()
-    else:
-        row_idx, col_idx = indexer
-        if row_idx is None:
-            row_idx = np.arange(arr.shape[0], dtype=np.int64)
-        else:
-            row_idx = ensure_int64(row_idx)
-        if col_idx is None:
-            col_idx = np.arange(arr.shape[1], dtype=np.int64)
-        else:
-            col_idx = ensure_int64(col_idx)
-        indexer = row_idx, col_idx
-        if not allow_fill:
+    # This is only called from one place in DataFrame._reindex_multi,
+    #  so we know indexer is well-behaved.
+    assert indexer is not None
+    assert indexer[0] is not None
+    assert indexer[1] is not None
+
+    row_idx, col_idx = indexer
+
+    row_idx = ensure_int64(row_idx)
+    col_idx = ensure_int64(col_idx)
+    indexer = row_idx, col_idx
+    mask_info = None
+
+    # check for promotion based on types only (do this first because
+    # it's faster than computing a mask)
+    dtype, fill_value = maybe_promote(arr.dtype, fill_value)
+    if dtype != arr.dtype:
+        # check if promotion is actually required based on indexer
+        row_mask = row_idx == -1
+        col_mask = col_idx == -1
+        row_needs = row_mask.any()
+        col_needs = col_mask.any()
+        mask_info = (row_mask, col_mask), (row_needs, col_needs)
+
+        if not (row_needs or col_needs):
+            # if not, then depromote, set fill_value to dummy
+            # (it won't be used but we don't want the cython code
+            # to crash when trying to cast it to dtype)
             dtype, fill_value = arr.dtype, arr.dtype.type()
-            mask_info = None, False
-        else:
-            # check for promotion based on types only (do this first because
-            # it's faster than computing a mask)
-            dtype, fill_value = maybe_promote(arr.dtype, fill_value)
-            if dtype != arr.dtype and (out is None or out.dtype != dtype):
-                # check if promotion is actually required based on indexer
-                if mask_info is not None:
-                    (row_mask, col_mask), (row_needs, col_needs) = mask_info
-                else:
-                    row_mask = row_idx == -1
-                    col_mask = col_idx == -1
-                    row_needs = row_mask.any()
-                    col_needs = col_mask.any()
-                    mask_info = (row_mask, col_mask), (row_needs, col_needs)
-                if row_needs or col_needs:
-                    if out is not None and out.dtype != dtype:
-                        raise TypeError("Incompatible type for fill_value")
-                else:
-                    # if not, then depromote, set fill_value to dummy
-                    # (it won't be used but we don't want the cython code
-                    # to crash when trying to cast it to dtype)
-                    dtype, fill_value = arr.dtype, arr.dtype.type()
 
     # at this point, it's guaranteed that dtype can hold both the arr values
     # and the fill_value
-    if out is None:
-        out_shape = len(row_idx), len(col_idx)
-        out = np.empty(out_shape, dtype=dtype)
+    out_shape = len(row_idx), len(col_idx)
+    out = np.empty(out_shape, dtype=dtype)
 
     func = _take_2d_multi_dict.get((arr.dtype.name, out.dtype.name), None)
     if func is None and arr.dtype != out.dtype:
@@ -1866,12 +1801,12 @@ def searchsorted(arr, value, side="left", sorter=None):
     elif not (
         is_object_dtype(arr) or is_numeric_dtype(arr) or is_categorical_dtype(arr)
     ):
-        from pandas.core.series import Series
-
         # E.g. if `arr` is an array with dtype='datetime64[ns]'
         # and `value` is a pd.Timestamp, we may need to convert value
-        value_ser = Series(value)._values
+        value_ser = array([value]) if is_scalar(value) else array(value)
         value = value_ser[0] if is_scalar(value) else value_ser
+        if isinstance(value, Timestamp) and value.tzinfo is None:
+            value = value.to_datetime64()
 
     result = arr.searchsorted(value, side=side, sorter=sorter)
     return result
@@ -1881,17 +1816,10 @@ def searchsorted(arr, value, side="left", sorter=None):
 # diff #
 # ---- #
 
-_diff_special = {
-    "float64": algos.diff_2d_float64,
-    "float32": algos.diff_2d_float32,
-    "int64": algos.diff_2d_int64,
-    "int32": algos.diff_2d_int32,
-    "int16": algos.diff_2d_int16,
-    "int8": algos.diff_2d_int8,
-}
+_diff_special = {"float64", "float32", "int64", "int32", "int16", "int8"}
 
 
-def diff(arr, n, axis=0):
+def diff(arr, n: int, axis: int = 0, stacklevel=3):
     """
     difference of n between self,
     analogous to s-s.shift(n)
@@ -1903,18 +1831,44 @@ def diff(arr, n, axis=0):
         number of periods
     axis : int
         axis to shift on
+    stacklevel : int
+        The stacklevel for the lost dtype warning.
 
     Returns
     -------
     shifted
-
     """
+    from pandas.core.arrays import PandasDtype
 
     n = int(n)
     na = np.nan
     dtype = arr.dtype
 
+    if dtype.kind == "b":
+        op = operator.xor
+    else:
+        op = operator.sub
+
+    if isinstance(dtype, PandasDtype):
+        # PandasArray cannot necessarily hold shifted versions of itself.
+        arr = np.asarray(arr)
+        dtype = arr.dtype
+
+    if is_extension_array_dtype(dtype):
+        if hasattr(arr, f"__{op.__name__}__"):
+            return op(arr, arr.shift(n))
+        else:
+            warn(
+                "dtype lost in 'diff()'. In the future this will raise a "
+                "TypeError. Convert to a suitable dtype prior to calling 'diff'.",
+                FutureWarning,
+                stacklevel=stacklevel,
+            )
+            arr = np.asarray(arr)
+            dtype = arr.dtype
+
     is_timedelta = False
+    is_bool = False
     if needs_i8_conversion(arr):
         dtype = np.float64
         arr = arr.view("i8")
@@ -1923,6 +1877,7 @@ def diff(arr, n, axis=0):
 
     elif is_bool_dtype(dtype):
         dtype = np.object_
+        is_bool = True
 
     elif is_integer_dtype(dtype):
         dtype = np.float64
@@ -1935,16 +1890,19 @@ def diff(arr, n, axis=0):
     out_arr[tuple(na_indexer)] = na
 
     if arr.ndim == 2 and arr.dtype.name in _diff_special:
-        f = _diff_special[arr.dtype.name]
-        f(arr, out_arr, n, axis)
+        # TODO: can diff_2d dtype specialization troubles be fixed by defining
+        #  out_arr inside diff_2d?
+        algos.diff_2d(arr, out_arr, n, axis)
     else:
-        res_indexer = [slice(None)] * arr.ndim
-        res_indexer[axis] = slice(n, None) if n >= 0 else slice(None, n)
-        res_indexer = tuple(res_indexer)
+        # To keep mypy happy, _res_indexer is a list while res_indexer is
+        #  a tuple, ditto for lag_indexer.
+        _res_indexer = [slice(None)] * arr.ndim
+        _res_indexer[axis] = slice(n, None) if n >= 0 else slice(None, n)
+        res_indexer = tuple(_res_indexer)
 
-        lag_indexer = [slice(None)] * arr.ndim
-        lag_indexer[axis] = slice(None, -n) if n > 0 else slice(-n, None)
-        lag_indexer = tuple(lag_indexer)
+        _lag_indexer = [slice(None)] * arr.ndim
+        _lag_indexer[axis] = slice(None, -n) if n > 0 else slice(-n, None)
+        lag_indexer = tuple(_lag_indexer)
 
         # need to make sure that we account for na for datelike/timedelta
         # we don't actually want to subtract these i8 numbers
@@ -1962,6 +1920,8 @@ def diff(arr, n, axis=0):
             result = res - lag
             result[mask] = na
             out_arr[res_indexer] = result
+        elif is_bool:
+            out_arr[res_indexer] = arr[res_indexer] ^ arr[lag_indexer]
         else:
             out_arr[res_indexer] = arr[res_indexer] - arr[lag_indexer]
 
@@ -1969,3 +1929,139 @@ def diff(arr, n, axis=0):
         out_arr = out_arr.astype("int64").view("timedelta64[ns]")
 
     return out_arr
+
+
+# --------------------------------------------------------------------
+# Helper functions
+
+# Note: safe_sort is in algorithms.py instead of sorting.py because it is
+#  low-dependency, is used in this module, and used private methods from
+#  this module.
+def safe_sort(
+    values,
+    codes=None,
+    na_sentinel: int = -1,
+    assume_unique: bool = False,
+    verify: bool = True,
+) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
+    """
+    Sort ``values`` and reorder corresponding ``codes``.
+
+    ``values`` should be unique if ``codes`` is not None.
+    Safe for use with mixed types (int, str), orders ints before strs.
+
+    Parameters
+    ----------
+    values : list-like
+        Sequence; must be unique if ``codes`` is not None.
+    codes : list_like, optional
+        Indices to ``values``. All out of bound indices are treated as
+        "not found" and will be masked with ``na_sentinel``.
+    na_sentinel : int, default -1
+        Value in ``codes`` to mark "not found".
+        Ignored when ``codes`` is None.
+    assume_unique : bool, default False
+        When True, ``values`` are assumed to be unique, which can speed up
+        the calculation. Ignored when ``codes`` is None.
+    verify : bool, default True
+        Check if codes are out of bound for the values and put out of bound
+        codes equal to na_sentinel. If ``verify=False``, it is assumed there
+        are no out of bound codes. Ignored when ``codes`` is None.
+
+        .. versionadded:: 0.25.0
+
+    Returns
+    -------
+    ordered : ndarray
+        Sorted ``values``
+    new_codes : ndarray
+        Reordered ``codes``; returned when ``codes`` is not None.
+
+    Raises
+    ------
+    TypeError
+        * If ``values`` is not list-like or if ``codes`` is neither None
+        nor list-like
+        * If ``values`` cannot be sorted
+    ValueError
+        * If ``codes`` is not None and ``values`` contain duplicates.
+    """
+    if not is_list_like(values):
+        raise TypeError(
+            "Only list-like objects are allowed to be passed to safe_sort as values"
+        )
+
+    if not isinstance(values, np.ndarray) and not is_extension_array_dtype(values):
+        # don't convert to string types
+        dtype, _ = infer_dtype_from_array(values)
+        values = np.asarray(values, dtype=dtype)
+
+    def sort_mixed(values):
+        # order ints before strings, safe in py3
+        str_pos = np.array([isinstance(x, str) for x in values], dtype=bool)
+        nums = np.sort(values[~str_pos])
+        strs = np.sort(values[str_pos])
+        return np.concatenate([nums, np.asarray(strs, dtype=object)])
+
+    sorter = None
+    if (
+        not is_extension_array_dtype(values)
+        and lib.infer_dtype(values, skipna=False) == "mixed-integer"
+    ):
+        # unorderable in py3 if mixed str/int
+        ordered = sort_mixed(values)
+    else:
+        try:
+            sorter = values.argsort()
+            ordered = values.take(sorter)
+        except TypeError:
+            # try this anyway
+            ordered = sort_mixed(values)
+
+    # codes:
+
+    if codes is None:
+        return ordered
+
+    if not is_list_like(codes):
+        raise TypeError(
+            "Only list-like objects or None are allowed to "
+            "be passed to safe_sort as codes"
+        )
+    codes = ensure_platform_int(np.asarray(codes))
+
+    from pandas import Index
+
+    if not assume_unique and not Index(values).is_unique:
+        raise ValueError("values should be unique if codes is not None")
+
+    if sorter is None:
+        # mixed types
+        hash_klass, values = _get_data_algo(values)
+        t = hash_klass(len(values))
+        t.map_locations(values)
+        sorter = ensure_platform_int(t.lookup(ordered))
+
+    if na_sentinel == -1:
+        # take_1d is faster, but only works for na_sentinels of -1
+        order2 = sorter.argsort()
+        new_codes = take_1d(order2, codes, fill_value=-1)
+        if verify:
+            mask = (codes < -len(values)) | (codes >= len(values))
+        else:
+            mask = None
+    else:
+        reverse_indexer = np.empty(len(sorter), dtype=np.int_)
+        reverse_indexer.put(sorter, np.arange(len(sorter)))
+        # Out of bound indices will be masked with `na_sentinel` next, so we
+        # may deal with them here without performance loss using `mode='wrap'`
+        new_codes = reverse_indexer.take(codes, mode="wrap")
+
+        mask = codes == na_sentinel
+        if verify:
+            mask = mask | (codes < -len(values)) | (codes >= len(values))
+
+    if mask is not None:
+        np.putmask(new_codes, mask, na_sentinel)
+
+    return ordered, ensure_platform_int(new_codes)
diff --git a/pandas/core/api.py b/pandas/core/api.py
index bd2a57a15bdd2..b0b65f9d0be34 100644
--- a/pandas/core/api.py
+++ b/pandas/core/api.py
@@ -1,6 +1,7 @@
 # flake8: noqa
 
-import numpy as np
+from pandas._libs import NaT, Period, Timedelta, Timestamp
+from pandas._libs.missing import NA
 
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
@@ -12,6 +13,7 @@
 
 from pandas.core.algorithms import factorize, unique, value_counts
 from pandas.core.arrays import Categorical
+from pandas.core.arrays.boolean import BooleanDtype
 from pandas.core.arrays.integer import (
     Int8Dtype,
     Int16Dtype,
@@ -22,13 +24,10 @@
     UInt32Dtype,
     UInt64Dtype,
 )
+from pandas.core.arrays.string_ import StringDtype
 from pandas.core.construction import array
-
 from pandas.core.groupby import Grouper, NamedAgg
-
-# DataFrame needs to be imported after NamedAgg to avoid a circular import
-from pandas.core.frame import DataFrame  # isort:skip
-from pandas.core.index import (
+from pandas.core.indexes.api import (
     CategoricalIndex,
     DatetimeIndex,
     Float64Index,
@@ -36,20 +35,16 @@
     Int64Index,
     IntervalIndex,
     MultiIndex,
-    NaT,
     PeriodIndex,
     RangeIndex,
     TimedeltaIndex,
     UInt64Index,
 )
-from pandas.core.indexes.datetimes import Timestamp, bdate_range, date_range
+from pandas.core.indexes.datetimes import bdate_range, date_range
 from pandas.core.indexes.interval import Interval, interval_range
-from pandas.core.indexes.period import Period, period_range
-from pandas.core.indexes.timedeltas import Timedelta, timedelta_range
+from pandas.core.indexes.period import period_range
+from pandas.core.indexes.timedeltas import timedelta_range
 from pandas.core.indexing import IndexSlice
-from pandas.core.reshape.reshape import (
-    get_dummies,
-)  # TODO: Remove get_dummies import when statsmodels updates #18264
 from pandas.core.series import Series
 from pandas.core.tools.datetimes import to_datetime
 from pandas.core.tools.numeric import to_numeric
@@ -57,3 +52,6 @@
 
 from pandas.io.formats.format import set_eng_float_format
 from pandas.tseries.offsets import DateOffset
+
+# DataFrame needs to be imported after NamedAgg to avoid a circular import
+from pandas.core.frame import DataFrame  # isort:skip
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index e6766a33a613b..81e1d84880f60 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -1,37 +1,43 @@
+import abc
 import inspect
-import warnings
+from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Tuple, Type, Union
 
 import numpy as np
 
 from pandas._libs import reduction as libreduction
+from pandas._typing import Axis
 from pandas.util._decorators import cache_readonly
 
 from pandas.core.dtypes.common import (
     is_dict_like,
-    is_extension_type,
+    is_extension_array_dtype,
     is_list_like,
     is_sequence,
 )
 from pandas.core.dtypes.generic import ABCSeries
 
-from pandas.io.formats.printing import pprint_thing
+from pandas.core.construction import create_series_with_explicit_dtype
+
+if TYPE_CHECKING:
+    from pandas import DataFrame, Series, Index
+
+ResType = Dict[int, Any]
 
 
 def frame_apply(
-    obj,
+    obj: "DataFrame",
     func,
-    axis=0,
-    broadcast=None,
-    raw=False,
-    reduce=None,
-    result_type=None,
-    ignore_failures=False,
+    axis: Axis = 0,
+    raw: bool = False,
+    result_type: Optional[str] = None,
+    ignore_failures: bool = False,
     args=None,
     kwds=None,
 ):
     """ construct and return a row or column based frame apply object """
 
     axis = obj._get_axis_number(axis)
+    klass: Type[FrameApply]
     if axis == 0:
         klass = FrameRowApply
     elif axis == 1:
@@ -40,9 +46,7 @@ def frame_apply(
     return klass(
         obj,
         func,
-        broadcast=broadcast,
         raw=raw,
-        reduce=reduce,
         result_type=result_type,
         ignore_failures=ignore_failures,
         args=args,
@@ -50,16 +54,42 @@ def frame_apply(
     )
 
 
-class FrameApply:
+class FrameApply(metaclass=abc.ABCMeta):
+
+    # ---------------------------------------------------------------
+    # Abstract Methods
+    axis: int
+
+    @property
+    @abc.abstractmethod
+    def result_index(self) -> "Index":
+        pass
+
+    @property
+    @abc.abstractmethod
+    def result_columns(self) -> "Index":
+        pass
+
+    @property
+    @abc.abstractmethod
+    def series_generator(self) -> Iterator["Series"]:
+        pass
+
+    @abc.abstractmethod
+    def wrap_results_for_axis(
+        self, results: ResType, res_index: "Index"
+    ) -> Union["Series", "DataFrame"]:
+        pass
+
+    # ---------------------------------------------------------------
+
     def __init__(
         self,
-        obj,
+        obj: "DataFrame",
         func,
-        broadcast,
-        raw,
-        reduce,
-        result_type,
-        ignore_failures,
+        raw: bool,
+        result_type: Optional[str],
+        ignore_failures: bool,
         args,
         kwds,
     ):
@@ -75,34 +105,6 @@ def __init__(
                 "of {None, 'reduce', 'broadcast', 'expand'}"
             )
 
-        if broadcast is not None:
-            warnings.warn(
-                "The broadcast argument is deprecated and will "
-                "be removed in a future version. You can specify "
-                "result_type='broadcast' to broadcast the result "
-                "to the original dimensions",
-                FutureWarning,
-                stacklevel=4,
-            )
-            if broadcast:
-                result_type = "broadcast"
-
-        if reduce is not None:
-            warnings.warn(
-                "The reduce argument is deprecated and will "
-                "be removed in a future version. You can specify "
-                "result_type='reduce' to try to reduce the result "
-                "to the original dimensions",
-                FutureWarning,
-                stacklevel=4,
-            )
-            if reduce:
-
-                if result_type is not None:
-                    raise ValueError("cannot pass both reduce=True and result_type")
-
-                result_type = "reduce"
-
         self.result_type = result_type
 
         # curry if needed
@@ -116,17 +118,16 @@ def f(x):
 
         self.f = f
 
-        # results
-        self.result = None
-        self.res_index = None
-        self.res_columns = None
+    @property
+    def res_columns(self) -> "Index":
+        return self.result_columns
 
     @property
-    def columns(self):
+    def columns(self) -> "Index":
         return self.obj.columns
 
     @property
-    def index(self):
+    def index(self) -> "Index":
         return self.obj.index
 
     @cache_readonly
@@ -134,11 +135,11 @@ def values(self):
         return self.obj.values
 
     @cache_readonly
-    def dtypes(self):
+    def dtypes(self) -> "Series":
         return self.obj.dtypes
 
     @property
-    def agg_axis(self):
+    def agg_axis(self) -> "Index":
         return self.obj._get_agg_axis(self.axis)
 
     def get_result(self):
@@ -173,7 +174,7 @@ def get_result(self):
 
         # broadcasting
         if self.result_type == "broadcast":
-            return self.apply_broadcast()
+            return self.apply_broadcast(self.obj)
 
         # one axis empty
         elif not all(self.obj.shape):
@@ -204,26 +205,33 @@ def apply_empty_result(self):
         from pandas import Series
 
         if not should_reduce:
-
-            EMPTY_SERIES = Series([])
             try:
-                r = self.f(EMPTY_SERIES, *self.args, **self.kwds)
+                r = self.f(Series([], dtype=np.float64))
             except Exception:
                 pass
             else:
                 should_reduce = not isinstance(r, Series)
 
         if should_reduce:
-            return self.obj._constructor_sliced(np.nan, index=self.agg_axis)
+            if len(self.agg_axis):
+                r = self.f(Series([], dtype=np.float64))
+            else:
+                r = np.nan
+
+            return self.obj._constructor_sliced(r, index=self.agg_axis)
         else:
             return self.obj.copy()
 
     def apply_raw(self):
         """ apply to the values as a numpy array """
-
         try:
             result = libreduction.compute_reduction(self.values, self.f, axis=self.axis)
-        except Exception:
+        except ValueError as err:
+            if "Function does not reduce" not in str(err):
+                # catch only ValueError raised intentionally in libreduction
+                raise
+            # We expect np.apply_along_axis to give a two-dimensional result, or
+            #  also raise.
             result = np.apply_along_axis(self.f, self.axis, self.values)
 
         # TODO: mixed type case
@@ -232,7 +240,7 @@ def apply_raw(self):
         else:
             return self.obj._constructor_sliced(result, index=self.agg_axis)
 
-    def apply_broadcast(self, target):
+    def apply_broadcast(self, target: "DataFrame") -> "DataFrame":
         result_values = np.empty_like(target.values)
 
         # axis which we want to compare compliance
@@ -269,37 +277,52 @@ def apply_standard(self):
         # as demonstrated in gh-12244
         if (
             self.result_type in ["reduce", None]
-            and not self.dtypes.apply(is_extension_type).any()
+            and not self.dtypes.apply(is_extension_array_dtype).any()
+            # Disallow dtypes where setting _index_data will break
+            #  ExtensionArray values, see GH#31182
+            and not self.dtypes.apply(lambda x: x.kind in ["m", "M"]).any()
+            # Disallow complex_internals since libreduction shortcut raises a TypeError
+            and not self.agg_axis._has_complex_internals
         ):
 
-            # Create a dummy Series from an empty array
-            from pandas import Series
-
             values = self.values
             index = self.obj._get_axis(self.axis)
             labels = self.agg_axis
             empty_arr = np.empty(len(index), dtype=values.dtype)
-            dummy = Series(empty_arr, index=index, dtype=values.dtype)
+
+            # Preserve subclass for e.g. test_subclassed_apply
+            dummy = self.obj._constructor_sliced(
+                empty_arr, index=index, dtype=values.dtype
+            )
 
             try:
                 result = libreduction.compute_reduction(
                     values, self.f, axis=self.axis, dummy=dummy, labels=labels
                 )
-                return self.obj._constructor_sliced(result, index=labels)
-            except Exception:
+            except ValueError as err:
+                if "Function does not reduce" not in str(err):
+                    # catch only ValueError raised intentionally in libreduction
+                    raise
+            except TypeError:
+                # e.g. test_apply_ignore_failures we just ignore
+                if not self.ignore_failures:
+                    raise
+            except ZeroDivisionError:
+                # reached via numexpr; fall back to python implementation
                 pass
+            else:
+                return self.obj._constructor_sliced(result, index=labels)
 
         # compute the result using the series generator
-        self.apply_series_generator()
+        results, res_index = self.apply_series_generator()
 
         # wrap results
-        return self.wrap_results()
+        return self.wrap_results(results, res_index)
 
-    def apply_series_generator(self):
+    def apply_series_generator(self) -> Tuple[ResType, "Index"]:
         series_gen = self.series_generator
         res_index = self.result_index
 
-        i = None
         keys = []
         results = {}
         if self.ignore_failures:
@@ -318,34 +341,35 @@ def apply_series_generator(self):
                 res_index = res_index.take(successes)
 
         else:
-            try:
-                for i, v in enumerate(series_gen):
-                    results[i] = self.f(v)
-                    keys.append(v.name)
-            except Exception as e:
-                if hasattr(e, "args"):
-
-                    # make sure i is defined
-                    if i is not None:
-                        k = res_index[i]
-                        e.args = e.args + ("occurred at index %s" % pprint_thing(k),)
-                raise
+            for i, v in enumerate(series_gen):
+                results[i] = self.f(v)
+                keys.append(v.name)
 
-        self.results = results
-        self.res_index = res_index
-        self.res_columns = self.result_columns
+        return results, res_index
 
-    def wrap_results(self):
-        results = self.results
+    def wrap_results(
+        self, results: ResType, res_index: "Index"
+    ) -> Union["Series", "DataFrame"]:
+        from pandas import Series
 
         # see if we can infer the results
-        if len(results) > 0 and is_sequence(results[0]):
+        if len(results) > 0 and 0 in results and is_sequence(results[0]):
 
-            return self.wrap_results_for_axis()
+            return self.wrap_results_for_axis(results, res_index)
 
         # dict of scalars
-        result = self.obj._constructor_sliced(results)
-        result.index = self.res_index
+
+        # the default dtype of an empty Series will be `object`, but this
+        # code can be hit by df.mean() where the result should have dtype
+        # float64 even if it's an empty Series.
+        constructor_sliced = self.obj._constructor_sliced
+        if constructor_sliced is Series:
+            result = create_series_with_explicit_dtype(
+                results, dtype_if_empty=np.float64
+            )
+        else:
+            result = constructor_sliced(results)
+        result.index = res_index
 
         return result
 
@@ -353,37 +377,34 @@ def wrap_results(self):
 class FrameRowApply(FrameApply):
     axis = 0
 
-    def apply_broadcast(self):
-        return super().apply_broadcast(self.obj)
+    def apply_broadcast(self, target: "DataFrame") -> "DataFrame":
+        return super().apply_broadcast(target)
 
     @property
     def series_generator(self):
         return (self.obj._ixs(i, axis=1) for i in range(len(self.columns)))
 
     @property
-    def result_index(self):
+    def result_index(self) -> "Index":
         return self.columns
 
     @property
-    def result_columns(self):
+    def result_columns(self) -> "Index":
         return self.index
 
-    def wrap_results_for_axis(self):
+    def wrap_results_for_axis(
+        self, results: ResType, res_index: "Index"
+    ) -> "DataFrame":
         """ return the results for the rows """
 
-        results = self.results
         result = self.obj._constructor(data=results)
 
         if not isinstance(results[0], ABCSeries):
-            try:
+            if len(result.index) == len(self.res_columns):
                 result.index = self.res_columns
-            except ValueError:
-                pass
 
-        try:
-            result.columns = self.res_index
-        except ValueError:
-            pass
+        if len(result.columns) == len(res_index):
+            result.columns = res_index
 
         return result
 
@@ -391,8 +412,8 @@ def wrap_results_for_axis(self):
 class FrameColumnApply(FrameApply):
     axis = 1
 
-    def apply_broadcast(self):
-        result = super().apply_broadcast(self.obj.T)
+    def apply_broadcast(self, target: "DataFrame") -> "DataFrame":
+        result = super().apply_broadcast(target.T)
         return result.T
 
     @property
@@ -404,43 +425,44 @@ def series_generator(self):
         )
 
     @property
-    def result_index(self):
+    def result_index(self) -> "Index":
         return self.index
 
     @property
-    def result_columns(self):
+    def result_columns(self) -> "Index":
         return self.columns
 
-    def wrap_results_for_axis(self):
+    def wrap_results_for_axis(
+        self, results: ResType, res_index: "Index"
+    ) -> Union["Series", "DataFrame"]:
         """ return the results for the columns """
-        results = self.results
+        result: Union["Series", "DataFrame"]
 
         # we have requested to expand
         if self.result_type == "expand":
-            result = self.infer_to_same_shape()
+            result = self.infer_to_same_shape(results, res_index)
 
         # we have a non-series and don't want inference
         elif not isinstance(results[0], ABCSeries):
             from pandas import Series
 
             result = Series(results)
-            result.index = self.res_index
+            result.index = res_index
 
         # we may want to infer results
         else:
-            result = self.infer_to_same_shape()
+            result = self.infer_to_same_shape(results, res_index)
 
         return result
 
-    def infer_to_same_shape(self):
+    def infer_to_same_shape(self, results: ResType, res_index: "Index") -> "DataFrame":
         """ infer the results to the same shape as the input object """
-        results = self.results
 
         result = self.obj._constructor(data=results)
         result = result.T
 
         # set the index
-        result.index = self.res_index
+        result.index = res_index
 
         # infer dtypes
         result = result.infer_objects()
diff --git a/pandas/core/arrays/__init__.py b/pandas/core/arrays/__init__.py
index 5c83ed8cf5e24..bf3469924a700 100644
--- a/pandas/core/arrays/__init__.py
+++ b/pandas/core/arrays/__init__.py
@@ -1,13 +1,36 @@
-from .base import (  # noqa: F401
+from pandas.core.arrays.base import (
     ExtensionArray,
     ExtensionOpsMixin,
     ExtensionScalarOpsMixin,
+    try_cast_to_ea,
 )
-from .categorical import Categorical  # noqa: F401
-from .datetimes import DatetimeArray  # noqa: F401
-from .integer import IntegerArray, integer_array  # noqa: F401
-from .interval import IntervalArray  # noqa: F401
-from .numpy_ import PandasArray, PandasDtype  # noqa: F401
-from .period import PeriodArray, period_array  # noqa: F401
-from .sparse import SparseArray  # noqa: F401
-from .timedeltas import TimedeltaArray  # noqa: F401
+from pandas.core.arrays.boolean import BooleanArray
+from pandas.core.arrays.categorical import Categorical
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.integer import IntegerArray, integer_array
+from pandas.core.arrays.interval import IntervalArray
+from pandas.core.arrays.numpy_ import PandasArray, PandasDtype
+from pandas.core.arrays.period import PeriodArray, period_array
+from pandas.core.arrays.sparse import SparseArray
+from pandas.core.arrays.string_ import StringArray
+from pandas.core.arrays.timedeltas import TimedeltaArray
+
+__all__ = [
+    "ExtensionArray",
+    "ExtensionOpsMixin",
+    "ExtensionScalarOpsMixin",
+    "try_cast_to_ea",
+    "BooleanArray",
+    "Categorical",
+    "DatetimeArray",
+    "IntegerArray",
+    "integer_array",
+    "IntervalArray",
+    "PandasArray",
+    "PandasDtype",
+    "PeriodArray",
+    "period_array",
+    "SparseArray",
+    "StringArray",
+    "TimedeltaArray",
+]
diff --git a/pandas/core/arrays/_arrow_utils.py b/pandas/core/arrays/_arrow_utils.py
new file mode 100644
index 0000000000000..e0d33bebeb421
--- /dev/null
+++ b/pandas/core/arrays/_arrow_utils.py
@@ -0,0 +1,124 @@
+from distutils.version import LooseVersion
+import json
+
+import numpy as np
+import pyarrow
+
+from pandas.core.arrays.interval import _VALID_CLOSED
+
+_pyarrow_version_ge_015 = LooseVersion(pyarrow.__version__) >= LooseVersion("0.15")
+
+
+def pyarrow_array_to_numpy_and_mask(arr, dtype):
+    """
+    Convert a primitive pyarrow.Array to a numpy array and boolean mask based
+    on the buffers of the Array.
+
+    Parameters
+    ----------
+    arr : pyarrow.Array
+    dtype : numpy.dtype
+
+    Returns
+    -------
+    (data, mask)
+        Tuple of two numpy arrays with the raw data (with specified dtype) and
+        a boolean mask (validity mask, so False means missing)
+    """
+    buflist = arr.buffers()
+    data = np.frombuffer(buflist[1], dtype=dtype)[arr.offset : arr.offset + len(arr)]
+    bitmask = buflist[0]
+    if bitmask is not None:
+        mask = pyarrow.BooleanArray.from_buffers(
+            pyarrow.bool_(), len(arr), [None, bitmask]
+        )
+        mask = np.asarray(mask)
+    else:
+        mask = np.ones(len(arr), dtype=bool)
+    return data, mask
+
+
+if _pyarrow_version_ge_015:
+    # the pyarrow extension types are only available for pyarrow 0.15+
+
+    class ArrowPeriodType(pyarrow.ExtensionType):
+        def __init__(self, freq):
+            # attributes need to be set first before calling
+            # super init (as that calls serialize)
+            self._freq = freq
+            pyarrow.ExtensionType.__init__(self, pyarrow.int64(), "pandas.period")
+
+        @property
+        def freq(self):
+            return self._freq
+
+        def __arrow_ext_serialize__(self):
+            metadata = {"freq": self.freq}
+            return json.dumps(metadata).encode()
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            metadata = json.loads(serialized.decode())
+            return ArrowPeriodType(metadata["freq"])
+
+        def __eq__(self, other):
+            if isinstance(other, pyarrow.BaseExtensionType):
+                return type(self) == type(other) and self.freq == other.freq
+            else:
+                return NotImplemented
+
+        def __hash__(self):
+            return hash((str(self), self.freq))
+
+    # register the type with a dummy instance
+    _period_type = ArrowPeriodType("D")
+    pyarrow.register_extension_type(_period_type)
+
+    class ArrowIntervalType(pyarrow.ExtensionType):
+        def __init__(self, subtype, closed):
+            # attributes need to be set first before calling
+            # super init (as that calls serialize)
+            assert closed in _VALID_CLOSED
+            self._closed = closed
+            if not isinstance(subtype, pyarrow.DataType):
+                subtype = pyarrow.type_for_alias(str(subtype))
+            self._subtype = subtype
+
+            storage_type = pyarrow.struct([("left", subtype), ("right", subtype)])
+            pyarrow.ExtensionType.__init__(self, storage_type, "pandas.interval")
+
+        @property
+        def subtype(self):
+            return self._subtype
+
+        @property
+        def closed(self):
+            return self._closed
+
+        def __arrow_ext_serialize__(self):
+            metadata = {"subtype": str(self.subtype), "closed": self.closed}
+            return json.dumps(metadata).encode()
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            metadata = json.loads(serialized.decode())
+            subtype = pyarrow.type_for_alias(metadata["subtype"])
+            closed = metadata["closed"]
+            return ArrowIntervalType(subtype, closed)
+
+        def __eq__(self, other):
+            if isinstance(other, pyarrow.BaseExtensionType):
+                return (
+                    type(self) == type(other)
+                    and self.subtype == other.subtype
+                    and self.closed == other.closed
+                )
+            else:
+                return NotImplemented
+
+        def __hash__(self):
+            return hash((str(self), str(self.subtype), self.closed))
+
+    # register the type with a dummy instance
+    _interval_type = ArrowIntervalType(pyarrow.int64(), "left")
+    pyarrow.register_extension_type(_interval_type)
diff --git a/pandas/core/arrays/_ranges.py b/pandas/core/arrays/_ranges.py
index 15ff1432f16e2..20e4cf70eddcf 100644
--- a/pandas/core/arrays/_ranges.py
+++ b/pandas/core/arrays/_ranges.py
@@ -114,10 +114,7 @@ def _generate_range_overflow_safe(
     assert side in ["start", "end"]
 
     i64max = np.uint64(np.iinfo(np.int64).max)
-    msg = (
-        "Cannot generate range with {side}={endpoint} and "
-        "periods={periods}".format(side=side, endpoint=endpoint, periods=periods)
-    )
+    msg = f"Cannot generate range with {side}={endpoint} and periods={periods}"
 
     with np.errstate(over="raise"):
         # if periods * strides cannot be multiplied within the *uint64* bounds,
@@ -182,7 +179,6 @@ def _generate_range_overflow_safe_signed(
             # watch out for very special case in which we just slightly
             #  exceed implementation bounds, but when passing the result to
             #  np.arange will get a result slightly within the bounds
-            assert endpoint >= 0
             result = np.uint64(endpoint) + np.uint64(addend)
             i64max = np.uint64(np.iinfo(np.int64).max)
             assert result > i64max
@@ -190,7 +186,5 @@ def _generate_range_overflow_safe_signed(
                 return result
 
     raise OutOfBoundsDatetime(
-        "Cannot generate range with "
-        "{side}={endpoint} and "
-        "periods={periods}".format(side=side, endpoint=endpoint, periods=periods)
+        f"Cannot generate range with {side}={endpoint} and periods={periods}"
     )
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 0778b6726d104..c3c91cea43f6b 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -10,6 +10,8 @@
 
 import numpy as np
 
+from pandas._libs import lib
+from pandas._typing import ArrayLike
 from pandas.compat import set_function_name
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError
@@ -21,15 +23,35 @@
 from pandas.core.dtypes.generic import ABCExtensionArray, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.missing import isna
 
-from pandas._typing import ArrayLike
 from pandas.core import ops
 from pandas.core.algorithms import _factorize_array, unique
 from pandas.core.missing import backfill_1d, pad_1d
 from pandas.core.sorting import nargsort
 
-_not_implemented_message = "{} does not implement {}."
+_extension_array_shared_docs: Dict[str, str] = dict()
+
+
+def try_cast_to_ea(cls_or_instance, obj, dtype=None):
+    """
+    Call to `_from_sequence` that returns the object unchanged on Exception.
 
-_extension_array_shared_docs = dict()  # type: Dict[str, str]
+    Parameters
+    ----------
+    cls_or_instance : ExtensionArray subclass or instance
+    obj : arraylike
+        Values to pass to cls._from_sequence
+    dtype : ExtensionDtype, optional
+
+    Returns
+    -------
+    ExtensionArray or obj
+    """
+    try:
+        result = cls_or_instance._from_sequence(obj, dtype=dtype)
+    except Exception:
+        # We can't predict what downstream EA constructors may raise
+        result = obj
+    return result
 
 
 class ExtensionArray:
@@ -154,6 +176,9 @@ class ExtensionArray:
        types present.
 
     See :ref:`extending.extension.ufunc` for more.
+
+    By default, ExtensionArrays are not hashable.  Immutable subclasses may
+    override this behavior.
     """
 
     # '_typ' is for pandas.core.dtypes.generic.ABCExtensionArray.
@@ -177,7 +202,7 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
         dtype : dtype, optional
             Construct for this particular dtype. This should be a Dtype
             compatible with the ExtensionArray.
-        copy : boolean, default False
+        copy : bool, default False
             If True, copy the underlying data.
 
         Returns
@@ -200,7 +225,7 @@ def _from_sequence_of_strings(cls, strings, dtype=None, copy=False):
         dtype : dtype, optional
             Construct for this particular dtype. This should be a Dtype
             compatible with the ExtensionArray.
-        copy : boolean, default False
+        copy : bool, default False
             If True, copy the underlying data.
 
         Returns
@@ -307,9 +332,7 @@ def __setitem__(self, key: Union[int, np.ndarray], value: Any) -> None:
         #   __init__ method coerces that value, then so should __setitem__
         # Note, also, that Series/DataFrame.where internally use __setitem__
         # on a copy of the data.
-        raise NotImplementedError(
-            _not_implemented_message.format(type(self), "__setitem__")
-        )
+        raise NotImplementedError(f"{type(self)} does not implement __setitem__.")
 
     def __len__(self) -> int:
         """
@@ -331,6 +354,39 @@ def __iter__(self):
         for i in range(len(self)):
             yield self[i]
 
+    def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default):
+        """
+        Convert to a NumPy ndarray.
+
+        .. versionadded:: 1.0.0
+
+        This is similar to :meth:`numpy.asarray`, but may provide additional control
+        over how the conversion is done.
+
+        Parameters
+        ----------
+        dtype : str or numpy.dtype, optional
+            The dtype to pass to :meth:`numpy.asarray`.
+        copy : bool, default False
+            Whether to ensure that the returned value is a not a view on
+            another array. Note that ``copy=False`` does not *ensure* that
+            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
+            a copy is made, even if not strictly necessary.
+        na_value : Any, optional
+            The value to use for missing values. The default value depends
+            on `dtype` and the type of the array.
+
+        Returns
+        -------
+        numpy.ndarray
+        """
+        result = np.asarray(self, dtype=dtype)
+        if copy or na_value is not lib.no_default:
+            result = result.copy()
+        if na_value is not lib.no_default:
+            result[self.isna()] = na_value
+        return result
+
     # ------------------------------------------------------------------------
     # Required attributes
     # ------------------------------------------------------------------------
@@ -428,7 +484,9 @@ def _values_for_argsort(self) -> np.ndarray:
         # Note: this is used in `ExtensionArray.argsort`.
         return np.array(self)
 
-    def argsort(self, ascending=True, kind="quicksort", *args, **kwargs):
+    def argsort(
+        self, ascending: bool = True, kind: str = "quicksort", *args, **kwargs
+    ) -> np.ndarray:
         """
         Return the indices that would sort this array.
 
@@ -444,7 +502,7 @@ def argsort(self, ascending=True, kind="quicksort", *args, **kwargs):
 
         Returns
         -------
-        index_array : ndarray
+        ndarray
             Array of indices that sort ``self``. If NaN values are contained,
             NaN values are placed at the end.
 
@@ -474,7 +532,7 @@ def fillna(self, value=None, method=None, limit=None):
         method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
             Method to use for filling holes in reindexed Series
             pad / ffill: propagate last valid observation forward to next valid
-            backfill / bfill: use NEXT valid observation to fill gap
+            backfill / bfill: use NEXT valid observation to fill gap.
         limit : int, default None
             If method is specified, this is the maximum number of consecutive
             NaN values to forward/backward fill. In other words, if there is
@@ -485,7 +543,8 @@ def fillna(self, value=None, method=None, limit=None):
 
         Returns
         -------
-        filled : ExtensionArray with NA/NaN filled
+        ExtensionArray
+            With NA/NaN filled.
         """
         value, method = validate_fillna_kwargs(value, method)
 
@@ -494,8 +553,8 @@ def fillna(self, value=None, method=None, limit=None):
         if is_array_like(value):
             if len(value) != len(self):
                 raise ValueError(
-                    "Length of 'value' does not match. Got ({}) "
-                    " expected {}".format(len(value), len(self))
+                    f"Length of 'value' does not match. Got ({len(value)}) "
+                    f"expected {len(self)}"
                 )
             value = value[mask]
 
@@ -539,13 +598,14 @@ def shift(self, periods: int = 1, fill_value: object = None) -> ABCExtensionArra
 
         fill_value : object, optional
             The scalar value to use for newly introduced missing values.
-            The default is ``self.dtype.na_value``
+            The default is ``self.dtype.na_value``.
 
             .. versionadded:: 0.24.0
 
         Returns
         -------
-        shifted : ExtensionArray
+        ExtensionArray
+            Shifted.
 
         Notes
         -----
@@ -665,11 +725,11 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ABCExtensionArra
         Parameters
         ----------
         na_sentinel : int, default -1
-            Value to use in the `labels` array to indicate missing values.
+            Value to use in the `codes` array to indicate missing values.
 
         Returns
         -------
-        labels : ndarray
+        codes : ndarray
             An integer NumPy array that's an indexer into the original
             ExtensionArray.
         uniques : ExtensionArray
@@ -699,12 +759,12 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ABCExtensionArra
         #    Complete control over factorization.
         arr, na_value = self._values_for_factorize()
 
-        labels, uniques = _factorize_array(
+        codes, uniques = _factorize_array(
             arr, na_sentinel=na_sentinel, na_value=na_value
         )
 
         uniques = self._from_factorized(uniques, self)
-        return labels, uniques
+        return codes, uniques
 
     _extension_array_shared_docs[
         "repeat"
@@ -769,7 +829,7 @@ def take(
 
         Parameters
         ----------
-        indices : sequence of integers
+        indices : sequence of int
             Indices to be taken.
         allow_fill : bool, default False
             How to handle negative values in `indices`.
@@ -869,11 +929,12 @@ def view(self, dtype=None) -> Union[ABCExtensionArray, np.ndarray]:
         Parameters
         ----------
         dtype : str, np.dtype, or ExtensionDtype, optional
-            Default None
+            Default None.
 
         Returns
         -------
         ExtensionArray
+            A view of the :class:`ExtensionArray`.
         """
         # NB:
         # - This must return a *new* object referencing the same data, not self.
@@ -887,20 +948,17 @@ def view(self, dtype=None) -> Union[ABCExtensionArray, np.ndarray]:
     # Printing
     # ------------------------------------------------------------------------
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         from pandas.io.formats.printing import format_object_summary
 
-        template = "{class_name}{data}\nLength: {length}, dtype: {dtype}"
         # the short repr has no trailing newline, while the truncated
         # repr does. So we include a newline in our template, and strip
         # any trailing newlines from format_object_summary
         data = format_object_summary(
             self, self._formatter(), indent_for_name=False
         ).rstrip(", \n")
-        class_name = "<{}>\n".format(self.__class__.__name__)
-        return template.format(
-            class_name=class_name, data=data, length=len(self), dtype=self.dtype
-        )
+        class_name = f"<{type(self).__name__}>\n"
+        return f"{class_name}{data}\nLength: {len(self)}, dtype: {self.dtype}"
 
     def _formatter(self, boxed: bool = False) -> Callable[[Any], Optional[str]]:
         """Formatting function for scalar values.
@@ -1016,11 +1074,10 @@ def _reduce(self, name, skipna=True, **kwargs):
         ------
         TypeError : subclass does not define reductions
         """
-        raise TypeError(
-            "cannot perform {name} with type {dtype}".format(
-                name=name, dtype=self.dtype
-            )
-        )
+        raise TypeError(f"cannot perform {name} with type {self.dtype}")
+
+    def __hash__(self):
+        raise TypeError(f"unhashable type: {repr(type(self).__name__)}")
 
 
 class ExtensionOpsMixin:
@@ -1062,6 +1119,15 @@ def _add_comparison_ops(cls):
         cls.__le__ = cls._create_comparison_method(operator.le)
         cls.__ge__ = cls._create_comparison_method(operator.ge)
 
+    @classmethod
+    def _add_logical_ops(cls):
+        cls.__and__ = cls._create_logical_method(operator.and_)
+        cls.__rand__ = cls._create_logical_method(ops.rand_)
+        cls.__or__ = cls._create_logical_method(operator.or_)
+        cls.__ror__ = cls._create_logical_method(ops.ror_)
+        cls.__xor__ = cls._create_logical_method(operator.xor)
+        cls.__rxor__ = cls._create_logical_method(ops.rxor)
+
 
 class ExtensionScalarOpsMixin(ExtensionOpsMixin):
     """
@@ -1101,7 +1167,7 @@ def _create_method(cls, op, coerce_to_dtype=True):
         ----------
         op : function
             An operator that takes arguments op(a, b)
-        coerce_to_dtype :  bool, default True
+        coerce_to_dtype : bool, default True
             boolean indicating whether to attempt to convert
             the result to the underlying ExtensionArray dtype.
             If it's not possible to create a new ExtensionArray with the
@@ -1153,9 +1219,9 @@ def _maybe_convert(arr):
                     # https://github.com/pandas-dev/pandas/issues/22850
                     # We catch all regular exceptions here, and fall back
                     # to an ndarray.
-                    try:
-                        res = self._from_sequence(arr)
-                    except Exception:
+                    res = try_cast_to_ea(self, arr)
+                    if not isinstance(res, type(self)):
+                        # exception raised in _from_sequence; ensure we have ndarray
                         res = np.asarray(arr)
                 else:
                     res = np.asarray(arr)
@@ -1163,10 +1229,9 @@ def _maybe_convert(arr):
 
             if op.__name__ in {"divmod", "rdivmod"}:
                 a, b = zip(*res)
-                res = _maybe_convert(a), _maybe_convert(b)
-            else:
-                res = _maybe_convert(res)
-            return res
+                return _maybe_convert(a), _maybe_convert(b)
+
+            return _maybe_convert(res)
 
         op_name = ops._get_op_name(op, True)
         return set_function_name(_binop, op_name, cls)
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
new file mode 100644
index 0000000000000..590b40b0434e5
--- /dev/null
+++ b/pandas/core/arrays/boolean.py
@@ -0,0 +1,800 @@
+import numbers
+from typing import TYPE_CHECKING, List, Tuple, Type, Union
+import warnings
+
+import numpy as np
+
+from pandas._libs import lib, missing as libmissing
+from pandas._typing import ArrayLike
+from pandas.compat import set_function_name
+from pandas.compat.numpy import function as nv
+
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.cast import astype_nansafe
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_extension_array_dtype,
+    is_float,
+    is_float_dtype,
+    is_integer_dtype,
+    is_list_like,
+    is_numeric_dtype,
+    is_scalar,
+    pandas_dtype,
+)
+from pandas.core.dtypes.dtypes import register_extension_dtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
+from pandas.core.dtypes.missing import isna, notna
+
+from pandas.core import nanops, ops
+from pandas.core.indexers import check_array_indexer
+
+from .masked import BaseMaskedArray
+
+if TYPE_CHECKING:
+    import pyarrow  # noqa: F401
+
+
+@register_extension_dtype
+class BooleanDtype(ExtensionDtype):
+    """
+    Extension dtype for boolean data.
+
+    .. versionadded:: 1.0.0
+
+    .. warning::
+
+       BooleanDtype is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    Examples
+    --------
+    >>> pd.BooleanDtype()
+    BooleanDtype
+    """
+
+    name = "boolean"
+
+    @property
+    def na_value(self) -> libmissing.NAType:
+        """
+        BooleanDtype uses :attr:`pandas.NA` as the missing NA value.
+
+        .. warning::
+
+           `na_value` may change in a future release.
+        """
+        return libmissing.NA
+
+    @property
+    def type(self) -> Type[np.bool_]:
+        return np.bool_
+
+    @property
+    def kind(self) -> str:
+        return "b"
+
+    @classmethod
+    def construct_array_type(cls) -> Type["BooleanArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return BooleanArray
+
+    def __repr__(self) -> str:
+        return "BooleanDtype"
+
+    @property
+    def _is_boolean(self) -> bool:
+        return True
+
+    def __from_arrow__(
+        self, array: Union["pyarrow.Array", "pyarrow.ChunkedArray"]
+    ) -> "BooleanArray":
+        """
+        Construct BooleanArray from pyarrow Array/ChunkedArray.
+        """
+        import pyarrow  # noqa: F811
+
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            # pyarrow.ChunkedArray
+            chunks = array.chunks
+
+        results = []
+        for arr in chunks:
+            # TODO should optimize this without going through object array
+            bool_arr = BooleanArray._from_sequence(np.array(arr))
+            results.append(bool_arr)
+
+        return BooleanArray._concat_same_type(results)
+
+
+def coerce_to_array(
+    values, mask=None, copy: bool = False
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Coerce the input values array to numpy arrays with a mask.
+
+    Parameters
+    ----------
+    values : 1D list-like
+    mask : bool 1D array, optional
+    copy : bool, default False
+        if True, copy the input
+
+    Returns
+    -------
+    tuple of (values, mask)
+    """
+    if isinstance(values, BooleanArray):
+        if mask is not None:
+            raise ValueError("cannot pass mask for BooleanArray input")
+        values, mask = values._data, values._mask
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+        return values, mask
+
+    mask_values = None
+    if isinstance(values, np.ndarray) and values.dtype == np.bool_:
+        if copy:
+            values = values.copy()
+    elif isinstance(values, np.ndarray) and is_numeric_dtype(values.dtype):
+        mask_values = isna(values)
+
+        values_bool = np.zeros(len(values), dtype=bool)
+        values_bool[~mask_values] = values[~mask_values].astype(bool)
+
+        if not np.all(
+            values_bool[~mask_values].astype(values.dtype) == values[~mask_values]
+        ):
+            raise TypeError("Need to pass bool-like values")
+
+        values = values_bool
+    else:
+        values_object = np.asarray(values, dtype=object)
+
+        inferred_dtype = lib.infer_dtype(values_object, skipna=True)
+        integer_like = ("floating", "integer", "mixed-integer-float")
+        if inferred_dtype not in ("boolean", "empty") + integer_like:
+            raise TypeError("Need to pass bool-like values")
+
+        mask_values = isna(values_object)
+        values = np.zeros(len(values), dtype=bool)
+        values[~mask_values] = values_object[~mask_values].astype(bool)
+
+        # if the values were integer-like, validate it were actually 0/1's
+        if inferred_dtype in integer_like:
+            if not np.all(
+                values[~mask_values].astype(float)
+                == values_object[~mask_values].astype(float)
+            ):
+                raise TypeError("Need to pass bool-like values")
+
+    if mask is None and mask_values is None:
+        mask = np.zeros(len(values), dtype=bool)
+    elif mask is None:
+        mask = mask_values
+    else:
+        if isinstance(mask, np.ndarray) and mask.dtype == np.bool_:
+            if mask_values is not None:
+                mask = mask | mask_values
+            else:
+                if copy:
+                    mask = mask.copy()
+        else:
+            mask = np.array(mask, dtype=bool)
+            if mask_values is not None:
+                mask = mask | mask_values
+
+    if not values.ndim == 1:
+        raise ValueError("values must be a 1D list-like")
+    if not mask.ndim == 1:
+        raise ValueError("mask must be a 1D list-like")
+
+    return values, mask
+
+
+class BooleanArray(BaseMaskedArray):
+    """
+    Array of boolean (True/False) data with missing values.
+
+    This is a pandas Extension array for boolean data, under the hood
+    represented by 2 numpy arrays: a boolean array with the data and
+    a boolean array with the mask (True indicating missing).
+
+    BooleanArray implements Kleene logic (sometimes called three-value
+    logic) for logical operations. See :ref:`boolean.kleene` for more.
+
+    To construct an BooleanArray from generic array-like input, use
+    :func:`pandas.array` specifying ``dtype="boolean"`` (see examples
+    below).
+
+    .. versionadded:: 1.0.0
+
+    .. warning::
+
+       BooleanArray is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+    Parameters
+    ----------
+    values : numpy.ndarray
+        A 1-d boolean-dtype array with the data.
+    mask : numpy.ndarray
+        A 1-d boolean-dtype array indicating missing values (True
+        indicates missing).
+    copy : bool, default False
+        Whether to copy the `values` and `mask` arrays.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    Returns
+    -------
+    BooleanArray
+
+    Examples
+    --------
+    Create an BooleanArray with :func:`pandas.array`:
+
+    >>> pd.array([True, False, None], dtype="boolean")
+    <BooleanArray>
+    [True, False, <NA>]
+    Length: 3, dtype: boolean
+    """
+
+    # The value used to fill '_data' to avoid upcasting
+    _internal_fill_value = False
+
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
+        if not (isinstance(values, np.ndarray) and values.dtype == np.bool_):
+            raise TypeError(
+                "values should be boolean numpy array. Use "
+                "the 'array' function instead"
+            )
+        if not (isinstance(mask, np.ndarray) and mask.dtype == np.bool_):
+            raise TypeError(
+                "mask should be boolean numpy array. Use "
+                "the 'array' function instead"
+            )
+        if not values.ndim == 1:
+            raise ValueError("values must be a 1D array")
+        if not mask.ndim == 1:
+            raise ValueError("mask must be a 1D array")
+
+        self._dtype = BooleanDtype()
+        super().__init__(values, mask, copy=copy)
+
+    @property
+    def dtype(self) -> BooleanDtype:
+        return self._dtype
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy: bool = False) -> "BooleanArray":
+        if dtype:
+            assert dtype == "boolean"
+        values, mask = coerce_to_array(scalars, copy=copy)
+        return BooleanArray(values, mask)
+
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings: List[str], dtype=None, copy: bool = False
+    ) -> "BooleanArray":
+        def map_string(s):
+            if isna(s):
+                return s
+            elif s in ["True", "TRUE", "true"]:
+                return True
+            elif s in ["False", "FALSE", "false"]:
+                return False
+            else:
+                raise ValueError(f"{s} cannot be cast to bool")
+
+        scalars = [map_string(x) for x in strings]
+        return cls._from_sequence(scalars, dtype, copy)
+
+    def _values_for_factorize(self) -> Tuple[np.ndarray, int]:
+        data = self._data.astype("int8")
+        data[self._mask] = -1
+        return data, -1
+
+    @classmethod
+    def _from_factorized(cls, values, original: "BooleanArray") -> "BooleanArray":
+        return cls._from_sequence(values, dtype=original.dtype)
+
+    _HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)
+
+    def __array_ufunc__(self, ufunc, method: str, *inputs, **kwargs):
+        # For BooleanArray inputs, we apply the ufunc to ._data
+        # and mask the result.
+        if method == "reduce":
+            # Not clear how to handle missing values in reductions. Raise.
+            raise NotImplementedError("The 'reduce' method is not supported.")
+        out = kwargs.get("out", ())
+
+        for x in inputs + out:
+            if not isinstance(x, self._HANDLED_TYPES + (BooleanArray,)):
+                return NotImplemented
+
+        # for binary ops, use our custom dunder methods
+        result = ops.maybe_dispatch_ufunc_to_dunder_op(
+            self, ufunc, method, *inputs, **kwargs
+        )
+        if result is not NotImplemented:
+            return result
+
+        mask = np.zeros(len(self), dtype=bool)
+        inputs2 = []
+        for x in inputs:
+            if isinstance(x, BooleanArray):
+                mask |= x._mask
+                inputs2.append(x._data)
+            else:
+                inputs2.append(x)
+
+        def reconstruct(x):
+            # we don't worry about scalar `x` here, since we
+            # raise for reduce up above.
+
+            if is_bool_dtype(x.dtype):
+                m = mask.copy()
+                return BooleanArray(x, m)
+            else:
+                x[mask] = np.nan
+            return x
+
+        result = getattr(ufunc, method)(*inputs2, **kwargs)
+        if isinstance(result, tuple):
+            tuple(reconstruct(x) for x in result)
+        else:
+            return reconstruct(result)
+
+    def __setitem__(self, key, value) -> None:
+        _is_scalar = is_scalar(value)
+        if _is_scalar:
+            value = [value]
+        value, mask = coerce_to_array(value)
+
+        if _is_scalar:
+            value = value[0]
+            mask = mask[0]
+
+        key = check_array_indexer(self, key)
+        self._data[key] = value
+        self._mask[key] = mask
+
+    def astype(self, dtype, copy: bool = True) -> ArrayLike:
+        """
+        Cast to a NumPy array or ExtensionArray with 'dtype'.
+
+        Parameters
+        ----------
+        dtype : str or dtype
+            Typecode or data-type to which the array is cast.
+        copy : bool, default True
+            Whether to copy the data, even if not necessary. If False,
+            a copy is made only if the old dtype does not match the
+            new dtype.
+
+        Returns
+        -------
+        ndarray or ExtensionArray
+            NumPy ndarray, BooleanArray or IntegerArray with 'dtype' for its dtype.
+
+        Raises
+        ------
+        TypeError
+            if incompatible type with an BooleanDtype, equivalent of same_kind
+            casting
+        """
+        dtype = pandas_dtype(dtype)
+
+        if isinstance(dtype, BooleanDtype):
+            values, mask = coerce_to_array(self, copy=copy)
+            return BooleanArray(values, mask, copy=False)
+
+        if is_bool_dtype(dtype):
+            # astype_nansafe converts np.nan to True
+            if self._hasna:
+                raise ValueError("cannot convert float NaN to bool")
+            else:
+                return self._data.astype(dtype, copy=copy)
+        if is_extension_array_dtype(dtype) and is_integer_dtype(dtype):
+            from pandas.core.arrays import IntegerArray
+
+            return IntegerArray(
+                self._data.astype(dtype.numpy_dtype), self._mask.copy(), copy=False
+            )
+        # for integer, error if there are missing values
+        if is_integer_dtype(dtype):
+            if self._hasna:
+                raise ValueError("cannot convert NA to integer")
+        # for float dtype, ensure we use np.nan before casting (numpy cannot
+        # deal with pd.NA)
+        na_value = self._na_value
+        if is_float_dtype(dtype):
+            na_value = np.nan
+        # coerce
+        data = self.to_numpy(na_value=na_value)
+        return astype_nansafe(data, dtype, copy=False)
+
+    def _values_for_argsort(self) -> np.ndarray:
+        """
+        Return values for sorting.
+
+        Returns
+        -------
+        ndarray
+            The transformed values should maintain the ordering between values
+            within the array.
+
+        See Also
+        --------
+        ExtensionArray.argsort
+        """
+        data = self._data.copy()
+        data[self._mask] = -1
+        return data
+
+    def any(self, skipna: bool = True, **kwargs):
+        """
+        Return whether any element is True.
+
+        Returns False unless there is at least one element that is True.
+        By default, NAs are skipped. If ``skipna=False`` is specified and
+        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
+        is used as for logical operations.
+
+        Parameters
+        ----------
+        skipna : bool, default True
+            Exclude NA values. If the entire array is NA and `skipna` is
+            True, then the result will be False, as for an empty array.
+            If `skipna` is False, the result will still be True if there is
+            at least one element that is True, otherwise NA will be returned
+            if there are NA's present.
+        **kwargs : any, default None
+            Additional keywords have no effect but might be accepted for
+            compatibility with NumPy.
+
+        Returns
+        -------
+        bool or :attr:`pandas.NA`
+
+        See Also
+        --------
+        numpy.any : Numpy version of this method.
+        BooleanArray.all : Return whether all elements are True.
+
+        Examples
+        --------
+
+        The result indicates whether any element is True (and by default
+        skips NAs):
+
+        >>> pd.array([True, False, True]).any()
+        True
+        >>> pd.array([True, False, pd.NA]).any()
+        True
+        >>> pd.array([False, False, pd.NA]).any()
+        False
+        >>> pd.array([], dtype="boolean").any()
+        False
+        >>> pd.array([pd.NA], dtype="boolean").any()
+        False
+
+        With ``skipna=False``, the result can be NA if this is logically
+        required (whether ``pd.NA`` is True or False influences the result):
+
+        >>> pd.array([True, False, pd.NA]).any(skipna=False)
+        True
+        >>> pd.array([False, False, pd.NA]).any(skipna=False)
+        <NA>
+        """
+        kwargs.pop("axis", None)
+        nv.validate_any((), kwargs)
+
+        values = self._data.copy()
+        np.putmask(values, self._mask, False)
+        result = values.any()
+        if skipna:
+            return result
+        else:
+            if result or len(self) == 0:
+                return result
+            else:
+                return self.dtype.na_value
+
+    def all(self, skipna: bool = True, **kwargs):
+        """
+        Return whether all elements are True.
+
+        Returns True unless there is at least one element that is False.
+        By default, NAs are skipped. If ``skipna=False`` is specified and
+        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
+        is used as for logical operations.
+
+        Parameters
+        ----------
+        skipna : bool, default True
+            Exclude NA values. If the entire array is NA and `skipna` is
+            True, then the result will be True, as for an empty array.
+            If `skipna` is False, the result will still be False if there is
+            at least one element that is False, otherwise NA will be returned
+            if there are NA's present.
+        **kwargs : any, default None
+            Additional keywords have no effect but might be accepted for
+            compatibility with NumPy.
+
+        Returns
+        -------
+        bool or :attr:`pandas.NA`
+
+        See Also
+        --------
+        numpy.all : Numpy version of this method.
+        BooleanArray.any : Return whether any element is True.
+
+        Examples
+        --------
+
+        The result indicates whether any element is True (and by default
+        skips NAs):
+
+        >>> pd.array([True, True, pd.NA]).all()
+        True
+        >>> pd.array([True, False, pd.NA]).all()
+        False
+        >>> pd.array([], dtype="boolean").all()
+        True
+        >>> pd.array([pd.NA], dtype="boolean").all()
+        True
+
+        With ``skipna=False``, the result can be NA if this is logically
+        required (whether ``pd.NA`` is True or False influences the result):
+
+        >>> pd.array([True, True, pd.NA]).all(skipna=False)
+        <NA>
+        >>> pd.array([True, False, pd.NA]).all(skipna=False)
+        False
+        """
+        kwargs.pop("axis", None)
+        nv.validate_all((), kwargs)
+
+        values = self._data.copy()
+        np.putmask(values, self._mask, True)
+        result = values.all()
+
+        if skipna:
+            return result
+        else:
+            if not result or len(self) == 0:
+                return result
+            else:
+                return self.dtype.na_value
+
+    @classmethod
+    def _create_logical_method(cls, op):
+        def logical_method(self, other):
+            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
+                # Rely on pandas to unbox and dispatch to us.
+                return NotImplemented
+
+            assert op.__name__ in {"or_", "ror_", "and_", "rand_", "xor", "rxor"}
+            other = lib.item_from_zerodim(other)
+            other_is_booleanarray = isinstance(other, BooleanArray)
+            other_is_scalar = lib.is_scalar(other)
+            mask = None
+
+            if other_is_booleanarray:
+                other, mask = other._data, other._mask
+            elif is_list_like(other):
+                other = np.asarray(other, dtype="bool")
+                if other.ndim > 1:
+                    raise NotImplementedError(
+                        "can only perform ops with 1-d structures"
+                    )
+                other, mask = coerce_to_array(other, copy=False)
+            elif isinstance(other, np.bool_):
+                other = other.item()
+
+            if other_is_scalar and not (other is libmissing.NA or lib.is_bool(other)):
+                raise TypeError(
+                    "'other' should be pandas.NA or a bool. "
+                    f"Got {type(other).__name__} instead."
+                )
+
+            if not other_is_scalar and len(self) != len(other):
+                raise ValueError("Lengths must match to compare")
+
+            if op.__name__ in {"or_", "ror_"}:
+                result, mask = ops.kleene_or(self._data, other, self._mask, mask)
+            elif op.__name__ in {"and_", "rand_"}:
+                result, mask = ops.kleene_and(self._data, other, self._mask, mask)
+            elif op.__name__ in {"xor", "rxor"}:
+                result, mask = ops.kleene_xor(self._data, other, self._mask, mask)
+
+            return BooleanArray(result, mask)
+
+        name = f"__{op.__name__}__"
+        return set_function_name(logical_method, name, cls)
+
+    @classmethod
+    def _create_comparison_method(cls, op):
+        def cmp_method(self, other):
+            from pandas.arrays import IntegerArray
+
+            if isinstance(
+                other, (ABCDataFrame, ABCSeries, ABCIndexClass, IntegerArray)
+            ):
+                # Rely on pandas to unbox and dispatch to us.
+                return NotImplemented
+
+            other = lib.item_from_zerodim(other)
+            mask = None
+
+            if isinstance(other, BooleanArray):
+                other, mask = other._data, other._mask
+
+            elif is_list_like(other):
+                other = np.asarray(other)
+                if other.ndim > 1:
+                    raise NotImplementedError(
+                        "can only perform ops with 1-d structures"
+                    )
+                if len(self) != len(other):
+                    raise ValueError("Lengths must match to compare")
+
+            if other is libmissing.NA:
+                # numpy does not handle pd.NA well as "other" scalar (it returns
+                # a scalar False instead of an array)
+                result = np.zeros_like(self._data)
+                mask = np.ones_like(self._data)
+            else:
+                # numpy will show a DeprecationWarning on invalid elementwise
+                # comparisons, this will raise in the future
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", "elementwise", FutureWarning)
+                    with np.errstate(all="ignore"):
+                        result = op(self._data, other)
+
+                # nans propagate
+                if mask is None:
+                    mask = self._mask.copy()
+                else:
+                    mask = self._mask | mask
+
+            return BooleanArray(result, mask, copy=False)
+
+        name = f"__{op.__name__}"
+        return set_function_name(cmp_method, name, cls)
+
+    def _reduce(self, name: str, skipna: bool = True, **kwargs):
+
+        if name in {"any", "all"}:
+            return getattr(self, name)(skipna=skipna, **kwargs)
+
+        data = self._data
+        mask = self._mask
+
+        # coerce to a nan-aware float if needed
+        if self._hasna:
+            data = self.to_numpy("float64", na_value=np.nan)
+
+        op = getattr(nanops, "nan" + name)
+        result = op(data, axis=0, skipna=skipna, mask=mask, **kwargs)
+
+        if np.isnan(result):
+            return libmissing.NA
+
+        # if we have numeric op that would result in an int, coerce to int if possible
+        if name in ["sum", "prod"] and notna(result):
+            int_result = np.int64(result)
+            if int_result == result:
+                result = int_result
+
+        elif name in ["min", "max"] and notna(result):
+            result = np.bool_(result)
+
+        return result
+
+    def _maybe_mask_result(self, result, mask, other, op_name: str):
+        """
+        Parameters
+        ----------
+        result : array-like
+        mask : array-like bool
+        other : scalar or array-like
+        op_name : str
+        """
+        # if we have a float operand we are by-definition
+        # a float result
+        # or our op is a divide
+        if (is_float_dtype(other) or is_float(other)) or (
+            op_name in ["rtruediv", "truediv"]
+        ):
+            result[mask] = np.nan
+            return result
+
+        if is_bool_dtype(result):
+            return BooleanArray(result, mask, copy=False)
+
+        elif is_integer_dtype(result):
+            from pandas.core.arrays import IntegerArray
+
+            return IntegerArray(result, mask, copy=False)
+        else:
+            result[mask] = np.nan
+            return result
+
+    @classmethod
+    def _create_arithmetic_method(cls, op):
+        op_name = op.__name__
+
+        def boolean_arithmetic_method(self, other):
+
+            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
+                # Rely on pandas to unbox and dispatch to us.
+                return NotImplemented
+
+            other = lib.item_from_zerodim(other)
+            mask = None
+
+            if isinstance(other, BooleanArray):
+                other, mask = other._data, other._mask
+
+            elif is_list_like(other):
+                other = np.asarray(other)
+                if other.ndim > 1:
+                    raise NotImplementedError(
+                        "can only perform ops with 1-d structures"
+                    )
+                if len(self) != len(other):
+                    raise ValueError("Lengths must match")
+
+            # nans propagate
+            if mask is None:
+                mask = self._mask
+            else:
+                mask = self._mask | mask
+
+            with np.errstate(all="ignore"):
+                result = op(self._data, other)
+
+            # divmod returns a tuple
+            if op_name == "divmod":
+                div, mod = result
+                return (
+                    self._maybe_mask_result(div, mask, other, "floordiv"),
+                    self._maybe_mask_result(mod, mask, other, "mod"),
+                )
+
+            return self._maybe_mask_result(result, mask, other, op_name)
+
+        name = f"__{op_name}__"
+        return set_function_name(boolean_arithmetic_method, name, cls)
+
+
+BooleanArray._add_logical_ops()
+BooleanArray._add_comparison_ops()
+BooleanArray._add_arithmetic_ops()
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 5929a8d51fe43..d26ff7490e714 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1,14 +1,14 @@
 import operator
 from shutil import get_terminal_size
-import textwrap
-from typing import Type, Union, cast
+from typing import Dict, Hashable, List, Type, Union, cast
 from warnings import warn
 
 import numpy as np
 
 from pandas._config import get_option
 
-from pandas._libs import algos as libalgos, hashtable as htable, lib
+from pandas._libs import algos as libalgos, hashtable as htable
+from pandas._typing import ArrayLike, Dtype, Ordered, Scalar
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import (
     Appender,
@@ -25,11 +25,9 @@
     ensure_platform_int,
     is_categorical_dtype,
     is_datetime64_dtype,
-    is_datetimelike,
     is_dict_like,
     is_dtype_equal,
     is_extension_array_dtype,
-    is_float_dtype,
     is_integer_dtype,
     is_iterator,
     is_list_like,
@@ -37,60 +35,38 @@
     is_scalar,
     is_sequence,
     is_timedelta64_dtype,
+    needs_i8_conversion,
 )
 from pandas.core.dtypes.dtypes import CategoricalDtype
-from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
+from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
 from pandas.core.dtypes.inference import is_hashable
 from pandas.core.dtypes.missing import isna, notna
 
-from pandas._typing import ArrayLike, Dtype, Ordered
 from pandas.core import ops
 from pandas.core.accessor import PandasDelegate, delegate_names
 import pandas.core.algorithms as algorithms
-from pandas.core.algorithms import (
-    _get_data_algo,
-    _hashtables,
-    factorize,
-    take,
-    take_1d,
-    unique1d,
+from pandas.core.algorithms import _get_data_algo, factorize, take, take_1d, unique1d
+from pandas.core.arrays.base import (
+    ExtensionArray,
+    _extension_array_shared_docs,
+    try_cast_to_ea,
 )
 from pandas.core.base import NoNewAttributesMixin, PandasObject, _shared_docs
 import pandas.core.common as com
-from pandas.core.construction import extract_array, sanitize_array
+from pandas.core.construction import array, extract_array, sanitize_array
+from pandas.core.indexers import check_array_indexer, deprecate_ndim_indexing
 from pandas.core.missing import interpolate_2d
+from pandas.core.ops.common import unpack_zerodim_and_defer
 from pandas.core.sorting import nargsort
 
 from pandas.io.formats import console
 
-from .base import ExtensionArray, _extension_array_shared_docs
-
-_take_msg = textwrap.dedent(
-    """\
-    Interpreting negative values in 'indexer' as missing values.
-    In the future, this will change to meaning positional indices
-    from the right.
-
-    Use 'allow_fill=True' to retain the previous behavior and silence this
-    warning.
-
-    Use 'allow_fill=False' to accept the new behavior."""
-)
-
 
 def _cat_compare_op(op):
-    opname = "__{op}__".format(op=op.__name__)
-
-    def f(self, other):
-        # On python2, you can usually compare any type to any type, and
-        # Categoricals can be seen as a custom type, but having different
-        # results depending whether categories are the same or not is kind of
-        # insane, so be a bit stricter here and use the python3 idea of
-        # comparing only things of equal type.
-        if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-            return NotImplemented
-
-        other = lib.item_from_zerodim(other)
+    opname = f"__{op.__name__}__"
+
+    @unpack_zerodim_and_defer(opname)
+    def func(self, other):
         if is_list_like(other) and len(other) != len(self):
             # TODO: Could this fail if the categories are listlike objects?
             raise ValueError("Lengths must match.")
@@ -122,9 +98,9 @@ def f(self, other):
             else:
                 other_codes = other._codes
 
-            mask = (self._codes == -1) | (other_codes == -1)
             f = getattr(self._codes, opname)
             ret = f(other_codes)
+            mask = (self._codes == -1) | (other_codes == -1)
             if mask.any():
                 # In other series, the leads to False, so do that here too
                 ret[mask] = False
@@ -135,21 +111,21 @@ def f(self, other):
                 i = self.categories.get_loc(other)
                 ret = getattr(self._codes, opname)(i)
 
-                # check for NaN in self
-                mask = self._codes == -1
-                ret[mask] = False
+                if opname not in {"__eq__", "__ge__", "__gt__"}:
+                    # check for NaN needed if we are not equal or larger
+                    mask = self._codes == -1
+                    ret[mask] = False
                 return ret
             else:
                 if opname == "__eq__":
-                    return np.repeat(False, len(self))
+                    return np.zeros(len(self), dtype=bool)
                 elif opname == "__ne__":
-                    return np.repeat(True, len(self))
+                    return np.ones(len(self), dtype=bool)
                 else:
-                    msg = (
-                        "Cannot compare a Categorical for op {op} with a "
+                    raise TypeError(
+                        f"Cannot compare a Categorical for op {opname} with a "
                         "scalar, which is not a category."
                     )
-                    raise TypeError(msg.format(op=opname))
         else:
 
             # allow categorical vs object dtype array comparisons for equality
@@ -157,16 +133,15 @@ def f(self, other):
             if opname in ["__eq__", "__ne__"]:
                 return getattr(np.array(self), opname)(np.array(other))
 
-            msg = (
-                "Cannot compare a Categorical for op {op} with type {typ}."
-                "\nIf you want to compare values, use 'np.asarray(cat) "
-                "<op> other'."
+            raise TypeError(
+                f"Cannot compare a Categorical for op {opname} with "
+                f"type {type(other)}.\nIf you want to compare values, "
+                "use 'np.asarray(cat) <op> other'."
             )
-            raise TypeError(msg.format(op=opname, typ=type(other)))
 
-    f.__name__ = opname
+    func.__name__ = opname
 
-    return f
+    return func
 
 
 def contains(cat, key, container):
@@ -261,7 +236,7 @@ class Categorical(ExtensionArray, PandasObject):
         `categories` attribute (which in turn is the `categories` argument, if
         provided).
     dtype : CategoricalDtype
-        An instance of ``CategoricalDtype`` to use for this categorical
+        An instance of ``CategoricalDtype`` to use for this categorical.
 
         .. versionadded:: 0.21.0
 
@@ -295,13 +270,13 @@ class Categorical(ExtensionArray, PandasObject):
 
     See Also
     --------
-    api.types.CategoricalDtype : Type for categorical data.
+    CategoricalDtype : Type for categorical data.
     CategoricalIndex : An Index with an underlying ``Categorical``.
 
     Notes
     -----
     See the `user guide
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html>`_
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html>`_
     for more.
 
     Examples
@@ -331,7 +306,7 @@ class Categorical(ExtensionArray, PandasObject):
     __array_priority__ = 1000
     _dtype = CategoricalDtype(ordered=False)
     # tolist is not actually deprecated, just suppressed in the __dir__
-    _deprecations = frozenset(["labels", "tolist"])
+    _deprecations = PandasObject._deprecations | frozenset(["tolist"])
     _typ = "categorical"
 
     def __init__(
@@ -343,7 +318,7 @@ def __init__(
         )
         # At this point, dtype is always a CategoricalDtype, but
         # we may have dtype.categories be None, and we need to
-        # infer categories in a factorization step futher below
+        # infer categories in a factorization step further below
 
         if fastpath:
             self._codes = coerce_indexer_dtype(values, dtype.categories)
@@ -357,7 +332,7 @@ def __init__(
         # sanitize input
         if is_categorical_dtype(values):
             if dtype.categories is None:
-                dtype = CategoricalDtype(values.categories, dtype._ordered)
+                dtype = CategoricalDtype(values.categories, dtype.ordered)
         elif not isinstance(values, (ABCIndexClass, ABCSeries)):
             # sanitize_array coerces np.nan to a string under certain versions
             # of numpy
@@ -380,7 +355,7 @@ def __init__(
                 codes, categories = factorize(values, sort=True)
             except TypeError:
                 codes, categories = factorize(values, sort=False)
-                if dtype._ordered:
+                if dtype.ordered:
                     # raise, as we don't have a sortable data structure and so
                     # the user should give us one by specifying categories
                     raise TypeError(
@@ -396,7 +371,7 @@ def __init__(
                 )
 
             # we're inferring from values
-            dtype = CategoricalDtype(categories, dtype._ordered)
+            dtype = CategoricalDtype(categories, dtype.ordered)
 
         elif is_categorical_dtype(values):
             old_codes = (
@@ -466,7 +441,7 @@ def ordered(self) -> Ordered:
         """
         Whether the categories have an ordered relationship.
         """
-        return self.dtype._ordered
+        return self.dtype.ordered
 
     @property
     def dtype(self) -> CategoricalDtype:
@@ -520,12 +495,16 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
             if dtype == self.dtype:
                 return self
             return self._set_dtype(dtype)
+        if is_extension_array_dtype(dtype):
+            return array(self, dtype=dtype, copy=copy)  # type: ignore # GH 28770
+        if is_integer_dtype(dtype) and self.isna().any():
+            raise ValueError("Cannot convert float NaN to integer")
         return np.array(self, dtype=dtype, copy=copy)
 
     @cache_readonly
     def size(self) -> int:
         """
-        return the len of myself
+        Return the len of myself.
         """
         return self._codes.size
 
@@ -536,7 +515,7 @@ def itemsize(self) -> int:
         """
         return self.categories.itemsize
 
-    def tolist(self) -> list:
+    def tolist(self) -> List[Scalar]:
         """
         Return a list of the values.
 
@@ -548,13 +527,6 @@ def tolist(self) -> list:
 
     to_list = tolist
 
-    @property
-    def base(self) -> None:
-        """
-        compat, we are always our own object
-        """
-        return None
-
     @classmethod
     def _from_inferred_categories(
         cls, inferred_categories, inferred_codes, dtype, true_values=None
@@ -631,7 +603,7 @@ def from_codes(cls, codes, categories=None, ordered=None, dtype=None):
 
         Parameters
         ----------
-        codes : array-like, integers
+        codes : array-like of int
             An integer array, where each integer points to a category in
             categories or dtype.categories, or else is -1 for NaN.
         categories : index-like, optional
@@ -642,7 +614,7 @@ def from_codes(cls, codes, categories=None, ordered=None, dtype=None):
             Whether or not this categorical is treated as an ordered
             categorical. If not given here or in `dtype`, the resulting
             categorical will be unordered.
-        dtype : CategoricalDtype or the string "category", optional
+        dtype : CategoricalDtype or "category", optional
             If :class:`CategoricalDtype`, cannot be used together with
             `categories` or `ordered`.
 
@@ -673,23 +645,8 @@ def from_codes(cls, codes, categories=None, ordered=None, dtype=None):
             raise ValueError(msg)
 
         codes = np.asarray(codes)  # #21767
-        if not is_integer_dtype(codes):
-            msg = "codes need to be array-like integers"
-            if is_float_dtype(codes):
-                icodes = codes.astype("i8")
-                if (icodes == codes).all():
-                    msg = None
-                    codes = icodes
-                    warn(
-                        (
-                            "float codes will be disallowed in the future and "
-                            "raise a ValueError"
-                        ),
-                        FutureWarning,
-                        stacklevel=2,
-                    )
-            if msg:
-                raise ValueError(msg)
+        if len(codes) and not is_integer_dtype(codes):
+            raise ValueError("codes need to be array-like integers")
 
         if len(codes) and (codes.max() >= len(dtype.categories) or codes.min() < -1):
             raise ValueError("codes need to be between -1 and len(categories)-1")
@@ -843,8 +800,8 @@ def set_categories(self, new_categories, ordered=None, rename=False, inplace=Fal
         On the other hand this methods does not do checks (e.g., whether the
         old categories are included in the new categories on a reorder), which
         can result in surprising changes, for example when using special string
-        dtypes on python3, which does not considers a S1 string equal to a
-        single char python string.
+        dtypes, which does not considers a S1 string equal to a single char
+        python string.
 
         Parameters
         ----------
@@ -879,7 +836,7 @@ def set_categories(self, new_categories, ordered=None, rename=False, inplace=Fal
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
         if ordered is None:
-            ordered = self.dtype._ordered
+            ordered = self.dtype.ordered
         new_dtype = CategoricalDtype(new_categories, ordered=ordered)
 
         cat = self if inplace else self.copy()
@@ -907,24 +864,26 @@ def rename_categories(self, new_categories, inplace=False):
         ----------
         new_categories : list-like, dict-like or callable
 
-           * list-like: all items must be unique and the number of items in
-             the new categories must match the existing number of categories.
+            New categories which will replace old categories.
+
+            * list-like: all items must be unique and the number of items in
+              the new categories must match the existing number of categories.
 
-           * dict-like: specifies a mapping from
-             old categories to new. Categories not contained in the mapping
-             are passed through and extra categories in the mapping are
-             ignored.
+            * dict-like: specifies a mapping from
+              old categories to new. Categories not contained in the mapping
+              are passed through and extra categories in the mapping are
+              ignored.
 
-             .. versionadded:: 0.21.0
+            .. versionadded:: 0.21.0.
 
-           * callable : a callable that is called on all items in the old
-             categories and whose return values comprise the new categories.
+            * callable : a callable that is called on all items in the old
+              categories and whose return values comprise the new categories.
 
-             .. versionadded:: 0.23.0
+            .. versionadded:: 0.23.0.
 
         inplace : bool, default False
-           Whether or not to rename the categories inplace or return a copy of
-           this categorical with renamed categories.
+            Whether or not to rename the categories inplace or return a copy of
+            this categorical with renamed categories.
 
         Returns
         -------
@@ -1059,11 +1018,9 @@ def add_categories(self, new_categories, inplace=False):
             new_categories = [new_categories]
         already_included = set(new_categories) & set(self.dtype.categories)
         if len(already_included) != 0:
-            msg = (
-                "new categories must not include old categories: "
-                "{already_included!s}"
+            raise ValueError(
+                f"new categories must not include old categories: {already_included}"
             )
-            raise ValueError(msg.format(already_included=already_included))
         new_categories = list(self.dtype.categories) + list(new_categories)
         new_dtype = CategoricalDtype(new_categories, self.ordered)
 
@@ -1109,18 +1066,17 @@ def remove_categories(self, removals, inplace=False):
         if not is_list_like(removals):
             removals = [removals]
 
-        removal_set = set(list(removals))
+        removal_set = set(removals)
         not_included = removal_set - set(self.dtype.categories)
         new_categories = [c for c in self.dtype.categories if c not in removal_set]
 
         # GH 10156
         if any(isna(removals)):
-            not_included = [x for x in not_included if notna(x)]
+            not_included = {x for x in not_included if notna(x)}
             new_categories = [x for x in new_categories if notna(x)]
 
         if len(not_included) != 0:
-            msg = "removals must all be in old categories: {not_included!s}"
-            raise ValueError(msg.format(not_included=not_included))
+            raise ValueError(f"removals must all be in old categories: {not_included}")
 
         return self.set_categories(
             new_categories, ordered=self.ordered, rename=False, inplace=inplace
@@ -1298,9 +1254,8 @@ def shift(self, periods, fill_value=None):
                 fill_value = self.categories.get_loc(fill_value)
             else:
                 raise ValueError(
-                    "'fill_value={}' is not present "
-                    "in this Categorical's "
-                    "categories".format(fill_value)
+                    f"'fill_value={fill_value}' is not present "
+                    "in this Categorical's categories"
                 )
             if periods > 0:
                 codes[:periods] = fill_value
@@ -1309,7 +1264,7 @@ def shift(self, periods, fill_value=None):
 
         return self.from_codes(codes, dtype=self.dtype)
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """
         The numpy array interface.
 
@@ -1341,8 +1296,8 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         # for all other cases, raise for now (similarly as what happens in
         # Series.__array_prepare__)
         raise TypeError(
-            "Object with dtype {dtype} cannot perform "
-            "the numpy op {op}".format(dtype=self.dtype, op=ufunc.__name__)
+            f"Object with dtype {self.dtype} cannot perform "
+            f"the numpy op {ufunc.__name__}"
         )
 
     def __setstate__(self, state):
@@ -1350,24 +1305,7 @@ def __setstate__(self, state):
         if not isinstance(state, dict):
             raise Exception("invalid pickle state")
 
-        # Provide compatibility with pre-0.15.0 Categoricals.
-        if "_categories" not in state and "_levels" in state:
-            state["_categories"] = self.dtype.validate_categories(state.pop("_levels"))
-        if "_codes" not in state and "labels" in state:
-            state["_codes"] = coerce_indexer_dtype(
-                state.pop("labels"), state["_categories"]
-            )
-
-        # 0.16.0 ordered change
-        if "_ordered" not in state:
-
-            # >=15.0 < 0.16.0
-            if "ordered" in state:
-                state["_ordered"] = state.pop("ordered")
-            else:
-                state["_ordered"] = False
-
-        # 0.21.0 CategoricalDtype change
+        # compat with pre 0.21.0 CategoricalDtype change
         if "_dtype" not in state:
             state["_dtype"] = CategoricalDtype(state["_categories"], state["_ordered"])
 
@@ -1413,21 +1351,14 @@ def memory_usage(self, deep=False):
     @Substitution(klass="Categorical")
     @Appender(_shared_docs["searchsorted"])
     def searchsorted(self, value, side="left", sorter=None):
-        if not self.ordered:
-            raise ValueError(
-                "Categorical not ordered\nyou can use "
-                ".as_ordered() to change the Categorical to an "
-                "ordered one"
-            )
-
-        from pandas.core.series import Series
-
-        codes = _get_codes_for_values(Series(value).values, self.categories)
-        if -1 in codes:
-            raise KeyError("Value(s) to be inserted must be in categories.")
-
-        codes = codes[0] if is_scalar(value) else codes
-
+        # searchsorted is very performance sensitive. By converting codes
+        # to same dtype as self.codes, we get much faster performance.
+        if is_scalar(value):
+            codes = self.categories.get_loc(value)
+            codes = self.codes.dtype.type(codes)
+        else:
+            locs = [self.categories.get_loc(x) for x in value]
+            codes = np.array(locs, dtype=self.codes.dtype)
         return self.codes.searchsorted(codes, side=side, sorter=sorter)
 
     def isna(self):
@@ -1531,31 +1462,20 @@ def value_counts(self, dropna=True):
 
         return Series(count, index=CategoricalIndex(ix), dtype="int64")
 
-    def get_values(self):
+    def _internal_get_values(self):
         """
         Return the values.
 
-        .. deprecated:: 0.25.0
-
         For internal compatibility with pandas formatting.
 
         Returns
         -------
-        numpy.array
+        np.ndarray or Index
             A numpy array of the same dtype as categorical.categories.dtype or
             Index if datetime / periods.
         """
-        warn(
-            "The 'get_values' method is deprecated and will be removed in a "
-            "future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._internal_get_values()
-
-    def _internal_get_values(self):
         # if we are a datetime and period index, return Index to keep metadata
-        if is_datetimelike(self.categories):
+        if needs_i8_conversion(self.categories):
             return self.categories.take(self._codes, fill_value=np.nan)
         elif is_integer_dtype(self.categories) and -1 in self._codes:
             return self.categories.astype("object").take(self._codes, fill_value=np.nan)
@@ -1565,9 +1485,9 @@ def check_for_ordered(self, op):
         """ assert that we are ordered """
         if not self.ordered:
             raise TypeError(
-                "Categorical is not ordered for operation {op}\n"
+                f"Categorical is not ordered for operation {op}\n"
                 "you can use .as_ordered() to change the "
-                "Categorical to an ordered one\n".format(op=op)
+                "Categorical to an ordered one\n"
             )
 
     def _values_for_argsort(self):
@@ -1702,8 +1622,7 @@ def sort_values(self, inplace=False, ascending=True, na_position="last"):
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
         if na_position not in ["last", "first"]:
-            msg = "invalid na_position: {na_position!r}"
-            raise ValueError(msg.format(na_position=na_position))
+            raise ValueError(f"invalid na_position: {repr(na_position)}")
 
         sorted_idx = nargsort(self, ascending=ascending, na_position=na_position)
 
@@ -1744,24 +1663,6 @@ def _values_for_rank(self):
             )
         return values
 
-    def ravel(self, order="C"):
-        """
-        Return a flattened (numpy) array.
-
-        For internal compatibility with numpy arrays.
-
-        Returns
-        -------
-        numpy.array
-        """
-        warn(
-            "Categorical.ravel will return a Categorical object instead "
-            "of an ndarray in a future version.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return np.array(self)
-
     def view(self, dtype=None):
         if dtype is not None:
             raise NotImplementedError(dtype)
@@ -1779,7 +1680,6 @@ def to_dense(self):
         """
         return np.asarray(self)
 
-    @deprecate_kwarg(old_arg_name="fill_value", new_arg_name="value")
     def fillna(self, value=None, method=None, limit=None):
         """
         Fill NA/NaN values using the specified method.
@@ -1858,14 +1758,13 @@ def fillna(self, value=None, method=None, limit=None):
 
             else:
                 raise TypeError(
-                    '"value" parameter must be a scalar, dict '
-                    "or Series, but you passed a "
-                    '"{0}"'.format(type(value).__name__)
+                    f"'value' parameter must be a scalar, dict "
+                    f"or Series, but you passed a {type(value).__name__}"
                 )
 
         return self._constructor(codes, dtype=self.dtype, fastpath=True)
 
-    def take_nd(self, indexer, allow_fill=None, fill_value=None):
+    def take(self, indexer, allow_fill: bool = False, fill_value=None):
         """
         Take elements from the Categorical.
 
@@ -1874,7 +1773,7 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
         indexer : sequence of int
             The indices in `self` to take. The meaning of negative values in
             `indexer` depends on the value of `allow_fill`.
-        allow_fill : bool, default None
+        allow_fill : bool, default False
             How to handle negative values in `indexer`.
 
             * False: negative values in `indices` indicate positional indices
@@ -1885,11 +1784,9 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
               (the default). These values are set to `fill_value`. Any other
               other negative values raise a ``ValueError``.
 
-            .. versionchanged:: 0.23.0
+            .. versionchanged:: 1.0.0
 
-               Deprecated the default value of `allow_fill`. The deprecated
-               default is ``True``. In the future, this will change to
-               ``False``.
+               Default value changed from ``True`` to ``False``.
 
         fill_value : object
             The value to use for `indices` that are missing (-1), when
@@ -1939,10 +1836,6 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
         will raise a ``TypeError``.
         """
         indexer = np.asarray(indexer, dtype=np.intp)
-        if allow_fill is None:
-            if (indexer < 0).any():
-                warn(_take_msg, FutureWarning, stacklevel=2)
-                allow_fill = True
 
         dtype = self.dtype
 
@@ -1953,16 +1846,26 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
             if fill_value in self.categories:
                 fill_value = self.categories.get_loc(fill_value)
             else:
-                msg = "'fill_value' ('{}') is not in this Categorical's categories."
-                raise TypeError(msg.format(fill_value))
+                msg = (
+                    f"'fill_value' ('{fill_value}') is not in this "
+                    "Categorical's categories."
+                )
+                raise TypeError(msg)
 
         codes = take(self._codes, indexer, allow_fill=allow_fill, fill_value=fill_value)
         result = type(self).from_codes(codes, dtype=dtype)
         return result
 
-    take = take_nd
+    def take_nd(self, indexer, allow_fill: bool = False, fill_value=None):
+        # GH#27745 deprecate alias that other EAs dont have
+        warn(
+            "Categorical.take_nd is deprecated, use Categorical.take instead",
+            FutureWarning,
+            stacklevel=2,
+        )
+        return self.take(indexer, allow_fill=allow_fill, fill_value=fill_value)
 
-    def __len__(self):
+    def __len__(self) -> int:
         """
         The length of this Categorical.
         """
@@ -1974,7 +1877,7 @@ def __iter__(self):
         """
         return iter(self._internal_get_values().tolist())
 
-    def __contains__(self, key):
+    def __contains__(self, key) -> bool:
         """
         Returns True if `key` is in this Categorical.
         """
@@ -1984,7 +1887,7 @@ def __contains__(self, key):
 
         return contains(self, key, container=self._codes)
 
-    def _tidy_repr(self, max_vals=10, footer=True):
+    def _tidy_repr(self, max_vals=10, footer=True) -> str:
         """ a short repr displaying only max_vals and an optional (but default
         footer)
         """
@@ -1992,11 +1895,9 @@ def _tidy_repr(self, max_vals=10, footer=True):
         head = self[:num]._get_repr(length=False, footer=False)
         tail = self[-(max_vals - num) :]._get_repr(length=False, footer=False)
 
-        result = "{head}, ..., {tail}".format(head=head[:-1], tail=tail[1:])
+        result = f"{head[:-1]}, ..., {tail[1:]}"
         if footer:
-            result = "{result}\n{footer}".format(
-                result=result, footer=self._repr_footer()
-            )
+            result = f"{result}\n{self._repr_footer()}"
 
         return str(result)
 
@@ -2023,16 +1924,14 @@ def _repr_categories(self):
         category_strs = [x.strip() for x in category_strs]
         return category_strs
 
-    def _repr_categories_info(self):
+    def _repr_categories_info(self) -> str:
         """
         Returns a string representation of the footer.
         """
 
         category_strs = self._repr_categories()
         dtype = str(self.categories.dtype)
-        levheader = "Categories ({length}, {dtype}): ".format(
-            length=len(self.categories), dtype=dtype
-        )
+        levheader = f"Categories ({len(self.categories)}, {dtype}): "
         width, height = get_terminal_size()
         max_width = get_option("display.width") or width
         if console.in_ipython_frontend():
@@ -2055,13 +1954,11 @@ def _repr_categories_info(self):
         # replace to simple save space by
         return levheader + "[" + levstring.replace(" < ... < ", " ... ") + "]"
 
-    def _repr_footer(self):
-
-        return "Length: {length}\n{info}".format(
-            length=len(self), info=self._repr_categories_info()
-        )
+    def _repr_footer(self) -> str:
+        info = self._repr_categories_info()
+        return f"Length: {len(self)}\n{info}"
 
-    def _get_repr(self, length=True, na_rep="NaN", footer=True):
+    def _get_repr(self, length=True, na_rep="NaN", footer=True) -> str:
         from pandas.io.formats import format as fmt
 
         formatter = fmt.CategoricalFormatter(
@@ -2070,7 +1967,7 @@ def _get_repr(self, length=True, na_rep="NaN", footer=True):
         result = formatter.to_string()
         return str(result)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         String representation.
         """
@@ -2081,7 +1978,7 @@ def __repr__(self):
             result = self._get_repr(length=len(self) > _maxlen)
         else:
             msg = self._get_repr(length=False, footer=True).replace("\n", ", ")
-            result = "[], {repr_msg}".format(repr_msg=msg)
+            result = f"[], {msg}"
 
         return result
 
@@ -2103,16 +2000,19 @@ def __getitem__(self, key):
                 return np.nan
             else:
                 return self.categories[i]
-        else:
-            return self._constructor(
-                values=self._codes[key], dtype=self.dtype, fastpath=True
-            )
+
+        key = check_array_indexer(self, key)
+
+        result = self._codes[key]
+        if result.ndim > 1:
+            deprecate_ndim_indexing(result)
+            return result
+        return self._constructor(result, dtype=self.dtype, fastpath=True)
 
     def __setitem__(self, key, value):
         """
         Item assignment.
 
-
         Raises
         ------
         ValueError
@@ -2173,9 +2073,11 @@ def __setitem__(self, key, value):
 
         lindexer = self.categories.get_indexer(rvalue)
         lindexer = self._maybe_coerce_indexer(lindexer)
+
+        key = check_array_indexer(self, key)
         self._codes[key] = lindexer
 
-    def _reverse_indexer(self):
+    def _reverse_indexer(self) -> Dict[Hashable, np.ndarray]:
         """
         Compute the inverse of a categorical, returning
         a dict of categories -> indexers.
@@ -2205,24 +2107,28 @@ def _reverse_indexer(self):
             self.codes.astype("int64"), categories.size
         )
         counts = counts.cumsum()
-        result = (r[start:end] for start, end in zip(counts, counts[1:]))
-        result = dict(zip(categories, result))
+        _result = (r[start:end] for start, end in zip(counts, counts[1:]))
+        result = dict(zip(categories, _result))
         return result
 
     # reduction ops #
     def _reduce(self, name, axis=0, **kwargs):
         func = getattr(self, name, None)
         if func is None:
-            msg = "Categorical cannot perform the operation {op}"
-            raise TypeError(msg.format(op=name))
+            raise TypeError(f"Categorical cannot perform the operation {name}")
         return func(**kwargs)
 
-    def min(self, numeric_only=None, **kwargs):
+    @deprecate_kwarg(old_arg_name="numeric_only", new_arg_name="skipna")
+    def min(self, skipna=True):
         """
         The minimum value of the object.
 
         Only ordered `Categoricals` have a minimum!
 
+        .. versionchanged:: 1.0.0
+
+           Returns an NA value on empty arrays
+
         Raises
         ------
         TypeError
@@ -2233,22 +2139,31 @@ def min(self, numeric_only=None, **kwargs):
         min : the minimum of this `Categorical`
         """
         self.check_for_ordered("min")
-        if numeric_only:
-            good = self._codes != -1
-            pointer = self._codes[good].min(**kwargs)
-        else:
-            pointer = self._codes.min(**kwargs)
-        if pointer == -1:
-            return np.nan
+
+        if not len(self._codes):
+            return self.dtype.na_value
+
+        good = self._codes != -1
+        if not good.all():
+            if skipna:
+                pointer = self._codes[good].min()
+            else:
+                return np.nan
         else:
-            return self.categories[pointer]
+            pointer = self._codes.min()
+        return self.categories[pointer]
 
-    def max(self, numeric_only=None, **kwargs):
+    @deprecate_kwarg(old_arg_name="numeric_only", new_arg_name="skipna")
+    def max(self, skipna=True):
         """
         The maximum value of the object.
 
         Only ordered `Categoricals` have a maximum!
 
+        .. versionchanged:: 1.0.0
+
+           Returns an NA value on empty arrays
+
         Raises
         ------
         TypeError
@@ -2259,15 +2174,19 @@ def max(self, numeric_only=None, **kwargs):
         max : the maximum of this `Categorical`
         """
         self.check_for_ordered("max")
-        if numeric_only:
-            good = self._codes != -1
-            pointer = self._codes[good].max(**kwargs)
-        else:
-            pointer = self._codes.max(**kwargs)
-        if pointer == -1:
-            return np.nan
+
+        if not len(self._codes):
+            return self.dtype.na_value
+
+        good = self._codes != -1
+        if not good.all():
+            if skipna:
+                pointer = self._codes[good].max()
+            else:
+                return np.nan
         else:
-            return self.categories[pointer]
+            pointer = self._codes.max()
+        return self.categories[pointer]
 
     def mode(self, dropna=True):
         """
@@ -2482,11 +2401,10 @@ def isin(self, values):
         array([ True, False,  True, False,  True, False])
         """
         if not is_list_like(values):
+            values_type = type(values).__name__
             raise TypeError(
-                "only list-like objects are allowed to be passed"
-                " to isin(), you passed a [{values_type}]".format(
-                    values_type=type(values).__name__
-                )
+                "only list-like objects are allowed to be passed "
+                f"to isin(), you passed a [{values_type}]"
             )
         values = sanitize_array(values, None, None)
         null_mask = np.asarray(isna(values))
@@ -2494,6 +2412,51 @@ def isin(self, values):
         code_values = code_values[null_mask | (code_values >= 0)]
         return algorithms.isin(self.codes, code_values)
 
+    def replace(self, to_replace, value, inplace: bool = False):
+        """
+        Replaces all instances of one value with another
+
+        Parameters
+        ----------
+        to_replace: object
+            The value to be replaced
+
+        value: object
+            The value to replace it with
+
+        inplace: bool
+            Whether the operation is done in-place
+
+        Returns
+        -------
+        None if inplace is True, otherwise the new Categorical after replacement
+
+
+        Examples
+        --------
+        >>> s = pd.Categorical([1, 2, 1, 3])
+        >>> s.replace(1, 3)
+        [3, 3, 2, 3]
+        Categories (2, int64): [2, 3]
+        """
+        inplace = validate_bool_kwarg(inplace, "inplace")
+        cat = self if inplace else self.copy()
+        if to_replace in cat.categories:
+            if isna(value):
+                cat.remove_categories(to_replace, inplace=True)
+            else:
+                categories = cat.categories.tolist()
+                index = categories.index(to_replace)
+                if value in cat.categories:
+                    value_index = categories.index(value)
+                    cat._codes[cat._codes == index] = value_index
+                    cat.remove_categories(to_replace, inplace=True)
+                else:
+                    categories[index] = value
+                    cat.rename_categories(categories, inplace=True)
+        if not inplace:
+            return cat
+
 
 # The Series.cat accessor
 
@@ -2576,43 +2539,6 @@ def _delegate_method(self, name, *args, **kwargs):
         if res is not None:
             return Series(res, index=self._index, name=self._name)
 
-    @property
-    def categorical(self):
-        # Note: Upon deprecation, `test_tab_completion_with_categorical` will
-        # need to be updated. `categorical` will need to be removed from
-        # `ok_for_cat`.
-        warn(
-            "`Series.cat.categorical` has been deprecated. Use the "
-            "attributes on 'Series.cat' directly instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._parent
-
-    @property
-    def name(self):
-        # Note: Upon deprecation, `test_tab_completion_with_categorical` will
-        # need to be updated. `name` will need to be removed from
-        # `ok_for_cat`.
-        warn(
-            "`Series.cat.name` has been deprecated. Use `Series.name` instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._name
-
-    @property
-    def index(self):
-        # Note: Upon deprecation, `test_tab_completion_with_categorical` will
-        # need to be updated. `index` will need to be removed from
-        # ok_for_cat`.
-        warn(
-            "`Series.cat.index` has been deprecated. Use `Series.index` instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._index
-
 
 # utility routines
 
@@ -2632,18 +2558,18 @@ def _get_codes_for_values(values, categories):
         # Support inferring the correct extension dtype from an array of
         # scalar objects. e.g.
         # Categorical(array[Period, Period], categories=PeriodIndex(...))
-        try:
-            values = categories.dtype.construct_array_type()._from_sequence(values)
-        except Exception:
-            # but that may fail for any reason, so fall back to object
+        cls = categories.dtype.construct_array_type()
+        values = try_cast_to_ea(cls, values)
+        if not isinstance(values, cls):
+            # exception raised in _from_sequence
             values = ensure_object(values)
             categories = ensure_object(categories)
     else:
         values = ensure_object(values)
         categories = ensure_object(categories)
 
-    (hash_klass, vec_klass), vals = _get_data_algo(values, _hashtables)
-    (_, _), cats = _get_data_algo(categories, _hashtables)
+    hash_klass, vals = _get_data_algo(values)
+    _, cats = _get_data_algo(categories)
     t = hash_klass(len(cats))
     t.map_locations(cats)
     return coerce_indexer_dtype(t.lookup(vals), cats)
@@ -2697,7 +2623,7 @@ def _convert_to_list_like(list_like):
         return [list_like]
 
 
-def _factorize_from_iterable(values):
+def factorize_from_iterable(values):
     """
     Factorize an input `values` into `categories` and `codes`. Preserves
     categorical dtype in `categories`.
@@ -2735,9 +2661,9 @@ def _factorize_from_iterable(values):
     return codes, categories
 
 
-def _factorize_from_iterables(iterables):
+def factorize_from_iterables(iterables):
     """
-    A higher-level wrapper over `_factorize_from_iterable`.
+    A higher-level wrapper over `factorize_from_iterable`.
 
     *This is an internal function*
 
@@ -2752,9 +2678,9 @@ def _factorize_from_iterables(iterables):
 
     Notes
     -----
-    See `_factorize_from_iterable` for more info.
+    See `factorize_from_iterable` for more info.
     """
     if len(iterables) == 0:
         # For consistency, it should return a list of 2 lists.
         return [[], []]
-    return map(list, zip(*(_factorize_from_iterable(it) for it in iterables)))
+    return map(list, zip(*(factorize_from_iterable(it) for it in iterables)))
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index bda5f8f4326f1..03c8e48c6e699 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -6,10 +6,12 @@
 import numpy as np
 
 from pandas._libs import NaT, NaTType, Timestamp, algos, iNaT, lib
-from pandas._libs.tslibs.c_timestamp import maybe_integer_op_deprecated
+from pandas._libs.tslibs.c_timestamp import integer_op_not_supported
 from pandas._libs.tslibs.period import DIFFERENT_FREQ, IncompatibleFrequency, Period
 from pandas._libs.tslibs.timedeltas import Timedelta, delta_to_nanoseconds
 from pandas._libs.tslibs.timestamps import RoundTo, round_nsint64
+from pandas._typing import DatetimeLikeScalar
+from pandas.compat import set_function_name
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError, NullFrequencyError, PerformanceWarning
 from pandas.util._decorators import Appender, Substitution
@@ -26,36 +28,105 @@
     is_integer_dtype,
     is_list_like,
     is_object_dtype,
-    is_offsetlike,
     is_period_dtype,
     is_string_dtype,
     is_timedelta64_dtype,
     is_unsigned_integer_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.generic import (
-    ABCDataFrame,
-    ABCIndexClass,
-    ABCPeriodArray,
-    ABCSeries,
-)
+from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.inference import is_array_like
 from pandas.core.dtypes.missing import is_valid_nat_for_dtype, isna
 
-from pandas._typing import DatetimeLikeScalar
-from pandas.core import missing, nanops
+from pandas.core import missing, nanops, ops
 from pandas.core.algorithms import checked_add_with_arr, take, unique1d, value_counts
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin
 import pandas.core.common as com
-from pandas.core.ops.invalid import make_invalid_op
+from pandas.core.indexers import check_array_indexer
+from pandas.core.ops.common import unpack_zerodim_and_defer
+from pandas.core.ops.invalid import invalid_comparison, make_invalid_op
 
 from pandas.tseries import frequencies
 from pandas.tseries.offsets import DateOffset, Tick
 
-from .base import ExtensionArray, ExtensionOpsMixin
+
+def _datetimelike_array_cmp(cls, op):
+    """
+    Wrap comparison operations to convert Timestamp/Timedelta/Period-like to
+    boxed scalars/arrays.
+    """
+    opname = f"__{op.__name__}__"
+    nat_result = opname == "__ne__"
+
+    @unpack_zerodim_and_defer(opname)
+    def wrapper(self, other):
+
+        if isinstance(other, str):
+            try:
+                # GH#18435 strings get a pass from tzawareness compat
+                other = self._scalar_from_string(other)
+            except ValueError:
+                # failed to parse as Timestamp/Timedelta/Period
+                return invalid_comparison(self, other, op)
+
+        if isinstance(other, self._recognized_scalars) or other is NaT:
+            other = self._scalar_type(other)
+            self._check_compatible_with(other)
+
+            other_i8 = self._unbox_scalar(other)
+
+            result = op(self.view("i8"), other_i8)
+            if isna(other):
+                result.fill(nat_result)
+
+        elif not is_list_like(other):
+            return invalid_comparison(self, other, op)
+
+        elif len(other) != len(self):
+            raise ValueError("Lengths must match")
+
+        else:
+            if isinstance(other, list):
+                # TODO: could use pd.Index to do inference?
+                other = np.array(other)
+
+            if not isinstance(other, (np.ndarray, type(self))):
+                return invalid_comparison(self, other, op)
+
+            if is_object_dtype(other):
+                # We have to use comp_method_OBJECT_ARRAY instead of numpy
+                #  comparison otherwise it would fail to raise when
+                #  comparing tz-aware and tz-naive
+                with np.errstate(all="ignore"):
+                    result = ops.comp_method_OBJECT_ARRAY(
+                        op, self.astype(object), other
+                    )
+                o_mask = isna(other)
+
+            elif not type(self)._is_recognized_dtype(other.dtype):
+                return invalid_comparison(self, other, op)
+
+            else:
+                # For PeriodDType this casting is unnecessary
+                other = type(self)._from_sequence(other)
+                self._check_compatible_with(other)
+
+                result = op(self.view("i8"), other.view("i8"))
+                o_mask = other._isnan
+
+            if o_mask.any():
+                result[o_mask] = nat_result
+
+        if self._hasnans:
+            result[self._isnan] = nat_result
+
+        return result
+
+    return set_function_name(wrapper, opname, cls)
 
 
 class AttributesMixin:
-    _data = None  # type: np.ndarray
+    _data: np.ndarray
 
     @classmethod
     def _simple_new(cls, values, **kwargs):
@@ -113,7 +184,7 @@ def _unbox_scalar(self, value: Union[Period, Timestamp, Timedelta, NaTType]) ->
         raise AbstractMethodError(self)
 
     def _check_compatible_with(
-        self, other: Union[Period, Timestamp, Timedelta, NaTType]
+        self, other: Union[Period, Timestamp, Timedelta, NaTType], setitem: bool = False
     ) -> None:
         """
         Verify that `self` and `other` are compatible.
@@ -127,6 +198,9 @@ def _check_compatible_with(
         Parameters
         ----------
         other
+        setitem : bool, default False
+            For __setitem__ we may have stricter compatiblity resrictions than
+            for comparisons.
 
         Raises
         ------
@@ -179,7 +253,8 @@ def strftime(self, date_format):
                'March 10, 2018, 09:00:02 AM'],
               dtype='object')
         """
-        return self._format_native_types(date_format=date_format).astype(object)
+        result = self._format_native_types(date_format=date_format, na_rep=np.nan)
+        return result.astype(object)
 
 
 class TimelikeOps:
@@ -207,7 +282,7 @@ class TimelikeOps:
               ambiguous times)
             - 'NaT' will return NaT where there are ambiguous times
             - 'raise' will raise an AmbiguousTimeError if there are ambiguous
-              times
+              times.
 
             .. versionadded:: 0.24.0
 
@@ -223,7 +298,7 @@ class TimelikeOps:
             - 'NaT' will return NaT where there are nonexistent times
             - timedelta objects will shift nonexistent times by the timedelta
             - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
@@ -292,16 +367,19 @@ class TimelikeOps:
 
     def _round(self, freq, mode, ambiguous, nonexistent):
         # round the local times
-        values = _ensure_datetimelike_to_i8(self)
+        if is_datetime64tz_dtype(self):
+            # operate on naive timestamps, then convert back to aware
+            naive = self.tz_localize(None)
+            result = naive._round(freq, mode, ambiguous, nonexistent)
+            aware = result.tz_localize(
+                self.tz, ambiguous=ambiguous, nonexistent=nonexistent
+            )
+            return aware
+
+        values = self.view("i8")
         result = round_nsint64(values, mode, freq)
         result = self._maybe_mask_results(result, fill_value=NaT)
-
-        dtype = self.dtype
-        if is_datetime64tz_dtype(self):
-            dtype = None
-        return self._ensure_localized(
-            self._simple_new(result, dtype=dtype), ambiguous, nonexistent
-        )
+        return self._simple_new(result, dtype=self.dtype)
 
     @Appender((_round_doc + _round_example).format(op="round"))
     def round(self, freq, ambiguous="raise", nonexistent="raise"):
@@ -328,6 +406,24 @@ class DatetimeLikeArrayMixin(ExtensionOpsMixin, AttributesMixin, ExtensionArray)
         _generate_range
     """
 
+    @property
+    def ndim(self) -> int:
+        return self._data.ndim
+
+    @property
+    def shape(self):
+        return self._data.shape
+
+    def reshape(self, *args, **kwargs):
+        # Note: we drop any freq
+        data = self._data.reshape(*args, **kwargs)
+        return type(self)(data, dtype=self.dtype)
+
+    def ravel(self, *args, **kwargs):
+        # Note: we drop any freq
+        data = self._data.ravel(*args, **kwargs)
+        return type(self)(data, dtype=self.dtype)
+
     @property
     def _box_func(self):
         """
@@ -385,7 +481,7 @@ def _formatter(self, boxed=False):
     def nbytes(self):
         return self._data.nbytes
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         # used for Timedelta/DatetimeArray, overwritten by PeriodArray
         if is_object_dtype(dtype):
             return np.array(list(self), dtype=object)
@@ -396,7 +492,7 @@ def size(self) -> int:
         """The number of elements in this array."""
         return np.prod(self.shape)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._data)
 
     def __getitem__(self, key):
@@ -416,14 +512,26 @@ def __getitem__(self, key):
         getitem = self._data.__getitem__
         if is_int:
             val = getitem(key)
-            return self._box_func(val)
+            if lib.is_scalar(val):
+                # i.e. self.ndim == 1
+                return self._box_func(val)
+            return type(self)(val, dtype=self.dtype)
 
         if com.is_bool_indexer(key):
+            # first convert to boolean, because check_array_indexer doesn't
+            # allow object dtype
             key = np.asarray(key, dtype=bool)
+            key = check_array_indexer(self, key)
             if key.all():
                 key = slice(0, None, None)
             else:
                 key = lib.maybe_booleans_to_slice(key.view(np.uint8))
+        elif isinstance(key, list) and len(key) == 1 and isinstance(key[0], slice):
+            # see https://github.com/pandas-dev/pandas/issues/31299, need to allow
+            # this for now (would otherwise raise in check_array_indexer)
+            pass
+        else:
+            key = check_array_indexer(self, key)
 
         is_period = is_period_dtype(self)
         if is_period:
@@ -444,8 +552,6 @@ def __getitem__(self, key):
         if result.ndim > 1:
             # To support MPL which performs slicing with 2 dim
             # even though it only has 1 dim by definition
-            if is_period:
-                return self._simple_new(result, dtype=self.dtype, freq=freq)
             return result
 
         return self._simple_new(result, dtype=self.dtype, freq=freq)
@@ -473,29 +579,30 @@ def __setitem__(
                 key = cast(Sequence, key)
                 if len(key) != len(value) and not com.is_bool_indexer(key):
                     msg = (
-                        "shape mismatch: value array of length '{}' does "
-                        "not match indexing result of length '{}'."
+                        f"shape mismatch: value array of length '{len(key)}' "
+                        "does not match indexing result of length "
+                        f"'{len(value)}'."
                     )
-                    raise ValueError(msg.format(len(key), len(value)))
+                    raise ValueError(msg)
                 elif not len(key):
                     return
 
             value = type(self)._from_sequence(value, dtype=self.dtype)
-            self._check_compatible_with(value)
+            self._check_compatible_with(value, setitem=True)
             value = value.asi8
         elif isinstance(value, self._scalar_type):
-            self._check_compatible_with(value)
+            self._check_compatible_with(value, setitem=True)
             value = self._unbox_scalar(value)
         elif is_valid_nat_for_dtype(value, self.dtype):
             value = iNaT
         else:
             msg = (
-                "'value' should be a '{scalar}', 'NaT', or array of those. "
-                "Got '{typ}' instead."
-            )
-            raise TypeError(
-                msg.format(scalar=self._scalar_type.__name__, typ=type(value).__name__)
+                f"'value' should be a '{self._scalar_type.__name__}', 'NaT', "
+                f"or array of those. Got '{type(value).__name__}' instead."
             )
+            raise TypeError(msg)
+
+        key = check_array_indexer(self, key)
         self._data[key] = value
         self._maybe_clear_freq()
 
@@ -535,8 +642,8 @@ def astype(self, dtype, copy=True):
         ) or is_float_dtype(dtype):
             # disallow conversion between datetime/timedelta,
             # and conversions for any datetimelike to float
-            msg = "Cannot cast {name} to dtype {dtype}"
-            raise TypeError(msg.format(name=type(self).__name__, dtype=dtype))
+            msg = f"Cannot cast {type(self).__name__} to dtype {dtype}"
+            raise TypeError(msg)
         elif is_categorical_dtype(dtype):
             return Categorical(self, dtype=dtype)
         else:
@@ -571,7 +678,17 @@ def _validate_fill_value(self, fill_value):
         ------
         ValueError
         """
-        raise AbstractMethodError(self)
+        if isna(fill_value):
+            fill_value = iNaT
+        elif isinstance(fill_value, self._recognized_scalars):
+            self._check_compatible_with(fill_value)
+            fill_value = self._scalar_type(fill_value)
+            fill_value = self._unbox_scalar(fill_value)
+        else:
+            raise ValueError(
+                f"'fill_value' should be a {self._scalar_type}. Got '{fill_value}'."
+            )
+        return fill_value
 
     def take(self, indices, allow_fill=False, fill_value=None):
         if allow_fill:
@@ -585,12 +702,31 @@ def take(self, indices, allow_fill=False, fill_value=None):
 
     @classmethod
     def _concat_same_type(cls, to_concat):
-        dtypes = {x.dtype for x in to_concat}
-        assert len(dtypes) == 1
-        dtype = list(dtypes)[0]
+
+        # do not pass tz to set because tzlocal cannot be hashed
+        dtypes = {str(x.dtype) for x in to_concat}
+        if len(dtypes) != 1:
+            raise ValueError("to_concat must have the same dtype (tz)", dtypes)
+
+        obj = to_concat[0]
+        dtype = obj.dtype
 
         values = np.concatenate([x.asi8 for x in to_concat])
-        return cls(values, dtype=dtype)
+
+        if is_period_dtype(to_concat[0].dtype):
+            new_freq = obj.freq
+        else:
+            # GH 3232: If the concat result is evenly spaced, we can retain the
+            # original frequency
+            new_freq = None
+            to_concat = [x for x in to_concat if len(x)]
+
+            if obj.freq is not None and all(x.freq == obj.freq for x in to_concat):
+                pairs = zip(to_concat[:-1], to_concat[1:])
+                if all(pair[0][-1] + obj.freq == pair[1][0] for pair in pairs):
+                    new_freq = obj.freq
+
+        return cls._simple_new(values, dtype=dtype, freq=new_freq)
 
     def copy(self):
         values = self.asi8.copy()
@@ -637,19 +773,36 @@ def searchsorted(self, value, side="left", sorter=None):
             Array of insertion points with the same shape as `value`.
         """
         if isinstance(value, str):
-            value = self._scalar_from_string(value)
+            try:
+                value = self._scalar_from_string(value)
+            except ValueError:
+                raise TypeError("searchsorted requires compatible dtype or scalar")
 
-        if not (isinstance(value, (self._scalar_type, type(self))) or isna(value)):
-            raise ValueError(
-                "Unexpected type for 'value': {valtype}".format(valtype=type(value))
-            )
+        elif is_valid_nat_for_dtype(value, self.dtype):
+            value = NaT
+
+        elif isinstance(value, self._recognized_scalars):
+            value = self._scalar_type(value)
+
+        elif isinstance(value, np.ndarray):
+            if not type(self)._is_recognized_dtype(value):
+                raise TypeError(
+                    "searchsorted requires compatible dtype or scalar, "
+                    f"not {type(value).__name__}"
+                )
+            value = type(self)(value)
+            self._check_compatible_with(value)
+
+        if not (isinstance(value, (self._scalar_type, type(self))) or (value is NaT)):
+            raise TypeError(f"Unexpected type for 'value': {type(value)}")
 
-        self._check_compatible_with(value)
         if isinstance(value, type(self)):
+            self._check_compatible_with(value)
             value = value.asi8
         else:
             value = self._unbox_scalar(value)
 
+        # TODO: Use datetime64 semantics for sorting, xref GH#29844
         return self.asi8.searchsorted(value, side=side, sorter=sorter)
 
     def repeat(self, repeats, *args, **kwargs):
@@ -670,7 +823,7 @@ def value_counts(self, dropna=False):
 
         Parameters
         ----------
-        dropna : boolean, default True
+        dropna : bool, default True
             Don't include counts of NaT values.
 
         Returns
@@ -728,7 +881,7 @@ def _maybe_mask_results(self, result, fill_value=iNaT, convert=None):
         ----------
         result : a ndarray
         fill_value : object, default iNaT
-        convert : string/dtype or None
+        convert : str, dtype or None
 
         Returns
         -------
@@ -762,8 +915,8 @@ def fillna(self, value=None, method=None, limit=None):
         if is_array_like(value):
             if len(value) != len(self):
                 raise ValueError(
-                    "Length of 'value' does not match. Got ({}) "
-                    " expected {}".format(len(value), len(self))
+                    f"Length of 'value' does not match. Got ({len(value)}) "
+                    f" expected {len(self)}"
                 )
             value = value[mask]
 
@@ -816,7 +969,7 @@ def freq(self, value):
     @property
     def freqstr(self):
         """
-        Return the frequency object as a string if its set, otherwise None
+        Return the frequency object as a string if its set, otherwise None.
         """
         if self.freq is None:
             return None
@@ -829,6 +982,8 @@ def inferred_freq(self):
         generated by infer_freq.  Returns None if it can't autodetect the
         frequency.
         """
+        if self.ndim != 1:
+            return None
         try:
             return frequencies.infer_freq(self)
         except ValueError:
@@ -883,10 +1038,8 @@ def _validate_frequency(cls, index, freq, **kwargs):
             #  raise a ValueError, which we re-raise with a more targeted
             #  message.
             raise ValueError(
-                "Inferred frequency {infer} from passed values "
-                "does not conform to passed frequency {passed}".format(
-                    infer=inferred, passed=freq.freqstr
-                )
+                f"Inferred frequency {inferred} from passed values "
+                f"does not conform to passed frequency {freq.freqstr}"
             )
 
     # monotonicity/uniqueness properties are called via frequencies.infer_freq,
@@ -906,6 +1059,7 @@ def _is_unique(self):
 
     # ------------------------------------------------------------------
     # Arithmetic Methods
+    _create_comparison_method = classmethod(_datetimelike_array_cmp)
 
     # pow is invalid for all three subclasses; TimedeltaArray will override
     #  the multiplication and division ops
@@ -923,29 +1077,21 @@ def _is_unique(self):
     __rdivmod__ = make_invalid_op("__rdivmod__")
 
     def _add_datetimelike_scalar(self, other):
-        # Overriden by TimedeltaArray
-        raise TypeError(
-            "cannot add {cls} and {typ}".format(
-                cls=type(self).__name__, typ=type(other).__name__
-            )
-        )
+        # Overridden by TimedeltaArray
+        raise TypeError(f"cannot add {type(self).__name__} and {type(other).__name__}")
 
     _add_datetime_arraylike = _add_datetimelike_scalar
 
     def _sub_datetimelike_scalar(self, other):
         # Overridden by DatetimeArray
         assert other is not NaT
-        raise TypeError(
-            "cannot subtract a datelike from a {cls}".format(cls=type(self).__name__)
-        )
+        raise TypeError(f"cannot subtract a datelike from a {type(self).__name__}")
 
     _sub_datetime_arraylike = _sub_datetimelike_scalar
 
     def _sub_period(self, other):
-        # Overriden by PeriodArray
-        raise TypeError(
-            "cannot subtract Period from a {cls}".format(cls=type(self).__name__)
-        )
+        # Overridden by PeriodArray
+        raise TypeError(f"cannot subtract Period from a {type(self).__name__}")
 
     def _add_offset(self, offset):
         raise AbstractMethodError(self)
@@ -984,7 +1130,7 @@ def _add_timedeltalike_scalar(self, other):
         """
         if isna(other):
             # i.e np.timedelta64("NaT"), not recognized by delta_to_nanoseconds
-            new_values = np.empty(len(self), dtype="i8")
+            new_values = np.empty(self.shape, dtype="i8")
             new_values[:] = iNaT
             return new_values
 
@@ -1025,14 +1171,12 @@ def _add_nat(self):
         """
         if is_period_dtype(self):
             raise TypeError(
-                "Cannot add {cls} and {typ}".format(
-                    cls=type(self).__name__, typ=type(NaT).__name__
-                )
+                f"Cannot add {type(self).__name__} and {type(NaT).__name__}"
             )
 
         # GH#19124 pd.NaT is treated like a timedelta for both timedelta
         # and datetime dtypes
-        result = np.zeros(len(self), dtype=np.int64)
+        result = np.zeros(self.shape, dtype=np.int64)
         result.fill(iNaT)
         return type(self)(result, dtype=self.dtype, freq=None)
 
@@ -1046,7 +1190,7 @@ def _sub_nat(self):
         # For datetime64 dtypes by convention we treat NaT as a datetime, so
         # this subtraction returns a timedelta64 dtype.
         # For period dtype, timedelta64 is a close-enough return dtype.
-        result = np.zeros(len(self), dtype=np.int64)
+        result = np.zeros(self.shape, dtype=np.int64)
         result.fill(iNaT)
         return result.view("timedelta64[ns]")
 
@@ -1067,13 +1211,9 @@ def _sub_period_array(self, other):
         """
         if not is_period_dtype(self):
             raise TypeError(
-                "cannot subtract {dtype}-dtype from {cls}".format(
-                    dtype=other.dtype, cls=type(self).__name__
-                )
+                f"cannot subtract {other.dtype}-dtype from {type(self).__name__}"
             )
 
-        if len(self) != len(other):
-            raise ValueError("cannot subtract arrays/indices of unequal length")
         if self.freq != other.freq:
             msg = DIFFERENT_FREQ.format(
                 cls=type(self).__name__, own_freq=self.freqstr, other_freq=other.freqstr
@@ -1090,47 +1230,13 @@ def _sub_period_array(self, other):
             new_values[mask] = NaT
         return new_values
 
-    def _addsub_int_array(self, other, op):
-        """
-        Add or subtract array-like of integers equivalent to applying
-        `_time_shift` pointwise.
-
-        Parameters
-        ----------
-        other : Index, ExtensionArray, np.ndarray
-            integer-dtype
-        op : {operator.add, operator.sub}
-
-        Returns
-        -------
-        result : same class as self
-        """
-        # _addsub_int_array is overriden by PeriodArray
-        assert not is_period_dtype(self)
-        assert op in [operator.add, operator.sub]
-
-        if self.freq is None:
-            # GH#19123
-            raise NullFrequencyError("Cannot shift with no freq")
-
-        elif isinstance(self.freq, Tick):
-            # easy case where we can convert to timedelta64 operation
-            td = Timedelta(self.freq)
-            return op(self, td * other)
-
-        # We should only get here with DatetimeIndex; dispatch
-        # to _addsub_offset_array
-        assert not is_timedelta64_dtype(self)
-        return op(self, np.array(other) * self.freq)
-
-    def _addsub_offset_array(self, other, op):
+    def _addsub_object_array(self, other: np.ndarray, op):
         """
         Add or subtract array-like of DateOffset objects
 
         Parameters
         ----------
-        other : Index, np.ndarray
-            object-dtype containing pd.DateOffset objects
+        other : np.ndarray[object]
         op : {operator.add, operator.sub}
 
         Returns
@@ -1143,18 +1249,23 @@ def _addsub_offset_array(self, other, op):
 
         warnings.warn(
             "Adding/subtracting array of DateOffsets to "
-            "{cls} not vectorized".format(cls=type(self).__name__),
+            f"{type(self).__name__} not vectorized",
             PerformanceWarning,
         )
 
         # For EA self.astype('O') returns a numpy array, not an Index
-        left = lib.values_from_object(self.astype("O"))
+        left = self.astype("O")
 
         res_values = op(left, np.array(other))
         kwargs = {}
         if not is_period_dtype(self):
             kwargs["freq"] = "infer"
-        return self._from_sequence(res_values, **kwargs)
+        try:
+            res = type(self)._from_sequence(res_values, **kwargs)
+        except ValueError:
+            # e.g. we've passed a Timestamp to TimedeltaArray
+            res = res_values
+        return res
 
     def _time_shift(self, periods, freq=None):
         """
@@ -1168,7 +1279,7 @@ def _time_shift(self, periods, freq=None):
         ----------
         periods : int
             Number of periods to shift by.
-        freq : pandas.DateOffset, pandas.Timedelta, or string
+        freq : pandas.DateOffset, pandas.Timedelta, or str
             Frequency increment to shift by.
         """
         if freq is not None and freq != self.freq:
@@ -1193,13 +1304,11 @@ def _time_shift(self, periods, freq=None):
         #  to be passed explicitly.
         return self._generate_range(start=start, end=end, periods=None, freq=self.freq)
 
+    @unpack_zerodim_and_defer("__add__")
     def __add__(self, other):
-        other = lib.item_from_zerodim(other)
-        if isinstance(other, (ABCSeries, ABCDataFrame, ABCIndexClass)):
-            return NotImplemented
 
         # scalar others
-        elif other is NaT:
+        if other is NaT:
             result = self._add_nat()
         elif isinstance(other, (Tick, timedelta, np.timedelta64)):
             result = self._add_delta(other)
@@ -1212,22 +1321,22 @@ def __add__(self, other):
             # This check must come after the check for np.timedelta64
             # as is_integer returns True for these
             if not is_period_dtype(self):
-                maybe_integer_op_deprecated(self)
+                raise integer_op_not_supported(self)
             result = self._time_shift(other)
 
         # array-like others
         elif is_timedelta64_dtype(other):
             # TimedeltaIndex, ndarray[timedelta64]
             result = self._add_delta(other)
-        elif is_offsetlike(other):
-            # Array/Index of DateOffset objects
-            result = self._addsub_offset_array(other, operator.add)
+        elif is_object_dtype(other):
+            # e.g. Array/Index of DateOffset objects
+            result = self._addsub_object_array(other, operator.add)
         elif is_datetime64_dtype(other) or is_datetime64tz_dtype(other):
             # DatetimeIndex, ndarray[datetime64]
             return self._add_datetime_arraylike(other)
         elif is_integer_dtype(other):
             if not is_period_dtype(self):
-                maybe_integer_op_deprecated(self)
+                raise integer_op_not_supported(self)
             result = self._addsub_int_array(other, operator.add)
         else:
             # Includes Categorical, other ExtensionArrays
@@ -1247,13 +1356,11 @@ def __radd__(self, other):
         # alias for __add__
         return self.__add__(other)
 
+    @unpack_zerodim_and_defer("__sub__")
     def __sub__(self, other):
-        other = lib.item_from_zerodim(other)
-        if isinstance(other, (ABCSeries, ABCDataFrame, ABCIndexClass)):
-            return NotImplemented
 
         # scalar others
-        elif other is NaT:
+        if other is NaT:
             result = self._sub_nat()
         elif isinstance(other, (Tick, timedelta, np.timedelta64)):
             result = self._add_delta(-other)
@@ -1266,7 +1373,7 @@ def __sub__(self, other):
             # This check must come after the check for np.timedelta64
             # as is_integer returns True for these
             if not is_period_dtype(self):
-                maybe_integer_op_deprecated(self)
+                raise integer_op_not_supported(self)
             result = self._time_shift(-other)
 
         elif isinstance(other, Period):
@@ -1276,9 +1383,9 @@ def __sub__(self, other):
         elif is_timedelta64_dtype(other):
             # TimedeltaIndex, ndarray[timedelta64]
             result = self._add_delta(-other)
-        elif is_offsetlike(other):
-            # Array/Index of DateOffset objects
-            result = self._addsub_offset_array(other, operator.sub)
+        elif is_object_dtype(other):
+            # e.g. Array/Index of DateOffset objects
+            result = self._addsub_object_array(other, operator.sub)
         elif is_datetime64_dtype(other) or is_datetime64tz_dtype(other):
             # DatetimeIndex, ndarray[datetime64]
             result = self._sub_datetime_arraylike(other)
@@ -1287,7 +1394,7 @@ def __sub__(self, other):
             result = self._sub_period_array(other)
         elif is_integer_dtype(other):
             if not is_period_dtype(self):
-                maybe_integer_op_deprecated(self)
+                raise integer_op_not_supported(self)
             result = self._addsub_int_array(other, operator.sub)
         else:
             # Includes ExtensionArrays, float_dtype
@@ -1303,6 +1410,9 @@ def __rsub__(self, other):
         if is_datetime64_any_dtype(other) and is_timedelta64_dtype(self.dtype):
             # ndarray[datetime64] cannot be subtracted from self, so
             # we need to wrap in DatetimeArray/Index and flip the operation
+            if lib.is_scalar(other):
+                # i.e. np.datetime64 object
+                return Timestamp(other) - self
             if not isinstance(other, DatetimeLikeArrayMixin):
                 # Avoid down-casting DatetimeIndex
                 from pandas.core.arrays import DatetimeArray
@@ -1317,17 +1427,11 @@ def __rsub__(self, other):
             # GH#19959 datetime - datetime is well-defined as timedelta,
             # but any other type - datetime is not well-defined.
             raise TypeError(
-                "cannot subtract {cls} from {typ}".format(
-                    cls=type(self).__name__, typ=type(other).__name__
-                )
+                f"cannot subtract {type(self).__name__} from {type(other).__name__}"
             )
         elif is_period_dtype(self.dtype) and is_timedelta64_dtype(other):
             # TODO: Can we simplify/generalize these cases at all?
-            raise TypeError(
-                "cannot subtract {cls} from {dtype}".format(
-                    cls=type(self).__name__, dtype=other.dtype
-                )
-            )
+            raise TypeError(f"cannot subtract {type(self).__name__} from {other.dtype}")
         elif is_timedelta64_dtype(self.dtype):
             if lib.is_integer(other) or is_integer_dtype(other):
                 # need to subtract before negating, since that flips freq
@@ -1338,53 +1442,23 @@ def __rsub__(self, other):
 
         return -(self - other)
 
-    # FIXME: DTA/TDA/PA inplace methods should actually be inplace, GH#24115
-    def __iadd__(self, other):
-        # alias for __add__
-        return self.__add__(other)
-
-    def __isub__(self, other):
-        # alias for __sub__
-        return self.__sub__(other)
-
-    # --------------------------------------------------------------
-    # Comparison Methods
+    def __iadd__(self, other):  # type: ignore
+        result = self + other
+        self[:] = result[:]
 
-    def _ensure_localized(
-        self, arg, ambiguous="raise", nonexistent="raise", from_utc=False
-    ):
-        """
-        Ensure that we are re-localized.
-
-        This is for compat as we can then call this on all datetimelike
-        arrays generally (ignored for Period/Timedelta)
-
-        Parameters
-        ----------
-        arg : Union[DatetimeLikeArray, DatetimeIndexOpsMixin, ndarray]
-        ambiguous : str, bool, or bool-ndarray, default 'raise'
-        nonexistent : str, default 'raise'
-        from_utc : bool, default False
-            If True, localize the i8 ndarray to UTC first before converting to
-            the appropriate tz. If False, localize directly to the tz.
+        if not is_period_dtype(self):
+            # restore freq, which is invalidated by setitem
+            self._freq = result._freq
+        return self
 
-        Returns
-        -------
-        localized array
-        """
+    def __isub__(self, other):  # type: ignore
+        result = self - other
+        self[:] = result[:]
 
-        # reconvert to local tz
-        tz = getattr(self, "tz", None)
-        if tz is not None:
-            if not isinstance(arg, type(self)):
-                arg = self._simple_new(arg)
-            if from_utc:
-                arg = arg.tz_localize("UTC").tz_convert(self.tz)
-            else:
-                arg = arg.tz_localize(
-                    self.tz, ambiguous=ambiguous, nonexistent=nonexistent
-                )
-        return arg
+        if not is_period_dtype(self):
+            # restore freq, which is invalidated by setitem
+            self._freq = result._freq
+        return self
 
     # --------------------------------------------------------------
     # Reductions
@@ -1441,7 +1515,7 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
             values = self.asi8
 
         if not len(values):
-            # short-circut for empty max / min
+            # short-circuit for empty max / min
             return NaT
 
         result = nanops.nanmax(values, skipna=skipna)
@@ -1457,15 +1531,16 @@ def mean(self, skipna=True):
         Parameters
         ----------
         skipna : bool, default True
-            Whether to ignore any NaT elements
+            Whether to ignore any NaT elements.
 
         Returns
         -------
-        scalar (Timestamp or Timedelta)
+        scalar
+            Timestamp or Timedelta.
 
         See Also
         --------
-        numpy.ndarray.mean
+        numpy.ndarray.mean : Returns the average of array elements along a given axis.
         Series.mean : Return the mean value in a Series.
 
         Notes
@@ -1475,9 +1550,9 @@ def mean(self, skipna=True):
         if is_period_dtype(self):
             # See discussion in GH#24757
             raise TypeError(
-                "mean is not implemented for {cls} since the meaning is "
-                "ambiguous.  An alternative is "
-                "obj.to_timestamp(how='start').mean()".format(cls=type(self).__name__)
+                f"mean is not implemented for {type(self).__name__} since the "
+                "meaning is ambiguous.  An alternative is "
+                "obj.to_timestamp(how='start').mean()"
             )
 
         mask = self.isna()
@@ -1489,7 +1564,7 @@ def mean(self, skipna=True):
             values = self
 
         if not len(values):
-            # short-circut for empty max / min
+            # short-circuit for empty max / min
             return NaT
 
         result = nanops.nanmean(values.view("i8"), skipna=skipna)
@@ -1497,6 +1572,8 @@ def mean(self, skipna=True):
         return self._box_func(result)
 
 
+DatetimeLikeArrayMixin._add_comparison_ops()
+
 # -------------------------------------------------------------------
 # Shared Constructor Helpers
 
@@ -1523,9 +1600,7 @@ def validate_periods(periods):
         if lib.is_float(periods):
             periods = int(periods)
         elif not lib.is_integer(periods):
-            raise TypeError(
-                "periods must be a number, got {periods}".format(periods=periods)
-            )
+            raise TypeError(f"periods must be a number, got {periods}")
     return periods
 
 
@@ -1586,9 +1661,9 @@ def validate_inferred_freq(freq, inferred_freq, freq_infer):
     if inferred_freq is not None:
         if freq is not None and freq != inferred_freq:
             raise ValueError(
-                "Inferred frequency {inferred} from passed "
+                f"Inferred frequency {inferred_freq} from passed "
                 "values does not conform to passed frequency "
-                "{passed}".format(inferred=inferred_freq, passed=freq.freqstr)
+                f"{freq.freqstr}"
             )
         elif freq is None:
             freq = inferred_freq
@@ -1622,38 +1697,3 @@ def maybe_infer_freq(freq):
             freq_infer = True
             freq = None
     return freq, freq_infer
-
-
-def _ensure_datetimelike_to_i8(other, to_utc=False):
-    """
-    Helper for coercing an input scalar or array to i8.
-
-    Parameters
-    ----------
-    other : 1d array
-    to_utc : bool, default False
-        If True, convert the values to UTC before extracting the i8 values
-        If False, extract the i8 values directly.
-
-    Returns
-    -------
-    i8 1d array
-    """
-    from pandas import Index
-
-    if lib.is_scalar(other) and isna(other):
-        return iNaT
-    elif isinstance(other, (ABCPeriodArray, ABCIndexClass, DatetimeLikeArrayMixin)):
-        # convert tz if needed
-        if getattr(other, "tz", None) is not None:
-            if to_utc:
-                other = other.tz_convert("UTC")
-            else:
-                other = other.tz_localize(None)
-    else:
-        try:
-            return np.array(other, copy=False).view("i8")
-        except TypeError:
-            # period array cannot be coerced to int
-            other = Index(other)
-    return other.asi8
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 5dff1f93264c3..5888600d2fa8e 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -1,5 +1,4 @@
 from datetime import datetime, time, timedelta
-import textwrap
 from typing import Union
 import warnings
 
@@ -19,19 +18,18 @@
     timezones,
     tzconversion,
 )
-import pandas.compat as compat
 from pandas.errors import PerformanceWarning
-from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
     _INT64_DTYPE,
     _NS_DTYPE,
     is_categorical_dtype,
+    is_datetime64_any_dtype,
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
     is_dtype_equal,
-    is_extension_type,
+    is_extension_array_dtype,
     is_float_dtype,
     is_object_dtype,
     is_period_dtype,
@@ -40,40 +38,18 @@
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
-from pandas.core.dtypes.generic import (
-    ABCDataFrame,
-    ABCIndexClass,
-    ABCPandasArray,
-    ABCSeries,
-)
+from pandas.core.dtypes.generic import ABCIndexClass, ABCPandasArray, ABCSeries
 from pandas.core.dtypes.missing import isna
 
-from pandas.core import ops
 from pandas.core.algorithms import checked_add_with_arr
 from pandas.core.arrays import datetimelike as dtl
 from pandas.core.arrays._ranges import generate_regular_range
 import pandas.core.common as com
-from pandas.core.ops.invalid import invalid_comparison
 
 from pandas.tseries.frequencies import get_period_alias, to_offset
 from pandas.tseries.offsets import Day, Tick
 
 _midnight = time(0, 0)
-# TODO(GH-24559): Remove warning, int_as_wall_time parameter.
-_i8_message = """
-    Passing integer-dtype data and a timezone to DatetimeIndex. Integer values
-    will be interpreted differently in a future version of pandas. Previously,
-    these were viewed as datetime64[ns] values representing the wall time
-    *in the specified timezone*. In the future, these will be viewed as
-    datetime64[ns] values representing the wall time *in UTC*. This is similar
-    to a nanosecond-precision UNIX epoch. To accept the future behavior, use
-
-        pd.to_datetime(integer_data, utc=True).tz_convert(tz)
-
-    To keep the previous behavior, use
-
-        pd.to_datetime(integer_data).tz_localize(tz)
-"""
 
 
 def tz_to_dtype(tz):
@@ -94,22 +70,6 @@ def tz_to_dtype(tz):
         return DatetimeTZDtype(tz=tz)
 
 
-def _to_M8(key, tz=None):
-    """
-    Timestamp-like => dt64
-    """
-    if not isinstance(key, Timestamp):
-        # this also converts strings
-        key = Timestamp(key)
-        if key.tzinfo is not None and tz is not None:
-            # Don't tz_localize(None) if key is already tz-aware
-            key = key.tz_convert(tz)
-        else:
-            key = key.tz_localize(tz)
-
-    return np.int64(conversion.pydt_to_i8(key)).view(_NS_DTYPE)
-
-
 def _field_accessor(name, field, docstring=None):
     def f(self):
         values = self.asi8
@@ -150,90 +110,6 @@ def f(self):
     return property(f)
 
 
-def _dt_array_cmp(cls, op):
-    """
-    Wrap comparison operations to convert datetime-like to datetime64
-    """
-    opname = "__{name}__".format(name=op.__name__)
-    nat_result = opname == "__ne__"
-
-    def wrapper(self, other):
-        if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-            return NotImplemented
-
-        other = lib.item_from_zerodim(other)
-
-        if isinstance(other, (datetime, np.datetime64, str)):
-            if isinstance(other, (datetime, np.datetime64)):
-                # GH#18435 strings get a pass from tzawareness compat
-                self._assert_tzawareness_compat(other)
-
-            try:
-                other = _to_M8(other, tz=self.tz)
-            except ValueError:
-                # string that cannot be parsed to Timestamp
-                return invalid_comparison(self, other, op)
-
-            result = op(self.asi8, other.view("i8"))
-            if isna(other):
-                result.fill(nat_result)
-        elif lib.is_scalar(other) or np.ndim(other) == 0:
-            return invalid_comparison(self, other, op)
-        elif len(other) != len(self):
-            raise ValueError("Lengths must match")
-        else:
-            if isinstance(other, list):
-                try:
-                    other = type(self)._from_sequence(other)
-                except ValueError:
-                    other = np.array(other, dtype=np.object_)
-            elif not isinstance(
-                other, (np.ndarray, ABCIndexClass, ABCSeries, DatetimeArray)
-            ):
-                # Following Timestamp convention, __eq__ is all-False
-                # and __ne__ is all True, others raise TypeError.
-                return invalid_comparison(self, other, op)
-
-            if is_object_dtype(other):
-                # We have to use comp_method_OBJECT_ARRAY instead of numpy
-                #  comparison otherwise it would fail to raise when
-                #  comparing tz-aware and tz-naive
-                with np.errstate(all="ignore"):
-                    result = ops.comp_method_OBJECT_ARRAY(
-                        op, self.astype(object), other
-                    )
-                o_mask = isna(other)
-            elif not (is_datetime64_dtype(other) or is_datetime64tz_dtype(other)):
-                # e.g. is_timedelta64_dtype(other)
-                return invalid_comparison(self, other, op)
-            else:
-                self._assert_tzawareness_compat(other)
-                if isinstance(other, (ABCIndexClass, ABCSeries)):
-                    other = other.array
-
-                if (
-                    is_datetime64_dtype(other)
-                    and not is_datetime64_ns_dtype(other)
-                    or not hasattr(other, "asi8")
-                ):
-                    # e.g. other.dtype == 'datetime64[s]'
-                    # or an object-dtype ndarray
-                    other = type(self)._from_sequence(other)
-
-                result = op(self.view("i8"), other.view("i8"))
-                o_mask = other._isnan
-
-            if o_mask.any():
-                result[o_mask] = nat_result
-
-        if self._hasnans:
-            result[self._isnan] = nat_result
-
-        return result
-
-    return compat.set_function_name(wrapper, opname, cls)
-
-
 class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps):
     """
     Pandas ExtensionArray for tz-naive or tz-aware datetime data.
@@ -253,12 +129,12 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps
         The datetime data.
 
         For DatetimeArray `values` (or a Series or Index boxing one),
-        `dtype` and `freq` will be extracted from `values`, with
-        precedence given to
+        `dtype` and `freq` will be extracted from `values`.
 
     dtype : numpy.dtype or DatetimeTZDtype
         Note that the only NumPy dtype allowed is 'datetime64[ns]'.
     freq : str or Offset, optional
+        The frequency.
     copy : bool, default False
         Whether to copy the underlying array of values.
 
@@ -273,6 +149,8 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps
 
     _typ = "datetimearray"
     _scalar_type = Timestamp
+    _recognized_scalars = (datetime, np.datetime64)
+    _is_recognized_dtype = is_datetime64_any_dtype
 
     # define my properties & methods for delegation
     _bool_ops = [
@@ -284,7 +162,7 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps
         "is_year_end",
         "is_leap_year",
     ]
-    _object_ops = ["weekday_name", "freq", "tz"]
+    _object_ops = ["freq", "tz"]
     _field_ops = [
         "year",
         "month",
@@ -327,7 +205,7 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps
     # -----------------------------------------------------------------
     # Constructors
 
-    _dtype = None  # type: Union[np.dtype, DatetimeTZDtype]
+    _dtype: Union[np.dtype, DatetimeTZDtype]
     _freq = None
 
     def __init__(self, values, dtype=_NS_DTYPE, freq=None, copy=False):
@@ -345,23 +223,22 @@ def __init__(self, values, dtype=_NS_DTYPE, freq=None, copy=False):
                 if not timezones.tz_compare(dtz, values.tz):
                     msg = (
                         "Timezone of the array and 'dtype' do not match. "
-                        "'{}' != '{}'"
+                        f"'{dtz}' != '{values.tz}'"
                     )
-                    raise TypeError(msg.format(dtz, values.tz))
+                    raise TypeError(msg)
             elif values.tz:
                 dtype = values.dtype
-            # freq = validate_values_freq(values, freq)
+
             if freq is None:
                 freq = values.freq
             values = values._data
 
         if not isinstance(values, np.ndarray):
-            msg = (
-                "Unexpected type '{}'. 'values' must be a DatetimeArray "
-                "ndarray, or Series or Index containing one of those."
+            raise ValueError(
+                f"Unexpected type '{type(values).__name__}'. 'values' must be "
+                "a DatetimeArray ndarray, or Series or Index containing one of those."
             )
-            raise ValueError(msg.format(type(values).__name__))
-        if values.ndim != 1:
+        if values.ndim not in [1, 2]:
             raise ValueError("Only 1-dimensional input arrays are supported.")
 
         if values.dtype == "i8":
@@ -371,20 +248,18 @@ def __init__(self, values, dtype=_NS_DTYPE, freq=None, copy=False):
             values = values.view(_NS_DTYPE)
 
         if values.dtype != _NS_DTYPE:
-            msg = (
-                "The dtype of 'values' is incorrect. Must be 'datetime64[ns]'."
-                " Got {} instead."
+            raise ValueError(
+                "The dtype of 'values' is incorrect. Must be 'datetime64[ns]'. "
+                f"Got {values.dtype} instead."
             )
-            raise ValueError(msg.format(values.dtype))
 
         dtype = _validate_dt64_dtype(dtype)
 
         if freq == "infer":
-            msg = (
+            raise ValueError(
                 "Frequency inference not allowed in DatetimeArray.__init__. "
                 "Use 'pd.array()' instead."
             )
-            raise ValueError(msg)
 
         if copy:
             values = values.copy()
@@ -428,7 +303,6 @@ def _from_sequence(
         dayfirst=False,
         yearfirst=False,
         ambiguous="raise",
-        int_as_wall_time=False,
     ):
 
         freq, freq_infer = dtl.maybe_infer_freq(freq)
@@ -441,7 +315,6 @@ def _from_sequence(
             dayfirst=dayfirst,
             yearfirst=yearfirst,
             ambiguous=ambiguous,
-            int_as_wall_time=int_as_wall_time,
         )
 
         freq, freq_infer = dtl.validate_inferred_freq(freq, inferred_freq, freq_infer)
@@ -580,15 +453,14 @@ def _unbox_scalar(self, value):
     def _scalar_from_string(self, value):
         return Timestamp(value, tz=self.tz)
 
-    def _check_compatible_with(self, other):
+    def _check_compatible_with(self, other, setitem: bool = False):
         if other is NaT:
             return
-        if not timezones.tz_compare(self.tz, other.tz):
-            raise ValueError(
-                "Timezones don't match. '{own} != {other}'".format(
-                    own=self.tz, other=other.tz
-                )
-            )
+        self._assert_tzawareness_compat(other)
+        if setitem:
+            # Stricter check for setitem vs comparison methods
+            if not timezones.tz_compare(self.tz, other.tz):
+                raise ValueError(f"Timezones don't match. '{self.tz} != {other.tz}'")
 
     def _maybe_clear_freq(self):
         self._freq = None
@@ -671,7 +543,7 @@ def _resolution(self):
     # ----------------------------------------------------------------
     # Array-Like / EA-Interface Methods
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         if dtype is None and self.tz:
             # The default for tz-aware is object, to preserve tz info
             dtype = object
@@ -728,23 +600,6 @@ def astype(self, dtype, copy=True):
             return self.to_period(freq=dtype.freq)
         return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy)
 
-    # ----------------------------------------------------------------
-    # ExtensionArray Interface
-
-    @Appender(dtl.DatetimeLikeArrayMixin._validate_fill_value.__doc__)
-    def _validate_fill_value(self, fill_value):
-        if isna(fill_value):
-            fill_value = iNaT
-        elif isinstance(fill_value, (datetime, np.datetime64)):
-            self._assert_tzawareness_compat(fill_value)
-            fill_value = Timestamp(fill_value).value
-        else:
-            raise ValueError(
-                "'fill_value' should be a Timestamp. "
-                "Got '{got}'.".format(got=fill_value)
-            )
-        return fill_value
-
     # -----------------------------------------------------------------
     # Rendering Methods
 
@@ -760,8 +615,6 @@ def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
     # -----------------------------------------------------------------
     # Comparison Methods
 
-    _create_comparison_method = classmethod(_dt_array_cmp)
-
     def _has_same_tz(self, other):
         zzone = self._timezone
 
@@ -806,8 +659,8 @@ def _sub_datetime_arraylike(self, other):
         if not self._has_same_tz(other):
             # require tz compat
             raise TypeError(
-                "{cls} subtraction must have the same "
-                "timezones or no timezones".format(cls=type(self).__name__)
+                f"{type(self).__name__} subtraction must have the same "
+                "timezones or no timezones"
             )
 
         self_i8 = self.asi8
@@ -819,15 +672,16 @@ def _sub_datetime_arraylike(self, other):
         return new_values.view("timedelta64[ns]")
 
     def _add_offset(self, offset):
+        if self.ndim == 2:
+            return self.ravel()._add_offset(offset).reshape(self.shape)
+
         assert not isinstance(offset, Tick)
         try:
             if self.tz is not None:
                 values = self.tz_localize(None)
             else:
                 values = self
-            result = offset.apply_index(values)
-            if self.tz is not None:
-                result = result.tz_localize(self.tz)
+            result = offset.apply_index(values).tz_localize(self.tz)
 
         except NotImplementedError:
             warnings.warn(
@@ -835,6 +689,9 @@ def _add_offset(self, offset):
                 PerformanceWarning,
             )
             result = self.astype("O") + offset
+            if not len(self):
+                # GH#30336 _from_sequence won't be able to infer self.tz
+                return type(self)._from_sequence(result).tz_localize(self.tz)
 
         return type(self)._from_sequence(result, freq="infer")
 
@@ -962,7 +819,7 @@ def tz_convert(self, tz):
         dtype = tz_to_dtype(tz)
         return self._simple_new(self.asi8, dtype=dtype, freq=self.freq)
 
-    def tz_localize(self, tz, ambiguous="raise", nonexistent="raise", errors=None):
+    def tz_localize(self, tz, ambiguous="raise", nonexistent="raise"):
         """
         Localize tz-naive Datetime Array/Index to tz-aware
         Datetime Array/Index.
@@ -993,7 +850,7 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise", errors=None):
               ambiguous times)
             - 'NaT' will return NaT where there are ambiguous times
             - 'raise' will raise an AmbiguousTimeError if there are ambiguous
-              times
+              times.
 
         nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, \
 default 'raise'
@@ -1007,20 +864,10 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise", errors=None):
             - 'NaT' will return NaT where there are nonexistent times
             - timedelta objects will shift nonexistent times by the timedelta
             - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
-        errors : {'raise', 'coerce'}, default None
-
-            - 'raise' will raise a NonExistentTimeError if a timestamp is not
-              valid in the specified time zone (e.g. due to a transition from
-              or to DST time). Use ``nonexistent='raise'`` instead.
-            - 'coerce' will return NaT if the timestamp can not be converted
-              to the specified time zone. Use ``nonexistent='NaT'`` instead.
-
-            .. deprecated:: 0.24.0
-
         Returns
         -------
         Same type as self
@@ -1111,31 +958,14 @@ def tz_localize(self, tz, ambiguous="raise", nonexistent="raise", errors=None):
         1   2015-03-29 03:30:00+02:00
         dtype: datetime64[ns, 'Europe/Warsaw']
         """
-        if errors is not None:
-            warnings.warn(
-                "The errors argument is deprecated and will be "
-                "removed in a future release. Use "
-                "nonexistent='NaT' or nonexistent='raise' "
-                "instead.",
-                FutureWarning,
-            )
-            if errors == "coerce":
-                nonexistent = "NaT"
-            elif errors == "raise":
-                nonexistent = "raise"
-            else:
-                raise ValueError(
-                    "The errors argument must be either 'coerce' or 'raise'."
-                )
-
         nonexistent_options = ("raise", "NaT", "shift_forward", "shift_backward")
         if nonexistent not in nonexistent_options and not isinstance(
             nonexistent, timedelta
         ):
             raise ValueError(
-                "The nonexistent argument must be one of 'raise',"
-                " 'NaT', 'shift_forward', 'shift_backward' or"
-                " a timedelta object"
+                "The nonexistent argument must be one of 'raise', "
+                "'NaT', 'shift_forward', 'shift_backward' or "
+                "a timedelta object"
             )
 
         if self.tz is not None:
@@ -1208,7 +1038,7 @@ def normalize(self):
         """
         if self.tz is None or timezones.is_utc(self.tz):
             not_null = ~self.isna()
-            DAY_NS = ccalendar.DAY_SECONDS * 1000000000
+            DAY_NS = ccalendar.DAY_SECONDS * 1_000_000_000
             new_values = self.asi8.copy()
             adjustment = new_values[not_null] % DAY_NS
             new_values[not_null] = new_values[not_null] - adjustment
@@ -1432,7 +1262,7 @@ def date(self):
         "day",
         "D",
         """
-        The month as January=1, December=12.
+        The day of the datetime.
         """,
     )
     hour = _field_accessor(
@@ -1515,14 +1345,6 @@ def date(self):
     dayofweek = _field_accessor("dayofweek", "dow", _dayofweek_doc)
     weekday = dayofweek
 
-    weekday_name = _field_accessor(
-        "weekday_name",
-        "weekday_name",
-        """
-        The name of day in a week (ex: Friday)\n\n.. deprecated:: 0.23.0
-        """,
-    )
-
     dayofyear = _field_accessor(
         "dayofyear",
         "doy",
@@ -1815,7 +1637,7 @@ def to_julian_date(self):
         """
         Convert Datetime Array to float64 ndarray of Julian Dates.
         0 Julian date is noon January 1, 4713 BC.
-        http://en.wikipedia.org/wiki/Julian_day
+        https://en.wikipedia.org/wiki/Julian_day
         """
 
         # http://mysite.verizon.net/aesir_research/date/jdalg2.htm
@@ -1832,7 +1654,7 @@ def to_julian_date(self):
             + np.floor(year / 4)
             - np.floor(year / 100)
             + np.floor(year / 400)
-            + 1721118.5
+            + 1_721_118.5
             + (
                 self.hour
                 + self.minute / 60.0
@@ -1844,9 +1666,6 @@ def to_julian_date(self):
         )
 
 
-DatetimeArray._add_comparison_ops()
-
-
 # -------------------------------------------------------------------
 # Constructor Helpers
 
@@ -1859,7 +1678,6 @@ def sequence_to_dt64ns(
     dayfirst=False,
     yearfirst=False,
     ambiguous="raise",
-    int_as_wall_time=False,
 ):
     """
     Parameters
@@ -1871,14 +1689,7 @@ def sequence_to_dt64ns(
     dayfirst : bool, default False
     yearfirst : bool, default False
     ambiguous : str, bool, or arraylike, default 'raise'
-        See pandas._libs.tslibs.conversion.tz_localize_to_utc
-    int_as_wall_time : bool, default False
-        Whether to treat ints as wall time in specified timezone, or as
-        nanosecond-precision UNIX epoch (wall time in UTC).
-        This is used in DatetimeIndex.__init__ to deprecate the wall-time
-        behaviour.
-
-        ..versionadded:: 0.24.0
+        See pandas._libs.tslibs.conversion.tz_localize_to_utc.
 
     Returns
     -------
@@ -1918,6 +1729,9 @@ def sequence_to_dt64ns(
     tz = validate_tz_from_dtype(dtype, tz)
 
     if isinstance(data, ABCIndexClass):
+        if data.nlevels > 1:
+            # Without this check, data._data below is None
+            raise TypeError("Cannot create a DatetimeArray from a MultiIndex.")
         data = data._data
 
     # By this point we are assured to have either a numpy array or Index
@@ -1936,10 +1750,6 @@ def sequence_to_dt64ns(
                 data, dayfirst=dayfirst, yearfirst=yearfirst
             )
             tz = maybe_infer_tz(tz, inferred_tz)
-            # When a sequence of timestamp objects is passed, we always
-            # want to treat the (now i8-valued) data as UTC timestamps,
-            # not wall times.
-            int_as_wall_time = False
 
     # `data` may have originally been a Categorical[datetime64[ns, tz]],
     # so we need to handle these types.
@@ -1973,12 +1783,6 @@ def sequence_to_dt64ns(
 
         if data.dtype != _INT64_DTYPE:
             data = data.astype(np.int64, copy=False)
-        if int_as_wall_time and tz is not None and not timezones.is_utc(tz):
-            warnings.warn(_i8_message, FutureWarning, stacklevel=4)
-            data = conversion.tz_localize_to_utc(
-                data.view("i8"), tz, ambiguous=ambiguous
-            )
-            data = data.view(_NS_DTYPE)
         result = data.view(_NS_DTYPE)
 
     if copy:
@@ -2012,7 +1816,7 @@ def objects_to_datetime64ns(
     dayfirst : bool
     yearfirst : bool
     utc : bool, default False
-        Whether to convert timezone-aware timestamps to UTC
+        Whether to convert timezone-aware timestamps to UTC.
     errors : {'raise', 'ignore', 'coerce'}
     allow_object : bool
         Whether to return an object-dtype ndarray instead of raising if the
@@ -2105,19 +1909,13 @@ def maybe_convert_dtype(data, copy):
         #  with integer dtypes.  See discussion in GH#23675
 
     elif is_timedelta64_dtype(data):
-        warnings.warn(
-            "Passing timedelta64-dtype data is deprecated, will "
-            "raise a TypeError in a future version",
-            FutureWarning,
-            stacklevel=5,
-        )
-        data = data.view(_NS_DTYPE)
-
+        # GH#29794 enforcing deprecation introduced in GH#23539
+        raise TypeError(f"dtype {data.dtype} cannot be converted to datetime64[ns]")
     elif is_period_dtype(data):
         # Note: without explicitly raising here, PeriodIndex
         #  test_setops.test_join_does_not_recur fails
         raise TypeError(
-            "Passing PeriodDtype data is invalid.  Use `data.to_timestamp()` instead"
+            "Passing PeriodDtype data is invalid. Use `data.to_timestamp()` instead"
         )
 
     elif is_categorical_dtype(data):
@@ -2127,7 +1925,7 @@ def maybe_convert_dtype(data, copy):
         data = data.categories.take(data.codes, fill_value=NaT)._values
         copy = False
 
-    elif is_extension_type(data) and not is_datetime64tz_dtype(data):
+    elif is_extension_array_dtype(data) and not is_datetime64tz_dtype(data):
         # Includes categorical
         # TODO: We have no tests for these
         data = np.array(data, dtype=np.object_)
@@ -2164,8 +1962,8 @@ def maybe_infer_tz(tz, inferred_tz):
         pass
     elif not timezones.tz_compare(tz, inferred_tz):
         raise TypeError(
-            "data is already tz-aware {inferred_tz}, unable to "
-            "set specified tz: {tz}".format(inferred_tz=inferred_tz, tz=tz)
+            f"data is already tz-aware {inferred_tz}, unable to "
+            f"set specified tz: {tz}"
         )
     return tz
 
@@ -2195,22 +1993,19 @@ def _validate_dt64_dtype(dtype):
     if dtype is not None:
         dtype = pandas_dtype(dtype)
         if is_dtype_equal(dtype, np.dtype("M8")):
-            # no precision, warn
-            dtype = _NS_DTYPE
-            msg = textwrap.dedent(
-                """\
-                Passing in 'datetime64' dtype with no precision is deprecated
-                and will raise in a future version. Please pass in
-                'datetime64[ns]' instead."""
+            # no precision, disallowed GH#24806
+            msg = (
+                "Passing in 'datetime64' dtype with no precision is not allowed. "
+                "Please pass in 'datetime64[ns]' instead."
             )
-            warnings.warn(msg, FutureWarning, stacklevel=5)
+            raise ValueError(msg)
 
         if (isinstance(dtype, np.dtype) and dtype != _NS_DTYPE) or not isinstance(
             dtype, (np.dtype, DatetimeTZDtype)
         ):
             raise ValueError(
-                "Unexpected value for 'dtype': '{dtype}'. "
-                "Must be 'datetime64[ns]' or DatetimeTZDtype'.".format(dtype=dtype)
+                f"Unexpected value for 'dtype': '{dtype}'. "
+                "Must be 'datetime64[ns]' or DatetimeTZDtype'."
             )
     return dtype
 
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 7b03bf35faf25..19ab43fc1c248 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -1,10 +1,11 @@
 import numbers
-from typing import Type
+from typing import TYPE_CHECKING, Tuple, Type, Union
 import warnings
 
 import numpy as np
 
-from pandas._libs import lib
+from pandas._libs import lib, missing as libmissing
+from pandas._typing import ArrayLike
 from pandas.compat import set_function_name
 from pandas.util._decorators import cache_readonly
 
@@ -19,16 +20,23 @@
     is_list_like,
     is_object_dtype,
     is_scalar,
+    pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import register_extension_dtype
-from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
-from pandas.core.dtypes.missing import isna, notna
+from pandas.core.dtypes.missing import isna
 
 from pandas.core import nanops, ops
-from pandas.core.algorithms import take
-from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+import pandas.core.common as com
+from pandas.core.indexers import check_array_indexer
+from pandas.core.ops import invalid_comparison
+from pandas.core.ops.common import unpack_zerodim_and_defer
 from pandas.core.tools.numeric import to_numeric
 
+from .masked import BaseMaskedArray
+
+if TYPE_CHECKING:
+    import pyarrow  # noqa: F401
+
 
 class _IntegerDtype(ExtensionDtype):
     """
@@ -40,44 +48,45 @@ class _IntegerDtype(ExtensionDtype):
     The attributes name & type are set when these subclasses are created.
     """
 
-    name = None  # type: str
+    name: str
     base = None
-    type = None  # type: Type
-    na_value = np.nan
+    type: Type
+    na_value = libmissing.NA
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         sign = "U" if self.is_unsigned_integer else ""
-        return "{sign}Int{size}Dtype()".format(sign=sign, size=8 * self.itemsize)
+        return f"{sign}Int{8 * self.itemsize}Dtype()"
 
     @cache_readonly
-    def is_signed_integer(self):
+    def is_signed_integer(self) -> bool:
         return self.kind == "i"
 
     @cache_readonly
-    def is_unsigned_integer(self):
+    def is_unsigned_integer(self) -> bool:
         return self.kind == "u"
 
     @property
-    def _is_numeric(self):
+    def _is_numeric(self) -> bool:
         return True
 
     @cache_readonly
-    def numpy_dtype(self):
+    def numpy_dtype(self) -> np.dtype:
         """ Return an instance of our numpy dtype """
         return np.dtype(self.type)
 
     @cache_readonly
-    def kind(self):
+    def kind(self) -> str:
         return self.numpy_dtype.kind
 
     @cache_readonly
-    def itemsize(self):
+    def itemsize(self) -> int:
         """ Return the number of bytes in this dtype """
         return self.numpy_dtype.itemsize
 
     @classmethod
-    def construct_array_type(cls):
-        """Return the array type associated with this dtype
+    def construct_array_type(cls) -> Type["IntegerArray"]:
+        """
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -85,8 +94,31 @@ def construct_array_type(cls):
         """
         return IntegerArray
 
+    def __from_arrow__(
+        self, array: Union["pyarrow.Array", "pyarrow.ChunkedArray"]
+    ) -> "IntegerArray":
+        """
+        Construct IntegerArray from pyarrow Array/ChunkedArray.
+        """
+        import pyarrow  # noqa: F811
+        from pandas.core.arrays._arrow_utils import pyarrow_array_to_numpy_and_mask
+
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            # pyarrow.ChunkedArray
+            chunks = array.chunks
+
+        results = []
+        for arr in chunks:
+            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype=self.type)
+            int_arr = IntegerArray(data.copy(), ~mask, copy=False)
+            results.append(int_arr)
 
-def integer_array(values, dtype=None, copy=False):
+        return IntegerArray._concat_same_type(results)
+
+
+def integer_array(values, dtype=None, copy: bool = False,) -> "IntegerArray":
     """
     Infer and return an integer array of the values.
 
@@ -95,7 +127,7 @@ def integer_array(values, dtype=None, copy=False):
     values : 1D list-like
     dtype : dtype, optional
         dtype to coerce
-    copy : boolean, default False
+    copy : bool, default False
 
     Returns
     -------
@@ -109,7 +141,7 @@ def integer_array(values, dtype=None, copy=False):
     return IntegerArray(values, mask)
 
 
-def safe_cast(values, dtype, copy):
+def safe_cast(values, dtype, copy: bool):
     """
     Safely cast the values to the dtype if they
     are equivalent, meaning floats must be equivalent to the
@@ -126,13 +158,13 @@ def safe_cast(values, dtype, copy):
             return casted
 
         raise TypeError(
-            "cannot safely cast non-equivalent {} to {}".format(
-                values.dtype, np.dtype(dtype)
-            )
+            f"cannot safely cast non-equivalent {values.dtype} to {np.dtype(dtype)}"
         )
 
 
-def coerce_to_array(values, dtype, mask=None, copy=False):
+def coerce_to_array(
+    values, dtype, mask=None, copy: bool = False,
+) -> Tuple[np.ndarray, np.ndarray]:
     """
     Coerce the input values array to numpy arrays with a mask
 
@@ -140,8 +172,8 @@ def coerce_to_array(values, dtype, mask=None, copy=False):
     ----------
     values : 1D list-like
     dtype : integer dtype
-    mask : boolean 1D array, optional
-    copy : boolean, default False
+    mask : bool 1D array, optional
+    copy : bool, default False
         if True, copy the input
 
     Returns
@@ -165,7 +197,7 @@ def coerce_to_array(values, dtype, mask=None, copy=False):
             try:
                 dtype = _dtypes[str(np.dtype(dtype))]
             except KeyError:
-                raise ValueError("invalid dtype specified {}".format(dtype))
+                raise ValueError(f"invalid dtype specified {dtype}")
 
     if isinstance(values, IntegerArray):
         values, mask = values._data, values._mask
@@ -190,17 +222,13 @@ def coerce_to_array(values, dtype, mask=None, copy=False):
             "integer-na",
             "mixed-integer-float",
         ]:
-            raise TypeError(
-                "{} cannot be converted to an IntegerDtype".format(values.dtype)
-            )
+            raise TypeError(f"{values.dtype} cannot be converted to an IntegerDtype")
 
     elif is_bool_dtype(values) and is_integer_dtype(dtype):
         values = np.array(values, dtype=int, copy=copy)
 
     elif not (is_integer_dtype(values) or is_float_dtype(values)):
-        raise TypeError(
-            "{} cannot be converted to an IntegerDtype".format(values.dtype)
-        )
+        raise TypeError(f"{values.dtype} cannot be converted to an IntegerDtype")
 
     if mask is None:
         mask = isna(values)
@@ -232,12 +260,17 @@ def coerce_to_array(values, dtype, mask=None, copy=False):
     return values, mask
 
 
-class IntegerArray(ExtensionArray, ExtensionOpsMixin):
+class IntegerArray(BaseMaskedArray):
     """
     Array of integer (optional missing) values.
 
     .. versionadded:: 0.24.0
 
+    .. versionchanged:: 1.0.0
+
+       Now uses :attr:`pandas.NA` as the missing value rather
+       than :attr:`numpy.nan`.
+
     .. warning::
 
        IntegerArray is currently experimental, and its API or internal
@@ -281,27 +314,30 @@ class IntegerArray(ExtensionArray, ExtensionOpsMixin):
     >>> int_array = pd.array([1, None, 3], dtype=pd.Int32Dtype())
     >>> int_array
     <IntegerArray>
-    [1, NaN, 3]
+    [1, <NA>, 3]
     Length: 3, dtype: Int32
 
     String aliases for the dtypes are also available. They are capitalized.
 
     >>> pd.array([1, None, 3], dtype='Int32')
     <IntegerArray>
-    [1, NaN, 3]
+    [1, <NA>, 3]
     Length: 3, dtype: Int32
 
     >>> pd.array([1, None, 3], dtype='UInt16')
     <IntegerArray>
-    [1, NaN, 3]
+    [1, <NA>, 3]
     Length: 3, dtype: UInt16
     """
 
+    # The value used to fill '_data' to avoid upcasting
+    _internal_fill_value = 1
+
     @cache_readonly
-    def dtype(self):
+    def dtype(self) -> _IntegerDtype:
         return _dtypes[str(self._data.dtype)]
 
-    def __init__(self, values, mask, copy=False):
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
         if not (isinstance(values, np.ndarray) and is_integer_dtype(values.dtype)):
             raise TypeError(
                 "values should be integer numpy array. Use "
@@ -312,72 +348,26 @@ def __init__(self, values, mask, copy=False):
                 "mask should be boolean numpy array. Use "
                 "the 'integer_array' function instead"
             )
-
-        if copy:
-            values = values.copy()
-            mask = mask.copy()
-
-        self._data = values
-        self._mask = mask
+        super().__init__(values, mask, copy=copy)
 
     @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
+    def _from_sequence(cls, scalars, dtype=None, copy: bool = False) -> "IntegerArray":
         return integer_array(scalars, dtype=dtype, copy=copy)
 
     @classmethod
-    def _from_sequence_of_strings(cls, strings, dtype=None, copy=False):
+    def _from_sequence_of_strings(
+        cls, strings, dtype=None, copy: bool = False
+    ) -> "IntegerArray":
         scalars = to_numeric(strings, errors="raise")
         return cls._from_sequence(scalars, dtype, copy)
 
     @classmethod
-    def _from_factorized(cls, values, original):
+    def _from_factorized(cls, values, original) -> "IntegerArray":
         return integer_array(values, dtype=original.dtype)
 
-    def _formatter(self, boxed=False):
-        def fmt(x):
-            if isna(x):
-                return "NaN"
-            return str(x)
-
-        return fmt
-
-    def __getitem__(self, item):
-        if is_integer(item):
-            if self._mask[item]:
-                return self.dtype.na_value
-            return self._data[item]
-        return type(self)(self._data[item], self._mask[item])
-
-    def _coerce_to_ndarray(self):
-        """
-        coerce to an ndarary of object dtype
-        """
-
-        # TODO(jreback) make this better
-        data = self._data.astype(object)
-        data[self._mask] = self._na_value
-        return data
-
-    __array_priority__ = 1000  # higher than ndarray so ops dispatch to us
-
-    def __array__(self, dtype=None):
-        """
-        the array interface, return my values
-        We return an object array here to preserve our scalar values
-        """
-        return self._coerce_to_ndarray()
-
-    def __arrow_array__(self, type=None):
-        """
-        Convert myself into a pyarrow Array.
-        """
-        import pyarrow as pa
-
-        return pa.array(self._data, mask=self._mask, type=type)
-
     _HANDLED_TYPES = (np.ndarray, numbers.Number)
 
-    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+    def __array_ufunc__(self, ufunc, method: str, *inputs, **kwargs):
         # For IntegerArray inputs, we apply the ufunc to ._data
         # and mask the result.
         if method == "reduce":
@@ -422,41 +412,7 @@ def reconstruct(x):
         else:
             return reconstruct(result)
 
-    def __iter__(self):
-        for i in range(len(self)):
-            if self._mask[i]:
-                yield self.dtype.na_value
-            else:
-                yield self._data[i]
-
-    def take(self, indexer, allow_fill=False, fill_value=None):
-        # we always fill with 1 internally
-        # to avoid upcasting
-        data_fill_value = 1 if isna(fill_value) else fill_value
-        result = take(
-            self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill
-        )
-
-        mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill)
-
-        # if we are filling
-        # we only fill where the indexer is null
-        # not existing missing values
-        # TODO(jreback) what if we have a non-na float as a fill value?
-        if allow_fill and notna(fill_value):
-            fill_mask = np.asarray(indexer) == -1
-            result[fill_mask] = fill_value
-            mask = mask ^ fill_mask
-
-        return type(self)(result, mask, copy=False)
-
-    def copy(self):
-        data, mask = self._data, self._mask
-        data = data.copy()
-        mask = mask.copy()
-        return type(self)(data, mask, copy=False)
-
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         _is_scalar = is_scalar(value)
         if _is_scalar:
             value = [value]
@@ -466,32 +422,13 @@ def __setitem__(self, key, value):
             value = value[0]
             mask = mask[0]
 
+        key = check_array_indexer(self, key)
         self._data[key] = value
         self._mask[key] = mask
 
-    def __len__(self):
-        return len(self._data)
-
-    @property
-    def nbytes(self):
-        return self._data.nbytes + self._mask.nbytes
-
-    def isna(self):
-        return self._mask
-
-    @property
-    def _na_value(self):
-        return np.nan
-
-    @classmethod
-    def _concat_same_type(cls, to_concat):
-        data = np.concatenate([x._data for x in to_concat])
-        mask = np.concatenate([x._mask for x in to_concat])
-        return cls(data, mask)
-
-    def astype(self, dtype, copy=True):
+    def astype(self, dtype, copy: bool = True) -> ArrayLike:
         """
-        Cast to a NumPy array or IntegerArray with 'dtype'.
+        Cast to a NumPy array or ExtensionArray with 'dtype'.
 
         Parameters
         ----------
@@ -504,8 +441,8 @@ def astype(self, dtype, copy=True):
 
         Returns
         -------
-        array : ndarray or IntegerArray
-            NumPy ndarray or IntergerArray with 'dtype' for its dtype.
+        ndarray or ExtensionArray
+            NumPy ndarray, BooleanArray or IntegerArray with 'dtype' for its dtype.
 
         Raises
         ------
@@ -513,15 +450,27 @@ def astype(self, dtype, copy=True):
             if incompatible type with an IntegerDtype, equivalent of same_kind
             casting
         """
+        from pandas.core.arrays.boolean import BooleanArray, BooleanDtype
+
+        dtype = pandas_dtype(dtype)
 
         # if we are astyping to an existing IntegerDtype we can fastpath
         if isinstance(dtype, _IntegerDtype):
             result = self._data.astype(dtype.numpy_dtype, copy=False)
             return type(self)(result, mask=self._mask, copy=False)
+        elif isinstance(dtype, BooleanDtype):
+            result = self._data.astype("bool", copy=False)
+            return BooleanArray(result, mask=self._mask, copy=False)
 
         # coerce
-        data = self._coerce_to_ndarray()
-        return astype_nansafe(data, dtype, copy=None)
+        if is_float_dtype(dtype):
+            # In astype, we consider dtype=float to also mean na_value=np.nan
+            kwargs = dict(na_value=np.nan)
+        else:
+            kwargs = {}
+
+        data = self.to_numpy(dtype=dtype, **kwargs)
+        return astype_nansafe(data, dtype, copy=False)
 
     @property
     def _ndarray_values(self) -> np.ndarray:
@@ -534,52 +483,10 @@ def _ndarray_values(self) -> np.ndarray:
         """
         return self._data
 
-    def value_counts(self, dropna=True):
-        """
-        Returns a Series containing counts of each category.
-
-        Every category will have an entry, even those with a count of 0.
-
-        Parameters
-        ----------
-        dropna : boolean, default True
-            Don't include counts of NaN.
-
-        Returns
-        -------
-        counts : Series
-
-        See Also
-        --------
-        Series.value_counts
-
-        """
-
-        from pandas import Index, Series
-
-        # compute counts on the data with no nans
-        data = self._data[~self._mask]
-        value_counts = Index(data).value_counts()
-        array = value_counts.values
-
-        # TODO(extension)
-        # if we have allow Index to hold an ExtensionArray
-        # this is easier
-        index = value_counts.index.astype(object)
-
-        # if we want nans, count the mask
-        if not dropna:
-
-            # TODO(extension)
-            # appending to an Index *always* infers
-            # w/o passing the dtype
-            array = np.append(array, [self._mask.sum()])
-            index = Index(
-                np.concatenate([index.values, np.array([np.nan], dtype=object)]),
-                dtype=object,
-            )
-
-        return Series(array, index=index)
+    def _values_for_factorize(self) -> Tuple[np.ndarray, float]:
+        # TODO: https://github.com/pandas-dev/pandas/issues/30037
+        # use masked algorithms, rather than object-dtype / np.nan.
+        return self.to_numpy(na_value=np.nan), np.nan
 
     def _values_for_argsort(self) -> np.ndarray:
         """Return values for sorting.
@@ -602,16 +509,13 @@ def _values_for_argsort(self) -> np.ndarray:
     def _create_comparison_method(cls, op):
         op_name = op.__name__
 
+        @unpack_zerodim_and_defer(op.__name__)
         def cmp_method(self, other):
+            from pandas.arrays import BooleanArray
 
-            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-                # Rely on pandas to unbox and dispatch to us.
-                return NotImplemented
-
-            other = lib.item_from_zerodim(other)
             mask = None
 
-            if isinstance(other, IntegerArray):
+            if isinstance(other, (BooleanArray, IntegerArray)):
                 other, mask = other._data, other._mask
 
             elif is_list_like(other):
@@ -623,36 +527,53 @@ def cmp_method(self, other):
                 if len(self) != len(other):
                     raise ValueError("Lengths must match to compare")
 
-            # numpy will show a DeprecationWarning on invalid elementwise
-            # comparisons, this will raise in the future
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", "elementwise", FutureWarning)
-                with np.errstate(all="ignore"):
-                    result = op(self._data, other)
+            if other is libmissing.NA:
+                # numpy does not handle pd.NA well as "other" scalar (it returns
+                # a scalar False instead of an array)
+                # This may be fixed by NA.__array_ufunc__. Revisit this check
+                # once that's implemented.
+                result = np.zeros(self._data.shape, dtype="bool")
+                mask = np.ones(self._data.shape, dtype="bool")
+            else:
+                with warnings.catch_warnings():
+                    # numpy may show a FutureWarning:
+                    #     elementwise comparison failed; returning scalar instead,
+                    #     but in the future will perform elementwise comparison
+                    # before returning NotImplemented. We fall back to the correct
+                    # behavior today, so that should be fine to ignore.
+                    warnings.filterwarnings("ignore", "elementwise", FutureWarning)
+                    with np.errstate(all="ignore"):
+                        method = getattr(self._data, f"__{op_name}__")
+                        result = method(other)
+
+                    if result is NotImplemented:
+                        result = invalid_comparison(self._data, other, op)
 
             # nans propagate
             if mask is None:
-                mask = self._mask
+                mask = self._mask.copy()
             else:
                 mask = self._mask | mask
 
-            result[mask] = op_name == "ne"
-            return result
+            return BooleanArray(result, mask)
 
-        name = "__{name}__".format(name=op.__name__)
+        name = f"__{op.__name__}__"
         return set_function_name(cmp_method, name, cls)
 
-    def _reduce(self, name, skipna=True, **kwargs):
+    def _reduce(self, name: str, skipna: bool = True, **kwargs):
         data = self._data
         mask = self._mask
 
         # coerce to a nan-aware float if needed
-        if mask.any():
-            data = self._data.astype("float64")
-            data[mask] = self._na_value
+        # (we explicitly use NaN within reductions)
+        if self._hasna:
+            data = self.to_numpy("float64", na_value=np.nan)
 
         op = getattr(nanops, "nan" + name)
-        result = op(data, axis=0, skipna=skipna, mask=mask)
+        result = op(data, axis=0, skipna=skipna, mask=mask, **kwargs)
+
+        if np.isnan(result):
+            return libmissing.NA
 
         # if we have a boolean op, don't coerce
         if name in ["any", "all"]:
@@ -660,14 +581,13 @@ def _reduce(self, name, skipna=True, **kwargs):
 
         # if we have a preservable numeric op,
         # provide coercion back to an integer type if possible
-        elif name in ["sum", "min", "max", "prod"] and notna(result):
-            int_result = int(result)
-            if int_result == result:
-                result = int_result
+        elif name in ["sum", "min", "max", "prod"]:
+            # GH#31409 more performant than casting-then-checking
+            result = com.cast_scalar_indexer(result)
 
         return result
 
-    def _maybe_mask_result(self, result, mask, other, op_name):
+    def _maybe_mask_result(self, result, mask, other, op_name: str):
         """
         Parameters
         ----------
@@ -677,11 +597,6 @@ def _maybe_mask_result(self, result, mask, other, op_name):
         op_name : str
         """
 
-        # may need to fill infs
-        # and mask wraparound
-        if is_float_dtype(result):
-            mask |= (result == np.inf) | (result == -np.inf)
-
         # if we have a float operand we are by-definition
         # a float result
         # or our op is a divide
@@ -697,17 +612,16 @@ def _maybe_mask_result(self, result, mask, other, op_name):
     def _create_arithmetic_method(cls, op):
         op_name = op.__name__
 
+        @unpack_zerodim_and_defer(op.__name__)
         def integer_arithmetic_method(self, other):
 
-            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-                # Rely on pandas to unbox and dispatch to us.
-                return NotImplemented
+            omask = None
 
-            other = lib.item_from_zerodim(other)
-            mask = None
+            if getattr(other, "ndim", 0) > 1:
+                raise NotImplementedError("can only perform ops with 1-d structures")
 
             if isinstance(other, IntegerArray):
-                other, mask = other._data, other._mask
+                other, omask = other._data, other._mask
 
             elif is_list_like(other):
                 other = np.asarray(other)
@@ -721,24 +635,39 @@ def integer_arithmetic_method(self, other):
                     raise TypeError("can only perform ops with numeric values")
 
             else:
-                if not (is_float(other) or is_integer(other)):
+                if not (is_float(other) or is_integer(other) or other is libmissing.NA):
                     raise TypeError("can only perform ops with numeric values")
 
-            # nans propagate
-            if mask is None:
-                mask = self._mask
+            if omask is None:
+                mask = self._mask.copy()
+                if other is libmissing.NA:
+                    mask |= True
             else:
-                mask = self._mask | mask
+                mask = self._mask | omask
 
-            # 1 ** np.nan is 1. So we have to unmask those.
             if op_name == "pow":
-                mask = np.where(self == 1, False, mask)
+                # 1 ** x is 1.
+                mask = np.where((self._data == 1) & ~self._mask, False, mask)
+                # x ** 0 is 1.
+                if omask is not None:
+                    mask = np.where((other == 0) & ~omask, False, mask)
+                elif other is not libmissing.NA:
+                    mask = np.where(other == 0, False, mask)
 
             elif op_name == "rpow":
-                mask = np.where(other == 1, False, mask)
-
-            with np.errstate(all="ignore"):
-                result = op(self._data, other)
+                # 1 ** x is 1.
+                if omask is not None:
+                    mask = np.where((other == 1) & ~omask, False, mask)
+                elif other is not libmissing.NA:
+                    mask = np.where(other == 1, False, mask)
+                # x ** 0 is 1.
+                mask = np.where((self._data == 0) & ~self._mask, False, mask)
+
+            if other is libmissing.NA:
+                result = np.ones_like(self._data)
+            else:
+                with np.errstate(all="ignore"):
+                    result = op(self._data, other)
 
             # divmod returns a tuple
             if op_name == "divmod":
@@ -750,7 +679,7 @@ def integer_arithmetic_method(self, other):
 
             return self._maybe_mask_result(result, mask, other, op_name)
 
-        name = "__{name}__".format(name=op.__name__)
+        name = f"__{op.__name__}__"
         return set_function_name(integer_arithmetic_method, name, cls)
 
 
@@ -761,6 +690,11 @@ def integer_arithmetic_method(self, other):
 _dtype_docstring = """
 An ExtensionDtype for {dtype} integer data.
 
+.. versionchanged:: 1.0.0
+
+   Now uses :attr:`pandas.NA` as its missing value,
+   rather than :attr:`numpy.nan`.
+
 Attributes
 ----------
 None
@@ -771,101 +705,63 @@ def integer_arithmetic_method(self, other):
 """
 
 # create the Dtype
-Int8Dtype = register_extension_dtype(
-    type(
-        "Int8Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.int8,
-            "name": "Int8",
-            "__doc__": _dtype_docstring.format(dtype="int8"),
-        },
-    )
-)
 
-Int16Dtype = register_extension_dtype(
-    type(
-        "Int16Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.int16,
-            "name": "Int16",
-            "__doc__": _dtype_docstring.format(dtype="int16"),
-        },
-    )
-)
 
-Int32Dtype = register_extension_dtype(
-    type(
-        "Int32Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.int32,
-            "name": "Int32",
-            "__doc__": _dtype_docstring.format(dtype="int32"),
-        },
-    )
-)
+@register_extension_dtype
+class Int8Dtype(_IntegerDtype):
+    type = np.int8
+    name = "Int8"
+    __doc__ = _dtype_docstring.format(dtype="int8")
 
-Int64Dtype = register_extension_dtype(
-    type(
-        "Int64Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.int64,
-            "name": "Int64",
-            "__doc__": _dtype_docstring.format(dtype="int64"),
-        },
-    )
-)
 
-UInt8Dtype = register_extension_dtype(
-    type(
-        "UInt8Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.uint8,
-            "name": "UInt8",
-            "__doc__": _dtype_docstring.format(dtype="uint8"),
-        },
-    )
-)
+@register_extension_dtype
+class Int16Dtype(_IntegerDtype):
+    type = np.int16
+    name = "Int16"
+    __doc__ = _dtype_docstring.format(dtype="int16")
 
-UInt16Dtype = register_extension_dtype(
-    type(
-        "UInt16Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.uint16,
-            "name": "UInt16",
-            "__doc__": _dtype_docstring.format(dtype="uint16"),
-        },
-    )
-)
 
-UInt32Dtype = register_extension_dtype(
-    type(
-        "UInt32Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.uint32,
-            "name": "UInt32",
-            "__doc__": _dtype_docstring.format(dtype="uint32"),
-        },
-    )
-)
+@register_extension_dtype
+class Int32Dtype(_IntegerDtype):
+    type = np.int32
+    name = "Int32"
+    __doc__ = _dtype_docstring.format(dtype="int32")
+
+
+@register_extension_dtype
+class Int64Dtype(_IntegerDtype):
+    type = np.int64
+    name = "Int64"
+    __doc__ = _dtype_docstring.format(dtype="int64")
+
+
+@register_extension_dtype
+class UInt8Dtype(_IntegerDtype):
+    type = np.uint8
+    name = "UInt8"
+    __doc__ = _dtype_docstring.format(dtype="uint8")
+
+
+@register_extension_dtype
+class UInt16Dtype(_IntegerDtype):
+    type = np.uint16
+    name = "UInt16"
+    __doc__ = _dtype_docstring.format(dtype="uint16")
+
+
+@register_extension_dtype
+class UInt32Dtype(_IntegerDtype):
+    type = np.uint32
+    name = "UInt32"
+    __doc__ = _dtype_docstring.format(dtype="uint32")
+
+
+@register_extension_dtype
+class UInt64Dtype(_IntegerDtype):
+    type = np.uint64
+    name = "UInt64"
+    __doc__ = _dtype_docstring.format(dtype="uint64")
 
-UInt64Dtype = register_extension_dtype(
-    type(
-        "UInt64Dtype",
-        (_IntegerDtype,),
-        {
-            "type": np.uint64,
-            "name": "UInt64",
-            "__doc__": _dtype_docstring.format(dtype="uint64"),
-        },
-    )
-)
 
 _dtypes = {
     "int8": Int8Dtype(),
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 1f4b76a259f00..c8bb0878b564d 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -17,6 +17,8 @@
     is_integer_dtype,
     is_interval,
     is_interval_dtype,
+    is_list_like,
+    is_object_dtype,
     is_scalar,
     is_string_dtype,
     is_timedelta64_dtype,
@@ -25,6 +27,7 @@
 from pandas.core.dtypes.dtypes import IntervalDtype
 from pandas.core.dtypes.generic import (
     ABCDatetimeIndex,
+    ABCExtensionArray,
     ABCIndexClass,
     ABCInterval,
     ABCIntervalIndex,
@@ -37,6 +40,8 @@
 from pandas.core.arrays.base import ExtensionArray, _extension_array_shared_docs
 from pandas.core.arrays.categorical import Categorical
 import pandas.core.common as com
+from pandas.core.construction import array
+from pandas.core.indexers import check_array_indexer
 from pandas.core.indexes.base import ensure_index
 
 _VALID_CLOSED = {"left", "right", "both", "neither"}
@@ -105,7 +110,7 @@
 Notes
 -----
 See the `user guide
-<http://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`_
+<https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`_
 for more.
 
 %(examples)s\
@@ -159,10 +164,10 @@ def __new__(cls, data, closed=None, dtype=None, copy=False, verify_integrity=Tru
             # don't allow scalars
             if is_scalar(data):
                 msg = (
-                    "{}(...) must be called with a collection of some kind,"
-                    " {} was passed"
+                    f"{cls.__name__}(...) must be called with a collection "
+                    f"of some kind, {data} was passed"
                 )
-                raise TypeError(msg.format(cls.__name__, data))
+                raise TypeError(msg)
 
             # might need to convert empty or purely na data
             data = maybe_convert_platform_interval(data)
@@ -194,8 +199,8 @@ def _simple_new(
             # GH 19262: dtype must be an IntervalDtype to override inferred
             dtype = pandas_dtype(dtype)
             if not is_interval_dtype(dtype):
-                msg = "dtype must be an IntervalDtype, got {dtype}"
-                raise TypeError(msg.format(dtype=dtype))
+                msg = f"dtype must be an IntervalDtype, got {dtype}"
+                raise TypeError(msg)
             elif dtype.subtype is not None:
                 left = left.astype(dtype.subtype)
                 right = right.astype(dtype.subtype)
@@ -207,10 +212,11 @@ def _simple_new(
             left = left.astype(right.dtype)
 
         if type(left) != type(right):
-            msg = "must not have differing left [{ltype}] and right [{rtype}] types"
-            raise ValueError(
-                msg.format(ltype=type(left).__name__, rtype=type(right).__name__)
+            msg = (
+                f"must not have differing left [{type(left).__name__}] and "
+                f"right [{type(right).__name__}] types"
             )
+            raise ValueError(msg)
         elif is_categorical_dtype(left.dtype) or is_string_dtype(left.dtype):
             # GH 19016
             msg = (
@@ -224,9 +230,9 @@ def _simple_new(
         elif isinstance(left, ABCDatetimeIndex) and str(left.tz) != str(right.tz):
             msg = (
                 "left and right must have the same time zone, got "
-                "'{left_tz}' and '{right_tz}'"
+                f"'{left.tz}' and '{right.tz}'"
             )
-            raise ValueError(msg.format(left_tz=left.tz, right_tz=right.tz))
+            raise ValueError(msg)
 
         result._left = left
         result._right = right
@@ -259,10 +265,10 @@ def _from_factorized(cls, values, original):
     closed : {'left', 'right', 'both', 'neither'}, default 'right'
         Whether the intervals are closed on the left-side, right-side, both
         or neither.
-    copy : boolean, default False
-        copy the data
+    copy : bool, default False
+        Copy the data.
     dtype : dtype or None, default None
-        If None, dtype will be inferred
+        If None, dtype will be inferred.
 
         .. versionadded:: 0.23.0
 
@@ -315,7 +321,7 @@ def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
         closed : {'left', 'right', 'both', 'neither'}, default 'right'
             Whether the intervals are closed on the left-side, right-side, both
             or neither.
-        copy : boolean, default False
+        copy : bool, default False
             Copy the data.
         dtype : dtype, optional
             If None, dtype will be inferred.
@@ -383,16 +389,16 @@ def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
     Parameters
     ----------
     data : array-like (1-dimensional)
-        Array of tuples
+        Array of tuples.
     closed : {'left', 'right', 'both', 'neither'}, default 'right'
         Whether the intervals are closed on the left-side, right-side, both
         or neither.
-    copy : boolean, default False
-        by-default copy the data, this is compat only and ignored
+    copy : bool, default False
+        By-default copy the data, this is compat only and ignored.
     dtype : dtype or None, default None
-        If None, dtype will be inferred
+        If None, dtype will be inferred.
 
-        ..versionadded:: 0.23.0
+        .. versionadded:: 0.23.0
 
     Returns
     -------
@@ -443,14 +449,10 @@ def from_tuples(cls, data, closed="right", copy=False, dtype=None):
                     # need list of length 2 tuples, e.g. [(0, 1), (1, 2), ...]
                     lhs, rhs = d
                 except ValueError:
-                    msg = (
-                        "{name}.from_tuples requires tuples of length 2, got {tpl}"
-                    ).format(name=name, tpl=d)
+                    msg = f"{name}.from_tuples requires tuples of length 2, got {d}"
                     raise ValueError(msg)
                 except TypeError:
-                    msg = ("{name}.from_tuples received an invalid item, {tpl}").format(
-                        name=name, tpl=d
-                    )
+                    msg = f"{name}.from_tuples received an invalid item, {d}"
                     raise TypeError(msg)
             left.append(lhs)
             right.append(rhs)
@@ -468,20 +470,22 @@ def _validate(self):
         * left is always below right
         """
         if self.closed not in _VALID_CLOSED:
-            raise ValueError(
-                "invalid option for 'closed': {closed}".format(closed=self.closed)
-            )
+            msg = f"invalid option for 'closed': {self.closed}"
+            raise ValueError(msg)
         if len(self.left) != len(self.right):
-            raise ValueError("left and right must have the same length")
+            msg = "left and right must have the same length"
+            raise ValueError(msg)
         left_mask = notna(self.left)
         right_mask = notna(self.right)
         if not (left_mask == right_mask).all():
-            raise ValueError(
+            msg = (
                 "missing values must be missing in the same "
                 "location both left and right sides"
             )
+            raise ValueError(msg)
         if not (self.left[left_mask] <= self.right[left_mask]).all():
-            raise ValueError("left side of interval must be <= right side")
+            msg = "left side of interval must be <= right side"
+            raise ValueError(msg)
 
     # ---------
     # Interface
@@ -489,17 +493,21 @@ def _validate(self):
     def __iter__(self):
         return iter(np.asarray(self))
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.left)
 
     def __getitem__(self, value):
+        value = check_array_indexer(self, value)
         left = self.left[value]
         right = self.right[value]
 
         # scalar
         if not isinstance(left, ABCIndexClass):
-            if isna(left):
+            if is_scalar(left) and isna(left):
                 return self._fill_value
+            if np.ndim(left) > 1:
+                # GH#30588 multi-dimensional indexer disallowed
+                raise ValueError("multi-dimensional indexing not allowed")
             return Interval(left, right, self.closed)
 
         return self._shallow_copy(left, right)
@@ -531,9 +539,10 @@ def __setitem__(self, key, value):
                 value_left, value_right = array.left, array.right
             except TypeError:
                 # wrong type: not interval or NA
-                msg = "'value' should be an interval type, got {} instead."
-                raise TypeError(msg.format(type(value)))
+                msg = f"'value' should be an interval type, got {type(value)} instead."
+                raise TypeError(msg)
 
+        key = check_array_indexer(self, key)
         # Need to ensure that left and right are updated atomically, so we're
         # forced to copy, update the copy, and swap in the new values.
         left = self.left.copy(deep=True)
@@ -548,6 +557,58 @@ def __setitem__(self, key, value):
         right.values[key] = value_right
         self._right = right
 
+    def __eq__(self, other):
+        # ensure pandas array for list-like and eliminate non-interval scalars
+        if is_list_like(other):
+            if len(self) != len(other):
+                raise ValueError("Lengths must match to compare")
+            other = array(other)
+        elif not isinstance(other, Interval):
+            # non-interval scalar -> no matches
+            return np.zeros(len(self), dtype=bool)
+
+        # determine the dtype of the elements we want to compare
+        if isinstance(other, Interval):
+            other_dtype = "interval"
+        elif not is_categorical_dtype(other):
+            other_dtype = other.dtype
+        else:
+            # for categorical defer to categories for dtype
+            other_dtype = other.categories.dtype
+
+            # extract intervals if we have interval categories with matching closed
+            if is_interval_dtype(other_dtype):
+                if self.closed != other.categories.closed:
+                    return np.zeros(len(self), dtype=bool)
+                other = other.categories.take(other.codes)
+
+        # interval-like -> need same closed and matching endpoints
+        if is_interval_dtype(other_dtype):
+            if self.closed != other.closed:
+                return np.zeros(len(self), dtype=bool)
+            return (self.left == other.left) & (self.right == other.right)
+
+        # non-interval/non-object dtype -> no matches
+        if not is_object_dtype(other_dtype):
+            return np.zeros(len(self), dtype=bool)
+
+        # object dtype -> iteratively check for intervals
+        result = np.zeros(len(self), dtype=bool)
+        for i, obj in enumerate(other):
+            # need object to be an Interval with same closed and endpoints
+            if (
+                isinstance(obj, Interval)
+                and self.closed == obj.closed
+                and self.left[i] == obj.left
+                and self.right[i] == obj.right
+            ):
+                result[i] = True
+
+        return result
+
+    def __ne__(self, other):
+        return ~self.__eq__(other)
+
     def fillna(self, value=None, method=None, limit=None):
         """
         Fill NA/NaN values using the specified method.
@@ -583,9 +644,7 @@ def fillna(self, value=None, method=None, limit=None):
         if not isinstance(value, ABCInterval):
             msg = (
                 "'IntervalArray.fillna' only supports filling with a "
-                "scalar 'pandas.Interval'. Got a '{}' instead.".format(
-                    type(value).__name__
-                )
+                f"scalar 'pandas.Interval'. Got a '{type(value).__name__}' instead."
             )
             raise TypeError(msg)
 
@@ -630,10 +689,9 @@ def astype(self, dtype, copy=True):
                 new_right = self.right.astype(dtype.subtype)
             except TypeError:
                 msg = (
-                    "Cannot convert {dtype} to {new_dtype}; subtypes are "
-                    "incompatible"
+                    f"Cannot convert {self.dtype} to {dtype}; subtypes are incompatible"
                 )
-                raise TypeError(msg.format(dtype=self.dtype, new_dtype=dtype))
+                raise TypeError(msg)
             return self._shallow_copy(new_left, new_right)
         elif is_categorical_dtype(dtype):
             return Categorical(np.asarray(self))
@@ -641,8 +699,8 @@ def astype(self, dtype, copy=True):
         try:
             return np.asarray(self).astype(dtype, copy=copy)
         except (TypeError, ValueError):
-            msg = "Cannot cast {name} to dtype {dtype}"
-            raise TypeError(msg.format(name=type(self).__name__, dtype=dtype))
+            msg = f"Cannot cast {type(self).__name__} to dtype {dtype}"
+            raise TypeError(msg)
 
     @classmethod
     def _concat_same_type(cls, to_concat):
@@ -673,11 +731,11 @@ def _shallow_copy(self, left=None, right=None, closed=None):
         Parameters
         ----------
         left : array-like
-            Values to be used for the left-side of the the intervals.
+            Values to be used for the left-side of the intervals.
             If None, the existing left and right values will be used.
 
         right : array-like
-            Values to be used for the right-side of the the intervals.
+            Values to be used for the right-side of the intervals.
             If None and left is IntervalArray-like, the left and right
             of the IntervalArray-like will be used.
 
@@ -732,6 +790,33 @@ def size(self) -> int:
         # Avoid materializing self.values
         return self.left.size
 
+    def shift(self, periods: int = 1, fill_value: object = None) -> ABCExtensionArray:
+        if not len(self) or periods == 0:
+            return self.copy()
+
+        if isna(fill_value):
+            fill_value = self.dtype.na_value
+
+        # ExtensionArray.shift doesn't work for two reasons
+        # 1. IntervalArray.dtype.na_value may not be correct for the dtype.
+        # 2. IntervalArray._from_sequence only accepts NaN for missing values,
+        #    not other values like NaT
+
+        empty_len = min(abs(periods), len(self))
+        if isna(fill_value):
+            fill_value = self.left._na_value
+            empty = IntervalArray.from_breaks([fill_value] * (empty_len + 1))
+        else:
+            empty = self._from_sequence([fill_value] * empty_len)
+
+        if periods > 0:
+            a = empty
+            b = self[:-periods]
+        else:
+            a = self[abs(periods) :]
+            b = empty
+        return self._concat_same_type([a, b])
+
     def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
         """
         Take elements from the IntervalArray.
@@ -790,9 +875,8 @@ def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
             elif not is_scalar(fill_value) and notna(fill_value):
                 msg = (
                     "'IntervalArray.fillna' only supports filling with a "
-                    "'scalar pandas.Interval or NA'. Got a '{}' instead.".format(
-                        type(fill_value).__name__
-                    )
+                    "'scalar pandas.Interval or NA'. "
+                    f"Got a '{type(fill_value).__name__}' instead."
                 )
                 raise ValueError(msg)
 
@@ -811,7 +895,7 @@ def value_counts(self, dropna=True):
 
         Parameters
         ----------
-        dropna : boolean, default True
+        dropna : bool, default True
             Don't include counts of NaN.
 
         Returns
@@ -840,48 +924,44 @@ def _format_data(self):
             summary = "[]"
         elif n == 1:
             first = formatter(self[0])
-            summary = "[{first}]".format(first=first)
+            summary = f"[{first}]"
         elif n == 2:
             first = formatter(self[0])
             last = formatter(self[-1])
-            summary = "[{first}, {last}]".format(first=first, last=last)
+            summary = f"[{first}, {last}]"
         else:
 
             if n > max_seq_items:
                 n = min(max_seq_items // 2, 10)
                 head = [formatter(x) for x in self[:n]]
                 tail = [formatter(x) for x in self[-n:]]
-                summary = "[{head} ... {tail}]".format(
-                    head=", ".join(head), tail=", ".join(tail)
-                )
+                head_str = ", ".join(head)
+                tail_str = ", ".join(tail)
+                summary = f"[{head_str} ... {tail_str}]"
             else:
                 tail = [formatter(x) for x in self]
-                summary = "[{tail}]".format(tail=", ".join(tail))
+                tail_str = ", ".join(tail)
+                summary = f"[{tail_str}]"
 
         return summary
 
-    def __repr__(self):
-        template = (
-            "{class_name}"
-            "{data}\n"
-            "Length: {length}, closed: {closed}, dtype: {dtype}"
-        )
+    def __repr__(self) -> str:
         # the short repr has no trailing newline, while the truncated
         # repr does. So we include a newline in our template, and strip
         # any trailing newlines from format_object_summary
         data = self._format_data()
-        class_name = "<{}>\n".format(self.__class__.__name__)
-        return template.format(
-            class_name=class_name,
-            data=data,
-            length=len(self),
-            closed=self.closed,
-            dtype=self.dtype,
+        class_name = f"<{type(self).__name__}>\n"
+
+        template = (
+            f"{class_name}"
+            f"{data}\n"
+            f"Length: {len(self)}, closed: {self.closed}, dtype: {self.dtype}"
         )
+        return template
 
     def _format_space(self):
-        space = " " * (len(self.__class__.__name__) + 1)
-        return "\n{space}".format(space=space)
+        space = " " * (len(type(self).__name__) + 1)
+        return f"\n{space}"
 
     @property
     def left(self):
@@ -951,8 +1031,8 @@ def closed(self):
     )
     def set_closed(self, closed):
         if closed not in _VALID_CLOSED:
-            msg = "invalid option for 'closed': {closed}"
-            raise ValueError(msg.format(closed=closed))
+            msg = f"invalid option for 'closed': {closed}"
+            raise ValueError(msg)
 
         return self._shallow_copy(closed=closed)
 
@@ -975,7 +1055,7 @@ def length(self):
     @property
     def mid(self):
         """
-        Return the midpoint of each Interval in the IntervalArray as an Index
+        Return the midpoint of each Interval in the IntervalArray as an Index.
         """
         try:
             return 0.5 * (self.left + self.right)
@@ -1017,7 +1097,7 @@ def is_non_overlapping_monotonic(self):
         )
 
     # Conversion
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """
         Return the IntervalArray's data as a numpy array of Interval
         objects (with dtype='object')
@@ -1035,6 +1115,59 @@ def __array__(self, dtype=None):
                 result[i] = Interval(left[i], right[i], closed)
         return result
 
+    def __arrow_array__(self, type=None):
+        """
+        Convert myself into a pyarrow Array.
+        """
+        import pyarrow
+        from pandas.core.arrays._arrow_utils import ArrowIntervalType
+
+        try:
+            subtype = pyarrow.from_numpy_dtype(self.dtype.subtype)
+        except TypeError:
+            raise TypeError(
+                "Conversion to arrow with subtype '{}' "
+                "is not supported".format(self.dtype.subtype)
+            )
+        interval_type = ArrowIntervalType(subtype, self.closed)
+        storage_array = pyarrow.StructArray.from_arrays(
+            [
+                pyarrow.array(self.left, type=subtype, from_pandas=True),
+                pyarrow.array(self.right, type=subtype, from_pandas=True),
+            ],
+            names=["left", "right"],
+        )
+        mask = self.isna()
+        if mask.any():
+            # if there are missing values, set validity bitmap also on the array level
+            null_bitmap = pyarrow.array(~mask).buffers()[1]
+            storage_array = pyarrow.StructArray.from_buffers(
+                storage_array.type,
+                len(storage_array),
+                [null_bitmap],
+                children=[storage_array.field(0), storage_array.field(1)],
+            )
+
+        if type is not None:
+            if type.equals(interval_type.storage_type):
+                return storage_array
+            elif isinstance(type, ArrowIntervalType):
+                # ensure we have the same subtype and closed attributes
+                if not type.equals(interval_type):
+                    raise TypeError(
+                        "Not supported to convert IntervalArray to type with "
+                        "different 'subtype' ({0} vs {1}) and 'closed' ({2} vs {3}) "
+                        "attributes".format(
+                            self.dtype.subtype, type.subtype, self.closed, type.closed
+                        )
+                    )
+            else:
+                raise TypeError(
+                    "Not supported to convert IntervalArray to '{0}' type".format(type)
+                )
+
+        return pyarrow.ExtensionArray.from_storage(interval_type, storage_array)
+
     _interval_shared_docs[
         "to_tuples"
     ] = """
@@ -1042,7 +1175,7 @@ def __array__(self, dtype=None):
 
         Parameters
         ----------
-        na_tuple : boolean, default True
+        na_tuple : bool, default True
             Returns NA as a tuple if True, ``(nan, nan)``, or just as the NA
             value itself if False, ``nan``.
 
@@ -1188,8 +1321,8 @@ def overlaps(self, other):
         if isinstance(other, (IntervalArray, ABCIntervalIndex)):
             raise NotImplementedError
         elif not isinstance(other, Interval):
-            msg = "`other` must be Interval-like, got {other}"
-            raise TypeError(msg.format(other=type(other).__name__))
+            msg = f"`other` must be Interval-like, got {type(other).__name__}"
+            raise TypeError(msg)
 
         # equality is okay if both endpoints are closed (overlap at a point)
         op1 = le if (self.closed_left and other.closed_right) else lt
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
new file mode 100644
index 0000000000000..47892b55b3ce8
--- /dev/null
+++ b/pandas/core/arrays/masked.py
@@ -0,0 +1,265 @@
+from typing import TYPE_CHECKING, Optional, Type, TypeVar
+
+import numpy as np
+
+from pandas._libs import lib, missing as libmissing
+from pandas._typing import Scalar
+
+from pandas.core.dtypes.common import is_integer, is_object_dtype, is_string_dtype
+from pandas.core.dtypes.missing import isna, notna
+
+from pandas.core.algorithms import take
+from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+from pandas.core.indexers import check_array_indexer
+
+if TYPE_CHECKING:
+    from pandas import Series
+
+
+BaseMaskedArrayT = TypeVar("BaseMaskedArrayT", bound="BaseMaskedArray")
+
+
+class BaseMaskedArray(ExtensionArray, ExtensionOpsMixin):
+    """
+    Base class for masked arrays (which use _data and _mask to store the data).
+
+    numpy based
+    """
+
+    # The value used to fill '_data' to avoid upcasting
+    _internal_fill_value: Scalar
+
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+
+        self._data = values
+        self._mask = mask
+
+    def __getitem__(self, item):
+        if is_integer(item):
+            if self._mask[item]:
+                return self.dtype.na_value
+            return self._data[item]
+
+        item = check_array_indexer(self, item)
+
+        return type(self)(self._data[item], self._mask[item])
+
+    def __iter__(self):
+        for i in range(len(self)):
+            if self._mask[i]:
+                yield self.dtype.na_value
+            else:
+                yield self._data[i]
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        return type(self)(~self._data, self._mask)
+
+    def to_numpy(
+        self, dtype=None, copy: bool = False, na_value: Scalar = lib.no_default,
+    ) -> np.ndarray:
+        """
+        Convert to a NumPy Array.
+
+        By default converts to an object-dtype NumPy array. Specify the `dtype` and
+        `na_value` keywords to customize the conversion.
+
+        Parameters
+        ----------
+        dtype : dtype, default object
+            The numpy dtype to convert to.
+        copy : bool, default False
+            Whether to ensure that the returned value is a not a view on
+            the array. Note that ``copy=False`` does not *ensure* that
+            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
+            a copy is made, even if not strictly necessary. This is typically
+            only possible when no missing values are present and `dtype`
+            is the equivalent numpy dtype.
+        na_value : scalar, optional
+             Scalar missing value indicator to use in numpy array. Defaults
+             to the native missing value indicator of this array (pd.NA).
+
+        Returns
+        -------
+        numpy.ndarray
+
+        Examples
+        --------
+        An object-dtype is the default result
+
+        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
+        >>> a.to_numpy()
+        array([True, False, NA], dtype=object)
+
+        When no missing values are present, an equivalent dtype can be used.
+
+        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
+        array([ True, False])
+        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
+        array([1, 2])
+
+        However, requesting such dtype will raise a ValueError if
+        missing values are present and the default missing value :attr:`NA`
+        is used.
+
+        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
+        >>> a
+        <BooleanArray>
+        [True, False, NA]
+        Length: 3, dtype: boolean
+
+        >>> a.to_numpy(dtype="bool")
+        Traceback (most recent call last):
+        ...
+        ValueError: cannot convert to bool numpy array in presence of missing values
+
+        Specify a valid `na_value` instead
+
+        >>> a.to_numpy(dtype="bool", na_value=False)
+        array([ True, False, False])
+        """
+        if na_value is lib.no_default:
+            na_value = libmissing.NA
+        if dtype is None:
+            dtype = object
+        if self._hasna:
+            if (
+                not (is_object_dtype(dtype) or is_string_dtype(dtype))
+                and na_value is libmissing.NA
+            ):
+                raise ValueError(
+                    f"cannot convert to '{dtype}'-dtype NumPy array "
+                    "with missing values. Specify an appropriate 'na_value' "
+                    "for this dtype."
+                )
+            # don't pass copy to astype -> always need a copy since we are mutating
+            data = self._data.astype(dtype)
+            data[self._mask] = na_value
+        else:
+            data = self._data.astype(dtype, copy=copy)
+        return data
+
+    __array_priority__ = 1000  # higher than ndarray so ops dispatch to us
+
+    def __array__(self, dtype=None) -> np.ndarray:
+        """
+        the array interface, return my values
+        We return an object array here to preserve our scalar values
+        """
+        return self.to_numpy(dtype=dtype)
+
+    def __arrow_array__(self, type=None):
+        """
+        Convert myself into a pyarrow Array.
+        """
+        import pyarrow as pa
+
+        return pa.array(self._data, mask=self._mask, type=type)
+
+    @property
+    def _hasna(self) -> bool:
+        # Note: this is expensive right now! The hope is that we can
+        # make this faster by having an optional mask, but not have to change
+        # source code using it..
+        return self._mask.any()
+
+    def isna(self) -> np.ndarray:
+        return self._mask
+
+    @property
+    def _na_value(self):
+        return self.dtype.na_value
+
+    @property
+    def nbytes(self) -> int:
+        return self._data.nbytes + self._mask.nbytes
+
+    @classmethod
+    def _concat_same_type(cls: Type[BaseMaskedArrayT], to_concat) -> BaseMaskedArrayT:
+        data = np.concatenate([x._data for x in to_concat])
+        mask = np.concatenate([x._mask for x in to_concat])
+        return cls(data, mask)
+
+    def take(
+        self: BaseMaskedArrayT,
+        indexer,
+        allow_fill: bool = False,
+        fill_value: Optional[Scalar] = None,
+    ) -> BaseMaskedArrayT:
+        # we always fill with 1 internally
+        # to avoid upcasting
+        data_fill_value = self._internal_fill_value if isna(fill_value) else fill_value
+        result = take(
+            self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill
+        )
+
+        mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill)
+
+        # if we are filling
+        # we only fill where the indexer is null
+        # not existing missing values
+        # TODO(jreback) what if we have a non-na float as a fill value?
+        if allow_fill and notna(fill_value):
+            fill_mask = np.asarray(indexer) == -1
+            result[fill_mask] = fill_value
+            mask = mask ^ fill_mask
+
+        return type(self)(result, mask, copy=False)
+
+    def copy(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
+        data, mask = self._data, self._mask
+        data = data.copy()
+        mask = mask.copy()
+        return type(self)(data, mask, copy=False)
+
+    def value_counts(self, dropna: bool = True) -> "Series":
+        """
+        Returns a Series containing counts of each unique value.
+
+        Parameters
+        ----------
+        dropna : bool, default True
+            Don't include counts of missing values.
+
+        Returns
+        -------
+        counts : Series
+
+        See Also
+        --------
+        Series.value_counts
+        """
+        from pandas import Index, Series
+        from pandas.arrays import IntegerArray
+
+        # compute counts on the data with no nans
+        data = self._data[~self._mask]
+        value_counts = Index(data).value_counts()
+
+        # TODO(extension)
+        # if we have allow Index to hold an ExtensionArray
+        # this is easier
+        index = value_counts.index.values.astype(object)
+
+        # if we want nans, count the mask
+        if dropna:
+            counts = value_counts.values
+        else:
+            counts = np.empty(len(value_counts) + 1, dtype="int64")
+            counts[:-1] = value_counts
+            counts[-1] = self._mask.sum()
+
+            index = Index(
+                np.concatenate([index, np.array([self.dtype.na_value], dtype=object)]),
+                dtype=object,
+            )
+
+        mask = np.zeros(len(counts), dtype="bool")
+        counts = IntegerArray(counts, mask)
+
+        return Series(counts, index=index)
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 4e2e37d88eb9a..e573fe661106e 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -1,4 +1,5 @@
 import numbers
+from typing import Optional, Tuple, Type, Union
 
 import numpy as np
 from numpy.lib.mixins import NDArrayOperatorsMixin
@@ -10,17 +11,17 @@
 
 from pandas.core.dtypes.dtypes import ExtensionDtype
 from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
-from pandas.core.dtypes.inference import is_array_like, is_list_like
+from pandas.core.dtypes.inference import is_array_like
 from pandas.core.dtypes.missing import isna
 
 from pandas import compat
 from pandas.core import nanops
 from pandas.core.algorithms import searchsorted, take, unique
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin
 from pandas.core.construction import extract_array
+from pandas.core.indexers import check_array_indexer
 from pandas.core.missing import backfill_1d, pad_1d
 
-from .base import ExtensionArray, ExtensionOpsMixin
-
 
 class PandasDtype(ExtensionDtype):
     """
@@ -33,56 +34,87 @@ class PandasDtype(ExtensionDtype):
 
     Parameters
     ----------
-    dtype : numpy.dtype
+    dtype : object
+        Object to be converted to a NumPy data type object.
+
+    See Also
+    --------
+    numpy.dtype
     """
 
     _metadata = ("_dtype",)
 
-    def __init__(self, dtype):
-        dtype = np.dtype(dtype)
-        self._dtype = dtype
-        self._name = dtype.name
-        self._type = dtype.type
+    def __init__(self, dtype: object):
+        self._dtype = np.dtype(dtype)
 
-    def __repr__(self):
-        return "PandasDtype({!r})".format(self.name)
+    def __repr__(self) -> str:
+        return f"PandasDtype({repr(self.name)})"
 
     @property
-    def numpy_dtype(self):
-        """The NumPy dtype this PandasDtype wraps."""
+    def numpy_dtype(self) -> np.dtype:
+        """
+        The NumPy dtype this PandasDtype wraps.
+        """
         return self._dtype
 
     @property
-    def name(self):
-        return self._name
+    def name(self) -> str:
+        """
+        A bit-width name for this data-type.
+        """
+        return self._dtype.name
 
     @property
-    def type(self):
-        return self._type
+    def type(self) -> Type[np.generic]:
+        """
+        The type object used to instantiate a scalar of this NumPy data-type.
+        """
+        return self._dtype.type
 
     @property
-    def _is_numeric(self):
+    def _is_numeric(self) -> bool:
         # exclude object, str, unicode, void.
         return self.kind in set("biufc")
 
     @property
-    def _is_boolean(self):
+    def _is_boolean(self) -> bool:
         return self.kind == "b"
 
     @classmethod
-    def construct_from_string(cls, string):
-        return cls(np.dtype(string))
+    def construct_from_string(cls, string: str) -> "PandasDtype":
+        try:
+            dtype = np.dtype(string)
+        except TypeError as err:
+            if not isinstance(string, str):
+                msg = f"'construct_from_string' expects a string, got {type(string)}"
+            else:
+                msg = f"Cannot construct a 'PandasDtype' from '{string}'"
+            raise TypeError(msg) from err
+        return cls(dtype)
 
-    def construct_array_type(cls):
+    @classmethod
+    def construct_array_type(cls) -> Type["PandasArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
         return PandasArray
 
     @property
-    def kind(self):
+    def kind(self) -> str:
+        """
+        A character code (one of 'biufcmMOSUV') identifying the general kind of data.
+        """
         return self._dtype.kind
 
     @property
-    def itemsize(self):
-        """The element size of this data-type object."""
+    def itemsize(self) -> int:
+        """
+        The element size of this data-type object.
+        """
         return self._dtype.itemsize
 
 
@@ -117,18 +149,17 @@ class PandasArray(ExtensionArray, ExtensionOpsMixin, NDArrayOperatorsMixin):
     # pandas internals, which turns off things like block consolidation.
     _typ = "npy_extension"
     __array_priority__ = 1000
+    _ndarray: np.ndarray
 
     # ------------------------------------------------------------------------
     # Constructors
 
-    def __init__(self, values, copy=False):
+    def __init__(self, values: Union[np.ndarray, "PandasArray"], copy: bool = False):
         if isinstance(values, type(self)):
             values = values._ndarray
         if not isinstance(values, np.ndarray):
             raise ValueError(
-                "'values' must be a NumPy array, not {typ}".format(
-                    typ=type(values).__name__
-                )
+                f"'values' must be a NumPy array, not {type(values).__name__}"
             )
 
         if values.ndim != 1:
@@ -141,7 +172,7 @@ def __init__(self, values, copy=False):
         self._dtype = PandasDtype(values.dtype)
 
     @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
+    def _from_sequence(cls, scalars, dtype=None, copy: bool = False) -> "PandasArray":
         if isinstance(dtype, PandasDtype):
             dtype = dtype._dtype
 
@@ -151,29 +182,29 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
         return cls(result)
 
     @classmethod
-    def _from_factorized(cls, values, original):
+    def _from_factorized(cls, values, original) -> "PandasArray":
         return cls(values)
 
     @classmethod
-    def _concat_same_type(cls, to_concat):
+    def _concat_same_type(cls, to_concat) -> "PandasArray":
         return cls(np.concatenate(to_concat))
 
     # ------------------------------------------------------------------------
     # Data
 
     @property
-    def dtype(self):
+    def dtype(self) -> PandasDtype:
         return self._dtype
 
     # ------------------------------------------------------------------------
     # NumPy Array Interface
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         return np.asarray(self._ndarray, dtype=dtype)
 
     _HANDLED_TYPES = (np.ndarray, numbers.Number)
 
-    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+    def __array_ufunc__(self, ufunc, method: str, *inputs, **kwargs):
         # Lightly modified version of
         # https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/\
         # numpy.lib.mixins.NDArrayOperatorsMixin.html
@@ -221,29 +252,27 @@ def __getitem__(self, item):
         if isinstance(item, type(self)):
             item = item._ndarray
 
+        item = check_array_indexer(self, item)
+
         result = self._ndarray[item]
         if not lib.is_scalar(item):
             result = type(self)(result)
         return result
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         value = extract_array(value, extract_numpy=True)
 
-        if not lib.is_scalar(key) and is_list_like(key):
+        key = check_array_indexer(self, key)
+        scalar_key = lib.is_scalar(key)
+        scalar_value = lib.is_scalar(value)
+
+        if not scalar_key and scalar_value:
             key = np.asarray(key)
 
-        if not lib.is_scalar(value):
-            value = np.asarray(value)
+        if not scalar_value:
+            value = np.asarray(value, dtype=self._ndarray.dtype)
 
-        values = self._ndarray
-        t = np.result_type(value, values)
-        if t != self._ndarray.dtype:
-            values = values.astype(t, casting="safe")
-            values[key] = value
-            self._dtype = PandasDtype(t)
-            self._ndarray = values
-        else:
-            self._ndarray[key] = value
+        self._ndarray[key] = value
 
     def __len__(self) -> int:
         return len(self._ndarray)
@@ -252,10 +281,12 @@ def __len__(self) -> int:
     def nbytes(self) -> int:
         return self._ndarray.nbytes
 
-    def isna(self):
+    def isna(self) -> np.ndarray:
         return isna(self._ndarray)
 
-    def fillna(self, value=None, method=None, limit=None):
+    def fillna(
+        self, value=None, method: Optional[str] = None, limit: Optional[int] = None,
+    ) -> "PandasArray":
         # TODO(_values_for_fillna): remove this
         value, method = validate_fillna_kwargs(value, method)
 
@@ -264,8 +295,8 @@ def fillna(self, value=None, method=None, limit=None):
         if is_array_like(value):
             if len(value) != len(self):
                 raise ValueError(
-                    "Length of 'value' does not match. Got ({}) "
-                    " expected {}".format(len(value), len(self))
+                    f"Length of 'value' does not match. Got ({len(value)}) "
+                    f" expected {len(self)}"
                 )
             value = value[mask]
 
@@ -282,22 +313,25 @@ def fillna(self, value=None, method=None, limit=None):
             new_values = self.copy()
         return new_values
 
-    def take(self, indices, allow_fill=False, fill_value=None):
+    def take(self, indices, allow_fill=False, fill_value=None) -> "PandasArray":
+        if fill_value is None:
+            # Primarily for subclasses
+            fill_value = self.dtype.na_value
         result = take(
             self._ndarray, indices, allow_fill=allow_fill, fill_value=fill_value
         )
         return type(self)(result)
 
-    def copy(self):
+    def copy(self) -> "PandasArray":
         return type(self)(self._ndarray.copy())
 
-    def _values_for_argsort(self):
+    def _values_for_argsort(self) -> np.ndarray:
         return self._ndarray
 
-    def _values_for_factorize(self):
+    def _values_for_factorize(self) -> Tuple[np.ndarray, int]:
         return self._ndarray, -1
 
-    def unique(self):
+    def unique(self) -> "PandasArray":
         return type(self)(unique(self._ndarray))
 
     # ------------------------------------------------------------------------
@@ -308,8 +342,8 @@ def _reduce(self, name, skipna=True, **kwargs):
         if meth:
             return meth(skipna=skipna, **kwargs)
         else:
-            msg = "'{}' does not implement reduction '{}'"
-            raise TypeError(msg.format(type(self).__name__, name))
+            msg = f"'{type(self).__name__}' does not implement reduction '{name}'"
+            raise TypeError(msg)
 
     def any(self, axis=None, out=None, keepdims=False, skipna=True):
         nv.validate_any((), dict(out=out, keepdims=keepdims))
@@ -405,27 +439,15 @@ def skew(self, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
 
     # ------------------------------------------------------------------------
     # Additional Methods
-    def to_numpy(self, dtype=None, copy=False):
-        """
-        Convert the PandasArray to a :class:`numpy.ndarray`.
-
-        By default, this requires no coercion or copying of data.
-
-        Parameters
-        ----------
-        dtype : numpy.dtype
-            The NumPy dtype to pass to :func:`numpy.asarray`.
-        copy : bool, default False
-            Whether to copy the underlying data.
-
-        Returns
-        -------
-        ndarray
-        """
+    def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default):
         result = np.asarray(self._ndarray, dtype=dtype)
-        if copy and result is self._ndarray:
+
+        if (copy or na_value is not lib.no_default) and result is self._ndarray:
             result = result.copy()
 
+        if na_value is not lib.no_default:
+            result[self.isna()] = na_value
+
         return result
 
     @Appender(ExtensionArray.searchsorted.__doc__)
@@ -456,9 +478,7 @@ def arithmetic_method(self, other):
 
             return cls(result)
 
-        return compat.set_function_name(
-            arithmetic_method, "__{}__".format(op.__name__), cls
-        )
+        return compat.set_function_name(arithmetic_method, f"__{op.__name__}__", cls)
 
     _create_comparison_method = _create_arithmetic_method
 
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index f2d74794eadf5..8383b783d90e7 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -4,7 +4,6 @@
 
 import numpy as np
 
-from pandas._libs import lib
 from pandas._libs.tslibs import (
     NaT,
     NaTType,
@@ -21,22 +20,20 @@
     period_asfreq_arr,
 )
 from pandas._libs.tslibs.timedeltas import Timedelta, delta_to_nanoseconds
-import pandas.compat as compat
-from pandas.util._decorators import Appender, cache_readonly
+from pandas.util._decorators import cache_readonly
 
 from pandas.core.dtypes.common import (
     _TD_DTYPE,
     ensure_object,
     is_datetime64_dtype,
     is_float_dtype,
-    is_list_like,
     is_period_dtype,
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import PeriodDtype
 from pandas.core.dtypes.generic import (
-    ABCDataFrame,
     ABCIndexClass,
+    ABCPeriod,
     ABCPeriodArray,
     ABCPeriodIndex,
     ABCSeries,
@@ -62,52 +59,6 @@ def f(self):
     return property(f)
 
 
-def _period_array_cmp(cls, op):
-    """
-    Wrap comparison operations to convert Period-like to PeriodDtype
-    """
-    opname = "__{name}__".format(name=op.__name__)
-    nat_result = opname == "__ne__"
-
-    def wrapper(self, other):
-        op = getattr(self.asi8, opname)
-
-        other = lib.item_from_zerodim(other)
-        if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-            return NotImplemented
-
-        if is_list_like(other) and len(other) != len(self):
-            raise ValueError("Lengths must match")
-
-        if isinstance(other, Period):
-            self._check_compatible_with(other)
-
-            result = op(other.ordinal)
-        elif isinstance(other, cls):
-            self._check_compatible_with(other)
-
-            result = op(other.asi8)
-
-            mask = self._isnan | other._isnan
-            if mask.any():
-                result[mask] = nat_result
-
-            return result
-        elif other is NaT:
-            result = np.empty(len(self.asi8), dtype=bool)
-            result.fill(nat_result)
-        else:
-            other = Period(other, freq=self.freq)
-            result = op(other.ordinal)
-
-        if self._hasnans:
-            result[self._isnan] = nat_result
-
-        return result
-
-    return compat.set_function_name(wrapper, opname, cls)
-
-
 class PeriodArray(dtl.DatetimeLikeArrayMixin, dtl.DatelikeOps):
     """
     Pandas ExtensionArray for storing Period data.
@@ -163,9 +114,11 @@ class PeriodArray(dtl.DatetimeLikeArrayMixin, dtl.DatelikeOps):
     __array_priority__ = 1000
     _typ = "periodarray"  # ABCPeriodArray
     _scalar_type = Period
+    _recognized_scalars = (Period,)
+    _is_recognized_dtype = is_period_dtype
 
     # Names others delegate to us
-    _other_ops = []  # type: List[str]
+    _other_ops: List[str] = []
     _bool_ops = ["is_leap_year"]
     _object_ops = ["start_time", "end_time", "freq"]
     _field_ops = [
@@ -207,12 +160,7 @@ def __init__(self, values, freq=None, dtype=None, copy=False):
 
         if isinstance(values, type(self)):
             if freq is not None and freq != values.freq:
-                msg = DIFFERENT_FREQ.format(
-                    cls=type(self).__name__,
-                    own_freq=values.freq.freqstr,
-                    other_freq=freq.freqstr,
-                )
-                raise IncompatibleFrequency(msg)
+                raise raise_on_incompatible(values, freq)
             values, freq = values._data, values.freq
 
         values = np.array(values, dtype="int64", copy=copy)
@@ -222,8 +170,9 @@ def __init__(self, values, freq=None, dtype=None, copy=False):
         self._dtype = PeriodDtype(freq)
 
     @classmethod
-    def _simple_new(cls, values, freq=None, **kwargs):
+    def _simple_new(cls, values: np.ndarray, freq=None, **kwargs):
         # alias for PeriodArray.__init__
+        assert isinstance(values, np.ndarray) and values.dtype == "i8"
         return cls(values, freq=freq, **kwargs)
 
     @classmethod
@@ -306,18 +255,16 @@ def _unbox_scalar(self, value: Union[Period, NaTType]) -> int:
                 self._check_compatible_with(value)
             return value.ordinal
         else:
-            raise ValueError(
-                "'value' should be a Period. Got '{val}' instead.".format(val=value)
-            )
+            raise ValueError(f"'value' should be a Period. Got '{value}' instead.")
 
     def _scalar_from_string(self, value: str) -> Period:
         return Period(value, freq=self.freq)
 
-    def _check_compatible_with(self, other):
+    def _check_compatible_with(self, other, setitem: bool = False):
         if other is NaT:
             return
         if self.freqstr != other.freqstr:
-            _raise_on_incompatible(self, other)
+            raise raise_on_incompatible(self, other)
 
     # --------------------------------------------------------------------
     # Data / Attributes
@@ -326,7 +273,7 @@ def _check_compatible_with(self, other):
     def dtype(self):
         return self._dtype
 
-    # read-only property overwriting read/write
+    # error: Read-only property cannot override read-write property  [misc]
     @property  # type: ignore
     def freq(self):
         """
@@ -334,10 +281,36 @@ def freq(self):
         """
         return self.dtype.freq
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         # overriding DatetimelikeArray
         return np.array(list(self), dtype=object)
 
+    def __arrow_array__(self, type=None):
+        """
+        Convert myself into a pyarrow Array.
+        """
+        import pyarrow
+        from pandas.core.arrays._arrow_utils import ArrowPeriodType
+
+        if type is not None:
+            if pyarrow.types.is_integer(type):
+                return pyarrow.array(self._data, mask=self.isna(), type=type)
+            elif isinstance(type, ArrowPeriodType):
+                # ensure we have the same freq
+                if self.freqstr != type.freq:
+                    raise TypeError(
+                        "Not supported to convert PeriodArray to array with different "
+                        f"'freq' ({self.freqstr} vs {type.freq})"
+                    )
+            else:
+                raise TypeError(
+                    f"Not supported to convert PeriodArray to '{type}' type"
+                )
+
+        period_type = ArrowPeriodType(self.freqstr)
+        storage_array = pyarrow.array(self._data, mask=self.isna(), type="int64")
+        return pyarrow.ExtensionArray.from_storage(period_type, storage_array)
+
     # --------------------------------------------------------------------
     # Vectorized analogues of Period properties
 
@@ -444,10 +417,11 @@ def to_timestamp(self, freq=None, how="start"):
 
         Parameters
         ----------
-        freq : string or DateOffset, optional
+        freq : str or DateOffset, optional
             Target frequency. The default is 'D' for week or longer,
-            'S' otherwise
+            'S' otherwise.
         how : {'s', 'e', 'start', 'end'}
+            Whether to use the start or end of the time period being converted.
 
         Returns
         -------
@@ -482,24 +456,8 @@ def to_timestamp(self, freq=None, how="start"):
     # --------------------------------------------------------------------
     # Array-like / EA-Interface Methods
 
-    def _formatter(self, boxed=False):
-        if boxed:
-            return str
-        return "'{}'".format
-
-    @Appender(dtl.DatetimeLikeArrayMixin._validate_fill_value.__doc__)
-    def _validate_fill_value(self, fill_value):
-        if isna(fill_value):
-            fill_value = iNaT
-        elif isinstance(fill_value, Period):
-            self._check_compatible_with(fill_value)
-            fill_value = fill_value.ordinal
-        else:
-            raise ValueError(
-                "'fill_value' should be a Period. "
-                "Got '{got}'.".format(got=fill_value)
-            )
-        return fill_value
+    def _values_for_argsort(self):
+        return self._data
 
     # --------------------------------------------------------------------
 
@@ -515,13 +473,13 @@ def _time_shift(self, periods, freq=None):
         ----------
         periods : int
             Number of periods to shift by.
-        freq : pandas.DateOffset, pandas.Timedelta, or string
+        freq : pandas.DateOffset, pandas.Timedelta, or str
             Frequency increment to shift by.
         """
         if freq is not None:
             raise TypeError(
                 "`freq` argument is not supported for "
-                "{cls}._time_shift".format(cls=type(self).__name__)
+                f"{type(self).__name__}._time_shift"
             )
         values = self.asi8 + periods * self.freq.n
         if self._hasnans:
@@ -539,17 +497,20 @@ def asfreq(self, freq=None, how="E"):
         Parameters
         ----------
         freq : str
-            a frequency
+            A frequency.
         how : str {'E', 'S'}
-            'E', 'END', or 'FINISH' for end,
-            'S', 'START', or 'BEGIN' for start.
             Whether the elements should be aligned to the end
-            or start within pa period. January 31st ('END') vs.
-            January 1st ('START') for example.
+            or start within pa period.
+
+            * 'E', 'END', or 'FINISH' for end,
+            * 'S', 'START', or 'BEGIN' for start.
+
+            January 31st ('END') vs. January 1st ('START') for example.
 
         Returns
         -------
-        new : Period Array/Index with the new frequency
+        Period Array/Index
+            Constructed with the new frequency.
 
         Examples
         --------
@@ -591,6 +552,11 @@ def asfreq(self, freq=None, how="E"):
     # ------------------------------------------------------------------
     # Rendering Methods
 
+    def _formatter(self, boxed=False):
+        if boxed:
+            return str
+        return "'{}'".format
+
     def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
         """
         actually format my specific types
@@ -600,7 +566,7 @@ def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
         if date_format:
             formatter = lambda dt: dt.strftime(date_format)
         else:
-            formatter = lambda dt: "%s" % dt
+            formatter = lambda dt: str(dt)
 
         if self._hasnans:
             mask = self._isnan
@@ -622,17 +588,8 @@ def astype(self, dtype, copy=True):
             return self.asfreq(dtype.freq)
         return super().astype(dtype, copy=copy)
 
-    @property
-    def flags(self):
-        # TODO: remove
-        # We need this since reduction.SeriesBinGrouper uses values.flags
-        # Ideally, we wouldn't be passing objects down there in the first
-        # place.
-        return self._data.flags
-
     # ------------------------------------------------------------------
     # Arithmetic Methods
-    _create_comparison_method = classmethod(_period_array_cmp)
 
     def _sub_datelike(self, other):
         assert other is not NaT
@@ -651,12 +608,23 @@ def _sub_period(self, other):
 
         return new_data
 
-    @Appender(dtl.DatetimeLikeArrayMixin._addsub_int_array.__doc__)
     def _addsub_int_array(
-        self,
-        other: Union[ABCPeriodArray, ABCSeries, ABCPeriodIndex, np.ndarray],
-        op: Callable[[Any], Any],
-    ) -> ABCPeriodArray:
+        self, other: np.ndarray, op: Callable[[Any, Any], Any],
+    ) -> "PeriodArray":
+        """
+        Add or subtract array of integers; equivalent to applying
+        `_time_shift` pointwise.
+
+        Parameters
+        ----------
+        other : np.ndarray[integer-dtype]
+        op : {operator.add, operator.sub}
+
+        Returns
+        -------
+        result : PeriodArray
+        """
+
         assert op in [operator.add, operator.sub]
         if op is operator.sub:
             other = -other
@@ -669,7 +637,7 @@ def _add_offset(self, other):
         assert not isinstance(other, Tick)
         base = libfrequencies.get_base_alias(other.rule_code)
         if base != self.freq.rule_code:
-            _raise_on_incompatible(self, other)
+            raise raise_on_incompatible(self, other)
 
         # Note: when calling parent class's _add_timedeltalike_scalar,
         #  it will call delta_to_nanoseconds(delta).  Because delta here
@@ -737,7 +705,7 @@ def _add_delta(self, other):
         """
         if not isinstance(self.freq, Tick):
             # We cannot add timedelta-like to non-tick PeriodArray
-            _raise_on_incompatible(self, other)
+            raise raise_on_incompatible(self, other)
 
         new_ordinals = super()._add_delta(other)
         return type(self)(new_ordinals, freq=self.freq)
@@ -789,16 +757,10 @@ def _check_timedeltalike_freq_compat(self, other):
             # by which will be added to self.
             return delta
 
-        _raise_on_incompatible(self, other)
-
-    def _values_for_argsort(self):
-        return self._data
-
-
-PeriodArray._add_comparison_ops()
+        raise raise_on_incompatible(self, other)
 
 
-def _raise_on_incompatible(left, right):
+def raise_on_incompatible(left, right):
     """
     Helper function to render a consistent error message when raising
     IncompatibleFrequency.
@@ -806,14 +768,15 @@ def _raise_on_incompatible(left, right):
     Parameters
     ----------
     left : PeriodArray
-    right : DateOffset, Period, ndarray, or timedelta-like
+    right : None, DateOffset, Period, ndarray, or timedelta-like
 
-    Raises
-    ------
+    Returns
+    -------
     IncompatibleFrequency
+        Exception to be raised by the caller.
     """
     # GH#24283 error message format depends on whether right is scalar
-    if isinstance(right, np.ndarray):
+    if isinstance(right, np.ndarray) or right is None:
         other_freq = None
     elif isinstance(right, (ABCPeriodIndex, PeriodArray, Period, DateOffset)):
         other_freq = right.freqstr
@@ -823,7 +786,7 @@ def _raise_on_incompatible(left, right):
     msg = DIFFERENT_FREQ.format(
         cls=type(left).__name__, own_freq=left.freqstr, other_freq=other_freq
     )
-    raise IncompatibleFrequency(msg)
+    return IncompatibleFrequency(msg)
 
 
 # -------------------------------------------------------------------
@@ -831,7 +794,9 @@ def _raise_on_incompatible(left, right):
 
 
 def period_array(
-    data: Sequence[Optional[Period]], freq: Optional[Tick] = None, copy: bool = False
+    data: Sequence[Optional[Period]],
+    freq: Optional[Union[str, Tick]] = None,
+    copy: bool = False,
 ) -> PeriodArray:
     """
     Construct a new PeriodArray from a sequence of Period scalars.
@@ -896,9 +861,9 @@ def period_array(
 
     data = np.asarray(data)
 
+    dtype: Optional[PeriodDtype]
     if freq:
-        # typed Optional here because the else block below assigns None
-        dtype = PeriodDtype(freq)  # type: Optional[PeriodDtype]
+        dtype = PeriodDtype(freq)
     else:
         dtype = None
 
@@ -964,7 +929,7 @@ def dt64arr_to_periodarr(data, freq, tz=None):
 
     """
     if data.dtype != np.dtype("M8[ns]"):
-        raise ValueError("Wrong dtype: {dtype}".format(dtype=data.dtype))
+        raise ValueError(f"Wrong dtype: {data.dtype}")
 
     if freq is None:
         if isinstance(data, ABCIndexClass):
@@ -996,8 +961,8 @@ def _get_ordinal_range(start, end, periods, freq, mult=1):
     if end is not None:
         end = Period(end, freq)
 
-    is_start_per = isinstance(start, Period)
-    is_end_per = isinstance(end, Period)
+    is_start_per = isinstance(start, ABCPeriod)
+    is_end_per = isinstance(end, ABCPeriod)
 
     if is_start_per and is_end_per and start.freq != end.freq:
         raise ValueError("start and end must have same freq")
diff --git a/pandas/core/arrays/sparse/__init__.py b/pandas/core/arrays/sparse/__init__.py
new file mode 100644
index 0000000000000..e928db499a771
--- /dev/null
+++ b/pandas/core/arrays/sparse/__init__.py
@@ -0,0 +1,10 @@
+# flake8: noqa: F401
+
+from pandas.core.arrays.sparse.accessor import SparseAccessor, SparseFrameAccessor
+from pandas.core.arrays.sparse.array import (
+    BlockIndex,
+    IntIndex,
+    SparseArray,
+    _make_index,
+)
+from pandas.core.arrays.sparse.dtype import SparseDtype
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
new file mode 100644
index 0000000000000..92c05f44d677c
--- /dev/null
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -0,0 +1,328 @@
+"""Sparse accessor"""
+
+import numpy as np
+
+from pandas.compat._optional import import_optional_dependency
+
+from pandas.core.dtypes.cast import find_common_type
+
+from pandas.core.accessor import PandasDelegate, delegate_names
+from pandas.core.arrays.sparse.array import SparseArray
+from pandas.core.arrays.sparse.dtype import SparseDtype
+
+
+class BaseAccessor:
+    _validation_msg = "Can only use the '.sparse' accessor with Sparse data."
+
+    def __init__(self, data=None):
+        self._parent = data
+        self._validate(data)
+
+    def _validate(self, data):
+        raise NotImplementedError
+
+
+@delegate_names(
+    SparseArray, ["npoints", "density", "fill_value", "sp_values"], typ="property"
+)
+class SparseAccessor(BaseAccessor, PandasDelegate):
+    """
+    Accessor for SparseSparse from other sparse matrix data types.
+    """
+
+    def _validate(self, data):
+        if not isinstance(data.dtype, SparseDtype):
+            raise AttributeError(self._validation_msg)
+
+    def _delegate_property_get(self, name, *args, **kwargs):
+        return getattr(self._parent.array, name)
+
+    def _delegate_method(self, name, *args, **kwargs):
+        if name == "from_coo":
+            return self.from_coo(*args, **kwargs)
+        elif name == "to_coo":
+            return self.to_coo(*args, **kwargs)
+        else:
+            raise ValueError
+
+    @classmethod
+    def from_coo(cls, A, dense_index=False):
+        """
+        Create a Series with sparse values from a scipy.sparse.coo_matrix.
+
+        Parameters
+        ----------
+        A : scipy.sparse.coo_matrix
+        dense_index : bool, default False
+            If False (default), the SparseSeries index consists of only the
+            coords of the non-null entries of the original coo_matrix.
+            If True, the SparseSeries index consists of the full sorted
+            (row, col) coordinates of the coo_matrix.
+
+        Returns
+        -------
+        s : Series
+            A Series with sparse values.
+
+        Examples
+        --------
+        >>> from scipy import sparse
+        >>> A = sparse.coo_matrix(([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])),
+                               shape=(3, 4))
+        >>> A
+        <3x4 sparse matrix of type '<class 'numpy.float64'>'
+                with 3 stored elements in COOrdinate format>
+        >>> A.todense()
+        matrix([[ 0.,  0.,  1.,  2.],
+                [ 3.,  0.,  0.,  0.],
+                [ 0.,  0.,  0.,  0.]])
+        >>> ss = pd.Series.sparse.from_coo(A)
+        >>> ss
+        0  2    1
+           3    2
+        1  0    3
+        dtype: float64
+        BlockIndex
+        Block locations: array([0], dtype=int32)
+        Block lengths: array([3], dtype=int32)
+        """
+        from pandas.core.arrays.sparse.scipy_sparse import _coo_to_sparse_series
+        from pandas import Series
+
+        result = _coo_to_sparse_series(A, dense_index=dense_index)
+        result = Series(result.array, index=result.index, copy=False)
+
+        return result
+
+    def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels=False):
+        """
+        Create a scipy.sparse.coo_matrix from a Series with MultiIndex.
+
+        Use row_levels and column_levels to determine the row and column
+        coordinates respectively. row_levels and column_levels are the names
+        (labels) or numbers of the levels. {row_levels, column_levels} must be
+        a partition of the MultiIndex level names (or numbers).
+
+        Parameters
+        ----------
+        row_levels : tuple/list
+        column_levels : tuple/list
+        sort_labels : bool, default False
+            Sort the row and column labels before forming the sparse matrix.
+
+        Returns
+        -------
+        y : scipy.sparse.coo_matrix
+        rows : list (row labels)
+        columns : list (column labels)
+
+        Examples
+        --------
+        >>> s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])
+        >>> s.index = pd.MultiIndex.from_tuples([(1, 2, 'a', 0),
+                                                (1, 2, 'a', 1),
+                                                (1, 1, 'b', 0),
+                                                (1, 1, 'b', 1),
+                                                (2, 1, 'b', 0),
+                                                (2, 1, 'b', 1)],
+                                                names=['A', 'B', 'C', 'D'])
+        >>> ss = s.astype("Sparse")
+        >>> A, rows, columns = ss.sparse.to_coo(row_levels=['A', 'B'],
+        ...                                     column_levels=['C', 'D'],
+        ...                                     sort_labels=True)
+        >>> A
+        <3x4 sparse matrix of type '<class 'numpy.float64'>'
+                with 3 stored elements in COOrdinate format>
+        >>> A.todense()
+        matrix([[ 0.,  0.,  1.,  3.],
+        [ 3.,  0.,  0.,  0.],
+        [ 0.,  0.,  0.,  0.]])
+        >>> rows
+        [(1, 1), (1, 2), (2, 1)]
+        >>> columns
+        [('a', 0), ('a', 1), ('b', 0), ('b', 1)]
+        """
+        from pandas.core.arrays.sparse.scipy_sparse import _sparse_series_to_coo
+
+        A, rows, columns = _sparse_series_to_coo(
+            self._parent, row_levels, column_levels, sort_labels=sort_labels
+        )
+        return A, rows, columns
+
+    def to_dense(self):
+        """
+        Convert a Series from sparse values to dense.
+
+        .. versionadded:: 0.25.0
+
+        Returns
+        -------
+        Series:
+            A Series with the same values, stored as a dense array.
+
+        Examples
+        --------
+        >>> series = pd.Series(pd.arrays.SparseArray([0, 1, 0]))
+        >>> series
+        0    0
+        1    1
+        2    0
+        dtype: Sparse[int64, 0]
+
+        >>> series.sparse.to_dense()
+        0    0
+        1    1
+        2    0
+        dtype: int64
+        """
+        from pandas import Series
+
+        return Series(
+            self._parent.array.to_dense(),
+            index=self._parent.index,
+            name=self._parent.name,
+        )
+
+
+class SparseFrameAccessor(BaseAccessor, PandasDelegate):
+    """
+    DataFrame accessor for sparse data.
+
+    .. versionadded:: 0.25.0
+    """
+
+    def _validate(self, data):
+        dtypes = data.dtypes
+        if not all(isinstance(t, SparseDtype) for t in dtypes):
+            raise AttributeError(self._validation_msg)
+
+    @classmethod
+    def from_spmatrix(cls, data, index=None, columns=None):
+        """
+        Create a new DataFrame from a scipy sparse matrix.
+
+        .. versionadded:: 0.25.0
+
+        Parameters
+        ----------
+        data : scipy.sparse.spmatrix
+            Must be convertible to csc format.
+        index, columns : Index, optional
+            Row and column labels to use for the resulting DataFrame.
+            Defaults to a RangeIndex.
+
+        Returns
+        -------
+        DataFrame
+            Each column of the DataFrame is stored as a
+            :class:`arrays.SparseArray`.
+
+        Examples
+        --------
+        >>> import scipy.sparse
+        >>> mat = scipy.sparse.eye(3)
+        >>> pd.DataFrame.sparse.from_spmatrix(mat)
+             0    1    2
+        0  1.0  0.0  0.0
+        1  0.0  1.0  0.0
+        2  0.0  0.0  1.0
+        """
+        from pandas import DataFrame
+
+        data = data.tocsc()
+        index, columns = cls._prep_index(data, index, columns)
+        sparrays = [SparseArray.from_spmatrix(data[:, i]) for i in range(data.shape[1])]
+        data = dict(enumerate(sparrays))
+        result = DataFrame(data, index=index)
+        result.columns = columns
+        return result
+
+    def to_dense(self):
+        """
+        Convert a DataFrame with sparse values to dense.
+
+        .. versionadded:: 0.25.0
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with the same values stored as dense arrays.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1, 0])})
+        >>> df.sparse.to_dense()
+           A
+        0  0
+        1  1
+        2  0
+        """
+        from pandas import DataFrame
+
+        data = {k: v.array.to_dense() for k, v in self._parent.items()}
+        return DataFrame(data, index=self._parent.index, columns=self._parent.columns)
+
+    def to_coo(self):
+        """
+        Return the contents of the frame as a sparse SciPy COO matrix.
+
+        .. versionadded:: 0.25.0
+
+        Returns
+        -------
+        coo_matrix : scipy.sparse.spmatrix
+            If the caller is heterogeneous and contains booleans or objects,
+            the result will be of dtype=object. See Notes.
+
+        Notes
+        -----
+        The dtype will be the lowest-common-denominator type (implicit
+        upcasting); that is to say if the dtypes (even of numeric types)
+        are mixed, the one that accommodates all will be chosen.
+
+        e.g. If the dtypes are float16 and float32, dtype will be upcast to
+        float32. By numpy.find_common_type convention, mixing int64 and
+        and uint64 will result in a float64 dtype.
+        """
+        import_optional_dependency("scipy")
+        from scipy.sparse import coo_matrix
+
+        dtype = find_common_type(self._parent.dtypes)
+        if isinstance(dtype, SparseDtype):
+            dtype = dtype.subtype
+
+        cols, rows, datas = [], [], []
+        for col, name in enumerate(self._parent):
+            s = self._parent[name]
+            row = s.array.sp_index.to_int_index().indices
+            cols.append(np.repeat(col, len(row)))
+            rows.append(row)
+            datas.append(s.array.sp_values.astype(dtype, copy=False))
+
+        cols = np.concatenate(cols)
+        rows = np.concatenate(rows)
+        datas = np.concatenate(datas)
+        return coo_matrix((datas, (rows, cols)), shape=self._parent.shape)
+
+    @property
+    def density(self) -> float:
+        """
+        Ratio of non-sparse points to total (dense) data points.
+        """
+        return np.mean([column.array.density for _, column in self._parent.items()])
+
+    @staticmethod
+    def _prep_index(data, index, columns):
+        import pandas.core.indexes.base as ibase
+
+        N, K = data.shape
+        if index is None:
+            index = ibase.default_index(N)
+        if columns is None:
+            columns = ibase.default_index(K)
+
+        if len(columns) != K:
+            raise ValueError(f"Column length mismatch: {len(columns)} vs. {K}")
+        if len(index) != N:
+            raise ValueError(f"Index length mismatch: {len(index)} vs. {N}")
+        return index, columns
diff --git a/pandas/core/arrays/sparse.py b/pandas/core/arrays/sparse/array.py
similarity index 65%
rename from pandas/core/arrays/sparse.py
rename to pandas/core/arrays/sparse/array.py
index 24dafd11ae2b7..8008805ddcf87 100644
--- a/pandas/core/arrays/sparse.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -4,22 +4,19 @@
 from collections import abc
 import numbers
 import operator
-import re
 from typing import Any, Callable
 import warnings
 
 import numpy as np
 
-from pandas._libs import index as libindex, lib
+from pandas._libs import lib
 import pandas._libs.sparse as splib
 from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex
 from pandas._libs.tslibs import NaT
 import pandas.compat as compat
-from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import function as nv
 from pandas.errors import PerformanceWarning
 
-from pandas.core.dtypes.base import ExtensionDtype
 from pandas.core.dtypes.cast import (
     astype_nansafe,
     construct_1d_arraylike_from_scalar,
@@ -37,352 +34,22 @@
     is_string_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.dtypes import register_extension_dtype
-from pandas.core.dtypes.generic import (
-    ABCDataFrame,
-    ABCIndexClass,
-    ABCSeries,
-    ABCSparseArray,
-    ABCSparseSeries,
-)
+from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries, ABCSparseArray
 from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna
 
-from pandas._typing import Dtype
-from pandas.core.accessor import PandasDelegate, delegate_names
 import pandas.core.algorithms as algos
 from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+from pandas.core.arrays.sparse.dtype import SparseDtype
 from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.construction import sanitize_array
+from pandas.core.indexers import check_array_indexer
 from pandas.core.missing import interpolate_2d
 import pandas.core.ops as ops
+from pandas.core.ops.common import unpack_zerodim_and_defer
 
 import pandas.io.formats.printing as printing
 
-
-# ----------------------------------------------------------------------------
-# Dtype
-@register_extension_dtype
-class SparseDtype(ExtensionDtype):
-    """
-    Dtype for data stored in :class:`SparseArray`.
-
-    This dtype implements the pandas ExtensionDtype interface.
-
-    .. versionadded:: 0.24.0
-
-    Parameters
-    ----------
-    dtype : str, ExtensionDtype, numpy.dtype, type, default numpy.float64
-        The dtype of the underlying array storing the non-fill value values.
-    fill_value : scalar, optional
-        The scalar value not stored in the SparseArray. By default, this
-        depends on `dtype`.
-
-        =========== ==========
-        dtype       na_value
-        =========== ==========
-        float       ``np.nan``
-        int         ``0``
-        bool        ``False``
-        datetime64  ``pd.NaT``
-        timedelta64 ``pd.NaT``
-        =========== ==========
-
-        The default value may be overridden by specifying a `fill_value`.
-
-    Attributes
-    ----------
-    None
-
-    Methods
-    -------
-    None
-    """
-
-    # We include `_is_na_fill_value` in the metadata to avoid hash collisions
-    # between SparseDtype(float, 0.0) and SparseDtype(float, nan).
-    # Without is_na_fill_value in the comparison, those would be equal since
-    # hash(nan) is (sometimes?) 0.
-    _metadata = ("_dtype", "_fill_value", "_is_na_fill_value")
-
-    def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None) -> None:
-
-        if isinstance(dtype, type(self)):
-            if fill_value is None:
-                fill_value = dtype.fill_value
-            dtype = dtype.subtype
-
-        dtype = pandas_dtype(dtype)
-        if is_string_dtype(dtype):
-            dtype = np.dtype("object")
-
-        if fill_value is None:
-            fill_value = na_value_for_dtype(dtype)
-
-        if not is_scalar(fill_value):
-            raise ValueError(
-                "fill_value must be a scalar. Got {} instead".format(fill_value)
-            )
-        self._dtype = dtype
-        self._fill_value = fill_value
-
-    def __hash__(self):
-        # Python3 doesn't inherit __hash__ when a base class overrides
-        # __eq__, so we explicitly do it here.
-        return super().__hash__()
-
-    def __eq__(self, other):
-        # We have to override __eq__ to handle NA values in _metadata.
-        # The base class does simple == checks, which fail for NA.
-        if isinstance(other, str):
-            try:
-                other = self.construct_from_string(other)
-            except TypeError:
-                return False
-
-        if isinstance(other, type(self)):
-            subtype = self.subtype == other.subtype
-            if self._is_na_fill_value:
-                # this case is complicated by two things:
-                # SparseDtype(float, float(nan)) == SparseDtype(float, np.nan)
-                # SparseDtype(float, np.nan)     != SparseDtype(float, pd.NaT)
-                # i.e. we want to treat any floating-point NaN as equal, but
-                # not a floating-point NaN and a datetime NaT.
-                fill_value = (
-                    other._is_na_fill_value
-                    and isinstance(self.fill_value, type(other.fill_value))
-                    or isinstance(other.fill_value, type(self.fill_value))
-                )
-            else:
-                fill_value = self.fill_value == other.fill_value
-
-            return subtype and fill_value
-        return False
-
-    @property
-    def fill_value(self):
-        """
-        The fill value of the array.
-
-        Converting the SparseArray to a dense ndarray will fill the
-        array with this value.
-
-        .. warning::
-
-           It's possible to end up with a SparseArray that has ``fill_value``
-           values in ``sp_values``. This can occur, for example, when setting
-           ``SparseArray.fill_value`` directly.
-        """
-        return self._fill_value
-
-    @property
-    def _is_na_fill_value(self):
-        return isna(self.fill_value)
-
-    @property
-    def _is_numeric(self):
-        return not is_object_dtype(self.subtype)
-
-    @property
-    def _is_boolean(self):
-        return is_bool_dtype(self.subtype)
-
-    @property
-    def kind(self):
-        """
-        The sparse kind. Either 'integer', or 'block'.
-        """
-        return self.subtype.kind
-
-    @property
-    def type(self):
-        return self.subtype.type
-
-    @property
-    def subtype(self):
-        return self._dtype
-
-    @property
-    def name(self):
-        return "Sparse[{}, {}]".format(self.subtype.name, self.fill_value)
-
-    def __repr__(self):
-        return self.name
-
-    @classmethod
-    def construct_array_type(cls):
-        return SparseArray
-
-    @classmethod
-    def construct_from_string(cls, string):
-        """
-        Construct a SparseDtype from a string form.
-
-        Parameters
-        ----------
-        string : str
-            Can take the following forms.
-
-            string           dtype
-            ================ ============================
-            'int'            SparseDtype[np.int64, 0]
-            'Sparse'         SparseDtype[np.float64, nan]
-            'Sparse[int]'    SparseDtype[np.int64, 0]
-            'Sparse[int, 0]' SparseDtype[np.int64, 0]
-            ================ ============================
-
-            It is not possible to specify non-default fill values
-            with a string. An argument like ``'Sparse[int, 1]'``
-            will raise a ``TypeError`` because the default fill value
-            for integers is 0.
-
-        Returns
-        -------
-        SparseDtype
-        """
-        msg = "Could not construct SparseDtype from '{}'".format(string)
-        if string.startswith("Sparse"):
-            try:
-                sub_type, has_fill_value = cls._parse_subtype(string)
-            except ValueError:
-                raise TypeError(msg)
-            else:
-                result = SparseDtype(sub_type)
-                msg = (
-                    "Could not construct SparseDtype from '{}'.\n\nIt "
-                    "looks like the fill_value in the string is not "
-                    "the default for the dtype. Non-default fill_values "
-                    "are not supported. Use the 'SparseDtype()' "
-                    "constructor instead."
-                )
-                if has_fill_value and str(result) != string:
-                    raise TypeError(msg.format(string))
-                return result
-        else:
-            raise TypeError(msg)
-
-    @staticmethod
-    def _parse_subtype(dtype):
-        """
-        Parse a string to get the subtype
-
-        Parameters
-        ----------
-        dtype : str
-            A string like
-
-            * Sparse[subtype]
-            * Sparse[subtype, fill_value]
-
-        Returns
-        -------
-        subtype : str
-
-        Raises
-        ------
-        ValueError
-            When the subtype cannot be extracted.
-        """
-        xpr = re.compile(r"Sparse\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\]$")
-        m = xpr.match(dtype)
-        has_fill_value = False
-        if m:
-            subtype = m.groupdict()["subtype"]
-            has_fill_value = m.groupdict()["fill_value"] or has_fill_value
-        elif dtype == "Sparse":
-            subtype = "float64"
-        else:
-            raise ValueError("Cannot parse {}".format(dtype))
-        return subtype, has_fill_value
-
-    @classmethod
-    def is_dtype(cls, dtype):
-        dtype = getattr(dtype, "dtype", dtype)
-        if isinstance(dtype, str) and dtype.startswith("Sparse"):
-            sub_type, _ = cls._parse_subtype(dtype)
-            dtype = np.dtype(sub_type)
-        elif isinstance(dtype, cls):
-            return True
-        return isinstance(dtype, np.dtype) or dtype == "Sparse"
-
-    def update_dtype(self, dtype):
-        """
-        Convert the SparseDtype to a new dtype.
-
-        This takes care of converting the ``fill_value``.
-
-        Parameters
-        ----------
-        dtype : Union[str, numpy.dtype, SparseDtype]
-            The new dtype to use.
-
-            * For a SparseDtype, it is simply returned
-            * For a NumPy dtype (or str), the current fill value
-              is converted to the new dtype, and a SparseDtype
-              with `dtype` and the new fill value is returned.
-
-        Returns
-        -------
-        SparseDtype
-            A new SparseDtype with the corret `dtype` and fill value
-            for that `dtype`.
-
-        Raises
-        ------
-        ValueError
-            When the current fill value cannot be converted to the
-            new `dtype` (e.g. trying to convert ``np.nan`` to an
-            integer dtype).
-
-
-        Examples
-        --------
-        >>> SparseDtype(int, 0).update_dtype(float)
-        Sparse[float64, 0.0]
-
-        >>> SparseDtype(int, 1).update_dtype(SparseDtype(float, np.nan))
-        Sparse[float64, nan]
-        """
-        cls = type(self)
-        dtype = pandas_dtype(dtype)
-
-        if not isinstance(dtype, cls):
-            fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
-            dtype = cls(dtype, fill_value=fill_value)
-
-        return dtype
-
-    @property
-    def _subtype_with_str(self):
-        """
-        Whether the SparseDtype's subtype should be considered ``str``.
-
-        Typically, pandas will store string data in an object-dtype array.
-        When converting values to a dtype, e.g. in ``.astype``, we need to
-        be more specific, we need the actual underlying type.
-
-        Returns
-        -------
-
-        >>> SparseDtype(int, 1)._subtype_with_str
-        dtype('int64')
-
-        >>> SparseDtype(object, 1)._subtype_with_str
-        dtype('O')
-
-        >>> dtype = SparseDtype(str, '')
-        >>> dtype.subtype
-        dtype('O')
-
-        >>> dtype._subtype_with_str
-        str
-        """
-        if isinstance(self.fill_value, str):
-            return type(self.fill_value)
-        return self.subtype
-
-
 # ----------------------------------------------------------------------------
 # Array
 
@@ -475,14 +142,14 @@ def _sparse_array_op(
             left, right = right, left
             name = name[1:]
 
-        if name in ("and", "or") and dtype == "bool":
-            opname = "sparse_{name}_uint8".format(name=name)
+        if name in ("and", "or", "xor") and dtype == "bool":
+            opname = f"sparse_{name}_uint8"
             # to make template simple, cast here
             left_sp_values = left.sp_values.view(np.uint8)
             right_sp_values = right.sp_values.view(np.uint8)
             result_dtype = np.bool
         else:
-            opname = "sparse_{name}_{dtype}".format(name=name, dtype=dtype)
+            opname = f"sparse_{name}_{dtype}"
             left_sp_values = left.sp_values
             right_sp_values = right.sp_values
 
@@ -592,6 +259,8 @@ class SparseArray(PandasObject, ExtensionArray, ExtensionOpsMixin):
 
     _pandas_ftype = "sparse"
     _subtyp = "sparse_array"  # register ABCSparseArray
+    _deprecations = PandasObject._deprecations | frozenset(["get_values"])
+    _sparse_index: SparseIndex
 
     def __init__(
         self,
@@ -607,7 +276,7 @@ def __init__(
         if fill_value is None and isinstance(dtype, SparseDtype):
             fill_value = dtype.fill_value
 
-        if isinstance(data, (type(self), ABCSparseSeries)):
+        if isinstance(data, type(self)):
             # disable normal inference on dtype, sparse_index, & fill_value
             if sparse_index is None:
                 sparse_index = data.sp_index
@@ -695,8 +364,8 @@ def __init__(
             sparse_values = np.asarray(data, dtype=dtype)
             if len(sparse_values) != sparse_index.npoints:
                 raise AssertionError(
-                    "Non array-like type {type} must "
-                    "have the same length as the index".format(type=type(sparse_values))
+                    f"Non array-like type {type(sparse_values)} must "
+                    "have the same length as the index"
                 )
         self._sparse_index = sparse_index
         self._sparse_values = sparse_values
@@ -705,7 +374,7 @@ def __init__(
     @classmethod
     def _simple_new(
         cls, sparse_array: np.ndarray, sparse_index: SparseIndex, dtype: SparseDtype
-    ) -> ABCSparseArray:
+    ) -> "SparseArray":
         new = cls([])
         new._sparse_index = sparse_index
         new._sparse_values = sparse_array
@@ -734,7 +403,7 @@ def from_spmatrix(cls, data):
         --------
         >>> import scipy.sparse
         >>> mat = scipy.sparse.coo_matrix((4, 1))
-        >>> pd.SparseArray.from_spmatrix(mat)
+        >>> pd.arrays.SparseArray.from_spmatrix(mat)
         [0.0, 0.0, 0.0, 0.0]
         Fill: 0.0
         IntIndex
@@ -743,7 +412,7 @@ def from_spmatrix(cls, data):
         length, ncol = data.shape
 
         if ncol != 1:
-            raise ValueError("'data' must have a single column, not '{}'".format(ncol))
+            raise ValueError(f"'data' must have a single column, not '{ncol}'")
 
         # our sparse index classes require that the positions be strictly
         # increasing. So we need to sort loc, and arr accordingly.
@@ -759,7 +428,7 @@ def from_spmatrix(cls, data):
 
         return cls._simple_new(arr, index, dtype)
 
-    def __array__(self, dtype=None, copy=True):
+    def __array__(self, dtype=None, copy=True) -> np.ndarray:
         fill_value = self.fill_value
 
         if self.sp_index.ngaps == 0:
@@ -899,23 +568,6 @@ def npoints(self) -> int:
         """
         return self.sp_index.npoints
 
-    @property
-    def values(self):
-        """
-        Dense values
-
-        .. deprecated:: 0.25.0
-
-            Use ``np.asarray(...)`` or the ``.to_dense()`` method instead.
-        """
-        msg = (
-            "The SparseArray.values attribute is deprecated and will be "
-            "removed in a future version. You can use `np.asarray(...)` or "
-            "the `.to_dense()` method instead."
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        return self.to_dense()
-
     def isna(self):
         # If null fill value, we want SparseDtype[bool, true]
         # to preserve the same memory usage.
@@ -1038,11 +690,11 @@ def factorize(self, na_sentinel=-1):
         # Currently, ExtensionArray.factorize -> Tuple[ndarray, EA]
         # The sparsity on this is backwards from what Sparse would want. Want
         # ExtensionArray.factorize -> Tuple[EA, EA]
-        # Given that we have to return a dense array of labels, why bother
+        # Given that we have to return a dense array of codes, why bother
         # implementing an efficient factorize?
-        labels, uniques = algos.factorize(np.asarray(self), na_sentinel=na_sentinel)
+        codes, uniques = algos.factorize(np.asarray(self), na_sentinel=na_sentinel)
         uniques = SparseArray(uniques, dtype=self.dtype)
-        return labels, uniques
+        return codes, uniques
 
     def value_counts(self, dropna=True):
         """
@@ -1086,6 +738,9 @@ def value_counts(self, dropna=True):
     # --------
 
     def __getitem__(self, key):
+        # avoid mypy issues when importing at the top-level
+        from pandas.core.indexing import check_bool_indexer
+
         if isinstance(key, tuple):
             if len(key) > 1:
                 raise IndexError("too many indices for array.")
@@ -1114,12 +769,16 @@ def __getitem__(self, key):
                 else:
                     key = np.asarray(key)
 
-            if com.is_bool_indexer(key) and len(self) == len(key):
+            key = check_array_indexer(self, key)
+
+            if com.is_bool_indexer(key):
+                key = check_bool_indexer(self, key)
+
                 return self.take(np.arange(len(key), dtype=np.int32)[key])
             elif hasattr(key, "__len__"):
                 return self.take(key)
             else:
-                raise ValueError("Cannot slice with '{}'".format(key))
+                raise ValueError(f"Cannot slice with '{key}'")
 
         return type(self)(data_slice, kind=self.kind)
 
@@ -1135,13 +794,13 @@ def _get_val_at(self, loc):
         if sp_loc == -1:
             return self.fill_value
         else:
-            return libindex.get_value_at(self.sp_values, sp_loc)
+            val = self.sp_values[sp_loc]
+            val = com.maybe_box_datetimelike(val, self.sp_values.dtype)
+            return val
 
     def take(self, indices, allow_fill=False, fill_value=None):
         if is_scalar(indices):
-            raise ValueError(
-                "'indices' must be an array, not a scalar '{}'.".format(indices)
-            )
+            raise ValueError(f"'indices' must be an array, not a scalar '{indices}'.")
         indices = np.asarray(indices, dtype=np.int32)
 
         if indices.size == 0:
@@ -1280,8 +939,8 @@ def _concat_same_type(cls, to_concat):
         if not (len(set(fill_values)) == 1 or isna(fill_values).all()):
             warnings.warn(
                 "Concatenating sparse arrays with multiple fill "
-                "values: '{}'. Picking the first and "
-                "converting the rest.".format(fill_values),
+                f"values: '{fill_values}'. Picking the first and "
+                "converting the rest.",
                 PerformanceWarning,
                 stacklevel=6,
             )
@@ -1424,7 +1083,7 @@ def map(self, mapper):
 
         Examples
         --------
-        >>> arr = pd.SparseArray([0, 1, 2])
+        >>> arr = pd.arrays.SparseArray([0, 1, 2])
         >>> arr.apply(lambda x: x + 10)
         [10, 11, 12]
         Fill: 10
@@ -1468,22 +1127,6 @@ def to_dense(self):
         """
         return np.asarray(self, dtype=self.sp_values.dtype)
 
-    def get_values(self):
-        """
-        Convert SparseArray to a NumPy array.
-
-        .. deprecated:: 0.25.0
-            Use `to_dense` instead.
-
-        """
-        warnings.warn(
-            "The 'get_values' method is deprecated and will be removed in a "
-            "future version. Use the 'to_dense' method instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._internal_get_values()
-
     _internal_get_values = to_dense
 
     # ------------------------------------------------------------------------
@@ -1517,11 +1160,7 @@ def _reduce(self, name, skipna=True, **kwargs):
         method = getattr(self, name, None)
 
         if method is None:
-            raise TypeError(
-                "cannot perform {name} with type {dtype}".format(
-                    name=name, dtype=self.dtype
-                )
-            )
+            raise TypeError(f"cannot perform {name} with type {self.dtype}")
 
         if skipna:
             arr = self
@@ -1617,7 +1256,7 @@ def cumsum(self, axis=0, *args, **kwargs):
         nv.validate_cumsum(args, kwargs)
 
         if axis is not None and axis >= self.ndim:  # Mimic ndarray behaviour.
-            raise ValueError("axis(={axis}) out of bounds".format(axis=axis))
+            raise ValueError(f"axis(={axis}) out of bounds")
 
         if not self._null_fill_value:
             return SparseArray(self.to_dense()).cumsum()
@@ -1724,26 +1363,22 @@ def __abs__(self):
     # ------------------------------------------------------------------------
 
     @classmethod
-    def _create_unary_method(cls, op):
-        def sparse_unary_method(self):
+    def _create_unary_method(cls, op) -> Callable[["SparseArray"], "SparseArray"]:
+        def sparse_unary_method(self) -> "SparseArray":
             fill_value = op(np.array(self.fill_value)).item()
             values = op(self.sp_values)
             dtype = SparseDtype(values.dtype, fill_value)
             return cls._simple_new(values, self.sp_index, dtype)
 
-        name = "__{name}__".format(name=op.__name__)
+        name = f"__{op.__name__}__"
         return compat.set_function_name(sparse_unary_method, name, cls)
 
     @classmethod
     def _create_arithmetic_method(cls, op):
         op_name = op.__name__
 
+        @unpack_zerodim_and_defer(op_name)
         def sparse_arithmetic_method(self, other):
-            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-                # Rely on pandas to dispatch to us.
-                return NotImplemented
-
-            other = lib.item_from_zerodim(other)
 
             if isinstance(other, SparseArray):
                 return _sparse_array_op(self, other, op, op_name)
@@ -1769,11 +1404,7 @@ def sparse_arithmetic_method(self, other):
                     # TODO: look into _wrap_result
                     if len(self) != len(other):
                         raise AssertionError(
-                            (
-                                "length mismatch: {self} vs. {other}".format(
-                                    self=len(self), other=len(other)
-                                )
-                            )
+                            (f"length mismatch: {len(self)} vs. {len(other)}")
                         )
                     if not isinstance(other, SparseArray):
                         dtype = getattr(other, "dtype", None)
@@ -1782,7 +1413,7 @@ def sparse_arithmetic_method(self, other):
                         )
                     return _sparse_array_op(self, other, op, op_name)
 
-        name = "__{name}__".format(name=op.__name__)
+        name = f"__{op.__name__}__"
         return compat.set_function_name(sparse_arithmetic_method, name, cls)
 
     @classmethod
@@ -1791,12 +1422,9 @@ def _create_comparison_method(cls, op):
         if op_name in {"and_", "or_"}:
             op_name = op_name[:-1]
 
+        @unpack_zerodim_and_defer(op_name)
         def cmp_method(self, other):
 
-            if isinstance(other, (ABCSeries, ABCIndexClass)):
-                # Rely on pandas to unbox and dispatch to us.
-                return NotImplemented
-
             if not is_scalar(other) and not isinstance(other, type(self)):
                 # convert list-like to ndarray
                 other = np.asarray(other)
@@ -1805,9 +1433,7 @@ def cmp_method(self, other):
                 # TODO: make this more flexible than just ndarray...
                 if len(self) != len(other):
                     raise AssertionError(
-                        "length mismatch: {self} vs. {other}".format(
-                            self=len(self), other=len(other)
-                        )
+                        f"length mismatch: {len(self)} vs. {len(other)}"
                     )
                 other = SparseArray(other, fill_value=self.fill_value)
 
@@ -1825,7 +1451,7 @@ def cmp_method(self, other):
                     dtype=np.bool_,
                 )
 
-        name = "__{name}__".format(name=op.__name__)
+        name = f"__{op.__name__}__"
         return compat.set_function_name(cmp_method, name, cls)
 
     @classmethod
@@ -1838,17 +1464,17 @@ def _add_unary_ops(cls):
     def _add_comparison_ops(cls):
         cls.__and__ = cls._create_comparison_method(operator.and_)
         cls.__or__ = cls._create_comparison_method(operator.or_)
+        cls.__xor__ = cls._create_arithmetic_method(operator.xor)
         super()._add_comparison_ops()
 
     # ----------
     # Formatting
     # -----------
-    def __repr__(self):
-        return "{self}\nFill: {fill}\n{index}".format(
-            self=printing.pprint_thing(self),
-            fill=printing.pprint_thing(self.fill_value),
-            index=printing.pprint_thing(self.sp_index),
-        )
+    def __repr__(self) -> str:
+        pp_str = printing.pprint_thing(self)
+        pp_fill = printing.pprint_thing(self.fill_value)
+        pp_index = printing.pprint_thing(self.sp_index)
+        return f"{pp_str}\nFill: {pp_fill}\n{pp_index}"
 
     def _formatter(self, boxed=False):
         # Defer to the formatter from the GenericArrayFormatter calling us.
@@ -1926,330 +1552,3 @@ def _make_index(length, indices, kind):
     else:  # pragma: no cover
         raise ValueError("must be block or integer type")
     return index
-
-
-# ----------------------------------------------------------------------------
-# Accessor
-
-
-class BaseAccessor:
-    _validation_msg = "Can only use the '.sparse' accessor with Sparse data."
-
-    def __init__(self, data=None):
-        self._parent = data
-        self._validate(data)
-
-    def _validate(self, data):
-        raise NotImplementedError
-
-
-@delegate_names(
-    SparseArray, ["npoints", "density", "fill_value", "sp_values"], typ="property"
-)
-class SparseAccessor(BaseAccessor, PandasDelegate):
-    """
-    Accessor for SparseSparse from other sparse matrix data types.
-    """
-
-    def _validate(self, data):
-        if not isinstance(data.dtype, SparseDtype):
-            raise AttributeError(self._validation_msg)
-
-    def _delegate_property_get(self, name, *args, **kwargs):
-        return getattr(self._parent.array, name)
-
-    def _delegate_method(self, name, *args, **kwargs):
-        if name == "from_coo":
-            return self.from_coo(*args, **kwargs)
-        elif name == "to_coo":
-            return self.to_coo(*args, **kwargs)
-        else:
-            raise ValueError
-
-    @classmethod
-    def from_coo(cls, A, dense_index=False):
-        """
-        Create a SparseSeries from a scipy.sparse.coo_matrix.
-
-        Parameters
-        ----------
-        A : scipy.sparse.coo_matrix
-        dense_index : bool, default False
-            If False (default), the SparseSeries index consists of only the
-            coords of the non-null entries of the original coo_matrix.
-            If True, the SparseSeries index consists of the full sorted
-            (row, col) coordinates of the coo_matrix.
-
-        Returns
-        -------
-        s : SparseSeries
-
-        Examples
-        --------
-        >>> from scipy import sparse
-        >>> A = sparse.coo_matrix(([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])),
-                               shape=(3, 4))
-        >>> A
-        <3x4 sparse matrix of type '<class 'numpy.float64'>'
-                with 3 stored elements in COOrdinate format>
-        >>> A.todense()
-        matrix([[ 0.,  0.,  1.,  2.],
-                [ 3.,  0.,  0.,  0.],
-                [ 0.,  0.,  0.,  0.]])
-        >>> ss = pd.SparseSeries.from_coo(A)
-        >>> ss
-        0  2    1
-           3    2
-        1  0    3
-        dtype: float64
-        BlockIndex
-        Block locations: array([0], dtype=int32)
-        Block lengths: array([3], dtype=int32)
-        """
-        from pandas.core.sparse.scipy_sparse import _coo_to_sparse_series
-        from pandas import Series
-
-        result = _coo_to_sparse_series(A, dense_index=dense_index, sparse_series=False)
-        result = Series(result.array, index=result.index, copy=False)
-
-        return result
-
-    def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels=False):
-        """
-        Create a scipy.sparse.coo_matrix from a SparseSeries with MultiIndex.
-
-        Use row_levels and column_levels to determine the row and column
-        coordinates respectively. row_levels and column_levels are the names
-        (labels) or numbers of the levels. {row_levels, column_levels} must be
-        a partition of the MultiIndex level names (or numbers).
-
-        Parameters
-        ----------
-        row_levels : tuple/list
-        column_levels : tuple/list
-        sort_labels : bool, default False
-            Sort the row and column labels before forming the sparse matrix.
-
-        Returns
-        -------
-        y : scipy.sparse.coo_matrix
-        rows : list (row labels)
-        columns : list (column labels)
-
-        Examples
-        --------
-        >>> s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])
-        >>> s.index = pd.MultiIndex.from_tuples([(1, 2, 'a', 0),
-                                                (1, 2, 'a', 1),
-                                                (1, 1, 'b', 0),
-                                                (1, 1, 'b', 1),
-                                                (2, 1, 'b', 0),
-                                                (2, 1, 'b', 1)],
-                                                names=['A', 'B', 'C', 'D'])
-        >>> ss = s.to_sparse()
-        >>> A, rows, columns = ss.to_coo(row_levels=['A', 'B'],
-                                         column_levels=['C', 'D'],
-                                         sort_labels=True)
-        >>> A
-        <3x4 sparse matrix of type '<class 'numpy.float64'>'
-                with 3 stored elements in COOrdinate format>
-        >>> A.todense()
-        matrix([[ 0.,  0.,  1.,  3.],
-        [ 3.,  0.,  0.,  0.],
-        [ 0.,  0.,  0.,  0.]])
-        >>> rows
-        [(1, 1), (1, 2), (2, 1)]
-        >>> columns
-        [('a', 0), ('a', 1), ('b', 0), ('b', 1)]
-        """
-        from pandas.core.sparse.scipy_sparse import _sparse_series_to_coo
-
-        A, rows, columns = _sparse_series_to_coo(
-            self._parent, row_levels, column_levels, sort_labels=sort_labels
-        )
-        return A, rows, columns
-
-    def to_dense(self):
-        """
-        Convert a Series from sparse values to dense.
-
-        .. versionadded:: 0.25.0
-
-        Returns
-        -------
-        Series:
-            A Series with the same values, stored as a dense array.
-
-        Examples
-        --------
-        >>> series = pd.Series(pd.SparseArray([0, 1, 0]))
-        >>> series
-        0    0
-        1    1
-        2    0
-        dtype: Sparse[int64, 0]
-
-        >>> series.sparse.to_dense()
-        0    0
-        1    1
-        2    0
-        dtype: int64
-        """
-        from pandas import Series
-
-        return Series(
-            self._parent.array.to_dense(),
-            index=self._parent.index,
-            name=self._parent.name,
-        )
-
-
-class SparseFrameAccessor(BaseAccessor, PandasDelegate):
-    """
-    DataFrame accessor for sparse data.
-
-    .. versionadded:: 0.25.0
-    """
-
-    def _validate(self, data):
-        dtypes = data.dtypes
-        if not all(isinstance(t, SparseDtype) for t in dtypes):
-            raise AttributeError(self._validation_msg)
-
-    @classmethod
-    def from_spmatrix(cls, data, index=None, columns=None):
-        """
-        Create a new DataFrame from a scipy sparse matrix.
-
-        .. versionadded:: 0.25.0
-
-        Parameters
-        ----------
-        data : scipy.sparse.spmatrix
-            Must be convertible to csc format.
-        index, columns : Index, optional
-            Row and column labels to use for the resulting DataFrame.
-            Defaults to a RangeIndex.
-
-        Returns
-        -------
-        DataFrame
-            Each column of the DataFrame is stored as a
-            :class:`SparseArray`.
-
-        Examples
-        --------
-        >>> import scipy.sparse
-        >>> mat = scipy.sparse.eye(3)
-        >>> pd.DataFrame.sparse.from_spmatrix(mat)
-             0    1    2
-        0  1.0  0.0  0.0
-        1  0.0  1.0  0.0
-        2  0.0  0.0  1.0
-        """
-        from pandas import DataFrame
-
-        data = data.tocsc()
-        index, columns = cls._prep_index(data, index, columns)
-        sparrays = [SparseArray.from_spmatrix(data[:, i]) for i in range(data.shape[1])]
-        data = dict(enumerate(sparrays))
-        result = DataFrame(data, index=index)
-        result.columns = columns
-        return result
-
-    def to_dense(self):
-        """
-        Convert a DataFrame with sparse values to dense.
-
-        .. versionadded:: 0.25.0
-
-        Returns
-        -------
-        DataFrame
-            A DataFrame with the same values stored as dense arrays.
-
-        Examples
-        --------
-        >>> df = pd.DataFrame({"A": pd.SparseArray([0, 1, 0])})
-        >>> df.sparse.to_dense()
-           A
-        0  0
-        1  1
-        2  0
-        """
-        from pandas import DataFrame
-
-        data = {k: v.array.to_dense() for k, v in self._parent.items()}
-        return DataFrame(data, index=self._parent.index, columns=self._parent.columns)
-
-    def to_coo(self):
-        """
-        Return the contents of the frame as a sparse SciPy COO matrix.
-
-        .. versionadded:: 0.25.0
-
-        Returns
-        -------
-        coo_matrix : scipy.sparse.spmatrix
-            If the caller is heterogeneous and contains booleans or objects,
-            the result will be of dtype=object. See Notes.
-
-        Notes
-        -----
-        The dtype will be the lowest-common-denominator type (implicit
-        upcasting); that is to say if the dtypes (even of numeric types)
-        are mixed, the one that accommodates all will be chosen.
-
-        e.g. If the dtypes are float16 and float32, dtype will be upcast to
-        float32. By numpy.find_common_type convention, mixing int64 and
-        and uint64 will result in a float64 dtype.
-        """
-        import_optional_dependency("scipy")
-        from scipy.sparse import coo_matrix
-
-        dtype = find_common_type(self._parent.dtypes)
-        if isinstance(dtype, SparseDtype):
-            dtype = dtype.subtype
-
-        cols, rows, datas = [], [], []
-        for col, name in enumerate(self._parent):
-            s = self._parent[name]
-            row = s.array.sp_index.to_int_index().indices
-            cols.append(np.repeat(col, len(row)))
-            rows.append(row)
-            datas.append(s.array.sp_values.astype(dtype, copy=False))
-
-        cols = np.concatenate(cols)
-        rows = np.concatenate(rows)
-        datas = np.concatenate(datas)
-        return coo_matrix((datas, (rows, cols)), shape=self._parent.shape)
-
-    @property
-    def density(self) -> float:
-        """
-        Ratio of non-sparse points to total (dense) data points
-        represented in the DataFrame.
-        """
-        return np.mean([column.array.density for _, column in self._parent.items()])
-
-    @staticmethod
-    def _prep_index(data, index, columns):
-        import pandas.core.indexes.base as ibase
-
-        N, K = data.shape
-        if index is None:
-            index = ibase.default_index(N)
-        if columns is None:
-            columns = ibase.default_index(K)
-
-        if len(columns) != K:
-            raise ValueError(
-                "Column length mismatch: {columns} vs. {K}".format(
-                    columns=len(columns), K=K
-                )
-            )
-        if len(index) != N:
-            raise ValueError(
-                "Index length mismatch: {index} vs. {N}".format(index=len(index), N=N)
-            )
-        return index, columns
diff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py
new file mode 100644
index 0000000000000..1ce735421e7d6
--- /dev/null
+++ b/pandas/core/arrays/sparse/dtype.py
@@ -0,0 +1,355 @@
+"""Sparse Dtype"""
+
+import re
+from typing import TYPE_CHECKING, Any, Tuple, Type
+
+import numpy as np
+
+from pandas._typing import Dtype
+
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.cast import astype_nansafe
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_object_dtype,
+    is_scalar,
+    is_string_dtype,
+    pandas_dtype,
+)
+from pandas.core.dtypes.dtypes import register_extension_dtype
+from pandas.core.dtypes.missing import isna, na_value_for_dtype
+
+if TYPE_CHECKING:
+    from pandas.core.arrays.sparse.array import SparseArray  # noqa: F401
+
+
+@register_extension_dtype
+class SparseDtype(ExtensionDtype):
+    """
+    Dtype for data stored in :class:`SparseArray`.
+
+    This dtype implements the pandas ExtensionDtype interface.
+
+    .. versionadded:: 0.24.0
+
+    Parameters
+    ----------
+    dtype : str, ExtensionDtype, numpy.dtype, type, default numpy.float64
+        The dtype of the underlying array storing the non-fill value values.
+    fill_value : scalar, optional
+        The scalar value not stored in the SparseArray. By default, this
+        depends on `dtype`.
+
+        =========== ==========
+        dtype       na_value
+        =========== ==========
+        float       ``np.nan``
+        int         ``0``
+        bool        ``False``
+        datetime64  ``pd.NaT``
+        timedelta64 ``pd.NaT``
+        =========== ==========
+
+        The default value may be overridden by specifying a `fill_value`.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+    """
+
+    # We include `_is_na_fill_value` in the metadata to avoid hash collisions
+    # between SparseDtype(float, 0.0) and SparseDtype(float, nan).
+    # Without is_na_fill_value in the comparison, those would be equal since
+    # hash(nan) is (sometimes?) 0.
+    _metadata = ("_dtype", "_fill_value", "_is_na_fill_value")
+
+    def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None):
+
+        if isinstance(dtype, type(self)):
+            if fill_value is None:
+                fill_value = dtype.fill_value
+            dtype = dtype.subtype
+
+        dtype = pandas_dtype(dtype)
+        if is_string_dtype(dtype):
+            dtype = np.dtype("object")
+
+        if fill_value is None:
+            fill_value = na_value_for_dtype(dtype)
+
+        if not is_scalar(fill_value):
+            raise ValueError(f"fill_value must be a scalar. Got {fill_value} instead")
+        self._dtype = dtype
+        self._fill_value = fill_value
+
+    def __hash__(self):
+        # Python3 doesn't inherit __hash__ when a base class overrides
+        # __eq__, so we explicitly do it here.
+        return super().__hash__()
+
+    def __eq__(self, other: Any) -> bool:
+        # We have to override __eq__ to handle NA values in _metadata.
+        # The base class does simple == checks, which fail for NA.
+        if isinstance(other, str):
+            try:
+                other = self.construct_from_string(other)
+            except TypeError:
+                return False
+
+        if isinstance(other, type(self)):
+            subtype = self.subtype == other.subtype
+            if self._is_na_fill_value:
+                # this case is complicated by two things:
+                # SparseDtype(float, float(nan)) == SparseDtype(float, np.nan)
+                # SparseDtype(float, np.nan)     != SparseDtype(float, pd.NaT)
+                # i.e. we want to treat any floating-point NaN as equal, but
+                # not a floating-point NaN and a datetime NaT.
+                fill_value = (
+                    other._is_na_fill_value
+                    and isinstance(self.fill_value, type(other.fill_value))
+                    or isinstance(other.fill_value, type(self.fill_value))
+                )
+            else:
+                fill_value = self.fill_value == other.fill_value
+
+            return subtype and fill_value
+        return False
+
+    @property
+    def fill_value(self):
+        """
+        The fill value of the array.
+
+        Converting the SparseArray to a dense ndarray will fill the
+        array with this value.
+
+        .. warning::
+
+           It's possible to end up with a SparseArray that has ``fill_value``
+           values in ``sp_values``. This can occur, for example, when setting
+           ``SparseArray.fill_value`` directly.
+        """
+        return self._fill_value
+
+    @property
+    def _is_na_fill_value(self):
+        return isna(self.fill_value)
+
+    @property
+    def _is_numeric(self) -> bool:
+        return not is_object_dtype(self.subtype)
+
+    @property
+    def _is_boolean(self) -> bool:
+        return is_bool_dtype(self.subtype)
+
+    @property
+    def kind(self):
+        """
+        The sparse kind. Either 'integer', or 'block'.
+        """
+        return self.subtype.kind
+
+    @property
+    def type(self):
+        return self.subtype.type
+
+    @property
+    def subtype(self):
+        return self._dtype
+
+    @property
+    def name(self):
+        return f"Sparse[{self.subtype.name}, {self.fill_value}]"
+
+    def __repr__(self) -> str:
+        return self.name
+
+    @classmethod
+    def construct_array_type(cls) -> Type["SparseArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        from pandas.core.arrays.sparse.array import SparseArray  # noqa: F811
+
+        return SparseArray
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> "SparseDtype":
+        """
+        Construct a SparseDtype from a string form.
+
+        Parameters
+        ----------
+        string : str
+            Can take the following forms.
+
+            string           dtype
+            ================ ============================
+            'int'            SparseDtype[np.int64, 0]
+            'Sparse'         SparseDtype[np.float64, nan]
+            'Sparse[int]'    SparseDtype[np.int64, 0]
+            'Sparse[int, 0]' SparseDtype[np.int64, 0]
+            ================ ============================
+
+            It is not possible to specify non-default fill values
+            with a string. An argument like ``'Sparse[int, 1]'``
+            will raise a ``TypeError`` because the default fill value
+            for integers is 0.
+
+        Returns
+        -------
+        SparseDtype
+        """
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
+        msg = f"Cannot construct a 'SparseDtype' from '{string}'"
+        if string.startswith("Sparse"):
+            try:
+                sub_type, has_fill_value = cls._parse_subtype(string)
+            except ValueError:
+                raise TypeError(msg)
+            else:
+                result = SparseDtype(sub_type)
+                msg = (
+                    f"Cannot construct a 'SparseDtype' from '{string}'.\n\nIt "
+                    "looks like the fill_value in the string is not "
+                    "the default for the dtype. Non-default fill_values "
+                    "are not supported. Use the 'SparseDtype()' "
+                    "constructor instead."
+                )
+                if has_fill_value and str(result) != string:
+                    raise TypeError(msg)
+                return result
+        else:
+            raise TypeError(msg)
+
+    @staticmethod
+    def _parse_subtype(dtype: str) -> Tuple[str, bool]:
+        """
+        Parse a string to get the subtype
+
+        Parameters
+        ----------
+        dtype : str
+            A string like
+
+            * Sparse[subtype]
+            * Sparse[subtype, fill_value]
+
+        Returns
+        -------
+        subtype : str
+
+        Raises
+        ------
+        ValueError
+            When the subtype cannot be extracted.
+        """
+        xpr = re.compile(r"Sparse\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\]$")
+        m = xpr.match(dtype)
+        has_fill_value = False
+        if m:
+            subtype = m.groupdict()["subtype"]
+            has_fill_value = bool(m.groupdict()["fill_value"])
+        elif dtype == "Sparse":
+            subtype = "float64"
+        else:
+            raise ValueError(f"Cannot parse {dtype}")
+        return subtype, has_fill_value
+
+    @classmethod
+    def is_dtype(cls, dtype: object) -> bool:
+        dtype = getattr(dtype, "dtype", dtype)
+        if isinstance(dtype, str) and dtype.startswith("Sparse"):
+            sub_type, _ = cls._parse_subtype(dtype)
+            dtype = np.dtype(sub_type)
+        elif isinstance(dtype, cls):
+            return True
+        return isinstance(dtype, np.dtype) or dtype == "Sparse"
+
+    def update_dtype(self, dtype):
+        """
+        Convert the SparseDtype to a new dtype.
+
+        This takes care of converting the ``fill_value``.
+
+        Parameters
+        ----------
+        dtype : Union[str, numpy.dtype, SparseDtype]
+            The new dtype to use.
+
+            * For a SparseDtype, it is simply returned
+            * For a NumPy dtype (or str), the current fill value
+              is converted to the new dtype, and a SparseDtype
+              with `dtype` and the new fill value is returned.
+
+        Returns
+        -------
+        SparseDtype
+            A new SparseDtype with the correct `dtype` and fill value
+            for that `dtype`.
+
+        Raises
+        ------
+        ValueError
+            When the current fill value cannot be converted to the
+            new `dtype` (e.g. trying to convert ``np.nan`` to an
+            integer dtype).
+
+
+        Examples
+        --------
+        >>> SparseDtype(int, 0).update_dtype(float)
+        Sparse[float64, 0.0]
+
+        >>> SparseDtype(int, 1).update_dtype(SparseDtype(float, np.nan))
+        Sparse[float64, nan]
+        """
+        cls = type(self)
+        dtype = pandas_dtype(dtype)
+
+        if not isinstance(dtype, cls):
+            fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
+            dtype = cls(dtype, fill_value=fill_value)
+
+        return dtype
+
+    @property
+    def _subtype_with_str(self):
+        """
+        Whether the SparseDtype's subtype should be considered ``str``.
+
+        Typically, pandas will store string data in an object-dtype array.
+        When converting values to a dtype, e.g. in ``.astype``, we need to
+        be more specific, we need the actual underlying type.
+
+        Returns
+        -------
+
+        >>> SparseDtype(int, 1)._subtype_with_str
+        dtype('int64')
+
+        >>> SparseDtype(object, 1)._subtype_with_str
+        dtype('O')
+
+        >>> dtype = SparseDtype(str, '')
+        >>> dtype.subtype
+        dtype('O')
+
+        >>> dtype._subtype_with_str
+        str
+        """
+        if isinstance(self.fill_value, str):
+            return type(self.fill_value)
+        return self.subtype
diff --git a/pandas/core/sparse/scipy_sparse.py b/pandas/core/arrays/sparse/scipy_sparse.py
similarity index 79%
rename from pandas/core/sparse/scipy_sparse.py
rename to pandas/core/arrays/sparse/scipy_sparse.py
index e8d8996fdd6ad..b67f2c9f52c76 100644
--- a/pandas/core/sparse/scipy_sparse.py
+++ b/pandas/core/arrays/sparse/scipy_sparse.py
@@ -1,11 +1,9 @@
 """
 Interaction with scipy.sparse matrices.
 
-Currently only includes SparseSeries.to_coo helpers.
+Currently only includes to_coo helpers.
 """
-from collections import OrderedDict
-
-from pandas.core.index import Index, MultiIndex
+from pandas.core.indexes.api import Index, MultiIndex
 from pandas.core.series import Series
 
 
@@ -19,14 +17,15 @@ def _check_is_partition(parts, whole):
 
 
 def _to_ijv(ss, row_levels=(0,), column_levels=(1,), sort_labels=False):
-    """ For arbitrary (MultiIndexed) SparseSeries return
+    """ For arbitrary (MultiIndexed) sparse Series return
     (v, i, j, ilabels, jlabels) where (v, (i, j)) is suitable for
-    passing to scipy.sparse.coo constructor. """
+    passing to scipy.sparse.coo constructor.
+    """
     # index and column levels must be a partition of the index
     _check_is_partition([row_levels, column_levels], range(ss.index.nlevels))
 
-    # from the SparseSeries: get the labels and data for non-null entries
-    values = ss._data.internal_values()._valid_sp_values
+    # from the sparse Series: get the labels and data for non-null entries
+    values = ss.array._valid_sp_values
 
     nonnull_labels = ss.dropna()
 
@@ -46,14 +45,13 @@ def get_indexers(levels):
         # labels_to_i[:] = np.arange(labels_to_i.shape[0])
 
         def _get_label_to_i_dict(labels, sort_labels=False):
-            """ Return OrderedDict of unique labels to number.
+            """ Return dict of unique labels to number.
             Optionally sort by label.
             """
             labels = Index(map(tuple, labels)).unique().tolist()  # squish
             if sort_labels:
-                labels = sorted(list(labels))
-            d = OrderedDict((k, i) for i, k in enumerate(labels))
-            return d
+                labels = sorted(labels)
+            return {k: i for i, k in enumerate(labels)}
 
         def _get_index_subset_to_coord_dict(index, subset, sort_labels=False):
             ilabels = list(zip(*[index._get_level_values(i) for i in subset]))
@@ -88,7 +86,7 @@ def _get_index_subset_to_coord_dict(index, subset, sort_labels=False):
 
 def _sparse_series_to_coo(ss, row_levels=(0,), column_levels=(1,), sort_labels=False):
     """
-    Convert a SparseSeries to a scipy.sparse.coo_matrix using index
+    Convert a sparse Series to a scipy.sparse.coo_matrix using index
     levels row_levels, column_levels as the row and column
     labels respectively. Returns the sparse_matrix, row and column labels.
     """
@@ -115,7 +113,7 @@ def _sparse_series_to_coo(ss, row_levels=(0,), column_levels=(1,), sort_labels=F
     return sparse_matrix, rows, columns
 
 
-def _coo_to_sparse_series(A, dense_index: bool = False, sparse_series: bool = True):
+def _coo_to_sparse_series(A, dense_index: bool = False):
     """
     Convert a scipy.sparse.coo_matrix to a SparseSeries.
 
@@ -123,31 +121,23 @@ def _coo_to_sparse_series(A, dense_index: bool = False, sparse_series: bool = Tr
     ----------
     A : scipy.sparse.coo.coo_matrix
     dense_index : bool, default False
-    sparse_series : bool, default True
 
     Returns
     -------
-    Series or SparseSeries
+    Series
 
     Raises
     ------
     TypeError if A is not a coo_matrix
-
     """
     from pandas import SparseDtype
 
     try:
         s = Series(A.data, MultiIndex.from_arrays((A.row, A.col)))
     except AttributeError:
-        raise TypeError("Expected coo_matrix. Got {} instead.".format(type(A).__name__))
+        raise TypeError(f"Expected coo_matrix. Got {type(A).__name__} instead.")
     s = s.sort_index()
-    if sparse_series:
-        # TODO(SparseSeries): remove this and the sparse_series keyword.
-        # This is just here to avoid a DeprecationWarning when
-        # _coo_to_sparse_series is called via Series.sparse.from_coo
-        s = s.to_sparse()  # TODO: specify kind?
-    else:
-        s = s.astype(SparseDtype(s.dtype))
+    s = s.astype(SparseDtype(s.dtype))
     if dense_index:
         # is there a better constructor method to use here?
         i = range(A.shape[0])
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
new file mode 100644
index 0000000000000..fcccd8cc14d6b
--- /dev/null
+++ b/pandas/core/arrays/string_.py
@@ -0,0 +1,337 @@
+import operator
+from typing import TYPE_CHECKING, Type, Union
+
+import numpy as np
+
+from pandas._libs import lib, missing as libmissing
+
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import register_extension_dtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
+from pandas.core.dtypes.inference import is_array_like
+
+from pandas import compat
+from pandas.core import ops
+from pandas.core.arrays import PandasArray
+from pandas.core.construction import extract_array
+from pandas.core.indexers import check_array_indexer
+from pandas.core.missing import isna
+
+if TYPE_CHECKING:
+    import pyarrow  # noqa: F401
+
+
+@register_extension_dtype
+class StringDtype(ExtensionDtype):
+    """
+    Extension dtype for string data.
+
+    .. versionadded:: 1.0.0
+
+    .. warning::
+
+       StringDtype is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+       In particular, StringDtype.na_value may change to no longer be
+       ``numpy.nan``.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    Examples
+    --------
+    >>> pd.StringDtype()
+    StringDtype
+    """
+
+    name = "string"
+
+    #: StringDtype.na_value uses pandas.NA
+    na_value = libmissing.NA
+
+    @property
+    def type(self) -> Type[str]:
+        return str
+
+    @classmethod
+    def construct_array_type(cls) -> Type["StringArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return StringArray
+
+    def __repr__(self) -> str:
+        return "StringDtype"
+
+    def __from_arrow__(
+        self, array: Union["pyarrow.Array", "pyarrow.ChunkedArray"]
+    ) -> "StringArray":
+        """
+        Construct StringArray from pyarrow Array/ChunkedArray.
+        """
+        import pyarrow  # noqa: F811
+
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            # pyarrow.ChunkedArray
+            chunks = array.chunks
+
+        results = []
+        for arr in chunks:
+            # using _from_sequence to ensure None is converted to NA
+            str_arr = StringArray._from_sequence(np.array(arr))
+            results.append(str_arr)
+
+        return StringArray._concat_same_type(results)
+
+
+class StringArray(PandasArray):
+    """
+    Extension array for string data.
+
+    .. versionadded:: 1.0.0
+
+    .. warning::
+
+       StringArray is considered experimental. The implementation and
+       parts of the API may change without warning.
+
+    Parameters
+    ----------
+    values : array-like
+        The array of data.
+
+        .. warning::
+
+           Currently, this expects an object-dtype ndarray
+           where the elements are Python strings or :attr:`pandas.NA`.
+           This may change without warning in the future. Use
+           :meth:`pandas.array` with ``dtype="string"`` for a stable way of
+           creating a `StringArray` from any sequence.
+
+    copy : bool, default False
+        Whether to copy the array of data.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    See Also
+    --------
+    array
+        The recommended function for creating a StringArray.
+    Series.str
+        The string methods are available on Series backed by
+        a StringArray.
+
+    Notes
+    -----
+    StringArray returns a BooleanArray for comparison methods.
+
+    Examples
+    --------
+    >>> pd.array(['This is', 'some text', None, 'data.'], dtype="string")
+    <StringArray>
+    ['This is', 'some text', <NA>, 'data.']
+    Length: 4, dtype: string
+
+    Unlike ``object`` dtype arrays, ``StringArray`` doesn't allow non-string
+    values.
+
+    >>> pd.array(['1', 1], dtype="string")
+    Traceback (most recent call last):
+    ...
+    ValueError: StringArray requires an object-dtype ndarray of strings.
+
+    For comparison methods, this returns a :class:`pandas.BooleanArray`
+
+    >>> pd.array(["a", None, "c"], dtype="string") == "a"
+    <BooleanArray>
+    [True, <NA>, False]
+    Length: 3, dtype: boolean
+    """
+
+    # undo the PandasArray hack
+    _typ = "extension"
+
+    def __init__(self, values, copy=False):
+        values = extract_array(values)
+        skip_validation = isinstance(values, type(self))
+
+        super().__init__(values, copy=copy)
+        self._dtype = StringDtype()
+        if not skip_validation:
+            self._validate()
+
+    def _validate(self):
+        """Validate that we only store NA or strings."""
+        if len(self._ndarray) and not lib.is_string_array(self._ndarray, skipna=True):
+            raise ValueError("StringArray requires a sequence of strings or pandas.NA")
+        if self._ndarray.dtype != "object":
+            raise ValueError(
+                "StringArray requires a sequence of strings or pandas.NA. Got "
+                f"'{self._ndarray.dtype}' dtype instead."
+            )
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        if dtype:
+            assert dtype == "string"
+
+        result = np.asarray(scalars, dtype="object")
+        if copy and result is scalars:
+            result = result.copy()
+
+        # Standardize all missing-like values to NA
+        # TODO: it would be nice to do this in _validate / lib.is_string_array
+        # We are already doing a scan over the values there.
+        na_values = isna(result)
+        if na_values.any():
+            if result is scalars:
+                # force a copy now, if we haven't already
+                result = result.copy()
+            result[na_values] = StringDtype.na_value
+
+        return cls(result)
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, dtype=None, copy=False):
+        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+
+    def __arrow_array__(self, type=None):
+        """
+        Convert myself into a pyarrow Array.
+        """
+        import pyarrow as pa
+
+        if type is None:
+            type = pa.string()
+
+        values = self._ndarray.copy()
+        values[self.isna()] = None
+        return pa.array(values, type=type, from_pandas=True)
+
+    def _values_for_factorize(self):
+        arr = self._ndarray.copy()
+        mask = self.isna()
+        arr[mask] = -1
+        return arr, -1
+
+    def __setitem__(self, key, value):
+        value = extract_array(value, extract_numpy=True)
+        if isinstance(value, type(self)):
+            # extract_array doesn't extract PandasArray subclasses
+            value = value._ndarray
+
+        key = check_array_indexer(self, key)
+        scalar_key = lib.is_scalar(key)
+        scalar_value = lib.is_scalar(value)
+        if scalar_key and not scalar_value:
+            raise ValueError("setting an array element with a sequence.")
+
+        # validate new items
+        if scalar_value:
+            if isna(value):
+                value = StringDtype.na_value
+            elif not isinstance(value, str):
+                raise ValueError(
+                    f"Cannot set non-string value '{value}' into a StringArray."
+                )
+        else:
+            if not is_array_like(value):
+                value = np.asarray(value, dtype=object)
+            if len(value) and not lib.is_string_array(value, skipna=True):
+                raise ValueError("Must provide strings.")
+
+        super().__setitem__(key, value)
+
+    def fillna(self, value=None, method=None, limit=None):
+        # TODO: validate dtype
+        return super().fillna(value, method, limit)
+
+    def astype(self, dtype, copy=True):
+        dtype = pandas_dtype(dtype)
+        if isinstance(dtype, StringDtype):
+            if copy:
+                return self.copy()
+            return self
+        return super().astype(dtype, copy)
+
+    def _reduce(self, name, skipna=True, **kwargs):
+        raise TypeError(f"Cannot perform reduction '{name}' with string dtype")
+
+    def value_counts(self, dropna=False):
+        from pandas import value_counts
+
+        return value_counts(self._ndarray, dropna=dropna).astype("Int64")
+
+    # Overrride parent because we have different return types.
+    @classmethod
+    def _create_arithmetic_method(cls, op):
+        # Note: this handles both arithmetic and comparison methods.
+        def method(self, other):
+            from pandas.arrays import BooleanArray
+
+            assert op.__name__ in ops.ARITHMETIC_BINOPS | ops.COMPARISON_BINOPS
+
+            if isinstance(other, (ABCIndexClass, ABCSeries, ABCDataFrame)):
+                return NotImplemented
+
+            elif isinstance(other, cls):
+                other = other._ndarray
+
+            mask = isna(self) | isna(other)
+            valid = ~mask
+
+            if not lib.is_scalar(other):
+                if len(other) != len(self):
+                    # prevent improper broadcasting when other is 2D
+                    raise ValueError(
+                        f"Lengths of operands do not match: {len(self)} != {len(other)}"
+                    )
+
+                other = np.asarray(other)
+                other = other[valid]
+
+            if op.__name__ in ops.ARITHMETIC_BINOPS:
+                result = np.empty_like(self._ndarray, dtype="object")
+                result[mask] = StringDtype.na_value
+                result[valid] = op(self._ndarray[valid], other)
+                return StringArray(result)
+            else:
+                # logical
+                result = np.zeros(len(self._ndarray), dtype="bool")
+                result[valid] = op(self._ndarray[valid], other)
+                return BooleanArray(result, mask)
+
+        return compat.set_function_name(method, f"__{op.__name__}__", cls)
+
+    @classmethod
+    def _add_arithmetic_ops(cls):
+        cls.__add__ = cls._create_arithmetic_method(operator.add)
+        cls.__radd__ = cls._create_arithmetic_method(ops.radd)
+
+        cls.__mul__ = cls._create_arithmetic_method(operator.mul)
+        cls.__rmul__ = cls._create_arithmetic_method(ops.rmul)
+
+    _create_comparison_method = _create_arithmetic_method
+
+
+StringArray._add_arithmetic_ops()
+StringArray._add_comparison_ops()
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 3609c68a26c0f..a7b16fd86468e 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -1,7 +1,5 @@
 from datetime import timedelta
-import textwrap
 from typing import List
-import warnings
 
 import numpy as np
 
@@ -13,18 +11,14 @@
     parse_timedelta_unit,
     precision_from_unit,
 )
-import pandas.compat as compat
-from pandas.util._decorators import Appender
+from pandas.compat.numpy import function as nv
 
 from pandas.core.dtypes.common import (
     _NS_DTYPE,
     _TD_DTYPE,
-    ensure_int64,
-    is_datetime64_dtype,
     is_dtype_equal,
     is_float_dtype,
     is_integer_dtype,
-    is_list_like,
     is_object_dtype,
     is_scalar,
     is_string_dtype,
@@ -41,21 +35,14 @@
 )
 from pandas.core.dtypes.missing import isna
 
+from pandas.core import nanops
 from pandas.core.algorithms import checked_add_with_arr
+from pandas.core.arrays import datetimelike as dtl
 import pandas.core.common as com
-from pandas.core.ops.invalid import invalid_comparison
 
 from pandas.tseries.frequencies import to_offset
 from pandas.tseries.offsets import Tick
 
-from . import datetimelike as dtl
-
-_BAD_DTYPE = "dtype {dtype} cannot be converted to timedelta64[ns]"
-
-
-def _is_convertible_to_td(key):
-    return isinstance(key, (Tick, timedelta, np.timedelta64, str))
-
 
 def _field_accessor(name, alias, docstring=None):
     def f(self):
@@ -69,60 +56,10 @@ def f(self):
         return result
 
     f.__name__ = name
-    f.__doc__ = "\n{}\n".format(docstring)
+    f.__doc__ = f"\n{docstring}\n"
     return property(f)
 
 
-def _td_array_cmp(cls, op):
-    """
-    Wrap comparison operations to convert timedelta-like to timedelta64
-    """
-    opname = "__{name}__".format(name=op.__name__)
-    nat_result = opname == "__ne__"
-
-    def wrapper(self, other):
-        other = lib.item_from_zerodim(other)
-        if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndexClass)):
-            return NotImplemented
-
-        if _is_convertible_to_td(other) or other is NaT:
-            try:
-                other = Timedelta(other)
-            except ValueError:
-                # failed to parse as timedelta
-                return invalid_comparison(self, other, op)
-
-            result = op(self.view("i8"), other.value)
-            if isna(other):
-                result.fill(nat_result)
-
-        elif not is_list_like(other):
-            return invalid_comparison(self, other, op)
-
-        elif len(other) != len(self):
-            raise ValueError("Lengths must match")
-
-        else:
-            try:
-                other = type(self)._from_sequence(other)._data
-            except (ValueError, TypeError):
-                return invalid_comparison(self, other, op)
-
-            result = op(self.view("i8"), other.view("i8"))
-            result = com.values_from_object(result)
-
-            o_mask = np.array(isna(other))
-            if o_mask.any():
-                result[o_mask] = nat_result
-
-        if self._hasnans:
-            result[self._isnan] = nat_result
-
-        return result
-
-    return compat.set_function_name(wrapper, opname, cls)
-
-
 class TimedeltaArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps):
     """
     Pandas ExtensionArray for timedelta data.
@@ -158,10 +95,13 @@ class TimedeltaArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps):
 
     _typ = "timedeltaarray"
     _scalar_type = Timedelta
+    _recognized_scalars = (timedelta, np.timedelta64, Tick)
+    _is_recognized_dtype = is_timedelta64_dtype
+
     __array_priority__ = 1000
     # define my properties & methods for delegation
-    _other_ops = []  # type: List[str]
-    _bool_ops = []  # type: List[str]
+    _other_ops: List[str] = []
+    _bool_ops: List[str] = []
     _object_ops = ["freq"]
     _field_ops = ["days", "seconds", "microseconds", "nanoseconds"]
     _datetimelike_ops = _field_ops + _object_ops + _bool_ops
@@ -216,11 +156,11 @@ def __init__(self, values, dtype=_TD_DTYPE, freq=None, copy=False):
 
         if not isinstance(values, np.ndarray):
             msg = (
-                "Unexpected type '{}'. 'values' must be a TimedeltaArray "
-                "ndarray, or Series or Index containing one of those."
+                f"Unexpected type '{type(values).__name__}'. 'values' must be a "
+                "TimedeltaArray ndarray, or Series or Index containing one of those."
             )
-            raise ValueError(msg.format(type(values).__name__))
-        if values.ndim != 1:
+            raise ValueError(msg)
+        if values.ndim not in [1, 2]:
             raise ValueError("Only 1-dimensional input arrays are supported.")
 
         if values.dtype == "i8":
@@ -255,9 +195,12 @@ def __init__(self, values, dtype=_TD_DTYPE, freq=None, copy=False):
     def _simple_new(cls, values, freq=None, dtype=_TD_DTYPE):
         assert dtype == _TD_DTYPE, dtype
         assert isinstance(values, np.ndarray), type(values)
+        if values.dtype != _TD_DTYPE:
+            assert values.dtype == "i8"
+            values = values.view(_TD_DTYPE)
 
         result = object.__new__(cls)
-        result._data = values.view(_TD_DTYPE)
+        result._data = values
         result._freq = to_offset(freq)
         result._dtype = _TD_DTYPE
         return result
@@ -335,7 +278,7 @@ def _unbox_scalar(self, value):
     def _scalar_from_string(self, value):
         return Timedelta(value)
 
-    def _check_compatible_with(self, other):
+    def _check_compatible_with(self, other, setitem: bool = False):
         # we don't have anything to validate.
         pass
 
@@ -345,19 +288,6 @@ def _maybe_clear_freq(self):
     # ----------------------------------------------------------------
     # Array-Like / EA-Interface Methods
 
-    @Appender(dtl.DatetimeLikeArrayMixin._validate_fill_value.__doc__)
-    def _validate_fill_value(self, fill_value):
-        if isna(fill_value):
-            fill_value = iNaT
-        elif isinstance(fill_value, (timedelta, np.timedelta64, Tick)):
-            fill_value = Timedelta(fill_value).value
-        else:
-            raise ValueError(
-                "'fill_value' should be a Timedelta. "
-                "Got '{got}'.".format(got=fill_value)
-            )
-        return fill_value
-
     def astype(self, dtype, copy=True):
         # We handle
         #   --> timedelta64[ns]
@@ -384,6 +314,65 @@ def astype(self, dtype, copy=True):
             return self
         return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy=copy)
 
+    # ----------------------------------------------------------------
+    # Reductions
+
+    def sum(
+        self,
+        axis=None,
+        dtype=None,
+        out=None,
+        keepdims: bool = False,
+        initial=None,
+        skipna: bool = True,
+        min_count: int = 0,
+    ):
+        nv.validate_sum(
+            (), dict(dtype=dtype, out=out, keepdims=keepdims, initial=initial)
+        )
+        if not len(self):
+            return NaT
+        if not skipna and self._hasnans:
+            return NaT
+
+        result = nanops.nansum(
+            self._data, axis=axis, skipna=skipna, min_count=min_count
+        )
+        return Timedelta(result)
+
+    def std(
+        self,
+        axis=None,
+        dtype=None,
+        out=None,
+        ddof: int = 1,
+        keepdims: bool = False,
+        skipna: bool = True,
+    ):
+        nv.validate_stat_ddof_func(
+            (), dict(dtype=dtype, out=out, keepdims=keepdims), fname="std"
+        )
+        if not len(self):
+            return NaT
+        if not skipna and self._hasnans:
+            return NaT
+
+        result = nanops.nanstd(self._data, axis=axis, skipna=skipna, ddof=ddof)
+        return Timedelta(result)
+
+    def median(
+        self,
+        axis=None,
+        out=None,
+        overwrite_input: bool = False,
+        keepdims: bool = False,
+        skipna: bool = True,
+    ):
+        nv.validate_median(
+            (), dict(out=out, overwrite_input=overwrite_input, keepdims=keepdims)
+        )
+        return nanops.nanmedian(self._data, axis=axis, skipna=skipna)
+
     # ----------------------------------------------------------------
     # Rendering Methods
 
@@ -392,7 +381,7 @@ def _formatter(self, boxed=False):
 
         return _get_format_timedelta64(self, box=True)
 
-    def _format_native_types(self, na_rep="NaT", date_format=None):
+    def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
         from pandas.io.formats.format import _get_format_timedelta64
 
         formatter = _get_format_timedelta64(self._data, na_rep)
@@ -401,14 +390,10 @@ def _format_native_types(self, na_rep="NaT", date_format=None):
     # ----------------------------------------------------------------
     # Arithmetic Methods
 
-    _create_comparison_method = classmethod(_td_array_cmp)
-
     def _add_offset(self, other):
         assert not isinstance(other, Tick)
         raise TypeError(
-            "cannot add the type {typ} to a {cls}".format(
-                typ=type(other).__name__, cls=type(self).__name__
-            )
+            f"cannot add the type {type(other).__name__} to a {type(self).__name__}"
         )
 
     def _add_delta(self, delta):
@@ -459,18 +444,16 @@ def _add_datetimelike_scalar(self, other):
         dtype = DatetimeTZDtype(tz=other.tz) if other.tz else _NS_DTYPE
         return DatetimeArray(result, dtype=dtype, freq=self.freq)
 
-    def _addsub_offset_array(self, other, op):
-        # Add or subtract Array-like of DateOffset objects
+    def _addsub_object_array(self, other, op):
+        # Add or subtract Array-like of objects
         try:
             # TimedeltaIndex can only operate with a subset of DateOffset
             # subclasses.  Incompatible classes will raise AttributeError,
             # which we re-raise as TypeError
-            return super()._addsub_offset_array(other, op)
+            return super()._addsub_object_array(other, op)
         except AttributeError:
             raise TypeError(
-                "Cannot add/subtract non-tick DateOffset to {cls}".format(
-                    cls=type(self).__name__
-                )
+                f"Cannot add/subtract non-tick DateOffset to {type(self).__name__}"
             )
 
     def __mul__(self, other):
@@ -495,7 +478,7 @@ def __mul__(self, other):
             #  for that instead of ValueError
             raise ValueError("Cannot multiply with unequal lengths")
 
-        if is_object_dtype(other):
+        if is_object_dtype(other.dtype):
             # this multiplication will succeed only if all elements of other
             #  are int or float scalars, so we will end up with
             #  timedelta64[ns]-dtyped result
@@ -543,11 +526,11 @@ def __truediv__(self, other):
         if len(other) != len(self):
             raise ValueError("Cannot divide vectors with unequal lengths")
 
-        elif is_timedelta64_dtype(other):
+        elif is_timedelta64_dtype(other.dtype):
             # let numpy handle it
             return self._data / other
 
-        elif is_object_dtype(other):
+        elif is_object_dtype(other.dtype):
             # Note: we do not do type inference on the result, so either
             #  an object array or numeric-dtyped (if numpy does inference)
             #  will be returned.  GH#23829
@@ -579,9 +562,7 @@ def __rtruediv__(self, other):
 
         elif lib.is_scalar(other):
             raise TypeError(
-                "Cannot divide {typ} by {cls}".format(
-                    typ=type(other).__name__, cls=type(self).__name__
-                )
+                f"Cannot divide {type(other).__name__} by {type(self).__name__}"
             )
 
         if not hasattr(other, "dtype"):
@@ -591,12 +572,12 @@ def __rtruediv__(self, other):
         if len(other) != len(self):
             raise ValueError("Cannot divide vectors with unequal lengths")
 
-        elif is_timedelta64_dtype(other):
+        elif is_timedelta64_dtype(other.dtype):
             # let numpy handle it
             return other / self._data
 
-        elif is_object_dtype(other):
-            # Note: unlike in __truediv__, we do not _need_ to do type#
+        elif is_object_dtype(other.dtype):
+            # Note: unlike in __truediv__, we do not _need_ to do type
             #  inference on the result.  It does not raise, a numeric array
             #  is returned.  GH#23829
             result = [other[n] / self[n] for n in range(len(self))]
@@ -604,9 +585,7 @@ def __rtruediv__(self, other):
 
         else:
             raise TypeError(
-                "Cannot divide {dtype} data by {cls}".format(
-                    dtype=other.dtype, cls=type(self).__name__
-                )
+                f"Cannot divide {other.dtype} data by {type(self).__name__}"
             )
 
     def __floordiv__(self, other):
@@ -643,7 +622,7 @@ def __floordiv__(self, other):
         if len(other) != len(self):
             raise ValueError("Cannot divide with unequal lengths")
 
-        elif is_timedelta64_dtype(other):
+        elif is_timedelta64_dtype(other.dtype):
             other = type(self)(other)
 
             # numpy timedelta64 does not natively support floordiv, so operate
@@ -655,7 +634,7 @@ def __floordiv__(self, other):
                 result[mask] = np.nan
             return result
 
-        elif is_object_dtype(other):
+        elif is_object_dtype(other.dtype):
             result = [self[n] // other[n] for n in range(len(self))]
             result = np.array(result)
             if lib.infer_dtype(result, skipna=False) == "timedelta":
@@ -663,17 +642,13 @@ def __floordiv__(self, other):
                 return type(self)(result)
             return result
 
-        elif is_integer_dtype(other) or is_float_dtype(other):
+        elif is_integer_dtype(other.dtype) or is_float_dtype(other.dtype):
             result = self._data // other
             return type(self)(result)
 
         else:
             dtype = getattr(other, "dtype", type(other).__name__)
-            raise TypeError(
-                "Cannot divide {typ} by {cls}".format(
-                    typ=dtype, cls=type(self).__name__
-                )
-            )
+            raise TypeError(f"Cannot divide {dtype} by {type(self).__name__}")
 
     def __rfloordiv__(self, other):
         if isinstance(other, (ABCSeries, ABCDataFrame, ABCIndexClass)):
@@ -694,9 +669,7 @@ def __rfloordiv__(self, other):
                 return result
 
             raise TypeError(
-                "Cannot divide {typ} by {cls}".format(
-                    typ=type(other).__name__, cls=type(self).__name__
-                )
+                f"Cannot divide {type(other).__name__} by {type(self).__name__}"
             )
 
         if not hasattr(other, "dtype"):
@@ -705,7 +678,7 @@ def __rfloordiv__(self, other):
         if len(other) != len(self):
             raise ValueError("Cannot divide with unequal lengths")
 
-        elif is_timedelta64_dtype(other):
+        elif is_timedelta64_dtype(other.dtype):
             other = type(self)(other)
 
             # numpy timedelta64 does not natively support floordiv, so operate
@@ -717,18 +690,14 @@ def __rfloordiv__(self, other):
                 result[mask] = np.nan
             return result
 
-        elif is_object_dtype(other):
+        elif is_object_dtype(other.dtype):
             result = [other[n] // self[n] for n in range(len(self))]
             result = np.array(result)
             return result
 
         else:
             dtype = getattr(other, "dtype", type(other).__name__)
-            raise TypeError(
-                "Cannot divide {typ} by {cls}".format(
-                    typ=dtype, cls=type(self).__name__
-                )
-            )
+            raise TypeError(f"Cannot divide {dtype} by {type(self).__name__}")
 
     def __mod__(self, other):
         # Note: This is a naive implementation, can likely be optimized
@@ -916,9 +885,6 @@ def f(x):
         return result
 
 
-TimedeltaArray._add_comparison_ops()
-
-
 # ---------------------------------------------------------------------
 # Constructor Helpers
 
@@ -999,27 +965,11 @@ def sequence_to_td64ns(data, copy=False, unit="ns", errors="raise"):
             data = data.astype(_TD_DTYPE)
             copy = False
 
-    elif is_datetime64_dtype(data):
-        # GH#23539
-        warnings.warn(
-            "Passing datetime64-dtype data to TimedeltaIndex is "
-            "deprecated, will raise a TypeError in a future "
-            "version",
-            FutureWarning,
-            stacklevel=4,
-        )
-        data = ensure_int64(data).view(_TD_DTYPE)
-
     else:
-        raise TypeError(
-            "dtype {dtype} cannot be converted to timedelta64[ns]".format(
-                dtype=data.dtype
-            )
-        )
+        # This includes datetime64-dtype, see GH#23539, GH#29794
+        raise TypeError(f"dtype {data.dtype} cannot be converted to timedelta64[ns]")
 
     data = np.array(data, copy=copy)
-    if data.ndim != 1:
-        raise ValueError("Only 1-dimensional input arrays are supported.")
 
     assert data.dtype == "m8[ns]", data
     return data, inferred_freq
@@ -1051,7 +1001,7 @@ def ints_to_td64ns(data, unit="ns"):
         copy_made = True
 
     if unit != "ns":
-        dtype_str = "timedelta64[{unit}]".format(unit=unit)
+        dtype_str = f"timedelta64[{unit}]"
         data = data.view(dtype_str)
 
         # TODO: watch out for overflows when converting from lower-resolution
@@ -1103,17 +1053,15 @@ def objects_to_td64ns(data, unit="ns", errors="raise"):
 def _validate_td64_dtype(dtype):
     dtype = pandas_dtype(dtype)
     if is_dtype_equal(dtype, np.dtype("timedelta64")):
-        dtype = _TD_DTYPE
-        msg = textwrap.dedent(
-            """\
-            Passing in 'timedelta' dtype with no precision is deprecated
-            and will raise in a future version. Please pass in
-            'timedelta64[ns]' instead."""
+        # no precision disallowed GH#24806
+        msg = (
+            "Passing in 'timedelta' dtype with no precision is not allowed. "
+            "Please pass in 'timedelta64[ns]' instead."
         )
-        warnings.warn(msg, FutureWarning, stacklevel=4)
+        raise ValueError(msg)
 
     if not is_dtype_equal(dtype, _TD_DTYPE):
-        raise ValueError(_BAD_DTYPE.format(dtype=dtype))
+        raise ValueError(f"dtype {dtype} cannot be converted to timedelta64[ns]")
 
     return dtype
 
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 2d5ffb5e91392..f3c8b50e774af 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -1,32 +1,30 @@
 """
 Base and utility classes for pandas objects.
 """
+
 import builtins
-from collections import OrderedDict
 import textwrap
-from typing import Dict, Optional
-import warnings
+from typing import Dict, FrozenSet, List, Optional, Union
 
 import numpy as np
 
 import pandas._libs.lib as lib
+from pandas._typing import T
 from pandas.compat import PYPY
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import Appender, Substitution, cache_readonly
 from pandas.util._validators import validate_bool_kwarg
 
+from pandas.core.dtypes.cast import is_nested_object
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
-    is_datetime64_ns_dtype,
-    is_datetime64tz_dtype,
-    is_datetimelike,
+    is_dict_like,
     is_extension_array_dtype,
-    is_extension_type,
     is_list_like,
     is_object_dtype,
     is_scalar,
-    is_timedelta64_ns_dtype,
+    needs_i8_conversion,
 )
 from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.missing import isna
@@ -35,9 +33,10 @@
 from pandas.core.accessor import DirNamesMixin
 from pandas.core.algorithms import duplicated, unique1d, value_counts
 from pandas.core.arrays import ExtensionArray
+from pandas.core.construction import create_series_with_explicit_dtype
 import pandas.core.nanops as nanops
 
-_shared_docs = dict()  # type: Dict[str, str]
+_shared_docs: Dict[str, str] = dict()
 _indexops_doc_kwargs = dict(
     klass="IndexOpsMixin",
     inplace="",
@@ -47,14 +46,18 @@
 
 
 class PandasObject(DirNamesMixin):
-    """baseclass for various pandas objects"""
+    """
+    Baseclass for various pandas objects.
+    """
 
     @property
     def _constructor(self):
-        """class constructor (for this class it's just `__class__`"""
-        return self.__class__
+        """
+        Class constructor (for this class it's just `__class__`.
+        """
+        return type(self)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Return a string representation for a particular object.
         """
@@ -79,32 +82,41 @@ def __sizeof__(self):
         """
         if hasattr(self, "memory_usage"):
             mem = self.memory_usage(deep=True)
-            if not is_scalar(mem):
-                mem = mem.sum()
-            return int(mem)
+            return int(mem if is_scalar(mem) else mem.sum())
 
-        # no memory_usage attribute, so fall back to
-        # object's 'sizeof'
+        # no memory_usage attribute, so fall back to object's 'sizeof'
         return super().__sizeof__()
 
+    def _ensure_type(self: T, obj) -> T:
+        """
+        Ensure that an object has same type as self.
+
+        Used by type checkers.
+        """
+        assert isinstance(obj, type(self)), type(obj)
+        return obj
+
 
 class NoNewAttributesMixin:
-    """Mixin which prevents adding new attributes.
+    """
+    Mixin which prevents adding new attributes.
 
     Prevents additional attributes via xxx.attribute = "something" after a
     call to `self.__freeze()`. Mainly used to prevent the user from using
-    wrong attributes on a accessor (`Series.cat/.str/.dt`).
+    wrong attributes on an accessor (`Series.cat/.str/.dt`).
 
     If you really want to add a new attribute at a later time, you need to use
     `object.__setattr__(self, key, value)`.
     """
 
     def _freeze(self):
-        """Prevents setting additional attributes"""
+        """
+        Prevents setting additional attributes.
+        """
         object.__setattr__(self, "__frozen", True)
 
     # prevent adding any attribute via s.xxx.new_attribute = ...
-    def __setattr__(self, key, value):
+    def __setattr__(self, key: str, value):
         # _cache is used by a decorator
         # We need to check both 1.) cls.__dict__ and 2.) getattr(self, key)
         # because
@@ -115,9 +127,7 @@ def __setattr__(self, key, value):
             or key in type(self).__dict__
             or getattr(self, key, None) is not None
         ):
-            raise AttributeError(
-                "You cannot add any new attribute '{key}'".format(key=key)
-            )
+            raise AttributeError(f"You cannot add any new attribute '{key}'")
         object.__setattr__(self, key, value)
 
 
@@ -143,51 +153,45 @@ class SelectionMixin:
     _internal_names = ["_cache", "__setstate__"]
     _internal_names_set = set(_internal_names)
 
-    _builtin_table = OrderedDict(
-        ((builtins.sum, np.sum), (builtins.max, np.max), (builtins.min, np.min))
-    )
-
-    _cython_table = OrderedDict(
-        (
-            (builtins.sum, "sum"),
-            (builtins.max, "max"),
-            (builtins.min, "min"),
-            (np.all, "all"),
-            (np.any, "any"),
-            (np.sum, "sum"),
-            (np.nansum, "sum"),
-            (np.mean, "mean"),
-            (np.nanmean, "mean"),
-            (np.prod, "prod"),
-            (np.nanprod, "prod"),
-            (np.std, "std"),
-            (np.nanstd, "std"),
-            (np.var, "var"),
-            (np.nanvar, "var"),
-            (np.median, "median"),
-            (np.nanmedian, "median"),
-            (np.max, "max"),
-            (np.nanmax, "max"),
-            (np.min, "min"),
-            (np.nanmin, "min"),
-            (np.cumprod, "cumprod"),
-            (np.nancumprod, "cumprod"),
-            (np.cumsum, "cumsum"),
-            (np.nancumsum, "cumsum"),
-        )
-    )
+    _builtin_table = {builtins.sum: np.sum, builtins.max: np.max, builtins.min: np.min}
+
+    _cython_table = {
+        builtins.sum: "sum",
+        builtins.max: "max",
+        builtins.min: "min",
+        np.all: "all",
+        np.any: "any",
+        np.sum: "sum",
+        np.nansum: "sum",
+        np.mean: "mean",
+        np.nanmean: "mean",
+        np.prod: "prod",
+        np.nanprod: "prod",
+        np.std: "std",
+        np.nanstd: "std",
+        np.var: "var",
+        np.nanvar: "var",
+        np.median: "median",
+        np.nanmedian: "median",
+        np.max: "max",
+        np.nanmax: "max",
+        np.min: "min",
+        np.nanmin: "min",
+        np.cumprod: "cumprod",
+        np.nancumprod: "cumprod",
+        np.cumsum: "cumsum",
+        np.nancumsum: "cumsum",
+    }
 
     @property
     def _selection_name(self):
         """
-        return a name for myself; this would ideally be called
-        the 'name' property, but we cannot conflict with the
-        Series.name property which can be set
+        Return a name for myself;
+
+        This would ideally be called the 'name' property,
+        but we cannot conflict with the Series.name property which can be set.
         """
-        if self._selection is None:
-            return None  # 'result'
-        else:
-            return self._selection
+        return self._selection
 
     @property
     def _selection_list(self):
@@ -199,14 +203,13 @@ def _selection_list(self):
 
     @cache_readonly
     def _selected_obj(self):
-
         if self._selection is None or isinstance(self.obj, ABCSeries):
             return self.obj
         else:
             return self.obj[self._selection]
 
     @cache_readonly
-    def ndim(self):
+    def ndim(self) -> int:
         return self._selected_obj.ndim
 
     @cache_readonly
@@ -221,43 +224,36 @@ def _obj_with_exclusions(self):
 
     def __getitem__(self, key):
         if self._selection is not None:
-            raise IndexError(
-                "Column(s) {selection} already selected".format(
-                    selection=self._selection
-                )
-            )
+            raise IndexError(f"Column(s) {self._selection} already selected")
 
         if isinstance(key, (list, tuple, ABCSeries, ABCIndexClass, np.ndarray)):
             if len(self.obj.columns.intersection(key)) != len(key):
                 bad_keys = list(set(key).difference(self.obj.columns))
-                raise KeyError(
-                    "Columns not found: {missing}".format(missing=str(bad_keys)[1:-1])
-                )
+                raise KeyError(f"Columns not found: {str(bad_keys)[1:-1]}")
             return self._gotitem(list(key), ndim=2)
 
         elif not getattr(self, "as_index", False):
             if key not in self.obj.columns:
-                raise KeyError("Column not found: {key}".format(key=key))
+                raise KeyError(f"Column not found: {key}")
             return self._gotitem(key, ndim=2)
 
         else:
             if key not in self.obj:
-                raise KeyError("Column not found: {key}".format(key=key))
+                raise KeyError(f"Column not found: {key}")
             return self._gotitem(key, ndim=1)
 
-    def _gotitem(self, key, ndim, subset=None):
+    def _gotitem(self, key, ndim: int, subset=None):
         """
         sub-classes to define
         return a sliced object
 
         Parameters
         ----------
-        key : string / list of selections
+        key : str / list of selections
         ndim : 1,2
             requested ndim of result
         subset : object, default None
             subset to act on
-
         """
         raise AbstractMethodError(self)
 
@@ -266,13 +262,12 @@ def aggregate(self, func, *args, **kwargs):
 
     agg = aggregate
 
-    def _try_aggregate_string_function(self, arg, *args, **kwargs):
+    def _try_aggregate_string_function(self, arg: str, *args, **kwargs):
         """
         if arg is a string, then try to operate on it:
         - try to find a function (or attribute) on ourselves
         - try to find a numpy function
         - raise
-
         """
         assert isinstance(arg, str)
 
@@ -284,22 +279,17 @@ def _try_aggregate_string_function(self, arg, *args, **kwargs):
             # people may try to aggregate on a non-callable attribute
             # but don't let them think they can pass args to it
             assert len(args) == 0
-            assert (
-                len([kwarg for kwarg in kwargs if kwarg not in ["axis", "_level"]]) == 0
-            )
+            assert len([kwarg for kwarg in kwargs if kwarg not in ["axis"]]) == 0
             return f
 
         f = getattr(np, arg, None)
         if f is not None:
-            try:
+            if hasattr(self, "__array__"):
+                # in particular exclude Window
                 return f(self, *args, **kwargs)
 
-            except (AttributeError, TypeError):
-                pass
-
         raise AttributeError(
-            "'{arg}' is not a valid function for "
-            "'{cls}' object".format(arg=arg, cls=type(self).__name__)
+            f"'{arg}' is not a valid function for '{type(self).__name__}' object"
         )
 
     def _aggregate(self, arg, *args, **kwargs):
@@ -322,44 +312,26 @@ def _aggregate(self, arg, *args, **kwargs):
         None if not required
         """
         is_aggregator = lambda x: isinstance(x, (list, tuple, dict))
-        is_nested_renamer = False
 
         _axis = kwargs.pop("_axis", None)
         if _axis is None:
             _axis = getattr(self, "axis", 0)
-        _level = kwargs.pop("_level", None)
 
         if isinstance(arg, str):
             return self._try_aggregate_string_function(arg, *args, **kwargs), None
 
         if isinstance(arg, dict):
-
             # aggregate based on the passed dict
             if _axis != 0:  # pragma: no cover
                 raise ValueError("Can only pass dict with axis=0")
 
             obj = self._selected_obj
 
-            def nested_renaming_depr(level=4):
-                # deprecation of nested renaming
-                # GH 15931
-                msg = textwrap.dedent(
-                    """\
-                using a dict with renaming is deprecated and will be removed
-                in a future version.
-
-                For column-specific groupby renaming, use named aggregation
-
-                    >>> df.groupby(...).agg(name=('column', aggfunc))
-                """
-                )
-                warnings.warn(msg, FutureWarning, stacklevel=level)
-
             # if we have a dict of any non-scalars
             # eg. {'A' : ['mean']}, normalize all to
             # be list-likes
             if any(is_aggregator(x) for x in arg.values()):
-                new_arg = OrderedDict()
+                new_arg = {}
                 for k, v in arg.items():
                     if not isinstance(v, (tuple, list, dict)):
                         new_arg[k] = [v]
@@ -377,20 +349,11 @@ def nested_renaming_depr(level=4):
                     # not ok
                     # {'ra' : { 'A' : 'mean' }}
                     if isinstance(v, dict):
-                        is_nested_renamer = True
-
-                        if k not in obj.columns:
-                            msg = (
-                                "cannot perform renaming for {key} with a "
-                                "nested dictionary"
-                            ).format(key=k)
-                            raise SpecificationError(msg)
-                        nested_renaming_depr(4 + (_level or 0))
-
+                        raise SpecificationError("nested renamer is not supported")
                     elif isinstance(obj, ABCSeries):
-                        nested_renaming_depr()
+                        raise SpecificationError("nested renamer is not supported")
                     elif isinstance(obj, ABCDataFrame) and k not in obj.columns:
-                        raise KeyError("Column '{col}' does not exist!".format(col=k))
+                        raise KeyError(f"Column '{k}' does not exist!")
 
                 arg = new_arg
 
@@ -401,7 +364,7 @@ def nested_renaming_depr(level=4):
                 if isinstance(obj, ABCDataFrame) and len(
                     obj.columns.intersection(keys)
                 ) != len(keys):
-                    nested_renaming_depr()
+                    raise SpecificationError("nested renamer is not supported")
 
             from pandas.core.reshape.concat import concat
 
@@ -414,47 +377,30 @@ def _agg_1dim(name, how, subset=None):
                     raise SpecificationError(
                         "nested dictionary is ambiguous in aggregation"
                     )
-                return colg.aggregate(how, _level=(_level or 0) + 1)
+                return colg.aggregate(how)
 
             def _agg_2dim(name, how):
                 """
                 aggregate a 2-dim with how
                 """
                 colg = self._gotitem(self._selection, ndim=2, subset=obj)
-                return colg.aggregate(how, _level=None)
+                return colg.aggregate(how)
 
             def _agg(arg, func):
                 """
                 run the aggregations over the arg with func
-                return an OrderedDict
+                return a dict
                 """
-                result = OrderedDict()
+                result = {}
                 for fname, agg_how in arg.items():
                     result[fname] = func(fname, agg_how)
                 return result
 
             # set the final keys
             keys = list(arg.keys())
-            result = OrderedDict()
+            result = {}
 
-            # nested renamer
-            if is_nested_renamer:
-                result = list(_agg(arg, _agg_1dim).values())
-
-                if all(isinstance(r, dict) for r in result):
-
-                    result, results = OrderedDict(), result
-                    for r in results:
-                        result.update(r)
-                    keys = list(result.keys())
-
-                else:
-
-                    if self._selection is not None:
-                        keys = None
-
-            # some selection on the object
-            elif self._selection is not None:
+            if self._selection is not None:
 
                 sl = set(self._selection_list)
 
@@ -489,11 +435,11 @@ def _agg(arg, func):
 
             # combine results
 
-            def is_any_series():
+            def is_any_series() -> bool:
                 # return a boolean if we have *any* nested series
                 return any(isinstance(r, ABCSeries) for r in result.values())
 
-            def is_any_frame():
+            def is_any_frame() -> bool:
                 # return a boolean if we have *any* nested series
                 return any(isinstance(r, ABCDataFrame) for r in result.values())
 
@@ -538,7 +484,7 @@ def is_any_frame():
             return result, True
         elif is_list_like(arg):
             # we require a list, but not an 'str'
-            return self._aggregate_multiple_funcs(arg, _level=_level, _axis=_axis), None
+            return self._aggregate_multiple_funcs(arg, _axis=_axis), None
         else:
             result = None
 
@@ -549,7 +495,7 @@ def is_any_frame():
         # caller can react
         return result, True
 
-    def _aggregate_multiple_funcs(self, arg, _level, _axis):
+    def _aggregate_multiple_funcs(self, arg, _axis):
         from pandas.core.reshape.concat import concat
 
         if _axis != 0:
@@ -566,32 +512,40 @@ def _aggregate_multiple_funcs(self, arg, _level, _axis):
         # degenerate case
         if obj.ndim == 1:
             for a in arg:
+                colg = self._gotitem(obj.name, ndim=1, subset=obj)
                 try:
-                    colg = self._gotitem(obj.name, ndim=1, subset=obj)
-                    results.append(colg.aggregate(a))
+                    new_res = colg.aggregate(a)
+
+                except TypeError:
+                    pass
+                else:
+                    results.append(new_res)
 
                     # make sure we find a good name
                     name = com.get_callable_name(a) or a
                     keys.append(name)
-                except (TypeError, DataError):
-                    pass
-                except SpecificationError:
-                    raise
 
         # multiples
         else:
             for index, col in enumerate(obj):
+                colg = self._gotitem(col, ndim=1, subset=obj.iloc[:, index])
                 try:
-                    colg = self._gotitem(col, ndim=1, subset=obj.iloc[:, index])
-                    results.append(colg.aggregate(arg))
-                    keys.append(col)
+                    new_res = colg.aggregate(arg)
                 except (TypeError, DataError):
                     pass
-                except ValueError:
+                except ValueError as err:
                     # cannot aggregate
-                    continue
-                except SpecificationError:
-                    raise
+                    if "Must produce aggregated value" in str(err):
+                        # raised directly in _aggregate_named
+                        pass
+                    elif "no results" in str(err):
+                        # raised direcly in _aggregate_multiple_funcs
+                        pass
+                    else:
+                        raise
+                else:
+                    results.append(new_res)
+                    keys.append(col)
 
         # if we are empty
         if not len(results):
@@ -604,7 +558,6 @@ def _aggregate_multiple_funcs(self, arg, _level, _axis):
             # we are concatting non-NDFrame objects,
             # e.g. a list of scalars
 
-            from pandas.core.dtypes.cast import is_nested_object
             from pandas import Series
 
             result = Series(results, index=keys, name=self.name)
@@ -612,21 +565,6 @@ def _aggregate_multiple_funcs(self, arg, _level, _axis):
                 raise ValueError("cannot combine transform and aggregation operations")
             return result
 
-    def _shallow_copy(self, obj=None, obj_type=None, **kwargs):
-        """
-        return a new object with the replacement attributes
-        """
-        if obj is None:
-            obj = self._selected_obj.copy()
-        if obj_type is None:
-            obj_type = self._constructor
-        if isinstance(obj, obj_type):
-            obj = obj.obj
-        for attr in self._attributes:
-            if attr not in kwargs:
-                kwargs[attr] = getattr(self, attr)
-        return obj_type(obj, **kwargs)
-
     def _get_cython_func(self, arg: str) -> Optional[str]:
         """
         if we define an internal function for this argument, return it
@@ -641,6 +579,21 @@ def _is_builtin_func(self, arg):
         return self._builtin_table.get(arg, arg)
 
 
+class ShallowMixin:
+    _attributes: List[str] = []
+
+    def _shallow_copy(self, obj, **kwargs):
+        """
+        return a new object with the replacement attributes
+        """
+        if isinstance(obj, self._constructor):
+            obj = obj.obj
+        for attr in self._attributes:
+            if attr not in kwargs:
+                kwargs[attr] = getattr(self, attr)
+        return self._constructor(obj, **kwargs)
+
+
 class IndexOpsMixin:
     """
     Common ops mixin to support a unified interface / docs for Series / Index
@@ -648,6 +601,14 @@ class IndexOpsMixin:
 
     # ndarray compatibility
     __array_priority__ = 1000
+    _deprecations: FrozenSet[str] = frozenset(
+        ["tolist"]  # tolist is not deprecated, just suppressed in the __dir__
+    )
+
+    @property
+    def _values(self) -> Union[ExtensionArray, np.ndarray]:
+        # must be defined here as a property for mypy
+        raise AbstractMethodError(self)
 
     def transpose(self, *args, **kwargs):
         """
@@ -667,22 +628,6 @@ def transpose(self, *args, **kwargs):
         """,
     )
 
-    @property
-    def _is_homogeneous_type(self):
-        """
-        Whether the object has a single dtype.
-
-        By definition, Series and Index are always considered homogeneous.
-        A MultiIndex may or may not be homogeneous, depending on the
-        dtypes of the levels.
-
-        See Also
-        --------
-        DataFrame._is_homogeneous_type
-        MultiIndex._is_homogeneous_type
-        """
-        return True
-
     @property
     def shape(self):
         """
@@ -690,8 +635,12 @@ def shape(self):
         """
         return self._values.shape
 
+    def __len__(self) -> int:
+        # We need this defined here for mypy
+        raise AbstractMethodError(self)
+
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         """
         Number of dimensions of the underlying data, by definition 1.
         """
@@ -701,109 +650,41 @@ def item(self):
         """
         Return the first element of the underlying data as a python scalar.
 
-        .. deprecated:: 0.25.0
-
         Returns
         -------
         scalar
             The first element of %(klass)s.
-        """
-        warnings.warn(
-            "`item` has been deprecated and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.item()
-
-    @property
-    def data(self):
-        """
-        Return the data pointer of the underlying data.
-
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "{obj}.data is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.data
 
-    @property
-    def itemsize(self):
+        Raises
+        ------
+        ValueError
+            If the data is not length-1.
         """
-        Return the size of the dtype of the item of the underlying data.
+        if not (
+            is_extension_array_dtype(self.dtype) or needs_i8_conversion(self.dtype)
+        ):
+            # numpy returns ints instead of datetime64/timedelta64 objects,
+            #  which we need to wrap in Timestamp/Timedelta/Period regardless.
+            return self.values.item()
 
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "{obj}.itemsize is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._ndarray_values.itemsize
+        if len(self) == 1:
+            return next(iter(self))
+        raise ValueError("can only convert an array of size 1 to a Python scalar")
 
     @property
-    def nbytes(self):
+    def nbytes(self) -> int:
         """
         Return the number of bytes in the underlying data.
         """
         return self._values.nbytes
 
     @property
-    def strides(self):
-        """
-        Return the strides of the underlying data.
-
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "{obj}.strides is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._ndarray_values.strides
-
-    @property
-    def size(self):
+    def size(self) -> int:
         """
         Return the number of elements in the underlying data.
         """
         return len(self._values)
 
-    @property
-    def flags(self):
-        """
-        Return the ndarray.flags for the underlying data.
-
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "{obj}.flags is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.flags
-
-    @property
-    def base(self):
-        """
-        Return the base object if the memory of the underlying data is shared.
-
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "{obj}.base is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.base
-
     @property
     def array(self) -> ExtensionArray:
         """
@@ -838,6 +719,8 @@ def array(self) -> ExtensionArray:
         period             PeriodArray
         interval           IntervalArray
         IntegerNA          IntegerArray
+        string             StringArray
+        boolean            BooleanArray
         datetime64[ns, tz] DatetimeArray
         ================== =============================
 
@@ -851,7 +734,6 @@ def array(self) -> ExtensionArray:
 
         Examples
         --------
-
         For regular NumPy types like int, and float, a PandasArray
         is returned.
 
@@ -868,28 +750,9 @@ def array(self) -> ExtensionArray:
         [a, b, a]
         Categories (2, object): [a, b]
         """
-        # As a mixin, we depend on the mixing class having _values.
-        # Special mixin syntax may be developed in the future:
-        # https://github.com/python/typing/issues/246
-        result = self._values  # type: ignore
-
-        if is_datetime64_ns_dtype(result.dtype):
-            from pandas.arrays import DatetimeArray
-
-            result = DatetimeArray(result)
-        elif is_timedelta64_ns_dtype(result.dtype):
-            from pandas.arrays import TimedeltaArray
-
-            result = TimedeltaArray(result)
-
-        elif not is_extension_array_dtype(result.dtype):
-            from pandas.core.arrays.numpy_ import PandasArray
-
-            result = PandasArray(result)
-
-        return result
+        raise AbstractMethodError(self)
 
-    def to_numpy(self, dtype=None, copy=False):
+    def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default, **kwargs):
         """
         A NumPy ndarray representing the values in this Series or Index.
 
@@ -898,12 +761,23 @@ def to_numpy(self, dtype=None, copy=False):
         Parameters
         ----------
         dtype : str or numpy.dtype, optional
-            The dtype to pass to :meth:`numpy.asarray`
+            The dtype to pass to :meth:`numpy.asarray`.
         copy : bool, default False
             Whether to ensure that the returned value is a not a view on
             another array. Note that ``copy=False`` does not *ensure* that
             ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
             a copy is made, even if not strictly necessary.
+        na_value : Any, optional
+            The value to use for missing values. The default value depends
+            on `dtype` and the type of the array.
+
+            .. versionadded:: 1.0.0
+
+        **kwargs
+            Additional keywords passed through to the ``to_numpy`` method
+            of the underlying array (for extension arrays).
+
+            .. versionadded:: 1.0.0
 
         Returns
         -------
@@ -973,16 +847,20 @@ def to_numpy(self, dtype=None, copy=False):
         array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00...'],
               dtype='datetime64[ns]')
         """
-        if is_datetime64tz_dtype(self.dtype) and dtype is None:
-            # note: this is going to change very soon.
-            # I have a WIP PR making this unnecessary, but it's
-            # a bit out of scope for the DatetimeArray PR.
-            dtype = "object"
+        if is_extension_array_dtype(self.dtype):
+            return self.array.to_numpy(dtype, copy=copy, na_value=na_value, **kwargs)
+        elif kwargs:
+            bad_keys = list(kwargs.keys())[0]
+            raise TypeError(
+                f"to_numpy() got an unexpected keyword argument '{bad_keys}'"
+            )
 
         result = np.asarray(self._values, dtype=dtype)
         # TODO(GH-24345): Avoid potential double copy
-        if copy:
+        if copy or na_value is not lib.no_default:
             result = result.copy()
+            if na_value is not lib.no_default:
+                result[self.isna()] = na_value
         return result
 
     @property
@@ -1054,7 +932,7 @@ def argmax(self, axis=None, skipna=True, *args, **kwargs):
         Parameters
         ----------
         axis : {None}
-            Dummy argument for consistency with Series
+            Dummy argument for consistency with Series.
         skipna : bool, default True
 
         Returns
@@ -1077,7 +955,7 @@ def min(self, axis=None, skipna=True, *args, **kwargs):
         Parameters
         ----------
         axis : {None}
-            Dummy argument for consistency with Series
+            Dummy argument for consistency with Series.
         skipna : bool, default True
 
         Returns
@@ -1118,7 +996,7 @@ def argmin(self, axis=None, skipna=True, *args, **kwargs):
         Parameters
         ----------
         axis : {None}
-            Dummy argument for consistency with Series
+            Dummy argument for consistency with Series.
         skipna : bool, default True
 
         Returns
@@ -1149,12 +1027,10 @@ def tolist(self):
         --------
         numpy.ndarray.tolist
         """
-        if is_datetimelike(self._values):
-            return [com.maybe_box_datetimelike(x) for x in self._values]
-        elif is_extension_array_dtype(self._values):
+        if not isinstance(self._values, np.ndarray):
+            # check for ndarray instead of dtype to catch DTA/TDA
             return list(self._values)
-        else:
-            return self._values.tolist()
+        return self._values.tolist()
 
     to_list = tolist
 
@@ -1171,9 +1047,8 @@ def __iter__(self):
         iterator
         """
         # We are explicitly making element iterators.
-        if is_datetimelike(self._values):
-            return map(com.maybe_box_datetimelike, self._values)
-        elif is_extension_array_dtype(self._values):
+        if not isinstance(self._values, np.ndarray):
+            # Check type instead of dtype to catch DTA/TDA
             return iter(self._values)
         else:
             return map(self._values.item, range(self._values.size))
@@ -1186,15 +1061,22 @@ def hasnans(self):
         return bool(isna(self).any())
 
     def _reduce(
-        self, op, name, axis=0, skipna=True, numeric_only=None, filter_type=None, **kwds
+        self,
+        op,
+        name: str,
+        axis=0,
+        skipna=True,
+        numeric_only=None,
+        filter_type=None,
+        **kwds,
     ):
-        """ perform the reduction type operation if we can """
+        """
+        Perform the reduction type operation if we can.
+        """
         func = getattr(self, name, None)
         if func is None:
             raise TypeError(
-                "{klass} cannot perform the operation {op}".format(
-                    klass=self.__class__.__name__, op=name
-                )
+                f"{type(self).__name__} cannot perform the operation {name}"
             )
         return func(skipna=skipna, **kwds)
 
@@ -1217,14 +1099,12 @@ def _map_values(self, mapper, na_action=None):
             The output of the mapping function applied to the index.
             If the function returns a tuple with more than one element
             a MultiIndex will be returned.
-
         """
-
         # we can fastpath dict/Series to an efficient map
         # as we know that we are not going to have to yield
         # python types
-        if isinstance(mapper, dict):
-            if hasattr(mapper, "__missing__"):
+        if is_dict_like(mapper):
+            if isinstance(mapper, dict) and hasattr(mapper, "__missing__"):
                 # If a dictionary subclass defines a default value method,
                 # convert mapper to a lookup function (GH #15999).
                 dict_with_default = mapper
@@ -1234,9 +1114,14 @@ def _map_values(self, mapper, na_action=None):
                 # convert to an Series for efficiency.
                 # we specify the keys here to handle the
                 # possibility that they are tuples
-                from pandas import Series
 
-                mapper = Series(mapper)
+                # The return value of mapping with an empty mapper is
+                # expected to be pd.Series(np.nan, ...). As np.nan is
+                # of dtype float64 the return value of this method should
+                # be float64 as well
+                mapper = create_series_with_explicit_dtype(
+                    mapper, dtype_if_empty=np.float64
+                )
 
         if isinstance(mapper, ABCSeries):
             # Since values were input this means we came from either
@@ -1245,7 +1130,7 @@ def _map_values(self, mapper, na_action=None):
                 # use the built in categorical series mapper which saves
                 # time by mapping the categories instead of all values
                 return self._values.map(mapper)
-            if is_extension_type(self.dtype):
+            if is_extension_array_dtype(self.dtype):
                 values = self._values
             else:
                 values = self.values
@@ -1256,7 +1141,8 @@ def _map_values(self, mapper, na_action=None):
             return new_values
 
         # we must convert to python types
-        if is_extension_type(self.dtype):
+        if is_extension_array_dtype(self.dtype) and hasattr(self._values, "map"):
+            # GH#23179 some EAs do not have `map`
             values = self._values
             if na_action is not None:
                 raise NotImplementedError
@@ -1289,17 +1175,17 @@ def value_counts(
 
         Parameters
         ----------
-        normalize : boolean, default False
+        normalize : bool, default False
             If True then the object returned will contain the relative
             frequencies of the unique values.
-        sort : boolean, default True
+        sort : bool, default True
             Sort by frequencies.
-        ascending : boolean, default False
+        ascending : bool, default False
             Sort in ascending order.
-        bins : integer, optional
+        bins : int, optional
             Rather than count values, group them into half-open bins,
             a convenience for ``pd.cut``, only works with numeric data.
-        dropna : boolean, default True
+        dropna : bool, default True
             Don't include counts of NaN.
 
         Returns
@@ -1373,12 +1259,16 @@ def unique(self):
         if hasattr(values, "unique"):
 
             result = values.unique()
+            if self.dtype.kind in ["m", "M"] and isinstance(self, ABCSeries):
+                # GH#31182 Series._values returns EA, unpack for backward-compat
+                if getattr(self.dtype, "tz", None) is None:
+                    result = np.asarray(result)
         else:
             result = unique1d(values)
 
         return result
 
-    def nunique(self, dropna=True):
+    def nunique(self, dropna: bool = True) -> int:
         """
         Return number of unique elements in the object.
 
@@ -1419,7 +1309,7 @@ def nunique(self, dropna=True):
         return n
 
     @property
-    def is_unique(self):
+    def is_unique(self) -> bool:
         """
         Return boolean if values in the object are unique.
 
@@ -1430,7 +1320,7 @@ def is_unique(self):
         return self.nunique(dropna=False) == len(self)
 
     @property
-    def is_monotonic(self):
+    def is_monotonic(self) -> bool:
         """
         Return boolean if values in the object are
         monotonic_increasing.
@@ -1443,10 +1333,16 @@ def is_monotonic(self):
 
         return Index(self).is_monotonic
 
-    is_monotonic_increasing = is_monotonic
+    @property
+    def is_monotonic_increasing(self) -> bool:
+        """
+        Alias for is_monotonic.
+        """
+        # mypy complains if we alias directly
+        return self.is_monotonic
 
     @property
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         """
         Return boolean if values in the object are
         monotonic_decreasing.
@@ -1467,7 +1363,7 @@ def memory_usage(self, deep=False):
         ----------
         deep : bool
             Introspect the data deeply, interrogate
-            `object` dtypes for system-level memory consumption
+            `object` dtypes for system-level memory consumption.
 
         Returns
         -------
@@ -1496,8 +1392,8 @@ def memory_usage(self, deep=False):
         size_hint="",
         sort=textwrap.dedent(
             """\
-            sort : boolean, default False
-                Sort `uniques` and shuffle `labels` to maintain the
+            sort : bool, default False
+                Sort `uniques` and shuffle `codes` to maintain the
                 relationship.
             """
         ),
@@ -1515,6 +1411,12 @@ def factorize(self, sort=False, na_sentinel=-1):
         corresponding elements in `value` were inserted before the indices,
         the order of `self` would be preserved.
 
+        .. note::
+
+            The %(klass)s *must* be monotonically sorted, otherwise
+            wrong locations will likely be returned. Pandas does *not*
+            check this for you.
+
         Parameters
         ----------
         value : array_like
@@ -1540,6 +1442,7 @@ def factorize(self, sort=False, na_sentinel=-1):
 
         See Also
         --------
+        sort_values
         numpy.searchsorted
 
         Notes
@@ -1548,7 +1451,6 @@ def factorize(self, sort=False, na_sentinel=-1):
 
         Examples
         --------
-
         >>> x = pd.Series([1, 2, 3])
         >>> x
         0    1
@@ -1578,11 +1480,18 @@ def factorize(self, sort=False, na_sentinel=-1):
 
         >>> x.searchsorted(['bread'], side='right')
         array([3])
+
+        If the values are not monotonically sorted, wrong locations
+        may be returned:
+
+        >>> x = pd.Series([2, 1, 3])
+        >>> x.searchsorted(1)
+        0  # wrong result, correct would be 1
         """
 
     @Substitution(klass="Index")
     @Appender(_shared_docs["searchsorted"])
-    def searchsorted(self, value, side="left", sorter=None):
+    def searchsorted(self, value, side="left", sorter=None) -> np.ndarray:
         return algorithms.searchsorted(self._values, value, side=side, sorter=sorter)
 
     def drop_duplicates(self, keep="first", inplace=False):
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 565f5076fdddb..00c7a41477017 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -5,16 +5,16 @@
 """
 
 import collections
-from collections import OrderedDict, abc
+from collections import abc
 from datetime import datetime, timedelta
 from functools import partial
 import inspect
-from typing import Any, Iterable, Union
+from typing import Any, Collection, Iterable, Union
 
 import numpy as np
 
 from pandas._libs import lib, tslibs
-from pandas.compat import PY36
+from pandas._typing import T
 
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
 from pandas.core.dtypes.common import (
@@ -72,18 +72,12 @@ def consensus_name_attr(objs):
     return name
 
 
-def maybe_box(indexer, values, obj, key):
-
-    # if we have multiples coming back, box em
-    if isinstance(values, np.ndarray):
-        return obj[indexer.get_loc(key)]
-
-    # return the value
-    return values
-
-
-def maybe_box_datetimelike(value):
+def maybe_box_datetimelike(value, dtype=None):
     # turn a datetime like into a Timestamp/timedelta as needed
+    if dtype == object:
+        # If we dont have datetime64/timedelta64 dtype, we dont want to
+        #  box datetimelike scalars
+        return value
 
     if isinstance(value, (np.datetime64, datetime)):
         value = tslibs.Timestamp(value)
@@ -111,14 +105,20 @@ def is_bool_indexer(key: Any) -> bool:
     Returns
     -------
     bool
+        Whether `key` is a valid boolean indexer.
 
     Raises
     ------
     ValueError
         When the array is an object-dtype ndarray or ExtensionArray
         and contains missing values.
+
+    See Also
+    --------
+    check_array_indexer : Check that `key` is a valid array to index,
+        and convert to an ndarray.
     """
-    na_msg = "cannot index with vector containing NA / NaN values"
+    na_msg = "cannot mask with array containing NA / NaN values"
     if isinstance(key, (ABCSeries, np.ndarray, ABCIndex)) or (
         is_array_like(key) and is_extension_array_dtype(key.dtype)
     ):
@@ -160,7 +160,7 @@ def cast_scalar_indexer(val):
     outval : scalar
     """
     # assumes lib.is_scalar(val)
-    if lib.is_float(val) and val == int(val):
+    if lib.is_float(val) and val.is_integer():
         return int(val)
     return val
 
@@ -172,35 +172,35 @@ def not_none(*args):
     return (arg for arg in args if arg is not None)
 
 
-def any_none(*args):
+def any_none(*args) -> bool:
     """
     Returns a boolean indicating if any argument is None.
     """
     return any(arg is None for arg in args)
 
 
-def all_none(*args):
+def all_none(*args) -> bool:
     """
     Returns a boolean indicating if all arguments are None.
     """
     return all(arg is None for arg in args)
 
 
-def any_not_none(*args):
+def any_not_none(*args) -> bool:
     """
     Returns a boolean indicating if any argument is not None.
     """
     return any(arg is not None for arg in args)
 
 
-def all_not_none(*args):
+def all_not_none(*args) -> bool:
     """
     Returns a boolean indicating if all arguments are not None.
     """
     return all(arg is not None for arg in args)
 
 
-def count_not_none(*args):
+def count_not_none(*args) -> int:
     """
     Returns the count of arguments that are not None.
     """
@@ -215,16 +215,6 @@ def try_sort(iterable):
         return listed
 
 
-def dict_keys_to_ordered_list(mapping):
-    # when pandas drops support for Python < 3.6, this function
-    # can be replaced by a simple list(mapping.keys())
-    if PY36 or isinstance(mapping, OrderedDict):
-        keys = list(mapping.keys())
-    else:
-        keys = try_sort(mapping)
-    return keys
-
-
 def asarray_tuplesafe(values, dtype=None):
 
     if not (isinstance(values, (list, tuple)) or hasattr(values, "__array__")):
@@ -281,7 +271,7 @@ def maybe_make_list(obj):
     return obj
 
 
-def maybe_iterable_to_list(obj: Union[Iterable, Any]) -> Union[list, Any]:
+def maybe_iterable_to_list(obj: Union[Iterable[T], T]) -> Union[Collection[T], T]:
     """
     If obj is Iterable but not list-like, consume into list.
     """
@@ -290,7 +280,7 @@ def maybe_iterable_to_list(obj: Union[Iterable, Any]) -> Union[list, Any]:
     return obj
 
 
-def is_null_slice(obj):
+def is_null_slice(obj) -> bool:
     """
     We have a null slice.
     """
@@ -310,7 +300,7 @@ def is_true_slices(l):
 
 
 # TODO: used only once in indexing; belongs elsewhere?
-def is_full_slice(obj, l):
+def is_full_slice(obj, l) -> bool:
     """
     We have a full length slice.
     """
@@ -328,7 +318,7 @@ def get_callable_name(obj):
         return get_callable_name(obj.func)
     # fall back to class name
     if hasattr(obj, "__call__"):
-        return obj.__class__.__name__
+        return type(obj).__name__
     # everything failed (probably because the argument
     # wasn't actually callable); we return None
     # instead of the empty string in this case to allow
@@ -399,7 +389,7 @@ def standardize_mapping(into):
             return partial(collections.defaultdict, into.default_factory)
         into = type(into)
     if not issubclass(into, abc.Mapping):
-        raise TypeError("unsupported type: {into}".format(into=into))
+        raise TypeError(f"unsupported type: {into}")
     elif into == collections.defaultdict:
         raise TypeError("to_dict() only accepts initialized defaultdicts")
     return into
@@ -462,7 +452,7 @@ def pipe(obj, func, *args, **kwargs):
     if isinstance(func, tuple):
         func, target = func
         if target in kwargs:
-            msg = "%s is both the pipe target and a keyword argument" % target
+            msg = f"{target} is both the pipe target and a keyword argument"
             raise ValueError(msg)
         kwargs[target] = obj
         return func(*args, **kwargs)
diff --git a/pandas/core/computation/align.py b/pandas/core/computation/align.py
index 3e1e5ed89d877..e45d3ca66b6ec 100644
--- a/pandas/core/computation/align.py
+++ b/pandas/core/computation/align.py
@@ -1,40 +1,51 @@
-"""Core eval alignment algorithms
+"""
+Core eval alignment algorithms.
 """
 
 from functools import partial, wraps
+from typing import Dict, Optional, Sequence, Tuple, Type, Union
 import warnings
 
 import numpy as np
 
+from pandas._typing import FrameOrSeries
 from pandas.errors import PerformanceWarning
 
-import pandas as pd
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+
 from pandas.core.base import PandasObject
 import pandas.core.common as com
-from pandas.core.computation.common import _result_type_many
+from pandas.core.computation.common import result_type_many
+
 
+def _align_core_single_unary_op(
+    term,
+) -> Tuple[Union[partial, Type[FrameOrSeries]], Optional[Dict[str, int]]]:
+
+    typ: Union[partial, Type[FrameOrSeries]]
+    axes: Optional[Dict[str, int]] = None
 
-def _align_core_single_unary_op(term):
     if isinstance(term.value, np.ndarray):
         typ = partial(np.asanyarray, dtype=term.value.dtype)
     else:
         typ = type(term.value)
-    ret = (typ,)
+        if hasattr(term.value, "axes"):
+            axes = _zip_axes_from_type(typ, term.value.axes)
 
-    if not hasattr(term.value, "axes"):
-        ret += (None,)
-    else:
-        ret += (_zip_axes_from_type(typ, term.value.axes),)
-    return ret
+    return typ, axes
 
 
-def _zip_axes_from_type(typ, new_axes):
-    axes = {ax_name: new_axes[ax_ind] for ax_ind, ax_name in typ._AXIS_NAMES.items()}
+def _zip_axes_from_type(
+    typ: Type[FrameOrSeries], new_axes: Sequence[int]
+) -> Dict[str, int]:
+    axes = {name: new_axes[i] for i, name in typ._AXIS_NAMES.items()}
     return axes
 
 
-def _any_pandas_objects(terms):
-    """Check a sequence of terms for instances of PandasObject."""
+def _any_pandas_objects(terms) -> bool:
+    """
+    Check a sequence of terms for instances of PandasObject.
+    """
     return any(isinstance(term.value, PandasObject) for term in terms)
 
 
@@ -49,7 +60,7 @@ def wrapper(terms):
 
         # we don't have any pandas objects
         if not _any_pandas_objects(terms):
-            return _result_type_many(*term_values), None
+            return result_type_many(*term_values), None
 
         return f(terms)
 
@@ -60,7 +71,10 @@ def wrapper(terms):
 def _align_core(terms):
     term_index = [i for i, term in enumerate(terms) if hasattr(term.value, "axes")]
     term_dims = [terms[i].value.ndim for i in term_index]
-    ndims = pd.Series(dict(zip(term_index, term_dims)))
+
+    from pandas import Series
+
+    ndims = Series(dict(zip(term_index, term_dims)))
 
     # initial axes are the axes of the largest-axis'd term
     biggest = terms[ndims.idxmax()].value
@@ -70,7 +84,7 @@ def _align_core(terms):
     gt_than_one_axis = naxes > 1
 
     for value in (terms[i].value for i in term_index):
-        is_series = isinstance(value, pd.Series)
+        is_series = isinstance(value, ABCSeries)
         is_series_and_gt_one_axis = is_series and gt_than_one_axis
 
         for axis, items in enumerate(value.axes):
@@ -87,7 +101,7 @@ def _align_core(terms):
             ti = terms[i].value
 
             if hasattr(ti, "reindex"):
-                transpose = isinstance(ti, pd.Series) and naxes > 1
+                transpose = isinstance(ti, ABCSeries) and naxes > 1
                 reindexer = axes[naxes - 1] if transpose else items
 
                 term_axis_size = len(ti.axes[axis])
@@ -96,10 +110,10 @@ def _align_core(terms):
                 ordm = np.log10(max(1, abs(reindexer_size - term_axis_size)))
                 if ordm >= 1 and reindexer_size >= 10000:
                     w = (
-                        "Alignment difference on axis {axis} is larger "
-                        "than an order of magnitude on term {term!r}, by "
-                        "more than {ordm:.4g}; performance may suffer"
-                    ).format(axis=axis, term=terms[i].name, ordm=ordm)
+                        f"Alignment difference on axis {axis} is larger "
+                        f"than an order of magnitude on term {repr(terms[i].name)}, "
+                        f"by more than {ordm:.4g}; performance may suffer"
+                    )
                     warnings.warn(w, category=PerformanceWarning, stacklevel=6)
 
                 f = partial(ti.reindex, reindexer, axis=axis, copy=False)
@@ -111,28 +125,30 @@ def _align_core(terms):
     return typ, _zip_axes_from_type(typ, axes)
 
 
-def _align(terms):
-    """Align a set of terms"""
+def align_terms(terms):
+    """
+    Align a set of terms.
+    """
     try:
         # flatten the parse tree (a nested list, really)
         terms = list(com.flatten(terms))
     except TypeError:
         # can't iterate so it must just be a constant or single variable
-        if isinstance(terms.value, pd.core.generic.NDFrame):
+        if isinstance(terms.value, (ABCSeries, ABCDataFrame)):
             typ = type(terms.value)
             return typ, _zip_axes_from_type(typ, terms.value.axes)
         return np.result_type(terms.type), None
 
     # if all resolved variables are numeric scalars
     if all(term.is_scalar for term in terms):
-        return _result_type_many(*(term.value for term in terms)).type, None
+        return result_type_many(*(term.value for term in terms)).type, None
 
     # perform the main alignment
     typ, axes = _align_core(terms)
     return typ, axes
 
 
-def _reconstruct_object(typ, obj, axes, dtype):
+def reconstruct_object(typ, obj, axes, dtype):
     """
     Reconstruct an object given its type, raw value, and possibly empty
     (None) axes.
diff --git a/pandas/core/computation/common.py b/pandas/core/computation/common.py
index bd32c8bee1cdf..19a8898a2987c 100644
--- a/pandas/core/computation/common.py
+++ b/pandas/core/computation/common.py
@@ -4,20 +4,21 @@
 
 from pandas._config import get_option
 
-# A token value Python's tokenizer probably will never use.
-_BACKTICK_QUOTED_STRING = 100
-
 
 def _ensure_decoded(s):
-    """ if we have bytes, decode them to unicode """
+    """
+    If we have bytes, decode them to unicode.
+    """
     if isinstance(s, (np.bytes_, bytes)):
         s = s.decode(get_option("display.encoding"))
     return s
 
 
-def _result_type_many(*arrays_and_dtypes):
-    """ wrapper around numpy.result_type which overcomes the NPY_MAXARGS (32)
-    argument limit """
+def result_type_many(*arrays_and_dtypes):
+    """
+    Wrapper around numpy.result_type which overcomes the NPY_MAXARGS (32)
+    argument limit.
+    """
     try:
         return np.result_type(*arrays_and_dtypes)
     except ValueError:
@@ -25,14 +26,5 @@ def _result_type_many(*arrays_and_dtypes):
         return reduce(np.result_type, arrays_and_dtypes)
 
 
-def _remove_spaces_column_name(name):
-    """Check if name contains any spaces, if it contains any spaces
-    the spaces will be removed and an underscore suffix is added."""
-    if not isinstance(name, str) or " " not in name:
-        return name
-
-    return name.replace(" ", "_") + "_BACKTICK_QUOTED_STRING"
-
-
 class NameResolutionError(NameError):
     pass
diff --git a/pandas/core/computation/engines.py b/pandas/core/computation/engines.py
index 3cc34ea1f4ed7..9c5388faae1bd 100644
--- a/pandas/core/computation/engines.py
+++ b/pandas/core/computation/engines.py
@@ -3,9 +3,10 @@
 """
 
 import abc
+from typing import Dict, Type
 
-from pandas.core.computation.align import _align, _reconstruct_object
-from pandas.core.computation.ops import UndefinedVariableError, _mathops, _reductions
+from pandas.core.computation.align import align_terms, reconstruct_object
+from pandas.core.computation.ops import _mathops, _reductions
 
 import pandas.io.formats.printing as printing
 
@@ -29,10 +30,9 @@ def _check_ne_builtin_clash(expr):
     overlap = names & _ne_builtins
 
     if overlap:
-        s = ", ".join(map(repr, overlap))
+        s = ", ".join(repr(x) for x in overlap)
         raise NumExprClobberingError(
-            'Variables in expression "{expr}" '
-            "overlap with builtins: ({s})".format(expr=expr, s=s)
+            f'Variables in expression "{expr}" overlap with builtins: ({s})'
         )
 
 
@@ -46,14 +46,15 @@ def __init__(self, expr):
         self.aligned_axes = None
         self.result_type = None
 
-    def convert(self):
-        """Convert an expression for evaluation.
+    def convert(self) -> str:
+        """
+        Convert an expression for evaluation.
 
         Defaults to return the expression as a string.
         """
         return printing.pprint_thing(self.expr)
 
-    def evaluate(self):
+    def evaluate(self) -> object:
         """
         Run the engine on the expression.
 
@@ -62,20 +63,20 @@ def evaluate(self):
 
         Returns
         -------
-        obj : object
+        object
             The result of the passed expression.
         """
         if not self._is_aligned:
-            self.result_type, self.aligned_axes = _align(self.expr.terms)
+            self.result_type, self.aligned_axes = align_terms(self.expr.terms)
 
         # make sure no names in resolvers and locals/globals clash
         res = self._evaluate()
-        return _reconstruct_object(
+        return reconstruct_object(
             self.result_type, res, self.aligned_axes, self.expr.terms.return_type
         )
 
     @property
-    def _is_aligned(self):
+    def _is_aligned(self) -> bool:
         return self.aligned_axes is not None and self.result_type is not None
 
     @abc.abstractmethod
@@ -101,31 +102,16 @@ class NumExprEngine(AbstractEngine):
 
     has_neg_frac = True
 
-    def __init__(self, expr):
-        super().__init__(expr)
-
-    def convert(self):
-        return str(super().convert())
-
     def _evaluate(self):
         import numexpr as ne
 
         # convert the expression to a valid numexpr expression
         s = self.convert()
 
-        try:
-            env = self.expr.env
-            scope = env.full_scope
-            truediv = scope["truediv"]
-            _check_ne_builtin_clash(self.expr)
-            return ne.evaluate(s, local_dict=scope, truediv=truediv)
-        except KeyError as e:
-            # python 3 compat kludge
-            try:
-                msg = e.message
-            except AttributeError:
-                msg = str(e)
-            raise UndefinedVariableError(msg)
+        env = self.expr.env
+        scope = env.full_scope
+        _check_ne_builtin_clash(self.expr)
+        return ne.evaluate(s, local_dict=scope)
 
 
 class PythonEngine(AbstractEngine):
@@ -137,14 +123,14 @@ class PythonEngine(AbstractEngine):
 
     has_neg_frac = False
 
-    def __init__(self, expr):
-        super().__init__(expr)
-
     def evaluate(self):
         return self.expr()
 
-    def _evaluate(self):
+    def _evaluate(self) -> None:
         pass
 
 
-_engines = {"numexpr": NumExprEngine, "python": PythonEngine}
+_engines: Dict[str, Type[AbstractEngine]] = {
+    "numexpr": NumExprEngine,
+    "python": PythonEngine,
+}
diff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py
index 8614230c4811f..4cdf4bac61316 100644
--- a/pandas/core/computation/eval.py
+++ b/pandas/core/computation/eval.py
@@ -1,52 +1,53 @@
-#!/usr/bin/env python
-
+#!/usr/bin/env python3
 """
 Top level ``eval`` module.
 """
 
 import tokenize
+from typing import Optional
 import warnings
 
+from pandas._libs.lib import no_default
 from pandas.util._validators import validate_bool_kwarg
 
 from pandas.core.computation.engines import _engines
-from pandas.core.computation.scope import _ensure_scope
+from pandas.core.computation.expr import Expr, _parsers
+from pandas.core.computation.parsing import tokenize_string
+from pandas.core.computation.scope import ensure_scope
 
 from pandas.io.formats.printing import pprint_thing
 
 
-def _check_engine(engine):
+def _check_engine(engine: Optional[str]) -> str:
     """
     Make sure a valid engine is passed.
 
     Parameters
     ----------
     engine : str
+        String to validate.
 
     Raises
     ------
     KeyError
-      * If an invalid engine is passed
+      * If an invalid engine is passed.
     ImportError
-      * If numexpr was requested but doesn't exist
+      * If numexpr was requested but doesn't exist.
 
     Returns
     -------
-    string engine
+    str
+        Engine name.
     """
     from pandas.core.computation.check import _NUMEXPR_INSTALLED
 
     if engine is None:
-        if _NUMEXPR_INSTALLED:
-            engine = "numexpr"
-        else:
-            engine = "python"
+        engine = "numexpr" if _NUMEXPR_INSTALLED else "python"
 
     if engine not in _engines:
-        valid = list(_engines.keys())
+        valid_engines = list(_engines.keys())
         raise KeyError(
-            "Invalid engine {engine!r} passed, valid engines are"
-            " {valid}".format(engine=engine, valid=valid)
+            f"Invalid engine '{engine}' passed, valid engines are {valid_engines}"
         )
 
     # TODO: validate this in a more general way (thinking of future engines
@@ -55,16 +56,14 @@ def _check_engine(engine):
     if engine == "numexpr":
         if not _NUMEXPR_INSTALLED:
             raise ImportError(
-                "'numexpr' is not installed or an "
-                "unsupported version. Cannot use "
-                "engine='numexpr' for query/eval "
-                "if 'numexpr' is not installed"
+                "'numexpr' is not installed or an unsupported version. Cannot use "
+                "engine='numexpr' for query/eval if 'numexpr' is not installed"
             )
 
     return engine
 
 
-def _check_parser(parser):
+def _check_parser(parser: str):
     """
     Make sure a valid parser is passed.
 
@@ -77,12 +76,9 @@ def _check_parser(parser):
     KeyError
       * If an invalid parser is passed
     """
-    from pandas.core.computation.expr import _parsers
-
     if parser not in _parsers:
         raise KeyError(
-            "Invalid parser {parser!r} passed, valid parsers are"
-            " {valid}".format(parser=parser, valid=_parsers.keys())
+            f"Invalid parser '{parser}' passed, valid parsers are {_parsers.keys()}"
         )
 
 
@@ -92,8 +88,8 @@ def _check_resolvers(resolvers):
             if not hasattr(resolver, "__getitem__"):
                 name = type(resolver).__name__
                 raise TypeError(
-                    "Resolver of type {name!r} does not implement "
-                    "the __getitem__ method".format(name=name)
+                    f"Resolver of type '{name}' does not "
+                    "implement the __getitem__ method"
                 )
 
 
@@ -115,11 +111,11 @@ def _check_expression(expr):
         raise ValueError("expr cannot be an empty string")
 
 
-def _convert_expression(expr):
+def _convert_expression(expr) -> str:
     """
     Convert an object to an expression.
 
-    Thus function converts an object to an expression (a unicode string) and
+    This function converts an object to an expression (a unicode string) and
     checks to make sure it isn't empty after conversion. This is used to
     convert operators to their string representation for recursive calls to
     :func:`~pandas.eval`.
@@ -131,7 +127,7 @@ def _convert_expression(expr):
 
     Returns
     -------
-    s : unicode
+    str
         The string representation of an object.
 
     Raises
@@ -144,8 +140,7 @@ def _convert_expression(expr):
     return s
 
 
-def _check_for_locals(expr, stack_level, parser):
-    from pandas.core.computation.expr import tokenize_string
+def _check_for_locals(expr: str, stack_level: int, parser: str):
 
     at_top_of_stack = stack_level == 0
     not_pandas_parser = parser != "pandas"
@@ -154,10 +149,8 @@ def _check_for_locals(expr, stack_level, parser):
         msg = "The '@' prefix is only supported by the pandas parser"
     elif at_top_of_stack:
         msg = (
-            "The '@' prefix is not allowed in "
-            "top-level eval calls, \nplease refer to "
-            "your variables by name without the '@' "
-            "prefix"
+            "The '@' prefix is not allowed in top-level eval calls.\n"
+            "please refer to your variables by name without the '@' prefix."
         )
 
     if at_top_of_stack or not_pandas_parser:
@@ -169,8 +162,8 @@ def _check_for_locals(expr, stack_level, parser):
 def eval(
     expr,
     parser="pandas",
-    engine=None,
-    truediv=True,
+    engine: Optional[str] = None,
+    truediv=no_default,
     local_dict=None,
     global_dict=None,
     resolvers=(),
@@ -192,20 +185,20 @@ def eval(
 
     Parameters
     ----------
-    expr : str or unicode
+    expr : str
         The expression to evaluate. This string cannot contain any Python
         `statements
         <https://docs.python.org/3/reference/simple_stmts.html#simple-statements>`__,
         only Python `expressions
         <https://docs.python.org/3/reference/simple_stmts.html#expression-statements>`__.
-    parser : string, default 'pandas', {'pandas', 'python'}
+    parser : {'pandas', 'python'}, default 'pandas'
         The parser to use to construct the syntax tree from the expression. The
         default of ``'pandas'`` parses code slightly different than standard
         Python. Alternatively, you can parse an expression using the
         ``'python'`` parser to retain strict Python semantics.  See the
         :ref:`enhancing performance <enhancingperf.eval>` documentation for
         more details.
-    engine : string or None, default 'numexpr', {'python', 'numexpr'}
+    engine : {'python', 'numexpr'}, default 'numexpr'
 
         The engine used to evaluate the expression. Supported engines are
 
@@ -219,7 +212,9 @@ def eval(
         More backends may be available in the future.
 
     truediv : bool, optional
-        Whether to use true division, like in Python >= 3
+        Whether to use true division, like in Python >= 3.
+        deprecated:: 1.0.0
+
     local_dict : dict or None, optional
         A dictionary of local variables, taken from locals() by default.
     global_dict : dict or None, optional
@@ -282,10 +277,18 @@ def eval(
     See the :ref:`enhancing performance <enhancingperf.eval>` documentation for
     more details.
     """
-    from pandas.core.computation.expr import Expr
-
     inplace = validate_bool_kwarg(inplace, "inplace")
 
+    if truediv is not no_default:
+        warnings.warn(
+            (
+                "The `truediv` parameter in pd.eval is deprecated and "
+                "will be removed in a future version."
+            ),
+            FutureWarning,
+            stacklevel=2,
+        )
+
     if isinstance(expr, str):
         _check_expression(expr)
         exprs = [e.strip() for e in expr.splitlines() if e.strip() != ""]
@@ -298,6 +301,9 @@ def eval(
             "multi-line expressions are only valid in the "
             "context of data, use DataFrame.eval"
         )
+    engine = _check_engine(engine)
+    _check_parser(parser)
+    _check_resolvers(resolvers)
 
     ret = None
     first_expr = True
@@ -305,13 +311,10 @@ def eval(
 
     for expr in exprs:
         expr = _convert_expression(expr)
-        engine = _check_engine(engine)
-        _check_parser(parser)
-        _check_resolvers(resolvers)
         _check_for_locals(expr, level, parser)
 
         # get our (possibly passed-in) scope
-        env = _ensure_scope(
+        env = ensure_scope(
             level + 1,
             global_dict=global_dict,
             local_dict=local_dict,
@@ -319,7 +322,7 @@ def eval(
             target=target,
         )
 
-        parsed_expr = Expr(expr, engine=engine, parser=parser, env=env, truediv=truediv)
+        parsed_expr = Expr(expr, engine=engine, parser=parser, env=env)
 
         # construct the engine and evaluate the parsed expression
         eng = _engines[engine]
@@ -329,8 +332,8 @@ def eval(
         if parsed_expr.assigner is None:
             if multi_line:
                 raise ValueError(
-                    "Multi-line expressions are only valid"
-                    " if all expressions contain an assignment"
+                    "Multi-line expressions are only valid "
+                    "if all expressions contain an assignment"
                 )
             elif inplace:
                 raise ValueError("Cannot operate inplace if there is no assignment")
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 45319a4d63d94..c26208d3b4465 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -1,22 +1,16 @@
-""":func:`~pandas.eval` parsers
+"""
+:func:`~pandas.eval` parsers.
 """
 
 import ast
 from functools import partial, reduce
-from io import StringIO
-import itertools as it
-import operator
+from keyword import iskeyword
 import tokenize
-from typing import Type
+from typing import Callable, Optional, Set, Tuple, Type, TypeVar
 
 import numpy as np
 
-import pandas as pd
-from pandas.core import common as com
-from pandas.core.computation.common import (
-    _BACKTICK_QUOTED_STRING,
-    _remove_spaces_column_name,
-)
+import pandas.core.common as com
 from pandas.core.computation.ops import (
     _LOCAL_TAG,
     BinOp,
@@ -35,40 +29,15 @@
     _unary_ops_syms,
     is_term,
 )
+from pandas.core.computation.parsing import clean_backtick_quoted_toks, tokenize_string
 from pandas.core.computation.scope import Scope
 
 import pandas.io.formats.printing as printing
 
 
-def tokenize_string(source):
-    """
-    Tokenize a Python source code string.
-
-    Parameters
-    ----------
-    source : str
-        A Python source code string
+def _rewrite_assign(tok: Tuple[int, str]) -> Tuple[int, str]:
     """
-    line_reader = StringIO(source).readline
-    token_generator = tokenize.generate_tokens(line_reader)
-
-    # Loop over all tokens till a backtick (`) is found.
-    # Then, take all tokens till the next backtick to form a backtick quoted
-    # string.
-    for toknum, tokval, _, _, _ in token_generator:
-        if tokval == "`":
-            tokval = " ".join(
-                it.takewhile(
-                    lambda tokval: tokval != "`",
-                    map(operator.itemgetter(1), token_generator),
-                )
-            )
-            toknum = _BACKTICK_QUOTED_STRING
-        yield toknum, tokval
-
-
-def _rewrite_assign(tok):
-    """Rewrite the assignment operator for PyTables expressions that use ``=``
+    Rewrite the assignment operator for PyTables expressions that use ``=``
     as a substitute for ``==``.
 
     Parameters
@@ -78,15 +47,16 @@ def _rewrite_assign(tok):
 
     Returns
     -------
-    t : tuple of int, str
+    tuple of int, str
         Either the input or token or the replacement values
     """
     toknum, tokval = tok
     return toknum, "==" if tokval == "=" else tokval
 
 
-def _replace_booleans(tok):
-    """Replace ``&`` with ``and`` and ``|`` with ``or`` so that bitwise
+def _replace_booleans(tok: Tuple[int, str]) -> Tuple[int, str]:
+    """
+    Replace ``&`` with ``and`` and ``|`` with ``or`` so that bitwise
     precedence is changed to boolean precedence.
 
     Parameters
@@ -96,7 +66,7 @@ def _replace_booleans(tok):
 
     Returns
     -------
-    t : tuple of int, str
+    tuple of int, str
         Either the input or token or the replacement values
     """
     toknum, tokval = tok
@@ -109,8 +79,9 @@ def _replace_booleans(tok):
     return toknum, tokval
 
 
-def _replace_locals(tok):
-    """Replace local variables with a syntactically valid name.
+def _replace_locals(tok: Tuple[int, str]) -> Tuple[int, str]:
+    """
+    Replace local variables with a syntactically valid name.
 
     Parameters
     ----------
@@ -119,7 +90,7 @@ def _replace_locals(tok):
 
     Returns
     -------
-    t : tuple of int, str
+    tuple of int, str
         Either the input or token or the replacement values
 
     Notes
@@ -134,52 +105,29 @@ def _replace_locals(tok):
     return toknum, tokval
 
 
-def _clean_spaces_backtick_quoted_names(tok):
-    """Clean up a column name if surrounded by backticks.
-
-    Backtick quoted string are indicated by a certain tokval value. If a string
-    is a backtick quoted token it will processed by
-    :func:`_remove_spaces_column_name` so that the parser can find this
-    string when the query is executed.
-    See also :meth:`NDFrame._get_space_character_free_column_resolver`.
-
-    Parameters
-    ----------
-    tok : tuple of int, str
-        ints correspond to the all caps constants in the tokenize module
-
-    Returns
-    -------
-    t : tuple of int, str
-        Either the input or token or the replacement values
-    """
-    toknum, tokval = tok
-    if toknum == _BACKTICK_QUOTED_STRING:
-        return tokenize.NAME, _remove_spaces_column_name(tokval)
-    return toknum, tokval
-
-
 def _compose2(f, g):
-    """Compose 2 callables"""
+    """
+    Compose 2 callables.
+    """
     return lambda *args, **kwargs: f(g(*args, **kwargs))
 
 
 def _compose(*funcs):
-    """Compose 2 or more callables"""
+    """
+    Compose 2 or more callables.
+    """
     assert len(funcs) > 1, "At least 2 callables must be passed to compose"
     return reduce(_compose2, funcs)
 
 
 def _preparse(
-    source,
+    source: str,
     f=_compose(
-        _replace_locals,
-        _replace_booleans,
-        _rewrite_assign,
-        _clean_spaces_backtick_quoted_names,
+        _replace_locals, _replace_booleans, _rewrite_assign, clean_backtick_quoted_toks
     ),
-):
-    """Compose a collection of tokenization functions
+) -> str:
+    """
+    Compose a collection of tokenization functions.
 
     Parameters
     ----------
@@ -193,7 +141,7 @@ def _preparse(
 
     Returns
     -------
-    s : str
+    str
         Valid Python source code
 
     Notes
@@ -207,7 +155,9 @@ def _preparse(
 
 
 def _is_type(t):
-    """Factory for a type checking function of type ``t`` or tuple of types."""
+    """
+    Factory for a type checking function of type ``t`` or tuple of types.
+    """
     return lambda x: isinstance(x.value, t)
 
 
@@ -225,7 +175,9 @@ def _is_type(t):
 
 
 def _filter_nodes(superclass, all_nodes=_all_nodes):
-    """Filter out AST nodes that are subclasses of ``superclass``."""
+    """
+    Filter out AST nodes that are subclasses of ``superclass``.
+    """
     node_names = (node.__name__ for node in all_nodes if issubclass(node, superclass))
     return frozenset(node_names)
 
@@ -283,39 +235,41 @@ def _filter_nodes(superclass, all_nodes=_all_nodes):
 # and we don't want `stmt` and friends in their so get only the class whose
 # names are capitalized
 _base_supported_nodes = (_all_node_names - _unsupported_nodes) | _hacked_nodes
-_msg = "cannot both support and not support {intersection}".format(
-    intersection=_unsupported_nodes & _base_supported_nodes
-)
-assert not _unsupported_nodes & _base_supported_nodes, _msg
+intersection = _unsupported_nodes & _base_supported_nodes
+_msg = f"cannot both support and not support {intersection}"
+assert not intersection, _msg
 
 
-def _node_not_implemented(node_name, cls):
-    """Return a function that raises a NotImplementedError with a passed node
-    name.
+# TODO: Python 3.6.2: replace Callable[..., None] with Callable[..., NoReturn]
+def _node_not_implemented(node_name: str) -> Callable[..., None]:
+    """
+    Return a function that raises a NotImplementedError with a passed node name.
     """
 
     def f(self, *args, **kwargs):
-        raise NotImplementedError(
-            "{name!r} nodes are not implemented".format(name=node_name)
-        )
+        raise NotImplementedError(f"'{node_name}' nodes are not implemented")
 
     return f
 
 
-def disallow(nodes):
-    """Decorator to disallow certain nodes from parsing. Raises a
+_T = TypeVar("_T", bound="BaseExprVisitor")
+
+
+def disallow(nodes: Set[str]) -> Callable[[Type[_T]], Type[_T]]:
+    """
+    Decorator to disallow certain nodes from parsing. Raises a
     NotImplementedError instead.
 
     Returns
     -------
-    disallowed : callable
+    callable
     """
 
-    def disallowed(cls):
+    def disallowed(cls: Type[_T]) -> Type[_T]:
         cls.unsupported_nodes = ()
         for node in nodes:
-            new_method = _node_not_implemented(node, cls)
-            name = "visit_{node}".format(node=node)
+            new_method = _node_not_implemented(node)
+            name = f"visit_{node}"
             cls.unsupported_nodes += (name,)
             setattr(cls, name, new_method)
         return cls
@@ -324,20 +278,21 @@ def disallowed(cls):
 
 
 def _op_maker(op_class, op_symbol):
-    """Return a function to create an op class with its symbol already passed.
+    """
+    Return a function to create an op class with its symbol already passed.
 
     Returns
     -------
-    f : callable
+    callable
     """
 
     def f(self, node, *args, **kwargs):
-        """Return a partial function with an Op subclass with an operator
-        already passed.
+        """
+        Return a partial function with an Op subclass with an operator already passed.
 
         Returns
         -------
-        f : callable
+        callable
         """
         return partial(op_class, op_symbol, *args, **kwargs)
 
@@ -348,17 +303,19 @@ def f(self, node, *args, **kwargs):
 
 
 def add_ops(op_classes):
-    """Decorator to add default implementation of ops."""
+    """
+    Decorator to add default implementation of ops.
+    """
 
     def f(cls):
         for op_attr_name, op_class in op_classes.items():
-            ops = getattr(cls, "{name}_ops".format(name=op_attr_name))
-            ops_map = getattr(cls, "{name}_op_nodes_map".format(name=op_attr_name))
+            ops = getattr(cls, f"{op_attr_name}_ops")
+            ops_map = getattr(cls, f"{op_attr_name}_op_nodes_map")
             for op in ops:
                 op_node = ops_map[op]
                 if op_node is not None:
                     made_op = _op_maker(op_class, op)
-                    setattr(cls, "visit_{node}".format(node=op_node), made_op)
+                    setattr(cls, f"visit_{op_node}", made_op)
         return cls
 
     return f
@@ -379,7 +336,7 @@ class BaseExprVisitor(ast.NodeVisitor):
     preparser : callable
     """
 
-    const_type = Constant  # type: Type[Term]
+    const_type: Type[Term] = Constant
     term_type = Term
 
     binary_ops = _cmp_ops_syms + _bool_ops_syms + _arith_ops_syms
@@ -417,6 +374,8 @@ class BaseExprVisitor(ast.NodeVisitor):
         ast.NotIn: ast.NotIn,
     }
 
+    unsupported_nodes: Tuple[str, ...]
+
     def __init__(self, env, engine, parser, preparser=_preparse):
         self.env = env
         self.engine = engine
@@ -430,13 +389,11 @@ def visit(self, node, **kwargs):
             try:
                 node = ast.fix_missing_locations(ast.parse(clean))
             except SyntaxError as e:
-                from keyword import iskeyword
-
                 if any(iskeyword(x) for x in clean.split()):
                     e.msg = "Python keyword not valid identifier in numexpr query"
                 raise e
 
-        method = "visit_" + node.__class__.__name__
+        method = "visit_" + type(node).__name__
         visitor = getattr(self, method)
         return visitor(node, **kwargs)
 
@@ -532,8 +489,8 @@ def _maybe_evaluate_binop(
 
         if res.has_invalid_return_type:
             raise TypeError(
-                "unsupported operand type(s) for {op}:"
-                " '{lhs}' and '{rhs}'".format(op=res.op, lhs=lhs.type, rhs=rhs.type)
+                f"unsupported operand type(s) for {res.op}: "
+                f"'{lhs.type}' and '{rhs.type}'"
             )
 
         if self.engine != "pytables":
@@ -565,8 +522,7 @@ def visit_BinOp(self, node, **kwargs):
         return self._maybe_evaluate_binop(op, op_class, left, right)
 
     def visit_Div(self, node, **kwargs):
-        truediv = self.env.scope["truediv"]
-        return lambda lhs, rhs: Div(lhs, rhs, truediv)
+        return lambda lhs, rhs: Div(lhs, rhs)
 
     def visit_UnaryOp(self, node, **kwargs):
         op = self.visit(node.op)
@@ -600,6 +556,8 @@ def visit_Index(self, node, **kwargs):
         return self.visit(node.value)
 
     def visit_Subscript(self, node, **kwargs):
+        import pandas as pd
+
         value = self.visit(node.value)
         slobj = self.visit(node.slice)
         result = pd.eval(
@@ -679,7 +637,7 @@ def visit_Attribute(self, node, **kwargs):
                 if isinstance(value, ast.Name) and value.id == attr:
                     return resolved
 
-        raise ValueError("Invalid Attribute context {name}".format(name=ctx.__name__))
+        raise ValueError(f"Invalid Attribute context {ctx.__name__}")
 
     def visit_Call(self, node, side=None, **kwargs):
 
@@ -699,7 +657,7 @@ def visit_Call(self, node, side=None, **kwargs):
                     raise
 
         if res is None:
-            raise ValueError("Invalid function call {func}".format(func=node.func.id))
+            raise ValueError(f"Invalid function call {node.func.id}")
         if hasattr(res, "value"):
             res = res.value
 
@@ -709,11 +667,10 @@ def visit_Call(self, node, side=None, **kwargs):
 
             if node.keywords:
                 raise TypeError(
-                    'Function "{name}" does not support keyword '
-                    "arguments".format(name=res.name)
+                    f'Function "{res.name}" does not support keyword arguments'
                 )
 
-            return res(*new_args, **kwargs)
+            return res(*new_args)
 
         else:
 
@@ -721,10 +678,7 @@ def visit_Call(self, node, side=None, **kwargs):
 
             for key in node.keywords:
                 if not isinstance(key, ast.keyword):
-                    raise ValueError(
-                        "keyword error in function call "
-                        "'{func}'".format(func=node.func.id)
-                    )
+                    raise ValueError(f"keyword error in function call '{node.func.id}'")
 
                 if key.arg:
                     kwargs[key.arg] = self.visit(key.value).value
@@ -788,9 +742,7 @@ def __init__(
         parser,
         preparser=partial(
             _preparse,
-            f=_compose(
-                _replace_locals, _replace_booleans, _clean_spaces_backtick_quoted_names
-            ),
+            f=_compose(_replace_locals, _replace_booleans, clean_backtick_quoted_toks),
         ),
     ):
         super().__init__(env, engine, parser, preparser)
@@ -812,18 +764,25 @@ class Expr:
     engine : str, optional, default 'numexpr'
     parser : str, optional, default 'pandas'
     env : Scope, optional, default None
-    truediv : bool, optional, default True
     level : int, optional, default 2
     """
 
+    env: Scope
+    engine: str
+    parser: str
+
     def __init__(
-        self, expr, engine="numexpr", parser="pandas", env=None, truediv=True, level=0
+        self,
+        expr,
+        engine: str = "numexpr",
+        parser: str = "pandas",
+        env: Optional[Scope] = None,
+        level: int = 0,
     ):
         self.expr = expr
         self.env = env or Scope(level=level + 1)
         self.engine = engine
         self.parser = parser
-        self.env.scope["truediv"] = truediv
         self._visitor = _parsers[parser](self.env, self.engine, self.parser)
         self.terms = self.parse()
 
@@ -834,19 +793,23 @@ def assigner(self):
     def __call__(self):
         return self.terms(self.env)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return printing.pprint_thing(self.terms)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.expr)
 
     def parse(self):
-        """Parse an expression"""
+        """
+        Parse an expression.
+        """
         return self._visitor.visit(self.expr)
 
     @property
     def names(self):
-        """Get the names in an expression"""
+        """
+        Get the names in an expression.
+        """
         if is_term(self.terms):
             return frozenset([self.terms.name])
         return frozenset(term.name for term in com.flatten(self.terms))
diff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py
index 90bb12b4cd727..fdc299ccdfde8 100644
--- a/pandas/core/computation/expressions.py
+++ b/pandas/core/computation/expressions.py
@@ -12,8 +12,6 @@
 
 from pandas._config import get_option
 
-from pandas._libs.lib import values_from_object
-
 from pandas.core.dtypes.generic import ABCDataFrame
 
 from pandas.core.computation.check import _NUMEXPR_INSTALLED
@@ -45,12 +43,9 @@ def set_use_numexpr(v=True):
 
     # choose what we are going to do
     global _evaluate, _where
-    if not _USE_NUMEXPR:
-        _evaluate = _evaluate_standard
-        _where = _where_standard
-    else:
-        _evaluate = _evaluate_numexpr
-        _where = _where_numexpr
+
+    _evaluate = _evaluate_numexpr if _USE_NUMEXPR else _evaluate_standard
+    _where = _where_numexpr if _USE_NUMEXPR else _where_standard
 
 
 def set_numexpr_threads(n=None):
@@ -62,9 +57,10 @@ def set_numexpr_threads(n=None):
         ne.set_num_threads(n)
 
 
-def _evaluate_standard(op, op_str, a, b, reversed=False):
-    """ standard evaluation """
-    # `reversed` kwarg is included for compatibility with _evaluate_numexpr
+def _evaluate_standard(op, op_str, a, b):
+    """
+    Standard evaluation.
+    """
     if _TEST_MODE:
         _store_test_result(False)
     with np.errstate(all="ignore"):
@@ -97,25 +93,23 @@ def _can_use_numexpr(op, op_str, a, b, dtype_check):
     return False
 
 
-def _evaluate_numexpr(op, op_str, a, b, reversed=False):
+def _evaluate_numexpr(op, op_str, a, b):
     result = None
 
     if _can_use_numexpr(op, op_str, a, b, "evaluate"):
-        if reversed:
+        is_reversed = op.__name__.strip("_").startswith("r")
+        if is_reversed:
             # we were originally called by a reversed op method
             a, b = b, a
 
         a_value = getattr(a, "values", a)
         b_value = getattr(b, "values", b)
-        try:
-            result = ne.evaluate(
-                "a_value {op} b_value".format(op=op_str),
-                local_dict={"a_value": a_value, "b_value": b_value},
-                casting="safe",
-            )
-        except ValueError as detail:
-            if "unknown type object" in str(detail):
-                pass
+
+        result = ne.evaluate(
+            f"a_value {op_str} b_value",
+            local_dict={"a_value": a_value, "b_value": b_value},
+            casting="safe",
+        )
 
     if _TEST_MODE:
         _store_test_result(result is not None)
@@ -127,34 +121,21 @@ def _evaluate_numexpr(op, op_str, a, b, reversed=False):
 
 
 def _where_standard(cond, a, b):
-    return np.where(
-        values_from_object(cond), values_from_object(a), values_from_object(b)
-    )
+    # Caller is responsible for calling values_from_object if necessary
+    return np.where(cond, a, b)
 
 
 def _where_numexpr(cond, a, b):
+    # Caller is responsible for calling values_from_object if necessary
     result = None
 
     if _can_use_numexpr(None, "where", a, b, "where"):
-        cond_value = getattr(cond, "values", cond)
-        a_value = getattr(a, "values", a)
-        b_value = getattr(b, "values", b)
 
-        try:
-            result = ne.evaluate(
-                "where(cond_value, a_value, b_value)",
-                local_dict={
-                    "cond_value": cond_value,
-                    "a_value": a_value,
-                    "b_value": b_value,
-                },
-                casting="safe",
-            )
-        except ValueError as detail:
-            if "unknown type object" in str(detail):
-                pass
-        except Exception as detail:
-            raise TypeError(str(detail))
+        result = ne.evaluate(
+            "where(cond_value, a_value, b_value)",
+            local_dict={"cond_value": cond, "a_value": a, "b_value": b},
+            casting="safe",
+        )
 
     if result is None:
         result = _where_standard(cond, a, b)
@@ -167,11 +148,10 @@ def _where_numexpr(cond, a, b):
 
 
 def _has_bool_dtype(x):
+    if isinstance(x, ABCDataFrame):
+        return "bool" in x.dtypes
     try:
-        if isinstance(x, ABCDataFrame):
-            return "bool" in x.dtypes
-        else:
-            return x.dtype == bool
+        return x.dtype == bool
     except AttributeError:
         return isinstance(x, (bool, np.bool_))
 
@@ -185,22 +165,20 @@ def _bool_arith_check(
     if _has_bool_dtype(a) and _has_bool_dtype(b):
         if op_str in unsupported:
             warnings.warn(
-                "evaluating in Python space because the {op!r} "
+                f"evaluating in Python space because the {repr(op_str)} "
                 "operator is not supported by numexpr for "
-                "the bool dtype, use {alt_op!r} instead".format(
-                    op=op_str, alt_op=unsupported[op_str]
-                )
+                f"the bool dtype, use {repr(unsupported[op_str])} instead"
             )
             return False
 
         if op_str in not_allowed:
             raise NotImplementedError(
-                "operator {op!r} not implemented for bool dtypes".format(op=op_str)
+                f"operator {repr(op_str)} not implemented for bool dtypes"
             )
     return True
 
 
-def evaluate(op, op_str, a, b, use_numexpr=True, reversed=False):
+def evaluate(op, op_str, a, b, use_numexpr=True):
     """
     Evaluate and return the expression of the op on a and b.
 
@@ -213,12 +191,10 @@ def evaluate(op, op_str, a, b, use_numexpr=True, reversed=False):
     b : right operand
     use_numexpr : bool, default True
         Whether to try to use numexpr.
-    reversed : bool, default False
     """
-
     use_numexpr = use_numexpr and _bool_arith_check(op_str, a, b)
     if use_numexpr:
-        return _evaluate(op, op_str, a, b, reversed=reversed)
+        return _evaluate(op, op_str, a, b)
     return _evaluate_standard(op, op_str, a, b)
 
 
@@ -234,10 +210,7 @@ def where(cond, a, b, use_numexpr=True):
     use_numexpr : bool, default True
         Whether to try to use numexpr.
     """
-
-    if use_numexpr:
-        return _where(cond, a, b)
-    return _where_standard(cond, a, b)
+    return _where(cond, a, b) if use_numexpr else _where_standard(cond, a, b)
 
 
 def set_test_mode(v=True):
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 28b6aef693bfe..5563d3ae27118 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -4,7 +4,8 @@
 from datetime import datetime
 from distutils.version import LooseVersion
 from functools import partial
-import operator as op
+import operator
+from typing import Callable, Iterable, Optional, Union
 
 import numpy as np
 
@@ -13,12 +14,12 @@
 from pandas.core.dtypes.common import is_list_like, is_scalar
 
 import pandas.core.common as com
-from pandas.core.computation.common import _ensure_decoded, _result_type_many
+from pandas.core.computation.common import _ensure_decoded, result_type_many
 from pandas.core.computation.scope import _DEFAULT_GLOBALS
 
 from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
 
-_reductions = "sum", "prod"
+_reductions = ("sum", "prod")
 
 _unary_math_ops = (
     "sin",
@@ -55,12 +56,13 @@ class UndefinedVariableError(NameError):
     NameError subclass for local variables.
     """
 
-    def __init__(self, name, is_local):
+    def __init__(self, name: str, is_local: Optional[bool] = None):
+        base_msg = f"{repr(name)} is not defined"
         if is_local:
-            msg = "local variable {0!r} is not defined"
+            msg = f"local variable {base_msg}"
         else:
-            msg = "name {0!r} is not defined"
-        super().__init__(msg.format(name))
+            msg = f"name {base_msg}"
+        super().__init__(msg)
 
 
 class Term:
@@ -69,7 +71,10 @@ def __new__(cls, name, env, side=None, encoding=None):
         supr_new = super(Term, klass).__new__
         return supr_new(klass)
 
+    is_local: bool
+
     def __init__(self, name, env, side=None, encoding=None):
+        # name is a str for Term, but may be something else for subclasses
         self._name = name
         self.env = env
         self.side = side
@@ -79,10 +84,10 @@ def __init__(self, name, env, side=None, encoding=None):
         self.encoding = encoding
 
     @property
-    def local_name(self):
+    def local_name(self) -> str:
         return self.name.replace(_LOCAL_TAG, "")
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return pprint_thing(self.name)
 
     def __call__(self, *args, **kwargs):
@@ -120,7 +125,7 @@ def update(self, value):
         self.value = value
 
     @property
-    def is_scalar(self):
+    def is_scalar(self) -> bool:
         return is_scalar(self._value)
 
     @property
@@ -139,14 +144,11 @@ def type(self):
     return_type = type
 
     @property
-    def raw(self):
-        return pprint_thing(
-            "{0}(name={1!r}, type={2})"
-            "".format(self.__class__.__name__, self.name, self.type)
-        )
+    def raw(self) -> str:
+        return f"{type(self).__name__}(name={repr(self.name)}, type={self.type})"
 
     @property
-    def is_datetime(self):
+    def is_datetime(self) -> bool:
         try:
             t = self.type.type
         except AttributeError:
@@ -167,7 +169,7 @@ def name(self):
         return self._name
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         return self._value.ndim
 
 
@@ -182,7 +184,7 @@ def _resolve_name(self):
     def name(self):
         return self.value
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # in python 2 str() of float
         # can truncate shorter than repr()
         return repr(self.name)
@@ -196,31 +198,33 @@ class Op:
     Hold an operator of arbitrary arity.
     """
 
-    def __init__(self, op, operands, *args, **kwargs):
+    op: str
+
+    def __init__(self, op: str, operands: Iterable[Union[Term, "Op"]], encoding=None):
         self.op = _bool_op_map.get(op, op)
         self.operands = operands
-        self.encoding = kwargs.get("encoding", None)
+        self.encoding = encoding
 
     def __iter__(self):
         return iter(self.operands)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Print a generic n-ary operator and its operands using infix notation.
         """
         # recurse over the operands
-        parened = ("({0})".format(pprint_thing(opr)) for opr in self.operands)
-        return pprint_thing(" {0} ".format(self.op).join(parened))
+        parened = (f"({pprint_thing(opr)})" for opr in self.operands)
+        return pprint_thing(f" {self.op} ".join(parened))
 
     @property
     def return_type(self):
         # clobber types to bool if the op is a boolean operator
         if self.op in (_cmp_ops_syms + _bool_ops_syms):
             return np.bool_
-        return _result_type_many(*(term.type for term in com.flatten(self)))
+        return result_type_many(*(term.type for term in com.flatten(self)))
 
     @property
-    def has_invalid_return_type(self):
+    def has_invalid_return_type(self) -> bool:
         types = self.operand_types
         obj_dtype_set = frozenset([np.dtype("object")])
         return self.return_type == object and types - obj_dtype_set
@@ -230,11 +234,11 @@ def operand_types(self):
         return frozenset(term.type for term in com.flatten(self))
 
     @property
-    def is_scalar(self):
+    def is_scalar(self) -> bool:
         return all(operand.is_scalar for operand in self.operands)
 
     @property
-    def is_datetime(self):
+    def is_datetime(self) -> bool:
         try:
             t = self.return_type.type
         except AttributeError:
@@ -273,20 +277,37 @@ def _not_in(x, y):
         return x not in y
 
 
-_cmp_ops_syms = ">", "<", ">=", "<=", "==", "!=", "in", "not in"
-_cmp_ops_funcs = op.gt, op.lt, op.ge, op.le, op.eq, op.ne, _in, _not_in
+_cmp_ops_syms = (">", "<", ">=", "<=", "==", "!=", "in", "not in")
+_cmp_ops_funcs = (
+    operator.gt,
+    operator.lt,
+    operator.ge,
+    operator.le,
+    operator.eq,
+    operator.ne,
+    _in,
+    _not_in,
+)
 _cmp_ops_dict = dict(zip(_cmp_ops_syms, _cmp_ops_funcs))
 
-_bool_ops_syms = "&", "|", "and", "or"
-_bool_ops_funcs = op.and_, op.or_, op.and_, op.or_
+_bool_ops_syms = ("&", "|", "and", "or")
+_bool_ops_funcs = (operator.and_, operator.or_, operator.and_, operator.or_)
 _bool_ops_dict = dict(zip(_bool_ops_syms, _bool_ops_funcs))
 
-_arith_ops_syms = "+", "-", "*", "/", "**", "//", "%"
-_arith_ops_funcs = (op.add, op.sub, op.mul, op.truediv, op.pow, op.floordiv, op.mod)
+_arith_ops_syms = ("+", "-", "*", "/", "**", "//", "%")
+_arith_ops_funcs = (
+    operator.add,
+    operator.sub,
+    operator.mul,
+    operator.truediv,
+    operator.pow,
+    operator.floordiv,
+    operator.mod,
+)
 _arith_ops_dict = dict(zip(_arith_ops_syms, _arith_ops_funcs))
 
-_special_case_arith_ops_syms = "**", "//", "%"
-_special_case_arith_ops_funcs = op.pow, op.floordiv, op.mod
+_special_case_arith_ops_syms = ("**", "//", "%")
+_special_case_arith_ops_funcs = (operator.pow, operator.floordiv, operator.mod)
 _special_case_arith_ops_dict = dict(
     zip(_special_case_arith_ops_syms, _special_case_arith_ops_funcs)
 )
@@ -322,7 +343,7 @@ def _cast_inplace(terms, acceptable_dtypes, dtype):
         term.update(new_value)
 
 
-def is_term(obj):
+def is_term(obj) -> bool:
     return isinstance(obj, Term)
 
 
@@ -333,11 +354,11 @@ class BinOp(Op):
     Parameters
     ----------
     op : str
-    left : Term or Op
-    right : Term or Op
+    lhs : Term or Op
+    rhs : Term or Op
     """
 
-    def __init__(self, op, lhs, rhs, **kwargs):
+    def __init__(self, op: str, lhs, rhs):
         super().__init__(op, (lhs, rhs))
         self.lhs = lhs
         self.rhs = rhs
@@ -352,8 +373,7 @@ def __init__(self, op, lhs, rhs, **kwargs):
             # has to be made a list for python3
             keys = list(_binary_ops_dict.keys())
             raise ValueError(
-                "Invalid binary operator {0!r}, valid"
-                " operators are {1}".format(op, keys)
+                f"Invalid binary operator {repr(op)}, valid operators are {keys}"
             )
 
     def __call__(self, env):
@@ -369,17 +389,13 @@ def __call__(self, env):
         object
             The result of an evaluated expression.
         """
-        # handle truediv
-        if self.op == "/" and env.scope["truediv"]:
-            self.func = op.truediv
-
         # recurse over the left/right nodes
         left = self.lhs(env)
         right = self.rhs(env)
 
         return self.func(left, right)
 
-    def evaluate(self, env, engine, parser, term_type, eval_in_python):
+    def evaluate(self, env, engine: str, parser, term_type, eval_in_python):
         """
         Evaluate a binary operation *before* being passed to the engine.
 
@@ -400,6 +416,7 @@ def evaluate(self, env, engine, parser, term_type, eval_in_python):
             res = self(env)
         else:
             # recurse over the left/right nodes
+
             left = self.lhs.evaluate(
                 env,
                 engine=engine,
@@ -407,6 +424,7 @@ def evaluate(self, env, engine, parser, term_type, eval_in_python):
                 term_type=term_type,
                 eval_in_python=eval_in_python,
             )
+
             right = self.rhs.evaluate(
                 env,
                 engine=engine,
@@ -431,6 +449,7 @@ def convert_values(self):
         """
 
         def stringify(value):
+            encoder: Callable
             if self.encoding is not None:
                 encoder = partial(pprint_thing_encoded, encoding=self.encoding)
             else:
@@ -471,7 +490,7 @@ def _disallow_scalar_only_bool_ops(self):
             raise NotImplementedError("cannot evaluate scalar only bool ops")
 
 
-def isnumeric(dtype):
+def isnumeric(dtype) -> bool:
     return issubclass(np.dtype(dtype).type, np.number)
 
 
@@ -483,18 +502,15 @@ class Div(BinOp):
     ----------
     lhs, rhs : Term or Op
         The Terms or Ops in the ``/`` expression.
-    truediv : bool
-        Whether or not to use true division. With Python 3 this happens
-        regardless of the value of ``truediv``.
     """
 
-    def __init__(self, lhs, rhs, truediv, *args, **kwargs):
-        super().__init__("/", lhs, rhs, *args, **kwargs)
+    def __init__(self, lhs, rhs):
+        super().__init__("/", lhs, rhs)
 
         if not isnumeric(lhs.return_type) or not isnumeric(rhs.return_type):
             raise TypeError(
-                "unsupported operand type(s) for {0}:"
-                " '{1}' and '{2}'".format(self.op, lhs.return_type, rhs.return_type)
+                f"unsupported operand type(s) for {self.op}: "
+                f"'{lhs.return_type}' and '{rhs.return_type}'"
             )
 
         # do not upcast float32s to float64 un-necessarily
@@ -502,8 +518,8 @@ def __init__(self, lhs, rhs, truediv, *args, **kwargs):
         _cast_inplace(com.flatten(self), acceptable_dtypes, np.float_)
 
 
-_unary_ops_syms = "+", "-", "~", "not"
-_unary_ops_funcs = op.pos, op.neg, op.invert, op.invert
+_unary_ops_syms = ("+", "-", "~", "not")
+_unary_ops_funcs = (operator.pos, operator.neg, operator.invert, operator.invert)
 _unary_ops_dict = dict(zip(_unary_ops_syms, _unary_ops_funcs))
 
 
@@ -524,7 +540,7 @@ class UnaryOp(Op):
         * If no function associated with the passed operator token is found.
     """
 
-    def __init__(self, op, operand):
+    def __init__(self, op: str, operand):
         super().__init__(op, (operand,))
         self.operand = operand
 
@@ -532,19 +548,19 @@ def __init__(self, op, operand):
             self.func = _unary_ops_dict[op]
         except KeyError:
             raise ValueError(
-                "Invalid unary operator {0!r}, valid operators "
-                "are {1}".format(op, _unary_ops_syms)
+                f"Invalid unary operator {repr(op)}, "
+                f"valid operators are {_unary_ops_syms}"
             )
 
     def __call__(self, env):
         operand = self.operand(env)
         return self.func(operand)
 
-    def __repr__(self):
-        return pprint_thing("{0}({1})".format(self.op, self.operand))
+    def __repr__(self) -> str:
+        return pprint_thing(f"{self.op}({self.operand})")
 
     @property
-    def return_type(self):
+    def return_type(self) -> np.dtype:
         operand = self.operand
         if operand.return_type == np.dtype("bool"):
             return np.dtype("bool")
@@ -565,13 +581,13 @@ def __call__(self, env):
         with np.errstate(all="ignore"):
             return self.func.func(*operands)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         operands = map(str, self.operands)
-        return pprint_thing("{0}({1})".format(self.op, ",".join(operands)))
+        return pprint_thing(f"{self.op}({','.join(operands)})")
 
 
 class FuncNode:
-    def __init__(self, name):
+    def __init__(self, name: str):
         from pandas.core.computation.check import _NUMEXPR_INSTALLED, _NUMEXPR_VERSION
 
         if name not in _mathops or (
@@ -579,7 +595,7 @@ def __init__(self, name):
             and _NUMEXPR_VERSION < LooseVersion("2.6.9")
             and name in ("floor", "ceil")
         ):
-            raise ValueError('"{0}" is not a supported function'.format(name))
+            raise ValueError(f'"{name}" is not a supported function')
 
         self.name = name
         self.func = getattr(np, name)
diff --git a/pandas/core/computation/parsing.py b/pandas/core/computation/parsing.py
new file mode 100644
index 0000000000000..ce213c8532834
--- /dev/null
+++ b/pandas/core/computation/parsing.py
@@ -0,0 +1,190 @@
+""":func:`~pandas.eval` source string parsing functions
+"""
+
+from io import StringIO
+from keyword import iskeyword
+import token
+import tokenize
+from typing import Iterator, Tuple
+
+# A token value Python's tokenizer probably will never use.
+BACKTICK_QUOTED_STRING = 100
+
+
+def create_valid_python_identifier(name: str) -> str:
+    """
+    Create valid Python identifiers from any string.
+
+    Check if name contains any special characters. If it contains any
+    special characters, the special characters will be replaced by
+    a special string and a prefix is added.
+
+    Raises
+    ------
+    SyntaxError
+        If the returned name is not a Python valid identifier, raise an exception.
+        This can happen if there is a hashtag in the name, as the tokenizer will
+        than terminate and not find the backtick.
+        But also for characters that fall out of the range of (U+0001..U+007F).
+    """
+    if name.isidentifier() and not iskeyword(name):
+        return name
+
+    # Create a dict with the special characters and their replacement string.
+    # EXACT_TOKEN_TYPES contains these special characters
+    # toke.tok_name contains a readable description of the replacement string.
+    special_characters_replacements = {
+        char: f"_{token.tok_name[tokval]}_"
+        # The ignore here is because of a bug in mypy that is resolved in 0.740
+        for char, tokval in tokenize.EXACT_TOKEN_TYPES.items()  # type: ignore
+    }
+    special_characters_replacements.update(
+        {
+            " ": "_",
+            "?": "_QUESTIONMARK_",
+            "!": "_EXCLAMATIONMARK_",
+            "$": "_DOLLARSIGN_",
+            "€": "_EUROSIGN_",
+            # Including quotes works, but there are exceptions.
+            "'": "_SINGLEQUOTE_",
+            '"': "_DOUBLEQUOTE_",
+            # Currently not possible. Terminates parser and won't find backtick.
+            # "#": "_HASH_",
+        }
+    )
+
+    name = "".join(special_characters_replacements.get(char, char) for char in name)
+    name = "BACKTICK_QUOTED_STRING_" + name
+
+    if not name.isidentifier():
+        raise SyntaxError(f"Could not convert '{name}' to a valid Python identifier.")
+
+    return name
+
+
+def clean_backtick_quoted_toks(tok: Tuple[int, str]) -> Tuple[int, str]:
+    """
+    Clean up a column name if surrounded by backticks.
+
+    Backtick quoted string are indicated by a certain tokval value. If a string
+    is a backtick quoted token it will processed by
+    :func:`_create_valid_python_identifier` so that the parser can find this
+    string when the query is executed.
+    In this case the tok will get the NAME tokval.
+
+    Parameters
+    ----------
+    tok : tuple of int, str
+        ints correspond to the all caps constants in the tokenize module
+
+    Returns
+    -------
+    tok : Tuple[int, str]
+        Either the input or token or the replacement values
+    """
+    toknum, tokval = tok
+    if toknum == BACKTICK_QUOTED_STRING:
+        return tokenize.NAME, create_valid_python_identifier(tokval)
+    return toknum, tokval
+
+
+def clean_column_name(name: str) -> str:
+    """
+    Function to emulate the cleaning of a backtick quoted name.
+
+    The purpose for this function is to see what happens to the name of
+    identifier if it goes to the process of being parsed a Python code
+    inside a backtick quoted string and than being cleaned
+    (removed of any special characters).
+
+    Parameters
+    ----------
+    name : str
+        Name to be cleaned.
+
+    Returns
+    -------
+    name : str
+        Returns the name after tokenizing and cleaning.
+
+    Notes
+    -----
+        For some cases, a name cannot be converted to a valid Python identifier.
+        In that case :func:`tokenize_string` raises a SyntaxError.
+        In that case, we just return the name unmodified.
+
+        If this name was used in the query string (this makes the query call impossible)
+        an error will be raised by :func:`tokenize_backtick_quoted_string` instead,
+        which is not catched and propogates to the user level.
+    """
+    try:
+        tokenized = tokenize_string(f"`{name}`")
+        tokval = next(tokenized)[1]
+        return create_valid_python_identifier(tokval)
+    except SyntaxError:
+        return name
+
+
+def tokenize_backtick_quoted_string(
+    token_generator: Iterator[tokenize.TokenInfo], source: str, string_start: int
+) -> Tuple[int, str]:
+    """
+    Creates a token from a backtick quoted string.
+
+    Moves the token_generator forwards till right after the next backtick.
+
+    Parameters
+    ----------
+    token_generator : Iterator[tokenize.TokenInfo]
+        The generator that yields the tokens of the source string (Tuple[int, str]).
+        The generator is at the first token after the backtick (`)
+
+    source : str
+        The Python source code string.
+
+    string_start : int
+        This is the start of backtick quoted string inside the source string.
+
+    Returns
+    -------
+    tok: Tuple[int, str]
+        The token that represents the backtick quoted string.
+        The integer is equal to BACKTICK_QUOTED_STRING (100).
+    """
+    for _, tokval, start, _, _ in token_generator:
+        if tokval == "`":
+            string_end = start[1]
+            break
+
+    return BACKTICK_QUOTED_STRING, source[string_start:string_end]
+
+
+def tokenize_string(source: str) -> Iterator[Tuple[int, str]]:
+    """
+    Tokenize a Python source code string.
+
+    Parameters
+    ----------
+    source : str
+        The Python source code string.
+
+    Returns
+    -------
+    tok_generator : Iterator[Tuple[int, str]]
+        An iterator yielding all tokens with only toknum and tokval (Tuple[ing, str]).
+    """
+    line_reader = StringIO(source).readline
+    token_generator = tokenize.generate_tokens(line_reader)
+
+    # Loop over all tokens till a backtick (`) is found.
+    # Then, take all tokens till the next backtick to form a backtick quoted string
+    for toknum, tokval, start, _, _ in token_generator:
+        if tokval == "`":
+            try:
+                yield tokenize_backtick_quoted_string(
+                    token_generator, source, string_start=start[1] + 1
+                )
+            except Exception:
+                raise SyntaxError(f"Failed to parse backticks in '{source}'.")
+        else:
+            yield toknum, tokval
diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index 81658ab23ba46..9f209cccd5be6 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -2,6 +2,7 @@
 
 import ast
 from functools import partial
+from typing import Any, Dict, Optional, Tuple
 
 import numpy as np
 
@@ -12,7 +13,7 @@
 
 import pandas as pd
 import pandas.core.common as com
-from pandas.core.computation import expr, ops
+from pandas.core.computation import expr, ops, scope as _scope
 from pandas.core.computation.common import _ensure_decoded
 from pandas.core.computation.expr import BaseExprVisitor
 from pandas.core.computation.ops import UndefinedVariableError, is_term
@@ -20,27 +21,38 @@
 from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
 
 
-class Scope(expr.Scope):
+class PyTablesScope(_scope.Scope):
     __slots__ = ("queryables",)
 
-    def __init__(self, level, global_dict=None, local_dict=None, queryables=None):
+    queryables: Dict[str, Any]
+
+    def __init__(
+        self,
+        level: int,
+        global_dict=None,
+        local_dict=None,
+        queryables: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(level + 1, global_dict=global_dict, local_dict=local_dict)
         self.queryables = queryables or dict()
 
 
 class Term(ops.Term):
+    env: PyTablesScope
+
     def __new__(cls, name, env, side=None, encoding=None):
         klass = Constant if not isinstance(name, str) else cls
         return object.__new__(klass)
 
-    def __init__(self, name, env, side=None, encoding=None):
+    def __init__(self, name, env: PyTablesScope, side=None, encoding=None):
         super().__init__(name, env, side=side, encoding=encoding)
 
     def _resolve_name(self):
         # must be a queryables
         if self.side == "left":
+            # Note: The behavior of __new__ ensures that self.name is a str here
             if self.name not in self.env.queryables:
-                raise NameError("name {name!r} is not defined".format(name=self.name))
+                raise NameError(f"name {repr(self.name)} is not defined")
             return self.name
 
         # resolve the rhs (and allow it to be None)
@@ -56,7 +68,8 @@ def value(self):
 
 
 class Constant(Term):
-    def __init__(self, value, env, side=None, encoding=None):
+    def __init__(self, value, env: PyTablesScope, side=None, encoding=None):
+        assert isinstance(env, PyTablesScope), type(env)
         super().__init__(value, env, side=side, encoding=encoding)
 
     def _resolve_name(self):
@@ -67,11 +80,13 @@ class BinOp(ops.BinOp):
 
     _max_selectors = 31
 
-    def __init__(self, op, lhs, rhs, queryables, encoding):
+    op: str
+    queryables: Dict[str, Any]
+
+    def __init__(self, op: str, lhs, rhs, queryables: Dict[str, Any], encoding):
         super().__init__(op, lhs, rhs)
         self.queryables = queryables
         self.encoding = encoding
-        self.filter = None
         self.condition = None
 
     def _disallow_scalar_only_bool_ops(self):
@@ -129,14 +144,15 @@ def conform(self, rhs):
         return rhs
 
     @property
-    def is_valid(self):
+    def is_valid(self) -> bool:
         """ return True if this is a valid field """
         return self.lhs in self.queryables
 
     @property
-    def is_in_table(self):
+    def is_in_table(self) -> bool:
         """ return True if this is a valid column name for generation (e.g. an
-        actual column in the table) """
+        actual column in the table)
+        """
         return self.queryables.get(self.lhs) is not None
 
     @property
@@ -154,14 +170,15 @@ def metadata(self):
         """ the metadata of my field """
         return getattr(self.queryables.get(self.lhs), "metadata", None)
 
-    def generate(self, v):
+    def generate(self, v) -> str:
         """ create and return the op string for this TermValue """
         val = v.tostring(self.encoding)
-        return "({lhs} {op} {val})".format(lhs=self.lhs, op=self.op, val=val)
+        return f"({self.lhs} {self.op} {val})"
 
-    def convert_value(self, v):
+    def convert_value(self, v) -> "TermValue":
         """ convert the expression that is in the term to something that is
-        accepted by pytables """
+        accepted by pytables
+        """
 
         def stringify(value):
             if self.encoding is not None:
@@ -218,21 +235,19 @@ def stringify(value):
             # string quoting
             return TermValue(v, stringify(v), "string")
         else:
-            raise TypeError(
-                "Cannot compare {v} of type {typ} to {kind} column".format(
-                    v=v, typ=type(v), kind=kind
-                )
-            )
+            raise TypeError(f"Cannot compare {v} of type {type(v)} to {kind} column")
 
     def convert_values(self):
         pass
 
 
 class FilterBinOp(BinOp):
-    def __repr__(self):
-        return pprint_thing(
-            "[Filter : [{lhs}] -> [{op}]".format(lhs=self.filter[0], op=self.filter[1])
-        )
+    filter: Optional[Tuple[Any, Any, pd.Index]] = None
+
+    def __repr__(self) -> str:
+        if self.filter is None:
+            return "Filter: Not Initialized"
+        return pprint_thing(f"[Filter : [{self.filter[0]}] -> [{self.filter[1]}]")
 
     def invert(self):
         """ invert the filter """
@@ -249,10 +264,10 @@ def format(self):
     def evaluate(self):
 
         if not self.is_valid:
-            raise ValueError("query term is not valid [{slf}]".format(slf=self))
+            raise ValueError(f"query term is not valid [{self}]")
 
         rhs = self.conform(self.rhs)
-        values = [TermValue(v, v, self.kind).value for v in rhs]
+        values = list(rhs)
 
         if self.is_in_table:
 
@@ -273,13 +288,12 @@ def evaluate(self):
 
         else:
             raise TypeError(
-                "passing a filterable condition to a non-table "
-                "indexer [{slf}]".format(slf=self)
+                f"passing a filterable condition to a non-table indexer [{self}]"
             )
 
         return self
 
-    def generate_filter_op(self, invert=False):
+    def generate_filter_op(self, invert: bool = False):
         if (self.op == "!=" and not invert) or (self.op == "==" and invert):
             return lambda axis, vals: ~axis.isin(vals)
         else:
@@ -295,8 +309,8 @@ def evaluate(self):
 
 
 class ConditionBinOp(BinOp):
-    def __repr__(self):
-        return pprint_thing("[Condition : [{cond}]]".format(cond=self.condition))
+    def __repr__(self) -> str:
+        return pprint_thing(f"[Condition : [{self.condition}]]")
 
     def invert(self):
         """ invert the condition """
@@ -314,7 +328,7 @@ def format(self):
     def evaluate(self):
 
         if not self.is_valid:
-            raise ValueError("query term is not valid [{slf}]".format(slf=self))
+            raise ValueError(f"query term is not valid [{self}]")
 
         # convert values if we are in the table
         if not self.is_in_table:
@@ -329,7 +343,7 @@ def evaluate(self):
             # too many values to create the expression?
             if len(values) <= self._max_selectors:
                 vs = [self.generate(v) for v in values]
-                self.condition = "({cond})".format(cond=" | ".join(vs))
+                self.condition = f"({' | '.join(vs)})"
 
             # use a filter after reading
             else:
@@ -342,9 +356,7 @@ def evaluate(self):
 
 class JointConditionBinOp(ConditionBinOp):
     def evaluate(self):
-        self.condition = "({lhs} {op} {rhs})".format(
-            lhs=self.lhs.condition, op=self.op, rhs=self.rhs.condition
-        )
+        self.condition = f"({self.lhs.condition} {self.op} {self.rhs.condition})"
         return self
 
 
@@ -368,10 +380,7 @@ def prune(self, klass):
         return None
 
 
-_op_classes = {"unary": UnaryOp}
-
-
-class ExprVisitor(BaseExprVisitor):
+class PyTablesExprVisitor(BaseExprVisitor):
     const_type = Constant
     term_type = Term
 
@@ -381,7 +390,7 @@ def __init__(self, env, engine, parser, **kwargs):
             bin_node = self.binary_op_nodes_map[bin_op]
             setattr(
                 self,
-                "visit_{node}".format(node=bin_node),
+                f"visit_{bin_node}",
                 lambda node, bin_op=bin_op: partial(BinOp, bin_op, **kwargs),
             )
 
@@ -415,16 +424,13 @@ def visit_Subscript(self, node, **kwargs):
         try:
             return self.const_type(value[slobj], self.env)
         except TypeError:
-            raise ValueError(
-                "cannot subscript {value!r} with "
-                "{slobj!r}".format(value=value, slobj=slobj)
-            )
+            raise ValueError(f"cannot subscript {repr(value)} with {repr(slobj)}")
 
     def visit_Attribute(self, node, **kwargs):
         attr = node.attr
         value = node.value
 
-        ctx = node.ctx.__class__
+        ctx = type(node.ctx)
         if ctx == ast.Load:
             # resolve the value
             resolved = self.visit(value)
@@ -443,7 +449,7 @@ def visit_Attribute(self, node, **kwargs):
                 if isinstance(value, ast.Name) and value.id == attr:
                     return resolved
 
-        raise ValueError("Invalid Attribute context {name}".format(name=ctx.__name__))
+        raise ValueError(f"Invalid Attribute context {ctx.__name__}")
 
     def translate_In(self, op):
         return ast.Eq() if isinstance(op, ast.In) else op
@@ -471,25 +477,29 @@ def _validate_where(w):
     TypeError : An invalid data type was passed in for w (e.g. dict).
     """
 
-    if not (isinstance(w, (Expr, str)) or is_list_like(w)):
-        raise TypeError("where must be passed as a string, Expr, or list-like of Exprs")
+    if not (isinstance(w, (PyTablesExpr, str)) or is_list_like(w)):
+        raise TypeError(
+            "where must be passed as a string, PyTablesExpr, "
+            "or list-like of PyTablesExpr"
+        )
 
     return w
 
 
-class Expr(expr.Expr):
-    """ hold a pytables like expression, comprised of possibly multiple 'terms'
+class PyTablesExpr(expr.Expr):
+    """
+    Hold a pytables-like expression, comprised of possibly multiple 'terms'.
 
     Parameters
     ----------
-    where : string term expression, Expr, or list-like of Exprs
+    where : string term expression, PyTablesExpr, or list-like of PyTablesExprs
     queryables : a "kinds" map (dict of column name -> kind), or None if column
         is non-indexable
     encoding : an encoding that will encode the query terms
 
     Returns
     -------
-    an Expr object
+    a PyTablesExpr object
 
     Examples
     --------
@@ -505,7 +515,16 @@ class Expr(expr.Expr):
     "major_axis>=20130101"
     """
 
-    def __init__(self, where, queryables=None, encoding=None, scope_level=0):
+    _visitor: Optional[PyTablesExprVisitor]
+    env: PyTablesScope
+
+    def __init__(
+        self,
+        where,
+        queryables: Optional[Dict[str, Any]] = None,
+        encoding=None,
+        scope_level: int = 0,
+    ):
 
         where = _validate_where(where)
 
@@ -516,27 +535,30 @@ def __init__(self, where, queryables=None, encoding=None, scope_level=0):
         self._visitor = None
 
         # capture the environment if needed
-        local_dict = DeepChainMap()
+        local_dict: DeepChainMap[Any, Any] = DeepChainMap()
 
-        if isinstance(where, Expr):
+        if isinstance(where, PyTablesExpr):
             local_dict = where.env.scope
-            where = where.expr
+            _where = where.expr
 
         elif isinstance(where, (list, tuple)):
+            where = list(where)
             for idx, w in enumerate(where):
-                if isinstance(w, Expr):
+                if isinstance(w, PyTablesExpr):
                     local_dict = w.env.scope
                 else:
                     w = _validate_where(w)
                     where[idx] = w
-            where = " & ".join(map("({})".format, com.flatten(where)))  # noqa
+            _where = " & ".join((f"({w})" for w in com.flatten(where)))
+        else:
+            _where = where
 
-        self.expr = where
-        self.env = Scope(scope_level + 1, local_dict=local_dict)
+        self.expr = _where
+        self.env = PyTablesScope(scope_level + 1, local_dict=local_dict)
 
         if queryables is not None and isinstance(self.expr, str):
             self.env.queryables.update(queryables)
-            self._visitor = ExprVisitor(
+            self._visitor = PyTablesExprVisitor(
                 self.env,
                 queryables=queryables,
                 parser="pytables",
@@ -545,7 +567,7 @@ def __init__(self, where, queryables=None, encoding=None, scope_level=0):
             )
             self.terms = self.parse()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self.terms is not None:
             return pprint_thing(self.terms)
         return pprint_thing(self.expr)
@@ -557,15 +579,15 @@ def evaluate(self):
             self.condition = self.terms.prune(ConditionBinOp)
         except AttributeError:
             raise ValueError(
-                "cannot process expression [{expr}], [{slf}] "
-                "is not a valid condition".format(expr=self.expr, slf=self)
+                f"cannot process expression [{self.expr}], [{self}] "
+                "is not a valid condition"
             )
         try:
             self.filter = self.terms.prune(FilterBinOp)
         except AttributeError:
             raise ValueError(
-                "cannot process expression [{expr}], [{slf}] "
-                "is not a valid filter".format(expr=self.expr, slf=self)
+                f"cannot process expression [{self.expr}], [{self}] "
+                "is not a valid filter"
             )
 
         return self.condition, self.filter
@@ -574,30 +596,30 @@ def evaluate(self):
 class TermValue:
     """ hold a term value the we use to construct a condition/filter """
 
-    def __init__(self, value, converted, kind):
+    def __init__(self, value, converted, kind: str):
+        assert isinstance(kind, str), kind
         self.value = value
         self.converted = converted
         self.kind = kind
 
-    def tostring(self, encoding):
-        """ quote the string if not encoded
-            else encode and return """
+    def tostring(self, encoding) -> str:
+        """ quote the string if not encoded else encode and return """
         if self.kind == "string":
             if encoding is not None:
-                return self.converted
-            return '"{converted}"'.format(converted=self.converted)
+                return str(self.converted)
+            return f'"{self.converted}"'
         elif self.kind == "float":
             # python 2 str(float) is not always
             # round-trippable so use repr()
             return repr(self.converted)
-        return self.converted
+        return str(self.converted)
 
 
-def maybe_expression(s):
+def maybe_expression(s) -> bool:
     """ loose checking if s is a pytables-acceptable expression """
     if not isinstance(s, str):
         return False
-    ops = ExprVisitor.binary_ops + ExprVisitor.unary_ops + ("=",)
+    ops = PyTablesExprVisitor.binary_ops + PyTablesExprVisitor.unary_ops + ("=",)
 
     # make sure we have an op at least
     return any(op in s for op in ops)
diff --git a/pandas/core/computation/scope.py b/pandas/core/computation/scope.py
index b11411eb2dc66..70dcf4defdb52 100644
--- a/pandas/core/computation/scope.py
+++ b/pandas/core/computation/scope.py
@@ -9,6 +9,7 @@
 import pprint
 import struct
 import sys
+from typing import List
 
 import numpy as np
 
@@ -16,9 +17,9 @@
 from pandas.compat.chainmap import DeepChainMap
 
 
-def _ensure_scope(
-    level, global_dict=None, local_dict=None, resolvers=(), target=None, **kwargs
-):
+def ensure_scope(
+    level: int, global_dict=None, local_dict=None, resolvers=(), target=None, **kwargs
+) -> "Scope":
     """Ensure that we are grabbing the correct scope."""
     return Scope(
         level + 1,
@@ -29,7 +30,7 @@ def _ensure_scope(
     )
 
 
-def _replacer(x):
+def _replacer(x) -> str:
     """Replace a number with its hexadecimal representation. Used to tag
     temporary variables with their calling scope's id.
     """
@@ -44,11 +45,11 @@ def _replacer(x):
     return hex(hexin)
 
 
-def _raw_hex_id(obj):
+def _raw_hex_id(obj) -> str:
     """Return the padded hexadecimal id of ``obj``."""
     # interpret as a pointer since that's what really what id returns
     packed = struct.pack("@P", id(obj))
-    return "".join(map(_replacer, packed))
+    return "".join(_replacer(x) for x in packed)
 
 
 _DEFAULT_GLOBALS = {
@@ -63,7 +64,7 @@ def _raw_hex_id(obj):
 }
 
 
-def _get_pretty_string(obj):
+def _get_pretty_string(obj) -> str:
     """
     Return a prettier version of obj.
 
@@ -74,7 +75,7 @@ def _get_pretty_string(obj):
 
     Returns
     -------
-    s : str
+    str
         Pretty print object repr
     """
     sio = StringIO()
@@ -119,7 +120,7 @@ def __init__(
             self.scope.update(local_dict.scope)
             if local_dict.target is not None:
                 self.target = local_dict.target
-            self.update(local_dict.level)
+            self._update(local_dict.level)
 
         frame = sys._getframe(self.level)
 
@@ -139,17 +140,16 @@ def __init__(
         self.resolvers = DeepChainMap(*resolvers)
         self.temps = {}
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         scope_keys = _get_pretty_string(list(self.scope.keys()))
         res_keys = _get_pretty_string(list(self.resolvers.keys()))
-        unicode_str = "{name}(scope={scope_keys}, resolvers={res_keys})"
-        return unicode_str.format(
-            name=type(self).__name__, scope_keys=scope_keys, res_keys=res_keys
-        )
+        unicode_str = f"{type(self).__name__}(scope={scope_keys}, resolvers={res_keys})"
+        return unicode_str
 
     @property
-    def has_resolvers(self):
-        """Return whether we have any extra scope.
+    def has_resolvers(self) -> bool:
+        """
+        Return whether we have any extra scope.
 
         For example, DataFrames pass Their columns as resolvers during calls to
         ``DataFrame.eval()`` and ``DataFrame.query()``.
@@ -160,7 +160,7 @@ def has_resolvers(self):
         """
         return bool(len(self.resolvers))
 
-    def resolve(self, key, is_local):
+    def resolve(self, key: str, is_local: bool):
         """
         Resolve a variable name in a possibly local context.
 
@@ -202,7 +202,7 @@ def resolve(self, key, is_local):
 
                 raise UndefinedVariableError(key, is_local)
 
-    def swapkey(self, old_key, new_key, new_value=None):
+    def swapkey(self, old_key: str, new_key: str, new_value=None):
         """
         Replace a variable name, with a potentially new value.
 
@@ -227,7 +227,7 @@ def swapkey(self, old_key, new_key, new_value=None):
                 mapping[new_key] = new_value
                 return
 
-    def _get_vars(self, stack, scopes):
+    def _get_vars(self, stack, scopes: List[str]):
         """
         Get specifically scoped variables from a list of stack frames.
 
@@ -250,13 +250,13 @@ def _get_vars(self, stack, scopes):
                 # scope after the loop
                 del frame
 
-    def update(self, level):
+    def _update(self, level: int):
         """
         Update the current scope by going back `level` levels.
 
         Parameters
         ----------
-        level : int or None, optional, default None
+        level : int
         """
         sl = level + 1
 
@@ -270,7 +270,7 @@ def update(self, level):
         finally:
             del stack[:], stack
 
-    def add_tmp(self, value):
+    def add_tmp(self, value) -> str:
         """
         Add a temporary variable to the scope.
 
@@ -281,12 +281,10 @@ def add_tmp(self, value):
 
         Returns
         -------
-        name : basestring
+        str
             The name of the temporary variable created.
         """
-        name = "{name}_{num}_{hex_id}".format(
-            name=type(value).__name__, num=self.ntemps, hex_id=_raw_hex_id(self)
-        )
+        name = f"{type(value).__name__}_{self.ntemps}_{_raw_hex_id(self)}"
 
         # add to inner most scope
         assert name not in self.temps
@@ -297,7 +295,7 @@ def add_tmp(self, value):
         return name
 
     @property
-    def ntemps(self):
+    def ntemps(self) -> int:
         """The number of temporary variables in this scope"""
         return len(self.temps)
 
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index dfc80140433f8..b0410e31c6de7 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -6,9 +6,11 @@
 module is imported, which may or may not be a problem.
 
 If you need to make sure options are available even before a certain
-module is imported, register them here rather then in the module.
+module is imported, register them here rather than in the module.
 
 """
+import warnings
+
 import pandas._config.config as cf
 from pandas._config.config import (
     is_bool,
@@ -148,10 +150,10 @@ def use_numexpr_cb(key):
 """
 
 max_colwidth_doc = """
-: int
+: int or None
     The maximum width in characters of a column in the repr of
     a pandas data structure. When the column overflows, a "..."
-    placeholder is embedded in the output.
+    placeholder is embedded in the output. A 'None' value means unlimited.
 """
 
 colheader_justify_doc = """
@@ -300,14 +302,15 @@ def table_schema_cb(key):
     _enable_data_resource_formatter(cf.get_option(key))
 
 
-def is_terminal():
+def is_terminal() -> bool:
     """
     Detect if Python is running in a terminal.
 
     Returns True if Python is running in a terminal or False if not.
     """
     try:
-        ip = get_ipython()
+        # error: Name 'get_ipython' is not defined
+        ip = get_ipython()  # type: ignore
     except NameError:  # assume standard Python interpreter in a terminal
         return True
     else:
@@ -340,7 +343,27 @@ def is_terminal():
         validator=is_instance_factory([type(None), int]),
     )
     cf.register_option("max_categories", 8, pc_max_categories_doc, validator=is_int)
-    cf.register_option("max_colwidth", 50, max_colwidth_doc, validator=is_int)
+
+    def _deprecate_negative_int_max_colwidth(key):
+        value = cf.get_option(key)
+        if value is not None and value < 0:
+            warnings.warn(
+                "Passing a negative integer is deprecated in version 1.0 and "
+                "will not be supported in future version. Instead, use None "
+                "to not limit the column width.",
+                FutureWarning,
+                stacklevel=4,
+            )
+
+    cf.register_option(
+        # FIXME: change `validator=is_nonnegative_int`
+        # in version 1.2
+        "max_colwidth",
+        50,
+        max_colwidth_doc,
+        validator=is_instance_factory([type(None), int]),
+        cb=_deprecate_negative_int_max_colwidth,
+    )
     if is_terminal():
         max_cols = 0  # automatically determine optimal number of columns
     else:
@@ -476,6 +499,7 @@ def use_inf_as_na_cb(key):
 _xlsm_options = ["xlrd", "openpyxl"]
 _xlsx_options = ["xlrd", "openpyxl"]
 _ods_options = ["odf"]
+_xlsb_options = ["pyxlsb"]
 
 
 with cf.config_prefix("io.excel.xls"):
@@ -512,6 +536,13 @@ def use_inf_as_na_cb(key):
         validator=str,
     )
 
+with cf.config_prefix("io.excel.xlsb"):
+    cf.register_option(
+        "reader",
+        "auto",
+        reader_engine_doc.format(ext="xlsb", others=", ".join(_xlsb_options)),
+        validator=str,
+    )
 
 # Set up the io.excel specific writer configuration.
 writer_engine_doc = """
@@ -597,7 +628,7 @@ def register_plotting_backend_cb(key):
 
 
 register_converter_doc = """
-: bool
+: bool or 'auto'.
     Whether to register converters with matplotlib's units registry for
     dates, times, datetimes, and Periods. Toggling to False will remove
     the converters, restoring any converters that pandas overwrote.
@@ -617,8 +648,8 @@ def register_converter_cb(key):
 with cf.config_prefix("plotting.matplotlib"):
     cf.register_option(
         "register_converters",
-        True,
+        "auto",
         register_converter_doc,
-        validator=bool,
+        validator=is_one_of_factory(["auto", True, False]),
         cb=register_converter_cb,
     )
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index 5bd2a2b69deb1..f947a1fda49f1 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -4,13 +4,14 @@
 
 These should not depend on core.internals.
 """
-from typing import Optional, Sequence, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Sequence, Union, cast
 
 import numpy as np
 import numpy.ma as ma
 
-from pandas._libs import lib, tslibs
+from pandas._libs import lib
 from pandas._libs.tslibs import IncompatibleFrequency, OutOfBoundsDatetime
+from pandas._typing import ArrayLike, Dtype
 
 from pandas.core.dtypes.cast import (
     construct_1d_arraylike_from_scalar,
@@ -27,7 +28,6 @@
     is_categorical_dtype,
     is_datetime64_ns_dtype,
     is_extension_array_dtype,
-    is_extension_type,
     is_float_dtype,
     is_integer_dtype,
     is_iterator,
@@ -36,7 +36,7 @@
     is_timedelta64_ns_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.dtypes import ExtensionDtype, registry
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype, registry
 from pandas.core.dtypes.generic import (
     ABCExtensionArray,
     ABCIndexClass,
@@ -47,6 +47,10 @@
 
 import pandas.core.common as com
 
+if TYPE_CHECKING:
+    from pandas.core.series import Series  # noqa: F401
+    from pandas.core.indexes.api import Index  # noqa: F401
+
 
 def array(
     data: Sequence[object],
@@ -95,10 +99,19 @@ def array(
         :class:`pandas.Period`         :class:`pandas.arrays.PeriodArray`
         :class:`datetime.datetime`     :class:`pandas.arrays.DatetimeArray`
         :class:`datetime.timedelta`    :class:`pandas.arrays.TimedeltaArray`
+        :class:`int`                   :class:`pandas.arrays.IntegerArray`
+        :class:`str`                   :class:`pandas.arrays.StringArray`
+        :class:`bool`                  :class:`pandas.arrays.BooleanArray`
         ============================== =====================================
 
         For all other cases, NumPy's usual inference rules will be used.
 
+        .. versionchanged:: 1.0.0
+
+           Pandas infers nullable-integer dtype for integer data,
+           string dtype for string data, and nullable-boolean dtype
+           for boolean data.
+
     copy : bool, default True
         Whether to copy the data, even if not necessary. Depending
         on the type of `data`, creating the new array may require
@@ -155,14 +168,6 @@ def array(
     ['a', 'b']
     Length: 2, dtype: str32
 
-    Or use the dedicated constructor for the array you're expecting, and
-    wrap that in a PandasArray
-
-    >>> pd.array(np.array(['a', 'b'], dtype='<U1'))
-    <PandasArray>
-    ['a', 'b']
-    Length: 2, dtype: str32
-
     Finally, Pandas has arrays that mostly overlap with NumPy
 
       * :class:`arrays.DatetimeArray`
@@ -185,20 +190,28 @@ def array(
 
     Examples
     --------
-    If a dtype is not specified, `data` is passed through to
-    :meth:`numpy.array`, and a :class:`arrays.PandasArray` is returned.
+    If a dtype is not specified, pandas will infer the best dtype from the values.
+    See the description of `dtype` for the types pandas infers for.
 
     >>> pd.array([1, 2])
-    <PandasArray>
+    <IntegerArray>
     [1, 2]
-    Length: 2, dtype: int64
+    Length: 2, dtype: Int64
 
-    Or the NumPy dtype can be specified
+    >>> pd.array([1, 2, np.nan])
+    <IntegerArray>
+    [1, 2, NaN]
+    Length: 3, dtype: Int64
 
-    >>> pd.array([1, 2], dtype=np.dtype("int32"))
-    <PandasArray>
-    [1, 2]
-    Length: 2, dtype: int32
+    >>> pd.array(["a", None, "c"])
+    <StringArray>
+    ['a', nan, 'c']
+    Length: 3, dtype: string
+
+    >>> pd.array([pd.Period('2000', freq="D"), pd.Period("2000", freq="D")])
+    <PeriodArray>
+    ['2000-01-01', '2000-01-01']
+    Length: 2, dtype: period[D]
 
     You can use the string alias for `dtype`
 
@@ -213,29 +226,24 @@ def array(
     [a, b, a]
     Categories (3, object): [a < b < c]
 
-    Because omitting the `dtype` passes the data through to NumPy,
-    a mixture of valid integers and NA will return a floating-point
-    NumPy array.
+    If pandas does not infer a dedicated extension type a
+    :class:`arrays.PandasArray` is returned.
 
-    >>> pd.array([1, 2, np.nan])
+    >>> pd.array([1.1, 2.2])
     <PandasArray>
-    [1.0,  2.0, nan]
-    Length: 3, dtype: float64
-
-    To use pandas' nullable :class:`pandas.arrays.IntegerArray`, specify
-    the dtype:
+    [1.1, 2.2]
+    Length: 2, dtype: float64
 
-    >>> pd.array([1, 2, np.nan], dtype='Int64')
-    <IntegerArray>
-    [1, 2, NaN]
-    Length: 3, dtype: Int64
-
-    Pandas will infer an ExtensionArray for some types of data:
+    As mentioned in the "Notes" section, new extension types may be added
+    in the future (by pandas or 3rd party libraries), causing the return
+    value to no longer be a :class:`arrays.PandasArray`. Specify the `dtype`
+    as a NumPy dtype if you need to ensure there's no future change in
+    behavior.
 
-    >>> pd.array([pd.Period('2000', freq="D"), pd.Period("2000", freq="D")])
-    <PeriodArray>
-    ['2000-01-01', '2000-01-01']
-    Length: 2, dtype: period[D]
+    >>> pd.array([1, 2], dtype=np.dtype("int32"))
+    <PandasArray>
+    [1, 2]
+    Length: 2, dtype: int32
 
     `data` must be 1-dimensional. A ValueError is raised when the input
     has the wrong dimensionality.
@@ -247,21 +255,26 @@ def array(
     """
     from pandas.core.arrays import (
         period_array,
+        BooleanArray,
+        IntegerArray,
         IntervalArray,
         PandasArray,
         DatetimeArray,
         TimedeltaArray,
+        StringArray,
     )
 
     if lib.is_scalar(data):
-        msg = "Cannot pass scalar '{}' to 'pandas.array'."
-        raise ValueError(msg.format(data))
+        msg = f"Cannot pass scalar '{data}' to 'pandas.array'."
+        raise ValueError(msg)
 
-    data = extract_array(data, extract_numpy=True)
-
-    if dtype is None and isinstance(data, ABCExtensionArray):
+    if dtype is None and isinstance(
+        data, (ABCSeries, ABCIndexClass, ABCExtensionArray)
+    ):
         dtype = data.dtype
 
+    data = extract_array(data, extract_numpy=True)
+
     # this returns None for not-found dtypes.
     if isinstance(dtype, str):
         dtype = registry.find(dtype) or dtype
@@ -271,11 +284,11 @@ def array(
         return cls._from_sequence(data, dtype=dtype, copy=copy)
 
     if dtype is None:
-        inferred_dtype = lib.infer_dtype(data, skipna=False)
+        inferred_dtype = lib.infer_dtype(data, skipna=True)
         if inferred_dtype == "period":
             try:
                 return period_array(data, copy=copy)
-            except tslibs.IncompatibleFrequency:
+            except IncompatibleFrequency:
                 # We may have a mixture of frequencies.
                 # We choose to return an ndarray, rather than raising.
                 pass
@@ -299,7 +312,14 @@ def array(
             # timedelta, timedelta64
             return TimedeltaArray._from_sequence(data, copy=copy)
 
-        # TODO(BooleanArray): handle this type
+        elif inferred_dtype == "string":
+            return StringArray._from_sequence(data, copy=copy)
+
+        elif inferred_dtype == "integer":
+            return IntegerArray._from_sequence(data, copy=copy)
+
+        elif inferred_dtype == "boolean":
+            return BooleanArray._from_sequence(data, copy=copy)
 
     # Pandas overrides NumPy for
     #   1. datetime64[ns]
@@ -314,7 +334,7 @@ def array(
     return result
 
 
-def extract_array(obj, extract_numpy=False):
+def extract_array(obj, extract_numpy: bool = False):
     """
     Extract the ndarray or ExtensionArray from a Series or Index.
 
@@ -365,7 +385,9 @@ def extract_array(obj, extract_numpy=False):
     return obj
 
 
-def sanitize_array(data, index, dtype=None, copy=False, raise_cast_failure=False):
+def sanitize_array(
+    data, index, dtype=None, copy: bool = False, raise_cast_failure: bool = False
+):
     """
     Sanitize input data to an ndarray, copy if specified, coerce to the
     dtype if specified.
@@ -475,24 +497,25 @@ def sanitize_array(data, index, dtype=None, copy=False, raise_cast_failure=False
 
         if is_object_dtype(subarr.dtype) and not is_object_dtype(dtype):
             inferred = lib.infer_dtype(subarr, skipna=False)
-            if inferred == "period":
-                from pandas.core.arrays import period_array
-
-                try:
-                    subarr = period_array(subarr)
-                except IncompatibleFrequency:
-                    pass
+            if inferred in {"interval", "period"}:
+                subarr = array(subarr)
 
     return subarr
 
 
-def _try_cast(arr, dtype, copy, raise_cast_failure):
+def _try_cast(
+    arr,
+    dtype: Optional[Union[np.dtype, "ExtensionDtype"]],
+    copy: bool,
+    raise_cast_failure: bool,
+):
     """
     Convert input to numpy ndarray and optionally cast to a given dtype.
 
     Parameters
     ----------
-    arr : array-like
+    arr : ndarray, list, tuple, iterator (catchall)
+        Excludes: ExtensionArray, Series, Index.
     dtype : np.dtype, ExtensionDtype or None
     copy : bool
         If False, don't copy the data if not needed.
@@ -519,7 +542,7 @@ def _try_cast(arr, dtype, copy, raise_cast_failure):
             and not (is_iterator(subarr) or isinstance(subarr, np.ndarray))
         ):
             subarr = construct_1d_object_array_from_listlike(subarr)
-        elif not is_extension_type(subarr):
+        elif not is_extension_array_dtype(subarr):
             subarr = construct_1d_ndarray_preserving_na(subarr, dtype, copy=copy)
     except OutOfBoundsDatetime:
         # in case of out of bound datetime64 -> always raise
@@ -528,11 +551,13 @@ def _try_cast(arr, dtype, copy, raise_cast_failure):
         if is_categorical_dtype(dtype):
             # We *do* allow casting to categorical, since we know
             # that Categorical is the only array type for 'category'.
+            dtype = cast(CategoricalDtype, dtype)
             subarr = dtype.construct_array_type()(
-                arr, dtype.categories, ordered=dtype._ordered
+                arr, dtype.categories, ordered=dtype.ordered
             )
         elif is_extension_array_dtype(dtype):
             # create an extension array from its dtype
+            dtype = cast(ExtensionDtype, dtype)
             array_type = dtype.construct_array_type()._from_sequence
             subarr = array_type(arr, dtype=dtype, copy=copy)
         elif dtype is not None and raise_cast_failure:
@@ -540,3 +565,62 @@ def _try_cast(arr, dtype, copy, raise_cast_failure):
         else:
             subarr = np.array(arr, dtype=object, copy=copy)
     return subarr
+
+
+def is_empty_data(data: Any) -> bool:
+    """
+    Utility to check if a Series is instantiated with empty data,
+    which does not contain dtype information.
+
+    Parameters
+    ----------
+    data : array-like, Iterable, dict, or scalar value
+        Contains data stored in Series.
+
+    Returns
+    -------
+    bool
+    """
+    is_none = data is None
+    is_list_like_without_dtype = is_list_like(data) and not hasattr(data, "dtype")
+    is_simple_empty = is_list_like_without_dtype and not data
+    return is_none or is_simple_empty
+
+
+def create_series_with_explicit_dtype(
+    data: Any = None,
+    index: Optional[Union[ArrayLike, "Index"]] = None,
+    dtype: Optional[Dtype] = None,
+    name: Optional[str] = None,
+    copy: bool = False,
+    fastpath: bool = False,
+    dtype_if_empty: Dtype = object,
+) -> "Series":
+    """
+    Helper to pass an explicit dtype when instantiating an empty Series.
+
+    This silences a DeprecationWarning described in GitHub-17261.
+
+    Parameters
+    ----------
+    data : Mirrored from Series.__init__
+    index : Mirrored from Series.__init__
+    dtype : Mirrored from Series.__init__
+    name : Mirrored from Series.__init__
+    copy : Mirrored from Series.__init__
+    fastpath : Mirrored from Series.__init__
+    dtype_if_empty : str, numpy.dtype, or ExtensionDtype
+        This dtype will be passed explicitly if an empty Series will
+        be instantiated.
+
+    Returns
+    -------
+    Series
+    """
+    from pandas.core.series import Series
+
+    if is_empty_data(data) and dtype is None:
+        dtype = dtype_if_empty
+    return Series(
+        data=data, index=index, dtype=dtype, name=name, copy=copy, fastpath=fastpath
+    )
diff --git a/pandas/core/dtypes/api.py b/pandas/core/dtypes/api.py
index 2b527e1fb5890..051affd0af1f9 100644
--- a/pandas/core/dtypes/api.py
+++ b/pandas/core/dtypes/api.py
@@ -1,6 +1,6 @@
 # flake8: noqa
 
-from .common import (
+from pandas.core.dtypes.common import (
     is_array_like,
     is_bool,
     is_bool_dtype,
@@ -12,7 +12,6 @@
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
-    is_datetimetz,
     is_dict_like,
     is_dtype_equal,
     is_extension_array_dtype,
@@ -32,7 +31,6 @@
     is_number,
     is_numeric_dtype,
     is_object_dtype,
-    is_period,
     is_period_dtype,
     is_re,
     is_re_compilable,
diff --git a/pandas/core/dtypes/base.py b/pandas/core/dtypes/base.py
index 59ef17e3d121f..618a35886a905 100644
--- a/pandas/core/dtypes/base.py
+++ b/pandas/core/dtypes/base.py
@@ -1,5 +1,8 @@
-"""Extend pandas with custom array types"""
-from typing import List, Optional, Tuple, Type
+"""
+Extend pandas with custom array types.
+"""
+
+from typing import Any, List, Optional, Tuple, Type
 
 import numpy as np
 
@@ -63,19 +66,32 @@ class property**.
        Added ``_metadata``, ``__hash__``, and changed the default definition
        of ``__eq__``.
 
+    For interaction with Apache Arrow (pyarrow), a ``__from_arrow__`` method
+    can be implemented: this method receives a pyarrow Array or ChunkedArray
+    as only argument and is expected to return the appropriate pandas
+    ExtensionArray for this dtype and the passed values::
+
+        class ExtensionDtype:
+
+            def __from_arrow__(
+                self, array: pyarrow.Array/ChunkedArray
+            ) -> ExtensionArray:
+                ...
+
     This class does not inherit from 'abc.ABCMeta' for performance reasons.
     Methods and properties required by the interface raise
     ``pandas.errors.AbstractMethodError`` and no ``register`` method is
     provided for registering virtual subclasses.
     """
 
-    _metadata = ()  # type: Tuple[str, ...]
+    _metadata: Tuple[str, ...] = ()
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
-    def __eq__(self, other):
-        """Check whether 'other' is equal to self.
+    def __eq__(self, other: Any) -> bool:
+        """
+        Check whether 'other' is equal to self.
 
         By default, 'other' is considered equal if either
 
@@ -103,10 +119,10 @@ def __eq__(self, other):
             )
         return False
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(tuple(getattr(self, attr) for attr in self._metadata))
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         return not self.__eq__(other)
 
     @property
@@ -159,7 +175,8 @@ def name(self) -> str:
 
     @property
     def names(self) -> Optional[List[str]]:
-        """Ordered list of field names, or None if there are no fields.
+        """
+        Ordered list of field names, or None if there are no fields.
 
         This is for compatibility with NumPy arrays, and may be removed in the
         future.
@@ -169,7 +186,7 @@ def names(self) -> Optional[List[str]]:
     @classmethod
     def construct_array_type(cls):
         """
-        Return the array type associated with this dtype
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -217,20 +234,25 @@ def construct_from_string(cls, string: str):
         ...     if match:
         ...         return cls(**match.groupdict())
         ...     else:
-        ...         raise TypeError("Cannot construct a '{}' from "
-        ...                         "'{}'".format(cls.__name__, string))
+        ...         raise TypeError(
+        ...             f"Cannot construct a '{cls.__name__}' from '{string}'"
+        ...         )
         """
         if not isinstance(string, str):
-            raise TypeError("Expects a string, got {}".format(type(string)))
-        if string != cls.name:
             raise TypeError(
-                "Cannot construct a '{}' from '{}'".format(cls.__name__, string)
+                f"'construct_from_string' expects a string, got {type(string)}"
             )
+        # error: Non-overlapping equality check (left operand type: "str", right
+        #  operand type: "Callable[[ExtensionDtype], str]")  [comparison-overlap]
+        assert isinstance(cls.name, str), (cls, type(cls.name))
+        if string != cls.name:
+            raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
         return cls()
 
     @classmethod
     def is_dtype(cls, dtype) -> bool:
-        """Check if we match 'dtype'.
+        """
+        Check if we match 'dtype'.
 
         Parameters
         ----------
@@ -263,10 +285,12 @@ def is_dtype(cls, dtype) -> bool:
             return False
         elif isinstance(dtype, cls):
             return True
-        try:
-            return cls.construct_from_string(dtype) is not None
-        except TypeError:
-            return False
+        if isinstance(dtype, str):
+            try:
+                return cls.construct_from_string(dtype) is not None
+            except TypeError:
+                return False
+        return False
 
     @property
     def _is_numeric(self) -> bool:
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index ac9b57dc8d342..6120bc92adbfc 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1,14 +1,25 @@
-""" routings for casting """
+"""
+Routines for casting.
+"""
 
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
 
 import numpy as np
 
 from pandas._libs import lib, tslib, tslibs
-from pandas._libs.tslibs import NaT, OutOfBoundsDatetime, Period, iNaT
+from pandas._libs.tslibs import (
+    NaT,
+    OutOfBoundsDatetime,
+    Period,
+    Timedelta,
+    Timestamp,
+    iNaT,
+)
+from pandas._libs.tslibs.timezones import tz_compare
+from pandas._typing import Dtype
 from pandas.util._validators import validate_bool_kwarg
 
-from .common import (
+from pandas.core.dtypes.common import (
     _INT64_DTYPE,
     _NS_DTYPE,
     _POSSIBLY_CAST_DTYPES,
@@ -21,21 +32,19 @@
     ensure_str,
     is_bool,
     is_bool_dtype,
-    is_categorical_dtype,
     is_complex,
     is_complex_dtype,
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
-    is_datetimelike,
     is_dtype_equal,
     is_extension_array_dtype,
-    is_extension_type,
     is_float,
     is_float_dtype,
     is_integer,
     is_integer_dtype,
+    is_numeric_dtype,
     is_object_dtype,
     is_scalar,
     is_string_dtype,
@@ -44,8 +53,13 @@
     is_unsigned_integer_dtype,
     pandas_dtype,
 )
-from .dtypes import DatetimeTZDtype, ExtensionDtype, PeriodDtype
-from .generic import (
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    ExtensionDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.generic import (
     ABCDataFrame,
     ABCDatetimeArray,
     ABCDatetimeIndex,
@@ -53,8 +67,8 @@
     ABCPeriodIndex,
     ABCSeries,
 )
-from .inference import is_list_like
-from .missing import isna, notna
+from pandas.core.dtypes.inference import is_list_like
+from pandas.core.dtypes.missing import isna, notna
 
 _int8_max = np.iinfo(np.int8).max
 _int16_max = np.iinfo(np.int16).max
@@ -75,7 +89,7 @@ def maybe_convert_platform(values):
     return values
 
 
-def is_nested_object(obj):
+def is_nested_object(obj) -> bool:
     """
     return a boolean if we have a nested object, e.g. a Series with 1 or
     more Series elements
@@ -202,7 +216,7 @@ def trans(x):
         r = result.ravel()
         arr = np.array([r[0]])
 
-        if isna(arr).any() or not np.allclose(arr, trans(arr).astype(dtype), rtol=0):
+        if isna(arr).any():
             # if we have any nulls, then we are done
             return result
 
@@ -233,7 +247,7 @@ def trans(x):
     return result
 
 
-def maybe_upcast_putmask(result, mask, other):
+def maybe_upcast_putmask(result: np.ndarray, mask: np.ndarray, other):
     """
     A safe version of putmask that potentially upcasts the result.
     The result is replaced with the first N elements of other,
@@ -246,32 +260,36 @@ def maybe_upcast_putmask(result, mask, other):
         The destination array. This will be mutated in-place if no upcasting is
         necessary.
     mask : boolean ndarray
-    other : ndarray or scalar
-        The source array or value
+    other : scalar
+        The source value.
 
     Returns
     -------
     result : ndarray
-    changed : boolean
-        Set to true if the result array was upcasted
+    changed : bool
+        Set to true if the result array was upcasted.
 
     Examples
     --------
-    >>> result, _ = maybe_upcast_putmask(np.arange(1,6),
-    np.array([False, True, False, True, True]), np.arange(21,23))
+    >>> arr = np.arange(1, 6)
+    >>> mask = np.array([False, True, False, True, True])
+    >>> result, _ = maybe_upcast_putmask(arr, mask, False)
     >>> result
-    array([1, 21, 3, 22, 21])
+    array([1, 0, 3, 0, 0])
     """
-
     if not isinstance(result, np.ndarray):
         raise ValueError("The result input must be a ndarray.")
+    if not is_scalar(other):
+        # We _could_ support non-scalar other, but until we have a compelling
+        #  use case, we assume away the possibility.
+        raise ValueError("other must be a scalar")
 
     if mask.any():
         # Two conversions for date-like dtypes that can't be done automatically
         # in np.place:
         #   NaN -> NaT
         #   integer or integer array -> date-like array
-        if is_datetimelike(result.dtype):
+        if result.dtype.kind in ["m", "M"]:
             if is_scalar(other):
                 if isna(other):
                     other = result.dtype.type("nat")
@@ -336,10 +354,30 @@ def changeit():
 
 
 def maybe_promote(dtype, fill_value=np.nan):
+    """
+    Find the minimal dtype that can hold both the given dtype and fill_value.
+
+    Parameters
+    ----------
+    dtype : np.dtype or ExtensionDtype
+    fill_value : scalar, default np.nan
+
+    Returns
+    -------
+    dtype
+        Upcasted from dtype argument if necessary.
+    fill_value
+        Upcasted from fill_value argument if necessary.
+    """
+    if not is_scalar(fill_value) and not is_object_dtype(dtype):
+        # with object dtype there is nothing to promote, and the user can
+        #  pass pretty much any weird fill_value they like
+        raise ValueError("fill_value must be a scalar")
+
     # if we passed an array here, determine the fill value by dtype
     if isinstance(fill_value, np.ndarray):
         if issubclass(fill_value.dtype.type, (np.datetime64, np.timedelta64)):
-            fill_value = iNaT
+            fill_value = fill_value.dtype.type("NaT", "ns")
         else:
 
             # we need to change to object type as our
@@ -348,37 +386,105 @@ def maybe_promote(dtype, fill_value=np.nan):
                 dtype = np.dtype(np.object_)
             fill_value = np.nan
 
+        if dtype == np.object_ or dtype.kind in ["U", "S"]:
+            # We treat string-like dtypes as object, and _always_ fill
+            #  with np.nan
+            fill_value = np.nan
+            dtype = np.dtype(np.object_)
+
     # returns tuple of (dtype, fill_value)
     if issubclass(dtype.type, np.datetime64):
-        fill_value = tslibs.Timestamp(fill_value).value
+        if isinstance(fill_value, datetime) and fill_value.tzinfo is not None:
+            # Trying to insert tzaware into tznaive, have to cast to object
+            dtype = np.dtype(np.object_)
+        elif is_integer(fill_value) or (is_float(fill_value) and not isna(fill_value)):
+            dtype = np.dtype(np.object_)
+        else:
+            try:
+                fill_value = tslibs.Timestamp(fill_value).to_datetime64()
+            except (TypeError, ValueError):
+                dtype = np.dtype(np.object_)
     elif issubclass(dtype.type, np.timedelta64):
-        fill_value = tslibs.Timedelta(fill_value).value
+        if (
+            is_integer(fill_value)
+            or (is_float(fill_value) and not np.isnan(fill_value))
+            or isinstance(fill_value, str)
+        ):
+            # TODO: What about str that can be a timedelta?
+            dtype = np.dtype(np.object_)
+        else:
+            try:
+                fv = tslibs.Timedelta(fill_value)
+            except ValueError:
+                dtype = np.dtype(np.object_)
+            else:
+                if fv is NaT:
+                    # NaT has no `to_timedelta64` method
+                    fill_value = np.timedelta64("NaT", "ns")
+                else:
+                    fill_value = fv.to_timedelta64()
     elif is_datetime64tz_dtype(dtype):
         if isna(fill_value):
             fill_value = NaT
+        elif not isinstance(fill_value, datetime):
+            dtype = np.dtype(np.object_)
+        elif fill_value.tzinfo is None:
+            dtype = np.dtype(np.object_)
+        elif not tz_compare(fill_value.tzinfo, dtype.tz):
+            # TODO: sure we want to cast here?
+            dtype = np.dtype(np.object_)
+
     elif is_extension_array_dtype(dtype) and isna(fill_value):
         fill_value = dtype.na_value
+
     elif is_float(fill_value):
         if issubclass(dtype.type, np.bool_):
-            dtype = np.object_
+            dtype = np.dtype(np.object_)
+
         elif issubclass(dtype.type, np.integer):
-            dtype = np.float64
+            dtype = np.dtype(np.float64)
+
+        elif dtype.kind == "f":
+            mst = np.min_scalar_type(fill_value)
+            if mst > dtype:
+                # e.g. mst is np.float64 and dtype is np.float32
+                dtype = mst
+
+        elif dtype.kind == "c":
+            mst = np.min_scalar_type(fill_value)
+            dtype = np.promote_types(dtype, mst)
+
     elif is_bool(fill_value):
         if not issubclass(dtype.type, np.bool_):
-            dtype = np.object_
+            dtype = np.dtype(np.object_)
+
     elif is_integer(fill_value):
         if issubclass(dtype.type, np.bool_):
-            dtype = np.object_
+            dtype = np.dtype(np.object_)
+
         elif issubclass(dtype.type, np.integer):
-            # upcast to prevent overflow
-            arr = np.asarray(fill_value)
-            if arr != arr.astype(dtype):
-                dtype = arr.dtype
+            if not np.can_cast(fill_value, dtype):
+                # upcast to prevent overflow
+                mst = np.min_scalar_type(fill_value)
+                dtype = np.promote_types(dtype, mst)
+                if dtype.kind == "f":
+                    # Case where we disagree with numpy
+                    dtype = np.dtype(np.object_)
+
     elif is_complex(fill_value):
         if issubclass(dtype.type, np.bool_):
-            dtype = np.object_
+            dtype = np.dtype(np.object_)
+
         elif issubclass(dtype.type, (np.integer, np.floating)):
-            dtype = np.complex128
+            mst = np.min_scalar_type(fill_value)
+            dtype = np.promote_types(dtype, mst)
+
+        elif dtype.kind == "c":
+            mst = np.min_scalar_type(fill_value)
+            if mst > dtype:
+                # e.g. mst is np.complex128 and dtype is np.complex64
+                dtype = mst
+
     elif fill_value is None:
         if is_float_dtype(dtype) or is_complex_dtype(dtype):
             fill_value = np.nan
@@ -386,31 +492,59 @@ def maybe_promote(dtype, fill_value=np.nan):
             dtype = np.float64
             fill_value = np.nan
         elif is_datetime_or_timedelta_dtype(dtype):
-            fill_value = iNaT
+            fill_value = dtype.type("NaT", "ns")
         else:
-            dtype = np.object_
+            dtype = np.dtype(np.object_)
             fill_value = np.nan
     else:
-        dtype = np.object_
+        dtype = np.dtype(np.object_)
 
     # in case we have a string that looked like a number
     if is_extension_array_dtype(dtype):
         pass
-    elif is_datetime64tz_dtype(dtype):
-        pass
-    elif issubclass(np.dtype(dtype).type, str):
-        dtype = np.object_
+    elif issubclass(np.dtype(dtype).type, (bytes, str)):
+        dtype = np.dtype(np.object_)
 
+    fill_value = _ensure_dtype_type(fill_value, dtype)
     return dtype, fill_value
 
 
-def infer_dtype_from(val, pandas_dtype=False):
+def _ensure_dtype_type(value, dtype):
+    """
+    Ensure that the given value is an instance of the given dtype.
+
+    e.g. if out dtype is np.complex64, we should have an instance of that
+    as opposed to a python complex object.
+
+    Parameters
+    ----------
+    value : object
+    dtype : np.dtype or ExtensionDtype
+
+    Returns
+    -------
+    object
+    """
+
+    # Start with exceptions in which we do _not_ cast to numpy types
+    if is_extension_array_dtype(dtype):
+        return value
+    elif dtype == np.object_:
+        return value
+    elif isna(value):
+        # e.g. keep np.nan rather than try to cast to np.float32(np.nan)
+        return value
+
+    return dtype.type(value)
+
+
+def infer_dtype_from(val, pandas_dtype: bool = False):
     """
-    interpret the dtype from a scalar or array. This is a convenience
-    routines to infer dtype from a scalar or an array
+    Interpret the dtype from a scalar or array.
 
     Parameters
     ----------
+    val : object
     pandas_dtype : bool, default False
         whether to infer dtype including pandas extension types.
         If False, scalar/array belongs to pandas extension types is inferred as
@@ -421,9 +555,9 @@ def infer_dtype_from(val, pandas_dtype=False):
     return infer_dtype_from_array(val, pandas_dtype=pandas_dtype)
 
 
-def infer_dtype_from_scalar(val, pandas_dtype=False):
+def infer_dtype_from_scalar(val, pandas_dtype: bool = False):
     """
-    interpret the dtype from a scalar
+    Interpret the dtype from a scalar.
 
     Parameters
     ----------
@@ -492,17 +626,20 @@ def infer_dtype_from_scalar(val, pandas_dtype=False):
         if lib.is_period(val):
             dtype = PeriodDtype(freq=val.freq)
             val = val.ordinal
+        elif lib.is_interval(val):
+            subtype = infer_dtype_from_scalar(val.left, pandas_dtype=True)[0]
+            dtype = IntervalDtype(subtype=subtype)
 
     return dtype, val
 
 
-def infer_dtype_from_array(arr, pandas_dtype=False):
+def infer_dtype_from_array(arr, pandas_dtype: bool = False):
     """
-    infer the dtype from a scalar or array
+    Infer the dtype from an array.
 
     Parameters
     ----------
-    arr : scalar or array
+    arr : array
     pandas_dtype : bool, default False
         whether to infer dtype including pandas extension types.
         If False, array belongs to pandas extension types
@@ -527,17 +664,15 @@ def infer_dtype_from_array(arr, pandas_dtype=False):
     array(['1', '1'], dtype='<U21')
 
     >>> infer_dtype_from_array([1, '1'])
-    (numpy.object_, [1, '1'])
-
+    (<class 'numpy.object_'>, [1, '1'])
     """
-
     if isinstance(arr, np.ndarray):
         return arr.dtype, arr
 
     if not is_list_like(arr):
         arr = [arr]
 
-    if pandas_dtype and is_extension_type(arr):
+    if pandas_dtype and is_extension_array_dtype(arr):
         return arr.dtype, arr
 
     elif isinstance(arr, ABCSeries):
@@ -545,7 +680,7 @@ def infer_dtype_from_array(arr, pandas_dtype=False):
 
     # don't force numpy coerce with nan's
     inferred = lib.infer_dtype(arr, skipna=False)
-    if inferred in ["string", "bytes", "unicode", "mixed", "mixed-integer"]:
+    if inferred in ["string", "bytes", "mixed", "mixed-integer"]:
         return (np.object_, arr)
 
     arr = np.asarray(arr)
@@ -553,7 +688,8 @@ def infer_dtype_from_array(arr, pandas_dtype=False):
 
 
 def maybe_infer_dtype_type(element):
-    """Try to infer an object's dtype, for use in arithmetic ops
+    """
+    Try to infer an object's dtype, for use in arithmetic ops.
 
     Uses `element.dtype` if that's available.
     Objects implementing the iterator protocol are cast to a NumPy array,
@@ -574,7 +710,7 @@ def maybe_infer_dtype_type(element):
     >>> from collections import namedtuple
     >>> Foo = namedtuple("Foo", "dtype")
     >>> maybe_infer_dtype_type(Foo(np.dtype("i8")))
-    numpy.int64
+    dtype('int64')
     """
     tipo = None
     if hasattr(element, "dtype"):
@@ -585,18 +721,24 @@ def maybe_infer_dtype_type(element):
     return tipo
 
 
-def maybe_upcast(values, fill_value=np.nan, dtype=None, copy=False):
-    """ provide explicit type promotion and coercion
+def maybe_upcast(values, fill_value=np.nan, dtype=None, copy: bool = False):
+    """
+    Provide explicit type promotion and coercion.
 
     Parameters
     ----------
-    values : the ndarray that we want to maybe upcast
+    values : ndarray or ExtensionArray
+        The array that we want to maybe upcast.
     fill_value : what we want to fill with
     dtype : if None, then use the dtype of the values, else coerce to this type
-    copy : if True always make a copy even if no upcast is required
+    copy : bool, default True
+        If True always make a copy even if no upcast is required.
     """
+    if not is_scalar(fill_value) and not is_object_dtype(values.dtype):
+        # We allow arbitrary fill values for object dtype
+        raise ValueError("fill_value must be a scalar")
 
-    if is_extension_type(values):
+    if is_extension_array_dtype(values):
         if copy:
             values = values.copy()
     else:
@@ -662,7 +804,7 @@ def conv(r, dtype):
     return [conv(r, dtype) for r, dtype in zip(result, dtypes)]
 
 
-def astype_nansafe(arr, dtype, copy=True, skipna=False):
+def astype_nansafe(arr, dtype, copy: bool = True, skipna: bool = False):
     """
     Cast the elements of an array to a given dtype a nan-safe manner.
 
@@ -696,21 +838,22 @@ def astype_nansafe(arr, dtype, copy=True, skipna=False):
         if is_object_dtype(dtype):
             return tslib.ints_to_pydatetime(arr.view(np.int64))
         elif dtype == np.int64:
+            if isna(arr).any():
+                raise ValueError("Cannot convert NaT values to integer")
             return arr.view(dtype)
 
         # allow frequency conversions
         if dtype.kind == "M":
             return arr.astype(dtype)
 
-        raise TypeError(
-            "cannot astype a datetimelike from [{from_dtype}] "
-            "to [{to_dtype}]".format(from_dtype=arr.dtype, to_dtype=dtype)
-        )
+        raise TypeError(f"cannot astype a datetimelike from [{arr.dtype}] to [{dtype}]")
 
     elif is_timedelta64_dtype(arr):
         if is_object_dtype(dtype):
             return tslibs.ints_to_pytimedelta(arr.view(np.int64))
         elif dtype == np.int64:
+            if isna(arr).any():
+                raise ValueError("Cannot convert NaT values to integer")
             return arr.view(dtype)
 
         if dtype not in [_INT64_DTYPE, _TD_DTYPE]:
@@ -725,10 +868,7 @@ def astype_nansafe(arr, dtype, copy=True, skipna=False):
         elif dtype == _TD_DTYPE:
             return arr.astype(_TD_DTYPE, copy=copy)
 
-        raise TypeError(
-            "cannot astype a timedelta from [{from_dtype}] "
-            "to [{to_dtype}]".format(from_dtype=arr.dtype, to_dtype=dtype)
-        )
+        raise TypeError(f"cannot astype a timedelta from [{arr.dtype}] to [{dtype}]")
 
     elif np.issubdtype(arr.dtype, np.floating) and np.issubdtype(dtype, np.integer):
 
@@ -754,8 +894,11 @@ def astype_nansafe(arr, dtype, copy=True, skipna=False):
             return astype_nansafe(to_timedelta(arr).values, dtype, copy=copy)
 
     if dtype.name in ("datetime64", "timedelta64"):
-        msg = "The '{dtype}' dtype has no unit. Please pass in '{dtype}[ns]' instead."
-        raise ValueError(msg.format(dtype=dtype.name))
+        msg = (
+            f"The '{dtype.name}' dtype has no unit. Please pass in "
+            f"'{dtype.name}[ns]' instead."
+        )
+        raise ValueError(msg)
 
     if copy or is_object_dtype(arr) or is_object_dtype(dtype):
         # Explicit copy, or required since NumPy can't view from / to object.
@@ -796,7 +939,7 @@ def maybe_convert_objects(values: np.ndarray, convert_numeric: bool = True):
                 new_values = lib.maybe_convert_numeric(
                     values, set(), coerce_numeric=True
                 )
-            except Exception:
+            except (ValueError, TypeError):
                 pass
             else:
                 # if we are all nans then leave me alone
@@ -875,7 +1018,7 @@ def soft_convert_objects(
     if numeric and is_object_dtype(values.dtype):
         try:
             converted = lib.maybe_convert_numeric(values, set(), coerce_numeric=True)
-        except Exception:
+        except (ValueError, TypeError):
             pass
         else:
             # If all NaNs, then do not-alter
@@ -885,7 +1028,81 @@ def soft_convert_objects(
     return values
 
 
-def maybe_castable(arr):
+def convert_dtypes(
+    input_array,
+    convert_string: bool = True,
+    convert_integer: bool = True,
+    convert_boolean: bool = True,
+) -> Dtype:
+    """
+    Convert objects to best possible type, and optionally,
+    to types supporting ``pd.NA``.
+
+    Parameters
+    ----------
+    input_array : ExtensionArray or PandasArray
+    convert_string : bool, default True
+        Whether object dtypes should be converted to ``StringDtype()``.
+    convert_integer : bool, default True
+        Whether, if possible, conversion can be done to integer extension types.
+    convert_boolean : bool, defaults True
+        Whether object dtypes should be converted to ``BooleanDtypes()``.
+
+    Returns
+    -------
+    dtype
+        new dtype
+    """
+
+    if convert_string or convert_integer or convert_boolean:
+        try:
+            inferred_dtype = lib.infer_dtype(input_array)
+        except ValueError:
+            # Required to catch due to Period.  Can remove once GH 23553 is fixed
+            inferred_dtype = input_array.dtype
+
+        if not convert_string and is_string_dtype(inferred_dtype):
+            inferred_dtype = input_array.dtype
+
+        if convert_integer:
+            target_int_dtype = "Int64"
+
+            if isinstance(inferred_dtype, str) and (
+                inferred_dtype == "mixed-integer"
+                or inferred_dtype == "mixed-integer-float"
+            ):
+                inferred_dtype = target_int_dtype
+            if is_integer_dtype(input_array.dtype) and not is_extension_array_dtype(
+                input_array.dtype
+            ):
+                from pandas.core.arrays.integer import _dtypes
+
+                inferred_dtype = _dtypes.get(input_array.dtype.name, target_int_dtype)
+            if not is_integer_dtype(input_array.dtype) and is_numeric_dtype(
+                input_array.dtype
+            ):
+                inferred_dtype = target_int_dtype
+
+        else:
+            if is_integer_dtype(inferred_dtype):
+                inferred_dtype = input_array.dtype
+
+        if convert_boolean:
+            if is_bool_dtype(input_array.dtype) and not is_extension_array_dtype(
+                input_array.dtype
+            ):
+                inferred_dtype = "boolean"
+        else:
+            if isinstance(inferred_dtype, str) and inferred_dtype == "boolean":
+                inferred_dtype = input_array.dtype
+
+    else:
+        inferred_dtype = input_array.dtype
+
+    return inferred_dtype
+
+
+def maybe_castable(arr) -> bool:
     # return False to force a non-fastpath
 
     # check datetime64[ns]/timedelta64[ns] are valid
@@ -899,7 +1116,7 @@ def maybe_castable(arr):
     return arr.dtype.name not in _POSSIBLY_CAST_DTYPES
 
 
-def maybe_infer_to_datetimelike(value, convert_dates=False):
+def maybe_infer_to_datetimelike(value, convert_dates: bool = False):
     """
     we might have a array (or single object) that is datetime like,
     and no dtype is passed don't change the value unless we find a
@@ -911,7 +1128,7 @@ def maybe_infer_to_datetimelike(value, convert_dates=False):
     Parameters
     ----------
     value : np.array / Series / Index / list-like
-    convert_dates : boolean, default False
+    convert_dates : bool, default False
        if True try really hard to convert dates (such as datetime.date), other
        leave inferred dtype 'date' alone
 
@@ -953,9 +1170,10 @@ def try_datetime(v):
             # we might have a sequence of the same-datetimes with tz's
             # if so coerce to a DatetimeIndex; if they are not the same,
             # then these stay as object dtype, xref GH19671
+            from pandas._libs.tslibs import conversion
+            from pandas import DatetimeIndex
+
             try:
-                from pandas._libs.tslibs import conversion
-                from pandas import DatetimeIndex
 
                 values, tz = conversion.datetime_to_datetime64(v)
                 return DatetimeIndex(values).tz_localize("UTC").tz_convert(tz=tz)
@@ -1005,7 +1223,7 @@ def try_timedelta(v):
     return value
 
 
-def maybe_cast_to_datetime(value, dtype, errors="raise"):
+def maybe_cast_to_datetime(value, dtype, errors: str = "raise"):
     """ try to cast the array/value to a datetimelike dtype, converting float
     nan to iNaT
     """
@@ -1024,8 +1242,8 @@ def maybe_cast_to_datetime(value, dtype, errors="raise"):
 
             # Force the dtype if needed.
             msg = (
-                "The '{dtype}' dtype has no unit. "
-                "Please pass in '{dtype}[ns]' instead."
+                f"The '{dtype.name}' dtype has no unit. "
+                f"Please pass in '{dtype.name}[ns]' instead."
             )
 
             if is_datetime64 and not is_dtype_equal(dtype, _NS_DTYPE):
@@ -1034,13 +1252,10 @@ def maybe_cast_to_datetime(value, dtype, errors="raise"):
                 # e.g., [ps], [fs], [as]
                 if dtype <= np.dtype("M8[ns]"):
                     if dtype.name == "datetime64":
-                        raise ValueError(msg.format(dtype=dtype.name))
+                        raise ValueError(msg)
                     dtype = _NS_DTYPE
                 else:
-                    raise TypeError(
-                        "cannot convert datetimelike to "
-                        "dtype [{dtype}]".format(dtype=dtype)
-                    )
+                    raise TypeError(f"cannot convert datetimelike to dtype [{dtype}]")
             elif is_datetime64tz:
 
                 # our NaT doesn't support tz's
@@ -1055,13 +1270,10 @@ def maybe_cast_to_datetime(value, dtype, errors="raise"):
                 # e.g., [ps], [fs], [as]
                 if dtype <= np.dtype("m8[ns]"):
                     if dtype.name == "timedelta64":
-                        raise ValueError(msg.format(dtype=dtype.name))
+                        raise ValueError(msg)
                     dtype = _TD_DTYPE
                 else:
-                    raise TypeError(
-                        "cannot convert timedeltalike to "
-                        "dtype [{dtype}]".format(dtype=dtype)
-                    )
+                    raise TypeError(f"cannot convert timedeltalike to dtype [{dtype}]")
 
             if is_scalar(value):
                 if value == iNaT or isna(value):
@@ -1113,7 +1325,7 @@ def maybe_cast_to_datetime(value, dtype, errors="raise"):
                 return tslib.ints_to_pydatetime(ints)
 
             # we have a non-castable dtype that was passed
-            raise TypeError("Cannot cast datetime64 to {dtype}".format(dtype=dtype))
+            raise TypeError(f"Cannot cast datetime64 to {dtype}")
 
     else:
 
@@ -1194,7 +1406,7 @@ def find_common_type(types):
 
 def cast_scalar_to_array(shape, value, dtype=None):
     """
-    create np.ndarray of specified shape and dtype, filled with values
+    Create np.ndarray of specified shape and dtype, filled with values.
 
     Parameters
     ----------
@@ -1220,7 +1432,7 @@ def cast_scalar_to_array(shape, value, dtype=None):
     return values
 
 
-def construct_1d_arraylike_from_scalar(value, length, dtype):
+def construct_1d_arraylike_from_scalar(value, length: int, dtype):
     """
     create a np.ndarray / pandas type of specified shape and dtype
     filled with values
@@ -1236,14 +1448,10 @@ def construct_1d_arraylike_from_scalar(value, length, dtype):
     np.ndarray / pandas type of length, filled with value
 
     """
-    if is_datetime64tz_dtype(dtype):
-        from pandas import DatetimeIndex
-
-        subarr = DatetimeIndex([value] * length, dtype=dtype)
-    elif is_categorical_dtype(dtype):
-        from pandas import Categorical
+    if is_extension_array_dtype(dtype):
+        cls = dtype.construct_array_type()
+        subarr = cls._from_sequence([value] * length, dtype=dtype)
 
-        subarr = Categorical([value] * length, dtype=dtype)
     else:
         if not isinstance(dtype, (np.dtype, type(np.dtype))):
             dtype = dtype.dtype
@@ -1289,7 +1497,7 @@ def construct_1d_object_array_from_listlike(values):
     return result
 
 
-def construct_1d_ndarray_preserving_na(values, dtype=None, copy=False):
+def construct_1d_ndarray_preserving_na(values, dtype=None, copy: bool = False):
     """
     Construct a new ndarray, coercing `values` to `dtype`, preserving NA.
 
@@ -1310,9 +1518,8 @@ def construct_1d_ndarray_preserving_na(values, dtype=None, copy=False):
     >>> np.array([1.0, 2.0, None], dtype='str')
     array(['1.0', '2.0', 'None'], dtype='<U4')
 
-    >>> construct_1d_ndarray_preserving_na([1.0, 2.0, None], dtype='str')
-
-
+    >>> construct_1d_ndarray_preserving_na([1.0, 2.0, None], dtype=np.dtype('str'))
+    array(['1.0', '2.0', None], dtype=object)
     """
     subarr = np.array(values, dtype=dtype, copy=copy)
 
@@ -1331,7 +1538,7 @@ def construct_1d_ndarray_preserving_na(values, dtype=None, copy=False):
     return subarr
 
 
-def maybe_cast_to_integer_array(arr, dtype, copy=False):
+def maybe_cast_to_integer_array(arr, dtype, copy: bool = False):
     """
     Takes any dtype and returns the casted version, raising for when data is
     incompatible with integer/unsigned integer dtypes.
@@ -1344,13 +1551,13 @@ def maybe_cast_to_integer_array(arr, dtype, copy=False):
         The array to cast.
     dtype : str, np.dtype
         The integer dtype to cast the array to.
-    copy: boolean, default False
+    copy: bool, default False
         Whether to make a copy of the array before returning.
 
     Returns
     -------
-    int_arr : ndarray
-        An array of integer or unsigned integer dtype
+    ndarray
+        Array of integer or unsigned integer dtype.
 
     Raises
     ------
@@ -1361,19 +1568,18 @@ def maybe_cast_to_integer_array(arr, dtype, copy=False):
     --------
     If you try to coerce negative values to unsigned integers, it raises:
 
-    >>> Series([-1], dtype="uint64")
+    >>> pd.Series([-1], dtype="uint64")
     Traceback (most recent call last):
         ...
     OverflowError: Trying to coerce negative values to unsigned integers
 
     Also, if you try to coerce float values to integers, it raises:
 
-    >>> Series([1, 2, 3.5], dtype="int64")
+    >>> pd.Series([1, 2, 3.5], dtype="int64")
     Traceback (most recent call last):
         ...
     ValueError: Trying to coerce float values to integers
     """
-
     try:
         if not hasattr(arr, "astype"):
             casted = np.array(arr, dtype=dtype, copy=copy)
@@ -1382,7 +1588,7 @@ def maybe_cast_to_integer_array(arr, dtype, copy=False):
     except OverflowError:
         raise OverflowError(
             "The elements provided in the data cannot all be "
-            "casted to the dtype {dtype}".format(dtype=dtype)
+            f"casted to the dtype {dtype}"
         )
 
     if np.array_equal(arr, casted):
@@ -1400,3 +1606,59 @@ def maybe_cast_to_integer_array(arr, dtype, copy=False):
 
     if is_integer_dtype(dtype) and (is_float_dtype(arr) or is_object_dtype(arr)):
         raise ValueError("Trying to coerce float values to integers")
+
+
+def convert_scalar_for_putitemlike(scalar, dtype: np.dtype):
+    """
+    Convert datetimelike scalar if we are setting into a datetime64
+    or timedelta64 ndarray.
+
+    Parameters
+    ----------
+    scalar : scalar
+    dtype : np.dtpye
+
+    Returns
+    -------
+    scalar
+    """
+    if dtype.kind == "m":
+        if isinstance(scalar, (timedelta, np.timedelta64)):
+            # We have to cast after asm8 in case we have NaT
+            return Timedelta(scalar).asm8.view("timedelta64[ns]")
+        elif scalar is None or scalar is NaT or (is_float(scalar) and np.isnan(scalar)):
+            return np.timedelta64("NaT", "ns")
+    if dtype.kind == "M":
+        if isinstance(scalar, (date, np.datetime64)):
+            # Note: we include date, not just datetime
+            return Timestamp(scalar).to_datetime64()
+        elif scalar is None or scalar is NaT or (is_float(scalar) and np.isnan(scalar)):
+            return np.datetime64("NaT", "ns")
+    else:
+        validate_numeric_casting(dtype, scalar)
+    return scalar
+
+
+def validate_numeric_casting(dtype: np.dtype, value):
+    """
+    Check that we can losslessly insert the given value into an array
+    with the given dtype.
+
+    Parameters
+    ----------
+    dtype : np.dtype
+    value : scalar
+
+    Raises
+    ------
+    ValueError
+    """
+    if issubclass(dtype.type, (np.integer, np.bool_)):
+        if is_float(value) and np.isnan(value):
+            raise ValueError("Cannot assign nan to integer series")
+
+    if issubclass(dtype.type, (np.integer, np.floating, np.complex)) and not issubclass(
+        dtype.type, np.bool_
+    ):
+        if is_bool(value):
+            raise ValueError("Cannot assign bool to float/integer series")
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index cf1a602e9e9f2..f8e14d1cbc9e9 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -1,4 +1,7 @@
-""" common type operations """
+"""
+Common type operations.
+"""
+
 from typing import Any, Callable, Union
 import warnings
 
@@ -6,7 +9,7 @@
 
 from pandas._libs import algos, lib
 from pandas._libs.tslibs import conversion
-from pandas.compat import PY36
+from pandas._typing import ArrayLike, DtypeObj
 
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
@@ -18,7 +21,6 @@
 )
 from pandas.core.dtypes.generic import (
     ABCCategorical,
-    ABCDateOffset,
     ABCDatetimeIndex,
     ABCIndexClass,
     ABCPeriodArray,
@@ -45,11 +47,8 @@
     is_re_compilable,
     is_scalar,
     is_sequence,
-    is_string_like,
 )
 
-from pandas._typing import ArrayLike
-
 _POSSIBLY_CAST_DTYPES = {
     np.dtype(t).name
     for t in [
@@ -152,7 +151,7 @@ def ensure_int_or_float(arr: ArrayLike, copy: bool = False) -> np.array:
     ----------
     arr : array-like
           The array whose data type we want to enforce.
-    copy: boolean
+    copy: bool
           Whether to copy the original array or reuse
           it in place, if possible.
 
@@ -175,6 +174,8 @@ def ensure_int_or_float(arr: ArrayLike, copy: bool = False) -> np.array:
     try:
         return arr.astype("uint64", copy=copy, casting="safe")  # type: ignore
     except TypeError:
+        if is_extension_array_dtype(arr.dtype):
+            return arr.to_numpy(dtype="float64", na_value=np.nan)
         return arr.astype("float64", copy=copy)
 
 
@@ -195,15 +196,12 @@ def ensure_python_int(value: Union[int, np.integer]) -> int:
     TypeError: if the value isn't an int or can't be converted to one.
     """
     if not is_scalar(value):
-        raise TypeError(
-            "Value needs to be a scalar value, was type {}".format(type(value))
-        )
-    msg = "Wrong type {} for value {}"
+        raise TypeError(f"Value needs to be a scalar value, was type {type(value)}")
     try:
         new_value = int(value)
         assert new_value == value
     except (TypeError, ValueError, AssertionError):
-        raise TypeError(msg.format(type(value), value))
+        raise TypeError(f"Wrong type {type(value)} for value {value}")
     return new_value
 
 
@@ -223,7 +221,7 @@ def classes_and_not_datetimelike(*klasses) -> Callable:
     )
 
 
-def is_object_dtype(arr_or_dtype):
+def is_object_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the object dtype.
 
@@ -253,7 +251,7 @@ def is_object_dtype(arr_or_dtype):
     return _is_dtype_type(arr_or_dtype, classes(np.object_))
 
 
-def is_sparse(arr):
+def is_sparse(arr) -> bool:
     """
     Check whether an array-like is a 1-D pandas sparse array.
 
@@ -271,19 +269,13 @@ def is_sparse(arr):
     bool
         Whether or not the array-like is a pandas sparse array.
 
-    See Also
-    --------
-    DataFrame.to_sparse : Convert DataFrame to a SparseDataFrame.
-    Series.to_sparse : Convert Series to SparseSeries.
-    Series.to_dense : Return dense representation of a Series.
-
     Examples
     --------
     Returns `True` if the parameter is a 1-D pandas sparse array.
 
-    >>> is_sparse(pd.SparseArray([0, 0, 1, 0]))
+    >>> is_sparse(pd.arrays.SparseArray([0, 0, 1, 0]))
     True
-    >>> is_sparse(pd.SparseSeries([0, 0, 1, 0]))
+    >>> is_sparse(pd.Series(pd.arrays.SparseArray([0, 0, 1, 0])))
     True
 
     Returns `False` if the parameter is not sparse.
@@ -300,14 +292,6 @@ def is_sparse(arr):
     False
 
     Returns `False` if the parameter has more than one dimension.
-
-    >>> df = pd.SparseDataFrame([389., 24., 80.5, np.nan],
-                                columns=['max_speed'],
-                                index=['falcon', 'parrot', 'lion', 'monkey'])
-    >>> is_sparse(df)
-    False
-    >>> is_sparse(df.max_speed)
-    True
     """
     from pandas.core.arrays.sparse import SparseDtype
 
@@ -315,7 +299,7 @@ def is_sparse(arr):
     return isinstance(dtype, SparseDtype)
 
 
-def is_scipy_sparse(arr):
+def is_scipy_sparse(arr) -> bool:
     """
     Check whether an array-like is a scipy.sparse.spmatrix instance.
 
@@ -338,9 +322,7 @@ def is_scipy_sparse(arr):
     >>> from scipy.sparse import bsr_matrix
     >>> is_scipy_sparse(bsr_matrix([1, 2, 3]))
     True
-    >>> is_scipy_sparse(pd.SparseArray([1, 2, 3]))
-    False
-    >>> is_scipy_sparse(pd.SparseSeries([1, 2, 3]))
+    >>> is_scipy_sparse(pd.arrays.SparseArray([1, 2, 3]))
     False
     """
 
@@ -352,6 +334,7 @@ def is_scipy_sparse(arr):
         except ImportError:
             _is_scipy_sparse = lambda _: False
 
+    assert _is_scipy_sparse is not None
     return _is_scipy_sparse(arr)
 
 
@@ -388,125 +371,7 @@ def is_categorical(arr) -> bool:
     return isinstance(arr, ABCCategorical) or is_categorical_dtype(arr)
 
 
-def is_datetimetz(arr):
-    """
-    Check whether an array-like is a datetime array-like with a timezone
-    component in its dtype.
-
-    .. deprecated:: 0.24.0
-
-    Parameters
-    ----------
-    arr : array-like
-        The array-like to check.
-
-    Returns
-    -------
-    boolean
-        Whether or not the array-like is a datetime array-like with a
-        timezone component in its dtype.
-
-    Examples
-    --------
-    >>> is_datetimetz([1, 2, 3])
-    False
-
-    Although the following examples are both DatetimeIndex objects,
-    the first one returns False because it has no timezone component
-    unlike the second one, which returns True.
-
-    >>> is_datetimetz(pd.DatetimeIndex([1, 2, 3]))
-    False
-    >>> is_datetimetz(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern"))
-    True
-
-    The object need not be a DatetimeIndex object. It just needs to have
-    a dtype which has a timezone component.
-
-    >>> dtype = DatetimeTZDtype("ns", tz="US/Eastern")
-    >>> s = pd.Series([], dtype=dtype)
-    >>> is_datetimetz(s)
-    True
-    """
-
-    warnings.warn(
-        "'is_datetimetz' is deprecated and will be removed in a "
-        "future version.  Use 'is_datetime64tz_dtype' instead.",
-        FutureWarning,
-        stacklevel=2,
-    )
-    return is_datetime64tz_dtype(arr)
-
-
-def is_offsetlike(arr_or_obj):
-    """
-    Check if obj or all elements of list-like is DateOffset
-
-    Parameters
-    ----------
-    arr_or_obj : object
-
-    Returns
-    -------
-    boolean
-        Whether the object is a DateOffset or listlike of DatetOffsets
-
-    Examples
-    --------
-    >>> is_offsetlike(pd.DateOffset(days=1))
-    True
-    >>> is_offsetlike('offset')
-    False
-    >>> is_offsetlike([pd.offsets.Minute(4), pd.offsets.MonthEnd()])
-    True
-    >>> is_offsetlike(np.array([pd.DateOffset(months=3), pd.Timestamp.now()]))
-    False
-    """
-    if isinstance(arr_or_obj, ABCDateOffset):
-        return True
-    elif is_list_like(arr_or_obj) and len(arr_or_obj) and is_object_dtype(arr_or_obj):
-        return all(isinstance(x, ABCDateOffset) for x in arr_or_obj)
-    return False
-
-
-def is_period(arr):
-    """
-    Check whether an array-like is a periodical index.
-
-    .. deprecated:: 0.24.0
-
-    Parameters
-    ----------
-    arr : array-like
-        The array-like to check.
-
-    Returns
-    -------
-    boolean
-        Whether or not the array-like is a periodical index.
-
-    Examples
-    --------
-    >>> is_period([1, 2, 3])
-    False
-    >>> is_period(pd.Index([1, 2, 3]))
-    False
-    >>> is_period(pd.PeriodIndex(["2017-01-01"], freq="D"))
-    True
-    """
-
-    warnings.warn(
-        "'is_period' is deprecated and will be removed in a future "
-        "version.  Use 'is_period_dtype' or is_period_arraylike' "
-        "instead.",
-        FutureWarning,
-        stacklevel=2,
-    )
-
-    return isinstance(arr, ABCPeriodIndex) or is_period_arraylike(arr)
-
-
-def is_datetime64_dtype(arr_or_dtype):
+def is_datetime64_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the datetime64 dtype.
 
@@ -537,7 +402,7 @@ def is_datetime64_dtype(arr_or_dtype):
     return _is_dtype_type(arr_or_dtype, classes(np.datetime64))
 
 
-def is_datetime64tz_dtype(arr_or_dtype):
+def is_datetime64tz_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of a DatetimeTZDtype dtype.
 
@@ -575,7 +440,7 @@ def is_datetime64tz_dtype(arr_or_dtype):
     return DatetimeTZDtype.is_dtype(arr_or_dtype)
 
 
-def is_timedelta64_dtype(arr_or_dtype):
+def is_timedelta64_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the timedelta64 dtype.
 
@@ -606,7 +471,7 @@ def is_timedelta64_dtype(arr_or_dtype):
     return _is_dtype_type(arr_or_dtype, classes(np.timedelta64))
 
 
-def is_period_dtype(arr_or_dtype):
+def is_period_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the Period dtype.
 
@@ -640,7 +505,7 @@ def is_period_dtype(arr_or_dtype):
     return PeriodDtype.is_dtype(arr_or_dtype)
 
 
-def is_interval_dtype(arr_or_dtype):
+def is_interval_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the Interval dtype.
 
@@ -709,7 +574,7 @@ def is_categorical_dtype(arr_or_dtype) -> bool:
     return CategoricalDtype.is_dtype(arr_or_dtype)
 
 
-def is_string_dtype(arr_or_dtype):
+def is_string_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of the string dtype.
 
@@ -739,13 +604,20 @@ def is_string_dtype(arr_or_dtype):
     """
 
     # TODO: gh-15585: consider making the checks stricter.
-    def condition(dtype):
-        return dtype.kind in ("O", "S", "U") and not is_period_dtype(dtype)
+    def condition(dtype) -> bool:
+        return dtype.kind in ("O", "S", "U") and not is_excluded_dtype(dtype)
+
+    def is_excluded_dtype(dtype) -> bool:
+        """
+        These have kind = "O" but aren't string dtypes so need to be explicitly excluded
+        """
+        is_excluded_checks = (is_period_dtype, is_interval_dtype)
+        return any(is_excluded(dtype) for is_excluded in is_excluded_checks)
 
     return _is_dtype(arr_or_dtype, condition)
 
 
-def is_period_arraylike(arr):
+def is_period_arraylike(arr) -> bool:
     """
     Check whether an array-like is a periodical array-like or PeriodIndex.
 
@@ -777,7 +649,7 @@ def is_period_arraylike(arr):
     return getattr(arr, "inferred_type", None) == "period"
 
 
-def is_datetime_arraylike(arr):
+def is_datetime_arraylike(arr) -> bool:
     """
     Check whether an array-like is a datetime array-like or DatetimeIndex.
 
@@ -812,55 +684,7 @@ def is_datetime_arraylike(arr):
     return getattr(arr, "inferred_type", None) == "datetime"
 
 
-def is_datetimelike(arr):
-    """
-    Check whether an array-like is a datetime-like array-like.
-
-    Acceptable datetime-like objects are (but not limited to) datetime
-    indices, periodic indices, and timedelta indices.
-
-    Parameters
-    ----------
-    arr : array-like
-        The array-like to check.
-
-    Returns
-    -------
-    boolean
-        Whether or not the array-like is a datetime-like array-like.
-
-    Examples
-    --------
-    >>> is_datetimelike([1, 2, 3])
-    False
-    >>> is_datetimelike(pd.Index([1, 2, 3]))
-    False
-    >>> is_datetimelike(pd.DatetimeIndex([1, 2, 3]))
-    True
-    >>> is_datetimelike(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern"))
-    True
-    >>> is_datetimelike(pd.PeriodIndex([], freq="A"))
-    True
-    >>> is_datetimelike(np.array([], dtype=np.datetime64))
-    True
-    >>> is_datetimelike(pd.Series([], dtype="timedelta64[ns]"))
-    True
-    >>>
-    >>> dtype = DatetimeTZDtype("ns", tz="US/Eastern")
-    >>> s = pd.Series([], dtype=dtype)
-    >>> is_datetimelike(s)
-    True
-    """
-
-    return (
-        is_datetime64_dtype(arr)
-        or is_datetime64tz_dtype(arr)
-        or is_timedelta64_dtype(arr)
-        or isinstance(arr, ABCPeriodIndex)
-    )
-
-
-def is_dtype_equal(source, target):
+def is_dtype_equal(source, target) -> bool:
     """
     Check if two dtypes are equal.
 
@@ -884,7 +708,7 @@ def is_dtype_equal(source, target):
     False
     >>> is_dtype_equal(CategoricalDtype(), "category")
     True
-    >>> is_dtype_equal(DatetimeTZDtype(), "datetime64")
+    >>> is_dtype_equal(DatetimeTZDtype(tz="UTC"), "datetime64")
     False
     """
 
@@ -900,7 +724,8 @@ def is_dtype_equal(source, target):
 
 
 def is_any_int_dtype(arr_or_dtype) -> bool:
-    """Check whether the provided array or dtype is of an integer dtype.
+    """
+    Check whether the provided array or dtype is of an integer dtype.
 
     In this function, timedelta64 instances are also considered "any-integer"
     type objects and will return True.
@@ -949,7 +774,7 @@ def is_any_int_dtype(arr_or_dtype) -> bool:
     return _is_dtype_type(arr_or_dtype, classes(np.integer, np.timedelta64))
 
 
-def is_integer_dtype(arr_or_dtype):
+def is_integer_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of an integer dtype.
 
@@ -1004,7 +829,7 @@ def is_integer_dtype(arr_or_dtype):
     return _is_dtype_type(arr_or_dtype, classes_and_not_datetimelike(np.integer))
 
 
-def is_signed_integer_dtype(arr_or_dtype):
+def is_signed_integer_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of a signed integer dtype.
 
@@ -1040,7 +865,7 @@ def is_signed_integer_dtype(arr_or_dtype):
     True
     >>> is_signed_integer_dtype('Int8')
     True
-    >>> is_signed_dtype(pd.Int8Dtype)
+    >>> is_signed_integer_dtype(pd.Int8Dtype)
     True
     >>> is_signed_integer_dtype(np.datetime64)
     False
@@ -1061,7 +886,7 @@ def is_signed_integer_dtype(arr_or_dtype):
     return _is_dtype_type(arr_or_dtype, classes_and_not_datetimelike(np.signedinteger))
 
 
-def is_unsigned_integer_dtype(arr_or_dtype):
+def is_unsigned_integer_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of an unsigned integer dtype.
 
@@ -1110,7 +935,7 @@ def is_unsigned_integer_dtype(arr_or_dtype):
     )
 
 
-def is_int64_dtype(arr_or_dtype):
+def is_int64_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of the int64 dtype.
 
@@ -1172,7 +997,7 @@ def is_datetime64_any_dtype(arr_or_dtype) -> bool:
 
     Returns
     -------
-    boolean
+    bool
         Whether or not the array or dtype is of the datetime64 dtype.
 
     Examples
@@ -1189,19 +1014,17 @@ def is_datetime64_any_dtype(arr_or_dtype) -> bool:
     False
     >>> is_datetime64_any_dtype(np.array([1, 2]))
     False
-    >>> is_datetime64_any_dtype(np.array([], dtype=np.datetime64))
+    >>> is_datetime64_any_dtype(np.array([], dtype="datetime64[ns]"))
     True
-    >>> is_datetime64_any_dtype(pd.DatetimeIndex([1, 2, 3],
-                                dtype=np.datetime64))
+    >>> is_datetime64_any_dtype(pd.DatetimeIndex([1, 2, 3], dtype="datetime64[ns]"))
     True
     """
-
     if arr_or_dtype is None:
         return False
     return is_datetime64_dtype(arr_or_dtype) or is_datetime64tz_dtype(arr_or_dtype)
 
 
-def is_datetime64_ns_dtype(arr_or_dtype):
+def is_datetime64_ns_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of the datetime64[ns] dtype.
 
@@ -1212,7 +1035,7 @@ def is_datetime64_ns_dtype(arr_or_dtype):
 
     Returns
     -------
-    boolean
+    bool
         Whether or not the array or dtype is of the datetime64[ns] dtype.
 
     Examples
@@ -1229,16 +1052,13 @@ def is_datetime64_ns_dtype(arr_or_dtype):
     False
     >>> is_datetime64_ns_dtype(np.array([1, 2]))
     False
-    >>> is_datetime64_ns_dtype(np.array([], dtype=np.datetime64))  # no unit
+    >>> is_datetime64_ns_dtype(np.array([], dtype="datetime64"))  # no unit
     False
-    >>> is_datetime64_ns_dtype(np.array([],
-                               dtype="datetime64[ps]"))  # wrong unit
+    >>> is_datetime64_ns_dtype(np.array([], dtype="datetime64[ps]"))  # wrong unit
     False
-    >>> is_datetime64_ns_dtype(pd.DatetimeIndex([1, 2, 3],
-                               dtype=np.datetime64))  # has 'ns' unit
+    >>> is_datetime64_ns_dtype(pd.DatetimeIndex([1, 2, 3], dtype="datetime64[ns]"))
     True
     """
-
     if arr_or_dtype is None:
         return False
     try:
@@ -1251,7 +1071,7 @@ def is_datetime64_ns_dtype(arr_or_dtype):
     return tipo == _NS_DTYPE or getattr(tipo, "base", None) == _NS_DTYPE
 
 
-def is_timedelta64_ns_dtype(arr_or_dtype):
+def is_timedelta64_ns_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of the timedelta64[ns] dtype.
 
@@ -1282,7 +1102,7 @@ def is_timedelta64_ns_dtype(arr_or_dtype):
     return _is_dtype(arr_or_dtype, lambda dtype: dtype == _TD_DTYPE)
 
 
-def is_datetime_or_timedelta_dtype(arr_or_dtype):
+def is_datetime_or_timedelta_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of
     a timedelta64 or datetime64 dtype.
@@ -1325,9 +1145,6 @@ def _is_unorderable_exception(e: TypeError) -> bool:
     """
     Check if the exception raised is an unorderable exception.
 
-    The error message differs for 3 <= PY <= 3.5 and PY >= 3.6, so
-    we need to condition based on Python version.
-
     Parameters
     ----------
     e : Exception or sub-class
@@ -1335,20 +1152,16 @@ def _is_unorderable_exception(e: TypeError) -> bool:
 
     Returns
     -------
-    boolean
+    bool
         Whether or not the exception raised is an unorderable exception.
     """
-
-    if PY36:
-        return "'>' not supported between instances of" in str(e)
-
-    return "unorderable" in str(e)
+    return "'>' not supported between instances of" in str(e)
 
 
+# This exists to silence numpy deprecation warnings, see GH#29553
 def is_numeric_v_string_like(a, b):
     """
     Check if we are comparing a string-like object to a numeric ndarray.
-
     NumPy doesn't like to compare such objects, especially numeric arrays
     and scalar string-likes.
 
@@ -1394,8 +1207,8 @@ def is_numeric_v_string_like(a, b):
     is_a_string_array = is_a_array and is_string_like_dtype(a)
     is_b_string_array = is_b_array and is_string_like_dtype(b)
 
-    is_a_scalar_string_like = not is_a_array and is_string_like(a)
-    is_b_scalar_string_like = not is_b_array and is_string_like(b)
+    is_a_scalar_string_like = not is_a_array and isinstance(a, str)
+    is_b_scalar_string_like = not is_b_array and isinstance(b, str)
 
     return (
         (is_a_numeric_array and is_b_scalar_string_like)
@@ -1405,10 +1218,10 @@ def is_numeric_v_string_like(a, b):
     )
 
 
+# This exists to silence numpy deprecation warnings, see GH#29553
 def is_datetimelike_v_numeric(a, b):
     """
     Check if we are comparing a datetime-like object to a numeric object.
-
     By "numeric," we mean an object that is either of an int or float dtype.
 
     Parameters
@@ -1425,7 +1238,8 @@ def is_datetimelike_v_numeric(a, b):
 
     Examples
     --------
-    >>> dt = np.datetime64(pd.datetime(2017, 1, 1))
+    >>> from datetime import datetime
+    >>> dt = np.datetime64(datetime(2017, 1, 1))
     >>>
     >>> is_datetimelike_v_numeric(1, 1)
     False
@@ -1458,13 +1272,12 @@ def is_numeric(x):
         """
         return is_integer_dtype(x) or is_float_dtype(x)
 
-    is_datetimelike = needs_i8_conversion
-    return (is_datetimelike(a) and is_numeric(b)) or (
-        is_datetimelike(b) and is_numeric(a)
+    return (needs_i8_conversion(a) and is_numeric(b)) or (
+        needs_i8_conversion(b) and is_numeric(a)
     )
 
 
-def needs_i8_conversion(arr_or_dtype):
+def needs_i8_conversion(arr_or_dtype) -> bool:
     """
     Check whether the array or dtype should be converted to int64.
 
@@ -1508,7 +1321,7 @@ def needs_i8_conversion(arr_or_dtype):
     )
 
 
-def is_numeric_dtype(arr_or_dtype):
+def is_numeric_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of a numeric dtype.
 
@@ -1551,7 +1364,7 @@ def is_numeric_dtype(arr_or_dtype):
     )
 
 
-def is_string_like_dtype(arr_or_dtype):
+def is_string_like_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of a string-like dtype.
 
@@ -1583,7 +1396,7 @@ def is_string_like_dtype(arr_or_dtype):
     return _is_dtype(arr_or_dtype, lambda dtype: dtype.kind in ("S", "U"))
 
 
-def is_float_dtype(arr_or_dtype):
+def is_float_dtype(arr_or_dtype) -> bool:
     """
     Check whether the provided array or dtype is of a float dtype.
 
@@ -1654,7 +1467,7 @@ def is_bool_dtype(arr_or_dtype) -> bool:
     True
     >>> is_bool_dtype(pd.Categorical([True, False]))
     True
-    >>> is_bool_dtype(pd.SparseArray([True, False]))
+    >>> is_bool_dtype(pd.arrays.SparseArray([True, False]))
     True
     """
     if arr_or_dtype is None:
@@ -1682,10 +1495,13 @@ def is_bool_dtype(arr_or_dtype) -> bool:
     return issubclass(dtype.type, np.bool_)
 
 
-def is_extension_type(arr):
+def is_extension_type(arr) -> bool:
     """
     Check whether an array-like is of a pandas extension class instance.
 
+    .. deprecated:: 1.0.0
+        Use ``is_extension_array_dtype`` instead.
+
     Extension classes include categoricals, pandas sparse objects (i.e.
     classes represented within the pandas library and not ones external
     to it like scipy sparse matrices), and datetime-like arrays.
@@ -1713,11 +1529,8 @@ def is_extension_type(arr):
     True
     >>> is_extension_type(pd.Series(cat))
     True
-    >>> is_extension_type(pd.SparseArray([1, 2, 3]))
-    True
-    >>> is_extension_type(pd.SparseSeries([1, 2, 3]))
+    >>> is_extension_type(pd.arrays.SparseArray([1, 2, 3]))
     True
-    >>>
     >>> from scipy.sparse import bsr_matrix
     >>> is_extension_type(bsr_matrix([1, 2, 3]))
     False
@@ -1731,6 +1544,12 @@ def is_extension_type(arr):
     >>> is_extension_type(s)
     True
     """
+    warnings.warn(
+        "'is_extension_type' is deprecated and will be removed in a future "
+        "version.  Use 'is_extension_array_dtype' instead.",
+        FutureWarning,
+        stacklevel=2,
+    )
 
     if is_categorical(arr):
         return True
@@ -1741,7 +1560,7 @@ def is_extension_type(arr):
     return False
 
 
-def is_extension_array_dtype(arr_or_dtype):
+def is_extension_array_dtype(arr_or_dtype) -> bool:
     """
     Check if an object is a pandas extension array type.
 
@@ -1848,7 +1667,7 @@ def _is_dtype(arr_or_dtype, condition) -> bool:
     return condition(dtype)
 
 
-def _get_dtype(arr_or_dtype):
+def _get_dtype(arr_or_dtype) -> DtypeObj:
     """
     Get the dtype instance associated with an array
     or dtype object.
@@ -2012,13 +1831,15 @@ def _validate_date_like_dtype(dtype) -> None:
     try:
         typ = np.datetime_data(dtype)[0]
     except ValueError as e:
-        raise TypeError("{error}".format(error=e))
+        raise TypeError(e)
     if typ != "generic" and typ != "ns":
-        msg = "{name!r} is too specific of a frequency, try passing {type!r}"
-        raise ValueError(msg.format(name=dtype.name, type=dtype.type.__name__))
+        raise ValueError(
+            f"{repr(dtype.name)} is too specific of a frequency, "
+            f"try passing {repr(dtype.type.__name__)}"
+        )
 
 
-def pandas_dtype(dtype):
+def pandas_dtype(dtype) -> DtypeObj:
     """
     Convert input into a pandas only dtype object or a numpy dtype object.
 
@@ -2051,7 +1872,7 @@ def pandas_dtype(dtype):
         npdtype = np.dtype(dtype)
     except SyntaxError:
         # np.dtype uses `eval` which can raise SyntaxError
-        raise TypeError("data type '{}' not understood".format(dtype))
+        raise TypeError(f"data type '{dtype}' not understood")
 
     # Any invalid dtype (such as pd.Timestamp) should raise an error.
     # np.dtype(invalid_type).kind = 0 for such objects. However, this will
@@ -2063,6 +1884,6 @@ def pandas_dtype(dtype):
         # here and `dtype` is an array
         return npdtype
     elif npdtype.kind == "O":
-        raise TypeError("dtype '{}' not understood".format(dtype))
+        raise TypeError(f"dtype '{dtype}' not understood")
 
     return npdtype
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 1094ab22238e9..fdc2eeb34b4ed 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -1,5 +1,5 @@
 """
-Utility functions related to concat
+Utility functions related to concat.
 """
 
 import numpy as np
@@ -69,7 +69,7 @@ def get_dtype_kinds(l):
     return typs
 
 
-def concat_compat(to_concat, axis=0):
+def concat_compat(to_concat, axis: int = 0):
     """
     provide concatenation of an array of arrays each of which is a single
     'normalized' dtypes (in that for example, if it's object, then it is a
@@ -88,7 +88,7 @@ def concat_compat(to_concat, axis=0):
 
     # filter empty arrays
     # 1-d dtypes always are included here
-    def is_nonempty(x):
+    def is_nonempty(x) -> bool:
         if x.ndim <= axis:
             return True
         return x.shape[axis] > 0
@@ -137,7 +137,7 @@ def is_nonempty(x):
     return np.concatenate(to_concat, axis=axis)
 
 
-def concat_categorical(to_concat, axis=0):
+def concat_categorical(to_concat, axis: int = 0):
     """Concatenate an object/categorical array of arrays, each of which is a
     single dtype
 
@@ -183,27 +183,28 @@ def concat_categorical(to_concat, axis=0):
     return result
 
 
-def union_categoricals(to_union, sort_categories=False, ignore_order=False):
+def union_categoricals(
+    to_union, sort_categories: bool = False, ignore_order: bool = False
+):
     """
-    Combine list-like of Categorical-like, unioning categories. All
-    categories must have the same dtype.
+    Combine list-like of Categorical-like, unioning categories.
+
+    All categories must have the same dtype.
 
     Parameters
     ----------
-    to_union : list-like of Categorical, CategoricalIndex,
-               or Series with dtype='category'
-    sort_categories : boolean, default False
+    to_union : list-like
+        Categorical, CategoricalIndex, or Series with dtype='category'.
+    sort_categories : bool, default False
         If true, resulting categories will be lexsorted, otherwise
         they will be ordered as they appear in the data.
-    ignore_order : boolean, default False
+    ignore_order : bool, default False
         If true, the ordered attribute of the Categoricals will be ignored.
         Results in an unordered categorical.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
-    result : Categorical
+    Categorical
 
     Raises
     ------
@@ -219,7 +220,7 @@ def union_categoricals(to_union, sort_categories=False, ignore_order=False):
     -----
 
     To learn more about categories, see `link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html#unioning>`__
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html#unioning>`__
 
     Examples
     --------
@@ -260,6 +261,8 @@ def union_categoricals(to_union, sort_categories=False, ignore_order=False):
     >>> a = pd.Categorical(["a", "b"], ordered=True)
     >>> b = pd.Categorical(["a", "b", "c"], ordered=True)
     >>> union_categoricals([a, b])
+    Traceback (most recent call last):
+        ...
     TypeError: to union ordered Categoricals, all categories must be the same
 
     New in version 0.20.0
@@ -356,7 +359,7 @@ def _maybe_unwrap(x):
     return Categorical(new_codes, categories=categories, ordered=ordered, fastpath=True)
 
 
-def _concatenate_2d(to_concat, axis):
+def _concatenate_2d(to_concat, axis: int):
     # coerce to 2d if needed & concatenate
     if axis == 1:
         to_concat = [np.atleast_2d(x) for x in to_concat]
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index aa7e6801ba431..8aaebe89871b6 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -1,27 +1,23 @@
-""" define extension dtypes """
+"""
+Define extension dtypes.
+"""
+
 import re
-from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast
-import warnings
+from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Type, Union, cast
 
 import numpy as np
 import pytz
 
 from pandas._libs.interval import Interval
 from pandas._libs.tslibs import NaT, Period, Timestamp, timezones
-
-from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCDateOffset, ABCIndexClass
-
 from pandas._typing import Ordered
 
-from .base import ExtensionDtype
-from .inference import is_bool, is_list_like
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCDateOffset, ABCIndexClass
+from pandas.core.dtypes.inference import is_bool, is_list_like
 
 str_type = str
 
-# GH26403: sentinel value used for the default value of ordered in the
-# CategoricalDtype constructor to detect when ordered=None is explicitly passed
-ordered_sentinel = object()  # type: object
-
 
 def register_extension_dtype(cls: Type[ExtensionDtype]) -> Type[ExtensionDtype]:
     """
@@ -51,7 +47,7 @@ def register_extension_dtype(cls: Type[ExtensionDtype]) -> Type[ExtensionDtype]:
 
 class Registry:
     """
-    Registry for dtype inference
+    Registry for dtype inference.
 
     The registry allows one to map a string repr of a extension
     dtype to an extension dtype. The string alias can be used in several
@@ -66,7 +62,7 @@ class Registry:
     """
 
     def __init__(self):
-        self.dtypes = []  # type: List[Type[ExtensionDtype]]
+        self.dtypes: List[Type[ExtensionDtype]] = []
 
     def register(self, dtype: Type[ExtensionDtype]) -> None:
         """
@@ -85,7 +81,7 @@ def find(
         """
         Parameters
         ----------
-        dtype : Type[ExtensionDtype] or string
+        dtype : Type[ExtensionDtype] or str
 
         Returns
         -------
@@ -119,21 +115,21 @@ class PandasExtensionDtype(ExtensionDtype):
     THIS IS NOT A REAL NUMPY DTYPE
     """
 
-    type = None  # type: Any
-    kind = None  # type: Any
+    type: Any
+    kind: Any
     # The Any type annotations above are here only because mypy seems to have a
     # problem dealing with with multiple inheritance from PandasExtensionDtype
     # and ExtensionDtype's @properties in the subclasses below. The kind and
     # type variables in those subclasses are explicitly typed below.
     subdtype = None
-    str = None  # type: Optional[str_type]
+    str: Optional[str_type] = None
     num = 100
-    shape = tuple()  # type: Tuple[int, ...]
+    shape: Tuple[int, ...] = tuple()
     itemsize = 8
     base = None
     isbuiltin = 0
     isnative = 0
-    _cache = {}  # type: Dict[str_type, 'PandasExtensionDtype']
+    _cache: Dict[str_type, "PandasExtensionDtype"] = {}
 
     def __str__(self) -> str_type:
         """
@@ -179,7 +175,11 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
     ----------
     categories : sequence, optional
         Must be unique, and must not contain any nulls.
-    ordered : bool, default False
+    ordered : bool or None, default False
+        Whether or not this categorical is treated as a ordered categorical.
+        None can be used to maintain the ordered value of existing categoricals when
+        used in operations that combine categoricals, e.g. astype, and will resolve to
+        False if there is no existing ordered to maintain.
 
     Attributes
     ----------
@@ -214,18 +214,14 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
 
     # TODO: Document public vs. private API
     name = "category"
-    type = CategoricalDtypeType  # type: Type[CategoricalDtypeType]
-    kind = "O"  # type: str_type
+    type: Type[CategoricalDtypeType] = CategoricalDtypeType
+    kind: str_type = "O"
     str = "|O08"
     base = np.dtype("O")
-    _metadata = ("categories", "ordered", "_ordered_from_sentinel")
-    _cache = {}  # type: Dict[str_type, PandasExtensionDtype]
-
-    def __init__(
-        self, categories=None, ordered: Union[Ordered, object] = ordered_sentinel
-    ):
-        # TODO(GH26403): Set type of ordered to Ordered
-        ordered = cast(Ordered, ordered)
+    _metadata = ("categories", "ordered")
+    _cache: Dict[str_type, PandasExtensionDtype] = {}
+
+    def __init__(self, categories=None, ordered: Ordered = False):
         self._finalize(categories, ordered, fastpath=False)
 
     @classmethod
@@ -293,23 +289,27 @@ def _from_values_or_dtype(
 
         Examples
         --------
-        >>> CategoricalDtype._from_values_or_dtype()
+        >>> pd.CategoricalDtype._from_values_or_dtype()
         CategoricalDtype(categories=None, ordered=None)
-        >>> CategoricalDtype._from_values_or_dtype(categories=['a', 'b'],
-        ...                                        ordered=True)
+        >>> pd.CategoricalDtype._from_values_or_dtype(
+        ...     categories=['a', 'b'], ordered=True
+        ... )
         CategoricalDtype(categories=['a', 'b'], ordered=True)
-        >>> dtype1 = CategoricalDtype(['a', 'b'], ordered=True)
-        >>> dtype2 = CategoricalDtype(['x', 'y'], ordered=False)
-        >>> c = Categorical([0, 1], dtype=dtype1, fastpath=True)
-        >>> CategoricalDtype._from_values_or_dtype(c, ['x', 'y'], ordered=True,
-        ...                                        dtype=dtype2)
+        >>> dtype1 = pd.CategoricalDtype(['a', 'b'], ordered=True)
+        >>> dtype2 = pd.CategoricalDtype(['x', 'y'], ordered=False)
+        >>> c = pd.Categorical([0, 1], dtype=dtype1, fastpath=True)
+        >>> pd.CategoricalDtype._from_values_or_dtype(
+        ...     c, ['x', 'y'], ordered=True, dtype=dtype2
+        ... )
+        Traceback (most recent call last):
+            ...
         ValueError: Cannot specify `categories` or `ordered` together with
         `dtype`.
 
         The supplied dtype takes precedence over values' dtype:
 
-        >>> CategoricalDtype._from_values_or_dtype(c, dtype=dtype2)
-        CategoricalDtype(['x', 'y'], ordered=False)
+        >>> pd.CategoricalDtype._from_values_or_dtype(c, dtype=dtype2)
+        CategoricalDtype(categories=['x', 'y'], ordered=False)
         """
         from pandas.core.dtypes.common import is_categorical
 
@@ -319,8 +319,7 @@ def _from_values_or_dtype(
                 if dtype == "category":
                     dtype = CategoricalDtype(categories, ordered)
                 else:
-                    msg = "Unknown dtype {dtype!r}"
-                    raise ValueError(msg.format(dtype=dtype))
+                    raise ValueError(f"Unknown dtype {repr(dtype)}")
             elif categories is not None or ordered is not None:
                 raise ValueError(
                     "Cannot specify `categories` or `ordered` together with `dtype`."
@@ -339,36 +338,65 @@ def _from_values_or_dtype(
 
         return dtype
 
+    @classmethod
+    def construct_from_string(cls, string: str_type) -> "CategoricalDtype":
+        """
+        Construct a CategoricalDtype from a string.
+
+        Parameters
+        ----------
+        string : str
+            Must be the string "category" in order to be successfully constructed.
+
+        Returns
+        -------
+        CategoricalDtype
+            Instance of the dtype.
+
+        Raises
+        ------
+        TypeError
+            If a CategoricalDtype cannot be constructed from the input.
+        """
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
+        if string != cls.name:
+            raise TypeError(f"Cannot construct a 'CategoricalDtype' from '{string}'")
+
+        # need ordered=None to ensure that operations specifying dtype="category" don't
+        # override the ordered value for existing categoricals
+        return cls(ordered=None)
+
     def _finalize(self, categories, ordered: Ordered, fastpath: bool = False) -> None:
 
-        if ordered is not None and ordered is not ordered_sentinel:
+        if ordered is not None:
             self.validate_ordered(ordered)
 
         if categories is not None:
             categories = self.validate_categories(categories, fastpath=fastpath)
 
         self._categories = categories
-        self._ordered = ordered if ordered is not ordered_sentinel else None
-        self._ordered_from_sentinel = ordered is ordered_sentinel
+        self._ordered = ordered
 
-    def __setstate__(self, state: Dict[str_type, Any]) -> None:
+    def __setstate__(self, state: MutableMapping[str_type, Any]) -> None:
         # for pickle compat. __get_state__ is defined in the
         # PandasExtensionDtype superclass and uses the public properties to
         # pickle -> need to set the settable private ones here (see GH26067)
         self._categories = state.pop("categories", None)
         self._ordered = state.pop("ordered", False)
-        self._ordered_from_sentinel = state.pop("_ordered_from_sentinel", False)
 
     def __hash__(self) -> int:
         # _hash_categories returns a uint64, so use the negative
         # space for when we have unknown categories to avoid a conflict
         if self.categories is None:
-            if self._ordered:
+            if self.ordered:
                 return -1
             else:
                 return -2
         # We *do* want to include the real self.ordered here
-        return int(self._hash_categories(self.categories, self._ordered))
+        return int(self._hash_categories(self.categories, self.ordered))
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -387,7 +415,7 @@ def __eq__(self, other: Any) -> bool:
             return other == self.name
         elif other is self:
             return True
-        elif not (hasattr(other, "_ordered") and hasattr(other, "categories")):
+        elif not (hasattr(other, "ordered") and hasattr(other, "categories")):
             return False
         elif self.categories is None or other.categories is None:
             # We're forced into a suboptimal corner thanks to math and
@@ -396,10 +424,10 @@ def __eq__(self, other: Any) -> bool:
             # CDT(., .) = CDT(None, False) and *all*
             # CDT(., .) = CDT(None, True).
             return True
-        elif self._ordered or other._ordered:
+        elif self.ordered or other.ordered:
             # At least one has ordered=True; equal if both have ordered=True
             # and the same values for categories in the same order.
-            return (self._ordered == other._ordered) and self.categories.equals(
+            return (self.ordered == other.ordered) and self.categories.equals(
                 other.categories
             )
         else:
@@ -415,13 +443,12 @@ def __eq__(self, other: Any) -> bool:
                 return True
             return hash(self) == hash(other)
 
-    def __repr__(self):
-        tpl = "CategoricalDtype(categories={}ordered={})"
+    def __repr__(self) -> str_type:
         if self.categories is None:
             data = "None, "
         else:
-            data = self.categories._format_data(name=self.__class__.__name__)
-        return tpl.format(data, self._ordered)
+            data = self.categories._format_data(name=type(self).__name__)
+        return f"CategoricalDtype(categories={data}ordered={self.ordered})"
 
     @staticmethod
     def _hash_categories(categories, ordered: Ordered = True) -> int:
@@ -465,7 +492,7 @@ def _hash_categories(categories, ordered: Ordered = True) -> int:
     @classmethod
     def construct_array_type(cls):
         """
-        Return the array type associated with this dtype
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -512,8 +539,9 @@ def validate_categories(categories, fastpath: bool = False):
         from pandas.core.indexes.base import Index
 
         if not fastpath and not is_list_like(categories):
-            msg = "Parameter 'categories' must be list-like, was {!r}"
-            raise TypeError(msg.format(categories))
+            raise TypeError(
+                f"Parameter 'categories' must be list-like, was {repr(categories)}"
+            )
         elif not isinstance(categories, ABCIndexClass):
             categories = Index(categories, tupleize_cols=False)
 
@@ -549,35 +577,19 @@ def update_dtype(
             # dtype='category' should not change anything
             return self
         elif not self.is_dtype(dtype):
-            msg = (
-                "a CategoricalDtype must be passed to perform an update, "
-                "got {dtype!r}"
-            ).format(dtype=dtype)
-            raise ValueError(msg)
+            raise ValueError(
+                f"a CategoricalDtype must be passed to perform an update, "
+                f"got {repr(dtype)}"
+            )
         else:
             # from here on, dtype is a CategoricalDtype
             dtype = cast(CategoricalDtype, dtype)
 
-        # dtype is CDT: keep current categories/ordered if None
-        new_categories = dtype.categories
-        if new_categories is None:
-            new_categories = self.categories
-
-        new_ordered = dtype._ordered
-        new_ordered_from_sentinel = dtype._ordered_from_sentinel
-        if new_ordered is None:
-            # maintain existing ordered if new dtype has ordered=None
-            new_ordered = self._ordered
-            if self._ordered and new_ordered_from_sentinel:
-                # only warn if we'd actually change the existing behavior
-                msg = (
-                    "Constructing a CategoricalDtype without specifying "
-                    "`ordered` will default to `ordered=False` in a future "
-                    "version, which will cause the resulting categorical's "
-                    "`ordered` attribute to change to False; `ordered=True`"
-                    " must be explicitly passed in order to be retained"
-                )
-                warnings.warn(msg, FutureWarning, stacklevel=3)
+        # update categories/ordered unless they've been explicitly passed as None
+        new_categories = (
+            dtype.categories if dtype.categories is not None else self.categories
+        )
+        new_ordered = dtype.ordered if dtype.ordered is not None else self.ordered
 
         return CategoricalDtype(new_categories, new_ordered)
 
@@ -593,16 +605,6 @@ def ordered(self) -> Ordered:
         """
         Whether the categories have an ordered relationship.
         """
-        # TODO: remove if block when ordered=None as default is deprecated
-        if self._ordered_from_sentinel and self._ordered is None:
-            # warn when accessing ordered if ordered=None and None was not
-            # explicitly passed to the constructor
-            msg = (
-                "Constructing a CategoricalDtype without specifying "
-                "`ordered` will default to `ordered=False` in a future "
-                "version; `ordered=None` must be explicitly passed."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=2)
         return self._ordered
 
     @property
@@ -650,15 +652,15 @@ class DatetimeTZDtype(PandasExtensionDtype):
     datetime64[ns, tzfile('/usr/share/zoneinfo/US/Central')]
     """
 
-    type = Timestamp  # type: Type[Timestamp]
-    kind = "M"  # type: str_type
+    type: Type[Timestamp] = Timestamp
+    kind: str_type = "M"
     str = "|M8[ns]"
     num = 101
     base = np.dtype("M8[ns]")
     na_value = NaT
     _metadata = ("unit", "tz")
     _match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
-    _cache = {}  # type: Dict[str_type, PandasExtensionDtype]
+    _cache: Dict[str_type, PandasExtensionDtype] = {}
 
     def __init__(self, unit="ns", tz=None):
         if isinstance(unit, DatetimeTZDtype):
@@ -672,11 +674,11 @@ def __init__(self, unit="ns", tz=None):
                 unit = result.unit
                 tz = result.tz
                 msg = (
-                    "Passing a dtype alias like 'datetime64[ns, {tz}]' "
-                    "to DatetimeTZDtype is deprecated. Use "
+                    f"Passing a dtype alias like 'datetime64[ns, {tz}]' "
+                    "to DatetimeTZDtype is no longer supported. Use "
                     "'DatetimeTZDtype.construct_from_string()' instead."
                 )
-                warnings.warn(msg.format(tz=tz), FutureWarning, stacklevel=2)
+                raise ValueError(msg)
             else:
                 raise ValueError("DatetimeTZDtype only supports ns units")
 
@@ -685,7 +687,7 @@ def __init__(self, unit="ns", tz=None):
             tz = timezones.tz_standardize(tz)
         elif tz is not None:
             raise pytz.UnknownTimeZoneError(tz)
-        elif tz is None:
+        if tz is None:
             raise TypeError("A 'tz' is required.")
 
         self._unit = unit
@@ -708,7 +710,7 @@ def tz(self):
     @classmethod
     def construct_array_type(cls):
         """
-        Return the array type associated with this dtype
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -719,7 +721,7 @@ def construct_array_type(cls):
         return DatetimeArray
 
     @classmethod
-    def construct_from_string(cls, string):
+    def construct_from_string(cls, string: str_type):
         """
         Construct a DatetimeTZDtype from a string.
 
@@ -735,34 +737,39 @@ def construct_from_string(cls, string):
         >>> DatetimeTZDtype.construct_from_string('datetime64[ns, UTC]')
         datetime64[ns, UTC]
         """
-        if isinstance(string, str):
-            msg = "Could not construct DatetimeTZDtype from '{}'"
-            try:
-                match = cls._match.match(string)
-                if match:
-                    d = match.groupdict()
-                    return cls(unit=d["unit"], tz=d["tz"])
-            except Exception:
-                # TODO(py3): Change this pass to `raise TypeError(msg) from e`
-                pass
-            raise TypeError(msg.format(string))
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
 
-        raise TypeError("Could not construct DatetimeTZDtype")
+        msg = f"Cannot construct a 'DatetimeTZDtype' from '{string}'"
+        match = cls._match.match(string)
+        if match:
+            d = match.groupdict()
+            try:
+                return cls(unit=d["unit"], tz=d["tz"])
+            except (KeyError, TypeError, ValueError) as err:
+                # KeyError if maybe_get_tz tries and fails to get a
+                #  pytz timezone (actually pytz.UnknownTimeZoneError).
+                # TypeError if we pass a nonsense tz;
+                # ValueError if we pass a unit other than "ns"
+                raise TypeError(msg) from err
+        raise TypeError(msg)
 
-    def __str__(self):
-        return "datetime64[{unit}, {tz}]".format(unit=self.unit, tz=self.tz)
+    def __str__(self) -> str_type:
+        return f"datetime64[{self.unit}, {self.tz}]"
 
     @property
-    def name(self):
+    def name(self) -> str_type:
         """A string representation of the dtype."""
         return str(self)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         # make myself hashable
         # TODO: update this.
         return hash(str(self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             return other == self.name
 
@@ -790,7 +797,7 @@ class PeriodDtype(PandasExtensionDtype):
     Parameters
     ----------
     freq : str or DateOffset
-        The frequency of this PeriodDtype
+        The frequency of this PeriodDtype.
 
     Attributes
     ----------
@@ -809,14 +816,14 @@ class PeriodDtype(PandasExtensionDtype):
     period[M]
     """
 
-    type = Period  # type: Type[Period]
-    kind = "O"  # type: str_type
+    type: Type[Period] = Period
+    kind: str_type = "O"
     str = "|O08"
     base = np.dtype("O")
     num = 102
     _metadata = ("freq",)
     _match = re.compile(r"(P|p)eriod\[(?P<freq>.+)\]")
-    _cache = {}  # type: Dict[str_type, PandasExtensionDtype]
+    _cache: Dict[str_type, PandasExtensionDtype] = {}
 
     def __new__(cls, freq=None):
         """
@@ -884,24 +891,28 @@ def construct_from_string(cls, string):
                 return cls(freq=string)
             except ValueError:
                 pass
-        raise TypeError("could not construct PeriodDtype")
+        if isinstance(string, str):
+            msg = f"Cannot construct a 'PeriodDtype' from '{string}'"
+        else:
+            msg = f"'construct_from_string' expects a string, got {type(string)}"
+        raise TypeError(msg)
 
-    def __str__(self):
+    def __str__(self) -> str_type:
         return self.name
 
     @property
-    def name(self):
-        return "period[{freq}]".format(freq=self.freq.freqstr)
+    def name(self) -> str_type:
+        return f"period[{self.freq.freqstr}]"
 
     @property
     def na_value(self):
         return NaT
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         # make myself hashable
         return hash(str(self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             return other == self.name or other == self.name.title()
 
@@ -914,7 +925,7 @@ def __setstate__(self, state):
         self._freq = state["freq"]
 
     @classmethod
-    def is_dtype(cls, dtype):
+    def is_dtype(cls, dtype) -> bool:
         """
         Return a boolean if we if the passed type is an actual dtype that we
         can match (via string or type)
@@ -937,10 +948,37 @@ def is_dtype(cls, dtype):
 
     @classmethod
     def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
         from pandas.core.arrays import PeriodArray
 
         return PeriodArray
 
+    def __from_arrow__(self, array):
+        """Construct PeriodArray from pyarrow Array/ChunkedArray."""
+        import pyarrow
+        from pandas.core.arrays import PeriodArray
+        from pandas.core.arrays._arrow_utils import pyarrow_array_to_numpy_and_mask
+
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            chunks = array.chunks
+
+        results = []
+        for arr in chunks:
+            data, mask = pyarrow_array_to_numpy_and_mask(arr, dtype="int64")
+            parr = PeriodArray(data.copy(), freq=self.freq, copy=False)
+            parr[~mask] = NaT
+            results.append(parr)
+
+        return PeriodArray._concat_same_type(results)
+
 
 @register_extension_dtype
 class IntervalDtype(PandasExtensionDtype):
@@ -969,13 +1007,13 @@ class IntervalDtype(PandasExtensionDtype):
     """
 
     name = "interval"
-    kind = None  # type: Optional[str_type]
+    kind: str_type = "O"
     str = "|O08"
     base = np.dtype("O")
     num = 103
     _metadata = ("subtype",)
     _match = re.compile(r"(I|i)nterval\[(?P<subtype>.+)\]")
-    _cache = {}  # type: Dict[str_type, PandasExtensionDtype]
+    _cache: Dict[str_type, PandasExtensionDtype] = {}
 
     def __new__(cls, subtype=None):
         from pandas.core.dtypes.common import (
@@ -1031,7 +1069,7 @@ def subtype(self):
     @classmethod
     def construct_array_type(cls):
         """
-        Return the array type associated with this dtype
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -1048,13 +1086,15 @@ def construct_from_string(cls, string):
         if its not possible
         """
         if not isinstance(string, str):
-            msg = "a string needs to be passed, got type {typ}"
-            raise TypeError(msg.format(typ=type(string)))
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
 
         if string.lower() == "interval" or cls._match.search(string) is not None:
             return cls(string)
 
         msg = (
+            f"Cannot construct a 'IntervalDtype' from '{string}'.\n\n"
             "Incorrectly formatted string passed to constructor. "
             "Valid formats include Interval or Interval[dtype] "
             "where dtype is numeric, datetime, or timedelta"
@@ -1065,16 +1105,16 @@ def construct_from_string(cls, string):
     def type(self):
         return Interval
 
-    def __str__(self):
+    def __str__(self) -> str_type:
         if self.subtype is None:
             return "interval"
-        return "interval[{subtype}]".format(subtype=self.subtype)
+        return f"interval[{self.subtype}]"
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         # make myself hashable
         return hash(str(self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             return other.lower() in (self.name.lower(), str(self).lower())
         elif not isinstance(other, IntervalDtype):
@@ -1094,7 +1134,7 @@ def __setstate__(self, state):
         self._subtype = state["subtype"]
 
     @classmethod
-    def is_dtype(cls, dtype):
+    def is_dtype(cls, dtype) -> bool:
         """
         Return a boolean if we if the passed type is an actual dtype that we
         can match (via string or type)
@@ -1112,3 +1152,22 @@ def is_dtype(cls, dtype):
             else:
                 return False
         return super().is_dtype(dtype)
+
+    def __from_arrow__(self, array):
+        """Construct IntervalArray from pyarrow Array/ChunkedArray."""
+        import pyarrow
+        from pandas.core.arrays import IntervalArray
+
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            chunks = array.chunks
+
+        results = []
+        for arr in chunks:
+            left = np.asarray(arr.storage.field("left"), dtype=self.subtype)
+            right = np.asarray(arr.storage.field("right"), dtype=self.subtype)
+            iarr = IntervalArray.from_arrays(left, right, closed=array.type.closed)
+            results.append(iarr)
+
+        return IntervalArray._concat_same_type(results)
diff --git a/pandas/core/dtypes/generic.py b/pandas/core/dtypes/generic.py
index de41644f09b66..435d80b2c4dfb 100644
--- a/pandas/core/dtypes/generic.py
+++ b/pandas/core/dtypes/generic.py
@@ -4,8 +4,11 @@
 # define abstract base classes to enable isinstance type checking on our
 # objects
 def create_pandas_abc_type(name, attr, comp):
-    @classmethod
-    def _check(cls, inst):
+
+    # https://github.com/python/mypy/issues/1006
+    # error: 'classmethod' used with a non-method
+    @classmethod  # type: ignore
+    def _check(cls, inst) -> bool:
         return getattr(inst, attr, "_typ") in comp
 
     dct = dict(__instancecheck__=_check, __subclasscheck__=_check)
@@ -52,15 +55,8 @@ def _check(cls, inst):
 
 ABCSeries = create_pandas_abc_type("ABCSeries", "_typ", ("series",))
 ABCDataFrame = create_pandas_abc_type("ABCDataFrame", "_typ", ("dataframe",))
-ABCSparseDataFrame = create_pandas_abc_type(
-    "ABCSparseDataFrame", "_subtyp", ("sparse_frame",)
-)
-ABCSparseSeries = create_pandas_abc_type(
-    "ABCSparseSeries", "_subtyp", ("sparse_series", "sparse_time_series")
-)
-ABCSparseArray = create_pandas_abc_type(
-    "ABCSparseArray", "_subtyp", ("sparse_array", "sparse_series")
-)
+
+ABCSparseArray = create_pandas_abc_type("ABCSparseArray", "_subtyp", ("sparse_array",))
 ABCCategorical = create_pandas_abc_type("ABCCategorical", "_typ", ("categorical"))
 ABCDatetimeArray = create_pandas_abc_type("ABCDatetimeArray", "_typ", ("datetimearray"))
 ABCTimedeltaArray = create_pandas_abc_type(
@@ -79,7 +75,7 @@ def _check(cls, inst):
 
 
 class _ABCGeneric(type):
-    def __instancecheck__(cls, inst):
+    def __instancecheck__(cls, inst) -> bool:
         return hasattr(inst, "_data")
 
 
diff --git a/pandas/core/dtypes/inference.py b/pandas/core/dtypes/inference.py
index 461b5cc6232cd..a9cd696633273 100644
--- a/pandas/core/dtypes/inference.py
+++ b/pandas/core/dtypes/inference.py
@@ -25,8 +25,10 @@
 
 is_list_like = lib.is_list_like
 
+is_iterator = lib.is_iterator
 
-def is_number(obj):
+
+def is_number(obj) -> bool:
     """
     Check if the object is a number.
 
@@ -67,31 +69,7 @@ def is_number(obj):
     return isinstance(obj, (Number, np.number))
 
 
-def is_string_like(obj):
-    """
-    Check if the object is a string.
-
-    Parameters
-    ----------
-    obj : The object to check
-
-    Examples
-    --------
-    >>> is_string_like("foo")
-    True
-    >>> is_string_like(1)
-    False
-
-    Returns
-    -------
-    is_str_like : bool
-        Whether `obj` is a string or not.
-    """
-
-    return isinstance(obj, str)
-
-
-def _iterable_not_string(obj):
+def _iterable_not_string(obj) -> bool:
     """
     Check if the object is an iterable but not a string.
 
@@ -117,41 +95,7 @@ def _iterable_not_string(obj):
     return isinstance(obj, abc.Iterable) and not isinstance(obj, str)
 
 
-def is_iterator(obj):
-    """
-    Check if the object is an iterator.
-
-    For example, lists are considered iterators
-    but not strings or datetime objects.
-
-    Parameters
-    ----------
-    obj : The object to check
-
-    Returns
-    -------
-    is_iter : bool
-        Whether `obj` is an iterator.
-
-    Examples
-    --------
-    >>> is_iterator([1, 2, 3])
-    True
-    >>> is_iterator(datetime(2017, 1, 1))
-    False
-    >>> is_iterator("foo")
-    False
-    >>> is_iterator(1)
-    False
-    """
-
-    if not hasattr(obj, "__iter__"):
-        return False
-
-    return hasattr(obj, "__next__")
-
-
-def is_file_like(obj):
+def is_file_like(obj) -> bool:
     """
     Check if the object is a file-like object.
 
@@ -162,8 +106,6 @@ def is_file_like(obj):
     Note: file-like objects must be iterable, but
     iterable objects need not be file-like.
 
-    .. versionadded:: 0.20.0
-
     Parameters
     ----------
     obj : The object to check
@@ -175,7 +117,8 @@ def is_file_like(obj):
 
     Examples
     --------
-    >>> buffer(StringIO("data"))
+    >>> import io
+    >>> buffer = io.StringIO("data")
     >>> is_file_like(buffer)
     True
     >>> is_file_like([1, 2, 3])
@@ -191,7 +134,7 @@ def is_file_like(obj):
     return True
 
 
-def is_re(obj):
+def is_re(obj) -> bool:
     """
     Check if the object is a regex pattern instance.
 
@@ -214,7 +157,7 @@ def is_re(obj):
     return isinstance(obj, Pattern)
 
 
-def is_re_compilable(obj):
+def is_re_compilable(obj) -> bool:
     """
     Check if the object can be compiled into a regex pattern instance.
 
@@ -243,7 +186,7 @@ def is_re_compilable(obj):
         return True
 
 
-def is_array_like(obj):
+def is_array_like(obj) -> bool:
     """
     Check if the object is array-like.
 
@@ -276,13 +219,11 @@ def is_array_like(obj):
     return is_list_like(obj) and hasattr(obj, "dtype")
 
 
-def is_nested_list_like(obj):
+def is_nested_list_like(obj) -> bool:
     """
     Check if the object is list-like, and that all of its elements
     are also list-like.
 
-    .. versionadded:: 0.20.0
-
     Parameters
     ----------
     obj : The object to check
@@ -324,7 +265,7 @@ def is_nested_list_like(obj):
     )
 
 
-def is_dict_like(obj):
+def is_dict_like(obj) -> bool:
     """
     Check if the object is dict-like.
 
@@ -356,7 +297,7 @@ def is_dict_like(obj):
     )
 
 
-def is_named_tuple(obj):
+def is_named_tuple(obj) -> bool:
     """
     Check if the object is a named tuple.
 
@@ -371,6 +312,7 @@ def is_named_tuple(obj):
 
     Examples
     --------
+    >>> from collections import namedtuple
     >>> Point = namedtuple("Point", ["x", "y"])
     >>> p = Point(1, 2)
     >>>
@@ -383,7 +325,7 @@ def is_named_tuple(obj):
     return isinstance(obj, tuple) and hasattr(obj, "_fields")
 
 
-def is_hashable(obj):
+def is_hashable(obj) -> bool:
     """
     Return True if hash(obj) will succeed, False otherwise.
 
@@ -399,6 +341,7 @@ def is_hashable(obj):
 
     Examples
     --------
+    >>> import collections
     >>> a = ([],)
     >>> isinstance(a, collections.abc.Hashable)
     True
@@ -420,7 +363,7 @@ def is_hashable(obj):
         return True
 
 
-def is_sequence(obj):
+def is_sequence(obj) -> bool:
     """
     Check if the object is a sequence of objects.
     String types are not included as sequences here.
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index 056cd2222af3c..0bc754b3e8fb3 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -8,8 +8,9 @@
 from pandas._libs import lib
 import pandas._libs.missing as libmissing
 from pandas._libs.tslibs import NaT, iNaT
+from pandas._typing import DtypeObj
 
-from .common import (
+from pandas.core.dtypes.common import (
     _NS_DTYPE,
     _TD_DTYPE,
     ensure_object,
@@ -17,7 +18,6 @@
     is_complex_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
-    is_datetimelike,
     is_datetimelike_v_numeric,
     is_dtype_equal,
     is_extension_array_dtype,
@@ -32,7 +32,7 @@
     needs_i8_conversion,
     pandas_dtype,
 )
-from .generic import (
+from pandas.core.dtypes.generic import (
     ABCDatetimeArray,
     ABCExtensionArray,
     ABCGeneric,
@@ -41,7 +41,7 @@
     ABCSeries,
     ABCTimedeltaArray,
 )
-from .inference import is_list_like
+from pandas.core.dtypes.inference import is_list_like
 
 isposinf_scalar = libmissing.isposinf_scalar
 isneginf_scalar = libmissing.isneginf_scalar
@@ -81,6 +81,9 @@ def isna(obj):
     >>> pd.isna('dog')
     False
 
+    >>> pd.isna(pd.NA)
+    True
+
     >>> pd.isna(np.nan)
     True
 
@@ -128,6 +131,7 @@ def isna(obj):
 
 
 def _isna_new(obj):
+
     if is_scalar(obj):
         return libmissing.checknull(obj)
     # hack (for now) because MI registers as ndarray
@@ -158,7 +162,8 @@ def _isna_new(obj):
 
 
 def _isna_old(obj):
-    """Detect missing values. Treat None, NaN, INF, -INF as null.
+    """
+    Detect missing values, treating None, NaN, INF, -INF as null.
 
     Parameters
     ----------
@@ -175,7 +180,7 @@ def _isna_old(obj):
         raise NotImplementedError("isna is not defined for MultiIndex")
     elif isinstance(obj, type):
         return False
-    elif isinstance(obj, (ABCSeries, np.ndarray, ABCIndexClass)):
+    elif isinstance(obj, (ABCSeries, np.ndarray, ABCIndexClass, ABCExtensionArray)):
         return _isna_ndarraylike_old(obj)
     elif isinstance(obj, ABCGeneric):
         return obj._constructor(obj._data.isna(func=_isna_old))
@@ -191,7 +196,9 @@ def _isna_old(obj):
 
 
 def _use_inf_as_na(key):
-    """Option change callback for na/inf behaviour
+    """
+    Option change callback for na/inf behaviour.
+
     Choose which replacement for numpy.isnan / -numpy.isfinite is used.
 
     Parameters
@@ -206,7 +213,7 @@ def _use_inf_as_na(key):
     This approach to setting global module values is discussed and
     approved here:
 
-    * http://stackoverflow.com/questions/4859217/
+    * https://stackoverflow.com/questions/4859217/
       programmatically-creating-variables-in-python/4859312#4859312
     """
     flag = get_option(key)
@@ -324,6 +331,9 @@ def notna(obj):
     >>> pd.notna('dog')
     True
 
+    >>> pd.notna(pd.NA)
+    False
+
     >>> pd.notna(np.nan)
     False
 
@@ -373,7 +383,7 @@ def notna(obj):
 notnull = notna
 
 
-def _isna_compat(arr, fill_value=np.nan):
+def _isna_compat(arr, fill_value=np.nan) -> bool:
     """
     Parameters
     ----------
@@ -390,7 +400,7 @@ def _isna_compat(arr, fill_value=np.nan):
     return True
 
 
-def array_equivalent(left, right, strict_nan=False):
+def array_equivalent(left, right, strict_nan: bool = False) -> bool:
     """
     True if two arrays, left and right, have equal non-NaN elements, and NaNs
     in corresponding locations.  False otherwise. It is assumed that left and
@@ -441,12 +451,23 @@ def array_equivalent(left, right, strict_nan=False):
             if left_value is NaT and right_value is not NaT:
                 return False
 
+            elif left_value is libmissing.NA and right_value is not libmissing.NA:
+                return False
+
             elif isinstance(left_value, float) and np.isnan(left_value):
                 if not isinstance(right_value, float) or not np.isnan(right_value):
                     return False
             else:
-                if left_value != right_value:
-                    return False
+                try:
+                    if np.any(np.asarray(left_value != right_value)):
+                        return False
+                except TypeError as err:
+                    if "Cannot compare tz-naive" in str(err):
+                        # tzawareness compat failure, see GH#28507
+                        return False
+                    elif "boolean value of NA is ambiguous" in str(err):
+                        return False
+                    raise
         return True
 
     # NaNs can occur in float and complex arrays.
@@ -457,12 +478,12 @@ def array_equivalent(left, right, strict_nan=False):
             return True
         return ((left == right) | (isna(left) & isna(right))).all()
 
-    # numpy will will not allow this type of datetimelike vs integer comparison
     elif is_datetimelike_v_numeric(left, right):
+        # GH#29553 avoid numpy deprecation warning
         return False
 
-    # M8/m8
-    elif needs_i8_conversion(left) and needs_i8_conversion(right):
+    elif needs_i8_conversion(left) or needs_i8_conversion(right):
+        # datetime64, timedelta64, Period
         if not is_dtype_equal(left.dtype, right.dtype):
             return False
 
@@ -487,7 +508,7 @@ def _infer_fill_value(val):
     if not is_list_like(val):
         val = [val]
     val = np.array(val, copy=False)
-    if is_datetimelike(val):
+    if needs_i8_conversion(val):
         return np.array("NaT", dtype=val.dtype)
     elif is_object_dtype(val.dtype):
         dtype = lib.infer_dtype(ensure_object(val), skipna=False)
@@ -507,14 +528,14 @@ def _maybe_fill(arr, fill_value=np.nan):
     return arr
 
 
-def na_value_for_dtype(dtype, compat=True):
+def na_value_for_dtype(dtype, compat: bool = True):
     """
     Return a dtype compat na value
 
     Parameters
     ----------
     dtype : string / dtype
-    compat : boolean, default True
+    compat : bool, default True
 
     Returns
     -------
@@ -565,7 +586,7 @@ def remove_na_arraylike(arr):
         return arr[notna(lib.values_from_object(arr))]
 
 
-def is_valid_nat_for_dtype(obj, dtype):
+def is_valid_nat_for_dtype(obj, dtype: DtypeObj) -> bool:
     """
     isna check that excludes incompatible dtypes
 
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index f1ed3a125f60c..0fca02f110031 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -8,14 +8,31 @@
 alignment and a host of useful data manipulation methods having to do with the
 labeling information
 """
+
 import collections
-from collections import OrderedDict, abc
-import functools
+from collections import abc
+import datetime
 from io import StringIO
 import itertools
 import sys
 from textwrap import dedent
-from typing import FrozenSet, List, Optional, Set, Tuple, Type, Union
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 import warnings
 
 import numpy as np
@@ -23,8 +40,10 @@
 
 from pandas._config import get_option
 
-from pandas._libs import algos as libalgos, lib
-from pandas.compat import PY36, raise_with_traceback
+from pandas._libs import algos as libalgos, lib, properties
+from pandas._typing import Axes, Axis, Dtype, FilePathOrBuffer, Label, Level, Renamer
+from pandas.compat import PY37
+from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import (
     Appender,
@@ -32,7 +51,11 @@
     deprecate_kwarg,
     rewrite_axis_style_signature,
 )
-from pandas.util._validators import validate_axis_style_args, validate_bool_kwarg
+from pandas.util._validators import (
+    validate_axis_style_args,
+    validate_bool_kwarg,
+    validate_percentile,
+)
 
 from pandas.core.dtypes.cast import (
     cast_scalar_to_array,
@@ -46,6 +69,7 @@
     maybe_infer_to_datetimelike,
     maybe_upcast,
     maybe_upcast_putmask,
+    validate_numeric_casting,
 )
 from pandas.core.dtypes.common import (
     ensure_float64,
@@ -53,12 +77,9 @@
     ensure_platform_int,
     infer_dtype_from_object,
     is_bool_dtype,
-    is_datetime64_any_dtype,
-    is_datetime64tz_dtype,
     is_dict_like,
     is_dtype_equal,
     is_extension_array_dtype,
-    is_extension_type,
     is_float_dtype,
     is_hashable,
     is_integer,
@@ -66,7 +87,6 @@
     is_iterator,
     is_list_like,
     is_named_tuple,
-    is_nested_list_like,
     is_object_dtype,
     is_scalar,
     is_sequence,
@@ -74,21 +94,22 @@
 )
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
+    ABCDatetimeIndex,
     ABCIndexClass,
     ABCMultiIndex,
+    ABCPeriodIndex,
     ABCSeries,
 )
 from pandas.core.dtypes.missing import isna, notna
 
-from pandas._typing import Axes, Dtype
 from pandas.core import algorithms, common as com, nanops, ops
 from pandas.core.accessor import CachedAccessor
 from pandas.core.arrays import Categorical, ExtensionArray
 from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin as DatetimeLikeArray
 from pandas.core.arrays.sparse import SparseFrameAccessor
 from pandas.core.generic import NDFrame, _shared_docs
-from pandas.core.index import Index, ensure_index, ensure_index_from_sequences
 from pandas.core.indexes import base as ibase
+from pandas.core.indexes.api import Index, ensure_index, ensure_index_from_sequences
 from pandas.core.indexes.datetimes import DatetimeIndex
 from pandas.core.indexes.multi import maybe_droplevels
 from pandas.core.indexes.period import PeriodIndex
@@ -107,10 +128,15 @@
 from pandas.core.ops.missing import dispatch_fill_zeros
 from pandas.core.series import Series
 
+from pandas.io.common import get_filepath_or_buffer
 from pandas.io.formats import console, format as fmt
 from pandas.io.formats.printing import pprint_thing
 import pandas.plotting
 
+if TYPE_CHECKING:
+    from pandas.core.groupby.generic import DataFrameGroupBy
+    from pandas.io.formats.style import Styler
+
 # ---------------------------------------------------------------------
 # Docstring templates
 
@@ -126,11 +152,12 @@
             Name or list of names to sort by.
 
             - if `axis` is 0 or `'index'` then `by` may contain index
-              levels and/or column labels
+              levels and/or column labels.
             - if `axis` is 1 or `'columns'` then `by` may contain column
-              levels and/or index labels
+              levels and/or index labels.
 
             .. versionchanged:: 0.23.0
+
                Allow specifying index or column level names.""",
     versionadded_to_excel="",
     optional_labels="""labels : array-like, optional
@@ -237,7 +264,6 @@
 
 Examples
 --------
-
 >>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
 ...                     'value': [1, 2, 3, 5]})
 >>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
@@ -297,15 +323,17 @@
 
 class DataFrame(NDFrame):
     """
-    Two-dimensional size-mutable, potentially heterogeneous tabular data
-    structure with labeled axes (rows and columns). Arithmetic operations
-    align on both row and column labels. Can be thought of as a dict-like
-    container for Series objects. The primary pandas data structure.
+    Two-dimensional, size-mutable, potentially heterogeneous tabular data.
+
+    Data structure also contains labeled axes (rows and columns).
+    Arithmetic operations align on both row and column labels. Can be
+    thought of as a dict-like container for Series objects. The primary
+    pandas data structure.
 
     Parameters
     ----------
     data : ndarray (structured or homogeneous), Iterable, dict, or DataFrame
-        Dict can contain Series, arrays, constants, or list-like objects
+        Dict can contain Series, arrays, constants, or list-like objects.
 
         .. versionchanged:: 0.23.0
            If data is a dict, column order follows insertion-order for
@@ -313,25 +341,26 @@ class DataFrame(NDFrame):
 
         .. versionchanged:: 0.25.0
            If data is a list of dicts, column order follows insertion-order
-           Python 3.6 and later.
+           for Python 3.6 and later.
 
     index : Index or array-like
         Index to use for resulting frame. Will default to RangeIndex if
-        no indexing information part of input data and no index provided
+        no indexing information part of input data and no index provided.
     columns : Index or array-like
         Column labels to use for resulting frame. Will default to
-        RangeIndex (0, 1, 2, ..., n) if no column labels are provided
+        RangeIndex (0, 1, 2, ..., n) if no column labels are provided.
     dtype : dtype, default None
-        Data type to force. Only a single dtype is allowed. If None, infer
-    copy : boolean, default False
-        Copy data from inputs. Only affects DataFrame / 2d ndarray input
+        Data type to force. Only a single dtype is allowed. If None, infer.
+    copy : bool, default False
+        Copy data from inputs. Only affects DataFrame / 2d ndarray input.
 
     See Also
     --------
     DataFrame.from_records : Constructor from tuples, also record arrays.
     DataFrame.from_dict : From dicts of Series, arrays, or dicts.
-    DataFrame.from_items : From sequence of (key, value) pairs
-        read_csv, pandas.read_table, pandas.read_clipboard.
+    read_csv
+    read_table
+    read_clipboard
 
     Examples
     --------
@@ -370,15 +399,16 @@ class DataFrame(NDFrame):
     2  7  8  9
     """
 
+    _internal_names_set = {"columns", "index"} | NDFrame._internal_names_set
+    _typ = "dataframe"
+
     @property
     def _constructor(self) -> Type["DataFrame"]:
         return DataFrame
 
-    _constructor_sliced = Series  # type: Type[Series]
-    _deprecations = NDFrame._deprecations | frozenset(
-        ["from_items"]
-    )  # type: FrozenSet[str]
-    _accessors = set()  # type: Set[str]
+    _constructor_sliced: Type[Series] = Series
+    _deprecations: FrozenSet[str] = NDFrame._deprecations | frozenset([])
+    _accessors: Set[str] = {"sparse"}
 
     @property
     def _constructor_expanddim(self):
@@ -441,7 +471,7 @@ def __init__(
 
         # For data is list-like, or Iterable (will consume into list)
         elif isinstance(data, abc.Iterable) and not isinstance(data, (str, bytes)):
-            if not isinstance(data, abc.Sequence):
+            if not isinstance(data, (abc.Sequence, ExtensionArray)):
                 data = list(data)
             if len(data) > 0:
                 if is_list_like(data[0]) and getattr(data[0], "ndim", 1) == 1:
@@ -467,12 +497,12 @@ def __init__(
         else:
             try:
                 arr = np.array(data, dtype=dtype, copy=copy)
-            except (ValueError, TypeError) as e:
+            except (ValueError, TypeError) as err:
                 exc = TypeError(
                     "DataFrame constructor called with "
-                    "incompatible data and dtype: {e}".format(e=e)
+                    f"incompatible data and dtype: {err}"
                 )
-                raise_with_traceback(exc)
+                raise exc from err
 
             if arr.ndim == 0 and index is not None and columns is not None:
                 values = cast_scalar_to_array(
@@ -536,6 +566,13 @@ def _is_homogeneous_type(self) -> bool:
         -------
         bool
 
+        See Also
+        --------
+        Index._is_homogeneous_type : Whether the object has a single
+            dtype.
+        MultiIndex._is_homogeneous_type : Whether all the levels of a
+            MultiIndex have the same dtype.
+
         Examples
         --------
         >>> DataFrame({"A": [1, 2], "B": [3, 4]})._is_homogeneous_type
@@ -559,25 +596,24 @@ def _is_homogeneous_type(self) -> bool:
     # ----------------------------------------------------------------------
     # Rendering Methods
 
-    def _repr_fits_vertical_(self):
+    def _repr_fits_vertical_(self) -> bool:
         """
         Check length against max_rows.
         """
         max_rows = get_option("display.max_rows")
         return len(self) <= max_rows
 
-    def _repr_fits_horizontal_(self, ignore_width=False):
+    def _repr_fits_horizontal_(self, ignore_width: bool = False) -> bool:
         """
         Check if full repr fits in horizontal boundaries imposed by the display
         options width and max_columns.
 
-        In case off non-interactive session, no boundaries apply.
+        In case of non-interactive session, no boundaries apply.
 
         `ignore_width` is here so ipnb+HTML output can behave the way
         users expect. display.max_columns remains in effect.
         GH3541, GH3573
         """
-
         width, height = console.get_console_size()
         max_columns = get_option("display.max_columns")
         nb_columns = len(self.columns)
@@ -620,7 +656,7 @@ def _repr_fits_horizontal_(self, ignore_width=False):
 
         return repr_width < width
 
-    def _info_repr(self):
+    def _info_repr(self) -> bool:
         """
         True if the repr should show the info view.
         """
@@ -629,7 +665,7 @@ def _info_repr(self):
             self._repr_fits_horizontal_() and self._repr_fits_vertical_()
         )
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Return a string representation for a particular DataFrame.
         """
@@ -641,6 +677,7 @@ def __repr__(self):
         max_rows = get_option("display.max_rows")
         min_rows = get_option("display.min_rows")
         max_cols = get_option("display.max_columns")
+        max_colwidth = get_option("display.max_colwidth")
         show_dimensions = get_option("display.show_dimensions")
         if get_option("display.expand_frame_repr"):
             width, _ = console.get_console_size()
@@ -652,12 +689,13 @@ def __repr__(self):
             min_rows=min_rows,
             max_cols=max_cols,
             line_width=width,
+            max_colwidth=max_colwidth,
             show_dimensions=show_dimensions,
         )
 
         return buf.getvalue()
 
-    def _repr_html_(self):
+    def _repr_html_(self) -> Optional[str]:
         """
         Return a html representation for a particular DataFrame.
 
@@ -704,6 +742,7 @@ def _repr_html_(self):
             return None
 
     @Substitution(
+        header_type="bool or sequence",
         header="Write out the column names. If a list of strings "
         "is given, it is assumed to be aliases for the "
         "column names",
@@ -713,29 +752,39 @@ def _repr_html_(self):
     @Substitution(shared_params=fmt.common_docstring, returns=fmt.return_docstring)
     def to_string(
         self,
-        buf=None,
-        columns=None,
-        col_space=None,
-        header=True,
-        index=True,
-        na_rep="NaN",
-        formatters=None,
-        float_format=None,
-        sparsify=None,
-        index_names=True,
-        justify=None,
-        max_rows=None,
-        min_rows=None,
-        max_cols=None,
-        show_dimensions=False,
-        decimal=".",
-        line_width=None,
-    ):
+        buf: Optional[FilePathOrBuffer[str]] = None,
+        columns: Optional[Sequence[str]] = None,
+        col_space: Optional[int] = None,
+        header: Union[bool, Sequence[str]] = True,
+        index: bool = True,
+        na_rep: str = "NaN",
+        formatters: Optional[fmt.formatters_type] = None,
+        float_format: Optional[fmt.float_format_type] = None,
+        sparsify: Optional[bool] = None,
+        index_names: bool = True,
+        justify: Optional[str] = None,
+        max_rows: Optional[int] = None,
+        min_rows: Optional[int] = None,
+        max_cols: Optional[int] = None,
+        show_dimensions: bool = False,
+        decimal: str = ".",
+        line_width: Optional[int] = None,
+        max_colwidth: Optional[int] = None,
+        encoding: Optional[str] = None,
+    ) -> Optional[str]:
         """
         Render a DataFrame to a console-friendly tabular output.
         %(shared_params)s
         line_width : int, optional
             Width to wrap a line in characters.
+        max_colwidth : int, optional
+            Max width to truncate each column in characters. By default, no limit.
+
+            .. versionadded:: 1.0.0
+        encoding : str, default "utf-8"
+            Set character encoding.
+
+            .. versionadded:: 1.0
         %(returns)s
         See Also
         --------
@@ -751,35 +800,39 @@ def to_string(
         1     2     5
         2     3     6
         """
+        from pandas import option_context
 
-        formatter = fmt.DataFrameFormatter(
-            self,
-            columns=columns,
-            col_space=col_space,
-            na_rep=na_rep,
-            formatters=formatters,
-            float_format=float_format,
-            sparsify=sparsify,
-            justify=justify,
-            index_names=index_names,
-            header=header,
-            index=index,
-            min_rows=min_rows,
-            max_rows=max_rows,
-            max_cols=max_cols,
-            show_dimensions=show_dimensions,
-            decimal=decimal,
-            line_width=line_width,
-        )
-        return formatter.to_string(buf=buf)
+        with option_context("display.max_colwidth", max_colwidth):
+            formatter = fmt.DataFrameFormatter(
+                self,
+                columns=columns,
+                col_space=col_space,
+                na_rep=na_rep,
+                formatters=formatters,
+                float_format=float_format,
+                sparsify=sparsify,
+                justify=justify,
+                index_names=index_names,
+                header=header,
+                index=index,
+                min_rows=min_rows,
+                max_rows=max_rows,
+                max_cols=max_cols,
+                show_dimensions=show_dimensions,
+                decimal=decimal,
+                line_width=line_width,
+            )
+            return formatter.to_string(buf=buf, encoding=encoding)
 
     # ----------------------------------------------------------------------
 
     @property
-    def style(self):
+    def style(self) -> "Styler":
         """
-        Property returning a Styler object containing methods for
-        building a styled HTML representation fo the DataFrame.
+        Returns a Styler object.
+
+        Contains methods for building a styled HTML representation of the DataFrame.
+        a styled HTML representation fo the DataFrame.
 
         See Also
         --------
@@ -818,12 +871,12 @@ def style(self):
         ...                   index=['panda', 'polar', 'koala'])
         >>> df
                 species   population
-        panda 	bear 	  1864
-        polar 	bear 	  22000
-        koala 	marsupial 80000
+        panda   bear      1864
+        polar   bear      22000
+        koala   marsupial 80000
         >>> for label, content in df.items():
-        ...     print('label:', label)
-        ...     print('content:', content, sep='\n')
+        ...     print(f'label: {label}')
+        ...     print(f'content: {content}', sep='\n')
         ...
         label: species
         content:
@@ -840,7 +893,7 @@ def style(self):
         """
 
     @Appender(_shared_docs["items"])
-    def items(self):
+    def items(self) -> Iterable[Tuple[Optional[Hashable], Series]]:
         if self.columns.is_unique and hasattr(self, "_item_cache"):
             for k in self.columns:
                 yield k, self._get_item_cache(k)
@@ -849,10 +902,10 @@ def items(self):
                 yield k, self._ixs(i, axis=1)
 
     @Appender(_shared_docs["items"])
-    def iteritems(self):
+    def iteritems(self) -> Iterable[Tuple[Optional[Hashable], Series]]:
         yield from self.items()
 
-    def iterrows(self):
+    def iterrows(self) -> Iterable[Tuple[Optional[Hashable], Series]]:
         """
         Iterate over DataFrame rows as (index, Series) pairs.
 
@@ -933,7 +986,8 @@ def itertuples(self, index=True, name="Pandas"):
         -----
         The column names will be renamed to positional names if they are
         invalid Python identifiers, repeated, or start with an underscore.
-        With a large number of columns (>255), regular tuples are returned.
+        On python versions < 3.7 regular tuples are returned for DataFrames
+        with a large number of columns (>254).
 
         Examples
         --------
@@ -976,15 +1030,16 @@ def itertuples(self, index=True, name="Pandas"):
         # use integer indexing because of possible duplicate column names
         arrays.extend(self.iloc[:, k] for k in range(len(self.columns)))
 
-        # Python 3 supports at most 255 arguments to constructor
-        if name is not None and len(self.columns) + index < 256:
+        # Python versions before 3.7 support at most 255 arguments to constructors
+        can_return_named_tuples = PY37 or len(self.columns) + index < 255
+        if name is not None and can_return_named_tuples:
             itertuple = collections.namedtuple(name, fields, rename=True)
             return map(itertuple._make, zip(*arrays))
 
         # fallback to regular tuples
         return zip(*arrays)
 
-    def __len__(self):
+    def __len__(self) -> int:
         """
         Returns length of info axis, but here we use the index.
         """
@@ -1082,8 +1137,7 @@ def dot(self, other):
             rvals = np.asarray(other)
             if lvals.shape[1] != rvals.shape[0]:
                 raise ValueError(
-                    "Dot product shape mismatch, "
-                    "{s} vs {r}".format(s=lvals.shape, r=rvals.shape)
+                    f"Dot product shape mismatch, {lvals.shape} vs {rvals.shape}"
                 )
 
         if isinstance(other, DataFrame):
@@ -1099,7 +1153,7 @@ def dot(self, other):
             else:
                 return Series(result, index=left.index)
         else:  # pragma: no cover
-            raise TypeError("unsupported type: {oth}".format(oth=type(other)))
+            raise TypeError(f"unsupported type: {type(other)}")
 
     def __matmul__(self, other):
         """
@@ -1117,7 +1171,7 @@ def __rmatmul__(self, other):
     # IO methods (to / from other formats)
 
     @classmethod
-    def from_dict(cls, data, orient="columns", dtype=None, columns=None):
+    def from_dict(cls, data, orient="columns", dtype=None, columns=None) -> "DataFrame":
         """
         Construct DataFrame from dict of array-like or dicts.
 
@@ -1197,7 +1251,7 @@ def from_dict(cls, data, orient="columns", dtype=None, columns=None):
 
         return cls(data, index=index, columns=columns, dtype=dtype)
 
-    def to_numpy(self, dtype=None, copy=False):
+    def to_numpy(self, dtype=None, copy=False) -> np.ndarray:
         """
         Convert the DataFrame to a NumPy array.
 
@@ -1233,7 +1287,7 @@ def to_numpy(self, dtype=None, copy=False):
         array([[1, 3],
                [2, 4]])
 
-        With heterogenous data, the lowest common type will have to
+        With heterogeneous data, the lowest common type will have to
         be used.
 
         >>> df = pd.DataFrame({"A": [1, 2], "B": [3.0, 4.5]})
@@ -1387,7 +1441,7 @@ def to_dict(self, orient="dict", into=dict):
                 for t in self.itertuples(name=None)
             )
         else:
-            raise ValueError("orient '{o}' not understood".format(o=orient))
+            raise ValueError(f"orient '{orient}' not understood")
 
     def to_gbq(
         self,
@@ -1401,9 +1455,7 @@ def to_gbq(
         location=None,
         progress_bar=True,
         credentials=None,
-        verbose=None,
-        private_key=None,
-    ):
+    ) -> None:
         """
         Write a DataFrame to a Google BigQuery table.
 
@@ -1431,7 +1483,7 @@ def to_gbq(
             Behavior when the destination table exists. Value can be one of:
 
             ``'fail'``
-                If table exists, do nothing.
+                If table exists raise pandas_gbq.gbq.TableCreationError.
             ``'replace'``
                 If table exists, drop it, recreate it, and insert data.
             ``'append'``
@@ -1441,9 +1493,9 @@ def to_gbq(
             when getting user credentials.
 
             .. _local webserver flow:
-                http://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
+                https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
             .. _console flow:
-                http://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
+                https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
 
             *New in version 0.2.0 of pandas-gbq*.
         table_schema : list of dicts, optional
@@ -1477,21 +1529,6 @@ def to_gbq(
             *New in version 0.8.0 of pandas-gbq*.
 
             .. versionadded:: 0.24.0
-        verbose : bool, deprecated
-            Deprecated in pandas-gbq version 0.4.0. Use the `logging module
-            to adjust verbosity instead
-            <https://pandas-gbq.readthedocs.io/en/latest/intro.html#logging>`__.
-        private_key : str, deprecated
-            Deprecated in pandas-gbq version 0.8.0. Use the ``credentials``
-            parameter and
-            :func:`google.oauth2.service_account.Credentials.from_service_account_info`
-            or
-            :func:`google.oauth2.service_account.Credentials.from_service_account_file`
-            instead.
-
-            Service account private key in JSON format. Can be file path
-            or string contents. This is useful for remote server
-            authentication (eg. Jupyter/IPython notebook on remote host).
 
         See Also
         --------
@@ -1512,8 +1549,6 @@ def to_gbq(
             location=location,
             progress_bar=progress_bar,
             credentials=credentials,
-            verbose=verbose,
-            private_key=private_key,
         )
 
     @classmethod
@@ -1525,35 +1560,34 @@ def from_records(
         columns=None,
         coerce_float=False,
         nrows=None,
-    ):
+    ) -> "DataFrame":
         """
         Convert structured or record ndarray to DataFrame.
 
         Parameters
         ----------
         data : ndarray (structured dtype), list of tuples, dict, or DataFrame
-        index : string, list of fields, array-like
+        index : str, list of fields, array-like
             Field of array to use as the index, alternately a specific set of
-            input labels to use
+            input labels to use.
         exclude : sequence, default None
-            Columns or fields to exclude
+            Columns or fields to exclude.
         columns : sequence, default None
             Column names to use. If the passed data do not have names
             associated with them, this argument provides names for the
             columns. Otherwise this argument indicates the order of the columns
             in the result (any names not found in the data will become all-NA
-            columns)
-        coerce_float : boolean, default False
+            columns).
+        coerce_float : bool, default False
             Attempt to convert values of non-string, non-numeric objects (like
-            decimal.Decimal) to floating point, useful for SQL result sets
+            decimal.Decimal) to floating point, useful for SQL result sets.
         nrows : int, default None
-            Number of rows to read if data is an iterator
+            Number of rows to read if data is an iterator.
 
         Returns
         -------
         DataFrame
         """
-
         # Make a copy of the input columns so we can modify it
         if columns is not None:
             columns = ensure_index(columns)
@@ -1628,11 +1662,12 @@ def from_records(
             else:
                 try:
                     index_data = [arrays[arr_columns.get_loc(field)] for field in index]
+                except (KeyError, TypeError):
+                    # raised by get_loc, see GH#29258
+                    result_index = index
+                else:
                     result_index = ensure_index_from_sequences(index_data, names=index)
-
                     exclude.update(index)
-                except Exception:
-                    result_index = index
 
         if any(exclude):
             arr_exclude = [x for x in exclude if x in arr_columns]
@@ -1647,8 +1682,8 @@ def from_records(
         return cls(mgr)
 
     def to_records(
-        self, index=True, convert_datetime64=None, column_dtypes=None, index_dtypes=None
-    ):
+        self, index=True, column_dtypes=None, index_dtypes=None
+    ) -> np.recarray:
         """
         Convert DataFrame to a NumPy record array.
 
@@ -1660,11 +1695,6 @@ def to_records(
         index : bool, default True
             Include index in resulting record array, stored in 'index'
             field or using the index label, if set.
-        convert_datetime64 : bool, default None
-            .. deprecated:: 0.23.0
-
-            Whether to convert the index to datetime.datetime if it is a
-            DatetimeIndex.
         column_dtypes : str, type, dict, default None
             .. versionadded:: 0.24.0
 
@@ -1733,30 +1763,17 @@ def to_records(
         rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
                   dtype=[('I', 'S2'), ('A', '<i8'), ('B', '<f8')])
 
-        >>> index_dtypes = "<S{}".format(df.index.str.len().max())
+        >>> index_dtypes = f"<S{df.index.str.len().max()}"
         >>> df.to_records(index_dtypes=index_dtypes)
         rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
                   dtype=[('I', 'S1'), ('A', '<i8'), ('B', '<f8')])
         """
-
-        if convert_datetime64 is not None:
-            warnings.warn(
-                "The 'convert_datetime64' parameter is "
-                "deprecated and will be removed in a future "
-                "version",
-                FutureWarning,
-                stacklevel=2,
-            )
-
         if index:
-            if is_datetime64_any_dtype(self.index) and convert_datetime64:
-                ix_vals = [self.index.to_pydatetime()]
+            if isinstance(self.index, ABCMultiIndex):
+                # array of tuples to numpy cols. copy copy copy
+                ix_vals = list(map(np.array, zip(*self.index.values)))
             else:
-                if isinstance(self.index, ABCMultiIndex):
-                    # array of tuples to numpy cols. copy copy copy
-                    ix_vals = list(map(np.array, zip(*self.index.values)))
-                else:
-                    ix_vals = [self.index.values]
+                ix_vals = [self.index.values]
 
             arrays = ix_vals + [self[c]._internal_get_values() for c in self.columns]
 
@@ -1766,7 +1783,7 @@ def to_records(
             if isinstance(self.index, ABCMultiIndex):
                 for i, n in enumerate(index_names):
                     if n is None:
-                        index_names[i] = "level_%d" % count
+                        index_names[i] = f"level_{count}"
                         count += 1
             elif index_names[0] is None:
                 index_names = ["index"]
@@ -1824,204 +1841,29 @@ def to_records(
                 formats.append(dtype_mapping)
             else:
                 element = "row" if i < index_len else "column"
-                msg = ("Invalid dtype {dtype} specified for {element} {name}").format(
-                    dtype=dtype_mapping, element=element, name=name
-                )
+                msg = f"Invalid dtype {dtype_mapping} specified for {element} {name}"
                 raise ValueError(msg)
 
         return np.rec.fromarrays(arrays, dtype={"names": names, "formats": formats})
 
     @classmethod
-    def from_items(cls, items, columns=None, orient="columns"):
-        """
-        Construct a DataFrame from a list of tuples.
-
-        .. deprecated:: 0.23.0
-          `from_items` is deprecated and will be removed in a future version.
-          Use :meth:`DataFrame.from_dict(dict(items)) <DataFrame.from_dict>`
-          instead.
-          :meth:`DataFrame.from_dict(OrderedDict(items)) <DataFrame.from_dict>`
-          may be used to preserve the key order.
-
-        Convert (key, value) pairs to DataFrame. The keys will be the axis
-        index (usually the columns, but depends on the specified
-        orientation). The values should be arrays or Series.
-
-        Parameters
-        ----------
-        items : sequence of (key, value) pairs
-            Values should be arrays or Series.
-        columns : sequence of column labels, optional
-            Must be passed if orient='index'.
-        orient : {'columns', 'index'}, default 'columns'
-            The "orientation" of the data. If the keys of the
-            input correspond to column labels, pass 'columns'
-            (default). Otherwise if the keys correspond to the index,
-            pass 'index'.
-
-        Returns
-        -------
-        DataFrame
-        """
-
-        warnings.warn(
-            "from_items is deprecated. Please use "
-            "DataFrame.from_dict(dict(items), ...) instead. "
-            "DataFrame.from_dict(OrderedDict(items)) may be used to "
-            "preserve the key order.",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        keys, values = zip(*items)
-
-        if orient == "columns":
-            if columns is not None:
-                columns = ensure_index(columns)
-
-                idict = dict(items)
-                if len(idict) < len(items):
-                    if not columns.equals(ensure_index(keys)):
-                        raise ValueError(
-                            "With non-unique item names, passed "
-                            "columns must be identical"
-                        )
-                    arrays = values
-                else:
-                    arrays = [idict[k] for k in columns if k in idict]
-            else:
-                columns = ensure_index(keys)
-                arrays = values
-
-            # GH 17312
-            # Provide more informative error msg when scalar values passed
-            try:
-                return cls._from_arrays(arrays, columns, None)
-
-            except ValueError:
-                if not is_nested_list_like(values):
-                    raise ValueError(
-                        "The value in each (key, value) pair "
-                        "must be an array, Series, or dict"
-                    )
-
-        elif orient == "index":
-            if columns is None:
-                raise TypeError("Must pass columns with orient='index'")
-
-            keys = ensure_index(keys)
-
-            # GH 17312
-            # Provide more informative error msg when scalar values passed
-            try:
-                arr = np.array(values, dtype=object).T
-                data = [lib.maybe_convert_objects(v) for v in arr]
-                return cls._from_arrays(data, columns, keys)
-
-            except TypeError:
-                if not is_nested_list_like(values):
-                    raise ValueError(
-                        "The value in each (key, value) pair "
-                        "must be an array, Series, or dict"
-                    )
-
-        else:  # pragma: no cover
-            raise ValueError("'orient' must be either 'columns' or 'index'")
-
-    @classmethod
-    def _from_arrays(cls, arrays, columns, index, dtype=None):
+    def _from_arrays(cls, arrays, columns, index, dtype=None) -> "DataFrame":
         mgr = arrays_to_mgr(arrays, columns, index, columns, dtype=dtype)
         return cls(mgr)
 
-    def to_sparse(self, fill_value=None, kind="block"):
-        """
-        Convert to SparseDataFrame.
-
-        .. deprecated:: 0.25.0
-
-        Implement the sparse version of the DataFrame meaning that any data
-        matching a specific value it's omitted in the representation.
-        The sparse DataFrame allows for a more efficient storage.
-
-        Parameters
-        ----------
-        fill_value : float, default None
-            The specific value that should be omitted in the representation.
-        kind : {'block', 'integer'}, default 'block'
-            The kind of the SparseIndex tracking where data is not equal to
-            the fill value:
-
-            - 'block' tracks only the locations and sizes of blocks of data.
-            - 'integer' keeps an array with all the locations of the data.
-
-            In most cases 'block' is recommended, since it's more memory
-            efficient.
-
-        Returns
-        -------
-        SparseDataFrame
-            The sparse representation of the DataFrame.
-
-        See Also
-        --------
-        DataFrame.to_dense :
-            Converts the DataFrame back to the its dense form.
-
-        Examples
-        --------
-        >>> df = pd.DataFrame([(np.nan, np.nan),
-        ...                    (1., np.nan),
-        ...                    (np.nan, 1.)])
-        >>> df
-             0    1
-        0  NaN  NaN
-        1  1.0  NaN
-        2  NaN  1.0
-        >>> type(df)
-        <class 'pandas.core.frame.DataFrame'>
-
-        >>> sdf = df.to_sparse()  # doctest: +SKIP
-        >>> sdf  # doctest: +SKIP
-             0    1
-        0  NaN  NaN
-        1  1.0  NaN
-        2  NaN  1.0
-        >>> type(sdf)  # doctest: +SKIP
-        <class 'pandas.core.sparse.frame.SparseDataFrame'>
-        """
-        warnings.warn(
-            "DataFrame.to_sparse is deprecated and will be removed "
-            "in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        from pandas.core.sparse.api import SparseDataFrame
-
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", message="SparseDataFrame")
-            return SparseDataFrame(
-                self._series,
-                index=self.index,
-                columns=self.columns,
-                default_kind=kind,
-                default_fill_value=fill_value,
-            )
-
-    @deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
+    @deprecate_kwarg(old_arg_name="fname", new_arg_name="path")
     def to_stata(
         self,
-        fname,
-        convert_dates=None,
-        write_index=True,
-        encoding="latin-1",
-        byteorder=None,
-        time_stamp=None,
-        data_label=None,
-        variable_labels=None,
-        version=114,
-        convert_strl=None,
-    ):
+        path: FilePathOrBuffer,
+        convert_dates: Optional[Dict[Label, str]] = None,
+        write_index: bool = True,
+        byteorder: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+        data_label: Optional[str] = None,
+        variable_labels: Optional[Dict[Label, str]] = None,
+        version: Optional[int] = 114,
+        convert_strl: Optional[Sequence[Label]] = None,
+    ) -> None:
         """
         Export DataFrame object to Stata dta format.
 
@@ -2030,11 +1872,16 @@ def to_stata(
 
         Parameters
         ----------
-        fname : str, buffer or path object
+        path : str, buffer or path object
             String, path object (pathlib.Path or py._path.local.LocalPath) or
             object implementing a binary write() function. If using a buffer
             then the buffer will not be automatically closed after the file
             data has been written.
+
+            .. versionchanged:: 1.0.0
+
+            Previously this was "fname"
+
         convert_dates : dict
             Dictionary mapping columns containing datetime types to stata
             internal format to use when writing the dates. Options are 'tc',
@@ -2044,8 +1891,6 @@ def to_stata(
             a datetime column has timezone information.
         write_index : bool
             Write the index to Stata dataset.
-        encoding : str
-            Default is latin-1. Unicode is not supported.
         byteorder : str
             Can be ">", "<", "little", or "big". default is `sys.byteorder`.
         time_stamp : datetime
@@ -2056,14 +1901,22 @@ def to_stata(
         variable_labels : dict
             Dictionary containing columns as keys and variable labels as
             values. Each label must be 80 characters or smaller.
-        version : {114, 117}, default 114
-            Version to use in the output dta file.  Version 114 can be used
-            read by Stata 10 and later.  Version 117 can be read by Stata 13
-            or later. Version 114 limits string variables to 244 characters or
-            fewer while 117 allows strings with lengths up to 2,000,000
-            characters.
+        version : {114, 117, 118, 119, None}, default 114
+            Version to use in the output dta file. Set to None to let pandas
+            decide between 118 or 119 formats depending on the number of
+            columns in the frame. Version 114 can be read by Stata 10 and
+            later. Version 117 can be read by Stata 13 or later. Version 118
+            is supported in Stata 14 and later. Version 119 is supported in
+            Stata 15 and later. Version 114 limits string variables to 244
+            characters or fewer while versions 117 and later allow strings
+            with lengths up to 2,000,000 characters. Versions 118 and 119
+            support Unicode characters, and version 119 supports more than
+            32,767 variables.
 
             .. versionadded:: 0.23.0
+            .. versionchanged:: 1.0.0
+
+                Added support for formats 118 and 119.
 
         convert_strl : list, optional
             List of column names to convert to string columns to Stata StrL
@@ -2097,20 +1950,30 @@ def to_stata(
         ...                    'speed': [350, 18, 361, 15]})
         >>> df.to_stata('animals.dta')  # doctest: +SKIP
         """
-        kwargs = {}
-        if version not in (114, 117):
-            raise ValueError("Only formats 114 and 117 supported.")
+        if version not in (114, 117, 118, 119, None):
+            raise ValueError("Only formats 114, 117, 118 and 119 are supported.")
         if version == 114:
             if convert_strl is not None:
-                raise ValueError("strl support is only available when using format 117")
+                raise ValueError("strl is not supported in format 114")
             from pandas.io.stata import StataWriter as statawriter
-        else:
-            from pandas.io.stata import StataWriter117 as statawriter
-
+        elif version == 117:
+            # mypy: Name 'statawriter' already defined (possibly by an import)
+            from pandas.io.stata import StataWriter117 as statawriter  # type: ignore
+        else:  # versions 118 and 119
+            # mypy: Name 'statawriter' already defined (possibly by an import)
+            from pandas.io.stata import StataWriterUTF8 as statawriter  # type:ignore
+
+        kwargs: Dict[str, Any] = {}
+        if version is None or version >= 117:
+            # strl conversion is only supported >= 117
             kwargs["convert_strl"] = convert_strl
+        if version is None or version >= 118:
+            # Specifying the version is only supported for UTF8 (118 or 119)
+            kwargs["version"] = version
 
-        writer = statawriter(
-            fname,
+        # mypy: Too many arguments for "StataWriter"
+        writer = statawriter(  # type: ignore
+            path,
             self,
             convert_dates=convert_dates,
             byteorder=byteorder,
@@ -2118,34 +1981,64 @@ def to_stata(
             data_label=data_label,
             write_index=write_index,
             variable_labels=variable_labels,
-            **kwargs
+            **kwargs,
         )
         writer.write_file()
 
-    def to_feather(self, fname):
+    @deprecate_kwarg(old_arg_name="fname", new_arg_name="path")
+    def to_feather(self, path) -> None:
         """
         Write out the binary feather-format for DataFrames.
 
-        .. versionadded:: 0.20.0
-
         Parameters
         ----------
-        fname : str
-            string file path
+        path : str
+            String file path.
         """
         from pandas.io.feather_format import to_feather
 
-        to_feather(self, fname)
+        to_feather(self, path)
+
+    @Appender(
+        """
+        Examples
+        --------
+        >>> df = pd.DataFrame(
+        ...     data={"animal_1": ["elk", "pig"], "animal_2": ["dog", "quetzal"]}
+        ... )
+        >>> print(df.to_markdown())
+        |    | animal_1   | animal_2   |
+        |---:|:-----------|:-----------|
+        |  0 | elk        | dog        |
+        |  1 | pig        | quetzal    |
+        """
+    )
+    @Substitution(klass="DataFrame")
+    @Appender(_shared_docs["to_markdown"])
+    def to_markdown(
+        self, buf: Optional[IO[str]] = None, mode: Optional[str] = None, **kwargs
+    ) -> Optional[str]:
+        kwargs.setdefault("headers", "keys")
+        kwargs.setdefault("tablefmt", "pipe")
+        tabulate = import_optional_dependency("tabulate")
+        result = tabulate.tabulate(self, **kwargs)
+        if buf is None:
+            return result
+        buf, _, _, _ = get_filepath_or_buffer(buf, mode=mode)
+        assert buf is not None  # Help mypy.
+        buf.writelines(result)
+        return None
 
+    @deprecate_kwarg(old_arg_name="fname", new_arg_name="path")
     def to_parquet(
         self,
-        fname,
+        path,
         engine="auto",
         compression="snappy",
         index=None,
         partition_cols=None,
-        **kwargs
-    ):
+        **kwargs,
+    ) -> None:
         """
         Write a DataFrame to the binary parquet format.
 
@@ -2158,11 +2051,13 @@ def to_parquet(
 
         Parameters
         ----------
-        fname : str
+        path : str
             File path or Root Directory path. Will be used as Root Directory
             path while writing a partitioned dataset.
 
-            .. versionchanged:: 0.24.0
+            .. versionchanged:: 1.0.0
+
+            Previously this was "fname"
 
         engine : {'auto', 'pyarrow', 'fastparquet'}, default 'auto'
             Parquet library to use. If 'auto', then the option
@@ -2173,14 +2068,18 @@ def to_parquet(
             Name of the compression to use. Use ``None`` for no compression.
         index : bool, default None
             If ``True``, include the dataframe's index(es) in the file output.
-            If ``False``, they will not be written to the file. If ``None``,
-            the behavior depends on the chosen engine.
+            If ``False``, they will not be written to the file.
+            If ``None``, similar to ``True`` the dataframe's index(es)
+            will be saved. However, instead of being saved as values,
+            the RangeIndex will be stored as a range in the metadata so it
+            doesn't require much space and is faster. Other indexes will
+            be included as columns in the file output.
 
             .. versionadded:: 0.24.0
 
         partition_cols : list, optional, default None
-            Column names by which to partition the dataset
-            Columns are partitioned in the order they are given
+            Column names by which to partition the dataset.
+            Columns are partitioned in the order they are given.
 
             .. versionadded:: 0.24.0
 
@@ -2215,15 +2114,16 @@ def to_parquet(
 
         to_parquet(
             self,
-            fname,
+            path,
             engine,
             compression=compression,
             index=index,
             partition_cols=partition_cols,
-            **kwargs
+            **kwargs,
         )
 
     @Substitution(
+        header_type="bool",
         header="Whether to print column labels, default True",
         col_space_type="str or int",
         col_space="The minimum width of each column in CSS length "
@@ -2256,6 +2156,7 @@ def to_html(
         border=None,
         table_id=None,
         render_links=False,
+        encoding=None,
     ):
         """
         Render a DataFrame as an HTML table.
@@ -2271,6 +2172,11 @@ def to_html(
         border : int
             A ``border=border`` attribute is included in the opening
             `<table>` tag. Default ``pd.options.display.html.border``.
+        encoding : str, default "utf-8"
+            Set character encoding.
+
+            .. versionadded:: 1.0
+
         table_id : str, optional
             A css id is included in the opening `<table>` tag if specified.
 
@@ -2285,7 +2191,6 @@ def to_html(
         --------
         to_string : Convert DataFrame to a string.
         """
-
         if justify is not None and justify not in fmt._VALID_JUSTIFY_PARAMETERS:
             raise ValueError("Invalid value for justify parameter")
 
@@ -2312,14 +2217,18 @@ def to_html(
         )
         # TODO: a generic formatter wld b in DataFrameFormatter
         return formatter.to_html(
-            buf=buf, classes=classes, notebook=notebook, border=border
+            buf=buf,
+            classes=classes,
+            notebook=notebook,
+            border=border,
+            encoding=encoding,
         )
 
     # ----------------------------------------------------------------------
 
     def info(
         self, verbose=None, buf=None, max_cols=None, memory_usage=None, null_counts=None
-    ):
+    ) -> None:
         """
         Print a concise summary of a DataFrame.
 
@@ -2392,9 +2301,11 @@ def info(
         <class 'pandas.core.frame.DataFrame'>
         RangeIndex: 5 entries, 0 to 4
         Data columns (total 3 columns):
-        int_col      5 non-null int64
-        text_col     5 non-null object
-        float_col    5 non-null float64
+         #   Column     Non-Null Count  Dtype
+        ---  ------     --------------  -----
+         0   int_col    5 non-null      int64
+         1   text_col   5 non-null      object
+         2   float_col  5 non-null      float64
         dtypes: float64(1), int64(1), object(1)
         memory usage: 248.0+ bytes
 
@@ -2433,9 +2344,11 @@ def info(
         <class 'pandas.core.frame.DataFrame'>
         RangeIndex: 1000000 entries, 0 to 999999
         Data columns (total 3 columns):
-        column_1    1000000 non-null object
-        column_2    1000000 non-null object
-        column_3    1000000 non-null object
+         #   Column    Non-Null Count    Dtype
+        ---  ------    --------------    -----
+         0   column_1  1000000 non-null  object
+         1   column_2  1000000 non-null  object
+         2   column_3  1000000 non-null  object
         dtypes: object(3)
         memory usage: 22.9+ MB
 
@@ -2443,13 +2356,14 @@ def info(
         <class 'pandas.core.frame.DataFrame'>
         RangeIndex: 1000000 entries, 0 to 999999
         Data columns (total 3 columns):
-        column_1    1000000 non-null object
-        column_2    1000000 non-null object
-        column_3    1000000 non-null object
+         #   Column    Non-Null Count    Dtype
+        ---  ------    --------------    -----
+         0   column_1  1000000 non-null  object
+         1   column_2  1000000 non-null  object
+         2   column_3  1000000 non-null  object
         dtypes: object(3)
         memory usage: 188.8 MB
         """
-
         if buf is None:  # pragma: no cover
             buf = sys.stdout
 
@@ -2459,11 +2373,12 @@ def info(
         lines.append(self.index._summary())
 
         if len(self.columns) == 0:
-            lines.append("Empty {name}".format(name=type(self).__name__))
+            lines.append(f"Empty {type(self).__name__}")
             fmt.buffer_put_lines(buf, lines)
             return
 
         cols = self.columns
+        col_count = len(self.columns)
 
         # hack
         if max_cols is None:
@@ -2472,39 +2387,76 @@ def info(
         max_rows = get_option("display.max_info_rows", len(self) + 1)
 
         if null_counts is None:
-            show_counts = (len(self.columns) <= max_cols) and (len(self) < max_rows)
+            show_counts = (col_count <= max_cols) and (len(self) < max_rows)
         else:
             show_counts = null_counts
-        exceeds_info_cols = len(self.columns) > max_cols
+        exceeds_info_cols = col_count > max_cols
 
         def _verbose_repr():
-            lines.append("Data columns (total %d columns):" % len(self.columns))
-            space = max(len(pprint_thing(k)) for k in self.columns) + 4
+            lines.append(f"Data columns (total {len(self.columns)} columns):")
+
+            id_head = " # "
+            column_head = "Column"
+            col_space = 2
+
+            max_col = max(len(pprint_thing(k)) for k in cols)
+            len_column = len(pprint_thing(column_head))
+            space = max(max_col, len_column) + col_space
+
+            max_id = len(pprint_thing(col_count))
+            len_id = len(pprint_thing(id_head))
+            space_num = max(max_id, len_id) + col_space
             counts = None
 
-            tmpl = "{count}{dtype}"
+            header = _put_str(id_head, space_num) + _put_str(column_head, space)
             if show_counts:
                 counts = self.count()
                 if len(cols) != len(counts):  # pragma: no cover
                     raise AssertionError(
-                        "Columns must equal counts "
-                        "({cols:d} != {counts:d})".format(
-                            cols=len(cols), counts=len(counts)
-                        )
+                        f"Columns must equal counts ({len(cols)} != {len(counts)})"
                     )
-                tmpl = "{count} non-null {dtype}"
+                count_header = "Non-Null Count"
+                len_count = len(count_header)
+                non_null = " non-null"
+                max_count = max(len(pprint_thing(k)) for k in counts) + len(non_null)
+                space_count = max(len_count, max_count) + col_space
+                count_temp = "{count}" + non_null
+            else:
+                count_header = ""
+                space_count = len(count_header)
+                len_count = space_count
+                count_temp = "{count}"
+
+            dtype_header = "Dtype"
+            len_dtype = len(dtype_header)
+            max_dtypes = max(len(pprint_thing(k)) for k in self.dtypes)
+            space_dtype = max(len_dtype, max_dtypes)
+            header += _put_str(count_header, space_count) + _put_str(
+                dtype_header, space_dtype
+            )
+
+            lines.append(header)
+            lines.append(
+                _put_str("-" * len_id, space_num)
+                + _put_str("-" * len_column, space)
+                + _put_str("-" * len_count, space_count)
+                + _put_str("-" * len_dtype, space_dtype)
+            )
 
-            dtypes = self.dtypes
             for i, col in enumerate(self.columns):
-                dtype = dtypes.iloc[i]
+                dtype = self.dtypes.iloc[i]
                 col = pprint_thing(col)
 
+                line_no = _put_str(f" {i}", space_num)
                 count = ""
                 if show_counts:
                     count = counts.iloc[i]
 
                 lines.append(
-                    _put_str(col, space) + tmpl.format(count=count, dtype=dtype)
+                    line_no
+                    + _put_str(col, space)
+                    + _put_str(count_temp.format(count=count), space_count)
+                    + _put_str(dtype, space_dtype)
                 )
 
         def _non_verbose_repr():
@@ -2514,13 +2466,9 @@ def _sizeof_fmt(num, size_qualifier):
             # returns size in human readable format
             for x in ["bytes", "KB", "MB", "GB", "TB"]:
                 if num < 1024.0:
-                    return "{num:3.1f}{size_q} {x}".format(
-                        num=num, size_q=size_qualifier, x=x
-                    )
+                    return f"{num:3.1f}{size_qualifier} {x}"
                 num /= 1024.0
-            return "{num:3.1f}{size_q} {pb}".format(
-                num=num, size_q=size_qualifier, pb="PB"
-            )
+            return f"{num:3.1f}{size_qualifier} PB"
 
         if verbose:
             _verbose_repr()
@@ -2533,8 +2481,8 @@ def _sizeof_fmt(num, size_qualifier):
                 _verbose_repr()
 
         counts = self._data.get_dtype_counts()
-        dtypes = ["{k}({kk:d})".format(k=k[0], kk=k[1]) for k in sorted(counts.items())]
-        lines.append("dtypes: {types}".format(types=", ".join(dtypes)))
+        dtypes = [f"{k[0]}({k[1]:d})" for k in sorted(counts.items())]
+        lines.append(f"dtypes: {', '.join(dtypes)}")
 
         if memory_usage is None:
             memory_usage = get_option("display.memory_usage")
@@ -2551,15 +2499,10 @@ def _sizeof_fmt(num, size_qualifier):
                 if "object" in counts or self.index._is_memory_usage_qualified():
                     size_qualifier = "+"
             mem_usage = self.memory_usage(index=True, deep=deep).sum()
-            lines.append(
-                "memory usage: {mem}\n".format(
-                    mem=_sizeof_fmt(mem_usage, size_qualifier)
-                )
-            )
-
+            lines.append(f"memory usage: {_sizeof_fmt(mem_usage, size_qualifier)}\n")
         fmt.buffer_put_lines(buf, lines)
 
-    def memory_usage(self, index=True, deep=False):
+    def memory_usage(self, index=True, deep=False) -> Series:
         """
         Return the memory usage of each column in bytes.
 
@@ -2653,7 +2596,7 @@ def memory_usage(self, index=True, deep=False):
             )
         return result
 
-    def transpose(self, *args, **kwargs):
+    def transpose(self, *args, copy: bool = False) -> "DataFrame":
         """
         Transpose index and columns.
 
@@ -2663,12 +2606,14 @@ def transpose(self, *args, **kwargs):
 
         Parameters
         ----------
+        *args : tuple, optional
+            Accepted for compatibility with NumPy.
         copy : bool, default False
-            If True, the underlying data is copied. Otherwise (default), no
-            copy is made if possible.
-        *args, **kwargs
-            Additional keywords have no effect but might be accepted for
-            compatibility with numpy.
+            Whether to copy the data after transposing, even for DataFrames
+            with a single dtype.
+
+            Note that a copy is always required for mixed dtype DataFrames,
+            or for DataFrames with any extension types.
 
         Returns
         -------
@@ -2749,41 +2694,31 @@ def transpose(self, *args, **kwargs):
         dtype: object
         """
         nv.validate_transpose(args, dict())
-        return super().transpose(1, 0, **kwargs)
+        # construct the args
 
-    T = property(transpose)
+        dtypes = list(self.dtypes)
+        if self._is_homogeneous_type and dtypes and is_extension_array_dtype(dtypes[0]):
+            # We have EAs with the same dtype. We can preserve that dtype in transpose.
+            dtype = dtypes[0]
+            arr_type = dtype.construct_array_type()
+            values = self.values
 
-    # ----------------------------------------------------------------------
-    # Picklability
+            new_values = [arr_type._from_sequence(row, dtype=dtype) for row in values]
+            result = self._constructor(
+                dict(zip(self.index, new_values)), index=self.columns
+            )
 
-    # legacy pickle formats
-    def _unpickle_frame_compat(self, state):  # pragma: no cover
-        if len(state) == 2:  # pragma: no cover
-            series, idx = state
-            columns = sorted(series)
         else:
-            series, cols, idx = state
-            columns = com._unpickle_array(cols)
-
-        index = com._unpickle_array(idx)
-        self._data = self._init_dict(series, index, columns, None)
-
-    def _unpickle_matrix_compat(self, state):  # pragma: no cover
-        # old unpickling
-        (vals, idx, cols), object_state = state
-
-        index = com._unpickle_array(idx)
-        dm = DataFrame(vals, index=index, columns=com._unpickle_array(cols), copy=False)
-
-        if object_state is not None:
-            ovals, _, ocols = object_state
-            objects = DataFrame(
-                ovals, index=index, columns=com._unpickle_array(ocols), copy=False
+            new_values = self.values.T
+            if copy:
+                new_values = new_values.copy()
+            result = self._constructor(
+                new_values, index=self.columns, columns=self.index
             )
 
-            dm = dm.join(objects)
+        return result.__finalize__(self)
 
-        self._data = dm._data
+    T = property(transpose)
 
     # ----------------------------------------------------------------------
     # Indexing Methods
@@ -2801,7 +2736,6 @@ def _ixs(self, i: int, axis: int = 0):
         """
         # irow
         if axis == 0:
-            label = self.index[i]
             new_values = self._data.fast_xs(i)
 
             # if we are a copy, mark as such
@@ -2819,14 +2753,7 @@ def _ixs(self, i: int, axis: int = 0):
         else:
             label = self.columns[i]
 
-            # if the values returned are not the same length
-            # as the index (iow a not found value), iget returns
-            # a 0-len ndarray. This is effectively catching
-            # a numpy error (as numpy should really raise)
             values = self._data.iget(i)
-
-            if len(self.index) and not len(values):
-                values = np.array([np.nan] * len(self.index), dtype=object)
             result = self._box_col_values(values, label)
 
             # this is a cached value, mark it so
@@ -2879,7 +2806,7 @@ def __getitem__(self, key):
         if getattr(indexer, "dtype", None) == bool:
             indexer = np.where(indexer)[0]
 
-        data = self.take(indexer, axis=1)
+        data = self._take_with_is_copy(indexer, axis=1)
 
         if is_single_key:
             # What does looking for a single key in a non-unique index return?
@@ -2905,14 +2832,14 @@ def _getitem_bool_array(self, key):
             )
         elif len(key) != len(self.index):
             raise ValueError(
-                "Item wrong length %d instead of %d." % (len(key), len(self.index))
+                f"Item wrong length {len(key)} instead of {len(self.index)}."
             )
 
         # check_bool_indexer will throw exception if Series key cannot
         # be reindexed to match DataFrame rows
         key = check_bool_indexer(self.index, key)
         indexer = key.nonzero()[0]
-        return self.take(indexer, axis=0)
+        return self._take_with_is_copy(indexer, axis=0)
 
     def _getitem_multilevel(self, key):
         # self.columns is a MultiIndex
@@ -2974,14 +2901,13 @@ def _get_value(self, index, col, takeable: bool = False):
         engine = self.index._engine
 
         try:
-            return engine.get_value(series._values, index)
+            loc = engine.get_loc(index)
+            return series._values[loc]
         except KeyError:
             # GH 20629
             if self.index.nlevels > 1:
                 # partial indexing forbidden
                 raise
-        except (TypeError, ValueError):
-            pass
 
         # we cannot handle direct indexing
         # use positional
@@ -3007,21 +2933,24 @@ def __setitem__(self, key, value):
             # set column
             self._set_item(key, value)
 
-    def _setitem_slice(self, key, value):
+    def _setitem_slice(self, key: slice, value):
+        # NB: we can't just use self.loc[key] = value because that
+        #  operates on labels and we need to operate positional for
+        #  backwards-compat, xref GH#31469
         self._check_setitem_copy()
-        self.loc[key] = value
+        self.iloc._setitem_with_indexer(key, value)
 
     def _setitem_array(self, key, value):
         # also raises Exception if object array with NA values
         if com.is_bool_indexer(key):
             if len(key) != len(self.index):
                 raise ValueError(
-                    "Item wrong length %d instead of %d!" % (len(key), len(self.index))
+                    f"Item wrong length {len(key)} instead of {len(self.index)}!"
                 )
             key = check_bool_indexer(self.index, key)
             indexer = key.nonzero()[0]
             self._check_setitem_copy()
-            self.loc._setitem_with_indexer(indexer, value)
+            self.iloc._setitem_with_indexer(indexer, value)
         else:
             if isinstance(value, DataFrame):
                 if len(value.columns) != len(key):
@@ -3033,7 +2962,7 @@ def _setitem_array(self, key, value):
                     key, axis=1, raise_missing=False
                 )[1]
                 self._check_setitem_copy()
-                self.loc._setitem_with_indexer((slice(None), indexer), value)
+                self.iloc._setitem_with_indexer((slice(None), indexer), value)
 
     def _setitem_frame(self, key, value):
         # support boolean setting with DataFrame input, e.g.
@@ -3062,7 +2991,6 @@ def _set_item(self, key, value):
         Series/TimeSeries will be conformed to the DataFrames index to
         ensure homogeneity.
         """
-
         self._ensure_valid_index(value)
         value = self._sanitize_column(key, value)
         NDFrame._set_item(self, key, value)
@@ -3083,24 +3011,22 @@ def _set_value(self, index, col, value, takeable: bool = False):
         col : column label
         value : scalar
         takeable : interpret the index/col as indexers, default False
-
-        Returns
-        -------
-        DataFrame
-            If label pair is contained, will be reference to calling DataFrame,
-            otherwise a new object.
         """
         try:
             if takeable is True:
                 series = self._iget_item_cache(col)
-                return series._set_value(index, value, takeable=True)
+                series._set_value(index, value, takeable=True)
+                return
 
             series = self._get_item_cache(col)
             engine = self.index._engine
-            engine.set_value(series._values, index, value)
-            return self
-        except (KeyError, TypeError):
+            loc = engine.get_loc(index)
+            validate_numeric_casting(series.dtype, value)
 
+            series._values[loc] = value
+            # Note: trying to use series._set_value breaks tests in
+            #  tests.frame.indexing.test_indexing and tests.indexing.test_partial
+        except (KeyError, TypeError):
             # set using a non-recursive method & reset the cache
             if takeable:
                 self.iloc[index, col] = value
@@ -3108,8 +3034,6 @@ def _set_value(self, index, col, value, takeable: bool = False):
                 self.loc[index, col] = value
             self._item_cache.pop(col, None)
 
-            return self
-
     def _ensure_valid_index(self, value):
         """
         Ensure that if we don't have an index, that we can create one from the
@@ -3122,8 +3046,7 @@ def _ensure_valid_index(self, value):
             except (ValueError, NotImplementedError, TypeError):
                 raise ValueError(
                     "Cannot set a frame with no defined index "
-                    "and a value that cannot be converted to a "
-                    "Series"
+                    "and a value that cannot be converted to a Series"
                 )
 
             self._data = self._data.reindex_axis(
@@ -3154,18 +3077,27 @@ def query(self, expr, inplace=False, **kwargs):
         Parameters
         ----------
         expr : str
-            The query string to evaluate.  You can refer to variables
+            The query string to evaluate.
+
+            You can refer to variables
             in the environment by prefixing them with an '@' character like
             ``@a + b``.
 
-            .. versionadded:: 0.25.0
-
-            You can refer to column names that contain spaces by surrounding
-            them in backticks.
+            You can refer to column names that contain spaces or operators by
+            surrounding them in backticks. This way you can also escape
+            names that start with a digit, or those that  are a Python keyword.
+            Basically when it is not valid Python identifier. See notes down
+            for more details.
 
             For example, if one of your columns is called ``a a`` and you want
             to sum it with ``b``, your query should be ```a a` + b``.
 
+            .. versionadded:: 0.25.0
+                Backtick quoting introduced.
+
+            .. versionadded:: 1.0.0
+                Expanding functionality of backtick quoting for more than only spaces.
+
         inplace : bool
             Whether the query should modify the data in place or return
             a modified copy.
@@ -3220,6 +3152,32 @@ def query(self, expr, inplace=False, **kwargs):
         For further details and examples see the ``query`` documentation in
         :ref:`indexing <indexing.query>`.
 
+        *Backtick quoted variables*
+
+        Backtick quoted variables are parsed as literal Python code and
+        are converted internally to a Python valid identifier.
+        This can lead to the following problems.
+
+        During parsing a number of disallowed characters inside the backtick
+        quoted string are replaced by strings that are allowed as a Python identifier.
+        These characters include all operators in Python, the space character, the
+        question mark, the exclamation mark, the dollar sign, and the euro sign.
+        For other characters that fall outside the ASCII range (U+0001..U+007F)
+        and those that are not further specified in PEP 3131,
+        the query parser will raise an error.
+        This excludes whitespace different than the space character,
+        but also the hashtag (as it is used for comments) and the backtick
+        itself (backtick can also not be escaped).
+
+        In a special case, quotes that make a pair around a backtick can
+        confuse the parser.
+        For example, ```it's` > `that's``` will raise an error,
+        as it forms a quoted string (``'s > `that'``) with a backtick inside.
+
+        See also the Python documentation about lexical analysis
+        (https://docs.python.org/3/reference/lexical_analysis.html)
+        in combination with the source code in :mod:`pandas.core.computation.parsing`.
+
         Examples
         --------
         >>> df = pd.DataFrame({'A': range(1, 6),
@@ -3256,8 +3214,8 @@ def query(self, expr, inplace=False, **kwargs):
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
         if not isinstance(expr, str):
-            msg = "expr must be a string to be evaluated, {0} given"
-            raise ValueError(msg.format(type(expr)))
+            msg = f"expr must be a string to be evaluated, {type(expr)} given"
+            raise ValueError(msg)
         kwargs["level"] = kwargs.pop("level", 0) + 1
         kwargs["target"] = None
         res = self.eval(expr, **kwargs)
@@ -3290,7 +3248,7 @@ def eval(self, expr, inplace=False, **kwargs):
             If the expression contains an assignment, whether to perform the
             operation inplace and mutate the existing DataFrame. Otherwise,
             a new DataFrame is returned.
-        kwargs : dict
+        **kwargs
             See the documentation for :func:`eval` for complete details
             on the keyword arguments accepted by
             :meth:`~pandas.DataFrame.query`.
@@ -3369,14 +3327,15 @@ def eval(self, expr, inplace=False, **kwargs):
         kwargs["level"] = kwargs.pop("level", 0) + 1
         if resolvers is None:
             index_resolvers = self._get_index_resolvers()
-            column_resolvers = self._get_space_character_free_column_resolvers()
+            column_resolvers = self._get_cleaned_column_resolvers()
             resolvers = column_resolvers, index_resolvers
         if "target" not in kwargs:
             kwargs["target"] = self
         kwargs["resolvers"] = kwargs.get("resolvers", ()) + tuple(resolvers)
+
         return _eval(expr, inplace=inplace, **kwargs)
 
-    def select_dtypes(self, include=None, exclude=None):
+    def select_dtypes(self, include=None, exclude=None) -> "DataFrame":
         """
         Return a subset of the DataFrame's columns based on the column dtypes.
 
@@ -3405,7 +3364,7 @@ def select_dtypes(self, include=None, exclude=None):
         * To select strings you must use the ``object`` dtype, but note that
           this will return *all* object dtype columns
         * See the `numpy dtype hierarchy
-          <http://docs.scipy.org/doc/numpy/reference/arrays.scalars.html>`__
+          <https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html>`__
         * To select datetimes, use ``np.datetime64``, ``'datetime'`` or
           ``'datetime64'``
         * To select timedeltas, use ``np.timedelta64``, ``'timedelta'`` or
@@ -3455,16 +3414,6 @@ def select_dtypes(self, include=None, exclude=None):
         4   True  1.0
         5  False  2.0
         """
-
-        def _get_info_slice(obj, indexer):
-            """Slice the info axis of `obj` with `indexer`."""
-            if not hasattr(obj, "_info_axis_number"):
-                msg = "object of type {typ!r} has no info axis"
-                raise TypeError(msg.format(typ=type(obj).__name__))
-            slices = [slice(None)] * obj.ndim
-            slices[obj._info_axis_number] = indexer
-            return tuple(slices)
-
         if not is_list_like(include):
             include = (include,) if include is not None else ()
         if not is_list_like(exclude):
@@ -3483,41 +3432,39 @@ def _get_info_slice(obj, indexer):
 
         # can't both include AND exclude!
         if not include.isdisjoint(exclude):
-            raise ValueError(
-                "include and exclude overlap on {inc_ex}".format(
-                    inc_ex=(include & exclude)
-                )
+            raise ValueError(f"include and exclude overlap on {(include & exclude)}")
+
+        # We raise when both include and exclude are empty
+        # Hence, we can just shrink the columns we want to keep
+        keep_these = np.full(self.shape[1], True)
+
+        def extract_unique_dtypes_from_dtypes_set(
+            dtypes_set: FrozenSet[Dtype], unique_dtypes: np.ndarray
+        ) -> List[Dtype]:
+            extracted_dtypes = [
+                unique_dtype
+                for unique_dtype in unique_dtypes
+                if issubclass(unique_dtype.type, tuple(dtypes_set))  # type: ignore
+            ]
+            return extracted_dtypes
+
+        unique_dtypes = self.dtypes.unique()
+
+        if include:
+            included_dtypes = extract_unique_dtypes_from_dtypes_set(
+                include, unique_dtypes
             )
+            keep_these &= self.dtypes.isin(included_dtypes)
 
-        # empty include/exclude -> defaults to True
-        # three cases (we've already raised if both are empty)
-        # case 1: empty include, nonempty exclude
-        # we have True, True, ... True for include, same for exclude
-        # in the loop below we get the excluded
-        # and when we call '&' below we get only the excluded
-        # case 2: nonempty include, empty exclude
-        # same as case 1, but with include
-        # case 3: both nonempty
-        # the "union" of the logic of case 1 and case 2:
-        # we get the included and excluded, and return their logical and
-        include_these = Series(not bool(include), index=self.columns)
-        exclude_these = Series(not bool(exclude), index=self.columns)
-
-        def is_dtype_instance_mapper(idx, dtype):
-            return idx, functools.partial(issubclass, dtype.type)
-
-        for idx, f in itertools.starmap(
-            is_dtype_instance_mapper, enumerate(self.dtypes)
-        ):
-            if include:  # checks for the case of empty include or exclude
-                include_these.iloc[idx] = any(map(f, include))
-            if exclude:
-                exclude_these.iloc[idx] = not any(map(f, exclude))
+        if exclude:
+            excluded_dtypes = extract_unique_dtypes_from_dtypes_set(
+                exclude, unique_dtypes
+            )
+            keep_these &= ~self.dtypes.isin(excluded_dtypes)
 
-        dtype_indexer = include_these & exclude_these
-        return self.loc[_get_info_slice(self, dtype_indexer)]
+        return self.iloc[:, keep_these.values]
 
-    def insert(self, loc, column, value, allow_duplicates=False):
+    def insert(self, loc, column, value, allow_duplicates=False) -> None:
         """
         Insert column into DataFrame at specified location.
 
@@ -3527,9 +3474,9 @@ def insert(self, loc, column, value, allow_duplicates=False):
         Parameters
         ----------
         loc : int
-            Insertion index. Must verify 0 <= loc <= len(columns)
-        column : string, number, or hashable object
-            label of the inserted column
+            Insertion index. Must verify 0 <= loc <= len(columns).
+        column : str, number, or hashable object
+            Label of the inserted column.
         value : int, Series, or array-like
         allow_duplicates : bool, optional
         """
@@ -3537,7 +3484,7 @@ def insert(self, loc, column, value, allow_duplicates=False):
         value = self._sanitize_column(column, value, broadcast=False)
         self._data.insert(loc, column, value, allow_duplicates=allow_duplicates)
 
-    def assign(self, **kwargs):
+    def assign(self, **kwargs) -> "DataFrame":
         r"""
         Assign new columns to a DataFrame.
 
@@ -3563,16 +3510,12 @@ def assign(self, **kwargs):
         Notes
         -----
         Assigning multiple columns within the same ``assign`` is possible.
-        For Python 3.6 and above, later items in '\*\*kwargs' may refer to
-        newly created or modified columns in 'df'; items are computed and
-        assigned into 'df' in order.  For Python 3.5 and below, the order of
-        keyword arguments is not specified, you cannot refer to newly created
-        or modified columns. All items are computed first, and then assigned
-        in alphabetical order.
+        Later items in '\*\*kwargs' may refer to newly created or modified
+        columns in 'df'; items are computed and assigned into 'df' in order.
 
         .. versionchanged:: 0.23.0
 
-           Keyword argument order is maintained for Python 3.6 and later.
+           Keyword argument order is maintained.
 
         Examples
         --------
@@ -3598,9 +3541,8 @@ def assign(self, **kwargs):
         Portland    17.0    62.6
         Berkeley    25.0    77.0
 
-        In Python 3.6+, you can create multiple columns within the same assign
-        where one of the columns depends on another one defined within the same
-        assign:
+        You can create multiple columns within the same assign where one
+        of the columns depends on another one defined within the same assign:
 
         >>> df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32,
         ...           temp_k=lambda x: (x['temp_f'] +  459.67) * 5 / 9)
@@ -3610,21 +3552,8 @@ def assign(self, **kwargs):
         """
         data = self.copy()
 
-        # >= 3.6 preserve order of kwargs
-        if PY36:
-            for k, v in kwargs.items():
-                data[k] = com.apply_if_callable(v, data)
-        else:
-            # <= 3.5: do all calculations first...
-            results = OrderedDict()
-            for k, v in kwargs.items():
-                results[k] = com.apply_if_callable(v, data)
-
-            # <= 3.5 and earlier
-            results = sorted(results.items())
-            # ... and then assign
-            for k, v in results:
-                data[k] = v
+        for k, v in kwargs.items():
+            data[k] = com.apply_if_callable(v, data)
         return data
 
     def _sanitize_column(self, key, value, broadcast=True):
@@ -3657,11 +3586,11 @@ def reindexer(value):
                 # GH 4107
                 try:
                     value = value.reindex(self.index)._values
-                except Exception as e:
-
-                    # duplicate axis
+                except ValueError as err:
+                    # raised in MultiIndex.from_tuples, see test_insert_error_msmgs
                     if not value.index.is_unique:
-                        raise e
+                        # duplicate axis
+                        raise err
 
                     # other
                     raise TypeError(
@@ -3688,12 +3617,12 @@ def reindexer(value):
             # Explicitly copy here, instead of in sanitize_index,
             # as sanitize_index won't copy an EA, even with copy=True
             value = value.copy()
-            value = sanitize_index(value, self.index, copy=False)
+            value = sanitize_index(value, self.index)
 
         elif isinstance(value, Index) or is_sequence(value):
 
             # turn me into an ndarray
-            value = sanitize_index(value, self.index, copy=False)
+            value = sanitize_index(value, self.index)
             if not isinstance(value, (np.ndarray, Index)):
                 if isinstance(value, list) and len(value) > 0:
                     value = maybe_convert_platform(value)
@@ -3719,7 +3648,7 @@ def reindexer(value):
             value = maybe_cast_to_datetime(value, infer_dtype)
 
         # return internal types directly
-        if is_extension_type(value) or is_extension_array_dtype(value):
+        if is_extension_array_dtype(value):
             return value
 
         # broadcast across multiple columns if necessary
@@ -3738,7 +3667,7 @@ def _series(self):
             for idx, item in enumerate(self.columns)
         }
 
-    def lookup(self, row_labels, col_labels):
+    def lookup(self, row_labels, col_labels) -> np.ndarray:
         """
         Label-based "fancy indexing" function for DataFrame.
 
@@ -3748,25 +3677,14 @@ def lookup(self, row_labels, col_labels):
         Parameters
         ----------
         row_labels : sequence
-            The row labels to use for lookup
+            The row labels to use for lookup.
         col_labels : sequence
-            The column labels to use for lookup
+            The column labels to use for lookup.
 
         Returns
         -------
         numpy.ndarray
-
-        Notes
-        -----
-        Akin to::
-
-            result = [df.get_value(row, col)
-                      for row, col in zip(row_labels, col_labels)]
-
-        Examples
-        --------
-        values : ndarray
-            The found values
+            The found values.
         """
         n = len(row_labels)
         if n != len(col_labels):
@@ -3853,11 +3771,10 @@ def _reindex_columns(
             allow_dups=False,
         )
 
-    def _reindex_multi(self, axes, copy, fill_value):
+    def _reindex_multi(self, axes, copy, fill_value) -> "DataFrame":
         """
         We are guaranteed non-Nones in the axes.
         """
-
         new_index, row_indexer = self.index.reindex(axes["index"])
         new_columns, col_indexer = self.columns.reindex(axes["columns"])
 
@@ -3887,7 +3804,7 @@ def align(
         limit=None,
         fill_axis=0,
         broadcast_axis=None,
-    ):
+    ) -> "DataFrame":
         return super().align(
             other,
             join=join,
@@ -3901,6 +3818,46 @@ def align(
             broadcast_axis=broadcast_axis,
         )
 
+    @Appender(
+        """
+        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+        Change the row labels.
+
+        >>> df.set_axis(['a', 'b', 'c'], axis='index')
+           A  B
+        a  1  4
+        b  2  5
+        c  3  6
+
+        Change the column labels.
+
+        >>> df.set_axis(['I', 'II'], axis='columns')
+           I  II
+        0  1   4
+        1  2   5
+        2  3   6
+
+        Now, update the labels inplace.
+
+        >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
+        >>> df
+           i  ii
+        0  1   4
+        1  2   5
+        2  3   6
+        """
+    )
+    @Substitution(
+        **_shared_doc_kwargs,
+        extended_summary_sub=" column or",
+        axis_description_sub=", and 1 identifies the columns",
+        see_also_sub=" or columns",
+    )
+    @Appender(NDFrame.set_axis.__doc__)
+    def set_axis(self, labels, axis=0, inplace=False):
+        return super().set_axis(labels, axis=axis, inplace=inplace)
+
     @Substitution(**_shared_doc_kwargs)
     @Appender(NDFrame.reindex.__doc__)
     @rewrite_axis_style_signature(
@@ -3914,13 +3871,13 @@ def align(
             ("tolerance", None),
         ],
     )
-    def reindex(self, *args, **kwargs):
+    def reindex(self, *args, **kwargs) -> "DataFrame":
         axes = validate_axis_style_args(self, args, kwargs, "labels", "reindex")
         kwargs.update(axes)
         # Pop these, since the values are in `kwargs` under different names
         kwargs.pop("axis", None)
         kwargs.pop("labels", None)
-        return super().reindex(**kwargs)
+        return self._ensure_type(super().reindex(**kwargs))
 
     def drop(
         self,
@@ -4068,7 +4025,18 @@ def drop(
         "mapper",
         [("copy", True), ("inplace", False), ("level", None), ("errors", "ignore")],
     )
-    def rename(self, *args, **kwargs):
+    def rename(
+        self,
+        mapper: Optional[Renamer] = None,
+        *,
+        index: Optional[Renamer] = None,
+        columns: Optional[Renamer] = None,
+        axis: Optional[Axis] = None,
+        copy: bool = True,
+        inplace: bool = False,
+        level: Optional[Level] = None,
+        errors: str = "ignore",
+    ) -> Optional["DataFrame"]:
         """
         Alter axes labels.
 
@@ -4126,7 +4094,6 @@ def rename(self, *args, **kwargs):
 
         Examples
         --------
-
         ``DataFrame.rename`` supports two calling conventions
 
         * ``(index=index_mapper, columns=columns_mapper, ...)``
@@ -4177,12 +4144,16 @@ def rename(self, *args, **kwargs):
         2  2  5
         4  3  6
         """
-        axes = validate_axis_style_args(self, args, kwargs, "mapper", "rename")
-        kwargs.update(axes)
-        # Pop these, since the values are in `kwargs` under different names
-        kwargs.pop("axis", None)
-        kwargs.pop("mapper", None)
-        return super().rename(**kwargs)
+        return super().rename(
+            mapper=mapper,
+            index=index,
+            columns=columns,
+            axis=axis,
+            copy=copy,
+            inplace=inplace,
+            level=level,
+            errors=errors,
+        )
 
     @Substitution(**_shared_doc_kwargs)
     @Appender(NDFrame.fillna.__doc__)
@@ -4194,8 +4165,7 @@ def fillna(
         inplace=False,
         limit=None,
         downcast=None,
-        **kwargs
-    ):
+    ) -> Optional["DataFrame"]:
         return super().fillna(
             value=value,
             method=method,
@@ -4203,7 +4173,6 @@ def fillna(
             inplace=inplace,
             limit=limit,
             downcast=downcast,
-            **kwargs
         )
 
     @Appender(_shared_docs["replace"] % _shared_doc_kwargs)
@@ -4226,9 +4195,9 @@ def replace(
         )
 
     @Appender(_shared_docs["shift"] % _shared_doc_kwargs)
-    def shift(self, periods=1, freq=None, axis=0, fill_value=None):
-        return super().shift(
-            periods=periods, freq=freq, axis=axis, fill_value=fill_value
+    def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> "DataFrame":
+        return self._ensure_type(
+            super().shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
         )
 
     def set_index(
@@ -4333,7 +4302,7 @@ def set_index(
             "one-dimensional arrays."
         )
 
-        missing = []
+        missing: List[Optional[Hashable]] = []
         for col in keys:
             if isinstance(
                 col, (ABCIndexClass, ABCSeries, np.ndarray, list, abc.Iterator)
@@ -4347,15 +4316,13 @@ def set_index(
                 try:
                     found = col in self.columns
                 except TypeError:
-                    raise TypeError(
-                        err_msg + " Received column of type {}".format(type(col))
-                    )
+                    raise TypeError(f"{err_msg}. Received column of type {type(col)}")
                 else:
                     if not found:
                         missing.append(col)
 
         if missing:
-            raise KeyError("None of {} are in the columns".format(missing))
+            raise KeyError(f"None of {missing} are in the columns")
 
         if inplace:
             frame = self
@@ -4365,14 +4332,14 @@ def set_index(
         arrays = []
         names = []
         if append:
-            names = [x for x in self.index.names]
+            names = list(self.index.names)
             if isinstance(self.index, ABCMultiIndex):
                 for i in range(self.index.nlevels):
                     arrays.append(self.index._get_level_values(i))
             else:
                 arrays.append(self.index)
 
-        to_remove = []
+        to_remove: List[Optional[Hashable]] = []
         for col in keys:
             if isinstance(col, ABCMultiIndex):
                 for n in range(col.nlevels):
@@ -4399,17 +4366,15 @@ def set_index(
                 # check newest element against length of calling frame, since
                 # ensure_index_from_sequences would not raise for append=False.
                 raise ValueError(
-                    "Length mismatch: Expected {len_self} rows, "
-                    "received array of length {len_col}".format(
-                        len_self=len(self), len_col=len(arrays[-1])
-                    )
+                    f"Length mismatch: Expected {len(self)} rows, "
+                    f"received array of length {len(arrays[-1])}"
                 )
 
         index = ensure_index_from_sequences(arrays, names)
 
         if verify_integrity and not index.is_unique:
             duplicates = index[index.duplicated()].unique()
-            raise ValueError("Index has duplicate keys: {dup}".format(dup=duplicates))
+            raise ValueError(f"Index has duplicate keys: {duplicates}")
 
         # use set to handle duplicate column names gracefully in case of drop
         for c in set(to_remove):
@@ -4424,8 +4389,13 @@ def set_index(
             return frame
 
     def reset_index(
-        self, level=None, drop=False, inplace=False, col_level=0, col_fill=""
-    ):
+        self,
+        level: Optional[Union[Hashable, Sequence[Hashable]]] = None,
+        drop: bool = False,
+        inplace: bool = False,
+        col_level: Hashable = 0,
+        col_fill: Optional[Hashable] = "",
+    ) -> Optional["DataFrame"]:
         """
         Reset the index, or a level of it.
 
@@ -4453,8 +4423,8 @@ def reset_index(
 
         Returns
         -------
-        DataFrame
-            DataFrame with the new index.
+        DataFrame or None
+            DataFrame with the new index or None if ``inplace=True``.
 
         See Also
         --------
@@ -4603,7 +4573,7 @@ def _maybe_casted_values(index, labels=None):
                         values = values._data
 
                     if mask.any():
-                        values, changed = maybe_upcast_putmask(values, mask, np.nan)
+                        values, _ = maybe_upcast_putmask(values, mask, np.nan)
 
                     if issubclass(values_type, DatetimeLikeArray):
                         values = values_type(values, dtype=values_dtype)
@@ -4619,10 +4589,11 @@ def _maybe_casted_values(index, labels=None):
                 new_index = self.index.droplevel(level)
 
         if not drop:
+            to_insert: Iterable[Tuple[Any, Optional[Any]]]
             if isinstance(self.index, ABCMultiIndex):
                 names = [
-                    n if n is not None else ("level_%d" % i)
-                    for (i, n) in enumerate(self.index.names)
+                    (n if n is not None else f"level_{i}")
+                    for i, n in enumerate(self.index.names)
                 ]
                 to_insert = zip(self.index.levels, self.index.codes)
             else:
@@ -4641,8 +4612,7 @@ def _maybe_casted_values(index, labels=None):
                         if len(col_name) not in (1, self.columns.nlevels):
                             raise ValueError(
                                 "col_fill=None is incompatible "
-                                "with incomplete column name "
-                                "{}".format(name)
+                                f"with incomplete column name {name}"
                             )
                         col_fill = col_name[0]
 
@@ -4659,23 +4629,25 @@ def _maybe_casted_values(index, labels=None):
         if not inplace:
             return new_obj
 
+        return None
+
     # ----------------------------------------------------------------------
     # Reindex-based selection methods
 
     @Appender(_shared_docs["isna"] % _shared_doc_kwargs)
-    def isna(self):
+    def isna(self) -> "DataFrame":
         return super().isna()
 
     @Appender(_shared_docs["isna"] % _shared_doc_kwargs)
-    def isnull(self):
+    def isnull(self) -> "DataFrame":
         return super().isnull()
 
     @Appender(_shared_docs["notna"] % _shared_doc_kwargs)
-    def notna(self):
+    def notna(self) -> "DataFrame":
         return super().notna()
 
     @Appender(_shared_docs["notna"] % _shared_doc_kwargs)
-    def notnull(self):
+    def notnull(self) -> "DataFrame":
         return super().notnull()
 
     def dropna(self, axis=0, how="any", thresh=None, subset=None, inplace=False):
@@ -4694,7 +4666,7 @@ def dropna(self, axis=0, how="any", thresh=None, subset=None, inplace=False):
             * 0, or 'index' : Drop rows which contain missing values.
             * 1, or 'columns' : Drop columns which contain missing value.
 
-            .. deprecated:: 0.23.0
+            .. versionchanged:: 1.0.0
 
                Pass tuple or list to drop on multiple axes.
                Only a single axis is allowed.
@@ -4784,70 +4756,75 @@ def dropna(self, axis=0, how="any", thresh=None, subset=None, inplace=False):
         inplace = validate_bool_kwarg(inplace, "inplace")
         if isinstance(axis, (tuple, list)):
             # GH20987
-            msg = (
-                "supplying multiple axes to axis is deprecated and "
-                "will be removed in a future version."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=2)
+            raise TypeError("supplying multiple axes to axis is no longer supported.")
 
-            result = self
-            for ax in axis:
-                result = result.dropna(how=how, thresh=thresh, subset=subset, axis=ax)
+        axis = self._get_axis_number(axis)
+        agg_axis = 1 - axis
+
+        agg_obj = self
+        if subset is not None:
+            ax = self._get_axis(agg_axis)
+            indices = ax.get_indexer_for(subset)
+            check = indices == -1
+            if check.any():
+                raise KeyError(list(np.compress(check, subset)))
+            agg_obj = self.take(indices, axis=agg_axis)
+
+        count = agg_obj.count(axis=agg_axis)
+
+        if thresh is not None:
+            mask = count >= thresh
+        elif how == "any":
+            mask = count == len(agg_obj._get_axis(agg_axis))
+        elif how == "all":
+            mask = count > 0
         else:
-            axis = self._get_axis_number(axis)
-            agg_axis = 1 - axis
-
-            agg_obj = self
-            if subset is not None:
-                ax = self._get_axis(agg_axis)
-                indices = ax.get_indexer_for(subset)
-                check = indices == -1
-                if check.any():
-                    raise KeyError(list(np.compress(check, subset)))
-                agg_obj = self.take(indices, axis=agg_axis)
-
-            count = agg_obj.count(axis=agg_axis)
-
-            if thresh is not None:
-                mask = count >= thresh
-            elif how == "any":
-                mask = count == len(agg_obj._get_axis(agg_axis))
-            elif how == "all":
-                mask = count > 0
+            if how is not None:
+                raise ValueError(f"invalid how option: {how}")
             else:
-                if how is not None:
-                    raise ValueError("invalid how option: {h}".format(h=how))
-                else:
-                    raise TypeError("must specify how or thresh")
+                raise TypeError("must specify how or thresh")
 
-            result = self.loc(axis=axis)[mask]
+        result = self.loc(axis=axis)[mask]
 
         if inplace:
             self._update_inplace(result)
         else:
             return result
 
-    def drop_duplicates(self, subset=None, keep="first", inplace=False):
+    def drop_duplicates(
+        self,
+        subset: Optional[Union[Hashable, Sequence[Hashable]]] = None,
+        keep: Union[str, bool] = "first",
+        inplace: bool = False,
+        ignore_index: bool = False,
+    ) -> Optional["DataFrame"]:
         """
-        Return DataFrame with duplicate rows removed, optionally only
-        considering certain columns. Indexes, including time indexes
+        Return DataFrame with duplicate rows removed.
+
+        Considering certain columns is optional. Indexes, including time indexes
         are ignored.
 
         Parameters
         ----------
         subset : column label or sequence of labels, optional
             Only consider certain columns for identifying duplicates, by
-            default use all of the columns
+            default use all of the columns.
         keep : {'first', 'last', False}, default 'first'
+            Determines which duplicates (if any) to keep.
             - ``first`` : Drop duplicates except for the first occurrence.
             - ``last`` : Drop duplicates except for the last occurrence.
             - False : Drop all duplicates.
-        inplace : boolean, default False
-            Whether to drop duplicates in place or to return a copy
+        inplace : bool, default False
+            Whether to drop duplicates in place or to return a copy.
+        ignore_index : bool, default False
+            If True, the resulting axis will be labeled 0, 1, …, n - 1.
+
+            .. versionadded:: 1.0.0
 
         Returns
         -------
         DataFrame
+            DataFrame with duplicates removed or None if ``inplace=True``.
         """
         if self.empty:
             return self.copy()
@@ -4856,27 +4833,41 @@ def drop_duplicates(self, subset=None, keep="first", inplace=False):
         duplicated = self.duplicated(subset, keep=keep)
 
         if inplace:
-            inds, = (-duplicated)._ndarray_values.nonzero()
+            (inds,) = (-duplicated)._ndarray_values.nonzero()
             new_data = self._data.take(inds)
+
+            if ignore_index:
+                new_data.axes[1] = ibase.default_index(len(inds))
             self._update_inplace(new_data)
         else:
-            return self[-duplicated]
+            result = self[-duplicated]
 
-    def duplicated(self, subset=None, keep="first"):
+            if ignore_index:
+                result.index = ibase.default_index(len(result))
+            return result
+
+        return None
+
+    def duplicated(
+        self,
+        subset: Optional[Union[Hashable, Sequence[Hashable]]] = None,
+        keep: Union[str, bool] = "first",
+    ) -> "Series":
         """
-        Return boolean Series denoting duplicate rows, optionally only
-        considering certain columns.
+        Return boolean Series denoting duplicate rows.
+
+        Considering certain columns is optional.
 
         Parameters
         ----------
         subset : column label or sequence of labels, optional
             Only consider certain columns for identifying duplicates, by
-            default use all of the columns
+            default use all of the columns.
         keep : {'first', 'last', False}, default 'first'
-            - ``first`` : Mark duplicates as ``True`` except for the
-              first occurrence.
-            - ``last`` : Mark duplicates as ``True`` except for the
-              last occurrence.
+            Determines which duplicates (if any) to mark.
+
+            - ``first`` : Mark duplicates as ``True`` except for the first occurrence.
+            - ``last`` : Mark duplicates as ``True`` except for the last occurrence.
             - False : Mark all duplicates as ``True``.
 
         Returns
@@ -4905,6 +4896,9 @@ def f(vals):
         ):
             subset = (subset,)
 
+        #  needed for mypy since can't narrow types using np.iterable
+        subset = cast(Iterable, subset)
+
         # Verify all columns in subset exist in the queried dataframe
         # Otherwise, raise a KeyError, same as if you try to __getitem__ with a
         # key that doesn't exist.
@@ -4931,6 +4925,7 @@ def sort_values(
         inplace=False,
         kind="quicksort",
         na_position="last",
+        ignore_index=False,
     ):
         inplace = validate_bool_kwarg(inplace, "inplace")
         axis = self._get_axis_number(axis)
@@ -4939,8 +4934,7 @@ def sort_values(
             by = [by]
         if is_sequence(ascending) and len(by) != len(ascending):
             raise ValueError(
-                "Length of ascending (%d) != length of by (%d)"
-                % (len(ascending), len(by))
+                f"Length of ascending ({len(ascending)}) != length of by ({len(by)})"
             )
         if len(by) > 1:
             from pandas.core.sorting import lexsort_indexer
@@ -4965,40 +4959,65 @@ def sort_values(
             indexer, axis=self._get_block_manager_axis(axis), verify=False
         )
 
+        if ignore_index:
+            new_data.axes[1] = ibase.default_index(len(indexer))
+
         if inplace:
             return self._update_inplace(new_data)
         else:
             return self._constructor(new_data).__finalize__(self)
 
-    @Substitution(**_shared_doc_kwargs)
-    @Appender(NDFrame.sort_index.__doc__)
     def sort_index(
         self,
         axis=0,
         level=None,
-        ascending=True,
-        inplace=False,
-        kind="quicksort",
-        na_position="last",
-        sort_remaining=True,
-        by=None,
+        ascending: bool = True,
+        inplace: bool = False,
+        kind: str = "quicksort",
+        na_position: str = "last",
+        sort_remaining: bool = True,
+        ignore_index: bool = False,
     ):
+        """
+        Sort object by labels (along an axis).
+
+        Parameters
+        ----------
+        axis : {0 or 'index', 1 or 'columns'}, default 0
+            The axis along which to sort.  The value 0 identifies the rows,
+            and 1 identifies the columns.
+        level : int or level name or list of ints or list of level names
+            If not None, sort on values in specified index level(s).
+        ascending : bool, default True
+            Sort ascending vs. descending.
+        inplace : bool, default False
+            If True, perform operation in-place.
+        kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
+            Choice of sorting algorithm. See also ndarray.np.sort for more
+            information.  `mergesort` is the only stable algorithm. For
+            DataFrames, this option is only applied when sorting on a single
+            column or label.
+        na_position : {'first', 'last'}, default 'last'
+            Puts NaNs at the beginning if `first`; `last` puts NaNs at the end.
+            Not implemented for MultiIndex.
+        sort_remaining : bool, default True
+            If True and sorting by level and index is multilevel, sort by other
+            levels too (in order) after sorting by specified level.
+        ignore_index : bool, default False
+            If True, the resulting axis will be labeled 0, 1, …, n - 1.
+
+            .. versionadded:: 1.0.0
+
+        Returns
+        -------
+        sorted_obj : DataFrame or None
+            DataFrame with sorted index if inplace=False, None otherwise.
+        """
 
         # TODO: this can be combined with Series.sort_index impl as
         # almost identical
 
         inplace = validate_bool_kwarg(inplace, "inplace")
-        # 10726
-        if by is not None:
-            warnings.warn(
-                "by argument to sort_index is deprecated, "
-                "please use .sort_values(by=...)",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if level is not None:
-                raise ValueError("unable to simultaneously sort by and level")
-            return self.sort_values(by, axis=axis, ascending=ascending, inplace=inplace)
 
         axis = self._get_axis_number(axis)
         labels = self._get_axis(axis)
@@ -5043,12 +5062,15 @@ def sort_index(
         # reconstruct axis if needed
         new_data.axes[baxis] = new_data.axes[baxis]._sort_levels_monotonic()
 
+        if ignore_index:
+            new_data.axes[1] = ibase.default_index(len(indexer))
+
         if inplace:
             return self._update_inplace(new_data)
         else:
             return self._constructor(new_data).__finalize__(self)
 
-    def nlargest(self, n, columns, keep="first"):
+    def nlargest(self, n, columns, keep="first") -> "DataFrame":
         """
         Return the first `n` rows ordered by `columns` in descending order.
 
@@ -5157,7 +5179,7 @@ def nlargest(self, n, columns, keep="first"):
         """
         return algorithms.SelectNFrame(self, n=n, keep=keep, columns=columns).nlargest()
 
-    def nsmallest(self, n, columns, keep="first"):
+    def nsmallest(self, n, columns, keep="first") -> "DataFrame":
         """
         Return the first `n` rows ordered by `columns` in ascending order.
 
@@ -5199,7 +5221,7 @@ def nsmallest(self, n, columns, keep="first"):
         Examples
         --------
         >>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
-        ...                                   434000, 434000, 337000, 11300,
+        ...                                   434000, 434000, 337000, 337000,
         ...                                   11300, 11300],
         ...                    'GDP': [1937894, 2583560 , 12011, 4520, 12128,
         ...                            17036, 182, 38, 311],
@@ -5216,18 +5238,18 @@ def nsmallest(self, n, columns, keep="first"):
         Maldives      434000     4520      MV
         Brunei        434000    12128      BN
         Iceland       337000    17036      IS
-        Nauru          11300      182      NR
+        Nauru         337000      182      NR
         Tuvalu         11300       38      TV
         Anguilla       11300      311      AI
 
         In the following example, we will use ``nsmallest`` to select the
-        three rows having the smallest values in column "a".
+        three rows having the smallest values in column "population".
 
         >>> df.nsmallest(3, 'population')
-                  population  GDP alpha-2
-        Nauru          11300  182      NR
-        Tuvalu         11300   38      TV
-        Anguilla       11300  311      AI
+                  population    GDP alpha-2
+        Tuvalu         11300     38      TV
+        Anguilla       11300    311      AI
+        Iceland       337000  17036	     IS
 
         When using ``keep='last'``, ties are resolved in reverse order:
 
@@ -5235,37 +5257,38 @@ def nsmallest(self, n, columns, keep="first"):
                   population  GDP alpha-2
         Anguilla       11300  311      AI
         Tuvalu         11300   38      TV
-        Nauru          11300  182      NR
+        Nauru         337000  182      NR
 
         When using ``keep='all'``, all duplicate items are maintained:
 
         >>> df.nsmallest(3, 'population', keep='all')
-                  population  GDP alpha-2
-        Nauru          11300  182      NR
-        Tuvalu         11300   38      TV
-        Anguilla       11300  311      AI
+                  population    GDP alpha-2
+        Tuvalu         11300     38      TV
+        Anguilla       11300    311      AI
+        Iceland       337000  17036      IS
+        Nauru         337000    182      NR
 
-        To order by the largest values in column "a" and then "c", we can
+        To order by the smallest values in column "population" and then "GDP", we can
         specify multiple columns like in the next example.
 
         >>> df.nsmallest(3, ['population', 'GDP'])
                   population  GDP alpha-2
         Tuvalu         11300   38      TV
-        Nauru          11300  182      NR
         Anguilla       11300  311      AI
+        Nauru         337000  182      NR
         """
         return algorithms.SelectNFrame(
             self, n=n, keep=keep, columns=columns
         ).nsmallest()
 
-    def swaplevel(self, i=-2, j=-1, axis=0):
+    def swaplevel(self, i=-2, j=-1, axis=0) -> "DataFrame":
         """
         Swap levels i and j in a MultiIndex on a particular axis.
 
         Parameters
         ----------
-        i, j : int, string (can be mixed)
-            Level of index to be swapped. Can pass level name as string.
+        i, j : int or str
+            Levels of the indices to be swapped. Can pass level name as string.
 
         Returns
         -------
@@ -5274,16 +5297,21 @@ def swaplevel(self, i=-2, j=-1, axis=0):
         result = self.copy()
 
         axis = self._get_axis_number(axis)
+
+        if not isinstance(result._get_axis(axis), ABCMultiIndex):  # pragma: no cover
+            raise TypeError("Can only swap levels on a hierarchical axis.")
+
         if axis == 0:
+            assert isinstance(result.index, ABCMultiIndex)
             result.index = result.index.swaplevel(i, j)
         else:
+            assert isinstance(result.columns, ABCMultiIndex)
             result.columns = result.columns.swaplevel(i, j)
         return result
 
-    def reorder_levels(self, order, axis=0):
+    def reorder_levels(self, order, axis=0) -> "DataFrame":
         """
-        Rearrange index levels using input order. May not drop or
-        duplicate levels.
+        Rearrange index levels using input order. May not drop or duplicate levels.
 
         Parameters
         ----------
@@ -5295,7 +5323,7 @@ def reorder_levels(self, order, axis=0):
 
         Returns
         -------
-        type of caller (new object)
+        DataFrame
         """
         axis = self._get_axis_number(axis)
         if not isinstance(self._get_axis(axis), ABCMultiIndex):  # pragma: no cover
@@ -5304,17 +5332,18 @@ def reorder_levels(self, order, axis=0):
         result = self.copy()
 
         if axis == 0:
+            assert isinstance(result.index, ABCMultiIndex)
             result.index = result.index.reorder_levels(order)
         else:
+            assert isinstance(result.columns, ABCMultiIndex)
             result.columns = result.columns.reorder_levels(order)
         return result
 
     # ----------------------------------------------------------------------
     # Arithmetic / combination related
 
-    def _combine_frame(self, other, func, fill_value=None, level=None):
-        this, other = self.align(other, join="outer", level=level, copy=False)
-        new_index, new_columns = this.index, this.columns
+    def _combine_frame(self, other: "DataFrame", func, fill_value=None):
+        # at this point we have `self._indexed_same(other)`
 
         if fill_value is None:
             # since _arith_op may be called in a loop, avoid function call
@@ -5330,42 +5359,51 @@ def _arith_op(left, right):
                 left, right = ops.fill_binop(left, right, fill_value)
                 return func(left, right)
 
-        if ops.should_series_dispatch(this, other, func):
+        if ops.should_series_dispatch(self, other, func):
             # iterate over columns
-            return ops.dispatch_to_series(this, other, _arith_op)
+            new_data = ops.dispatch_to_series(self, other, _arith_op)
         else:
             with np.errstate(all="ignore"):
-                result = _arith_op(this.values, other.values)
-            result = dispatch_fill_zeros(func, this.values, other.values, result)
-            return self._constructor(
-                result, index=new_index, columns=new_columns, copy=False
-            )
+                res_values = _arith_op(self.values, other.values)
+            new_data = dispatch_fill_zeros(func, self.values, other.values, res_values)
+
+        return new_data
 
-    def _combine_match_index(self, other, func, level=None):
-        left, right = self.align(other, join="outer", axis=0, level=level, copy=False)
-        # at this point we have `left.index.equals(right.index)`
+    def _combine_match_index(self, other: Series, func):
+        # at this point we have `self.index.equals(other.index)`
 
-        if left._is_mixed_type or right._is_mixed_type:
+        if ops.should_series_dispatch(self, other, func):
             # operate column-wise; avoid costly object-casting in `.values`
-            return ops.dispatch_to_series(left, right, func)
+            new_data = ops.dispatch_to_series(self, other, func)
         else:
             # fastpath --> operate directly on values
+            other_vals = other.values.reshape(-1, 1)
             with np.errstate(all="ignore"):
-                new_data = func(left.values.T, right.values).T
-            return self._constructor(
-                new_data, index=left.index, columns=self.columns, copy=False
-            )
+                new_data = func(self.values, other_vals)
+            new_data = dispatch_fill_zeros(func, self.values, other_vals, new_data)
+        return new_data
 
-    def _combine_match_columns(self, other: Series, func, level=None):
-        left, right = self.align(other, join="outer", axis=1, level=level, copy=False)
-        # at this point we have `left.columns.equals(right.index)`
-        return ops.dispatch_to_series(left, right, func, axis="columns")
+    def _construct_result(self, result) -> "DataFrame":
+        """
+        Wrap the result of an arithmetic, comparison, or logical operation.
 
-    def _combine_const(self, other, func):
-        # scalar other or np.ndim(other) == 0
-        return ops.dispatch_to_series(self, other, func)
+        Parameters
+        ----------
+        result : DataFrame
 
-    def combine(self, other, func, fill_value=None, overwrite=True):
+        Returns
+        -------
+        DataFrame
+        """
+        out = self._constructor(result, index=self.index, copy=False)
+        # Pin columns instead of passing to constructor for compat with
+        #  non-unique columns case
+        out.columns = self.columns
+        return out
+
+    def combine(
+        self, other: "DataFrame", func, fill_value=None, overwrite=True
+    ) -> "DataFrame":
         """
         Perform column-wise combine with another DataFrame.
 
@@ -5532,7 +5570,7 @@ def combine(self, other, func, fill_value=None, overwrite=True):
         # convert_objects just in case
         return self._constructor(result, index=new_index, columns=new_columns)
 
-    def combine_first(self, other):
+    def combine_first(self, other: "DataFrame") -> "DataFrame":
         """
         Update null elements with value in the same location in `other`.
 
@@ -5556,7 +5594,6 @@ def combine_first(self, other):
 
         Examples
         --------
-
         >>> df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
         >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
         >>> df1.combine_first(df2)
@@ -5608,14 +5645,9 @@ def combiner(x, y):
 
         return self.combine(other, combiner, overwrite=False)
 
-    @deprecate_kwarg(
-        old_arg_name="raise_conflict",
-        new_arg_name="errors",
-        mapping={False: "ignore", True: "raise"},
-    )
     def update(
         self, other, join="left", overwrite=True, filter_func=None, errors="ignore"
-    ):
+    ) -> None:
         """
         Modify in place using non-NA values from another DataFrame.
 
@@ -5766,6 +5798,83 @@ def update(
 
     # ----------------------------------------------------------------------
     # Data reshaping
+    @Appender(
+        """
+Examples
+--------
+>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
+...                               'Parrot', 'Parrot'],
+...                    'Max Speed': [380., 370., 24., 26.]})
+>>> df
+   Animal  Max Speed
+0  Falcon      380.0
+1  Falcon      370.0
+2  Parrot       24.0
+3  Parrot       26.0
+>>> df.groupby(['Animal']).mean()
+        Max Speed
+Animal
+Falcon      375.0
+Parrot       25.0
+
+**Hierarchical Indexes**
+
+We can groupby different levels of a hierarchical index
+using the `level` parameter:
+
+>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
+...           ['Captive', 'Wild', 'Captive', 'Wild']]
+>>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
+>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
+...                   index=index)
+>>> df
+                Max Speed
+Animal Type
+Falcon Captive      390.0
+       Wild         350.0
+Parrot Captive       30.0
+       Wild          20.0
+>>> df.groupby(level=0).mean()
+        Max Speed
+Animal
+Falcon      370.0
+Parrot       25.0
+>>> df.groupby(level="Type").mean()
+         Max Speed
+Type
+Captive      210.0
+Wild         185.0
+"""
+    )
+    @Appender(_shared_docs["groupby"] % _shared_doc_kwargs)
+    def groupby(
+        self,
+        by=None,
+        axis=0,
+        level=None,
+        as_index: bool = True,
+        sort: bool = True,
+        group_keys: bool = True,
+        squeeze: bool = False,
+        observed: bool = False,
+    ) -> "DataFrameGroupBy":
+        from pandas.core.groupby.generic import DataFrameGroupBy
+
+        if level is None and by is None:
+            raise TypeError("You have to supply one of 'by' and 'level'")
+        axis = self._get_axis_number(axis)
+
+        return DataFrameGroupBy(
+            obj=self,
+            keys=by,
+            axis=axis,
+            level=level,
+            as_index=as_index,
+            sort=sort,
+            group_keys=group_keys,
+            squeeze=squeeze,
+            observed=observed,
+        )
 
     _shared_docs[
         "pivot"
@@ -5780,12 +5889,20 @@ def update(
 
         Parameters
         ----------%s
-        index : string or object, optional
+        index : str or object or a list of str, optional
             Column to use to make new frame's index. If None, uses
             existing index.
-        columns : string or object
+
+            .. versionchanged:: 1.1.0
+               Also accept list of index names.
+
+        columns : str or object or a list of str
             Column to use to make new frame's columns.
-        values : string, object or a list of the previous, optional
+
+            .. versionchanged:: 1.1.0
+               Also accept list of columns names.
+
+        values : str, object or a list of the previous, optional
             Column(s) to use for populating new frame's values. If not
             specified, all remaining columns will be used and the result will
             have hierarchically indexed columns.
@@ -5851,6 +5968,38 @@ def update(
         one   1  2  3   x  y  z
         two   4  5  6   q  w  t
 
+        You could also assign a list of column names or a list of index names.
+
+        >>> df = pd.DataFrame({
+        ...        "lev1": [1, 1, 1, 2, 2, 2],
+        ...        "lev2": [1, 1, 2, 1, 1, 2],
+        ...        "lev3": [1, 2, 1, 2, 1, 2],
+        ...        "lev4": [1, 2, 3, 4, 5, 6],
+        ...        "values": [0, 1, 2, 3, 4, 5]})
+        >>> df
+            lev1 lev2 lev3 lev4 values
+        0   1    1    1    1    0
+        1   1    1    2    2    1
+        2   1    2    1    3    2
+        3   2    1    2    4    3
+        4   2    1    1    5    4
+        5   2    2    2    6    5
+
+        >>> df.pivot(index="lev1", columns=["lev2", "lev3"],values="values")
+        lev2    1         2
+        lev3    1    2    1    2
+        lev1
+        1     0.0  1.0  2.0  NaN
+        2     4.0  3.0  NaN  5.0
+
+        >>> df.pivot(index=["lev1", "lev2"], columns=["lev3"],values="values")
+              lev3    1    2
+        lev1  lev2
+           1     1  0.0  1.0
+                 2  2.0  NaN
+           2     1  4.0  3.0
+                 2  NaN  5.0
+
         A ValueError is raised if there are any duplicates.
 
         >>> df = pd.DataFrame({"foo": ['one', 'one', 'two', 'two'],
@@ -5874,7 +6023,7 @@ def update(
 
     @Substitution("")
     @Appender(_shared_docs["pivot"])
-    def pivot(self, index=None, columns=None, values=None):
+    def pivot(self, index=None, columns=None, values=None) -> "DataFrame":
         from pandas.core.reshape.pivot import pivot
 
         return pivot(self, index=index, columns=columns, values=values)
@@ -5882,9 +6031,10 @@ def pivot(self, index=None, columns=None, values=None):
     _shared_docs[
         "pivot_table"
     ] = """
-        Create a spreadsheet-style pivot table as a DataFrame. The levels in
-        the pivot table will be stored in MultiIndex objects (hierarchical
-        indexes) on the index and columns of the result DataFrame.
+        Create a spreadsheet-style pivot table as a DataFrame.
+
+        The levels in the pivot table will be stored in MultiIndex objects
+        (hierarchical indexes) on the index and columns of the result DataFrame.
 
         Parameters
         ----------%s
@@ -5904,17 +6054,17 @@ def pivot(self, index=None, columns=None, values=None):
             hierarchical columns whose top level are the function names
             (inferred from the function objects themselves)
             If dict is passed, the key is column to aggregate and value
-            is function or list of functions
+            is function or list of functions.
         fill_value : scalar, default None
-            Value to replace missing values with
-        margins : boolean, default False
-            Add all row / columns (e.g. for subtotal / grand totals)
-        dropna : boolean, default True
-            Do not include columns whose entries are all NaN
-        margins_name : string, default 'All'
+            Value to replace missing values with.
+        margins : bool, default False
+            Add all row / columns (e.g. for subtotal / grand totals).
+        dropna : bool, default True
+            Do not include columns whose entries are all NaN.
+        margins_name : str, default 'All'
             Name of the row / column that will contain the totals
             when margins is True.
-        observed : boolean, default False
+        observed : bool, default False
             This only applies if any of the groupers are Categoricals.
             If True: only show observed values for categorical groupers.
             If False: show all values for categorical groupers.
@@ -5924,6 +6074,7 @@ def pivot(self, index=None, columns=None, values=None):
         Returns
         -------
         DataFrame
+            An Excel style pivot table.
 
         See Also
         --------
@@ -6019,7 +6170,7 @@ def pivot_table(
         dropna=True,
         margins_name="All",
         observed=False,
-    ):
+    ) -> "DataFrame":
         from pandas.core.reshape.pivot import pivot_table
 
         return pivot_table(
@@ -6261,23 +6412,26 @@ def explode(self, column: Union[str, Tuple]) -> "DataFrame":
         3    3  1
         3    4  1
         """
-
         if not (is_scalar(column) or isinstance(column, tuple)):
             raise ValueError("column must be a scalar")
         if not self.columns.is_unique:
             raise ValueError("columns must be unique")
 
-        result = self[column].explode()
-        return (
-            self.drop([column], axis=1)
-            .join(result)
-            .reindex(columns=self.columns, copy=False)
-        )
+        df = self.reset_index(drop=True)
+        # TODO: use overload to refine return type of reset_index
+        assert df is not None  # needed for mypy
+        result = df[column].explode()
+        result = df.drop([column], axis=1).join(result)
+        result.index = self.index.take(result.index)
+        result = result.reindex(columns=self.columns, copy=False)
+
+        return result
 
     def unstack(self, level=-1, fill_value=None):
         """
-        Pivot a level of the (necessarily hierarchical) index labels, returning
-        a DataFrame having a new level of column labels whose inner-most level
+        Pivot a level of the (necessarily hierarchical) index labels.
+
+        Returns a DataFrame having a new level of column labels whose inner-most level
         consists of the pivoted index labels.
 
         If the index is not a MultiIndex, the output will be a Series
@@ -6287,10 +6441,10 @@ def unstack(self, level=-1, fill_value=None):
 
         Parameters
         ----------
-        level : int, string, or list of these, default -1 (last level)
-            Level(s) of index to unstack, can pass level name
-        fill_value : replace NaN with this value if the unstack produces
-            missing values
+        level : int, str, or list of these, default -1 (last level)
+            Level(s) of index to unstack, can pass level name.
+        fill_value : int, str or dict
+            Replace NaN with this value if the unstack produces missing values.
 
         Returns
         -------
@@ -6339,8 +6493,7 @@ def unstack(self, level=-1, fill_value=None):
     _shared_docs[
         "melt"
     ] = """
-    Unpivot a DataFrame from wide format to long format, optionally
-    leaving identifier variables set.
+    Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.
 
     This function is useful to massage a DataFrame into a format where one
     or more columns are identifier variables (`id_vars`), while all other
@@ -6350,7 +6503,6 @@ def unstack(self, level=-1, fill_value=None):
     %(versionadded)s
     Parameters
     ----------
-    frame : DataFrame
     id_vars : tuple, list, or ndarray, optional
         Column(s) to use as identifier variables.
     value_vars : tuple, list, or ndarray, optional
@@ -6361,7 +6513,7 @@ def unstack(self, level=-1, fill_value=None):
         ``frame.columns.name`` or 'variable'.
     value_name : scalar, default 'value'
         Name to use for the 'value' column.
-    col_level : int or string, optional
+    col_level : int or str, optional
         If columns are a MultiIndex then use this level to melt.
 
     Returns
@@ -6437,7 +6589,9 @@ def unstack(self, level=-1, fill_value=None):
     @Appender(
         _shared_docs["melt"]
         % dict(
-            caller="df.melt(", versionadded=".. versionadded:: 0.20.0\n", other="melt"
+            caller="df.melt(",
+            versionadded="\n    .. versionadded:: 0.20.0\n",
+            other="melt",
         )
     )
     def melt(
@@ -6447,7 +6601,7 @@ def melt(
         var_name=None,
         value_name="value",
         col_level=None,
-    ):
+    ) -> "DataFrame":
         from pandas.core.reshape.melt import melt
 
         return melt(
@@ -6462,7 +6616,7 @@ def melt(
     # ----------------------------------------------------------------------
     # Time series-related
 
-    def diff(self, periods=1, axis=0):
+    def diff(self, periods=1, axis=0) -> "DataFrame":
         """
         First discrete difference of element.
 
@@ -6478,8 +6632,6 @@ def diff(self, periods=1, axis=0):
         axis : {0 or 'index', 1 or 'columns'}, default 0
             Take difference over rows (0) or columns (1).
 
-            .. versionadded:: 0.16.1.
-
         Returns
         -------
         DataFrame
@@ -6491,6 +6643,11 @@ def diff(self, periods=1, axis=0):
         DataFrame.shift: Shift index by desired number of periods with an
             optional time freq.
 
+        Notes
+        -----
+        For boolean dtypes, this uses :meth:`operator.xor` rather than
+        :meth:`operator.sub`.
+
         Examples
         --------
         Difference with previous row
@@ -6645,7 +6802,7 @@ def _gotitem(
         see_also=_agg_summary_and_see_also_doc,
         examples=_agg_examples_doc,
         versionadded="\n.. versionadded:: 0.20.0\n",
-        **_shared_doc_kwargs
+        **_shared_doc_kwargs,
     )
     @Appender(_shared_docs["aggregate"])
     def aggregate(self, func, axis=0, *args, **kwargs):
@@ -6672,23 +6829,13 @@ def _aggregate(self, arg, axis=0, *args, **kwargs):
     agg = aggregate
 
     @Appender(_shared_docs["transform"] % _shared_doc_kwargs)
-    def transform(self, func, axis=0, *args, **kwargs):
+    def transform(self, func, axis=0, *args, **kwargs) -> "DataFrame":
         axis = self._get_axis_number(axis)
         if axis == 1:
             return self.T.transform(func, *args, **kwargs).T
         return super().transform(func, *args, **kwargs)
 
-    def apply(
-        self,
-        func,
-        axis=0,
-        broadcast=None,
-        raw=False,
-        reduce=None,
-        result_type=None,
-        args=(),
-        **kwds
-    ):
+    def apply(self, func, axis=0, raw=False, result_type=None, args=(), **kwds):
         """
         Apply a function along an axis of the DataFrame.
 
@@ -6707,40 +6854,16 @@ def apply(
 
             * 0 or 'index': apply function to each column.
             * 1 or 'columns': apply function to each row.
-        broadcast : bool, optional
-            Only relevant for aggregation functions:
-
-            * ``False`` or ``None`` : returns a Series whose length is the
-              length of the index or the number of columns (based on the
-              `axis` parameter)
-            * ``True`` : results will be broadcast to the original shape
-              of the frame, the original index and columns will be retained.
-
-            .. deprecated:: 0.23.0
-               This argument will be removed in a future version, replaced
-               by result_type='broadcast'.
 
         raw : bool, default False
+            Determines if row or column is passed as a Series or ndarray object:
+
             * ``False`` : passes each row or column as a Series to the
               function.
             * ``True`` : the passed function will receive ndarray objects
               instead.
               If you are just applying a NumPy reduction function this will
               achieve much better performance.
-        reduce : bool or None, default None
-            Try to apply reduction procedures. If the DataFrame is empty,
-            `apply` will use `reduce` to determine whether the result
-            should be a Series or a DataFrame. If ``reduce=None`` (the
-            default), `apply`'s return value will be guessed by calling
-            `func` on an empty Series
-            (note: while guessing, exceptions raised by `func` will be
-            ignored).
-            If ``reduce=True`` a Series will always be returned, and if
-            ``reduce=False`` a DataFrame will always be returned.
-
-            .. deprecated:: 0.23.0
-               This argument will be removed in a future version, replaced
-               by ``result_type='reduce'``.
 
         result_type : {'expand', 'reduce', 'broadcast', None}, default None
             These only act when ``axis=1`` (columns):
@@ -6778,17 +6901,8 @@ def apply(
         DataFrame.aggregate: Only perform aggregating type operations.
         DataFrame.transform: Only perform transforming type operations.
 
-        Notes
-        -----
-        In the current implementation apply calls `func` twice on the
-        first column/row to decide whether it can take a fast or slow
-        code path. This can lead to unexpected behavior if `func` has
-        side-effects, as they will take effect twice for the first
-        column/row.
-
         Examples
         --------
-
         >>> df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
         >>> df
            A  B
@@ -6862,16 +6976,14 @@ def apply(
             self,
             func=func,
             axis=axis,
-            broadcast=broadcast,
             raw=raw,
-            reduce=reduce,
             result_type=result_type,
             args=args,
             kwds=kwds,
         )
         return op.get_result()
 
-    def applymap(self, func):
+    def applymap(self, func) -> "DataFrame":
         """
         Apply a function to a Dataframe elementwise.
 
@@ -6940,7 +7052,9 @@ def infer(x):
     # ----------------------------------------------------------------------
     # Merging / joining methods
 
-    def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
+    def append(
+        self, other, ignore_index=False, verify_integrity=False, sort=False
+    ) -> "DataFrame":
         """
         Append rows of `other` to the end of caller, returning a new object.
 
@@ -6950,18 +7064,17 @@ def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
         ----------
         other : DataFrame or Series/dict-like object, or list of these
             The data to append.
-        ignore_index : boolean, default False
+        ignore_index : bool, default False
             If True, do not use the index labels.
-        verify_integrity : boolean, default False
+        verify_integrity : bool, default False
             If True, raise ValueError on creating index with duplicates.
-        sort : boolean, default None
+        sort : bool, default False
             Sort columns if the columns of `self` and `other` are not aligned.
-            The default sorting is deprecated and will change to not-sorting
-            in a future version of pandas. Explicitly pass ``sort=True`` to
-            silence the warning and sort. Explicitly pass ``sort=False`` to
-            silence the warning and not sort.
 
             .. versionadded:: 0.23.0
+            .. versionchanged:: 1.0.0
+
+                Changed to not sort by default.
 
         Returns
         -------
@@ -6984,7 +7097,6 @@ def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
 
         Examples
         --------
-
         >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
         >>> df
            A  B
@@ -7036,43 +7148,41 @@ def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
         """
         if isinstance(other, (Series, dict)):
             if isinstance(other, dict):
+                if not ignore_index:
+                    raise TypeError("Can only append a dict if ignore_index=True")
                 other = Series(other)
             if other.name is None and not ignore_index:
                 raise TypeError(
-                    "Can only append a Series if ignore_index=True"
-                    " or if the Series has a name"
+                    "Can only append a Series if ignore_index=True "
+                    "or if the Series has a name"
                 )
 
-            if other.name is None:
-                index = None
-            else:
-                # other must have the same index name as self, otherwise
-                # index name will be reset
-                index = Index([other.name], name=self.index.name)
-
+            index = Index([other.name], name=self.index.name)
             idx_diff = other.index.difference(self.columns)
             try:
                 combined_columns = self.columns.append(idx_diff)
             except TypeError:
                 combined_columns = self.columns.astype(object).append(idx_diff)
-            other = other.reindex(combined_columns, copy=False)
-            other = DataFrame(
-                other.values.reshape((1, len(other))),
-                index=index,
-                columns=combined_columns,
+            other = (
+                other.reindex(combined_columns, copy=False)
+                .to_frame()
+                .T.infer_objects()
+                .rename_axis(index.names, copy=False)
             )
-            other = other._convert(datetime=True, timedelta=True)
             if not self.columns.equals(combined_columns):
                 self = self.reindex(columns=combined_columns)
-        elif isinstance(other, list) and not isinstance(other[0], DataFrame):
-            other = DataFrame(other)
-            if (self.columns.get_indexer(other.columns) >= 0).all():
-                other = other.reindex(columns=self.columns)
+        elif isinstance(other, list):
+            if not other:
+                pass
+            elif not isinstance(other[0], DataFrame):
+                other = DataFrame(other)
+                if (self.columns.get_indexer(other.columns) >= 0).all():
+                    other = other.reindex(columns=self.columns)
 
         from pandas.core.reshape.concat import concat
 
         if isinstance(other, (list, tuple)):
-            to_concat = [self] + other
+            to_concat = [self, *other]
         else:
             to_concat = [self, other]
         return concat(
@@ -7082,7 +7192,9 @@ def append(self, other, ignore_index=False, verify_integrity=False, sort=None):
             sort=sort,
         )
 
-    def join(self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False):
+    def join(
+        self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False
+    ) -> "DataFrame":
         """
         Join columns of another DataFrame.
 
@@ -7200,7 +7312,6 @@ def join(self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False):
         4  K4  A4  NaN
         5  K5  A5  NaN
         """
-        # For SparseDataFrame's benefit
         return self._join_compat(
             other, on=on, how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort
         )
@@ -7274,7 +7385,7 @@ def merge(
         copy=True,
         indicator=False,
         validate=None,
-    ):
+    ) -> "DataFrame":
         from pandas.core.reshape.merge import merge
 
         return merge(
@@ -7293,7 +7404,7 @@ def merge(
             validate=validate,
         )
 
-    def round(self, decimals=0, *args, **kwargs):
+    def round(self, decimals=0, *args, **kwargs) -> "DataFrame":
         """
         Round a DataFrame to a variable number of decimal places.
 
@@ -7390,7 +7501,7 @@ def _series_round(s, decimals):
             if isinstance(decimals, Series):
                 if not decimals.index.is_unique:
                     raise ValueError("Index of decimals must be unique")
-            new_cols = [col for col in _dict_round(self, decimals)]
+            new_cols = list(_dict_round(self, decimals))
         elif is_integer(decimals):
             # Dispatch to Series.round
             new_cols = [_series_round(v, decimals) for _, v in self.items()]
@@ -7407,20 +7518,23 @@ def _series_round(s, decimals):
     # ----------------------------------------------------------------------
     # Statistical methods, etc.
 
-    def corr(self, method="pearson", min_periods=1):
+    def corr(self, method="pearson", min_periods=1) -> "DataFrame":
         """
         Compute pairwise correlation of columns, excluding NA/null values.
 
         Parameters
         ----------
         method : {'pearson', 'kendall', 'spearman'} or callable
+            Method of correlation:
+
             * pearson : standard correlation coefficient
             * kendall : Kendall Tau correlation coefficient
             * spearman : Spearman rank correlation
             * callable: callable with input two 1d ndarrays
                 and returning a float. Note that the returned matrix from corr
                 will have 1 along the diagonals and will be symmetric
-                regardless of the callable's behavior
+                regardless of the callable's behavior.
+
                 .. versionadded:: 0.24.0
 
         min_periods : int, optional
@@ -7487,12 +7601,12 @@ def corr(self, method="pearson", min_periods=1):
             raise ValueError(
                 "method must be either 'pearson', "
                 "'spearman', 'kendall', or a callable, "
-                "'{method}' was supplied".format(method=method)
+                f"'{method}' was supplied"
             )
 
         return self._constructor(correl, index=idx, columns=cols)
 
-    def cov(self, min_periods=None):
+    def cov(self, min_periods=None) -> "DataFrame":
         """
         Compute pairwise covariance of columns, excluding NA/null values.
 
@@ -7545,7 +7659,7 @@ def cov(self, min_periods=None):
         semi-definite. This could lead to estimate correlations having
         absolute values which are greater than one, and/or a non-invertible
         covariance matrix. See `Estimation of covariance matrices
-        <http://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_
+        <https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_
         matrices>`__ for more details.
 
         Examples
@@ -7602,26 +7716,32 @@ def cov(self, min_periods=None):
 
         return self._constructor(baseCov, index=idx, columns=cols)
 
-    def corrwith(self, other, axis=0, drop=False, method="pearson"):
+    def corrwith(self, other, axis=0, drop=False, method="pearson") -> Series:
         """
-        Compute pairwise correlation between rows or columns of DataFrame
-        with rows or columns of Series or DataFrame.  DataFrames are first
-        aligned along both axes before computing the correlations.
+        Compute pairwise correlation.
+
+        Pairwise correlation is computed between rows or columns of
+        DataFrame with rows or columns of Series or DataFrame. DataFrames
+        are first aligned along both axes before computing the
+        correlations.
 
         Parameters
         ----------
         other : DataFrame, Series
             Object with which to compute correlations.
         axis : {0 or 'index', 1 or 'columns'}, default 0
-            0 or 'index' to compute column-wise, 1 or 'columns' for row-wise.
+            The axis to use. 0 or 'index' to compute column-wise, 1 or 'columns' for
+            row-wise.
         drop : bool, default False
             Drop missing indices from result.
         method : {'pearson', 'kendall', 'spearman'} or callable
+            Method of correlation:
+
             * pearson : standard correlation coefficient
             * kendall : Kendall Tau correlation coefficient
             * spearman : Spearman rank correlation
             * callable: callable with input two 1d ndarrays
-                and returning a float
+                and returning a float.
 
             .. versionadded:: 0.24.0
 
@@ -7672,9 +7792,9 @@ def c(x):
 
         else:
             raise ValueError(
-                "Invalid method {method} was passed, "
+                f"Invalid method {method} was passed, "
                 "valid methods are: 'pearson', 'kendall', "
-                "'spearman', or callable".format(method=method)
+                "'spearman', or callable"
             )
 
         if not drop:
@@ -7804,8 +7924,7 @@ def _count_level(self, level, axis=0, numeric_only=False):
 
         if not isinstance(count_axis, ABCMultiIndex):
             raise TypeError(
-                "Can only count levels on hierarchical "
-                "{ax}.".format(ax=self._get_axis_name(axis))
+                f"Can only count levels on hierarchical {self._get_axis_name(axis)}."
             )
 
         if frame._is_mixed_type:
@@ -7824,7 +7943,8 @@ def _count_level(self, level, axis=0, numeric_only=False):
         if isinstance(level, str):
             level = count_axis._get_level_number(level)
 
-        level_index = count_axis.levels[level]
+        level_name = count_axis._names[level]
+        level_index = count_axis.levels[level]._shallow_copy(name=level_name)
         level_codes = ensure_int64(count_axis.codes[level])
         counts = lib.count_level_2d(mask, level_codes, len(level_index), axis=0)
 
@@ -7851,20 +7971,46 @@ def _reduce(
         def f(x):
             return op(x, axis=axis, skipna=skipna, **kwds)
 
-        # exclude timedelta/datetime unless we are uniform types
-        if (
-            axis == 1
-            and self._is_datelike_mixed_type
-            and (
-                not self._is_homogeneous_type
-                and not is_datetime64tz_dtype(self.dtypes[0])
-            )
-        ):
-            numeric_only = True
+        def _get_data(axis_matters):
+            if filter_type is None or filter_type == "numeric":
+                data = self._get_numeric_data()
+            elif filter_type == "bool":
+                if axis_matters:
+                    # GH#25101, GH#24434
+                    data = self._get_bool_data() if axis == 0 else self
+                else:
+                    data = self._get_bool_data()
+            else:  # pragma: no cover
+                msg = (
+                    f"Generating numeric_only data with filter_type {filter_type} "
+                    "not supported."
+                )
+                raise NotImplementedError(msg)
+            return data
+
+        if numeric_only is not None and axis in [0, 1]:
+            df = self
+            if numeric_only is True:
+                df = _get_data(axis_matters=True)
+            if axis == 1:
+                df = df.T
+                axis = 0
+
+            out_dtype = "bool" if filter_type == "bool" else None
+
+            # After possibly _get_data and transposing, we are now in the
+            #  simple case where we can use BlockManager._reduce
+            res = df._data.reduce(op, axis=1, skipna=skipna, **kwds)
+            assert isinstance(res, dict)
+            if len(res):
+                assert len(res) == max(list(res.keys())) + 1, res.keys()
+            out = df._constructor_sliced(res, index=range(len(res)), dtype=out_dtype)
+            out.index = df.columns
+            return out
 
         if numeric_only is None:
+            values = self.values
             try:
-                values = self.values
                 result = f(values)
 
                 if filter_type == "bool" and is_object_dtype(values) and axis is None:
@@ -7872,58 +8018,38 @@ def f(x):
                     # TODO: combine with hasattr(result, 'dtype') further down
                     # hard since we don't have `values` down there.
                     result = np.bool_(result)
-            except Exception as e:
+            except TypeError:
+                # e.g. in nanops trying to convert strs to float
 
                 # try by-column first
                 if filter_type is None and axis == 0:
-                    try:
-
-                        # this can end up with a non-reduction
-                        # but not always. if the types are mixed
-                        # with datelike then need to make sure a series
-
-                        # we only end up here if we have not specified
-                        # numeric_only and yet we have tried a
-                        # column-by-column reduction, where we have mixed type.
-                        # So let's just do what we can
-                        from pandas.core.apply import frame_apply
-
-                        opa = frame_apply(
-                            self, func=f, result_type="expand", ignore_failures=True
-                        )
-                        result = opa.get_result()
-                        if result.ndim == self.ndim:
-                            result = result.iloc[0]
-                        return result
-                    except Exception:
-                        pass
-
-                if filter_type is None or filter_type == "numeric":
-                    data = self._get_numeric_data()
-                elif filter_type == "bool":
-                    data = self._get_bool_data()
-                else:  # pragma: no cover
-                    e = NotImplementedError(
-                        "Handling exception with filter_type {f} not"
-                        "implemented.".format(f=filter_type)
+                    # this can end up with a non-reduction
+                    # but not always. if the types are mixed
+                    # with datelike then need to make sure a series
+
+                    # we only end up here if we have not specified
+                    # numeric_only and yet we have tried a
+                    # column-by-column reduction, where we have mixed type.
+                    # So let's just do what we can
+                    from pandas.core.apply import frame_apply
+
+                    opa = frame_apply(
+                        self, func=f, result_type="expand", ignore_failures=True
                     )
-                    raise_with_traceback(e)
+                    result = opa.get_result()
+                    if result.ndim == self.ndim:
+                        result = result.iloc[0]
+                    return result
+
+                # TODO: why doesnt axis matter here?
+                data = _get_data(axis_matters=False)
                 with np.errstate(all="ignore"):
                     result = f(data.values)
                 labels = data._get_agg_axis(axis)
         else:
             if numeric_only:
-                if filter_type is None or filter_type == "numeric":
-                    data = self._get_numeric_data()
-                elif filter_type == "bool":
-                    # GH 25101, # GH 24434
-                    data = self._get_bool_data() if axis == 0 else self
-                else:  # pragma: no cover
-                    msg = (
-                        "Generating numeric_only data with filter_type {f}"
-                        "not supported.".format(f=filter_type)
-                    )
-                    raise NotImplementedError(msg)
+                data = _get_data(axis_matters=True)
+
                 values = data.values
                 labels = data._get_agg_axis(axis)
             else:
@@ -7943,18 +8069,16 @@ def f(x):
                     result = coerce_to_dtypes(result, self.dtypes)
 
         if constructor is not None:
-            result = Series(result, index=labels)
+            result = self._constructor_sliced(result, index=labels)
         return result
 
-    def nunique(self, axis=0, dropna=True):
+    def nunique(self, axis=0, dropna=True) -> Series:
         """
         Count distinct observations over requested axis.
 
         Return Series with number of distinct observations. Can ignore NaN
         values.
 
-        .. versionadded:: 0.20.0
-
         Parameters
         ----------
         axis : {0 or 'index', 1 or 'columns'}, default 0
@@ -7988,16 +8112,17 @@ def nunique(self, axis=0, dropna=True):
         """
         return self.apply(Series.nunique, axis=axis, dropna=dropna)
 
-    def idxmin(self, axis=0, skipna=True):
+    def idxmin(self, axis=0, skipna=True) -> Series:
         """
         Return index of first occurrence of minimum over requested axis.
+
         NA/null values are excluded.
 
         Parameters
         ----------
         axis : {0 or 'index', 1 or 'columns'}, default 0
-            0 or 'index' for row-wise, 1 or 'columns' for column-wise
-        skipna : boolean, default True
+            The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+        skipna : bool, default True
             Exclude NA/null values. If an entire row/column is NA, the result
             will be NA.
 
@@ -8025,16 +8150,17 @@ def idxmin(self, axis=0, skipna=True):
         result = [index[i] if i >= 0 else np.nan for i in indices]
         return Series(result, index=self._get_agg_axis(axis))
 
-    def idxmax(self, axis=0, skipna=True):
+    def idxmax(self, axis=0, skipna=True) -> Series:
         """
         Return index of first occurrence of maximum over requested axis.
+
         NA/null values are excluded.
 
         Parameters
         ----------
         axis : {0 or 'index', 1 or 'columns'}, default 0
-            0 or 'index' for row-wise, 1 or 'columns' for column-wise
-        skipna : boolean, default True
+            The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+        skipna : bool, default True
             Exclude NA/null values. If an entire row/column is NA, the result
             will be NA.
 
@@ -8071,9 +8197,9 @@ def _get_agg_axis(self, axis_num):
         elif axis_num == 1:
             return self.index
         else:
-            raise ValueError("Axis must be 0 or 1 (got %r)" % axis_num)
+            raise ValueError(f"Axis must be 0 or 1 (got {repr(axis_num)})")
 
-    def mode(self, axis=0, numeric_only=False, dropna=True):
+    def mode(self, axis=0, numeric_only=False, dropna=True) -> "DataFrame":
         """
         Get the mode(s) of each element along the selected axis.
 
@@ -8086,7 +8212,8 @@ def mode(self, axis=0, numeric_only=False, dropna=True):
             The axis to iterate over while searching for the mode:
 
             * 0 or 'index' : get mode of each column
-            * 1 or 'columns' : get mode of each row
+            * 1 or 'columns' : get mode of each row.
+
         numeric_only : bool, default False
             If True, only apply to numeric columns.
         dropna : bool, default True
@@ -8225,7 +8352,7 @@ def quantile(self, q=0.5, axis=0, numeric_only=True, interpolation="linear"):
         C        1 days 12:00:00
         Name: 0.5, dtype: object
         """
-        self._check_percentile(q)
+        validate_percentile(q)
 
         data = self._get_numeric_data() if numeric_only else self
         axis = self._get_axis_number(axis)
@@ -8239,7 +8366,7 @@ def quantile(self, q=0.5, axis=0, numeric_only=True, interpolation="linear"):
             cols = Index([], name=self.columns.name)
             if is_list_like(q):
                 return self._constructor([], index=q, columns=cols)
-            return self._constructor_sliced([], index=cols, name=q)
+            return self._constructor_sliced([], index=cols, name=q, dtype=np.float64)
 
         result = data._data.quantile(
             qs=q, axis=1, interpolation=interpolation, transposed=is_transposed
@@ -8255,7 +8382,7 @@ def quantile(self, q=0.5, axis=0, numeric_only=True, interpolation="linear"):
 
         return result
 
-    def to_timestamp(self, freq=None, how="start", axis=0, copy=True):
+    def to_timestamp(self, freq=None, how="start", axis=0, copy=True) -> "DataFrame":
         """
         Cast to DatetimeIndex of timestamps, at *beginning* of period.
 
@@ -8281,16 +8408,20 @@ def to_timestamp(self, freq=None, how="start", axis=0, copy=True):
 
         axis = self._get_axis_number(axis)
         if axis == 0:
+            assert isinstance(self.index, (ABCDatetimeIndex, ABCPeriodIndex))
             new_data.set_axis(1, self.index.to_timestamp(freq=freq, how=how))
         elif axis == 1:
+            assert isinstance(self.columns, (ABCDatetimeIndex, ABCPeriodIndex))
             new_data.set_axis(0, self.columns.to_timestamp(freq=freq, how=how))
         else:  # pragma: no cover
-            raise AssertionError("Axis must be 0 or 1. Got {ax!s}".format(ax=axis))
+            raise AssertionError(f"Axis must be 0 or 1. Got {axis}")
 
         return self._constructor(new_data)
 
-    def to_period(self, freq=None, axis=0, copy=True):
+    def to_period(self, freq=None, axis=0, copy=True) -> "DataFrame":
         """
+        Convert DataFrame from DatetimeIndex to PeriodIndex.
+
         Convert DataFrame from DatetimeIndex to PeriodIndex with desired
         frequency (inferred from index if not passed).
 
@@ -8313,15 +8444,17 @@ def to_period(self, freq=None, axis=0, copy=True):
 
         axis = self._get_axis_number(axis)
         if axis == 0:
+            assert isinstance(self.index, ABCDatetimeIndex)
             new_data.set_axis(1, self.index.to_period(freq=freq))
         elif axis == 1:
+            assert isinstance(self.columns, ABCDatetimeIndex)
             new_data.set_axis(0, self.columns.to_period(freq=freq))
         else:  # pragma: no cover
-            raise AssertionError("Axis must be 0 or 1. Got {ax!s}".format(ax=axis))
+            raise AssertionError(f"Axis must be 0 or 1. Got {axis}")
 
         return self._constructor(new_data)
 
-    def isin(self, values):
+    def isin(self, values) -> "DataFrame":
         """
         Whether each element in the DataFrame is contained in values.
 
@@ -8349,7 +8482,6 @@ def isin(self, values):
 
         Examples
         --------
-
         >>> df = pd.DataFrame({'num_legs': [2, 4], 'num_wings': [2, 0]},
         ...                   index=['falcon', 'dog'])
         >>> df
@@ -8388,12 +8520,14 @@ def isin(self, values):
             from pandas.core.reshape.concat import concat
 
             values = collections.defaultdict(list, values)
-            return concat(
-                (
-                    self.iloc[:, [i]].isin(values[col])
-                    for i, col in enumerate(self.columns)
-                ),
-                axis=1,
+            return self._ensure_type(
+                concat(
+                    (
+                        self.iloc[:, [i]].isin(values[col])
+                        for i, col in enumerate(self.columns)
+                    ),
+                    axis=1,
+                )
             )
         elif isinstance(values, Series):
             if not values.index.is_unique:
@@ -8406,10 +8540,9 @@ def isin(self, values):
         else:
             if not is_list_like(values):
                 raise TypeError(
-                    "only list-like or dict-like objects are "
-                    "allowed to be passed to DataFrame.isin(), "
-                    "you passed a "
-                    "{0!r}".format(type(values).__name__)
+                    "only list-like or dict-like objects are allowed "
+                    "to be passed to DataFrame.isin(), "
+                    f"you passed a '{type(values).__name__}'"
                 )
             return DataFrame(
                 algorithms.isin(self.values.ravel(), values).reshape(self.shape),
@@ -8417,6 +8550,15 @@ def isin(self, values):
                 self.columns,
             )
 
+    # ----------------------------------------------------------------------
+    # Add index and columns
+    index: "Index" = properties.AxisProperty(
+        axis=1, doc="The index (row labels) of the DataFrame."
+    )
+    columns: "Index" = properties.AxisProperty(
+        axis=0, doc="The column labels of the DataFrame."
+    )
+
     # ----------------------------------------------------------------------
     # Add plotting methods to DataFrame
     plot = CachedAccessor("plot", pandas.plotting.PlotAccessor)
@@ -8427,10 +8569,6 @@ def isin(self, values):
 
 DataFrame._setup_axes(
     ["index", "columns"],
-    info_axis=1,
-    stat_axis=0,
-    axes_are_reversed=True,
-    aliases={"rows": 0},
     docs={
         "index": "The index (row labels) of the DataFrame.",
         "columns": "The column labels of the DataFrame.",
@@ -8445,13 +8583,13 @@ def isin(self, values):
 
 def _from_nested_dict(data):
     # TODO: this should be seriously cythonized
-    new_data = OrderedDict()
+    new_data = {}
     for index, s in data.items():
         for col, v in s.items():
-            new_data[col] = new_data.get(col, OrderedDict())
+            new_data[col] = new_data.get(col, {})
             new_data[col][index] = v
     return new_data
 
 
 def _put_str(s, space):
-    return "{s}".format(s=s)[:space].ljust(space)
+    return str(s)[:space].ljust(space)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 68308b2f83b60..dfafb1057a543 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8,14 +8,19 @@
 import re
 from textwrap import dedent
 from typing import (
+    TYPE_CHECKING,
+    Any,
     Callable,
     Dict,
     FrozenSet,
     Hashable,
     List,
+    Mapping,
     Optional,
     Sequence,
     Set,
+    Tuple,
+    Type,
     Union,
 )
 import warnings
@@ -25,15 +30,28 @@
 
 from pandas._config import config
 
-from pandas._libs import Timestamp, iNaT, properties
+from pandas._libs import Timestamp, iNaT, lib
+from pandas._typing import (
+    Axis,
+    Dtype,
+    FilePathOrBuffer,
+    FrameOrSeries,
+    JSONSerializable,
+    Label,
+    Level,
+    Renamer,
+)
 from pandas.compat import set_function_name
 from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import Appender, Substitution, rewrite_axis_style_signature
-from pandas.util._validators import validate_bool_kwarg, validate_fillna_kwargs
+from pandas.util._validators import (
+    validate_bool_kwarg,
+    validate_fillna_kwargs,
+    validate_percentile,
+)
 
-from pandas.core.dtypes.cast import maybe_promote, maybe_upcast_putmask
 from pandas.core.dtypes.common import (
     ensure_int64,
     ensure_object,
@@ -61,12 +79,12 @@
 from pandas.core.dtypes.missing import isna, notna
 
 import pandas as pd
-from pandas._typing import Dtype, FilePathOrBuffer
 from pandas.core import missing, nanops
 import pandas.core.algorithms as algos
 from pandas.core.base import PandasObject, SelectionMixin
 import pandas.core.common as com
-from pandas.core.index import (
+from pandas.core.construction import create_series_with_explicit_dtype
+from pandas.core.indexes.api import (
     Index,
     InvalidIndexError,
     MultiIndex,
@@ -77,6 +95,7 @@
 from pandas.core.indexes.period import Period, PeriodIndex
 import pandas.core.indexing as indexing
 from pandas.core.internals import BlockManager
+from pandas.core.missing import find_valid_index
 from pandas.core.ops import _align_method_FRAME
 
 from pandas.io.formats import format as fmt
@@ -84,9 +103,12 @@
 from pandas.io.formats.printing import pprint_thing
 from pandas.tseries.frequencies import to_offset
 
+if TYPE_CHECKING:
+    from pandas.core.resample import Resampler
+
 # goal is to be able to define the docs close to function, while still being
 # able to share
-_shared_docs = dict()  # type: Dict[str, str]
+_shared_docs: Dict[str, str] = dict()
 _shared_doc_kwargs = dict(
     axes="keywords for axes",
     klass="Series/DataFrame",
@@ -97,10 +119,6 @@
             Name or list of names to sort by""",
 )
 
-# sentinel value to use as kwarg in place of None when None has special meaning
-# and needs to be distinguished from a user explicitly passing None.
-sentinel = object()
-
 
 def _single_replace(self, to_replace, method, inplace, limit):
     """
@@ -109,9 +127,8 @@ def _single_replace(self, to_replace, method, inplace, limit):
     """
     if self.ndim != 1:
         raise TypeError(
-            "cannot replace {0} with method {1} on a {2}".format(
-                to_replace, method, type(self).__name__
-            )
+            f"cannot replace {to_replace} with method {method} on a "
+            f"{type(self).__name__}"
         )
 
     orig_dtype = self.dtype
@@ -136,7 +153,7 @@ def _single_replace(self, to_replace, method, inplace, limit):
 bool_t = bool  # Need alias because NDFrame has def bool:
 
 
-class NDFrame(PandasObject, SelectionMixin):
+class NDFrame(PandasObject, SelectionMixin, indexing.IndexingMixin):
     """
     N-dimensional analogue of DataFrame. Store multi-dimensional in a
     size-mutable, labeled data structure
@@ -148,7 +165,7 @@ class NDFrame(PandasObject, SelectionMixin):
     copy : bool, default False
     """
 
-    _internal_names = [
+    _internal_names: List[str] = [
         "_data",
         "_cacher",
         "_item_cache",
@@ -162,15 +179,15 @@ class NDFrame(PandasObject, SelectionMixin):
         "_metadata",
         "__array_struct__",
         "__array_interface__",
-    ]  # type: List[str]
-    _internal_names_set = set(_internal_names)  # type: Set[str]
-    _accessors = set()  # type: Set[str]
-    _deprecations = frozenset(
-        ["as_blocks", "blocks", "is_copy"]
-    )  # type: FrozenSet[str]
-    _metadata = []  # type: List[str]
+    ]
+    _internal_names_set: Set[str] = set(_internal_names)
+    _accessors: Set[str] = set()
+    _deprecations: FrozenSet[str] = frozenset(["get_values"])
+    _metadata: List[str] = []
     _is_copy = None
-    _data = None  # type: BlockManager
+    _data: BlockManager
+    _attrs: Dict[Optional[Hashable], Any]
+    _typ: str
 
     # ----------------------------------------------------------------------
     # Constructors
@@ -181,6 +198,7 @@ def __init__(
         axes: Optional[List[Index]] = None,
         copy: bool = False,
         dtype: Optional[Dtype] = None,
+        attrs: Optional[Mapping[Optional[Hashable], Any]] = None,
         fastpath: bool = False,
     ):
 
@@ -197,6 +215,11 @@ def __init__(
         object.__setattr__(self, "_is_copy", None)
         object.__setattr__(self, "_data", data)
         object.__setattr__(self, "_item_cache", {})
+        if attrs is None:
+            attrs = {}
+        else:
+            attrs = dict(attrs)
+        object.__setattr__(self, "_attrs", attrs)
 
     def _init_mgr(self, mgr, axes=None, dtype=None, copy=False):
         """ passed a manager and a axes dict """
@@ -218,27 +241,21 @@ def _init_mgr(self, mgr, axes=None, dtype=None, copy=False):
     # ----------------------------------------------------------------------
 
     @property
-    def is_copy(self):
+    def attrs(self) -> Dict[Optional[Hashable], Any]:
         """
-        Return the copy.
+        Dictionary of global attributes on this object.
+
+        .. warning::
+
+           attrs is experimental and may change without warning.
         """
-        warnings.warn(
-            "Attribute 'is_copy' is deprecated and will be removed "
-            "in a future version.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._is_copy
-
-    @is_copy.setter
-    def is_copy(self, msg):
-        warnings.warn(
-            "Attribute 'is_copy' is deprecated and will be removed "
-            "in a future version.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        self._is_copy = msg
+        if self._attrs is None:
+            self._attrs = {}
+        return self._attrs
+
+    @attrs.setter
+    def attrs(self, value: Mapping[Optional[Hashable], Any]) -> None:
+        self._attrs = dict(value)
 
     def _validate_dtype(self, dtype):
         """ validate the passed dtype """
@@ -249,8 +266,8 @@ def _validate_dtype(self, dtype):
             # a compound dtype
             if dtype.kind == "V":
                 raise NotImplementedError(
-                    "compound dtypes are not implemented"
-                    " in the {0} constructor".format(self.__class__.__name__)
+                    "compound dtypes are not implemented "
+                    f"in the {type(self).__name__} constructor"
                 )
 
         return dtype
@@ -259,7 +276,7 @@ def _validate_dtype(self, dtype):
     # Construction
 
     @property
-    def _constructor(self):
+    def _constructor(self: FrameOrSeries) -> Type[FrameOrSeries]:
         """Used when a manipulation result has the same dimensions as the
         original.
         """
@@ -281,71 +298,40 @@ def _constructor_expanddim(self):
 
     # ----------------------------------------------------------------------
     # Axis
+    _AXIS_ALIASES = {"rows": 0}
+    _AXIS_IALIASES = {0: "rows"}
+    _stat_axis_number = 0
+    _stat_axis_name = "index"
+    _ix = None
+    _AXIS_ORDERS: List[str]
+    _AXIS_NUMBERS: Dict[str, int]
+    _AXIS_NAMES: Dict[int, str]
+    _AXIS_REVERSED: bool
+    _info_axis_number: int
+    _info_axis_name: str
+    _AXIS_LEN: int
 
     @classmethod
-    def _setup_axes(
-        cls,
-        axes,
-        info_axis=None,
-        stat_axis=None,
-        aliases=None,
-        axes_are_reversed=False,
-        build_axes=True,
-        ns=None,
-        docs=None,
-    ):
+    def _setup_axes(cls, axes: List[str], docs: Dict[str, str]) -> None:
         """
         Provide axes setup for the major PandasObjects.
 
         Parameters
         ----------
         axes : the names of the axes in order (lowest to highest)
-        info_axis_num : the axis of the selector dimension (int)
-        stat_axis_num : the number of axis for the default stats (int)
-        aliases : other names for a single axis (dict)
-        axes_are_reversed : bool
-            Whether to treat passed axes as reversed (DataFrame).
-        build_axes : setup the axis properties (default True)
+        docs : docstrings for the axis properties
         """
+        info_axis = len(axes) - 1
+        axes_are_reversed = len(axes) > 1
 
         cls._AXIS_ORDERS = axes
         cls._AXIS_NUMBERS = {a: i for i, a in enumerate(axes)}
         cls._AXIS_LEN = len(axes)
-        cls._AXIS_ALIASES = aliases or dict()
-        cls._AXIS_IALIASES = {v: k for k, v in cls._AXIS_ALIASES.items()}
         cls._AXIS_NAMES = dict(enumerate(axes))
         cls._AXIS_REVERSED = axes_are_reversed
 
-        # typ
-        setattr(cls, "_typ", cls.__name__.lower())
-
-        # indexing support
-        cls._ix = None
-
-        if info_axis is not None:
-            cls._info_axis_number = info_axis
-            cls._info_axis_name = axes[info_axis]
-
-        if stat_axis is not None:
-            cls._stat_axis_number = stat_axis
-            cls._stat_axis_name = axes[stat_axis]
-
-        # setup the actual axis
-        if build_axes:
-
-            def set_axis(a, i):
-                setattr(cls, a, properties.AxisProperty(i, docs.get(a, a)))
-                cls._internal_names_set.add(a)
-
-            if axes_are_reversed:
-                m = cls._AXIS_LEN - 1
-                for i, a in cls._AXIS_NAMES.items():
-                    set_axis(a, m - i)
-            else:
-                for i, a in cls._AXIS_NAMES.items():
-                    set_axis(a, i)
-
-        assert not isinstance(ns, dict)
+        cls._info_axis_number = info_axis
+        cls._info_axis_name = axes[info_axis]
 
     def _construct_axes_dict(self, axes=None, **kwargs):
         """Return an axes dictionary for myself."""
@@ -353,15 +339,8 @@ def _construct_axes_dict(self, axes=None, **kwargs):
         d.update(kwargs)
         return d
 
-    @staticmethod
-    def _construct_axes_dict_from(self, axes, **kwargs):
-        """Return an axes dictionary for the passed axes."""
-        d = {a: ax for a, ax in zip(self._AXIS_ORDERS, axes)}
-        d.update(kwargs)
-        return d
-
     def _construct_axes_from_arguments(
-        self, args, kwargs, require_all=False, sentinel=None
+        self, args, kwargs, require_all: bool = False, sentinel=None
     ):
         """Construct and returns axes if supplied in args/kwargs.
 
@@ -377,20 +356,6 @@ def _construct_axes_from_arguments(
         args = list(args)
         for a in self._AXIS_ORDERS:
 
-            # if we have an alias for this axis
-            alias = self._AXIS_IALIASES.get(a)
-            if alias is not None:
-                if a in kwargs:
-                    if alias in kwargs:
-                        raise TypeError(
-                            "arguments are mutually exclusive "
-                            "for [%s,%s]" % (a, alias)
-                        )
-                    continue
-                if alias in kwargs:
-                    kwargs[a] = kwargs.pop(alias)
-                    continue
-
             # look for a argument by position
             if a not in kwargs:
                 try:
@@ -402,18 +367,6 @@ def _construct_axes_from_arguments(
         axes = {a: kwargs.pop(a, sentinel) for a in self._AXIS_ORDERS}
         return axes, kwargs
 
-    @classmethod
-    def _from_axes(cls, data, axes, **kwargs):
-        # for construction from BlockManager
-        if isinstance(data, BlockManager):
-            return cls(data, **kwargs)
-        else:
-            if cls._AXIS_REVERSED:
-                axes = axes[::-1]
-            d = cls._construct_axes_dict_from(cls, axes, copy=False)
-            d.update(kwargs)
-            return cls(data, **d)
-
     @classmethod
     def _get_axis_number(cls, axis):
         axis = cls._AXIS_ALIASES.get(axis, axis)
@@ -425,7 +378,7 @@ def _get_axis_number(cls, axis):
                 return cls._AXIS_NUMBERS[axis]
             except KeyError:
                 pass
-        raise ValueError("No axis named {0} for object type {1}".format(axis, cls))
+        raise ValueError(f"No axis named {axis} for object type {cls}")
 
     @classmethod
     def _get_axis_name(cls, axis):
@@ -438,7 +391,7 @@ def _get_axis_name(cls, axis):
                 return cls._AXIS_NAMES[axis]
             except KeyError:
                 pass
-        raise ValueError("No axis named {0} for object type {1}".format(axis, cls))
+        raise ValueError(f"No axis named {axis} for object type {cls}")
 
     def _get_axis(self, axis):
         name = self._get_axis_name(axis)
@@ -453,7 +406,7 @@ def _get_block_manager_axis(cls, axis):
             return m - axis
         return axis
 
-    def _get_axis_resolvers(self, axis):
+    def _get_axis_resolvers(self, axis: str) -> Dict[str, ABCSeries]:
         # index or columns
         axis_index = getattr(self, axis)
         d = dict()
@@ -466,7 +419,7 @@ def _get_axis_resolvers(self, axis):
                 # prefix with 'i' or 'c' depending on the input axis
                 # e.g., you must do ilevel_0 for the 0th level of an unnamed
                 # multiiindex
-                key = "{prefix}level_{i}".format(prefix=prefix, i=i)
+                key = f"{prefix}level_{i}"
                 level = i
 
             level_values = axis_index.get_level_values(level)
@@ -483,22 +436,31 @@ def _get_axis_resolvers(self, axis):
         d[axis] = dindex
         return d
 
-    def _get_index_resolvers(self):
-        d = {}
+    def _get_index_resolvers(self) -> Dict[str, ABCSeries]:
+        from pandas.core.computation.parsing import clean_column_name
+
+        d: Dict[str, ABCSeries] = {}
         for axis_name in self._AXIS_ORDERS:
             d.update(self._get_axis_resolvers(axis_name))
-        return d
 
-    def _get_space_character_free_column_resolvers(self):
-        """Return the space character free column resolvers of a dataframe.
+        return {clean_column_name(k): v for k, v in d.items() if not isinstance(k, int)}
+
+    def _get_cleaned_column_resolvers(self) -> Dict[str, ABCSeries]:
+        """
+        Return the special character free column resolvers of a dataframe.
 
-        Column names with spaces are 'cleaned up' so that they can be referred
-        to by backtick quoting.
+        Column names with special characters are 'cleaned up' so that they can
+        be referred to by backtick quoting.
         Used in :meth:`DataFrame.eval`.
         """
-        from pandas.core.computation.common import _remove_spaces_column_name
+        from pandas.core.computation.parsing import clean_column_name
+
+        if isinstance(self, ABCSeries):
+            return {clean_column_name(self.name): self}
 
-        return {_remove_spaces_column_name(k): v for k, v in self.items()}
+        return {
+            clean_column_name(k): v for k, v in self.items() if not isinstance(k, int)
+        }
 
     @property
     def _info_axis(self):
@@ -509,14 +471,14 @@ def _stat_axis(self):
         return getattr(self, self._stat_axis_name)
 
     @property
-    def shape(self):
+    def shape(self) -> Tuple[int, ...]:
         """
         Return a tuple of axis dimensions
         """
         return tuple(len(self._get_axis(a)) for a in self._AXIS_ORDERS)
 
     @property
-    def axes(self):
+    def axes(self) -> List[Index]:
         """
         Return index label(s) of the internal NDFrame
         """
@@ -525,7 +487,7 @@ def axes(self):
         return [self._get_axis(a) for a in self._AXIS_ORDERS]
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         """
         Return an int representing the number of axes / array dimensions.
 
@@ -572,12 +534,12 @@ def size(self):
         return np.prod(self.shape)
 
     @property
-    def _selected_obj(self):
+    def _selected_obj(self: FrameOrSeries) -> FrameOrSeries:
         """ internal compat with SelectionMixin """
         return self
 
     @property
-    def _obj_with_exclusions(self):
+    def _obj_with_exclusions(self: FrameOrSeries) -> FrameOrSeries:
         """ internal compat with SelectionMixin """
         return self
 
@@ -585,7 +547,7 @@ def set_axis(self, labels, axis=0, inplace=False):
         """
         Assign desired index to given axis.
 
-        Indexes for column or row labels can be changed by assigning
+        Indexes for%(extended_summary_sub)s row labels can be changed by assigning
         a list-like or Index.
 
         .. versionchanged:: 0.21.0
@@ -600,9 +562,8 @@ def set_axis(self, labels, axis=0, inplace=False):
         labels : list-like, Index
             The values for the new index.
 
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis to update. The value 0 identifies the rows, and 1
-            identifies the columns.
+        axis : %(axes_single_arg)s, default 0
+            The axis to update. The value 0 identifies the rows%(axis_description_sub)s.
 
         inplace : bool, default False
             Whether to return a new %(klass)s instance.
@@ -610,69 +571,15 @@ def set_axis(self, labels, axis=0, inplace=False):
         Returns
         -------
         renamed : %(klass)s or None
-            An object of same type as caller if inplace=False, None otherwise.
+            An object of type %(klass)s if inplace=False, None otherwise.
 
         See Also
         --------
-        DataFrame.rename_axis : Alter the name of the index or columns.
+        %(klass)s.rename_axis : Alter the name of the index%(see_also_sub)s.
 
         Examples
         --------
-        **Series**
-
-        >>> s = pd.Series([1, 2, 3])
-        >>> s
-        0    1
-        1    2
-        2    3
-        dtype: int64
-
-        >>> s.set_axis(['a', 'b', 'c'], axis=0)
-        a    1
-        b    2
-        c    3
-        dtype: int64
-
-        **DataFrame**
-
-        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-
-        Change the row labels.
-
-        >>> df.set_axis(['a', 'b', 'c'], axis='index')
-           A  B
-        a  1  4
-        b  2  5
-        c  3  6
-
-        Change the column labels.
-
-        >>> df.set_axis(['I', 'II'], axis='columns')
-           I  II
-        0  1   4
-        1  2   5
-        2  3   6
-
-        Now, update the labels inplace.
-
-        >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
-        >>> df
-           i  ii
-        0  1   4
-        1  2   5
-        2  3   6
         """
-        if is_scalar(labels):
-            warnings.warn(
-                'set_axis now takes "labels" as first argument, and '
-                '"axis" as named parameter. The old form, with "axis" as '
-                'first parameter and "labels" as second, is still supported '
-                "but will be deprecated in a future version of pandas.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            labels, axis = axis, labels
-
         if inplace:
             setattr(self, self._get_axis_name(axis), labels)
         else:
@@ -680,55 +587,11 @@ def set_axis(self, labels, axis=0, inplace=False):
             obj.set_axis(labels, axis=axis, inplace=True)
             return obj
 
-    def _set_axis(self, axis, labels):
+    def _set_axis(self, axis, labels) -> None:
         self._data.set_axis(axis, labels)
         self._clear_item_cache()
 
-    def transpose(self, *args, **kwargs):
-        """
-        Permute the dimensions of the %(klass)s
-
-        Parameters
-        ----------
-        args : %(args_transpose)s
-        copy : bool, default False
-            Make a copy of the underlying data. Mixed-dtype data will
-            always result in a copy
-        **kwargs
-            Additional keyword arguments will be passed to the function.
-
-        Returns
-        -------
-        y : same as input
-
-        Examples
-        --------
-        >>> p.transpose(2, 0, 1)
-        >>> p.transpose(2, 0, 1, copy=True)
-        """
-
-        # construct the args
-        axes, kwargs = self._construct_axes_from_arguments(
-            args, kwargs, require_all=True
-        )
-        axes_names = tuple(self._get_axis_name(axes[a]) for a in self._AXIS_ORDERS)
-        axes_numbers = tuple(self._get_axis_number(axes[a]) for a in self._AXIS_ORDERS)
-
-        # we must have unique axes
-        if len(axes) != len(set(axes)):
-            raise ValueError("Must specify %s unique axes" % self._AXIS_LEN)
-
-        new_axes = self._construct_axes_dict_from(
-            self, [self._get_axis(x) for x in axes_names]
-        )
-        new_values = self.values.transpose(axes_numbers)
-        if kwargs.pop("copy", None) or (len(args) and args[-1]):
-            new_values = new_values.copy()
-
-        nv.validate_transpose(tuple(), kwargs)
-        return self._constructor(new_values, **new_axes).__finalize__(self)
-
-    def swapaxes(self, axis1, axis2, copy=True):
+    def swapaxes(self: FrameOrSeries, axis1, axis2, copy=True) -> FrameOrSeries:
         """
         Interchange axes and swap values axes appropriately.
 
@@ -753,7 +616,7 @@ def swapaxes(self, axis1, axis2, copy=True):
 
         return self._constructor(new_values, *new_axes).__finalize__(self)
 
-    def droplevel(self, level, axis=0):
+    def droplevel(self: FrameOrSeries, level, axis=0) -> FrameOrSeries:
         """
         Return DataFrame with requested index / column level(s) removed.
 
@@ -770,7 +633,8 @@ def droplevel(self, level, axis=0):
 
         Returns
         -------
-        DataFrame.droplevel()
+        DataFrame
+            DataFrame with requested index / column level(s) removed.
 
         Examples
         --------
@@ -812,7 +676,7 @@ def droplevel(self, level, axis=0):
         result = self.set_axis(new_labels, axis=axis, inplace=False)
         return result
 
-    def pop(self, item):
+    def pop(self: FrameOrSeries, item) -> FrameOrSeries:
         """
         Return item and drop from frame. Raise KeyError if not found.
 
@@ -830,7 +694,7 @@ def pop(self, item):
         >>> df = pd.DataFrame([('falcon', 'bird', 389.0),
         ...                    ('parrot', 'bird', 24.0),
         ...                    ('lion', 'mammal', 80.5),
-        ...                    ('monkey','mammal', np.nan)],
+        ...                    ('monkey', 'mammal', np.nan)],
         ...                   columns=('name', 'class', 'max_speed'))
         >>> df
              name   class  max_speed
@@ -881,8 +745,6 @@ def squeeze(self, axis=None):
             A specific axis to squeeze. By default, all length-1 axes are
             squeezed.
 
-            .. versionadded:: 0.20.0
-
         Returns
         -------
         DataFrame, Series, or scalar
@@ -968,39 +830,28 @@ def squeeze(self, axis=None):
         1
         """
         axis = self._AXIS_NAMES if axis is None else (self._get_axis_number(axis),)
-        try:
-            return self.iloc[
-                tuple(
-                    0 if i in axis and len(a) == 1 else slice(None)
-                    for i, a in enumerate(self.axes)
-                )
-            ]
-        except Exception:
-            return self
-
-    def swaplevel(self, i=-2, j=-1, axis=0):
-        """
-        Swap levels i and j in a MultiIndex on a particular axis
-
-        Parameters
-        ----------
-        i, j : int, str (can be mixed)
-            Level of index to be swapped. Can pass level name as string.
-
-        Returns
-        -------
-        swapped : same type as caller (new object)
-        """
-        axis = self._get_axis_number(axis)
-        result = self.copy()
-        labels = result._data.axes[axis]
-        result._data.set_axis(axis, labels.swaplevel(i, j))
-        return result
+        return self.iloc[
+            tuple(
+                0 if i in axis and len(a) == 1 else slice(None)
+                for i, a in enumerate(self.axes)
+            )
+        ]
 
     # ----------------------------------------------------------------------
     # Rename
 
-    def rename(self, *args, **kwargs):
+    def rename(
+        self: FrameOrSeries,
+        mapper: Optional[Renamer] = None,
+        *,
+        index: Optional[Renamer] = None,
+        columns: Optional[Renamer] = None,
+        axis: Optional[Axis] = None,
+        copy: bool = True,
+        inplace: bool = False,
+        level: Optional[Level] = None,
+        errors: str = "ignore",
+    ) -> Optional[FrameOrSeries]:
         """
         Alter axes input function or functions. Function / dict values must be
         unique (1-to-1). Labels not contained in a dict / Series will be left
@@ -1113,46 +964,48 @@ def rename(self, *args, **kwargs):
 
         See the :ref:`user guide <basics.rename>` for more.
         """
-        axes, kwargs = self._construct_axes_from_arguments(args, kwargs)
-        copy = kwargs.pop("copy", True)
-        inplace = kwargs.pop("inplace", False)
-        level = kwargs.pop("level", None)
-        axis = kwargs.pop("axis", None)
-        errors = kwargs.pop("errors", "ignore")
-        if axis is not None:
-            # Validate the axis
-            self._get_axis_number(axis)
-
-        if kwargs:
-            raise TypeError(
-                "rename() got an unexpected keyword "
-                'argument "{0}"'.format(list(kwargs.keys())[0])
-            )
-
-        if com.count_not_none(*axes.values()) == 0:
+        if mapper is None and index is None and columns is None:
             raise TypeError("must pass an index to rename")
 
-        self._consolidate_inplace()
+        if index is not None or columns is not None:
+            if axis is not None:
+                raise TypeError(
+                    "Cannot specify both 'axis' and any of 'index' or 'columns'"
+                )
+            elif mapper is not None:
+                raise TypeError(
+                    "Cannot specify both 'mapper' and any of 'index' or 'columns'"
+                )
+        else:
+            # use the mapper argument
+            if axis and self._get_axis_number(axis) == 1:
+                columns = mapper
+            else:
+                index = mapper
+
         result = self if inplace else self.copy(deep=copy)
 
-        # start in the axis order to eliminate too many copies
-        for axis in range(self._AXIS_LEN):
-            v = axes.get(self._AXIS_NAMES[axis])
-            if v is None:
+        for axis_no, replacements in enumerate((index, columns)):
+            if replacements is None:
                 continue
-            f = com.get_rename_function(v)
-            baxis = self._get_block_manager_axis(axis)
+
+            ax = self._get_axis(axis_no)
+            baxis = self._get_block_manager_axis(axis_no)
+            f = com.get_rename_function(replacements)
+
             if level is not None:
-                level = self.axes[axis]._get_level_number(level)
+                level = ax._get_level_number(level)
 
             # GH 13473
-            if not callable(v):
-                indexer = self.axes[axis].get_indexer_for(v)
+            if not callable(replacements):
+                indexer = ax.get_indexer_for(replacements)
                 if errors == "raise" and len(indexer[indexer == -1]):
                     missing_labels = [
-                        label for index, label in enumerate(v) if indexer[index] == -1
+                        label
+                        for index, label in enumerate(replacements)
+                        if indexer[index] == -1
                     ]
-                    raise KeyError("{} not found in axis".format(missing_labels))
+                    raise KeyError(f"{missing_labels} not found in axis")
 
             result._data = result._data.rename_axis(
                 f, axis=baxis, copy=copy, level=level
@@ -1161,11 +1014,12 @@ def rename(self, *args, **kwargs):
 
         if inplace:
             self._update_inplace(result._data)
+            return None
         else:
             return result.__finalize__(self)
 
     @rewrite_axis_style_signature("mapper", [("copy", True), ("inplace", False)])
-    def rename_axis(self, mapper=sentinel, **kwargs):
+    def rename_axis(self, mapper=lib.no_default, **kwargs):
         """
         Set the name of the axis for the index or columns.
 
@@ -1290,7 +1144,7 @@ class  name
                monkey         2         2
         """
         axes, kwargs = self._construct_axes_from_arguments(
-            (), kwargs, sentinel=sentinel
+            (), kwargs, sentinel=lib.no_default
         )
         copy = kwargs.pop("copy", True)
         inplace = kwargs.pop("inplace", False)
@@ -1301,12 +1155,12 @@ class  name
         if kwargs:
             raise TypeError(
                 "rename_axis() got an unexpected keyword "
-                'argument "{0}"'.format(list(kwargs.keys())[0])
+                f'argument "{list(kwargs.keys())[0]}"'
             )
 
         inplace = validate_bool_kwarg(inplace, "inplace")
 
-        if mapper is not sentinel:
+        if mapper is not lib.no_default:
             # Use v0.23 behavior if a scalar or list
             non_mapper = is_scalar(mapper) or (
                 is_list_like(mapper) and not is_dict_like(mapper)
@@ -1322,7 +1176,7 @@ class  name
 
             for axis in range(self._AXIS_LEN):
                 v = axes.get(self._AXIS_NAMES[axis])
-                if v is sentinel:
+                if v is lib.no_default:
                     continue
                 non_mapper = is_scalar(v) or (is_list_like(v) and not is_dict_like(v))
                 if non_mapper:
@@ -1399,7 +1253,7 @@ def _set_axis_name(self, name, axis=0, inplace=False):
     # ----------------------------------------------------------------------
     # Comparison Methods
 
-    def _indexed_same(self, other):
+    def _indexed_same(self, other) -> bool:
         return all(
             self._get_axis(a).equals(other._get_axis(a)) for a in self._AXIS_ORDERS
         )
@@ -1433,10 +1287,11 @@ def equals(self, other):
         DataFrame.eq : Compare two DataFrame objects of the same shape and
             return a DataFrame where each element is True if the respective
             element in each DataFrame is equal, False otherwise.
-        assert_series_equal : Return True if left and right Series are equal,
-            False otherwise.
-        assert_frame_equal : Return True if left and right DataFrames are
-            equal, False otherwise.
+        testing.assert_series_equal : Raises an AssertionError if left and
+            right are not equal. Provides an easy interface to ignore
+            inequality in dtypes, indexes and precision among others.
+        testing.assert_frame_equal : Like assert_series_equal, but targets
+            DataFrames.
         numpy.array_equal : Return True if two arrays have the same shape
             and elements, False otherwise.
 
@@ -1504,9 +1359,7 @@ def __neg__(self):
         ):
             arr = operator.neg(values)
         else:
-            raise TypeError(
-                "Unary negative expects numeric dtype, not {}".format(values.dtype)
-            )
+            raise TypeError(f"Unary negative expects numeric dtype, not {values.dtype}")
         return self.__array_wrap__(arr)
 
     def __pos__(self):
@@ -1520,9 +1373,7 @@ def __pos__(self):
         ):
             arr = operator.pos(values)
         else:
-            raise TypeError(
-                "Unary plus expects numeric dtype, not {}".format(values.dtype)
-            )
+            raise TypeError(f"Unary plus expects numeric dtype, not {values.dtype}")
         return self.__array_wrap__(arr)
 
     def __invert__(self):
@@ -1530,15 +1381,14 @@ def __invert__(self):
             # inv fails with 0 len
             return self
 
-        arr = operator.inv(com.values_from_object(self))
-        return self.__array_wrap__(arr)
+        new_data = self._data.apply(operator.invert)
+        result = self._constructor(new_data).__finalize__(self)
+        return result
 
     def __nonzero__(self):
         raise ValueError(
-            "The truth value of a {0} is ambiguous. "
-            "Use a.empty, a.bool(), a.item(), a.any() or a.all().".format(
-                self.__class__.__name__
-            )
+            f"The truth value of a {type(self).__name__} is ambiguous. "
+            "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
         )
 
     __bool__ = __nonzero__
@@ -1562,15 +1412,15 @@ def bool(self):
         elif is_scalar(v):
             raise ValueError(
                 "bool cannot act on a non-boolean single element "
-                "{0}".format(self.__class__.__name__)
+                f"{type(self).__name__}"
             )
 
         self.__nonzero__()
 
-    def __abs__(self):
+    def __abs__(self: FrameOrSeries) -> FrameOrSeries:
         return self.abs()
 
-    def __round__(self, decimals=0):
+    def __round__(self: FrameOrSeries, decimals: int = 0) -> FrameOrSeries:
         return self.round(decimals)
 
     # -------------------------------------------------------------------------
@@ -1611,7 +1461,7 @@ def _is_level_reference(self, key, axis=0):
             and not self._is_label_reference(key, axis=axis)
         )
 
-    def _is_label_reference(self, key, axis=0):
+    def _is_label_reference(self, key, axis=0) -> bool_t:
         """
         Test whether a key is a label reference for a given axis.
 
@@ -1640,7 +1490,7 @@ def _is_label_reference(self, key, axis=0):
             and any(key in self.axes[ax] for ax in other_axes)
         )
 
-    def _is_label_or_level_reference(self, key, axis=0):
+    def _is_label_or_level_reference(self, key: str, axis: int = 0) -> bool_t:
         """
         Test whether a key is a label or level reference for a given axis.
 
@@ -1664,7 +1514,7 @@ def _is_label_or_level_reference(self, key, axis=0):
             key, axis=axis
         )
 
-    def _check_label_or_level_ambiguity(self, key, axis=0):
+    def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:
         """
         Check whether `key` is ambiguous.
 
@@ -1674,9 +1524,9 @@ def _check_label_or_level_ambiguity(self, key, axis=0):
         Parameters
         ----------
         key: str or object
-            label or level name
+            Label or level name.
         axis: int, default 0
-            Axis that levels are associated with (0 for index, 1 for columns)
+            Axis that levels are associated with (0 for index, 1 for columns).
 
         Raises
         ------
@@ -1702,18 +1552,12 @@ def _check_label_or_level_ambiguity(self, key, axis=0):
             )
 
             msg = (
-                "'{key}' is both {level_article} {level_type} level and "
-                "{label_article} {label_type} label, which is ambiguous."
-            ).format(
-                key=key,
-                level_article=level_article,
-                level_type=level_type,
-                label_article=label_article,
-                label_type=label_type,
+                f"'{key}' is both {level_article} {level_type} level and "
+                f"{label_article} {label_type} label, which is ambiguous."
             )
             raise ValueError(msg)
 
-    def _get_label_or_level_values(self, key, axis=0):
+    def _get_label_or_level_values(self, key: str, axis: int = 0) -> np.ndarray:
         """
         Return a 1-D array of values associated with `key`, a label or level
         from the given `axis`.
@@ -1765,8 +1609,7 @@ def _get_label_or_level_values(self, key, axis=0):
                 multi_message = (
                     "\n"
                     "For a multi-index, the label must be a "
-                    "tuple with elements corresponding to "
-                    "each level."
+                    "tuple with elements corresponding to each level."
                 )
             else:
                 multi_message = ""
@@ -1774,18 +1617,14 @@ def _get_label_or_level_values(self, key, axis=0):
             label_axis_name = "column" if axis == 0 else "index"
             raise ValueError(
                 (
-                    "The {label_axis_name} label '{key}' "
-                    "is not unique.{multi_message}"
-                ).format(
-                    key=key,
-                    label_axis_name=label_axis_name,
-                    multi_message=multi_message,
+                    f"The {label_axis_name} label '{key}' "
+                    f"is not unique.{multi_message}"
                 )
             )
 
         return values
 
-    def _drop_labels_or_levels(self, keys, axis=0):
+    def _drop_labels_or_levels(self, keys, axis: int = 0):
         """
         Drop labels and/or levels for the given `axis`.
 
@@ -1823,8 +1662,8 @@ def _drop_labels_or_levels(self, keys, axis=0):
             raise ValueError(
                 (
                     "The following keys are not valid labels or "
-                    "levels for axis {axis}: {invalid_keys}"
-                ).format(axis=axis, invalid_keys=invalid_keys)
+                    f"levels for axis {axis}: {invalid_keys}"
+                )
             )
 
         # Compute levels and labels to drop
@@ -1867,8 +1706,8 @@ def _drop_labels_or_levels(self, keys, axis=0):
 
     def __hash__(self):
         raise TypeError(
-            "{0!r} objects are mutable, thus they cannot be"
-            " hashed".format(self.__class__.__name__)
+            f"{repr(type(self).__name__)} objects are mutable, "
+            f"thus they cannot be hashed"
         )
 
     def __iter__(self):
@@ -1912,16 +1751,16 @@ def items(self):
     def iteritems(self):
         return self.items()
 
-    def __len__(self):
+    def __len__(self) -> int:
         """Returns length of info axis"""
         return len(self._info_axis)
 
-    def __contains__(self, key):
+    def __contains__(self, key) -> bool_t:
         """True if the key is in the info axis"""
         return key in self._info_axis
 
     @property
-    def empty(self):
+    def empty(self) -> bool_t:
         """
         Indicator whether DataFrame is empty.
 
@@ -1976,10 +1815,15 @@ def empty(self):
     # GH#23114 Ensure ndarray.__op__(DataFrame) returns NotImplemented
     __array_priority__ = 1000
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         return com.values_from_object(self)
 
     def __array_wrap__(self, result, context=None):
+        result = lib.item_from_zerodim(result)
+        if is_scalar(result):
+            # e.g. we get here with np.ptp(series)
+            # ptp also requires the item_from_zerodim
+            return result
         d = self._construct_axes_dict(self._AXIS_ORDERS, copy=False)
         return self._constructor(result, **d).__finalize__(self)
 
@@ -1991,32 +1835,18 @@ def __array_wrap__(self, result, context=None):
     #    values = self.values
     #    return dict(typestr=values.dtype.str,shape=values.shape,data=values)
 
-    def to_dense(self):
-        """
-        Return dense representation of Series/DataFrame (as opposed to sparse).
-
-        .. deprecated:: 0.25.0
-
-        Returns
-        -------
-        %(klass)s
-            Dense %(klass)s.
-        """
-        warnings.warn(
-            "DataFrame/Series.to_dense is deprecated "
-            "and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        # compat
-        return self
-
     # ----------------------------------------------------------------------
     # Picklability
 
-    def __getstate__(self):
+    def __getstate__(self) -> Dict[str, Any]:
         meta = {k: getattr(self, k, None) for k in self._metadata}
-        return dict(_data=self._data, _typ=self._typ, _metadata=self._metadata, **meta)
+        return dict(
+            _data=self._data,
+            _typ=self._typ,
+            _metadata=self._metadata,
+            attrs=self.attrs,
+            **meta,
+        )
 
     def __setstate__(self, state):
 
@@ -2025,6 +1855,8 @@ def __setstate__(self, state):
         elif isinstance(state, dict):
             typ = state.get("_typ")
             if typ is not None:
+                attrs = state.get("_attrs", {})
+                object.__setattr__(self, "_attrs", attrs)
 
                 # set in the order of internal names
                 # to avoid definitional recursion
@@ -2041,30 +1873,20 @@ def __setstate__(self, state):
                         object.__setattr__(self, k, v)
 
             else:
-                self._unpickle_series_compat(state)
-        elif isinstance(state[0], dict):
-            if len(state) == 5:
-                self._unpickle_sparse_frame_compat(state)
-            else:
-                self._unpickle_frame_compat(state)
-        elif len(state) == 4:
-            self._unpickle_panel_compat(state)
+                raise NotImplementedError("Pre-0.12 pickles are no longer supported")
         elif len(state) == 2:
-            self._unpickle_series_compat(state)
-        else:  # pragma: no cover
-            # old pickling format, for compatibility
-            self._unpickle_matrix_compat(state)
+            raise NotImplementedError("Pre-0.12 pickles are no longer supported")
 
         self._item_cache = {}
 
     # ----------------------------------------------------------------------
     # Rendering Methods
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # string representation based upon iterating over self
         # (since, by definition, `PandasContainers` are iterable)
-        prepr = "[%s]" % ",".join(map(pprint_thing, self))
-        return "%s(%s)" % (self.__class__.__name__, prepr)
+        prepr = f"[{','.join(map(pprint_thing, self))}]"
+        return f"{type(self).__name__}({prepr})"
 
     def _repr_latex_(self):
         """
@@ -2091,6 +1913,28 @@ def _repr_data_resource_(self):
     # ----------------------------------------------------------------------
     # I/O Methods
 
+    _shared_docs[
+        "to_markdown"
+    ] = """
+    Print %(klass)s in Markdown-friendly format.
+
+    .. versionadded:: 1.0.0
+
+    Parameters
+    ----------
+    buf : str, Path or StringIO-like, optional, default None
+        Buffer to write to. If None, the output is returned as a string.
+    mode : str, optional
+        Mode in which file is opened.
+    **kwargs
+        These parameters will be passed to `tabulate`.
+
+    Returns
+    -------
+    str
+        %(klass)s in Markdown-friendly format.
+    """
+
     _shared_docs[
         "to_excel"
     ] = """
@@ -2150,8 +1994,6 @@ def _repr_data_resource_(self):
         Specifies the one-based bottommost row and rightmost column that
         is to be frozen.
 
-        .. versionadded:: 0.20.0.
-
     See Also
     --------
     to_csv : Write DataFrame to a comma-separated values (csv) file.
@@ -2222,7 +2064,7 @@ def to_excel(
         inf_rep="inf",
         verbose=True,
         freeze_panes=None,
-    ):
+    ) -> None:
         df = self if isinstance(self, ABCDataFrame) else self.to_frame()
 
         from pandas.io.formats.excel import ExcelFormatter
@@ -2249,17 +2091,18 @@ def to_excel(
 
     def to_json(
         self,
-        path_or_buf=None,
-        orient=None,
-        date_format=None,
-        double_precision=10,
-        force_ascii=True,
-        date_unit="ms",
-        default_handler=None,
-        lines=False,
-        compression="infer",
-        index=True,
-    ):
+        path_or_buf: Optional[FilePathOrBuffer] = None,
+        orient: Optional[str] = None,
+        date_format: Optional[str] = None,
+        double_precision: int = 10,
+        force_ascii: bool_t = True,
+        date_unit: str = "ms",
+        default_handler: Optional[Callable[[Any], JSONSerializable]] = None,
+        lines: bool_t = False,
+        compression: Optional[str] = "infer",
+        index: bool_t = True,
+        indent: Optional[int] = None,
+    ) -> Optional[str]:
         """
         Convert the object to a JSON string.
 
@@ -2274,31 +2117,30 @@ def to_json(
         orient : str
             Indication of expected JSON string format.
 
-            * Series
+            * Series:
+
+                - default is 'index'
+                - allowed values are: {'split','records','index','table'}.
 
-              - default is 'index'
-              - allowed values are: {'split','records','index','table'}
+            * DataFrame:
 
-            * DataFrame
+                - default is 'columns'
+                - allowed values are: {'split', 'records', 'index', 'columns',
+                  'values', 'table'}.
 
-              - default is 'columns'
-              - allowed values are:
-                {'split','records','index','columns','values','table'}
+            * The format of the JSON string:
 
-            * The format of the JSON string
+                - 'split' : dict like {'index' -> [index], 'columns' -> [columns],
+                  'data' -> [values]}
+                - 'records' : list like [{column -> value}, ... , {column -> value}]
+                - 'index' : dict like {index -> {column -> value}}
+                - 'columns' : dict like {column -> {index -> value}}
+                - 'values' : just the values array
+                - 'table' : dict like {'schema': {schema}, 'data': {data}}
 
-              - 'split' : dict like {'index' -> [index],
-                'columns' -> [columns], 'data' -> [values]}
-              - 'records' : list like
-                [{column -> value}, ... , {column -> value}]
-              - 'index' : dict like {index -> {column -> value}}
-              - 'columns' : dict like {column -> {index -> value}}
-              - 'values' : just the values array
-              - 'table' : dict like {'schema': {schema}, 'data': {data}}
-                describing the data, and the data component is
-                like ``orient='records'``.
+                Describing the data, where data component is like ``orient='records'``.
 
-                .. versionchanged:: 0.20.0
+            .. versionchanged:: 0.20.0
 
         date_format : {None, 'epoch', 'iso'}
             Type of date conversion. 'epoch' = epoch milliseconds,
@@ -2310,7 +2152,7 @@ def to_json(
             floating point values.
         force_ascii : bool, default True
             Force encoded string to be ASCII.
-        date_unit : string, default 'ms' (milliseconds)
+        date_unit : str, default 'ms' (milliseconds)
             The time unit to encode to, governs timestamp and ISO8601
             precision.  One of 's', 'ms', 'us', 'ns' for second, millisecond,
             microsecond, and nanosecond respectively.
@@ -2339,6 +2181,11 @@ def to_json(
 
             .. versionadded:: 0.23.0
 
+        indent : int, optional
+           Length of whitespace used to indent each record.
+
+           .. versionadded:: 1.0.0
+
         Returns
         -------
         None or str
@@ -2349,6 +2196,13 @@ def to_json(
         --------
         read_json
 
+        Notes
+        -----
+        The behavior of ``indent=0`` varies from the stdlib, which does not
+        indent the output but does insert newlines. Currently, ``indent=0``
+        and the default ``indent=None`` are equivalent in pandas, though this
+        may change in a future release.
+
         Examples
         --------
 
@@ -2399,6 +2253,10 @@ def to_json(
             date_format = "iso"
         elif date_format is None:
             date_format = "epoch"
+
+        config.is_nonnegative_int(indent)
+        indent = indent or 0
+
         return json.to_json(
             path_or_buf=path_or_buf,
             obj=self,
@@ -2411,9 +2269,26 @@ def to_json(
             lines=lines,
             compression=compression,
             index=index,
+            indent=indent,
         )
 
-    def to_hdf(self, path_or_buf, key, **kwargs):
+    def to_hdf(
+        self,
+        path_or_buf,
+        key: str,
+        mode: str = "a",
+        complevel: Optional[int] = None,
+        complib: Optional[str] = None,
+        append: bool_t = False,
+        format: Optional[str] = None,
+        index: bool_t = True,
+        min_itemsize: Optional[Union[int, Dict[str, int]]] = None,
+        nan_rep=None,
+        dropna: Optional[bool_t] = None,
+        data_columns: Optional[List[str]] = None,
+        errors: str = "strict",
+        encoding: str = "UTF-8",
+    ) -> None:
         """
         Write the contained data to an HDF5 file using HDFStore.
 
@@ -2441,21 +2316,6 @@ def to_hdf(self, path_or_buf, key, **kwargs):
             - 'a': append, an existing file is opened for reading and
               writing, and if the file does not exist it is created.
             - 'r+': similar to 'a', but the file must already exist.
-        format : {'fixed', 'table'}, default 'fixed'
-            Possible values:
-
-            - 'fixed': Fixed format. Fast writing/reading. Not-appendable,
-              nor searchable.
-            - 'table': Table format. Write as a PyTables Table structure
-              which may perform worse but allow more flexible operations
-              like searching / selecting subsets of the data.
-        append : bool, default False
-            For Table formats, append the input data to the existing.
-        data_columns :  list of columns or True, optional
-            List of columns to create as indexed data columns for on-disk
-            queries, or True to use all columns. By default only the axes
-            of the object are indexed. See :ref:`io.hdf5-query-data-columns`.
-            Applicable only to format='table'.
         complevel : {0-9}, optional
             Specifies a compression level for data.
             A value of 0 disables compression.
@@ -2467,14 +2327,33 @@ def to_hdf(self, path_or_buf, key, **kwargs):
             'blosc:zlib', 'blosc:zstd'}.
             Specifying a compression library which is not available issues
             a ValueError.
-        fletcher32 : bool, default False
-            If applying compression use the fletcher32 checksum.
-        dropna : bool, default False
-            If true, ALL nan rows will not be written to store.
+        append : bool, default False
+            For Table formats, append the input data to the existing.
+        format : {'fixed', 'table', None}, default 'fixed'
+            Possible values:
+
+            - 'fixed': Fixed format. Fast writing/reading. Not-appendable,
+              nor searchable.
+            - 'table': Table format. Write as a PyTables Table structure
+              which may perform worse but allow more flexible operations
+              like searching / selecting subsets of the data.
+            - If None, pd.get_option('io.hdf.default_format') is checked,
+              followed by fallback to "fixed"
         errors : str, default 'strict'
             Specifies how encoding and decoding errors are to be handled.
             See the errors argument for :func:`open` for a full list
             of options.
+        encoding : str, default "UTF-8"
+        min_itemsize : dict or int, optional
+            Map column names to minimum string sizes for columns.
+        nan_rep : Any, optional
+            How to represent null values as str.
+            Not allowed with append=True.
+        data_columns : list of columns or True, optional
+            List of columns to create as indexed data columns for on-disk
+            queries, or True to use all columns. By default only the axes
+            of the object are indexed. See :ref:`io.hdf5-query-data-columns`.
+            Applicable only to format='table'.
 
         See Also
         --------
@@ -2516,50 +2395,36 @@ def to_hdf(self, path_or_buf, key, **kwargs):
         """
         from pandas.io import pytables
 
-        pytables.to_hdf(path_or_buf, key, self, **kwargs)
-
-    def to_msgpack(self, path_or_buf=None, encoding="utf-8", **kwargs):
-        """
-        Serialize object to input file path using msgpack format.
-
-        .. deprecated:: 0.25.0
-
-        to_msgpack is deprecated and will be removed in a future version.
-        It is recommended to use pyarrow for on-the-wire transmission of
-        pandas objects.
-
-        Parameters
-        ----------
-        path : string File path, buffer-like, or None
-            if None, return generated bytes
-        append : bool whether to append to an existing msgpack
-            (default is False)
-        compress : type of compressor (zlib or blosc), default to None (no
-            compression)
-
-        Returns
-        -------
-        None or bytes
-            If path_or_buf is None, returns the resulting msgpack format as a
-            byte string. Otherwise returns None.
-        """
-
-        from pandas.io import packers
-
-        return packers.to_msgpack(path_or_buf, self, encoding=encoding, **kwargs)
+        pytables.to_hdf(
+            path_or_buf,
+            key,
+            self,
+            mode=mode,
+            complevel=complevel,
+            complib=complib,
+            append=append,
+            format=format,
+            index=index,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            dropna=dropna,
+            data_columns=data_columns,
+            errors=errors,
+            encoding=encoding,
+        )
 
     def to_sql(
         self,
         name: str,
         con,
         schema=None,
-        if_exists="fail",
-        index=True,
+        if_exists: str = "fail",
+        index: bool_t = True,
         index_label=None,
         chunksize=None,
         dtype=None,
         method=None,
-    ):
+    ) -> None:
         """
         Write records stored in a DataFrame to a SQL database.
 
@@ -2572,7 +2437,11 @@ def to_sql(
             Name of SQL table.
         con : sqlalchemy.engine.Engine or sqlite3.Connection
             Using SQLAlchemy makes it possible to use any DB supported by that
-            library. Legacy support is provided for sqlite3.Connection objects.
+            library. Legacy support is provided for sqlite3.Connection objects. The user
+            is responsible for engine disposal and connection closure for the SQLAlchemy
+            connectable See `here \
+                <https://docs.sqlalchemy.org/en/13/core/connections.html>`_
+
         schema : str, optional
             Specify the schema (if database flavor supports this). If None, use
             default schema.
@@ -2631,7 +2500,7 @@ def to_sql(
 
         References
         ----------
-        .. [1] http://docs.sqlalchemy.org
+        .. [1] https://docs.sqlalchemy.org
         .. [2] https://www.python.org/dev/peps/pep-0249/
 
         Examples
@@ -2702,7 +2571,12 @@ def to_sql(
             method=method,
         )
 
-    def to_pickle(self, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL):
+    def to_pickle(
+        self,
+        path,
+        compression: Optional[str] = "infer",
+        protocol: int = pickle.HIGHEST_PROTOCOL,
+    ) -> None:
         """
         Pickle (serialize) object to file.
 
@@ -2714,16 +2588,14 @@ def to_pickle(self, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL)
         default 'infer'
             A string representing the compression to use in the output file. By
             default, infers from the file extension in specified path.
-
-            .. versionadded:: 0.20.0
         protocol : int
             Int which indicates which protocol should be used by the pickler,
             default HIGHEST_PROTOCOL (see [1]_ paragraph 12.1.2). The possible
             values are 0, 1, 2, 3, 4. A negative value for the protocol
             parameter is equivalent to setting its value to HIGHEST_PROTOCOL.
 
-            .. [1] https://docs.python.org/3/library/pickle.html
-            .. versionadded:: 0.21.0
+            .. [1] https://docs.python.org/3/library/pickle.html.
+            .. versionadded:: 0.21.0.
 
         See Also
         --------
@@ -2760,7 +2632,9 @@ def to_pickle(self, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL)
 
         to_pickle(self, path, compression=compression, protocol=protocol)
 
-    def to_clipboard(self, excel=True, sep=None, **kwargs):
+    def to_clipboard(
+        self, excel: bool_t = True, sep: Optional[str] = None, **kwargs
+    ) -> None:
         r"""
         Copy object to the system clipboard.
 
@@ -2770,10 +2644,10 @@ def to_clipboard(self, excel=True, sep=None, **kwargs):
         Parameters
         ----------
         excel : bool, default True
-            - True, use the provided separator, writing in a csv format for
-              allowing easy pasting into excel.
-            - False, write a string representation of the object to the
-              clipboard.
+            Produce output in a csv format for easy pasting into excel.
+
+            - True, use the provided separator for csv pasting.
+            - False, write a string representation of the object to the clipboard.
 
         sep : str, default ``'\t'``
             Field delimiter.
@@ -2805,7 +2679,7 @@ def to_clipboard(self, excel=True, sep=None, **kwargs):
         ... # 0,1,2,3
         ... # 1,4,5,6
 
-        We can omit the the index by passing the keyword `index` and setting
+        We can omit the index by passing the keyword `index` and setting
         it to false.
 
         >>> df.to_clipboard(sep=',', index=False)
@@ -2835,16 +2709,16 @@ def to_xarray(self):
 
         Notes
         -----
-        See the `xarray docs <http://xarray.pydata.org/en/stable/>`__
+        See the `xarray docs <https://xarray.pydata.org/en/stable/>`__
 
         Examples
         --------
-        >>> df = pd.DataFrame([('falcon', 'bird',  389.0, 2),
+        >>> df = pd.DataFrame([('falcon', 'bird', 389.0, 2),
         ...                    ('parrot', 'bird', 24.0, 2),
-        ...                    ('lion',   'mammal', 80.5, 4),
+        ...                    ('lion', 'mammal', 80.5, 4),
         ...                    ('monkey', 'mammal', np.nan, 4)],
-        ...                    columns=['name', 'class', 'max_speed',
-        ...                             'num_legs'])
+        ...                   columns=['name', 'class', 'max_speed',
+        ...                            'num_legs'])
         >>> df
              name   class  max_speed  num_legs
         0  falcon    bird      389.0         2
@@ -2872,10 +2746,11 @@ class      (index) object 'bird' 'bird' 'mammal' 'mammal'
         >>> dates = pd.to_datetime(['2018-01-01', '2018-01-01',
         ...                         '2018-01-02', '2018-01-02'])
         >>> df_multiindex = pd.DataFrame({'date': dates,
-        ...                    'animal': ['falcon', 'parrot', 'falcon',
-        ...                               'parrot'],
-        ...                    'speed': [350, 18, 361, 15]}).set_index(['date',
-        ...                                                    'animal'])
+        ...                               'animal': ['falcon', 'parrot',
+        ...                                          'falcon', 'parrot'],
+        ...                               'speed': [350, 18, 361, 15]})
+        >>> df_multiindex = df_multiindex.set_index(['date', 'animal'])
+
         >>> df_multiindex
                            speed
         date       animal
@@ -2990,22 +2865,15 @@ def to_latex(
         multicolumn : bool, default True
             Use \multicolumn to enhance MultiIndex columns.
             The default will be read from the config module.
-
-            .. versionadded:: 0.20.0
         multicolumn_format : str, default 'l'
             The alignment for multicolumns, similar to `column_format`
             The default will be read from the config module.
-
-            .. versionadded:: 0.20.0
         multirow : bool, default False
             Use \multirow to enhance MultiIndex rows. Requires adding a
             \usepackage{multirow} to your LaTeX preamble. Will print
             centered labels (instead of top-aligned) across the contained
             rows, separating groups via clines. The default will be read
             from the pandas config module.
-
-            .. versionadded:: 0.20.0
-
         caption : str, optional
             The LaTeX caption to be placed inside ``\caption{}`` in the output.
 
@@ -3085,13 +2953,13 @@ def to_csv(
         sep: str = ",",
         na_rep: str = "",
         float_format: Optional[str] = None,
-        columns: Optional[Sequence[Hashable]] = None,
+        columns: Optional[Sequence[Label]] = None,
         header: Union[bool_t, List[str]] = True,
         index: bool_t = True,
-        index_label: Optional[Union[bool_t, str, Sequence[Hashable]]] = None,
+        index_label: Optional[Union[bool_t, str, Sequence[Label]]] = None,
         mode: str = "w",
         encoding: Optional[str] = None,
-        compression: Optional[Union[str, Dict[str, str]]] = "infer",
+        compression: Optional[Union[str, Mapping[str, str]]] = "infer",
         quoting: Optional[int] = None,
         quotechar: str = '"',
         line_terminator: Optional[str] = None,
@@ -3157,7 +3025,7 @@ def to_csv(
             and mode is 'zip' or inferred as 'zip', other entries passed as
             additional compression options.
 
-            .. versionchanged:: 0.25.0
+            .. versionchanged:: 1.0.0
 
                May now be a dict with key 'method' as compression mode
                and other entries as additional compression options if
@@ -3207,10 +3075,10 @@ def to_csv(
         >>> df.to_csv(index=False)
         'name,mask,weapon\nRaphael,red,sai\nDonatello,purple,bo staff\n'
 
-        # create 'out.zip' containing 'out.csv'
+        Create 'out.zip' containing 'out.csv'
+
         >>> compression_opts = dict(method='zip',
         ...                         archive_name='out.csv')  # doctest: +SKIP
-
         >>> df.to_csv('out.zip', index=False,
         ...           compression=compression_opts)  # doctest: +SKIP
         """
@@ -3248,37 +3116,27 @@ def to_csv(
 
         return None
 
-    # ----------------------------------------------------------------------
-    # Fancy Indexing
-
-    @classmethod
-    def _create_indexer(cls, name, indexer):
-        """Create an indexer like _name in the class."""
-        if getattr(cls, name, None) is None:
-            _indexer = functools.partial(indexer, name)
-            setattr(cls, name, property(_indexer, doc=indexer.__doc__))
-
     # ----------------------------------------------------------------------
     # Lookup Caching
 
-    def _set_as_cached(self, item, cacher):
+    def _set_as_cached(self, item, cacher) -> None:
         """Set the _cacher attribute on the calling object with a weakref to
         cacher.
         """
         self._cacher = (item, weakref.ref(cacher))
 
-    def _reset_cacher(self):
+    def _reset_cacher(self) -> None:
         """Reset the cacher."""
         if hasattr(self, "_cacher"):
             del self._cacher
 
-    def _maybe_cache_changed(self, item, value):
+    def _maybe_cache_changed(self, item, value) -> None:
         """The object has called back to us saying maybe it has changed.
         """
         self._data.set(item, value)
 
     @property
-    def _is_cached(self):
+    def _is_cached(self) -> bool_t:
         """Return boolean indicating if self is cached or not."""
         return getattr(self, "_cacher", None) is not None
 
@@ -3289,7 +3147,9 @@ def _get_cacher(self):
             cacher = cacher[1]()
         return cacher
 
-    def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
+    def _maybe_update_cacher(
+        self, clear: bool_t = False, verify_is_copy: bool_t = True
+    ) -> None:
         """
         See if we need to update our parent cacher if clear, then clear our
         cache.
@@ -3311,9 +3171,13 @@ def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
             if ref is None:
                 del self._cacher
             else:
+                # Note: we need to call ref._maybe_cache_changed even in the
+                #  case where it will raise.  (Uh, not clear why)
                 try:
                     ref._maybe_cache_changed(cacher[0], self)
-                except Exception:
+                except AssertionError:
+                    # ref._data.setitem can raise
+                    #  AssertionError because of shape mismatch
                     pass
 
         if verify_is_copy:
@@ -3322,13 +3186,15 @@ def _maybe_update_cacher(self, clear=False, verify_is_copy=True):
         if clear:
             self._clear_item_cache()
 
-    def _clear_item_cache(self):
+    def _clear_item_cache(self) -> None:
         self._item_cache.clear()
 
     # ----------------------------------------------------------------------
     # Indexing Methods
 
-    def take(self, indices, axis=0, is_copy=True, **kwargs):
+    def take(
+        self: FrameOrSeries, indices, axis=0, is_copy: Optional[bool_t] = None, **kwargs
+    ) -> FrameOrSeries:
         """
         Return the elements in the given *positional* indices along an axis.
 
@@ -3343,8 +3209,13 @@ def take(self, indices, axis=0, is_copy=True, **kwargs):
         axis : {0 or 'index', 1 or 'columns', None}, default 0
             The axis on which to select elements. ``0`` means that we are
             selecting rows, ``1`` means that we are selecting columns.
-        is_copy : bool, default True
-            Whether to return a copy of the original object or not.
+        is_copy : bool
+            Before pandas 1.0, ``is_copy=False`` can be specified to ensure
+            that the return value is an actual copy. Starting with pandas 1.0,
+            ``take`` always returns a copy, and the keyword is therefore
+            deprecated.
+
+            .. deprecated:: 1.0.0
         **kwargs
             For compatibility with :meth:`numpy.take`. Has no effect on the
             output.
@@ -3362,12 +3233,12 @@ def take(self, indices, axis=0, is_copy=True, **kwargs):
 
         Examples
         --------
-        >>> df = pd.DataFrame([('falcon', 'bird',    389.0),
-        ...                    ('parrot', 'bird',     24.0),
-        ...                    ('lion',   'mammal',   80.5),
+        >>> df = pd.DataFrame([('falcon', 'bird', 389.0),
+        ...                    ('parrot', 'bird', 24.0),
+        ...                    ('lion', 'mammal', 80.5),
         ...                    ('monkey', 'mammal', np.nan)],
-        ...                    columns=['name', 'class', 'max_speed'],
-        ...                    index=[0, 2, 3, 1])
+        ...                   columns=['name', 'class', 'max_speed'],
+        ...                   index=[0, 2, 3, 1])
         >>> df
              name   class  max_speed
         0  falcon    bird      389.0
@@ -3403,6 +3274,14 @@ class  max_speed
         1  monkey  mammal        NaN
         3    lion  mammal       80.5
         """
+        if is_copy is not None:
+            warnings.warn(
+                "is_copy is deprecated and will be removed in a future version. "
+                "'take' always returns a copy, so there is no need to specify this.",
+                FutureWarning,
+                stacklevel=2,
+            )
+
         nv.validate_take(tuple(), kwargs)
 
         self._consolidate_inplace()
@@ -3410,16 +3289,25 @@ class  max_speed
         new_data = self._data.take(
             indices, axis=self._get_block_manager_axis(axis), verify=True
         )
-        result = self._constructor(new_data).__finalize__(self)
+        return self._constructor(new_data).__finalize__(self)
 
-        # Maybe set copy if we didn't actually change the index.
-        if is_copy:
-            if not result._get_axis(axis).equals(self._get_axis(axis)):
-                result._set_is_copy(self)
+    def _take_with_is_copy(
+        self: FrameOrSeries, indices, axis=0, **kwargs
+    ) -> FrameOrSeries:
+        """
+        Internal version of the `take` method that sets the `_is_copy`
+        attribute to keep track of the parent dataframe (using in indexing
+        for the SettingWithCopyWarning).
 
+        See the docstring of `take` for full explanation of the parameters.
+        """
+        result = self.take(indices=indices, axis=axis, **kwargs)
+        # Maybe set copy if we didn't actually change the index.
+        if not result._get_axis(axis).equals(self._get_axis(axis)):
+            result._set_is_copy(self)
         return result
 
-    def xs(self, key, axis=0, level=None, drop_level=True):
+    def xs(self, key, axis=0, level=None, drop_level: bool_t = True):
         """
         Return cross-section from the Series/DataFrame.
 
@@ -3524,9 +3412,9 @@ class   animal   locomotion
             loc, new_ax = labels.get_loc_level(key, level=level, drop_level=drop_level)
 
             # create the tuple of the indexer
-            indexer = [slice(None)] * self.ndim
-            indexer[axis] = loc
-            indexer = tuple(indexer)
+            _indexer = [slice(None)] * self.ndim
+            _indexer[axis] = loc
+            indexer = tuple(_indexer)
 
             result = self.iloc[indexer]
             setattr(result, result._get_axis_name(axis), new_ax)
@@ -3545,24 +3433,23 @@ class   animal   locomotion
 
             if isinstance(loc, np.ndarray):
                 if loc.dtype == np.bool_:
-                    inds, = loc.nonzero()
-                    return self.take(inds, axis=axis)
+                    (inds,) = loc.nonzero()
+                    return self._take_with_is_copy(inds, axis=axis)
                 else:
-                    return self.take(loc, axis=axis)
+                    return self._take_with_is_copy(loc, axis=axis)
 
             if not is_scalar(loc):
                 new_index = self.index[loc]
 
         if is_scalar(loc):
-            new_values = self._data.fast_xs(loc)
+            # In this case loc should be an integer
+            if self.ndim == 1:
+                # if we encounter an array-like and we only have 1 dim
+                # that means that their are list/ndarrays inside the Series!
+                # so just return them (GH 6394)
+                return self._values[loc]
 
-            # may need to box a datelike-scalar
-            #
-            # if we encounter an array-like and we only have 1 dim
-            # that means that their are list/ndarrays inside the Series!
-            # so just return them (GH 6394)
-            if not is_list_like(new_values) or self.ndim == 1:
-                return com.maybe_box_datetimelike(new_values)
+            new_values = self._data.fast_xs(loc)
 
             result = self._constructor_sliced(
                 new_values,
@@ -3580,7 +3467,7 @@ class   animal   locomotion
         result._set_is_copy(self, copy=not result._is_view)
         return result
 
-    _xs = xs  # type: Callable
+    _xs: Callable = xs
 
     def __getitem__(self, item):
         raise AbstractMethodError(self)
@@ -3605,17 +3492,17 @@ def _iget_item_cache(self, item):
         if ax.is_unique:
             lower = self._get_item_cache(ax[item])
         else:
-            lower = self.take(item, axis=self._info_axis_number)
+            lower = self._take_with_is_copy(item, axis=self._info_axis_number)
         return lower
 
     def _box_item_values(self, key, values):
         raise AbstractMethodError(self)
 
-    def _slice(self, slobj: slice, axis=0, kind=None):
+    def _slice(self: FrameOrSeries, slobj: slice, axis=0) -> FrameOrSeries:
         """
         Construct a slice of this container.
 
-        kind parameter is maintained for compatibility with Series slicing.
+        Slicing with this method is *always* positional.
         """
         axis = self._get_block_manager_axis(axis)
         result = self._constructor(self._data.get_slice(slobj, axis=axis))
@@ -3627,20 +3514,18 @@ def _slice(self, slobj: slice, axis=0, kind=None):
         result._set_is_copy(self, copy=is_copy)
         return result
 
-    def _set_item(self, key, value):
+    def _set_item(self, key, value) -> None:
         self._data.set(key, value)
         self._clear_item_cache()
 
-    def _set_is_copy(self, ref=None, copy=True):
+    def _set_is_copy(self, ref, copy: bool_t = True) -> None:
         if not copy:
             self._is_copy = None
         else:
-            if ref is not None:
-                self._is_copy = weakref.ref(ref)
-            else:
-                self._is_copy = None
+            assert ref is not None
+            self._is_copy = weakref.ref(ref)
 
-    def _check_is_chained_assignment_possible(self):
+    def _check_is_chained_assignment_possible(self) -> bool_t:
         """
         Check if we are a view, have a cacher, and are of mixed type.
         If so, then force a setitem_copy check.
@@ -3717,7 +3602,7 @@ def _check_setitem_copy(self, stacklevel=4, t="setting", force=False):
                 "A value is trying to be set on a copy of a slice from a "
                 "DataFrame\n\n"
                 "See the caveats in the documentation: "
-                "http://pandas.pydata.org/pandas-docs/stable/user_guide/"
+                "https://pandas.pydata.org/pandas-docs/stable/user_guide/"
                 "indexing.html#returning-a-view-versus-a-copy"
             )
 
@@ -3728,7 +3613,7 @@ def _check_setitem_copy(self, stacklevel=4, t="setting", force=False):
                 "DataFrame.\n"
                 "Try using .loc[row_indexer,col_indexer] = value "
                 "instead\n\nSee the caveats in the documentation: "
-                "http://pandas.pydata.org/pandas-docs/stable/user_guide/"
+                "https://pandas.pydata.org/pandas-docs/stable/user_guide/"
                 "indexing.html#returning-a-view-versus-a-copy"
             )
 
@@ -3737,7 +3622,7 @@ def _check_setitem_copy(self, stacklevel=4, t="setting", force=False):
         elif value == "warn":
             warnings.warn(t, com.SettingWithCopyWarning, stacklevel=stacklevel)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key) -> None:
         """
         Delete item
         """
@@ -3798,7 +3683,14 @@ def _is_view(self):
         """Return boolean indicating if self is view of another array """
         return self._data.is_view
 
-    def reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None):
+    def reindex_like(
+        self: FrameOrSeries,
+        other,
+        method: Optional[str] = None,
+        copy: bool_t = True,
+        limit=None,
+        tolerance=None,
+    ) -> FrameOrSeries:
         """
         Return an object with matching indices as other object.
 
@@ -3821,7 +3713,7 @@ def reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None
             * pad / ffill: propagate last valid observation forward to next
               valid
             * backfill / bfill: use next valid observation to fill gap
-            * nearest: use nearest valid observations to fill gap
+            * nearest: use nearest valid observations to fill gap.
 
         copy : bool, default True
             Return a new object, even if the passed indexes are the same.
@@ -3862,9 +3754,10 @@ def reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None
         ...                     [31, 87.8, 'high'],
         ...                     [22, 71.6, 'medium'],
         ...                     [35, 95, 'medium']],
-        ...     columns=['temp_celsius', 'temp_fahrenheit', 'windspeed'],
-        ...     index=pd.date_range(start='2014-02-12',
-        ...                         end='2014-02-15', freq='D'))
+        ...                    columns=['temp_celsius', 'temp_fahrenheit',
+        ...                             'windspeed'],
+        ...                    index=pd.date_range(start='2014-02-12',
+        ...                                        end='2014-02-15', freq='D'))
 
         >>> df1
                     temp_celsius  temp_fahrenheit windspeed
@@ -3876,9 +3769,9 @@ def reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None
         >>> df2 = pd.DataFrame([[28, 'low'],
         ...                     [30, 'low'],
         ...                     [35.1, 'medium']],
-        ...     columns=['temp_celsius', 'windspeed'],
-        ...     index=pd.DatetimeIndex(['2014-02-12', '2014-02-13',
-        ...                             '2014-02-15']))
+        ...                    columns=['temp_celsius', 'windspeed'],
+        ...                    index=pd.DatetimeIndex(['2014-02-12', '2014-02-13',
+        ...                                            '2014-02-15']))
 
         >>> df2
                     temp_celsius windspeed
@@ -3910,8 +3803,8 @@ def drop(
         index=None,
         columns=None,
         level=None,
-        inplace=False,
-        errors="raise",
+        inplace: bool_t = False,
+        errors: str = "raise",
     ):
 
         inplace = validate_bool_kwarg(inplace, "inplace")
@@ -3939,7 +3832,9 @@ def drop(
         else:
             return obj
 
-    def _drop_axis(self, labels, axis, level=None, errors="raise"):
+    def _drop_axis(
+        self: FrameOrSeries, labels, axis, level=None, errors: str = "raise"
+    ) -> FrameOrSeries:
         """
         Drop labels from specified axis. Used in the ``drop`` method
         internally.
@@ -3977,13 +3872,13 @@ def _drop_axis(self, labels, axis, level=None, errors="raise"):
 
                 # GH 18561 MultiIndex.drop should raise if label is absent
                 if errors == "raise" and indexer.all():
-                    raise KeyError("{} not found in axis".format(labels))
+                    raise KeyError(f"{labels} not found in axis")
             else:
                 indexer = ~axis.isin(labels)
                 # Check if label doesn't exist along axis
                 labels_missing = (axis.get_indexer_for(labels) == -1).any()
                 if errors == "raise" and labels_missing:
-                    raise KeyError("{} not found in axis".format(labels))
+                    raise KeyError(f"{labels} not found in axis")
 
             slicer = [slice(None)] * self.ndim
             slicer[self._get_axis_number(axis_name)] = indexer
@@ -3992,7 +3887,7 @@ def _drop_axis(self, labels, axis, level=None, errors="raise"):
 
         return result
 
-    def _update_inplace(self, result, verify_is_copy=True):
+    def _update_inplace(self, result, verify_is_copy: bool_t = True) -> None:
         """
         Replace self internals with result.
 
@@ -4009,7 +3904,7 @@ def _update_inplace(self, result, verify_is_copy=True):
         self._data = getattr(result, "_data", result)
         self._maybe_update_cacher(verify_is_copy=verify_is_copy)
 
-    def add_prefix(self, prefix):
+    def add_prefix(self: FrameOrSeries, prefix: str) -> FrameOrSeries:
         """
         Prefix labels with string `prefix`.
 
@@ -4048,7 +3943,7 @@ def add_prefix(self, prefix):
         item_3    4
         dtype: int64
 
-        >>> df = pd.DataFrame({'A': [1, 2, 3, 4],  'B': [3, 4, 5, 6]})
+        >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
         >>> df
            A  B
         0  1  3
@@ -4066,9 +3961,9 @@ def add_prefix(self, prefix):
         f = functools.partial("{prefix}{}".format, prefix=prefix)
 
         mapper = {self._info_axis_name: f}
-        return self.rename(**mapper)
+        return self.rename(**mapper)  # type: ignore
 
-    def add_suffix(self, suffix):
+    def add_suffix(self: FrameOrSeries, suffix: str) -> FrameOrSeries:
         """
         Suffix labels with string `suffix`.
 
@@ -4107,7 +4002,7 @@ def add_suffix(self, suffix):
         3_item    4
         dtype: int64
 
-        >>> df = pd.DataFrame({'A': [1, 2, 3, 4],  'B': [3, 4, 5, 6]})
+        >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
         >>> df
            A  B
         0  1  3
@@ -4125,16 +4020,16 @@ def add_suffix(self, suffix):
         f = functools.partial("{}{suffix}".format, suffix=suffix)
 
         mapper = {self._info_axis_name: f}
-        return self.rename(**mapper)
+        return self.rename(**mapper)  # type: ignore
 
     def sort_values(
         self,
-        by=None,
         axis=0,
         ascending=True,
-        inplace=False,
-        kind="quicksort",
-        na_position="last",
+        inplace: bool_t = False,
+        kind: str = "quicksort",
+        na_position: str = "last",
+        ignore_index: bool_t = False,
     ):
         """
         Sort by the values along either axis.
@@ -4157,6 +4052,10 @@ def sort_values(
         na_position : {'first', 'last'}, default 'last'
              Puts NaNs at the beginning if `first`; `last` puts NaNs at the
              end.
+        ignore_index : bool, default False
+             If True, the resulting axis will be labeled 0, 1, …, n - 1.
+
+             .. versionadded:: 1.0.0
 
         Returns
         -------
@@ -4225,68 +4124,11 @@ def sort_values(
         """
         raise AbstractMethodError(self)
 
-    def sort_index(
-        self,
-        axis=0,
-        level=None,
-        ascending=True,
-        inplace=False,
-        kind="quicksort",
-        na_position="last",
-        sort_remaining=True,
-    ):
+    def reindex(self: FrameOrSeries, *args, **kwargs) -> FrameOrSeries:
         """
-        Sort object by labels (along an axis).
+        Conform %(klass)s to new index with optional filling logic.
 
-        Parameters
-        ----------
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            The axis along which to sort.  The value 0 identifies the rows,
-            and 1 identifies the columns.
-        level : int or level name or list of ints or list of level names
-            If not None, sort on values in specified index level(s).
-        ascending : bool, default True
-            Sort ascending vs. descending.
-        inplace : bool, default False
-            If True, perform operation in-place.
-        kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
-            Choice of sorting algorithm. See also ndarray.np.sort for more
-            information.  `mergesort` is the only stable algorithm. For
-            DataFrames, this option is only applied when sorting on a single
-            column or label.
-        na_position : {'first', 'last'}, default 'last'
-            Puts NaNs at the beginning if `first`; `last` puts NaNs at the end.
-            Not implemented for MultiIndex.
-        sort_remaining : bool, default True
-            If True and sorting by level and index is multilevel, sort by other
-            levels too (in order) after sorting by specified level.
-
-        Returns
-        -------
-        sorted_obj : DataFrame or None
-            DataFrame with sorted index if inplace=False, None otherwise.
-        """
-        inplace = validate_bool_kwarg(inplace, "inplace")
-        axis = self._get_axis_number(axis)
-        axis_name = self._get_axis_name(axis)
-        labels = self._get_axis(axis)
-
-        if level is not None:
-            raise NotImplementedError("level is not implemented")
-        if inplace:
-            raise NotImplementedError("inplace is not implemented")
-
-        sort_index = labels.argsort()
-        if not ascending:
-            sort_index = sort_index[::-1]
-
-        new_axis = labels.take(sort_index)
-        return self.reindex(**{axis_name: new_axis})
-
-    def reindex(self, *args, **kwargs):
-        """
-        Conform %(klass)s to new index with optional filling logic, placing
-        NA/NaN in locations having no value in the previous index. A new object
+        Places NA/NaN in locations having no value in the previous index. A new object
         is produced unless the new index is equivalent to the current one and
         ``copy=False``.
 
@@ -4295,7 +4137,7 @@ def reindex(self, *args, **kwargs):
         %(optional_labels)s
         %(axes)s : array-like, optional
             New labels / index to conform to, should be specified using
-            keywords. Preferably an Index object to avoid duplicating data
+            keywords. Preferably an Index object to avoid duplicating data.
         %(optional_axis)s
         method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}
             Method to use for filling holes in reindexed DataFrame.
@@ -4303,10 +4145,10 @@ def reindex(self, *args, **kwargs):
             monotonically increasing/decreasing index.
 
             * None (default): don't fill gaps
-            * pad / ffill: propagate last valid observation forward to next
-              valid
-            * backfill / bfill: use next valid observation to fill gap
-            * nearest: use nearest valid observations to fill gap
+            * pad / ffill: Propagate last valid observation forward to next
+              valid.
+            * backfill / bfill: Use next valid observation to fill gap.
+            * nearest: Use nearest valid observations to fill gap.
 
         copy : bool, default True
             Return a new object, even if the passed indexes are the same.
@@ -4355,10 +4197,9 @@ def reindex(self, *args, **kwargs):
         Create a dataframe with some fictional data.
 
         >>> index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']
-        >>> df = pd.DataFrame({
-        ...      'http_status': [200,200,404,404,301],
-        ...      'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
-        ...       index=index)
+        >>> df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],
+        ...                   'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
+        ...                   index=index)
         >>> df
                    http_status  response_time
         Firefox            200           0.04
@@ -4371,8 +4212,8 @@ def reindex(self, *args, **kwargs):
         values in the new index that do not have corresponding
         records in the dataframe are assigned ``NaN``.
 
-        >>> new_index= ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',
-        ...             'Chrome']
+        >>> new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',
+        ...              'Chrome']
         >>> df.reindex(new_index)
                        http_status  response_time
         Safari               404.0           0.07
@@ -4506,7 +4347,7 @@ def reindex(self, *args, **kwargs):
         if kwargs:
             raise TypeError(
                 "reindex() got an unexpected keyword "
-                'argument "{0}"'.format(list(kwargs.keys())[0])
+                f'argument "{list(kwargs.keys())[0]}"'
             )
 
         self._consolidate_inplace()
@@ -4524,17 +4365,16 @@ def reindex(self, *args, **kwargs):
 
         # check if we are a multi reindex
         if self._needs_reindex_multi(axes, method, level):
-            try:
-                return self._reindex_multi(axes, copy, fill_value)
-            except Exception:
-                pass
+            return self._reindex_multi(axes, copy, fill_value)
 
         # perform the reindex on the axes
         return self._reindex_axes(
             axes, level, limit, tolerance, method, fill_value, copy
         ).__finalize__(self)
 
-    def _reindex_axes(self, axes, level, limit, tolerance, method, fill_value, copy):
+    def _reindex_axes(
+        self: FrameOrSeries, axes, level, limit, tolerance, method, fill_value, copy
+    ) -> FrameOrSeries:
         """Perform the reindex for all the axes."""
         obj = self
         for a in self._AXIS_ORDERS:
@@ -4557,7 +4397,7 @@ def _reindex_axes(self, axes, level, limit, tolerance, method, fill_value, copy)
 
         return obj
 
-    def _needs_reindex_multi(self, axes, method, level):
+    def _needs_reindex_multi(self, axes, method, level) -> bool_t:
         """Check if we do need a multi reindex."""
         return (
             (com.count_not_none(*axes.values()) == self._AXIS_LEN)
@@ -4567,11 +4407,15 @@ def _needs_reindex_multi(self, axes, method, level):
         )
 
     def _reindex_multi(self, axes, copy, fill_value):
-        return NotImplemented
+        raise AbstractMethodError(self)
 
     def _reindex_with_indexers(
-        self, reindexers, fill_value=None, copy=False, allow_dups=False
-    ):
+        self: FrameOrSeries,
+        reindexers,
+        fill_value=None,
+        copy: bool_t = False,
+        allow_dups: bool_t = False,
+    ) -> FrameOrSeries:
         """allow_dups indicates an internal call here """
 
         # reindex doing multiple operations on different axes if indicated
@@ -4602,10 +4446,15 @@ def _reindex_with_indexers(
 
         return self._constructor(new_data).__finalize__(self)
 
-    def filter(self, items=None, like=None, regex=None, axis=None):
+    def filter(
+        self: FrameOrSeries,
+        items=None,
+        like: Optional[str] = None,
+        regex: Optional[str] = None,
+        axis=None,
+    ) -> FrameOrSeries:
         """
-        Subset rows or columns of dataframe according to labels in
-        the specified index.
+        Subset the dataframe rows or columns according to the specified index labels.
 
         Note that this routine does not filter a dataframe on its
         contents. The filter is applied to the labels of the index.
@@ -4618,8 +4467,9 @@ def filter(self, items=None, like=None, regex=None, axis=None):
             Keep labels from axis for which "like in label == True".
         regex : str (regular expression)
             Keep labels from axis for which re.search(regex, label) == True.
-        axis : int or string axis name
-            The axis to filter on.  By default this is the info axis,
+        axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
+            The axis to filter on, expressed either as an index (int)
+            or axis name (str). By default this is the info axis,
             'index' for Series, 'columns' for DataFrame.
 
         Returns
@@ -4693,7 +4543,7 @@ def f(x):
         else:
             raise TypeError("Must pass either `items`, `like`, or `regex`")
 
-    def head(self, n=5):
+    def head(self: FrameOrSeries, n: int = 5) -> FrameOrSeries:
         """
         Return the first `n` rows.
 
@@ -4701,6 +4551,9 @@ def head(self, n=5):
         on position. It is useful for quickly testing if your object
         has the right type of data in it.
 
+        For negative values of `n`, this function returns all rows except
+        the last `n` rows, equivalent to ``df[:-n]``.
+
         Parameters
         ----------
         n : int, default 5
@@ -4708,7 +4561,7 @@ def head(self, n=5):
 
         Returns
         -------
-        obj_head : same type as caller
+        same type as caller
             The first `n` rows of the caller object.
 
         See Also
@@ -4717,7 +4570,7 @@ def head(self, n=5):
 
         Examples
         --------
-        >>> df = pd.DataFrame({'animal':['alligator', 'bee', 'falcon', 'lion',
+        >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
         ...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})
         >>> df
               animal
@@ -4748,11 +4601,22 @@ def head(self, n=5):
         0  alligator
         1        bee
         2     falcon
+
+        For negative values of `n`
+
+        >>> df.head(-3)
+              animal
+        0  alligator
+        1        bee
+        2     falcon
+        3       lion
+        4     monkey
+        5     parrot
         """
 
         return self.iloc[:n]
 
-    def tail(self, n=5):
+    def tail(self: FrameOrSeries, n: int = 5) -> FrameOrSeries:
         """
         Return the last `n` rows.
 
@@ -4760,6 +4624,9 @@ def tail(self, n=5):
         position. It is useful for quickly verifying data, for example,
         after sorting or appending rows.
 
+        For negative values of `n`, this function returns all rows except
+        the first `n` rows, equivalent to ``df[n:]``.
+
         Parameters
         ----------
         n : int, default 5
@@ -4776,7 +4643,7 @@ def tail(self, n=5):
 
         Examples
         --------
-        >>> df = pd.DataFrame({'animal':['alligator', 'bee', 'falcon', 'lion',
+        >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
         ...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})
         >>> df
               animal
@@ -4807,6 +4674,17 @@ def tail(self, n=5):
         6  shark
         7  whale
         8  zebra
+
+        For negative values of `n`
+
+        >>> df.tail(-3)
+           animal
+        3    lion
+        4  monkey
+        5  parrot
+        6   shark
+        7   whale
+        8   zebra
         """
 
         if n == 0:
@@ -4814,14 +4692,14 @@ def tail(self, n=5):
         return self.iloc[-n:]
 
     def sample(
-        self,
+        self: FrameOrSeries,
         n=None,
         frac=None,
         replace=False,
         weights=None,
         random_state=None,
         axis=None,
-    ):
+    ) -> FrameOrSeries:
         """
         Return a random sample of items from an axis of object.
 
@@ -4852,7 +4730,7 @@ def sample(
         random_state : int or numpy.random.RandomState, optional
             Seed for the random number generator (if int), or numpy RandomState
             object.
-        axis : int or string, optional
+        axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
             Axis to sample. Accepts axis number or name. Default is stat axis
             for given data type (0 for Series and DataFrames).
 
@@ -4867,6 +4745,10 @@ def sample(
         numpy.random.choice: Generates a random sample from a given 1-D numpy
             array.
 
+        Notes
+        -----
+        If `frac` > 1, `replacement` should be set to `True`.
+
         Examples
         --------
         >>> df = pd.DataFrame({'num_legs': [2, 4, 8, 0],
@@ -4897,6 +4779,20 @@ def sample(
         dog          4          0                  2
         fish         0          0                  8
 
+        An upsample sample of the ``DataFrame`` with replacement:
+        Note that `replace` parameter has to be `True` for `frac` parameter > 1.
+
+        >>> df.sample(frac=2, replace=True, random_state=1)
+                num_legs  num_wings  num_specimen_seen
+        dog            4          0                  2
+        fish           0          0                  8
+        falcon         2          2                 10
+        falcon         2          2                 10
+        fish           0          0                  8
+        dog            4          0                  2
+        fish           0          0                  8
+        dog            4          0                  2
+
         Using a DataFrame column as weights. Rows with larger value in the
         `num_specimen_seen` column are more likely to be sampled.
 
@@ -4972,6 +4868,11 @@ def sample(
         # If no frac or n, default to n=1.
         if n is None and frac is None:
             n = 1
+        elif frac is not None and frac > 1 and not replace:
+            raise ValueError(
+                "Replace has to be set to `True` when "
+                "upsampling the population `frac` > 1."
+            )
         elif n is not None and frac is None and n % 1 != 0:
             raise ValueError("Only integers accepted as `n` values")
         elif n is None and frac is not None:
@@ -4986,7 +4887,7 @@ def sample(
             )
 
         locs = rs.choice(axis_length, size=n, replace=replace, p=weights)
-        return self.take(locs, axis=axis, is_copy=False)
+        return self.take(locs, axis=axis)
 
     _shared_docs[
         "pipe"
@@ -4996,15 +4897,15 @@ def sample(
         Parameters
         ----------
         func : function
-            function to apply to the %(klass)s.
+            Function to apply to the %(klass)s.
             ``args``, and ``kwargs`` are passed into ``func``.
             Alternatively a ``(callable, data_keyword)`` tuple where
             ``data_keyword`` is a string indicating the keyword of
             ``callable`` that expects the %(klass)s.
         args : iterable, optional
-            positional arguments passed into ``func``.
+            Positional arguments passed into ``func``.
         kwargs : mapping, optional
-            a dictionary of keyword arguments passed into ``func``.
+            A dictionary of keyword arguments passed into ``func``.
 
         Returns
         -------
@@ -5090,10 +4991,9 @@ def pipe(self, func, *args, **kwargs):
     _shared_docs[
         "transform"
     ] = """
-    Call ``func`` on self producing a %(klass)s with transformed values
-    and that has the same axis length as self.
+    Call ``func`` on self producing a %(klass)s with transformed values.
 
-    .. versionadded:: 0.20.0
+    Produced %(klass)s will have same axis length as self.
 
     Parameters
     ----------
@@ -5160,7 +5060,9 @@ def pipe(self, func, *args, **kwargs):
     # ----------------------------------------------------------------------
     # Attribute access
 
-    def __finalize__(self, other, method=None, **kwargs):
+    def __finalize__(
+        self: FrameOrSeries, other, method=None, **kwargs
+    ) -> FrameOrSeries:
         """
         Propagate metadata from other to self.
 
@@ -5173,11 +5075,15 @@ def __finalize__(self, other, method=None, **kwargs):
 
         """
         if isinstance(other, NDFrame):
+            for name in other.attrs:
+                self.attrs[name] = other.attrs[name]
+            # For subclasses using _metadata.
             for name in self._metadata:
+                assert isinstance(name, str)
                 object.__setattr__(self, name, getattr(other, name, None))
         return self
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str):
         """After regular attribute access, try looking up the name
         This allows simpler access to columns for interactive use.
         """
@@ -5196,7 +5102,7 @@ def __getattr__(self, name):
                 return self[name]
             return object.__getattribute__(self, name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value) -> None:
         """After regular attribute access, try setting the name
         This allows simpler access to columns for interactive use.
         """
@@ -5261,7 +5167,7 @@ def _protect_consolidate(self, f):
             self._clear_item_cache()
         return result
 
-    def _consolidate_inplace(self):
+    def _consolidate_inplace(self) -> None:
         """Consolidate data in place and return None"""
 
         def f():
@@ -5269,7 +5175,7 @@ def f():
 
         self._protect_consolidate(f)
 
-    def _consolidate(self, inplace=False):
+    def _consolidate(self, inplace: bool_t = False):
         """
         Compute NDFrame with "consolidated" internals (data of each dtype
         grouped together in a single ndarray).
@@ -5301,12 +5207,7 @@ def _is_numeric_mixed_type(self):
         f = lambda: self._data.is_numeric_mixed_type
         return self._protect_consolidate(f)
 
-    @property
-    def _is_datelike_mixed_type(self):
-        f = lambda: self._data.is_datelike_mixed_type
-        return self._protect_consolidate(f)
-
-    def _check_inplace_setting(self, value):
+    def _check_inplace_setting(self, value) -> bool_t:
         """ check whether we allow in-place setting with this type of value """
 
         if self._is_mixed_type:
@@ -5332,56 +5233,8 @@ def _get_bool_data(self):
     # ----------------------------------------------------------------------
     # Internal Interface Methods
 
-    def as_matrix(self, columns=None):
-        """
-        Convert the frame to its Numpy-array representation.
-
-        .. deprecated:: 0.23.0
-            Use :meth:`DataFrame.values` instead.
-
-        Parameters
-        ----------
-        columns : list, optional, default:None
-            If None, return all columns, otherwise, returns specified columns.
-
-        Returns
-        -------
-        values : ndarray
-            If the caller is heterogeneous and contains booleans or objects,
-            the result will be of dtype=object. See Notes.
-
-        See Also
-        --------
-        DataFrame.values
-
-        Notes
-        -----
-        Return is NOT a Numpy-matrix, rather, a Numpy-array.
-
-        The dtype will be a lower-common-denominator dtype (implicit
-        upcasting); that is to say if the dtypes (even of numeric types)
-        are mixed, the one that accommodates all will be chosen. Use this
-        with care if you are not dealing with the blocks.
-
-        e.g. If the dtypes are float16 and float32, dtype will be upcast to
-        float32.  If dtypes are int32 and uint8, dtype will be upcase to
-        int32. By numpy.find_common_type convention, mixing int64 and uint64
-        will result in a float64 dtype.
-
-        This method is provided for backwards compatibility. Generally,
-        it is recommended to use '.values'.
-        """
-        warnings.warn(
-            "Method .as_matrix will be removed in a future version. "
-            "Use .values instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        self._consolidate_inplace()
-        return self._data.as_array(transpose=self._AXIS_REVERSED, items=columns)
-
     @property
-    def values(self):
+    def values(self) -> np.ndarray:
         """
         Return a Numpy representation of the DataFrame.
 
@@ -5458,22 +5311,14 @@ def values(self):
         return self._data.as_array(transpose=self._AXIS_REVERSED)
 
     @property
-    def _values(self):
+    def _values(self) -> np.ndarray:
         """internal implementation"""
         return self.values
 
-    @property
-    def _get_values(self):
-        # compat
-        return self.values
-
-    def get_values(self):
+    def _internal_get_values(self) -> np.ndarray:
         """
         Return an ndarray after converting sparse values to dense.
 
-        .. deprecated:: 0.25.0
-            Use ``np.asarray(..)`` or :meth:`DataFrame.values` instead.
-
         This is the same as ``.values`` for non-sparse data. For sparse
         data contained in a `SparseArray`, the data are first
         converted to a dense representation.
@@ -5487,133 +5332,8 @@ def get_values(self):
         --------
         values : Numpy representation of DataFrame.
         SparseArray : Container for sparse data.
-
-        Examples
-        --------
-        >>> df = pd.DataFrame({'a': [1, 2], 'b': [True, False],
-        ...                    'c': [1.0, 2.0]})
-        >>> df
-           a      b    c
-        0  1   True  1.0
-        1  2  False  2.0
-
-        >>> df.get_values()
-        array([[1, True, 1.0], [2, False, 2.0]], dtype=object)
-
-        >>> df = pd.DataFrame({"a": pd.SparseArray([1, None, None]),
-        ...                    "c": [1.0, 2.0, 3.0]})
-        >>> df
-             a    c
-        0  1.0  1.0
-        1  NaN  2.0
-        2  NaN  3.0
-
-        >>> df.get_values()
-        array([[ 1.,  1.],
-               [nan,  2.],
-               [nan,  3.]])
-        """
-        warnings.warn(
-            "The 'get_values' method is deprecated and will be removed in a "
-            "future version. Use '.values' or 'np.asarray(..)' instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._internal_get_values()
-
-    def _internal_get_values(self):
-        return self.values
-
-    def get_dtype_counts(self):
         """
-        Return counts of unique dtypes in this object.
-
-        .. deprecated:: 0.25.0
-
-        Use `.dtypes.value_counts()` instead.
-
-        Returns
-        -------
-        dtype : Series
-            Series with the count of columns with each dtype.
-
-        See Also
-        --------
-        dtypes : Return the dtypes in this object.
-
-        Examples
-        --------
-        >>> a = [['a', 1, 1.0], ['b', 2, 2.0], ['c', 3, 3.0]]
-        >>> df = pd.DataFrame(a, columns=['str', 'int', 'float'])
-        >>> df
-          str  int  float
-        0   a    1    1.0
-        1   b    2    2.0
-        2   c    3    3.0
-
-        >>> df.get_dtype_counts()
-        float64    1
-        int64      1
-        object     1
-        dtype: int64
-        """
-        warnings.warn(
-            "`get_dtype_counts` has been deprecated and will be "
-            "removed in a future version. For DataFrames use "
-            "`.dtypes.value_counts()",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        from pandas import Series
-
-        return Series(self._data.get_dtype_counts())
-
-    def get_ftype_counts(self):
-        """
-        Return counts of unique ftypes in this object.
-
-        .. deprecated:: 0.23.0
-
-        This is useful for SparseDataFrame or for DataFrames containing
-        sparse arrays.
-
-        Returns
-        -------
-        dtype : Series
-            Series with the count of columns with each type and
-            sparsity (dense/sparse).
-
-        See Also
-        --------
-        ftypes : Return ftypes (indication of sparse/dense and dtype) in
-            this object.
-
-        Examples
-        --------
-        >>> a = [['a', 1, 1.0], ['b', 2, 2.0], ['c', 3, 3.0]]
-        >>> df = pd.DataFrame(a, columns=['str', 'int', 'float'])
-        >>> df
-          str  int  float
-        0   a    1    1.0
-        1   b    2    2.0
-        2   c    3    3.0
-
-        >>> df.get_ftype_counts()  # doctest: +SKIP
-        float64:dense    1
-        int64:dense      1
-        object:dense     1
-        dtype: int64
-        """
-        warnings.warn(
-            "get_ftype_counts is deprecated and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        from pandas import Series
-
-        return Series(self._data.get_ftype_counts())
+        return self.values
 
     @property
     def dtypes(self):
@@ -5630,10 +5350,6 @@ def dtypes(self):
         pandas.Series
             The data type of each column.
 
-        See Also
-        --------
-        DataFrame.ftypes : Dtype and sparsity information.
-
         Examples
         --------
         >>> df = pd.DataFrame({'float': [1.0],
@@ -5651,99 +5367,7 @@ def dtypes(self):
 
         return Series(self._data.get_dtypes(), index=self._info_axis, dtype=np.object_)
 
-    @property
-    def ftypes(self):
-        """
-        Return the ftypes (indication of sparse/dense and dtype) in DataFrame.
-
-        .. deprecated:: 0.25.0
-           Use :func:`dtypes` instead.
-
-        This returns a Series with the data type of each column.
-        The result's index is the original DataFrame's columns. Columns
-        with mixed types are stored with the ``object`` dtype.  See
-        :ref:`the User Guide <basics.dtypes>` for more.
-
-        Returns
-        -------
-        pandas.Series
-            The data type and indication of sparse/dense of each column.
-
-        See Also
-        --------
-        DataFrame.dtypes: Series with just dtype information.
-        SparseDataFrame : Container for sparse tabular data.
-
-        Notes
-        -----
-        Sparse data should have the same dtypes as its dense representation.
-
-        Examples
-        --------
-        >>> arr = np.random.RandomState(0).randn(100, 4)
-        >>> arr[arr < .8] = np.nan
-        >>> pd.DataFrame(arr).ftypes
-        0    float64:dense
-        1    float64:dense
-        2    float64:dense
-        3    float64:dense
-        dtype: object
-
-        >>> pd.SparseDataFrame(arr).ftypes  # doctest: +SKIP
-        0    float64:sparse
-        1    float64:sparse
-        2    float64:sparse
-        3    float64:sparse
-        dtype: object
-        """
-        warnings.warn(
-            "DataFrame.ftypes is deprecated and will "
-            "be removed in a future version. "
-            "Use DataFrame.dtypes instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        from pandas import Series
-
-        return Series(self._data.get_ftypes(), index=self._info_axis, dtype=np.object_)
-
-    def as_blocks(self, copy=True):
-        """
-        Convert the frame to a dict of dtype -> Constructor Types that each has
-        a homogeneous dtype.
-
-        .. deprecated:: 0.21.0
-
-        NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in
-              as_matrix)
-
-        Parameters
-        ----------
-        copy : bool, default True
-
-        Returns
-        -------
-        dict
-            Mapping dtype -> Constructor Types.
-        """
-        warnings.warn(
-            "as_blocks is deprecated and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._to_dict_of_blocks(copy=copy)
-
-    @property
-    def blocks(self):
-        """
-        Internal property, property synonym for as_blocks().
-
-        .. deprecated:: 0.21.0
-        """
-        return self.as_blocks()
-
-    def _to_dict_of_blocks(self, copy=True):
+    def _to_dict_of_blocks(self, copy: bool_t = True):
         """
         Return a dict of dtype -> Constructor Types that
         each is a homogeneous dtype.
@@ -5755,7 +5379,9 @@ def _to_dict_of_blocks(self, copy=True):
             for k, v, in self._data.to_dict(copy=copy).items()
         }
 
-    def astype(self, dtype, copy=True, errors="raise", **kwargs):
+    def astype(
+        self: FrameOrSeries, dtype, copy: bool_t = True, errors: str = "raise"
+    ) -> FrameOrSeries:
         """
         Cast a pandas object to a specified dtype ``dtype``.
 
@@ -5776,10 +5402,6 @@ def astype(self, dtype, copy=True, errors="raise", **kwargs):
             - ``raise`` : allow exceptions to be raised
             - ``ignore`` : suppress exceptions. On error return original object.
 
-            .. versionadded:: 0.20.0
-
-        **kwargs : keyword arguments to pass on to the constructor
-
         Returns
         -------
         casted : same type as caller
@@ -5865,7 +5487,7 @@ def astype(self, dtype, copy=True, errors="raise", **kwargs):
                         "the key in Series dtype mappings."
                     )
                 new_type = dtype[self.name]
-                return self.astype(new_type, copy, errors, **kwargs)
+                return self.astype(new_type, copy, errors)
 
             for col_name in dtype.keys():
                 if col_name not in self:
@@ -5877,26 +5499,22 @@ def astype(self, dtype, copy=True, errors="raise", **kwargs):
             for col_name, col in self.items():
                 if col_name in dtype:
                     results.append(
-                        col.astype(
-                            dtype=dtype[col_name], copy=copy, errors=errors, **kwargs
-                        )
+                        col.astype(dtype=dtype[col_name], copy=copy, errors=errors)
                     )
                 else:
-                    results.append(results.append(col.copy() if copy else col))
+                    results.append(col.copy() if copy else col)
 
         elif is_extension_array_dtype(dtype) and self.ndim > 1:
             # GH 18099/22869: columnwise conversion to extension dtype
             # GH 24704: use iloc to handle duplicate column names
-            results = (
+            results = [
                 self.iloc[:, i].astype(dtype, copy=copy)
                 for i in range(len(self.columns))
-            )
+            ]
 
         else:
             # else, only a single dtype is given
-            new_data = self._data.astype(
-                dtype=dtype, copy=copy, errors=errors, **kwargs
-            )
+            new_data = self._data.astype(dtype=dtype, copy=copy, errors=errors)
             return self._constructor(new_data).__finalize__(self)
 
         # GH 19920: retain column metadata after concat
@@ -5904,7 +5522,7 @@ def astype(self, dtype, copy=True, errors="raise", **kwargs):
         result.columns = self.columns
         return result
 
-    def copy(self, deep=True):
+    def copy(self: FrameOrSeries, deep: bool_t = True) -> FrameOrSeries:
         """
         Make a copy of this object's indices and data.
 
@@ -6012,23 +5630,26 @@ def copy(self, deep=True):
         data = self._data.copy(deep=deep)
         return self._constructor(data).__finalize__(self)
 
-    def __copy__(self, deep=True):
+    def __copy__(self: FrameOrSeries, deep: bool_t = True) -> FrameOrSeries:
         return self.copy(deep=deep)
 
-    def __deepcopy__(self, memo=None):
+    def __deepcopy__(self: FrameOrSeries, memo=None) -> FrameOrSeries:
         """
         Parameters
         ----------
         memo, default None
             Standard signature. Unused
         """
-        if memo is None:
-            memo = {}
         return self.copy(deep=True)
 
     def _convert(
-        self, datetime=False, numeric=False, timedelta=False, coerce=False, copy=True
-    ):
+        self: FrameOrSeries,
+        datetime: bool_t = False,
+        numeric: bool_t = False,
+        timedelta: bool_t = False,
+        coerce: bool_t = False,
+        copy: bool_t = True,
+    ) -> FrameOrSeries:
         """
         Attempt to infer better dtype for object columns
 
@@ -6068,7 +5689,7 @@ def _convert(
             )
         ).__finalize__(self)
 
-    def infer_objects(self):
+    def infer_objects(self: FrameOrSeries) -> FrameOrSeries:
         """
         Attempt to infer better dtypes for object columns.
 
@@ -6088,6 +5709,7 @@ def infer_objects(self):
         to_datetime : Convert argument to datetime.
         to_timedelta : Convert argument to timedelta.
         to_numeric : Convert argument to numeric type.
+        convert_dtypes : Convert argument to best possible dtype.
 
         Examples
         --------
@@ -6116,18 +5738,154 @@ def infer_objects(self):
             )
         ).__finalize__(self)
 
+    def convert_dtypes(
+        self: FrameOrSeries,
+        infer_objects: bool_t = True,
+        convert_string: bool_t = True,
+        convert_integer: bool_t = True,
+        convert_boolean: bool_t = True,
+    ) -> FrameOrSeries:
+        """
+        Convert columns to best possible dtypes using dtypes supporting ``pd.NA``.
+
+        .. versionadded:: 1.0.0
+
+        Parameters
+        ----------
+        infer_objects : bool, default True
+            Whether object dtypes should be converted to the best possible types.
+        convert_string : bool, default True
+            Whether object dtypes should be converted to ``StringDtype()``.
+        convert_integer : bool, default True
+            Whether, if possible, conversion can be done to integer extension types.
+        convert_boolean : bool, defaults True
+            Whether object dtypes should be converted to ``BooleanDtypes()``.
+
+        Returns
+        -------
+        Series or DataFrame
+            Copy of input object with new dtype.
+
+        See Also
+        --------
+        infer_objects : Infer dtypes of objects.
+        to_datetime : Convert argument to datetime.
+        to_timedelta : Convert argument to timedelta.
+        to_numeric : Convert argument to a numeric type.
+
+        Notes
+        -----
+
+        By default, ``convert_dtypes`` will attempt to convert a Series (or each
+        Series in a DataFrame) to dtypes that support ``pd.NA``. By using the options
+        ``convert_string``, ``convert_integer``, and ``convert_boolean``, it is
+        possible to turn off individual conversions to ``StringDtype``, the integer
+        extension types or ``BooleanDtype``, respectively.
+
+        For object-dtyped columns, if ``infer_objects`` is ``True``, use the inference
+        rules as during normal Series/DataFrame construction.  Then, if possible,
+        convert to ``StringDtype``, ``BooleanDtype`` or an appropriate integer extension
+        type, otherwise leave as ``object``.
+
+        If the dtype is integer, convert to an appropriate integer extension type.
+
+        If the dtype is numeric, and consists of all integers, convert to an
+        appropriate integer extension type.
+
+        In the future, as new dtypes are added that support ``pd.NA``, the results
+        of this method will change to support those new dtypes.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame(
+        ...     {
+        ...         "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
+        ...         "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
+        ...         "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),
+        ...         "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
+        ...         "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),
+        ...         "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
+        ...     }
+        ... )
+
+        Start with a DataFrame with default dtypes.
+
+        >>> df
+           a  b      c    d     e      f
+        0  1  x   True    h  10.0    NaN
+        1  2  y  False    i   NaN  100.5
+        2  3  z    NaN  NaN  20.0  200.0
+
+        >>> df.dtypes
+        a      int32
+        b     object
+        c     object
+        d     object
+        e    float64
+        f    float64
+        dtype: object
+
+        Convert the DataFrame to use best possible dtypes.
+
+        >>> dfn = df.convert_dtypes()
+        >>> dfn
+           a  b      c     d     e      f
+        0  1  x   True     h    10    NaN
+        1  2  y  False     i  <NA>  100.5
+        2  3  z   <NA>  <NA>    20  200.0
+
+        >>> dfn.dtypes
+        a      Int32
+        b     string
+        c    boolean
+        d     string
+        e      Int64
+        f    float64
+        dtype: object
+
+        Start with a Series of strings and missing data represented by ``np.nan``.
+
+        >>> s = pd.Series(["a", "b", np.nan])
+        >>> s
+        0      a
+        1      b
+        2    NaN
+        dtype: object
+
+        Obtain a Series with dtype ``StringDtype``.
+
+        >>> s.convert_dtypes()
+        0       a
+        1       b
+        2    <NA>
+        dtype: string
+        """
+        if self.ndim == 1:
+            return self._convert_dtypes(
+                infer_objects, convert_string, convert_integer, convert_boolean
+            )
+        else:
+            results = [
+                col._convert_dtypes(
+                    infer_objects, convert_string, convert_integer, convert_boolean
+                )
+                for col_name, col in self.items()
+            ]
+            result = pd.concat(results, axis=1, copy=False)
+            return result
+
     # ----------------------------------------------------------------------
     # Filling NA's
 
     def fillna(
-        self,
+        self: FrameOrSeries,
         value=None,
         method=None,
         axis=None,
-        inplace=False,
+        inplace: bool_t = False,
         limit=None,
         downcast=None,
-    ):
+    ) -> Optional[FrameOrSeries]:
         """
         Fill NA/NaN values using the specified method.
 
@@ -6163,8 +5921,8 @@ def fillna(
 
         Returns
         -------
-        %(klass)s
-            Object with missing values filled.
+        %(klass)s or None
+            Object with missing values filled or None if ``inplace=True``.
 
         See Also
         --------
@@ -6261,16 +6019,16 @@ def fillna(
 
             if self.ndim == 1:
                 if isinstance(value, (dict, ABCSeries)):
-                    from pandas import Series
-
-                    value = Series(value)
+                    value = create_series_with_explicit_dtype(
+                        value, dtype_if_empty=object
+                    )
                 elif not is_list_like(value):
                     pass
                 else:
                     raise TypeError(
                         '"value" parameter must be a scalar, dict '
                         "or Series, but you passed a "
-                        '"{0}"'.format(type(value).__name__)
+                        f'"{type(value).__name__}"'
                     )
 
                 new_data = self._data.fillna(
@@ -6300,34 +6058,47 @@ def fillna(
             elif isinstance(value, ABCDataFrame) and self.ndim == 2:
                 new_data = self.where(self.notna(), value)
             else:
-                raise ValueError("invalid fill value with a %s" % type(value))
+                raise ValueError(f"invalid fill value with a {type(value)}")
 
         if inplace:
             self._update_inplace(new_data)
+            return None
         else:
             return self._constructor(new_data).__finalize__(self)
 
-    def ffill(self, axis=None, inplace=False, limit=None, downcast=None):
+    def ffill(
+        self: FrameOrSeries,
+        axis=None,
+        inplace: bool_t = False,
+        limit=None,
+        downcast=None,
+    ) -> Optional[FrameOrSeries]:
         """
         Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
 
         Returns
         -------
-        %(klass)s
-            Object with missing values filled.
+        %(klass)s or None
+            Object with missing values filled or None if ``inplace=True``.
         """
         return self.fillna(
             method="ffill", axis=axis, inplace=inplace, limit=limit, downcast=downcast
         )
 
-    def bfill(self, axis=None, inplace=False, limit=None, downcast=None):
+    def bfill(
+        self: FrameOrSeries,
+        axis=None,
+        inplace: bool_t = False,
+        limit=None,
+        downcast=None,
+    ) -> Optional[FrameOrSeries]:
         """
         Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
 
         Returns
         -------
-        %(klass)s
-            Object with missing values filled.
+        %(klass)s or None
+            Object with missing values filled or None if ``inplace=True``.
         """
         return self.fillna(
             method="bfill", axis=axis, inplace=inplace, limit=limit, downcast=downcast
@@ -6658,8 +6429,8 @@ def replace(
             if not is_dict_like(to_replace):
                 if not is_dict_like(regex):
                     raise TypeError(
-                        'If "to_replace" and "value" are both None'
-                        ' and "to_replace" is not a list, then '
+                        'If "to_replace" and "value" are both None '
+                        'and "to_replace" is not a list, then '
                         "regex must be a mapping"
                     )
                 to_replace = regex
@@ -6673,9 +6444,8 @@ def replace(
             if any(are_mappings):
                 if not all(are_mappings):
                     raise TypeError(
-                        "If a nested mapping is passed, all values"
-                        " of the top level mapping must be "
-                        "mappings"
+                        "If a nested mapping is passed, all values "
+                        "of the top level mapping must be mappings"
                     )
                 # passed a nested dict/Series
                 to_rep_dict = {}
@@ -6737,9 +6507,8 @@ def replace(
                 if is_list_like(value):
                     if len(to_replace) != len(value):
                         raise ValueError(
-                            "Replacement lists must match "
-                            "in length. Expecting %d got %d "
-                            % (len(to_replace), len(value))
+                            f"Replacement lists must match in length. "
+                            f"Expecting {len(to_replace)} got {len(value)} "
                         )
 
                     new_data = self._data.replace_list(
@@ -6760,11 +6529,9 @@ def replace(
                     or is_dict_like(regex)
                 ):
                     raise TypeError(
-                        "'regex' must be a string or a compiled "
-                        "regular expression or a list or dict of "
-                        "strings or regular expressions, you "
-                        "passed a"
-                        " {0!r}".format(type(regex).__name__)
+                        f"'regex' must be a string or a compiled regular expression "
+                        f"or a list or dict of strings or regular expressions, "
+                        f"you passed a {repr(type(regex).__name__)}"
                     )
                 return self.replace(
                     regex, value, inplace=inplace, limit=limit, regex=True
@@ -6790,10 +6557,9 @@ def replace(
                         to_replace=to_replace, value=value, inplace=inplace, regex=regex
                     )
                 else:
-                    msg = ('Invalid "to_replace" type: ' "{0!r}").format(
-                        type(to_replace).__name__
+                    raise TypeError(
+                        f'Invalid "to_replace" type: {repr(type(to_replace).__name__)}'
                     )
-                    raise TypeError(msg)  # pragma: no cover
 
         if inplace:
             self._update_inplace(new_data)
@@ -6883,9 +6649,9 @@ def replace(
         similar names. These use the actual numerical values of the index.
         For more information on their behavior, see the
         `SciPy documentation
-        <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__
+        <https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__
         and `SciPy tutorial
-        <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__.
+        <https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__.
 
         Examples
         --------
@@ -6993,21 +6759,22 @@ def interpolate(
         limit_direction="forward",
         limit_area=None,
         downcast=None,
-        **kwargs
+        **kwargs,
     ):
         """
         Interpolate values according to different methods.
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
 
+        axis = self._get_axis_number(axis)
+
         if axis == 0:
             ax = self._info_axis_name
             _maybe_transposed_self = self
         elif axis == 1:
             _maybe_transposed_self = self.T
             ax = 1
-        else:
-            _maybe_transposed_self = self
+
         ax = _maybe_transposed_self._get_axis_number(ax)
 
         if _maybe_transposed_self.ndim == 2:
@@ -7044,9 +6811,9 @@ def interpolate(
             if method not in methods and not is_numeric_or_datetime:
                 raise ValueError(
                     "Index column must be numeric or datetime type when "
-                    "using {method} method other than linear. "
+                    f"using {method} method other than linear. "
                     "Try setting a numeric or datetime index column before "
-                    "interpolating.".format(method=method)
+                    "interpolating."
                 )
 
         if isna(index).any():
@@ -7066,7 +6833,7 @@ def interpolate(
             limit_area=limit_area,
             inplace=inplace,
             downcast=downcast,
-            **kwargs
+            **kwargs,
         )
 
         if inplace:
@@ -7198,14 +6965,13 @@ def asof(self, where, subset=None):
         if not is_list:
             start = self.index[0]
             if isinstance(self.index, PeriodIndex):
-                where = Period(where, freq=self.index.freq).ordinal
-                start = start.ordinal
+                where = Period(where, freq=self.index.freq)
 
             if where < start:
                 if not is_series:
                     from pandas import Series
 
-                    return Series(index=self.columns, name=where)
+                    return Series(index=self.columns, name=where, dtype=np.float64)
                 return np.nan
 
             # It's always much faster to use a *while* loop here for
@@ -7244,7 +7010,7 @@ def asof(self, where, subset=None):
 
         # mask the missing
         missing = locs == -1
-        data = self.take(locs, is_copy=False)
+        data = self.take(locs)
         data.index = where
         data.loc[missing] = np.nan
         return data if is_list else data.iloc[-1]
@@ -7315,11 +7081,11 @@ def asof(self, where, subset=None):
         """
 
     @Appender(_shared_docs["isna"] % _shared_doc_kwargs)
-    def isna(self):
+    def isna(self: FrameOrSeries) -> FrameOrSeries:
         return isna(self).__finalize__(self)
 
     @Appender(_shared_docs["isna"] % _shared_doc_kwargs)
-    def isnull(self):
+    def isnull(self: FrameOrSeries) -> FrameOrSeries:
         return isna(self).__finalize__(self)
 
     _shared_docs[
@@ -7385,14 +7151,14 @@ def isnull(self):
         """
 
     @Appender(_shared_docs["notna"] % _shared_doc_kwargs)
-    def notna(self):
+    def notna(self: FrameOrSeries) -> FrameOrSeries:
         return notna(self).__finalize__(self)
 
     @Appender(_shared_docs["notna"] % _shared_doc_kwargs)
-    def notnull(self):
+    def notnull(self: FrameOrSeries) -> FrameOrSeries:
         return notna(self).__finalize__(self)
 
-    def _clip_with_scalar(self, lower, upper, inplace=False):
+    def _clip_with_scalar(self, lower, upper, inplace: bool_t = False):
         if (lower is not None and np.any(isna(lower))) or (
             upper is not None and np.any(isna(upper))
         ):
@@ -7437,10 +7203,18 @@ def _clip_with_one_bound(self, threshold, method, axis, inplace):
             if isinstance(self, ABCSeries):
                 threshold = self._constructor(threshold, index=self.index)
             else:
-                threshold = _align_method_FRAME(self, threshold, axis)
+                threshold = _align_method_FRAME(self, threshold, axis, flex=None)[1]
         return self.where(subset, threshold, axis=axis, inplace=inplace)
 
-    def clip(self, lower=None, upper=None, axis=None, inplace=False, *args, **kwargs):
+    def clip(
+        self: FrameOrSeries,
+        lower=None,
+        upper=None,
+        axis=None,
+        inplace: bool_t = False,
+        *args,
+        **kwargs,
+    ) -> FrameOrSeries:
         """
         Trim values at input threshold(s).
 
@@ -7554,222 +7328,10 @@ def clip(self, lower=None, upper=None, axis=None, inplace=False, *args, **kwargs
 
         return result
 
-    def clip_upper(self, threshold, axis=None, inplace=False):
-        """
-        Trim values above a given threshold.
-
-        .. deprecated:: 0.24.0
-            Use clip(upper=threshold) instead.
-
-        Elements above the `threshold` will be changed to match the
-        `threshold` value(s). Threshold can be a single value or an array,
-        in the latter case it performs the truncation element-wise.
-
-        Parameters
-        ----------
-        threshold : numeric or array-like
-            Maximum value allowed. All values above threshold will be set to
-            this value.
-
-            * float : every value is compared to `threshold`.
-            * array-like : The shape of `threshold` should match the object
-              it's compared to. When `self` is a Series, `threshold` should be
-              the length. When `self` is a DataFrame, `threshold` should 2-D
-              and the same shape as `self` for ``axis=None``, or 1-D and the
-              same length as the axis being compared.
-
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            Align object with `threshold` along the given axis.
-        inplace : bool, default False
-            Whether to perform the operation in place on the data.
-
-            .. versionadded:: 0.21.0
-
-        Returns
-        -------
-        Series or DataFrame
-            Original data with values trimmed.
-
-        See Also
-        --------
-        Series.clip : General purpose method to trim Series values to given
-            threshold(s).
-        DataFrame.clip : General purpose method to trim DataFrame values to
-            given threshold(s).
-
-        Examples
-        --------
-        >>> s = pd.Series([1, 2, 3, 4, 5])
-        >>> s
-        0    1
-        1    2
-        2    3
-        3    4
-        4    5
-        dtype: int64
-
-        >>> s.clip(upper=3)
-        0    1
-        1    2
-        2    3
-        3    3
-        4    3
-        dtype: int64
-
-        >>> elemwise_thresholds = [5, 4, 3, 2, 1]
-        >>> elemwise_thresholds
-        [5, 4, 3, 2, 1]
-
-        >>> s.clip(upper=elemwise_thresholds)
-        0    1
-        1    2
-        2    3
-        3    2
-        4    1
-        dtype: int64
-        """
-        warnings.warn(
-            "clip_upper(threshold) is deprecated, use clip(upper=threshold) instead",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._clip_with_one_bound(
-            threshold, method=self.le, axis=axis, inplace=inplace
-        )
-
-    def clip_lower(self, threshold, axis=None, inplace=False):
-        """
-        Trim values below a given threshold.
-
-        .. deprecated:: 0.24.0
-            Use clip(lower=threshold) instead.
-
-        Elements below the `threshold` will be changed to match the
-        `threshold` value(s). Threshold can be a single value or an array,
-        in the latter case it performs the truncation element-wise.
-
-        Parameters
-        ----------
-        threshold : numeric or array-like
-            Minimum value allowed. All values below threshold will be set to
-            this value.
-
-            * float : every value is compared to `threshold`.
-            * array-like : The shape of `threshold` should match the object
-              it's compared to. When `self` is a Series, `threshold` should be
-              the length. When `self` is a DataFrame, `threshold` should 2-D
-              and the same shape as `self` for ``axis=None``, or 1-D and the
-              same length as the axis being compared.
-
-        axis : {0 or 'index', 1 or 'columns'}, default 0
-            Align `self` with `threshold` along the given axis.
-
-        inplace : bool, default False
-            Whether to perform the operation in place on the data.
-
-            .. versionadded:: 0.21.0
-
-        Returns
-        -------
-        Series or DataFrame
-            Original data with values trimmed.
-
-        See Also
-        --------
-        Series.clip : General purpose method to trim Series values to given
-            threshold(s).
-        DataFrame.clip : General purpose method to trim DataFrame values to
-            given threshold(s).
-
-        Examples
-        --------
-
-        Series single threshold clipping:
-
-        >>> s = pd.Series([5, 6, 7, 8, 9])
-        >>> s.clip(lower=8)
-        0    8
-        1    8
-        2    8
-        3    8
-        4    9
-        dtype: int64
-
-        Series clipping element-wise using an array of thresholds. `threshold`
-        should be the same length as the Series.
-
-        >>> elemwise_thresholds = [4, 8, 7, 2, 5]
-        >>> s.clip(lower=elemwise_thresholds)
-        0    5
-        1    8
-        2    7
-        3    8
-        4    9
-        dtype: int64
-
-        DataFrames can be compared to a scalar.
-
-        >>> df = pd.DataFrame({"A": [1, 3, 5], "B": [2, 4, 6]})
-        >>> df
-           A  B
-        0  1  2
-        1  3  4
-        2  5  6
-
-        >>> df.clip(lower=3)
-           A  B
-        0  3  3
-        1  3  4
-        2  5  6
-
-        Or to an array of values. By default, `threshold` should be the same
-        shape as the DataFrame.
-
-        >>> df.clip(lower=np.array([[3, 4], [2, 2], [6, 2]]))
-           A  B
-        0  3  4
-        1  3  4
-        2  6  6
-
-        Control how `threshold` is broadcast with `axis`. In this case
-        `threshold` should be the same length as the axis specified by
-        `axis`.
-
-        >>> df.clip(lower=[3, 3, 5], axis='index')
-           A  B
-        0  3  3
-        1  3  4
-        2  5  6
-
-        >>> df.clip(lower=[4, 5], axis='columns')
-           A  B
-        0  4  5
-        1  4  5
-        2  5  6
-        """
-        warnings.warn(
-            "clip_lower(threshold) is deprecated, use clip(lower=threshold) instead",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._clip_with_one_bound(
-            threshold, method=self.ge, axis=axis, inplace=inplace
-        )
-
-    def groupby(
-        self,
-        by=None,
-        axis=0,
-        level=None,
-        as_index=True,
-        sort=True,
-        group_keys=True,
-        squeeze=False,
-        observed=False,
-        **kwargs
-    ):
-        """
-        Group DataFrame or Series using a mapper or by a Series of columns.
+    _shared_docs[
+        "groupby"
+    ] = """
+        Group %(klass)s using a mapper or by a Series of columns.
 
         A groupby operation involves some combination of splitting the
         object, applying a function, and combining the results. This can be
@@ -7812,15 +7374,10 @@ def groupby(
 
             .. versionadded:: 0.23.0
 
-        **kwargs
-            Optional, only accepts keyword argument 'mutated' and is passed
-            to groupby.
-
         Returns
         -------
-        DataFrameGroupBy or SeriesGroupBy
-            Depends on the calling object and returns groupby object that
-            contains information about the groups.
+        %(klass)sGroupBy
+            Returns a groupby object that contains information about the groups.
 
         See Also
         --------
@@ -7830,72 +7387,17 @@ def groupby(
         Notes
         -----
         See the `user guide
-        <http://pandas.pydata.org/pandas-docs/stable/groupby.html>`_ for more.
-
-        Examples
-        --------
-        >>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
-        ...                               'Parrot', 'Parrot'],
-        ...                    'Max Speed': [380., 370., 24., 26.]})
-        >>> df
-           Animal  Max Speed
-        0  Falcon      380.0
-        1  Falcon      370.0
-        2  Parrot       24.0
-        3  Parrot       26.0
-        >>> df.groupby(['Animal']).mean()
-                Max Speed
-        Animal
-        Falcon      375.0
-        Parrot       25.0
-
-        **Hierarchical Indexes**
-
-        We can groupby different levels of a hierarchical index
-        using the `level` parameter:
-
-        >>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
-        ...           ['Captive', 'Wild', 'Captive', 'Wild']]
-        >>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
-        >>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
-        ...                   index=index)
-        >>> df
-                        Max Speed
-        Animal Type
-        Falcon Captive      390.0
-               Wild         350.0
-        Parrot Captive       30.0
-               Wild          20.0
-        >>> df.groupby(level=0).mean()
-                Max Speed
-        Animal
-        Falcon      370.0
-        Parrot       25.0
-        >>> df.groupby(level=1).mean()
-                 Max Speed
-        Type
-        Captive      210.0
-        Wild         185.0
-        """
-        from pandas.core.groupby.groupby import groupby
-
-        if level is None and by is None:
-            raise TypeError("You have to supply one of 'by' and 'level'")
-        axis = self._get_axis_number(axis)
-        return groupby(
-            self,
-            by=by,
-            axis=axis,
-            level=level,
-            as_index=as_index,
-            sort=sort,
-            group_keys=group_keys,
-            squeeze=squeeze,
-            observed=observed,
-            **kwargs
-        )
+        <https://pandas.pydata.org/pandas-docs/stable/groupby.html>`_ for more.
+        """
 
-    def asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None):
+    def asfreq(
+        self: FrameOrSeries,
+        freq,
+        method=None,
+        how: Optional[str] = None,
+        normalize: bool_t = False,
+        fill_value=None,
+    ) -> FrameOrSeries:
         """
         Convert TimeSeries to specified frequency.
 
@@ -7914,17 +7416,15 @@ def asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None):
 
             * 'pad' / 'ffill': propagate last valid observation forward to next
               valid
-            * 'backfill' / 'bfill': use NEXT valid observation to fill
+            * 'backfill' / 'bfill': use NEXT valid observation to fill.
         how : {'start', 'end'}, default end
-            For PeriodIndex only, see PeriodIndex.asfreq
+            For PeriodIndex only (see PeriodIndex.asfreq).
         normalize : bool, default False
-            Whether to reset output index to midnight
+            Whether to reset output index to midnight.
         fill_value : scalar, optional
             Value to use for missing values, applied during upsampling (note
             this does not fill NaNs that already were present).
 
-            .. versionadded:: 0.20.0
-
         Returns
         -------
         converted : same type as caller
@@ -7936,7 +7436,7 @@ def asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None):
         Notes
         -----
         To learn more about the frequency strings, please see `this link
-        <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+        <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
         Examples
         --------
@@ -8000,9 +7500,11 @@ def asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None):
             fill_value=fill_value,
         )
 
-    def at_time(self, time, asof=False, axis=None):
+    def at_time(
+        self: FrameOrSeries, time, asof: bool_t = False, axis=None
+    ) -> FrameOrSeries:
         """
-        Select values at particular time of day (e.g. 9:30AM).
+        Select values at particular time of day (e.g., 9:30AM).
 
         Parameters
         ----------
@@ -8054,11 +7556,16 @@ def at_time(self, time, asof=False, axis=None):
         except AttributeError:
             raise TypeError("Index must be DatetimeIndex")
 
-        return self.take(indexer, axis=axis)
+        return self._take_with_is_copy(indexer, axis=axis)
 
     def between_time(
-        self, start_time, end_time, include_start=True, include_end=True, axis=None
-    ):
+        self: FrameOrSeries,
+        start_time,
+        end_time,
+        include_start: bool_t = True,
+        include_end: bool_t = True,
+        axis=None,
+    ) -> FrameOrSeries:
         """
         Select values between particular times of the day (e.g., 9:00-9:30 AM).
 
@@ -8131,24 +7638,21 @@ def between_time(
         except AttributeError:
             raise TypeError("Index must be DatetimeIndex")
 
-        return self.take(indexer, axis=axis)
+        return self._take_with_is_copy(indexer, axis=axis)
 
     def resample(
         self,
         rule,
-        how=None,
         axis=0,
-        fill_method=None,
-        closed=None,
-        label=None,
-        convention="start",
-        kind=None,
+        closed: Optional[str] = None,
+        label: Optional[str] = None,
+        convention: str = "start",
+        kind: Optional[str] = None,
         loffset=None,
-        limit=None,
-        base=0,
+        base: int = 0,
         on=None,
         level=None,
-    ):
+    ) -> "Resampler":
         """
         Resample time-series data.
 
@@ -8161,22 +7665,10 @@ def resample(
         ----------
         rule : DateOffset, Timedelta or str
             The offset string or object representing target conversion.
-        how : str
-            Method for down/re-sampling, default to 'mean' for downsampling.
-
-            .. deprecated:: 0.18.0
-               The new syntax is ``.resample(...).mean()``, or
-               ``.resample(...).apply(<func>)``
         axis : {0 or 'index', 1 or 'columns'}, default 0
             Which axis to use for up- or down-sampling. For `Series` this
             will default to 0, i.e. along the rows. Must be
             `DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.
-        fill_method : str, default None
-            Filling method for upsampling.
-
-            .. deprecated:: 0.18.0
-               The new syntax is ``.resample(...).<func>()``,
-               e.g. ``.resample(...).pad()``
         closed : {'right', 'left'}, default None
             Which side of bin interval is closed. The default is 'left'
             for all frequency offsets except for 'M', 'A', 'Q', 'BM',
@@ -8194,10 +7686,6 @@ def resample(
             By default the input representation is retained.
         loffset : timedelta, default None
             Adjust the resampled time labels.
-        limit : int, default None
-            Maximum size gap when reindexing with `fill_method`.
-
-            .. deprecated:: 0.18.0
         base : int, default 0
             For frequencies that evenly subdivide 1 day, the "origin" of the
             aggregated intervals. For example, for '5min' frequency, base could
@@ -8227,7 +7715,7 @@ def resample(
         for more.
 
         To learn more about the offset strings, please see `this link
-        <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects>`__.
+        <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects>`__.
 
         Examples
         --------
@@ -8429,10 +7917,10 @@ def resample(
         2000-01-04     36      90
         """
 
-        from pandas.core.resample import resample, _maybe_process_deprecations
+        from pandas.core.resample import get_resampler
 
         axis = self._get_axis_number(axis)
-        r = resample(
+        return get_resampler(
             self,
             freq=rule,
             label=label,
@@ -8445,18 +7933,14 @@ def resample(
             key=on,
             level=level,
         )
-        return _maybe_process_deprecations(
-            r, how=how, fill_method=fill_method, limit=limit
-        )
 
-    def first(self, offset):
+    def first(self: FrameOrSeries, offset) -> FrameOrSeries:
         """
-        Convenience method for subsetting initial periods of time series data
-        based on a date offset.
+        Method to subset initial periods of time series data based on a date offset.
 
         Parameters
         ----------
-        offset : string, DateOffset, dateutil.relativedelta
+        offset : str, DateOffset, dateutil.relativedelta
 
         Returns
         -------
@@ -8505,21 +7989,20 @@ def first(self, offset):
         end_date = end = self.index[0] + offset
 
         # Tick-like, e.g. 3 weeks
-        if not offset.isAnchored() and hasattr(offset, "_inc"):
+        if not offset.is_anchored() and hasattr(offset, "_inc"):
             if end_date in self.index:
                 end = self.index.searchsorted(end_date, side="left")
                 return self.iloc[:end]
 
         return self.loc[:end]
 
-    def last(self, offset):
+    def last(self: FrameOrSeries, offset) -> FrameOrSeries:
         """
-        Convenience method for subsetting final periods of time series data
-        based on a date offset.
+        Method to subset final periods of time series data based on a date offset.
 
         Parameters
         ----------
-        offset : string, DateOffset, dateutil.relativedelta
+        offset : str, DateOffset, dateutil.relativedelta
 
         Returns
         -------
@@ -8539,7 +8022,7 @@ def last(self, offset):
         Examples
         --------
         >>> i = pd.date_range('2018-04-09', periods=4, freq='2D')
-        >>> ts = pd.DataFrame({'A': [1,2,3,4]}, index=i)
+        >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
         >>> ts
                     A
         2018-04-09  1
@@ -8571,14 +8054,14 @@ def last(self, offset):
         return self.iloc[start:]
 
     def rank(
-        self,
+        self: FrameOrSeries,
         axis=0,
-        method="average",
-        numeric_only=None,
-        na_option="keep",
-        ascending=True,
-        pct=False,
-    ):
+        method: str = "average",
+        numeric_only: Optional[bool_t] = None,
+        na_option: str = "keep",
+        ascending: bool_t = True,
+        pct: bool_t = False,
+    ) -> FrameOrSeries:
         """
         Compute numerical data ranks (1 through n) along axis.
 
@@ -8590,14 +8073,14 @@ def rank(
         axis : {0 or 'index', 1 or 'columns'}, default 0
             Index to direct ranking.
         method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
-            How to rank the group of records that have the same value
-            (i.e. ties):
+            How to rank the group of records that have the same value (i.e. ties):
 
             * average: average rank of the group
             * min: lowest rank in the group
             * max: highest rank in the group
             * first: ranks assigned in order they appear in the array
-            * dense: like 'min', but rank always increases by 1 between groups
+            * dense: like 'min', but rank always increases by 1 between groups.
+
         numeric_only : bool, optional
             For DataFrame objects, rank only numeric columns if set to True.
         na_option : {'keep', 'top', 'bottom'}, default 'keep'
@@ -8605,7 +8088,8 @@ def rank(
 
             * keep: assign NaN rank to NaN values
             * top: assign smallest rank to NaN values if ascending
-            * bottom: assign highest rank to NaN values if ascending
+            * bottom: assign highest rank to NaN values if ascending.
+
         ascending : bool, default True
             Whether or not the elements should be ranked in ascending order.
         pct : bool, default False
@@ -8696,28 +8180,31 @@ def ranker(data):
     _shared_docs[
         "align"
     ] = """
-        Align two objects on their axes with the
-        specified join method for each axis Index.
+        Align two objects on their axes with the specified join method.
+
+        Join method is specified for each axis Index.
 
         Parameters
         ----------
         other : DataFrame or Series
         join : {'outer', 'inner', 'left', 'right'}, default 'outer'
         axis : allowed axis of the other object, default None
-            Align on index (0), columns (1), or both (None)
+            Align on index (0), columns (1), or both (None).
         level : int or level name, default None
             Broadcast across a level, matching Index values on the
-            passed MultiIndex level
+            passed MultiIndex level.
         copy : bool, default True
             Always returns new objects. If copy=False and no reindexing is
             required then original objects are returned.
         fill_value : scalar, default np.NaN
             Value to use for missing values. Defaults to NaN, but can be any
-            "compatible" value
+            "compatible" value.
         method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
-            Method to use for filling holes in reindexed Series
-            pad / ffill: propagate last valid observation forward to next valid
-            backfill / bfill: use NEXT valid observation to fill gap
+            Method to use for filling holes in reindexed Series:
+
+            - pad / ffill: propagate last valid observation forward to next valid.
+            - backfill / bfill: use NEXT valid observation to fill gap.
+
         limit : int, default None
             If method is specified, this is the maximum number of consecutive
             NaN values to forward/backward fill. In other words, if there is
@@ -8726,10 +8213,10 @@ def ranker(data):
             maximum number of entries along the entire axis where NaNs will be
             filled. Must be greater than 0 if not None.
         fill_axis : %(axes_single_arg)s, default 0
-            Filling axis, method and limit
+            Filling axis, method and limit.
         broadcast_axis : %(axes_single_arg)s, default None
             Broadcast values along this axis, if aligning two objects of
-            different dimensions
+            different dimensions.
 
         Returns
         -------
@@ -8818,7 +8305,7 @@ def align(
                 fill_axis=fill_axis,
             )
         else:  # pragma: no cover
-            raise TypeError("unsupported type: %s" % type(other))
+            raise TypeError(f"unsupported type: {type(other)}")
 
     def _align_frame(
         self,
@@ -8826,7 +8313,7 @@ def _align_frame(
         join="outer",
         axis=None,
         level=None,
-        copy=True,
+        copy: bool_t = True,
         fill_value=None,
         method=None,
         limit=None,
@@ -8868,8 +8355,10 @@ def _align_frame(
         )
 
         if method is not None:
-            left = left.fillna(axis=fill_axis, method=method, limit=limit)
-            right = right.fillna(axis=fill_axis, method=method, limit=limit)
+            left = self._ensure_type(
+                left.fillna(method=method, axis=fill_axis, limit=limit)
+            )
+            right = right.fillna(method=method, axis=fill_axis, limit=limit)
 
         # if DatetimeIndex have different tz, convert to UTC
         if is_datetime64tz_dtype(left.index):
@@ -8886,7 +8375,7 @@ def _align_series(
         join="outer",
         axis=None,
         level=None,
-        copy=True,
+        copy: bool_t = True,
         fill_value=None,
         method=None,
         limit=None,
@@ -9050,23 +8539,9 @@ def _where(
 
                         # try to not change dtype at first (if try_quick)
                         if try_quick:
-
-                            try:
-                                new_other = com.values_from_object(self)
-                                new_other = new_other.copy()
-                                new_other[icond] = other
-                                other = new_other
-                            except Exception:
-                                try_quick = False
-
-                        # let's create a new (if we failed at the above
-                        # or not try_quick
-                        if not try_quick:
-
-                            dtype, fill_value = maybe_promote(other.dtype)
-                            new_other = np.empty(len(icond), dtype=dtype)
-                            new_other.fill(fill_value)
-                            maybe_upcast_putmask(new_other, icond, other)
+                            new_other = com.values_from_object(self)
+                            new_other = new_other.copy()
+                            new_other[icond] = other
                             other = new_other
 
                     else:
@@ -9127,7 +8602,7 @@ def _where(
 
         Parameters
         ----------
-        cond : boolean %(klass)s, array-like, or callable
+        cond : bool %(klass)s, array-like, or callable
             Where `cond` is %(cond)s, keep the original value. Where
             %(cond_rev)s, replace with corresponding value from `other`.
             If `cond` is callable, it is computed on the %(klass)s and
@@ -9376,7 +8851,9 @@ def mask(
     """
 
     @Appender(_shared_docs["shift"] % _shared_doc_kwargs)
-    def shift(self, periods=1, freq=None, axis=0, fill_value=None):
+    def shift(
+        self: FrameOrSeries, periods=1, freq=None, axis=0, fill_value=None
+    ) -> FrameOrSeries:
         if periods == 0:
             return self.copy()
 
@@ -9390,16 +8867,17 @@ def shift(self, periods=1, freq=None, axis=0, fill_value=None):
 
         return self._constructor(new_data).__finalize__(self)
 
-    def slice_shift(self, periods=1, axis=0):
+    def slice_shift(self: FrameOrSeries, periods: int = 1, axis=0) -> FrameOrSeries:
         """
-        Equivalent to `shift` without copying data. The shifted data will
-        not include the dropped periods and the shifted axis will be smaller
-        than the original.
+        Equivalent to `shift` without copying data.
+
+        The shifted data will not include the dropped periods and the
+        shifted axis will be smaller than the original.
 
         Parameters
         ----------
         periods : int
-            Number of periods to move, can be positive or negative
+            Number of periods to move, can be positive or negative.
 
         Returns
         -------
@@ -9426,18 +8904,21 @@ def slice_shift(self, periods=1, axis=0):
 
         return new_obj.__finalize__(self)
 
-    def tshift(self, periods=1, freq=None, axis=0):
+    def tshift(
+        self: FrameOrSeries, periods: int = 1, freq=None, axis=0
+    ) -> FrameOrSeries:
         """
         Shift the time index, using the index's frequency if available.
 
         Parameters
         ----------
         periods : int
-            Number of periods to move, can be positive or negative
-        freq : DateOffset, timedelta, or time rule string, default None
-            Increment to use from the tseries module or time rule (e.g. 'EOM')
-        axis : int or basestring
-            Corresponds to the axis that contains the Index
+            Number of periods to move, can be positive or negative.
+        freq : DateOffset, timedelta, or str, default None
+            Increment to use from the tseries module
+            or time rule expressed as a string (e.g. 'EOM').
+        axis : {0 or ‘index’, 1 or ‘columns’, None}, default 0
+            Corresponds to the axis that contains the Index.
 
         Returns
         -------
@@ -9473,19 +8954,20 @@ def tshift(self, periods=1, freq=None, axis=0):
             if freq == orig_freq:
                 new_data = self._data.copy()
                 new_data.axes[block_axis] = index.shift(periods)
-            else:
-                msg = "Given freq %s does not match PeriodIndex freq %s" % (
-                    freq.rule_code,
-                    orig_freq.rule_code,
+            elif orig_freq is not None:
+                raise ValueError(
+                    f"Given freq {freq.rule_code} does not match "
+                    f"PeriodIndex freq {orig_freq.rule_code}"
                 )
-                raise ValueError(msg)
         else:
             new_data = self._data.copy()
             new_data.axes[block_axis] = index.shift(periods, freq)
 
         return self._constructor(new_data).__finalize__(self)
 
-    def truncate(self, before=None, after=None, axis=None, copy=True):
+    def truncate(
+        self: FrameOrSeries, before=None, after=None, axis=None, copy: bool_t = True
+    ) -> FrameOrSeries:
         """
         Truncate a Series or DataFrame before and after some index value.
 
@@ -9494,9 +8976,9 @@ def truncate(self, before=None, after=None, axis=None, copy=True):
 
         Parameters
         ----------
-        before : date, string, int
+        before : date, str, int
             Truncate all rows before this index value.
-        after : date, string, int
+        after : date, str, int
             Truncate all rows after this index value.
         axis : {0 or 'index', 1 or 'columns'}, optional
             Axis to truncate. Truncates the index (rows) by default.
@@ -9524,7 +9006,7 @@ def truncate(self, before=None, after=None, axis=None, copy=True):
         >>> df = pd.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],
         ...                    'B': ['f', 'g', 'h', 'i', 'j'],
         ...                    'C': ['k', 'l', 'm', 'n', 'o']},
-        ...                    index=[1, 2, 3, 4, 5])
+        ...                   index=[1, 2, 3, 4, 5])
         >>> df
            A  B  C
         1  a  f  k
@@ -9603,7 +9085,6 @@ def truncate(self, before=None, after=None, axis=None, copy=True):
         2016-01-10 23:59:58  1
         2016-01-10 23:59:59  1
         """
-
         if axis is None:
             axis = self._stat_axis_number
         axis = self._get_axis_number(axis)
@@ -9624,7 +9105,7 @@ def truncate(self, before=None, after=None, axis=None, copy=True):
 
         if before is not None and after is not None:
             if before > after:
-                raise ValueError("Truncate: %s must be after %s" % (after, before))
+                raise ValueError(f"Truncate: {after} must be after {before}")
 
         slicer = [slice(None, None)] * self._AXIS_LEN
         slicer[axis] = slice(before, after)
@@ -9638,7 +9119,9 @@ def truncate(self, before=None, after=None, axis=None, copy=True):
 
         return result
 
-    def tz_convert(self, tz, axis=0, level=None, copy=True):
+    def tz_convert(
+        self: FrameOrSeries, tz, axis=0, level=None, copy: bool_t = True
+    ) -> FrameOrSeries:
         """
         Convert tz-aware axis to target time zone.
 
@@ -9670,7 +9153,7 @@ def _tz_convert(ax, tz):
                 if len(ax) > 0:
                     ax_name = self._get_axis_name(axis)
                     raise TypeError(
-                        "%s is not a valid DatetimeIndex or PeriodIndex" % ax_name
+                        f"{ax_name} is not a valid DatetimeIndex or PeriodIndex"
                     )
                 else:
                     ax = DatetimeIndex([], tz=tz)
@@ -9686,7 +9169,7 @@ def _tz_convert(ax, tz):
             ax = ax.set_levels(new_level, level=level)
         else:
             if level not in (None, 0, ax.name):
-                raise ValueError("The level {0} is not valid".format(level))
+                raise ValueError(f"The level {level} is not valid")
             ax = _tz_convert(ax, tz)
 
         result = self._constructor(self._data, copy=copy)
@@ -9694,8 +9177,14 @@ def _tz_convert(ax, tz):
         return result.__finalize__(self)
 
     def tz_localize(
-        self, tz, axis=0, level=None, copy=True, ambiguous="raise", nonexistent="raise"
-    ):
+        self: FrameOrSeries,
+        tz,
+        axis=0,
+        level=None,
+        copy: bool_t = True,
+        ambiguous="raise",
+        nonexistent: str = "raise",
+    ) -> FrameOrSeries:
         """
         Localize tz-naive index of a Series or DataFrame to target time zone.
 
@@ -9708,9 +9197,9 @@ def tz_localize(
         axis : the axis to localize
         level : int, str, default None
             If axis ia a MultiIndex, localize a specific level. Otherwise
-            must be None
+            must be None.
         copy : bool, default True
-            Also make a copy of the underlying data
+            Also make a copy of the underlying data.
         ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
             When clocks moved backward due to DST, ambiguous times may arise.
             For example in Central European Time (UTC+01), when going from
@@ -9726,7 +9215,7 @@ def tz_localize(
               ambiguous times)
             - 'NaT' will return NaT where there are ambiguous times
             - 'raise' will raise an AmbiguousTimeError if there are ambiguous
-              times
+              times.
         nonexistent : str, default 'raise'
             A nonexistent time does not exist in a particular timezone
             where clocks moved forward due to DST. Valid values are:
@@ -9738,7 +9227,7 @@ def tz_localize(
             - 'NaT' will return NaT where there are nonexistent times
             - timedelta objects will shift nonexistent times by the timedelta
             - 'raise' will raise an NonExistentTimeError if there are
-              nonexistent times
+              nonexistent times.
 
             .. versionadded:: 0.24.0
 
@@ -9758,7 +9247,7 @@ def tz_localize(
         Localize local times:
 
         >>> s = pd.Series([1],
-        ... index=pd.DatetimeIndex(['2018-09-15 01:30:00']))
+        ...               index=pd.DatetimeIndex(['2018-09-15 01:30:00']))
         >>> s.tz_localize('CET')
         2018-09-15 01:30:00+02:00    1
         dtype: int64
@@ -9766,14 +9255,14 @@ def tz_localize(
         Be careful with DST changes. When there is sequential data, pandas
         can infer the DST time:
 
-        >>> s = pd.Series(range(7), index=pd.DatetimeIndex([
-        ... '2018-10-28 01:30:00',
-        ... '2018-10-28 02:00:00',
-        ... '2018-10-28 02:30:00',
-        ... '2018-10-28 02:00:00',
-        ... '2018-10-28 02:30:00',
-        ... '2018-10-28 03:00:00',
-        ... '2018-10-28 03:30:00']))
+        >>> s = pd.Series(range(7),
+        ...               index=pd.DatetimeIndex(['2018-10-28 01:30:00',
+        ...                                       '2018-10-28 02:00:00',
+        ...                                       '2018-10-28 02:30:00',
+        ...                                       '2018-10-28 02:00:00',
+        ...                                       '2018-10-28 02:30:00',
+        ...                                       '2018-10-28 03:00:00',
+        ...                                       '2018-10-28 03:30:00']))
         >>> s.tz_localize('CET', ambiguous='infer')
         2018-10-28 01:30:00+02:00    0
         2018-10-28 02:00:00+02:00    1
@@ -9787,10 +9276,10 @@ def tz_localize(
         In some cases, inferring the DST is impossible. In such cases, you can
         pass an ndarray to the ambiguous parameter to set the DST explicitly
 
-        >>> s = pd.Series(range(3), index=pd.DatetimeIndex([
-        ... '2018-10-28 01:20:00',
-        ... '2018-10-28 02:36:00',
-        ... '2018-10-28 03:46:00']))
+        >>> s = pd.Series(range(3),
+        ...               index=pd.DatetimeIndex(['2018-10-28 01:20:00',
+        ...                                       '2018-10-28 02:36:00',
+        ...                                       '2018-10-28 03:46:00']))
         >>> s.tz_localize('CET', ambiguous=np.array([True, True, False]))
         2018-10-28 01:20:00+02:00    0
         2018-10-28 02:36:00+02:00    1
@@ -9800,9 +9289,9 @@ def tz_localize(
         If the DST transition causes nonexistent times, you can shift these
         dates forward or backwards with a timedelta object or `'shift_forward'`
         or `'shift_backwards'`.
-        >>> s = pd.Series(range(2), index=pd.DatetimeIndex([
-        ... '2015-03-29 02:30:00',
-        ... '2015-03-29 03:30:00']))
+        >>> s = pd.Series(range(2),
+        ...               index=pd.DatetimeIndex(['2015-03-29 02:30:00',
+        ...                                       '2015-03-29 03:30:00']))
         >>> s.tz_localize('Europe/Warsaw', nonexistent='shift_forward')
         2015-03-29 03:00:00+02:00    0
         2015-03-29 03:30:00+02:00    1
@@ -9821,9 +9310,9 @@ def tz_localize(
             nonexistent, timedelta
         ):
             raise ValueError(
-                "The nonexistent argument must be one of 'raise',"
-                " 'NaT', 'shift_forward', 'shift_backward' or"
-                " a timedelta object"
+                "The nonexistent argument must be one of 'raise', "
+                "'NaT', 'shift_forward', 'shift_backward' or "
+                "a timedelta object"
             )
 
         axis = self._get_axis_number(axis)
@@ -9834,7 +9323,7 @@ def _tz_localize(ax, tz, ambiguous, nonexistent):
                 if len(ax) > 0:
                     ax_name = self._get_axis_name(axis)
                     raise TypeError(
-                        "%s is not a valid DatetimeIndex or PeriodIndex" % ax_name
+                        f"{ax_name} is not a valid DatetimeIndex or PeriodIndex"
                     )
                 else:
                     ax = DatetimeIndex([], tz=tz)
@@ -9850,7 +9339,7 @@ def _tz_localize(ax, tz, ambiguous, nonexistent):
             ax = ax.set_levels(new_level, level=level)
         else:
             if level not in (None, 0, ax.name):
-                raise ValueError("The level {0} is not valid".format(level))
+                raise ValueError(f"The level {level} is not valid")
             ax = _tz_localize(ax, tz, ambiguous, nonexistent)
 
         result = self._constructor(self._data, copy=copy)
@@ -9859,7 +9348,7 @@ def _tz_localize(ax, tz, ambiguous, nonexistent):
 
     # ----------------------------------------------------------------------
     # Numeric Methods
-    def abs(self):
+    def abs(self: FrameOrSeries) -> FrameOrSeries:
         """
         Return a Series/DataFrame with absolute numeric value of each element.
 
@@ -9928,11 +9417,15 @@ def abs(self):
         """
         return np.abs(self)
 
-    def describe(self, percentiles=None, include=None, exclude=None):
+    def describe(
+        self: FrameOrSeries, percentiles=None, include=None, exclude=None
+    ) -> FrameOrSeries:
         """
-        Generate descriptive statistics that summarize the central tendency,
-        dispersion and shape of a dataset's distribution, excluding
-        ``NaN`` values.
+        Generate descriptive statistics.
+
+        Descriptive statistics include those that summarize the central
+        tendency, dispersion and shape of a
+        dataset's distribution, excluding ``NaN`` values.
 
         Analyzes both numeric and object series, as well
         as ``DataFrame`` column sets of mixed data types. The output
@@ -10169,7 +9662,7 @@ def describe(self, percentiles=None, include=None, exclude=None):
             percentiles = list(percentiles)
 
             # get them all to be in [0, 1]
-            self._check_percentile(percentiles)
+            validate_percentile(percentiles)
 
             # median should always be included
             if 0.5 not in percentiles:
@@ -10205,26 +9698,8 @@ def describe_categorical_1d(data):
             dtype = None
             if result[1] > 0:
                 top, freq = objcounts.index[0], objcounts.iloc[0]
-
-                if is_datetime64_any_dtype(data):
-                    tz = data.dt.tz
-                    asint = data.dropna().values.view("i8")
-                    top = Timestamp(top)
-                    if top.tzinfo is not None and tz is not None:
-                        # Don't tz_localize(None) if key is already tz-aware
-                        top = top.tz_convert(tz)
-                    else:
-                        top = top.tz_localize(tz)
-                    names += ["top", "freq", "first", "last"]
-                    result += [
-                        top,
-                        freq,
-                        Timestamp(asint.min(), tz=tz),
-                        Timestamp(asint.max(), tz=tz),
-                    ]
-                else:
-                    names += ["top", "freq"]
-                    result += [top, freq]
+                names += ["top", "freq"]
+                result += [top, freq]
 
             # If the DataFrame is empty, set 'top' and 'freq' to None
             # to maintain output shape consistency
@@ -10235,11 +9710,23 @@ def describe_categorical_1d(data):
 
             return pd.Series(result, index=names, name=data.name, dtype=dtype)
 
+        def describe_timestamp_1d(data):
+            # GH-30164
+            stat_index = ["count", "mean", "min"] + formatted_percentiles + ["max"]
+            d = (
+                [data.count(), data.mean(), data.min()]
+                + data.quantile(percentiles).tolist()
+                + [data.max()]
+            )
+            return pd.Series(d, index=stat_index, name=data.name)
+
         def describe_1d(data):
             if is_bool_dtype(data):
                 return describe_categorical_1d(data)
             elif is_numeric_dtype(data):
                 return describe_numeric_1d(data)
+            elif is_datetime64_any_dtype(data):
+                return describe_timestamp_1d(data)
             elif is_timedelta64_dtype(data):
                 return describe_numeric_1d(data)
             else:
@@ -10262,7 +9749,7 @@ def describe_1d(data):
 
         ldesc = [describe_1d(s) for _, s in data.items()]
         # set a convenient order for rows
-        names = []
+        names: List[Optional[Hashable]] = []
         ldesc_indexes = sorted((x.index for x in ldesc), key=len)
         for idxnames in ldesc_indexes:
             for name in idxnames:
@@ -10273,21 +9760,6 @@ def describe_1d(data):
         d.columns = data.columns.copy()
         return d
 
-    def _check_percentile(self, q):
-        """
-        Validate percentiles (used by describe and quantile).
-        """
-
-        msg = "percentiles should all be in the interval [0, 1]. Try {0} instead."
-        q = np.asarray(q)
-        if q.ndim == 0:
-            if not 0 <= q <= 1:
-                raise ValueError(msg.format(q / 100.0))
-        else:
-            if not all(0 <= qs <= 1 for qs in q):
-                raise ValueError(msg.format(q / 100.0))
-        return q
-
     _shared_docs[
         "pct_change"
     ] = """
@@ -10305,7 +9777,7 @@ def _check_percentile(self, q):
             How to handle NAs before computing percent changes.
         limit : int, default None
             The number of consecutive NAs to fill before stopping.
-        freq : DateOffset, timedelta, or offset alias string, optional
+        freq : DateOffset, timedelta, or str, optional
             Increment to use from time series API (e.g. 'M' or BDay()).
         **kwargs
             Additional keyword arguments are passed into
@@ -10406,19 +9878,29 @@ def _check_percentile(self, q):
         """
 
     @Appender(_shared_docs["pct_change"] % _shared_doc_kwargs)
-    def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None, **kwargs):
+    def pct_change(
+        self: FrameOrSeries,
+        periods=1,
+        fill_method="pad",
+        limit=None,
+        freq=None,
+        **kwargs,
+    ) -> FrameOrSeries:
         # TODO: Not sure if above is correct - need someone to confirm.
         axis = self._get_axis_number(kwargs.pop("axis", self._stat_axis_name))
         if fill_method is None:
             data = self
         else:
-            data = self.fillna(method=fill_method, limit=limit, axis=axis)
+            data = self._ensure_type(
+                self.fillna(method=fill_method, axis=axis, limit=limit)
+            )
 
         rs = data.div(data.shift(periods=periods, freq=freq, axis=axis, **kwargs)) - 1
-        rs = rs.reindex_like(data)
-        if freq is None:
-            mask = isna(com.values_from_object(data))
-            np.putmask(rs.values, mask, np.nan)
+        if freq is not None:
+            # Shift method is implemented differently when freq is not None
+            # We want to restore the original index
+            rs = rs.loc[~rs.index.duplicated()]
+            rs = rs.reindex_like(data)
         return rs
 
     def _agg_by_level(self, name, axis=0, level=0, skipna=True, **kwargs):
@@ -10475,7 +9957,7 @@ def _add_numeric_operations(cls):
             see_also="",
             examples="",
         )
-        @Appender(_num_doc)
+        @Appender(_num_doc_mad)
         def mad(self, axis=None, skipna=None, level=None):
             if skipna is None:
                 skipna = True
@@ -10526,29 +10008,6 @@ def mad(self, axis=None, skipna=None, level=None):
             nanops.nanstd,
         )
 
-        @Substitution(
-            desc="Return the compound percentage of the values for "
-            "the requested axis.\n\n.. deprecated:: 0.25.0",
-            name1=name,
-            name2=name2,
-            axis_descr=axis_descr,
-            min_count="",
-            see_also="",
-            examples="",
-        )
-        @Appender(_num_doc)
-        def compound(self, axis=None, skipna=None, level=None):
-            msg = (
-                "The 'compound' method is deprecated and will be"
-                "removed in a future version."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=2)
-            if skipna is None:
-                skipna = True
-            return (1 + self).prod(axis=axis, skipna=skipna, level=level) - 1
-
-        cls.compound = compound
-
         cls.cummin = _make_cum_function(
             cls,
             "cummin",
@@ -10556,7 +10015,7 @@ def compound(self, axis=None, skipna=None, level=None):
             name2,
             axis_descr,
             "minimum",
-            lambda y, axis: np.minimum.accumulate(y, axis),
+            np.minimum.accumulate,
             "min",
             np.inf,
             np.nan,
@@ -10569,7 +10028,7 @@ def compound(self, axis=None, skipna=None, level=None):
             name2,
             axis_descr,
             "sum",
-            lambda y, axis: y.cumsum(axis),
+            np.cumsum,
             "sum",
             0.0,
             np.nan,
@@ -10582,7 +10041,7 @@ def compound(self, axis=None, skipna=None, level=None):
             name2,
             axis_descr,
             "product",
-            lambda y, axis: y.cumprod(axis),
+            np.cumprod,
             "prod",
             1.0,
             np.nan,
@@ -10595,7 +10054,7 @@ def compound(self, axis=None, skipna=None, level=None):
             name2,
             axis_descr,
             "maximum",
-            lambda y, axis: np.maximum.accumulate(y, axis),
+            np.maximum.accumulate,
             "max",
             -np.inf,
             np.nan,
@@ -10629,7 +10088,7 @@ def compound(self, axis=None, skipna=None, level=None):
             name,
             name2,
             axis_descr,
-            "Return unbiased skew over requested axis\nNormalized by N-1.",
+            "Return unbiased skew over requested axis.\n\nNormalized by N-1.",
             nanops.nanskew,
         )
         cls.kurt = _make_stat_function(
@@ -10638,8 +10097,9 @@ def compound(self, axis=None, skipna=None, level=None):
             name,
             name2,
             axis_descr,
-            "Return unbiased kurtosis over requested axis using Fisher's "
-            "definition of\nkurtosis (kurtosis of normal == 0.0). Normalized "
+            "Return unbiased kurtosis over requested axis.\n\n"
+            "Kurtosis obtained using Fisher's definition of\n"
+            "kurtosis (kurtosis of normal == 0.0). Normalized "
             "by N-1.",
             nanops.nankurt,
         )
@@ -10691,39 +10151,6 @@ def compound(self, axis=None, skipna=None, level=None):
             _min_examples,
         )
 
-    @classmethod
-    def _add_series_only_operations(cls):
-        """
-        Add the series only operations to the cls; evaluate the doc
-        strings again.
-        """
-
-        axis_descr, name, name2 = _doc_parms(cls)
-
-        def nanptp(values, axis=0, skipna=True):
-            nmax = nanops.nanmax(values, axis, skipna)
-            nmin = nanops.nanmin(values, axis, skipna)
-            warnings.warn(
-                "Method .ptp is deprecated and will be removed "
-                "in a future version. Use numpy.ptp instead.",
-                FutureWarning,
-                stacklevel=4,
-            )
-            return nmax - nmin
-
-        cls.ptp = _make_stat_function(
-            cls,
-            "ptp",
-            name,
-            name2,
-            axis_descr,
-            """Return the difference between the maximum value and the
-            minimum value in the object. This is the equivalent of the
-            ``numpy.ndarray`` method ``ptp``.\n\n.. deprecated:: 0.24.0
-                Use numpy.ptp instead""",
-            nanptp,
-        )
-
     @classmethod
     def _add_series_or_dataframe_operations(cls):
         """
@@ -10831,7 +10258,7 @@ def transform(self, func, *args, **kwargs):
         Also returns None for empty %(klass)s.
         """
 
-    def _find_valid_index(self, how):
+    def _find_valid_index(self, how: str):
         """
         Retrieves the index of the first valid value.
 
@@ -10844,27 +10271,11 @@ def _find_valid_index(self, how):
         -------
         idx_first_valid : type of index
         """
-        assert how in ["first", "last"]
-
-        if len(self) == 0:  # early stop
-            return None
-        is_valid = ~self.isna()
-
-        if self.ndim == 2:
-            is_valid = is_valid.any(1)  # reduce axis 1
-
-        if how == "first":
-            idxpos = is_valid.values[::].argmax()
 
-        if how == "last":
-            idxpos = len(self) - 1 - is_valid.values[::-1].argmax()
-
-        chk_notna = is_valid.iat[idxpos]
-        idx = self.index[idxpos]
-
-        if not chk_notna:
+        idxpos = find_valid_index(self._values, how)
+        if idxpos is None:
             return None
-        return idx
+        return self.index[idxpos]
 
     @Appender(
         _shared_docs["valid_index"] % {"position": "first", "klass": "Series/DataFrame"}
@@ -10881,8 +10292,8 @@ def last_valid_index(self):
 
 def _doc_parms(cls):
     """Return a tuple of the doc parms."""
-    axis_descr = "{%s}" % ", ".join(
-        "{0} ({1})".format(a, i) for i, a in enumerate(cls._AXIS_ORDERS)
+    axis_descr = (
+        f"{{{', '.join(f'{a} ({i})' for i, a in enumerate(cls._AXIS_ORDERS))}}}"
     )
     name = cls._constructor_sliced.__name__ if cls._AXIS_LEN > 1 else "scalar"
     name2 = cls.__name__
@@ -10915,6 +10326,26 @@ def _doc_parms(cls):
 %(examples)s
 """
 
+_num_doc_mad = """
+%(desc)s
+
+Parameters
+----------
+axis : %(axis_descr)s
+    Axis for the function to be applied on.
+skipna : bool, default None
+    Exclude NA/null values when computing the result.
+level : int or level name, default None
+    If the axis is a MultiIndex (hierarchical), count along a
+    particular level, collapsing into a %(name1)s.
+
+Returns
+-------
+%(name1)s or %(name2)s (if level specified)\
+%(see_also)s\
+%(examples)s
+"""
+
 _num_ddof_doc = """
 %(desc)s
 
@@ -10923,10 +10354,10 @@ def _doc_parms(cls):
 axis : %(axis_descr)s
 skipna : bool, default True
     Exclude NA/null values. If an entire row/column is NA, the result
-    will be NA
+    will be NA.
 level : int or level name, default None
     If the axis is a MultiIndex (hierarchical), count along a
-    particular level, collapsing into a %(name1)s
+    particular level, collapsing into a %(name1)s.
 ddof : int, default 1
     Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
     where N represents the number of elements.
@@ -11539,7 +10970,7 @@ def _doc_parms(cls):
 
 
 def _make_min_count_stat_function(
-    cls, name, name1, name2, axis_descr, desc, f, see_also="", examples=""
+    cls, name, name1, name2, axis_descr, desc, f, see_also: str = "", examples: str = ""
 ):
     @Substitution(
         desc=desc,
@@ -11558,7 +10989,7 @@ def stat_func(
         level=None,
         numeric_only=None,
         min_count=0,
-        **kwargs
+        **kwargs,
     ):
         if name == "sum":
             nv.validate_sum(tuple(), kwargs)
@@ -11587,7 +11018,7 @@ def stat_func(
 
 
 def _make_stat_function(
-    cls, name, name1, name2, axis_descr, desc, f, see_also="", examples=""
+    cls, name, name1, name2, axis_descr, desc, f, see_also: str = "", examples: str = ""
 ):
     @Substitution(
         desc=desc,
@@ -11670,19 +11101,64 @@ def cum_func(self, axis=None, skipna=True, *args, **kwargs):
         else:
             axis = self._get_axis_number(axis)
 
-        y = com.values_from_object(self).copy()
-
-        if skipna and issubclass(y.dtype.type, (np.datetime64, np.timedelta64)):
-            result = accum_func(y, axis)
-            mask = isna(self)
-            np.putmask(result, mask, iNaT)
-        elif skipna and not issubclass(y.dtype.type, (np.integer, np.bool_)):
-            mask = isna(self)
-            np.putmask(y, mask, mask_a)
-            result = accum_func(y, axis)
-            np.putmask(result, mask, mask_b)
-        else:
-            result = accum_func(y, axis)
+        if axis == 1:
+            return cum_func(self.T, axis=0, skipna=skipna, *args, **kwargs).T
+
+        def na_accum_func(blk_values):
+            # We will be applying this function to block values
+            if blk_values.dtype.kind in ["m", "M"]:
+                # GH#30460, GH#29058
+                # numpy 1.18 started sorting NaTs at the end instead of beginning,
+                #  so we need to work around to maintain backwards-consistency.
+                orig_dtype = blk_values.dtype
+
+                # We need to define mask before masking NaTs
+                mask = isna(blk_values)
+
+                if accum_func == np.minimum.accumulate:
+                    # Note: the accum_func comparison fails as an "is" comparison
+                    y = blk_values.view("i8")
+                    y[mask] = np.iinfo(np.int64).max
+                    changed = True
+                else:
+                    y = blk_values
+                    changed = False
+
+                result = accum_func(y.view("i8"), axis)
+                if skipna:
+                    np.putmask(result, mask, iNaT)
+                elif accum_func == np.minimum.accumulate:
+                    # Restore NaTs that we masked previously
+                    nz = (~np.asarray(mask)).nonzero()[0]
+                    if len(nz):
+                        # everything up to the first non-na entry stays NaT
+                        result[: nz[0]] = iNaT
+
+                if changed:
+                    # restore NaT elements
+                    y[mask] = iNaT  # TODO: could try/finally for this?
+
+                if isinstance(blk_values, np.ndarray):
+                    result = result.view(orig_dtype)
+                else:
+                    # DatetimeArray
+                    result = type(blk_values)._from_sequence(result, dtype=orig_dtype)
+
+            elif skipna and not issubclass(
+                blk_values.dtype.type, (np.integer, np.bool_)
+            ):
+                vals = blk_values.copy().T
+                mask = isna(vals)
+                np.putmask(vals, mask, mask_a)
+                result = accum_func(vals, axis)
+                np.putmask(result, mask, mask_b)
+            else:
+                result = accum_func(blk_values.T, axis)
+
+            # transpose back for ndarray, not for EA
+            return result.T if hasattr(result, "T") else result
+
+        result = self._data.apply(na_accum_func)
 
         d = self._construct_axes_dict()
         d["copy"] = False
@@ -11722,8 +11198,3 @@ def logical_func(self, axis=0, bool_only=None, skipna=True, level=None, **kwargs
         )
 
     return set_function_name(logical_func, name, cls)
-
-
-# install the indexes
-for _name, _indexer in indexing.get_indexers_list():
-    NDFrame._create_indexer(_name, _indexer)
diff --git a/pandas/core/groupby/__init__.py b/pandas/core/groupby/__init__.py
index 252f20ed40068..0c5d2658978b4 100644
--- a/pandas/core/groupby/__init__.py
+++ b/pandas/core/groupby/__init__.py
@@ -1,7 +1,11 @@
-from pandas.core.groupby.generic import (  # noqa: F401
-    DataFrameGroupBy,
-    NamedAgg,
-    SeriesGroupBy,
-)
-from pandas.core.groupby.groupby import GroupBy  # noqa: F401
-from pandas.core.groupby.grouper import Grouper  # noqa: F401
+from pandas.core.groupby.generic import DataFrameGroupBy, NamedAgg, SeriesGroupBy
+from pandas.core.groupby.groupby import GroupBy
+from pandas.core.groupby.grouper import Grouper
+
+__all__ = [
+    "DataFrameGroupBy",
+    "NamedAgg",
+    "SeriesGroupBy",
+    "GroupBy",
+    "Grouper",
+]
diff --git a/pandas/core/groupby/base.py b/pandas/core/groupby/base.py
index fc3bb69afd0cb..700d8d503d086 100644
--- a/pandas/core/groupby/base.py
+++ b/pandas/core/groupby/base.py
@@ -1,32 +1,20 @@
 """
-Provide basic components for groupby. These defintiions
+Provide basic components for groupby. These definitions
 hold the whitelist of methods that are exposed on the
 SeriesGroupBy and the DataFrameGroupBy objects.
 """
+import collections
+
 from pandas.core.dtypes.common import is_list_like, is_scalar
 
+OutputKey = collections.namedtuple("OutputKey", ["label", "position"])
+
 
 class GroupByMixin:
     """
     Provide the groupby facilities to the mixed object.
     """
 
-    @staticmethod
-    def _dispatch(name, *args, **kwargs):
-        """
-        Dispatch to apply.
-        """
-
-        def outer(self, *args, **kwargs):
-            def f(x):
-                x = self._shallow_copy(x, groupby=self._groupby)
-                return getattr(x, name)(*args, **kwargs)
-
-            return self._groupby.apply(f)
-
-        outer.__name__ = name
-        return outer
-
     def _gotitem(self, key, ndim, subset=None):
         """
         Sub-classes to define. Return a sliced object.
@@ -53,7 +41,7 @@ def _gotitem(self, key, ndim, subset=None):
         except IndexError:
             groupby = self._groupby
 
-        self = self.__class__(subset, groupby=groupby, parent=self, **kwargs)
+        self = type(self)(subset, groupby=groupby, parent=self, **kwargs)
         self._reset_cache()
         if subset.ndim == 2:
             if is_scalar(key) and key in subset or is_list_like(key):
diff --git a/pandas/core/groupby/categorical.py b/pandas/core/groupby/categorical.py
index fcf52ecfcbbcd..399ed9ddc9ba1 100644
--- a/pandas/core/groupby/categorical.py
+++ b/pandas/core/groupby/categorical.py
@@ -8,7 +8,7 @@
 )
 
 
-def recode_for_groupby(c, sort, observed):
+def recode_for_groupby(c: Categorical, sort: bool, observed: bool):
     """
     Code the categories to ensure we can groupby for categoricals.
 
@@ -74,7 +74,7 @@ def recode_for_groupby(c, sort, observed):
     return c.reorder_categories(cat.categories), None
 
 
-def recode_from_groupby(c, sort, ci):
+def recode_from_groupby(c: Categorical, sort: bool, ci):
     """
     Reverse the codes_to_groupby to account for sort / observed.
 
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index e731cffea0671..f194c774cf329 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -5,20 +5,32 @@
 These are user facing as the result of the ``df.groupby(...)`` operations,
 which here returns a DataFrameGroupBy object.
 """
-from collections import OrderedDict, abc, namedtuple
+from collections import abc, namedtuple
 import copy
-import functools
 from functools import partial
 from textwrap import dedent
 import typing
-from typing import Any, Callable, FrozenSet, Iterator, Sequence, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    Iterable,
+    List,
+    Mapping,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 import warnings
 
 import numpy as np
 
 from pandas._libs import Timestamp, lib
-from pandas.compat import PY36
-from pandas.errors import AbstractMethodError
+from pandas._typing import FrameOrSeries
 from pandas.util._decorators import Appender, Substitution
 
 from pandas.core.dtypes.cast import (
@@ -30,21 +42,24 @@
     ensure_int64,
     ensure_platform_int,
     is_bool,
-    is_datetimelike,
-    is_dict_like,
     is_integer_dtype,
     is_interval_dtype,
-    is_list_like,
     is_numeric_dtype,
     is_object_dtype,
     is_scalar,
+    needs_i8_conversion,
 )
 from pandas.core.dtypes.missing import _isna_ndarraylike, isna, notna
 
-from pandas._typing import FrameOrSeries
+from pandas.core.aggregation import (
+    is_multi_agg_with_relabel,
+    maybe_mangle_lambdas,
+    normalize_keyword_aggregation,
+)
 import pandas.core.algorithms as algorithms
 from pandas.core.base import DataError, SpecificationError
 import pandas.core.common as com
+from pandas.core.construction import create_series_with_explicit_dtype
 from pandas.core.frame import DataFrame
 from pandas.core.generic import ABCDataFrame, ABCSeries, NDFrame, _shared_docs
 from pandas.core.groupby import base
@@ -52,16 +67,19 @@
     GroupBy,
     _apply_docs,
     _transform_template,
-    groupby,
+    get_groupby,
 )
-from pandas.core.index import Index, MultiIndex, _all_indexes_same
+from pandas.core.indexes.api import Index, MultiIndex, all_indexes_same
 import pandas.core.indexes.base as ibase
 from pandas.core.internals import BlockManager, make_block
 from pandas.core.series import Series
-from pandas.core.sparse.frame import SparseDataFrame
 
 from pandas.plotting import boxplot_frame_groupby
 
+if TYPE_CHECKING:
+    from pandas.core.internals import Block
+
+
 NamedAgg = namedtuple("NamedAgg", ["column", "aggfunc"])
 # TODO(typing) the return value on this callable should be any *scalar*.
 AggScalar = Union[str, Callable[..., Any]]
@@ -71,716 +89,753 @@
 ScalarResult = typing.TypeVar("ScalarResult")
 
 
-def whitelist_method_generator(
-    base_class: Type[GroupBy], klass: Type[FrameOrSeries], whitelist: FrozenSet[str]
-) -> Iterator[str]:
+def generate_property(name: str, klass: Type[FrameOrSeries]):
+    """
+    Create a property for a GroupBy subclass to dispatch to DataFrame/Series.
+
+    Parameters
+    ----------
+    name : str
+    klass : {DataFrame, Series}
+
+    Returns
+    -------
+    property
+    """
+
+    def prop(self):
+        return self._make_wrapper(name)
+
+    parent_method = getattr(klass, name)
+    prop.__doc__ = parent_method.__doc__ or ""
+    prop.__name__ = name
+    return property(prop)
+
+
+def pin_whitelisted_properties(klass: Type[FrameOrSeries], whitelist: FrozenSet[str]):
     """
-    Yields all GroupBy member defs for DataFrame/Series names in whitelist.
+    Create GroupBy member defs for DataFrame/Series names in a whitelist.
 
     Parameters
     ----------
-    base_class : Groupby class
-        base class
     klass : DataFrame or Series class
         class where members are defined.
-    whitelist : frozenset
+    whitelist : frozenset[str]
         Set of names of klass methods to be constructed
 
     Returns
     -------
-    The generator yields a sequence of strings, each suitable for exec'ing,
-    that define implementations of the named methods for DataFrameGroupBy
-    or SeriesGroupBy.
+    class decorator
 
+    Notes
+    -----
     Since we don't want to override methods explicitly defined in the
     base class, any such name is skipped.
     """
-    property_wrapper_template = """@property
-def %(name)s(self) :
-    \"""%(doc)s\"""
-    return self.__getattr__('%(name)s')"""
-
-    for name in whitelist:
-        # don't override anything that was explicitly defined
-        # in the base class
-        if hasattr(base_class, name):
-            continue
-        # ugly, but we need the name string itself in the method.
-        f = getattr(klass, name)
-        doc = f.__doc__
-        doc = doc if type(doc) == str else ""
-        wrapper_template = property_wrapper_template
-        params = {"name": name, "doc": doc}
-        yield wrapper_template % params
-
-
-class NDFrameGroupBy(GroupBy):
-    def _iterate_slices(self):
-        if self.axis == 0:
-            # kludge
-            if self._selection is None:
-                slice_axis = self.obj.columns
-            else:
-                slice_axis = self._selection_list
-            slicer = lambda x: self.obj[x]
-        else:
-            slice_axis = self.obj.index
-            slicer = self.obj.xs
 
-        for val in slice_axis:
-            if val in self.exclusions:
+    def pinner(cls):
+        for name in whitelist:
+            if hasattr(cls, name):
+                # don't override anything that was explicitly defined
+                #  in the base class
                 continue
-            yield val, slicer(val)
 
-    def _cython_agg_general(self, how, alt=None, numeric_only=True, min_count=-1):
-        new_items, new_blocks = self._cython_agg_blocks(
-            how, alt=alt, numeric_only=numeric_only, min_count=min_count
-        )
-        return self._wrap_agged_blocks(new_items, new_blocks)
+            prop = generate_property(name, klass)
+            setattr(cls, name, prop)
 
-    _block_agg_axis = 0
+        return cls
 
-    def _cython_agg_blocks(self, how, alt=None, numeric_only=True, min_count=-1):
-        # TODO: the actual managing of mgr_locs is a PITA
-        # here, it should happen via BlockManager.combine
+    return pinner
 
-        data, agg_axis = self._get_data_to_aggregate()
 
-        if numeric_only:
-            data = data.get_numeric_data(copy=False)
+@pin_whitelisted_properties(Series, base.series_apply_whitelist)
+class SeriesGroupBy(GroupBy):
+    _apply_whitelist = base.series_apply_whitelist
 
-        new_blocks = []
-        new_items = []
-        deleted_items = []
-        no_result = object()
-        for block in data.blocks:
-            # Avoid inheriting result from earlier in the loop
-            result = no_result
-            locs = block.mgr_locs.as_array
-            try:
-                result, _ = self.grouper.aggregate(
-                    block.values, how, axis=agg_axis, min_count=min_count
-                )
-            except NotImplementedError:
-                # generally if we have numeric_only=False
-                # and non-applicable functions
-                # try to python agg
+    def _iterate_slices(self) -> Iterable[Series]:
+        yield self._selected_obj
 
-                if alt is None:
-                    # we cannot perform the operation
-                    # in an alternate way, exclude the block
-                    deleted_items.append(locs)
-                    continue
+    @property
+    def _selection_name(self):
+        """
+        since we are a series, we by definition only have
+        a single name, but may be the result of a selection or
+        the name of our object
+        """
+        if self._selection is None:
+            return self.obj.name
+        else:
+            return self._selection
 
-                # call our grouper again with only this block
-                obj = self.obj[data.items[locs]]
-                s = groupby(obj, self.grouper)
-                try:
-                    result = s.aggregate(lambda x: alt(x, axis=self.axis))
-                except TypeError:
-                    # we may have an exception in trying to aggregate
-                    # continue and exclude the block
-                    deleted_items.append(locs)
-                    continue
-            finally:
-                if result is not no_result:
-                    # see if we can cast the block back to the original dtype
-                    result = maybe_downcast_numeric(result, block.dtype)
-                    newb = block.make_block(result)
+    _agg_see_also_doc = dedent(
+        """
+    See Also
+    --------
+    pandas.Series.groupby.apply
+    pandas.Series.groupby.transform
+    pandas.Series.aggregate
+    """
+    )
 
-            new_items.append(locs)
-            new_blocks.append(newb)
+    _agg_examples_doc = dedent(
+        """
+    Examples
+    --------
+    >>> s = pd.Series([1, 2, 3, 4])
 
-        if len(new_blocks) == 0:
-            raise DataError("No numeric types to aggregate")
+    >>> s
+    0    1
+    1    2
+    2    3
+    3    4
+    dtype: int64
 
-        # reset the locs in the blocks to correspond to our
-        # current ordering
-        indexer = np.concatenate(new_items)
-        new_items = data.items.take(np.sort(indexer))
+    >>> s.groupby([1, 1, 2, 2]).min()
+    1    1
+    2    3
+    dtype: int64
 
-        if len(deleted_items):
+    >>> s.groupby([1, 1, 2, 2]).agg('min')
+    1    1
+    2    3
+    dtype: int64
 
-            # we need to adjust the indexer to account for the
-            # items we have removed
-            # really should be done in internals :<
+    >>> s.groupby([1, 1, 2, 2]).agg(['min', 'max'])
+       min  max
+    1    1    2
+    2    3    4
 
-            deleted = np.concatenate(deleted_items)
-            ai = np.arange(len(data))
-            mask = np.zeros(len(data))
-            mask[deleted] = 1
-            indexer = (ai - mask.cumsum())[indexer]
+    The output column names can be controlled by passing
+    the desired column names and aggregations as keyword arguments.
 
-        offset = 0
-        for b in new_blocks:
-            loc = len(b.mgr_locs)
-            b.mgr_locs = indexer[offset : (offset + loc)]
-            offset += loc
+    >>> s.groupby([1, 1, 2, 2]).agg(
+    ...     minimum='min',
+    ...     maximum='max',
+    ... )
+       minimum  maximum
+    1        1        2
+    2        3        4
+    """
+    )
 
-        return new_items, new_blocks
+    @Appender(
+        _apply_docs["template"].format(
+            input="series", examples=_apply_docs["series_examples"]
+        )
+    )
+    def apply(self, func, *args, **kwargs):
+        return super().apply(func, *args, **kwargs)
 
-    def aggregate(self, func, *args, **kwargs):
-        _level = kwargs.pop("_level", None)
+    @Substitution(
+        see_also=_agg_see_also_doc,
+        examples=_agg_examples_doc,
+        versionadded="",
+        klass="Series",
+        axis="",
+    )
+    @Appender(_shared_docs["aggregate"])
+    def aggregate(self, func=None, *args, **kwargs):
 
-        relabeling = func is None and _is_multi_agg_with_relabel(**kwargs)
+        relabeling = func is None
+        columns = None
+        no_arg_message = "Must provide 'func' or named aggregation **kwargs."
         if relabeling:
-            func, columns, order = _normalize_keyword_aggregation(kwargs)
-
+            columns = list(kwargs)
+            func = [kwargs[col] for col in columns]
             kwargs = {}
-        elif func is None:
-            # nicer error message
-            raise TypeError("Must provide 'func' or tuples of '(column, aggfunc).")
-
-        func = _maybe_mangle_lambdas(func)
+            if not columns:
+                raise TypeError(no_arg_message)
 
-        result, how = self._aggregate(func, _level=_level, *args, **kwargs)
-        if how is None:
-            return result
+        if isinstance(func, str):
+            return getattr(self, func)(*args, **kwargs)
 
-        if result is None:
+        elif isinstance(func, abc.Iterable):
+            # Catch instances of lists / tuples
+            # but not the class list / tuple itself.
+            func = maybe_mangle_lambdas(func)
+            ret = self._aggregate_multiple_funcs(func)
+            if relabeling:
+                ret.columns = columns
+        else:
+            cyfunc = self._get_cython_func(func)
+            if cyfunc and not args and not kwargs:
+                return getattr(self, cyfunc)()
 
-            # grouper specific aggregations
             if self.grouper.nkeys > 1:
                 return self._python_agg_general(func, *args, **kwargs)
-            elif args or kwargs:
-                result = self._aggregate_generic(func, *args, **kwargs)
-            else:
-
-                # try to treat as if we are passing a list
-                try:
-                    result = self._aggregate_multiple_funcs(
-                        [func], _level=_level, _axis=self.axis
-                    )
-                except Exception:
-                    result = self._aggregate_generic(func)
-                else:
-                    result.columns = Index(
-                        result.columns.levels[0], name=self._selected_obj.columns.name
-                    )
 
-                    if isinstance(self.obj, SparseDataFrame):
-                        # Backwards compat for groupby.agg() with sparse
-                        # values. concat no longer converts DataFrame[Sparse]
-                        # to SparseDataFrame, so we do it here.
-                        result = SparseDataFrame(result._data)
+            try:
+                return self._python_agg_general(func, *args, **kwargs)
+            except (ValueError, KeyError):
+                # TODO: KeyError is raised in _python_agg_general,
+                #  see see test_groupby.test_basic
+                result = self._aggregate_named(func, *args, **kwargs)
 
-        if not self.as_index:
-            self._insert_inaxis_grouper_inplace(result)
-            result.index = np.arange(len(result))
+            index = Index(sorted(result), name=self.grouper.names[0])
+            ret = create_series_with_explicit_dtype(
+                result, index=index, dtype_if_empty=object
+            )
 
-        if relabeling:
+        if not self.as_index:  # pragma: no cover
+            print("Warning, ignoring as_index=True")
 
-            # used reordered index of columns
-            result = result.iloc[:, order]
-            result.columns = columns
+        if isinstance(ret, dict):
+            from pandas import concat
 
-        return result._convert(datetime=True)
+            ret = concat(ret, axis=1)
+        return ret
 
     agg = aggregate
 
-    def _aggregate_generic(self, func, *args, **kwargs):
-        if self.grouper.nkeys != 1:
-            raise AssertionError("Number of keys must be 1")
+    def _aggregate_multiple_funcs(self, arg):
+        if isinstance(arg, dict):
 
-        axis = self.axis
-        obj = self._obj_with_exclusions
+            # show the deprecation, but only if we
+            # have not shown a higher level one
+            # GH 15931
+            if isinstance(self._selected_obj, Series):
+                raise SpecificationError("nested renamer is not supported")
 
-        result = OrderedDict()
-        if axis != obj._info_axis_number:
-            try:
-                for name, data in self:
-                    result[name] = self._try_cast(func(data, *args, **kwargs), data)
-            except Exception:
-                return self._aggregate_item_by_item(func, *args, **kwargs)
+            columns = list(arg.keys())
+            arg = arg.items()
+        elif any(isinstance(x, (tuple, list)) for x in arg):
+            arg = [(x, x) if not isinstance(x, (tuple, list)) else x for x in arg]
+
+            # indicated column order
+            columns = next(zip(*arg))
         else:
-            for name in self.indices:
-                try:
-                    data = self.get_group(name, obj=obj)
-                    result[name] = self._try_cast(func(data, *args, **kwargs), data)
-                except Exception:
-                    wrapper = lambda x: func(x, *args, **kwargs)
-                    result[name] = data.apply(wrapper, axis=axis)
+            # list of functions / function names
+            columns = []
+            for f in arg:
+                columns.append(com.get_callable_name(f) or f)
 
-        return self._wrap_generic_output(result, obj)
+            arg = zip(columns, arg)
 
-    def _wrap_aggregated_output(self, output, names=None):
-        raise AbstractMethodError(self)
+        results = {}
+        for name, func in arg:
+            obj = self
 
-    def _aggregate_item_by_item(self, func, *args, **kwargs):
-        # only for axis==0
+            # reset the cache so that we
+            # only include the named selection
+            if name in self._selected_obj:
+                obj = copy.copy(obj)
+                obj._reset_cache()
+                obj._selection = name
+            results[name] = obj.aggregate(func)
 
-        obj = self._obj_with_exclusions
-        result = OrderedDict()
-        cannot_agg = []
-        errors = None
-        for item in obj:
-            data = obj[item]
-            colg = SeriesGroupBy(data, selection=item, grouper=self.grouper)
+        if any(isinstance(x, DataFrame) for x in results.values()):
+            # let higher level handle
+            return results
 
-            try:
-                cast = self._transform_should_cast(func)
+        return DataFrame(results, columns=columns)
 
-                result[item] = colg.aggregate(func, *args, **kwargs)
-                if cast:
-                    result[item] = self._try_cast(result[item], data)
+    def _wrap_series_output(
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]], index: Index
+    ) -> Union[Series, DataFrame]:
+        """
+        Wraps the output of a SeriesGroupBy operation into the expected result.
 
-            except ValueError as err:
-                if "Must produce aggregated value" in str(err):
-                    # raised in _aggregate_named, handle at higher level
-                    #  see test_apply_with_mutated_index
-                    raise
-                cannot_agg.append(item)
-                continue
-            except TypeError as e:
-                cannot_agg.append(item)
-                errors = e
-                continue
+        Parameters
+        ----------
+        output : Mapping[base.OutputKey, Union[Series, np.ndarray]]
+            Data to wrap.
+        index : pd.Index
+            Index to apply to the output.
 
-        result_columns = obj.columns
-        if cannot_agg:
-            result_columns = result_columns.drop(cannot_agg)
-
-            # GH6337
-            if not len(result_columns) and errors is not None:
-                raise errors
+        Returns
+        -------
+        Series or DataFrame
 
-        return DataFrame(result, columns=result_columns)
+        Notes
+        -----
+        In the vast majority of cases output and columns will only contain one
+        element. The exception is operations that expand dimensions, like ohlc.
+        """
+        indexed_output = {key.position: val for key, val in output.items()}
+        columns = Index(key.label for key in output)
 
-    def _decide_output_index(self, output, labels):
-        if len(output) == len(labels):
-            output_keys = labels
+        result: Union[Series, DataFrame]
+        if len(output) > 1:
+            result = DataFrame(indexed_output, index=index)
+            result.columns = columns
         else:
-            output_keys = sorted(output)
-            try:
-                output_keys.sort()
-            except TypeError:
-                pass
+            result = Series(indexed_output[0], index=index, name=columns[0])
 
-            if isinstance(labels, MultiIndex):
-                output_keys = MultiIndex.from_tuples(output_keys, names=labels.names)
+        return result
 
-        return output_keys
+    def _wrap_aggregated_output(
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]]
+    ) -> Union[Series, DataFrame]:
+        """
+        Wraps the output of a SeriesGroupBy aggregation into the expected result.
 
-    def _wrap_applied_output(self, keys, values, not_indexed_same=False):
-        if len(keys) == 0:
-            return DataFrame(index=keys)
+        Parameters
+        ----------
+        output : Mapping[base.OutputKey, Union[Series, np.ndarray]]
+            Data to wrap.
 
-        key_names = self.grouper.names
+        Returns
+        -------
+        Series or DataFrame
 
-        # GH12824.
-        def first_not_none(values):
-            try:
-                return next(com.not_none(*values))
-            except StopIteration:
-                return None
+        Notes
+        -----
+        In the vast majority of cases output will only contain one element.
+        The exception is operations that expand dimensions, like ohlc.
+        """
+        result = self._wrap_series_output(
+            output=output, index=self.grouper.result_index
+        )
+        return self._reindex_output(result)._convert(datetime=True)
 
-        v = first_not_none(values)
+    def _wrap_transformed_output(
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]]
+    ) -> Series:
+        """
+        Wraps the output of a SeriesGroupBy aggregation into the expected result.
 
-        if v is None:
-            # GH9684. If all values are None, then this will throw an error.
-            # We'd prefer it return an empty dataframe.
-            return DataFrame()
-        elif isinstance(v, DataFrame):
-            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
-        elif self.grouper.groupings is not None:
-            if len(self.grouper.groupings) > 1:
-                key_index = self.grouper.result_index
+        Parameters
+        ----------
+        output : dict[base.OutputKey, Union[Series, np.ndarray]]
+            Dict with a sole key of 0 and a value of the result values.
 
-            else:
-                ping = self.grouper.groupings[0]
-                if len(keys) == ping.ngroups:
-                    key_index = ping.group_index
-                    key_index.name = key_names[0]
+        Returns
+        -------
+        Series
 
-                    key_lookup = Index(keys)
-                    indexer = key_lookup.get_indexer(key_index)
+        Notes
+        -----
+        output should always contain one element. It is specified as a dict
+        for consistency with DataFrame methods and _wrap_aggregated_output.
+        """
+        assert len(output) == 1
+        result = self._wrap_series_output(output=output, index=self.obj.index)
 
-                    # reorder the values
-                    values = [values[i] for i in indexer]
-                else:
+        # No transformations increase the ndim of the result
+        assert isinstance(result, Series)
+        return result
 
-                    key_index = Index(keys, name=key_names[0])
+    def _wrap_applied_output(self, keys, values, not_indexed_same=False):
+        if len(keys) == 0:
+            # GH #6265
+            return Series([], name=self._selection_name, index=keys, dtype=np.float64)
 
-                # don't use the key indexer
-                if not self.as_index:
-                    key_index = None
+        def _get_index() -> Index:
+            if self.grouper.nkeys > 1:
+                index = MultiIndex.from_tuples(keys, names=self.grouper.names)
+            else:
+                index = Index(keys, name=self.grouper.names[0])
+            return index
 
-            # make Nones an empty object
-            v = first_not_none(values)
-            if v is None:
-                return DataFrame()
-            elif isinstance(v, NDFrame):
-                values = [
-                    x if x is not None else v._constructor(**v._construct_axes_dict())
-                    for x in values
-                ]
+        if isinstance(values[0], dict):
+            # GH #823 #24880
+            index = _get_index()
+            result = self._reindex_output(DataFrame(values, index=index))
+            # if self.observed is False,
+            # keep all-NaN rows created while re-indexing
+            result = result.stack(dropna=self.observed)
+            result.name = self._selection_name
+            return result
 
-            v = values[0]
+        if isinstance(values[0], Series):
+            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
+        elif isinstance(values[0], DataFrame):
+            # possible that Series -> DataFrame by applied function
+            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
+        else:
+            # GH #6265 #24880
+            result = Series(data=values, index=_get_index(), name=self._selection_name)
+            return self._reindex_output(result)
 
-            if isinstance(v, (np.ndarray, Index, Series)):
-                if isinstance(v, Series):
-                    applied_index = self._selected_obj._get_axis(self.axis)
-                    all_indexed_same = _all_indexes_same([x.index for x in values])
-                    singular_series = len(values) == 1 and applied_index.nlevels == 1
+    def _aggregate_named(self, func, *args, **kwargs):
+        result = {}
 
-                    # GH3596
-                    # provide a reduction (Frame -> Series) if groups are
-                    # unique
-                    if self.squeeze:
-                        # assign the name to this series
-                        if singular_series:
-                            values[0].name = keys[0]
+        for name, group in self:
+            group.name = name
+            output = func(group, *args, **kwargs)
+            if isinstance(output, (Series, Index, np.ndarray)):
+                raise ValueError("Must produce aggregated value")
+            result[name] = output
 
-                            # GH2893
-                            # we have series in the values array, we want to
-                            # produce a series:
-                            # if any of the sub-series are not indexed the same
-                            # OR we don't have a multi-index and we have only a
-                            # single values
-                            return self._concat_objects(
-                                keys, values, not_indexed_same=not_indexed_same
-                            )
+        return result
 
-                        # still a series
-                        # path added as of GH 5545
-                        elif all_indexed_same:
-                            from pandas.core.reshape.concat import concat
+    @Substitution(klass="Series", selected="A.")
+    @Appender(_transform_template)
+    def transform(self, func, *args, **kwargs):
+        func = self._get_cython_func(func) or func
 
-                            return concat(values)
+        if not isinstance(func, str):
+            return self._transform_general(func, *args, **kwargs)
 
-                    if not all_indexed_same:
-                        # GH 8467
-                        return self._concat_objects(keys, values, not_indexed_same=True)
+        elif func not in base.transform_kernel_whitelist:
+            msg = f"'{func}' is not a valid function name for transform(name)"
+            raise ValueError(msg)
+        elif func in base.cythonized_kernels:
+            # cythonized transform or canned "agg+broadcast"
+            return getattr(self, func)(*args, **kwargs)
 
-                try:
-                    if self.axis == 0:
-                        # GH6124 if the list of Series have a consistent name,
-                        # then propagate that name to the result.
-                        index = v.index.copy()
-                        if index.name is None:
-                            # Only propagate the series name to the result
-                            # if all series have a consistent name.  If the
-                            # series do not have a consistent name, do
-                            # nothing.
-                            names = {v.name for v in values}
-                            if len(names) == 1:
-                                index.name = list(names)[0]
-
-                        # normally use vstack as its faster than concat
-                        # and if we have mi-columns
-                        if (
-                            isinstance(v.index, MultiIndex)
-                            or key_index is None
-                            or isinstance(key_index, MultiIndex)
-                        ):
-                            stacked_values = np.vstack([np.asarray(v) for v in values])
-                            result = DataFrame(
-                                stacked_values, index=key_index, columns=index
-                            )
-                        else:
-                            # GH5788 instead of stacking; concat gets the
-                            # dtypes correct
-                            from pandas.core.reshape.concat import concat
+        # If func is a reduction, we need to broadcast the
+        # result to the whole group. Compute func result
+        # and deal with possible broadcasting below.
+        result = getattr(self, func)(*args, **kwargs)
+        return self._transform_fast(result, func)
 
-                            result = concat(
-                                values,
-                                keys=key_index,
-                                names=key_index.names,
-                                axis=self.axis,
-                            ).unstack()
-                            result.columns = index
-                    else:
-                        stacked_values = np.vstack([np.asarray(v) for v in values])
-                        result = DataFrame(
-                            stacked_values.T, index=v.index, columns=key_index
-                        )
+    def _transform_general(self, func, *args, **kwargs):
+        """
+        Transform with a non-str `func`.
+        """
+        klass = type(self._selected_obj)
 
-                except (ValueError, AttributeError):
-                    # GH1738: values is list of arrays of unequal lengths fall
-                    # through to the outer else caluse
-                    return Series(values, index=key_index, name=self._selection_name)
+        results = []
+        for name, group in self:
+            object.__setattr__(group, "name", name)
+            res = func(group, *args, **kwargs)
 
-                # if we have date/time like in the original, then coerce dates
-                # as we are stacking can easily have object dtypes here
-                so = self._selected_obj
-                if so.ndim == 2 and so.dtypes.apply(is_datetimelike).any():
-                    result = _recast_datetimelike_result(result)
-                else:
-                    result = result._convert(datetime=True)
+            if isinstance(res, (ABCDataFrame, ABCSeries)):
+                res = res._values
 
-                return self._reindex_output(result)
+            indexer = self._get_index(name)
+            ser = klass(res, indexer)
+            results.append(ser)
 
-            # values are not series or array-like but scalars
-            else:
-                # only coerce dates if we find at least 1 datetime
-                coerce = any(isinstance(x, Timestamp) for x in values)
-                # self._selection_name not passed through to Series as the
-                # result should not take the name of original selection
-                # of columns
-                return Series(values, index=key_index)._convert(
-                    datetime=True, coerce=coerce
-                )
+        # check for empty "results" to avoid concat ValueError
+        if results:
+            from pandas.core.reshape.concat import concat
 
+            result = concat(results).sort_index()
         else:
-            # Handle cases like BinGrouper
-            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
+            result = Series(dtype=np.float64)
 
-    def _transform_general(self, func, *args, **kwargs):
-        from pandas.core.reshape.concat import concat
+        # we will only try to coerce the result type if
+        # we have a numeric dtype, as these are *always* user-defined funcs
+        # the cython take a different path (and casting)
+        dtype = self._selected_obj.dtype
+        if is_numeric_dtype(dtype):
+            result = maybe_downcast_to_dtype(result, dtype)
 
-        applied = []
-        obj = self._obj_with_exclusions
-        gen = self.grouper.get_iterator(obj, axis=self.axis)
-        fast_path, slow_path = self._define_paths(func, *args, **kwargs)
+        result.name = self._selected_obj.name
+        result.index = self._selected_obj.index
+        return result
 
-        path = None
-        for name, group in gen:
-            object.__setattr__(group, "name", name)
+    def _transform_fast(self, result, func_nm: str) -> Series:
+        """
+        fast version of transform, only applicable to
+        builtin/cythonizable functions
+        """
+        ids, _, ngroup = self.grouper.group_info
+        cast = self._transform_should_cast(func_nm)
+        out = algorithms.take_1d(result._values, ids)
+        if cast:
+            out = self._try_cast(out, self.obj)
+        return Series(out, index=self.obj.index, name=self.obj.name)
 
-            if path is None:
-                # Try slow path and fast path.
-                try:
-                    path, res = self._choose_path(fast_path, slow_path, group)
-                except TypeError:
-                    return self._transform_item_by_item(obj, fast_path)
-                except ValueError:
-                    msg = "transform must return a scalar value for each group"
-                    raise ValueError(msg)
-            else:
-                res = path(group)
+    def filter(self, func, dropna=True, *args, **kwargs):
+        """
+        Return a copy of a Series excluding elements from groups that
+        do not satisfy the boolean criterion specified by func.
 
-            if isinstance(res, Series):
+        Parameters
+        ----------
+        func : function
+            To apply to each group. Should return True or False.
+        dropna : Drop groups that do not pass the filter. True by default;
+            if False, groups that evaluate False are filled with NaNs.
 
-                # we need to broadcast across the
-                # other dimension; this will preserve dtypes
-                # GH14457
-                if not np.prod(group.shape):
-                    continue
-                elif res.index.is_(obj.index):
-                    r = concat([res] * len(group.columns), axis=1)
-                    r.columns = group.columns
-                    r.index = group.index
-                else:
-                    r = DataFrame(
-                        np.concatenate([res.values] * len(group.index)).reshape(
-                            group.shape
-                        ),
-                        columns=group.columns,
-                        index=group.index,
-                    )
-
-                applied.append(r)
-            else:
-                applied.append(res)
-
-        concat_index = obj.columns if self.axis == 0 else obj.index
-        other_axis = 1 if self.axis == 0 else 0  # switches between 0 & 1
-        concatenated = concat(applied, axis=self.axis, verify_integrity=False)
-        concatenated = concatenated.reindex(concat_index, axis=other_axis, copy=False)
-        return self._set_result_index_ordered(concatenated)
-
-    @Substitution(klass="DataFrame", selected="")
-    @Appender(_transform_template)
-    def transform(self, func, *args, **kwargs):
-
-        # optimized transforms
-        func = self._get_cython_func(func) or func
+        Examples
+        --------
+        >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
+        ...                           'foo', 'bar'],
+        ...                    'B' : [1, 2, 3, 4, 5, 6],
+        ...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
+        >>> grouped = df.groupby('A')
+        >>> df.groupby('A').B.filter(lambda x: x.mean() > 3.)
+        1    2
+        3    4
+        5    6
+        Name: B, dtype: int64
 
+        Returns
+        -------
+        filtered : Series
+        """
         if isinstance(func, str):
-            if not (func in base.transform_kernel_whitelist):
-                msg = "'{func}' is not a valid function name for transform(name)"
-                raise ValueError(msg.format(func=func))
-            if func in base.cythonized_kernels:
-                # cythonized transformation or canned "reduction+broadcast"
-                return getattr(self, func)(*args, **kwargs)
-            else:
-                # If func is a reduction, we need to broadcast the
-                # result to the whole group. Compute func result
-                # and deal with possible broadcasting below.
-                result = getattr(self, func)(*args, **kwargs)
+            wrapper = lambda x: getattr(x, func)(*args, **kwargs)
         else:
-            return self._transform_general(func, *args, **kwargs)
-
-        # a reduction transform
-        if not isinstance(result, DataFrame):
-            return self._transform_general(func, *args, **kwargs)
+            wrapper = lambda x: func(x, *args, **kwargs)
 
-        obj = self._obj_with_exclusions
+        # Interpret np.nan as False.
+        def true_and_notna(x, *args, **kwargs) -> bool:
+            b = wrapper(x, *args, **kwargs)
+            return b and notna(b)
 
-        # nuisance columns
-        if not result.columns.equals(obj.columns):
-            return self._transform_general(func, *args, **kwargs)
+        try:
+            indices = [
+                self._get_index(name) for name, group in self if true_and_notna(group)
+            ]
+        except (ValueError, TypeError):
+            raise TypeError("the filter must return a boolean result")
 
-        return self._transform_fast(result, obj, func)
+        filtered = self._apply_filter(indices, dropna)
+        return filtered
 
-    def _transform_fast(self, result, obj, func_nm):
+    def nunique(self, dropna: bool = True) -> Series:
         """
-        Fast transform path for aggregations
+        Return number of unique elements in the group.
+
+        Returns
+        -------
+        Series
+            Number of unique values within each group.
         """
-        # if there were groups with no observations (Categorical only?)
-        # try casting data to original dtype
-        cast = self._transform_should_cast(func_nm)
+        ids, _, _ = self.grouper.group_info
 
-        # for each col, reshape to to size of original frame
-        # by take operation
-        ids, _, ngroup = self.grouper.group_info
-        output = []
-        for i, _ in enumerate(result.columns):
-            res = algorithms.take_1d(result.iloc[:, i].values, ids)
-            if cast:
-                res = self._try_cast(res, obj.iloc[:, i])
-            output.append(res)
+        val = self.obj._internal_get_values()
 
-        return DataFrame._from_arrays(output, columns=result.columns, index=obj.index)
+        # GH 27951
+        # temporary fix while we wait for NumPy bug 12629 to be fixed
+        val[isna(val)] = np.datetime64("NaT")
 
-    def _define_paths(self, func, *args, **kwargs):
-        if isinstance(func, str):
-            fast_path = lambda group: getattr(group, func)(*args, **kwargs)
-            slow_path = lambda group: group.apply(
-                lambda x: getattr(x, func)(*args, **kwargs), axis=self.axis
-            )
+        try:
+            sorter = np.lexsort((val, ids))
+        except TypeError:  # catches object dtypes
+            msg = f"val.dtype must be object, got {val.dtype}"
+            assert val.dtype == object, msg
+            val, _ = algorithms.factorize(val, sort=False)
+            sorter = np.lexsort((val, ids))
+            _isna = lambda a: a == -1
         else:
-            fast_path = lambda group: func(group, *args, **kwargs)
-            slow_path = lambda group: group.apply(
-                lambda x: func(x, *args, **kwargs), axis=self.axis
-            )
-        return fast_path, slow_path
+            _isna = isna
 
-    def _choose_path(self, fast_path, slow_path, group):
-        path = slow_path
-        res = slow_path(group)
+        ids, val = ids[sorter], val[sorter]
 
-        # if we make it here, test if we can use the fast path
-        try:
-            res_fast = fast_path(group)
-        except Exception:
-            # Hard to know ex-ante what exceptions `fast_path` might raise
-            return path, res
+        # group boundaries are where group ids change
+        # unique observations are where sorted values change
+        idx = np.r_[0, 1 + np.nonzero(ids[1:] != ids[:-1])[0]]
+        inc = np.r_[1, val[1:] != val[:-1]]
 
-        # verify fast path does not change columns (and names), otherwise
-        # its results cannot be joined with those of the slow path
-        if not isinstance(res_fast, DataFrame):
-            return path, res
+        # 1st item of each group is a new unique observation
+        mask = _isna(val)
+        if dropna:
+            inc[idx] = 1
+            inc[mask] = 0
+        else:
+            inc[mask & np.r_[False, mask[:-1]]] = 0
+            inc[idx] = 1
 
-        if not res_fast.columns.equals(group.columns):
-            return path, res
+        out = np.add.reduceat(inc, idx).astype("int64", copy=False)
+        if len(ids):
+            # NaN/NaT group exists if the head of ids is -1,
+            # so remove it from res and exclude its index from idx
+            if ids[0] == -1:
+                res = out[1:]
+                idx = idx[np.flatnonzero(idx)]
+            else:
+                res = out
+        else:
+            res = out[1:]
+        ri = self.grouper.result_index
 
-        if res_fast.equals(res):
-            path = fast_path
+        # we might have duplications among the bins
+        if len(res) != len(ri):
+            res, out = np.zeros(len(ri), dtype=out.dtype), res
+            res[ids[idx]] = out
 
-        return path, res
+        result = Series(res, index=ri, name=self._selection_name)
+        return self._reindex_output(result, fill_value=0)
 
-    def _transform_item_by_item(self, obj, wrapper):
-        # iterate through columns
-        output = {}
-        inds = []
-        for i, col in enumerate(obj):
-            try:
-                output[col] = self[col].transform(wrapper)
-                inds.append(i)
-            except Exception:
-                pass
+    @Appender(Series.describe.__doc__)
+    def describe(self, **kwargs):
+        result = self.apply(lambda x: x.describe(**kwargs))
+        if self.axis == 1:
+            return result.T
+        return result.unstack()
 
-        if len(output) == 0:
-            raise TypeError("Transform function invalid for data types")
+    def value_counts(
+        self, normalize=False, sort=True, ascending=False, bins=None, dropna=True
+    ):
 
-        columns = obj.columns
-        if len(output) < len(obj.columns):
-            columns = columns.take(inds)
+        from pandas.core.reshape.tile import cut
+        from pandas.core.reshape.merge import _get_join_indexers
 
-        return DataFrame(output, index=obj.index, columns=columns)
+        if bins is not None and not np.iterable(bins):
+            # scalar bins cannot be done at top level
+            # in a backward compatible way
+            return self.apply(
+                Series.value_counts,
+                normalize=normalize,
+                sort=sort,
+                ascending=ascending,
+                bins=bins,
+            )
 
-    def filter(self, func, dropna=True, *args, **kwargs):
-        """
-        Return a copy of a DataFrame excluding elements from groups that
-        do not satisfy the boolean criterion specified by func.
+        ids, _, _ = self.grouper.group_info
+        val = self.obj._internal_get_values()
 
-        Parameters
-        ----------
-        f : function
-            Function to apply to each subframe. Should return True or False.
-        dropna : Drop groups that do not pass the filter. True by default;
-            if False, groups that evaluate False are filled with NaNs.
+        # groupby removes null keys from groupings
+        mask = ids != -1
+        ids, val = ids[mask], val[mask]
 
-        Returns
-        -------
-        filtered : DataFrame
+        if bins is None:
+            lab, lev = algorithms.factorize(val, sort=True)
+            llab = lambda lab, inc: lab[inc]
+        else:
 
-        Notes
-        -----
-        Each subframe is endowed the attribute 'name' in case you need to know
-        which group you are working on.
+            # lab is a Categorical with categories an IntervalIndex
+            lab = cut(Series(val), bins, include_lowest=True)
+            lev = lab.cat.categories
+            lab = lev.take(lab.cat.codes)
+            llab = lambda lab, inc: lab[inc]._multiindex.codes[-1]
 
-        Examples
-        --------
-        >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
-        ...                           'foo', 'bar'],
-        ...                    'B' : [1, 2, 3, 4, 5, 6],
-        ...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
-        >>> grouped = df.groupby('A')
-        >>> grouped.filter(lambda x: x['B'].mean() > 3.)
-             A  B    C
-        1  bar  2  5.0
-        3  bar  4  1.0
-        5  bar  6  9.0
-        """
+        if is_interval_dtype(lab):
+            # TODO: should we do this inside II?
+            sorter = np.lexsort((lab.left, lab.right, ids))
+        else:
+            sorter = np.lexsort((lab, ids))
 
-        indices = []
+        ids, lab = ids[sorter], lab[sorter]
 
-        obj = self._selected_obj
-        gen = self.grouper.get_iterator(obj, axis=self.axis)
+        # group boundaries are where group ids change
+        idx = np.r_[0, 1 + np.nonzero(ids[1:] != ids[:-1])[0]]
 
-        for name, group in gen:
-            object.__setattr__(group, "name", name)
+        # new values are where sorted labels change
+        lchanges = llab(lab, slice(1, None)) != llab(lab, slice(None, -1))
+        inc = np.r_[True, lchanges]
+        inc[idx] = True  # group boundaries are also new values
+        out = np.diff(np.nonzero(np.r_[inc, True])[0])  # value counts
 
-            res = func(group, *args, **kwargs)
+        # num. of times each group should be repeated
+        rep = partial(np.repeat, repeats=np.add.reduceat(inc, idx))
 
-            try:
-                res = res.squeeze()
-            except AttributeError:  # allow e.g., scalars and frames to pass
-                pass
+        # multi-index components
+        codes = self.grouper.reconstructed_codes
+        codes = [rep(level_codes) for level_codes in codes] + [llab(lab, inc)]
+        levels = [ping.group_index for ping in self.grouper.groupings] + [lev]
+        names = self.grouper.names + [self._selection_name]
 
-            # interpret the result of the filter
-            if is_bool(res) or (is_scalar(res) and isna(res)):
-                if res and notna(res):
-                    indices.append(self._get_index(name))
+        if dropna:
+            mask = codes[-1] != -1
+            if mask.all():
+                dropna = False
             else:
-                # non scalars aren't allowed
-                raise TypeError(
-                    "filter function returned a %s, "
-                    "but expected a scalar bool" % type(res).__name__
-                )
+                out, codes = out[mask], [level_codes[mask] for level_codes in codes]
 
-        return self._apply_filter(indices, dropna)
+        if normalize:
+            out = out.astype("float")
+            d = np.diff(np.r_[idx, len(ids)])
+            if dropna:
+                m = ids[lab == -1]
+                np.add.at(d, m, -1)
+                acc = rep(d)[mask]
+            else:
+                acc = rep(d)
+            out /= acc
 
+        if sort and bins is None:
+            cat = ids[inc][mask] if dropna else ids[inc]
+            sorter = np.lexsort((out if ascending else -out, cat))
+            out, codes[-1] = out[sorter], codes[-1][sorter]
 
-class SeriesGroupBy(GroupBy):
-    #
-    # Make class defs of attributes on SeriesGroupBy whitelist
+        if bins is None:
+            mi = MultiIndex(
+                levels=levels, codes=codes, names=names, verify_integrity=False
+            )
 
-    _apply_whitelist = base.series_apply_whitelist
-    for _def_str in whitelist_method_generator(GroupBy, Series, _apply_whitelist):
-        exec(_def_str)
+            if is_integer_dtype(out):
+                out = ensure_int64(out)
+            return Series(out, index=mi, name=self._selection_name)
 
-    @property
-    def _selection_name(self):
+        # for compat. with libgroupby.value_counts need to ensure every
+        # bin is present at every index level, null filled with zeros
+        diff = np.zeros(len(out), dtype="bool")
+        for level_codes in codes[:-1]:
+            diff |= np.r_[True, level_codes[1:] != level_codes[:-1]]
+
+        ncat, nbin = diff.sum(), len(levels[-1])
+
+        left = [np.repeat(np.arange(ncat), nbin), np.tile(np.arange(nbin), ncat)]
+
+        right = [diff.cumsum() - 1, codes[-1]]
+
+        _, idx = _get_join_indexers(left, right, sort=False, how="left")
+        out = np.where(idx != -1, out[idx], 0)
+
+        if sort:
+            sorter = np.lexsort((out if ascending else -out, left[0]))
+            out, left[-1] = out[sorter], left[-1][sorter]
+
+        # build the multi-index w/ full levels
+        def build_codes(lev_codes: np.ndarray) -> np.ndarray:
+            return np.repeat(lev_codes[diff], nbin)
+
+        codes = [build_codes(lev_codes) for lev_codes in codes[:-1]]
+        codes.append(left[-1])
+
+        mi = MultiIndex(levels=levels, codes=codes, names=names, verify_integrity=False)
+
+        if is_integer_dtype(out):
+            out = ensure_int64(out)
+        return Series(out, index=mi, name=self._selection_name)
+
+    def count(self) -> Series:
         """
-        since we are a series, we by definition only have
-        a single name, but may be the result of a selection or
-        the name of our object
+        Compute count of group, excluding missing values.
+
+        Returns
+        -------
+        Series
+            Count of values within each group.
         """
-        if self._selection is None:
-            return self.obj.name
-        else:
-            return self._selection
+        ids, _, ngroups = self.grouper.group_info
+        val = self.obj._internal_get_values()
+
+        mask = (ids != -1) & ~isna(val)
+        ids = ensure_platform_int(ids)
+        minlength = ngroups or 0
+        out = np.bincount(ids[mask], minlength=minlength)
+
+        result = Series(
+            out,
+            index=self.grouper.result_index,
+            name=self._selection_name,
+            dtype="int64",
+        )
+        return self._reindex_output(result, fill_value=0)
+
+    def _apply_to_column_groupbys(self, func):
+        """ return a pass thru """
+        return func(self)
+
+    def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None):
+        """Calculate pct_change of each value to previous entry in group"""
+        # TODO: Remove this conditional when #23918 is fixed
+        if freq:
+            return self.apply(
+                lambda x: x.pct_change(
+                    periods=periods, fill_method=fill_method, limit=limit, freq=freq
+                )
+            )
+        if fill_method is None:  # GH30463
+            fill_method = "pad"
+            limit = 0
+        filled = getattr(self, fill_method)(limit=limit)
+        fill_grp = filled.groupby(self.grouper.codes)
+        shifted = fill_grp.shift(periods=periods, freq=freq)
+
+        return (filled / shifted) - 1
+
+
+@pin_whitelisted_properties(DataFrame, base.dataframe_apply_whitelist)
+class DataFrameGroupBy(GroupBy):
+
+    _apply_whitelist = base.dataframe_apply_whitelist
 
     _agg_see_also_doc = dedent(
         """
     See Also
     --------
-    pandas.Series.groupby.apply
-    pandas.Series.groupby.transform
-    pandas.Series.aggregate
+    pandas.DataFrame.groupby.apply
+    pandas.DataFrame.groupby.transform
+    pandas.DataFrame.aggregate
     """
     )
 
@@ -788,700 +843,777 @@ def _selection_name(self):
         """
     Examples
     --------
-    >>> s = pd.Series([1, 2, 3, 4])
 
-    >>> s
-    0    1
-    1    2
-    2    3
-    3    4
-    dtype: int64
+    >>> df = pd.DataFrame({'A': [1, 1, 2, 2],
+    ...                    'B': [1, 2, 3, 4],
+    ...                    'C': np.random.randn(4)})
 
-    >>> s.groupby([1, 1, 2, 2]).min()
-    1    1
-    2    3
-    dtype: int64
+    >>> df
+       A  B         C
+    0  1  1  0.362838
+    1  1  2  0.227877
+    2  2  3  1.267767
+    3  2  4 -0.562860
 
-    >>> s.groupby([1, 1, 2, 2]).agg('min')
-    1    1
-    2    3
-    dtype: int64
+    The aggregation is for each column.
 
-    >>> s.groupby([1, 1, 2, 2]).agg(['min', 'max'])
+    >>> df.groupby('A').agg('min')
+       B         C
+    A
+    1  1  0.227877
+    2  3 -0.562860
+
+    Multiple aggregations
+
+    >>> df.groupby('A').agg(['min', 'max'])
+        B             C
+      min max       min       max
+    A
+    1   1   2  0.227877  0.362838
+    2   3   4 -0.562860  1.267767
+
+    Select a column for aggregation
+
+    >>> df.groupby('A').B.agg(['min', 'max'])
        min  max
+    A
     1    1    2
     2    3    4
 
-    The output column names can be controlled by passing
-    the desired column names and aggregations as keyword arguments.
+    Different aggregations per column
 
-    >>> s.groupby([1, 1, 2, 2]).agg(
-    ...     minimum='min',
-    ...     maximum='max',
-    ... )
-       minimum  maximum
-    1        1        2
-    2        3        4
-    """
-    )
+    >>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
+        B             C
+      min max       sum
+    A
+    1   1   2  0.590716
+    2   3   4  0.704907
 
-    @Appender(
-        _apply_docs["template"].format(
-            input="series", examples=_apply_docs["series_examples"]
-        )
+    To control the output names with different aggregations per column,
+    pandas supports "named aggregation"
+
+    >>> df.groupby("A").agg(
+    ...     b_min=pd.NamedAgg(column="B", aggfunc="min"),
+    ...     c_sum=pd.NamedAgg(column="C", aggfunc="sum"))
+       b_min     c_sum
+    A
+    1      1 -1.956929
+    2      3 -0.322183
+
+    - The keywords are the *output* column names
+    - The values are tuples whose first element is the column to select
+      and the second element is the aggregation to apply to that column.
+      Pandas provides the ``pandas.NamedAgg`` namedtuple with the fields
+      ``['column', 'aggfunc']`` to make it clearer what the arguments are.
+      As usual, the aggregation can be a callable or a string alias.
+
+    See :ref:`groupby.aggregate.named` for more.
+    """
     )
-    def apply(self, func, *args, **kwargs):
-        return super().apply(func, *args, **kwargs)
 
     @Substitution(
         see_also=_agg_see_also_doc,
         examples=_agg_examples_doc,
         versionadded="",
-        klass="Series",
+        klass="DataFrame",
         axis="",
     )
     @Appender(_shared_docs["aggregate"])
     def aggregate(self, func=None, *args, **kwargs):
-        _level = kwargs.pop("_level", None)
 
-        relabeling = func is None
-        columns = None
-        no_arg_message = "Must provide 'func' or named aggregation **kwargs."
+        relabeling = func is None and is_multi_agg_with_relabel(**kwargs)
         if relabeling:
-            columns = list(kwargs)
-            if not PY36:
-                # sort for 3.5 and earlier
-                columns = list(sorted(columns))
+            func, columns, order = normalize_keyword_aggregation(kwargs)
 
-            func = [kwargs[col] for col in columns]
             kwargs = {}
-            if not columns:
-                raise TypeError(no_arg_message)
+        elif isinstance(func, list) and len(func) > len(set(func)):
 
-        if isinstance(func, str):
-            return getattr(self, func)(*args, **kwargs)
+            # GH 28426 will raise error if duplicated function names are used and
+            # there is no reassigned name
+            raise SpecificationError(
+                "Function names must be unique if there is no new column "
+                "names assigned"
+            )
+        elif func is None:
+            # nicer error message
+            raise TypeError("Must provide 'func' or tuples of '(column, aggfunc).")
 
-        if isinstance(func, abc.Iterable):
-            # Catch instances of lists / tuples
-            # but not the class list / tuple itself.
-            func = _maybe_mangle_lambdas(func)
-            ret = self._aggregate_multiple_funcs(func, (_level or 0) + 1)
-            if relabeling:
-                ret.columns = columns
-        else:
-            cyfunc = self._get_cython_func(func)
-            if cyfunc and not args and not kwargs:
-                return getattr(self, cyfunc)()
+        func = maybe_mangle_lambdas(func)
+
+        result, how = self._aggregate(func, *args, **kwargs)
+        if how is None:
+            return result
 
+        if result is None:
+
+            # grouper specific aggregations
             if self.grouper.nkeys > 1:
                 return self._python_agg_general(func, *args, **kwargs)
+            elif args or kwargs:
+                result = self._aggregate_frame(func, *args, **kwargs)
 
-            try:
-                return self._python_agg_general(func, *args, **kwargs)
-            except Exception:
-                result = self._aggregate_named(func, *args, **kwargs)
+            elif self.axis == 1:
+                # _aggregate_multiple_funcs does not allow self.axis == 1
+                result = self._aggregate_frame(func)
 
-            index = Index(sorted(result), name=self.grouper.names[0])
-            ret = Series(result, index=index)
+            else:
 
-        if not self.as_index:  # pragma: no cover
-            print("Warning, ignoring as_index=True")
+                # try to treat as if we are passing a list
+                try:
+                    result = self._aggregate_multiple_funcs([func], _axis=self.axis)
+                except ValueError as err:
+                    if "no results" not in str(err):
+                        # raised directly by _aggregate_multiple_funcs
+                        raise
+                    result = self._aggregate_frame(func)
+                else:
+                    result.columns = Index(
+                        result.columns.levels[0], name=self._selected_obj.columns.name
+                    )
 
-        # _level handled at higher
-        if not _level and isinstance(ret, dict):
-            from pandas import concat
+        if not self.as_index:
+            self._insert_inaxis_grouper_inplace(result)
+            result.index = np.arange(len(result))
 
-            ret = concat(ret, axis=1)
-        return ret
+        if relabeling:
 
-    agg = aggregate
+            # used reordered index of columns
+            result = result.iloc[:, order]
+            result.columns = columns
 
-    def _aggregate_multiple_funcs(self, arg, _level):
-        if isinstance(arg, dict):
+        return result._convert(datetime=True)
 
-            # show the deprecation, but only if we
-            # have not shown a higher level one
-            # GH 15931
-            if isinstance(self._selected_obj, Series) and _level <= 1:
-                msg = dedent(
-                    """\
-                using a dict on a Series for aggregation
-                is deprecated and will be removed in a future version. Use \
-                named aggregation instead.
-
-                    >>> grouper.agg(name_1=func_1, name_2=func_2)
-                """
-                )
-                warnings.warn(msg, FutureWarning, stacklevel=3)
+    agg = aggregate
 
-            columns = list(arg.keys())
-            arg = arg.items()
-        elif any(isinstance(x, (tuple, list)) for x in arg):
-            arg = [(x, x) if not isinstance(x, (tuple, list)) else x for x in arg]
+    def _iterate_slices(self) -> Iterable[Series]:
+        obj = self._selected_obj
+        if self.axis == 1:
+            obj = obj.T
 
-            # indicated column order
-            columns = next(zip(*arg))
+        if isinstance(obj, Series) and obj.name not in self.exclusions:
+            # Occurs when doing DataFrameGroupBy(...)["X"]
+            yield obj
         else:
-            # list of functions / function names
-            columns = []
-            for f in arg:
-                columns.append(com.get_callable_name(f) or f)
+            for label, values in obj.items():
+                if label in self.exclusions:
+                    continue
 
-            arg = zip(columns, arg)
+                yield values
 
-        results = OrderedDict()
-        for name, func in arg:
-            obj = self
-            if name in results:
-                raise SpecificationError(
-                    "Function names must be unique, found multiple named "
-                    "{}".format(name)
-                )
+    def _cython_agg_general(
+        self, how: str, alt=None, numeric_only: bool = True, min_count: int = -1
+    ) -> DataFrame:
+        agg_blocks, agg_items = self._cython_agg_blocks(
+            how, alt=alt, numeric_only=numeric_only, min_count=min_count
+        )
+        return self._wrap_agged_blocks(agg_blocks, items=agg_items)
 
-            # reset the cache so that we
-            # only include the named selection
-            if name in self._selected_obj:
-                obj = copy.copy(obj)
-                obj._reset_cache()
-                obj._selection = name
-            results[name] = obj.aggregate(func)
+    def _cython_agg_blocks(
+        self, how: str, alt=None, numeric_only: bool = True, min_count: int = -1
+    ) -> "Tuple[List[Block], Index]":
+        # TODO: the actual managing of mgr_locs is a PITA
+        # here, it should happen via BlockManager.combine
 
-        if any(isinstance(x, DataFrame) for x in results.values()):
-            # let higher level handle
-            if _level:
-                return results
+        data: BlockManager = self._get_data_to_aggregate()
 
-        return DataFrame(results, columns=columns)
+        if numeric_only:
+            data = data.get_numeric_data(copy=False)
 
-    def _wrap_output(self, output, index, names=None):
-        """ common agg/transform wrapping logic """
-        output = output[self._selection_name]
+        agg_blocks: List[Block] = []
+        new_items: List[np.ndarray] = []
+        deleted_items: List[np.ndarray] = []
+        # Some object-dtype blocks might be split into List[Block[T], Block[U]]
+        split_items: List[np.ndarray] = []
+        split_frames: List[DataFrame] = []
 
-        if names is not None:
-            return DataFrame(output, index=index, columns=names)
-        else:
-            name = self._selection_name
-            if name is None:
-                name = self._selected_obj.name
-            return Series(output, index=index, name=name)
-
-    def _wrap_aggregated_output(self, output, names=None):
-        result = self._wrap_output(
-            output=output, index=self.grouper.result_index, names=names
-        )
-        return self._reindex_output(result)._convert(datetime=True)
+        no_result = object()
+        for block in data.blocks:
+            # Avoid inheriting result from earlier in the loop
+            result = no_result
+            locs = block.mgr_locs.as_array
+            try:
+                result, _ = self.grouper.aggregate(
+                    block.values, how, axis=1, min_count=min_count
+                )
+            except NotImplementedError:
+                # generally if we have numeric_only=False
+                # and non-applicable functions
+                # try to python agg
 
-    def _wrap_transformed_output(self, output, names=None):
-        return self._wrap_output(output=output, index=self.obj.index, names=names)
+                if alt is None:
+                    # we cannot perform the operation
+                    # in an alternate way, exclude the block
+                    assert how == "ohlc"
+                    deleted_items.append(locs)
+                    continue
 
-    def _wrap_applied_output(self, keys, values, not_indexed_same=False):
-        if len(keys) == 0:
-            # GH #6265
-            return Series([], name=self._selection_name, index=keys)
+                # call our grouper again with only this block
+                obj = self.obj[data.items[locs]]
+                if obj.shape[1] == 1:
+                    # Avoid call to self.values that can occur in DataFrame
+                    #  reductions; see GH#28949
+                    obj = obj.iloc[:, 0]
 
-        def _get_index():
-            if self.grouper.nkeys > 1:
-                index = MultiIndex.from_tuples(keys, names=self.grouper.names)
-            else:
-                index = Index(keys, name=self.grouper.names[0])
-            return index
+                s = get_groupby(obj, self.grouper)
+                try:
+                    result = s.aggregate(lambda x: alt(x, axis=self.axis))
+                except TypeError:
+                    # we may have an exception in trying to aggregate
+                    # continue and exclude the block
+                    deleted_items.append(locs)
+                    continue
+                else:
+                    result = cast(DataFrame, result)
+                    # unwrap DataFrame to get array
+                    if len(result._data.blocks) != 1:
+                        # We've split an object block! Everything we've assumed
+                        # about a single block input returning a single block output
+                        # is a lie. To keep the code-path for the typical non-split case
+                        # clean, we choose to clean up this mess later on.
+                        split_items.append(locs)
+                        split_frames.append(result)
+                        continue
+
+                    assert len(result._data.blocks) == 1
+                    result = result._data.blocks[0].values
+                    if isinstance(result, np.ndarray) and result.ndim == 1:
+                        result = result.reshape(1, -1)
+
+            assert not isinstance(result, DataFrame)
+
+            if result is not no_result:
+                # see if we can cast the block back to the original dtype
+                result = maybe_downcast_numeric(result, block.dtype)
+
+                if block.is_extension and isinstance(result, np.ndarray):
+                    # e.g. block.values was an IntegerArray
+                    # (1, N) case can occur if block.values was Categorical
+                    #  and result is ndarray[object]
+                    assert result.ndim == 1 or result.shape[0] == 1
+                    try:
+                        # Cast back if feasible
+                        result = type(block.values)._from_sequence(
+                            result.ravel(), dtype=block.values.dtype
+                        )
+                    except ValueError:
+                        # reshape to be valid for non-Extension Block
+                        result = result.reshape(1, -1)
 
-        if isinstance(values[0], dict):
-            # GH #823 #24880
-            index = _get_index()
-            result = self._reindex_output(DataFrame(values, index=index))
-            # if self.observed is False,
-            # keep all-NaN rows created while re-indexing
-            result = result.stack(dropna=self.observed)
-            result.name = self._selection_name
-            return result
+                agg_block: Block = block.make_block(result)
 
-        if isinstance(values[0], Series):
-            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
-        elif isinstance(values[0], DataFrame):
-            # possible that Series -> DataFrame by applied function
-            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
-        else:
-            # GH #6265 #24880
-            result = Series(data=values, index=_get_index(), name=self._selection_name)
-            return self._reindex_output(result)
-
-    def _aggregate_named(self, func, *args, **kwargs):
-        result = OrderedDict()
+            new_items.append(locs)
+            agg_blocks.append(agg_block)
 
-        for name, group in self:
-            group.name = name
-            output = func(group, *args, **kwargs)
-            if isinstance(output, (Series, Index, np.ndarray)):
-                raise ValueError("Must produce aggregated value")
-            result[name] = self._try_cast(output, group)
+        if not (agg_blocks or split_frames):
+            raise DataError("No numeric types to aggregate")
 
-        return result
+        if split_items:
+            # Clean up the mess left over from split blocks.
+            for locs, result in zip(split_items, split_frames):
+                assert len(locs) == result.shape[1]
+                for i, loc in enumerate(locs):
+                    new_items.append(np.array([loc], dtype=locs.dtype))
+                    agg_blocks.append(result.iloc[:, [i]]._data.blocks[0])
 
-    @Substitution(klass="Series", selected="A.")
-    @Appender(_transform_template)
-    def transform(self, func, *args, **kwargs):
-        func = self._get_cython_func(func) or func
+        # reset the locs in the blocks to correspond to our
+        # current ordering
+        indexer = np.concatenate(new_items)
+        agg_items = data.items.take(np.sort(indexer))
 
-        if isinstance(func, str):
-            if not (func in base.transform_kernel_whitelist):
-                msg = "'{func}' is not a valid function name for transform(name)"
-                raise ValueError(msg.format(func=func))
-            if func in base.cythonized_kernels:
-                # cythonized transform or canned "agg+broadcast"
-                return getattr(self, func)(*args, **kwargs)
-            else:
-                # If func is a reduction, we need to broadcast the
-                # result to the whole group. Compute func result
-                # and deal with possible broadcasting below.
-                return self._transform_fast(
-                    lambda: getattr(self, func)(*args, **kwargs), func
-                )
+        if deleted_items:
 
-        # reg transform
-        klass = self._selected_obj.__class__
-        results = []
-        wrapper = lambda x: func(x, *args, **kwargs)
-        for name, group in self:
-            object.__setattr__(group, "name", name)
-            res = wrapper(group)
+            # we need to adjust the indexer to account for the
+            # items we have removed
+            # really should be done in internals :<
 
-            if isinstance(res, (ABCDataFrame, ABCSeries)):
-                res = res._values
+            deleted = np.concatenate(deleted_items)
+            ai = np.arange(len(data))
+            mask = np.zeros(len(data))
+            mask[deleted] = 1
+            indexer = (ai - mask.cumsum())[indexer]
 
-            indexer = self._get_index(name)
-            s = klass(res, indexer)
-            results.append(s)
+        offset = 0
+        for blk in agg_blocks:
+            loc = len(blk.mgr_locs)
+            blk.mgr_locs = indexer[offset : (offset + loc)]
+            offset += loc
 
-        # check for empty "results" to avoid concat ValueError
-        if results:
-            from pandas.core.reshape.concat import concat
+        return agg_blocks, agg_items
 
-            result = concat(results).sort_index()
-        else:
-            result = Series()
+    def _aggregate_frame(self, func, *args, **kwargs) -> DataFrame:
+        if self.grouper.nkeys != 1:
+            raise AssertionError("Number of keys must be 1")
 
-        # we will only try to coerce the result type if
-        # we have a numeric dtype, as these are *always* udfs
-        # the cython take a different path (and casting)
-        dtype = self._selected_obj.dtype
-        if is_numeric_dtype(dtype):
-            result = maybe_downcast_to_dtype(result, dtype)
+        axis = self.axis
+        obj = self._obj_with_exclusions
 
-        result.name = self._selected_obj.name
-        result.index = self._selected_obj.index
-        return result
+        result: Dict[Union[int, str], Union[NDFrame, np.ndarray]] = {}
+        if axis != obj._info_axis_number:
+            for name, data in self:
+                fres = func(data, *args, **kwargs)
+                result[name] = fres
+        else:
+            for name in self.indices:
+                data = self.get_group(name, obj=obj)
+                fres = func(data, *args, **kwargs)
+                result[name] = fres
 
-    def _transform_fast(self, func, func_nm):
-        """
-        fast version of transform, only applicable to
-        builtin/cythonizable functions
-        """
-        if isinstance(func, str):
-            func = getattr(self, func)
+        return self._wrap_frame_output(result, obj)
 
-        ids, _, ngroup = self.grouper.group_info
-        cast = self._transform_should_cast(func_nm)
-        out = algorithms.take_1d(func()._values, ids)
-        if cast:
-            out = self._try_cast(out, self.obj)
-        return Series(out, index=self.obj.index, name=self.obj.name)
+    def _aggregate_item_by_item(self, func, *args, **kwargs) -> DataFrame:
+        # only for axis==0
 
-    def filter(self, func, dropna=True, *args, **kwargs):  # noqa
-        """
-        Return a copy of a Series excluding elements from groups that
-        do not satisfy the boolean criterion specified by func.
+        obj = self._obj_with_exclusions
+        result: Dict[Union[int, str], NDFrame] = {}
+        cannot_agg = []
+        for item in obj:
+            data = obj[item]
+            colg = SeriesGroupBy(data, selection=item, grouper=self.grouper)
 
-        Parameters
-        ----------
-        func : function
-            To apply to each group. Should return True or False.
-        dropna : Drop groups that do not pass the filter. True by default;
-            if False, groups that evaluate False are filled with NaNs.
+            cast = self._transform_should_cast(func)
+            try:
+                result[item] = colg.aggregate(func, *args, **kwargs)
 
-        Examples
-        --------
-        >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
-        ...                           'foo', 'bar'],
-        ...                    'B' : [1, 2, 3, 4, 5, 6],
-        ...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
-        >>> grouped = df.groupby('A')
-        >>> df.groupby('A').B.filter(lambda x: x.mean() > 3.)
-        1    2
-        3    4
-        5    6
-        Name: B, dtype: int64
+            except ValueError as err:
+                if "Must produce aggregated value" in str(err):
+                    # raised in _aggregate_named, handle at higher level
+                    #  see test_apply_with_mutated_index
+                    raise
+                # otherwise we get here from an AttributeError in _make_wrapper
+                cannot_agg.append(item)
+                continue
 
-        Returns
-        -------
-        filtered : Series
-        """
-        if isinstance(func, str):
-            wrapper = lambda x: getattr(x, func)(*args, **kwargs)
-        else:
-            wrapper = lambda x: func(x, *args, **kwargs)
+            else:
+                if cast:
+                    result[item] = self._try_cast(result[item], data)
 
-        # Interpret np.nan as False.
-        def true_and_notna(x, *args, **kwargs):
-            b = wrapper(x, *args, **kwargs)
-            return b and notna(b)
+        result_columns = obj.columns
+        if cannot_agg:
+            result_columns = result_columns.drop(cannot_agg)
 
-        try:
-            indices = [
-                self._get_index(name) for name, group in self if true_and_notna(group)
-            ]
-        except ValueError:
-            raise TypeError("the filter must return a boolean result")
-        except TypeError:
-            raise TypeError("the filter must return a boolean result")
+        return DataFrame(result, columns=result_columns)
 
-        filtered = self._apply_filter(indices, dropna)
-        return filtered
+    def _wrap_applied_output(self, keys, values, not_indexed_same=False):
+        if len(keys) == 0:
+            return DataFrame(index=keys)
 
-    def nunique(self, dropna=True):
-        """
-        Return number of unique elements in the group.
+        key_names = self.grouper.names
 
-        Returns
-        -------
-        Series
-            Number of unique values within each group.
-        """
-        ids, _, _ = self.grouper.group_info
+        # GH12824.
+        def first_not_none(values):
+            try:
+                return next(com.not_none(*values))
+            except StopIteration:
+                return None
 
-        val = self.obj._internal_get_values()
+        v = first_not_none(values)
 
-        # GH 27951
-        # temporary fix while we wait for NumPy bug 12629 to be fixed
-        val[isna(val)] = np.datetime64("NaT")
+        if v is None:
+            # GH9684. If all values are None, then this will throw an error.
+            # We'd prefer it return an empty dataframe.
+            return DataFrame()
+        elif isinstance(v, DataFrame):
+            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
+        elif self.grouper.groupings is not None:
+            if len(self.grouper.groupings) > 1:
+                key_index = self.grouper.result_index
 
-        try:
-            sorter = np.lexsort((val, ids))
-        except TypeError:  # catches object dtypes
-            msg = "val.dtype must be object, got {}".format(val.dtype)
-            assert val.dtype == object, msg
-            val, _ = algorithms.factorize(val, sort=False)
-            sorter = np.lexsort((val, ids))
-            _isna = lambda a: a == -1
-        else:
-            _isna = isna
+            else:
+                ping = self.grouper.groupings[0]
+                if len(keys) == ping.ngroups:
+                    key_index = ping.group_index
+                    key_index.name = key_names[0]
 
-        ids, val = ids[sorter], val[sorter]
+                    key_lookup = Index(keys)
+                    indexer = key_lookup.get_indexer(key_index)
 
-        # group boundaries are where group ids change
-        # unique observations are where sorted values change
-        idx = np.r_[0, 1 + np.nonzero(ids[1:] != ids[:-1])[0]]
-        inc = np.r_[1, val[1:] != val[:-1]]
+                    # reorder the values
+                    values = [values[i] for i in indexer]
+                else:
 
-        # 1st item of each group is a new unique observation
-        mask = _isna(val)
-        if dropna:
-            inc[idx] = 1
-            inc[mask] = 0
-        else:
-            inc[mask & np.r_[False, mask[:-1]]] = 0
-            inc[idx] = 1
+                    key_index = Index(keys, name=key_names[0])
 
-        out = np.add.reduceat(inc, idx).astype("int64", copy=False)
-        if len(ids):
-            # NaN/NaT group exists if the head of ids is -1,
-            # so remove it from res and exclude its index from idx
-            if ids[0] == -1:
-                res = out[1:]
-                idx = idx[np.flatnonzero(idx)]
-            else:
-                res = out
-        else:
-            res = out[1:]
-        ri = self.grouper.result_index
+                # don't use the key indexer
+                if not self.as_index:
+                    key_index = None
 
-        # we might have duplications among the bins
-        if len(res) != len(ri):
-            res, out = np.zeros(len(ri), dtype=out.dtype), res
-            res[ids[idx]] = out
+            # make Nones an empty object
+            v = first_not_none(values)
+            if v is None:
+                return DataFrame()
+            elif isinstance(v, NDFrame):
 
-        return Series(res, index=ri, name=self._selection_name)
+                # this is to silence a DeprecationWarning
+                # TODO: Remove when default dtype of empty Series is object
+                kwargs = v._construct_axes_dict()
+                if v._constructor is Series:
+                    backup = create_series_with_explicit_dtype(
+                        **kwargs, dtype_if_empty=object
+                    )
+                else:
+                    backup = v._constructor(**kwargs)
 
-    @Appender(Series.describe.__doc__)
-    def describe(self, **kwargs):
-        result = self.apply(lambda x: x.describe(**kwargs))
-        if self.axis == 1:
-            return result.T
-        return result.unstack()
+                values = [x if (x is not None) else backup for x in values]
 
-    def value_counts(
-        self, normalize=False, sort=True, ascending=False, bins=None, dropna=True
-    ):
+            v = values[0]
 
-        from pandas.core.reshape.tile import cut
-        from pandas.core.reshape.merge import _get_join_indexers
+            if isinstance(v, (np.ndarray, Index, Series)):
+                if isinstance(v, Series):
+                    applied_index = self._selected_obj._get_axis(self.axis)
+                    all_indexed_same = all_indexes_same([x.index for x in values])
+                    singular_series = len(values) == 1 and applied_index.nlevels == 1
 
-        if bins is not None and not np.iterable(bins):
-            # scalar bins cannot be done at top level
-            # in a backward compatible way
-            return self.apply(
-                Series.value_counts,
-                normalize=normalize,
-                sort=sort,
-                ascending=ascending,
-                bins=bins,
-            )
+                    # GH3596
+                    # provide a reduction (Frame -> Series) if groups are
+                    # unique
+                    if self.squeeze:
+                        # assign the name to this series
+                        if singular_series:
+                            values[0].name = keys[0]
 
-        ids, _, _ = self.grouper.group_info
-        val = self.obj._internal_get_values()
+                            # GH2893
+                            # we have series in the values array, we want to
+                            # produce a series:
+                            # if any of the sub-series are not indexed the same
+                            # OR we don't have a multi-index and we have only a
+                            # single values
+                            return self._concat_objects(
+                                keys, values, not_indexed_same=not_indexed_same
+                            )
 
-        # groupby removes null keys from groupings
-        mask = ids != -1
-        ids, val = ids[mask], val[mask]
+                        # still a series
+                        # path added as of GH 5545
+                        elif all_indexed_same:
+                            from pandas.core.reshape.concat import concat
 
-        if bins is None:
-            lab, lev = algorithms.factorize(val, sort=True)
-            llab = lambda lab, inc: lab[inc]
-        else:
+                            return concat(values)
 
-            # lab is a Categorical with categories an IntervalIndex
-            lab = cut(Series(val), bins, include_lowest=True)
-            lev = lab.cat.categories
-            lab = lev.take(lab.cat.codes)
-            llab = lambda lab, inc: lab[inc]._multiindex.codes[-1]
+                    if not all_indexed_same:
+                        # GH 8467
+                        return self._concat_objects(keys, values, not_indexed_same=True)
 
-        if is_interval_dtype(lab):
-            # TODO: should we do this inside II?
-            sorter = np.lexsort((lab.left, lab.right, ids))
-        else:
-            sorter = np.lexsort((lab, ids))
+                if self.axis == 0 and isinstance(v, ABCSeries):
+                    # GH6124 if the list of Series have a consistent name,
+                    # then propagate that name to the result.
+                    index = v.index.copy()
+                    if index.name is None:
+                        # Only propagate the series name to the result
+                        # if all series have a consistent name.  If the
+                        # series do not have a consistent name, do
+                        # nothing.
+                        names = {v.name for v in values}
+                        if len(names) == 1:
+                            index.name = list(names)[0]
+
+                    # normally use vstack as its faster than concat
+                    # and if we have mi-columns
+                    if (
+                        isinstance(v.index, MultiIndex)
+                        or key_index is None
+                        or isinstance(key_index, MultiIndex)
+                    ):
+                        stacked_values = np.vstack([np.asarray(v) for v in values])
+                        result = DataFrame(
+                            stacked_values, index=key_index, columns=index
+                        )
+                    else:
+                        # GH5788 instead of stacking; concat gets the
+                        # dtypes correct
+                        from pandas.core.reshape.concat import concat
+
+                        result = concat(
+                            values,
+                            keys=key_index,
+                            names=key_index.names,
+                            axis=self.axis,
+                        ).unstack()
+                        result.columns = index
+                elif isinstance(v, ABCSeries):
+                    stacked_values = np.vstack([np.asarray(v) for v in values])
+                    result = DataFrame(
+                        stacked_values.T, index=v.index, columns=key_index
+                    )
+                else:
+                    # GH#1738: values is list of arrays of unequal lengths
+                    #  fall through to the outer else clause
+                    # TODO: sure this is right?  we used to do this
+                    #  after raising AttributeError above
+                    return Series(values, index=key_index, name=self._selection_name)
 
-        ids, lab = ids[sorter], lab[sorter]
+                # if we have date/time like in the original, then coerce dates
+                # as we are stacking can easily have object dtypes here
+                so = self._selected_obj
+                if so.ndim == 2 and so.dtypes.apply(needs_i8_conversion).any():
+                    result = _recast_datetimelike_result(result)
+                else:
+                    result = result._convert(datetime=True)
 
-        # group boundaries are where group ids change
-        idx = np.r_[0, 1 + np.nonzero(ids[1:] != ids[:-1])[0]]
+                return self._reindex_output(result)
 
-        # new values are where sorted labels change
-        lchanges = llab(lab, slice(1, None)) != llab(lab, slice(None, -1))
-        inc = np.r_[True, lchanges]
-        inc[idx] = True  # group boundaries are also new values
-        out = np.diff(np.nonzero(np.r_[inc, True])[0])  # value counts
+            # values are not series or array-like but scalars
+            else:
+                # only coerce dates if we find at least 1 datetime
+                should_coerce = any(isinstance(x, Timestamp) for x in values)
+                # self._selection_name not passed through to Series as the
+                # result should not take the name of original selection
+                # of columns
+                return Series(values, index=key_index)._convert(
+                    datetime=True, coerce=should_coerce
+                )
 
-        # num. of times each group should be repeated
-        rep = partial(np.repeat, repeats=np.add.reduceat(inc, idx))
+        else:
+            # Handle cases like BinGrouper
+            return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
 
-        # multi-index components
-        labels = list(map(rep, self.grouper.recons_labels)) + [llab(lab, inc)]
-        levels = [ping.group_index for ping in self.grouper.groupings] + [lev]
-        names = self.grouper.names + [self._selection_name]
+    def _transform_general(self, func, *args, **kwargs):
+        from pandas.core.reshape.concat import concat
 
-        if dropna:
-            mask = labels[-1] != -1
-            if mask.all():
-                dropna = False
-            else:
-                out, labels = out[mask], [label[mask] for label in labels]
+        applied = []
+        obj = self._obj_with_exclusions
+        gen = self.grouper.get_iterator(obj, axis=self.axis)
+        fast_path, slow_path = self._define_paths(func, *args, **kwargs)
 
-        if normalize:
-            out = out.astype("float")
-            d = np.diff(np.r_[idx, len(ids)])
-            if dropna:
-                m = ids[lab == -1]
-                np.add.at(d, m, -1)
-                acc = rep(d)[mask]
-            else:
-                acc = rep(d)
-            out /= acc
+        path = None
+        for name, group in gen:
+            object.__setattr__(group, "name", name)
 
-        if sort and bins is None:
-            cat = ids[inc][mask] if dropna else ids[inc]
-            sorter = np.lexsort((out if ascending else -out, cat))
-            out, labels[-1] = out[sorter], labels[-1][sorter]
+            if path is None:
+                # Try slow path and fast path.
+                try:
+                    path, res = self._choose_path(fast_path, slow_path, group)
+                except TypeError:
+                    return self._transform_item_by_item(obj, fast_path)
+                except ValueError:
+                    msg = "transform must return a scalar value for each group"
+                    raise ValueError(msg)
+            else:
+                res = path(group)
 
-        if bins is None:
-            mi = MultiIndex(
-                levels=levels, codes=labels, names=names, verify_integrity=False
-            )
+            if isinstance(res, Series):
 
-            if is_integer_dtype(out):
-                out = ensure_int64(out)
-            return Series(out, index=mi, name=self._selection_name)
+                # we need to broadcast across the
+                # other dimension; this will preserve dtypes
+                # GH14457
+                if not np.prod(group.shape):
+                    continue
+                elif res.index.is_(obj.index):
+                    r = concat([res] * len(group.columns), axis=1)
+                    r.columns = group.columns
+                    r.index = group.index
+                else:
+                    r = DataFrame(
+                        np.concatenate([res.values] * len(group.index)).reshape(
+                            group.shape
+                        ),
+                        columns=group.columns,
+                        index=group.index,
+                    )
 
-        # for compat. with libgroupby.value_counts need to ensure every
-        # bin is present at every index level, null filled with zeros
-        diff = np.zeros(len(out), dtype="bool")
-        for lab in labels[:-1]:
-            diff |= np.r_[True, lab[1:] != lab[:-1]]
+                applied.append(r)
+            else:
+                applied.append(res)
 
-        ncat, nbin = diff.sum(), len(levels[-1])
+        concat_index = obj.columns if self.axis == 0 else obj.index
+        other_axis = 1 if self.axis == 0 else 0  # switches between 0 & 1
+        concatenated = concat(applied, axis=self.axis, verify_integrity=False)
+        concatenated = concatenated.reindex(concat_index, axis=other_axis, copy=False)
+        return self._set_result_index_ordered(concatenated)
 
-        left = [np.repeat(np.arange(ncat), nbin), np.tile(np.arange(nbin), ncat)]
+    @Substitution(klass="DataFrame", selected="")
+    @Appender(_transform_template)
+    def transform(self, func, *args, **kwargs):
 
-        right = [diff.cumsum() - 1, labels[-1]]
+        # optimized transforms
+        func = self._get_cython_func(func) or func
 
-        _, idx = _get_join_indexers(left, right, sort=False, how="left")
-        out = np.where(idx != -1, out[idx], 0)
+        if not isinstance(func, str):
+            return self._transform_general(func, *args, **kwargs)
 
-        if sort:
-            sorter = np.lexsort((out if ascending else -out, left[0]))
-            out, left[-1] = out[sorter], left[-1][sorter]
+        elif func not in base.transform_kernel_whitelist:
+            msg = f"'{func}' is not a valid function name for transform(name)"
+            raise ValueError(msg)
+        elif func in base.cythonized_kernels:
+            # cythonized transformation or canned "reduction+broadcast"
+            return getattr(self, func)(*args, **kwargs)
 
-        # build the multi-index w/ full levels
-        codes = list(map(lambda lab: np.repeat(lab[diff], nbin), labels[:-1]))
-        codes.append(left[-1])
+        # GH 30918
+        # Use _transform_fast only when we know func is an aggregation
+        if func in base.reduction_kernels:
+            # If func is a reduction, we need to broadcast the
+            # result to the whole group. Compute func result
+            # and deal with possible broadcasting below.
+            result = getattr(self, func)(*args, **kwargs)
 
-        mi = MultiIndex(levels=levels, codes=codes, names=names, verify_integrity=False)
+            if isinstance(result, DataFrame) and result.columns.equals(
+                self._obj_with_exclusions.columns
+            ):
+                return self._transform_fast(result, func)
 
-        if is_integer_dtype(out):
-            out = ensure_int64(out)
-        return Series(out, index=mi, name=self._selection_name)
+        return self._transform_general(func, *args, **kwargs)
 
-    def count(self):
+    def _transform_fast(self, result: DataFrame, func_nm: str) -> DataFrame:
         """
-        Compute count of group, excluding missing values.
-
-        Returns
-        -------
-        Series
-            Count of values within each group.
+        Fast transform path for aggregations
         """
-        ids, _, ngroups = self.grouper.group_info
-        val = self.obj._internal_get_values()
+        # if there were groups with no observations (Categorical only?)
+        # try casting data to original dtype
+        cast = self._transform_should_cast(func_nm)
 
-        mask = (ids != -1) & ~isna(val)
-        ids = ensure_platform_int(ids)
-        minlength = ngroups or 0
-        out = np.bincount(ids[mask], minlength=minlength)
+        obj = self._obj_with_exclusions
 
-        return Series(
-            out,
-            index=self.grouper.result_index,
-            name=self._selection_name,
-            dtype="int64",
-        )
+        # for each col, reshape to to size of original frame
+        # by take operation
+        ids, _, ngroup = self.grouper.group_info
+        output = []
+        for i, _ in enumerate(result.columns):
+            res = algorithms.take_1d(result.iloc[:, i].values, ids)
+            # TODO: we have no test cases that get here with EA dtypes;
+            #  try_cast may not be needed if EAs never get here
+            if cast:
+                res = self._try_cast(res, obj.iloc[:, i])
+            output.append(res)
 
-    def _apply_to_column_groupbys(self, func):
-        """ return a pass thru """
-        return func(self)
+        return DataFrame._from_arrays(output, columns=result.columns, index=obj.index)
 
-    def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None):
-        """Calculate pct_change of each value to previous entry in group"""
-        # TODO: Remove this conditional when #23918 is fixed
-        if freq:
-            return self.apply(
-                lambda x: x.pct_change(
-                    periods=periods, fill_method=fill_method, limit=limit, freq=freq
-                )
+    def _define_paths(self, func, *args, **kwargs):
+        if isinstance(func, str):
+            fast_path = lambda group: getattr(group, func)(*args, **kwargs)
+            slow_path = lambda group: group.apply(
+                lambda x: getattr(x, func)(*args, **kwargs), axis=self.axis
+            )
+        else:
+            fast_path = lambda group: func(group, *args, **kwargs)
+            slow_path = lambda group: group.apply(
+                lambda x: func(x, *args, **kwargs), axis=self.axis
             )
-        filled = getattr(self, fill_method)(limit=limit)
-        fill_grp = filled.groupby(self.grouper.labels)
-        shifted = fill_grp.shift(periods=periods, freq=freq)
-
-        return (filled / shifted) - 1
+        return fast_path, slow_path
 
+    def _choose_path(self, fast_path: Callable, slow_path: Callable, group: DataFrame):
+        path = slow_path
+        res = slow_path(group)
 
-class DataFrameGroupBy(NDFrameGroupBy):
+        # if we make it here, test if we can use the fast path
+        try:
+            res_fast = fast_path(group)
+        except AssertionError:
+            raise
+        except Exception:
+            # GH#29631 For user-defined function, we cant predict what may be
+            #  raised; see test_transform.test_transform_fastpath_raises
+            return path, res
 
-    _apply_whitelist = base.dataframe_apply_whitelist
+        # verify fast path does not change columns (and names), otherwise
+        # its results cannot be joined with those of the slow path
+        if not isinstance(res_fast, DataFrame):
+            return path, res
 
-    #
-    # Make class defs of attributes on DataFrameGroupBy whitelist.
-    for _def_str in whitelist_method_generator(GroupBy, DataFrame, _apply_whitelist):
-        exec(_def_str)
+        if not res_fast.columns.equals(group.columns):
+            return path, res
 
-    _block_agg_axis = 1
+        if res_fast.equals(res):
+            path = fast_path
 
-    _agg_see_also_doc = dedent(
-        """
-    See Also
-    --------
-    pandas.DataFrame.groupby.apply
-    pandas.DataFrame.groupby.transform
-    pandas.DataFrame.aggregate
-    """
-    )
+        return path, res
 
-    _agg_examples_doc = dedent(
-        """
-    Examples
-    --------
+    def _transform_item_by_item(self, obj: DataFrame, wrapper) -> DataFrame:
+        # iterate through columns
+        output = {}
+        inds = []
+        for i, col in enumerate(obj):
+            try:
+                output[col] = self[col].transform(wrapper)
+            except TypeError:
+                # e.g. trying to call nanmean with string values
+                pass
+            else:
+                inds.append(i)
 
-    >>> df = pd.DataFrame({'A': [1, 1, 2, 2],
-    ...                    'B': [1, 2, 3, 4],
-    ...                    'C': np.random.randn(4)})
+        if len(output) == 0:
+            raise TypeError("Transform function invalid for data types")
 
-    >>> df
-       A  B         C
-    0  1  1  0.362838
-    1  1  2  0.227877
-    2  2  3  1.267767
-    3  2  4 -0.562860
+        columns = obj.columns
+        if len(output) < len(obj.columns):
+            columns = columns.take(inds)
 
-    The aggregation is for each column.
+        return DataFrame(output, index=obj.index, columns=columns)
 
-    >>> df.groupby('A').agg('min')
-       B         C
-    A
-    1  1  0.227877
-    2  3 -0.562860
+    def filter(self, func, dropna=True, *args, **kwargs):
+        """
+        Return a copy of a DataFrame excluding elements from groups that
+        do not satisfy the boolean criterion specified by func.
 
-    Multiple aggregations
+        Parameters
+        ----------
+        f : function
+            Function to apply to each subframe. Should return True or False.
+        dropna : Drop groups that do not pass the filter. True by default;
+            If False, groups that evaluate False are filled with NaNs.
 
-    >>> df.groupby('A').agg(['min', 'max'])
-        B             C
-      min max       min       max
-    A
-    1   1   2  0.227877  0.362838
-    2   3   4 -0.562860  1.267767
+        Returns
+        -------
+        filtered : DataFrame
 
-    Select a column for aggregation
+        Notes
+        -----
+        Each subframe is endowed the attribute 'name' in case you need to know
+        which group you are working on.
 
-    >>> df.groupby('A').B.agg(['min', 'max'])
-       min  max
-    A
-    1    1    2
-    2    3    4
+        Examples
+        --------
+        >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
+        ...                           'foo', 'bar'],
+        ...                    'B' : [1, 2, 3, 4, 5, 6],
+        ...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
+        >>> grouped = df.groupby('A')
+        >>> grouped.filter(lambda x: x['B'].mean() > 3.)
+             A  B    C
+        1  bar  2  5.0
+        3  bar  4  1.0
+        5  bar  6  9.0
+        """
 
-    Different aggregations per column
+        indices = []
 
-    >>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
-        B             C
-      min max       sum
-    A
-    1   1   2  0.590716
-    2   3   4  0.704907
+        obj = self._selected_obj
+        gen = self.grouper.get_iterator(obj, axis=self.axis)
 
-    To control the output names with different aggregations per column,
-    pandas supports "named aggregation"
+        for name, group in gen:
+            object.__setattr__(group, "name", name)
 
-    >>> df.groupby("A").agg(
-    ...     b_min=pd.NamedAgg(column="B", aggfunc="min"),
-    ...     c_sum=pd.NamedAgg(column="C", aggfunc="sum"))
-       b_min     c_sum
-    A
-    1      1 -1.956929
-    2      3 -0.322183
+            res = func(group, *args, **kwargs)
 
-    - The keywords are the *output* column names
-    - The values are tuples whose first element is the column to select
-      and the second element is the aggregation to apply to that column.
-      Pandas provides the ``pandas.NamedAgg`` namedtuple with the fields
-      ``['column', 'aggfunc']`` to make it clearer what the arguments are.
-      As usual, the aggregation can be a callable or a string alias.
+            try:
+                res = res.squeeze()
+            except AttributeError:  # allow e.g., scalars and frames to pass
+                pass
 
-    See :ref:`groupby.aggregate.named` for more.
-    """
-    )
+            # interpret the result of the filter
+            if is_bool(res) or (is_scalar(res) and isna(res)):
+                if res and notna(res):
+                    indices.append(self._get_index(name))
+            else:
+                # non scalars aren't allowed
+                raise TypeError(
+                    f"filter function returned a {type(res).__name__}, "
+                    "but expected a scalar bool"
+                )
 
-    @Substitution(
-        see_also=_agg_see_also_doc,
-        examples=_agg_examples_doc,
-        versionadded="",
-        klass="DataFrame",
-        axis="",
-    )
-    @Appender(_shared_docs["aggregate"])
-    def aggregate(self, func=None, *args, **kwargs):
-        return super().aggregate(func, *args, **kwargs)
+        return self._apply_filter(indices, dropna)
 
-    agg = aggregate
+    def __getitem__(self, key):
+        # per GH 23566
+        if isinstance(key, tuple) and len(key) > 1:
+            # if len == 1, then it becomes a SeriesGroupBy and this is actually
+            # valid syntax, so don't raise warning
+            warnings.warn(
+                "Indexing with multiple keys (implicitly converted to a tuple "
+                "of keys) will be deprecated, use a list instead.",
+                FutureWarning,
+                stacklevel=2,
+            )
+        return super().__getitem__(key)
 
-    def _gotitem(self, key, ndim, subset=None):
+    def _gotitem(self, key, ndim: int, subset=None):
         """
         sub-classes to define
         return a sliced object
@@ -1516,7 +1648,7 @@ def _gotitem(self, key, ndim, subset=None):
 
         raise AssertionError("invalid ndim for _gotitem")
 
-    def _wrap_generic_output(self, result, obj):
+    def _wrap_frame_output(self, result, obj) -> DataFrame:
         result_index = self.grouper.levels[0]
 
         if self.axis == 0:
@@ -1524,12 +1656,12 @@ def _wrap_generic_output(self, result, obj):
         else:
             return DataFrame(result, index=obj.index, columns=result_index)
 
-    def _get_data_to_aggregate(self):
+    def _get_data_to_aggregate(self) -> BlockManager:
         obj = self._obj_with_exclusions
         if self.axis == 1:
-            return obj.T._data, 1
+            return obj.T._data
         else:
-            return obj._data, 1
+            return obj._data
 
     def _insert_inaxis_grouper_inplace(self, result):
         # zip in reverse so we can always insert at loc 0
@@ -1548,39 +1680,74 @@ def _insert_inaxis_grouper_inplace(self, result):
             if in_axis:
                 result.insert(0, name, lev)
 
-    def _wrap_aggregated_output(self, output, names=None):
-        agg_axis = 0 if self.axis == 1 else 1
-        agg_labels = self._obj_with_exclusions._get_axis(agg_axis)
+    def _wrap_aggregated_output(
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]]
+    ) -> DataFrame:
+        """
+        Wraps the output of DataFrameGroupBy aggregations into the expected result.
+
+        Parameters
+        ----------
+        output : Mapping[base.OutputKey, Union[Series, np.ndarray]]
+           Data to wrap.
+
+        Returns
+        -------
+        DataFrame
+        """
+        indexed_output = {key.position: val for key, val in output.items()}
+        columns = Index(key.label for key in output)
 
-        output_keys = self._decide_output_index(output, agg_labels)
+        result = DataFrame(indexed_output)
+        result.columns = columns
 
         if not self.as_index:
-            result = DataFrame(output, columns=output_keys)
             self._insert_inaxis_grouper_inplace(result)
             result = result._consolidate()
         else:
             index = self.grouper.result_index
-            result = DataFrame(output, index=index, columns=output_keys)
+            result.index = index
 
         if self.axis == 1:
             result = result.T
 
         return self._reindex_output(result)._convert(datetime=True)
 
-    def _wrap_transformed_output(self, output, names=None):
-        return DataFrame(output, index=self.obj.index)
+    def _wrap_transformed_output(
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]]
+    ) -> DataFrame:
+        """
+        Wraps the output of DataFrameGroupBy transformations into the expected result.
+
+        Parameters
+        ----------
+        output : Mapping[base.OutputKey, Union[Series, np.ndarray]]
+            Data to wrap.
+
+        Returns
+        -------
+        DataFrame
+        """
+        indexed_output = {key.position: val for key, val in output.items()}
+        columns = Index(key.label for key in output)
+
+        result = DataFrame(indexed_output)
+        result.columns = columns
+        result.index = self.obj.index
+
+        return result
 
-    def _wrap_agged_blocks(self, items, blocks):
+    def _wrap_agged_blocks(self, blocks: "Sequence[Block]", items: Index) -> DataFrame:
         if not self.as_index:
             index = np.arange(blocks[0].values.shape[-1])
-            mgr = BlockManager(blocks, [items, index])
+            mgr = BlockManager(blocks, axes=[items, index])
             result = DataFrame(mgr)
 
             self._insert_inaxis_grouper_inplace(result)
             result = result._consolidate()
         else:
             index = self.grouper.result_index
-            mgr = BlockManager(blocks, [items, index])
+            mgr = BlockManager(blocks, axes=[items, index])
             result = DataFrame(mgr)
 
         if self.axis == 1:
@@ -1615,31 +1782,31 @@ def count(self):
         DataFrame
             Count of values within each group.
         """
-        data, _ = self._get_data_to_aggregate()
+        data = self._get_data_to_aggregate()
         ids, _, ngroups = self.grouper.group_info
         mask = ids != -1
 
-        val = (
+        vals = (
             (mask & ~_isna_ndarraylike(np.atleast_2d(blk.get_values())))
             for blk in data.blocks
         )
-        loc = (blk.mgr_locs for blk in data.blocks)
+        locs = (blk.mgr_locs for blk in data.blocks)
 
-        counter = partial(lib.count_level_2d, labels=ids, max_bin=ngroups, axis=1)
-        blk = map(make_block, map(counter, val), loc)
+        counted = (
+            lib.count_level_2d(x, labels=ids, max_bin=ngroups, axis=1) for x in vals
+        )
+        blocks = [make_block(val, placement=loc) for val, loc in zip(counted, locs)]
 
-        return self._wrap_agged_blocks(data.items, list(blk))
+        return self._wrap_agged_blocks(blocks, items=data.items)
 
-    def nunique(self, dropna=True):
+    def nunique(self, dropna: bool = True):
         """
         Return DataFrame with number of distinct observations per group for
         each column.
 
-        .. versionadded:: 0.20.0
-
         Parameters
         ----------
-        dropna : boolean, default True
+        dropna : bool, default True
             Don't include NaN in the counts.
 
         Returns
@@ -1688,11 +1855,24 @@ def groupby_series(obj, col=None):
         if isinstance(obj, Series):
             results = groupby_series(obj)
         else:
+            # TODO: this is duplicative of how GroupBy naturally works
+            # Try to consolidate with normal wrapping functions
             from pandas.core.reshape.concat import concat
 
-            results = [groupby_series(obj[col], col) for col in obj.columns]
+            axis_number = obj._get_axis_number(self.axis)
+            other_axis = int(not axis_number)
+            if axis_number == 0:
+                iter_func = obj.items
+            else:
+                iter_func = obj.iterrows
+
+            results = [groupby_series(content, label) for label, content in iter_func()]
             results = concat(results, axis=1)
-            results.columns.names = obj.columns.names
+
+            if axis_number == 1:
+                results = results.T
+
+            results._get_axis(other_axis).names = obj._get_axis(other_axis).names
 
         if not self.as_index:
             results.index = ibase.default_index(len(results))
@@ -1701,196 +1881,6 @@ def groupby_series(obj, col=None):
     boxplot = boxplot_frame_groupby
 
 
-def _is_multi_agg_with_relabel(**kwargs):
-    """
-    Check whether kwargs passed to .agg look like multi-agg with relabeling.
-
-    Parameters
-    ----------
-    **kwargs : dict
-
-    Returns
-    -------
-    bool
-
-    Examples
-    --------
-    >>> _is_multi_agg_with_relabel(a='max')
-    False
-    >>> _is_multi_agg_with_relabel(a_max=('a', 'max'),
-    ...                            a_min=('a', 'min'))
-    True
-    >>> _is_multi_agg_with_relabel()
-    False
-    """
-    return all(isinstance(v, tuple) and len(v) == 2 for v in kwargs.values()) and kwargs
-
-
-def _normalize_keyword_aggregation(kwargs):
-    """
-    Normalize user-provided "named aggregation" kwargs.
-
-    Transforms from the new ``Dict[str, NamedAgg]`` style kwargs
-    to the old OrderedDict[str, List[scalar]]].
-
-    Parameters
-    ----------
-    kwargs : dict
-
-    Returns
-    -------
-    aggspec : dict
-        The transformed kwargs.
-    columns : List[str]
-        The user-provided keys.
-    col_idx_order : List[int]
-        List of columns indices.
-
-    Examples
-    --------
-    >>> _normalize_keyword_aggregation({'output': ('input', 'sum')})
-    (OrderedDict([('input', ['sum'])]), ('output',), [('input', 'sum')])
-    """
-    if not PY36:
-        kwargs = OrderedDict(sorted(kwargs.items()))
-
-    # Normalize the aggregation functions as Dict[column, List[func]],
-    # process normally, then fixup the names.
-    # TODO(Py35): When we drop python 3.5, change this to
-    # defaultdict(list)
-    # TODO: aggspec type: typing.OrderedDict[str, List[AggScalar]]
-    # May be hitting https://github.com/python/mypy/issues/5958
-    # saying it doesn't have an attribute __name__
-    aggspec = OrderedDict()
-    order = []
-    columns, pairs = list(zip(*kwargs.items()))
-
-    for name, (column, aggfunc) in zip(columns, pairs):
-        if column in aggspec:
-            aggspec[column].append(aggfunc)
-        else:
-            aggspec[column] = [aggfunc]
-        order.append((column, com.get_callable_name(aggfunc) or aggfunc))
-
-    # uniquify aggfunc name if duplicated in order list
-    uniquified_order = _make_unique(order)
-
-    # GH 25719, due to aggspec will change the order of assigned columns in aggregation
-    # uniquified_aggspec will store uniquified order list and will compare it with order
-    # based on index
-    aggspec_order = [
-        (column, com.get_callable_name(aggfunc) or aggfunc)
-        for column, aggfuncs in aggspec.items()
-        for aggfunc in aggfuncs
-    ]
-    uniquified_aggspec = _make_unique(aggspec_order)
-
-    # get the new indice of columns by comparison
-    col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
-    return aggspec, columns, col_idx_order
-
-
-def _make_unique(seq):
-    """Uniquify aggfunc name of the pairs in the order list
-
-    Examples:
-    --------
-    >>> _make_unique([('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')])
-    [('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
-    """
-    return [
-        (pair[0], "_".join([pair[1], str(seq[:i].count(pair))]))
-        if seq.count(pair) > 1
-        else pair
-        for i, pair in enumerate(seq)
-    ]
-
-
-# TODO: Can't use, because mypy doesn't like us setting __name__
-#   error: "partial[Any]" has no attribute "__name__"
-# the type is:
-#   typing.Sequence[Callable[..., ScalarResult]]
-#     -> typing.Sequence[Callable[..., ScalarResult]]:
-
-
-def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
-    """
-    Possibly mangle a list of aggfuncs.
-
-    Parameters
-    ----------
-    aggfuncs : Sequence
-
-    Returns
-    -------
-    mangled: list-like
-        A new AggSpec sequence, where lambdas have been converted
-        to have unique names.
-
-    Notes
-    -----
-    If just one aggfunc is passed, the name will not be mangled.
-    """
-    if len(aggfuncs) <= 1:
-        # don't mangle for .agg([lambda x: .])
-        return aggfuncs
-    i = 0
-    mangled_aggfuncs = []
-    for aggfunc in aggfuncs:
-        if com.get_callable_name(aggfunc) == "<lambda>":
-            aggfunc = functools.partial(aggfunc)
-            aggfunc.__name__ = "<lambda_{}>".format(i)
-            i += 1
-        mangled_aggfuncs.append(aggfunc)
-
-    return mangled_aggfuncs
-
-
-def _maybe_mangle_lambdas(agg_spec: Any) -> Any:
-    """
-    Make new lambdas with unique names.
-
-    Parameters
-    ----------
-    agg_spec : Any
-        An argument to NDFrameGroupBy.agg.
-        Non-dict-like `agg_spec` are pass through as is.
-        For dict-like `agg_spec` a new spec is returned
-        with name-mangled lambdas.
-
-    Returns
-    -------
-    mangled : Any
-        Same type as the input.
-
-    Examples
-    --------
-    >>> _maybe_mangle_lambdas('sum')
-    'sum'
-
-    >>> _maybe_mangle_lambdas([lambda: 1, lambda: 2])  # doctest: +SKIP
-    [<function __main__.<lambda_0>,
-     <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
-    """
-    is_dict = is_dict_like(agg_spec)
-    if not (is_dict or is_list_like(agg_spec)):
-        return agg_spec
-    mangled_aggspec = type(agg_spec)()  # dict or OrderdDict
-
-    if is_dict:
-        for key, aggfuncs in agg_spec.items():
-            if is_list_like(aggfuncs) and not is_dict_like(aggfuncs):
-                mangled_aggfuncs = _managle_lambda_list(aggfuncs)
-            else:
-                mangled_aggfuncs = aggfuncs
-
-            mangled_aggspec[key] = mangled_aggfuncs
-    else:
-        mangled_aggspec = _managle_lambda_list(agg_spec)
-
-    return mangled_aggspec
-
-
 def _recast_datetimelike_result(result: DataFrame) -> DataFrame:
     """
     If we have date/time like in the original, then coerce dates
@@ -1912,7 +1902,9 @@ def _recast_datetimelike_result(result: DataFrame) -> DataFrame:
     result = result.copy()
 
     obj_cols = [
-        idx for idx in range(len(result.columns)) if is_object_dtype(result.dtypes[idx])
+        idx
+        for idx in range(len(result.columns))
+        if is_object_dtype(result.dtypes.iloc[idx])
     ]
 
     # See GH#26285
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index e010e615e176e..153bf386d4f33 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -4,15 +4,28 @@ class providing the base-class of operations.
 
 The SeriesGroupBy and DataFrameGroupBy sub-class
 (defined in pandas.core.groupby.generic)
-expose these user-facing objects to provide specific functionailty.
+expose these user-facing objects to provide specific functionality.
 """
 
-import collections
 from contextlib import contextmanager
 import datetime
 from functools import partial, wraps
+import inspect
+import re
 import types
-from typing import FrozenSet, List, Optional, Tuple, Type, Union
+from typing import (
+    Callable,
+    Dict,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 
 import numpy as np
 
@@ -20,17 +33,16 @@ class providing the base-class of operations.
 
 from pandas._libs import Timestamp
 import pandas._libs.groupby as libgroupby
+from pandas._typing import FrameOrSeries, Scalar
 from pandas.compat import set_function_name
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import Appender, Substitution, cache_readonly
-from pandas.util._validators import validate_kwargs
 
 from pandas.core.dtypes.cast import maybe_downcast_to_dtype
 from pandas.core.dtypes.common import (
     ensure_float,
     is_datetime64_dtype,
-    is_datetime64tz_dtype,
     is_extension_array_dtype,
     is_integer_dtype,
     is_numeric_dtype,
@@ -39,21 +51,15 @@ class providing the base-class of operations.
 )
 from pandas.core.dtypes.missing import isna, notna
 
+from pandas.core import nanops
 import pandas.core.algorithms as algorithms
-from pandas.core.arrays import Categorical
-from pandas.core.base import (
-    DataError,
-    GroupByError,
-    PandasObject,
-    SelectionMixin,
-    SpecificationError,
-)
+from pandas.core.arrays import Categorical, DatetimeArray, try_cast_to_ea
+from pandas.core.base import DataError, PandasObject, SelectionMixin
 import pandas.core.common as com
-from pandas.core.construction import extract_array
 from pandas.core.frame import DataFrame
 from pandas.core.generic import NDFrame
-from pandas.core.groupby import base
-from pandas.core.index import CategoricalIndex, Index, MultiIndex
+from pandas.core.groupby import base, ops
+from pandas.core.indexes.api import CategoricalIndex, Index, MultiIndex
 from pandas.core.series import Series
 from pandas.core.sorting import get_group_index_sorter
 
@@ -66,7 +72,7 @@ class providing the base-class of operations.
 
 _apply_docs = dict(
     template="""
-    Apply function `func`  group-wise and combine the results together.
+    Apply function `func` group-wise and combine the results together.
 
     The function passed to `apply` must take a {input} as its first
     argument and return a DataFrame, Series or scalar. `apply` will
@@ -212,9 +218,9 @@ class providing the base-class of operations.
     string indicating the keyword of `callable` that expects the
     %(klass)s object.
 args : iterable, optional
-       positional arguments passed into `func`.
+       Positional arguments passed into `func`.
 kwargs : dict, optional
-         a dictionary of keyword arguments passed into `func`.
+         A dictionary of keyword arguments passed into `func`.
 
 Returns
 -------
@@ -230,7 +236,7 @@ class providing the base-class of operations.
 Notes
 -----
 See more `here
-<http://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#piping-function-calls>`_
+<https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#piping-function-calls>`_
 
 Examples
 --------
@@ -319,7 +325,7 @@ def f(self):
         f.__name__ = "plot"
         return self._groupby.apply(f)
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str):
         def attr(*args, **kwargs):
             def f(self):
                 return getattr(self.plot, name)(*args, **kwargs)
@@ -339,25 +345,34 @@ def _group_selection_context(groupby):
     groupby._reset_group_selection()
 
 
+_KeysArgType = Union[
+    Hashable,
+    List[Hashable],
+    Callable[[Hashable], Hashable],
+    List[Callable[[Hashable], Hashable]],
+    Mapping[Hashable, Hashable],
+]
+
+
 class _GroupBy(PandasObject, SelectionMixin):
     _group_selection = None
-    _apply_whitelist = frozenset()  # type: FrozenSet[str]
+    _apply_whitelist: FrozenSet[str] = frozenset()
 
     def __init__(
         self,
         obj: NDFrame,
-        keys=None,
-        axis=0,
+        keys: Optional[_KeysArgType] = None,
+        axis: int = 0,
         level=None,
-        grouper=None,
+        grouper: "Optional[ops.BaseGrouper]" = None,
         exclusions=None,
         selection=None,
-        as_index=True,
-        sort=True,
-        group_keys=True,
-        squeeze=False,
-        observed=False,
-        **kwargs
+        as_index: bool = True,
+        sort: bool = True,
+        group_keys: bool = True,
+        squeeze: bool = False,
+        observed: bool = False,
+        mutated: bool = False,
     ):
 
         self._selection = selection
@@ -379,12 +394,12 @@ def __init__(
         self.group_keys = group_keys
         self.squeeze = squeeze
         self.observed = observed
-        self.mutated = kwargs.pop("mutated", False)
+        self.mutated = mutated
 
         if grouper is None:
-            from pandas.core.groupby.grouper import _get_grouper
+            from pandas.core.groupby.grouper import get_grouper
 
-            grouper, exclusions, obj = _get_grouper(
+            grouper, exclusions, obj = get_grouper(
                 obj,
                 keys,
                 axis=axis,
@@ -399,13 +414,10 @@ def __init__(
         self.grouper = grouper
         self.exclusions = set(exclusions) if exclusions else set()
 
-        # we accept no other args
-        validate_kwargs("group", kwargs, {})
-
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.groups)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # TODO: Better repr for GroupBy object
         return object.__repr__(self)
 
@@ -446,7 +458,7 @@ def _get_indices(self, names):
         def get_converter(s):
             # possibly convert to the actual key types
             # in the indices, could be a Timestamp or a np.datetime64
-            if isinstance(s, (Timestamp, datetime.datetime)):
+            if isinstance(s, datetime.datetime):
                 return lambda key: Timestamp(key)
             elif isinstance(s, np.datetime64):
                 return lambda key: Timestamp(key).asm8
@@ -473,8 +485,8 @@ def get_converter(s):
                 except KeyError:
                     # turns out it wasn't a tuple
                     msg = (
-                        "must supply a same-length tuple to get_group"
-                        " with multiple grouping keys"
+                        "must supply a same-length tuple to get_group "
+                        "with multiple grouping keys"
                     )
                     raise ValueError(msg)
 
@@ -495,6 +507,7 @@ def _get_index(self, name):
 
     @cache_readonly
     def _selected_obj(self):
+        # Note: _selected_obj is always just `self.obj` for SeriesGroupBy
 
         if self._selection is None or isinstance(self.obj, Series):
             if self._group_selection is not None:
@@ -557,16 +570,14 @@ def _set_result_index_ordered(self, result):
     def _dir_additions(self):
         return self.obj._dir_additions() | self._apply_whitelist
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str):
         if attr in self._internal_names_set:
             return object.__getattribute__(self, attr)
         if attr in self.obj:
             return self[attr]
-        if hasattr(self.obj, attr):
-            return self._make_wrapper(attr)
 
         raise AttributeError(
-            "%r object has no attribute %r" % (type(self).__name__, attr)
+            f"'{type(self).__name__}' object has no attribute '{attr}'"
         )
 
     @Substitution(
@@ -597,14 +608,7 @@ def pipe(self, func, *args, **kwargs):
     plot = property(GroupByPlot)
 
     def _make_wrapper(self, name):
-        if name not in self._apply_whitelist:
-            is_callable = callable(getattr(self._selected_obj, name, None))
-            kind = " callable " if is_callable else " "
-            msg = (
-                "Cannot access{0}attribute {1!r} of {2!r} objects, try "
-                "using the 'apply' method".format(kind, name, type(self).__name__)
-            )
-            raise AttributeError(msg)
+        assert name in self._apply_whitelist
 
         self._set_group_selection()
 
@@ -615,23 +619,21 @@ def _make_wrapper(self, name):
             return self.apply(lambda self: getattr(self, name))
 
         f = getattr(type(self._selected_obj), name)
+        sig = inspect.signature(f)
 
         def wrapper(*args, **kwargs):
             # a little trickery for aggregation functions that need an axis
             # argument
-            kwargs_with_axis = kwargs.copy()
-            if "axis" not in kwargs_with_axis or kwargs_with_axis["axis"] is None:
-                kwargs_with_axis["axis"] = self.axis
-
-            def curried_with_axis(x):
-                return f(x, *args, **kwargs_with_axis)
+            if "axis" in sig.parameters:
+                if kwargs.get("axis", None) is None:
+                    kwargs["axis"] = self.axis
 
             def curried(x):
                 return f(x, *args, **kwargs)
 
             # preserve the name so we can detect it when calling plot methods,
             # to avoid duplicates
-            curried.__name__ = curried_with_axis.__name__ = name
+            curried.__name__ = name
 
             # special case otherwise extra plots are created when catching the
             # exception below
@@ -639,24 +641,24 @@ def curried(x):
                 return self.apply(curried)
 
             try:
-                return self.apply(curried_with_axis)
-            except Exception:
-                try:
-                    return self.apply(curried)
-                except Exception:
-
-                    # related to : GH3688
-                    # try item-by-item
-                    # this can be called recursively, so need to raise
-                    # ValueError
-                    # if we don't have this method to indicated to aggregate to
-                    # mark this column as an error
-                    try:
-                        return self._aggregate_item_by_item(name, *args, **kwargs)
-                    except AttributeError:
-                        # e.g. SparseArray has no flags attr
-                        raise ValueError
+                return self.apply(curried)
+            except TypeError as err:
+                if not re.search(
+                    "reduction operation '.*' not allowed for this dtype", str(err)
+                ):
+                    # We don't have a cython implementation
+                    # TODO: is the above comment accurate?
+                    raise
+
+            if self.obj.ndim == 1:
+                # this can be called recursively, so need to raise ValueError
+                raise ValueError
 
+            # GH#3688 try to operate item-by-item
+            result = self._aggregate_item_by_item(name, *args, **kwargs)
+            return result
+
+        wrapper.__name__ = name
         return wrapper
 
     def get_group(self, name, obj=None):
@@ -666,11 +668,11 @@ def get_group(self, name, obj=None):
         Parameters
         ----------
         name : object
-            the name of the group to get as a DataFrame
+            The name of the group to get as a DataFrame.
         obj : DataFrame, default None
-            the DataFrame to take the DataFrame out of.  If
+            The DataFrame to take the DataFrame out of.  If
             it is None, the object groupby was called on will
-            be used
+            be used.
 
         Returns
         -------
@@ -683,7 +685,7 @@ def get_group(self, name, obj=None):
         if not len(inds):
             raise KeyError(name)
 
-        return obj.take(inds, axis=self.axis)
+        return obj._take_with_is_copy(inds, axis=self.axis)
 
     def __iter__(self):
         """
@@ -716,6 +718,10 @@ def f(g):
                     with np.errstate(all="ignore"):
                         return func(g, *args, **kwargs)
 
+            elif hasattr(nanops, "nan" + func):
+                # TODO: should we wrap this in to e.g. _is_builtin_func?
+                f = getattr(nanops, "nan" + func)
+
             else:
                 raise ValueError(
                     "func must be a callable if args or kwargs are supplied"
@@ -748,13 +754,13 @@ def _python_apply_general(self, f):
             keys, values, not_indexed_same=mutated or self.mutated
         )
 
-    def _iterate_slices(self):
-        yield self._selection_name, self._selected_obj
+    def _iterate_slices(self) -> Iterable[Series]:
+        raise AbstractMethodError(self)
 
     def transform(self, func, *args, **kwargs):
         raise AbstractMethodError(self)
 
-    def _cumcount_array(self, ascending=True):
+    def _cumcount_array(self, ascending: bool = True):
         """
         Parameters
         ----------
@@ -786,7 +792,7 @@ def _cumcount_array(self, ascending=True):
         rev[sorter] = np.arange(count, dtype=np.intp)
         return out[rev].astype(np.int64, copy=False)
 
-    def _try_cast(self, result, obj, numeric_only=False):
+    def _try_cast(self, result, obj, numeric_only: bool = False):
         """
         Try to cast the result to our obj original type,
         we may have roundtripped through object in the mean-time.
@@ -801,38 +807,22 @@ def _try_cast(self, result, obj, numeric_only=False):
             dtype = obj.dtype
 
         if not is_scalar(result):
-            if is_datetime64tz_dtype(dtype):
-                # GH 23683
-                # Prior results _may_ have been generated in UTC.
-                # Ensure we localize to UTC first before converting
-                # to the target timezone
-                arr = extract_array(obj)
-                try:
-                    result = arr._from_sequence(result, dtype="datetime64[ns, UTC]")
-                    result = result.astype(dtype)
-                except TypeError:
-                    # _try_cast was called at a point where the result
-                    # was already tz-aware
-                    pass
-            elif is_extension_array_dtype(dtype):
+            if is_extension_array_dtype(dtype) and dtype.kind != "M":
                 # The function can return something of any type, so check
-                # if the type is compatible with the calling EA.
+                #  if the type is compatible with the calling EA.
+                # datetime64tz is handled correctly in agg_series,
+                #  so is excluded here.
+
+                if len(result) and isinstance(result[0], dtype.type):
+                    cls = dtype.construct_array_type()
+                    result = try_cast_to_ea(cls, result, dtype=dtype)
 
-                # return the same type (Series) as our caller
-                try:
-                    result = obj._values._from_sequence(result, dtype=dtype)
-                except Exception:
-                    # https://github.com/pandas-dev/pandas/issues/22850
-                    # pandas has no control over what 3rd-party ExtensionArrays
-                    # do in _values_from_sequence. We still want ops to work
-                    # though, so we catch any regular Exception.
-                    pass
             elif numeric_only and is_numeric_dtype(dtype) or not numeric_only:
                 result = maybe_downcast_to_dtype(result, dtype)
 
         return result
 
-    def _transform_should_cast(self, func_nm):
+    def _transform_should_cast(self, func_nm: str) -> bool:
         """
         Parameters
         ----------
@@ -848,61 +838,105 @@ def _transform_should_cast(self, func_nm):
             func_nm not in base.cython_cast_blacklist
         )
 
-    def _cython_transform(self, how, numeric_only=True, **kwargs):
-        output = collections.OrderedDict()
-        for name, obj in self._iterate_slices():
+    def _cython_transform(self, how: str, numeric_only: bool = True, **kwargs):
+        output: Dict[base.OutputKey, np.ndarray] = {}
+        for idx, obj in enumerate(self._iterate_slices()):
+            name = obj.name
             is_numeric = is_numeric_dtype(obj.dtype)
             if numeric_only and not is_numeric:
                 continue
 
             try:
-                result, names = self.grouper.transform(obj.values, how, **kwargs)
+                result, _ = self.grouper.transform(obj.values, how, **kwargs)
             except NotImplementedError:
                 continue
-            except AssertionError as e:
-                raise GroupByError(str(e))
+
             if self._transform_should_cast(how):
-                output[name] = self._try_cast(result, obj)
-            else:
-                output[name] = result
+                result = self._try_cast(result, obj)
+
+            key = base.OutputKey(label=name, position=idx)
+            output[key] = result
 
         if len(output) == 0:
             raise DataError("No numeric types to aggregate")
 
-        return self._wrap_transformed_output(output, names)
+        return self._wrap_transformed_output(output)
+
+    def _wrap_aggregated_output(self, output: Mapping[base.OutputKey, np.ndarray]):
+        raise AbstractMethodError(self)
+
+    def _wrap_transformed_output(self, output: Mapping[base.OutputKey, np.ndarray]):
+        raise AbstractMethodError(self)
 
-    def _cython_agg_general(self, how, alt=None, numeric_only=True, min_count=-1):
-        output = {}
-        for name, obj in self._iterate_slices():
+    def _wrap_applied_output(self, keys, values, not_indexed_same: bool = False):
+        raise AbstractMethodError(self)
+
+    def _cython_agg_general(
+        self, how: str, alt=None, numeric_only: bool = True, min_count: int = -1
+    ):
+        output: Dict[base.OutputKey, Union[np.ndarray, DatetimeArray]] = {}
+        # Ideally we would be able to enumerate self._iterate_slices and use
+        # the index from enumeration as the key of output, but ohlc in particular
+        # returns a (n x 4) array. Output requires 1D ndarrays as values, so we
+        # need to slice that up into 1D arrays
+        idx = 0
+        for obj in self._iterate_slices():
+            name = obj.name
             is_numeric = is_numeric_dtype(obj.dtype)
             if numeric_only and not is_numeric:
                 continue
 
-            try:
-                result, names = self.grouper.aggregate(
-                    obj.values, how, min_count=min_count
-                )
-            except AssertionError as e:
-                raise GroupByError(str(e))
-            output[name] = self._try_cast(result, obj)
+            result, agg_names = self.grouper.aggregate(
+                obj._values, how, min_count=min_count
+            )
+
+            if agg_names:
+                # e.g. ohlc
+                assert len(agg_names) == result.shape[1]
+                for result_column, result_name in zip(result.T, agg_names):
+                    key = base.OutputKey(label=result_name, position=idx)
+                    output[key] = self._try_cast(result_column, obj)
+                    idx += 1
+            else:
+                assert result.ndim == 1
+                key = base.OutputKey(label=name, position=idx)
+                output[key] = self._try_cast(result, obj)
+                idx += 1
 
         if len(output) == 0:
             raise DataError("No numeric types to aggregate")
 
-        return self._wrap_aggregated_output(output, names)
+        return self._wrap_aggregated_output(output)
 
     def _python_agg_general(self, func, *args, **kwargs):
         func = self._is_builtin_func(func)
         f = lambda x: func(x, *args, **kwargs)
 
         # iterate through "columns" ex exclusions to populate output dict
-        output = {}
-        for name, obj in self._iterate_slices():
+        output: Dict[base.OutputKey, np.ndarray] = {}
+
+        for idx, obj in enumerate(self._iterate_slices()):
+            name = obj.name
+            if self.grouper.ngroups == 0:
+                # agg_series below assumes ngroups > 0
+                continue
+
             try:
-                result, counts = self.grouper.agg_series(obj, f)
-                output[name] = self._try_cast(result, obj, numeric_only=True)
+                # if this function is invalid for this dtype, we will ignore it.
+                func(obj[:0])
             except TypeError:
                 continue
+            except AssertionError:
+                raise
+            except Exception:
+                # Our function depends on having a non-empty argument
+                #  See test_groupby_agg_err_catching
+                pass
+
+            result, counts = self.grouper.agg_series(obj, f)
+            assert result is not None
+            key = base.OutputKey(label=name, position=idx)
+            output[key] = self._try_cast(result, obj, numeric_only=True)
 
         if len(output) == 0:
             return self._python_apply_general(f)
@@ -910,21 +944,18 @@ def _python_agg_general(self, func, *args, **kwargs):
         if self.grouper._filter_empty_groups:
 
             mask = counts.ravel() > 0
-            for name, result in output.items():
+            for key, result in output.items():
 
                 # since we are masking, make sure that we have a float object
                 values = result
                 if is_numeric_dtype(values.dtype):
                     values = ensure_float(values)
 
-                output[name] = self._try_cast(values[mask], result)
+                output[key] = self._try_cast(values[mask], result)
 
         return self._wrap_aggregated_output(output)
 
-    def _wrap_applied_output(self, *args, **kwargs):
-        raise AbstractMethodError(self)
-
-    def _concat_objects(self, keys, values, not_indexed_same=False):
+    def _concat_objects(self, keys, values, not_indexed_same: bool = False):
         from pandas.core.reshape.concat import concat
 
         def reset_identity(values):
@@ -939,22 +970,17 @@ def reset_identity(values):
             result = concat(values, axis=self.axis)
             ax = self._selected_obj._get_axis(self.axis)
 
-            if isinstance(result, Series):
-                result = result.reindex(ax)
+            # this is a very unfortunate situation
+            # we can't use reindex to restore the original order
+            # when the ax has duplicates
+            # so we resort to this
+            # GH 14776, 30667
+            if ax.has_duplicates:
+                indexer, _ = result.index.get_indexer_non_unique(ax.values)
+                indexer = algorithms.unique1d(indexer)
+                result = result.take(indexer, axis=self.axis)
             else:
-
-                # this is a very unfortunate situation
-                # we have a multi-index that is NOT lexsorted
-                # and we have a result which is duplicated
-                # we can't reindex, so we resort to this
-                # GH 14776
-                if isinstance(ax, MultiIndex) and not ax.is_unique:
-                    indexer = algorithms.unique1d(
-                        result.index.get_indexer_for(ax.values)
-                    )
-                    result = result.take(indexer, axis=self.axis)
-                else:
-                    result = result.reindex(ax, axis=self.axis)
+                result = result.reindex(ax, axis=self.axis)
 
         elif self.group_keys:
 
@@ -984,10 +1010,7 @@ def reset_identity(values):
             values = reset_identity(values)
             result = concat(values, axis=self.axis)
 
-        if (
-            isinstance(result, Series)
-            and getattr(self, "_selection_name", None) is not None
-        ):
+        if isinstance(result, Series) and self._selection_name is not None:
 
             result.name = self._selection_name
 
@@ -1032,7 +1055,7 @@ class GroupBy(_GroupBy):
         Most users should ignore this
     exclusions : array-like, optional
         List of columns to exclude
-    name : string
+    name : str
         Most users should ignore this
 
     Returns
@@ -1096,9 +1119,8 @@ def result_to_bool(result: np.ndarray, inference: Type) -> np.ndarray:
 
         return self._get_cythonized_result(
             "group_any_all",
-            self.grouper,
             aggregate=True,
-            cython_dtype=np.uint8,
+            cython_dtype=np.dtype(np.uint8),
             needs_values=True,
             needs_mask=True,
             pre_processing=objs_to_bool,
@@ -1109,14 +1131,14 @@ def result_to_bool(result: np.ndarray, inference: Type) -> np.ndarray:
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def any(self, skipna=True):
+    def any(self, skipna: bool = True):
         """
         Return True if any value in the group is truthful, else False.
 
         Parameters
         ----------
         skipna : bool, default True
-            Flag to ignore nan values during truth testing
+            Flag to ignore nan values during truth testing.
 
         Returns
         -------
@@ -1126,14 +1148,14 @@ def any(self, skipna=True):
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def all(self, skipna=True):
+    def all(self, skipna: bool = True):
         """
         Return True if all values in the group are truthful, else False.
 
         Parameters
         ----------
         skipna : bool, default True
-            Flag to ignore nan values during truth testing
+            Flag to ignore nan values during truth testing.
 
         Returns
         -------
@@ -1158,10 +1180,16 @@ def count(self):
 
     @Substitution(name="groupby")
     @Substitution(see_also=_common_see_also)
-    def mean(self, *args, **kwargs):
+    def mean(self, numeric_only: bool = True):
         """
         Compute mean of groups, excluding missing values.
 
+        Parameters
+        ----------
+        numeric_only : bool, default True
+            Include only float, int, boolean columns. If None, will attempt to use
+            everything, then use only numeric data.
+
         Returns
         -------
         pandas.Series or pandas.DataFrame
@@ -1200,52 +1228,40 @@ def mean(self, *args, **kwargs):
         2    4.0
         Name: B, dtype: float64
         """
-        nv.validate_groupby_func("mean", args, kwargs, ["numeric_only"])
-        try:
-            return self._cython_agg_general(
-                "mean", alt=lambda x, axis: Series(x).mean(**kwargs), **kwargs
-            )
-        except GroupByError:
-            raise
-        except Exception:
-            with _group_selection_context(self):
-                f = lambda x: x.mean(axis=self.axis, **kwargs)
-                return self._python_agg_general(f)
+        return self._cython_agg_general(
+            "mean",
+            alt=lambda x, axis: Series(x).mean(numeric_only=numeric_only),
+            numeric_only=numeric_only,
+        )
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def median(self, **kwargs):
+    def median(self, numeric_only=True):
         """
         Compute median of groups, excluding missing values.
 
         For multiple groupings, the result index will be a MultiIndex
 
+        Parameters
+        ----------
+        numeric_only : bool, default True
+            Include only float, int, boolean columns. If None, will attempt to use
+            everything, then use only numeric data.
+
         Returns
         -------
         Series or DataFrame
             Median of values within each group.
         """
-        try:
-            return self._cython_agg_general(
-                "median",
-                alt=lambda x, axis: Series(x).median(axis=axis, **kwargs),
-                **kwargs
-            )
-        except GroupByError:
-            raise
-        except Exception:
-
-            def f(x):
-                if isinstance(x, np.ndarray):
-                    x = Series(x)
-                return x.median(axis=self.axis, **kwargs)
-
-            with _group_selection_context(self):
-                return self._python_agg_general(f)
+        return self._cython_agg_general(
+            "median",
+            alt=lambda x, axis: Series(x).median(axis=axis, numeric_only=numeric_only),
+            numeric_only=numeric_only,
+        )
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def std(self, ddof=1, *args, **kwargs):
+    def std(self, ddof: int = 1):
         """
         Compute standard deviation of groups, excluding missing values.
 
@@ -1253,8 +1269,8 @@ def std(self, ddof=1, *args, **kwargs):
 
         Parameters
         ----------
-        ddof : integer, default 1
-            degrees of freedom
+        ddof : int, default 1
+            Degrees of freedom.
 
         Returns
         -------
@@ -1263,12 +1279,11 @@ def std(self, ddof=1, *args, **kwargs):
         """
 
         # TODO: implement at Cython level?
-        nv.validate_groupby_func("std", args, kwargs)
-        return np.sqrt(self.var(ddof=ddof, **kwargs))
+        return np.sqrt(self.var(ddof=ddof))
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def var(self, ddof=1, *args, **kwargs):
+    def var(self, ddof: int = 1):
         """
         Compute variance of groups, excluding missing values.
 
@@ -1276,34 +1291,26 @@ def var(self, ddof=1, *args, **kwargs):
 
         Parameters
         ----------
-        ddof : integer, default 1
-            degrees of freedom
+        ddof : int, default 1
+            Degrees of freedom.
 
         Returns
         -------
         Series or DataFrame
             Variance of values within each group.
         """
-        nv.validate_groupby_func("var", args, kwargs)
         if ddof == 1:
-            try:
-                return self._cython_agg_general(
-                    "var",
-                    alt=lambda x, axis: Series(x).var(ddof=ddof, **kwargs),
-                    **kwargs
-                )
-            except Exception:
-                f = lambda x: x.var(ddof=ddof, **kwargs)
-                with _group_selection_context(self):
-                    return self._python_agg_general(f)
+            return self._cython_agg_general(
+                "var", alt=lambda x, axis: Series(x).var(ddof=ddof)
+            )
         else:
-            f = lambda x: x.var(ddof=ddof, **kwargs)
+            func = lambda x: x.var(ddof=ddof)
             with _group_selection_context(self):
-                return self._python_agg_general(f)
+                return self._python_agg_general(func)
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def sem(self, ddof=1):
+    def sem(self, ddof: int = 1):
         """
         Compute standard error of the mean of groups, excluding missing values.
 
@@ -1311,8 +1318,8 @@ def sem(self, ddof=1):
 
         Parameters
         ----------
-        ddof : integer, default 1
-            degrees of freedom
+        ddof : int, default 1
+            Degrees of freedom.
 
         Returns
         -------
@@ -1335,8 +1342,8 @@ def size(self):
         result = self.grouper.size()
 
         if isinstance(self.obj, Series):
-            result.name = getattr(self.obj, "name", None)
-        return result
+            result.name = self.obj.name
+        return self._reindex_output(result, fill_value=0)
 
     @classmethod
     def _add_numeric_operations(cls):
@@ -1344,51 +1351,65 @@ def _add_numeric_operations(cls):
         Add numeric operations to the GroupBy generically.
         """
 
-        def groupby_function(name, alias, npfunc, numeric_only=True, min_count=-1):
+        def groupby_function(
+            name: str,
+            alias: str,
+            npfunc,
+            numeric_only: bool = True,
+            min_count: int = -1,
+        ):
 
             _local_template = """
             Compute %(f)s of group values.
 
+            Parameters
+            ----------
+            numeric_only : bool, default %(no)s
+                Include only float, int, boolean columns. If None, will attempt to use
+                everything, then use only numeric data.
+            min_count : int, default %(mc)s
+                The required number of valid values to perform the operation. If fewer
+                than ``min_count`` non-NA values are present the result will be NA.
+
             Returns
             -------
             Series or DataFrame
                 Computed %(f)s of values within each group.
             """
 
-            @Substitution(name="groupby", f=name)
+            @Substitution(name="groupby", f=name, no=numeric_only, mc=min_count)
             @Appender(_common_see_also)
             @Appender(_local_template)
-            def f(self, **kwargs):
-                if "numeric_only" not in kwargs:
-                    kwargs["numeric_only"] = numeric_only
-                if "min_count" not in kwargs:
-                    kwargs["min_count"] = min_count
-
+            def func(self, numeric_only=numeric_only, min_count=min_count):
                 self._set_group_selection()
 
                 # try a cython aggregation if we can
                 try:
-                    return self._cython_agg_general(alias, alt=npfunc, **kwargs)
-                except AssertionError as e:
-                    raise SpecificationError(str(e))
-                except Exception:
+                    return self._cython_agg_general(
+                        how=alias,
+                        alt=npfunc,
+                        numeric_only=numeric_only,
+                        min_count=min_count,
+                    )
+                except DataError:
                     pass
+                except NotImplementedError as err:
+                    if "function is not implemented for this dtype" in str(
+                        err
+                    ) or "category dtype not supported" in str(err):
+                        # raised in _get_cython_function, in some cases can
+                        #  be trimmed by implementing cython funcs for more dtypes
+                        pass
+                    else:
+                        raise
 
                 # apply a non-cython aggregation
                 result = self.aggregate(lambda x: npfunc(x, axis=self.axis))
-
-                # coerce the resulting columns if we can
-                if isinstance(result, DataFrame):
-                    for col in result.columns:
-                        result[col] = self._try_cast(result[col], self.obj[col])
-                else:
-                    result = self._try_cast(result, self.obj)
-
                 return result
 
-            set_function_name(f, name, cls)
+            set_function_name(func, name, cls)
 
-            return f
+            return func
 
         def first_compat(x, axis=0):
             def first(x):
@@ -1426,7 +1447,7 @@ def last(x):
 
     @Substitution(name="groupby")
     @Appender(_common_see_also)
-    def ohlc(self):
+    def ohlc(self) -> DataFrame:
         """
         Compute sum of values, excluding missing values.
 
@@ -1608,9 +1629,8 @@ def _fill(self, direction, limit=None):
 
         return self._get_cythonized_result(
             "group_fillna_indexer",
-            self.grouper,
             needs_mask=True,
-            cython_dtype=np.int64,
+            cython_dtype=np.dtype(np.int64),
             result_is_index=True,
             direction=direction,
             limit=limit,
@@ -1623,8 +1643,8 @@ def pad(self, limit=None):
 
         Parameters
         ----------
-        limit : integer, optional
-            limit of how many values to fill
+        limit : int, optional
+            Limit of how many values to fill.
 
         Returns
         -------
@@ -1649,8 +1669,8 @@ def backfill(self, limit=None):
 
         Parameters
         ----------
-        limit : integer, optional
-            limit of how many values to fill
+        limit : int, optional
+            Limit of how many values to fill.
 
         Returns
         -------
@@ -1682,10 +1702,10 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
         Parameters
         ----------
         n : int or list of ints
-            a single nth value for the row or a list of nth values
+            A single nth value for the row or a list of nth values.
         dropna : None or str, optional
-            apply the specified dropna operation before counting which row is
-            the nth row. Needs to be None, 'any' or 'all'
+            Apply the specified dropna operation before counting which row is
+            the nth row. Needs to be None, 'any' or 'all'.
 
         Returns
         -------
@@ -1778,6 +1798,7 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
             if not self.observed and isinstance(result_index, CategoricalIndex):
                 out = out.reindex(result_index)
 
+            out = self._reindex_output(out)
             return out.sort_index() if self.sort else out
 
         # dropna is truthy
@@ -1789,7 +1810,7 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
             raise ValueError(
                 "For a DataFrame groupby, dropna must be "
                 "either None, 'any' or 'all', "
-                "(was passed {dropna}).".format(dropna=dropna)
+                f"(was passed {dropna})."
             )
 
         # old behaviour, but with all and any support for DataFrames.
@@ -1810,9 +1831,9 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
 
             # create a grouper with the original parameters, but on dropped
             # object
-            from pandas.core.groupby.grouper import _get_grouper
+            from pandas.core.groupby.grouper import get_grouper
 
-            grouper, _, _ = _get_grouper(
+            grouper, _, _ = get_grouper(
                 dropped,
                 key=self.keys,
                 axis=self.axis,
@@ -1839,7 +1860,7 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
 
         return result
 
-    def quantile(self, q=0.5, interpolation="linear"):
+    def quantile(self, q=0.5, interpolation: str = "linear"):
         """
         Return group values at the given quantile, a la numpy.percentile.
 
@@ -1904,11 +1925,10 @@ def post_processor(vals: np.ndarray, inference: Optional[Type]) -> np.ndarray:
         if is_scalar(q):
             return self._get_cythonized_result(
                 "group_quantile",
-                self.grouper,
                 aggregate=True,
                 needs_values=True,
                 needs_mask=True,
-                cython_dtype=np.float64,
+                cython_dtype=np.dtype(np.float64),
                 pre_processing=pre_processor,
                 post_processing=post_processor,
                 q=q,
@@ -1918,11 +1938,10 @@ def post_processor(vals: np.ndarray, inference: Optional[Type]) -> np.ndarray:
             results = [
                 self._get_cythonized_result(
                     "group_quantile",
-                    self.grouper,
                     aggregate=True,
                     needs_values=True,
                     needs_mask=True,
-                    cython_dtype=np.float64,
+                    cython_dtype=np.dtype(np.float64),
                     pre_processing=pre_processor,
                     post_processing=post_processor,
                     q=qi,
@@ -1936,25 +1955,26 @@ def post_processor(vals: np.ndarray, inference: Optional[Type]) -> np.ndarray:
             #  >>> result.stack(0).loc[pd.IndexSlice[:, ..., q], :]
             #  but this hits https://github.com/pandas-dev/pandas/issues/10710
             #  which doesn't reorder the list-like `q` on the inner level.
-            order = np.roll(list(range(result.index.nlevels)), -1)
-            result = result.reorder_levels(order)
-            result = result.reindex(q, level=-1)
+            order = list(range(1, result.index.nlevels)) + [0]
+
+            # temporarily saves the index names
+            index_names = np.array(result.index.names)
+
+            # set index names to positions to avoid confusion
+            result.index.names = np.arange(len(index_names))
 
-            # fix order.
-            hi = len(q) * self.ngroups
-            arr = np.arange(0, hi, self.ngroups)
-            arrays = []
+            # place quantiles on the inside
+            result = result.reorder_levels(order)
 
-            for i in range(self.ngroups):
-                arr2 = arr + i
-                arrays.append(arr2)
+            # restore the index names in order
+            result.index.names = index_names[order]
 
-            indices = np.concatenate(arrays)
-            assert len(indices) == len(result)
+            # reorder rows to keep things sorted
+            indices = np.arange(len(result)).reshape([len(q), self.ngroups]).T.flatten()
             return result.take(indices)
 
     @Substitution(name="groupby")
-    def ngroup(self, ascending=True):
+    def ngroup(self, ascending: bool = True):
         """
         Number each group from 0 to the number of groups - 1.
 
@@ -1963,8 +1983,6 @@ def ngroup(self, ascending=True):
         would be seen when iterating over the groupby object, not the
         order they are first observed.
 
-        .. versionadded:: 0.20.2
-
         Parameters
         ----------
         ascending : bool, default True
@@ -2025,7 +2043,7 @@ def ngroup(self, ascending=True):
             return result
 
     @Substitution(name="groupby")
-    def cumcount(self, ascending=True):
+    def cumcount(self, ascending: bool = True):
         """
         Number each item in each group from 0 to the length of that group - 1.
 
@@ -2086,7 +2104,12 @@ def cumcount(self, ascending=True):
     @Substitution(name="groupby")
     @Appender(_common_see_also)
     def rank(
-        self, method="average", ascending=True, na_option="keep", pct=False, axis=0
+        self,
+        method: str = "average",
+        ascending: bool = True,
+        na_option: str = "keep",
+        pct: bool = False,
+        axis: int = 0,
     ):
         """
         Provide the rank of values within each group.
@@ -2094,19 +2117,19 @@ def rank(
         Parameters
         ----------
         method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
-            * average: average rank of group
-            * min: lowest rank in group
-            * max: highest rank in group
-            * first: ranks assigned in order they appear in the array
-            * dense: like 'min', but rank always increases by 1 between groups
-        ascending : boolean, default True
-            False for ranks by high (1) to low (N)
-        na_option :  {'keep', 'top', 'bottom'}, default 'keep'
-            * keep: leave NA values where they are
-            * top: smallest rank if ascending
-            * bottom: smallest rank if descending
-        pct : boolean, default False
-            Compute percentage rank of data within each group
+            * average: average rank of group.
+            * min: lowest rank in group.
+            * max: highest rank in group.
+            * first: ranks assigned in order they appear in the array.
+            * dense: like 'min', but rank always increases by 1 between groups.
+        ascending : bool, default True
+            False for ranks by high (1) to low (N).
+        na_option : {'keep', 'top', 'bottom'}, default 'keep'
+            * keep: leave NA values where they are.
+            * top: smallest rank if ascending.
+            * bottom: smallest rank if descending.
+        pct : bool, default False
+            Compute percentage rank of data within each group.
         axis : int, default 0
             The axis of the object over which to compute the rank.
 
@@ -2191,17 +2214,16 @@ def cummax(self, axis=0, **kwargs):
 
     def _get_cythonized_result(
         self,
-        how,
-        grouper,
-        aggregate=False,
-        cython_dtype=None,
-        needs_values=False,
-        needs_mask=False,
-        needs_ngroups=False,
-        result_is_index=False,
+        how: str,
+        cython_dtype: np.dtype,
+        aggregate: bool = False,
+        needs_values: bool = False,
+        needs_mask: bool = False,
+        needs_ngroups: bool = False,
+        result_is_index: bool = False,
         pre_processing=None,
         post_processing=None,
-        **kwargs
+        **kwargs,
     ):
         """
         Get result for Cythonized functions.
@@ -2209,13 +2231,11 @@ def _get_cythonized_result(
         Parameters
         ----------
         how : str, Cythonized function name to be called
-        grouper : Grouper object containing pertinent group info
+        cython_dtype : np.dtype
+            Type of the array that will be modified by the Cython call.
         aggregate : bool, default False
             Whether the result should be aggregated to match the number of
             groups
-        cython_dtype : default None
-            Type of the array that will be modified by the Cython call. If
-            `None`, the type will be inferred from the values of each slice
         needs_values : bool, default False
             Whether the values should be a part of the Cython call
             signature
@@ -2258,11 +2278,14 @@ def _get_cythonized_result(
                     "Cannot use 'pre_processing' without specifying 'needs_values'!"
                 )
 
+        grouper = self.grouper
+
         labels, _, ngroups = grouper.group_info
-        output = collections.OrderedDict()
+        output: Dict[base.OutputKey, np.ndarray] = {}
         base_func = getattr(libgroupby, how)
 
-        for name, obj in self._iterate_slices():
+        for idx, obj in enumerate(self._iterate_slices()):
+            name = obj.name
             values = obj._data._values
 
             if aggregate:
@@ -2270,9 +2293,6 @@ def _get_cythonized_result(
             else:
                 result_sz = len(values)
 
-            if not cython_dtype:
-                cython_dtype = values.dtype
-
             result = np.zeros(result_sz, dtype=cython_dtype)
             func = partial(base_func, result, labels)
             inferences = None
@@ -2298,7 +2318,8 @@ def _get_cythonized_result(
             if post_processing:
                 result = post_processing(result, inferences)
 
-            output[name] = result
+            key = base.OutputKey(label=name, position=idx)
+            output[key] = result
 
         if aggregate:
             return self._wrap_aggregated_output(output)
@@ -2313,9 +2334,10 @@ def shift(self, periods=1, freq=None, axis=0, fill_value=None):
 
         Parameters
         ----------
-        periods : integer, default 1
-            number of periods to shift
-        freq : frequency string
+        periods : int, default 1
+            Number of periods to shift.
+        freq : str, optional
+            Frequency string
         axis : axis to shift, default 0
         fill_value : optional
 
@@ -2332,8 +2354,7 @@ def shift(self, periods=1, freq=None, axis=0, fill_value=None):
 
         return self._get_cythonized_result(
             "group_shift_indexer",
-            self.grouper,
-            cython_dtype=np.int64,
+            cython_dtype=np.dtype(np.int64),
             needs_ngroups=True,
             result_is_index=True,
             periods=periods,
@@ -2360,8 +2381,11 @@ def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None, axis=0
                     axis=axis,
                 )
             )
+        if fill_method is None:  # GH30463
+            fill_method = "pad"
+            limit = 0
         filled = getattr(self, fill_method)(limit=limit)
-        fill_grp = filled.groupby(self.grouper.labels)
+        fill_grp = filled.groupby(self.grouper.codes)
         shifted = fill_grp.shift(periods=periods, freq=freq)
         return (filled / shifted) - 1
 
@@ -2375,6 +2399,8 @@ def head(self, n=5):
         from the original DataFrame with original index and order preserved
         (``as_index`` flag is ignored).
 
+        Does not work for negative values of `n`.
+
         Returns
         -------
         Series or DataFrame
@@ -2388,6 +2414,10 @@ def head(self, n=5):
            A  B
         0  1  2
         2  5  6
+        >>> df.groupby('A').head(-1)
+        Empty DataFrame
+        Columns: [A, B]
+        Index: []
         """
         self._reset_group_selection()
         mask = self._cumcount_array() < n
@@ -2403,6 +2433,8 @@ def tail(self, n=5):
         from the original DataFrame with original index and order preserved
         (``as_index`` flag is ignored).
 
+        Does not work for negative values of `n`.
+
         Returns
         -------
         Series or DataFrame
@@ -2416,12 +2448,18 @@ def tail(self, n=5):
            A  B
         1  a  2
         3  b  2
+        >>> df.groupby('A').tail(-1)
+        Empty DataFrame
+        Columns: [A, B]
+        Index: []
         """
         self._reset_group_selection()
         mask = self._cumcount_array(ascending=False) < n
         return self._selected_obj[mask]
 
-    def _reindex_output(self, output):
+    def _reindex_output(
+        self, output: FrameOrSeries, fill_value: Scalar = np.NaN
+    ) -> FrameOrSeries:
         """
         If we have categorical groupers, then we might want to make sure that
         we have a fully re-indexed output to the levels. This means expanding
@@ -2435,8 +2473,10 @@ def _reindex_output(self, output):
 
         Parameters
         ----------
-        output: Series or DataFrame
+        output : Series or DataFrame
             Object resulting from grouping and applying an operation.
+        fill_value : scalar, default np.NaN
+            Value to use for unobserved categories if self.observed is False.
 
         Returns
         -------
@@ -2467,7 +2507,11 @@ def _reindex_output(self, output):
         ).sortlevel()
 
         if self.as_index:
-            d = {self.obj._get_axis_name(self.axis): index, "copy": False}
+            d = {
+                self.obj._get_axis_name(self.axis): index,
+                "copy": False,
+                "fill_value": fill_value,
+            }
             return output.reindex(**d)
 
         # GH 13204
@@ -2489,7 +2533,9 @@ def _reindex_output(self, output):
         output = output.drop(labels=list(g_names), axis=1)
 
         # Set a temp index and reindex (possibly expanding)
-        output = output.set_index(self.grouper.result_index).reindex(index, copy=False)
+        output = output.set_index(self.grouper.result_index).reindex(
+            index, copy=False, fill_value=fill_value
+        )
 
         # Reset in-axis grouper columns
         # (using level numbers `g_nums` because level names may not be unique)
@@ -2502,7 +2548,23 @@ def _reindex_output(self, output):
 
 
 @Appender(GroupBy.__doc__)
-def groupby(obj, by, **kwds):
+def get_groupby(
+    obj: NDFrame,
+    by: Optional[_KeysArgType] = None,
+    axis: int = 0,
+    level=None,
+    grouper: "Optional[ops.BaseGrouper]" = None,
+    exclusions=None,
+    selection=None,
+    as_index: bool = True,
+    sort: bool = True,
+    group_keys: bool = True,
+    squeeze: bool = False,
+    observed: bool = False,
+    mutated: bool = False,
+) -> GroupBy:
+
+    klass: Type[GroupBy]
     if isinstance(obj, Series):
         from pandas.core.groupby.generic import SeriesGroupBy
 
@@ -2512,6 +2574,20 @@ def groupby(obj, by, **kwds):
 
         klass = DataFrameGroupBy
     else:
-        raise TypeError("invalid type: {}".format(obj))
-
-    return klass(obj, by, **kwds)
+        raise TypeError(f"invalid type: {obj}")
+
+    return klass(
+        obj=obj,
+        keys=by,
+        axis=axis,
+        level=level,
+        grouper=grouper,
+        exclusions=exclusions,
+        selection=selection,
+        as_index=as_index,
+        sort=sort,
+        group_keys=group_keys,
+        squeeze=squeeze,
+        observed=observed,
+        mutated=mutated,
+    )
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 2ebfbed0b132a..f0c6eedf5cee4 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -3,18 +3,17 @@
 split-apply-combine paradigm.
 """
 
-from typing import Tuple
-import warnings
+from typing import Dict, Hashable, List, Optional, Tuple
 
 import numpy as np
 
+from pandas._typing import FrameOrSeries
 from pandas.util._decorators import cache_readonly
 
 from pandas.core.dtypes.common import (
     ensure_categorical,
     is_categorical_dtype,
     is_datetime64_dtype,
-    is_hashable,
     is_list_like,
     is_scalar,
     is_timedelta64_dtype,
@@ -25,10 +24,10 @@
 from pandas.core.arrays import Categorical, ExtensionArray
 import pandas.core.common as com
 from pandas.core.frame import DataFrame
-from pandas.core.generic import NDFrame
+from pandas.core.groupby import ops
 from pandas.core.groupby.categorical import recode_for_groupby, recode_from_groupby
-from pandas.core.groupby.ops import BaseGrouper
-from pandas.core.index import CategoricalIndex, Index, MultiIndex
+from pandas.core.indexes.api import CategoricalIndex, Index, MultiIndex
+from pandas.core.indexes.base import InvalidIndexError
 from pandas.core.series import Series
 
 from pandas.io.formats.printing import pprint_thing
@@ -36,8 +35,7 @@
 
 class Grouper:
     """
-    A Grouper allows the user to specify a groupby instruction for a target
-    object.
+    A Grouper allows the user to specify a groupby instruction for an object.
 
     This specification will select a column via the key parameter, or if the
     level and/or axis parameters are given, a level of the index of the target
@@ -48,18 +46,19 @@ class Grouper:
 
     Parameters
     ----------
-    key : string, defaults to None
-        groupby key, which selects the grouping column of the target
+    key : str, defaults to None
+        Groupby key, which selects the grouping column of the target.
     level : name/number, defaults to None
-        the level for the target index
-    freq : string / frequency object, defaults to None
+        The level for the target index.
+    freq : str / frequency object, defaults to None
         This will groupby the specified frequency if the target selection
         (via key or level) is a datetime-like object. For full specification
         of available frequencies, please see `here
-        <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_.
-    axis : number/name of the axis, defaults to 0
-    sort : boolean, default to False
-        whether to sort the resulting labels
+        <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_.
+    axis : str, int, defaults to 0
+        Number/name of the axis.
+    sort : bool, default to False
+        Whether to sort the resulting labels.
     closed : {'left' or 'right'}
         Closed end of interval. Only when `freq` parameter is passed.
     label : {'left' or 'right'}
@@ -69,7 +68,7 @@ class Grouper:
         If grouper is PeriodIndex and `freq` parameter is passed.
     base : int, default 0
         Only when `freq` parameter is passed.
-    loffset : string, DateOffset, timedelta object
+    loffset : str, DateOffset, timedelta object
         Only when `freq` parameter is passed.
 
     Returns
@@ -93,7 +92,7 @@ class Grouper:
     >>> df.groupby(Grouper(level='date', freq='60s', axis=1))
     """
 
-    _attributes = ("key", "level", "freq", "axis", "sort")  # type: Tuple[str, ...]
+    _attributes: Tuple[str, ...] = ("key", "level", "freq", "axis", "sort")
 
     def __new__(cls, *args, **kwargs):
         if kwargs.get("freq") is not None:
@@ -119,7 +118,7 @@ def __init__(self, key=None, level=None, freq=None, axis=0, sort=False):
     def ax(self):
         return self.grouper
 
-    def _get_grouper(self, obj, validate=True):
+    def _get_grouper(self, obj, validate: bool = True):
         """
         Parameters
         ----------
@@ -133,7 +132,7 @@ def _get_grouper(self, obj, validate=True):
         """
 
         self._set_grouper(obj)
-        self.grouper, exclusions, self.obj = _get_grouper(
+        self.grouper, _, self.obj = get_grouper(
             self.obj,
             [self.key],
             axis=self.axis,
@@ -143,17 +142,18 @@ def _get_grouper(self, obj, validate=True):
         )
         return self.binner, self.grouper, self.obj
 
-    def _set_grouper(self, obj, sort=False):
+    def _set_grouper(self, obj: FrameOrSeries, sort: bool = False):
         """
         given an object and the specifications, setup the internal grouper
         for this particular specification
 
         Parameters
         ----------
-        obj : the subject object
+        obj : Series or DataFrame
         sort : bool, default False
             whether the resulting grouper should be sorted
         """
+        assert obj is not None
 
         if self.key is not None and self.level is not None:
             raise ValueError("The Grouper cannot specify both a key and a level!")
@@ -172,7 +172,7 @@ def _set_grouper(self, obj, sort=False):
                 ax = self._grouper.take(obj.index)
             else:
                 if key not in obj._info_axis:
-                    raise KeyError("The grouper name {0} is not found".format(key))
+                    raise KeyError(f"The grouper name {key} is not found")
                 ax = Index(obj[key], name=key)
 
         else:
@@ -188,14 +188,14 @@ def _set_grouper(self, obj, sort=False):
 
                 else:
                     if level not in (0, ax.name):
-                        raise ValueError("The level {0} is not valid".format(level))
+                        raise ValueError(f"The level {level} is not valid")
 
         # possibly sort
         if (self.sort or sort) and not ax.is_monotonic:
             # use stable sort to support first, last, nth
             indexer = self.indexer = ax.argsort(kind="mergesort")
             ax = ax.take(indexer)
-            obj = obj.take(indexer, axis=self.axis, is_copy=False)
+            obj = obj.take(indexer, axis=self.axis)
 
         self.obj = obj
         self.grouper = ax
@@ -205,15 +205,15 @@ def _set_grouper(self, obj, sort=False):
     def groups(self):
         return self.grouper.groups
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         attrs_list = (
-            "{}={!r}".format(attr_name, getattr(self, attr_name))
+            f"{attr_name}={repr(getattr(self, attr_name))}"
             for attr_name in self._attributes
             if getattr(self, attr_name) is not None
         )
         attrs = ", ".join(attrs_list)
-        cls_name = self.__class__.__name__
-        return "{}({})".format(cls_name, attrs)
+        cls_name = type(self).__name__
+        return f"{cls_name}({attrs})"
 
 
 class Grouping:
@@ -224,10 +224,10 @@ class Grouping:
     ----------
     index : Index
     grouper :
-    obj :
+    obj Union[DataFrame, Series]:
     name :
     level :
-    observed : boolean, default False
+    observed : bool, default False
         If we are a Categorical, use the observed values
     in_axis : if the Grouping is a column in self.obj and hence among
         Groupby.exclusions list
@@ -236,25 +236,22 @@ class Grouping:
     -------
     **Attributes**:
       * indices : dict of {group -> index_list}
-      * labels : ndarray, group labels
-      * ids : mapping of label -> group
-      * counts : array of group counts
+      * codes : ndarray, group codes
       * group_index : unique groups
       * groups : dict of {group -> label_list}
     """
 
     def __init__(
         self,
-        index,
+        index: Index,
         grouper=None,
-        obj=None,
+        obj: Optional[FrameOrSeries] = None,
         name=None,
         level=None,
-        sort=True,
-        observed=False,
-        in_axis=False,
+        sort: bool = True,
+        observed: bool = False,
+        in_axis: bool = False,
     ):
-
         self.name = name
         self.level = level
         self.grouper = _convert_grouper(index, grouper)
@@ -278,18 +275,20 @@ def __init__(
         if level is not None:
             if not isinstance(level, int):
                 if level not in index.names:
-                    raise AssertionError("Level {} not in index".format(level))
+                    raise AssertionError(f"Level {level} not in index")
                 level = index.names.index(level)
 
             if self.name is None:
                 self.name = index.names[level]
 
-            self.grouper, self._labels, self._group_index = index._get_grouper_for_level(  # noqa: E501
-                self.grouper, level
-            )
+            (
+                self.grouper,
+                self._codes,
+                self._group_index,
+            ) = index._get_grouper_for_level(self.grouper, level)
 
         # a passed Grouper like, directly get the grouper in the same way
-        # as single grouper groupby, use the group_info to get labels
+        # as single grouper groupby, use the group_info to get codes
         elif isinstance(self.grouper, Grouper):
             # get the new grouper; we already have disambiguated
             # what key/level refer to exactly, don't need to
@@ -302,7 +301,7 @@ def __init__(
             self.grouper = grouper._get_grouper()
 
         else:
-            if self.grouper is None and self.name is not None:
+            if self.grouper is None and self.name is not None and self.obj is not None:
                 self.grouper = self.obj[self.name]
 
             elif isinstance(self.grouper, (list, tuple)):
@@ -318,7 +317,7 @@ def __init__(
 
                 # we make a CategoricalIndex out of the cat grouper
                 # preserving the categories / ordered attributes
-                self._labels = self.grouper.codes
+                self._codes = self.grouper.codes
                 if observed:
                     codes = algorithms.unique1d(self.grouper.codes)
                     codes = codes[codes != -1]
@@ -330,7 +329,8 @@ def __init__(
                 self._group_index = CategoricalIndex(
                     Categorical.from_codes(
                         codes=codes, categories=categories, ordered=self.grouper.ordered
-                    )
+                    ),
+                    name=self.name,
                 )
 
             # we are done
@@ -343,15 +343,16 @@ def __init__(
             ):
                 if getattr(self.grouper, "ndim", 1) != 1:
                     t = self.name or str(type(self.grouper))
-                    raise ValueError("Grouper for '{}' not 1-dimensional".format(t))
+                    raise ValueError(f"Grouper for '{t}' not 1-dimensional")
                 self.grouper = self.index.map(self.grouper)
                 if not (
                     hasattr(self.grouper, "__len__")
                     and len(self.grouper) == len(self.index)
                 ):
+                    grper = pprint_thing(self.grouper)
                     errmsg = (
                         "Grouper result violates len(labels) == "
-                        "len(data)\nresult: %s" % pprint_thing(self.grouper)
+                        f"len(data)\nresult: {grper}"
                     )
                     self.grouper = None  # Try for sanity
                     raise AssertionError(errmsg)
@@ -365,75 +366,76 @@ def __init__(
 
                 self.grouper = self.grouper.astype("timedelta64[ns]")
 
-    def __repr__(self):
-        return "Grouping({0})".format(self.name)
+    def __repr__(self) -> str:
+        return f"Grouping({self.name})"
 
     def __iter__(self):
         return iter(self.indices)
 
-    _labels = None
-    _group_index = None
+    _codes: Optional[np.ndarray] = None
+    _group_index: Optional[Index] = None
 
     @property
-    def ngroups(self):
+    def ngroups(self) -> int:
         return len(self.group_index)
 
     @cache_readonly
     def indices(self):
         # we have a list of groupers
-        if isinstance(self.grouper, BaseGrouper):
+        if isinstance(self.grouper, ops.BaseGrouper):
             return self.grouper.indices
 
         values = ensure_categorical(self.grouper)
         return values._reverse_indexer()
 
     @property
-    def labels(self):
-        if self._labels is None:
-            self._make_labels()
-        return self._labels
+    def codes(self) -> np.ndarray:
+        if self._codes is None:
+            self._make_codes()
+        return self._codes
 
     @cache_readonly
-    def result_index(self):
+    def result_index(self) -> Index:
         if self.all_grouper is not None:
             return recode_from_groupby(self.all_grouper, self.sort, self.group_index)
         return self.group_index
 
     @property
-    def group_index(self):
+    def group_index(self) -> Index:
         if self._group_index is None:
-            self._make_labels()
+            self._make_codes()
+        assert self._group_index is not None
         return self._group_index
 
-    def _make_labels(self):
-        if self._labels is None or self._group_index is None:
+    def _make_codes(self) -> None:
+        if self._codes is None or self._group_index is None:
             # we have a list of groupers
-            if isinstance(self.grouper, BaseGrouper):
-                labels = self.grouper.label_info
+            if isinstance(self.grouper, ops.BaseGrouper):
+                codes = self.grouper.codes_info
                 uniques = self.grouper.result_index
             else:
-                labels, uniques = algorithms.factorize(self.grouper, sort=self.sort)
+                codes, uniques = algorithms.factorize(self.grouper, sort=self.sort)
                 uniques = Index(uniques, name=self.name)
-            self._labels = labels
+            self._codes = codes
             self._group_index = uniques
 
     @cache_readonly
-    def groups(self):
-        return self.index.groupby(Categorical.from_codes(self.labels, self.group_index))
+    def groups(self) -> Dict[Hashable, np.ndarray]:
+        return self.index.groupby(Categorical.from_codes(self.codes, self.group_index))
 
 
-def _get_grouper(
-    obj: NDFrame,
+def get_grouper(
+    obj: FrameOrSeries,
     key=None,
-    axis=0,
+    axis: int = 0,
     level=None,
-    sort=True,
-    observed=False,
-    mutated=False,
-    validate=True,
-):
+    sort: bool = True,
+    observed: bool = False,
+    mutated: bool = False,
+    validate: bool = True,
+) -> "Tuple[ops.BaseGrouper, List[Hashable], FrameOrSeries]":
     """
-    create and return a BaseGrouper, which is an internal
+    Create and return a BaseGrouper, which is an internal
     mapping of how to create the grouper indexers.
     This may be composed of multiple Grouping objects, indicating
     multiple groupers
@@ -449,9 +451,9 @@ def _get_grouper(
     a BaseGrouper.
 
     If observed & we have a categorical grouper, only show the observed
-    values
+    values.
 
-    If validate, then check for key/level overlaps
+    If validate, then check for key/level overlaps.
 
     """
     group_axis = obj._get_axis(axis)
@@ -490,9 +492,10 @@ def _get_grouper(
                     raise ValueError("multiple levels only valid with MultiIndex")
 
             if isinstance(level, str):
-                if obj.index.name != level:
+                if obj._get_axis(axis).name != level:
                     raise ValueError(
-                        "level name {} is not the name of the index".format(level)
+                        f"level name {level} is not the name "
+                        f"of the {obj._get_axis_name(axis)}"
                     )
             elif level > 0 or level < -1:
                 raise ValueError("level > 0 or level < -1 only valid with MultiIndex")
@@ -508,36 +511,12 @@ def _get_grouper(
         if key.key is None:
             return grouper, [], obj
         else:
-            return grouper, {key.key}, obj
+            return grouper, [key.key], obj
 
     # already have a BaseGrouper, just return it
-    elif isinstance(key, BaseGrouper):
+    elif isinstance(key, ops.BaseGrouper):
         return key, [], obj
 
-    # In the future, a tuple key will always mean an actual key,
-    # not an iterable of keys. In the meantime, we attempt to provide
-    # a warning. We can assume that the user wanted a list of keys when
-    # the key is not in the index. We just have to be careful with
-    # unhashable elements of `key`. Any unhashable elements implies that
-    # they wanted a list of keys.
-    # https://github.com/pandas-dev/pandas/issues/18314
-    is_tuple = isinstance(key, tuple)
-    all_hashable = is_tuple and is_hashable(key)
-
-    if is_tuple:
-        if (
-            all_hashable and key not in obj and set(key).issubset(obj)
-        ) or not all_hashable:
-            # column names ('a', 'b') -> ['a', 'b']
-            # arrays like (a, b) -> [a, b]
-            msg = (
-                "Interpreting tuple 'by' as a list of keys, rather than "
-                "a single key. Use 'by=[...]' instead of 'by=(...)'. In "
-                "the future, a tuple will always mean a single key."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=5)
-            key = list(key)
-
     if not isinstance(key, list):
         keys = [key]
         match_axis_length = False
@@ -564,7 +543,8 @@ def _get_grouper(
             all_in_columns_index = all(
                 g in obj.columns or g in obj.index.names for g in keys
             )
-        elif isinstance(obj, Series):
+        else:
+            assert isinstance(obj, Series)
             all_in_columns_index = all(g in obj.index.names for g in keys)
 
         if not all_in_columns_index:
@@ -577,23 +557,23 @@ def _get_grouper(
     else:
         levels = [level] * len(keys)
 
-    groupings = []
-    exclusions = []
+    groupings: List[Grouping] = []
+    exclusions: List[Hashable] = []
 
     # if the actual grouper should be obj[key]
-    def is_in_axis(key):
+    def is_in_axis(key) -> bool:
         if not _is_label_like(key):
             items = obj._data.items
             try:
                 items.get_loc(key)
-            except (KeyError, TypeError):
+            except (KeyError, TypeError, InvalidIndexError):
                 # TypeError shows up here if we pass e.g. Int64Index
                 return False
 
         return True
 
     # if the grouper is obj[name]
-    def is_in_obj(gpr):
+    def is_in_obj(gpr) -> bool:
         if not hasattr(gpr, "name"):
             return False
         try:
@@ -626,12 +606,8 @@ def is_in_obj(gpr):
 
         if is_categorical_dtype(gpr) and len(gpr) != obj.shape[axis]:
             raise ValueError(
-                (
-                    "Length of grouper ({len_gpr}) and axis ({len_axis})"
-                    " must be same length".format(
-                        len_gpr=len(gpr), len_axis=obj.shape[axis]
-                    )
-                )
+                f"Length of grouper ({len(gpr)}) and axis ({obj.shape[axis]}) "
+                "must be same length"
             )
 
         # create the Grouping
@@ -659,15 +635,15 @@ def is_in_obj(gpr):
         groupings.append(Grouping(Index([], dtype="int"), np.array([], dtype=np.intp)))
 
     # create the internals grouper
-    grouper = BaseGrouper(group_axis, groupings, sort=sort, mutated=mutated)
+    grouper = ops.BaseGrouper(group_axis, groupings, sort=sort, mutated=mutated)
     return grouper, exclusions, obj
 
 
-def _is_label_like(val):
+def _is_label_like(val) -> bool:
     return isinstance(val, (str, tuple)) or (val is not None and is_scalar(val))
 
 
-def _convert_grouper(axis, grouper):
+def _convert_grouper(axis: Index, grouper):
     if isinstance(grouper, dict):
         return grouper.get
     elif isinstance(grouper, Series):
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 40517eefe4d5d..4e593ce543ea6 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -7,12 +7,14 @@
 """
 
 import collections
+from typing import List, Optional, Sequence, Tuple, Type
 
 import numpy as np
 
 from pandas._libs import NaT, iNaT, lib
 import pandas._libs.groupby as libgroupby
 import pandas._libs.reduction as libreduction
+from pandas._typing import FrameOrSeries
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import cache_readonly
 
@@ -26,8 +28,10 @@
     is_complex_dtype,
     is_datetime64_any_dtype,
     is_datetime64tz_dtype,
+    is_extension_array_dtype,
     is_integer_dtype,
     is_numeric_dtype,
+    is_period_dtype,
     is_sparse,
     is_timedelta64_dtype,
     needs_i8_conversion,
@@ -39,8 +43,8 @@
 import pandas.core.common as com
 from pandas.core.frame import DataFrame
 from pandas.core.generic import NDFrame
-from pandas.core.groupby import base
-from pandas.core.index import Index, MultiIndex, ensure_index
+from pandas.core.groupby import base, grouper
+from pandas.core.indexes.api import Index, MultiIndex, ensure_index
 from pandas.core.series import Series
 from pandas.core.sorting import (
     compress_group_index,
@@ -52,59 +56,6 @@
 )
 
 
-def generate_bins_generic(values, binner, closed):
-    """
-    Generate bin edge offsets and bin labels for one array using another array
-    which has bin edge values. Both arrays must be sorted.
-
-    Parameters
-    ----------
-    values : array of values
-    binner : a comparable array of values representing bins into which to bin
-        the first array. Note, 'values' end-points must fall within 'binner'
-        end-points.
-    closed : which end of bin is closed; left (default), right
-
-    Returns
-    -------
-    bins : array of offsets (into 'values' argument) of bins.
-        Zero and last edge are excluded in result, so for instance the first
-        bin is values[0:bin[0]] and the last is values[bin[-1]:]
-    """
-    lenidx = len(values)
-    lenbin = len(binner)
-
-    if lenidx <= 0 or lenbin <= 0:
-        raise ValueError("Invalid length for values or for binner")
-
-    # check binner fits data
-    if values[0] < binner[0]:
-        raise ValueError("Values falls before first bin")
-
-    if values[lenidx - 1] > binner[lenbin - 1]:
-        raise ValueError("Values falls after last bin")
-
-    bins = np.empty(lenbin - 1, dtype=np.int64)
-
-    j = 0  # index into values
-    bc = 0  # bin count
-
-    # linear scan, presume nothing about values/binner except that it fits ok
-    for i in range(0, lenbin - 1):
-        r_bin = binner[i + 1]
-
-        # count values in current bin, advance to next bin
-        while j < lenidx and (
-            values[j] < r_bin or (closed == "right" and values[j] == r_bin)
-        ):
-            j += 1
-
-        bins[bc] = j
-        bc += 1
-
-    return bins
-
-
 class BaseGrouper:
     """
     This is an internal Grouper class, which actually holds
@@ -112,15 +63,14 @@ class BaseGrouper:
 
     Parameters
     ----------
-    axis : int
-        the axis to group
-    groupings : array of grouping
+    axis : Index
+    groupings : Sequence[Grouping]
         all the grouping instances to handle in this grouper
         for example for grouper list to groupby, need to pass the list
-    sort : boolean, default True
+    sort : bool, default True
         whether this grouper will give sorted result or not
-    group_keys : boolean, default True
-    mutated : boolean, default False
+    group_keys : bool, default True
+    mutated : bool, default False
     indexer : intp array, optional
         the indexer created by Grouper
         some groupers (TimeGrouper) will sort its axis and its
@@ -129,16 +79,28 @@ class BaseGrouper:
     """
 
     def __init__(
-        self, axis, groupings, sort=True, group_keys=True, mutated=False, indexer=None
+        self,
+        axis: Index,
+        groupings: "Sequence[grouper.Grouping]",
+        sort: bool = True,
+        group_keys: bool = True,
+        mutated: bool = False,
+        indexer: Optional[np.ndarray] = None,
     ):
+        assert isinstance(axis, Index), axis
+
         self._filter_empty_groups = self.compressed = len(groupings) != 1
         self.axis = axis
-        self.groupings = groupings
+        self._groupings: List[grouper.Grouping] = list(groupings)
         self.sort = sort
         self.group_keys = group_keys
         self.mutated = mutated
         self.indexer = indexer
 
+    @property
+    def groupings(self) -> List["grouper.Grouping"]:
+        return self._groupings
+
     @property
     def shape(self):
         return tuple(ping.ngroups for ping in self.groupings)
@@ -147,10 +109,10 @@ def __iter__(self):
         return iter(self.indices)
 
     @property
-    def nkeys(self):
+    def nkeys(self) -> int:
         return len(self.groupings)
 
-    def get_iterator(self, data, axis=0):
+    def get_iterator(self, data: FrameOrSeries, axis: int = 0):
         """
         Groupby iterator
 
@@ -164,7 +126,7 @@ def get_iterator(self, data, axis=0):
         for key, (i, group) in zip(keys, splitter):
             yield key, group
 
-    def _get_splitter(self, data, axis=0):
+    def _get_splitter(self, data: FrameOrSeries, axis: int = 0) -> "DataSplitter":
         comp_ids, _, ngroups = self.group_info
         return get_splitter(data, comp_ids, ngroups, axis=axis)
 
@@ -184,41 +146,45 @@ def _get_group_keys(self):
             comp_ids, _, ngroups = self.group_info
 
             # provide "flattened" iterator for multi-group setting
-            return get_flattened_iterator(comp_ids, ngroups, self.levels, self.labels)
+            return get_flattened_iterator(comp_ids, ngroups, self.levels, self.codes)
 
-    def apply(self, f, data, axis=0):
+    def apply(self, f, data: FrameOrSeries, axis: int = 0):
         mutated = self.mutated
         splitter = self._get_splitter(data, axis=axis)
         group_keys = self._get_group_keys()
         result_values = None
 
-        # oh boy
-        f_name = com.get_callable_name(f)
-        if (
-            f_name not in base.plotting_methods
-            and hasattr(splitter, "fast_apply")
+        sdata: FrameOrSeries = splitter._get_sorted_data()
+        if sdata.ndim == 2 and np.any(sdata.dtypes.apply(is_extension_array_dtype)):
+            # calling splitter.fast_apply will raise TypeError via apply_frame_axis0
+            #  if we pass EA instead of ndarray
+            #  TODO: can we have a workaround for EAs backed by ndarray?
+            pass
+
+        elif (
+            com.get_callable_name(f) not in base.plotting_methods
+            and isinstance(splitter, FrameSplitter)
             and axis == 0
+            # fast_apply/libreduction doesn't allow non-numpy backed indexes
+            and not sdata.index._has_complex_internals
         ):
             try:
                 result_values, mutated = splitter.fast_apply(f, group_keys)
 
+            except libreduction.InvalidApply as err:
+                # This Exception is raised if `f` triggers an exception
+                # but it is preferable to raise the exception in Python.
+                if "Let this error raise above us" not in str(err):
+                    # TODO: can we infer anything about whether this is
+                    #  worth-retrying in pure-python?
+                    raise
+
+            else:
                 # If the fast apply path could be used we can return here.
                 # Otherwise we need to fall back to the slow implementation.
                 if len(result_values) == len(group_keys):
                     return group_keys, result_values, mutated
 
-            except libreduction.InvalidApply:
-                # Cannot fast apply on MultiIndex (_has_complex_internals).
-                # This Exception is also raised if `f` triggers an exception
-                # but it is preferable to raise the exception in Python.
-                pass
-            except TypeError as err:
-                if "Cannot convert" in str(err):
-                    # via apply_frame_axis0 if we pass a non-ndarray
-                    pass
-                else:
-                    raise
-
         for key, (i, group) in zip(group_keys, splitter):
             object.__setattr__(group, "name", key)
 
@@ -236,7 +202,7 @@ def apply(self, f, data, axis=0):
                 continue
 
             # group might be modified
-            group_axes = _get_axes(group)
+            group_axes = group.axes
             res = f(group)
             if not _is_indexed_like(res, group_axes):
                 mutated = True
@@ -250,26 +216,25 @@ def indices(self):
         if len(self.groupings) == 1:
             return self.groupings[0].indices
         else:
-            label_list = [ping.labels for ping in self.groupings]
+            codes_list = [ping.codes for ping in self.groupings]
             keys = [com.values_from_object(ping.group_index) for ping in self.groupings]
-            return get_indexer_dict(label_list, keys)
+            return get_indexer_dict(codes_list, keys)
 
     @property
-    def labels(self):
-        return [ping.labels for ping in self.groupings]
+    def codes(self) -> List[np.ndarray]:
+        return [ping.codes for ping in self.groupings]
 
     @property
-    def levels(self):
+    def levels(self) -> List[Index]:
         return [ping.group_index for ping in self.groupings]
 
     @property
     def names(self):
         return [ping.name for ping in self.groupings]
 
-    def size(self):
+    def size(self) -> Series:
         """
-        Compute group sizes
-
+        Compute group sizes.
         """
         ids, _, ngroup = self.group_info
         ids = ensure_platform_int(ids)
@@ -290,52 +255,52 @@ def groups(self):
             return self.axis.groupby(to_groupby)
 
     @cache_readonly
-    def is_monotonic(self):
+    def is_monotonic(self) -> bool:
         # return if my group orderings are monotonic
         return Index(self.group_info[0]).is_monotonic
 
     @cache_readonly
     def group_info(self):
-        comp_ids, obs_group_ids = self._get_compressed_labels()
+        comp_ids, obs_group_ids = self._get_compressed_codes()
 
         ngroups = len(obs_group_ids)
         comp_ids = ensure_int64(comp_ids)
         return comp_ids, obs_group_ids, ngroups
 
     @cache_readonly
-    def label_info(self):
-        # return the labels of items in original grouped axis
-        labels, _, _ = self.group_info
+    def codes_info(self) -> np.ndarray:
+        # return the codes of items in original grouped axis
+        codes, _, _ = self.group_info
         if self.indexer is not None:
-            sorter = np.lexsort((labels, self.indexer))
-            labels = labels[sorter]
-        return labels
-
-    def _get_compressed_labels(self):
-        all_labels = [ping.labels for ping in self.groupings]
-        if len(all_labels) > 1:
-            group_index = get_group_index(all_labels, self.shape, sort=True, xnull=True)
+            sorter = np.lexsort((codes, self.indexer))
+            codes = codes[sorter]
+        return codes
+
+    def _get_compressed_codes(self) -> Tuple[np.ndarray, np.ndarray]:
+        all_codes = self.codes
+        if len(all_codes) > 1:
+            group_index = get_group_index(all_codes, self.shape, sort=True, xnull=True)
             return compress_group_index(group_index, sort=self.sort)
 
         ping = self.groupings[0]
-        return ping.labels, np.arange(len(ping.group_index))
+        return ping.codes, np.arange(len(ping.group_index))
 
     @cache_readonly
-    def ngroups(self):
+    def ngroups(self) -> int:
         return len(self.result_index)
 
     @property
-    def recons_labels(self):
+    def reconstructed_codes(self) -> List[np.ndarray]:
+        codes = self.codes
         comp_ids, obs_ids, _ = self.group_info
-        labels = (ping.labels for ping in self.groupings)
-        return decons_obs_group_ids(comp_ids, obs_ids, self.shape, labels, xnull=True)
+        return decons_obs_group_ids(comp_ids, obs_ids, self.shape, codes, xnull=True)
 
     @cache_readonly
-    def result_index(self):
+    def result_index(self) -> Index:
         if not self.compressed and len(self.groupings) == 1:
             return self.groupings[0].result_index.rename(self.names[0])
 
-        codes = self.recons_labels
+        codes = self.reconstructed_codes
         levels = [ping.result_index for ping in self.groupings]
         result = MultiIndex(
             levels=levels, codes=codes, verify_integrity=False, names=self.names
@@ -347,9 +312,9 @@ def get_group_levels(self):
             return [self.groupings[0].result_index]
 
         name_list = []
-        for ping, labels in zip(self.groupings, self.recons_labels):
-            labels = ensure_platform_int(labels)
-            levels = ping.result_index.take(labels)
+        for ping, codes in zip(self.groupings, self.reconstructed_codes):
+            codes = ensure_platform_int(codes)
+            levels = ping.result_index.take(codes)
 
             name_list.append(levels)
 
@@ -365,12 +330,9 @@ def get_group_levels(self):
             "min": "group_min",
             "max": "group_max",
             "mean": "group_mean",
-            "median": {"name": "group_median"},
+            "median": "group_median",
             "var": "group_var",
-            "first": {
-                "name": "group_nth",
-                "f": lambda func, a, b, c, d, e: func(a, b, c, d, 1, -1),
-            },
+            "first": "group_nth",
             "last": "group_last",
             "ohlc": "group_ohlc",
         },
@@ -379,84 +341,109 @@ def get_group_levels(self):
             "cumsum": "group_cumsum",
             "cummin": "group_cummin",
             "cummax": "group_cummax",
-            "rank": {
-                "name": "group_rank",
-                "f": lambda func, a, b, c, d, e, **kwargs: func(
-                    a,
-                    b,
-                    c,
-                    e,
-                    kwargs.get("ties_method", "average"),
-                    kwargs.get("ascending", True),
-                    kwargs.get("pct", False),
-                    kwargs.get("na_option", "keep"),
-                ),
-            },
+            "rank": "group_rank",
         },
     }
 
     _cython_arity = {"ohlc": 4}  # OHLC
 
-    _name_functions = {"ohlc": lambda *args: ["open", "high", "low", "close"]}
+    _name_functions = {"ohlc": ["open", "high", "low", "close"]}
 
     def _is_builtin_func(self, arg):
         """
-        if we define an builtin function for this argument, return it,
+        if we define a builtin function for this argument, return it,
         otherwise return the arg
         """
         return SelectionMixin._builtin_table.get(arg, arg)
 
-    def _get_cython_function(self, kind, how, values, is_numeric):
+    def _get_cython_function(self, kind: str, how: str, values, is_numeric: bool):
 
         dtype_str = values.dtype.name
-
-        def get_func(fname):
-            # see if there is a fused-type version of function
-            # only valid for numeric
-            f = getattr(libgroupby, fname, None)
-            if f is not None and is_numeric:
-                return f
-
-            # otherwise find dtype-specific version, falling back to object
-            for dt in [dtype_str, "object"]:
-                f = getattr(
-                    libgroupby,
-                    "{fname}_{dtype_str}".format(fname=fname, dtype_str=dt),
-                    None,
-                )
-                if f is not None:
-                    return f
-
         ftype = self._cython_functions[kind][how]
 
-        if isinstance(ftype, dict):
-            func = afunc = get_func(ftype["name"])
+        # see if there is a fused-type version of function
+        # only valid for numeric
+        f = getattr(libgroupby, ftype, None)
+        if f is not None and is_numeric:
+            return f
 
-            # a sub-function
-            f = ftype.get("f")
-            if f is not None:
+        # otherwise find dtype-specific version, falling back to object
+        for dt in [dtype_str, "object"]:
+            f2 = getattr(libgroupby, f"{ftype}_{dt}", None)
+            if f2 is not None:
+                return f2
 
-                def wrapper(*args, **kwargs):
-                    return f(afunc, *args, **kwargs)
+        if hasattr(f, "__signatures__"):
+            # inspect what fused types are implemented
+            if dtype_str == "object" and "object" not in f.__signatures__:
+                # disallow this function so we get a NotImplementedError below
+                #  instead of a TypeError at runtime
+                f = None
 
-                # need to curry our sub-function
-                func = wrapper
-
-        else:
-            func = get_func(ftype)
+        func = f
 
         if func is None:
             raise NotImplementedError(
-                "function is not implemented for this dtype: "
-                "[how->{how},dtype->{dtype_str}]".format(how=how, dtype_str=dtype_str)
+                f"function is not implemented for this dtype: "
+                f"[how->{how},dtype->{dtype_str}]"
             )
 
         return func
 
-    def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
+    def _get_cython_func_and_vals(
+        self, kind: str, how: str, values: np.ndarray, is_numeric: bool
+    ):
+        """
+        Find the appropriate cython function, casting if necessary.
+
+        Parameters
+        ----------
+        kind : sttr
+        how : srt
+        values : np.ndarray
+        is_numeric : bool
+
+        Returns
+        -------
+        func : callable
+        values : np.ndarray
+        """
+        try:
+            func = self._get_cython_function(kind, how, values, is_numeric)
+        except NotImplementedError:
+            if is_numeric:
+                try:
+                    values = ensure_float64(values)
+                except TypeError:
+                    if lib.infer_dtype(values, skipna=False) == "complex":
+                        values = values.astype(complex)
+                    else:
+                        raise
+                func = self._get_cython_function(kind, how, values, is_numeric)
+            else:
+                raise
+        return func, values
+
+    def _cython_operation(
+        self, kind: str, values, how: str, axis, min_count: int = -1, **kwargs
+    ) -> Tuple[np.ndarray, Optional[List[str]]]:
+        """
+        Returns the values of a cython operation as a Tuple of [data, names].
+
+        Names is only useful when dealing with 2D results, like ohlc
+        (see self._name_functions).
+        """
+
         assert kind in ["transform", "aggregate"]
         orig_values = values
 
+        if values.ndim > 2:
+            raise NotImplementedError("number of dimensions is currently limited to 2")
+        elif values.ndim == 2:
+            # Note: it is *not* the case that axis is always 0 for 1-dim values,
+            #  as we can have 1D ExtensionArrays that we need to treat as 2D
+            assert axis == 1, axis
+
         # can we do this operation with our cython functions
         # if not raise NotImplementedError
 
@@ -466,16 +453,16 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
         # categoricals are only 1d, so we
         # are not setup for dim transforming
         if is_categorical_dtype(values) or is_sparse(values):
-            raise NotImplementedError("{} dtype not supported".format(values.dtype))
+            raise NotImplementedError(f"{values.dtype} dtype not supported")
         elif is_datetime64_any_dtype(values):
             if how in ["add", "prod", "cumsum", "cumprod"]:
                 raise NotImplementedError(
-                    "datetime64 type does not support {} operations".format(how)
+                    f"datetime64 type does not support {how} operations"
                 )
         elif is_timedelta64_dtype(values):
             if how in ["prod", "cumprod"]:
                 raise NotImplementedError(
-                    "timedelta64 type does not support {} operations".format(how)
+                    f"timedelta64 type does not support {how} operations"
                 )
 
         if is_datetime64tz_dtype(values.dtype):
@@ -522,26 +509,17 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
                 )
             out_shape = (self.ngroups,) + values.shape[1:]
 
-        try:
-            func = self._get_cython_function(kind, how, values, is_numeric)
-        except NotImplementedError:
-            if is_numeric:
-                values = ensure_float64(values)
-                func = self._get_cython_function(kind, how, values, is_numeric)
-            else:
-                raise
+        func, values = self._get_cython_func_and_vals(kind, how, values, is_numeric)
 
         if how == "rank":
             out_dtype = "float"
         else:
             if is_numeric:
-                out_dtype = "{kind}{itemsize}".format(
-                    kind=values.dtype.kind, itemsize=values.dtype.itemsize
-                )
+                out_dtype = f"{values.dtype.kind}{values.dtype.itemsize}"
             else:
                 out_dtype = "object"
 
-        labels, _, _ = self.group_info
+        codes, _, _ = self.group_info
 
         if kind == "aggregate":
             result = _maybe_fill(
@@ -549,14 +527,7 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
             )
             counts = np.zeros(self.ngroups, dtype=np.int64)
             result = self._aggregate(
-                result,
-                counts,
-                values,
-                labels,
-                func,
-                is_numeric,
-                is_datetimelike,
-                min_count,
+                result, counts, values, codes, func, is_datetimelike, min_count
             )
         elif kind == "transform":
             result = _maybe_fill(
@@ -565,7 +536,7 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
 
             # TODO: min_count
             result = self._transform(
-                result, values, labels, func, is_numeric, is_datetimelike, **kwargs
+                result, values, codes, func, is_datetimelike, **kwargs
             )
 
         if is_integer_dtype(result) and not is_datetimelike:
@@ -573,6 +544,17 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
             if mask.any():
                 result = result.astype("float64")
                 result[mask] = np.nan
+        elif (
+            how == "add"
+            and is_integer_dtype(orig_values.dtype)
+            and is_extension_array_dtype(orig_values.dtype)
+        ):
+            # We need this to ensure that Series[Int64Dtype].resample().sum()
+            # remains int64 dtype.
+            # Two options for avoiding this special case
+            # 1. mask-aware ops and avoid casting to float with NaN above
+            # 2. specify the result dtype when calling this method
+            result = result.astype("int64")
 
         if kind == "aggregate" and self._filter_empty_groups and not counts.all():
             assert result.ndim != 2
@@ -581,28 +563,31 @@ def _cython_operation(self, kind, values, how, axis, min_count=-1, **kwargs):
         if vdim == 1 and arity == 1:
             result = result[:, 0]
 
-        if how in self._name_functions:
-            # TODO
-            names = self._name_functions[how]()
-        else:
-            names = None
+        names: Optional[List[str]] = self._name_functions.get(how, None)
 
         if swapped:
             result = result.swapaxes(0, axis)
 
-        if is_datetime64tz_dtype(orig_values.dtype):
+        if is_datetime64tz_dtype(orig_values.dtype) or is_period_dtype(
+            orig_values.dtype
+        ):
+            # We need to use the constructors directly for these dtypes
+            # since numpy won't recognize them
+            # https://github.com/pandas-dev/pandas/issues/31471
             result = type(orig_values)(result.astype(np.int64), dtype=orig_values.dtype)
         elif is_datetimelike and kind == "aggregate":
             result = result.astype(orig_values.dtype)
 
         return result, names
 
-    def aggregate(self, values, how, axis=0, min_count=-1):
+    def aggregate(
+        self, values, how: str, axis: int = 0, min_count: int = -1
+    ) -> Tuple[np.ndarray, Optional[List[str]]]:
         return self._cython_operation(
             "aggregate", values, how, axis, min_count=min_count
         )
 
-    def transform(self, values, how, axis=0, **kwargs):
+    def transform(self, values, how: str, axis: int = 0, **kwargs):
         return self._cython_operation("transform", values, how, axis, **kwargs)
 
     def _aggregate(
@@ -612,54 +597,68 @@ def _aggregate(
         values,
         comp_ids,
         agg_func,
-        is_numeric,
-        is_datetimelike,
-        min_count=-1,
+        is_datetimelike: bool,
+        min_count: int = -1,
     ):
-        if values.ndim > 2:
-            # punting for now
-            raise NotImplementedError("number of dimensions is currently limited to 2")
+        if agg_func is libgroupby.group_nth:
+            # different signature from the others
+            # TODO: should we be using min_count instead of hard-coding it?
+            agg_func(result, counts, values, comp_ids, rank=1, min_count=-1)
         else:
             agg_func(result, counts, values, comp_ids, min_count)
 
         return result
 
     def _transform(
-        self,
-        result,
-        values,
-        comp_ids,
-        transform_func,
-        is_numeric,
-        is_datetimelike,
-        **kwargs
+        self, result, values, comp_ids, transform_func, is_datetimelike: bool, **kwargs
     ):
 
         comp_ids, _, ngroups = self.group_info
-        if values.ndim > 2:
-            # punting for now
-            raise NotImplementedError("number of dimensions is currently limited to 2")
-        else:
-            transform_func(result, values, comp_ids, ngroups, is_datetimelike, **kwargs)
+        transform_func(result, values, comp_ids, ngroups, is_datetimelike, **kwargs)
 
         return result
 
-    def agg_series(self, obj, func):
-        try:
-            return self._aggregate_series_fast(obj, func)
-        except Exception:
+    def agg_series(self, obj: Series, func):
+        # Caller is responsible for checking ngroups != 0
+        assert self.ngroups != 0
+
+        if len(obj) == 0:
+            # SeriesGrouper would raise if we were to call _aggregate_series_fast
             return self._aggregate_series_pure_python(obj, func)
 
-    def _aggregate_series_fast(self, obj, func):
-        func = self._is_builtin_func(func)
+        elif is_extension_array_dtype(obj.dtype):
+            # _aggregate_series_fast would raise TypeError when
+            #  calling libreduction.Slider
+            # In the datetime64tz case it would incorrectly cast to tz-naive
+            # TODO: can we get a performant workaround for EAs backed by ndarray?
+            return self._aggregate_series_pure_python(obj, func)
 
-        if obj.index._has_complex_internals:
-            raise TypeError("Incompatible index for Cython grouper")
+        elif obj.index._has_complex_internals:
+            # Pre-empt TypeError in _aggregate_series_fast
+            return self._aggregate_series_pure_python(obj, func)
+
+        try:
+            return self._aggregate_series_fast(obj, func)
+        except ValueError as err:
+            if "Function does not reduce" in str(err):
+                # raised in libreduction
+                pass
+            else:
+                raise
+        return self._aggregate_series_pure_python(obj, func)
+
+    def _aggregate_series_fast(self, obj: Series, func):
+        # At this point we have already checked that
+        #  - obj.index is not a MultiIndex
+        #  - obj is backed by an ndarray, not ExtensionArray
+        #  - len(obj) > 0
+        #  - ngroups != 0
+        func = self._is_builtin_func(func)
 
         group_index, _, ngroups = self.group_info
 
         # avoids object / Series creation overhead
-        dummy = obj._get_values(slice(None, 0))
+        dummy = obj.iloc[:0]
         indexer = get_group_index_sorter(group_index, ngroups)
         obj = obj.take(indexer)
         group_index = algorithms.take_nd(group_index, indexer, allow_fill=False)
@@ -667,26 +666,34 @@ def _aggregate_series_fast(self, obj, func):
         result, counts = grouper.get_result()
         return result, counts
 
-    def _aggregate_series_pure_python(self, obj, func):
+    def _aggregate_series_pure_python(self, obj: Series, func):
 
         group_index, _, ngroups = self.group_info
 
         counts = np.zeros(ngroups, dtype=int)
         result = None
 
-        splitter = get_splitter(obj, group_index, ngroups, axis=self.axis)
+        splitter = get_splitter(obj, group_index, ngroups, axis=0)
 
         for label, group in splitter:
             res = func(group)
             if result is None:
                 if isinstance(res, (Series, Index, np.ndarray)):
-                    raise ValueError("Function does not reduce")
+                    if len(res) == 1:
+                        # e.g. test_agg_lambda_with_timezone lambda e: e.head(1)
+                        # FIXME: are we potentially losing import res.index info?
+                        res = res.item()
+                    else:
+                        raise ValueError("Function does not reduce")
                 result = np.empty(ngroups, dtype="O")
 
             counts[label] = group.shape[0]
             result[label] = res
 
+        assert result is not None
         result = lib.maybe_convert_objects(result, try_float=0)
+        # TODO: try_cast back to EA?
+
         return result, counts
 
 
@@ -721,7 +728,12 @@ class BinGrouper(BaseGrouper):
     """
 
     def __init__(
-        self, bins, binlabels, filter_empty=False, mutated=False, indexer=None
+        self,
+        bins,
+        binlabels,
+        filter_empty: bool = False,
+        mutated: bool = False,
+        indexer=None,
     ):
         self.bins = ensure_int64(bins)
         self.binlabels = ensure_index(binlabels)
@@ -729,6 +741,10 @@ def __init__(
         self.mutated = mutated
         self.indexer = indexer
 
+        # These lengths must match, otherwise we could call agg_series
+        #  with empty self.bins, which would raise in libreduction.
+        assert len(self.binlabels) == len(self.bins)
+
     @cache_readonly
     def groups(self):
         """ dict {group name -> group labels} """
@@ -743,7 +759,7 @@ def groups(self):
         return result
 
     @property
-    def nkeys(self):
+    def nkeys(self) -> int:
         return 1
 
     def _get_grouper(self):
@@ -755,7 +771,7 @@ def _get_grouper(self):
         """
         return self
 
-    def get_iterator(self, data, axis=0):
+    def get_iterator(self, data: FrameOrSeries, axis: int = 0):
         """
         Groupby iterator
 
@@ -764,12 +780,12 @@ def get_iterator(self, data, axis=0):
         Generator yielding sequence of (name, subsetted object)
         for each group
         """
-        if isinstance(data, NDFrame):
-            slicer = lambda start, edge: data._slice(slice(start, edge), axis=axis)
-            length = len(data.axes[axis])
+        if axis == 0:
+            slicer = lambda start, edge: data.iloc[start:edge]
         else:
-            slicer = lambda start, edge: data[slice(start, edge)]
-            length = len(data)
+            slicer = lambda start, edge: data.iloc[:, start:edge]
+
+        length = len(data.axes[axis])
 
         start = 0
         for edge, label in zip(self.bins, self.binlabels):
@@ -810,6 +826,11 @@ def group_info(self):
             ngroups,
         )
 
+    @cache_readonly
+    def reconstructed_codes(self) -> List[np.ndarray]:
+        # get unique result indices, and prepend 0 as groupby starts from the first
+        return [np.r_[0, np.flatnonzero(self.bins[1:] != self.bins[:-1]) + 1]]
+
     @cache_readonly
     def result_index(self):
         if len(self.binlabels) != 0 and isna(self.binlabels[0]):
@@ -826,28 +847,27 @@ def names(self):
         return [self.binlabels.name]
 
     @property
-    def groupings(self):
-        from pandas.core.groupby.grouper import Grouping
-
+    def groupings(self) -> "List[grouper.Grouping]":
         return [
-            Grouping(lvl, lvl, in_axis=False, level=None, name=name)
+            grouper.Grouping(lvl, lvl, in_axis=False, level=None, name=name)
             for lvl, name in zip(self.levels, self.names)
         ]
 
-    def agg_series(self, obj, func):
+    def agg_series(self, obj: Series, func):
+        # Caller is responsible for checking ngroups != 0
+        assert self.ngroups != 0
+        assert len(self.bins) > 0  # otherwise we'd get IndexError in get_result
+
+        if is_extension_array_dtype(obj.dtype):
+            # pre-empt SeriesBinGrouper from raising TypeError
+            return self._aggregate_series_pure_python(obj, func)
+
         dummy = obj[:0]
         grouper = libreduction.SeriesBinGrouper(obj, func, self.bins, dummy)
         return grouper.get_result()
 
 
-def _get_axes(group):
-    if isinstance(group, Series):
-        return [group.index]
-    else:
-        return group.axes
-
-
-def _is_indexed_like(obj, axes):
+def _is_indexed_like(obj, axes) -> bool:
     if isinstance(obj, Series):
         if len(axes) > 1:
             return False
@@ -863,12 +883,13 @@ def _is_indexed_like(obj, axes):
 
 
 class DataSplitter:
-    def __init__(self, data, labels, ngroups, axis=0):
+    def __init__(self, data: FrameOrSeries, labels, ngroups: int, axis: int = 0):
         self.data = data
         self.labels = ensure_int64(labels)
         self.ngroups = ngroups
 
         self.axis = axis
+        assert isinstance(axis, int), axis
 
     @cache_readonly
     def slabels(self):
@@ -891,27 +912,18 @@ def __iter__(self):
         starts, ends = lib.generate_slices(self.slabels, self.ngroups)
 
         for i, (start, end) in enumerate(zip(starts, ends)):
-            # Since I'm now compressing the group ids, it's now not "possible"
-            # to produce empty slices because such groups would not be observed
-            # in the data
-            # if start >= end:
-            #     raise AssertionError('Start %s must be less than end %s'
-            #                          % (str(start), str(end)))
             yield i, self._chop(sdata, slice(start, end))
 
-    def _get_sorted_data(self):
+    def _get_sorted_data(self) -> FrameOrSeries:
         return self.data.take(self.sort_idx, axis=self.axis)
 
-    def _chop(self, sdata, slice_obj):
-        raise AbstractMethodError(self)
-
-    def apply(self, f):
+    def _chop(self, sdata, slice_obj: slice) -> NDFrame:
         raise AbstractMethodError(self)
 
 
 class SeriesSplitter(DataSplitter):
-    def _chop(self, sdata, slice_obj):
-        return sdata._get_values(slice_obj)
+    def _chop(self, sdata: Series, slice_obj: slice) -> Series:
+        return sdata.iloc[slice_obj]
 
 
 class FrameSplitter(DataSplitter):
@@ -922,17 +934,18 @@ def fast_apply(self, f, names):
         sdata = self._get_sorted_data()
         return libreduction.apply_frame_axis0(sdata, f, names, starts, ends)
 
-    def _chop(self, sdata, slice_obj):
+    def _chop(self, sdata: DataFrame, slice_obj: slice) -> DataFrame:
         if self.axis == 0:
             return sdata.iloc[slice_obj]
         else:
-            return sdata._slice(slice_obj, axis=1)
+            return sdata.iloc[:, slice_obj]
 
 
-def get_splitter(data, *args, **kwargs):
+def get_splitter(data: FrameOrSeries, *args, **kwargs) -> DataSplitter:
     if isinstance(data, Series):
-        klass = SeriesSplitter
-    elif isinstance(data, DataFrame):
+        klass: Type[DataSplitter] = SeriesSplitter
+    else:
+        # i.e. DataFrame
         klass = FrameSplitter
 
     return klass(data, *args, **kwargs)
diff --git a/pandas/core/index.py b/pandas/core/index.py
index d308ac1a9b1c7..8cff53d7a8b74 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -1,3 +1,5 @@
+import warnings
+
 from pandas.core.indexes.api import (  # noqa:F401
     CategoricalIndex,
     DatetimeIndex,
@@ -13,13 +15,17 @@
     RangeIndex,
     TimedeltaIndex,
     UInt64Index,
-    _all_indexes_same,
-    _get_combined_index,
-    _get_consensus_names,
-    _get_objs_combined_axis,
     _new_Index,
-    _union_indexes,
     ensure_index,
     ensure_index_from_sequences,
+    get_objs_combined_axis,
 )
 from pandas.core.indexes.multi import _sparsify  # noqa:F401
+
+# GH#30193
+warnings.warn(
+    "pandas.core.index is deprecated and will be removed in a future version.  "
+    "The public classes are available in the top-level namespace.",
+    FutureWarning,
+    stacklevel=2,
+)
diff --git a/pandas/core/indexers.py b/pandas/core/indexers.py
index 433bca940c028..fe475527f4596 100644
--- a/pandas/core/indexers.py
+++ b/pandas/core/indexers.py
@@ -1,9 +1,18 @@
 """
 Low-dependency indexing utilities.
 """
+import warnings
+
 import numpy as np
 
-from pandas.core.dtypes.common import is_list_like
+from pandas._typing import Any, AnyArrayLike
+
+from pandas.core.dtypes.common import (
+    is_array_like,
+    is_bool_dtype,
+    is_integer_dtype,
+    is_list_like,
+)
 from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
 
 # -----------------------------------------------------------
@@ -27,8 +36,13 @@ def is_list_like_indexer(key) -> bool:
 
 
 def is_scalar_indexer(indexer, arr_value) -> bool:
-    # return True if we are all scalar indexers
+    """
+    Return True if we are all scalar indexers.
 
+    Returns
+    -------
+    bool
+    """
     if arr_value.ndim == 1:
         if not isinstance(indexer, tuple):
             indexer = tuple([indexer])
@@ -73,11 +87,11 @@ def check_setitem_lengths(indexer, value, values) -> None:
     Parameters
     ----------
     indexer : sequence
-        The key for the setitem
+        Key for the setitem.
     value : array-like
-        The value for the setitem
+        Value for the setitem.
     values : array-like
-        The values being set into
+        Values being set into.
 
     Returns
     -------
@@ -86,8 +100,7 @@ def check_setitem_lengths(indexer, value, values) -> None:
     Raises
     ------
     ValueError
-        When the indexer is an ndarray or list and the lengths don't
-        match.
+        When the indexer is an ndarray or list and the lengths don't match.
     """
     # boolean with truth values == len of the value is ok too
     if isinstance(indexer, (np.ndarray, list)):
@@ -122,7 +135,7 @@ def validate_indices(indices: np.ndarray, n: int) -> None:
     ----------
     indices : ndarray
     n : int
-        length of the array being indexed
+        Length of the array being indexed.
 
     Raises
     ------
@@ -144,9 +157,7 @@ def validate_indices(indices: np.ndarray, n: int) -> None:
     if len(indices):
         min_idx = indices.min()
         if min_idx < -1:
-            msg = "'indices' contains values less than allowed ({} < {})".format(
-                min_idx, -1
-            )
+            msg = f"'indices' contains values less than allowed ({min_idx} < -1)"
             raise ValueError(msg)
 
         max_idx = indices.max()
@@ -168,27 +179,27 @@ def maybe_convert_indices(indices, n: int):
     Parameters
     ----------
     indices : array-like
-        The array of indices that we are to convert.
+        Array of indices that we are to convert.
     n : int
-        The number of elements in the array that we are indexing.
+        Number of elements in the array that we are indexing.
 
     Returns
     -------
-    valid_indices : array-like
+    array-like
         An array-like of positive indices that correspond to the ones
         that were passed in initially to this function.
 
     Raises
     ------
-    IndexError : one of the converted indices either exceeded the number
-        of elements (specified by `n`) OR was still negative.
+    IndexError
+        One of the converted indices either exceeded the number of,
+        elements (specified by `n`), or was still negative.
     """
-
     if isinstance(indices, list):
         indices = np.array(indices)
         if len(indices) == 0:
-            # If list is empty, np.array will return float and cause indexing
-            # errors.
+            # If `indices` is empty, np.array will return a float,
+            # and will cause indexing errors.
             return np.empty(0, dtype=np.intp)
 
     mask = indices < 0
@@ -208,7 +219,11 @@ def maybe_convert_indices(indices, n: int):
 
 def length_of_indexer(indexer, target=None) -> int:
     """
-    return the length of a single non-tuple indexer which could be a slice
+    Return the length of a single non-tuple indexer which could be a slice.
+
+    Returns
+    -------
+    int
     """
     if target is not None and isinstance(indexer, slice):
         target_len = len(target)
@@ -234,3 +249,168 @@ def length_of_indexer(indexer, target=None) -> int:
     elif not is_list_like_indexer(indexer):
         return 1
     raise AssertionError("cannot find the length of the indexer")
+
+
+def deprecate_ndim_indexing(result):
+    """
+    Helper function to raise the deprecation warning for multi-dimensional
+    indexing on 1D Series/Index.
+
+    GH#27125 indexer like idx[:, None] expands dim, but we cannot do that
+    and keep an index, so we currently return ndarray, which is deprecated
+    (Deprecation GH#30588).
+    """
+    if np.ndim(result) > 1:
+        warnings.warn(
+            "Support for multi-dimensional indexing (e.g. `index[:, None]`) "
+            "on an Index is deprecated and will be removed in a future "
+            "version.  Convert to a numpy array before indexing instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+
+
+# -----------------------------------------------------------
+# Public indexer validation
+
+
+def check_array_indexer(array: AnyArrayLike, indexer: Any) -> Any:
+    """
+    Check if `indexer` is a valid array indexer for `array`.
+
+    For a boolean mask, `array` and `indexer` are checked to have the same
+    length. The dtype is validated, and if it is an integer or boolean
+    ExtensionArray, it is checked if there are missing values present, and
+    it is converted to the appropriate numpy array. Other dtypes will raise
+    an error.
+
+    Non-array indexers (integer, slice, Ellipsis, tuples, ..) are passed
+    through as is.
+
+    .. versionadded:: 1.0.0
+
+    Parameters
+    ----------
+    array : array-like
+        The array that is being indexed (only used for the length).
+    indexer : array-like or list-like
+        The array-like that's used to index. List-like input that is not yet
+        a numpy array or an ExtensionArray is converted to one. Other input
+        types are passed through as is
+
+    Returns
+    -------
+    numpy.ndarray
+        The validated indexer as a numpy array that can be used to index.
+
+    Raises
+    ------
+    IndexError
+        When the lengths don't match.
+    ValueError
+        When `indexer` cannot be converted to a numpy ndarray to index
+        (e.g. presence of missing values).
+
+    See Also
+    --------
+    api.types.is_bool_dtype : Check if `key` is of boolean dtype.
+
+    Examples
+    --------
+    When checking a boolean mask, a boolean ndarray is returned when the
+    arguments are all valid.
+
+    >>> mask = pd.array([True, False])
+    >>> arr = pd.array([1, 2])
+    >>> pd.api.indexers.check_array_indexer(arr, mask)
+    array([ True, False])
+
+    An IndexError is raised when the lengths don't match.
+
+    >>> mask = pd.array([True, False, True])
+    >>> pd.api.indexers.check_array_indexer(arr, mask)
+    Traceback (most recent call last):
+    ...
+    IndexError: Boolean index has wrong length: 3 instead of 2.
+
+    A ValueError is raised when the mask cannot be converted to
+    a bool-dtype ndarray.
+
+    >>> mask = pd.array([True, pd.NA])
+    >>> pd.api.indexers.check_array_indexer(arr, mask)
+    Traceback (most recent call last):
+    ...
+    ValueError: Cannot mask with a boolean indexer containing NA values
+
+    A numpy boolean mask will get passed through (if the length is correct):
+
+    >>> mask = np.array([True, False])
+    >>> pd.api.indexers.check_array_indexer(arr, mask)
+    array([ True, False])
+
+    Similarly for integer indexers, an integer ndarray is returned when it is
+    a valid indexer, otherwise an error is  (for integer indexers, a matching
+    length is not required):
+
+    >>> indexer = pd.array([0, 2], dtype="Int64")
+    >>> arr = pd.array([1, 2, 3])
+    >>> pd.api.indexers.check_array_indexer(arr, indexer)
+    array([0, 2])
+
+    >>> indexer = pd.array([0, pd.NA], dtype="Int64")
+    >>> pd.api.indexers.check_array_indexer(arr, indexer)
+    Traceback (most recent call last):
+    ...
+    ValueError: Cannot index with an integer indexer containing NA values
+
+    For non-integer/boolean dtypes, an appropriate error is raised:
+
+    >>> indexer = np.array([0., 2.], dtype="float64")
+    >>> pd.api.indexers.check_array_indexer(arr, indexer)
+    Traceback (most recent call last):
+    ...
+    IndexError: arrays used as indices must be of integer or boolean type
+    """
+    from pandas.core.construction import array as pd_array
+
+    # whathever is not an array-like is returned as-is (possible valid array
+    # indexers that are not array-like: integer, slice, Ellipsis, None)
+    # In this context, tuples are not considered as array-like, as they have
+    # a specific meaning in indexing (multi-dimensional indexing)
+    if is_list_like(indexer):
+        if isinstance(indexer, tuple):
+            return indexer
+    else:
+        return indexer
+
+    # convert list-likes to array
+    if not is_array_like(indexer):
+        indexer = pd_array(indexer)
+        if len(indexer) == 0:
+            # empty list is converted to float array by pd.array
+            indexer = np.array([], dtype=np.intp)
+
+    dtype = indexer.dtype
+    if is_bool_dtype(dtype):
+        try:
+            indexer = np.asarray(indexer, dtype=bool)
+        except ValueError:
+            raise ValueError("Cannot mask with a boolean indexer containing NA values")
+
+        # GH26658
+        if len(indexer) != len(array):
+            raise IndexError(
+                f"Boolean index has wrong length: "
+                f"{len(indexer)} instead of {len(array)}"
+            )
+    elif is_integer_dtype(dtype):
+        try:
+            indexer = np.asarray(indexer, dtype=np.intp)
+        except ValueError:
+            raise ValueError(
+                "Cannot index with an integer indexer containing NA values"
+            )
+    else:
+        raise IndexError("arrays used as indices must be of integer or boolean type")
+
+    return indexer
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index cc8ecc0e64684..db774a03c02f8 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -16,7 +16,6 @@
 from pandas.core.dtypes.generic import ABCSeries
 
 from pandas.core.accessor import PandasDelegate, delegate_names
-from pandas.core.algorithms import take_1d
 from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
 from pandas.core.base import NoNewAttributesMixin, PandasObject
 from pandas.core.indexes.datetimes import DatetimeIndex
@@ -27,8 +26,7 @@ class Properties(PandasDelegate, PandasObject, NoNewAttributesMixin):
     def __init__(self, data, orig):
         if not isinstance(data, ABCSeries):
             raise TypeError(
-                "cannot convert an object of type {0} to a "
-                "datetimelike index".format(type(data))
+                f"cannot convert an object of type {type(data)} to a datetimelike index"
             )
 
         self._parent = data
@@ -55,8 +53,7 @@ def _get_values(self):
                 return DatetimeIndex(data, copy=False, name=self.name)
 
         raise TypeError(
-            "cannot convert an object of type {0} to a "
-            "datetimelike index".format(type(data))
+            f"cannot convert an object of type {type(data)} to a datetimelike index"
         )
 
     def _delegate_property_get(self, name):
@@ -75,9 +72,7 @@ def _delegate_property_get(self, name):
 
         result = np.asarray(result)
 
-        # blow up if we operate on categories
         if self.orig is not None:
-            result = take_1d(result, self.orig.cat.codes)
             index = self.orig.index
         else:
             index = self._parent.index
@@ -95,9 +90,8 @@ def _delegate_property_get(self, name):
 
     def _delegate_property_set(self, name, value, *args, **kwargs):
         raise ValueError(
-            "modifications to a property of a datetimelike "
-            "object are not supported. Change values on the "
-            "original."
+            "modifications to a property of a datetimelike object are not supported. "
+            "Change values on the original."
         )
 
     def _delegate_method(self, name, *args, **kwargs):
@@ -226,7 +220,7 @@ def to_pytimedelta(self):
 
         Returns
         -------
-        a : numpy.ndarray
+        numpy.ndarray
             Array of 1D containing data with `datetime.timedelta` type.
 
         See Also
@@ -318,13 +312,17 @@ def __new__(cls, data):
 
         if not isinstance(data, ABCSeries):
             raise TypeError(
-                "cannot convert an object of type {0} to a "
-                "datetimelike index".format(type(data))
+                f"cannot convert an object of type {type(data)} to a datetimelike index"
             )
 
         orig = data if is_categorical_dtype(data) else None
         if orig is not None:
-            data = Series(orig.values.categories, name=orig.name, copy=False)
+            data = Series(
+                orig.array,
+                name=orig.name,
+                copy=False,
+                dtype=orig.values.categories.dtype,
+            )
 
         if is_datetime64_dtype(data.dtype):
             return DatetimeProperties(data, orig)
diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 86d55ce2e7cc3..0a23d38ace37e 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -1,28 +1,28 @@
 import textwrap
-import warnings
+from typing import List, Set
 
 from pandas._libs import NaT, lib
 
 import pandas.core.common as com
 from pandas.core.indexes.base import (
     Index,
+    InvalidIndexError,
     _new_Index,
     ensure_index,
     ensure_index_from_sequences,
 )
-from pandas.core.indexes.base import InvalidIndexError  # noqa:F401
-from pandas.core.indexes.category import CategoricalIndex  # noqa:F401
+from pandas.core.indexes.category import CategoricalIndex
 from pandas.core.indexes.datetimes import DatetimeIndex
-from pandas.core.indexes.interval import IntervalIndex  # noqa:F401
-from pandas.core.indexes.multi import MultiIndex  # noqa:F401
-from pandas.core.indexes.numeric import (  # noqa:F401
+from pandas.core.indexes.interval import IntervalIndex
+from pandas.core.indexes.multi import MultiIndex
+from pandas.core.indexes.numeric import (
     Float64Index,
     Int64Index,
     NumericIndex,
     UInt64Index,
 )
 from pandas.core.indexes.period import PeriodIndex
-from pandas.core.indexes.range import RangeIndex  # noqa:F401
+from pandas.core.indexes.range import RangeIndex
 from pandas.core.indexes.timedeltas import TimedeltaIndex
 
 _sort_msg = textwrap.dedent(
@@ -37,8 +37,6 @@
 )
 
 
-# TODO: there are many places that rely on these private methods existing in
-# pandas.core.index
 __all__ = [
     "Index",
     "MultiIndex",
@@ -57,15 +55,16 @@
     "NaT",
     "ensure_index",
     "ensure_index_from_sequences",
-    "_get_combined_index",
-    "_get_objs_combined_axis",
-    "_union_indexes",
-    "_get_consensus_names",
-    "_all_indexes_same",
+    "get_objs_combined_axis",
+    "union_indexes",
+    "get_consensus_names",
+    "all_indexes_same",
 ]
 
 
-def _get_objs_combined_axis(objs, intersect=False, axis=0, sort=True):
+def get_objs_combined_axis(
+    objs, intersect: bool = False, axis=0, sort: bool = True, copy: bool = False
+) -> Index:
     """
     Extract combined index: return intersection or union (depending on the
     value of "intersect") of indexes on given axis, or None if all objects
@@ -73,9 +72,8 @@ def _get_objs_combined_axis(objs, intersect=False, axis=0, sort=True):
 
     Parameters
     ----------
-    objs : list of objects
-        Each object will only be considered if it has a _get_axis
-        attribute.
+    objs : list
+        Series or DataFrame objects, may be mix of the two.
     intersect : bool, default False
         If True, calculate the intersection between indexes. Otherwise,
         calculate the union.
@@ -83,31 +81,37 @@ def _get_objs_combined_axis(objs, intersect=False, axis=0, sort=True):
         The axis to extract indexes from.
     sort : bool, default True
         Whether the result index should come out sorted or not.
+    copy : bool, default False
+        If True, return a copy of the combined index.
 
     Returns
     -------
     Index
     """
-    obs_idxes = [obj._get_axis(axis) for obj in objs if hasattr(obj, "_get_axis")]
-    if obs_idxes:
-        return _get_combined_index(obs_idxes, intersect=intersect, sort=sort)
+    obs_idxes = [obj._get_axis(axis) for obj in objs]
+    return _get_combined_index(obs_idxes, intersect=intersect, sort=sort, copy=copy)
 
 
-def _get_distinct_objs(objs):
+def _get_distinct_objs(objs: List[Index]) -> List[Index]:
     """
     Return a list with distinct elements of "objs" (different ids).
     Preserves order.
     """
-    ids = set()
+    ids: Set[int] = set()
     res = []
     for obj in objs:
-        if not id(obj) in ids:
+        if id(obj) not in ids:
             ids.add(id(obj))
             res.append(obj)
     return res
 
 
-def _get_combined_index(indexes, intersect=False, sort=False):
+def _get_combined_index(
+    indexes: List[Index],
+    intersect: bool = False,
+    sort: bool = False,
+    copy: bool = False,
+) -> Index:
     """
     Return the union or intersection of indexes.
 
@@ -120,12 +124,13 @@ def _get_combined_index(indexes, intersect=False, sort=False):
         calculate the union.
     sort : bool, default False
         Whether the result index should come out sorted or not.
+    copy : bool, default False
+        If True, return a copy of the combined index.
 
     Returns
     -------
     Index
     """
-
     # TODO: handle index names!
     indexes = _get_distinct_objs(indexes)
     if len(indexes) == 0:
@@ -137,7 +142,7 @@ def _get_combined_index(indexes, intersect=False, sort=False):
         for other in indexes[1:]:
             index = index.intersection(other)
     else:
-        index = _union_indexes(indexes, sort=sort)
+        index = union_indexes(indexes, sort=sort)
         index = ensure_index(index)
 
     if sort:
@@ -145,10 +150,15 @@ def _get_combined_index(indexes, intersect=False, sort=False):
             index = index.sort_values()
         except TypeError:
             pass
+
+    # GH 29879
+    if copy:
+        index = index.copy()
+
     return index
 
 
-def _union_indexes(indexes, sort=True):
+def union_indexes(indexes, sort=True) -> Index:
     """
     Return the union of indexes.
 
@@ -174,7 +184,7 @@ def _union_indexes(indexes, sort=True):
 
     indexes, kind = _sanitize_and_check(indexes)
 
-    def _unique_indices(inds):
+    def _unique_indices(inds) -> Index:
         """
         Convert indexes to lists and concatenate them, removing duplicates.
 
@@ -200,6 +210,7 @@ def conv(i):
         result = indexes[0]
 
         if hasattr(result, "union_many"):
+            # DatetimeIndex
             return result.union_many(indexes[1:])
         else:
             for other in indexes[1:]:
@@ -209,15 +220,9 @@ def conv(i):
         index = indexes[0]
         for other in indexes[1:]:
             if not index.equals(other):
-
-                if sort is None:
-                    # TODO: remove once pd.concat sort default changes
-                    warnings.warn(_sort_msg, FutureWarning, stacklevel=8)
-                    sort = True
-
                 return _unique_indices(indexes)
 
-        name = _get_consensus_names(indexes)[0]
+        name = get_consensus_names(indexes)[0]
         if name != index.name:
             index = index._shallow_copy(name=name)
         return index
@@ -264,7 +269,7 @@ def _sanitize_and_check(indexes):
         return indexes, "array"
 
 
-def _get_consensus_names(indexes):
+def get_consensus_names(indexes):
     """
     Give a consensus 'names' to indexes.
 
@@ -280,7 +285,6 @@ def _get_consensus_names(indexes):
     list
         A list representing the consensus 'names' found.
     """
-
     # find the non-none names, need to tupleify to make
     # the set hashable, then reverse on return
     consensus_names = {tuple(i.names) for i in indexes if com.any_not_none(*i.names)}
@@ -289,7 +293,7 @@ def _get_consensus_names(indexes):
     return [None] * indexes[0].nlevels
 
 
-def _all_indexes_same(indexes):
+def all_indexes_same(indexes):
     """
     Determine if all indexes contain the same elements.
 
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 2dbd592fc6787..719bf13cbd313 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1,7 +1,7 @@
 from datetime import datetime
 import operator
 from textwrap import dedent
-from typing import Union
+from typing import TYPE_CHECKING, Any, FrozenSet, Hashable, Optional, Union
 import warnings
 
 import numpy as np
@@ -12,12 +12,16 @@
 from pandas._libs.tslibs import OutOfBoundsDatetime, Timestamp
 from pandas._libs.tslibs.period import IncompatibleFrequency
 from pandas._libs.tslibs.timezones import tz_compare
+from pandas._typing import Label
 from pandas.compat import set_function_name
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender, Substitution, cache_readonly
 
 from pandas.core.dtypes import concat as _concat
-from pandas.core.dtypes.cast import maybe_cast_to_integer_array
+from pandas.core.dtypes.cast import (
+    maybe_cast_to_integer_array,
+    validate_numeric_casting,
+)
 from pandas.core.dtypes.common import (
     ensure_categorical,
     ensure_int64,
@@ -45,44 +49,47 @@
     is_signed_integer_dtype,
     is_timedelta64_dtype,
     is_unsigned_integer_dtype,
-    pandas_dtype,
 )
 from pandas.core.dtypes.concat import concat_compat
 from pandas.core.dtypes.generic import (
     ABCCategorical,
     ABCDataFrame,
-    ABCDatetimeArray,
     ABCDatetimeIndex,
-    ABCIndexClass,
+    ABCIntervalIndex,
     ABCMultiIndex,
     ABCPandasArray,
     ABCPeriodIndex,
+    ABCRangeIndex,
     ABCSeries,
     ABCTimedeltaIndex,
 )
 from pandas.core.dtypes.missing import array_equivalent, isna
 
 from pandas.core import ops
-from pandas.core.accessor import CachedAccessor, DirNamesMixin
+from pandas.core.accessor import CachedAccessor
 import pandas.core.algorithms as algos
 from pandas.core.arrays import ExtensionArray
 from pandas.core.base import IndexOpsMixin, PandasObject
 import pandas.core.common as com
-from pandas.core.indexers import maybe_convert_indices
+from pandas.core.indexers import deprecate_ndim_indexing
 from pandas.core.indexes.frozen import FrozenList
 import pandas.core.missing as missing
 from pandas.core.ops import get_op_result_name
 from pandas.core.ops.invalid import make_invalid_op
-import pandas.core.sorting as sorting
 from pandas.core.strings import StringMethods
 
 from pandas.io.formats.printing import (
+    PrettyDict,
     default_pprint,
     format_object_attrs,
     format_object_summary,
     pprint_thing,
 )
 
+if TYPE_CHECKING:
+    from pandas import Series
+
+
 __all__ = ["Index"]
 
 _unsortable_types = frozenset(("mixed", "mixed-integer"))
@@ -96,6 +103,7 @@
     duplicated="np.ndarray",
 )
 _index_shared_docs = dict()
+str_t = str
 
 
 def _make_comparison_op(op, cls):
@@ -107,6 +115,11 @@ def cmp_method(self, other):
         if is_object_dtype(self) and isinstance(other, ABCCategorical):
             left = type(other)(self._values, dtype=other.dtype)
             return op(left, other)
+        elif is_object_dtype(self) and isinstance(other, ExtensionArray):
+            # e.g. PeriodArray
+            with np.errstate(all="ignore"):
+                result = op(self.values, other)
+
         elif is_object_dtype(self) and not isinstance(self, ABCMultiIndex):
             # don't pass MultiIndex
             with np.errstate(all="ignore"):
@@ -120,7 +133,7 @@ def cmp_method(self, other):
             return result
         return ops.invalid_comparison(self, other, op)
 
-    name = "__{name}__".format(name=op.__name__)
+    name = f"__{op.__name__}__"
     return set_function_name(cmp_method, name, cls)
 
 
@@ -136,7 +149,7 @@ def index_arithmetic_method(self, other):
             return (Index(result[0]), Index(result[1]))
         return Index(result)
 
-    name = "__{name}__".format(name=op.__name__)
+    name = f"__{op.__name__}__"
     # TODO: docstring?
     return set_function_name(index_arithmetic_method, name, cls)
 
@@ -160,6 +173,12 @@ def _new_Index(cls, d):
         from pandas.core.indexes.period import _new_PeriodIndex
 
         return _new_PeriodIndex(cls, **d)
+
+    if issubclass(cls, ABCMultiIndex):
+        if "labels" in d and "codes" not in d:
+            # GH#23752 "labels" kwarg has been replaced with "codes"
+            d["codes"] = d.pop("labels")
+
     return cls.__new__(cls, **d)
 
 
@@ -176,11 +195,11 @@ class Index(IndexOpsMixin, PandasObject):
         If an actual dtype is provided, we coerce to that dtype if it's safe.
         Otherwise, an error will be raised.
     copy : bool
-        Make a copy of input ndarray
+        Make a copy of input ndarray.
     name : object
-        Name to be stored in the index
+        Name to be stored in the index.
     tupleize_cols : bool (default: True)
-        When True, attempt to create a MultiIndex if possible
+        When True, attempt to create a MultiIndex if possible.
 
     See Also
     --------
@@ -205,7 +224,11 @@ class Index(IndexOpsMixin, PandasObject):
     """
 
     # tolist is not actually deprecated, just suppressed in the __dir__
-    _deprecations = DirNamesMixin._deprecations | frozenset(["tolist"])
+    _deprecations: FrozenSet[str] = (
+        PandasObject._deprecations
+        | IndexOpsMixin._deprecations
+        | frozenset(["contains", "set_value"])
+    )
 
     # To hand over control to subclasses
     _join_precedence = 1
@@ -227,9 +250,13 @@ def _outer_indexer(self, left, right):
         return libjoin.outer_join_indexer(left, right)
 
     _typ = "index"
-    _data = None
+    _data: Union[ExtensionArray, np.ndarray]
     _id = None
-    name = None
+    _name: Label = None
+    # MultiIndex.levels previously allowed setting the index name. We
+    # don't allow this anymore, and raise if it happens rather than
+    # failing silently.
+    _no_setting_name: bool = False
     _comparables = ["name"]
     _attributes = ["name"]
     _is_numeric_dtype = False
@@ -255,34 +282,12 @@ def _outer_indexer(self, left, right):
     # Constructors
 
     def __new__(
-        cls,
-        data=None,
-        dtype=None,
-        copy=False,
-        name=None,
-        fastpath=None,
-        tupleize_cols=True,
-        **kwargs
+        cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs,
     ) -> "Index":
 
-        from .range import RangeIndex
-        from pandas import PeriodIndex, DatetimeIndex, TimedeltaIndex
-        from .numeric import Float64Index, Int64Index, UInt64Index
-        from .interval import IntervalIndex
-        from .category import CategoricalIndex
-
-        if name is None and hasattr(data, "name"):
-            name = data.name
-
-        if fastpath is not None:
-            warnings.warn(
-                "The 'fastpath' keyword is deprecated, and will be "
-                "removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if fastpath:
-                return cls._simple_new(data, name)
+        from pandas.core.indexes.range import RangeIndex
+
+        name = maybe_extract_name(name, data, cls)
 
         if isinstance(data, ABCPandasArray):
             # ensure users don't accidentally put a PandasArray in an index.
@@ -296,20 +301,33 @@ def __new__(
 
         # categorical
         elif is_categorical_dtype(data) or is_categorical_dtype(dtype):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas.core.indexes.category import CategoricalIndex
+
             return CategoricalIndex(data, dtype=dtype, copy=copy, name=name, **kwargs)
 
         # interval
-        elif (
-            is_interval_dtype(data) or is_interval_dtype(dtype)
-        ) and not is_object_dtype(dtype):
-            closed = kwargs.get("closed", None)
-            return IntervalIndex(data, dtype=dtype, name=name, copy=copy, closed=closed)
+        elif is_interval_dtype(data) or is_interval_dtype(dtype):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas.core.indexes.interval import IntervalIndex
+
+            closed = kwargs.pop("closed", None)
+            if is_dtype_equal(_o_dtype, dtype):
+                return IntervalIndex(
+                    data, name=name, copy=copy, closed=closed, **kwargs
+                ).astype(object)
+            return IntervalIndex(
+                data, dtype=dtype, name=name, copy=copy, closed=closed, **kwargs
+            )
 
         elif (
             is_datetime64_any_dtype(data)
             or is_datetime64_any_dtype(dtype)
             or "tz" in kwargs
         ):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas import DatetimeIndex
+
             if is_dtype_equal(_o_dtype, dtype):
                 # GH#23524 passing `dtype=object` to DatetimeIndex is invalid,
                 #  will raise in the where `data` is already tz-aware.  So
@@ -317,32 +335,41 @@ def __new__(
                 #  the DatetimeIndex construction.
                 # Note we can pass copy=False because the .astype below
                 #  will always make a copy
-                result = DatetimeIndex(
-                    data, copy=False, name=name, **kwargs
-                )  # type: "Index"
-                return result.astype(object)
+                return DatetimeIndex(data, copy=False, name=name, **kwargs).astype(
+                    object
+                )
             else:
                 return DatetimeIndex(data, copy=copy, name=name, dtype=dtype, **kwargs)
 
         elif is_timedelta64_dtype(data) or is_timedelta64_dtype(dtype):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas import TimedeltaIndex
+
             if is_dtype_equal(_o_dtype, dtype):
                 # Note we can pass copy=False because the .astype below
                 #  will always make a copy
-                result = TimedeltaIndex(data, copy=False, name=name, **kwargs)
-                return result.astype(object)
+                return TimedeltaIndex(data, copy=False, name=name, **kwargs).astype(
+                    object
+                )
             else:
                 return TimedeltaIndex(data, copy=copy, name=name, dtype=dtype, **kwargs)
 
-        elif is_period_dtype(data) and not is_object_dtype(dtype):
-            return PeriodIndex(data, copy=copy, name=name, **kwargs)
+        elif is_period_dtype(data) or is_period_dtype(dtype):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas import PeriodIndex
+
+            if is_dtype_equal(_o_dtype, dtype):
+                return PeriodIndex(data, copy=False, name=name, **kwargs).astype(object)
+            return PeriodIndex(data, dtype=dtype, copy=copy, name=name, **kwargs)
 
         # extension dtype
         elif is_extension_array_dtype(data) or is_extension_array_dtype(dtype):
-            data = np.asarray(data)
             if not (dtype is None or is_object_dtype(dtype)):
                 # coerce to the provided dtype
                 ea_cls = dtype.construct_array_type()
                 data = ea_cls._from_sequence(data, dtype=dtype, copy=False)
+            else:
+                data = np.asarray(data, dtype=object)
 
             # coerce to the object dtype
             data = data.astype(object)
@@ -350,47 +377,21 @@ def __new__(
 
         # index-like
         elif isinstance(data, (np.ndarray, Index, ABCSeries)):
+            # Delay import for perf. https://github.com/pandas-dev/pandas/pull/31423
+            from pandas.core.indexes.numeric import (
+                Float64Index,
+                Int64Index,
+                UInt64Index,
+            )
+
             if dtype is not None:
                 # we need to avoid having numpy coerce
                 # things that look like ints/floats to ints unless
                 # they are actually ints, e.g. '0' and 0.0
                 # should not be coerced
                 # GH 11836
-                if is_integer_dtype(dtype):
-                    inferred = lib.infer_dtype(data, skipna=False)
-                    if inferred == "integer":
-                        data = maybe_cast_to_integer_array(data, dtype, copy=copy)
-                    elif inferred in ["floating", "mixed-integer-float"]:
-                        if isna(data).any():
-                            raise ValueError("cannot convert float NaN to integer")
-
-                        if inferred == "mixed-integer-float":
-                            data = maybe_cast_to_integer_array(data, dtype)
-
-                        # If we are actually all equal to integers,
-                        # then coerce to integer.
-                        try:
-                            return cls._try_convert_to_int_index(
-                                data, copy, name, dtype
-                            )
-                        except ValueError:
-                            pass
-
-                        # Return an actual float index.
-                        return Float64Index(data, copy=copy, dtype=dtype, name=name)
-
-                    elif inferred == "string":
-                        pass
-                    else:
-                        data = data.astype(dtype)
-                elif is_float_dtype(dtype):
-                    inferred = lib.infer_dtype(data, skipna=False)
-                    if inferred == "string":
-                        pass
-                    else:
-                        data = data.astype(dtype)
-                else:
-                    data = np.array(data, dtype=dtype, copy=copy)
+                data = _maybe_cast_with_dtype(data, dtype, copy)
+                dtype = data.dtype  # TODO: maybe not for object?
 
             # maybe coerce to a sub-class
             if is_signed_integer_dtype(data.dtype):
@@ -410,49 +411,23 @@ def __new__(
                 subarr = subarr.copy()
 
             if dtype is None:
-                inferred = lib.infer_dtype(subarr, skipna=False)
-                if inferred == "integer":
-                    try:
-                        return cls._try_convert_to_int_index(subarr, copy, name, dtype)
-                    except ValueError:
-                        pass
-
-                    return Index(subarr, copy=copy, dtype=object, name=name)
-                elif inferred in ["floating", "mixed-integer-float", "integer-na"]:
-                    # TODO: Returns IntegerArray for integer-na case in the future
-                    return Float64Index(subarr, copy=copy, name=name)
-                elif inferred == "interval":
-                    try:
-                        return IntervalIndex(subarr, name=name, copy=copy)
-                    except ValueError:
-                        # GH27172: mixed closed Intervals --> object dtype
-                        pass
-                elif inferred == "boolean":
-                    # don't support boolean explicitly ATM
-                    pass
-                elif inferred != "string":
-                    if inferred.startswith("datetime"):
-                        try:
-                            return DatetimeIndex(subarr, copy=copy, name=name, **kwargs)
-                        except (ValueError, OutOfBoundsDatetime):
-                            # GH 27011
-                            # If we have mixed timezones, just send it
-                            # down the base constructor
-                            pass
-
-                    elif inferred.startswith("timedelta"):
-                        return TimedeltaIndex(subarr, copy=copy, name=name, **kwargs)
-                    elif inferred == "period":
-                        try:
-                            return PeriodIndex(subarr, name=name, **kwargs)
-                        except IncompatibleFrequency:
-                            pass
+                new_data, new_dtype = _maybe_cast_data_without_dtype(subarr)
+                if new_dtype is not None:
+                    return cls(
+                        new_data, dtype=new_dtype, copy=False, name=name, **kwargs
+                    )
+
+            if kwargs:
+                raise TypeError(f"Unexpected keyword arguments {repr(set(kwargs))}")
+            if subarr.ndim > 1:
+                # GH#13601, GH#20285, GH#27125
+                raise ValueError("Index data must be 1-dimensional")
             return cls._simple_new(subarr, name)
 
         elif hasattr(data, "__array__"):
             return Index(np.asarray(data), dtype=dtype, copy=copy, name=name, **kwargs)
         elif data is None or is_scalar(data):
-            cls._scalar_data_error(data)
+            raise cls._scalar_data_error(data)
         else:
             if tupleize_cols and is_list_like(data):
                 # GH21470: convert iterable to list before determining if empty
@@ -462,7 +437,7 @@ def __new__(
                 if data and all(isinstance(e, tuple) for e in data):
                     # we must be all tuples, otherwise don't construct
                     # 10697
-                    from .multi import MultiIndex
+                    from pandas.core.indexes.multi import MultiIndex
 
                     return MultiIndex.from_tuples(
                         data, names=name or kwargs.get("names")
@@ -503,18 +478,14 @@ def asi8(self):
         return None
 
     @classmethod
-    def _simple_new(cls, values, name=None, dtype=None, **kwargs):
+    def _simple_new(cls, values, name=None, dtype=None):
         """
         We require that we have a dtype compat for the values. If we are passed
         a non-dtype compat, then coerce using the constructor.
 
         Must be careful not to recurse.
         """
-        if isinstance(values, (ABCSeries, ABCIndexClass)):
-            # Index._data must always be an ndarray.
-            # This is no-copy for when _values is an ndarray,
-            # which should be always at this point.
-            values = np.asarray(values._values)
+        assert isinstance(values, np.ndarray), type(values)
 
         result = object.__new__(cls)
         result._data = values
@@ -524,9 +495,8 @@ def _simple_new(cls, values, name=None, dtype=None, **kwargs):
         # data buffers and strides. We don't re-use `_ndarray_values`, since
         # we actually set this value too.
         result._index_data = values
-        result.name = name
-        for k, v in kwargs.items():
-            setattr(result, k, v)
+        result._name = name
+
         return result._reset_identity()
 
     @cache_readonly
@@ -542,9 +512,8 @@ def _get_attributes_dict(self):
         """
         return {k: getattr(self, k, None) for k in self._attributes}
 
-    _index_shared_docs[
-        "_shallow_copy"
-    ] = """
+    def _shallow_copy(self, values=None, **kwargs):
+        """
         Create a new Index with the same class as the caller, don't copy the
         data, use the same object attributes with passed in attributes taking
         precedence.
@@ -556,22 +525,12 @@ def _get_attributes_dict(self):
         values : the values to create the new Index, optional
         kwargs : updates the default attributes for this Index
         """
-
-    @Appender(_index_shared_docs["_shallow_copy"])
-    def _shallow_copy(self, values=None, **kwargs):
         if values is None:
             values = self.values
+
         attributes = self._get_attributes_dict()
-        attributes.update(kwargs)
-        if not len(values) and "dtype" not in kwargs:
-            attributes["dtype"] = self.dtype
 
-        # _simple_new expects an the type of self._data
-        values = getattr(values, "_values", values)
-        if isinstance(values, ABCDatetimeArray):
-            # `self.values` returns `self` for tz-aware, so we need to unwrap
-            #  more specifically
-            values = values.asi8
+        attributes.update(kwargs)
 
         return self._simple_new(values, **attributes)
 
@@ -592,6 +551,7 @@ def _shallow_copy_with_infer(self, values, **kwargs):
         attributes.update(kwargs)
         attributes["copy"] = False
         if not len(values) and "dtype" not in kwargs:
+            # TODO: what if hasattr(values, "dtype")?
             attributes["dtype"] = self.dtype
         if self._infer_as_myclass:
             try:
@@ -604,7 +564,7 @@ def _update_inplace(self, result, **kwargs):
         # guard when called from IndexOpsMixin
         raise TypeError("Index can't be updated inplace")
 
-    def is_(self, other):
+    def is_(self, other) -> bool:
         """
         More flexible, faster check like ``is`` but that works through views.
 
@@ -646,13 +606,13 @@ def _engine(self):
     # Array-Like Methods
 
     # ndarray compat
-    def __len__(self):
+    def __len__(self) -> int:
         """
         Return the length of the Index.
         """
         return len(self._data)
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """
         The array interface, return my values.
         """
@@ -663,7 +623,7 @@ def __array_wrap__(self, result, context=None):
         Gets called after a ufunc.
         """
         result = lib.item_from_zerodim(result)
-        if is_bool_dtype(result) or lib.is_scalar(result):
+        if is_bool_dtype(result) or lib.is_scalar(result) or np.ndim(result) > 1:
             return result
 
         attrs = self._get_attributes_dict()
@@ -676,21 +636,6 @@ def dtype(self):
         """
         return self._data.dtype
 
-    @property
-    def dtype_str(self):
-        """
-        Return the dtype str of the underlying data.
-
-        .. deprecated:: 0.25.0
-        """
-        warnings.warn(
-            "`dtype_str` has been deprecated. Call `str` on the "
-            "dtype attribute instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return str(self.dtype)
-
     def ravel(self, order="C"):
         """
         Return an ndarray of the flattened values of the underlying data.
@@ -718,9 +663,8 @@ def view(self, cls=None):
             result._id = self._id
         return result
 
-    _index_shared_docs[
-        "astype"
-    ] = """
+    def astype(self, dtype, copy=True):
+        """
         Create an Index with values cast to dtypes. The class of a new Index
         is determined by dtype. When conversion is impossible, a ValueError
         exception is raised.
@@ -742,40 +686,22 @@ def view(self, cls=None):
         Index
             Index with values cast to specified dtype.
         """
-
-    @Appender(_index_shared_docs["astype"])
-    def astype(self, dtype, copy=True):
         if is_dtype_equal(self.dtype, dtype):
             return self.copy() if copy else self
 
         elif is_categorical_dtype(dtype):
-            from .category import CategoricalIndex
+            from pandas.core.indexes.category import CategoricalIndex
 
             return CategoricalIndex(self.values, name=self.name, dtype=dtype, copy=copy)
-        elif is_datetime64tz_dtype(dtype):
-            # TODO(GH-24559): Remove this block, use the following elif.
-            # avoid FutureWarning from DatetimeIndex constructor.
-            from pandas import DatetimeIndex
-
-            tz = pandas_dtype(dtype).tz
-            return DatetimeIndex(np.asarray(self)).tz_localize("UTC").tz_convert(tz)
 
         elif is_extension_array_dtype(dtype):
             return Index(np.asarray(self), dtype=dtype, copy=copy)
 
         try:
-            if is_datetime64tz_dtype(dtype):
-                from pandas import DatetimeIndex
-
-                return DatetimeIndex(
-                    self.values, name=self.name, dtype=dtype, copy=copy
-                )
-            return Index(
-                self.values.astype(dtype, copy=copy), name=self.name, dtype=dtype
-            )
+            casted = self.values.astype(dtype, copy=copy)
         except (TypeError, ValueError):
-            msg = "Cannot cast {name} to dtype {dtype}"
-            raise TypeError(msg.format(name=type(self).__name__, dtype=dtype))
+            raise TypeError(f"Cannot cast {type(self).__name__} to dtype {dtype}")
+        return Index(casted, name=self.name, dtype=dtype)
 
     _index_shared_docs[
         "take"
@@ -787,13 +713,13 @@ def astype(self, dtype, copy=True):
         Parameters
         ----------
         indices : list
-            Indices to be taken
+            Indices to be taken.
         axis : int, optional
             The axis over which to select values, always 0.
         allow_fill : bool, default True
         fill_value : bool, default None
             If allow_fill=True and fill_value is not None, indices specified by
-            -1 is regarded as NA. If Index doesn't hold NA, raise ValueError
+            -1 is regarded as NA. If Index doesn't hold NA, raise ValueError.
 
         Returns
         -------
@@ -820,8 +746,10 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
             )
         else:
             if allow_fill and fill_value is not None:
-                msg = "Unable to fill values because {0} cannot contain NA"
-                raise ValueError(msg.format(self.__class__.__name__))
+                cls_name = type(self).__name__
+                raise ValueError(
+                    f"Unable to fill values because {cls_name} cannot contain NA"
+                )
             taken = self.values.take(indices)
         return self._shallow_copy(taken)
 
@@ -836,11 +764,10 @@ def _assert_take_fillable(
         # only fill if we are passing a non-None fill_value
         if allow_fill and fill_value is not None:
             if (indices < -1).any():
-                msg = (
+                raise ValueError(
                     "When allow_fill=True and fill_value is not None, "
                     "all indices must be >= -1"
                 )
-                raise ValueError(msg)
             taken = algos.take(
                 values, indices, allow_fill=allow_fill, fill_value=na_value
             )
@@ -896,36 +823,33 @@ def repeat(self, repeats, axis=None):
     # --------------------------------------------------------------------
     # Copying Methods
 
-    _index_shared_docs[
-        "copy"
-    ] = """
+    def copy(self, name=None, deep=False, dtype=None, names=None):
+        """
         Make a copy of this object.  Name and dtype sets those attributes on
         the new object.
 
         Parameters
         ----------
-        name : string, optional
-        deep : boolean, default False
-        dtype : numpy dtype or pandas type
+        name : Label
+        deep : bool, default False
+        dtype : numpy dtype or pandas type, optional
+        names : list-like, optional
+            Kept for compatibility with MultiIndex. Should not be used.
 
         Returns
         -------
-        copy : Index
+        Index
 
         Notes
         -----
         In most cases, there should be no functional difference from using
         ``deep``, but if ``deep`` is passed it will attempt to deepcopy.
         """
-
-    @Appender(_index_shared_docs["copy"])
-    def copy(self, name=None, deep=False, dtype=None, **kwargs):
         if deep:
             new_index = self._shallow_copy(self._data.copy())
         else:
             new_index = self._shallow_copy()
 
-        names = kwargs.get("names")
         names = self._validate_names(name=name, names=names, deep=deep)
         new_index = new_index.set_names(names)
 
@@ -943,33 +867,31 @@ def __deepcopy__(self, memo=None):
         memo, default None
             Standard signature. Unused
         """
-        if memo is None:
-            memo = {}
         return self.copy(deep=True)
 
     # --------------------------------------------------------------------
     # Rendering Methods
 
-    def __repr__(self):
+    def __repr__(self) -> str_t:
         """
         Return a string representation for this object.
         """
-        klass = self.__class__.__name__
+        klass_name = type(self).__name__
         data = self._format_data()
         attrs = self._format_attrs()
         space = self._format_space()
-
-        prepr = (",%s" % space).join("%s=%s" % (k, v) for k, v in attrs)
+        attrs_str = [f"{k}={v}" for k, v in attrs]
+        prepr = f",{space}".join(attrs_str)
 
         # no data provided, just attributes
         if data is None:
             data = ""
 
-        res = "%s(%s%s)" % (klass, data, prepr)
+        res = f"{klass_name}({data}{prepr})"
 
         return res
 
-    def _format_space(self):
+    def _format_space(self) -> str_t:
 
         # using space here controls if the attributes
         # are line separated or not (the default)
@@ -986,18 +908,19 @@ def _formatter_func(self):
         """
         return default_pprint
 
-    def _format_data(self, name=None):
+    def _format_data(self, name=None) -> str_t:
         """
         Return the formatted data as a unicode string.
         """
 
         # do we want to justify (only do so for non-objects)
-        is_justify = not (
-            self.inferred_type in ("string", "unicode")
-            or (
-                self.inferred_type == "categorical" and is_object_dtype(self.categories)
-            )
-        )
+        is_justify = True
+
+        if self.inferred_type == "string":
+            is_justify = False
+        elif self.inferred_type == "categorical":
+            if is_object_dtype(self.categories):  # type: ignore
+                is_justify = False
 
         return format_object_summary(
             self, self._formatter_func, is_justify=is_justify, name=name
@@ -1013,7 +936,7 @@ def _mpl_repr(self):
         # how to represent ourselves to matplotlib
         return self.values
 
-    def format(self, name=False, formatter=None, **kwargs):
+    def format(self, name: bool = False, formatter=None, **kwargs):
         """
         Render a string representation of the Index.
         """
@@ -1073,7 +996,7 @@ def to_native_types(self, slicer=None, **kwargs):
             2) quoting : bool or None
                 Whether or not there are quoted values in `self`
             3) date_format : str
-                The format used to represent date-like values
+                The format used to represent date-like values.
 
         Returns
         -------
@@ -1099,7 +1022,7 @@ def _format_native_types(self, na_rep="", quoting=None, **kwargs):
         values[mask] = na_rep
         return values
 
-    def _summary(self, name=None):
+    def _summary(self, name=None) -> str_t:
         """
         Return a summarized representation.
 
@@ -1119,26 +1042,13 @@ def _summary(self, name=None):
             tail = self[-1]
             if hasattr(tail, "format") and not isinstance(tail, str):
                 tail = tail.format()
-            index_summary = ", %s to %s" % (pprint_thing(head), pprint_thing(tail))
+            index_summary = f", {head} to {tail}"
         else:
             index_summary = ""
 
         if name is None:
             name = type(self).__name__
-        return "%s: %s entries%s" % (name, len(self), index_summary)
-
-    def summary(self, name=None):
-        """
-        Return a summarized representation.
-
-        .. deprecated:: 0.23.0
-        """
-        warnings.warn(
-            "'summary' is deprecated and will be removed in a future version.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._summary(name)
+        return f"{name}: {len(self)} entries{index_summary}"
 
     # --------------------------------------------------------------------
     # Conversion Methods
@@ -1165,20 +1075,22 @@ def to_flat_index(self):
 
     def to_series(self, index=None, name=None):
         """
-        Create a Series with both index and values equal to the index keys
-        useful with map for returning an indexer based on an index.
+        Create a Series with both index and values equal to the index keys.
+
+        Useful with map for returning an indexer based on an index.
 
         Parameters
         ----------
         index : Index, optional
-            index of resulting Series. If None, defaults to original index
-        name : string, optional
-            name of resulting Series. If None, defaults to name of original
-            index
+            Index of resulting Series. If None, defaults to original index.
+        name : str, optional
+            Dame of resulting Series. If None, defaults to name of original
+            index.
 
         Returns
         -------
-        Series : dtype will be based on the type of the Index values.
+        Series
+            The dtype will be based on the type of the Index values.
         """
 
         from pandas import Series
@@ -1190,7 +1102,7 @@ def to_series(self, index=None, name=None):
 
         return Series(self.values.copy(), index=index, name=name)
 
-    def to_frame(self, index=True, name=None):
+    def to_frame(self, index: bool = True, name=None):
         """
         Create a DataFrame with a column containing the Index.
 
@@ -1198,7 +1110,7 @@ def to_frame(self, index=True, name=None):
 
         Parameters
         ----------
-        index : boolean, default True
+        index : bool, default True
             Set the index of the returned DataFrame as the original Index.
 
         name : object, default None
@@ -1255,7 +1167,25 @@ def to_frame(self, index=True, name=None):
     # --------------------------------------------------------------------
     # Name-Centric Methods
 
-    def _validate_names(self, name=None, names=None, deep=False):
+    @property
+    def name(self):
+        """
+        Return Index or MultiIndex name.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if self._no_setting_name:
+            # Used in MultiIndex.levels to avoid silently ignoring name updates.
+            raise RuntimeError(
+                "Cannot set name on a level of a MultiIndex. Use "
+                "'MultiIndex.set_names' instead."
+            )
+        maybe_extract_name(value, None, type(self))
+        self._name = value
+
+    def _validate_names(self, name=None, names=None, deep: bool = False):
         """
         Handles the quirks of having a singular 'name' parameter for general
         Index and plural 'names' parameter for MultiIndex.
@@ -1297,20 +1227,18 @@ def _set_names(self, values, level=None):
         if not is_list_like(values):
             raise ValueError("Names must be a list-like")
         if len(values) != 1:
-            raise ValueError("Length of new names must be 1, got %d" % len(values))
+            raise ValueError(f"Length of new names must be 1, got {len(values)}")
 
         # GH 20527
         # All items in 'name' need to be hashable:
         for name in values:
             if not is_hashable(name):
-                raise TypeError(
-                    "{}.name must be a hashable type".format(self.__class__.__name__)
-                )
-        self.name = values[0]
+                raise TypeError(f"{type(self).__name__}.name must be a hashable type")
+        self._name = values[0]
 
     names = property(fset=_set_names, fget=_get_names)
 
-    def set_names(self, names, level=None, inplace=False):
+    def set_names(self, names, level=None, inplace: bool = False):
         """
         Set Index or MultiIndex name.
 
@@ -1371,8 +1299,7 @@ def set_names(self, names, level=None, inplace=False):
             raise ValueError("Level must be None for non-MultiIndex")
 
         if level is not None and not is_list_like(level) and is_list_like(names):
-            msg = "Names must be a string when a single level is provided."
-            raise TypeError(msg)
+            raise TypeError("Names must be a string when a single level is provided.")
 
         if not is_list_like(names) and level is None and self.nlevels > 1:
             raise TypeError("Must pass list-like as `names`.")
@@ -1401,7 +1328,7 @@ def rename(self, name, inplace=False):
         ----------
         name : label or list of labels
             Name(s) to set.
-        inplace : boolean, default False
+        inplace : bool, default False
             Modifies the object directly, instead of creating a new Index or
             MultiIndex.
 
@@ -1445,7 +1372,7 @@ def rename(self, name, inplace=False):
     # Level-Centric Methods
 
     @property
-    def nlevels(self):
+    def nlevels(self) -> int:
         """
         Number of levels.
         """
@@ -1468,21 +1395,19 @@ def _validate_index_level(self, level):
         if isinstance(level, int):
             if level < 0 and level != -1:
                 raise IndexError(
-                    "Too many levels: Index has only 1 level,"
-                    " %d is not a valid level number" % (level,)
+                    "Too many levels: Index has only 1 level, "
+                    f"{level} is not a valid level number"
                 )
             elif level > 0:
                 raise IndexError(
-                    "Too many levels: Index has only 1 level, not %d" % (level + 1)
+                    f"Too many levels: Index has only 1 level, not {level + 1}"
                 )
         elif level != self.name:
             raise KeyError(
-                "Requested level ({}) does not match index name ({})".format(
-                    level, self.name
-                )
+                f"Requested level ({level}) does not match index name ({self.name})"
             )
 
-    def _get_level_number(self, level):
+    def _get_level_number(self, level) -> int:
         self._validate_index_level(level)
         return 0
 
@@ -1494,7 +1419,7 @@ def sortlevel(self, level=None, ascending=True, sort_remaining=None):
 
         Parameters
         ----------
-        ascending : boolean, default True
+        ascending : bool, default True
             False to sort in descending order
 
         level, sort_remaining are compat parameters
@@ -1575,9 +1500,8 @@ def droplevel(self, level=0):
             return self
         if len(level) >= self.nlevels:
             raise ValueError(
-                "Cannot remove {} levels from an index with {} "
-                "levels: at least one level must be "
-                "left.".format(len(level), self.nlevels)
+                f"Cannot remove {len(level)} levels from an index with {self.nlevels} "
+                "levels: at least one level must be left."
             )
         # The two checks above guarantee that here self is a MultiIndex
 
@@ -1598,10 +1522,10 @@ def droplevel(self, level=0):
             if mask.any():
                 result = result.putmask(mask, np.nan)
 
-            result.name = new_names[0]
+            result._name = new_names[0]
             return result
         else:
-            from .multi import MultiIndex
+            from pandas.core.indexes.multi import MultiIndex
 
             return MultiIndex(
                 levels=new_levels,
@@ -1610,9 +1534,8 @@ def droplevel(self, level=0):
                 verify_integrity=False,
             )
 
-    _index_shared_docs[
-        "_get_grouper_for_level"
-    ] = """
+    def _get_grouper_for_level(self, mapper, level=None):
+        """
         Get index grouper corresponding to an index level
 
         Parameters
@@ -1631,9 +1554,6 @@ def droplevel(self, level=0):
         uniques : Index or None
             Index of unique values for level.
         """
-
-    @Appender(_index_shared_docs["_get_grouper_for_level"])
-    def _get_grouper_for_level(self, mapper, level=None):
         assert level is None or level == 0
         if mapper is None:
             grouper = self
@@ -1646,14 +1566,14 @@ def _get_grouper_for_level(self, mapper, level=None):
     # Introspection Methods
 
     @property
-    def is_monotonic(self):
+    def is_monotonic(self) -> bool:
         """
         Alias for is_monotonic_increasing.
         """
         return self.is_monotonic_increasing
 
     @property
-    def is_monotonic_increasing(self):
+    def is_monotonic_increasing(self) -> bool:
         """
         Return if the index is monotonic increasing (only equal or
         increasing) values.
@@ -1670,7 +1590,7 @@ def is_monotonic_increasing(self):
         return self._engine.is_monotonic_increasing
 
     @property
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         """
         Return if the index is monotonic decreasing (only equal or
         decreasing) values.
@@ -1687,7 +1607,7 @@ def is_monotonic_decreasing(self):
         return self._engine.is_monotonic_decreasing
 
     @property
-    def _is_strictly_monotonic_increasing(self):
+    def _is_strictly_monotonic_increasing(self) -> bool:
         """
         Return if the index is strictly monotonic increasing
         (only increasing) values.
@@ -1704,7 +1624,7 @@ def _is_strictly_monotonic_increasing(self):
         return self.is_unique and self.is_monotonic_increasing
 
     @property
-    def _is_strictly_monotonic_decreasing(self):
+    def _is_strictly_monotonic_decreasing(self) -> bool:
         """
         Return if the index is strictly monotonic decreasing
         (only decreasing) values.
@@ -1720,47 +1640,260 @@ def _is_strictly_monotonic_decreasing(self):
         """
         return self.is_unique and self.is_monotonic_decreasing
 
-    def is_lexsorted_for_tuple(self, tup):
-        return True
-
     @cache_readonly
-    def is_unique(self):
+    def is_unique(self) -> bool:
         """
         Return if the index has unique values.
         """
         return self._engine.is_unique
 
     @property
-    def has_duplicates(self):
+    def has_duplicates(self) -> bool:
+        """
+        Check if the Index has duplicate values.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index has duplicate values.
+
+        Examples
+        --------
+        >>> idx = pd.Index([1, 5, 7, 7])
+        >>> idx.has_duplicates
+        True
+
+        >>> idx = pd.Index([1, 5, 7])
+        >>> idx.has_duplicates
+        False
+
+        >>> idx = pd.Index(["Watermelon", "Orange", "Apple",
+        ...                 "Watermelon"]).astype("category")
+        >>> idx.has_duplicates
+        True
+
+        >>> idx = pd.Index(["Orange", "Apple",
+        ...                 "Watermelon"]).astype("category")
+        >>> idx.has_duplicates
+        False
+        """
         return not self.is_unique
 
-    def is_boolean(self):
+    def is_boolean(self) -> bool:
+        """
+        Check if the Index only consists of booleans.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index only consists of booleans.
+
+        See Also
+        --------
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index([True, False, True])
+        >>> idx.is_boolean()
+        True
+
+        >>> idx = pd.Index(["True", "False", "True"])
+        >>> idx.is_boolean()
+        False
+
+        >>> idx = pd.Index([True, False, "True"])
+        >>> idx.is_boolean()
+        False
+        """
         return self.inferred_type in ["boolean"]
 
-    def is_integer(self):
+    def is_integer(self) -> bool:
+        """
+        Check if the Index only consists of integers.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index only consists of integers.
+
+        See Also
+        --------
+        is_boolean : Check if the Index only consists of booleans.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index([1, 2, 3, 4])
+        >>> idx.is_integer()
+        True
+
+        >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
+        >>> idx.is_integer()
+        False
+
+        >>> idx = pd.Index(["Apple", "Mango", "Watermelon"])
+        >>> idx.is_integer()
+        False
+        """
         return self.inferred_type in ["integer"]
 
-    def is_floating(self):
+    def is_floating(self) -> bool:
+        """
+        Check if the Index is a floating type.
+
+        The Index may consist of only floats, NaNs, or a mix of floats,
+        integers, or NaNs.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index only consists of only consists of floats, NaNs, or
+            a mix of floats, integers, or NaNs.
+
+        See Also
+        --------
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
+        >>> idx.is_floating()
+        True
+
+        >>> idx = pd.Index([1.0, 2.0, np.nan, 4.0])
+        >>> idx.is_floating()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4, np.nan])
+        >>> idx.is_floating()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4])
+        >>> idx.is_floating()
+        False
+        """
         return self.inferred_type in ["floating", "mixed-integer-float", "integer-na"]
 
-    def is_numeric(self):
+    def is_numeric(self) -> bool:
+        """
+        Check if the Index only consists of numeric data.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index only consists of numeric data.
+
+        See Also
+        --------
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
+        >>> idx.is_numeric()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4.0])
+        >>> idx.is_numeric()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4])
+        >>> idx.is_numeric()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4.0, np.nan])
+        >>> idx.is_numeric()
+        True
+
+        >>> idx = pd.Index([1, 2, 3, 4.0, np.nan, "Apple"])
+        >>> idx.is_numeric()
+        False
+        """
         return self.inferred_type in ["integer", "floating"]
 
-    def is_object(self):
+    def is_object(self) -> bool:
+        """
+        Check if the Index is of the object dtype.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index is of the object dtype.
+
+        See Also
+        --------
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index(["Apple", "Mango", "Watermelon"])
+        >>> idx.is_object()
+        True
+
+        >>> idx = pd.Index(["Apple", "Mango", 2.0])
+        >>> idx.is_object()
+        True
+
+        >>> idx = pd.Index(["Watermelon", "Orange", "Apple",
+        ...                 "Watermelon"]).astype("category")
+        >>> idx.object()
+        False
+
+        >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
+        >>> idx.is_object()
+        False
+        """
         return is_object_dtype(self.dtype)
 
-    def is_categorical(self):
+    def is_categorical(self) -> bool:
         """
         Check if the Index holds categorical data.
 
         Returns
         -------
-        boolean
+        bool
             True if the Index is categorical.
 
         See Also
         --------
         CategoricalIndex : Index for categorical data.
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_interval : Check if the Index holds Interval objects.
+        is_mixed : Check if the Index holds data with mixed data types.
 
         Examples
         --------
@@ -1785,27 +1918,88 @@ def is_categorical(self):
         """
         return self.inferred_type in ["categorical"]
 
-    def is_interval(self):
+    def is_interval(self) -> bool:
+        """
+        Check if the Index holds Interval objects.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index holds Interval objects.
+
+        See Also
+        --------
+        IntervalIndex : Index for Interval objects.
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_mixed : Check if the Index holds data with mixed data types.
+
+        Examples
+        --------
+        >>> idx = pd.Index([pd.Interval(left=0, right=5),
+        ...                 pd.Interval(left=5, right=10)])
+        >>> idx.is_interval()
+        True
+
+        >>> idx = pd.Index([1, 3, 5, 7])
+        >>> idx.is_interval()
+        False
+        """
         return self.inferred_type in ["interval"]
 
-    def is_mixed(self):
+    def is_mixed(self) -> bool:
+        """
+        Check if the Index holds data with mixed data types.
+
+        Returns
+        -------
+        bool
+            Whether or not the Index holds data with mixed data types.
+
+        See Also
+        --------
+        is_boolean : Check if the Index only consists of booleans.
+        is_integer : Check if the Index only consists of integers.
+        is_floating : Check if the Index is a floating type.
+        is_numeric : Check if the Index only consists of numeric data.
+        is_object : Check if the Index is of the object dtype.
+        is_categorical : Check if the Index holds categorical data.
+        is_interval : Check if the Index holds Interval objects.
+
+        Examples
+        --------
+        >>> idx = pd.Index(['a', np.nan, 'b'])
+        >>> idx.is_mixed()
+        True
+
+        >>> idx = pd.Index([1.0, 2.0, 3.0, 5.0])
+        >>> idx.is_mixed()
+        False
+        """
         return self.inferred_type in ["mixed"]
 
-    def holds_integer(self):
+    def holds_integer(self) -> bool:
         """
         Whether the type is an integer type.
         """
         return self.inferred_type in ["integer", "mixed-integer"]
 
     @cache_readonly
-    def inferred_type(self):
+    def inferred_type(self) -> str_t:
         """
         Return a string of the type inferred from the values.
         """
         return lib.infer_dtype(self, skipna=False)
 
     @cache_readonly
-    def is_all_dates(self):
+    def is_all_dates(self) -> bool:
+        """
+        Whether or not the index values only consist of dates.
+        """
         return is_datetime_array(ensure_object(self.values))
 
     # --------------------------------------------------------------------
@@ -1814,36 +2008,7 @@ def is_all_dates(self):
     def __reduce__(self):
         d = dict(data=self._data)
         d.update(self._get_attributes_dict())
-        return _new_Index, (self.__class__, d), None
-
-    def __setstate__(self, state):
-        """
-        Necessary for making this object picklable.
-        """
-
-        if isinstance(state, dict):
-            self._data = state.pop("data")
-            for k, v in state.items():
-                setattr(self, k, v)
-
-        elif isinstance(state, tuple):
-
-            if len(state) == 2:
-                nd_state, own_state = state
-                data = np.empty(nd_state[1], dtype=nd_state[2])
-                np.ndarray.__setstate__(data, nd_state)
-                self.name = own_state[0]
-
-            else:  # pragma: no cover
-                data = np.empty(state)
-                np.ndarray.__setstate__(data, state)
-
-            self._data = data
-            self._reset_identity()
-        else:
-            raise Exception("invalid pickle state")
-
-    _unpickle_compat = __setstate__
+        return _new_Index, (type(self), d), None
 
     # --------------------------------------------------------------------
     # Null Handling Methods
@@ -1867,13 +2032,12 @@ def _isnan(self):
     @cache_readonly
     def _nan_idxs(self):
         if self._can_hold_na:
-            w, = self._isnan.nonzero()
-            return w
+            return self._isnan.nonzero()[0]
         else:
             return np.array([], dtype=np.int64)
 
     @cache_readonly
-    def hasnans(self):
+    def hasnans(self) -> bool:
         """
         Return if I have any nans; enables various perf speedups.
         """
@@ -1893,8 +2057,6 @@ def isna(self):
         empty strings `''` or :attr:`numpy.inf` are not considered NA values
         (unless you set ``pandas.options.mode.use_inf_as_na = True``).
 
-        .. versionadded:: 0.20.0
-
         Returns
         -------
         numpy.ndarray
@@ -1952,8 +2114,6 @@ def notna(self):
         NA values, such as None or :attr:`numpy.NaN`, get mapped to ``False``
         values.
 
-        .. versionadded:: 0.20.0
-
         Returns
         -------
         numpy.ndarray
@@ -1989,9 +2149,8 @@ def notna(self):
 
     notnull = notna
 
-    _index_shared_docs[
-        "fillna"
-    ] = """
+    def fillna(self, value=None, downcast=None):
+        """
         Fill NA/NaN values with the specified value.
 
         Parameters
@@ -2002,15 +2161,12 @@ def notna(self):
         downcast : dict, default is None
             a dict of item->dtype of what to downcast if possible,
             or the string 'infer' which will try to downcast to an appropriate
-            equal type (e.g. float64 to int64 if possible)
+            equal type (e.g. float64 to int64 if possible).
 
         Returns
         -------
         filled : Index
         """
-
-    @Appender(_index_shared_docs["fillna"])
-    def fillna(self, value=None, downcast=None):
         self._assert_can_do_op(value)
         if self.hasnans:
             result = self.putmask(self._isnan, value)
@@ -2020,14 +2176,13 @@ def fillna(self, value=None, downcast=None):
                 return Index(result, name=self.name)
         return self._shallow_copy()
 
-    _index_shared_docs[
-        "dropna"
-    ] = """
+    def dropna(self, how="any"):
+        """
         Return Index without NA/NaN values.
 
         Parameters
         ----------
-        how :  {'any', 'all'}, default 'any'
+        how : {'any', 'all'}, default 'any'
             If the Index is a MultiIndex, drop the value when any or all levels
             are NaN.
 
@@ -2035,29 +2190,25 @@ def fillna(self, value=None, downcast=None):
         -------
         valid : Index
         """
-
-    @Appender(_index_shared_docs["dropna"])
-    def dropna(self, how="any"):
         if how not in ("any", "all"):
-            raise ValueError("invalid how option: {0}".format(how))
+            raise ValueError(f"invalid how option: {how}")
 
         if self.hasnans:
-            return self._shallow_copy(self.values[~self._isnan])
+            return self._shallow_copy(self._values[~self._isnan])
         return self._shallow_copy()
 
     # --------------------------------------------------------------------
     # Uniqueness Methods
 
-    _index_shared_docs[
-        "index_unique"
-    ] = """
+    def unique(self, level=None):
+        """
         Return unique values in the index. Uniques are returned in order
         of appearance, this does NOT sort.
 
         Parameters
         ----------
         level : int or str, optional, default None
-            Only return values from specified level (for MultiIndex)
+            Only return values from specified level (for MultiIndex).
 
             .. versionadded:: 0.23.0
 
@@ -2070,9 +2221,6 @@ def dropna(self, how="any"):
         unique
         Series.unique
         """
-
-    @Appender(_index_shared_docs["index_unique"] % _index_doc_kwargs)
-    def unique(self, level=None):
         if level is not None:
             self._validate_index_level(level)
         result = super().unique()
@@ -2182,75 +2330,13 @@ def duplicated(self, keep="first"):
         """
         return super().duplicated(keep=keep)
 
-    def get_duplicates(self):
-        """
-        Extract duplicated index elements.
-
-        .. deprecated:: 0.23.0
-            Use idx[idx.duplicated()].unique() instead
-
-        Returns a sorted list of index elements which appear more than once in
-        the index.
-
-        Returns
-        -------
-        array-like
-            List of duplicated indexes.
-
-        See Also
-        --------
-        Index.duplicated : Return boolean array denoting duplicates.
-        Index.drop_duplicates : Return Index with duplicates removed.
-
-        Examples
-        --------
-
-        Works on different Index of types.
-
-        >>> pd.Index([1, 2, 2, 3, 3, 3, 4]).get_duplicates()  # doctest: +SKIP
-        [2, 3]
-
-        Note that for a DatetimeIndex, it does not return a list but a new
-        DatetimeIndex:
-
-        >>> dates = pd.to_datetime(['2018-01-01', '2018-01-02', '2018-01-03',
-        ...                         '2018-01-03', '2018-01-04', '2018-01-04'],
-        ...                        format='%Y-%m-%d')
-        >>> pd.Index(dates).get_duplicates()  # doctest: +SKIP
-        DatetimeIndex(['2018-01-03', '2018-01-04'],
-                      dtype='datetime64[ns]', freq=None)
-
-        Sorts duplicated elements even when indexes are unordered.
-
-        >>> pd.Index([1, 2, 3, 2, 3, 4, 3]).get_duplicates()  # doctest: +SKIP
-        [2, 3]
-
-        Return empty array-like structure when all elements are unique.
-
-        >>> pd.Index([1, 2, 3, 4]).get_duplicates()  # doctest: +SKIP
-        []
-        >>> dates = pd.to_datetime(['2018-01-01', '2018-01-02', '2018-01-03'],
-        ...                        format='%Y-%m-%d')
-        >>> pd.Index(dates).get_duplicates()  # doctest: +SKIP
-        DatetimeIndex([], dtype='datetime64[ns]', freq=None)
-        """
-        warnings.warn(
-            "'get_duplicates' is deprecated and will be removed in "
-            "a future release. You can use "
-            "idx[idx.duplicated()].unique() instead",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        return self[self.duplicated()].unique()
-
-    def _get_unique_index(self, dropna=False):
+    def _get_unique_index(self, dropna: bool = False):
         """
         Returns an index containing unique values.
 
         Parameters
         ----------
-        dropna : bool
+        dropna : bool, default False
             If True, NaN values are dropped.
 
         Returns
@@ -2264,6 +2350,9 @@ def _get_unique_index(self, dropna=False):
 
         if not self.is_unique:
             values = self.unique()
+            if not isinstance(self, ABCMultiIndex):
+                # extract an array to pass to _shallow_copy
+                values = values._data
 
         if dropna:
             try:
@@ -2313,10 +2402,8 @@ def __xor__(self, other):
 
     def __nonzero__(self):
         raise ValueError(
-            "The truth value of a {0} is ambiguous. "
-            "Use a.empty, a.bool(), a.item(), a.any() or a.all().".format(
-                self.__class__.__name__
-            )
+            f"The truth value of a {type(self).__name__} is ambiguous. "
+            "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
         )
 
     __bool__ = __nonzero__
@@ -2359,7 +2446,7 @@ def _union_incompatible_dtypes(self, other, sort):
         other = Index(other).astype(object, copy=False)
         return Index.union(this, other, sort=sort).astype(object, copy=False)
 
-    def _is_compatible_with_other(self, other):
+    def _is_compatible_with_other(self, other) -> bool:
         """
         Check whether this and the other dtype are compatible with each other.
         Meaning a union can be formed between them without needing to be cast
@@ -2379,7 +2466,7 @@ def _validate_sort_keyword(self, sort):
         if sort not in [None, False]:
             raise ValueError(
                 "The 'sort' keyword only takes the values of "
-                "None or False; {0} was passed.".format(sort)
+                f"None or False; {sort} was passed."
             )
 
     def union(self, other, sort=None):
@@ -2469,11 +2556,11 @@ def _union(self, other, sort):
             return other._get_reconciled_name_object(self)
 
         # TODO(EA): setops-refactor, clean all this up
-        if is_period_dtype(self) or is_datetime64tz_dtype(self):
+        if is_datetime64tz_dtype(self):
             lvals = self._ndarray_values
         else:
             lvals = self._values
-        if is_period_dtype(other) or is_datetime64tz_dtype(other):
+        if is_datetime64tz_dtype(other):
             rvals = other._ndarray_values
         else:
             rvals = other._values
@@ -2488,9 +2575,14 @@ def _union(self, other, sort):
                 # worth making this faster? a very unusual case
                 value_set = set(lvals)
                 result.extend([x for x in rvals if x not in value_set])
+                result = Index(result)._values  # do type inference here
         else:
-            indexer = self.get_indexer(other)
-            indexer, = (indexer == -1).nonzero()
+            # find indexes of things in "other" that are not in "self"
+            if self.is_unique:
+                indexer = self.get_indexer(other)
+                indexer = (indexer == -1).nonzero()[0]
+            else:
+                indexer = algos.unique1d(self.get_indexer_non_unique(other)[1])
 
             if len(indexer) > 0:
                 other_diff = algos.take_nd(rvals, indexer, allow_fill=False)
@@ -2501,11 +2593,10 @@ def _union(self, other, sort):
 
             if sort is None:
                 try:
-                    result = sorting.safe_sort(result)
-                except TypeError as e:
+                    result = algos.safe_sort(result)
+                except TypeError as err:
                     warnings.warn(
-                        "{}, sort order is undefined for "
-                        "incomparable objects".format(e),
+                        f"{err}, sort order is undefined for incomparable objects",
                         RuntimeWarning,
                         stacklevel=3,
                     )
@@ -2514,11 +2605,12 @@ def _union(self, other, sort):
         return self._wrap_setop_result(other, result)
 
     def _wrap_setop_result(self, other, result):
-        return self._constructor(result, name=get_op_result_name(self, other))
+        name = get_op_result_name(self, other)
+        return self._shallow_copy(result, name=name)
 
-    _index_shared_docs[
-        "intersection"
-    ] = """
+    # TODO: standardize return type of non-union setops type(self vs other)
+    def intersection(self, other, sort=False):
+        """
         Form the intersection of two Index objects.
 
         This returns a new Index with elements common to the index and `other`.
@@ -2552,10 +2644,6 @@ def _wrap_setop_result(self, other, result):
         >>> idx1.intersection(idx2)
         Int64Index([3, 4], dtype='int64')
         """
-
-    # TODO: standardize return type of non-union setops type(self vs other)
-    @Appender(_index_shared_docs["intersection"])
-    def intersection(self, other, sort=False):
         self._validate_sort_keyword(sort)
         self._assert_can_do_setop(other)
         other = ensure_index(other)
@@ -2569,43 +2657,34 @@ def intersection(self, other, sort=False):
             return this.intersection(other, sort=sort)
 
         # TODO(EA): setops-refactor, clean all this up
-        if is_period_dtype(self):
-            lvals = self._ndarray_values
-        else:
-            lvals = self._values
-        if is_period_dtype(other):
-            rvals = other._ndarray_values
-        else:
-            rvals = other._values
+        lvals = self._values
+        rvals = other._values
 
         if self.is_monotonic and other.is_monotonic:
             try:
                 result = self._inner_indexer(lvals, rvals)[0]
-                return self._wrap_setop_result(other, result)
             except TypeError:
                 pass
+            else:
+                return self._wrap_setop_result(other, result)
 
         try:
             indexer = Index(rvals).get_indexer(lvals)
             indexer = indexer.take((indexer != -1).nonzero()[0])
-        except Exception:
-            # duplicates
+        except (InvalidIndexError, IncompatibleFrequency):
+            # InvalidIndexError raised by get_indexer if non-unique
+            # IncompatibleFrequency raised by PeriodIndex.get_indexer
             indexer = algos.unique1d(Index(rvals).get_indexer_non_unique(lvals)[0])
             indexer = indexer[indexer != -1]
 
         taken = other.take(indexer)
+        res_name = get_op_result_name(self, other)
 
         if sort is None:
-            taken = sorting.safe_sort(taken.values)
-            if self.name != other.name:
-                name = None
-            else:
-                name = self.name
-            return self._shallow_copy(taken, name=name)
-
-        if self.name != other.name:
-            taken.name = None
+            taken = algos.safe_sort(taken.values)
+            return self._shallow_copy(taken, name=res_name)
 
+        taken.name = res_name
         return taken
 
     def difference(self, other, sort=None):
@@ -2666,11 +2745,11 @@ def difference(self, other, sort=None):
         the_diff = this.values.take(label_diff)
         if sort is None:
             try:
-                the_diff = sorting.safe_sort(the_diff)
+                the_diff = algos.safe_sort(the_diff)
             except TypeError:
                 pass
 
-        return this._shallow_copy(the_diff, name=result_name, freq=None)
+        return this._shallow_copy(the_diff, name=result_name)
 
     def symmetric_difference(self, other, result_name=None, sort=None):
         """
@@ -2734,16 +2813,16 @@ def symmetric_difference(self, other, result_name=None, sort=None):
         left_indexer = np.setdiff1d(
             np.arange(this.size), common_indexer, assume_unique=True
         )
-        left_diff = this.values.take(left_indexer)
+        left_diff = this._values.take(left_indexer)
 
         # {other} minus {this}
         right_indexer = (indexer == -1).nonzero()[0]
-        right_diff = other.values.take(right_indexer)
+        right_diff = other._values.take(right_indexer)
 
         the_diff = concat_compat([left_diff, right_diff])
         if sort is None:
             try:
-                the_diff = sorting.safe_sort(the_diff)
+                the_diff = algos.safe_sort(the_diff)
             except TypeError:
                 pass
 
@@ -2769,9 +2848,8 @@ def _convert_can_do_setop(self, other):
     # --------------------------------------------------------------------
     # Indexing Methods
 
-    _index_shared_docs[
-        "get_loc"
-    ] = """
+    def get_loc(self, key, method=None, tolerance=None):
+        """
         Get integer location, slice or boolean mask for requested label.
 
         Parameters
@@ -2808,19 +2886,21 @@ def _convert_can_do_setop(self, other):
         >>> non_monotonic_index.get_loc('b')
         array([False,  True, False,  True], dtype=bool)
         """
-
-    @Appender(_index_shared_docs["get_loc"])
-    def get_loc(self, key, method=None, tolerance=None):
         if method is None:
             if tolerance is not None:
                 raise ValueError(
                     "tolerance argument only valid if using pad, "
                     "backfill or nearest lookups"
                 )
+            casted_key = self._maybe_cast_indexer(key)
             try:
-                return self._engine.get_loc(key)
+                return self._engine.get_loc(casted_key)
             except KeyError:
-                return self._engine.get_loc(self._maybe_cast_indexer(key))
+                raise KeyError(key)
+
+        if tolerance is not None:
+            tolerance = self._convert_tolerance(tolerance, np.asarray(key))
+
         indexer = self.get_indexer([key], method=method, tolerance=tolerance)
         if indexer.ndim > 1 or indexer.size > 1:
             raise TypeError("get_loc requires scalar valued input")
@@ -2879,7 +2959,9 @@ def get_loc(self, key, method=None, tolerance=None):
         """
 
     @Appender(_index_shared_docs["get_indexer"] % _index_doc_kwargs)
-    def get_indexer(self, target, method=None, limit=None, tolerance=None):
+    def get_indexer(
+        self, target, method=None, limit=None, tolerance=None
+    ) -> np.ndarray:
         method = missing.clean_reindex_fill_method(method)
         target = ensure_index(target)
         if tolerance is not None:
@@ -2936,14 +3018,16 @@ def _convert_tolerance(self, tolerance, target):
             raise ValueError("list-like tolerance size must match target index size")
         return tolerance
 
-    def _get_fill_indexer(self, target, method, limit=None, tolerance=None):
+    def _get_fill_indexer(
+        self, target: "Index", method: str_t, limit=None, tolerance=None
+    ) -> np.ndarray:
         if self.is_monotonic_increasing and target.is_monotonic_increasing:
-            method = (
+            engine_method = (
                 self._engine.get_pad_indexer
                 if method == "pad"
                 else self._engine.get_backfill_indexer
             )
-            indexer = method(target._ndarray_values, limit)
+            indexer = engine_method(target._ndarray_values, limit)
         else:
             indexer = self._get_fill_indexer_searchsorted(target, method, limit)
         if tolerance is not None:
@@ -2952,15 +3036,17 @@ def _get_fill_indexer(self, target, method, limit=None, tolerance=None):
             )
         return indexer
 
-    def _get_fill_indexer_searchsorted(self, target, method, limit=None):
+    def _get_fill_indexer_searchsorted(
+        self, target: "Index", method: str_t, limit=None
+    ) -> np.ndarray:
         """
         Fallback pad/backfill get_indexer that works for monotonic decreasing
         indexes and non-monotonic targets.
         """
         if limit is not None:
             raise ValueError(
-                "limit argument for %r method only well-defined "
-                "if index and target are monotonic" % method
+                f"limit argument for {repr(method)} method only well-defined "
+                "if index and target are monotonic"
             )
 
         side = "left" if method == "pad" else "right"
@@ -2983,7 +3069,7 @@ def _get_fill_indexer_searchsorted(self, target, method, limit=None):
             indexer[indexer == len(self)] = -1
         return indexer
 
-    def _get_nearest_indexer(self, target, limit, tolerance):
+    def _get_nearest_indexer(self, target: "Index", limit, tolerance) -> np.ndarray:
         """
         Get the indexer for the nearest index labels; requires an index with
         values that can be subtracted from each other (e.g., not strings or
@@ -2992,9 +3078,8 @@ def _get_nearest_indexer(self, target, limit, tolerance):
         left_indexer = self.get_indexer(target, "pad", limit=limit)
         right_indexer = self.get_indexer(target, "backfill", limit=limit)
 
-        target = np.asarray(target)
-        left_distances = abs(self.values[left_indexer] - target)
-        right_distances = abs(self.values[right_indexer] - target)
+        left_distances = np.abs(self[left_indexer] - target)
+        right_distances = np.abs(self[right_indexer] - target)
 
         op = operator.lt if self.is_monotonic_increasing else operator.le
         indexer = np.where(
@@ -3006,7 +3091,9 @@ def _get_nearest_indexer(self, target, limit, tolerance):
             indexer = self._filter_indexer_tolerance(target, indexer, tolerance)
         return indexer
 
-    def _filter_indexer_tolerance(self, target, indexer, tolerance):
+    def _filter_indexer_tolerance(
+        self, target: "Index", indexer: np.ndarray, tolerance
+    ) -> np.ndarray:
         distance = abs(self.values[indexer] - target)
         indexer = np.where(distance <= tolerance, indexer, -1)
         return indexer
@@ -3014,36 +3101,29 @@ def _filter_indexer_tolerance(self, target, indexer, tolerance):
     # --------------------------------------------------------------------
     # Indexer Conversion Methods
 
-    _index_shared_docs[
-        "_convert_scalar_indexer"
-    ] = """
+    def _convert_scalar_indexer(self, key, kind: str_t):
+        """
         Convert a scalar indexer.
 
         Parameters
         ----------
         key : label of the slice bound
-        kind : {'ix', 'loc', 'getitem', 'iloc'} or None
-    """
-
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
-
-        if kind == "iloc":
-            return self._validate_indexer("positional", key, kind)
+        kind : {'loc', 'getitem'}
+        """
+        assert kind in ["loc", "getitem"]
 
         if len(self) and not isinstance(self, ABCMultiIndex):
 
             # we can raise here if we are definitive that this
-            # is positional indexing (eg. .ix on with a float)
+            # is positional indexing (eg. .loc on with a float)
             # or label indexing if we are using a type able
             # to be represented in the index
 
-            if kind in ["getitem", "ix"] and is_float(key):
+            if kind == "getitem" and is_float(key):
                 if not self.is_floating():
-                    return self._invalid_indexer("label", key)
+                    self._invalid_indexer("label", key)
 
-            elif kind in ["loc"] and is_float(key):
+            elif kind == "loc" and is_float(key):
 
                 # we want to raise KeyError on string/mixed here
                 # technically we *could* raise a TypeError
@@ -3053,20 +3133,27 @@ def _convert_scalar_indexer(self, key, kind=None):
                     "mixed-integer-float",
                     "integer-na",
                     "string",
-                    "unicode",
                     "mixed",
                 ]:
-                    return self._invalid_indexer("label", key)
+                    self._invalid_indexer("label", key)
 
-            elif kind in ["loc"] and is_integer(key):
+            elif kind == "loc" and is_integer(key):
                 if not self.holds_integer():
-                    return self._invalid_indexer("label", key)
+                    self._invalid_indexer("label", key)
 
         return key
 
-    _index_shared_docs[
-        "_convert_slice_indexer"
-    ] = """
+    def _validate_positional_slice(self, key: slice):
+        """
+        For positional indexing, a slice must have either int or None
+        for each of start, stop, and step.
+        """
+        self._validate_indexer("positional", key.start, "iloc")
+        self._validate_indexer("positional", key.stop, "iloc")
+        self._validate_indexer("positional", key.step, "iloc")
+
+    def _convert_slice_indexer(self, key: slice, kind: str_t):
+        """
         Convert a slice indexer.
 
         By definition, these are labels unless 'iloc' is passed in.
@@ -3075,20 +3162,9 @@ def _convert_scalar_indexer(self, key, kind=None):
         Parameters
         ----------
         key : label of the slice bound
-        kind : {'ix', 'loc', 'getitem', 'iloc'} or None
-    """
-
-    @Appender(_index_shared_docs["_convert_slice_indexer"])
-    def _convert_slice_indexer(self, key: slice, kind=None):
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
-
-        # validate iloc
-        if kind == "iloc":
-            return slice(
-                self._validate_indexer("slice", key.start, kind),
-                self._validate_indexer("slice", key.stop, kind),
-                self._validate_indexer("slice", key.step, kind),
-            )
+        kind : {'loc', 'getitem'}
+        """
+        assert kind in ["loc", "getitem"], kind
 
         # potentially cast the bounds to integers
         start, stop, step = key.start, key.stop, key.step
@@ -3099,7 +3175,9 @@ def is_int(v):
 
         is_null_slicer = start is None and stop is None
         is_index_slice = is_int(start) and is_int(stop)
-        is_positional = is_index_slice and not self.is_integer()
+        is_positional = is_index_slice and not (
+            self.is_integer() or self.is_categorical()
+        )
 
         if kind == "getitem":
             """
@@ -3107,46 +3185,35 @@ def is_int(v):
             integers
             """
             if self.is_integer() or is_index_slice:
-                return slice(
-                    self._validate_indexer("slice", key.start, kind),
-                    self._validate_indexer("slice", key.stop, kind),
-                    self._validate_indexer("slice", key.step, kind),
-                )
+                self._validate_indexer("slice", key.start, "getitem")
+                self._validate_indexer("slice", key.stop, "getitem")
+                self._validate_indexer("slice", key.step, "getitem")
+                return key
 
         # convert the slice to an indexer here
 
         # if we are mixed and have integers
-        try:
-            if is_positional and self.is_mixed():
+        if is_positional and self.is_mixed():
+            try:
                 # Validate start & stop
                 if start is not None:
                     self.get_loc(start)
                 if stop is not None:
                     self.get_loc(stop)
                 is_positional = False
-        except KeyError:
-            if self.inferred_type in ["mixed-integer-float", "integer-na"]:
-                raise
+            except KeyError:
+                pass
 
         if is_null_slicer:
             indexer = key
         elif is_positional:
             indexer = key
         else:
-            try:
-                indexer = self.slice_indexer(start, stop, step, kind=kind)
-            except Exception:
-                if is_index_slice:
-                    if self.is_integer():
-                        raise
-                    else:
-                        indexer = key
-                else:
-                    raise
+            indexer = self.slice_indexer(start, stop, step, kind=kind)
 
         return indexer
 
-    def _convert_listlike_indexer(self, keyarr, kind=None):
+    def _convert_listlike_indexer(self, keyarr):
         """
         Parameters
         ----------
@@ -3165,12 +3232,11 @@ def _convert_listlike_indexer(self, keyarr, kind=None):
         else:
             keyarr = self._convert_arr_indexer(keyarr)
 
-        indexer = self._convert_list_indexer(keyarr, kind=kind)
+        indexer = self._convert_list_indexer(keyarr)
         return indexer, keyarr
 
-    _index_shared_docs[
-        "_convert_arr_indexer"
-    ] = """
+    def _convert_arr_indexer(self, keyarr):
+        """
         Convert an array-like indexer to the appropriate dtype.
 
         Parameters
@@ -3181,16 +3247,12 @@ def _convert_listlike_indexer(self, keyarr, kind=None):
         Returns
         -------
         converted_keyarr : array-like
-    """
-
-    @Appender(_index_shared_docs["_convert_arr_indexer"])
-    def _convert_arr_indexer(self, keyarr):
+        """
         keyarr = com.asarray_tuplesafe(keyarr)
         return keyarr
 
-    _index_shared_docs[
-        "_convert_index_indexer"
-    ] = """
+    def _convert_index_indexer(self, keyarr):
+        """
         Convert an Index indexer to the appropriate dtype.
 
         Parameters
@@ -3201,65 +3263,32 @@ def _convert_arr_indexer(self, keyarr):
         Returns
         -------
         converted_keyarr : Index (or sub-class)
-    """
-
-    @Appender(_index_shared_docs["_convert_index_indexer"])
-    def _convert_index_indexer(self, keyarr):
+        """
         return keyarr
 
-    _index_shared_docs[
-        "_convert_list_indexer"
-    ] = """
+    def _convert_list_indexer(self, keyarr):
+        """
         Convert a list-like indexer to the appropriate dtype.
 
         Parameters
         ----------
         keyarr : Index (or sub-class)
             Indexer to convert.
-        kind : iloc, ix, loc, optional
+        kind : iloc, loc, optional
 
         Returns
         -------
         positional indexer or None
-    """
-
-    @Appender(_index_shared_docs["_convert_list_indexer"])
-    def _convert_list_indexer(self, keyarr, kind=None):
-        if (
-            kind in [None, "iloc", "ix"]
-            and is_integer_dtype(keyarr)
-            and not self.is_floating()
-            and not isinstance(keyarr, ABCPeriodIndex)
-        ):
-
-            if self.inferred_type == "mixed-integer":
-                indexer = self.get_indexer(keyarr)
-                if (indexer >= 0).all():
-                    return indexer
-                # missing values are flagged as -1 by get_indexer and negative
-                # indices are already converted to positive indices in the
-                # above if-statement, so the negative flags are changed to
-                # values outside the range of indices so as to trigger an
-                # IndexError in maybe_convert_indices
-                indexer[indexer < 0] = len(self)
-
-                return maybe_convert_indices(indexer, len(self))
-
-            elif not self.inferred_type == "integer":
-                keyarr = np.where(keyarr < 0, len(self) + keyarr, keyarr)
-                return keyarr
-
+        """
         return None
 
-    def _invalid_indexer(self, form, key):
+    def _invalid_indexer(self, form: str_t, key):
         """
         Consistent invalid indexer message.
         """
         raise TypeError(
-            "cannot do {form} indexing on {klass} with these "
-            "indexers [{key}] of {kind}".format(
-                form=form, klass=type(self), key=key, kind=type(key)
-            )
+            f"cannot do {form} indexing on {type(self).__name__} with these "
+            f"indexers [{key}] of type {type(key).__name__}"
         )
 
     # --------------------------------------------------------------------
@@ -3308,7 +3337,10 @@ def reindex(self, target, method=None, level=None, limit=None, tolerance=None):
         if not isinstance(target, Index) and len(target) == 0:
             attrs = self._get_attributes_dict()
             attrs.pop("freq", None)  # don't preserve freq
-            values = self._data[:0]  # appropriately-dtyped empty array
+            if isinstance(self, ABCRangeIndex):
+                values = range(0)
+            else:
+                values = self._data[:0]  # appropriately-dtyped empty array
             target = self._simple_new(values, dtype=self.dtype, **attrs)
         else:
             target = ensure_index(target)
@@ -3398,15 +3430,14 @@ def _reindex_non_unique(self, target):
                 new_indexer = np.arange(len(self.take(indexer)))
                 new_indexer[~check] = -1
 
-        new_index = self._shallow_copy_with_infer(new_labels, freq=None)
+        new_index = self._shallow_copy_with_infer(new_labels)
         return new_index, indexer, new_indexer
 
     # --------------------------------------------------------------------
     # Join Methods
 
-    _index_shared_docs[
-        "join"
-    ] = """
+    def join(self, other, how="left", level=None, return_indexers=False, sort=False):
+        """
         Compute join_index and indexers to conform data
         structures to the new index.
 
@@ -3415,20 +3446,15 @@ def _reindex_non_unique(self, target):
         other : Index
         how : {'left', 'right', 'inner', 'outer'}
         level : int or level name, default None
-        return_indexers : boolean, default False
-        sort : boolean, default False
+        return_indexers : bool, default False
+        sort : bool, default False
             Sort the join keys lexicographically in the result Index. If False,
-            the order of the join keys depends on the join type (how keyword)
-
-            .. versionadded:: 0.20.0
+            the order of the join keys depends on the join type (how keyword).
 
         Returns
         -------
         join_index, (left_indexer, right_indexer)
         """
-
-    @Appender(_index_shared_docs["join"])
-    def join(self, other, how="left", level=None, return_indexers=False, sort=False):
         self_is_mi = isinstance(self, ABCMultiIndex)
         other_is_mi = isinstance(other, ABCMultiIndex)
 
@@ -3534,7 +3560,7 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
             return join_index
 
     def _join_multi(self, other, how, return_indexers=True):
-        from .multi import MultiIndex
+        from pandas.core.indexes.multi import MultiIndex
         from pandas.core.reshape.merge import _restore_dropped_levels_multijoin
 
         # figure out join names
@@ -3546,8 +3572,8 @@ def _join_multi(self, other, how, return_indexers=True):
         if not overlap:
             raise ValueError("cannot join with no overlapping index names")
 
-        self_is_mi = isinstance(self, MultiIndex)
-        other_is_mi = isinstance(other, MultiIndex)
+        self_is_mi = isinstance(self, ABCMultiIndex)
+        other_is_mi = isinstance(other, ABCMultiIndex)
 
         if self_is_mi and other_is_mi:
 
@@ -3555,8 +3581,13 @@ def _join_multi(self, other, how, return_indexers=True):
             ldrop_names = list(self_names - overlap)
             rdrop_names = list(other_names - overlap)
 
-            self_jnlevels = self.droplevel(ldrop_names)
-            other_jnlevels = other.droplevel(rdrop_names)
+            # if only the order differs
+            if not len(ldrop_names + rdrop_names):
+                self_jnlevels = self
+                other_jnlevels = other.reorder_levels(self.names)
+            else:
+                self_jnlevels = self.droplevel(ldrop_names)
+                other_jnlevels = other.droplevel(rdrop_names)
 
             # Join left and right
             # Join on same leveled multi-index frames is supported
@@ -3636,7 +3667,7 @@ def _join_level(
         MultiIndex will not be changed; otherwise, it will tie out
         with `other`.
         """
-        from .multi import MultiIndex
+        from pandas.core.indexes.multi import MultiIndex
 
         def _get_leaf_sorter(labels):
             """
@@ -3818,7 +3849,7 @@ def _wrap_joined_index(self, joined, other):
     # Uncategorized Methods
 
     @property
-    def values(self):
+    def values(self) -> np.ndarray:
         """
         Return an array representing the data in the Index.
 
@@ -3839,17 +3870,28 @@ def values(self):
         """
         return self._data.view(np.ndarray)
 
+    @cache_readonly
+    @Appender(IndexOpsMixin.array.__doc__)  # type: ignore
+    def array(self) -> ExtensionArray:
+        array = self._data
+        if isinstance(array, np.ndarray):
+            from pandas.core.arrays.numpy_ import PandasArray
+
+            array = PandasArray(array)
+        return array
+
     @property
-    def _values(self) -> Union[ExtensionArray, ABCIndexClass, np.ndarray]:
-        # TODO(EA): remove index types as they become extension arrays
+    def _values(self) -> Union[ExtensionArray, np.ndarray]:
         """
         The best array representation.
 
-        This is an ndarray, ExtensionArray, or Index subclass. This differs
-        from ``_ndarray_values``, which always returns an ndarray.
+        This is an ndarray or ExtensionArray. This differs from
+        ``_ndarray_values``, which always returns an ndarray.
 
         Both ``_values`` and ``_ndarray_values`` are consistent between
-        ``Series`` and ``Index``.
+        ``Series`` and ``Index`` (except for datetime64[ns], which returns
+        a DatetimeArray for _values on the Index, but ndarray[M8ns] on the
+        Series).
 
         It may differ from the public '.values' method.
 
@@ -3857,8 +3899,8 @@ def _values(self) -> Union[ExtensionArray, ABCIndexClass, np.ndarray]:
         ----------------- | --------------- | ------------- | --------------- |
         Index             | ndarray         | ndarray       | ndarray         |
         CategoricalIndex  | Categorical     | Categorical   | ndarray[int]    |
-        DatetimeIndex     | ndarray[M8ns]   | ndarray[M8ns] | ndarray[M8ns]   |
-        DatetimeIndex[tz] | ndarray[M8ns]   | DTI[tz]       | ndarray[M8ns]   |
+        DatetimeIndex     | ndarray[M8ns]   | DatetimeArray | ndarray[M8ns]   |
+        DatetimeIndex[tz] | ndarray[M8ns]   | DatetimeArray | ndarray[M8ns]   |
         PeriodIndex       | ndarray[object] | PeriodArray   | ndarray[int]    |
         IntervalIndex     | IntervalArray   | IntervalArray | ndarray[object] |
 
@@ -3869,13 +3911,10 @@ def _values(self) -> Union[ExtensionArray, ABCIndexClass, np.ndarray]:
         """
         return self._data
 
-    def get_values(self):
+    def _internal_get_values(self) -> np.ndarray:
         """
         Return `Index` data as an `numpy.ndarray`.
 
-        .. deprecated:: 0.25.0
-            Use :meth:`Index.to_numpy` or :attr:`Index.array` instead.
-
         Returns
         -------
         numpy.ndarray
@@ -3883,7 +3922,7 @@ def get_values(self):
 
         See Also
         --------
-        Index.values : The attribute that get_values wraps.
+        Index.values : The attribute that _internal_get_values wraps.
 
         Examples
         --------
@@ -3896,62 +3935,49 @@ def get_values(self):
         a  1  2  3
         b  4  5  6
         c  7  8  9
-        >>> df.index.get_values()
+        >>> df.index._internal_get_values()
         array(['a', 'b', 'c'], dtype=object)
 
         Standalone `Index` values:
 
         >>> idx = pd.Index(['1', '2', '3'])
-        >>> idx.get_values()
+        >>> idx._internal_get_values()
         array(['1', '2', '3'], dtype=object)
 
         `MultiIndex` arrays also have only one dimension:
 
         >>> midx = pd.MultiIndex.from_arrays([[1, 2, 3], ['a', 'b', 'c']],
         ...                                  names=('number', 'letter'))
-        >>> midx.get_values()
+        >>> midx._internal_get_values()
         array([(1, 'a'), (2, 'b'), (3, 'c')], dtype=object)
-        >>> midx.get_values().ndim
+        >>> midx._internal_get_values().ndim
         1
         """
-        warnings.warn(
-            "The 'get_values' method is deprecated and will be removed in a "
-            "future version. Use '.to_numpy()' or '.array' instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._internal_get_values()
-
-    def _internal_get_values(self):
         return self.values
 
     @Appender(IndexOpsMixin.memory_usage.__doc__)
-    def memory_usage(self, deep=False):
+    def memory_usage(self, deep: bool = False) -> int:
         result = super().memory_usage(deep=deep)
 
         # include our engine hashtable
         result += self._engine.sizeof(deep=deep)
         return result
 
-    _index_shared_docs[
-        "where"
-    ] = """
+    def where(self, cond, other=None):
+        """
         Return an Index of same shape as self and whose corresponding
         entries are from self where cond is True and otherwise are from
         other.
 
         Parameters
         ----------
-        cond : boolean array-like with the same length as self
+        cond : bool array-like with the same length as self
         other : scalar, or array-like
 
         Returns
         -------
         Index
         """
-
-    @Appender(_index_shared_docs["where"])
-    def where(self, cond, other=None):
         if other is None:
             other = self._na_value
 
@@ -3974,55 +4000,13 @@ def where(self, cond, other=None):
         return self._shallow_copy_with_infer(values, dtype=dtype)
 
     # construction helpers
-    @classmethod
-    def _try_convert_to_int_index(cls, data, copy, name, dtype):
-        """
-        Attempt to convert an array of data into an integer index.
-
-        Parameters
-        ----------
-        data : The data to convert.
-        copy : Whether to copy the data or not.
-        name : The name of the index returned.
-
-        Returns
-        -------
-        int_index : data converted to either an Int64Index or a
-                    UInt64Index
-
-        Raises
-        ------
-        ValueError if the conversion was not successful.
-        """
-
-        from .numeric import Int64Index, UInt64Index
-
-        if not is_unsigned_integer_dtype(dtype):
-            # skip int64 conversion attempt if uint-like dtype is passed, as
-            # this could return Int64Index when UInt64Index is what's desired
-            try:
-                res = data.astype("i8", copy=False)
-                if (res == data).all():
-                    return Int64Index(res, copy=copy, name=name)
-            except (OverflowError, TypeError, ValueError):
-                pass
-
-        # Conversion to int64 failed (possibly due to overflow) or was skipped,
-        # so let's try now with uint64.
-        try:
-            res = data.astype("u8", copy=False)
-            if (res == data).all():
-                return UInt64Index(res, copy=copy, name=name)
-        except (OverflowError, TypeError, ValueError):
-            pass
-
-        raise ValueError
-
     @classmethod
     def _scalar_data_error(cls, data):
-        raise TypeError(
-            "{0}(...) must be called with a collection of some "
-            "kind, {1} was passed".format(cls.__name__, repr(data))
+        # We return the TypeError so that we can raise it from the constructor
+        #  in order to keep mypy happy
+        return TypeError(
+            f"{cls.__name__}(...) must be called with a collection of some "
+            f"kind, {repr(data)} was passed"
         )
 
     @classmethod
@@ -4032,30 +4016,6 @@ def _string_data_error(cls, data):
             "to explicitly cast to a numeric type"
         )
 
-    @classmethod
-    def _coerce_to_ndarray(cls, data):
-        """
-        Coerces data to ndarray.
-
-        Converts other iterables to list first and then to array.
-        Does not touch ndarrays.
-
-        Raises
-        ------
-        TypeError
-            When the data passed in is a scalar.
-        """
-
-        if not isinstance(data, (np.ndarray, Index)):
-            if data is None or is_scalar(data):
-                cls._scalar_data_error(data)
-
-            # other iterable of some kind
-            if not isinstance(data, (ABCSeries, list, tuple)):
-                data = list(data)
-            data = np.asarray(data)
-        return data
-
     def _coerce_scalar_to_index(self, item):
         """
         We need to coerce a scalar to a compat for our index type.
@@ -4090,29 +4050,30 @@ def _assert_can_do_op(self, value):
         Check value is valid for scalar op.
         """
         if not is_scalar(value):
-            msg = "'value' must be a scalar, passed: {0}"
-            raise TypeError(msg.format(type(value).__name__))
+            raise TypeError(f"'value' must be a scalar, passed: {type(value).__name__}")
 
     @property
-    def _has_complex_internals(self):
-        # to disable groupby tricks in MultiIndex
+    def _has_complex_internals(self) -> bool:
+        """
+        Indicates if an index is not directly backed by a numpy array
+        """
+        # used to avoid libreduction code paths, which raise or require conversion
         return False
 
-    def _is_memory_usage_qualified(self):
+    def _is_memory_usage_qualified(self) -> bool:
         """
         Return a boolean if we need a qualified .info display.
         """
         return self.is_object()
 
-    def is_type_compatible(self, kind):
+    def is_type_compatible(self, kind) -> bool:
         """
         Whether the index type is compatible with the provided type.
         """
         return kind == self.inferred_type
 
-    _index_shared_docs[
-        "contains"
-    ] = """
+    def __contains__(self, key: Any) -> bool:
+        """
         Return a boolean indicating whether the provided key is in the index.
 
         Parameters
@@ -4125,6 +4086,11 @@ def is_type_compatible(self, kind):
         bool
             Whether the key search is in the index.
 
+        Raises
+        ------
+        TypeError
+            If the key is not hashable.
+
         See Also
         --------
         Index.isin : Returns an ndarray of boolean dtype indicating whether the
@@ -4141,37 +4107,14 @@ def is_type_compatible(self, kind):
         >>> 6 in idx
         False
         """
-
-    @Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
-    def __contains__(self, key):
         hash(key)
         try:
             return key in self._engine
         except (OverflowError, TypeError, ValueError):
             return False
 
-    def contains(self, key):
-        """
-        Return a boolean indicating whether the provided key is in the index.
-
-        .. deprecated:: 0.25.0
-            Use ``key in index`` instead of ``index.contains(key)``.
-
-        Returns
-        -------
-        bool
-        """
-        warnings.warn(
-            "The 'contains' method is deprecated and will be removed in a "
-            "future version. Use 'key in index' instead of "
-            "'index.contains(key)'",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return key in self
-
     def __hash__(self):
-        raise TypeError("unhashable type: %r" % type(self).__name__)
+        raise TypeError(f"unhashable type: {repr(type(self).__name__)}")
 
     def __setitem__(self, key, value):
         raise TypeError("Index does not support mutable operations")
@@ -4207,11 +4150,14 @@ def __getitem__(self, key):
         key = com.values_from_object(key)
         result = getitem(key)
         if not is_scalar(result):
+            if np.ndim(result) > 1:
+                deprecate_ndim_indexing(result)
+                return result
             return promote(result)
         else:
             return result
 
-    def _can_hold_identifiers_and_holds_name(self, name):
+    def _can_hold_identifiers_and_holds_name(self, name) -> bool:
         """
         Faster check for ``name in self`` when we know `name` is a Python
         identifier (e.g. in NDFrame.__getattr__, which hits this to support
@@ -4266,7 +4212,13 @@ def _concat_same_dtype(self, to_concat, name):
         Concatenate to_concat which has the same class.
         """
         # must be overridden in specific classes
-        klasses = (ABCDatetimeIndex, ABCTimedeltaIndex, ABCPeriodIndex, ExtensionArray)
+        klasses = (
+            ABCDatetimeIndex,
+            ABCTimedeltaIndex,
+            ABCPeriodIndex,
+            ExtensionArray,
+            ABCIntervalIndex,
+        )
         to_concat = [
             x.astype(object) if isinstance(x, klasses) else x for x in to_concat
         ]
@@ -4302,7 +4254,7 @@ def putmask(self, mask, value):
             # coerces to object
             return self.astype(object).putmask(mask, value)
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determine if two Index objects contain the same elements.
 
@@ -4322,14 +4274,17 @@ def equals(self, other):
             # if other is not object, use other's logic for coercion
             return other.equals(self)
 
-        try:
-            return array_equivalent(
-                com.values_from_object(self), com.values_from_object(other)
-            )
-        except Exception:
-            return False
+        if isinstance(other, ABCMultiIndex):
+            # d-level MultiIndex can equal d-tuple Index
+            if not is_object_dtype(self.dtype):
+                if self.nlevels != other.nlevels:
+                    return False
+
+        return array_equivalent(
+            com.values_from_object(self), com.values_from_object(other)
+        )
 
-    def identical(self, other):
+    def identical(self, other) -> bool:
         """
         Similar to equals, but check that other comparable attributes are
         also equal.
@@ -4422,7 +4377,7 @@ def asof_locs(self, where, mask):
         every entry in the `where` argument.
 
         As in the `asof` function, if the label (a particular entry in
-        `where`) is not in the index, the latest index label upto the
+        `where`) is not in the index, the latest index label up to the
         passed label is chosen and its index returned.
 
         If all of the labels in the index are later than a label in `where`,
@@ -4455,7 +4410,7 @@ def asof_locs(self, where, mask):
 
         return result
 
-    def sort_values(self, return_indexer=False, ascending=True):
+    def sort_values(self, return_indexer: bool = False, ascending: bool = True):
         """
         Return a sorted copy of the index.
 
@@ -4527,7 +4482,7 @@ def shift(self, periods=1, freq=None):
         periods : int, default 1
             Number of periods (or increments) to shift by,
             can be positive or negative.
-        freq : pandas.DateOffset, pandas.Timedelta or string, optional
+        freq : pandas.DateOffset, pandas.Timedelta or str, optional
             Frequency increment to shift by.
             If None, the index is shifted by its own `freq` attribute.
             Offset aliases are valid strings, e.g., 'D', 'W', 'M' etc.
@@ -4571,9 +4526,9 @@ def shift(self, periods=1, freq=None):
                        '2012-03-01'],
                       dtype='datetime64[ns]', freq='MS')
         """
-        raise NotImplementedError("Not supported for type %s" % type(self).__name__)
+        raise NotImplementedError(f"Not supported for type {type(self).__name__}")
 
-    def argsort(self, *args, **kwargs):
+    def argsort(self, *args, **kwargs) -> np.ndarray:
         """
         Return the integer indices that would sort the index.
 
@@ -4613,80 +4568,82 @@ def argsort(self, *args, **kwargs):
             result = np.array(self)
         return result.argsort(*args, **kwargs)
 
-    _index_shared_docs[
-        "get_value"
-    ] = """
+    def get_value(self, series: "Series", key):
+        """
         Fast lookup of value from 1-dimensional ndarray. Only use this if you
         know what you're doing.
 
         Returns
         -------
-        scalar
-            A value in the Series with the index of the key value in self.
+        scalar or Series
         """
+        if not is_scalar(key):
+            # if key is not a scalar, directly raise an error (the code below
+            # would convert to numpy arrays and raise later any way) - GH29926
+            raise InvalidIndexError(key)
 
-    @Appender(_index_shared_docs["get_value"] % _index_doc_kwargs)
-    def get_value(self, series, key):
-
-        # if we have something that is Index-like, then
-        # use this, e.g. DatetimeIndex
-        # Things like `Series._get_value` (via .at) pass the EA directly here.
-        s = getattr(series, "_values", series)
-        if isinstance(s, (ExtensionArray, Index)) and is_scalar(key):
+        try:
             # GH 20882, 21257
-            # Unify Index and ExtensionArray treatment
             # First try to convert the key to a location
             # If that fails, raise a KeyError if an integer
             # index, otherwise, see if key is an integer, and
             # try that
-            try:
-                iloc = self.get_loc(key)
-                return s[iloc]
-            except KeyError:
-                if len(self) > 0 and (self.holds_integer() or self.is_boolean()):
-                    raise
-                elif is_integer(key):
-                    return s[key]
+            loc = self.get_loc(key)
+        except KeyError:
+            if not self._should_fallback_to_positional():
+                raise
+            elif is_integer(key):
+                # If the Index cannot hold integer, then this is unambiguously
+                #  a locational lookup.
+                loc = key
+            else:
+                raise
 
-        s = com.values_from_object(series)
-        k = com.values_from_object(key)
+        return self._get_values_for_loc(series, loc, key)
 
-        k = self._convert_scalar_indexer(k, kind="getitem")
-        try:
-            return self._engine.get_value(s, k, tz=getattr(series.dtype, "tz", None))
-        except KeyError as e1:
-            if len(self) > 0 and (self.holds_integer() or self.is_boolean()):
-                raise
+    def _should_fallback_to_positional(self) -> bool:
+        """
+        If an integer key is not found, should we fall back to positional indexing?
+        """
+        if len(self) > 0 and (self.holds_integer() or self.is_boolean()):
+            return False
+        return True
 
-            try:
-                return libindex.get_value_at(s, key)
-            except IndexError:
-                raise
-            except TypeError:
-                # generator/iterator-like
-                if is_iterator(key):
-                    raise InvalidIndexError(key)
-                else:
-                    raise e1
-            except Exception:  # pragma: no cover
-                raise e1
-        except TypeError:
-            # python 3
-            if is_scalar(key):  # pragma: no cover
-                raise IndexError(key)
-            raise InvalidIndexError(key)
+    def _get_values_for_loc(self, series: "Series", loc, key):
+        """
+        Do a positional lookup on the given Series, returning either a scalar
+        or a Series.
+
+        Assumes that `series.index is self`
+
+        key is included for MultiIndex compat.
+        """
+        if is_integer(loc):
+            return series._values[loc]
+
+        return series.iloc[loc]
 
     def set_value(self, arr, key, value):
         """
         Fast lookup of value from 1-dimensional ndarray.
 
+        .. deprecated:: 1.0
+
         Notes
         -----
         Only use this if you know what you're doing.
         """
-        self._engine.set_value(
-            com.values_from_object(arr), com.values_from_object(key), value
+        warnings.warn(
+            (
+                "The 'set_value' method is deprecated, and "
+                "will be removed in a future version."
+            ),
+            FutureWarning,
+            stacklevel=2,
         )
+        loc = self._engine.get_loc(key)
+        validate_numeric_casting(arr.dtype, value)
+        arr[loc] = value
 
     _index_shared_docs[
         "get_indexer_non_unique"
@@ -4713,13 +4670,13 @@ def set_value(self, arr, key, value):
     @Appender(_index_shared_docs["get_indexer_non_unique"] % _index_doc_kwargs)
     def get_indexer_non_unique(self, target):
         target = ensure_index(target)
-        if is_categorical(target):
-            target = target.astype(target.dtype.categories.dtype)
         pself, ptarget = self._maybe_promote(target)
         if pself is not self or ptarget is not target:
             return pself.get_indexer_non_unique(ptarget)
 
-        if self.is_all_dates:
+        if is_categorical(target):
+            tgt_values = np.asarray(target)
+        elif self.is_all_dates and target.is_all_dates:  # GH 30399
             tgt_values = target.asi8
         else:
             tgt_values = target._ndarray_values
@@ -4731,7 +4688,7 @@ def get_indexer_for(self, target, **kwargs):
         """
         Guaranteed return of an indexer even when non-unique.
 
-        This dispatches to get_indexer or get_indexer_nonunique
+        This dispatches to get_indexer or get_indexer_non_unique
         as appropriate.
 
         Returns
@@ -4746,16 +4703,15 @@ def get_indexer_for(self, target, **kwargs):
 
     def _maybe_promote(self, other):
         # A hack, but it works
-        from pandas import DatetimeIndex
 
-        if self.inferred_type == "date" and isinstance(other, DatetimeIndex):
-            return DatetimeIndex(self), other
+        if self.inferred_type == "date" and isinstance(other, ABCDatetimeIndex):
+            return type(other)(self), other
         elif self.inferred_type == "boolean":
             if not is_object_dtype(self.dtype):
                 return self.astype("object"), other.astype("object")
         return self, other
 
-    def groupby(self, values):
+    def groupby(self, values) -> PrettyDict[Hashable, np.ndarray]:
         """
         Group the index labels by a given array of values.
 
@@ -4766,7 +4722,7 @@ def groupby(self, values):
 
         Returns
         -------
-        groups : dict
+        dict
             {group name -> group labels}
         """
 
@@ -4780,7 +4736,7 @@ def groupby(self, values):
         # map to the label
         result = {k: self.take(v) for k, v in result.items()}
 
-        return result
+        return PrettyDict(result)
 
     def map(self, mapper, na_action=None):
         """
@@ -4802,7 +4758,7 @@ def map(self, mapper, na_action=None):
             a MultiIndex will be returned.
         """
 
-        from .multi import MultiIndex
+        from pandas.core.indexes.multi import MultiIndex
 
         new_values = super()._map_values(mapper, na_action=na_action)
 
@@ -4908,7 +4864,7 @@ def isin(self, values, level=None):
             self._validate_index_level(level)
         return algos.isin(self, values)
 
-    def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
+    def _get_string_slice(self, key: str_t, use_lhs: bool = True, use_rhs: bool = True):
         # this is for partial string indexing,
         # overridden in DatetimeIndex, TimedeltaIndex and PeriodIndex
         raise NotImplementedError
@@ -4921,11 +4877,11 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
         Parameters
         ----------
         start : label, default None
-            If None, defaults to the beginning
+            If None, defaults to the beginning.
         end : label, default None
-            If None, defaults to the end
+            If None, defaults to the end.
         step : int, default None
-        kind : string, default None
+        kind : str, default None
 
         Returns
         -------
@@ -4968,33 +4924,26 @@ def _maybe_cast_indexer(self, key):
         to an int if equivalent.
         """
 
-        if is_float(key) and not self.is_floating():
-            try:
-                ckey = int(key)
-                if ckey == key:
-                    key = ckey
-            except (OverflowError, ValueError, TypeError):
-                pass
+        if not self.is_floating():
+            return com.cast_scalar_indexer(key)
         return key
 
-    def _validate_indexer(self, form, key, kind):
+    def _validate_indexer(self, form: str_t, key, kind: str_t):
         """
         If we are positional indexer, validate that we have appropriate
         typed bounds must be an integer.
         """
-        assert kind in ["ix", "loc", "getitem", "iloc"]
+        assert kind in ["getitem", "iloc"]
 
         if key is None:
             pass
         elif is_integer(key):
             pass
-        elif kind in ["iloc", "getitem"]:
+        else:
             self._invalid_indexer(form, key)
-        return key
 
-    _index_shared_docs[
-        "_maybe_cast_slice_bound"
-    ] = """
+    def _maybe_cast_slice_bound(self, label, side: str_t, kind):
+        """
         This function should be overloaded in subclasses that allow non-trivial
         casting on label-slice bounds, e.g. datetime-like indices allowing
         strings containing formatted datetimes.
@@ -5003,29 +4952,24 @@ def _validate_indexer(self, form, key, kind):
         ----------
         label : object
         side : {'left', 'right'}
-        kind : {'ix', 'loc', 'getitem'}
+        kind : {'loc', 'getitem'} or None
 
         Returns
         -------
-        label :  object
+        label : object
 
         Notes
         -----
         Value of `side` parameter should be validated in caller.
-
         """
-
-    @Appender(_index_shared_docs["_maybe_cast_slice_bound"])
-    def _maybe_cast_slice_bound(self, label, side, kind):
-        assert kind in ["ix", "loc", "getitem", None]
+        assert kind in ["loc", "getitem", None]
 
         # We are a plain index here (sub-class override this method if they
         # wish to have special treatment for floats/ints, e.g. Float64Index and
         # datetimelike Indexes
         # reject them
         if is_float(label):
-            if not (kind in ["ix"] and (self.holds_integer() or self.is_floating())):
-                self._invalid_indexer("slice", label)
+            self._invalid_indexer("slice", label)
 
         # we are trying to find integer bounds on a non-integer based index
         # this is rejected (generally .loc gets you here)
@@ -5048,7 +4992,7 @@ def _searchsorted_monotonic(self, label, side="left"):
 
         raise ValueError("index must be monotonic increasing or decreasing")
 
-    def get_slice_bound(self, label, side, kind):
+    def get_slice_bound(self, label, side: str_t, kind) -> int:
         """
         Calculate slice bound that corresponds to given label.
 
@@ -5059,19 +5003,19 @@ def get_slice_bound(self, label, side, kind):
         ----------
         label : object
         side : {'left', 'right'}
-        kind : {'ix', 'loc', 'getitem'}
+        kind : {'loc', 'getitem'} or None
 
         Returns
         -------
         int
             Index of label.
         """
-        assert kind in ["ix", "loc", "getitem", None]
+        assert kind in ["loc", "getitem", None]
 
         if side not in ("left", "right"):
             raise ValueError(
-                "Invalid value for side kwarg,"
-                " must be either 'left' or 'right': %s" % (side,)
+                "Invalid value for side kwarg, must be either "
+                f"'left' or 'right': {side}"
             )
 
         original_label = label
@@ -5099,8 +5043,8 @@ def get_slice_bound(self, label, side, kind):
                 slc = lib.maybe_indices_to_slice(slc.astype("i8"), len(self))
             if isinstance(slc, np.ndarray):
                 raise KeyError(
-                    "Cannot get %s slice bound for non-unique "
-                    "label: %r" % (side, original_label)
+                    f"Cannot get {side} slice bound for non-unique "
+                    f"label: {repr(original_label)}"
                 )
 
         if isinstance(slc, slice):
@@ -5121,12 +5065,12 @@ def slice_locs(self, start=None, end=None, step=None, kind=None):
         Parameters
         ----------
         start : label, default None
-            If None, defaults to the beginning
+            If None, defaults to the beginning.
         end : label, default None
-            If None, defaults to the end
+            If None, defaults to the end.
         step : int, defaults None
-            If None, defaults to 1
-        kind : {'ix', 'loc', 'getitem'} or None
+            If None, defaults to 1.
+        kind : {'loc', 'getitem'} or None
 
         Returns
         -------
@@ -5213,7 +5157,7 @@ def delete(self, loc):
         """
         return self._shallow_copy(np.delete(self._data, loc))
 
-    def insert(self, loc, item):
+    def insert(self, loc: int, item):
         """
         Make new Index inserting new item at location.
 
@@ -5233,7 +5177,7 @@ def insert(self, loc, item):
         idx = np.concatenate((_self[:loc], item, _self[loc:]))
         return self._shallow_copy_with_infer(idx)
 
-    def drop(self, labels, errors="raise"):
+    def drop(self, labels, errors: str_t = "raise"):
         """
         Make new Index with passed list of labels deleted.
 
@@ -5258,7 +5202,7 @@ def drop(self, labels, errors="raise"):
         mask = indexer == -1
         if mask.any():
             if errors != "ignore":
-                raise KeyError("{} not found in axis".format(labels[mask]))
+                raise KeyError(f"{labels[mask]} not found in axis")
             indexer = indexer[~mask]
         return self.delete(indexer)
 
@@ -5524,7 +5468,7 @@ def ensure_index_from_sequences(sequences, names=None):
     --------
     ensure_index
     """
-    from .multi import MultiIndex
+    from pandas.core.indexes.multi import MultiIndex
 
     if len(sequences) == 1:
         if names is not None:
@@ -5585,7 +5529,7 @@ def ensure_index(index_like, copy=False):
         converted, all_arrays = lib.clean_index_list(index_like)
 
         if len(converted) > 0 and all_arrays:
-            from .multi import MultiIndex
+            from pandas.core.indexes.multi import MultiIndex
 
             return MultiIndex.from_arrays(converted)
         else:
@@ -5625,10 +5569,195 @@ def _trim_front(strings):
 
 def _validate_join_method(method):
     if method not in ["left", "right", "inner", "outer"]:
-        raise ValueError("do not recognize join method %s" % method)
+        raise ValueError(f"do not recognize join method {method}")
 
 
 def default_index(n):
-    from pandas.core.index import RangeIndex
+    from pandas.core.indexes.range import RangeIndex
 
     return RangeIndex(0, n, name=None)
+
+
+def maybe_extract_name(name, obj, cls) -> Optional[Hashable]:
+    """
+    If no name is passed, then extract it from data, validating hashability.
+    """
+    if name is None and isinstance(obj, (Index, ABCSeries)):
+        # Note we don't just check for "name" attribute since that would
+        #  pick up e.g. dtype.name
+        name = obj.name
+
+    # GH#29069
+    if not is_hashable(name):
+        raise TypeError(f"{cls.__name__}.name must be a hashable type")
+
+    return name
+
+
+def _maybe_cast_with_dtype(data: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+    """
+    If a dtype is passed, cast to the closest matching dtype that is supported
+    by Index.
+
+    Parameters
+    ----------
+    data : np.ndarray
+    dtype : np.dtype
+    copy : bool
+
+    Returns
+    -------
+    np.ndarray
+    """
+    # we need to avoid having numpy coerce
+    # things that look like ints/floats to ints unless
+    # they are actually ints, e.g. '0' and 0.0
+    # should not be coerced
+    # GH 11836
+    if is_integer_dtype(dtype):
+        inferred = lib.infer_dtype(data, skipna=False)
+        if inferred == "integer":
+            data = maybe_cast_to_integer_array(data, dtype, copy=copy)
+        elif inferred in ["floating", "mixed-integer-float"]:
+            if isna(data).any():
+                raise ValueError("cannot convert float NaN to integer")
+
+            if inferred == "mixed-integer-float":
+                data = maybe_cast_to_integer_array(data, dtype)
+
+            # If we are actually all equal to integers,
+            # then coerce to integer.
+            try:
+                data = _try_convert_to_int_array(data, copy, dtype)
+            except ValueError:
+                data = np.array(data, dtype=np.float64, copy=copy)
+
+        elif inferred == "string":
+            pass
+        else:
+            data = data.astype(dtype)
+    elif is_float_dtype(dtype):
+        inferred = lib.infer_dtype(data, skipna=False)
+        if inferred == "string":
+            pass
+        else:
+            data = data.astype(dtype)
+    else:
+        data = np.array(data, dtype=dtype, copy=copy)
+
+    return data
+
+
+def _maybe_cast_data_without_dtype(subarr):
+    """
+    If we have an arraylike input but no passed dtype, try to infer
+    a supported dtype.
+
+    Parameters
+    ----------
+    subarr : np.ndarray, Index, or Series
+
+    Returns
+    -------
+    converted : np.ndarray or ExtensionArray
+    dtype : np.dtype or ExtensionDtype
+    """
+    # Runtime import needed bc IntervalArray imports Index
+    from pandas.core.arrays import (
+        IntervalArray,
+        PeriodArray,
+        DatetimeArray,
+        TimedeltaArray,
+    )
+
+    inferred = lib.infer_dtype(subarr, skipna=False)
+
+    if inferred == "integer":
+        try:
+            data = _try_convert_to_int_array(subarr, False, None)
+            return data, data.dtype
+        except ValueError:
+            pass
+
+        return subarr, object
+
+    elif inferred in ["floating", "mixed-integer-float", "integer-na"]:
+        # TODO: Returns IntegerArray for integer-na case in the future
+        return subarr, np.float64
+
+    elif inferred == "interval":
+        try:
+            data = IntervalArray._from_sequence(subarr, copy=False)
+            return data, data.dtype
+        except ValueError:
+            # GH27172: mixed closed Intervals --> object dtype
+            pass
+    elif inferred == "boolean":
+        # don't support boolean explicitly ATM
+        pass
+    elif inferred != "string":
+        if inferred.startswith("datetime"):
+            try:
+                data = DatetimeArray._from_sequence(subarr, copy=False)
+                return data, data.dtype
+            except (ValueError, OutOfBoundsDatetime):
+                # GH 27011
+                # If we have mixed timezones, just send it
+                # down the base constructor
+                pass
+
+        elif inferred.startswith("timedelta"):
+            data = TimedeltaArray._from_sequence(subarr, copy=False)
+            return data, data.dtype
+        elif inferred == "period":
+            try:
+                data = PeriodArray._from_sequence(subarr)
+                return data, data.dtype
+            except IncompatibleFrequency:
+                pass
+
+    return subarr, subarr.dtype
+
+
+def _try_convert_to_int_array(
+    data: np.ndarray, copy: bool, dtype: np.dtype
+) -> np.ndarray:
+    """
+    Attempt to convert an array of data into an integer array.
+
+    Parameters
+    ----------
+    data : The data to convert.
+    copy : bool
+        Whether to copy the data or not.
+    dtype : np.dtype
+
+    Returns
+    -------
+    int_array : data converted to either an ndarray[int64] or ndarray[uint64]
+
+    Raises
+    ------
+    ValueError if the conversion was not successful.
+    """
+
+    if not is_unsigned_integer_dtype(dtype):
+        # skip int64 conversion attempt if uint-like dtype is passed, as
+        # this could return Int64Index when UInt64Index is what's desired
+        try:
+            res = data.astype("i8", copy=False)
+            if (res == data).all():
+                return res  # TODO: might still need to copy
+        except (OverflowError, TypeError, ValueError):
+            pass
+
+    # Conversion to int64 failed (possibly due to overflow) or was skipped,
+    # so let's try now with uint64.
+    try:
+        res = data.astype("u8", copy=False)
+        if (res == data).all():
+            return res  # TODO: might still need to copy
+    except (OverflowError, TypeError, ValueError):
+        pass
+
+    raise ValueError
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 82806c7351db6..7373f41daefa4 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -1,5 +1,4 @@
-import operator
-from typing import Any
+from typing import Any, List
 import warnings
 
 import numpy as np
@@ -8,8 +7,6 @@
 
 from pandas._libs import index as libindex
 from pandas._libs.hashtable import duplicated_int64
-import pandas.compat as compat
-from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender, cache_readonly
 
 from pandas.core.dtypes.common import (
@@ -23,20 +20,35 @@
 from pandas.core.dtypes.generic import ABCCategorical, ABCSeries
 from pandas.core.dtypes.missing import isna
 
-from pandas._typing import AnyArrayLike
 from pandas.core import accessor
 from pandas.core.algorithms import take_1d
 from pandas.core.arrays.categorical import Categorical, _recode_for_categories, contains
 import pandas.core.common as com
 import pandas.core.indexes.base as ibase
-from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.base import Index, _index_shared_docs, maybe_extract_name
+from pandas.core.indexes.extension import ExtensionIndex, inherit_names
 import pandas.core.missing as missing
-from pandas.core.ops import get_op_result_name
 
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(dict(target_klass="CategoricalIndex"))
 
 
+@inherit_names(
+    [
+        "argsort",
+        "_internal_get_values",
+        "tolist",
+        "codes",
+        "categories",
+        "ordered",
+        "_reverse_indexer",
+        "searchsorted",
+        "is_dtype_equal",
+        "min",
+        "max",
+    ],
+    Categorical,
+)
 @accessor.delegate_names(
     delegate=Categorical,
     accessors=[
@@ -48,13 +60,11 @@
         "set_categories",
         "as_ordered",
         "as_unordered",
-        "min",
-        "max",
     ],
     typ="method",
     overwrite=True,
 )
-class CategoricalIndex(Index, accessor.PandasDelegate):
+class CategoricalIndex(ExtensionIndex, accessor.PandasDelegate):
     """
     Index based on an underlying :class:`Categorical`.
 
@@ -76,7 +86,7 @@ class CategoricalIndex(Index, accessor.PandasDelegate):
         Whether or not this categorical is treated as an ordered
         categorical. If not given here or in `dtype`, the resulting
         categorical will be unordered.
-    dtype : CategoricalDtype or the string "category", optional
+    dtype : CategoricalDtype or "category", optional
         If :class:`CategoricalDtype`, cannot be used together with
         `categories` or `ordered`.
 
@@ -121,7 +131,7 @@ class CategoricalIndex(Index, accessor.PandasDelegate):
     Notes
     -----
     See the `user guide
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#categoricalindex>`_
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#categoricalindex>`_
     for more.
 
     Examples
@@ -147,6 +157,10 @@ class CategoricalIndex(Index, accessor.PandasDelegate):
 
     _typ = "categoricalindex"
 
+    codes: np.ndarray
+    categories: Index
+    _data: Categorical
+
     @property
     def _engine_type(self):
         # self.codes can have dtype int8, int16, int32 or int64, so we need
@@ -164,37 +178,19 @@ def _engine_type(self):
     # Constructors
 
     def __new__(
-        cls,
-        data=None,
-        categories=None,
-        ordered=None,
-        dtype=None,
-        copy=False,
-        name=None,
-        fastpath=None,
+        cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None
     ):
 
-        if fastpath is not None:
-            warnings.warn(
-                "The 'fastpath' keyword is deprecated, and will be "
-                "removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if fastpath:
-                return cls._simple_new(data, name=name, dtype=dtype)
-
         dtype = CategoricalDtype._from_values_or_dtype(data, categories, ordered, dtype)
 
-        if name is None and hasattr(data, "name"):
-            name = data.name
+        name = maybe_extract_name(name, data, cls)
 
         if not is_categorical_dtype(data):
             # don't allow scalars
             # if data is None, then categories must be provided
             if is_scalar(data):
                 if data is not None or categories is None:
-                    cls._scalar_data_error(data)
+                    raise cls._scalar_data_error(data)
                 data = []
 
         data = cls._create_categorical(data, dtype=dtype)
@@ -255,27 +251,26 @@ def _create_categorical(cls, data, dtype=None):
         return data
 
     @classmethod
-    def _simple_new(cls, values, name=None, dtype=None, **kwargs):
+    def _simple_new(cls, values, name=None, dtype=None):
         result = object.__new__(cls)
 
         values = cls._create_categorical(values, dtype=dtype)
         result._data = values
         result.name = name
-        for k, v in kwargs.items():
-            setattr(result, k, v)
 
         result._reset_identity()
+        result._no_setting_name = False
         return result
 
     # --------------------------------------------------------------------
 
-    @Appender(_index_shared_docs["_shallow_copy"])
+    @Appender(Index._shallow_copy.__doc__)
     def _shallow_copy(self, values=None, dtype=None, **kwargs):
         if dtype is None:
             dtype = self.dtype
         return super()._shallow_copy(values=values, dtype=dtype, **kwargs)
 
-    def _is_dtype_compat(self, other):
+    def _is_dtype_compat(self, other) -> bool:
         """
         *this is an internal non-public method*
 
@@ -305,7 +300,7 @@ def _is_dtype_compat(self, other):
 
         return other
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determine if two CategoricalIndex objects contain the same elements.
 
@@ -356,7 +351,7 @@ def _format_attrs(self):
         ]
         if self.name is not None:
             attrs.append(("name", ibase.default_pprint(self.name)))
-        attrs.append(("dtype", "'%s'" % self.dtype.name))
+        attrs.append(("dtype", f"'{self.dtype.name}'"))
         max_seq_items = get_option("display.max_seq_items") or len(self)
         if len(self) > max_seq_items:
             attrs.append(("length", len(self)))
@@ -365,7 +360,7 @@ def _format_attrs(self):
     # --------------------------------------------------------------------
 
     @property
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         return "categorical"
 
     @property
@@ -374,50 +369,24 @@ def values(self):
         return self._data
 
     @property
-    def itemsize(self):
-        # Size of the items in categories, not codes.
-        return self.values.itemsize
-
-    def _wrap_setop_result(self, other, result):
-        name = get_op_result_name(self, other)
-        return self._shallow_copy(result, name=name)
-
-    def _internal_get_values(self):
-        # override base Index version to get the numpy array representation of
-        # the underlying Categorical
-        return self._data._internal_get_values()
-
-    def tolist(self):
-        return self._data.tolist()
-
-    @property
-    def codes(self):
-        return self._data.codes
-
-    @property
-    def categories(self):
-        return self._data.categories
+    def _has_complex_internals(self) -> bool:
+        # used to avoid libreduction code paths, which raise or require conversion
+        return True
 
-    @property
-    def ordered(self):
-        return self._data.ordered
-
-    def _reverse_indexer(self):
-        return self._data._reverse_indexer()
-
-    @Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
-    def __contains__(self, key):
+    @Appender(Index.__contains__.__doc__)
+    def __contains__(self, key: Any) -> bool:
         # if key is a NaN, check if any NaN is in self.
         if is_scalar(key) and isna(key):
             return self.hasnans
 
+        hash(key)
         return contains(self, key, container=self._engine)
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """ the array interface, return my values """
         return np.array(self._data, dtype=dtype)
 
-    @Appender(_index_shared_docs["astype"])
+    @Appender(Index.astype.__doc__)
     def astype(self, dtype, copy=True):
         if is_interval_dtype(dtype):
             from pandas import IntervalIndex
@@ -429,21 +398,18 @@ def astype(self, dtype, copy=True):
             if dtype == self.dtype:
                 return self.copy() if copy else self
 
-        return super().astype(dtype=dtype, copy=copy)
+        return Index.astype(self, dtype=dtype, copy=copy)
 
     @cache_readonly
     def _isnan(self):
         """ return if each value is nan"""
         return self._data.codes == -1
 
-    @Appender(ibase._index_shared_docs["fillna"])
+    @Appender(Index.fillna.__doc__)
     def fillna(self, value, downcast=None):
         self._assert_can_do_op(value)
         return CategoricalIndex(self._data.fillna(value), name=self.name)
 
-    def argsort(self, *args, **kwargs):
-        return self.values.argsort(*args, **kwargs)
-
     @cache_readonly
     def _engine(self):
         # we are going to look things up with the codes themselves.
@@ -452,20 +418,7 @@ def _engine(self):
         codes = self.codes
         return self._engine_type(lambda: codes, len(self))
 
-    # introspection
-    @cache_readonly
-    def is_unique(self):
-        return self._engine.is_unique
-
-    @property
-    def is_monotonic_increasing(self):
-        return self._engine.is_monotonic_increasing
-
-    @property
-    def is_monotonic_decreasing(self):
-        return self._engine.is_monotonic_decreasing
-
-    @Appender(_index_shared_docs["index_unique"] % _index_doc_kwargs)
+    @Appender(Index.unique.__doc__)
     def unique(self, level=None):
         if level is not None:
             self._validate_index_level(level)
@@ -483,79 +436,12 @@ def _to_safe_for_reshape(self):
         """ convert to object if we are a categorical """
         return self.astype("object")
 
-    def get_loc(self, key, method=None):
-        """
-        Get integer location, slice or boolean mask for requested label.
-
-        Parameters
-        ----------
-        key : label
-        method : {None}
-            * default: exact matches only.
-
-        Returns
-        -------
-        loc : int if unique index, slice if monotonic index, else mask
-
-        Raises
-        ------
-        KeyError : if the key is not in the index
-
-        Examples
-        --------
-        >>> unique_index = pd.CategoricalIndex(list('abc'))
-        >>> unique_index.get_loc('b')
-        1
-
-        >>> monotonic_index = pd.CategoricalIndex(list('abbc'))
-        >>> monotonic_index.get_loc('b')
-        slice(1, 3, None)
-
-        >>> non_monotonic_index = pd.CategoricalIndex(list('abcb'))
-        >>> non_monotonic_index.get_loc('b')
-        array([False,  True, False,  True], dtype=bool)
-        """
+    def _maybe_cast_indexer(self, key):
         code = self.categories.get_loc(key)
         code = self.codes.dtype.type(code)
-        try:
-            return self._engine.get_loc(code)
-        except KeyError:
-            raise KeyError(key)
+        return code
 
-    def get_value(self, series: AnyArrayLike, key: Any):
-        """
-        Fast lookup of value from 1-dimensional ndarray. Only use this if you
-        know what you're doing
-
-        Parameters
-        ----------
-        series : Series, ExtensionArray, Index, or ndarray
-            1-dimensional array to take values from
-        key: : scalar
-            The value of this index at the position of the desired value,
-            otherwise the positional index of the desired value
-
-        Returns
-        -------
-        Any
-            The element of the series at the position indicated by the key
-        """
-        try:
-            k = com.values_from_object(key)
-            k = self._convert_scalar_indexer(k, kind="getitem")
-            indexer = self.get_loc(k)
-            return series.take([indexer])[0]
-        except (KeyError, TypeError):
-            pass
-
-        # we might be a positional inexer
-        return super().get_value(series, key)
-
-    def _can_reindex(self, indexer):
-        """ always allow reindexing """
-        pass
-
-    @Appender(_index_shared_docs["where"])
+    @Appender(Index.where.__doc__)
     def where(self, cond, other=None):
         # TODO: Investigate an alternative implementation with
         # 1. copy the underlying Categorical
@@ -579,7 +465,6 @@ def reindex(self, target, method=None, level=None, limit=None, tolerance=None):
             Indices of output values in original index
 
         """
-
         if method is not None:
             raise NotImplementedError(
                 "argument method is not implemented for CategoricalIndex.reindex"
@@ -595,13 +480,11 @@ def reindex(self, target, method=None, level=None, limit=None, tolerance=None):
 
         target = ibase.ensure_index(target)
 
+        missing: List[int]
         if self.equals(target):
             indexer = None
             missing = []
         else:
-            if not target.is_unique:
-                raise ValueError("cannot reindex with a non-unique indexer")
-
             indexer, missing = self.get_indexer_non_unique(np.array(target))
 
         if len(self.codes) and indexer is not None:
@@ -708,33 +591,34 @@ def get_indexer_non_unique(self, target):
         indexer, missing = self._engine.get_indexer_non_unique(codes)
         return ensure_platform_int(indexer), missing
 
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        if self.categories._defer_to_indexing:
-            return self.categories._convert_scalar_indexer(key, kind=kind)
-
+    @Appender(Index._convert_scalar_indexer.__doc__)
+    def _convert_scalar_indexer(self, key, kind: str):
+        assert kind in ["loc", "getitem"]
+        if kind == "loc":
+            try:
+                return self.categories._convert_scalar_indexer(key, kind="loc")
+            except TypeError:
+                self._invalid_indexer("label", key)
         return super()._convert_scalar_indexer(key, kind=kind)
 
-    @Appender(_index_shared_docs["_convert_list_indexer"])
-    def _convert_list_indexer(self, keyarr, kind=None):
+    @Appender(Index._convert_list_indexer.__doc__)
+    def _convert_list_indexer(self, keyarr):
         # Return our indexer or raise if all of the values are not included in
         # the categories
 
         if self.categories._defer_to_indexing:
-            indexer = self.categories._convert_list_indexer(keyarr, kind=kind)
+            indexer = self.categories._convert_list_indexer(keyarr)
             return Index(self.codes).get_indexer_for(indexer)
 
         indexer = self.categories.get_indexer(np.asarray(keyarr))
         if (indexer == -1).any():
             raise KeyError(
-                "a list-indexer must only "
-                "include values that are "
-                "in the categories"
+                "a list-indexer must only include values that are in the categories"
             )
 
         return self.get_indexer(keyarr)
 
-    @Appender(_index_shared_docs["_convert_arr_indexer"])
+    @Appender(Index._convert_arr_indexer.__doc__)
     def _convert_arr_indexer(self, keyarr):
         keyarr = com.asarray_tuplesafe(keyarr)
 
@@ -743,27 +627,25 @@ def _convert_arr_indexer(self, keyarr):
 
         return self._shallow_copy(keyarr)
 
-    @Appender(_index_shared_docs["_convert_index_indexer"])
+    @Appender(Index._convert_index_indexer.__doc__)
     def _convert_index_indexer(self, keyarr):
         return self._shallow_copy(keyarr)
 
-    @Appender(_index_shared_docs["take"] % _index_doc_kwargs)
-    def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
-        nv.validate_take(tuple(), kwargs)
-        indices = ensure_platform_int(indices)
-        taken = self._assert_take_fillable(
-            self.codes,
-            indices,
-            allow_fill=allow_fill,
-            fill_value=fill_value,
-            na_value=-1,
+    def take_nd(self, *args, **kwargs):
+        """Alias for `take`"""
+        warnings.warn(
+            "CategoricalIndex.take_nd is deprecated, use CategoricalIndex.take instead",
+            FutureWarning,
+            stacklevel=2,
         )
-        return self._create_from_codes(taken)
+        return self.take(*args, **kwargs)
 
-    def is_dtype_equal(self, other):
-        return self._data.is_dtype_equal(other)
+    @Appender(Index._maybe_cast_slice_bound.__doc__)
+    def _maybe_cast_slice_bound(self, label, side, kind):
+        if kind == "loc":
+            return label
 
-    take_nd = take
+        return super()._maybe_cast_slice_bound(label, side, kind)
 
     def map(self, mapper):
         """
@@ -844,7 +726,7 @@ def delete(self, loc):
         """
         return self._create_from_codes(np.delete(self.codes, loc))
 
-    def insert(self, loc, item):
+    def insert(self, loc: int, item):
         """
         Make new Index inserting new item at location. Follows
         Python list.append semantics for negative values
@@ -889,36 +771,7 @@ def _concat_same_dtype(self, to_concat, name):
         result.name = name
         return result
 
-    def _codes_for_groupby(self, sort, observed):
-        """ Return a Categorical adjusted for groupby """
-        return self.values._codes_for_groupby(sort, observed)
-
-    @classmethod
-    def _add_comparison_methods(cls):
-        """ add in comparison methods """
-
-        def _make_compare(op):
-            opname = "__{op}__".format(op=op.__name__)
-
-            def _evaluate_compare(self, other):
-                with np.errstate(all="ignore"):
-                    result = op(self.array, other)
-                if isinstance(result, ABCSeries):
-                    # Dispatch to pd.Categorical returned NotImplemented
-                    # and we got a Series back; down-cast to ndarray
-                    result = result._values
-                return result
-
-            return compat.set_function_name(_evaluate_compare, opname, cls)
-
-        cls.__eq__ = _make_compare(operator.eq)
-        cls.__ne__ = _make_compare(operator.ne)
-        cls.__lt__ = _make_compare(operator.lt)
-        cls.__gt__ = _make_compare(operator.gt)
-        cls.__le__ = _make_compare(operator.le)
-        cls.__ge__ = _make_compare(operator.ge)
-
-    def _delegate_method(self, name, *args, **kwargs):
+    def _delegate_method(self, name: str, *args, **kwargs):
         """ method delegation to the ._values """
         method = getattr(self._values, name)
         if "inplace" in kwargs:
@@ -932,4 +785,3 @@ def _delegate_method(self, name, *args, **kwargs):
 CategoricalIndex._add_numeric_methods_add_sub_disabled()
 CategoricalIndex._add_numeric_methods_disabled()
 CategoricalIndex._add_logical_methods_disabled()
-CategoricalIndex._add_comparison_methods()
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index c7664d9777c71..941b6c876bb36 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -1,155 +1,106 @@
 """
 Base and utility classes for tseries type pandas objects.
 """
-import operator
-from typing import Set
-import warnings
+from datetime import datetime
+from typing import Any, List, Optional, Union
 
 import numpy as np
 
-from pandas._libs import NaT, iNaT, lib
-from pandas._libs.algos import unique_deltas
+from pandas._libs import NaT, iNaT, join as libjoin, lib
+from pandas._libs.tslibs import timezones
 from pandas.compat.numpy import function as nv
 from pandas.errors import AbstractMethodError
-from pandas.util._decorators import Appender, cache_readonly, deprecate_kwarg
+from pandas.util._decorators import Appender, cache_readonly
 
 from pandas.core.dtypes.common import (
     ensure_int64,
     is_bool_dtype,
+    is_categorical_dtype,
     is_dtype_equal,
     is_float,
     is_integer,
     is_list_like,
     is_period_dtype,
     is_scalar,
+    needs_i8_conversion,
 )
+from pandas.core.dtypes.concat import concat_compat
 from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
+from pandas.core.dtypes.missing import is_valid_nat_for_dtype, isna
 
-from pandas.core import algorithms, ops
-from pandas.core.accessor import PandasDelegate
-from pandas.core.arrays import ExtensionOpsMixin
-from pandas.core.arrays.datetimelike import (
-    DatetimeLikeArrayMixin,
-    _ensure_datetimelike_to_i8,
-)
+from pandas.core import algorithms
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
+from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+from pandas.core.base import _shared_docs
 import pandas.core.indexes.base as ibase
 from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.extension import (
+    ExtensionIndex,
+    inherit_names,
+    make_wrapped_arith_op,
+)
+from pandas.core.indexes.numeric import Int64Index
+from pandas.core.ops import get_op_result_name
 from pandas.core.tools.timedeltas import to_timedelta
 
-import pandas.io.formats.printing as printing
-from pandas.tseries.frequencies import to_offset
+from pandas.tseries.frequencies import DateOffset, to_offset
 
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 
 
-def ea_passthrough(array_method):
+def _join_i8_wrapper(joinf, with_indexers: bool = True):
     """
-    Make an alias for a method of the underlying ExtensionArray.
-
-    Parameters
-    ----------
-    array_method : method on an Array class
-
-    Returns
-    -------
-    method
+    Create the join wrapper methods.
     """
 
-    def method(self, *args, **kwargs):
-        return array_method(self._data, *args, **kwargs)
+    @staticmethod  # type: ignore
+    def wrapper(left, right):
+        if isinstance(left, (np.ndarray, ABCIndex, ABCSeries, DatetimeLikeArrayMixin)):
+            left = left.view("i8")
+        if isinstance(right, (np.ndarray, ABCIndex, ABCSeries, DatetimeLikeArrayMixin)):
+            right = right.view("i8")
 
-    method.__name__ = array_method.__name__
-    method.__doc__ = array_method.__doc__
-    return method
+        results = joinf(left, right)
+        if with_indexers:
+            # dtype should be timedelta64[ns] for TimedeltaIndex
+            #  and datetime64[ns] for DatetimeIndex
+            dtype = left.dtype.base
 
+            join_index, left_indexer, right_indexer = results
+            join_index = join_index.view(dtype)
+            return join_index, left_indexer, right_indexer
+        return results
 
-def _make_wrapped_arith_op(opname):
-    def method(self, other):
-        meth = getattr(self._data, opname)
-        result = meth(maybe_unwrap_index(other))
-        return wrap_arithmetic_op(self, other, result)
+    return wrapper
 
-    method.__name__ = opname
-    return method
 
-
-class DatetimeIndexOpsMixin(ExtensionOpsMixin):
+@inherit_names(
+    ["inferred_freq", "_isnan", "_resolution", "resolution"],
+    DatetimeLikeArrayMixin,
+    cache=True,
+)
+@inherit_names(
+    ["mean", "freq", "freqstr", "asi8", "_box_values", "_box_func"],
+    DatetimeLikeArrayMixin,
+)
+class DatetimeIndexOpsMixin(ExtensionIndex):
     """
-    common ops mixin to support a unified interface datetimelike Index
+    Common ops mixin to support a unified interface datetimelike Index.
     """
 
-    _data = None
+    _data: Union[DatetimeArray, TimedeltaArray, PeriodArray]
+    freq: Optional[DateOffset]
+    freqstr: Optional[str]
+    _resolution: int
+    _bool_ops: List[str] = []
+    _field_ops: List[str] = []
 
-    # DatetimeLikeArrayMixin assumes subclasses are mutable, so these are
-    # properties there.  They can be made into cache_readonly for Index
-    # subclasses bc they are immutable
-    inferred_freq = cache_readonly(
-        DatetimeLikeArrayMixin.inferred_freq.fget  # type: ignore
-    )
-    _isnan = cache_readonly(DatetimeLikeArrayMixin._isnan.fget)  # type: ignore
     hasnans = cache_readonly(DatetimeLikeArrayMixin._hasnans.fget)  # type: ignore
     _hasnans = hasnans  # for index / array -agnostic code
-    _resolution = cache_readonly(
-        DatetimeLikeArrayMixin._resolution.fget  # type: ignore
-    )
-    resolution = cache_readonly(DatetimeLikeArrayMixin.resolution.fget)  # type: ignore
-
-    _maybe_mask_results = ea_passthrough(DatetimeLikeArrayMixin._maybe_mask_results)
-    __iter__ = ea_passthrough(DatetimeLikeArrayMixin.__iter__)
-    mean = ea_passthrough(DatetimeLikeArrayMixin.mean)
 
     @property
-    def freq(self):
-        """
-        Return the frequency object if it is set, otherwise None.
-        """
-        return self._data.freq
-
-    @freq.setter
-    def freq(self, value):
-        # validation is handled by _data setter
-        self._data.freq = value
-
-    @property
-    def freqstr(self):
-        """
-        Return the frequency object as a string if it is set, otherwise None.
-        """
-        return self._data.freqstr
-
-    def unique(self, level=None):
-        if level is not None:
-            self._validate_index_level(level)
-
-        result = self._data.unique()
-
-        # Note: if `self` is already unique, then self.unique() should share
-        #  a `freq` with self.  If not already unique, then self.freq must be
-        #  None, so again sharing freq is correct.
-        return self._shallow_copy(result._data)
-
-    @classmethod
-    def _create_comparison_method(cls, op):
-        """
-        Create a comparison method that dispatches to ``cls.values``.
-        """
-
-        def wrapper(self, other):
-            if isinstance(other, ABCSeries):
-                # the arrays defer to Series for comparison ops but the indexes
-                #  don't, so we have to unwrap here.
-                other = other._values
-
-            result = op(self._data, maybe_unwrap_index(other))
-            return result
-
-        wrapper.__doc__ = op.__doc__
-        wrapper.__name__ = "__{}__".format(op.__name__)
-        return wrapper
-
-    @property
-    def _ndarray_values(self):
-        return self._data._ndarray_values
+    def is_all_dates(self) -> bool:
+        return True
 
     # ------------------------------------------------------------------------
     # Abstract data attributes
@@ -159,11 +110,6 @@ def values(self):
         # Note: PeriodArray overrides this to return an ndarray of objects.
         return self._data._data
 
-    @property  # type: ignore # https://github.com/python/mypy/issues/1362
-    @Appender(DatetimeLikeArrayMixin.asi8.__doc__)
-    def asi8(self):
-        return self._data.asi8
-
     def __array_wrap__(self, result, context=None):
         """
         Gets called after a ufunc.
@@ -180,7 +126,7 @@ def __array_wrap__(self, result, context=None):
 
     # ------------------------------------------------------------------------
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determines if two Index objects contain the same elements.
         """
@@ -192,89 +138,29 @@ def equals(self, other):
         elif not isinstance(other, type(self)):
             try:
                 other = type(self)(other)
-            except Exception:
+            except (ValueError, TypeError, OverflowError):
+                # e.g.
+                #  ValueError -> cannot parse str entry, or OutOfBoundsDatetime
+                #  TypeError  -> trying to convert IntervalIndex to DatetimeIndex
+                #  OverflowError -> Index([very_large_timedeltas])
                 return False
 
         if not is_dtype_equal(self.dtype, other.dtype):
             # have different timezone
             return False
 
-        elif is_period_dtype(self):
-            if not is_period_dtype(other):
-                return False
-            if self.freq != other.freq:
-                return False
-
         return np.array_equal(self.asi8, other.asi8)
 
-    @staticmethod
-    def _join_i8_wrapper(joinf, dtype, with_indexers=True):
-        """
-        Create the join wrapper methods.
-        """
-        from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
-
-        @staticmethod
-        def wrapper(left, right):
-            if isinstance(
-                left, (np.ndarray, ABCIndex, ABCSeries, DatetimeLikeArrayMixin)
-            ):
-                left = left.view("i8")
-            if isinstance(
-                right, (np.ndarray, ABCIndex, ABCSeries, DatetimeLikeArrayMixin)
-            ):
-                right = right.view("i8")
-            results = joinf(left, right)
-            if with_indexers:
-                join_index, left_indexer, right_indexer = results
-                join_index = join_index.view(dtype)
-                return join_index, left_indexer, right_indexer
-            return results
-
-        return wrapper
-
-    def _ensure_localized(
-        self, arg, ambiguous="raise", nonexistent="raise", from_utc=False
-    ):
-        # See DatetimeLikeArrayMixin._ensure_localized.__doc__
-        if getattr(self, "tz", None):
-            # ensure_localized is only relevant for tz-aware DTI
-            result = self._data._ensure_localized(
-                arg, ambiguous=ambiguous, nonexistent=nonexistent, from_utc=from_utc
-            )
-            return type(self)._simple_new(result, name=self.name)
-        return arg
-
-    def _box_values(self, values):
-        return self._data._box_values(values)
-
-    @Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
-    def __contains__(self, key):
+    @Appender(Index.__contains__.__doc__)
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
         try:
             res = self.get_loc(key)
-            return (
-                is_scalar(res)
-                or isinstance(res, slice)
-                or (is_list_like(res) and len(res))
-            )
         except (KeyError, TypeError, ValueError):
             return False
-
-    # Try to run function on index first, and then on elements of index
-    # Especially important for group-by functionality
-    def map(self, mapper, na_action=None):
-        try:
-            result = mapper(self)
-
-            # Try to use this result if we can
-            if isinstance(result, np.ndarray):
-                result = Index(result)
-
-            if not isinstance(result, Index):
-                raise TypeError("The map function must return an Index object")
-            return result
-        except Exception:
-            return self.astype(object).map(mapper)
+        return bool(
+            is_scalar(res) or isinstance(res, slice) or (is_list_like(res) and len(res))
+        )
 
     def sort_values(self, return_indexer=False, ascending=True):
         """
@@ -287,21 +173,25 @@ def sort_values(self, return_indexer=False, ascending=True):
             sorted_index = self.take(_as)
             return sorted_index, _as
         else:
-            sorted_values = np.sort(self._ndarray_values)
-            attribs = self._get_attributes_dict()
-            freq = attribs["freq"]
+            # NB: using asi8 instead of _ndarray_values matters in numpy 1.18
+            #  because the treatment of NaT has been changed to put NaT last
+            #  instead of first.
+            sorted_values = np.sort(self.asi8)
 
+            freq = self.freq
             if freq is not None and not is_period_dtype(self):
                 if freq.n > 0 and not ascending:
                     freq = freq * -1
                 elif freq.n < 0 and ascending:
                     freq = freq * -1
-            attribs["freq"] = freq
 
             if not ascending:
                 sorted_values = sorted_values[::-1]
 
-            return self._simple_new(sorted_values, **attribs)
+            arr = type(self._data)._simple_new(
+                sorted_values, dtype=self.dtype, freq=freq
+            )
+            return type(self)._simple_new(arr, name=self.name)
 
     @Appender(_index_shared_docs["take"] % _index_doc_kwargs)
     def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
@@ -312,40 +202,27 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
         if isinstance(maybe_slice, slice):
             return self[maybe_slice]
 
-        taken = self._assert_take_fillable(
-            self.asi8,
-            indices,
-            allow_fill=allow_fill,
-            fill_value=fill_value,
-            na_value=iNaT,
+        return ExtensionIndex.take(
+            self, indices, axis, allow_fill, fill_value, **kwargs
         )
 
-        # keep freq in PeriodArray/Index, reset otherwise
-        freq = self.freq if is_period_dtype(self) else None
-        return self._shallow_copy(taken, freq=freq)
+    @Appender(_shared_docs["searchsorted"])
+    def searchsorted(self, value, side="left", sorter=None):
+        if isinstance(value, str):
+            raise TypeError(
+                "searchsorted requires compatible dtype or scalar, "
+                f"not {type(value).__name__}"
+            )
+        if isinstance(value, Index):
+            value = value._data
+
+        return self._data.searchsorted(value, side=side, sorter=sorter)
 
     _can_hold_na = True
 
     _na_value = NaT
     """The expected NA value to use with this index."""
 
-    @property
-    def asobject(self):
-        """
-        Return object Index which contains boxed values.
-
-        .. deprecated:: 0.23.0
-            Use ``astype(object)`` instead.
-
-        *this is an internal non-public method*
-        """
-        warnings.warn(
-            "'asobject' is deprecated. Use 'astype(object)' instead",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.astype(object)
-
     def _convert_tolerance(self, tolerance, target):
         tolerance = np.asarray(to_timedelta(tolerance).to_numpy())
 
@@ -353,7 +230,7 @@ def _convert_tolerance(self, tolerance, target):
             raise ValueError("list-like tolerance size must match target index size")
         return tolerance
 
-    def tolist(self):
+    def tolist(self) -> List:
         """
         Return a list of the underlying data.
         """
@@ -492,13 +369,14 @@ def _format_attrs(self):
             if attrib == "freq":
                 freq = self.freqstr
                 if freq is not None:
-                    freq = "'%s'" % freq
+                    freq = repr(freq)
                 attrs.append(("freq", freq))
         return attrs
 
     # --------------------------------------------------------------------
+    # Indexing Methods
 
-    def _convert_scalar_indexer(self, key, kind=None):
+    def _convert_scalar_indexer(self, key, kind: str):
         """
         We don't allow integer or float indexing on datetime-like when using
         loc.
@@ -506,68 +384,94 @@ def _convert_scalar_indexer(self, key, kind=None):
         Parameters
         ----------
         key : label of the slice bound
-        kind : {'ix', 'loc', 'getitem', 'iloc'} or None
+        kind : {'loc', 'getitem'}
         """
 
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
+        assert kind in ["loc", "getitem"]
+
+        if not is_scalar(key):
+            raise TypeError(key)
 
         # we don't allow integer/float indexing for loc
-        # we don't allow float indexing for ix/getitem
-        if is_scalar(key):
-            is_int = is_integer(key)
-            is_flt = is_float(key)
-            if kind in ["loc"] and (is_int or is_flt):
-                self._invalid_indexer("index", key)
-            elif kind in ["ix", "getitem"] and is_flt:
-                self._invalid_indexer("index", key)
+        # we don't allow float indexing for getitem
+        is_int = is_integer(key)
+        is_flt = is_float(key)
+        if kind == "loc" and (is_int or is_flt):
+            self._invalid_indexer("label", key)
+        elif kind == "getitem" and is_flt:
+            self._invalid_indexer("label", key)
 
         return super()._convert_scalar_indexer(key, kind=kind)
 
-    @classmethod
-    def _add_datetimelike_methods(cls):
+    def _validate_partial_date_slice(self, reso: str):
+        raise NotImplementedError
+
+    def _parsed_string_to_bounds(self, reso: str, parsed: datetime):
+        raise NotImplementedError
+
+    def _partial_date_slice(
+        self, reso: str, parsed: datetime, use_lhs: bool = True, use_rhs: bool = True
+    ):
         """
-        Add in the datetimelike methods (as we may have to override the
-        superclass).
+        Parameters
+        ----------
+        reso : str
+        parsed : datetime
+        use_lhs : bool, default True
+        use_rhs : bool, default True
+
+        Returns
+        -------
+        slice or ndarray[intp]
         """
+        self._validate_partial_date_slice(reso)
 
-        def __add__(self, other):
-            # dispatch to ExtensionArray implementation
-            result = self._data.__add__(maybe_unwrap_index(other))
-            return wrap_arithmetic_op(self, other, result)
+        t1, t2 = self._parsed_string_to_bounds(reso, parsed)
+        i8vals = self.asi8
+        unbox = self._data._unbox_scalar
 
-        cls.__add__ = __add__
+        if self.is_monotonic:
 
-        def __radd__(self, other):
-            # alias for __add__
-            return self.__add__(other)
+            if len(self) and (
+                (use_lhs and t1 < self[0] and t2 < self[0])
+                or ((use_rhs and t1 > self[-1] and t2 > self[-1]))
+            ):
+                # we are out of range
+                raise KeyError
 
-        cls.__radd__ = __radd__
+            # TODO: does this depend on being monotonic _increasing_?
 
-        def __sub__(self, other):
-            # dispatch to ExtensionArray implementation
-            result = self._data.__sub__(maybe_unwrap_index(other))
-            return wrap_arithmetic_op(self, other, result)
+            # a monotonic (sorted) series can be sliced
+            # Use asi8.searchsorted to avoid re-validating Periods/Timestamps
+            left = i8vals.searchsorted(unbox(t1), side="left") if use_lhs else None
+            right = i8vals.searchsorted(unbox(t2), side="right") if use_rhs else None
+            return slice(left, right)
 
-        cls.__sub__ = __sub__
+        else:
+            lhs_mask = (i8vals >= unbox(t1)) if use_lhs else True
+            rhs_mask = (i8vals <= unbox(t2)) if use_rhs else True
 
-        def __rsub__(self, other):
-            result = self._data.__rsub__(maybe_unwrap_index(other))
-            return wrap_arithmetic_op(self, other, result)
+            # try to find the dates
+            return (lhs_mask & rhs_mask).nonzero()[0]
 
-        cls.__rsub__ = __rsub__
+    # --------------------------------------------------------------------
 
-    __pow__ = _make_wrapped_arith_op("__pow__")
-    __rpow__ = _make_wrapped_arith_op("__rpow__")
-    __mul__ = _make_wrapped_arith_op("__mul__")
-    __rmul__ = _make_wrapped_arith_op("__rmul__")
-    __floordiv__ = _make_wrapped_arith_op("__floordiv__")
-    __rfloordiv__ = _make_wrapped_arith_op("__rfloordiv__")
-    __mod__ = _make_wrapped_arith_op("__mod__")
-    __rmod__ = _make_wrapped_arith_op("__rmod__")
-    __divmod__ = _make_wrapped_arith_op("__divmod__")
-    __rdivmod__ = _make_wrapped_arith_op("__rdivmod__")
-    __truediv__ = _make_wrapped_arith_op("__truediv__")
-    __rtruediv__ = _make_wrapped_arith_op("__rtruediv__")
+    __add__ = make_wrapped_arith_op("__add__")
+    __radd__ = make_wrapped_arith_op("__radd__")
+    __sub__ = make_wrapped_arith_op("__sub__")
+    __rsub__ = make_wrapped_arith_op("__rsub__")
+    __pow__ = make_wrapped_arith_op("__pow__")
+    __rpow__ = make_wrapped_arith_op("__rpow__")
+    __mul__ = make_wrapped_arith_op("__mul__")
+    __rmul__ = make_wrapped_arith_op("__rmul__")
+    __floordiv__ = make_wrapped_arith_op("__floordiv__")
+    __rfloordiv__ = make_wrapped_arith_op("__rfloordiv__")
+    __mod__ = make_wrapped_arith_op("__mod__")
+    __rmod__ = make_wrapped_arith_op("__rmod__")
+    __divmod__ = make_wrapped_arith_op("__divmod__")
+    __rdivmod__ = make_wrapped_arith_op("__rdivmod__")
+    __truediv__ = make_wrapped_arith_op("__truediv__")
+    __rtruediv__ = make_wrapped_arith_op("__rtruediv__")
 
     def isin(self, values, level=None):
         """
@@ -593,108 +497,56 @@ def isin(self, values, level=None):
 
         return algorithms.isin(self.asi8, values.asi8)
 
-    def intersection(self, other, sort=False):
-        self._validate_sort_keyword(sort)
-        self._assert_can_do_setop(other)
-
-        if self.equals(other):
-            return self._get_reconciled_name_object(other)
-
-        if len(self) == 0:
-            return self.copy()
-        if len(other) == 0:
-            return other.copy()
-
-        if not isinstance(other, type(self)):
-            result = Index.intersection(self, other, sort=sort)
-            if isinstance(result, type(self)):
-                if result.freq is None:
-                    result.freq = to_offset(result.inferred_freq)
-            return result
-
-        elif (
-            other.freq is None
-            or self.freq is None
-            or other.freq != self.freq
-            or not other.freq.isAnchored()
-            or (not self.is_monotonic or not other.is_monotonic)
-        ):
-            result = Index.intersection(self, other, sort=sort)
+    @Appender(Index.where.__doc__)
+    def where(self, cond, other=None):
+        values = self.view("i8")
 
-            # Invalidate the freq of `result`, which may not be correct at
-            # this point, depending on the values.
-            result.freq = None
-            if hasattr(self, "tz"):
-                result = self._shallow_copy(
-                    result._values, name=result.name, tz=result.tz, freq=None
-                )
-            else:
-                result = self._shallow_copy(result._values, name=result.name, freq=None)
-            if result.freq is None:
-                result.freq = to_offset(result.inferred_freq)
-            return result
+        if is_scalar(other) and isna(other):
+            other = NaT.value
 
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
         else:
-            left, right = other, self
+            # Do type inference if necessary up front
+            # e.g. we passed PeriodIndex.values and got an ndarray of Periods
+            other = Index(other)
 
-        # after sorting, the intersection always starts with the right index
-        # and ends with the index of which the last elements is smallest
-        end = min(left[-1], right[-1])
-        start = right[0]
+            if is_categorical_dtype(other):
+                # e.g. we have a Categorical holding self.dtype
+                if needs_i8_conversion(other.categories):
+                    other = other._internal_get_values()
 
-        if end < start:
-            return type(self)(data=[])
-        else:
-            lslice = slice(*left.slice_locs(start, end))
-            left_chunk = left.values[lslice]
-            return self._shallow_copy(left_chunk)
+            if not is_dtype_equal(self.dtype, other.dtype):
+                raise TypeError(f"Where requires matching dtype, not {other.dtype}")
 
-    @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
-    def repeat(self, repeats, axis=None):
-        nv.validate_repeat(tuple(), dict(axis=axis))
-        freq = self.freq if is_period_dtype(self) else None
-        return self._shallow_copy(self.asi8.repeat(repeats), freq=freq)
+            other = other.view("i8")
 
-    @Appender(_index_shared_docs["where"] % _index_doc_kwargs)
-    def where(self, cond, other=None):
-        other = _ensure_datetimelike_to_i8(other, to_utc=True)
-        values = _ensure_datetimelike_to_i8(self, to_utc=True)
         result = np.where(cond, values, other).astype("i8")
-
-        result = self._ensure_localized(result, from_utc=True)
         return self._shallow_copy(result)
 
-    def _summary(self, name=None):
+    def _summary(self, name=None) -> str:
         """
         Return a summarized representation.
 
         Parameters
         ----------
         name : str
-            name to use in the summary representation
+            Name to use in the summary representation.
 
         Returns
         -------
-        String with a summarized representation of the index
+        str
+            Summarized representation of the index.
         """
         formatter = self._formatter_func
         if len(self) > 0:
-            index_summary = ", %s to %s" % (formatter(self[0]), formatter(self[-1]))
+            index_summary = f", {formatter(self[0])} to {formatter(self[-1])}"
         else:
             index_summary = ""
 
         if name is None:
             name = type(self).__name__
-        result = "%s: %s entries%s" % (
-            printing.pprint_thing(name),
-            len(self),
-            index_summary,
-        )
+        result = f"{name}: {len(self)} entries{index_summary}"
         if self.freq:
-            result += "\nFreq: %s" % self.freqstr
+            result += f"\nFreq: {self.freqstr}"
 
         # display as values, not quoted
         result = result.replace("'", "")
@@ -704,37 +556,12 @@ def _concat_same_dtype(self, to_concat, name):
         """
         Concatenate to_concat which has the same class.
         """
-        attribs = self._get_attributes_dict()
-        attribs["name"] = name
-        # do not pass tz to set because tzlocal cannot be hashed
-        if len({str(x.dtype) for x in to_concat}) != 1:
-            raise ValueError("to_concat must have the same tz")
-
-        new_data = type(self._values)._concat_same_type(to_concat).asi8
-
-        # GH 3232: If the concat result is evenly spaced, we can retain the
-        # original frequency
-        is_diff_evenly_spaced = len(unique_deltas(new_data)) == 1
-        if not is_period_dtype(self) and not is_diff_evenly_spaced:
-            # reset freq
-            attribs["freq"] = None
 
-        return self._simple_new(new_data, **attribs)
+        new_data = type(self._data)._concat_same_type(to_concat)
 
-    @Appender(_index_shared_docs["astype"])
-    def astype(self, dtype, copy=True):
-        if is_dtype_equal(self.dtype, dtype) and copy is False:
-            # Ensure that self.astype(self.dtype) is self
-            return self
+        return self._simple_new(new_data, name=name)
 
-        new_values = self._data.astype(dtype, copy=copy)
-
-        # pass copy=False because any copying will be done in the
-        #  _data.astype call above
-        return Index(new_values, dtype=new_values.dtype, name=self.name, copy=False)
-
-    @deprecate_kwarg(old_arg_name="n", new_arg_name="periods")
-    def shift(self, periods, freq=None):
+    def shift(self, periods=1, freq=None):
         """
         Shift index by desired number of time frequency increments.
 
@@ -743,7 +570,7 @@ def shift(self, periods, freq=None):
 
         Parameters
         ----------
-        periods : int
+        periods : int, default 1
             Number of periods (or increments) to shift by,
             can be positive or negative.
 
@@ -767,88 +594,396 @@ def shift(self, periods, freq=None):
         result = self._data._time_shift(periods, freq=freq)
         return type(self)(result, name=self.name)
 
+    # --------------------------------------------------------------------
+    # List-like Methods
 
-def wrap_arithmetic_op(self, other, result):
-    if result is NotImplemented:
-        return NotImplemented
-
-    if isinstance(result, tuple):
-        # divmod, rdivmod
-        assert len(result) == 2
-        return (
-            wrap_arithmetic_op(self, other, result[0]),
-            wrap_arithmetic_op(self, other, result[1]),
-        )
+    def delete(self, loc):
+        new_i8s = np.delete(self.asi8, loc)
 
-    if not isinstance(result, Index):
-        # Index.__new__ will choose appropriate subclass for dtype
-        result = Index(result)
+        freq = None
+        if is_period_dtype(self):
+            freq = self.freq
+        elif is_integer(loc):
+            if loc in (0, -len(self), -1, len(self) - 1):
+                freq = self.freq
+        else:
+            if is_list_like(loc):
+                loc = lib.maybe_indices_to_slice(ensure_int64(np.array(loc)), len(self))
+            if isinstance(loc, slice) and loc.step in (1, None):
+                if loc.start in (0, None) or loc.stop in (len(self), None):
+                    freq = self.freq
 
-    res_name = ops.get_op_result_name(self, other)
-    result.name = res_name
-    return result
+        arr = type(self._data)._simple_new(new_i8s, dtype=self.dtype, freq=freq)
+        return type(self)._simple_new(arr, name=self.name)
 
 
-def maybe_unwrap_index(obj):
+class DatetimeTimedeltaMixin(DatetimeIndexOpsMixin, Int64Index):
+    """
+    Mixin class for methods shared by DatetimeIndex and TimedeltaIndex,
+    but not PeriodIndex
     """
-    If operating against another Index object, we need to unwrap the underlying
-    data before deferring to the DatetimeArray/TimedeltaArray/PeriodArray
-    implementation, otherwise we will incorrectly return NotImplemented.
 
-    Parameters
-    ----------
-    obj : object
+    # Compat for frequency inference, see GH#23789
+    _is_monotonic_increasing = Index.is_monotonic_increasing
+    _is_monotonic_decreasing = Index.is_monotonic_decreasing
+    _is_unique = Index.is_unique
 
-    Returns
-    -------
-    unwrapped object
-    """
-    if isinstance(obj, ABCIndexClass):
-        return obj._data
-    return obj
+    def _set_freq(self, freq):
+        """
+        Set the _freq attribute on our underlying DatetimeArray.
 
+        Parameters
+        ----------
+        freq : DateOffset, None, or "infer"
+        """
+        # GH#29843
+        if freq is None:
+            # Always valid
+            pass
+        elif len(self) == 0 and isinstance(freq, DateOffset):
+            # Always valid.  In the TimedeltaIndex case, we assume this
+            #  is a Tick offset.
+            pass
+        else:
+            # As an internal method, we can ensure this assertion always holds
+            assert freq == "infer"
+            freq = to_offset(self.inferred_freq)
 
-class DatetimelikeDelegateMixin(PandasDelegate):
-    """
-    Delegation mechanism, specific for Datetime, Timedelta, and Period types.
-
-    Functionality is delegated from the Index class to an Array class. A
-    few things can be customized
-
-    * _delegate_class : type
-        The class being delegated to.
-    * _delegated_methods, delegated_properties : List
-        The list of property / method names being delagated.
-    * raw_methods : Set
-        The set of methods whose results should should *not* be
-        boxed in an index, after being returned from the array
-    * raw_properties : Set
-        The set of properties whose results should should *not* be
-        boxed in an index, after being returned from the array
-    """
+        self._data._freq = freq
 
-    # raw_methods : dispatch methods that shouldn't be boxed in an Index
-    _raw_methods = set()  # type: Set[str]
-    # raw_properties : dispatch properties that shouldn't be boxed in an Index
-    _raw_properties = set()  # type: Set[str]
-    name = None
-    _data = None
+    def _shallow_copy(self, values=None, **kwargs):
+        if values is None:
+            values = self._data
 
-    @property
-    def _delegate_class(self):
-        raise AbstractMethodError
+        if isinstance(values, type(self)):
+            values = values._data
+        if isinstance(values, np.ndarray):
+            # TODO: We would rather not get here
+            if kwargs.get("freq") is not None:
+                raise ValueError(kwargs)
+            values = type(self._data)(values, dtype=self.dtype)
 
-    def _delegate_property_get(self, name, *args, **kwargs):
-        result = getattr(self._data, name)
-        if name not in self._raw_properties:
-            result = Index(result, name=self.name)
-        return result
+        attributes = self._get_attributes_dict()
 
-    def _delegate_property_set(self, name, value, *args, **kwargs):
-        setattr(self._data, name, value)
+        if "freq" not in kwargs and self.freq is not None:
+            if isinstance(values, (DatetimeArray, TimedeltaArray)):
+                if values.freq is None:
+                    del attributes["freq"]
 
-    def _delegate_method(self, name, *args, **kwargs):
-        result = operator.methodcaller(name, *args, **kwargs)(self._data)
-        if name not in self._raw_methods:
-            result = Index(result, name=self.name)
-        return result
+        attributes.update(kwargs)
+        return type(self)._simple_new(values, **attributes)
+
+    # --------------------------------------------------------------------
+    # Set Operation Methods
+
+    @Appender(Index.difference.__doc__)
+    def difference(self, other, sort=None):
+        new_idx = super().difference(other, sort=sort)
+        new_idx._set_freq(None)
+        return new_idx
+
+    def intersection(self, other, sort=False):
+        """
+        Specialized intersection for DatetimeIndex/TimedeltaIndex.
+
+        May be much faster than Index.intersection
+
+        Parameters
+        ----------
+        other : Same type as self or array-like
+        sort : False or None, default False
+            Sort the resulting index if possible.
+
+            .. versionadded:: 0.24.0
+
+            .. versionchanged:: 0.24.1
+
+               Changed the default to ``False`` to match the behaviour
+               from before 0.24.0.
+
+            .. versionchanged:: 0.25.0
+
+               The `sort` keyword is added
+
+        Returns
+        -------
+        y : Index or same type as self
+        """
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+
+        if self.equals(other):
+            return self._get_reconciled_name_object(other)
+
+        if len(self) == 0:
+            return self.copy()
+        if len(other) == 0:
+            return other.copy()
+
+        if not isinstance(other, type(self)):
+            result = Index.intersection(self, other, sort=sort)
+            if isinstance(result, type(self)):
+                if result.freq is None:
+                    result._set_freq("infer")
+            return result
+
+        elif (
+            other.freq is None
+            or self.freq is None
+            or other.freq != self.freq
+            or not other.freq.is_anchored()
+            or (not self.is_monotonic or not other.is_monotonic)
+        ):
+            result = Index.intersection(self, other, sort=sort)
+
+            # Invalidate the freq of `result`, which may not be correct at
+            # this point, depending on the values.
+
+            result._set_freq(None)
+            result = self._shallow_copy(
+                result._data, name=result.name, dtype=result.dtype, freq=None
+            )
+            if result.freq is None:
+                result._set_freq("infer")
+            return result
+
+        # to make our life easier, "sort" the two ranges
+        if self[0] <= other[0]:
+            left, right = self, other
+        else:
+            left, right = other, self
+
+        # after sorting, the intersection always starts with the right index
+        # and ends with the index of which the last elements is smallest
+        end = min(left[-1], right[-1])
+        start = right[0]
+
+        if end < start:
+            return type(self)(data=[])
+        else:
+            lslice = slice(*left.slice_locs(start, end))
+            left_chunk = left.values[lslice]
+            return self._shallow_copy(left_chunk)
+
+    def _can_fast_union(self, other) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+
+        freq = self.freq
+
+        if freq is None or freq != other.freq:
+            return False
+
+        if not self.is_monotonic or not other.is_monotonic:
+            return False
+
+        if len(self) == 0 or len(other) == 0:
+            return True
+
+        # to make our life easier, "sort" the two ranges
+        if self[0] <= other[0]:
+            left, right = self, other
+        else:
+            left, right = other, self
+
+        right_start = right[0]
+        left_end = left[-1]
+
+        # Only need to "adjoin", not overlap
+        try:
+            return (right_start == left_end + freq) or right_start in left
+        except ValueError:
+            # if we are comparing a freq that does not propagate timezones
+            # this will raise
+            return False
+
+    def _fast_union(self, other, sort=None):
+        if len(other) == 0:
+            return self.view(type(self))
+
+        if len(self) == 0:
+            return other.view(type(self))
+
+        # to make our life easier, "sort" the two ranges
+        if self[0] <= other[0]:
+            left, right = self, other
+        elif sort is False:
+            # TDIs are not in the "correct" order and we don't want
+            #  to sort but want to remove overlaps
+            left, right = self, other
+            left_start = left[0]
+            loc = right.searchsorted(left_start, side="left")
+            right_chunk = right.values[:loc]
+            dates = concat_compat((left.values, right_chunk))
+            return self._shallow_copy(dates)
+        else:
+            left, right = other, self
+
+        left_end = left[-1]
+        right_end = right[-1]
+
+        # concatenate
+        if left_end < right_end:
+            loc = right.searchsorted(left_end, side="right")
+            right_chunk = right.values[loc:]
+            dates = concat_compat((left.values, right_chunk))
+            return self._shallow_copy(dates)
+        else:
+            return left
+
+    def _union(self, other, sort):
+        if not len(other) or self.equals(other) or not len(self):
+            return super()._union(other, sort=sort)
+
+        # We are called by `union`, which is responsible for this validation
+        assert isinstance(other, type(self))
+
+        this, other = self._maybe_utc_convert(other)
+
+        if this._can_fast_union(other):
+            result = this._fast_union(other, sort=sort)
+            if result.freq is None:
+                result._set_freq("infer")
+            return result
+        else:
+            i8self = Int64Index._simple_new(self.asi8, name=self.name)
+            i8other = Int64Index._simple_new(other.asi8, name=other.name)
+            i8result = i8self._union(i8other, sort=sort)
+            result = type(self)(i8result, dtype=self.dtype, freq="infer")
+            return result
+
+    # --------------------------------------------------------------------
+    # Join Methods
+    _join_precedence = 10
+
+    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer)
+    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer)
+    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer)
+    _left_indexer_unique = _join_i8_wrapper(
+        libjoin.left_join_indexer_unique, with_indexers=False
+    )
+
+    def join(
+        self, other, how: str = "left", level=None, return_indexers=False, sort=False
+    ):
+        """
+        See Index.join
+        """
+        if self._is_convertible_to_index_for_join(other):
+            try:
+                other = type(self)(other)
+            except (TypeError, ValueError):
+                pass
+
+        this, other = self._maybe_utc_convert(other)
+        return Index.join(
+            this,
+            other,
+            how=how,
+            level=level,
+            return_indexers=return_indexers,
+            sort=sort,
+        )
+
+    def _maybe_utc_convert(self, other):
+        this = self
+        if not hasattr(self, "tz"):
+            return this, other
+
+        if isinstance(other, type(self)):
+            if self.tz is not None:
+                if other.tz is None:
+                    raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
+            elif other.tz is not None:
+                raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
+
+            if not timezones.tz_compare(self.tz, other.tz):
+                this = self.tz_convert("UTC")
+                other = other.tz_convert("UTC")
+        return this, other
+
+    @classmethod
+    def _is_convertible_to_index_for_join(cls, other: Index) -> bool:
+        """
+        return a boolean whether I can attempt conversion to a
+        DatetimeIndex/TimedeltaIndex
+        """
+        if isinstance(other, cls):
+            return False
+        elif len(other) > 0 and other.inferred_type not in (
+            "floating",
+            "mixed-integer",
+            "integer",
+            "integer-na",
+            "mixed-integer-float",
+            "mixed",
+        ):
+            return True
+        return False
+
+    def _wrap_joined_index(self, joined, other):
+        name = get_op_result_name(self, other)
+        if self._can_fast_union(other):
+            joined = self._shallow_copy(joined)
+            joined.name = name
+            return joined
+        else:
+            kwargs = {}
+            if hasattr(self, "tz"):
+                kwargs["tz"] = getattr(other, "tz", None)
+            return type(self)._simple_new(joined, name, **kwargs)
+
+    # --------------------------------------------------------------------
+    # List-Like Methods
+
+    def insert(self, loc, item):
+        """
+        Make new Index inserting new item at location
+        Parameters
+        ----------
+        loc : int
+        item : object
+            if not either a Python datetime or a numpy integer-like, returned
+            Index dtype will be object rather than datetime.
+        Returns
+        -------
+        new_index : Index
+        """
+        if isinstance(item, self._data._recognized_scalars):
+            item = self._data._scalar_type(item)
+        elif is_valid_nat_for_dtype(item, self.dtype):
+            # GH 18295
+            item = self._na_value
+        elif is_scalar(item) and isna(item):
+            raise TypeError(
+                f"cannot insert {type(self).__name__} with incompatible label"
+            )
+
+        freq = None
+        if isinstance(item, self._data._scalar_type) or item is NaT:
+            self._data._check_compatible_with(item, setitem=True)
+
+            # check freq can be preserved on edge cases
+            if self.size and self.freq is not None:
+                if item is NaT:
+                    pass
+                elif (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
+                    freq = self.freq
+                elif (loc == len(self)) and item - self.freq == self[-1]:
+                    freq = self.freq
+            item = item.asm8
+
+        try:
+            new_i8s = np.concatenate(
+                (self[:loc].asi8, [item.view(np.int64)], self[loc:].asi8)
+            )
+            arr = type(self._data)._simple_new(new_i8s, dtype=self.dtype, freq=freq)
+            return type(self)._simple_new(arr, name=self.name)
+        except (AttributeError, TypeError):
+
+            # fall back to object index
+            if isinstance(item, str):
+                return self.astype(object).insert(loc, item)
+            raise TypeError(
+                f"cannot insert {type(self).__name__} with incompatible label"
+            )
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index cce390d98c037..b67d0dcea0ac6 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -1,100 +1,82 @@
-from datetime import datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, tzinfo
 import operator
+from typing import Optional
 import warnings
 
 import numpy as np
 
-from pandas._libs import NaT, Timestamp, index as libindex, lib, tslib as libts
-import pandas._libs.join as libjoin
-from pandas._libs.tslibs import ccalendar, fields, parsing, timezones
-from pandas.util._decorators import Appender, Substitution, cache_readonly
-
-from pandas.core.dtypes.common import (
-    _NS_DTYPE,
-    ensure_int64,
-    is_float,
-    is_integer,
-    is_list_like,
-    is_scalar,
-    is_string_like,
-)
-from pandas.core.dtypes.concat import concat_compat
+from pandas._libs import NaT, Period, Timestamp, index as libindex, lib, tslib as libts
+from pandas._libs.tslibs import fields, parsing, timezones
+from pandas.util._decorators import cache_readonly
+
+from pandas.core.dtypes.common import _NS_DTYPE, is_float, is_integer, is_scalar
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
-from pandas.core.dtypes.missing import isna
+from pandas.core.dtypes.missing import is_valid_nat_for_dtype
 
-from pandas.core.accessor import delegate_names
 from pandas.core.arrays.datetimes import (
     DatetimeArray,
-    _to_M8,
     tz_to_dtype,
     validate_tz_from_dtype,
 )
-from pandas.core.base import _shared_docs
 import pandas.core.common as com
-from pandas.core.indexes.base import Index
-from pandas.core.indexes.datetimelike import (
-    DatetimeIndexOpsMixin,
-    DatetimelikeDelegateMixin,
-    ea_passthrough,
-)
-from pandas.core.indexes.numeric import Int64Index
-from pandas.core.ops import get_op_result_name
+from pandas.core.indexes.base import Index, InvalidIndexError, maybe_extract_name
+from pandas.core.indexes.datetimelike import DatetimeTimedeltaMixin
+from pandas.core.indexes.extension import inherit_names
 import pandas.core.tools.datetimes as tools
 
 from pandas.tseries.frequencies import Resolution, to_offset
-from pandas.tseries.offsets import Nano, prefix_mapping
+from pandas.tseries.offsets import prefix_mapping
 
 
 def _new_DatetimeIndex(cls, d):
-    """ This is called upon unpickling, rather than the default which doesn't
-    have arguments and breaks __new__ """
-
+    """
+    This is called upon unpickling, rather than the default which doesn't
+    have arguments and breaks __new__
+    """
     if "data" in d and not isinstance(d["data"], DatetimeIndex):
         # Avoid need to verify integrity by calling simple_new directly
         data = d.pop("data")
         result = cls._simple_new(data, **d)
     else:
         with warnings.catch_warnings():
-            # we ignore warnings from passing verify_integrity=False
             # TODO: If we knew what was going in to **d, we might be able to
             #  go through _simple_new instead
             warnings.simplefilter("ignore")
-            result = cls.__new__(cls, verify_integrity=False, **d)
+            result = cls.__new__(cls, **d)
 
     return result
 
 
-class DatetimeDelegateMixin(DatetimelikeDelegateMixin):
-    # Most attrs are dispatched via datetimelike_{ops,methods}
-    # Some are "raw" methods, the result is not not re-boxed in an Index
-    # We also have a few "extra" attrs, which may or may not be raw,
-    # which we we dont' want to expose in the .dt accessor.
-    _extra_methods = ["to_period", "to_perioddelta", "to_julian_date", "strftime"]
-    _extra_raw_methods = ["to_pydatetime", "_local_timestamps", "_has_same_tz"]
-    _extra_raw_properties = ["_box_func", "tz", "tzinfo"]
-    _delegated_properties = DatetimeArray._datetimelike_ops + _extra_raw_properties
-    _delegated_methods = (
-        DatetimeArray._datetimelike_methods + _extra_methods + _extra_raw_methods
-    )
-    _raw_properties = (
-        {"date", "time", "timetz"}
-        | set(DatetimeArray._bool_ops)
-        | set(_extra_raw_properties)
-    )
-    _raw_methods = set(_extra_raw_methods)
-    _delegate_class = DatetimeArray
-
-
-@delegate_names(
-    DatetimeArray, DatetimeDelegateMixin._delegated_properties, typ="property"
+@inherit_names(
+    ["to_period", "to_perioddelta", "to_julian_date", "strftime"]
+    + DatetimeArray._field_ops
+    + DatetimeArray._datetimelike_methods,
+    DatetimeArray,
+    wrap=True,
 )
-@delegate_names(
+@inherit_names(["_timezone", "is_normalized", "_resolution"], DatetimeArray, cache=True)
+@inherit_names(
+    [
+        "_bool_ops",
+        "_object_ops",
+        "_field_ops",
+        "_datetimelike_ops",
+        "_datetimelike_methods",
+        "tz",
+        "tzinfo",
+        "dtype",
+        "to_pydatetime",
+        "_local_timestamps",
+        "_has_same_tz",
+        "_format_native_types",
+        "date",
+        "time",
+        "timetz",
+    ]
+    + DatetimeArray._bool_ops,
     DatetimeArray,
-    DatetimeDelegateMixin._delegated_methods,
-    typ="method",
-    overwrite=False,
 )
-class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
+class DatetimeIndex(DatetimeTimedeltaMixin):
     """
     Immutable ndarray of datetime64 data, represented internally as int64, and
     which can be boxed to Timestamp objects that are subclasses of datetime and
@@ -102,39 +84,14 @@ class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
 
     Parameters
     ----------
-    data  : array-like (1-dimensional), optional
-        Optional datetime-like data to construct index with
-    copy  : bool
-        Make a copy of input ndarray
-    freq : string or pandas offset object, optional
+    data : array-like (1-dimensional), optional
+        Optional datetime-like data to construct index with.
+    copy : bool
+        Make a copy of input ndarray.
+    freq : str or pandas offset object, optional
         One of pandas date offset strings or corresponding objects. The string
         'infer' can be passed in order to set the frequency of the index as the
-        inferred frequency upon creation
-
-    start : starting value, datetime-like, optional
-        If data is None, start is used as the start point in generating regular
-        timestamp data.
-
-        .. deprecated:: 0.24.0
-
-    periods  : int, optional, > 0
-        Number of periods to generate, if generating index. Takes precedence
-        over end argument
-
-        .. deprecated:: 0.24.0
-
-    end : end time, datetime-like, optional
-        If periods is none, generated index will extend to first conforming
-        time on or just past end argument
-
-        .. deprecated:: 0.24.0
-
-    closed : string or None, default None
-        Make the interval closed with respect to the given frequency to
-        the 'left', 'right', or both sides (None)
-
-        .. deprecated:: 0.24. 0
-
+        inferred frequency upon creation.
     tz : pytz.timezone or dateutil.tz.tzfile
     ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
         When clocks moved backward due to DST, ambiguous times may arise.
@@ -149,13 +106,13 @@ class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
           non-DST time (note that this flag is only applicable for ambiguous
           times)
         - 'NaT' will return NaT where there are ambiguous times
-        - 'raise' will raise an AmbiguousTimeError if there are ambiguous times
+        - 'raise' will raise an AmbiguousTimeError if there are ambiguous times.
     name : object
-        Name to be stored in the index
+        Name to be stored in the index.
     dayfirst : bool, default False
-        If True, parse dates in `data` with the day first order
+        If True, parse dates in `data` with the day first order.
     yearfirst : bool, default False
-        If True parse dates in `data` with the year first order
+        If True parse dates in `data` with the year first order.
 
     Attributes
     ----------
@@ -218,44 +175,22 @@ class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
     Notes
     -----
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
-
-    Creating a DatetimeIndex based on `start`, `periods`, and `end` has
-    been deprecated in favor of :func:`date_range`.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
     """
 
     _typ = "datetimeindex"
-    _join_precedence = 10
-
-    def _join_i8_wrapper(joinf, **kwargs):
-        return DatetimeIndexOpsMixin._join_i8_wrapper(joinf, dtype="M8[ns]", **kwargs)
-
-    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer_int64)
-    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer_int64)
-    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer_int64)
-    _left_indexer_unique = _join_i8_wrapper(
-        libjoin.left_join_indexer_unique_int64, with_indexers=False
-    )
 
     _engine_type = libindex.DatetimeEngine
     _supports_partial_string_indexing = True
 
-    _tz = None
-    _freq = None
     _comparables = ["name", "freqstr", "tz"]
     _attributes = ["name", "tz", "freq"]
 
     _is_numeric_dtype = False
     _infer_as_myclass = True
 
-    # Use faster implementation given we know we have DatetimeArrays
-    __iter__ = DatetimeArray.__iter__
-    # some things like freq inference make use of these attributes.
-    _bool_ops = DatetimeArray._bool_ops
-    _object_ops = DatetimeArray._object_ops
-    _field_ops = DatetimeArray._field_ops
-    _datetimelike_ops = DatetimeArray._datetimelike_ops
-    _datetimelike_methods = DatetimeArray._datetimelike_methods
+    _data: DatetimeArray
+    tz: Optional[tzinfo]
 
     # --------------------------------------------------------------------
     # Constructors
@@ -264,9 +199,6 @@ def __new__(
         cls,
         data=None,
         freq=None,
-        start=None,
-        end=None,
-        periods=None,
         tz=None,
         normalize=False,
         closed=None,
@@ -276,51 +208,17 @@ def __new__(
         dtype=None,
         copy=False,
         name=None,
-        verify_integrity=None,
     ):
 
-        if verify_integrity is not None:
-            warnings.warn(
-                "The 'verify_integrity' argument is deprecated, "
-                "will be removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-        else:
-            verify_integrity = True
-
-        if data is None:
-            dtarr = DatetimeArray._generate_range(
-                start,
-                end,
-                periods,
-                freq=freq,
-                tz=tz,
-                normalize=normalize,
-                closed=closed,
-                ambiguous=ambiguous,
-            )
-            warnings.warn(
-                "Creating a DatetimeIndex by passing range "
-                "endpoints is deprecated.  Use "
-                "`pandas.date_range` instead.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            return cls._simple_new(dtarr._data, freq=dtarr.freq, tz=dtarr.tz, name=name)
-
         if is_scalar(data):
             raise TypeError(
-                "{cls}() must be called with a "
-                "collection of some kind, {data} was passed".format(
-                    cls=cls.__name__, data=repr(data)
-                )
+                f"{cls.__name__}() must be called with a "
+                f"collection of some kind, {repr(data)} was passed"
             )
 
         # - Cases checked above all return/raise before reaching here - #
 
-        if name is None and hasattr(data, "name"):
-            name = data.name
+        name = maybe_extract_name(name, data, cls)
 
         dtarr = DatetimeArray._from_sequence(
             data,
@@ -331,16 +229,15 @@ def __new__(
             dayfirst=dayfirst,
             yearfirst=yearfirst,
             ambiguous=ambiguous,
-            int_as_wall_time=True,
         )
 
-        subarr = cls._simple_new(dtarr, name=name, freq=dtarr.freq, tz=dtarr.tz)
+        subarr = cls._simple_new(dtarr, name=name)
         return subarr
 
     @classmethod
     def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
         """
-        we require the we have a dtype compat for the values
+        We require the we have a dtype compat for the values
         if we are passed a non-dtype compat, then coerce using the constructor
         """
         if isinstance(values, DatetimeArray):
@@ -355,10 +252,6 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
             freq = values.freq
             values = values._data
 
-        # DatetimeArray._simple_new will accept either i8 or M8[ns] dtypes
-        if isinstance(values, DatetimeIndex):
-            values = values._data
-
         dtype = tz_to_dtype(tz)
         dtarr = DatetimeArray._simple_new(values, freq=freq, dtype=dtype)
         assert isinstance(dtarr, DatetimeArray)
@@ -366,6 +259,7 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
         result = object.__new__(cls)
         result._data = dtarr
         result.name = name
+        result._no_setting_name = False
         # For groupby perf. See note in indexes/base about _index_data
         result._index_data = dtarr._data
         result._reset_identity()
@@ -373,46 +267,18 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
 
     # --------------------------------------------------------------------
 
-    def __array__(self, dtype=None):
-        if (
-            dtype is None
-            and isinstance(self._data, DatetimeArray)
-            and getattr(self.dtype, "tz", None)
-        ):
-            msg = (
-                "Converting timezone-aware DatetimeArray to timezone-naive "
-                "ndarray with 'datetime64[ns]' dtype. In the future, this "
-                "will return an ndarray with 'object' dtype where each "
-                "element is a 'pandas.Timestamp' with the correct 'tz'.\n\t"
-                "To accept the future behavior, pass 'dtype=object'.\n\t"
-                "To keep the old behavior, pass 'dtype=\"datetime64[ns]\"'."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=3)
-            dtype = "M8[ns]"
+    def __array__(self, dtype=None) -> np.ndarray:
         return np.asarray(self._data, dtype=dtype)
 
-    @property
-    def dtype(self):
-        return self._data.dtype
-
-    @property
-    def tz(self):
-        # GH 18595
-        return self._data.tz
-
-    @tz.setter
-    def tz(self, value):
-        # GH 3746: Prevent localizing or converting the index by setting tz
-        raise AttributeError(
-            "Cannot directly set timezone. Use tz_localize() "
-            "or tz_convert() as appropriate"
-        )
-
-    tzinfo = tz
-
     @cache_readonly
-    def _is_dates_only(self):
-        """Return a boolean if we are only dates (and don't have a timezone)"""
+    def _is_dates_only(self) -> bool:
+        """
+        Return a boolean if we are only dates (and don't have a timezone)
+
+        Returns
+        -------
+        bool
+        """
         from pandas.io.formats.format import _is_dates_only
 
         return _is_dates_only(self.values) and self.tz is None
@@ -424,45 +290,14 @@ def __reduce__(self):
 
         d = dict(data=self._data)
         d.update(self._get_attributes_dict())
-        return _new_DatetimeIndex, (self.__class__, d), None
-
-    def __setstate__(self, state):
-        """Necessary for making this object picklable"""
-        if isinstance(state, dict):
-            super().__setstate__(state)
-
-        elif isinstance(state, tuple):
-
-            # < 0.15 compat
-            if len(state) == 2:
-                nd_state, own_state = state
-                data = np.empty(nd_state[1], dtype=nd_state[2])
-                np.ndarray.__setstate__(data, nd_state)
-
-                freq = own_state[1]
-                tz = timezones.tz_standardize(own_state[2])
-                dtype = tz_to_dtype(tz)
-                dtarr = DatetimeArray._simple_new(data, freq=freq, dtype=dtype)
-
-                self.name = own_state[0]
-
-            else:  # pragma: no cover
-                data = np.empty(state)
-                np.ndarray.__setstate__(data, state)
-                dtarr = DatetimeArray(data)
-
-            self._data = dtarr
-            self._reset_identity()
-
-        else:
-            raise Exception("invalid pickle state")
-
-    _unpickle_compat = __setstate__
+        return _new_DatetimeIndex, (type(self), d), None
 
     def _convert_for_op(self, value):
-        """ Convert value to be insertable to ndarray """
+        """
+        Convert value to be insertable to ndarray.
+        """
         if self._has_same_tz(value):
-            return _to_M8(value)
+            return Timestamp(value).asm8
         raise ValueError("Passed item and index have different timezone")
 
     # --------------------------------------------------------------------
@@ -472,57 +307,19 @@ def _mpl_repr(self):
         # how to represent ourselves to matplotlib
         return libts.ints_to_pydatetime(self.asi8, self.tz)
 
-    def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
-        from pandas.io.formats.format import _get_format_datetime64_from_values
-
-        fmt = _get_format_datetime64_from_values(self, date_format)
-
-        return libts.format_array_from_datetime(
-            self.asi8, tz=self.tz, format=fmt, na_rep=na_rep
-        )
-
     @property
     def _formatter_func(self):
         from pandas.io.formats.format import _get_format_datetime64
 
         formatter = _get_format_datetime64(is_dates_only=self._is_dates_only)
-        return lambda x: "'%s'" % formatter(x, tz=self.tz)
+        return lambda x: f"'{formatter(x, tz=self.tz)}'"
 
     # --------------------------------------------------------------------
     # Set Operation Methods
 
-    def _union(self, other, sort):
-        if not len(other) or self.equals(other) or not len(self):
-            return super()._union(other, sort=sort)
-
-        if len(other) == 0 or self.equals(other) or len(self) == 0:
-            return super().union(other, sort=sort)
-
-        if not isinstance(other, DatetimeIndex):
-            try:
-                other = DatetimeIndex(other)
-            except TypeError:
-                pass
-
-        this, other = self._maybe_utc_convert(other)
-
-        if this._can_fast_union(other):
-            return this._fast_union(other, sort=sort)
-        else:
-            result = Index._union(this, other, sort=sort)
-            if isinstance(result, DatetimeIndex):
-                # TODO: we shouldn't be setting attributes like this;
-                #  in all the tests this equality already holds
-                result._data._dtype = this.dtype
-                if result.freq is None and (
-                    this.freq is not None or other.freq is not None
-                ):
-                    result.freq = to_offset(result.inferred_freq)
-            return result
-
     def union_many(self, others):
         """
-        A bit of a hack to accelerate unioning a collection of indexes
+        A bit of a hack to accelerate unioning a collection of indexes.
         """
         this = self
 
@@ -542,114 +339,9 @@ def union_many(self, others):
             if this._can_fast_union(other):
                 this = this._fast_union(other)
             else:
-                dtype = this.dtype
                 this = Index.union(this, other)
-                if isinstance(this, DatetimeIndex):
-                    # TODO: we shouldn't be setting attributes like this;
-                    #  in all the tests this equality already holds
-                    this._data._dtype = dtype
         return this
 
-    def _can_fast_union(self, other):
-        if not isinstance(other, DatetimeIndex):
-            return False
-
-        freq = self.freq
-
-        if freq is None or freq != other.freq:
-            return False
-
-        if not self.is_monotonic or not other.is_monotonic:
-            return False
-
-        if len(self) == 0 or len(other) == 0:
-            return True
-
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        right_start = right[0]
-        left_end = left[-1]
-
-        # Only need to "adjoin", not overlap
-        try:
-            return (right_start == left_end + freq) or right_start in left
-        except (ValueError):
-
-            # if we are comparing a freq that does not propagate timezones
-            # this will raise
-            return False
-
-    def _fast_union(self, other, sort=None):
-        if len(other) == 0:
-            return self.view(type(self))
-
-        if len(self) == 0:
-            return other.view(type(self))
-
-        # Both DTIs are monotonic. Check if they are already
-        # in the "correct" order
-        if self[0] <= other[0]:
-            left, right = self, other
-        # DTIs are not in the "correct" order and we don't want
-        # to sort but want to remove overlaps
-        elif sort is False:
-            left, right = self, other
-            left_start = left[0]
-            loc = right.searchsorted(left_start, side="left")
-            right_chunk = right.values[:loc]
-            dates = concat_compat((left.values, right_chunk))
-            return self._shallow_copy(dates)
-        # DTIs are not in the "correct" order and we want
-        # to sort
-        else:
-            left, right = other, self
-
-        left_end = left[-1]
-        right_end = right[-1]
-
-        # TODO: consider re-implementing freq._should_cache for fastpath
-
-        # concatenate dates
-        if left_end < right_end:
-            loc = right.searchsorted(left_end, side="right")
-            right_chunk = right.values[loc:]
-            dates = concat_compat((left.values, right_chunk))
-            return self._shallow_copy(dates)
-        else:
-            return left
-
-    def intersection(self, other, sort=False):
-        """
-        Specialized intersection for DatetimeIndex objects.
-        May be much faster than Index.intersection
-
-        Parameters
-        ----------
-        other : DatetimeIndex or array-like
-        sort : False or None, default False
-            Sort the resulting index if possible.
-
-            .. versionadded:: 0.24.0
-
-            .. versionchanged:: 0.24.1
-
-               Changed the default to ``False`` to match the behaviour
-               from before 0.24.0.
-
-        Returns
-        -------
-        y : Index or DatetimeIndex or TimedeltaIndex
-        """
-        return super().intersection(other, sort=sort)
-
-    def _wrap_setop_result(self, other, result):
-        name = get_op_result_name(self, other)
-        return self._shallow_copy(result, name=name, freq=None, tz=self.tz)
-
     # --------------------------------------------------------------------
 
     def _get_time_micros(self):
@@ -658,14 +350,14 @@ def _get_time_micros(self):
             values = self._data._local_timestamps()
         return fields.get_time_micros(values)
 
-    def to_series(self, keep_tz=None, index=None, name=None):
+    def to_series(self, keep_tz=lib.no_default, index=None, name=None):
         """
         Create a Series with both index and values equal to the index keys
         useful with map for returning an indexer based on an index.
 
         Parameters
         ----------
-        keep_tz : optional, defaults False
+        keep_tz : optional, defaults True
             Return the data keeping the timezone.
 
             If keep_tz is True:
@@ -681,10 +373,10 @@ def to_series(self, keep_tz=None, index=None, name=None):
               Series will have a datetime64[ns] dtype. TZ aware
               objects will have the tz removed.
 
-            .. versionchanged:: 0.24
-                The default value will change to True in a future release.
-                You can set ``keep_tz=True`` to already obtain the future
-                behaviour and silence the warning.
+            .. versionchanged:: 1.0.0
+                The default value is now True.  In a future version,
+                this keyword will be removed entirely.  Stop passing the
+                argument to obtain the future behavior and silence the warning.
 
         index : Index, optional
             Index of resulting Series. If None, defaults to original index.
@@ -703,27 +395,27 @@ def to_series(self, keep_tz=None, index=None, name=None):
         if name is None:
             name = self.name
 
-        if keep_tz is None and self.tz is not None:
-            warnings.warn(
-                "The default of the 'keep_tz' keyword in "
-                "DatetimeIndex.to_series will change "
-                "to True in a future release. You can set "
-                "'keep_tz=True' to obtain the future behaviour and "
-                "silence this warning.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            keep_tz = False
-        elif keep_tz is False:
-            warnings.warn(
-                "Specifying 'keep_tz=False' is deprecated and this "
-                "option will be removed in a future release. If "
-                "you want to remove the timezone information, you "
-                "can do 'idx.tz_convert(None)' before calling "
-                "'to_series'.",
-                FutureWarning,
-                stacklevel=2,
-            )
+        if keep_tz is not lib.no_default:
+            if keep_tz:
+                warnings.warn(
+                    "The 'keep_tz' keyword in DatetimeIndex.to_series "
+                    "is deprecated and will be removed in a future version.  "
+                    "You can stop passing 'keep_tz' to silence this warning.",
+                    FutureWarning,
+                    stacklevel=2,
+                )
+            else:
+                warnings.warn(
+                    "Specifying 'keep_tz=False' is deprecated and this "
+                    "option will be removed in a future release. If "
+                    "you want to remove the timezone information, you "
+                    "can do 'idx.tz_convert(None)' before calling "
+                    "'to_series'.",
+                    FutureWarning,
+                    stacklevel=2,
+                )
+        else:
+            keep_tz = True
 
         if keep_tz and self.tz is not None:
             # preserve the tz & copy
@@ -748,7 +440,7 @@ def snap(self, freq="S"):
 
         for i, v in enumerate(self):
             s = v
-            if not freq.onOffset(s):
+            if not freq.is_on_offset(s):
                 t0 = freq.rollback(s)
                 t1 = freq.rollforward(s)
                 if abs(s - t0) < abs(t1 - s):
@@ -757,76 +449,16 @@ def snap(self, freq="S"):
                     s = t1
             snapped[i] = s
 
-        # we know it conforms; skip check
-        return DatetimeIndex._simple_new(snapped, name=self.name, tz=self.tz, freq=freq)
+        dta = DatetimeArray(snapped, dtype=self.dtype)
+        return DatetimeIndex._simple_new(dta, name=self.name)
 
-    def join(self, other, how="left", level=None, return_indexers=False, sort=False):
-        """
-        See Index.join
-        """
-        if (
-            not isinstance(other, DatetimeIndex)
-            and len(other) > 0
-            and other.inferred_type
-            not in (
-                "floating",
-                "integer",
-                "integer-na",
-                "mixed-integer",
-                "mixed-integer-float",
-                "mixed",
-            )
-        ):
-            try:
-                other = DatetimeIndex(other)
-            except (TypeError, ValueError):
-                pass
-
-        this, other = self._maybe_utc_convert(other)
-        return Index.join(
-            this,
-            other,
-            how=how,
-            level=level,
-            return_indexers=return_indexers,
-            sort=sort,
-        )
-
-    def _maybe_utc_convert(self, other):
-        this = self
-        if isinstance(other, DatetimeIndex):
-            if self.tz is not None:
-                if other.tz is None:
-                    raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
-            elif other.tz is not None:
-                raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
-
-            if not timezones.tz_compare(self.tz, other.tz):
-                this = self.tz_convert("UTC")
-                other = other.tz_convert("UTC")
-        return this, other
-
-    def _wrap_joined_index(self, joined, other):
-        name = get_op_result_name(self, other)
-        if (
-            isinstance(other, DatetimeIndex)
-            and self.freq == other.freq
-            and self._can_fast_union(other)
-        ):
-            joined = self._shallow_copy(joined)
-            joined.name = name
-            return joined
-        else:
-            tz = getattr(other, "tz", None)
-            return self._simple_new(joined, name, tz=tz)
-
-    def _parsed_string_to_bounds(self, reso, parsed):
+    def _parsed_string_to_bounds(self, reso: str, parsed: datetime):
         """
         Calculate datetime bounds for parsed time string and its resolution.
 
         Parameters
         ----------
-        reso : Resolution
+        reso : str
             Resolution provided by parsed string.
         parsed : datetime
             Datetime from parsed string.
@@ -834,7 +466,6 @@ def _parsed_string_to_bounds(self, reso, parsed):
         Returns
         -------
         lower, upper: pd.Timestamp
-
         """
         valid_resos = {
             "year",
@@ -850,50 +481,11 @@ def _parsed_string_to_bounds(self, reso, parsed):
         }
         if reso not in valid_resos:
             raise KeyError
-        if reso == "year":
-            start = Timestamp(parsed.year, 1, 1)
-            end = Timestamp(parsed.year, 12, 31, 23, 59, 59, 999999)
-        elif reso == "month":
-            d = ccalendar.get_days_in_month(parsed.year, parsed.month)
-            start = Timestamp(parsed.year, parsed.month, 1)
-            end = Timestamp(parsed.year, parsed.month, d, 23, 59, 59, 999999)
-        elif reso == "quarter":
-            qe = (((parsed.month - 1) + 2) % 12) + 1  # two months ahead
-            d = ccalendar.get_days_in_month(parsed.year, qe)  # at end of month
-            start = Timestamp(parsed.year, parsed.month, 1)
-            end = Timestamp(parsed.year, qe, d, 23, 59, 59, 999999)
-        elif reso == "day":
-            start = Timestamp(parsed.year, parsed.month, parsed.day)
-            end = start + timedelta(days=1) - Nano(1)
-        elif reso == "hour":
-            start = Timestamp(parsed.year, parsed.month, parsed.day, parsed.hour)
-            end = start + timedelta(hours=1) - Nano(1)
-        elif reso == "minute":
-            start = Timestamp(
-                parsed.year, parsed.month, parsed.day, parsed.hour, parsed.minute
-            )
-            end = start + timedelta(minutes=1) - Nano(1)
-        elif reso == "second":
-            start = Timestamp(
-                parsed.year,
-                parsed.month,
-                parsed.day,
-                parsed.hour,
-                parsed.minute,
-                parsed.second,
-            )
-            end = start + timedelta(seconds=1) - Nano(1)
-        elif reso == "microsecond":
-            start = Timestamp(
-                parsed.year,
-                parsed.month,
-                parsed.day,
-                parsed.hour,
-                parsed.minute,
-                parsed.second,
-                parsed.microsecond,
-            )
-            end = start + timedelta(microseconds=1) - Nano(1)
+
+        grp = Resolution.get_freq_group(reso)
+        per = Period(parsed, freq=(grp, 1))
+        start, end = per.start_time, per.end_time
+
         # GH 24076
         # If an incoming date string contained a UTC offset, need to localize
         # the parsed date to this offset first before aligning with the index's
@@ -901,9 +493,8 @@ def _parsed_string_to_bounds(self, reso, parsed):
         if parsed.tzinfo is not None:
             if self.tz is None:
                 raise ValueError(
-                    "The index must be timezone aware "
-                    "when indexing with a date string with a "
-                    "UTC offset"
+                    "The index must be timezone aware when indexing "
+                    "with a date string with a UTC offset"
                 )
             start = start.tz_localize(parsed.tzinfo).tz_convert(self.tz)
             end = end.tz_localize(parsed.tzinfo).tz_convert(self.tz)
@@ -912,10 +503,9 @@ def _parsed_string_to_bounds(self, reso, parsed):
             end = end.tz_localize(self.tz)
         return start, end
 
-    def _partial_date_slice(self, reso, parsed, use_lhs=True, use_rhs=True):
-        is_monotonic = self.is_monotonic
+    def _validate_partial_date_slice(self, reso: str):
         if (
-            is_monotonic
+            self.is_monotonic
             and reso in ["day", "hour", "minute", "second"]
             and self._resolution >= Resolution.get_reso(reso)
         ):
@@ -930,83 +520,11 @@ def _partial_date_slice(self, reso, parsed, use_lhs=True, use_rhs=True):
             # _parsed_string_to_bounds allows it.
             raise KeyError
 
-        t1, t2 = self._parsed_string_to_bounds(reso, parsed)
-        stamps = self.asi8
-
-        if is_monotonic:
-
-            # we are out of range
-            if len(stamps) and (
-                (use_lhs and t1.value < stamps[0] and t2.value < stamps[0])
-                or ((use_rhs and t1.value > stamps[-1] and t2.value > stamps[-1]))
-            ):
-                raise KeyError
-
-            # a monotonic (sorted) series can be sliced
-            left = stamps.searchsorted(t1.value, side="left") if use_lhs else None
-            right = stamps.searchsorted(t2.value, side="right") if use_rhs else None
-
-            return slice(left, right)
-
-        lhs_mask = (stamps >= t1.value) if use_lhs else True
-        rhs_mask = (stamps <= t2.value) if use_rhs else True
-
-        # try to find a the dates
-        return (lhs_mask & rhs_mask).nonzero()[0]
-
     def _maybe_promote(self, other):
         if other.inferred_type == "date":
             other = DatetimeIndex(other)
         return self, other
 
-    def get_value(self, series, key):
-        """
-        Fast lookup of value from 1-dimensional ndarray. Only use this if you
-        know what you're doing
-        """
-
-        if isinstance(key, datetime):
-
-            # needed to localize naive datetimes
-            if self.tz is not None:
-                if key.tzinfo is not None:
-                    key = Timestamp(key).tz_convert(self.tz)
-                else:
-                    key = Timestamp(key).tz_localize(self.tz)
-
-            return self.get_value_maybe_box(series, key)
-
-        if isinstance(key, time):
-            locs = self.indexer_at_time(key)
-            return series.take(locs)
-
-        try:
-            return com.maybe_box(self, Index.get_value(self, series, key), series, key)
-        except KeyError:
-            try:
-                loc = self._get_string_slice(key)
-                return series[loc]
-            except (TypeError, ValueError, KeyError):
-                pass
-
-            try:
-                return self.get_value_maybe_box(series, key)
-            except (TypeError, ValueError, KeyError):
-                raise KeyError(key)
-
-    def get_value_maybe_box(self, series, key):
-        # needed to localize naive datetimes
-        if self.tz is not None:
-            key = Timestamp(key)
-            if key.tzinfo is not None:
-                key = key.tz_convert(self.tz)
-            else:
-                key = key.tz_localize(self.tz)
-        elif not isinstance(key, Timestamp):
-            key = Timestamp(key)
-        values = self._engine.get_value(com.values_from_object(series), key, tz=self.tz)
-        return com.maybe_box(self, values, series, key)
-
     def get_loc(self, key, method=None, tolerance=None):
         """
         Get integer location for requested label
@@ -1015,59 +533,60 @@ def get_loc(self, key, method=None, tolerance=None):
         -------
         loc : int
         """
+        if not is_scalar(key):
+            raise InvalidIndexError(key)
 
-        if tolerance is not None:
-            # try converting tolerance now, so errors don't get swallowed by
-            # the try/except clauses below
-            tolerance = self._convert_tolerance(tolerance, np.asarray(key))
+        orig_key = key
+        if is_valid_nat_for_dtype(key, self.dtype):
+            key = NaT
 
-        if isinstance(key, datetime):
+        if isinstance(key, self._data._recognized_scalars):
             # needed to localize naive datetimes
-            if key.tzinfo is None:
-                key = Timestamp(key, tz=self.tz)
-            else:
-                key = Timestamp(key).tz_convert(self.tz)
-            return Index.get_loc(self, key, method, tolerance)
+            key = self._maybe_cast_for_get_loc(key)
+
+        elif isinstance(key, str):
+            try:
+                return self._get_string_slice(key)
+            except (TypeError, KeyError, ValueError, OverflowError):
+                pass
+
+            try:
+                key = self._maybe_cast_for_get_loc(key)
+            except ValueError:
+                raise KeyError(key)
 
         elif isinstance(key, timedelta):
             # GH#20464
             raise TypeError(
-                "Cannot index {cls} with {other}".format(
-                    cls=type(self).__name__, other=type(key).__name__
-                )
+                f"Cannot index {type(self).__name__} with {type(key).__name__}"
             )
 
-        if isinstance(key, time):
+        elif isinstance(key, time):
             if method is not None:
                 raise NotImplementedError(
                     "cannot yet lookup inexact labels when key is a time object"
                 )
             return self.indexer_at_time(key)
 
+        else:
+            # unrecognized type
+            raise KeyError(key)
+
         try:
             return Index.get_loc(self, key, method, tolerance)
-        except (KeyError, ValueError, TypeError):
-            try:
-                return self._get_string_slice(key)
-            except (TypeError, KeyError, ValueError, OverflowError):
-                pass
+        except KeyError:
+            raise KeyError(orig_key)
 
-            try:
-                stamp = Timestamp(key)
-                if stamp.tzinfo is not None and self.tz is not None:
-                    stamp = stamp.tz_convert(self.tz)
-                else:
-                    stamp = stamp.tz_localize(self.tz)
-                return Index.get_loc(self, stamp, method, tolerance)
-            except KeyError:
-                raise KeyError(key)
-            except ValueError as e:
-                # list-like tolerance size must match target index size
-                if "list-like" in str(e):
-                    raise e
-                raise KeyError(key)
+    def _maybe_cast_for_get_loc(self, key) -> Timestamp:
+        # needed to localize naive datetimes
+        key = Timestamp(key)
+        if key.tzinfo is None:
+            key = key.tz_localize(self.tz)
+        else:
+            key = key.tz_convert(self.tz)
+        return key
 
-    def _maybe_cast_slice_bound(self, label, side, kind):
+    def _maybe_cast_slice_bound(self, label, side: str, kind):
         """
         If label is a string, cast it to datetime according to resolution.
 
@@ -1075,25 +594,24 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         ----------
         label : object
         side : {'left', 'right'}
-        kind : {'ix', 'loc', 'getitem'}
+        kind : {'loc', 'getitem'} or None
 
         Returns
         -------
-        label :  object
+        label : object
 
         Notes
         -----
         Value of `side` parameter should be validated in caller.
-
         """
-        assert kind in ["ix", "loc", "getitem", None]
+        assert kind in ["loc", "getitem", None]
 
         if is_float(label) or isinstance(label, time) or is_integer(label):
             self._invalid_indexer("slice", label)
 
         if isinstance(label, str):
             freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
-            _, parsed, reso = parsing.parse_time_string(label, freq)
+            parsed, reso = parsing.parse_time_string(label, freq)
             lower, upper = self._parsed_string_to_bounds(reso, parsed)
             # lower, upper form the half-open interval:
             #   [parsed, parsed + 1 freq)
@@ -1107,9 +625,9 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         else:
             return label
 
-    def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
+    def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True):
         freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
-        _, parsed, reso = parsing.parse_time_string(key, freq)
+        parsed, reso = parsing.parse_time_string(key, freq)
         loc = self._partial_date_slice(reso, parsed, use_lhs=use_lhs, use_rhs=use_rhs)
         return loc
 
@@ -1138,6 +656,13 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
         if isinstance(start, time) or isinstance(end, time):
             raise KeyError("Cannot mix time and non-time slice keys")
 
+        # Pandas supports slicing with dates, treated as datetimes at midnight.
+        # https://github.com/pandas-dev/pandas/issues/31501
+        if isinstance(start, date) and not isinstance(start, datetime):
+            start = datetime.combine(start, time(0, 0))
+        if isinstance(end, date) and not isinstance(end, datetime):
+            end = datetime.combine(end, time(0, 0))
+
         try:
             return Index.slice_indexer(self, start, end, step, kind=kind)
         except KeyError:
@@ -1164,163 +689,17 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
             else:
                 raise
 
-    # --------------------------------------------------------------------
-    # Wrapping DatetimeArray
-
-    # Compat for frequency inference, see GH#23789
-    _is_monotonic_increasing = Index.is_monotonic_increasing
-    _is_monotonic_decreasing = Index.is_monotonic_decreasing
-    _is_unique = Index.is_unique
-
-    _timezone = cache_readonly(DatetimeArray._timezone.fget)  # type: ignore
-    is_normalized = cache_readonly(DatetimeArray.is_normalized.fget)  # type: ignore
-    _resolution = cache_readonly(DatetimeArray._resolution.fget)  # type: ignore
-
-    _has_same_tz = ea_passthrough(DatetimeArray._has_same_tz)
-
-    @property
-    def offset(self):
-        """
-        get/set the frequency of the instance
-        """
-        msg = (
-            "{cls}.offset has been deprecated and will be removed "
-            "in a future version; use {cls}.freq instead.".format(
-                cls=type(self).__name__
-            )
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        return self.freq
-
-    @offset.setter
-    def offset(self, value):
-        """
-        get/set the frequency of the instance
-        """
-        msg = (
-            "{cls}.offset has been deprecated and will be removed "
-            "in a future version; use {cls}.freq instead.".format(
-                cls=type(self).__name__
-            )
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        self.freq = value
-
-    def __getitem__(self, key):
-        result = self._data.__getitem__(key)
-        if is_scalar(result):
-            return result
-        elif result.ndim > 1:
-            # To support MPL which performs slicing with 2 dim
-            # even though it only has 1 dim by definition
-            assert isinstance(result, np.ndarray), result
-            return result
-        return type(self)(result, name=self.name)
-
-    @property
-    def _box_func(self):
-        return lambda x: Timestamp(x, tz=self.tz)
-
     # --------------------------------------------------------------------
 
-    @Substitution(klass="DatetimeIndex")
-    @Appender(_shared_docs["searchsorted"])
-    def searchsorted(self, value, side="left", sorter=None):
-        if isinstance(value, (np.ndarray, Index)):
-            value = np.array(value, dtype=_NS_DTYPE, copy=False)
-        else:
-            value = _to_M8(value, tz=self.tz)
-
-        return self.values.searchsorted(value, side=side)
-
-    def is_type_compatible(self, typ):
+    def is_type_compatible(self, typ) -> bool:
         return typ == self.inferred_type or typ == "datetime"
 
     @property
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         # b/c datetime is represented as microseconds since the epoch, make
         # sure we can't have ambiguous indexing
         return "datetime64"
 
-    @property
-    def is_all_dates(self):
-        return True
-
-    def insert(self, loc, item):
-        """
-        Make new Index inserting new item at location
-
-        Parameters
-        ----------
-        loc : int
-        item : object
-            if not either a Python datetime or a numpy integer-like, returned
-            Index dtype will be object rather than datetime.
-
-        Returns
-        -------
-        new_index : Index
-        """
-        if is_scalar(item) and isna(item):
-            # GH 18295
-            item = self._na_value
-
-        freq = None
-
-        if isinstance(item, (datetime, np.datetime64)):
-            self._assert_can_do_op(item)
-            if not self._has_same_tz(item) and not isna(item):
-                raise ValueError("Passed item and index have different timezone")
-            # check freq can be preserved on edge cases
-            if self.size and self.freq is not None:
-                if item is NaT:
-                    pass
-                elif (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
-                    freq = self.freq
-                elif (loc == len(self)) and item - self.freq == self[-1]:
-                    freq = self.freq
-            item = _to_M8(item, tz=self.tz)
-
-        try:
-            new_dates = np.concatenate(
-                (self[:loc].asi8, [item.view(np.int64)], self[loc:].asi8)
-            )
-            return self._shallow_copy(new_dates, freq=freq)
-        except (AttributeError, TypeError):
-
-            # fall back to object index
-            if isinstance(item, str):
-                return self.astype(object).insert(loc, item)
-            raise TypeError("cannot insert DatetimeIndex with incompatible label")
-
-    def delete(self, loc):
-        """
-        Make a new DatetimeIndex with passed location(s) deleted.
-
-        Parameters
-        ----------
-        loc: int, slice or array of ints
-            Indicate which sub-arrays to remove.
-
-        Returns
-        -------
-        new_index : DatetimeIndex
-        """
-        new_dates = np.delete(self.asi8, loc)
-
-        freq = None
-        if is_integer(loc):
-            if loc in (0, -len(self), -1, len(self) - 1):
-                freq = self.freq
-        else:
-            if is_list_like(loc):
-                loc = lib.maybe_indices_to_slice(ensure_int64(np.array(loc)), len(self))
-            if isinstance(loc, slice) and loc.step in (1, None):
-                if loc.start in (0, None) or loc.stop in (len(self), None):
-                    freq = self.freq
-
-        return self._shallow_copy(new_dates, freq=freq)
-
     def indexer_at_time(self, time, asof=False):
         """
         Return index locations of index values at particular time of day
@@ -1328,7 +707,7 @@ def indexer_at_time(self, time, asof=False):
 
         Parameters
         ----------
-        time : datetime.time or string
+        time : datetime.time or str
             datetime.time or string in appropriate format ("%H:%M", "%H%M",
             "%I:%M%p", "%I%M%p", "%H:%M:%S", "%H%M%S", "%I:%M:%S%p",
             "%I%M%S%p").
@@ -1371,8 +750,8 @@ def indexer_between_time(
             datetime.time or string in appropriate format ("%H:%M", "%H%M",
             "%I:%M%p", "%I%M%p", "%H:%M:%S", "%H%M%S", "%I:%M:%S%p",
             "%I%M%S%p").
-        include_start : boolean, default True
-        include_end : boolean, default True
+        include_start : bool, default True
+        include_end : bool, default True
 
         Returns
         -------
@@ -1409,10 +788,8 @@ def indexer_between_time(
         return mask.nonzero()[0]
 
 
-DatetimeIndex._add_comparison_ops()
 DatetimeIndex._add_numeric_methods_disabled()
 DatetimeIndex._add_logical_methods_disabled()
-DatetimeIndex._add_datetimelike_methods()
 
 
 def date_range(
@@ -1424,8 +801,8 @@ def date_range(
     normalize=False,
     name=None,
     closed=None,
-    **kwargs
-):
+    **kwargs,
+) -> DatetimeIndex:
     """
     Return a fixed frequency DatetimeIndex.
 
@@ -1435,7 +812,7 @@ def date_range(
         Left bound for generating dates.
     end : str or datetime-like, optional
         Right bound for generating dates.
-    periods : integer, optional
+    periods : int, optional
         Number of periods to generate.
     freq : str or DateOffset, default 'D'
         Frequency strings can have multiples, e.g. '5H'. See
@@ -1474,7 +851,7 @@ def date_range(
     ``start`` and ``end`` (closed on both sides).
 
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     Examples
     --------
@@ -1574,9 +951,9 @@ def date_range(
         tz=tz,
         normalize=normalize,
         closed=closed,
-        **kwargs
+        **kwargs,
     )
-    return DatetimeIndex._simple_new(dtarr, tz=dtarr.tz, freq=dtarr.freq, name=name)
+    return DatetimeIndex._simple_new(dtarr, name=name)
 
 
 def bdate_range(
@@ -1590,30 +967,30 @@ def bdate_range(
     weekmask=None,
     holidays=None,
     closed=None,
-    **kwargs
-):
+    **kwargs,
+) -> DatetimeIndex:
     """
     Return a fixed frequency DatetimeIndex, with business day as the default
     frequency.
 
     Parameters
     ----------
-    start : string or datetime-like, default None
+    start : str or datetime-like, default None
         Left bound for generating dates.
-    end : string or datetime-like, default None
+    end : str or datetime-like, default None
         Right bound for generating dates.
-    periods : integer, default None
+    periods : int, default None
         Number of periods to generate.
-    freq : string or DateOffset, default 'B' (business daily)
+    freq : str or DateOffset, default 'B' (business daily)
         Frequency strings can have multiples, e.g. '5H'.
-    tz : string or None
+    tz : str or None
         Time zone name for returning localized DatetimeIndex, for example
         Asia/Beijing.
     normalize : bool, default False
         Normalize start/end dates to midnight before generating date range.
-    name : string, default None
+    name : str, default None
         Name of the resulting DatetimeIndex.
-    weekmask : string or None, default None
+    weekmask : str or None, default None
         Weekmask of valid business days, passed to ``numpy.busdaycalendar``,
         only used when custom frequency strings are passed.  The default
         value None is equivalent to 'Mon Tue Wed Thu Fri'.
@@ -1627,7 +1004,7 @@ def bdate_range(
 
         .. versionadded:: 0.21.0
 
-    closed : string, default None
+    closed : str, default None
         Make the interval closed with respect to the given frequency to
         the 'left', 'right', or both sides (None).
     **kwargs
@@ -1645,7 +1022,7 @@ def bdate_range(
     desired.
 
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     Examples
     --------
@@ -1660,18 +1037,18 @@ def bdate_range(
         msg = "freq must be specified for bdate_range; use date_range instead"
         raise TypeError(msg)
 
-    if is_string_like(freq) and freq.startswith("C"):
+    if isinstance(freq, str) and freq.startswith("C"):
         try:
             weekmask = weekmask or "Mon Tue Wed Thu Fri"
             freq = prefix_mapping[freq](holidays=holidays, weekmask=weekmask)
         except (KeyError, TypeError):
-            msg = "invalid custom frequency string: {freq}".format(freq=freq)
+            msg = f"invalid custom frequency string: {freq}"
             raise ValueError(msg)
     elif holidays or weekmask:
         msg = (
             "a custom frequency string is required when holidays or "
-            "weekmask are passed, got frequency {freq}"
-        ).format(freq=freq)
+            f"weekmask are passed, got frequency {freq}"
+        )
         raise ValueError(msg)
 
     return date_range(
@@ -1683,7 +1060,7 @@ def bdate_range(
         normalize=normalize,
         name=name,
         closed=closed,
-        **kwargs
+        **kwargs,
     )
 
 
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
new file mode 100644
index 0000000000000..04b4b275bf90a
--- /dev/null
+++ b/pandas/core/indexes/extension.py
@@ -0,0 +1,307 @@
+"""
+Shared methods for Index subclasses backed by ExtensionArray.
+"""
+from typing import List
+
+import numpy as np
+
+from pandas.compat.numpy import function as nv
+from pandas.util._decorators import Appender, cache_readonly
+
+from pandas.core.dtypes.common import (
+    ensure_platform_int,
+    is_dtype_equal,
+    is_object_dtype,
+)
+from pandas.core.dtypes.generic import ABCSeries
+
+from pandas.core.arrays import ExtensionArray
+from pandas.core.indexers import deprecate_ndim_indexing
+from pandas.core.indexes.base import Index
+from pandas.core.ops import get_op_result_name
+
+
+def inherit_from_data(name: str, delegate, cache: bool = False, wrap: bool = False):
+    """
+    Make an alias for a method of the underlying ExtensionArray.
+
+    Parameters
+    ----------
+    name : str
+        Name of an attribute the class should inherit from its EA parent.
+    delegate : class
+    cache : bool, default False
+        Whether to convert wrapped properties into cache_readonly
+    wrap : bool, default False
+        Whether to wrap the inherited result in an Index.
+
+    Returns
+    -------
+    attribute, method, property, or cache_readonly
+    """
+
+    attr = getattr(delegate, name)
+
+    if isinstance(attr, property):
+        if cache:
+
+            def cached(self):
+                return getattr(self._data, name)
+
+            cached.__name__ = name
+            cached.__doc__ = attr.__doc__
+            method = cache_readonly(cached)
+
+        else:
+
+            def fget(self):
+                result = getattr(self._data, name)
+                if wrap:
+                    if isinstance(result, type(self._data)):
+                        return type(self)._simple_new(result, name=self.name)
+                    return Index(result, name=self.name)
+                return result
+
+            def fset(self, value):
+                setattr(self._data, name, value)
+
+            fget.__name__ = name
+            fget.__doc__ = attr.__doc__
+
+            method = property(fget, fset)
+
+    elif not callable(attr):
+        # just a normal attribute, no wrapping
+        method = attr
+
+    else:
+
+        def method(self, *args, **kwargs):
+            result = attr(self._data, *args, **kwargs)
+            if wrap:
+                if isinstance(result, type(self._data)):
+                    return type(self)._simple_new(result, name=self.name)
+                return Index(result, name=self.name)
+            return result
+
+        method.__name__ = name
+        method.__doc__ = attr.__doc__
+    return method
+
+
+def inherit_names(names: List[str], delegate, cache: bool = False, wrap: bool = False):
+    """
+    Class decorator to pin attributes from an ExtensionArray to a Index subclass.
+
+    Parameters
+    ----------
+    names : List[str]
+    delegate : class
+    cache : bool, default False
+    wrap : bool, default False
+        Whether to wrap the inherited result in an Index.
+    """
+
+    def wrapper(cls):
+        for name in names:
+            meth = inherit_from_data(name, delegate, cache=cache, wrap=wrap)
+            setattr(cls, name, meth)
+
+        return cls
+
+    return wrapper
+
+
+def _make_wrapped_comparison_op(opname: str):
+    """
+    Create a comparison method that dispatches to ``._data``.
+    """
+
+    def wrapper(self, other):
+        if isinstance(other, ABCSeries):
+            # the arrays defer to Series for comparison ops but the indexes
+            #  don't, so we have to unwrap here.
+            other = other._values
+
+        other = _maybe_unwrap_index(other)
+
+        op = getattr(self._data, opname)
+        return op(other)
+
+    wrapper.__name__ = opname
+    return wrapper
+
+
+def make_wrapped_arith_op(opname: str):
+    def method(self, other):
+        if (
+            isinstance(other, Index)
+            and is_object_dtype(other.dtype)
+            and type(other) is not Index
+        ):
+            # We return NotImplemented for object-dtype index *subclasses* so they have
+            # a chance to implement ops before we unwrap them.
+            # See https://github.com/pandas-dev/pandas/issues/31109
+            return NotImplemented
+        meth = getattr(self._data, opname)
+        result = meth(_maybe_unwrap_index(other))
+        return _wrap_arithmetic_op(self, other, result)
+
+    method.__name__ = opname
+    return method
+
+
+def _wrap_arithmetic_op(self, other, result):
+    if result is NotImplemented:
+        return NotImplemented
+
+    if isinstance(result, tuple):
+        # divmod, rdivmod
+        assert len(result) == 2
+        return (
+            _wrap_arithmetic_op(self, other, result[0]),
+            _wrap_arithmetic_op(self, other, result[1]),
+        )
+
+    if not isinstance(result, Index):
+        # Index.__new__ will choose appropriate subclass for dtype
+        result = Index(result)
+
+    res_name = get_op_result_name(self, other)
+    result.name = res_name
+    return result
+
+
+def _maybe_unwrap_index(obj):
+    """
+    If operating against another Index object, we need to unwrap the underlying
+    data before deferring to the DatetimeArray/TimedeltaArray/PeriodArray
+    implementation, otherwise we will incorrectly return NotImplemented.
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    unwrapped object
+    """
+    if isinstance(obj, Index):
+        return obj._data
+    return obj
+
+
+class ExtensionIndex(Index):
+    """
+    Index subclass for indexes backed by ExtensionArray.
+    """
+
+    # The base class already passes through to _data:
+    #  size, __len__, dtype
+
+    _data: ExtensionArray
+
+    __eq__ = _make_wrapped_comparison_op("__eq__")
+    __ne__ = _make_wrapped_comparison_op("__ne__")
+    __lt__ = _make_wrapped_comparison_op("__lt__")
+    __gt__ = _make_wrapped_comparison_op("__gt__")
+    __le__ = _make_wrapped_comparison_op("__le__")
+    __ge__ = _make_wrapped_comparison_op("__ge__")
+
+    # ---------------------------------------------------------------------
+    # NDarray-Like Methods
+
+    def __getitem__(self, key):
+        result = self._data[key]
+        if isinstance(result, type(self._data)):
+            return type(self)(result, name=self.name)
+
+        # Includes cases where we get a 2D ndarray back for MPL compat
+        deprecate_ndim_indexing(result)
+        return result
+
+    def __iter__(self):
+        return self._data.__iter__()
+
+    # ---------------------------------------------------------------------
+
+    @property
+    def _ndarray_values(self) -> np.ndarray:
+        return self._data._ndarray_values
+
+    @Appender(Index.dropna.__doc__)
+    def dropna(self, how="any"):
+        if how not in ("any", "all"):
+            raise ValueError(f"invalid how option: {how}")
+
+        if self.hasnans:
+            return self._shallow_copy(self._data[~self._isnan])
+        return self._shallow_copy()
+
+    def repeat(self, repeats, axis=None):
+        nv.validate_repeat(tuple(), dict(axis=axis))
+        result = self._data.repeat(repeats, axis=axis)
+        return self._shallow_copy(result)
+
+    def _concat_same_dtype(self, to_concat, name):
+        arr = type(self._data)._concat_same_type(to_concat)
+        return type(self)._simple_new(arr, name=name)
+
+    @Appender(Index.take.__doc__)
+    def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
+        nv.validate_take(tuple(), kwargs)
+        indices = ensure_platform_int(indices)
+
+        taken = self._assert_take_fillable(
+            self._data,
+            indices,
+            allow_fill=allow_fill,
+            fill_value=fill_value,
+            na_value=self._na_value,
+        )
+        return type(self)(taken, name=self.name)
+
+    def unique(self, level=None):
+        if level is not None:
+            self._validate_index_level(level)
+
+        result = self._data.unique()
+        return self._shallow_copy(result)
+
+    def _get_unique_index(self, dropna=False):
+        if self.is_unique and not dropna:
+            return self
+
+        result = self._data.unique()
+        if dropna and self.hasnans:
+            result = result[~result.isna()]
+        return self._shallow_copy(result)
+
+    @Appender(Index.map.__doc__)
+    def map(self, mapper, na_action=None):
+        # Try to run function on index first, and then on elements of index
+        # Especially important for group-by functionality
+        try:
+            result = mapper(self)
+
+            # Try to use this result if we can
+            if isinstance(result, np.ndarray):
+                result = Index(result)
+
+            if not isinstance(result, Index):
+                raise TypeError("The map function must return an Index object")
+            return result
+        except Exception:
+            return self.astype(object).map(mapper)
+
+    @Appender(Index.astype.__doc__)
+    def astype(self, dtype, copy=True):
+        if is_dtype_equal(self.dtype, dtype) and copy is False:
+            # Ensure that self.astype(self.dtype) is self
+            return self
+
+        new_values = self._data.astype(dtype, copy=copy)
+
+        # pass copy=False because any copying will be done in the
+        #  _data.astype call above
+        return Index(new_values, dtype=new_values.dtype, name=self.name, copy=False)
diff --git a/pandas/core/indexes/frozen.py b/pandas/core/indexes/frozen.py
index a6c39d049c50c..909643d50e9d7 100644
--- a/pandas/core/indexes/frozen.py
+++ b/pandas/core/indexes/frozen.py
@@ -4,17 +4,10 @@
 These are used for:
 
 - .names (FrozenList)
-- .levels & .codes (FrozenNDArray)
 
 """
 
-import warnings
-
-import numpy as np
-
-from pandas.util._decorators import deprecate_kwarg
-
-from pandas.core.dtypes.cast import coerce_indexer_dtype
+from typing import Any
 
 from pandas.core.base import PandasObject
 
@@ -31,7 +24,7 @@ class FrozenList(PandasObject, list):
     # Side note: This has to be of type list. Otherwise,
     #            it messes up PyTables type checks.
 
-    def union(self, other):
+    def union(self, other) -> "FrozenList":
         """
         Returns a FrozenList with other concatenated to the end of self.
 
@@ -42,14 +35,14 @@ def union(self, other):
 
         Returns
         -------
-        diff : FrozenList
+        FrozenList
             The collection difference between self and other.
         """
         if isinstance(other, tuple):
             other = list(other)
         return type(self)(super().__add__(other))
 
-    def difference(self, other):
+    def difference(self, other) -> "FrozenList":
         """
         Returns a FrozenList with elements from other removed from self.
 
@@ -60,7 +53,7 @@ def difference(self, other):
 
         Returns
         -------
-        diff : FrozenList
+        FrozenList
             The collection difference between self and other.
         """
         other = set(other)
@@ -72,15 +65,15 @@ def difference(self, other):
 
     def __getitem__(self, n):
         if isinstance(n, slice):
-            return self.__class__(super().__getitem__(n))
+            return type(self)(super().__getitem__(n))
         return super().__getitem__(n)
 
     def __radd__(self, other):
         if isinstance(other, tuple):
             other = list(other)
-        return self.__class__(other + list(self))
+        return type(self)(other + list(self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, (tuple, FrozenList)):
             other = list(other)
         return super().__eq__(other)
@@ -88,100 +81,27 @@ def __eq__(self, other):
     __req__ = __eq__
 
     def __mul__(self, other):
-        return self.__class__(super().__mul__(other))
+        return type(self)(super().__mul__(other))
 
     __imul__ = __mul__
 
     def __reduce__(self):
-        return self.__class__, (list(self),)
+        return type(self), (list(self),)
 
     def __hash__(self):
         return hash(tuple(self))
 
     def _disabled(self, *args, **kwargs):
-        """This method will not function because object is immutable."""
-        raise TypeError(
-            "'%s' does not support mutable operations." % self.__class__.__name__
-        )
+        """
+        This method will not function because object is immutable.
+        """
+        raise TypeError(f"'{type(self).__name__}' does not support mutable operations.")
 
-    def __str__(self):
+    def __str__(self) -> str:
         return pprint_thing(self, quote_strings=True, escape_chars=("\t", "\r", "\n"))
 
-    def __repr__(self):
-        return "%s(%s)" % (self.__class__.__name__, str(self))
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({str(self)})"
 
     __setitem__ = __setslice__ = __delitem__ = __delslice__ = _disabled
     pop = append = extend = remove = sort = insert = _disabled
-
-
-class FrozenNDArray(PandasObject, np.ndarray):
-
-    # no __array_finalize__ for now because no metadata
-    def __new__(cls, data, dtype=None, copy=False):
-        warnings.warn(
-            "\nFrozenNDArray is deprecated and will be removed in a "
-            "future version.\nPlease use `numpy.ndarray` instead.\n",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        if copy is None:
-            copy = not isinstance(data, FrozenNDArray)
-        res = np.array(data, dtype=dtype, copy=copy).view(cls)
-        return res
-
-    def _disabled(self, *args, **kwargs):
-        """This method will not function because object is immutable."""
-        raise TypeError("'%s' does not support mutable operations." % self.__class__)
-
-    __setitem__ = __setslice__ = __delitem__ = __delslice__ = _disabled
-    put = itemset = fill = _disabled
-
-    def _shallow_copy(self):
-        return self.view()
-
-    def values(self):
-        """returns *copy* of underlying array"""
-        arr = self.view(np.ndarray).copy()
-        return arr
-
-    def __repr__(self):
-        """
-        Return a string representation for this object.
-        """
-        prepr = pprint_thing(self, escape_chars=("\t", "\r", "\n"), quote_strings=True)
-        return "%s(%s, dtype='%s')" % (type(self).__name__, prepr, self.dtype)
-
-    @deprecate_kwarg(old_arg_name="v", new_arg_name="value")
-    def searchsorted(self, value, side="left", sorter=None):
-        """
-        Find indices to insert `value` so as to maintain order.
-
-        For full documentation, see `numpy.searchsorted`
-
-        See Also
-        --------
-        numpy.searchsorted : Equivalent function.
-        """
-
-        # We are much more performant if the searched
-        # indexer is the same type as the array.
-        #
-        # This doesn't matter for int64, but DOES
-        # matter for smaller int dtypes.
-        #
-        # xref: https://github.com/numpy/numpy/issues/5370
-        try:
-            value = self.dtype.type(value)
-        except ValueError:
-            pass
-
-        return super().searchsorted(value, side=side, sorter=sorter)
-
-
-def _ensure_frozen(array_like, categories, copy=False):
-    array_like = coerce_indexer_dtype(array_like, categories)
-    array_like = array_like.view(FrozenNDArray)
-    if copy:
-        array_like = array_like.copy()
-    return array_like
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 29e297cb28a3b..9c4cd6cf72d35 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -2,7 +2,6 @@
 from operator import le, lt
 import textwrap
 from typing import Any, Optional, Tuple, Union
-import warnings
 
 import numpy as np
 
@@ -10,6 +9,7 @@
 
 from pandas._libs import Timedelta, Timestamp, lib
 from pandas._libs.interval import Interval, IntervalMixin, IntervalTree
+from pandas._typing import AnyArrayLike
 from pandas.util._decorators import Appender, Substitution, cache_readonly
 from pandas.util._exceptions import rewrite_exception
 
@@ -20,6 +20,7 @@
 )
 from pandas.core.dtypes.common import (
     ensure_platform_int,
+    is_categorical,
     is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
     is_dtype_equal,
@@ -33,10 +34,9 @@
     is_object_dtype,
     is_scalar,
 )
-from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import isna
 
-from pandas._typing import AnyArrayLike
+from pandas.core.algorithms import take_1d
 from pandas.core.arrays.interval import IntervalArray, _interval_shared_docs
 import pandas.core.common as com
 import pandas.core.indexes.base as ibase
@@ -46,8 +46,10 @@
     _index_shared_docs,
     default_pprint,
     ensure_index,
+    maybe_extract_name,
 )
 from pandas.core.indexes.datetimes import DatetimeIndex, date_range
+from pandas.core.indexes.extension import ExtensionIndex, inherit_names
 from pandas.core.indexes.multi import MultiIndex
 from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
 from pandas.core.ops import get_op_result_name
@@ -84,9 +86,7 @@ def _get_next_label(label):
     elif is_float_dtype(dtype):
         return np.nextafter(label, np.infty)
     else:
-        raise TypeError(
-            "cannot determine next label for type {typ!r}".format(typ=type(label))
-        )
+        raise TypeError(f"cannot determine next label for type {repr(type(label))}")
 
 
 def _get_prev_label(label):
@@ -100,28 +100,13 @@ def _get_prev_label(label):
     elif is_float_dtype(dtype):
         return np.nextafter(label, -np.infty)
     else:
-        raise TypeError(
-            "cannot determine next label for type {typ!r}".format(typ=type(label))
-        )
-
-
-def _get_interval_closed_bounds(interval):
-    """
-    Given an Interval or IntervalIndex, return the corresponding interval with
-    closed bounds.
-    """
-    left, right = interval.left, interval.right
-    if interval.open_left:
-        left = _get_next_label(left)
-    if interval.open_right:
-        right = _get_prev_label(right)
-    return left, right
+        raise TypeError(f"cannot determine next label for type {repr(type(label))}")
 
 
 def _new_IntervalIndex(cls, d):
     """
     This is called upon unpickling, rather than the default which doesn't have
-    arguments and breaks __new__
+    arguments and breaks __new__.
     """
     return cls.from_arrays(**d)
 
@@ -146,21 +131,19 @@ def func(intvidx_self, other, sort=False):
                     result = result.astype(intvidx_self.dtype)
                 return result
             elif intvidx_self.closed != other.closed:
-                msg = (
+                raise ValueError(
                     "can only do set operations between two IntervalIndex "
                     "objects that are closed on the same side"
                 )
-                raise ValueError(msg)
 
             # GH 19016: ensure set op will not return a prohibited dtype
             subtypes = [intvidx_self.dtype.subtype, other.dtype.subtype]
             common_subtype = find_common_type(subtypes)
             if is_object_dtype(common_subtype):
-                msg = (
-                    "can only do {op} between two IntervalIndex "
+                raise TypeError(
+                    f"can only do {self.op_name} between two IntervalIndex "
                     "objects that have compatible dtypes"
                 )
-                raise TypeError(msg.format(op=self.op_name))
 
             return setop(intvidx_self, other, sort)
 
@@ -198,7 +181,14 @@ def func(intvidx_self, other, sort=False):
         ),
     )
 )
-class IntervalIndex(IntervalMixin, Index):
+@inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
+@inherit_names(
+    ["__array__", "overlaps", "contains", "left", "right", "length"], IntervalArray,
+)
+@inherit_names(
+    ["is_non_overlapping_monotonic", "mid", "closed"], IntervalArray, cache=True,
+)
+class IntervalIndex(IntervalMixin, ExtensionIndex):
     _typ = "intervalindex"
     _comparables = ["name"]
     _attributes = ["name", "closed"]
@@ -209,15 +199,21 @@ class IntervalIndex(IntervalMixin, Index):
     # Immutable, so we are able to cache computations like isna in '_mask'
     _mask = None
 
+    _data: IntervalArray
     # --------------------------------------------------------------------
     # Constructors
 
     def __new__(
-        cls, data, closed=None, dtype=None, copy=False, name=None, verify_integrity=True
+        cls,
+        data,
+        closed=None,
+        dtype=None,
+        copy: bool = False,
+        name=None,
+        verify_integrity: bool = True,
     ):
 
-        if name is None and hasattr(data, "name"):
-            name = data.name
+        name = maybe_extract_name(name, data, cls)
 
         with rewrite_exception("IntervalArray", cls.__name__):
             array = IntervalArray(
@@ -243,9 +239,12 @@ def _simple_new(cls, array, name, closed=None):
         closed : Any
             Ignored.
         """
+        assert isinstance(array, IntervalArray), type(array)
+
         result = IntervalMixin.__new__(cls)
         result._data = array
         result.name = name
+        result._no_setting_name = False
         result._reset_identity()
         return result
 
@@ -266,7 +265,9 @@ def _simple_new(cls, array, name, closed=None):
             ),
         )
     )
-    def from_breaks(cls, breaks, closed="right", name=None, copy=False, dtype=None):
+    def from_breaks(
+        cls, breaks, closed: str = "right", name=None, copy: bool = False, dtype=None
+    ):
         with rewrite_exception("IntervalArray", cls.__name__):
             array = IntervalArray.from_breaks(
                 breaks, closed=closed, copy=copy, dtype=dtype
@@ -291,7 +292,13 @@ def from_breaks(cls, breaks, closed="right", name=None, copy=False, dtype=None):
         )
     )
     def from_arrays(
-        cls, left, right, closed="right", name=None, copy=False, dtype=None
+        cls,
+        left,
+        right,
+        closed: str = "right",
+        name=None,
+        copy: bool = False,
+        dtype=None,
     ):
         with rewrite_exception("IntervalArray", cls.__name__):
             array = IntervalArray.from_arrays(
@@ -316,14 +323,16 @@ def from_arrays(
             ),
         )
     )
-    def from_tuples(cls, data, closed="right", name=None, copy=False, dtype=None):
+    def from_tuples(
+        cls, data, closed: str = "right", name=None, copy: bool = False, dtype=None
+    ):
         with rewrite_exception("IntervalArray", cls.__name__):
             arr = IntervalArray.from_tuples(data, closed=closed, copy=copy, dtype=dtype)
         return cls._simple_new(arr, name=name)
 
     # --------------------------------------------------------------------
 
-    @Appender(_index_shared_docs["_shallow_copy"])
+    @Appender(Index._shallow_copy.__doc__)
     def _shallow_copy(self, left=None, right=None, **kwargs):
         result = self._data._shallow_copy(left=left, right=right)
         attributes = self._get_attributes_dict()
@@ -332,7 +341,9 @@ def _shallow_copy(self, left=None, right=None, **kwargs):
 
     @cache_readonly
     def _isnan(self):
-        """Return a mask indicating if each value is NA"""
+        """
+        Return a mask indicating if each value is NA.
+        """
         if self._mask is None:
             self._mask = isna(self.left)
         return self._mask
@@ -343,7 +354,7 @@ def _engine(self):
         right = self._maybe_convert_i8(self.right)
         return IntervalTree(left, right, closed=self.closed)
 
-    def __contains__(self, key):
+    def __contains__(self, key: Any) -> bool:
         """
         return a boolean if this key is IN the index
         We *only* accept an Interval
@@ -354,8 +365,9 @@ def __contains__(self, key):
 
         Returns
         -------
-        boolean
+        bool
         """
+        hash(key)
         if not isinstance(key, Interval):
             return False
 
@@ -365,130 +377,21 @@ def __contains__(self, key):
         except KeyError:
             return False
 
-    @Appender(
-        _interval_shared_docs["to_tuples"]
-        % dict(
-            return_type="Index",
-            examples="""
-        Examples
-        --------
-        >>> idx = pd.IntervalIndex.from_arrays([0, np.nan, 2], [1, np.nan, 3])
-        >>> idx.to_tuples()
-        Index([(0.0, 1.0), (nan, nan), (2.0, 3.0)], dtype='object')
-        >>> idx.to_tuples(na_tuple=False)
-        Index([(0.0, 1.0), nan, (2.0, 3.0)], dtype='object')
-        """,
-        )
-    )
-    def to_tuples(self, na_tuple=True):
-        tuples = self._data.to_tuples(na_tuple=na_tuple)
-        return Index(tuples)
-
     @cache_readonly
-    def _multiindex(self):
+    def _multiindex(self) -> MultiIndex:
         return MultiIndex.from_arrays([self.left, self.right], names=["left", "right"])
 
-    @property
-    def left(self):
-        """
-        Return the left endpoints of each Interval in the IntervalIndex as
-        an Index
-        """
-        return self._data._left
-
-    @property
-    def right(self):
-        """
-        Return the right endpoints of each Interval in the IntervalIndex as
-        an Index
-        """
-        return self._data._right
-
-    @property
-    def closed(self):
-        """
-        Whether the intervals are closed on the left-side, right-side, both or
-        neither
-        """
-        return self._data._closed
-
-    @Appender(
-        _interval_shared_docs["set_closed"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
-                """\
-        Examples
-        --------
-        >>> index = pd.interval_range(0, 3)
-        >>> index
-        IntervalIndex([(0, 1], (1, 2], (2, 3]],
-                      closed='right',
-                      dtype='interval[int64]')
-        >>> index.set_closed('both')
-        IntervalIndex([[0, 1], [1, 2], [2, 3]],
-                      closed='both',
-                      dtype='interval[int64]')
-        """
-            ),
-        )
-    )
-    def set_closed(self, closed):
-        if closed not in _VALID_CLOSED:
-            msg = "invalid option for 'closed': {closed}"
-            raise ValueError(msg.format(closed=closed))
-
-        # return self._shallow_copy(closed=closed)
-        array = self._data.set_closed(closed)
-        return self._simple_new(array, self.name)
-
-    @property
-    def length(self):
-        """
-        Return an Index with entries denoting the length of each Interval in
-        the IntervalIndex
-        """
-        return self._data.length
-
-    @property
-    def size(self):
-        # Avoid materializing ndarray[Interval]
-        return self._data.size
-
-    @property
-    def itemsize(self):
-        msg = (
-            "IntervalIndex.itemsize is deprecated and will be removed in "
-            "a future version"
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-
-        # suppress the warning from the underlying left/right itemsize
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            return self.left.itemsize + self.right.itemsize
-
-    def __len__(self):
-        return len(self.left)
-
     @cache_readonly
-    def values(self):
+    def values(self) -> IntervalArray:
         """
         Return the IntervalIndex's data as an IntervalArray.
         """
         return self._data
 
-    @cache_readonly
-    def _values(self):
-        return self._data
-
-    @cache_readonly
-    def _ndarray_values(self):
-        return np.array(self._data)
-
-    def __array__(self, result=None):
-        """ the array interface, return my values """
-        return self._ndarray_values
+    @property
+    def _has_complex_internals(self) -> bool:
+        # used to avoid libreduction code paths, which raise or require conversion
+        return True
 
     def __array_wrap__(self, result, context=None):
         # we don't want the superclass implementation
@@ -497,68 +400,31 @@ def __array_wrap__(self, result, context=None):
     def __reduce__(self):
         d = dict(left=self.left, right=self.right)
         d.update(self._get_attributes_dict())
-        return _new_IntervalIndex, (self.__class__, d), None
-
-    @Appender(_index_shared_docs["copy"])
-    def copy(self, deep=False, name=None):
-        array = self._data
-        if deep:
-            array = array.copy()
-        attributes = self._get_attributes_dict()
-        if name is not None:
-            attributes.update(name=name)
+        return _new_IntervalIndex, (type(self), d), None
 
-        return self._simple_new(array, **attributes)
-
-    @Appender(_index_shared_docs["astype"])
+    @Appender(Index.astype.__doc__)
     def astype(self, dtype, copy=True):
-        with rewrite_exception("IntervalArray", self.__class__.__name__):
+        with rewrite_exception("IntervalArray", type(self).__name__):
             new_values = self.values.astype(dtype, copy=copy)
         if is_interval_dtype(new_values):
             return self._shallow_copy(new_values.left, new_values.right)
-        return super().astype(dtype, copy=copy)
-
-    @cache_readonly
-    def dtype(self):
-        """Return the dtype object of the underlying data"""
-        return self._data.dtype
+        return Index.astype(self, dtype, copy=copy)
 
     @property
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         """Return a string of the type inferred from the values"""
         return "interval"
 
     @Appender(Index.memory_usage.__doc__)
-    def memory_usage(self, deep=False):
+    def memory_usage(self, deep: bool = False) -> int:
         # we don't use an explicit engine
         # so return the bytes here
         return self.left.memory_usage(deep=deep) + self.right.memory_usage(deep=deep)
 
+    # IntervalTree doesn't have a is_monotonic_decreasing, so have to override
+    #  the Index implemenation
     @cache_readonly
-    def mid(self):
-        """
-        Return the midpoint of each Interval in the IntervalIndex as an Index
-        """
-        return self._data.mid
-
-    @cache_readonly
-    def is_monotonic(self):
-        """
-        Return True if the IntervalIndex is monotonic increasing (only equal or
-        increasing values), else False
-        """
-        return self.is_monotonic_increasing
-
-    @cache_readonly
-    def is_monotonic_increasing(self):
-        """
-        Return True if the IntervalIndex is monotonic increasing (only equal or
-        increasing values), else False
-        """
-        return self._engine.is_monotonic_increasing
-
-    @cache_readonly
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         """
         Return True if the IntervalIndex is monotonic decreasing (only equal or
         decreasing values), else False
@@ -568,7 +434,7 @@ def is_monotonic_decreasing(self):
     @cache_readonly
     def is_unique(self):
         """
-        Return True if the IntervalIndex contains unique elements, else False
+        Return True if the IntervalIndex contains unique elements, else False.
         """
         left = self.left
         right = self.right
@@ -589,13 +455,8 @@ def is_unique(self):
 
         return True
 
-    @cache_readonly
-    @Appender(_interval_shared_docs["is_non_overlapping_monotonic"] % _index_doc_kwargs)
-    def is_non_overlapping_monotonic(self):
-        return self._data.is_non_overlapping_monotonic
-
     @property
-    def is_overlapping(self):
+    def is_overlapping(self) -> bool:
         """
         Return True if the IntervalIndex has overlapping intervals, else False.
 
@@ -649,17 +510,22 @@ def is_overlapping(self):
         # GH 23309
         return self._engine.is_overlapping
 
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        if kind == "iloc":
-            return super()._convert_scalar_indexer(key, kind=kind)
+    def _should_fallback_to_positional(self):
+        # integer lookups in Series.__getitem__ are unambiguously
+        #  positional in this case
+        return self.dtype.subtype.kind in ["m", "M"]
+
+    @Appender(Index._convert_scalar_indexer.__doc__)
+    def _convert_scalar_indexer(self, key, kind: str):
+        assert kind in ["getitem", "loc"]
+        # never iloc, so no-op
         return key
 
     def _maybe_cast_slice_bound(self, label, side, kind):
         return getattr(self, side)._maybe_cast_slice_bound(label, side, kind)
 
-    @Appender(_index_shared_docs["_convert_list_indexer"])
-    def _convert_list_indexer(self, keyarr, kind=None):
+    @Appender(Index._convert_list_indexer.__doc__)
+    def _convert_list_indexer(self, keyarr):
         """
         we are passed a list-like indexer. Return the
         indexer for matching intervals.
@@ -672,26 +538,6 @@ def _convert_list_indexer(self, keyarr, kind=None):
 
         return locs
 
-    def _maybe_cast_indexed(self, key):
-        """
-        we need to cast the key, which could be a scalar
-        or an array-like to the type of our subtype
-        """
-        if isinstance(key, IntervalIndex):
-            return key
-
-        subtype = self.dtype.subtype
-        if is_float_dtype(subtype):
-            if is_integer(key):
-                key = float(key)
-            elif isinstance(key, (np.ndarray, Index)):
-                key = key.astype("float64")
-        elif is_integer_dtype(subtype):
-            if is_integer(key):
-                key = int(key)
-
-        return key
-
     def _can_reindex(self, indexer: np.ndarray) -> None:
         """
         Check if we are allowing reindexing with this particular indexer.
@@ -709,7 +555,7 @@ def _can_reindex(self, indexer: np.ndarray) -> None:
         if self.is_overlapping and len(indexer):
             raise ValueError("cannot reindex from an overlapping axis")
 
-    def _needs_i8_conversion(self, key):
+    def _needs_i8_conversion(self, key) -> bool:
         """
         Check if a given key needs i8 conversion. Conversion is necessary for
         Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An
@@ -725,7 +571,7 @@ def _needs_i8_conversion(self, key):
 
         Returns
         -------
-        boolean
+        bool
         """
         if is_interval_dtype(key) or isinstance(key, Interval):
             return self._needs_i8_conversion(key.left)
@@ -746,8 +592,8 @@ def _maybe_convert_i8(self, key):
 
         Returns
         -------
-        key: scalar or list-like
-            The original key if no conversion occured, int if converted scalar,
+        scalar or list-like
+            The original key if no conversion occurred, int if converted scalar,
             Int64Index if converted list-like.
         """
         original = key
@@ -778,12 +624,12 @@ def _maybe_convert_i8(self, key):
 
         # ensure consistency with IntervalIndex subtype
         subtype = self.dtype.subtype
-        msg = (
-            "Cannot index an IntervalIndex of subtype {subtype} with "
-            "values of dtype {other}"
-        )
+
         if not is_dtype_equal(subtype, key_dtype):
-            raise ValueError(msg.format(subtype=subtype, other=key_dtype))
+            raise ValueError(
+                f"Cannot index an IntervalIndex of subtype {subtype} with "
+                f"values of dtype {key_dtype}"
+            )
 
         return key_i8
 
@@ -792,22 +638,21 @@ def _check_method(self, method):
             return
 
         if method in ["bfill", "backfill", "pad", "ffill", "nearest"]:
-            msg = "method {method} not yet implemented for IntervalIndex"
-            raise NotImplementedError(msg.format(method=method))
+            raise NotImplementedError(
+                f"method {method} not yet implemented for IntervalIndex"
+            )
 
         raise ValueError("Invalid fill method")
 
     def _searchsorted_monotonic(self, label, side, exclude_label=False):
         if not self.is_non_overlapping_monotonic:
             raise KeyError(
-                "can only get slices from an IntervalIndex if "
-                "bounds are non-overlapping and all monotonic "
-                "increasing or decreasing"
+                "can only get slices from an IntervalIndex if bounds are "
+                "non-overlapping and all monotonic increasing or decreasing"
             )
 
         if isinstance(label, IntervalMixin):
-            msg = "Interval objects are not currently supported"
-            raise NotImplementedError(msg)
+            raise NotImplementedError("Interval objects are not currently supported")
 
         # GH 20921: "not is_monotonic_increasing" for the second condition
         # instead of "is_monotonic_decreasing" to account for single element
@@ -825,36 +670,8 @@ def _searchsorted_monotonic(self, label, side, exclude_label=False):
 
         return sub_idx._searchsorted_monotonic(label, side)
 
-    def _find_non_overlapping_monotonic_bounds(self, key):
-        if isinstance(key, IntervalMixin):
-            start = self._searchsorted_monotonic(
-                key.left, "left", exclude_label=key.open_left
-            )
-            stop = self._searchsorted_monotonic(
-                key.right, "right", exclude_label=key.open_right
-            )
-        elif isinstance(key, slice):
-            # slice
-            start, stop = key.start, key.stop
-            if (key.step or 1) != 1:
-                raise NotImplementedError("cannot slice with a slice step")
-            if start is None:
-                start = 0
-            else:
-                start = self._searchsorted_monotonic(start, "left")
-            if stop is None:
-                stop = len(self)
-            else:
-                stop = self._searchsorted_monotonic(stop, "right")
-        else:
-            # scalar or index-like
-
-            start = self._searchsorted_monotonic(key, "left")
-            stop = self._searchsorted_monotonic(key, "right")
-        return start, stop
-
     def get_loc(
-        self, key: Any, method: Optional[str] = None, tolerance=None
+        self, key, method: Optional[str] = None, tolerance=None
     ) -> Union[int, slice, np.ndarray]:
         """
         Get integer location, slice or boolean mask for requested label.
@@ -867,7 +684,7 @@ def get_loc(
 
         Returns
         -------
-        loc : int if unique index, slice if monotonic index, else mask
+        int if unique index, slice if monotonic index, else mask
 
         Examples
         --------
@@ -896,10 +713,8 @@ def get_loc(
         """
         self._check_method(method)
 
-        # list-like are invalid labels for II but in some cases may work, e.g
-        # single element array of comparable type, so guard against them early
-        if is_list_like(key):
-            raise KeyError(key)
+        if not is_scalar(key):
+            raise InvalidIndexError(key)
 
         if isinstance(key, Interval):
             if self.closed != key.closed:
@@ -935,7 +750,7 @@ def get_loc(
             None is specified as these are not yet implemented.
         """
                 )
-            }
+            },
         )
     )
     @Appender(_index_shared_docs["get_indexer"])
@@ -950,11 +765,10 @@ def get_indexer(
         self._check_method(method)
 
         if self.is_overlapping:
-            msg = (
-                "cannot handle overlapping indices; use "
-                "IntervalIndex.get_indexer_non_unique"
+            raise InvalidIndexError(
+                "cannot handle overlapping indices; "
+                "use IntervalIndex.get_indexer_non_unique"
             )
-            raise InvalidIndexError(msg)
 
         target_as_index = ensure_index(target)
 
@@ -976,6 +790,10 @@ def get_indexer(
             left_indexer = self.left.get_indexer(target_as_index.left)
             right_indexer = self.right.get_indexer(target_as_index.right)
             indexer = np.where(left_indexer == right_indexer, left_indexer, -1)
+        elif is_categorical(target_as_index):
+            # get an indexer for unique categories then propagate to codes via take_1d
+            categories_indexer = self.get_indexer(target_as_index.categories)
+            indexer = take_1d(categories_indexer, target_as_index.codes, fill_value=-1)
         elif not is_object_dtype(target_as_index):
             # homogeneous scalar index: use IntervalTree
             target_as_index = self._maybe_convert_i8(target_as_index)
@@ -989,6 +807,9 @@ def get_indexer(
                     loc = self.get_loc(key)
                 except KeyError:
                     loc = -1
+                except InvalidIndexError:
+                    # i.e. non-scalar key
+                    raise TypeError(key)
                 indexer.append(loc)
 
         return ensure_platform_int(indexer)
@@ -1051,27 +872,12 @@ def get_indexer_for(self, target: AnyArrayLike, **kwargs) -> np.ndarray:
             return self.get_indexer_non_unique(target)[0]
         return self.get_indexer(target, **kwargs)
 
-    @Appender(_index_shared_docs["get_value"] % _index_doc_kwargs)
-    def get_value(self, series: ABCSeries, key: Any) -> Any:
+    def _convert_slice_indexer(self, key: slice, kind: str):
+        if not (key.step is None or key.step == 1):
+            raise ValueError("cannot support not-default step in a slice")
+        return super()._convert_slice_indexer(key, kind)
 
-        if com.is_bool_indexer(key):
-            loc = key
-        elif is_list_like(key):
-            if self.is_overlapping:
-                loc, missing = self.get_indexer_non_unique(key)
-                if len(missing):
-                    raise KeyError
-            else:
-                loc = self.get_indexer(key)
-        elif isinstance(key, slice):
-            if not (key.step is None or key.step == 1):
-                raise ValueError("cannot support not-default step in a slice")
-            loc = self._convert_slice_indexer(key, kind="getitem")
-        else:
-            loc = self.get_loc(key)
-        return series.iloc[loc]
-
-    @Appender(_index_shared_docs["where"])
+    @Appender(Index.where.__doc__)
     def where(self, cond, other=None):
         if other is None:
             other = self._na_value
@@ -1084,7 +890,7 @@ def delete(self, loc):
 
         Returns
         -------
-        new_index : IntervalIndex
+        IntervalIndex
         """
         new_left = self.left.delete(loc)
         new_right = self.right.delete(loc)
@@ -1103,7 +909,7 @@ def insert(self, loc, item):
 
         Returns
         -------
-        new_index : IntervalIndex
+        IntervalIndex
         """
         if isinstance(item, Interval):
             if item.closed != self.closed:
@@ -1124,34 +930,12 @@ def insert(self, loc, item):
         new_right = self.right.insert(loc, right_insert)
         return self._shallow_copy(new_left, new_right)
 
-    def _concat_same_dtype(self, to_concat, name):
-        """
-        assert that we all have the same .closed
-        we allow a 0-len index here as well
-        """
-        if not len({i.closed for i in to_concat if len(i)}) == 1:
-            msg = (
-                "can only append two IntervalIndex objects "
-                "that are closed on the same side"
-            )
-            raise ValueError(msg)
-        return super()._concat_same_dtype(to_concat, name)
-
     @Appender(_index_shared_docs["take"] % _index_doc_kwargs)
     def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
         result = self._data.take(
             indices, axis=axis, allow_fill=allow_fill, fill_value=fill_value, **kwargs
         )
-        attributes = self._get_attributes_dict()
-        return self._simple_new(result, **attributes)
-
-    def __getitem__(self, value):
-        result = self._data[value]
-        if isinstance(result, IntervalArray):
-            return self._shallow_copy(result)
-        else:
-            # scalar
-            return result
+        return self._shallow_copy(result)
 
     # --------------------------------------------------------------------
     # Rendering Methods
@@ -1177,23 +961,24 @@ def _format_data(self, name=None):
             summary = "[]"
         elif n == 1:
             first = formatter(self[0])
-            summary = "[{first}]".format(first=first)
+            summary = f"[{first}]"
         elif n == 2:
             first = formatter(self[0])
             last = formatter(self[-1])
-            summary = "[{first}, {last}]".format(first=first, last=last)
+            summary = f"[{first}, {last}]"
         else:
 
             if n > max_seq_items:
                 n = min(max_seq_items // 2, 10)
                 head = [formatter(x) for x in self[:n]]
                 tail = [formatter(x) for x in self[-n:]]
-                summary = "[{head} ... {tail}]".format(
-                    head=", ".join(head), tail=", ".join(tail)
-                )
+                head_joined = ", ".join(head)
+                tail_joined = ", ".join(tail)
+                summary = f"[{head_joined} ... {tail_joined}]"
             else:
                 tail = [formatter(x) for x in self]
-                summary = "[{tail}]".format(tail=", ".join(tail))
+                joined = ", ".join(tail)
+                summary = f"[{joined}]"
 
         return summary + "," + self._format_space()
 
@@ -1201,21 +986,21 @@ def _format_attrs(self):
         attrs = [("closed", repr(self.closed))]
         if self.name is not None:
             attrs.append(("name", default_pprint(self.name)))
-        attrs.append(("dtype", "'{dtype}'".format(dtype=self.dtype)))
+        attrs.append(("dtype", f"'{self.dtype}'"))
         return attrs
 
-    def _format_space(self):
-        space = " " * (len(self.__class__.__name__) + 1)
-        return "\n{space}".format(space=space)
+    def _format_space(self) -> str:
+        space = " " * (len(type(self).__name__) + 1)
+        return f"\n{space}"
 
     # --------------------------------------------------------------------
 
-    def argsort(self, *args, **kwargs):
+    def argsort(self, *args, **kwargs) -> np.ndarray:
         return np.lexsort((self.right, self.left))
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
-        Determines if two IntervalIndex objects contain the same elements
+        Determines if two IntervalIndex objects contain the same elements.
         """
         if self.is_(other):
             return True
@@ -1225,7 +1010,7 @@ def equals(self, other):
         if not isinstance(other, IntervalIndex):
             if not is_interval_dtype(other):
                 return False
-            other = Index(getattr(other, ".values", other))
+            other = Index(other)
 
         return (
             self.left.equals(other.left)
@@ -1233,45 +1018,7 @@ def equals(self, other):
             and self.closed == other.closed
         )
 
-    @Appender(
-        _interval_shared_docs["contains"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
-                """\
-        >>> intervals = pd.IntervalIndex.from_tuples([(0, 1), (1, 3), (2, 4)])
-        >>> intervals
-        IntervalIndex([(0, 1], (1, 3], (2, 4]],
-                  closed='right',
-                  dtype='interval[int64]')
-        >>> intervals.contains(0.5)
-        array([ True, False, False])
-        """
-            ),
-        )
-    )
-    def contains(self, other):
-        return self._data.contains(other)
-
-    @Appender(
-        _interval_shared_docs["overlaps"]
-        % dict(
-            klass="IntervalIndex",
-            examples=textwrap.dedent(
-                """\
-        >>> intervals = pd.IntervalIndex.from_tuples([(0, 1), (1, 3), (2, 4)])
-        >>> intervals
-        IntervalIndex([(0, 1], (1, 3], (2, 4]],
-              closed='right',
-              dtype='interval[int64]')
-        """
-            ),
-        )
-    )
-    def overlaps(self, other):
-        return self._data.overlaps(other)
-
-    @Appender(_index_shared_docs["intersection"])
+    @Appender(Index.intersection.__doc__)
     @SetopCheck(op_name="intersection")
     def intersection(
         self, other: "IntervalIndex", sort: bool = False
@@ -1303,7 +1050,7 @@ def _intersection_unique(self, other: "IntervalIndex") -> "IntervalIndex":
 
         Returns
         -------
-        taken : IntervalIndex
+        IntervalIndex
         """
         lindexer = self.left.get_indexer(other.left)
         rindexer = self.right.get_indexer(other.right)
@@ -1325,7 +1072,7 @@ def _intersection_non_unique(self, other: "IntervalIndex") -> "IntervalIndex":
 
         Returns
         -------
-        taken : IntervalIndex
+        IntervalIndex
         """
         mask = np.zeros(len(self), dtype=bool)
 
@@ -1340,7 +1087,7 @@ def _intersection_non_unique(self, other: "IntervalIndex") -> "IntervalIndex":
 
         return self[mask]
 
-    def _setop(op_name, sort=None):
+    def _setop(op_name: str, sort=None):
         @SetopCheck(op_name=op_name)
         def func(self, other, sort=sort):
             result = getattr(self._multiindex, op_name)(other._multiindex, sort=sort)
@@ -1357,7 +1104,7 @@ def func(self, other, sort=sort):
         return func
 
     @property
-    def is_all_dates(self):
+    def is_all_dates(self) -> bool:
         """
         This is False even when left/right contain datetime-like objects,
         as the check is done on the Interval itself
@@ -1370,12 +1117,27 @@ def is_all_dates(self):
 
     # TODO: arithmetic operations
 
+    # GH#30817 until IntervalArray implements inequalities, get them from Index
+    def __lt__(self, other):
+        return Index.__lt__(self, other)
+
+    def __le__(self, other):
+        return Index.__le__(self, other)
+
+    def __gt__(self, other):
+        return Index.__gt__(self, other)
+
+    def __ge__(self, other):
+        return Index.__ge__(self, other)
+
 
 IntervalIndex._add_logical_methods_disabled()
 
 
-def _is_valid_endpoint(endpoint):
-    """helper for interval_range to check if start/end are valid types"""
+def _is_valid_endpoint(endpoint) -> bool:
+    """
+    Helper for interval_range to check if start/end are valid types.
+    """
     return any(
         [
             is_number(endpoint),
@@ -1386,8 +1148,10 @@ def _is_valid_endpoint(endpoint):
     )
 
 
-def _is_type_compatible(a, b):
-    """helper for interval_range to check type compat of start/end/freq"""
+def _is_type_compatible(a, b) -> bool:
+    """
+    Helper for interval_range to check type compat of start/end/freq.
+    """
     is_ts_compat = lambda x: isinstance(x, (Timestamp, DateOffset))
     is_td_compat = lambda x: isinstance(x, (Timedelta, DateOffset))
     return (
@@ -1407,24 +1171,24 @@ def interval_range(
     Parameters
     ----------
     start : numeric or datetime-like, default None
-        Left bound for generating intervals
+        Left bound for generating intervals.
     end : numeric or datetime-like, default None
-        Right bound for generating intervals
-    periods : integer, default None
-        Number of periods to generate
-    freq : numeric, string, or DateOffset, default None
+        Right bound for generating intervals.
+    periods : int, default None
+        Number of periods to generate.
+    freq : numeric, str, or DateOffset, default None
         The length of each interval. Must be consistent with the type of start
         and end, e.g. 2 for numeric, or '5H' for datetime-like.  Default is 1
         for numeric and 'D' for datetime-like.
-    name : string, default None
-        Name of the resulting IntervalIndex
+    name : str, default None
+        Name of the resulting IntervalIndex.
     closed : {'left', 'right', 'both', 'neither'}, default 'right'
         Whether the intervals are closed on the left-side, right-side, both
         or neither.
 
     Returns
     -------
-    rng : IntervalIndex
+    IntervalIndex
 
     See Also
     --------
@@ -1438,7 +1202,7 @@ def interval_range(
     ``start`` and ``end``, inclusively.
 
     To learn more about datetime-like frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     Examples
     --------
@@ -1502,25 +1266,21 @@ def interval_range(
         )
 
     if not _is_valid_endpoint(start):
-        msg = "start must be numeric or datetime-like, got {start}"
-        raise ValueError(msg.format(start=start))
+        raise ValueError(f"start must be numeric or datetime-like, got {start}")
     elif not _is_valid_endpoint(end):
-        msg = "end must be numeric or datetime-like, got {end}"
-        raise ValueError(msg.format(end=end))
+        raise ValueError(f"end must be numeric or datetime-like, got {end}")
 
     if is_float(periods):
         periods = int(periods)
     elif not is_integer(periods) and periods is not None:
-        msg = "periods must be a number, got {periods}"
-        raise TypeError(msg.format(periods=periods))
+        raise TypeError(f"periods must be a number, got {periods}")
 
     if freq is not None and not is_number(freq):
         try:
             freq = to_offset(freq)
         except ValueError:
             raise ValueError(
-                "freq must be numeric or convertible to "
-                "DateOffset, got {freq}".format(freq=freq)
+                f"freq must be numeric or convertible to DateOffset, got {freq}"
             )
 
     # verify type compatibility
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 761862b9f30e9..ac151daac951a 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1,18 +1,29 @@
-from collections import OrderedDict
-import datetime
 from sys import getsizeof
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Hashable,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
 import warnings
 
 import numpy as np
 
 from pandas._config import get_option
 
-from pandas._libs import Timestamp, algos as libalgos, index as libindex, lib, tslibs
+from pandas._libs import algos as libalgos, index as libindex, lib
 from pandas._libs.hashtable import duplicated_int64
+from pandas._typing import AnyArrayLike, ArrayLike, Scalar
 from pandas.compat.numpy import function as nv
 from pandas.errors import PerformanceWarning, UnsortedIndexError
-from pandas.util._decorators import Appender, cache_readonly, deprecate_kwarg
+from pandas.util._decorators import Appender, cache_readonly
 
+from pandas.core.dtypes.cast import coerce_indexer_dtype
 from pandas.core.dtypes.common import (
     ensure_int64,
     ensure_platform_int,
@@ -31,7 +42,7 @@
 
 import pandas.core.algorithms as algos
 from pandas.core.arrays import Categorical
-from pandas.core.arrays.categorical import _factorize_from_iterables
+from pandas.core.arrays.categorical import factorize_from_iterables
 import pandas.core.common as com
 import pandas.core.indexes.base as ibase
 from pandas.core.indexes.base import (
@@ -40,7 +51,7 @@
     _index_shared_docs,
     ensure_index,
 )
-from pandas.core.indexes.frozen import FrozenList, _ensure_frozen
+from pandas.core.indexes.frozen import FrozenList
 import pandas.core.missing as missing
 from pandas.core.sorting import (
     get_group_index,
@@ -55,6 +66,9 @@
     pprint_thing,
 )
 
+if TYPE_CHECKING:
+    from pandas import Series  # noqa:F401
+
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(
     dict(klass="MultiIndex", target_klass="MultiIndex or list of tuples")
@@ -82,7 +96,7 @@ def _codes_to_ints(self, codes):
 
         Returns
         -------
-        int_keys : scalar or 1-dimensional array, of dtype uint64
+        scalar or 1-dimensional array, of dtype uint64
             Integer(s) representing one combination (each).
         """
         # Shift the representation of each level by the pre-calculated number
@@ -122,7 +136,7 @@ def _codes_to_ints(self, codes):
 
         Returns
         -------
-        int_keys : int, or 1-dimensional array of dtype object
+        int, or 1-dimensional array of dtype object
             Integer(s) representing one combination (each).
         """
 
@@ -154,11 +168,6 @@ class MultiIndex(Index):
         Integers for each level designating which label at each location.
 
         .. versionadded:: 0.24.0
-    labels : sequence of arrays
-        Integers for each level designating which label at each location.
-
-        .. deprecated:: 0.24.0
-            Use ``codes`` instead
     sortorder : optional int
         Level of sortedness (must be lexicographically sorted by that
         level).
@@ -193,6 +202,7 @@ class MultiIndex(Index):
     swaplevel
     reorder_levels
     remove_unused_levels
+    get_locs
 
     See Also
     --------
@@ -206,7 +216,7 @@ class MultiIndex(Index):
     Notes
     -----
     See the `user guide
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html>`_
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html>`_
     for more.
 
     Examples
@@ -227,6 +237,8 @@ class MultiIndex(Index):
     of the mentioned helper methods.
     """
 
+    _deprecations = Index._deprecations | frozenset()
+
     # initialize to zero-length tuples to make everything work
     _typ = "multiindex"
     _names = FrozenList()
@@ -235,10 +247,11 @@ class MultiIndex(Index):
     _comparables = ["names"]
     rename = Index.set_names
 
+    _tuples = None
+
     # --------------------------------------------------------------------
     # Constructors
 
-    @deprecate_kwarg(old_arg_name="labels", new_arg_name="codes")
     def __new__(
         cls,
         levels=None,
@@ -248,8 +261,8 @@ def __new__(
         dtype=None,
         copy=False,
         name=None,
-        verify_integrity=True,
-        _set_identity=True,
+        verify_integrity: bool = True,
+        _set_identity: bool = True,
     ):
 
         # compat with Index
@@ -268,6 +281,7 @@ def __new__(
         result._set_levels(levels, copy=copy, validate=False)
         result._set_codes(codes, copy=copy, validate=False)
 
+        result._names = [None] * len(levels)
         if names is not None:
             # handles name validation
             result._set_names(names)
@@ -286,7 +300,7 @@ def __new__(
 
         return result
 
-    def _validate_codes(self, level: list, code: list):
+    def _validate_codes(self, level: List, code: List):
         """
         Reassign code values as -1 if their corresponding levels are NaN.
 
@@ -299,7 +313,7 @@ def _validate_codes(self, level: list, code: list):
 
         Returns
         -------
-        code : new code where code value = -1 if it corresponds
+        new code where code value = -1 if it corresponds
         to a level with missing values (NaN, NaT, None).
         """
         null_mask = isna(level)
@@ -307,9 +321,10 @@ def _validate_codes(self, level: list, code: list):
             code = np.where(null_mask[code], -1, code)
         return code
 
-    def _verify_integrity(self, codes=None, levels=None):
+    def _verify_integrity(
+        self, codes: Optional[List] = None, levels: Optional[List] = None
+    ):
         """
-
         Parameters
         ----------
         codes : optional list
@@ -325,7 +340,7 @@ def _verify_integrity(self, codes=None, levels=None):
 
         Returns
         -------
-        codes : new codes where code value = -1 if it corresponds to a
+        new codes where code value = -1 if it corresponds to a
         NaN level.
         """
         # NOTE: Currently does not check, among other things, that cached
@@ -335,33 +350,33 @@ def _verify_integrity(self, codes=None, levels=None):
 
         if len(levels) != len(codes):
             raise ValueError(
-                "Length of levels and codes must match. NOTE:"
-                " this index is in an inconsistent state."
+                "Length of levels and codes must match. NOTE: "
+                "this index is in an inconsistent state."
             )
         codes_length = len(codes[0])
         for i, (level, level_codes) in enumerate(zip(levels, codes)):
             if len(level_codes) != codes_length:
                 raise ValueError(
-                    "Unequal code lengths: %s" % ([len(code_) for code_ in codes])
+                    f"Unequal code lengths: {[len(code_) for code_ in codes]}"
                 )
             if len(level_codes) and level_codes.max() >= len(level):
-                msg = (
-                    "On level {level}, code max ({max_code}) >= length of "
-                    "level ({level_len}). NOTE: this index is in an "
-                    "inconsistent state".format(
-                        level=i, max_code=level_codes.max(), level_len=len(level)
-                    )
+                raise ValueError(
+                    f"On level {i}, code max ({level_codes.max()}) >= length of "
+                    f"level ({len(level)}). NOTE: this index is in an "
+                    "inconsistent state"
                 )
-                raise ValueError(msg)
             if len(level_codes) and level_codes.min() < -1:
+                raise ValueError(f"On level {i}, code value ({level_codes.min()}) < -1")
+            if not level.is_unique:
                 raise ValueError(
-                    "On level {level}, code value ({code})"
-                    " < -1".format(level=i, code=level_codes.min())
+                    f"Level values must be unique: {list(level)} on level {i}"
                 )
-            if not level.is_unique:
+        if self.sortorder is not None:
+            if self.sortorder > self._lexsort_depth():
                 raise ValueError(
-                    "Level values must be unique: {values} on "
-                    "level {level}".format(values=[value for value in level], level=i)
+                    "Value for sortorder must be inferior or equal to actual "
+                    f"lexsort_depth: sortorder {self.sortorder} "
+                    f"with lexsort_depth {self._lexsort_depth()}"
                 )
 
         codes = [
@@ -371,7 +386,7 @@ def _verify_integrity(self, codes=None, levels=None):
         return new_codes
 
     @classmethod
-    def from_arrays(cls, arrays, sortorder=None, names=None):
+    def from_arrays(cls, arrays, sortorder=None, names=lib.no_default):
         """
         Convert arrays to MultiIndex.
 
@@ -388,7 +403,7 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
 
         Returns
         -------
-        index : MultiIndex
+        MultiIndex
 
         See Also
         --------
@@ -424,8 +439,8 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
             if len(arrays[i]) != len(arrays[i - 1]):
                 raise ValueError("all arrays must be same length")
 
-        codes, levels = _factorize_from_iterables(arrays)
-        if names is None:
+        codes, levels = factorize_from_iterables(arrays)
+        if names is lib.no_default:
             names = [getattr(arr, "name", None) for arr in arrays]
 
         return MultiIndex(
@@ -453,7 +468,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
 
         Returns
         -------
-        index : MultiIndex
+        MultiIndex
 
         See Also
         --------
@@ -480,8 +495,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
 
         if len(tuples) == 0:
             if names is None:
-                msg = "Cannot infer number of levels from empty list"
-                raise TypeError(msg)
+                raise TypeError("Cannot infer number of levels from empty list")
             arrays = [[]] * len(names)
         elif isinstance(tuples, (np.ndarray, Index)):
             if isinstance(tuples, Index):
@@ -496,7 +510,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
         return MultiIndex.from_arrays(arrays, sortorder=sortorder, names=names)
 
     @classmethod
-    def from_product(cls, iterables, sortorder=None, names=None):
+    def from_product(cls, iterables, sortorder=None, names=lib.no_default):
         """
         Make a MultiIndex from the cartesian product of multiple iterables.
 
@@ -510,9 +524,14 @@ def from_product(cls, iterables, sortorder=None, names=None):
         names : list / sequence of str, optional
             Names for the levels in the index.
 
+            .. versionchanged:: 1.0.0
+
+               If not explicitly provided, names will be inferred from the
+               elements of iterables if an element has a name attribute
+
         Returns
         -------
-        index : MultiIndex
+        MultiIndex
 
         See Also
         --------
@@ -541,7 +560,10 @@ def from_product(cls, iterables, sortorder=None, names=None):
         elif is_iterator(iterables):
             iterables = list(iterables)
 
-        codes, levels = _factorize_from_iterables(iterables)
+        codes, levels = factorize_from_iterables(iterables)
+        if names is lib.no_default:
+            names = [getattr(it, "name", None) for it in iterables]
+
         codes = cartesian_product(codes)
         return MultiIndex(levels, codes, sortorder=sortorder, names=names)
 
@@ -613,23 +635,29 @@ def from_frame(cls, df, sortorder=None, names=None):
 
     # --------------------------------------------------------------------
 
-    @property
-    def levels(self):
-        return self._levels
-
     @property
     def _values(self):
-        # We override here, since our parent uses _data, which we dont' use.
+        # We override here, since our parent uses _data, which we don't use.
         return self.values
 
     @property
-    def shape(self):
-        """
-        Return a tuple of the shape of the underlying data.
-        """
-        # overriding the base Index.shape definition to avoid materializing
-        # the values (GH-27384, GH-27775)
-        return (len(self),)
+    def values(self):
+        if self._tuples is not None:
+            return self._tuples
+
+        values = []
+
+        for i in range(self.nlevels):
+            vals = self._get_level_values(i)
+            if is_categorical_dtype(vals):
+                vals = vals._internal_get_values()
+            if isinstance(vals.dtype, ExtensionDtype) or hasattr(vals, "_box_values"):
+                vals = vals.astype(object)
+            vals = np.array(vals, copy=False)
+            values.append(vals)
+
+        self._tuples = lib.fast_zip(values)
+        return self._tuples
 
     @property
     def array(self):
@@ -641,33 +669,38 @@ def array(self):
         ------
         ValueError
         """
-        msg = (
+        raise ValueError(
             "MultiIndex has no single backing array. Use "
             "'MultiIndex.to_numpy()' to get a NumPy array of tuples."
         )
-        raise ValueError(msg)
 
     @property
-    def _is_homogeneous_type(self):
-        """Whether the levels of a MultiIndex all have the same dtype.
+    def shape(self):
+        """
+        Return a tuple of the shape of the underlying data.
+        """
+        # overriding the base Index.shape definition to avoid materializing
+        # the values (GH-27384, GH-27775)
+        return (len(self),)
 
-        This looks at the dtypes of the levels.
+    def __len__(self) -> int:
+        return len(self.codes[0])
 
-        See Also
-        --------
-        Index._is_homogeneous_type
-        DataFrame._is_homogeneous_type
+    # --------------------------------------------------------------------
+    # Levels Methods
 
-        Examples
-        --------
-        >>> MultiIndex.from_tuples([
-        ...     ('a', 'b'), ('a', 'c')])._is_homogeneous_type
-        True
-        >>> MultiIndex.from_tuples([
-        ...     ('a', 1), ('a', 2)])._is_homogeneous_type
-        False
-        """
-        return len({x.dtype for x in self.levels}) <= 1
+    @cache_readonly
+    def levels(self):
+        # Use cache_readonly to ensure that self.get_locs doesn't repeatedly
+        # create new IndexEngine
+        # https://github.com/pandas-dev/pandas/issues/31648
+        result = [
+            x._shallow_copy(name=name) for x, name in zip(self._levels, self._names)
+        ]
+        for level in result:
+            # disallow midx.levels[0].name = "foo"
+            level._no_setting_name = True
+        return FrozenList(result)
 
     def _set_levels(
         self, levels, level=None, copy=False, validate=True, verify_integrity=False
@@ -675,22 +708,23 @@ def _set_levels(
         # This is NOT part of the levels property because it should be
         # externally not allowed to set levels. User beware if you change
         # _levels directly
-        if validate and len(levels) == 0:
-            raise ValueError("Must set non-zero number of levels.")
-        if validate and level is None and len(levels) != self.nlevels:
-            raise ValueError("Length of levels must match number of levels.")
-        if validate and level is not None and len(levels) != len(level):
-            raise ValueError("Length of levels must match length of level.")
+        if validate:
+            if len(levels) == 0:
+                raise ValueError("Must set non-zero number of levels.")
+            if level is None and len(levels) != self.nlevels:
+                raise ValueError("Length of levels must match number of levels.")
+            if level is not None and len(levels) != len(level):
+                raise ValueError("Length of levels must match length of level.")
 
         if level is None:
             new_levels = FrozenList(
                 ensure_index(lev, copy=copy)._shallow_copy() for lev in levels
             )
         else:
-            level = [self._get_level_number(l) for l in level]
+            level_numbers = [self._get_level_number(lev) for lev in level]
             new_levels = list(self._levels)
-            for l, v in zip(level, levels):
-                new_levels[l] = ensure_index(v, copy=copy)._shallow_copy()
+            for lev_num, lev in zip(level_numbers, levels):
+                new_levels[lev_num] = ensure_index(lev, copy=copy)._shallow_copy()
             new_levels = FrozenList(new_levels)
 
         if verify_integrity:
@@ -707,19 +741,18 @@ def _set_levels(
 
     def set_levels(self, levels, level=None, inplace=False, verify_integrity=True):
         """
-        Set new levels on MultiIndex. Defaults to returning
-        new index.
+        Set new levels on MultiIndex. Defaults to returning new index.
 
         Parameters
         ----------
         levels : sequence or list of sequence
-            new level(s) to apply
+            New level(s) to apply.
         level : int, level name, or sequence of int/level names (default None)
-            level(s) to set (None for all levels)
+            Level(s) to set (None for all levels).
         inplace : bool
-            if True, mutates in place
-        verify_integrity : bool (default True)
-            if True, checks that levels and codes are compatible
+            If True, mutates in place.
+        verify_integrity : bool, default True
+            If True, checks that levels and codes are compatible.
 
         Returns
         -------
@@ -728,32 +761,47 @@ def set_levels(self, levels, level=None, inplace=False, verify_integrity=True):
         Examples
         --------
         >>> idx = pd.MultiIndex.from_tuples([(1, 'one'), (1, 'two'),
-                                            (2, 'one'), (2, 'two')],
+                                            (2, 'one'), (2, 'two'),
+                                            (3, 'one'), (3, 'two')],
                                             names=['foo', 'bar'])
-        >>> idx.set_levels([['a', 'b'], [1, 2]])
+        >>> idx.set_levels([['a', 'b', 'c'], [1, 2]])
         MultiIndex([('a', 1),
                     ('a', 2),
                     ('b', 1),
-                    ('b', 2)],
+                    ('b', 2),
+                    ('c', 1),
+                    ('c', 2)],
                    names=['foo', 'bar'])
-        >>> idx.set_levels(['a', 'b'], level=0)
+        >>> idx.set_levels(['a', 'b', 'c'], level=0)
         MultiIndex([('a', 'one'),
                     ('a', 'two'),
                     ('b', 'one'),
-                    ('b', 'two')],
+                    ('b', 'two'),
+                    ('c', 'one'),
+                    ('c', 'two')],
                    names=['foo', 'bar'])
         >>> idx.set_levels(['a', 'b'], level='bar')
         MultiIndex([(1, 'a'),
                     (1, 'b'),
                     (2, 'a'),
-                    (2, 'b')],
+                    (2, 'b'),
+                    (3, 'a'),
+                    (3, 'b')],
                    names=['foo', 'bar'])
-        >>> idx.set_levels([['a', 'b'], [1, 2]], level=[0, 1])
+
+        If any of the levels passed to ``set_levels()`` exceeds the
+        existing length, all of the values from that argument will
+        be stored in the MultiIndex levels, though the values will
+        be truncated in the MultiIndex output.
+
+        >>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1])
         MultiIndex([('a', 1),
                     ('a', 2),
                     ('b', 1),
                     ('b', 2)],
                    names=['foo', 'bar'])
+        >>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1]).levels
+        FrozenList([['a', 'b', 'c'], [1, 2, 3, 4]])
         """
         if is_list_like(levels) and not isinstance(levels, Index):
             levels = list(levels)
@@ -781,39 +829,46 @@ def set_levels(self, levels, level=None, inplace=False, verify_integrity=True):
             return idx
 
     @property
-    def codes(self):
-        return self._codes
+    def nlevels(self) -> int:
+        """
+        Integer number of levels in this MultiIndex.
+        """
+        return len(self._levels)
 
     @property
-    def labels(self):
-        warnings.warn(
-            (".labels was deprecated in version 0.24.0. Use .codes instead."),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.codes
+    def levshape(self):
+        """
+        A tuple with the length of each level.
+        """
+        return tuple(len(x) for x in self.levels)
+
+    # --------------------------------------------------------------------
+    # Codes Methods
+
+    @property
+    def codes(self):
+        return self._codes
 
     def _set_codes(
         self, codes, level=None, copy=False, validate=True, verify_integrity=False
     ):
-        if validate and level is None and len(codes) != self.nlevels:
-            raise ValueError("Length of codes must match number of levels")
-        if validate and level is not None and len(codes) != len(level):
-            raise ValueError("Length of codes must match length of levels.")
+        if validate:
+            if level is None and len(codes) != self.nlevels:
+                raise ValueError("Length of codes must match number of levels")
+            if level is not None and len(codes) != len(level):
+                raise ValueError("Length of codes must match length of levels.")
 
         if level is None:
             new_codes = FrozenList(
-                _ensure_frozen(level_codes, lev, copy=copy)._shallow_copy()
-                for lev, level_codes in zip(self.levels, codes)
+                _coerce_indexer_frozen(level_codes, lev, copy=copy).view()
+                for lev, level_codes in zip(self._levels, codes)
             )
         else:
-            level = [self._get_level_number(l) for l in level]
+            level_numbers = [self._get_level_number(lev) for lev in level]
             new_codes = list(self._codes)
-            for lev_idx, level_codes in zip(level, codes):
-                lev = self.levels[lev_idx]
-                new_codes[lev_idx] = _ensure_frozen(
-                    level_codes, lev, copy=copy
-                )._shallow_copy()
+            for lev_num, level_codes in zip(level_numbers, codes):
+                lev = self.levels[lev_num]
+                new_codes[lev_num] = _coerce_indexer_frozen(level_codes, lev, copy=copy)
             new_codes = FrozenList(new_codes)
 
         if verify_integrity:
@@ -824,23 +879,6 @@ def _set_codes(
         self._tuples = None
         self._reset_cache()
 
-    def set_labels(self, labels, level=None, inplace=False, verify_integrity=True):
-        warnings.warn(
-            (
-                ".set_labels was deprecated in version 0.24.0. "
-                "Use .set_codes instead."
-            ),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.set_codes(
-            codes=labels,
-            level=level,
-            inplace=inplace,
-            verify_integrity=verify_integrity,
-        )
-
-    @deprecate_kwarg(old_arg_name="labels", new_arg_name="codes")
     def set_codes(self, codes, level=None, inplace=False, verify_integrity=True):
         """
         Set new codes on MultiIndex. Defaults to returning
@@ -853,13 +891,13 @@ def set_codes(self, codes, level=None, inplace=False, verify_integrity=True):
         Parameters
         ----------
         codes : sequence or list of sequence
-            new codes to apply
+            New codes to apply.
         level : int, level name, or sequence of int/level names (default None)
-            level(s) to set (None for all levels)
+            Level(s) to set (None for all levels).
         inplace : bool
-            if True, mutates in place
+            If True, mutates in place.
         verify_integrity : bool (default True)
-            if True, checks that levels and codes are compatible
+            If True, checks that levels and codes are compatible.
 
         Returns
         -------
@@ -917,7 +955,57 @@ def set_codes(self, codes, level=None, inplace=False, verify_integrity=True):
         if not inplace:
             return idx
 
-    @deprecate_kwarg(old_arg_name="labels", new_arg_name="codes")
+    # --------------------------------------------------------------------
+    # Index Internals
+
+    @cache_readonly
+    def _engine(self):
+        # Calculate the number of bits needed to represent labels in each
+        # level, as log2 of their sizes (including -1 for NaN):
+        sizes = np.ceil(np.log2([len(l) + 1 for l in self.levels]))
+
+        # Sum bit counts, starting from the _right_....
+        lev_bits = np.cumsum(sizes[::-1])[::-1]
+
+        # ... in order to obtain offsets such that sorting the combination of
+        # shifted codes (one for each level, resulting in a unique integer) is
+        # equivalent to sorting lexicographically the codes themselves. Notice
+        # that each level needs to be shifted by the number of bits needed to
+        # represent the _previous_ ones:
+        offsets = np.concatenate([lev_bits[1:], [0]]).astype("uint64")
+
+        # Check the total number of bits needed for our representation:
+        if lev_bits[0] > 64:
+            # The levels would overflow a 64 bit uint - use Python integers:
+            return MultiIndexPyIntEngine(self.levels, self.codes, offsets)
+        return MultiIndexUIntEngine(self.levels, self.codes, offsets)
+
+    @property
+    def _constructor(self):
+        return MultiIndex.from_tuples
+
+    @Appender(Index._shallow_copy.__doc__)
+    def _shallow_copy(self, values=None, **kwargs):
+        if values is not None:
+            names = kwargs.pop("names", kwargs.pop("name", self.names))
+            # discards freq
+            kwargs.pop("freq", None)
+            return MultiIndex.from_tuples(values, names=names, **kwargs)
+        return self.copy(**kwargs)
+
+    def _shallow_copy_with_infer(self, values, **kwargs):
+        # On equal MultiIndexes the difference is empty.
+        # Therefore, an empty MultiIndex is returned GH13490
+        if len(values) == 0:
+            return MultiIndex(
+                levels=[[] for _ in range(self.nlevels)],
+                codes=[[] for _ in range(self.nlevels)],
+                **kwargs,
+            )
+        return self._shallow_copy(values, **kwargs)
+
+    # --------------------------------------------------------------------
+
     def copy(
         self,
         names=None,
@@ -925,8 +1013,8 @@ def copy(
         levels=None,
         codes=None,
         deep=False,
+        name=None,
         _set_identity=False,
-        **kwargs
     ):
         """
         Make a copy of this object. Names, dtype, levels and codes can be
@@ -938,10 +1026,13 @@ def copy(
         dtype : numpy dtype or pandas type, optional
         levels : sequence, optional
         codes : sequence, optional
+        deep : bool, default False
+        name : Label
+            Kept for compatibility with 1-dimensional Index. Should not be used.
 
         Returns
         -------
-        copy : MultiIndex
+        MultiIndex
 
         Notes
         -----
@@ -949,9 +1040,7 @@ def copy(
         ``deep``, but if ``deep`` is passed it will attempt to deepcopy.
         This could be potentially expensive on large MultiIndex objects.
         """
-        name = kwargs.get("name")
         names = self._validate_names(name=name, names=names, deep=deep)
-
         if deep:
             from copy import deepcopy
 
@@ -973,7 +1062,7 @@ def copy(
             _set_identity=_set_identity,
         )
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """ the array interface, return my values """
         return self.values
 
@@ -983,19 +1072,8 @@ def view(self, cls=None):
         result._id = self._id
         return result
 
-    def _shallow_copy_with_infer(self, values, **kwargs):
-        # On equal MultiIndexes the difference is empty.
-        # Therefore, an empty MultiIndex is returned GH13490
-        if len(values) == 0:
-            return MultiIndex(
-                levels=[[] for _ in range(self.nlevels)],
-                codes=[[] for _ in range(self.nlevels)],
-                **kwargs
-            )
-        return self._shallow_copy(values, **kwargs)
-
-    @Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
-    def __contains__(self, key):
+    @Appender(Index.__contains__.__doc__)
+    def __contains__(self, key: Any) -> bool:
         hash(key)
         try:
             self.get_loc(key)
@@ -1003,20 +1081,11 @@ def __contains__(self, key):
         except (LookupError, TypeError, ValueError):
             return False
 
-    @Appender(_index_shared_docs["_shallow_copy"])
-    def _shallow_copy(self, values=None, **kwargs):
-        if values is not None:
-            names = kwargs.pop("names", kwargs.pop("name", self.names))
-            # discards freq
-            kwargs.pop("freq", None)
-            return MultiIndex.from_tuples(values, names=names, **kwargs)
-        return self.copy(**kwargs)
-
     @cache_readonly
-    def dtype(self):
+    def dtype(self) -> np.dtype:
         return np.dtype("O")
 
-    def _is_memory_usage_qualified(self):
+    def _is_memory_usage_qualified(self) -> bool:
         """ return a boolean if we need a qualified .info display """
 
         def f(l):
@@ -1025,18 +1094,18 @@ def f(l):
         return any(f(l) for l in self._inferred_type_levels)
 
     @Appender(Index.memory_usage.__doc__)
-    def memory_usage(self, deep=False):
+    def memory_usage(self, deep: bool = False) -> int:
         # we are overwriting our base class to avoid
         # computing .values here which could materialize
         # a tuple representation unnecessarily
         return self._nbytes(deep)
 
     @cache_readonly
-    def nbytes(self):
+    def nbytes(self) -> int:
         """ return the number of bytes in the underlying data """
         return self._nbytes(False)
 
-    def _nbytes(self, deep=False):
+    def _nbytes(self, deep: bool = False) -> int:
         """
         return the number of bytes in the underlying data
         deeply introspect the level data if deep=True
@@ -1061,6 +1130,7 @@ def _nbytes(self, deep=False):
 
     # --------------------------------------------------------------------
     # Rendering Methods
+
     def _formatter_func(self, tup):
         """
         Formats each item in tup according to its level's formatter function.
@@ -1094,7 +1164,8 @@ def _format_native_types(self, na_rep="nan", **kwargs):
             if mask.any():
                 nan_index = len(level)
                 level = np.append(level, na_rep)
-                level_codes = level_codes.values()
+                assert not level_codes.flags.writeable  # i.e. copy is needed
+                level_codes = level_codes.copy()  # make writeable
                 level_codes[mask] = nan_index
             new_levels.append(level)
             new_codes.append(level_codes)
@@ -1186,12 +1257,10 @@ def format(
             return result_levels
 
     # --------------------------------------------------------------------
-
-    def __len__(self):
-        return len(self.codes[0])
+    # Names Methods
 
     def _get_names(self):
-        return FrozenList(level.name for level in self.levels)
+        return FrozenList(self._names)
 
     def _set_names(self, names, level=None, validate=True):
         """
@@ -1224,36 +1293,40 @@ def _set_names(self, names, level=None, validate=True):
             raise ValueError("Names should be list-like for a MultiIndex")
         names = list(names)
 
-        if validate and level is not None and len(names) != len(level):
-            raise ValueError("Length of names must match length of level.")
-        if validate and level is None and len(names) != self.nlevels:
-            raise ValueError(
-                "Length of names must match number of levels in MultiIndex."
-            )
+        if validate:
+            if level is not None and len(names) != len(level):
+                raise ValueError("Length of names must match length of level.")
+            if level is None and len(names) != self.nlevels:
+                raise ValueError(
+                    "Length of names must match number of levels in MultiIndex."
+                )
 
         if level is None:
             level = range(self.nlevels)
         else:
-            level = [self._get_level_number(l) for l in level]
+            level = [self._get_level_number(lev) for lev in level]
 
         # set the name
-        for l, name in zip(level, names):
+        for lev, name in zip(level, names):
             if name is not None:
                 # GH 20527
                 # All items in 'names' need to be hashable:
                 if not is_hashable(name):
                     raise TypeError(
-                        "{}.name must be a hashable type".format(
-                            self.__class__.__name__
-                        )
+                        f"{type(self).__name__}.name must be a hashable type"
                     )
-            self.levels[l].rename(name, inplace=True)
+            self._names[lev] = name
+
+        # If .levels has been accessed, the names in our cache will be stale.
+        self._reset_cache()
 
     names = property(
         fset=_set_names, fget=_get_names, doc="""\nNames of levels in MultiIndex.\n"""
     )
 
-    @Appender(_index_shared_docs["_get_grouper_for_level"])
+    # --------------------------------------------------------------------
+
+    @Appender(Index._get_grouper_for_level.__doc__)
     def _get_grouper_for_level(self, mapper, level):
         indexer = self.codes[level]
         level_index = self.levels[level]
@@ -1278,97 +1351,56 @@ def _get_grouper_for_level(self, mapper, level):
         if len(uniques) < len(level_index):
             # Remove unobserved levels from level_index
             level_index = level_index.take(uniques)
+        else:
+            # break references back to us so that setting the name
+            # on the output of a groupby doesn't reflect back here.
+            level_index = level_index.copy()
 
-        grouper = level_index.take(codes)
+        if level_index._can_hold_na:
+            grouper = level_index.take(codes, fill_value=True)
+        else:
+            grouper = level_index.take(codes)
 
         return grouper, codes, level_index
 
-    @property
-    def _constructor(self):
-        return MultiIndex.from_tuples
-
     @cache_readonly
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         return "mixed"
 
-    def _get_level_number(self, level):
+    def _get_level_number(self, level) -> int:
         count = self.names.count(level)
         if (count > 1) and not is_integer(level):
             raise ValueError(
-                "The name %s occurs multiple times, use a level number" % level
+                f"The name {level} occurs multiple times, use a level number"
             )
         try:
             level = self.names.index(level)
         except ValueError:
             if not is_integer(level):
-                raise KeyError("Level %s not found" % str(level))
+                raise KeyError(f"Level {level} not found")
             elif level < 0:
                 level += self.nlevels
                 if level < 0:
                     orig_level = level - self.nlevels
                     raise IndexError(
-                        "Too many levels: Index has only %d "
-                        "levels, %d is not a valid level number"
-                        % (self.nlevels, orig_level)
+                        f"Too many levels: Index has only {self.nlevels} levels, "
+                        f"{orig_level} is not a valid level number"
                     )
             # Note: levels are zero-based
             elif level >= self.nlevels:
                 raise IndexError(
-                    "Too many levels: Index has only %d levels, "
-                    "not %d" % (self.nlevels, level + 1)
+                    f"Too many levels: Index has only {self.nlevels} levels, "
+                    f"not {level + 1}"
                 )
         return level
 
-    _tuples = None
-
-    @cache_readonly
-    def _engine(self):
-        # Calculate the number of bits needed to represent labels in each
-        # level, as log2 of their sizes (including -1 for NaN):
-        sizes = np.ceil(np.log2([len(l) + 1 for l in self.levels]))
-
-        # Sum bit counts, starting from the _right_....
-        lev_bits = np.cumsum(sizes[::-1])[::-1]
-
-        # ... in order to obtain offsets such that sorting the combination of
-        # shifted codes (one for each level, resulting in a unique integer) is
-        # equivalent to sorting lexicographically the codes themselves. Notice
-        # that each level needs to be shifted by the number of bits needed to
-        # represent the _previous_ ones:
-        offsets = np.concatenate([lev_bits[1:], [0]]).astype("uint64")
-
-        # Check the total number of bits needed for our representation:
-        if lev_bits[0] > 64:
-            # The levels would overflow a 64 bit uint - use Python integers:
-            return MultiIndexPyIntEngine(self.levels, self.codes, offsets)
-        return MultiIndexUIntEngine(self.levels, self.codes, offsets)
-
-    @property
-    def values(self):
-        if self._tuples is not None:
-            return self._tuples
-
-        values = []
-
-        for i in range(self.nlevels):
-            vals = self._get_level_values(i)
-            if is_categorical_dtype(vals):
-                vals = vals._internal_get_values()
-            if isinstance(vals.dtype, ExtensionDtype) or hasattr(vals, "_box_values"):
-                vals = vals.astype(object)
-            vals = np.array(vals, copy=False)
-            values.append(vals)
-
-        self._tuples = lib.fast_zip(values)
-        return self._tuples
-
     @property
-    def _has_complex_internals(self):
-        # to disable groupby tricks
+    def _has_complex_internals(self) -> bool:
+        # used to avoid libreduction code paths, which raise or require conversion
         return True
 
     @cache_readonly
-    def is_monotonic_increasing(self):
+    def is_monotonic_increasing(self) -> bool:
         """
         return if the index is monotonic increasing (only equal or
         increasing) values.
@@ -1393,7 +1425,7 @@ def is_monotonic_increasing(self):
             return Index(self.values).is_monotonic
 
     @cache_readonly
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         """
         return if the index is monotonic decreasing (only equal or
         decreasing) values.
@@ -1464,7 +1496,7 @@ def fillna(self, value=None, downcast=None):
         """
         raise NotImplementedError("isna is not defined for MultiIndex")
 
-    @Appender(_index_shared_docs["dropna"])
+    @Appender(Index.dropna.__doc__)
     def dropna(self, how="any"):
         nans = [level_codes == -1 for level_codes in self.codes]
         if how == "any":
@@ -1472,73 +1504,11 @@ def dropna(self, how="any"):
         elif how == "all":
             indexer = np.all(nans, axis=0)
         else:
-            raise ValueError("invalid how option: {0}".format(how))
+            raise ValueError(f"invalid how option: {how}")
 
         new_codes = [level_codes[~indexer] for level_codes in self.codes]
         return self.copy(codes=new_codes, deep=True)
 
-    def get_value(self, series, key):
-        # Label-based
-        s = com.values_from_object(series)
-        k = com.values_from_object(key)
-
-        def _try_mi(k):
-            # TODO: what if a level contains tuples??
-            loc = self.get_loc(k)
-            new_values = series._values[loc]
-            new_index = self[loc]
-            new_index = maybe_droplevels(new_index, k)
-            return series._constructor(
-                new_values, index=new_index, name=series.name
-            ).__finalize__(self)
-
-        try:
-            return self._engine.get_value(s, k)
-        except KeyError as e1:
-            try:
-                return _try_mi(key)
-            except KeyError:
-                pass
-
-            try:
-                return libindex.get_value_at(s, k)
-            except IndexError:
-                raise
-            except TypeError:
-                # generator/iterator-like
-                if is_iterator(key):
-                    raise InvalidIndexError(key)
-                else:
-                    raise e1
-            except Exception:  # pragma: no cover
-                raise e1
-        except TypeError:
-
-            # a Timestamp will raise a TypeError in a multi-index
-            # rather than a KeyError, try it here
-            # note that a string that 'looks' like a Timestamp will raise
-            # a KeyError! (GH5725)
-            if isinstance(key, (datetime.datetime, np.datetime64, str)):
-                try:
-                    return _try_mi(key)
-                except KeyError:
-                    raise
-                except (IndexError, ValueError, TypeError):
-                    pass
-
-                try:
-                    return _try_mi(Timestamp(key))
-                except (
-                    KeyError,
-                    TypeError,
-                    IndexError,
-                    ValueError,
-                    tslibs.OutOfBoundsDatetime,
-                ):
-                    pass
-
-            raise InvalidIndexError(key)
-
     def _get_level_values(self, level, unique=False):
         """
         Return vector of label values for requested level,
@@ -1557,13 +1527,13 @@ def _get_level_values(self, level, unique=False):
         values : ndarray
         """
 
-        values = self.levels[level]
+        lev = self.levels[level]
         level_codes = self.codes[level]
+        name = self._names[level]
         if unique:
             level_codes = algos.unique(level_codes)
-        filled = algos.take_1d(values._values, level_codes, fill_value=values._na_value)
-        values = values._shallow_copy(filled)
-        return values
+        filled = algos.take_1d(lev._values, level_codes, fill_value=lev._na_value)
+        return lev._shallow_copy(filled, name=name)
 
     def get_level_values(self, level):
         """
@@ -1601,7 +1571,7 @@ def get_level_values(self, level):
         values = self._get_level_values(level)
         return values
 
-    @Appender(_index_shared_docs["index_unique"] % _index_doc_kwargs)
+    @Appender(Index.unique.__doc__)
     def unique(self, level=None):
 
         if level is None:
@@ -1625,10 +1595,10 @@ def to_frame(self, index=True, name=None):
 
         Parameters
         ----------
-        index : boolean, default True
+        index : bool, default True
             Set the index of the returned DataFrame as the original MultiIndex.
 
-        name : list / sequence of strings, optional
+        name : list / sequence of str, optional
             The passed names should substitute index level names.
 
         Returns
@@ -1654,17 +1624,12 @@ def to_frame(self, index=True, name=None):
         else:
             idx_names = self.names
 
-        # Guarantee resulting column order
+        # Guarantee resulting column order - PY36+ dict maintains insertion order
         result = DataFrame(
-            OrderedDict(
-                [
-                    (
-                        (level if lvlname is None else lvlname),
-                        self._get_level_values(level),
-                    )
-                    for lvlname, level in zip(idx_names, range(len(self.levels)))
-                ]
-            ),
+            {
+                (level if lvlname is None else lvlname): self._get_level_values(level)
+                for lvlname, level in zip(idx_names, range(len(self.levels)))
+            },
             copy=False,
         )
 
@@ -1672,62 +1637,6 @@ def to_frame(self, index=True, name=None):
             result.index = self
         return result
 
-    def to_hierarchical(self, n_repeat, n_shuffle=1):
-        """
-        Return a MultiIndex reshaped to conform to the
-        shapes given by n_repeat and n_shuffle.
-
-        .. deprecated:: 0.24.0
-
-        Useful to replicate and rearrange a MultiIndex for combination
-        with another Index with n_repeat items.
-
-        Parameters
-        ----------
-        n_repeat : int
-            Number of times to repeat the labels on self
-        n_shuffle : int
-            Controls the reordering of the labels. If the result is going
-            to be an inner level in a MultiIndex, n_shuffle will need to be
-            greater than one. The size of each label must divisible by
-            n_shuffle.
-
-        Returns
-        -------
-        MultiIndex
-
-        Examples
-        --------
-        >>> idx = pd.MultiIndex.from_tuples([(1, 'one'), (1, 'two'),
-                                            (2, 'one'), (2, 'two')])
-        >>> idx.to_hierarchical(3)
-        MultiIndex([(1, 'one'),
-                    (1, 'one'),
-                    (1, 'one'),
-                    (1, 'two'),
-                    (1, 'two'),
-                    (1, 'two'),
-                    (2, 'one'),
-                    (2, 'one'),
-                    (2, 'one'),
-                    (2, 'two'),
-                    (2, 'two'),
-                    (2, 'two')],
-                   )
-        """
-        levels = self.levels
-        codes = [np.repeat(level_codes, n_repeat) for level_codes in self.codes]
-        # Assumes that each level_codes is divisible by n_shuffle
-        codes = [x.reshape(n_shuffle, -1).ravel(order="F") for x in codes]
-        names = self.names
-        warnings.warn(
-            "Method .to_hierarchical is deprecated and will "
-            "be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return MultiIndex(levels=levels, codes=codes, names=names)
-
     def to_flat_index(self):
         """
         Convert a MultiIndex to an Index of Tuples containing the level values.
@@ -1757,10 +1666,10 @@ def to_flat_index(self):
         return Index(self.values, tupleize_cols=False)
 
     @property
-    def is_all_dates(self):
+    def is_all_dates(self) -> bool:
         return False
 
-    def is_lexsorted(self):
+    def is_lexsorted(self) -> bool:
         """
         Return True if the codes are lexicographically sorted.
 
@@ -1773,22 +1682,27 @@ def is_lexsorted(self):
     @cache_readonly
     def lexsort_depth(self):
         if self.sortorder is not None:
-            if self.sortorder == 0:
-                return self.nlevels
-            else:
-                return 0
+            return self.sortorder
 
+        return self._lexsort_depth()
+
+    def _lexsort_depth(self) -> int:
+        """
+        Compute and return the lexsort_depth, the number of levels of the
+        MultiIndex that are sorted lexically
+
+        Returns
+        ------
+        int
+        """
         int64_codes = [ensure_int64(level_codes) for level_codes in self.codes]
         for k in range(self.nlevels, 0, -1):
             if libalgos.is_lexsorted(int64_codes[:k]):
                 return k
-
         return 0
 
     def _sort_levels_monotonic(self):
         """
-        .. versionadded:: 0.20.0
-
         This is an *internal* function.
 
         Create a new MultiIndex from the current to monotonically sorted
@@ -1865,8 +1779,6 @@ def remove_unused_levels(self):
         appearance, meaning the same .values and ordering. It will also
         be .equals() to the original.
 
-        .. versionadded:: 0.20.0
-
         Returns
         -------
         MultiIndex
@@ -1941,31 +1853,20 @@ def remove_unused_levels(self):
             result._set_levels(new_levels, validate=False)
             result._set_codes(new_codes, validate=False)
 
-        return result
-
-    @property
-    def nlevels(self):
-        """
-        Integer number of levels in this MultiIndex.
-        """
-        return len(self.levels)
+        return result
 
-    @property
-    def levshape(self):
-        """
-        A tuple with the length of each level.
-        """
-        return tuple(len(x) for x in self.levels)
+    # --------------------------------------------------------------------
+    # Pickling Methods
 
     def __reduce__(self):
         """Necessary for making this object picklable"""
         d = dict(
-            levels=[lev for lev in self.levels],
-            codes=[level_codes for level_codes in self.codes],
+            levels=list(self.levels),
+            codes=list(self.codes),
             sortorder=self.sortorder,
             names=list(self.names),
         )
-        return ibase._new_Index, (self.__class__, d), None
+        return ibase._new_Index, (type(self), d), None
 
     def __setstate__(self, state):
         """Necessary for making this object picklable"""
@@ -1989,6 +1890,8 @@ def __setstate__(self, state):
         self.sortorder = sortorder
         self._reset_identity()
 
+    # --------------------------------------------------------------------
+
     def __getitem__(self, key):
         if is_scalar(key):
             key = com.cast_scalar_indexer(key)
@@ -2054,7 +1957,7 @@ def _assert_take_fillable(
             if mask.any():
                 masked = []
                 for new_label in taken:
-                    label_values = new_label.values()
+                    label_values = new_label
                     label_values[mask] = na_value
                     masked.append(np.asarray(label_values))
                 taken = masked
@@ -2096,7 +1999,7 @@ def append(self, other):
         except (TypeError, IndexError):
             return Index(new_tuples)
 
-    def argsort(self, *args, **kwargs):
+    def argsort(self, *args, **kwargs) -> np.ndarray:
         return self.values.argsort(*args, **kwargs)
 
     @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
@@ -2117,7 +2020,6 @@ def repeat(self, repeats, axis=None):
     def where(self, cond, other=None):
         raise NotImplementedError(".where is not supported for MultiIndex operations")
 
-    @deprecate_kwarg(old_arg_name="labels", new_arg_name="codes")
     def drop(self, codes, level=None, errors="raise"):
         """
         Make new MultiIndex with passed list of codes deleted
@@ -2127,24 +2029,20 @@ def drop(self, codes, level=None, errors="raise"):
         codes : array-like
             Must be a list of tuples
         level : int or level name, default None
+        errors : str, default 'raise'
 
         Returns
         -------
         dropped : MultiIndex
         """
         if level is not None:
-            return self._drop_from_level(codes, level)
+            return self._drop_from_level(codes, level, errors)
 
-        try:
-            if not isinstance(codes, (np.ndarray, Index)):
-                codes = com.index_labels_to_array(codes)
-            indexer = self.get_indexer(codes)
-            mask = indexer == -1
-            if mask.any():
-                if errors != "ignore":
-                    raise ValueError("codes %s not contained in axis" % codes[mask])
-        except Exception:
-            pass
+        if not isinstance(codes, (np.ndarray, Index)):
+            try:
+                codes = com.index_labels_to_array(codes, dtype=object)
+            except ValueError:
+                pass
 
         inds = []
         for level_codes in codes:
@@ -2159,16 +2057,15 @@ def drop(self, codes, level=None, errors="raise"):
                 elif com.is_bool_indexer(loc):
                     if self.lexsort_depth == 0:
                         warnings.warn(
-                            "dropping on a non-lexsorted multi-index"
-                            " without a level parameter may impact "
-                            "performance.",
+                            "dropping on a non-lexsorted multi-index "
+                            "without a level parameter may impact performance.",
                             PerformanceWarning,
                             stacklevel=3,
                         )
                     loc = loc.nonzero()[0]
                     inds.extend(loc)
                 else:
-                    msg = "unsupported indexer of type {}".format(type(loc))
+                    msg = f"unsupported indexer of type {type(loc)}"
                     raise AssertionError(msg)
             except KeyError:
                 if errors != "ignore":
@@ -2176,13 +2073,15 @@ def drop(self, codes, level=None, errors="raise"):
 
         return self.delete(inds)
 
-    def _drop_from_level(self, codes, level):
+    def _drop_from_level(self, codes, level, errors="raise"):
         codes = com.index_labels_to_array(codes)
         i = self._get_level_number(level)
         index = self.levels[i]
         values = index.get_indexer(codes)
 
         mask = ~algos.isin(self.codes[i], values)
+        if mask.all() and errors != "ignore":
+            raise KeyError(f"labels {codes} not found in level")
 
         return self[mask]
 
@@ -2258,8 +2157,8 @@ def reorder_levels(self, order):
         order = [self._get_level_number(i) for i in order]
         if len(order) != self.nlevels:
             raise AssertionError(
-                "Length of order must be same as "
-                "number of levels (%d), got %d" % (self.nlevels, len(order))
+                f"Length of order must be same as number of levels ({self.nlevels}), "
+                f"got {len(order)}"
             )
         new_levels = [self.levels[i] for i in order]
         new_codes = [self.codes[i] for i in order]
@@ -2269,9 +2168,6 @@ def reorder_levels(self, order):
             levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False
         )
 
-    def __getslice__(self, i, j):
-        return self.__getitem__(slice(i, j))
-
     def _get_codes_for_sorting(self):
         """
         we categorizing our codes by using the
@@ -2300,11 +2196,11 @@ def sortlevel(self, level=0, ascending=True, sort_remaining=True):
         Parameters
         ----------
         level : list-like, int or str, default 0
-            If a string is given, must be a name of the level
+            If a string is given, must be a name of the level.
             If list-like must be names or ints of levels.
-        ascending : boolean, default True
-            False to sort in descending order
-            Can also be a list to specify a directed ordering
+        ascending : bool, default True
+            False to sort in descending order.
+            Can also be a list to specify a directed ordering.
         sort_remaining : sort by the remaining levels after level
 
         Returns
@@ -2368,7 +2264,108 @@ def sortlevel(self, level=0, ascending=True, sort_remaining=True):
 
         return new_index, indexer
 
-    def _convert_listlike_indexer(self, keyarr, kind=None):
+    def reindex(self, target, method=None, level=None, limit=None, tolerance=None):
+        """
+        Create index with target's values (move/add/delete values as necessary)
+
+        Returns
+        -------
+        new_index : pd.MultiIndex
+            Resulting index
+        indexer : np.ndarray or None
+            Indices of output values in original index.
+
+        """
+        # GH6552: preserve names when reindexing to non-named target
+        # (i.e. neither Index nor Series).
+        preserve_names = not hasattr(target, "names")
+
+        if level is not None:
+            if method is not None:
+                raise TypeError("Fill method not supported if level passed")
+
+            # GH7774: preserve dtype/tz if target is empty and not an Index.
+            # target may be an iterator
+            target = ibase._ensure_has_len(target)
+            if len(target) == 0 and not isinstance(target, Index):
+                idx = self.levels[level]
+                attrs = idx._get_attributes_dict()
+                attrs.pop("freq", None)  # don't preserve freq
+                target = type(idx)._simple_new(np.empty(0, dtype=idx.dtype), **attrs)
+            else:
+                target = ensure_index(target)
+            target, indexer, _ = self._join_level(
+                target, level, how="right", return_indexers=True, keep_order=False
+            )
+        else:
+            target = ensure_index(target)
+            if self.equals(target):
+                indexer = None
+            else:
+                if self.is_unique:
+                    indexer = self.get_indexer(
+                        target, method=method, limit=limit, tolerance=tolerance
+                    )
+                else:
+                    raise ValueError("cannot handle a non-unique multi-index!")
+
+        if not isinstance(target, MultiIndex):
+            if indexer is None:
+                target = self
+            elif (indexer >= 0).all():
+                target = self.take(indexer)
+            else:
+                # hopefully?
+                target = MultiIndex.from_tuples(target)
+
+        if (
+            preserve_names
+            and target.nlevels == self.nlevels
+            and target.names != self.names
+        ):
+            target = target.copy(deep=False)
+            target.names = self.names
+
+        return target, indexer
+
+    # --------------------------------------------------------------------
+    # Indexing Methods
+
+    def get_value(self, series, key):
+        # Label-based
+        if not is_hashable(key) or is_iterator(key):
+            # We allow tuples if they are hashable, whereas other Index
+            #  subclasses require scalar.
+            # We have to explicitly exclude generators, as these are hashable.
+            raise InvalidIndexError(key)
+
+        try:
+            loc = self.get_loc(key)
+        except KeyError:
+            if is_integer(key):
+                loc = key
+            else:
+                raise
+
+        return self._get_values_for_loc(series, loc, key)
+
+    def _get_values_for_loc(self, series: "Series", loc, key):
+        """
+        Do a positional lookup on the given Series, returning either a scalar
+        or a Series.
+
+        Assumes that `series.index is self`
+        """
+        new_values = series._values[loc]
+        if is_scalar(loc):
+            return new_values
+
+        new_index = self[loc]
+        new_index = maybe_droplevels(new_index, key)
+        new_ser = series._constructor(new_values, index=new_index, name=series.name)
+        return new_ser.__finalize__(series)
+
+    def _convert_listlike_indexer(self, keyarr):
         """
         Parameters
         ----------
@@ -2381,7 +2378,7 @@ def _convert_listlike_indexer(self, keyarr, kind=None):
             indexer is an ndarray or None if cannot convert
             keyarr are tuple-safe keys
         """
-        indexer, keyarr = super()._convert_listlike_indexer(keyarr, kind=kind)
+        indexer, keyarr = super()._convert_listlike_indexer(keyarr)
 
         # are we indexing a specific level
         if indexer is None and len(keyarr) and not isinstance(keyarr[0], tuple):
@@ -2395,7 +2392,7 @@ def _convert_listlike_indexer(self, keyarr, kind=None):
             check = self.levels[0].get_indexer(keyarr)
             mask = check == -1
             if mask.any():
-                raise KeyError("%s not in index" % keyarr[mask])
+                raise KeyError(f"{keyarr[mask]} not in index")
 
         return indexer, keyarr
 
@@ -2442,71 +2439,53 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
     def get_indexer_non_unique(self, target):
         return super().get_indexer_non_unique(target)
 
-    def reindex(self, target, method=None, level=None, limit=None, tolerance=None):
+    def get_slice_bound(
+        self, label: Union[Hashable, Sequence[Hashable]], side: str, kind: str
+    ) -> int:
         """
-        Create index with target's values (move/add/delete values as necessary)
+        For an ordered MultiIndex, compute slice bound
+        that corresponds to given label.
+
+        Returns leftmost (one-past-the-rightmost if `side=='right') position
+        of given label.
+
+        Parameters
+        ----------
+        label : object or tuple of objects
+        side : {'left', 'right'}
+        kind : {'loc', 'getitem'}
 
         Returns
         -------
-        new_index : pd.MultiIndex
-            Resulting index
-        indexer : np.ndarray or None
-            Indices of output values in original index.
+        int
+            Index of label.
 
-        """
-        # GH6552: preserve names when reindexing to non-named target
-        # (i.e. neither Index nor Series).
-        preserve_names = not hasattr(target, "names")
+        Notes
+        -----
+        This method only works if level 0 index of the MultiIndex is lexsorted.
 
-        if level is not None:
-            if method is not None:
-                raise TypeError("Fill method not supported if level passed")
+        Examples
+        --------
+        >>> mi = pd.MultiIndex.from_arrays([list('abbc'), list('gefd')])
 
-            # GH7774: preserve dtype/tz if target is empty and not an Index.
-            # target may be an iterator
-            target = ibase._ensure_has_len(target)
-            if len(target) == 0 and not isinstance(target, Index):
-                idx = self.levels[level]
-                attrs = idx._get_attributes_dict()
-                attrs.pop("freq", None)  # don't preserve freq
-                target = type(idx)._simple_new(np.empty(0, dtype=idx.dtype), **attrs)
-            else:
-                target = ensure_index(target)
-            target, indexer, _ = self._join_level(
-                target, level, how="right", return_indexers=True, keep_order=False
-            )
-        else:
-            target = ensure_index(target)
-            if self.equals(target):
-                indexer = None
-            else:
-                if self.is_unique:
-                    indexer = self.get_indexer(
-                        target, method=method, limit=limit, tolerance=tolerance
-                    )
-                else:
-                    raise ValueError("cannot handle a non-unique multi-index!")
+        Get the locations from the leftmost 'b' in the first level
+        until the end of the multiindex:
 
-        if not isinstance(target, MultiIndex):
-            if indexer is None:
-                target = self
-            elif (indexer >= 0).all():
-                target = self.take(indexer)
-            else:
-                # hopefully?
-                target = MultiIndex.from_tuples(target)
+        >>> mi.get_slice_bound('b', side="left", kind="loc")
+        1
 
-        if (
-            preserve_names
-            and target.nlevels == self.nlevels
-            and target.names != self.names
-        ):
-            target = target.copy(deep=False)
-            target.names = self.names
+        Like above, but if you get the locations from the rightmost
+        'b' in the first level and 'f' in the second level:
 
-        return target, indexer
+        >>> mi.get_slice_bound(('b','f'), side="right", kind="loc")
+        3
 
-    def get_slice_bound(self, label, side, kind):
+        See Also
+        --------
+        MultiIndex.get_loc : Get location for a label or a tuple of labels.
+        MultiIndex.get_locs : Get location for a label/slice/list/mask or a
+                              sequence of such.
+        """
 
         if not isinstance(label, tuple):
             label = (label,)
@@ -2571,8 +2550,8 @@ def slice_locs(self, start=None, end=None, step=None, kind=None):
     def _partial_tup_index(self, tup, side="left"):
         if len(tup) > self.lexsort_depth:
             raise UnsortedIndexError(
-                "Key length (%d) was greater than MultiIndex"
-                " lexsort depth (%d)" % (len(tup), self.lexsort_depth)
+                f"Key length ({len(tup)}) was greater than MultiIndex lexsort depth "
+                f"({self.lexsort_depth})"
             )
 
         n = len(tup)
@@ -2581,9 +2560,9 @@ def _partial_tup_index(self, tup, side="left"):
         for k, (lab, lev, labs) in enumerate(zipped):
             section = labs[start:end]
 
-            if lab not in lev:
+            if lab not in lev and not isna(lab):
                 if not lev.is_type_compatible(lib.infer_dtype([lab], skipna=False)):
-                    raise TypeError("Level type mismatch: %s" % lab)
+                    raise TypeError(f"Level type mismatch: {lab}")
 
                 # short circuit
                 loc = lev.searchsorted(lab, side=side)
@@ -2591,13 +2570,38 @@ def _partial_tup_index(self, tup, side="left"):
                     loc -= 1
                 return start + section.searchsorted(loc, side=side)
 
-            idx = lev.get_loc(lab)
+            idx = self._get_loc_single_level_index(lev, lab)
             if k < n - 1:
                 end = start + section.searchsorted(idx, side="right")
                 start = start + section.searchsorted(idx, side="left")
             else:
                 return start + section.searchsorted(idx, side=side)
 
+    def _get_loc_single_level_index(self, level_index: Index, key: Hashable) -> int:
+        """
+        If key is NA value, location of index unify as -1.
+
+        Parameters
+        ----------
+        level_index: Index
+        key : label
+
+        Returns
+        -------
+        loc : int
+            If key is NA value, loc is -1
+            Else, location of key in index.
+
+        See Also
+        --------
+        Index.get_loc : The get_loc method for (single-level) index.
+        """
+
+        if is_scalar(key) and isna(key):
+            return -1
+        else:
+            return level_index.get_loc(key)
+
     def get_loc(self, key, method=None):
         """
         Get location for a label or a tuple of labels as an integer, slice or
@@ -2658,15 +2662,15 @@ def _maybe_to_slice(loc):
             mask[loc] = True
             return mask
 
-        if not isinstance(key, tuple):
+        if not isinstance(key, (tuple, list)):
+            # not including list here breaks some indexing, xref #30892
             loc = self._get_level_indexer(key, level=0)
             return _maybe_to_slice(loc)
 
         keylen = len(key)
         if self.nlevels < keylen:
             raise KeyError(
-                "Key length ({0}) exceeds index depth ({1})"
-                "".format(keylen, self.nlevels)
+                f"Key length ({keylen}) exceeds index depth ({self.nlevels})"
             )
 
         if keylen == self.nlevels and self.is_unique:
@@ -2697,7 +2701,9 @@ def _maybe_to_slice(loc):
         loc = np.arange(start, stop, dtype="int64")
 
         for i, k in enumerate(follow_key, len(lead_key)):
-            mask = self.codes[i][loc] == self.levels[i].get_loc(k)
+            mask = self.codes[i][loc] == self._get_loc_single_level_index(
+                self.levels[i], k
+            )
             if not mask.all():
                 loc = loc[mask]
             if not len(loc):
@@ -2715,7 +2721,7 @@ def get_loc_level(self, key, level=0, drop_level: bool = True):
         key : label or sequence of labels
         level : int/level name or list thereof, optional
         drop_level : bool, default True
-            if ``False``, the resulting index will not drop any level.
+            If ``False``, the resulting index will not drop any level.
 
         Returns
         -------
@@ -2792,7 +2798,7 @@ def maybe_mi_droplevels(indexer, levels, drop_level: bool):
                     indexer = self._get_level_indexer(key, level=level)
                     new_index = maybe_mi_droplevels(indexer, [0], drop_level)
                     return indexer, new_index
-            except TypeError:
+            except (TypeError, InvalidIndexError):
                 pass
 
             if not any(isinstance(k, slice) for k in key):
@@ -2925,7 +2931,7 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
 
         else:
 
-            code = level_index.get_loc(key)
+            code = self._get_loc_single_level_index(level_index, key)
 
             if level > 0 or self.lexsort_depth == 0:
                 # Desired level is not sorted
@@ -2944,47 +2950,46 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
 
     def get_locs(self, seq):
         """
-        Get location for a given label/slice/list/mask or a sequence of such as
-        an array of integers.
+        Get location for a sequence of labels.
 
         Parameters
         ----------
-        seq : label/slice/list/mask or a sequence of such
+        seq : label, slice, list, mask or a sequence of such
            You should use one of the above for each level.
            If a level should not be used, set it to ``slice(None)``.
 
         Returns
         -------
-        locs : array of integers suitable for passing to iloc
+        numpy.ndarray
+            NumPy array of integers suitable for passing to iloc.
+
+        See Also
+        --------
+        MultiIndex.get_loc : Get location for a label or a tuple of labels.
+        MultiIndex.slice_locs : Get slice location given start label(s) and
+                                end label(s).
 
         Examples
         --------
         >>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])
 
-        >>> mi.get_locs('b')
+        >>> mi.get_locs('b')  # doctest: +SKIP
         array([1, 2], dtype=int64)
 
-        >>> mi.get_locs([slice(None), ['e', 'f']])
+        >>> mi.get_locs([slice(None), ['e', 'f']])  # doctest: +SKIP
         array([1, 2], dtype=int64)
 
-        >>> mi.get_locs([[True, False, True], slice('e', 'f')])
+        >>> mi.get_locs([[True, False, True], slice('e', 'f')])  # doctest: +SKIP
         array([2], dtype=int64)
-
-        See Also
-        --------
-        MultiIndex.get_loc : Get location for a label or a tuple of labels.
-        MultiIndex.slice_locs : Get slice location given start label(s) and
-                                end label(s).
         """
-        from .numeric import Int64Index
+        from pandas.core.indexes.numeric import Int64Index
 
         # must be lexsorted to at least as many levels
         true_slices = [i for (i, s) in enumerate(com.is_true_slices(seq)) if s]
         if true_slices and true_slices[-1] >= self.lexsort_depth:
             raise UnsortedIndexError(
-                "MultiIndex slicing requires the index "
-                "to be lexsorted: slicing on levels {0}, "
-                "lexsort depth {1}".format(true_slices, self.lexsort_depth)
+                "MultiIndex slicing requires the index to be lexsorted: slicing "
+                f"on levels {true_slices}, lexsort depth {self.lexsort_depth}"
             )
         # indexer
         # this is the list of all values that we want to select
@@ -3067,8 +3072,70 @@ def _update_indexer(idxr, indexer=indexer):
         # empty indexer
         if indexer is None:
             return Int64Index([])._ndarray_values
+
+        indexer = self._reorder_indexer(seq, indexer)
+
         return indexer._ndarray_values
 
+    def _reorder_indexer(
+        self, seq: Tuple[Union[Scalar, Iterable, AnyArrayLike], ...], indexer: ArrayLike
+    ) -> ArrayLike:
+        """
+        Reorder an indexer of a MultiIndex (self) so that the label are in the
+        same order as given in seq
+
+        Parameters
+        ----------
+        seq : label/slice/list/mask or a sequence of such
+        indexer: an Int64Index indexer of self
+
+        Returns
+        -------
+        indexer : a sorted Int64Index indexer of self ordered as seq
+        """
+        # If the index is lexsorted and the list_like label in seq are sorted
+        # then we do not need to sort
+        if self.is_lexsorted():
+            need_sort = False
+            for i, k in enumerate(seq):
+                if is_list_like(k):
+                    if not need_sort:
+                        k_codes = self.levels[i].get_indexer(k)
+                        k_codes = k_codes[k_codes >= 0]  # Filter absent keys
+                        # True if the given codes are not ordered
+                        need_sort = (k_codes[:-1] > k_codes[1:]).any()
+            # Bail out if both index and seq are sorted
+            if not need_sort:
+                return indexer
+
+        n = len(self)
+        keys: Tuple[np.ndarray, ...] = tuple()
+        # For each level of the sequence in seq, map the level codes with the
+        # order they appears in a list-like sequence
+        # This mapping is then use to reorder the indexer
+        for i, k in enumerate(seq):
+            if com.is_bool_indexer(k):
+                new_order = np.arange(n)[indexer]
+            elif is_list_like(k):
+                # Generate a map with all level codes as sorted initially
+                key_order_map = np.ones(len(self.levels[i]), dtype=np.uint64) * len(
+                    self.levels[i]
+                )
+                # Set order as given in the indexer list
+                level_indexer = self.levels[i].get_indexer(k)
+                level_indexer = level_indexer[level_indexer >= 0]  # Filter absent keys
+                key_order_map[level_indexer] = np.arange(len(level_indexer))
+
+                new_order = key_order_map[self.codes[i][indexer]]
+            else:
+                # For all other case, use the same order as the level
+                new_order = np.arange(n)[indexer]
+            keys = (new_order,) + keys
+
+        # Find the reordering using lexsort on the keys mapping
+        ind = np.lexsort(keys)
+        return indexer[ind]
+
     def truncate(self, before=None, after=None):
         """
         Slice index between two labels / tuples, return new MultiIndex
@@ -3098,7 +3165,7 @@ def truncate(self, before=None, after=None):
 
         return MultiIndex(levels=new_levels, codes=new_codes, verify_integrity=False)
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determines if two MultiIndex objects have the same labeling information
         (the levels themselves do not necessarily have to be the same)
@@ -3114,6 +3181,11 @@ def equals(self, other):
             return False
 
         if not isinstance(other, MultiIndex):
+            # d-level MultiIndex can equal d-tuple Index
+            if not is_object_dtype(other.dtype):
+                if self.nlevels != other.nlevels:
+                    return False
+
             other_vals = com.values_from_object(ensure_index(other))
             return array_equivalent(self._ndarray_values, other_vals)
 
@@ -3149,7 +3221,7 @@ def equals(self, other):
 
         return True
 
-    def equal_levels(self, other):
+    def equal_levels(self, other) -> bool:
         """
         Return True if the levels of both MultiIndex objects are the same
 
@@ -3162,6 +3234,9 @@ def equal_levels(self, other):
                 return False
         return True
 
+    # --------------------------------------------------------------------
+    # Set Methods
+
     def union(self, other, sort=None):
         """
         Form the union of two MultiIndex objects
@@ -3314,21 +3389,6 @@ def difference(self, other, sort=None):
         else:
             return MultiIndex.from_tuples(difference, sortorder=0, names=result_names)
 
-    @Appender(_index_shared_docs["astype"])
-    def astype(self, dtype, copy=True):
-        dtype = pandas_dtype(dtype)
-        if is_categorical_dtype(dtype):
-            msg = "> 1 ndim Categorical are not supported at this time"
-            raise NotImplementedError(msg)
-        elif not is_object_dtype(dtype):
-            msg = (
-                "Setting {cls} dtype to anything other than object is not supported"
-            ).format(cls=self.__class__)
-            raise TypeError(msg)
-        elif copy is True:
-            return self._shallow_copy()
-        return self
-
     def _convert_can_do_setop(self, other):
         result_names = self.names
 
@@ -3349,7 +3409,24 @@ def _convert_can_do_setop(self, other):
             result_names = self.names if self.names == other.names else None
         return other, result_names
 
-    def insert(self, loc, item):
+    # --------------------------------------------------------------------
+
+    @Appender(Index.astype.__doc__)
+    def astype(self, dtype, copy=True):
+        dtype = pandas_dtype(dtype)
+        if is_categorical_dtype(dtype):
+            msg = "> 1 ndim Categorical are not supported at this time"
+            raise NotImplementedError(msg)
+        elif not is_object_dtype(dtype):
+            raise TypeError(
+                f"Setting {type(self)} dtype to anything other "
+                "than object is not supported"
+            )
+        elif copy is True:
+            return self._shallow_copy()
+        return self
+
+    def insert(self, loc: int, item):
         """
         Make new MultiIndex inserting new item at location
 
@@ -3416,14 +3493,11 @@ def isin(self, values, level=None):
             return algos.isin(self.values, values)
         else:
             num = self._get_level_number(level)
-            levs = self.levels[num]
-            level_codes = self.codes[num]
+            levs = self.get_level_values(num)
 
-            sought_labels = levs.isin(values).nonzero()[0]
             if levs.size == 0:
-                return np.zeros(len(level_codes), dtype=np.bool_)
-            else:
-                return np.lib.arraysetops.in1d(level_codes, sought_labels)
+                return np.zeros(len(levs), dtype=np.bool_)
+            return levs.isin(values)
 
 
 MultiIndex._add_numeric_methods_disabled()
@@ -3431,7 +3505,7 @@ def isin(self, values, level=None):
 MultiIndex._add_logical_methods_disabled()
 
 
-def _sparsify(label_list, start=0, sentinel=""):
+def _sparsify(label_list, start: int = 0, sentinel=""):
     pivoted = list(zip(*label_list))
     k = len(label_list)
 
@@ -3459,7 +3533,7 @@ def _sparsify(label_list, start=0, sentinel=""):
     return list(zip(*result))
 
 
-def _get_na_rep(dtype):
+def _get_na_rep(dtype) -> str:
     return {np.datetime64: "NaT", np.timedelta64: "NaT"}.get(dtype, "NaN")
 
 
@@ -3492,3 +3566,26 @@ def maybe_droplevels(index, key):
             pass
 
     return index
+
+
+def _coerce_indexer_frozen(array_like, categories, copy: bool = False) -> np.ndarray:
+    """
+    Coerce the array_like indexer to the smallest integer dtype that can encode all
+    of the given categories.
+
+    Parameters
+    ----------
+    array_like : array-like
+    categories : array-like
+    copy : bool
+
+    Returns
+    -------
+    np.ndarray
+        Non-writeable.
+    """
+    array_like = coerce_indexer_dtype(array_like, categories)
+    if copy:
+        array_like = array_like.copy()
+    array_like.flags.writeable = False
+    return array_like
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 2cdf73788dd9b..877b3d1d2ba30 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -1,10 +1,12 @@
-import warnings
+from typing import Any
 
 import numpy as np
 
-from pandas._libs import index as libindex
+from pandas._libs import index as libindex, lib
+from pandas._typing import Dtype
 from pandas.util._decorators import Appender, cache_readonly
 
+from pandas.core.dtypes.cast import astype_nansafe
 from pandas.core.dtypes.common import (
     is_bool,
     is_bool_dtype,
@@ -14,6 +16,8 @@
     is_float_dtype,
     is_integer_dtype,
     is_scalar,
+    is_signed_integer_dtype,
+    is_unsigned_integer_dtype,
     needs_i8_conversion,
     pandas_dtype,
 )
@@ -21,13 +25,14 @@
     ABCFloat64Index,
     ABCInt64Index,
     ABCRangeIndex,
+    ABCSeries,
     ABCUInt64Index,
 )
 from pandas.core.dtypes.missing import isna
 
 from pandas.core import algorithms
 import pandas.core.common as com
-from pandas.core.indexes.base import Index, InvalidIndexError, _index_shared_docs
+from pandas.core.indexes.base import Index, maybe_extract_name
 from pandas.core.ops import get_op_result_name
 
 _num_index_shared_docs = dict()
@@ -35,28 +40,27 @@
 
 class NumericIndex(Index):
     """
-    Provide numeric type operations
-
-    This is an abstract class
+    Provide numeric type operations.
 
+    This is an abstract class.
     """
 
     _is_numeric_dtype = True
 
-    def __new__(cls, data=None, dtype=None, copy=False, name=None, fastpath=None):
+    def __new__(cls, data=None, dtype=None, copy=False, name=None):
+        cls._validate_dtype(dtype)
+        name = maybe_extract_name(name, data, cls)
 
-        if fastpath is not None:
-            warnings.warn(
-                "The 'fastpath' keyword is deprecated, and will be "
-                "removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if fastpath:
-                return cls._simple_new(data, name=name)
+        # Coerce to ndarray if not already ndarray or Index
+        if not isinstance(data, (np.ndarray, Index)):
+            if is_scalar(data):
+                raise cls._scalar_data_error(data)
 
-        # is_scalar, generators handled in coerce_to_ndarray
-        data = cls._coerce_to_ndarray(data)
+            # other iterable of some kind
+            if not isinstance(data, (ABCSeries, list, tuple)):
+                data = list(data)
+
+            data = np.asarray(data, dtype=dtype)
 
         if issubclass(data.dtype.type, str):
             cls._string_data_error(data)
@@ -67,18 +71,38 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None, fastpath=None):
         else:
             subarr = data
 
-        if name is None and hasattr(data, "name"):
-            name = data.name
+        if subarr.ndim > 1:
+            # GH#13601, GH#20285, GH#27125
+            raise ValueError("Index data must be 1-dimensional")
+
+        subarr = np.asarray(subarr)
         return cls._simple_new(subarr, name=name)
 
-    @Appender(_index_shared_docs["_maybe_cast_slice_bound"])
+    @classmethod
+    def _validate_dtype(cls, dtype: Dtype) -> None:
+        if dtype is None:
+            return
+        validation_metadata = {
+            "int64index": (is_signed_integer_dtype, "signed integer"),
+            "uint64index": (is_unsigned_integer_dtype, "unsigned integer"),
+            "float64index": (is_float_dtype, "float"),
+            "rangeindex": (is_signed_integer_dtype, "signed integer"),
+        }
+
+        validation_func, expected = validation_metadata[cls._typ]
+        if not validation_func(dtype):
+            raise ValueError(
+                f"Incorrect `dtype` passed: expected {expected}, received {dtype}"
+            )
+
+    @Appender(Index._maybe_cast_slice_bound.__doc__)
     def _maybe_cast_slice_bound(self, label, side, kind):
-        assert kind in ["ix", "loc", "getitem", None]
+        assert kind in ["loc", "getitem", None]
 
         # we will try to coerce to integers
         return self._maybe_cast_indexer(label)
 
-    @Appender(_index_shared_docs["_shallow_copy"])
+    @Appender(Index._shallow_copy.__doc__)
     def _shallow_copy(self, values=None, **kwargs):
         if values is not None and not self._can_hold_na:
             # Ensure we are not returning an Int64Index with float data:
@@ -86,8 +110,9 @@ def _shallow_copy(self, values=None, **kwargs):
         return super()._shallow_copy(values=values, **kwargs)
 
     def _convert_for_op(self, value):
-        """ Convert value to be insertable to ndarray """
-
+        """
+        Convert value to be insertable to ndarray.
+        """
         if is_bool(value) or is_bool_dtype(value):
             # force conversion to object
             # so we don't lose the bools
@@ -102,19 +127,13 @@ def _convert_tolerance(self, tolerance, target):
         if not np.issubdtype(tolerance.dtype, np.number):
             if tolerance.ndim > 0:
                 raise ValueError(
-                    (
-                        "tolerance argument for %s must contain "
-                        "numeric elements if it is list type"
-                    )
-                    % (type(self).__name__,)
+                    f"tolerance argument for {type(self).__name__} must contain "
+                    "numeric elements if it is list type"
                 )
             else:
                 raise ValueError(
-                    (
-                        "tolerance argument for %s must be numeric "
-                        "if it is a scalar: %r"
-                    )
-                    % (type(self).__name__, tolerance)
+                    f"tolerance argument for {type(self).__name__} must be numeric "
+                    f"if it is a scalar: {repr(tolerance)}"
                 )
         return tolerance
 
@@ -132,14 +151,14 @@ def _concat_same_dtype(self, indexes, name):
         return result.rename(name)
 
     @property
-    def is_all_dates(self):
+    def is_all_dates(self) -> bool:
         """
-        Checks that all the labels are datetime objects
+        Checks that all the labels are datetime objects.
         """
         return False
 
     @Appender(Index.insert.__doc__)
-    def insert(self, loc, item):
+    def insert(self, loc: int, item):
         # treat NA values as nans:
         if is_scalar(item) and isna(item):
             item = self._na_value
@@ -168,16 +187,16 @@ def _union(self, other, sort):
 ] = """
     Immutable ndarray implementing an ordered, sliceable set. The basic object
     storing axis labels for all pandas objects. %(klass)s is a special case
-    of `Index` with purely %(ltype)s labels. %(extra)s
+    of `Index` with purely %(ltype)s labels. %(extra)s.
 
     Parameters
     ----------
     data : array-like (1-dimensional)
     dtype : NumPy dtype (default: %(dtype)s)
     copy : bool
-        Make a copy of input ndarray
+        Make a copy of input ndarray.
     name : object
-        Name to be stored in the index
+        Name to be stored in the index.
 
     Attributes
     ----------
@@ -204,7 +223,9 @@ class IntegerIndex(NumericIndex):
     This is an abstract class for Int64Index, UInt64Index.
     """
 
-    def __contains__(self, key):
+    _default_dtype: np.dtype
+
+    def __contains__(self, key) -> bool:
         """
         Check if key is a float and has a decimal. If it has, return False.
         """
@@ -216,34 +237,35 @@ def __contains__(self, key):
         except (OverflowError, TypeError, ValueError):
             return False
 
-
-class Int64Index(IntegerIndex):
-    __doc__ = _num_index_shared_docs["class_descr"] % _int64_descr_args
-
-    _typ = "int64index"
-    _can_hold_na = False
-    _engine_type = libindex.Int64Engine
-    _default_dtype = np.int64
-
     @property
-    def inferred_type(self):
-        """Always 'integer' for ``Int64Index``"""
+    def inferred_type(self) -> str:
+        """
+        Always 'integer' for ``Int64Index`` and ``UInt64Index``
+        """
         return "integer"
 
     @property
-    def asi8(self):
+    def asi8(self) -> np.ndarray:
         # do not cache or you'll create a memory leak
-        return self.values.view("i8")
+        return self.values.view(self._default_dtype)
 
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
+    @Appender(Index._convert_scalar_indexer.__doc__)
+    def _convert_scalar_indexer(self, key, kind: str):
+        assert kind in ["loc", "getitem"]
 
-        # don't coerce ilocs to integers
-        if kind != "iloc":
-            key = self._maybe_cast_indexer(key)
+        # never iloc, which we don't coerce to integers
+        key = self._maybe_cast_indexer(key)
         return super()._convert_scalar_indexer(key, kind=kind)
 
+
+class Int64Index(IntegerIndex):
+    __doc__ = _num_index_shared_docs["class_descr"] % _int64_descr_args
+
+    _typ = "int64index"
+    _can_hold_na = False
+    _engine_type = libindex.Int64Engine
+    _default_dtype = np.dtype(np.int64)
+
     def _wrap_joined_index(self, joined, other):
         name = get_op_result_name(self, other)
         return Int64Index(joined, name=name)
@@ -257,9 +279,9 @@ def _assert_safe_casting(cls, data, subarr):
             if not np.array_equal(data, subarr):
                 raise TypeError("Unsafe NumPy casting, you must explicitly cast")
 
-    def _is_compatible_with_other(self, other):
+    def _is_compatible_with_other(self, other) -> bool:
         return super()._is_compatible_with_other(other) or all(
-            isinstance(type(obj), (ABCInt64Index, ABCFloat64Index, ABCRangeIndex))
+            isinstance(obj, (ABCInt64Index, ABCFloat64Index, ABCRangeIndex))
             for obj in [self, other]
         )
 
@@ -278,38 +300,21 @@ class UInt64Index(IntegerIndex):
     _typ = "uint64index"
     _can_hold_na = False
     _engine_type = libindex.UInt64Engine
-    _default_dtype = np.uint64
+    _default_dtype = np.dtype(np.uint64)
 
-    @property
-    def inferred_type(self):
-        """Always 'integer' for ``UInt64Index``"""
-        return "integer"
-
-    @property
-    def asi8(self):
-        # do not cache or you'll create a memory leak
-        return self.values.view("u8")
-
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
-
-        # don't coerce ilocs to integers
-        if kind != "iloc":
-            key = self._maybe_cast_indexer(key)
-        return super()._convert_scalar_indexer(key, kind=kind)
-
-    @Appender(_index_shared_docs["_convert_arr_indexer"])
+    @Appender(Index._convert_arr_indexer.__doc__)
     def _convert_arr_indexer(self, keyarr):
-        # Cast the indexer to uint64 if possible so
-        # that the values returned from indexing are
-        # also uint64.
-        keyarr = com.asarray_tuplesafe(keyarr)
-        if is_integer_dtype(keyarr):
-            return com.asarray_tuplesafe(keyarr, dtype=np.uint64)
-        return keyarr
+        # Cast the indexer to uint64 if possible so that the values returned
+        # from indexing are also uint64.
+        dtype = None
+        if is_integer_dtype(keyarr) or (
+            lib.infer_dtype(keyarr, skipna=False) == "integer"
+        ):
+            dtype = np.uint64
+
+        return com.asarray_tuplesafe(keyarr, dtype=dtype)
 
-    @Appender(_index_shared_docs["_convert_index_indexer"])
+    @Appender(Index._convert_index_indexer.__doc__)
     def _convert_index_indexer(self, keyarr):
         # Cast the indexer to uint64 if possible so
         # that the values returned from indexing are
@@ -331,10 +336,9 @@ def _assert_safe_casting(cls, data, subarr):
             if not np.array_equal(data, subarr):
                 raise TypeError("Unsafe NumPy casting, you must explicitly cast")
 
-    def _is_compatible_with_other(self, other):
+    def _is_compatible_with_other(self, other) -> bool:
         return super()._is_compatible_with_other(other) or all(
-            isinstance(type(obj), (ABCUInt64Index, ABCFloat64Index))
-            for obj in [self, other]
+            isinstance(obj, (ABCUInt64Index, ABCFloat64Index)) for obj in [self, other]
         )
 
 
@@ -354,48 +358,50 @@ class Float64Index(NumericIndex):
     _default_dtype = np.float64
 
     @property
-    def inferred_type(self):
-        """Always 'floating' for ``Float64Index``"""
+    def inferred_type(self) -> str:
+        """
+        Always 'floating' for ``Float64Index``
+        """
         return "floating"
 
-    @Appender(_index_shared_docs["astype"])
+    @Appender(Index.astype.__doc__)
     def astype(self, dtype, copy=True):
         dtype = pandas_dtype(dtype)
         if needs_i8_conversion(dtype):
-            msg = (
-                "Cannot convert Float64Index to dtype {dtype}; integer "
+            raise TypeError(
+                f"Cannot convert Float64Index to dtype {dtype}; integer "
                 "values are required for conversion"
-            ).format(dtype=dtype)
-            raise TypeError(msg)
-        elif (
-            is_integer_dtype(dtype) and not is_extension_array_dtype(dtype)
-        ) and self.hasnans:
+            )
+        elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
             # TODO(jreback); this can change once we have an EA Index type
             # GH 13149
-            raise ValueError("Cannot convert NA to integer")
+            arr = astype_nansafe(self.values, dtype=dtype)
+            return Int64Index(arr)
         return super().astype(dtype, copy=copy)
 
-    @Appender(_index_shared_docs["_convert_scalar_indexer"])
-    def _convert_scalar_indexer(self, key, kind=None):
-        assert kind in ["ix", "loc", "getitem", "iloc", None]
+    # ----------------------------------------------------------------
+    # Indexing Methods
 
-        if kind == "iloc":
-            return self._validate_indexer("positional", key, kind)
+    @Appender(Index._should_fallback_to_positional.__doc__)
+    def _should_fallback_to_positional(self):
+        return False
 
+    @Appender(Index._convert_scalar_indexer.__doc__)
+    def _convert_scalar_indexer(self, key, kind: str):
+        assert kind in ["loc", "getitem"]
+        # no-op for non-iloc
         return key
 
-    @Appender(_index_shared_docs["_convert_slice_indexer"])
-    def _convert_slice_indexer(self, key, kind=None):
-        # if we are not a slice, then we are done
-        if not isinstance(key, slice):
-            return key
-
-        if kind == "iloc":
-            return super()._convert_slice_indexer(key, kind=kind)
+    @Appender(Index._convert_slice_indexer.__doc__)
+    def _convert_slice_indexer(self, key: slice, kind: str):
+        assert kind in ["loc", "getitem"]
 
+        # We always treat __getitem__ slicing as label-based
         # translate to locations
         return self.slice_indexer(key.start, key.stop, key.step, kind=kind)
 
+    # ----------------------------------------------------------------
+
     def _format_native_types(
         self, na_rep="", float_format=None, decimal=".", quoting=None, **kwargs
     ):
@@ -411,18 +417,7 @@ def _format_native_types(
         )
         return formatter.get_result_as_array()
 
-    def get_value(self, series, key):
-        """ we always want to get an index value, never a value """
-        if not is_scalar(key):
-            raise InvalidIndexError
-
-        k = com.values_from_object(key)
-        loc = self.get_loc(k)
-        new_values = com.values_from_object(series)[loc]
-
-        return new_values
-
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determines if two Index objects contain the same elements.
         """
@@ -444,42 +439,31 @@ def equals(self, other):
         except (TypeError, ValueError):
             return False
 
-    def __contains__(self, other):
+    def __contains__(self, other: Any) -> bool:
+        hash(other)
         if super().__contains__(other):
             return True
 
-        try:
-            # if other is a sequence this throws a ValueError
-            return np.isnan(other) and self.hasnans
-        except ValueError:
-            try:
-                return len(other) <= 1 and other.item() in self
-            except AttributeError:
-                return len(other) <= 1 and other in self
-            except TypeError:
-                pass
-        except TypeError:
-            pass
+        return is_float(other) and np.isnan(other) and self.hasnans
 
-        return False
-
-    @Appender(_index_shared_docs["get_loc"])
+    @Appender(Index.get_loc.__doc__)
     def get_loc(self, key, method=None, tolerance=None):
-        try:
-            if np.all(np.isnan(key)) or is_bool(key):
-                nan_idxs = self._nan_idxs
-                try:
-                    return nan_idxs.item()
-                except ValueError:
-                    if not len(nan_idxs):
-                        raise KeyError(key)
-                    return nan_idxs
-        except (TypeError, NotImplementedError):
-            pass
+        if is_bool(key):
+            # Catch this to avoid accidentally casting to 1.0
+            raise KeyError(key)
+
+        if is_float(key) and np.isnan(key):
+            nan_idxs = self._nan_idxs
+            if not len(nan_idxs):
+                raise KeyError(key)
+            elif len(nan_idxs) == 1:
+                return nan_idxs[0]
+            return nan_idxs
+
         return super().get_loc(key, method=method, tolerance=tolerance)
 
     @cache_readonly
-    def is_unique(self):
+    def is_unique(self) -> bool:
         return super().is_unique and self._nan_idxs.size < 2
 
     @Appender(Index.isin.__doc__)
@@ -488,11 +472,10 @@ def isin(self, values, level=None):
             self._validate_index_level(level)
         return algorithms.isin(np.array(self), values)
 
-    def _is_compatible_with_other(self, other):
+    def _is_compatible_with_other(self, other) -> bool:
         return super()._is_compatible_with_other(other) or all(
             isinstance(
-                type(obj),
-                (ABCInt64Index, ABCFloat64Index, ABCUInt64Index, ABCRangeIndex),
+                obj, (ABCInt64Index, ABCFloat64Index, ABCUInt64Index, ABCRangeIndex),
             )
             for obj in [self, other]
         )
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index ee85b0fb91acb..987725bb4b70b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -1,40 +1,48 @@
 from datetime import datetime, timedelta
-import warnings
+from typing import Any
 import weakref
 
 import numpy as np
 
 from pandas._libs import index as libindex
-from pandas._libs.tslibs import NaT, frequencies as libfrequencies, iNaT, resolution
-from pandas._libs.tslibs.period import DIFFERENT_FREQ, IncompatibleFrequency, Period
-from pandas.util._decorators import Appender, Substitution, cache_readonly
+from pandas._libs.tslibs import frequencies as libfrequencies, resolution
+from pandas._libs.tslibs.parsing import parse_time_string
+from pandas._libs.tslibs.period import Period
+from pandas.util._decorators import Appender, cache_readonly
 
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     is_bool_dtype,
     is_datetime64_any_dtype,
+    is_dtype_equal,
     is_float,
-    is_float_dtype,
     is_integer,
     is_integer_dtype,
+    is_object_dtype,
+    is_scalar,
     pandas_dtype,
 )
 
-from pandas.core import common as com
-from pandas.core.accessor import delegate_names
-from pandas.core.algorithms import unique1d
-from pandas.core.arrays.period import PeriodArray, period_array, validate_dtype_freq
-from pandas.core.base import _shared_docs
+from pandas.core.arrays.period import (
+    PeriodArray,
+    period_array,
+    raise_on_incompatible,
+    validate_dtype_freq,
+)
+import pandas.core.common as com
 import pandas.core.indexes.base as ibase
-from pandas.core.indexes.base import _index_shared_docs, ensure_index
-from pandas.core.indexes.datetimelike import (
-    DatetimeIndexOpsMixin,
-    DatetimelikeDelegateMixin,
+from pandas.core.indexes.base import (
+    InvalidIndexError,
+    _index_shared_docs,
+    ensure_index,
+    maybe_extract_name,
 )
-from pandas.core.indexes.datetimes import DatetimeIndex, Index, Int64Index
-from pandas.core.missing import isna
+from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
+from pandas.core.indexes.datetimes import DatetimeIndex, Index
+from pandas.core.indexes.extension import inherit_names
+from pandas.core.indexes.numeric import Int64Index
 from pandas.core.ops import get_op_result_name
-from pandas.core.tools.datetimes import DateParseError, parse_time_string
+from pandas.core.tools.datetimes import DateParseError
 
 from pandas.tseries import frequencies
 from pandas.tseries.offsets import DateOffset, Tick
@@ -42,7 +50,6 @@
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(dict(target_klass="PeriodIndex or list of Periods"))
 
-
 # --- Period index sketch
 
 
@@ -57,58 +64,28 @@ def _new_PeriodIndex(cls, **d):
         return cls(values, **d)
 
 
-class PeriodDelegateMixin(DatetimelikeDelegateMixin):
-    """
-    Delegate from PeriodIndex to PeriodArray.
-    """
-
-    _delegate_class = PeriodArray
-    _delegated_properties = PeriodArray._datetimelike_ops
-    _delegated_methods = set(PeriodArray._datetimelike_methods) | {
-        "_addsub_int_array",
-        "strftime",
-    }
-    _raw_properties = {"is_leap_year"}
-
-
-@delegate_names(PeriodArray, PeriodDelegateMixin._delegated_properties, typ="property")
-@delegate_names(
-    PeriodArray, PeriodDelegateMixin._delegated_methods, typ="method", overwrite=True
+@inherit_names(
+    ["strftime", "to_timestamp", "asfreq", "start_time", "end_time"]
+    + PeriodArray._field_ops,
+    PeriodArray,
+    wrap=True,
 )
-class PeriodIndex(DatetimeIndexOpsMixin, Int64Index, PeriodDelegateMixin):
+@inherit_names(["is_leap_year", "freq", "_format_native_types"], PeriodArray)
+class PeriodIndex(DatetimeIndexOpsMixin, Int64Index):
     """
-    Immutable ndarray holding ordinal values indicating regular periods in
-    time such as particular years, quarters, months, etc.
+    Immutable ndarray holding ordinal values indicating regular periods in time.
 
     Index keys are boxed to Period objects which carries the metadata (eg,
     frequency information).
 
     Parameters
     ----------
-    data : array-like (1d integer np.ndarray or PeriodArray), optional
-        Optional period-like data to construct index with
+    data : array-like (1d int np.ndarray or PeriodArray), optional
+        Optional period-like data to construct index with.
     copy : bool
-        Make a copy of input ndarray
-    freq : string or period object, optional
+        Make a copy of input ndarray.
+    freq : str or period object, optional
         One of pandas period strings or corresponding objects
-    start : starting value, period-like, optional
-        If data is None, used as the start point in generating regular
-        period data.
-
-        .. deprecated:: 0.24.0
-
-    periods : int, optional, > 0
-        Number of periods to generate, if generating index. Takes precedence
-        over end argument
-
-        .. deprecated:: 0.24.0
-
-    end : end value, period-like, optional
-        If periods is none, generated index will extend to first conforming
-        period on or just past end argument
-
-        .. deprecated:: 0.24.0
-
     year : int, array, or Series, default None
     month : int, array, or Series, default None
     quarter : int, array, or Series, default None
@@ -117,7 +94,7 @@ class PeriodIndex(DatetimeIndexOpsMixin, Int64Index, PeriodDelegateMixin):
     minute : int, array, or Series, default None
     second : int, array, or Series, default None
     tz : object, default None
-        Timezone for converting datetime64 data to Periods
+        Timezone for converting datetime64 data to Periods.
     dtype : str or PeriodDtype, default None
 
     Attributes
@@ -157,11 +134,6 @@ class PeriodIndex(DatetimeIndexOpsMixin, Int64Index, PeriodDelegateMixin):
     TimedeltaIndex : Index of timedelta64 data.
     period_range : Create a fixed-frequency PeriodIndex.
 
-    Notes
-    -----
-    Creating a PeriodIndex based on `start`, `periods`, and `end` has
-    been deprecated in favor of :func:`period_range`.
-
     Examples
     --------
     >>> idx = pd.PeriodIndex(year=year_arr, quarter=q_arr)
@@ -174,7 +146,7 @@ class PeriodIndex(DatetimeIndexOpsMixin, Int64Index, PeriodDelegateMixin):
     _is_numeric_dtype = False
     _infer_as_myclass = True
 
-    _data = None
+    _data: PeriodArray
 
     _engine_type = libindex.PeriodEngine
     _supports_partial_string_indexing = True
@@ -187,14 +159,11 @@ def __new__(
         data=None,
         ordinal=None,
         freq=None,
-        start=None,
-        end=None,
-        periods=None,
         tz=None,
         dtype=None,
         copy=False,
         name=None,
-        **fields
+        **fields,
     ):
 
         valid_field_set = {
@@ -208,40 +177,16 @@ def __new__(
         }
 
         if not set(fields).issubset(valid_field_set):
-            raise TypeError(
-                "__new__() got an unexpected keyword argument {}".format(
-                    list(set(fields) - valid_field_set)[0]
-                )
-            )
+            argument = list(set(fields) - valid_field_set)[0]
+            raise TypeError(f"__new__() got an unexpected keyword argument {argument}")
 
-        if name is None and hasattr(data, "name"):
-            name = data.name
+        name = maybe_extract_name(name, data, cls)
 
         if data is None and ordinal is None:
             # range-based.
-            data, freq2 = PeriodArray._generate_range(start, end, periods, freq, fields)
-            # PeriodArray._generate range does validate that fields is
+            data, freq2 = PeriodArray._generate_range(None, None, None, freq, fields)
+            # PeriodArray._generate range does validation that fields is
             # empty when really using the range-based constructor.
-            if not fields:
-                msg = (
-                    "Creating a PeriodIndex by passing range "
-                    "endpoints is deprecated.  Use "
-                    "`pandas.period_range` instead."
-                )
-                # period_range differs from PeriodIndex for cases like
-                # start="2000", periods=4
-                # PeriodIndex interprets that as A-DEC freq.
-                # period_range interprets it as 'D' freq.
-                cond = freq is None and (
-                    (start and not isinstance(start, Period))
-                    or (end and not isinstance(end, Period))
-                )
-                if cond:
-                    msg += (
-                        " Note that the default `freq` may differ. Pass "
-                        "'freq=\"{}\"' to ensure the same output."
-                    ).format(freq2.freqstr)
-                warnings.warn(msg, FutureWarning, stacklevel=2)
             freq = freq2
 
             data = PeriodArray(data, freq=freq)
@@ -276,24 +221,13 @@ def _simple_new(cls, values, name=None, freq=None, **kwargs):
 
         Parameters
         ----------
-        values : PeriodArray, PeriodIndex, Index[int64], ndarray[int64]
+        values : PeriodArray
             Values that can be converted to a PeriodArray without inference
             or coercion.
-
         """
-        # TODO: raising on floats is tested, but maybe not useful.
-        # Should the callers know not to pass floats?
-        # At the very least, I think we can ensure that lists aren't passed.
-        if isinstance(values, list):
-            values = np.asarray(values)
-        if is_float_dtype(values):
-            raise TypeError("PeriodIndex._simple_new does not accept floats.")
-        if freq:
-            freq = Period._maybe_convert_freq(freq)
-        values = PeriodArray(values, freq=freq)
+        assert isinstance(values, PeriodArray), type(values)
+        assert freq is None or freq == values.freq, (freq, values.freq)
 
-        if not isinstance(values, PeriodArray):
-            raise TypeError("PeriodIndex._simple_new only accepts PeriodArray")
         result = object.__new__(cls)
         result._data = values
         # For groupby perf. See note in indexes/base about _index_data
@@ -310,23 +244,9 @@ def values(self):
         return np.asarray(self)
 
     @property
-    def freq(self):
-        return self._data.freq
-
-    @freq.setter
-    def freq(self, value):
-        value = Period._maybe_convert_freq(value)
-        # TODO: When this deprecation is enforced, PeriodIndex.freq can
-        # be removed entirely, and we'll just inherit.
-        msg = (
-            "Setting {cls}.freq has been deprecated and will be "
-            "removed in a future version; use {cls}.asfreq instead. "
-            "The {cls}.freq setter is not guaranteed to work."
-        )
-        warnings.warn(msg.format(cls=type(self).__name__), FutureWarning, stacklevel=2)
-        # PeriodArray._freq isn't actually mutable. We set the private _freq
-        # here, but people shouldn't be doing this anyway.
-        self._data._freq = value
+    def _has_complex_internals(self):
+        # used to avoid libreduction code paths, which raise or require conversion
+        return True
 
     def _shallow_copy(self, values=None, **kwargs):
         # TODO: simplify, figure out type of values
@@ -334,19 +254,14 @@ def _shallow_copy(self, values=None, **kwargs):
             values = self._data
 
         if isinstance(values, type(self)):
-            values = values._values
+            values = values._data
 
         if not isinstance(values, PeriodArray):
-            if isinstance(values, np.ndarray) and is_integer_dtype(values.dtype):
+            if isinstance(values, np.ndarray) and values.dtype == "i8":
                 values = PeriodArray(values, freq=self.freq)
             else:
-                # in particular, I would like to avoid period_array here.
-                # Some people seem to be calling use with unexpected types
-                # Index.difference -> ndarray[Period]
-                # DatetimelikeIndexOpsMixin.repeat -> ndarray[ordinal]
-                # I think that once all of Datetime* are EAs, we can simplify
-                # this quite a bit.
-                values = period_array(values, freq=self.freq)
+                # GH#30713 this should never be reached
+                raise TypeError(type(values), getattr(values, "dtype", None))
 
         # We don't allow changing `freq` in _shallow_copy.
         validate_dtype_freq(self.dtype, kwargs.get("freq"))
@@ -361,22 +276,6 @@ def _shallow_copy_with_infer(self, values=None, **kwargs):
         """ we always want to return a PeriodIndex """
         return self._shallow_copy(values=values, **kwargs)
 
-    @property
-    def _box_func(self):
-        """Maybe box an ordinal or Period"""
-        # TODO(DatetimeArray): Avoid double-boxing
-        # PeriodArray takes care of boxing already, so we need to check
-        # whether we're given an ordinal or a Period. It seems like some
-        # places outside of indexes/period.py are calling this _box_func,
-        # but passing data that's already boxed.
-        def func(x):
-            if isinstance(x, Period) or x is NaT:
-                return x
-            else:
-                return Period._from_ordinal(ordinal=x, freq=self.freq)
-
-        return func
-
     def _maybe_convert_timedelta(self, other):
         """
         Convert timedelta-like input to an integer multiple of self.freq
@@ -406,10 +305,7 @@ def _maybe_convert_timedelta(self, other):
             if base == self.freq.rule_code:
                 return other.n
 
-            msg = DIFFERENT_FREQ.format(
-                cls=type(self).__name__, own_freq=self.freqstr, other_freq=other.freqstr
-            )
-            raise IncompatibleFrequency(msg)
+            raise raise_on_incompatible(self, other)
         elif is_integer(other):
             # integer is passed to .shift via
             # _add_datetimelike_methods basically
@@ -417,18 +313,11 @@ def _maybe_convert_timedelta(self, other):
             return other
 
         # raise when input doesn't have freq
-        msg = DIFFERENT_FREQ.format(
-            cls=type(self).__name__, own_freq=self.freqstr, other_freq=None
-        )
-        raise IncompatibleFrequency(msg)
+        raise raise_on_incompatible(self, None)
 
     # ------------------------------------------------------------------------
     # Rendering Methods
 
-    def _format_native_types(self, na_rep="NaT", quoting=None, **kwargs):
-        # just dispatch, return ndarray
-        return self._data._format_native_types(na_rep=na_rep, quoting=quoting, **kwargs)
-
     def _mpl_repr(self):
         # how to represent ourselves to matplotlib
         return self.astype(object).values
@@ -446,38 +335,29 @@ def _engine(self):
         period = weakref.ref(self)
         return self._engine_type(period, len(self))
 
-    @Appender(_index_shared_docs["contains"])
-    def __contains__(self, key):
+    @Appender(Index.__contains__.__doc__)
+    def __contains__(self, key: Any) -> bool:
         if isinstance(key, Period):
             if key.freq != self.freq:
                 return False
             else:
                 return key.ordinal in self._engine
         else:
+            hash(key)
             try:
                 self.get_loc(key)
                 return True
-            except Exception:
+            except KeyError:
                 return False
 
     @cache_readonly
-    def _int64index(self):
+    def _int64index(self) -> Int64Index:
         return Int64Index._simple_new(self.asi8, name=self.name)
 
     # ------------------------------------------------------------------------
     # Index Methods
 
-    def _coerce_scalar_to_index(self, item):
-        """
-        we need to coerce a scalar to a compat for our index type
-
-        Parameters
-        ----------
-        item : scalar item to coerce
-        """
-        return PeriodIndex([item], **self._get_attributes_dict())
-
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         if is_integer_dtype(dtype):
             return self.asi8
         else:
@@ -505,10 +385,10 @@ def __array_wrap__(self, result, context=None):
                     return Index(result, name=name)
             elif isinstance(func, np.ufunc):
                 if "M->M" not in func.types:
-                    msg = "ufunc '{0}' not supported for the PeriodIndex"
+                    msg = f"ufunc '{func.__name__}' not supported for the PeriodIndex"
                     # This should be TypeError, but TypeError cannot be raised
                     # from here because numpy catches.
-                    raise ValueError(msg.format(func.__name__))
+                    raise ValueError(msg)
 
         if is_bool_dtype(result):
             return result
@@ -540,7 +420,7 @@ def asof_locs(self, where, mask):
 
         return result
 
-    @Appender(_index_shared_docs["astype"])
+    @Appender(Index.astype.__doc__)
     def astype(self, dtype, copy=True, how="start"):
         dtype = pandas_dtype(dtype)
 
@@ -552,32 +432,8 @@ def astype(self, dtype, copy=True, how="start"):
         # TODO: should probably raise on `how` here, so we don't ignore it.
         return super().astype(dtype, copy=copy)
 
-    @Substitution(klass="PeriodIndex")
-    @Appender(_shared_docs["searchsorted"])
-    def searchsorted(self, value, side="left", sorter=None):
-        if isinstance(value, Period):
-            if value.freq != self.freq:
-                msg = DIFFERENT_FREQ.format(
-                    cls=type(self).__name__,
-                    own_freq=self.freqstr,
-                    other_freq=value.freqstr,
-                )
-                raise IncompatibleFrequency(msg)
-            value = value.ordinal
-        elif isinstance(value, str):
-            try:
-                value = Period(value, freq=self.freq).ordinal
-            except DateParseError:
-                raise KeyError("Cannot interpret '{}' as period".format(value))
-
-        return self._ndarray_values.searchsorted(value, side=side, sorter=sorter)
-
     @property
-    def is_all_dates(self):
-        return True
-
-    @property
-    def is_full(self):
+    def is_full(self) -> bool:
         """
         Returns True if this PeriodIndex is range-like in that all Periods
         between start and end are present, in order.
@@ -590,66 +446,21 @@ def is_full(self):
         return ((values[1:] - values[:-1]) < 2).all()
 
     @property
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         # b/c data is represented as ints make sure we can't have ambiguous
         # indexing
         return "period"
 
-    def get_value(self, series, key):
-        """
-        Fast lookup of value from 1-dimensional ndarray. Only use this if you
-        know what you're doing
-        """
-        s = com.values_from_object(series)
-        try:
-            return com.maybe_box(self, super().get_value(s, key), series, key)
-        except (KeyError, IndexError):
-            try:
-                asdt, parsed, reso = parse_time_string(key, self.freq)
-                grp = resolution.Resolution.get_freq_group(reso)
-                freqn = resolution.get_freq_group(self.freq)
-
-                vals = self._ndarray_values
-
-                # if our data is higher resolution than requested key, slice
-                if grp < freqn:
-                    iv = Period(asdt, freq=(grp, 1))
-                    ord1 = iv.asfreq(self.freq, how="S").ordinal
-                    ord2 = iv.asfreq(self.freq, how="E").ordinal
-
-                    if ord2 < vals[0] or ord1 > vals[-1]:
-                        raise KeyError(key)
-
-                    pos = np.searchsorted(self._ndarray_values, [ord1, ord2])
-                    key = slice(pos[0], pos[1] + 1)
-                    return series[key]
-                elif grp == freqn:
-                    key = Period(asdt, freq=self.freq).ordinal
-                    return com.maybe_box(
-                        self, self._int64index.get_value(s, key), series, key
-                    )
-                else:
-                    raise KeyError(key)
-            except TypeError:
-                pass
-
-            period = Period(key, self.freq)
-            key = period.value if isna(period) else period.ordinal
-            return com.maybe_box(self, self._int64index.get_value(s, key), series, key)
-
     @Appender(_index_shared_docs["get_indexer"] % _index_doc_kwargs)
     def get_indexer(self, target, method=None, limit=None, tolerance=None):
         target = ensure_index(target)
 
-        if hasattr(target, "freq") and target.freq != self.freq:
-            msg = DIFFERENT_FREQ.format(
-                cls=type(self).__name__,
-                own_freq=self.freqstr,
-                other_freq=target.freqstr,
-            )
-            raise IncompatibleFrequency(msg)
-
         if isinstance(target, PeriodIndex):
+            if target.freq != self.freq:
+                # No matches
+                no_matches = -1 * np.ones(self.shape, dtype=np.intp)
+                return no_matches
+
             target = target.asi8
             self_index = self._int64index
         else:
@@ -657,6 +468,10 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
 
         if tolerance is not None:
             tolerance = self._convert_tolerance(tolerance, target)
+            if self_index is not self:
+                # convert tolerance to i8
+                tolerance = self._maybe_convert_timedelta(tolerance)
+
         return Index.get_indexer(self_index, target, method, limit, tolerance)
 
     @Appender(_index_shared_docs["get_indexer_non_unique"] % _index_doc_kwargs)
@@ -664,79 +479,85 @@ def get_indexer_non_unique(self, target):
         target = ensure_index(target)
 
         if isinstance(target, PeriodIndex):
+            if target.freq != self.freq:
+                no_matches = -1 * np.ones(self.shape, dtype=np.intp)
+                return no_matches, no_matches
+
             target = target.asi8
-            if hasattr(target, "freq") and target.freq != self.freq:
-                msg = DIFFERENT_FREQ.format(
-                    cls=type(self).__name__,
-                    own_freq=self.freqstr,
-                    other_freq=target.freqstr,
-                )
-                raise IncompatibleFrequency(msg)
 
         indexer, missing = self._int64index.get_indexer_non_unique(target)
         return ensure_platform_int(indexer), missing
 
-    def _get_unique_index(self, dropna=False):
-        """
-        wrap Index._get_unique_index to handle NaT
-        """
-        res = super()._get_unique_index(dropna=dropna)
-        if dropna:
-            res = res.dropna()
-        return res
-
-    @Appender(Index.unique.__doc__)
-    def unique(self, level=None):
-        # override the Index.unique method for performance GH#23083
-        if level is not None:
-            # this should never occur, but is retained to make the signature
-            # match Index.unique
-            self._validate_index_level(level)
-
-        values = self._ndarray_values
-        result = unique1d(values)
-        return self._shallow_copy(result)
-
     def get_loc(self, key, method=None, tolerance=None):
         """
-        Get integer location for requested label
+        Get integer location for requested label.
+
+        Parameters
+        ----------
+        key : Period, NaT, str, or datetime
+            String or datetime key must be parseable as Period.
 
         Returns
         -------
-        loc : int
+        loc : int or ndarray[int64]
+
+        Raises
+        ------
+        KeyError
+            Key is not present in the index.
+        TypeError
+            If key is listlike or otherwise not hashable.
         """
-        try:
-            return self._engine.get_loc(key)
-        except KeyError:
-            if is_integer(key):
-                raise
+        orig_key = key
+
+        if not is_scalar(key):
+            raise InvalidIndexError(key)
+
+        if isinstance(key, str):
 
             try:
-                asdt, parsed, reso = parse_time_string(key, self.freq)
-                key = asdt
-            except TypeError:
+                loc = self._get_string_slice(key)
+                return loc
+            except (TypeError, ValueError):
                 pass
+
+            try:
+                asdt, reso = parse_time_string(key, self.freq)
             except DateParseError:
                 # A string with invalid format
-                raise KeyError("Cannot interpret '{}' as period".format(key))
+                raise KeyError(f"Cannot interpret '{key}' as period")
 
-            try:
-                key = Period(key, freq=self.freq)
-            except ValueError:
-                # we cannot construct the Period
-                # as we have an invalid type
-                raise KeyError(key)
+            grp = resolution.Resolution.get_freq_group(reso)
+            freqn = resolution.get_freq_group(self.freq)
 
-            try:
-                ordinal = iNaT if key is NaT else key.ordinal
-                if tolerance is not None:
-                    tolerance = self._convert_tolerance(tolerance, np.asarray(key))
-                return self._int64index.get_loc(ordinal, method, tolerance)
+            # _get_string_slice will handle cases where grp < freqn
+            assert grp >= freqn
 
-            except KeyError:
+            if grp == freqn:
+                key = Period(asdt, freq=self.freq)
+                loc = self.get_loc(key, method=method, tolerance=tolerance)
+                return loc
+            elif method is None:
                 raise KeyError(key)
+            else:
+                key = asdt
+
+        elif is_integer(key):
+            # Period constructor will cast to string, which we dont want
+            raise KeyError(key)
+
+        try:
+            key = Period(key, freq=self.freq)
+        except ValueError:
+            # we cannot construct the Period
+            raise KeyError(orig_key)
 
-    def _maybe_cast_slice_bound(self, label, side, kind):
+        try:
+            return Index.get_loc(self, key, method, tolerance)
+        except KeyError:
+            raise KeyError(orig_key)
+
+    def _maybe_cast_slice_bound(self, label, side: str, kind: str):
         """
         If label is a string or a datetime, cast it to Period.ordinal according
         to resolution.
@@ -745,7 +566,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         ----------
         label : object
         side : {'left', 'right'}
-        kind : {'ix', 'loc', 'getitem'}
+        kind : {'loc', 'getitem'}
 
         Returns
         -------
@@ -756,84 +577,50 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         Value of `side` parameter should be validated in caller.
 
         """
-        assert kind in ["ix", "loc", "getitem"]
+        assert kind in ["loc", "getitem"]
 
         if isinstance(label, datetime):
             return Period(label, freq=self.freq)
         elif isinstance(label, str):
             try:
-                _, parsed, reso = parse_time_string(label, self.freq)
+                parsed, reso = parse_time_string(label, self.freq)
                 bounds = self._parsed_string_to_bounds(reso, parsed)
                 return bounds[0 if side == "left" else 1]
-            except Exception:
+            except ValueError:
+                # string cannot be parsed as datetime-like
+                # TODO: we need tests for this case
                 raise KeyError(label)
         elif is_integer(label) or is_float(label):
             self._invalid_indexer("slice", label)
 
         return label
 
-    def _parsed_string_to_bounds(self, reso, parsed):
-        if reso == "year":
-            t1 = Period(year=parsed.year, freq="A")
-        elif reso == "month":
-            t1 = Period(year=parsed.year, month=parsed.month, freq="M")
-        elif reso == "quarter":
-            q = (parsed.month - 1) // 3 + 1
-            t1 = Period(year=parsed.year, quarter=q, freq="Q-DEC")
-        elif reso == "day":
-            t1 = Period(year=parsed.year, month=parsed.month, day=parsed.day, freq="D")
-        elif reso == "hour":
-            t1 = Period(
-                year=parsed.year,
-                month=parsed.month,
-                day=parsed.day,
-                hour=parsed.hour,
-                freq="H",
-            )
-        elif reso == "minute":
-            t1 = Period(
-                year=parsed.year,
-                month=parsed.month,
-                day=parsed.day,
-                hour=parsed.hour,
-                minute=parsed.minute,
-                freq="T",
-            )
-        elif reso == "second":
-            t1 = Period(
-                year=parsed.year,
-                month=parsed.month,
-                day=parsed.day,
-                hour=parsed.hour,
-                minute=parsed.minute,
-                second=parsed.second,
-                freq="S",
-            )
-        else:
+    def _parsed_string_to_bounds(self, reso: str, parsed: datetime):
+        if reso not in ["year", "month", "quarter", "day", "hour", "minute", "second"]:
             raise KeyError(reso)
-        return (t1.asfreq(self.freq, how="start"), t1.asfreq(self.freq, how="end"))
 
-    def _get_string_slice(self, key):
-        if not self.is_monotonic:
-            raise ValueError("Partial indexing only valid for ordered time series")
+        grp = resolution.Resolution.get_freq_group(reso)
+        iv = Period(parsed, freq=(grp, 1))
+        return (iv.asfreq(self.freq, how="start"), iv.asfreq(self.freq, how="end"))
 
-        key, parsed, reso = parse_time_string(key, self.freq)
+    def _validate_partial_date_slice(self, reso: str):
         grp = resolution.Resolution.get_freq_group(reso)
         freqn = resolution.get_freq_group(self.freq)
-        if reso in ["day", "hour", "minute", "second"] and not grp < freqn:
-            raise KeyError(key)
 
-        t1, t2 = self._parsed_string_to_bounds(reso, parsed)
-        return slice(
-            self.searchsorted(t1.ordinal, side="left"),
-            self.searchsorted(t2.ordinal, side="right"),
-        )
+        if not grp < freqn:
+            # TODO: we used to also check for
+            #  reso in ["day", "hour", "minute", "second"]
+            #  why is that check not needed?
+            raise ValueError
+
+    def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True):
+        # TODO: Check for non-True use_lhs/use_rhs
+        parsed, reso = parse_time_string(key, self.freq)
 
-    def _convert_tolerance(self, tolerance, target):
-        tolerance = DatetimeIndexOpsMixin._convert_tolerance(self, tolerance, target)
-        if target.size != tolerance.size and tolerance.size > 1:
-            raise ValueError("list-like tolerance size must match target index size")
-        return self._maybe_convert_timedelta(tolerance)
+        try:
+            return self._partial_date_slice(reso, parsed, use_lhs, use_rhs)
+        except KeyError:
+            raise KeyError(key)
 
     def insert(self, loc, item):
         if not isinstance(item, Period) or self.freq != item.freq:
@@ -869,9 +656,8 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
             return self._apply_meta(result), lidx, ridx
         return self._apply_meta(result)
 
-    @Appender(Index.intersection.__doc__)
-    def intersection(self, other, sort=False):
-        return Index.intersection(self, other, sort=sort)
+    # ------------------------------------------------------------------------
+    # Set Operation Methods
 
     def _assert_can_do_setop(self, other):
         super()._assert_can_do_setop(other)
@@ -879,107 +665,80 @@ def _assert_can_do_setop(self, other):
         # *Can't* use PeriodIndexes of different freqs
         # *Can* use PeriodIndex/DatetimeIndex
         if isinstance(other, PeriodIndex) and self.freq != other.freq:
-            msg = DIFFERENT_FREQ.format(
-                cls=type(self).__name__, own_freq=self.freqstr, other_freq=other.freqstr
-            )
-            raise IncompatibleFrequency(msg)
+            raise raise_on_incompatible(self, other)
 
-    def _wrap_setop_result(self, other, result):
-        name = get_op_result_name(self, other)
-        result = self._apply_meta(result)
-        result.name = name
-        return result
+    def _setop(self, other, sort, opname: str):
+        """
+        Perform a set operation by dispatching to the Int64Index implementation.
+        """
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        res_name = get_op_result_name(self, other)
+        other = ensure_index(other)
 
-    def _apply_meta(self, rawarr):
-        if not isinstance(rawarr, PeriodIndex):
-            rawarr = PeriodIndex._simple_new(rawarr, freq=self.freq, name=self.name)
-        return rawarr
+        i8self = Int64Index._simple_new(self.asi8)
+        i8other = Int64Index._simple_new(other.asi8)
+        i8result = getattr(i8self, opname)(i8other, sort=sort)
 
-    def __setstate__(self, state):
-        """Necessary for making this object picklable"""
+        parr = type(self._data)(np.asarray(i8result, dtype=np.int64), dtype=self.dtype)
+        result = type(self)._simple_new(parr, name=res_name)
+        return result
 
-        if isinstance(state, dict):
-            super().__setstate__(state)
+    def intersection(self, other, sort=False):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        other = ensure_index(other)
 
-        elif isinstance(state, tuple):
+        if self.equals(other):
+            return self._get_reconciled_name_object(other)
 
-            # < 0.15 compat
-            if len(state) == 2:
-                nd_state, own_state = state
-                data = np.empty(nd_state[1], dtype=nd_state[2])
-                np.ndarray.__setstate__(data, nd_state)
+        if not is_dtype_equal(self.dtype, other.dtype):
+            # TODO: fastpath for if we have a different PeriodDtype
+            this = self.astype("O")
+            other = other.astype("O")
+            return this.intersection(other, sort=sort)
 
-                # backcompat
-                freq = Period._maybe_convert_freq(own_state[1])
+        return self._setop(other, sort, opname="intersection")
 
-            else:  # pragma: no cover
-                data = np.empty(state)
-                np.ndarray.__setstate__(self, state)
-                freq = None  # ?
+    def difference(self, other, sort=None):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        other = ensure_index(other)
 
-            data = PeriodArray(data, freq=freq)
-            self._data = data
+        if self.equals(other):
+            # pass an empty PeriodArray with the appropriate dtype
+            return type(self)._simple_new(self._data[:0], name=self.name)
 
-        else:
-            raise Exception("invalid pickle state")
+        if is_object_dtype(other):
+            return self.astype(object).difference(other).astype(self.dtype)
 
-    _unpickle_compat = __setstate__
+        elif not is_dtype_equal(self.dtype, other.dtype):
+            return self
 
-    @property
-    def flags(self):
-        """ return the ndarray.flags for the underlying data """
-        warnings.warn(
-            "{obj}.flags is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._ndarray_values.flags
+        return self._setop(other, sort, opname="difference")
 
-    def item(self):
-        """
-        return the first element of the underlying data as a python
-        scalar
+    def _union(self, other, sort):
+        if not len(other) or self.equals(other) or not len(self):
+            return super()._union(other, sort=sort)
 
-        .. deprecated:: 0.25.0
+        # We are called by `union`, which is responsible for this validation
+        assert isinstance(other, type(self))
 
-        """
-        warnings.warn(
-            "`item` has been deprecated and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        # TODO(DatetimeArray): remove
-        if len(self) == 1:
-            return self[0]
-        else:
-            # TODO: is this still necessary?
-            # copy numpy's message here because Py26 raises an IndexError
-            raise ValueError("can only convert an array of size 1 to a Python scalar")
+        if not is_dtype_equal(self.dtype, other.dtype):
+            this = self.astype("O")
+            other = other.astype("O")
+            return this._union(other, sort=sort)
 
-    @property
-    def data(self):
-        """ return the data pointer of the underlying data """
-        warnings.warn(
-            "{obj}.data is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return np.asarray(self._data).data
+        return self._setop(other, sort, opname="_union")
 
-    @property
-    def base(self):
-        """ return the base object if the memory of the underlying data is
-        shared
-        """
-        warnings.warn(
-            "{obj}.base is deprecated and will be removed "
-            "in a future version".format(obj=type(self).__name__),
-            FutureWarning,
-            stacklevel=2,
-        )
-        return np.asarray(self._data)
+    # ------------------------------------------------------------------------
+
+    def _apply_meta(self, rawarr) -> "PeriodIndex":
+        if not isinstance(rawarr, PeriodIndex):
+            if not isinstance(rawarr, PeriodArray):
+                rawarr = PeriodArray(rawarr, freq=self.freq)
+            rawarr = PeriodIndex._simple_new(rawarr, name=self.name)
+        return rawarr
 
     def memory_usage(self, deep=False):
         result = super().memory_usage(deep=deep)
@@ -988,36 +747,36 @@ def memory_usage(self, deep=False):
         return result
 
 
-PeriodIndex._add_comparison_ops()
 PeriodIndex._add_numeric_methods_disabled()
 PeriodIndex._add_logical_methods_disabled()
-PeriodIndex._add_datetimelike_methods()
 
 
-def period_range(start=None, end=None, periods=None, freq=None, name=None):
+def period_range(
+    start=None, end=None, periods=None, freq=None, name=None
+) -> PeriodIndex:
     """
-    Return a fixed frequency PeriodIndex, with day (calendar) as the default
-    frequency.
+    Return a fixed frequency PeriodIndex.
+
+    The day (calendar) is the default frequency.
 
     Parameters
     ----------
-    start : string or period-like, default None
-        Left bound for generating periods
-    end : string or period-like, default None
-        Right bound for generating periods
-    periods : integer, default None
-        Number of periods to generate
-    freq : string or DateOffset, optional
+    start : str or period-like, default None
+        Left bound for generating periods.
+    end : str or period-like, default None
+        Right bound for generating periods.
+    periods : int, default None
+        Number of periods to generate.
+    freq : str or DateOffset, optional
         Frequency alias. By default the freq is taken from `start` or `end`
         if those are Period objects. Otherwise, the default is ``"D"`` for
         daily frequency.
-
-    name : string, default None
-        Name of the resulting PeriodIndex
+    name : str, default None
+        Name of the resulting PeriodIndex.
 
     Returns
     -------
-    prng : PeriodIndex
+    PeriodIndex
 
     Notes
     -----
@@ -1025,7 +784,7 @@ def period_range(start=None, end=None, periods=None, freq=None, name=None):
     must be specified.
 
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     Examples
     --------
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 8783351cc74d1..d6752da6bc58f 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -1,7 +1,7 @@
 from datetime import timedelta
 import operator
 from sys import getsizeof
-from typing import Union
+from typing import Any, Optional
 import warnings
 
 import numpy as np
@@ -14,24 +14,27 @@
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     ensure_python_int,
-    is_int64_dtype,
+    is_float,
     is_integer,
     is_integer_dtype,
     is_list_like,
     is_scalar,
     is_timedelta64_dtype,
 )
-from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries, ABCTimedeltaIndex
+from pandas.core.dtypes.generic import ABCTimedeltaIndex
 
 from pandas.core import ops
 import pandas.core.common as com
 from pandas.core.construction import extract_array
 import pandas.core.indexes.base as ibase
-from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.base import _index_shared_docs, maybe_extract_name
 from pandas.core.indexes.numeric import Int64Index
+from pandas.core.ops.common import unpack_zerodim_and_defer
 
 from pandas.io.formats.printing import pprint_thing
 
+_empty_range = range(0)
+
 
 class RangeIndex(Int64Index):
     """
@@ -51,7 +54,7 @@ class RangeIndex(Int64Index):
     stop : int (default: 0)
     step : int (default: 1)
     name : object, optional
-        Name to be stored in the index
+        Name to be stored in the index.
     copy : bool, default False
         Unused, accepted for homogeneity with other index types.
 
@@ -73,39 +76,22 @@ class RangeIndex(Int64Index):
 
     _typ = "rangeindex"
     _engine_type = libindex.Int64Engine
-    _range = None  # type: range
+    _range: range
 
     # check whether self._data has been called
-    _cached_data = None  # type: np.ndarray
+    _cached_data: Optional[np.ndarray] = None
     # --------------------------------------------------------------------
     # Constructors
 
     def __new__(
-        cls,
-        start=None,
-        stop=None,
-        step=None,
-        dtype=None,
-        copy=False,
-        name=None,
-        fastpath=None,
+        cls, start=None, stop=None, step=None, dtype=None, copy=False, name=None,
     ):
 
-        if fastpath is not None:
-            warnings.warn(
-                "The 'fastpath' keyword is deprecated, and will be "
-                "removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if fastpath:
-                return cls._simple_new(range(start, stop, step), name=name)
-
         cls._validate_dtype(dtype)
+        name = maybe_extract_name(name, start, cls)
 
         # RangeIndex
         if isinstance(start, RangeIndex):
-            name = start.name if name is None else name
             start = start._range
             return cls._simple_new(start, dtype=dtype, name=name)
 
@@ -128,7 +114,7 @@ def __new__(
         return cls._simple_new(rng, dtype=dtype, name=name)
 
     @classmethod
-    def from_range(cls, data, name=None, dtype=None):
+    def from_range(cls, data: range, name=None, dtype=None) -> "RangeIndex":
         """
         Create RangeIndex from a range object.
 
@@ -138,41 +124,27 @@ def from_range(cls, data, name=None, dtype=None):
         """
         if not isinstance(data, range):
             raise TypeError(
-                "{0}(...) must be called with object coercible to a "
-                "range, {1} was passed".format(cls.__name__, repr(data))
+                f"{cls.__name__}(...) must be called with object coercible to a "
+                f"range, {repr(data)} was passed"
             )
 
         cls._validate_dtype(dtype)
         return cls._simple_new(data, dtype=dtype, name=name)
 
     @classmethod
-    def _simple_new(cls, values, name=None, dtype=None, **kwargs):
+    def _simple_new(cls, values: range, name=None, dtype=None) -> "RangeIndex":
         result = object.__new__(cls)
 
-        # handle passed None, non-integers
-        if values is None:
-            # empty
-            values = range(0, 0, 1)
-        elif not isinstance(values, range):
-            return Index(values, dtype=dtype, name=name, **kwargs)
+        assert isinstance(values, range)
 
         result._range = values
-
         result.name = name
-        for k, v in kwargs.items():
-            setattr(result, k, v)
 
         result._reset_identity()
         return result
 
     # --------------------------------------------------------------------
 
-    @staticmethod
-    def _validate_dtype(dtype):
-        """ require dtype to be None or int64 """
-        if not (dtype is None or is_int64_dtype(dtype)):
-            raise TypeError("Invalid to pass a non-int64 dtype to RangeIndex")
-
     @cache_readonly
     def _constructor(self):
         """ return the class to use for construction """
@@ -205,7 +177,7 @@ def _get_data_as_items(self):
     def __reduce__(self):
         d = self._get_attributes_dict()
         d.update(dict(self._get_data_as_items()))
-        return ibase._new_Index, (self.__class__, d), None
+        return ibase._new_Index, (type(self), d), None
 
     # --------------------------------------------------------------------
     # Rendering Methods
@@ -251,7 +223,7 @@ def _start(self):
         """
         warnings.warn(
             self._deprecation_message.format("_start", "start"),
-            DeprecationWarning,
+            FutureWarning,
             stacklevel=2,
         )
         return self.start
@@ -274,7 +246,7 @@ def _stop(self):
         # GH 25710
         warnings.warn(
             self._deprecation_message.format("_stop", "stop"),
-            DeprecationWarning,
+            FutureWarning,
             stacklevel=2,
         )
         return self.stop
@@ -298,13 +270,13 @@ def _step(self):
         # GH 25710
         warnings.warn(
             self._deprecation_message.format("_step", "step"),
-            DeprecationWarning,
+            FutureWarning,
             stacklevel=2,
         )
         return self.step
 
     @cache_readonly
-    def nbytes(self):
+    def nbytes(self) -> int:
         """
         Return the number of bytes in the underlying data.
         """
@@ -314,7 +286,7 @@ def nbytes(self):
             for attr_name in ["start", "stop", "step"]
         )
 
-    def memory_usage(self, deep=False):
+    def memory_usage(self, deep: bool = False) -> int:
         """
         Memory usage of my values
 
@@ -340,27 +312,27 @@ def memory_usage(self, deep=False):
         return self.nbytes
 
     @property
-    def dtype(self):
+    def dtype(self) -> np.dtype:
         return np.dtype(np.int64)
 
     @property
-    def is_unique(self):
+    def is_unique(self) -> bool:
         """ return if the index has unique values """
         return True
 
     @cache_readonly
-    def is_monotonic_increasing(self):
+    def is_monotonic_increasing(self) -> bool:
         return self._range.step > 0 or len(self) <= 1
 
     @cache_readonly
-    def is_monotonic_decreasing(self):
+    def is_monotonic_decreasing(self) -> bool:
         return self._range.step < 0 or len(self) <= 1
 
     @property
-    def has_duplicates(self):
+    def has_duplicates(self) -> bool:
         return False
 
-    def __contains__(self, key: Union[int, np.integer]) -> bool:
+    def __contains__(self, key: Any) -> bool:
         hash(key)
         try:
             key = ensure_python_int(key)
@@ -368,26 +340,31 @@ def __contains__(self, key: Union[int, np.integer]) -> bool:
             return False
         return key in self._range
 
-    @Appender(_index_shared_docs["get_loc"])
+    @Appender(Int64Index.get_loc.__doc__)
     def get_loc(self, key, method=None, tolerance=None):
-        if is_integer(key) and method is None and tolerance is None:
-            new_key = int(key)
-            try:
-                return self._range.index(new_key)
-            except ValueError:
-                raise KeyError(key)
+        if method is None and tolerance is None:
+            if is_integer(key) or (is_float(key) and key.is_integer()):
+                new_key = int(key)
+                try:
+                    return self._range.index(new_key)
+                except ValueError:
+                    raise KeyError(key)
+            raise KeyError(key)
         return super().get_loc(key, method=method, tolerance=tolerance)
 
     @Appender(_index_shared_docs["get_indexer"])
     def get_indexer(self, target, method=None, limit=None, tolerance=None):
-        if not (method is None and tolerance is None and is_list_like(target)):
-            return super().get_indexer(target, method=method, tolerance=tolerance)
+        if com.any_not_none(method, tolerance, limit) or not is_list_like(target):
+            return super().get_indexer(
+                target, method=method, tolerance=tolerance, limit=limit
+            )
 
         if self.step > 0:
             start, stop, step = self.start, self.stop, self.step
         else:
-            # Work on reversed range for simplicity:
-            start, stop, step = (self.stop - self.step, self.start + 1, -self.step)
+            # GH 28678: work on reversed range for simplicity
+            reverse = self._range[::-1]
+            start, stop, step = reverse.start, reverse.stop, reverse.step
 
         target_array = np.asarray(target)
         if not (is_integer_dtype(target_array) and target_array.ndim == 1):
@@ -407,7 +384,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
     def tolist(self):
         return list(self._range)
 
-    @Appender(_index_shared_docs["_shallow_copy"])
+    @Appender(Int64Index._shallow_copy.__doc__)
     def _shallow_copy(self, values=None, **kwargs):
         if values is None:
             name = kwargs.get("name", self.name)
@@ -416,14 +393,14 @@ def _shallow_copy(self, values=None, **kwargs):
             kwargs.setdefault("name", self.name)
             return self._int64index._shallow_copy(values, **kwargs)
 
-    @Appender(ibase._index_shared_docs["copy"])
+    @Appender(Int64Index.copy.__doc__)
     def copy(self, name=None, deep=False, dtype=None, **kwargs):
         self._validate_dtype(dtype)
         if name is None:
             name = self.name
         return self.from_range(self._range, name=name)
 
-    def _minmax(self, meth):
+    def _minmax(self, meth: str):
         no_steps = len(self) - 1
         if no_steps == -1:
             return np.nan
@@ -432,19 +409,19 @@ def _minmax(self, meth):
 
         return self.start + self.step * no_steps
 
-    def min(self, axis=None, skipna=True, *args, **kwargs):
+    def min(self, axis=None, skipna=True, *args, **kwargs) -> int:
         """The minimum value of the RangeIndex"""
         nv.validate_minmax_axis(axis)
         nv.validate_min(args, kwargs)
         return self._minmax("min")
 
-    def max(self, axis=None, skipna=True, *args, **kwargs):
+    def max(self, axis=None, skipna=True, *args, **kwargs) -> int:
         """The maximum value of the RangeIndex"""
         nv.validate_minmax_axis(axis)
         nv.validate_max(args, kwargs)
         return self._minmax("max")
 
-    def argsort(self, *args, **kwargs):
+    def argsort(self, *args, **kwargs) -> np.ndarray:
         """
         Returns the indices that would sort the index and its
         underlying data.
@@ -464,7 +441,7 @@ def argsort(self, *args, **kwargs):
         else:
             return np.arange(len(self) - 1, -1, -1)
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         """
         Determines if two Index objects contain the same elements.
         """
@@ -502,7 +479,7 @@ def intersection(self, other, sort=False):
             return super().intersection(other, sort=sort)
 
         if not len(self) or not len(other):
-            return self._simple_new(None)
+            return self._simple_new(_empty_range)
 
         first = self._range[::-1] if self.step < 0 else self._range
         second = other._range[::-1] if other.step < 0 else other._range
@@ -512,7 +489,7 @@ def intersection(self, other, sort=False):
         int_low = max(first.start, second.start)
         int_high = min(first.stop, second.stop)
         if int_high <= int_low:
-            return self._simple_new(None)
+            return self._simple_new(_empty_range)
 
         # Method hint: linear Diophantine equation
         # solve intersection problem
@@ -522,7 +499,7 @@ def intersection(self, other, sort=False):
 
         # check whether element sets intersect
         if (first.start - second.start) % gcd:
-            return self._simple_new(None)
+            return self._simple_new(_empty_range)
 
         # calculate parameters for the RangeIndex describing the
         # intersection disregarding the lower bounds
@@ -542,12 +519,12 @@ def intersection(self, other, sort=False):
             new_index = new_index.sort_values()
         return new_index
 
-    def _min_fitting_element(self, lower_limit):
+    def _min_fitting_element(self, lower_limit: int) -> int:
         """Returns the smallest element greater than or equal to the limit"""
         no_steps = -(-(lower_limit - self.start) // abs(self.step))
         return self.start + abs(self.step) * no_steps
 
-    def _max_fitting_element(self, upper_limit):
+    def _max_fitting_element(self, upper_limit: int) -> int:
         """Returns the largest element smaller than or equal to the limit"""
         no_steps = (upper_limit - self.start) // abs(self.step)
         return self.start + abs(self.step) * no_steps
@@ -615,30 +592,30 @@ def _union(self, other, sort):
                     and (start_s - end_o) <= step_s
                     and (start_o - end_s) <= step_s
                 ):
-                    return self.__class__(start_r, end_r + step_s, step_s)
+                    return type(self)(start_r, end_r + step_s, step_s)
                 if (
                     (step_s % 2 == 0)
                     and (abs(start_s - start_o) <= step_s / 2)
                     and (abs(end_s - end_o) <= step_s / 2)
                 ):
-                    return self.__class__(start_r, end_r + step_s / 2, step_s / 2)
+                    return type(self)(start_r, end_r + step_s / 2, step_s / 2)
             elif step_o % step_s == 0:
                 if (
                     (start_o - start_s) % step_s == 0
                     and (start_o + step_s >= start_s)
                     and (end_o - step_s <= end_s)
                 ):
-                    return self.__class__(start_r, end_r + step_s, step_s)
+                    return type(self)(start_r, end_r + step_s, step_s)
             elif step_s % step_o == 0:
                 if (
                     (start_s - start_o) % step_o == 0
                     and (start_s + step_o >= start_o)
                     and (end_s - step_o <= end_o)
                 ):
-                    return self.__class__(start_r, end_r + step_o, step_o)
+                    return type(self)(start_r, end_r + step_o, step_o)
         return self._int64index._union(other, sort=sort)
 
-    @Appender(_index_shared_docs["join"])
+    @Appender(Int64Index.join.__doc__)
     def join(self, other, how="left", level=None, return_indexers=False, sort=False):
         if how == "outer" and self is not other:
             # note: could return RangeIndex in more circumstances
@@ -660,7 +637,7 @@ def _concat_same_dtype(self, indexes, name):
         non_empty_indexes = [obj for obj in indexes if len(obj)]
 
         for obj in non_empty_indexes:
-            rng = obj._range  # type: range
+            rng: range = obj._range
 
             if start is None:
                 # This is set by the first non-empty index
@@ -695,14 +672,14 @@ def _concat_same_dtype(self, indexes, name):
         # In this case return an empty range index.
         return RangeIndex(0, 0).rename(name)
 
-    def __len__(self):
+    def __len__(self) -> int:
         """
         return the length of the RangeIndex
         """
         return len(self._range)
 
     @property
-    def size(self):
+    def size(self) -> int:
         return len(self)
 
     def __getitem__(self, key):
@@ -718,8 +695,7 @@ def __getitem__(self, key):
                 return self._range[new_key]
             except IndexError:
                 raise IndexError(
-                    "index {key} is out of bounds for axis 0 "
-                    "with size {size}".format(key=key, size=len(self))
+                    f"index {key} is out of bounds for axis 0 with size {len(self)}"
                 )
         elif is_scalar(key):
             raise IndexError(
@@ -731,9 +707,8 @@ def __getitem__(self, key):
         # fall back to Int64Index
         return super().__getitem__(key)
 
+    @unpack_zerodim_and_defer("__floordiv__")
     def __floordiv__(self, other):
-        if isinstance(other, (ABCSeries, ABCDataFrame)):
-            return NotImplemented
 
         if is_integer(other) and other != 0:
             if len(self) == 0 or self.start % other == 0 and self.step % other == 0:
@@ -769,10 +744,9 @@ def _make_evaluate_binop(op, step=False):
                 if False, use the existing step
             """
 
+            @unpack_zerodim_and_defer(op.__name__)
             def _evaluate_numeric_binop(self, other):
-                if isinstance(other, (ABCSeries, ABCDataFrame)):
-                    return NotImplemented
-                elif isinstance(other, ABCTimedeltaIndex):
+                if isinstance(other, ABCTimedeltaIndex):
                     # Defer to TimedeltaIndex implementation
                     return NotImplemented
                 elif isinstance(other, (timedelta, np.timedelta64)):
@@ -806,7 +780,7 @@ def _evaluate_numeric_binop(self, other):
                         rstart = op(left.start, right)
                         rstop = op(left.stop, right)
 
-                    result = self.__class__(rstart, rstop, rstep, **attrs)
+                    result = type(self)(rstart, rstop, rstep, **attrs)
 
                     # for compat with numpy / Int64Index
                     # even if we can represent as a RangeIndex, return
@@ -821,7 +795,7 @@ def _evaluate_numeric_binop(self, other):
                     return op(self._int64index, other)
                     # TODO: Do attrs get handled reliably?
 
-            name = "__{name}__".format(name=op.__name__)
+            name = f"__{op.__name__}__"
             return compat.set_function_name(_evaluate_numeric_binop, name, cls)
 
         cls.__add__ = _make_evaluate_binop(operator.add)
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index b03d60c7b5b37..4a69570f1844c 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -1,71 +1,66 @@
 """ implement the TimedeltaIndex """
-from datetime import datetime
-import warnings
 
-import numpy as np
-
-from pandas._libs import NaT, Timedelta, index as libindex, join as libjoin, lib
-from pandas.util._decorators import Appender, Substitution
+from pandas._libs import NaT, Timedelta, index as libindex
+from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
     _TD_DTYPE,
-    ensure_int64,
     is_float,
     is_integer,
-    is_list_like,
     is_scalar,
     is_timedelta64_dtype,
     is_timedelta64_ns_dtype,
     pandas_dtype,
 )
-from pandas.core.dtypes.concat import concat_compat
-from pandas.core.dtypes.missing import isna
+from pandas.core.dtypes.missing import is_valid_nat_for_dtype
 
-from pandas.core.accessor import delegate_names
 from pandas.core.arrays import datetimelike as dtl
-from pandas.core.arrays.timedeltas import TimedeltaArray, _is_convertible_to_td
-from pandas.core.base import _shared_docs
+from pandas.core.arrays.timedeltas import TimedeltaArray
 import pandas.core.common as com
-from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.base import Index, InvalidIndexError, maybe_extract_name
 from pandas.core.indexes.datetimelike import (
     DatetimeIndexOpsMixin,
-    DatetimelikeDelegateMixin,
+    DatetimeTimedeltaMixin,
 )
-from pandas.core.indexes.numeric import Int64Index
-from pandas.core.ops import get_op_result_name
+from pandas.core.indexes.extension import inherit_names
 
 from pandas.tseries.frequencies import to_offset
 
 
-class TimedeltaDelegateMixin(DatetimelikeDelegateMixin):
-    # Most attrs are dispatched via datetimelike_{ops,methods}
-    # Some are "raw" methods, the result is not not re-boxed in an Index
-    # We also have a few "extra" attrs, which may or may not be raw,
-    # which we we dont' want to expose in the .dt accessor.
-    _delegate_class = TimedeltaArray
-    _delegated_properties = TimedeltaArray._datetimelike_ops + ["components"]
-    _delegated_methods = TimedeltaArray._datetimelike_methods + [
+@inherit_names(
+    [
         "_box_values",
         "__neg__",
         "__pos__",
         "__abs__",
+        "total_seconds",
+        "round",
+        "floor",
+        "ceil",
     ]
-    _raw_properties = {"components"}
-    _raw_methods = {"to_pytimedelta"}
-
-
-@delegate_names(
-    TimedeltaArray, TimedeltaDelegateMixin._delegated_properties, typ="property"
+    + TimedeltaArray._field_ops,
+    TimedeltaArray,
+    wrap=True,
 )
-@delegate_names(
+@inherit_names(
+    [
+        "_bool_ops",
+        "_object_ops",
+        "_field_ops",
+        "_datetimelike_ops",
+        "_datetimelike_methods",
+        "_other_ops",
+        "components",
+        "to_pytimedelta",
+        "sum",
+        "std",
+        "median",
+        "_format_native_types",
+        "freq",
+    ],
     TimedeltaArray,
-    TimedeltaDelegateMixin._delegated_methods,
-    typ="method",
-    overwrite=True,
 )
-class TimedeltaIndex(
-    DatetimeIndexOpsMixin, dtl.TimelikeOps, Int64Index, TimedeltaDelegateMixin
-):
+class TimedeltaIndex(DatetimeTimedeltaMixin, dtl.TimelikeOps):
     """
     Immutable ndarray of timedelta64 data, represented internally as int64, and
     which can be boxed to timedelta objects.
@@ -82,30 +77,6 @@ class TimedeltaIndex(
         inferred frequency upon creation.
     copy  : bool
         Make a copy of input ndarray.
-    start : starting value, timedelta-like, optional
-        If data is None, start is used as the start point in generating regular
-        timedelta data.
-
-        .. deprecated:: 0.24.0
-
-    periods  : int, optional, > 0
-        Number of periods to generate, if generating index. Takes precedence
-        over end argument.
-
-        .. deprecated:: 0.24.0
-
-    end : end time, timedelta-like, optional
-        If periods is none, generated index will extend to first conforming
-        time on or just past end argument.
-
-        .. deprecated:: 0.24. 0
-
-    closed : str or None, default None
-        Make the interval closed with respect to the given frequency to
-        the 'left', 'right', or both sides (None).
-
-        .. deprecated:: 0.24. 0
-
     name : object
         Name to be stored in the index.
 
@@ -139,24 +110,10 @@ class TimedeltaIndex(
     Notes
     -----
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
-
-    Creating a TimedeltaIndex based on `start`, `periods`, and `end` has
-    been deprecated in favor of :func:`timedelta_range`.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
     """
 
     _typ = "timedeltaindex"
-    _join_precedence = 10
-
-    def _join_i8_wrapper(joinf, **kwargs):
-        return DatetimeIndexOpsMixin._join_i8_wrapper(joinf, dtype="m8[ns]", **kwargs)
-
-    _inner_indexer = _join_i8_wrapper(libjoin.inner_join_indexer_int64)
-    _outer_indexer = _join_i8_wrapper(libjoin.outer_join_indexer_int64)
-    _left_indexer = _join_i8_wrapper(libjoin.left_join_indexer_int64)
-    _left_indexer_unique = _join_i8_wrapper(
-        libjoin.left_join_indexer_unique_int64, with_indexers=False
-    )
 
     _engine_type = libindex.TimedeltaEngine
 
@@ -165,14 +122,7 @@ def _join_i8_wrapper(joinf, **kwargs):
     _is_numeric_dtype = True
     _infer_as_myclass = True
 
-    _freq = None
-
-    _bool_ops = TimedeltaArray._bool_ops
-    _object_ops = TimedeltaArray._object_ops
-    _field_ops = TimedeltaArray._field_ops
-    _datetimelike_ops = TimedeltaArray._datetimelike_ops
-    _datetimelike_methods = TimedeltaArray._datetimelike_methods
-    _other_ops = TimedeltaArray._other_ops
+    _data: TimedeltaArray
 
     # -------------------------------------------------------------------
     # Constructors
@@ -182,57 +132,26 @@ def __new__(
         data=None,
         unit=None,
         freq=None,
-        start=None,
-        end=None,
-        periods=None,
         closed=None,
         dtype=_TD_DTYPE,
         copy=False,
         name=None,
-        verify_integrity=None,
     ):
-
-        if verify_integrity is not None:
-            warnings.warn(
-                "The 'verify_integrity' argument is deprecated, "
-                "will be removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
-            )
-        else:
-            verify_integrity = True
-
-        if data is None:
-            freq, freq_infer = dtl.maybe_infer_freq(freq)
-            warnings.warn(
-                "Creating a TimedeltaIndex by passing range "
-                "endpoints is deprecated.  Use "
-                "`pandas.timedelta_range` instead.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            result = TimedeltaArray._generate_range(
-                start, end, periods, freq, closed=closed
-            )
-            return cls._simple_new(result._data, freq=freq, name=name)
+        name = maybe_extract_name(name, data, cls)
 
         if is_scalar(data):
             raise TypeError(
-                "{cls}() must be called with a "
-                "collection of some kind, {data} was passed".format(
-                    cls=cls.__name__, data=repr(data)
-                )
+                f"{cls.__name__}() must be called with a "
+                f"collection of some kind, {repr(data)} was passed"
             )
 
         if unit in {"Y", "y", "M"}:
-            warnings.warn(
-                "M and Y units are deprecated and "
-                "will be removed in a future version.",
-                FutureWarning,
-                stacklevel=2,
+            raise ValueError(
+                "Units 'M' and 'Y' are no longer supported, as they do not "
+                "represent unambiguous timedelta values durations."
             )
 
-        if isinstance(data, TimedeltaArray):
+        if isinstance(data, TimedeltaArray) and freq is None:
             if copy:
                 data = data.copy()
             return cls._simple_new(data, name=name, freq=freq)
@@ -248,42 +167,25 @@ def __new__(
         tdarr = TimedeltaArray._from_sequence(
             data, freq=freq, unit=unit, dtype=dtype, copy=copy
         )
-        return cls._simple_new(tdarr._data, freq=tdarr.freq, name=name)
+        return cls._simple_new(tdarr, name=name)
 
     @classmethod
     def _simple_new(cls, values, name=None, freq=None, dtype=_TD_DTYPE):
         # `dtype` is passed by _shallow_copy in corner cases, should always
         #  be timedelta64[ns] if present
-        if not isinstance(values, TimedeltaArray):
-            values = TimedeltaArray._simple_new(values, dtype=dtype, freq=freq)
-        else:
-            if freq is None:
-                freq = values.freq
-        assert isinstance(values, TimedeltaArray), type(values)
         assert dtype == _TD_DTYPE, dtype
-        assert values.dtype == "m8[ns]", values.dtype
+        assert isinstance(values, TimedeltaArray)
+        assert freq is None or values.freq == freq
 
-        tdarr = TimedeltaArray._simple_new(values._data, freq=freq)
         result = object.__new__(cls)
-        result._data = tdarr
-        result.name = name
+        result._data = values
+        result._name = name
         # For groupby perf. See note in indexes/base about _index_data
-        result._index_data = tdarr._data
+        result._index_data = values._data
 
         result._reset_identity()
         return result
 
-    # -------------------------------------------------------------------
-
-    def __setstate__(self, state):
-        """Necessary for making this object picklable"""
-        if isinstance(state, dict):
-            super().__setstate__(state)
-        else:
-            raise Exception("invalid pickle state")
-
-    _unpickle_compat = __setstate__
-
     # -------------------------------------------------------------------
     # Rendering Methods
 
@@ -293,36 +195,9 @@ def _formatter_func(self):
 
         return _get_format_timedelta64(self, box=True)
 
-    def _format_native_types(self, na_rep="NaT", date_format=None, **kwargs):
-        from pandas.io.formats.format import Timedelta64Formatter
-
-        return np.asarray(
-            Timedelta64Formatter(
-                values=self, nat_rep=na_rep, justify="all"
-            ).get_result()
-        )
-
     # -------------------------------------------------------------------
-    # Wrapping TimedeltaArray
-
-    # Compat for frequency inference, see GH#23789
-    _is_monotonic_increasing = Index.is_monotonic_increasing
-    _is_monotonic_decreasing = Index.is_monotonic_decreasing
-    _is_unique = Index.is_unique
-
-    @property
-    def _box_func(self):
-        return lambda x: Timedelta(x, unit="ns")
-
-    def __getitem__(self, key):
-        result = self._data.__getitem__(key)
-        if is_scalar(result):
-            return result
-        return type(self)(result, name=self.name)
 
-    # -------------------------------------------------------------------
-
-    @Appender(_index_shared_docs["astype"])
+    @Appender(Index.astype.__doc__)
     def astype(self, dtype, copy=True):
         dtype = pandas_dtype(dtype)
         if is_timedelta64_dtype(dtype) and not is_timedelta64_ns_dtype(dtype):
@@ -335,230 +210,54 @@ def astype(self, dtype, copy=True):
             return Index(result.astype("i8"), name=self.name)
         return DatetimeIndexOpsMixin.astype(self, dtype, copy=copy)
 
-    def _union(self, other, sort):
-        if len(other) == 0 or self.equals(other) or len(self) == 0:
-            return super()._union(other, sort=sort)
-
-        if not isinstance(other, TimedeltaIndex):
-            try:
-                other = TimedeltaIndex(other)
-            except (TypeError, ValueError):
-                pass
-        this, other = self, other
-
-        if this._can_fast_union(other):
-            return this._fast_union(other)
-        else:
-            result = Index._union(this, other, sort=sort)
-            if isinstance(result, TimedeltaIndex):
-                if result.freq is None:
-                    result.freq = to_offset(result.inferred_freq)
-            return result
-
-    def join(self, other, how="left", level=None, return_indexers=False, sort=False):
-        """
-        See Index.join
-        """
-        if _is_convertible_to_index(other):
-            try:
-                other = TimedeltaIndex(other)
-            except (TypeError, ValueError):
-                pass
-
-        return Index.join(
-            self,
-            other,
-            how=how,
-            level=level,
-            return_indexers=return_indexers,
-            sort=sort,
-        )
-
-    def intersection(self, other, sort=False):
-        """
-        Specialized intersection for TimedeltaIndex objects.
-        May be much faster than Index.intersection
-
-        Parameters
-        ----------
-        other : TimedeltaIndex or array-like
-        sort : False or None, default False
-            Sort the resulting index if possible.
-
-            .. versionadded:: 0.24.0
-
-            .. versionchanged:: 0.24.1
-
-               Changed the default to ``False`` to match the behaviour
-               from before 0.24.0.
-
-            .. versionchanged:: 0.25.0
-
-               The `sort` keyword is added
-
-        Returns
-        -------
-        y : Index or  TimedeltaIndex
-        """
-        return super().intersection(other, sort=sort)
-
-    def _wrap_joined_index(self, joined, other):
-        name = get_op_result_name(self, other)
-        if (
-            isinstance(other, TimedeltaIndex)
-            and self.freq == other.freq
-            and self._can_fast_union(other)
-        ):
-            joined = self._shallow_copy(joined, name=name)
-            return joined
-        else:
-            return self._simple_new(joined, name)
-
-    def _can_fast_union(self, other):
-        if not isinstance(other, TimedeltaIndex):
-            return False
-
-        freq = self.freq
-
-        if freq is None or freq != other.freq:
-            return False
-
-        if not self.is_monotonic or not other.is_monotonic:
-            return False
-
-        if len(self) == 0 or len(other) == 0:
-            return True
-
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        right_start = right[0]
-        left_end = left[-1]
-
-        # Only need to "adjoin", not overlap
-        return (right_start == left_end + freq) or right_start in left
-
-    def _fast_union(self, other):
-        if len(other) == 0:
-            return self.view(type(self))
-
-        if len(self) == 0:
-            return other.view(type(self))
-
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        left_end = left[-1]
-        right_end = right[-1]
-
-        # concatenate
-        if left_end < right_end:
-            loc = right.searchsorted(left_end, side="right")
-            right_chunk = right.values[loc:]
-            dates = concat_compat((left.values, right_chunk))
-            return self._shallow_copy(dates)
-        else:
-            return left
-
     def _maybe_promote(self, other):
         if other.inferred_type == "timedelta":
             other = TimedeltaIndex(other)
         return self, other
 
-    def get_value(self, series, key):
-        """
-        Fast lookup of value from 1-dimensional ndarray. Only use this if you
-        know what you're doing
-        """
-
-        if _is_convertible_to_td(key):
-            key = Timedelta(key)
-            return self.get_value_maybe_box(series, key)
-
-        try:
-            return com.maybe_box(self, Index.get_value(self, series, key), series, key)
-        except KeyError:
-            try:
-                loc = self._get_string_slice(key)
-                return series[loc]
-            except (TypeError, ValueError, KeyError):
-                pass
-
-            try:
-                return self.get_value_maybe_box(series, key)
-            except (TypeError, ValueError, KeyError):
-                raise KeyError(key)
-
-    def get_value_maybe_box(self, series, key):
-        if not isinstance(key, Timedelta):
-            key = Timedelta(key)
-        values = self._engine.get_value(com.values_from_object(series), key)
-        return com.maybe_box(self, values, series, key)
-
     def get_loc(self, key, method=None, tolerance=None):
         """
         Get integer location for requested label
 
         Returns
         -------
-        loc : int
+        loc : int, slice, or ndarray[int]
         """
-        if is_list_like(key) or (isinstance(key, datetime) and key is not NaT):
-            # GH#20464 datetime check here is to ensure we don't allow
-            #   datetime objects to be incorrectly treated as timedelta
-            #   objects; NaT is a special case because it plays a double role
-            #   as Not-A-Timedelta
-            raise TypeError
-
-        if isna(key):
+        if not is_scalar(key):
+            raise InvalidIndexError(key)
+
+        if is_valid_nat_for_dtype(key, self.dtype):
             key = NaT
 
-        if tolerance is not None:
-            # try converting tolerance now, so errors don't get swallowed by
-            # the try/except clauses below
-            tolerance = self._convert_tolerance(tolerance, np.asarray(key))
+        elif isinstance(key, str):
+            try:
+                key = Timedelta(key)
+            except ValueError:
+                raise KeyError(key)
 
-        if _is_convertible_to_td(key):
+        elif isinstance(key, self._data._recognized_scalars) or key is NaT:
             key = Timedelta(key)
-            return Index.get_loc(self, key, method, tolerance)
 
-        try:
-            return Index.get_loc(self, key, method, tolerance)
-        except (KeyError, ValueError, TypeError):
-            try:
-                return self._get_string_slice(key)
-            except (TypeError, KeyError, ValueError):
-                pass
+        else:
+            raise KeyError(key)
 
-            try:
-                stamp = Timedelta(key)
-                return Index.get_loc(self, stamp, method, tolerance)
-            except (KeyError, ValueError):
-                raise KeyError(key)
+        return Index.get_loc(self, key, method, tolerance)
 
-    def _maybe_cast_slice_bound(self, label, side, kind):
+    def _maybe_cast_slice_bound(self, label, side: str, kind):
         """
         If label is a string, cast it to timedelta according to resolution.
 
-
         Parameters
         ----------
         label : object
         side : {'left', 'right'}
-        kind : {'ix', 'loc', 'getitem'}
+        kind : {'loc', 'getitem'} or None
 
         Returns
         -------
-        label :  object
-
+        label : object
         """
-        assert kind in ["ix", "loc", "getitem", None]
+        assert kind in ["loc", "getitem", None]
 
         if isinstance(label, str):
             parsed = Timedelta(label)
@@ -572,164 +271,39 @@ def _maybe_cast_slice_bound(self, label, side, kind):
 
         return label
 
-    def _get_string_slice(self, key):
-        if is_integer(key) or is_float(key) or key is NaT:
-            self._invalid_indexer("slice", key)
-        loc = self._partial_td_slice(key)
-        return loc
-
-    def _partial_td_slice(self, key):
-
-        # given a key, try to figure out a location for a partial slice
-        if not isinstance(key, str):
-            return key
-
-        raise NotImplementedError
-
-    @Substitution(klass="TimedeltaIndex")
-    @Appender(_shared_docs["searchsorted"])
-    def searchsorted(self, value, side="left", sorter=None):
-        if isinstance(value, (np.ndarray, Index)):
-            value = np.array(value, dtype=_TD_DTYPE, copy=False)
-        else:
-            value = Timedelta(value).asm8.view(_TD_DTYPE)
-
-        return self.values.searchsorted(value, side=side, sorter=sorter)
-
-    def is_type_compatible(self, typ):
+    def is_type_compatible(self, typ) -> bool:
         return typ == self.inferred_type or typ == "timedelta"
 
     @property
-    def inferred_type(self):
+    def inferred_type(self) -> str:
         return "timedelta64"
 
-    @property
-    def is_all_dates(self):
-        return True
-
-    def insert(self, loc, item):
-        """
-        Make new Index inserting new item at location
-
-        Parameters
-        ----------
-        loc : int
-        item : object
-            if not either a Python datetime or a numpy integer-like, returned
-            Index dtype will be object rather than datetime.
-
-        Returns
-        -------
-        new_index : Index
-        """
-        # try to convert if possible
-        if _is_convertible_to_td(item):
-            try:
-                item = Timedelta(item)
-            except Exception:
-                pass
-        elif is_scalar(item) and isna(item):
-            # GH 18295
-            item = self._na_value
-
-        freq = None
-        if isinstance(item, Timedelta) or (is_scalar(item) and isna(item)):
-
-            # check freq can be preserved on edge cases
-            if self.freq is not None:
-                if (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
-                    freq = self.freq
-                elif (loc == len(self)) and item - self.freq == self[-1]:
-                    freq = self.freq
-            item = Timedelta(item).asm8.view(_TD_DTYPE)
-
-        try:
-            new_tds = np.concatenate(
-                (self[:loc].asi8, [item.view(np.int64)], self[loc:].asi8)
-            )
-            return self._shallow_copy(new_tds, freq=freq)
-
-        except (AttributeError, TypeError):
-
-            # fall back to object index
-            if isinstance(item, str):
-                return self.astype(object).insert(loc, item)
-            raise TypeError("cannot insert TimedeltaIndex with incompatible label")
-
-    def delete(self, loc):
-        """
-        Make a new TimedeltaIndex with passed location(s) deleted.
 
-        Parameters
-        ----------
-        loc: int, slice or array of ints
-            Indicate which sub-arrays to remove.
-
-        Returns
-        -------
-        new_index : TimedeltaIndex
-        """
-        new_tds = np.delete(self.asi8, loc)
-
-        freq = "infer"
-        if is_integer(loc):
-            if loc in (0, -len(self), -1, len(self) - 1):
-                freq = self.freq
-        else:
-            if is_list_like(loc):
-                loc = lib.maybe_indices_to_slice(ensure_int64(np.array(loc)), len(self))
-            if isinstance(loc, slice) and loc.step in (1, None):
-                if loc.start in (0, None) or loc.stop in (len(self), None):
-                    freq = self.freq
-
-        return TimedeltaIndex(new_tds, name=self.name, freq=freq)
-
-
-TimedeltaIndex._add_comparison_ops()
 TimedeltaIndex._add_logical_methods_disabled()
-TimedeltaIndex._add_datetimelike_methods()
-
-
-def _is_convertible_to_index(other):
-    """
-    return a boolean whether I can attempt conversion to a TimedeltaIndex
-    """
-    if isinstance(other, TimedeltaIndex):
-        return True
-    elif len(other) > 0 and other.inferred_type not in (
-        "floating",
-        "mixed-integer",
-        "integer",
-        "integer-na",
-        "mixed-integer-float",
-        "mixed",
-    ):
-        return True
-    return False
 
 
 def timedelta_range(
     start=None, end=None, periods=None, freq=None, name=None, closed=None
-):
+) -> TimedeltaIndex:
     """
     Return a fixed frequency TimedeltaIndex, with day as the default
     frequency.
 
     Parameters
     ----------
-    start : string or timedelta-like, default None
-        Left bound for generating timedeltas
-    end : string or timedelta-like, default None
-        Right bound for generating timedeltas
-    periods : integer, default None
-        Number of periods to generate
-    freq : string or DateOffset, default 'D'
-        Frequency strings can have multiples, e.g. '5H'
-    name : string, default None
-        Name of the resulting TimedeltaIndex
-    closed : string, default None
+    start : str or timedelta-like, default None
+        Left bound for generating timedeltas.
+    end : str or timedelta-like, default None
+        Right bound for generating timedeltas.
+    periods : int, default None
+        Number of periods to generate.
+    freq : str or DateOffset, default 'D'
+        Frequency strings can have multiples, e.g. '5H'.
+    name : str, default None
+        Name of the resulting TimedeltaIndex.
+    closed : str, default None
         Make the interval closed with respect to the given frequency to
-        the 'left', 'right', or both sides (None)
+        the 'left', 'right', or both sides (None).
 
     Returns
     -------
@@ -743,7 +317,7 @@ def timedelta_range(
     ``start`` and ``end`` (closed on both sides).
 
     To learn more about the frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     Examples
     --------
@@ -781,4 +355,4 @@ def timedelta_range(
 
     freq, freq_infer = dtl.maybe_infer_freq(freq)
     tdarr = TimedeltaArray._generate_range(start, end, periods, freq, closed=closed)
-    return TimedeltaIndex._simple_new(tdarr._data, freq=tdarr.freq, name=name)
+    return TimedeltaIndex._simple_new(tdarr, name=name)
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 45cb037600fd7..f498e1696ea5b 100755
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1,6 +1,4 @@
-import textwrap
-from typing import Tuple
-import warnings
+from typing import Hashable, List, Tuple, Union
 
 import numpy as np
 
@@ -10,37 +8,25 @@
 from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
-    ensure_platform_int,
     is_float,
     is_integer,
-    is_integer_dtype,
     is_iterator,
     is_list_like,
     is_numeric_dtype,
     is_scalar,
     is_sequence,
-    is_sparse,
 )
 from pandas.core.dtypes.concat import concat_compat
 from pandas.core.dtypes.generic import ABCDataFrame, ABCMultiIndex, ABCSeries
 from pandas.core.dtypes.missing import _infer_fill_value, isna
 
 import pandas.core.common as com
-from pandas.core.index import Index, InvalidIndexError
-from pandas.core.indexers import is_list_like_indexer, length_of_indexer
-
-
-# the supported indexers
-def get_indexers_list():
-
-    return [
-        ("ix", _IXIndexer),
-        ("iloc", _iLocIndexer),
-        ("loc", _LocIndexer),
-        ("at", _AtIndexer),
-        ("iat", _iAtIndexer),
-    ]
-
+from pandas.core.indexers import (
+    check_array_indexer,
+    is_list_like_indexer,
+    length_of_indexer,
+)
+from pandas.core.indexes.api import Index, InvalidIndexError
 
 # "null slice"
 _NS = slice(None, None)
@@ -99,55 +85,499 @@ class IndexingError(Exception):
     pass
 
 
-class _NDFrameIndexer(_NDFrameIndexerBase):
-    _valid_types = None  # type: str
-    _exception = Exception
+class IndexingMixin:
+    """Mixin for adding .loc/.iloc/.at/.iat to Datafames and Series.
+    """
+
+    @property
+    def iloc(self) -> "_iLocIndexer":
+        """
+        Purely integer-location based indexing for selection by position.
+
+        ``.iloc[]`` is primarily integer position based (from ``0`` to
+        ``length-1`` of the axis), but may also be used with a boolean
+        array.
+
+        Allowed inputs are:
+
+        - An integer, e.g. ``5``.
+        - A list or array of integers, e.g. ``[4, 3, 0]``.
+        - A slice object with ints, e.g. ``1:7``.
+        - A boolean array.
+        - A ``callable`` function with one argument (the calling Series or
+          DataFrame) and that returns valid output for indexing (one of the above).
+          This is useful in method chains, when you don't have a reference to the
+          calling object, but would like to base your selection on some value.
+
+        ``.iloc`` will raise ``IndexError`` if a requested indexer is
+        out-of-bounds, except *slice* indexers which allow out-of-bounds
+        indexing (this conforms with python/numpy *slice* semantics).
+
+        See more at :ref:`Selection by Position <indexing.integer>`.
+
+        See Also
+        --------
+        DataFrame.iat : Fast integer location scalar accessor.
+        DataFrame.loc : Purely label-location based indexer for selection by label.
+        Series.iloc : Purely integer-location based indexing for
+                       selection by position.
+
+        Examples
+        --------
+
+        >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
+        ...           {'a': 100, 'b': 200, 'c': 300, 'd': 400},
+        ...           {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
+        >>> df = pd.DataFrame(mydict)
+        >>> df
+              a     b     c     d
+        0     1     2     3     4
+        1   100   200   300   400
+        2  1000  2000  3000  4000
+
+        **Indexing just the rows**
+
+        With a scalar integer.
+
+        >>> type(df.iloc[0])
+        <class 'pandas.core.series.Series'>
+        >>> df.iloc[0]
+        a    1
+        b    2
+        c    3
+        d    4
+        Name: 0, dtype: int64
+
+        With a list of integers.
+
+        >>> df.iloc[[0]]
+           a  b  c  d
+        0  1  2  3  4
+        >>> type(df.iloc[[0]])
+        <class 'pandas.core.frame.DataFrame'>
+
+        >>> df.iloc[[0, 1]]
+             a    b    c    d
+        0    1    2    3    4
+        1  100  200  300  400
+
+        With a `slice` object.
+
+        >>> df.iloc[:3]
+              a     b     c     d
+        0     1     2     3     4
+        1   100   200   300   400
+        2  1000  2000  3000  4000
+
+        With a boolean mask the same length as the index.
+
+        >>> df.iloc[[True, False, True]]
+              a     b     c     d
+        0     1     2     3     4
+        2  1000  2000  3000  4000
+
+        With a callable, useful in method chains. The `x` passed
+        to the ``lambda`` is the DataFrame being sliced. This selects
+        the rows whose index label even.
+
+        >>> df.iloc[lambda x: x.index % 2 == 0]
+              a     b     c     d
+        0     1     2     3     4
+        2  1000  2000  3000  4000
+
+        **Indexing both axes**
+
+        You can mix the indexer types for the index and columns. Use ``:`` to
+        select the entire axis.
+
+        With scalar integers.
+
+        >>> df.iloc[0, 1]
+        2
+
+        With lists of integers.
+
+        >>> df.iloc[[0, 2], [1, 3]]
+              b     d
+        0     2     4
+        2  2000  4000
+
+        With `slice` objects.
+
+        >>> df.iloc[1:3, 0:3]
+              a     b     c
+        1   100   200   300
+        2  1000  2000  3000
+
+        With a boolean array whose length matches the columns.
+
+        >>> df.iloc[:, [True, False, True, False]]
+              a     c
+        0     1     3
+        1   100   300
+        2  1000  3000
+
+        With a callable function that expects the Series or DataFrame.
+
+        >>> df.iloc[:, lambda df: [0, 2]]
+              a     c
+        0     1     3
+        1   100   300
+        2  1000  3000
+        """
+        return _iLocIndexer("iloc", self)
+
+    @property
+    def loc(self) -> "_LocIndexer":
+        """
+        Access a group of rows and columns by label(s) or a boolean array.
+
+        ``.loc[]`` is primarily label based, but may also be used with a
+        boolean array.
+
+        Allowed inputs are:
+
+        - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is
+          interpreted as a *label* of the index, and **never** as an
+          integer position along the index).
+        - A list or array of labels, e.g. ``['a', 'b', 'c']``.
+        - A slice object with labels, e.g. ``'a':'f'``.
+
+          .. warning:: Note that contrary to usual python slices, **both** the
+              start and the stop are included
+
+        - A boolean array of the same length as the axis being sliced,
+          e.g. ``[True, False, True]``.
+        - A ``callable`` function with one argument (the calling Series or
+          DataFrame) and that returns valid output for indexing (one of the above)
+
+        See more at :ref:`Selection by Label <indexing.label>`
+
+        Raises
+        ------
+        KeyError
+            If any items are not found.
+
+        See Also
+        --------
+        DataFrame.at : Access a single value for a row/column label pair.
+        DataFrame.iloc : Access group of rows and columns by integer position(s).
+        DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the
+            Series/DataFrame.
+        Series.loc : Access group of values using labels.
+
+        Examples
+        --------
+        **Getting values**
+
+        >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
+        ...      index=['cobra', 'viper', 'sidewinder'],
+        ...      columns=['max_speed', 'shield'])
+        >>> df
+                    max_speed  shield
+        cobra               1       2
+        viper               4       5
+        sidewinder          7       8
+
+        Single label. Note this returns the row as a Series.
+
+        >>> df.loc['viper']
+        max_speed    4
+        shield       5
+        Name: viper, dtype: int64
+
+        List of labels. Note using ``[[]]`` returns a DataFrame.
+
+        >>> df.loc[['viper', 'sidewinder']]
+                    max_speed  shield
+        viper               4       5
+        sidewinder          7       8
+
+        Single label for row and column
+
+        >>> df.loc['cobra', 'shield']
+        2
+
+        Slice with labels for row and single label for column. As mentioned
+        above, note that both the start and stop of the slice are included.
+
+        >>> df.loc['cobra':'viper', 'max_speed']
+        cobra    1
+        viper    4
+        Name: max_speed, dtype: int64
+
+        Boolean list with the same length as the row axis
+
+        >>> df.loc[[False, False, True]]
+                    max_speed  shield
+        sidewinder          7       8
+
+        Conditional that returns a boolean Series
+
+        >>> df.loc[df['shield'] > 6]
+                    max_speed  shield
+        sidewinder          7       8
+
+        Conditional that returns a boolean Series with column labels specified
+
+        >>> df.loc[df['shield'] > 6, ['max_speed']]
+                    max_speed
+        sidewinder          7
+
+        Callable that returns a boolean Series
+
+        >>> df.loc[lambda df: df['shield'] == 8]
+                    max_speed  shield
+        sidewinder          7       8
+
+        **Setting values**
+
+        Set value for all items matching the list of labels
+
+        >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50
+        >>> df
+                    max_speed  shield
+        cobra               1       2
+        viper               4      50
+        sidewinder          7      50
+
+        Set value for an entire row
+
+        >>> df.loc['cobra'] = 10
+        >>> df
+                    max_speed  shield
+        cobra              10      10
+        viper               4      50
+        sidewinder          7      50
+
+        Set value for an entire column
+
+        >>> df.loc[:, 'max_speed'] = 30
+        >>> df
+                    max_speed  shield
+        cobra              30      10
+        viper              30      50
+        sidewinder         30      50
+
+        Set value for rows matching callable condition
+
+        >>> df.loc[df['shield'] > 35] = 0
+        >>> df
+                    max_speed  shield
+        cobra              30      10
+        viper               0       0
+        sidewinder          0       0
+
+        **Getting values on a DataFrame with an index that has integer labels**
+
+        Another example using integers for the index
+
+        >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
+        ...      index=[7, 8, 9], columns=['max_speed', 'shield'])
+        >>> df
+           max_speed  shield
+        7          1       2
+        8          4       5
+        9          7       8
+
+        Slice with integer labels for rows. As mentioned above, note that both
+        the start and stop of the slice are included.
+
+        >>> df.loc[7:9]
+           max_speed  shield
+        7          1       2
+        8          4       5
+        9          7       8
+
+        **Getting values with a MultiIndex**
+
+        A number of examples using a DataFrame with a MultiIndex
+
+        >>> tuples = [
+        ...    ('cobra', 'mark i'), ('cobra', 'mark ii'),
+        ...    ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),
+        ...    ('viper', 'mark ii'), ('viper', 'mark iii')
+        ... ]
+        >>> index = pd.MultiIndex.from_tuples(tuples)
+        >>> values = [[12, 2], [0, 4], [10, 20],
+        ...         [1, 4], [7, 1], [16, 36]]
+        >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)
+        >>> df
+                             max_speed  shield
+        cobra      mark i           12       2
+                   mark ii           0       4
+        sidewinder mark i           10      20
+                   mark ii           1       4
+        viper      mark ii           7       1
+                   mark iii         16      36
+
+        Single label. Note this returns a DataFrame with a single index.
+
+        >>> df.loc['cobra']
+                 max_speed  shield
+        mark i          12       2
+        mark ii          0       4
+
+        Single index tuple. Note this returns a Series.
+
+        >>> df.loc[('cobra', 'mark ii')]
+        max_speed    0
+        shield       4
+        Name: (cobra, mark ii), dtype: int64
+
+        Single label for row and column. Similar to passing in a tuple, this
+        returns a Series.
+
+        >>> df.loc['cobra', 'mark i']
+        max_speed    12
+        shield        2
+        Name: (cobra, mark i), dtype: int64
+
+        Single tuple. Note using ``[[]]`` returns a DataFrame.
+
+        >>> df.loc[[('cobra', 'mark ii')]]
+                       max_speed  shield
+        cobra mark ii          0       4
+
+        Single tuple for the index with a single label for the column
+
+        >>> df.loc[('cobra', 'mark i'), 'shield']
+        2
+
+        Slice from index tuple to single label
+
+        >>> df.loc[('cobra', 'mark i'):'viper']
+                             max_speed  shield
+        cobra      mark i           12       2
+                   mark ii           0       4
+        sidewinder mark i           10      20
+                   mark ii           1       4
+        viper      mark ii           7       1
+                   mark iii         16      36
+
+        Slice from index tuple to index tuple
+
+        >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]
+                            max_speed  shield
+        cobra      mark i          12       2
+                   mark ii          0       4
+        sidewinder mark i          10      20
+                   mark ii          1       4
+        viper      mark ii          7       1
+        """
+        return _LocIndexer("loc", self)
+
+    @property
+    def at(self) -> "_AtIndexer":
+        """
+        Access a single value for a row/column label pair.
+
+        Similar to ``loc``, in that both provide label-based lookups. Use
+        ``at`` if you only need to get or set a single value in a DataFrame
+        or Series.
+
+        Raises
+        ------
+        KeyError
+            If 'label' does not exist in DataFrame.
+
+        See Also
+        --------
+        DataFrame.iat : Access a single value for a row/column pair by integer
+            position.
+        DataFrame.loc : Access a group of rows and columns by label(s).
+        Series.at : Access a single value using a label.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
+        ...                   index=[4, 5, 6], columns=['A', 'B', 'C'])
+        >>> df
+            A   B   C
+        4   0   2   3
+        5   0   4   1
+        6  10  20  30
+
+        Get value at specified row/column pair
+
+        >>> df.at[4, 'B']
+        2
+
+        Set value at specified row/column pair
+
+        >>> df.at[4, 'B'] = 10
+        >>> df.at[4, 'B']
+        10
+
+        Get value within a Series
+
+        >>> df.loc[5].at['B']
+        4
+        """
+        return _AtIndexer("at", self)
+
+    @property
+    def iat(self) -> "_iAtIndexer":
+        """
+        Access a single value for a row/column pair by integer position.
+
+        Similar to ``iloc``, in that both provide integer-based lookups. Use
+        ``iat`` if you only need to get or set a single value in a DataFrame
+        or Series.
+
+        Raises
+        ------
+        IndexError
+            When integer position is out of bounds.
+
+        See Also
+        --------
+        DataFrame.at : Access a single value for a row/column label pair.
+        DataFrame.loc : Access a group of rows and columns by label(s).
+        DataFrame.iloc : Access a group of rows and columns by integer position(s).
+
+        Examples
+        --------
+        >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
+        ...                   columns=['A', 'B', 'C'])
+        >>> df
+            A   B   C
+        0   0   2   3
+        1   0   4   1
+        2  10  20  30
+
+        Get value at specified row/column pair
+
+        >>> df.iat[1, 2]
+        1
+
+        Set value at specified row/column pair
+
+        >>> df.iat[1, 2] = 10
+        >>> df.iat[1, 2]
+        10
+
+        Get value within a series
+
+        >>> df.loc[0].iat[1]
+        2
+        """
+        return _iAtIndexer("iat", self)
+
+
+class _LocationIndexer(_NDFrameIndexerBase):
+    _valid_types: str
     axis = None
 
     def __call__(self, axis=None):
         # we need to return a copy of ourselves
-        new_self = self.__class__(self.name, self.obj)
+        new_self = type(self)(self.name, self.obj)
 
         if axis is not None:
             axis = self.obj._get_axis_number(axis)
         new_self.axis = axis
         return new_self
 
-    def __iter__(self):
-        raise NotImplementedError("ix is not iterable")
-
-    def __getitem__(self, key):
-        # Used in ix and downstream in geopandas _CoordinateIndexer
-        if type(key) is tuple:
-            # Note: we check the type exactly instead of with isinstance
-            #  because NamedTuple is checked separately.
-            key = tuple(com.apply_if_callable(x, self.obj) for x in key)
-            try:
-                values = self.obj._get_value(*key)
-            except (KeyError, TypeError, InvalidIndexError, AttributeError):
-                # TypeError occurs here if the key has non-hashable entries,
-                #  generally slice or list.
-                # TODO(ix): most/all of the TypeError cases here are for ix,
-                #  so this check can be removed once ix is removed.
-                # The InvalidIndexError is only catched for compatibility
-                #  with geopandas, see
-                #  https://github.com/pandas-dev/pandas/issues/27258
-                # TODO: The AttributeError is for IntervalIndex which
-                #  incorrectly implements get_value, see
-                #  https://github.com/pandas-dev/pandas/issues/27865
-                pass
-            else:
-                if is_scalar(values):
-                    return values
-
-            return self._getitem_tuple(key)
-        else:
-            # we by definition only have the 0th axis
-            axis = self.axis or 0
-
-            key = com.apply_if_callable(key, self.obj)
-            return self._getitem_axis(key, axis=axis)
-
     def _get_label(self, label, axis: int):
         if self.ndim == 1:
             # for perf reasons we want to try _xs first
@@ -160,37 +590,33 @@ def _get_label(self, label, axis: int):
 
         return self.obj._xs(label, axis=axis)
 
-    def _get_loc(self, key: int, axis: int):
-        return self.obj._ixs(key, axis=axis)
-
-    def _slice(self, obj, axis: int, kind=None):
-        return self.obj._slice(obj, axis=axis, kind=kind)
-
     def _get_setitem_indexer(self, key):
+        """
+        Convert a potentially-label-based key into a positional indexer.
+        """
         if self.axis is not None:
-            return self._convert_tuple(key)
+            return self._convert_tuple(key, is_setter=True)
 
         ax = self.obj._get_axis(0)
 
         if isinstance(ax, ABCMultiIndex) and self.name != "iloc":
             try:
                 return ax.get_loc(key)
-            except (TypeError, KeyError):
+            except (TypeError, KeyError, InvalidIndexError):
                 # TypeError e.g. passed a bool
                 pass
 
         if isinstance(key, tuple):
             try:
-                return self._convert_tuple(key)
+                return self._convert_tuple(key, is_setter=True)
             except IndexingError:
                 pass
 
         if isinstance(key, range):
             return list(key)
 
-        axis = self.axis or 0
         try:
-            return self._convert_to_indexer(key, axis=axis)
+            return self._convert_to_indexer(key, axis=0, is_setter=True)
         except TypeError as e:
 
             # invalid indexer type vs 'other' indexing errors
@@ -204,7 +630,10 @@ def __setitem__(self, key, value):
         else:
             key = com.apply_if_callable(key, self.obj)
         indexer = self._get_setitem_indexer(key)
-        self._setitem_with_indexer(indexer, value)
+        self._has_valid_setitem_indexer(key)
+
+        iloc = self if self.name == "iloc" else self.obj.iloc
+        iloc._setitem_with_indexer(indexer, value)
 
     def _validate_key(self, key, axis: int):
         """
@@ -213,23 +642,25 @@ def _validate_key(self, key, axis: int):
         Parameters
         ----------
         key : scalar, slice or list-like
-            The key requested
+            Key requested.
         axis : int
-            Dimension on which the indexing is being made
+            Dimension on which the indexing is being made.
 
         Raises
         ------
         TypeError
-            If the key (or some element of it) has wrong type
+            If the key (or some element of it) has wrong type.
         IndexError
-            If the key (or some element of it) is out of bounds
+            If the key (or some element of it) is out of bounds.
         KeyError
-            If the key was not found
+            If the key was not found.
         """
         raise AbstractMethodError(self)
 
     def _has_valid_tuple(self, key: Tuple):
-        """ check the key for valid keys across my indexer """
+        """
+        Check the key for valid keys across my indexer.
+        """
         for i, k in enumerate(key):
             if i >= self.ndim:
                 raise IndexingError("Too many indexers")
@@ -238,968 +669,486 @@ def _has_valid_tuple(self, key: Tuple):
             except ValueError:
                 raise ValueError(
                     "Location based indexing can only have "
-                    "[{types}] types".format(types=self._valid_types)
+                    f"[{self._valid_types}] types"
                 )
 
-    def _is_nested_tuple_indexer(self, tup: Tuple):
+    def _is_nested_tuple_indexer(self, tup: Tuple) -> bool:
+        """
+        Returns
+        -------
+        bool
+        """
         if any(isinstance(ax, ABCMultiIndex) for ax in self.obj.axes):
             return any(is_nested_tuple(tup, ax) for ax in self.obj.axes)
         return False
 
-    def _convert_tuple(self, key):
+    def _convert_tuple(self, key, is_setter: bool = False):
         keyidx = []
         if self.axis is not None:
             axis = self.obj._get_axis_number(self.axis)
             for i in range(self.ndim):
                 if i == axis:
-                    keyidx.append(self._convert_to_indexer(key, axis=axis))
+                    keyidx.append(
+                        self._convert_to_indexer(key, axis=axis, is_setter=is_setter)
+                    )
                 else:
                     keyidx.append(slice(None))
         else:
             for i, k in enumerate(key):
                 if i >= self.ndim:
                     raise IndexingError("Too many indexers")
-                idx = self._convert_to_indexer(k, axis=i)
+                idx = self._convert_to_indexer(k, axis=i, is_setter=is_setter)
                 keyidx.append(idx)
         return tuple(keyidx)
 
-    def _convert_scalar_indexer(self, key, axis: int):
-        # if we are accessing via lowered dim, use the last dim
-        ax = self.obj._get_axis(min(axis, self.ndim - 1))
-        # a scalar
-        return ax._convert_scalar_indexer(key, kind=self.name)
+    def _handle_lowerdim_multi_index_axis0(self, tup: Tuple):
+        # we have an axis0 multi-index, handle or raise
+        axis = self.axis or 0
+        try:
+            # fast path for series or for tup devoid of slices
+            return self._get_label(tup, axis=axis)
+        except TypeError:
+            # slices are unhashable
+            pass
+        except KeyError as ek:
+            # raise KeyError if number of indexers match
+            # else IndexingError will be raised
+            if len(tup) <= self.obj.index.nlevels and len(tup) > self.ndim:
+                raise ek
 
-    def _convert_slice_indexer(self, key: slice, axis: int):
-        # if we are accessing via lowered dim, use the last dim
-        ax = self.obj._get_axis(min(axis, self.ndim - 1))
-        return ax._convert_slice_indexer(key, kind=self.name)
+        return None
 
-    def _has_valid_setitem_indexer(self, indexer):
-        return True
+    def _getitem_lowerdim(self, tup: Tuple):
 
-    def _has_valid_positional_setitem_indexer(self, indexer):
-        """ validate that an positional indexer cannot enlarge its target
-        will raise if needed, does not modify the indexer externally
-        """
-        if isinstance(indexer, dict):
-            raise IndexError("{0} cannot enlarge its target object".format(self.name))
-        else:
-            if not isinstance(indexer, tuple):
-                indexer = _tuplify(self.ndim, indexer)
-            for ax, i in zip(self.obj.axes, indexer):
-                if isinstance(i, slice):
-                    # should check the stop slice?
-                    pass
-                elif is_list_like_indexer(i):
-                    # should check the elements?
-                    pass
-                elif is_integer(i):
-                    if i >= len(ax):
-                        raise IndexError(
-                            "{name} cannot enlarge its target "
-                            "object".format(name=self.name)
-                        )
-                elif isinstance(i, dict):
-                    raise IndexError(
-                        "{name} cannot enlarge its target object".format(name=self.name)
-                    )
+        # we can directly get the axis result since the axis is specified
+        if self.axis is not None:
+            axis = self.obj._get_axis_number(self.axis)
+            return self._getitem_axis(tup, axis=axis)
 
-        return True
+        # we may have a nested tuples indexer here
+        if self._is_nested_tuple_indexer(tup):
+            return self._getitem_nested_tuple(tup)
 
-    def _setitem_with_indexer(self, indexer, value):
-        self._has_valid_setitem_indexer(indexer)
+        # we maybe be using a tuple to represent multiple dimensions here
+        ax0 = self.obj._get_axis(0)
+        # ...but iloc should handle the tuple as simple integer-location
+        # instead of checking it as multiindex representation (GH 13797)
+        if isinstance(ax0, ABCMultiIndex) and self.name != "iloc":
+            result = self._handle_lowerdim_multi_index_axis0(tup)
+            if result is not None:
+                return result
 
-        # also has the side effect of consolidating in-place
-        from pandas import Series
+        if len(tup) > self.ndim:
+            raise IndexingError("Too many indexers. handle elsewhere")
 
-        info_axis = self.obj._info_axis_number
+        for i, key in enumerate(tup):
+            if is_label_like(key) or isinstance(key, tuple):
+                section = self._getitem_axis(key, axis=i)
 
-        # maybe partial set
-        take_split_path = self.obj._is_mixed_type
+                # we have yielded a scalar ?
+                if not is_list_like_indexer(section):
+                    return section
 
-        # if there is only one block/type, still have to take split path
-        # unless the block is one-dimensional or it can hold the value
-        if not take_split_path and self.obj._data.blocks:
-            blk, = self.obj._data.blocks
-            if 1 < blk.ndim:  # in case of dict, keys are indices
-                val = list(value.values()) if isinstance(value, dict) else value
-                take_split_path = not blk._can_hold_element(val)
+                elif section.ndim == self.ndim:
+                    # we're in the middle of slicing through a MultiIndex
+                    # revise the key wrt to `section` by inserting an _NS
+                    new_key = tup[:i] + (_NS,) + tup[i + 1 :]
 
-        # if we have any multi-indexes that have non-trivial slices
-        # (not null slices) then we must take the split path, xref
-        # GH 10360, GH 27841
-        if isinstance(indexer, tuple) and len(indexer) == len(self.obj.axes):
-            for i, ax in zip(indexer, self.obj.axes):
-                if isinstance(ax, ABCMultiIndex) and not (
-                    is_integer(i) or com.is_null_slice(i)
-                ):
-                    take_split_path = True
-                    break
+                else:
+                    # Note: the section.ndim == self.ndim check above
+                    #  rules out having DataFrame here, so we dont need to worry
+                    #  about transposing.
+                    new_key = tup[:i] + tup[i + 1 :]
 
-        if isinstance(indexer, tuple):
-            nindexer = []
-            for i, idx in enumerate(indexer):
-                if isinstance(idx, dict):
+                    if len(new_key) == 1:
+                        new_key = new_key[0]
 
-                    # reindex the axis to the new value
-                    # and set inplace
-                    key, _ = convert_missing_indexer(idx)
+                # Slices should return views, but calling iloc/loc with a null
+                # slice returns a new object.
+                if com.is_null_slice(new_key):
+                    return section
+                # This is an elided recursive call to iloc/loc/etc'
+                return getattr(section, self.name)[new_key]
 
-                    # if this is the items axes, then take the main missing
-                    # path first
-                    # this correctly sets the dtype and avoids cache issues
-                    # essentially this separates out the block that is needed
-                    # to possibly be modified
-                    if self.ndim > 1 and i == self.obj._info_axis_number:
-
-                        # add the new item, and set the value
-                        # must have all defined axes if we have a scalar
-                        # or a list-like on the non-info axes if we have a
-                        # list-like
-                        len_non_info_axes = (
-                            len(_ax) for _i, _ax in enumerate(self.obj.axes) if _i != i
-                        )
-                        if any(not l for l in len_non_info_axes):
-                            if not is_list_like_indexer(value):
-                                raise ValueError(
-                                    "cannot set a frame with no "
-                                    "defined index and a scalar"
-                                )
-                            self.obj[key] = value
-                            return self.obj
-
-                        # add a new item with the dtype setup
-                        self.obj[key] = _infer_fill_value(value)
-
-                        new_indexer = convert_from_missing_indexer_tuple(
-                            indexer, self.obj.axes
-                        )
-                        self._setitem_with_indexer(new_indexer, value)
-
-                        return self.obj
-
-                    # reindex the axis
-                    # make sure to clear the cache because we are
-                    # just replacing the block manager here
-                    # so the object is the same
-                    index = self.obj._get_axis(i)
-                    labels = index.insert(len(index), key)
-                    self.obj._data = self.obj.reindex(labels, axis=i)._data
-                    self.obj._maybe_update_cacher(clear=True)
-                    self.obj._is_copy = None
-
-                    nindexer.append(labels.get_loc(key))
-
-                else:
-                    nindexer.append(idx)
-
-            indexer = tuple(nindexer)
-        else:
-
-            indexer, missing = convert_missing_indexer(indexer)
-
-            if missing:
-                return self._setitem_with_indexer_missing(indexer, value)
-
-        # set
-        item_labels = self.obj._get_axis(info_axis)
-
-        # align and set the values
-        if take_split_path:
-            # Above we only set take_split_path to True for 2D cases
-            assert self.ndim == 2
-            assert info_axis == 1
-
-            if not isinstance(indexer, tuple):
-                indexer = _tuplify(self.ndim, indexer)
-
-            if isinstance(value, ABCSeries):
-                value = self._align_series(indexer, value)
-
-            info_idx = indexer[info_axis]
-            if is_integer(info_idx):
-                info_idx = [info_idx]
-            labels = item_labels[info_idx]
-
-            # if we have a partial multiindex, then need to adjust the plane
-            # indexer here
-            if len(labels) == 1 and isinstance(
-                self.obj[labels[0]].axes[0], ABCMultiIndex
-            ):
-                item = labels[0]
-                obj = self.obj[item]
-                index = obj.index
-                idx = indexer[:info_axis][0]
-
-                plane_indexer = tuple([idx]) + indexer[info_axis + 1 :]
-                lplane_indexer = length_of_indexer(plane_indexer[0], index)
-
-                # require that we are setting the right number of values that
-                # we are indexing
-                if (
-                    is_list_like_indexer(value)
-                    and np.iterable(value)
-                    and lplane_indexer != len(value)
-                ):
-
-                    if len(obj[idx]) != len(value):
-                        raise ValueError(
-                            "cannot set using a multi-index "
-                            "selection indexer with a different "
-                            "length than the value"
-                        )
-
-                    # make sure we have an ndarray
-                    value = getattr(value, "values", value).ravel()
-
-                    # we can directly set the series here
-                    # as we select a slice indexer on the mi
-                    idx = index._convert_slice_indexer(idx)
-                    obj._consolidate_inplace()
-                    obj = obj.copy()
-                    obj._data = obj._data.setitem(indexer=tuple([idx]), value=value)
-                    self.obj[item] = obj
-                    return
-
-            # non-mi
-            else:
-                plane_indexer = indexer[:info_axis] + indexer[info_axis + 1 :]
-                plane_axis = self.obj.axes[:info_axis][0]
-                lplane_indexer = length_of_indexer(plane_indexer[0], plane_axis)
-
-            def setter(item, v):
-                s = self.obj[item]
-                pi = plane_indexer[0] if lplane_indexer == 1 else plane_indexer
-
-                # perform the equivalent of a setitem on the info axis
-                # as we have a null slice or a slice with full bounds
-                # which means essentially reassign to the columns of a
-                # multi-dim object
-                # GH6149 (null slice), GH10408 (full bounds)
-                if isinstance(pi, tuple) and all(
-                    com.is_null_slice(idx) or com.is_full_slice(idx, len(self.obj))
-                    for idx in pi
-                ):
-                    s = v
-                else:
-                    # set the item, possibly having a dtype change
-                    s._consolidate_inplace()
-                    s = s.copy()
-                    s._data = s._data.setitem(indexer=pi, value=v)
-                    s._maybe_update_cacher(clear=True)
-
-                # reset the sliced object if unique
-                self.obj[item] = s
-
-            # we need an iterable, with a ndim of at least 1
-            # eg. don't pass through np.array(0)
-            if is_list_like_indexer(value) and getattr(value, "ndim", 1) > 0:
-
-                # we have an equal len Frame
-                if isinstance(value, ABCDataFrame):
-                    sub_indexer = list(indexer)
-                    multiindex_indexer = isinstance(labels, ABCMultiIndex)
-
-                    for item in labels:
-                        if item in value:
-                            sub_indexer[info_axis] = item
-                            v = self._align_series(
-                                tuple(sub_indexer), value[item], multiindex_indexer
-                            )
-                        else:
-                            v = np.nan
-
-                        setter(item, v)
-
-                # we have an equal len ndarray/convertible to our labels
-                # hasattr first, to avoid coercing to ndarray without reason.
-                # But we may be relying on the ndarray coercion to check ndim.
-                # Why not just convert to an ndarray earlier on if needed?
-                elif np.ndim(value) == 2:
-
-                    # note that this coerces the dtype if we are mixed
-                    # GH 7551
-                    value = np.array(value, dtype=object)
-                    if len(labels) != value.shape[1]:
-                        raise ValueError(
-                            "Must have equal len keys and value "
-                            "when setting with an ndarray"
-                        )
-
-                    for i, item in enumerate(labels):
-
-                        # setting with a list, recoerces
-                        setter(item, value[:, i].tolist())
-
-                # we have an equal len list/ndarray
-                elif _can_do_equal_len(
-                    labels, value, plane_indexer, lplane_indexer, self.obj
-                ):
-                    setter(labels[0], value)
-
-                # per label values
-                else:
-
-                    if len(labels) != len(value):
-                        raise ValueError(
-                            "Must have equal len keys and value "
-                            "when setting with an iterable"
-                        )
-
-                    for item, v in zip(labels, value):
-                        setter(item, v)
-            else:
-
-                # scalar
-                for item in labels:
-                    setter(item, value)
-
-        else:
-            if isinstance(indexer, tuple):
-                indexer = maybe_convert_ix(*indexer)
-
-                # if we are setting on the info axis ONLY
-                # set using those methods to avoid block-splitting
-                # logic here
-                if (
-                    len(indexer) > info_axis
-                    and is_integer(indexer[info_axis])
-                    and all(
-                        com.is_null_slice(idx)
-                        for i, idx in enumerate(indexer)
-                        if i != info_axis
-                    )
-                    and item_labels.is_unique
-                ):
-                    self.obj[item_labels[indexer[info_axis]]] = value
-                    return
-
-            if isinstance(value, (ABCSeries, dict)):
-                # TODO(EA): ExtensionBlock.setitem this causes issues with
-                # setting for extensionarrays that store dicts. Need to decide
-                # if it's worth supporting that.
-                value = self._align_series(indexer, Series(value))
-
-            elif isinstance(value, ABCDataFrame):
-                value = self._align_frame(indexer, value)
-
-            # check for chained assignment
-            self.obj._check_is_chained_assignment_possible()
-
-            # actually do the set
-            self.obj._consolidate_inplace()
-            self.obj._data = self.obj._data.setitem(indexer=indexer, value=value)
-            self.obj._maybe_update_cacher(clear=True)
-
-    def _setitem_with_indexer_missing(self, indexer, value):
-        """
-        Insert new row(s) or column(s) into the Series or DataFrame.
-        """
-        from pandas import Series
-
-        # reindex the axis to the new value
-        # and set inplace
-        if self.ndim == 1:
-            index = self.obj.index
-            new_index = index.insert(len(index), indexer)
-
-            # we have a coerced indexer, e.g. a float
-            # that matches in an Int64Index, so
-            # we will not create a duplicate index, rather
-            # index to that element
-            # e.g. 0.0 -> 0
-            # GH#12246
-            if index.is_unique:
-                new_indexer = index.get_indexer([new_index[-1]])
-                if (new_indexer != -1).any():
-                    return self._setitem_with_indexer(new_indexer, value)
-
-            # this preserves dtype of the value
-            new_values = Series([value])._values
-            if len(self.obj._values):
-                # GH#22717 handle casting compatibility that np.concatenate
-                #  does incorrectly
-                new_values = concat_compat([self.obj._values, new_values])
-            self.obj._data = self.obj._constructor(
-                new_values, index=new_index, name=self.obj.name
-            )._data
-            self.obj._maybe_update_cacher(clear=True)
-            return self.obj
-
-        elif self.ndim == 2:
-
-            if not len(self.obj.columns):
-                # no columns and scalar
-                raise ValueError("cannot set a frame with no defined columns")
-
-            if isinstance(value, ABCSeries):
-                # append a Series
-                value = value.reindex(index=self.obj.columns, copy=True)
-                value.name = indexer
-
-            else:
-                # a list-list
-                if is_list_like_indexer(value):
-                    # must have conforming columns
-                    if len(value) != len(self.obj.columns):
-                        raise ValueError("cannot set a row with mismatched columns")
-
-                value = Series(value, index=self.obj.columns, name=indexer)
-
-            self.obj._data = self.obj.append(value)._data
-            self.obj._maybe_update_cacher(clear=True)
-            return self.obj
-
-    def _align_series(self, indexer, ser: ABCSeries, multiindex_indexer: bool = False):
-        """
-        Parameters
-        ----------
-        indexer : tuple, slice, scalar
-            The indexer used to get the locations that will be set to
-            `ser`
-        ser : pd.Series
-            The values to assign to the locations specified by `indexer`
-        multiindex_indexer : boolean, optional
-            Defaults to False. Should be set to True if `indexer` was from
-            a `pd.MultiIndex`, to avoid unnecessary broadcasting.
-
-        Returns
-        -------
-        `np.array` of `ser` broadcast to the appropriate shape for assignment
-        to the locations selected by `indexer`
-        """
-        if isinstance(indexer, (slice, np.ndarray, list, Index)):
-            indexer = tuple([indexer])
-
-        if isinstance(indexer, tuple):
-
-            # flatten np.ndarray indexers
-            def ravel(i):
-                return i.ravel() if isinstance(i, np.ndarray) else i
-
-            indexer = tuple(map(ravel, indexer))
-
-            aligners = [not com.is_null_slice(idx) for idx in indexer]
-            sum_aligners = sum(aligners)
-            single_aligner = sum_aligners == 1
-            is_frame = self.ndim == 2
-            obj = self.obj
-
-            # are we a single alignable value on a non-primary
-            # dim (e.g. panel: 1,2, or frame: 0) ?
-            # hence need to align to a single axis dimension
-            # rather that find all valid dims
-
-            # frame
-            if is_frame:
-                single_aligner = single_aligner and aligners[0]
-
-            # we have a frame, with multiple indexers on both axes; and a
-            # series, so need to broadcast (see GH5206)
-            if sum_aligners == self.ndim and all(is_sequence(_) for _ in indexer):
-                ser = ser.reindex(obj.axes[0][indexer[0]], copy=True)._values
-
-                # single indexer
-                if len(indexer) > 1 and not multiindex_indexer:
-                    len_indexer = len(indexer[1])
-                    ser = np.tile(ser, len_indexer).reshape(len_indexer, -1).T
-
-                return ser
-
-            for i, idx in enumerate(indexer):
-                ax = obj.axes[i]
-
-                # multiple aligners (or null slices)
-                if is_sequence(idx) or isinstance(idx, slice):
-                    if single_aligner and com.is_null_slice(idx):
-                        continue
-                    new_ix = ax[idx]
-                    if not is_list_like_indexer(new_ix):
-                        new_ix = Index([new_ix])
-                    else:
-                        new_ix = Index(new_ix)
-                    if ser.index.equals(new_ix) or not len(new_ix):
-                        return ser._values.copy()
-
-                    return ser.reindex(new_ix)._values
-
-                # 2 dims
-                elif single_aligner:
-
-                    # reindex along index
-                    ax = self.obj.axes[1]
-                    if ser.index.equals(ax) or not len(ax):
-                        return ser._values.copy()
-                    return ser.reindex(ax)._values
-
-        elif is_scalar(indexer):
-            ax = self.obj._get_axis(1)
-
-            if ser.index.equals(ax):
-                return ser._values.copy()
-
-            return ser.reindex(ax)._values
-
-        raise ValueError("Incompatible indexer with Series")
-
-    def _align_frame(self, indexer, df: ABCDataFrame):
-        is_frame = self.ndim == 2
-
-        if isinstance(indexer, tuple):
-
-            idx, cols = None, None
-            sindexers = []
-            for i, ix in enumerate(indexer):
-                ax = self.obj.axes[i]
-                if is_sequence(ix) or isinstance(ix, slice):
-                    if isinstance(ix, np.ndarray):
-                        ix = ix.ravel()
-                    if idx is None:
-                        idx = ax[ix]
-                    elif cols is None:
-                        cols = ax[ix]
-                    else:
-                        break
-                else:
-                    sindexers.append(i)
-
-            if idx is not None and cols is not None:
-
-                if df.index.equals(idx) and df.columns.equals(cols):
-                    val = df.copy()._values
-                else:
-                    val = df.reindex(idx, columns=cols)._values
-                return val
-
-        elif (isinstance(indexer, slice) or is_list_like_indexer(indexer)) and is_frame:
-            ax = self.obj.index[indexer]
-            if df.index.equals(ax):
-                val = df.copy()._values
-            else:
-
-                # we have a multi-index and are trying to align
-                # with a particular, level GH3738
-                if (
-                    isinstance(ax, ABCMultiIndex)
-                    and isinstance(df.index, ABCMultiIndex)
-                    and ax.nlevels != df.index.nlevels
-                ):
-                    raise TypeError(
-                        "cannot align on a multi-index with out "
-                        "specifying the join levels"
-                    )
-
-                val = df.reindex(index=ax)._values
-            return val
-
-        raise ValueError("Incompatible indexer with DataFrame")
+        raise IndexingError("not applicable")
 
-    def _getitem_tuple(self, tup: Tuple):
-        try:
-            return self._getitem_lowerdim(tup)
-        except IndexingError:
-            pass
+    def _getitem_nested_tuple(self, tup: Tuple):
+        # we have a nested tuple so have at least 1 multi-index level
+        # we should be able to match up the dimensionality here
 
-        # no multi-index, so validate all of the indexers
-        self._has_valid_tuple(tup)
+        # we have too many indexers for our dim, but have at least 1
+        # multi-index dimension, try to see if we have something like
+        # a tuple passed to a series with a multi-index
+        if len(tup) > self.ndim:
+            result = self._handle_lowerdim_multi_index_axis0(tup)
+            if result is not None:
+                return result
 
-        # ugly hack for GH #836
-        if self._multi_take_opportunity(tup):
-            return self._multi_take(tup)
+            # this is a series with a multi-index specified a tuple of
+            # selectors
+            axis = self.axis or 0
+            return self._getitem_axis(tup, axis=axis)
 
-        # no shortcut needed
-        retval = self.obj
+        # handle the multi-axis by taking sections and reducing
+        # this is iterative
+        obj = self.obj
+        axis = 0
         for i, key in enumerate(tup):
+
             if com.is_null_slice(key):
+                axis += 1
                 continue
 
-            retval = getattr(retval, self.name)._getitem_axis(key, axis=i)
-
-        return retval
-
-    def _multi_take_opportunity(self, tup: Tuple):
-        """
-        Check whether there is the possibility to use ``_multi_take``.
-        Currently the limit is that all axes being indexed must be indexed with
-        list-likes.
-
-        Parameters
-        ----------
-        tup : tuple
-            Tuple of indexers, one per axis
-
-        Returns
-        -------
-        boolean: Whether the current indexing can be passed through _multi_take
-        """
-        if not all(is_list_like_indexer(x) for x in tup):
-            return False
-
-        # just too complicated
-        if any(com.is_bool_indexer(x) for x in tup):
-            return False
-
-        return True
-
-    def _multi_take(self, tup: Tuple):
-        """
-        Create the indexers for the passed tuple of keys, and execute the take
-        operation. This allows the take operation to be executed all at once -
-        rather than once for each dimension - improving efficiency.
-
-        Parameters
-        ----------
-        tup : tuple
-            Tuple of indexers, one per axis
-
-        Returns
-        -------
-        values: same type as the object being indexed
-        """
-        # GH 836
-        o = self.obj
-        d = {
-            axis: self._get_listlike_indexer(key, axis)
-            for (key, axis) in zip(tup, o._AXIS_ORDERS)
-        }
-        return o._reindex_with_indexers(d, copy=True, allow_dups=True)
-
-    def _convert_for_reindex(self, key, axis: int):
-        return key
-
-    def _handle_lowerdim_multi_index_axis0(self, tup: Tuple):
-        # we have an axis0 multi-index, handle or raise
-        axis = self.axis or 0
-        try:
-            # fast path for series or for tup devoid of slices
-            return self._get_label(tup, axis=axis)
-        except TypeError:
-            # slices are unhashable
-            pass
-        except KeyError as ek:
-            # raise KeyError if number of indexers match
-            # else IndexingError will be raised
-            if len(tup) <= self.obj.index.nlevels and len(tup) > self.ndim:
-                raise ek
-        except Exception as e1:
-            if isinstance(tup[0], (slice, Index)):
-                raise IndexingError("Handle elsewhere")
+            current_ndim = obj.ndim
+            obj = getattr(obj, self.name)._getitem_axis(key, axis=axis)
+            axis += 1
 
-            # raise the error if we are not sorted
-            ax0 = self.obj._get_axis(0)
-            if not ax0.is_lexsorted_for_tuple(tup):
-                raise e1
+            # if we have a scalar, we are done
+            if is_scalar(obj) or not hasattr(obj, "ndim"):
+                break
 
-        return None
+            # has the dim of the obj changed?
+            # GH 7199
+            if obj.ndim < current_ndim:
+                axis -= 1
 
-    def _getitem_lowerdim(self, tup: Tuple):
+        return obj
 
-        # we can directly get the axis result since the axis is specified
-        if self.axis is not None:
-            axis = self.obj._get_axis_number(self.axis)
-            return self._getitem_axis(tup, axis=axis)
+    def _convert_to_indexer(self, key, axis: int, is_setter: bool = False):
+        raise AbstractMethodError(self)
 
-        # we may have a nested tuples indexer here
-        if self._is_nested_tuple_indexer(tup):
-            return self._getitem_nested_tuple(tup)
+    def __getitem__(self, key):
+        if type(key) is tuple:
+            key = tuple(com.apply_if_callable(x, self.obj) for x in key)
+            if self._is_scalar_access(key):
+                try:
+                    return self.obj._get_value(*key, takeable=self._takeable)
+                except (KeyError, IndexError, AttributeError):
+                    # AttributeError for IntervalTree get_value
+                    pass
+            return self._getitem_tuple(key)
+        else:
+            # we by definition only have the 0th axis
+            axis = self.axis or 0
 
-        # we maybe be using a tuple to represent multiple dimensions here
-        ax0 = self.obj._get_axis(0)
-        # ...but iloc should handle the tuple as simple integer-location
-        # instead of checking it as multiindex representation (GH 13797)
-        if isinstance(ax0, ABCMultiIndex) and self.name != "iloc":
-            result = self._handle_lowerdim_multi_index_axis0(tup)
-            if result is not None:
-                return result
+            maybe_callable = com.apply_if_callable(key, self.obj)
+            return self._getitem_axis(maybe_callable, axis=axis)
 
-        if len(tup) > self.ndim:
-            raise IndexingError("Too many indexers. handle elsewhere")
+    def _is_scalar_access(self, key: Tuple):
+        raise NotImplementedError()
 
-        # to avoid wasted computation
-        # df.ix[d1:d2, 0] -> columns first (True)
-        # df.ix[0, ['C', 'B', A']] -> rows first (False)
-        for i, key in enumerate(tup):
-            if is_label_like(key) or isinstance(key, tuple):
-                section = self._getitem_axis(key, axis=i)
+    def _getitem_tuple(self, tup: Tuple):
+        raise AbstractMethodError(self)
 
-                # we have yielded a scalar ?
-                if not is_list_like_indexer(section):
-                    return section
+    def _getitem_axis(self, key, axis: int):
+        raise NotImplementedError()
 
-                elif section.ndim == self.ndim:
-                    # we're in the middle of slicing through a MultiIndex
-                    # revise the key wrt to `section` by inserting an _NS
-                    new_key = tup[:i] + (_NS,) + tup[i + 1 :]
+    def _has_valid_setitem_indexer(self, indexer) -> bool:
+        raise AbstractMethodError(self)
 
-                else:
-                    new_key = tup[:i] + tup[i + 1 :]
+    def _getbool_axis(self, key, axis: int):
+        # caller is responsible for ensuring non-None axis
+        labels = self.obj._get_axis(axis)
+        key = check_bool_indexer(labels, key)
+        inds = key.nonzero()[0]
+        return self.obj._take_with_is_copy(inds, axis=axis)
 
-                    # unfortunately need an odious kludge here because of
-                    # DataFrame transposing convention
-                    if (
-                        isinstance(section, ABCDataFrame)
-                        and i > 0
-                        and len(new_key) == 2
-                    ):
-                        a, b = new_key
-                        new_key = b, a
 
-                    if len(new_key) == 1:
-                        new_key = new_key[0]
+@Appender(IndexingMixin.loc.__doc__)
+class _LocIndexer(_LocationIndexer):
+    _takeable: bool = False
+    _valid_types = (
+        "labels (MUST BE IN THE INDEX), slices of labels (BOTH "
+        "endpoints included! Can be slices of integers if the "
+        "index is integers), listlike of labels, boolean"
+    )
 
-                # Slices should return views, but calling iloc/loc with a null
-                # slice returns a new object.
-                if com.is_null_slice(new_key):
-                    return section
-                # This is an elided recursive call to iloc/loc/etc'
-                return getattr(section, self.name)[new_key]
+    # -------------------------------------------------------------------
+    # Key Checks
 
-        raise IndexingError("not applicable")
+    @Appender(_LocationIndexer._validate_key.__doc__)
+    def _validate_key(self, key, axis: int):
 
-    def _getitem_nested_tuple(self, tup: Tuple):
-        # we have a nested tuple so have at least 1 multi-index level
-        # we should be able to match up the dimensionality here
+        # valid for a collection of labels (we check their presence later)
+        # slice of labels (where start-end in labels)
+        # slice of integers (only if in the labels)
+        # boolean
 
-        # we have too many indexers for our dim, but have at least 1
-        # multi-index dimension, try to see if we have something like
-        # a tuple passed to a series with a multi-index
-        if len(tup) > self.ndim:
-            result = self._handle_lowerdim_multi_index_axis0(tup)
-            if result is not None:
-                return result
+        if isinstance(key, slice):
+            return
 
-            # this is a series with a multi-index specified a tuple of
-            # selectors
-            axis = self.axis or 0
-            return self._getitem_axis(tup, axis=axis)
+        if com.is_bool_indexer(key):
+            return
 
-        # handle the multi-axis by taking sections and reducing
-        # this is iterative
-        obj = self.obj
-        axis = 0
-        for i, key in enumerate(tup):
+        if not is_list_like_indexer(key):
+            labels = self.obj._get_axis(axis)
+            labels._convert_scalar_indexer(key, kind="loc")
 
-            if com.is_null_slice(key):
-                axis += 1
-                continue
+    def _has_valid_setitem_indexer(self, indexer) -> bool:
+        return True
 
-            current_ndim = obj.ndim
-            obj = getattr(obj, self.name)._getitem_axis(key, axis=axis)
-            axis += 1
+    def _is_scalar_access(self, key: Tuple) -> bool:
+        """
+        Returns
+        -------
+        bool
+        """
+        # this is a shortcut accessor to both .loc and .iloc
+        # that provide the equivalent access of .at and .iat
+        # a) avoid getting things via sections and (to minimize dtype changes)
+        # b) provide a performant path
+        if len(key) != self.ndim:
+            return False
 
-            # if we have a scalar, we are done
-            if is_scalar(obj) or not hasattr(obj, "ndim"):
-                break
+        for i, k in enumerate(key):
+            if not is_scalar(k):
+                return False
 
-            # has the dim of the obj changed?
-            # GH 7199
-            if obj.ndim < current_ndim:
-                axis -= 1
+            ax = self.obj.axes[i]
+            if isinstance(ax, ABCMultiIndex):
+                return False
 
-        return obj
+            if isinstance(k, str) and ax._supports_partial_string_indexing:
+                # partial string indexing, df.loc['2000', 'A']
+                # should not be considered scalar
+                return False
 
-    def _getitem_axis(self, key, axis: int):
-        if is_iterator(key):
-            key = list(key)
-        self._validate_key(key, axis)
+            if not ax.is_unique:
+                return False
 
-        labels = self.obj._get_axis(axis)
-        if isinstance(key, slice):
-            return self._get_slice_axis(key, axis=axis)
-        elif is_list_like_indexer(key) and not (
-            isinstance(key, tuple) and isinstance(labels, ABCMultiIndex)
-        ):
+        return True
 
-            if hasattr(key, "ndim") and key.ndim > 1:
-                raise ValueError("Cannot index with multidimensional key")
+    # -------------------------------------------------------------------
+    # MultiIndex Handling
 
-            return self._getitem_iterable(key, axis=axis)
-        else:
+    def _multi_take_opportunity(self, tup: Tuple) -> bool:
+        """
+        Check whether there is the possibility to use ``_multi_take``.
+
+        Currently the limit is that all axes being indexed, must be indexed with
+        list-likes.
 
-            # maybe coerce a float scalar to integer
-            key = labels._maybe_cast_indexer(key)
+        Parameters
+        ----------
+        tup : tuple
+            Tuple of indexers, one per axis.
 
-            if is_integer(key):
-                if axis == 0 and isinstance(labels, ABCMultiIndex):
-                    try:
-                        return self._get_label(key, axis=axis)
-                    except (KeyError, TypeError):
-                        if self.obj.index.levels[0].is_integer():
-                            raise
+        Returns
+        -------
+        bool
+            Whether the current indexing,
+            can be passed through `_multi_take`.
+        """
+        if not all(is_list_like_indexer(x) for x in tup):
+            return False
 
-                # this is the fallback! (for a non-float, non-integer index)
-                if not labels.is_floating() and not labels.is_integer():
-                    return self._get_loc(key, axis=axis)
+        # just too complicated
+        if any(com.is_bool_indexer(x) for x in tup):
+            return False
 
-            return self._get_label(key, axis=axis)
+        return True
 
-    def _get_listlike_indexer(self, key, axis: int, raise_missing: bool = False):
+    def _multi_take(self, tup: Tuple):
         """
-        Transform a list-like of keys into a new index and an indexer.
+        Create the indexers for the passed tuple of keys, and
+        executes the take operation. This allows the take operation to be
+        executed all at once, rather than once for each dimension.
+        Improving efficiency.
 
         Parameters
         ----------
-        key : list-like
-            Target labels
-        axis: int
-            Dimension on which the indexing is being made
-        raise_missing: bool
-            Whether to raise a KeyError if some labels are not found. Will be
-            removed in the future, and then this method will always behave as
-            if raise_missing=True.
-
-        Raises
-        ------
-        KeyError
-            If at least one key was requested but none was found, and
-            raise_missing=True.
+        tup : tuple
+            Tuple of indexers, one per axis.
 
         Returns
         -------
-        keyarr: Index
-            New index (coinciding with 'key' if the axis is unique)
-        values : array-like
-            An indexer for the return object; -1 denotes keys not found
+        values: same type as the object being indexed
         """
-        o = self.obj
-        ax = o._get_axis(axis)
+        # GH 836
+        d = {
+            axis: self._get_listlike_indexer(key, axis)
+            for (key, axis) in zip(tup, self.obj._AXIS_ORDERS)
+        }
+        return self.obj._reindex_with_indexers(d, copy=True, allow_dups=True)
 
-        # Have the index compute an indexer or return None
-        # if it cannot handle:
-        indexer, keyarr = ax._convert_listlike_indexer(key, kind=self.name)
-        # We only act on all found values:
-        if indexer is not None and (indexer != -1).all():
-            self._validate_read_indexer(key, indexer, axis, raise_missing=raise_missing)
-            return ax[indexer], indexer
+    # -------------------------------------------------------------------
 
-        if ax.is_unique and not getattr(ax, "is_overlapping", False):
-            # If we are trying to get actual keys from empty Series, we
-            # patiently wait for a KeyError later on - otherwise, convert
-            if len(ax) or not len(key):
-                key = self._convert_for_reindex(key, axis)
-            indexer = ax.get_indexer_for(key)
-            keyarr = ax.reindex(keyarr)[0]
-        else:
-            keyarr, indexer, new_indexer = ax._reindex_non_unique(keyarr)
+    def _get_partial_string_timestamp_match_key(self, key, labels):
+        """
+        Translate any partial string timestamp matches in key, returning the
+        new key.
 
-        self._validate_read_indexer(
-            keyarr, indexer, o._get_axis_number(axis), raise_missing=raise_missing
-        )
-        return keyarr, indexer
+        (GH 10331)
+        """
+        if isinstance(labels, ABCMultiIndex):
+            if (
+                isinstance(key, str)
+                and labels.levels[0]._supports_partial_string_indexing
+            ):
+                # Convert key '2016-01-01' to
+                # ('2016-01-01'[, slice(None, None, None)]+)
+                key = tuple([key] + [slice(None)] * (len(labels.levels) - 1))
+
+            if isinstance(key, tuple):
+                # Convert (..., '2016-01-01', ...) in tuple to
+                # (..., slice('2016-01-01', '2016-01-01', None), ...)
+                new_key = []
+                for i, component in enumerate(key):
+                    if (
+                        isinstance(component, str)
+                        and labels.levels[i]._supports_partial_string_indexing
+                    ):
+                        new_key.append(slice(component, component, None))
+                    else:
+                        new_key.append(component)
+                key = tuple(new_key)
+
+        return key
 
     def _getitem_iterable(self, key, axis: int):
         """
-        Index current object with an an iterable key (which can be a boolean
-        indexer, or a collection of keys).
+        Index current object with an an iterable collection of keys.
 
         Parameters
         ----------
         key : iterable
-            Target labels, or boolean indexer
+            Targeted labels.
         axis: int
-            Dimension on which the indexing is being made
+            Dimension on which the indexing is being made.
 
         Raises
         ------
         KeyError
             If no key was found. Will change in the future to raise if not all
             keys were found.
-        IndexingError
-            If the boolean indexer is unalignable with the object being
-            indexed.
 
         Returns
         -------
-        scalar, DataFrame, or Series: indexed value(s),
+        scalar, DataFrame, or Series: indexed value(s).
         """
-        # caller is responsible for ensuring non-None axis
+        # we assume that not com.is_bool_indexer(key), as that is
+        #  handled before we get here.
         self._validate_key(key, axis)
 
-        labels = self.obj._get_axis(axis)
+        # A collection of keys
+        keyarr, indexer = self._get_listlike_indexer(key, axis, raise_missing=False)
+        return self.obj._reindex_with_indexers(
+            {axis: [keyarr, indexer]}, copy=True, allow_dups=True
+        )
 
-        if com.is_bool_indexer(key):
-            # A boolean indexer
-            key = check_bool_indexer(labels, key)
-            inds, = key.nonzero()
-            return self.obj.take(inds, axis=axis)
-        else:
-            # A collection of keys
-            keyarr, indexer = self._get_listlike_indexer(key, axis, raise_missing=False)
-            return self.obj._reindex_with_indexers(
-                {axis: [keyarr, indexer]}, copy=True, allow_dups=True
-            )
+    def _getitem_tuple(self, tup: Tuple):
+        try:
+            return self._getitem_lowerdim(tup)
+        except IndexingError:
+            pass
 
-    def _validate_read_indexer(
-        self, key, indexer, axis: int, raise_missing: bool = False
-    ):
-        """
-        Check that indexer can be used to return a result (e.g. at least one
-        element was found, unless the list of keys was actually empty).
+        # no multi-index, so validate all of the indexers
+        self._has_valid_tuple(tup)
 
-        Parameters
-        ----------
-        key : list-like
-            Target labels (only used to show correct error message)
-        indexer: array-like of booleans
-            Indices corresponding to the key (with -1 indicating not found)
-        axis: int
-            Dimension on which the indexing is being made
-        raise_missing: bool
-            Whether to raise a KeyError if some labels are not found. Will be
-            removed in the future, and then this method will always behave as
-            if raise_missing=True.
+        # ugly hack for GH #836
+        if self._multi_take_opportunity(tup):
+            return self._multi_take(tup)
 
-        Raises
-        ------
-        KeyError
-            If at least one key was requested but none was found, and
-            raise_missing=True.
-        """
+        # no shortcut needed
+        retval = self.obj
+        for i, key in enumerate(tup):
+            if com.is_null_slice(key):
+                continue
 
-        ax = self.obj._get_axis(axis)
+            retval = getattr(retval, self.name)._getitem_axis(key, axis=i)
 
-        if len(key) == 0:
-            return
+        return retval
 
-        # Count missing values:
-        missing = (indexer < 0).sum()
+    def _getitem_axis(self, key, axis: int):
+        key = item_from_zerodim(key)
+        if is_iterator(key):
+            key = list(key)
 
-        if missing:
-            if missing == len(indexer):
-                raise KeyError(
-                    "None of [{key}] are in the [{axis}]".format(
-                        key=key, axis=self.obj._get_axis_name(axis)
+        labels = self.obj._get_axis(axis)
+        key = self._get_partial_string_timestamp_match_key(key, labels)
+
+        if isinstance(key, slice):
+            self._validate_key(key, axis)
+            return self._get_slice_axis(key, axis=axis)
+        elif com.is_bool_indexer(key):
+            return self._getbool_axis(key, axis=axis)
+        elif is_list_like_indexer(key):
+
+            # convert various list-like indexers
+            # to a list of keys
+            # we will use the *values* of the object
+            # and NOT the index if its a PandasObject
+            if isinstance(labels, ABCMultiIndex):
+
+                if isinstance(key, (ABCSeries, np.ndarray)) and key.ndim <= 1:
+                    # Series, or 0,1 ndim ndarray
+                    # GH 14730
+                    key = list(key)
+                elif isinstance(key, ABCDataFrame):
+                    # GH 15438
+                    raise NotImplementedError(
+                        "Indexing a MultiIndex with a "
+                        "DataFrame key is not "
+                        "implemented"
+                    )
+                elif hasattr(key, "ndim") and key.ndim > 1:
+                    raise NotImplementedError(
+                        "Indexing a MultiIndex with a "
+                        "multidimensional key is not "
+                        "implemented"
                     )
-                )
 
-            # We (temporarily) allow for some missing keys with .loc, except in
-            # some cases (e.g. setting) in which "raise_missing" will be False
-            if not (self.name == "loc" and not raise_missing):
-                not_found = list(set(key) - set(ax))
-                raise KeyError("{} not in index".format(not_found))
+                if (
+                    not isinstance(key, tuple)
+                    and len(key)
+                    and not isinstance(key[0], tuple)
+                ):
+                    key = tuple([key])
 
-            # we skip the warning on Categorical/Interval
-            # as this check is actually done (check for
-            # non-missing values), but a bit later in the
-            # code, so we want to avoid warning & then
-            # just raising
+            # an iterable multi-selection
+            if not (isinstance(key, tuple) and isinstance(labels, ABCMultiIndex)):
+
+                if hasattr(key, "ndim") and key.ndim > 1:
+                    raise ValueError("Cannot index with multidimensional key")
 
-            _missing_key_warning = textwrap.dedent(
-                """
-            Passing list-likes to .loc or [] with any missing label will raise
-            KeyError in the future, you can use .reindex() as an alternative.
+                return self._getitem_iterable(key, axis=axis)
 
-            See the documentation here:
-            https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike"""  # noqa: E501
-            )
+            # nested tuple slicing
+            if is_nested_tuple(key, labels):
+                locs = labels.get_locs(key)
+                indexer = [slice(None)] * self.ndim
+                indexer[axis] = locs
+                return self.obj.iloc[tuple(indexer)]
+
+        # fall thru to straight lookup
+        self._validate_key(key, axis)
+        return self._get_label(key, axis=axis)
+
+    def _get_slice_axis(self, slice_obj: slice, axis: int):
+        """
+        This is pretty simple as we just have to deal with labels.
+        """
+        # caller is responsible for ensuring non-None axis
+        obj = self.obj
+        if not need_slice(slice_obj):
+            return obj.copy(deep=False)
+
+        labels = obj._get_axis(axis)
+        indexer = labels.slice_indexer(
+            slice_obj.start, slice_obj.stop, slice_obj.step, kind="loc"
+        )
 
-            if not (ax.is_categorical() or ax.is_interval()):
-                warnings.warn(_missing_key_warning, FutureWarning, stacklevel=6)
+        if isinstance(indexer, slice):
+            return self.obj._slice(indexer, axis=axis)
+        else:
+            # DatetimeIndex overrides Index.slice_indexer and may
+            #  return a DatetimeIndex instead of a slice object.
+            return self.obj.take(indexer, axis=axis)
 
-    def _convert_to_indexer(self, obj, axis: int, raise_missing: bool = False):
+    def _convert_to_indexer(self, key, axis: int, is_setter: bool = False):
         """
         Convert indexing key into something we can use to do actual fancy
-        indexing on an ndarray
+        indexing on a ndarray.
 
         Examples
         ix[:5] -> slice(0, 5)
@@ -1213,33 +1162,38 @@ def _convert_to_indexer(self, obj, axis: int, raise_missing: bool = False):
         """
         labels = self.obj._get_axis(axis)
 
-        if isinstance(obj, slice):
-            return self._convert_slice_indexer(obj, axis)
+        if isinstance(key, slice):
+            return labels._convert_slice_indexer(key, kind="loc")
 
-        # try to find out correct indexer, if not type correct raise
-        try:
-            obj = self._convert_scalar_indexer(obj, axis)
-        except TypeError:
-            # but we will allow setting
-            pass
+        if is_scalar(key):
+            # try to find out correct indexer, if not type correct raise
+            try:
+                key = labels._convert_scalar_indexer(key, kind="loc")
+            except TypeError:
+                # but we will allow setting
+                if not is_setter:
+                    raise
 
         # see if we are positional in nature
         is_int_index = labels.is_integer()
-        is_int_positional = is_integer(obj) and not is_int_index
+        is_int_positional = is_integer(key) and not is_int_index
 
-        # if we are a label return me
-        try:
-            return labels.get_loc(obj)
-        except LookupError:
-            if isinstance(obj, tuple) and isinstance(labels, ABCMultiIndex):
-                if len(obj) == labels.nlevels:
-                    return {"key": obj}
-                raise
-        except TypeError:
-            pass
-        except ValueError:
-            if not is_int_positional:
-                raise
+        if is_scalar(key) or isinstance(labels, ABCMultiIndex):
+            # Otherwise get_loc will raise InvalidIndexError
+
+            # if we are a label return me
+            try:
+                return labels.get_loc(key)
+            except LookupError:
+                if isinstance(key, tuple) and isinstance(labels, ABCMultiIndex):
+                    if len(key) == labels.nlevels:
+                        return {"key": key}
+                    raise
+            except TypeError:
+                pass
+            except ValueError:
+                if not is_int_positional:
+                    raise
 
         # a positional
         if is_int_positional:
@@ -1247,923 +1201,861 @@ def _convert_to_indexer(self, obj, axis: int, raise_missing: bool = False):
             # if we are setting and its not a valid location
             # its an insert which fails by definition
 
-            if self.name == "loc":
-                # always valid
-                return {"key": obj}
-
-            if obj >= self.obj.shape[axis] and not isinstance(labels, ABCMultiIndex):
-                # a positional
-                raise ValueError("cannot set by positional indexing with enlargement")
-
-            return obj
+            # always valid
+            return {"key": key}
 
-        if is_nested_tuple(obj, labels):
-            return labels.get_locs(obj)
+        if is_nested_tuple(key, labels):
+            return labels.get_locs(key)
 
-        elif is_list_like_indexer(obj):
+        elif is_list_like_indexer(key):
 
-            if com.is_bool_indexer(obj):
-                obj = check_bool_indexer(labels, obj)
-                inds, = obj.nonzero()
+            if com.is_bool_indexer(key):
+                key = check_bool_indexer(labels, key)
+                (inds,) = key.nonzero()
                 return inds
             else:
                 # When setting, missing keys are not allowed, even with .loc:
-                return self._get_listlike_indexer(obj, axis, raise_missing=True)[1]
+                return self._get_listlike_indexer(key, axis, raise_missing=True)[1]
         else:
             try:
-                return labels.get_loc(obj)
+                return labels.get_loc(key)
             except LookupError:
                 # allow a not found key only if we are a setter
-                if not is_list_like_indexer(obj):
-                    return {"key": obj}
+                if not is_list_like_indexer(key):
+                    return {"key": key}
                 raise
 
-    def _get_slice_axis(self, slice_obj: slice, axis: int):
-        # caller is responsible for ensuring non-None axis
-        obj = self.obj
-
-        if not need_slice(slice_obj):
-            return obj.copy(deep=False)
-
-        indexer = self._convert_slice_indexer(slice_obj, axis)
-        return self._slice(indexer, axis=axis, kind="iloc")
-
-
-class _IXIndexer(_NDFrameIndexer):
-    """
-    A primarily label-location based indexer, with integer position
-    fallback.
-
-    Warning: Starting in 0.20.0, the .ix indexer is deprecated, in
-    favor of the more strict .iloc and .loc indexers.
-
-    ``.ix[]`` supports mixed integer and label based access. It is
-    primarily label based, but will fall back to integer positional
-    access unless the corresponding axis is of integer type.
-
-    ``.ix`` is the most general indexer and will support any of the
-    inputs in ``.loc`` and ``.iloc``. ``.ix`` also supports floating
-    point label schemes. ``.ix`` is exceptionally useful when dealing
-    with mixed positional and label based hierarchical indexes.
-
-    However, when an axis is integer based, ONLY label based access
-    and not positional access is supported. Thus, in such cases, it's
-    usually better to be explicit and use ``.iloc`` or ``.loc``.
-
-    See more at :ref:`Advanced Indexing <advanced>`.
-    """
-
-    _ix_deprecation_warning = textwrap.dedent(
-        """
-        .ix is deprecated. Please use
-        .loc for label based indexing or
-        .iloc for positional indexing
-
-        See the documentation here:
-        http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#ix-indexer-is-deprecated"""  # noqa: E501
-    )
-
-    def __init__(self, name, obj):
-        warnings.warn(self._ix_deprecation_warning, FutureWarning, stacklevel=2)
-        super().__init__(name, obj)
-
-    @Appender(_NDFrameIndexer._validate_key.__doc__)
-    def _validate_key(self, key, axis: int):
-        if isinstance(key, slice):
-            return True
-
-        elif com.is_bool_indexer(key):
-            return True
-
-        elif is_list_like_indexer(key):
-            return True
-
-        else:
-
-            self._convert_scalar_indexer(key, axis)
-
-        return True
-
-    def _convert_for_reindex(self, key, axis: int):
+    def _get_listlike_indexer(self, key, axis: int, raise_missing: bool = False):
         """
-        Transform a list of keys into a new array ready to be used as axis of
-        the object we return (e.g. including NaNs).
+        Transform a list-like of keys into a new index and an indexer.
 
         Parameters
         ----------
         key : list-like
-            Target labels
+            Targeted labels.
         axis: int
-            Where the indexing is being made
+            Dimension on which the indexing is being made.
+        raise_missing: bool, default False
+            Whether to raise a KeyError if some labels were not found.
+            Will be removed in the future, and then this method will always behave as
+            if ``raise_missing=True``.
+
+        Raises
+        ------
+        KeyError
+            If at least one key was requested but none was found, and
+            raise_missing=True.
 
         Returns
         -------
-        list-like of labels
+        keyarr: Index
+            New index (coinciding with 'key' if the axis is unique).
+        values : array-like
+            Indexer for the return object, -1 denotes keys not found.
         """
-        labels = self.obj._get_axis(axis)
+        ax = self.obj._get_axis(axis)
 
-        if com.is_bool_indexer(key):
-            key = check_bool_indexer(labels, key)
-            return labels[key]
+        # Have the index compute an indexer or return None
+        # if it cannot handle:
+        indexer, keyarr = ax._convert_listlike_indexer(key)
+        # We only act on all found values:
+        if indexer is not None and (indexer != -1).all():
+            self._validate_read_indexer(key, indexer, axis, raise_missing=raise_missing)
+            return ax[indexer], indexer
 
-        if isinstance(key, Index):
-            keyarr = labels._convert_index_indexer(key)
+        if ax.is_unique and not getattr(ax, "is_overlapping", False):
+            indexer = ax.get_indexer_for(key)
+            keyarr = ax.reindex(keyarr)[0]
         else:
-            # asarray can be unsafe, NumPy strings are weird
-            keyarr = com.asarray_tuplesafe(key)
-
-        if is_integer_dtype(keyarr):
-            # Cast the indexer to uint64 if possible so
-            # that the values returned from indexing are
-            # also uint64.
-            keyarr = labels._convert_arr_indexer(keyarr)
-
-            if not labels.is_integer():
-                keyarr = ensure_platform_int(keyarr)
-                return labels.take(keyarr)
-
-        return keyarr
-
+            keyarr, indexer, new_indexer = ax._reindex_non_unique(keyarr)
 
-class _LocationIndexer(_NDFrameIndexer):
-    _exception = Exception
+        self._validate_read_indexer(keyarr, indexer, axis, raise_missing=raise_missing)
+        return keyarr, indexer
 
-    def __getitem__(self, key):
-        if type(key) is tuple:
-            key = tuple(com.apply_if_callable(x, self.obj) for x in key)
-            if self._is_scalar_access(key):
-                try:
-                    return self._getitem_scalar(key)
-                except (KeyError, IndexError, AttributeError):
-                    pass
-            return self._getitem_tuple(key)
-        else:
-            # we by definition only have the 0th axis
-            axis = self.axis or 0
+    def _validate_read_indexer(
+        self, key, indexer, axis: int, raise_missing: bool = False
+    ):
+        """
+        Check that indexer can be used to return a result.
 
-            maybe_callable = com.apply_if_callable(key, self.obj)
-            return self._getitem_axis(maybe_callable, axis=axis)
+        e.g. at least one element was found,
+        unless the list of keys was actually empty.
 
-    def _is_scalar_access(self, key: Tuple):
-        raise NotImplementedError()
+        Parameters
+        ----------
+        key : list-like
+            Targeted labels (only used to show correct error message).
+        indexer: array-like of booleans
+            Indices corresponding to the key,
+            (with -1 indicating not found).
+        axis: int
+            Dimension on which the indexing is being made.
+        raise_missing: bool
+            Whether to raise a KeyError if some labels are not found. Will be
+            removed in the future, and then this method will always behave as
+            if raise_missing=True.
 
-    def _getitem_scalar(self, key):
-        raise NotImplementedError()
+        Raises
+        ------
+        KeyError
+            If at least one key was requested but none was found, and
+            raise_missing=True.
+        """
+        ax = self.obj._get_axis(axis)
 
-    def _getitem_axis(self, key, axis: int):
-        raise NotImplementedError()
+        if len(key) == 0:
+            return
 
-    def _getbool_axis(self, key, axis: int):
-        # caller is responsible for ensuring non-None axis
-        labels = self.obj._get_axis(axis)
-        key = check_bool_indexer(labels, key)
-        inds = key.nonzero()[0]
-        try:
-            return self.obj.take(inds, axis=axis)
-        except Exception as detail:
-            raise self._exception(detail)
+        # Count missing values:
+        missing = (indexer < 0).sum()
 
-    def _get_slice_axis(self, slice_obj: slice, axis: int):
-        """ this is pretty simple as we just have to deal with labels """
-        # caller is responsible for ensuring non-None axis
-        obj = self.obj
-        if not need_slice(slice_obj):
-            return obj.copy(deep=False)
+        if missing:
+            if missing == len(indexer):
+                axis_name = self.obj._get_axis_name(axis)
+                raise KeyError(f"None of [{key}] are in the [{axis_name}]")
 
-        labels = obj._get_axis(axis)
-        indexer = labels.slice_indexer(
-            slice_obj.start, slice_obj.stop, slice_obj.step, kind=self.name
-        )
+            # We (temporarily) allow for some missing keys with .loc, except in
+            # some cases (e.g. setting) in which "raise_missing" will be False
+            if not (self.name == "loc" and not raise_missing):
+                not_found = list(set(key) - set(ax))
+                raise KeyError(f"{not_found} not in index")
 
-        if isinstance(indexer, slice):
-            return self._slice(indexer, axis=axis, kind="iloc")
-        else:
-            # DatetimeIndex overrides Index.slice_indexer and may
-            #  return a DatetimeIndex instead of a slice object.
-            return self.obj.take(indexer, axis=axis)
+            # we skip the warning on Categorical/Interval
+            # as this check is actually done (check for
+            # non-missing values), but a bit later in the
+            # code, so we want to avoid warning & then
+            # just raising
+            if not (ax.is_categorical() or ax.is_interval()):
+                raise KeyError(
+                    "Passing list-likes to .loc or [] with any missing labels "
+                    "is no longer supported, see "
+                    "https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike"  # noqa:E501
+                )
 
 
-class _LocIndexer(_LocationIndexer):
-    """
-    Access a group of rows and columns by label(s) or a boolean array.
+@Appender(IndexingMixin.iloc.__doc__)
+class _iLocIndexer(_LocationIndexer):
+    _valid_types = (
+        "integer, integer slice (START point is INCLUDED, END "
+        "point is EXCLUDED), listlike of integers, boolean array"
+    )
+    _takeable = True
 
-    ``.loc[]`` is primarily label based, but may also be used with a
-    boolean array.
+    # -------------------------------------------------------------------
+    # Key Checks
 
-    Allowed inputs are:
+    def _validate_key(self, key, axis: int):
+        if com.is_bool_indexer(key):
+            if hasattr(key, "index") and isinstance(key.index, Index):
+                if key.index.inferred_type == "integer":
+                    raise NotImplementedError(
+                        "iLocation based boolean "
+                        "indexing on an integer type "
+                        "is not available"
+                    )
+                raise ValueError(
+                    "iLocation based boolean indexing cannot use "
+                    "an indexable as a mask"
+                )
+            return
 
-    - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is
-      interpreted as a *label* of the index, and **never** as an
-      integer position along the index).
-    - A list or array of labels, e.g. ``['a', 'b', 'c']``.
-    - A slice object with labels, e.g. ``'a':'f'``.
+        if isinstance(key, slice):
+            return
+        elif is_integer(key):
+            self._validate_integer(key, axis)
+        elif isinstance(key, tuple):
+            # a tuple should already have been caught by this point
+            # so don't treat a tuple as a valid indexer
+            raise IndexingError("Too many indexers")
+        elif is_list_like_indexer(key):
+            arr = np.array(key)
+            len_axis = len(self.obj._get_axis(axis))
 
-      .. warning:: Note that contrary to usual python slices, **both** the
-          start and the stop are included
+            # check that the key has a numeric dtype
+            if not is_numeric_dtype(arr.dtype):
+                raise IndexError(f".iloc requires numeric indexers, got {arr}")
 
-    - A boolean array of the same length as the axis being sliced,
-      e.g. ``[True, False, True]``.
-    - A ``callable`` function with one argument (the calling Series or
-      DataFrame) and that returns valid output for indexing (one of the above)
+            # check that the key does not exceed the maximum size of the index
+            if len(arr) and (arr.max() >= len_axis or arr.min() < -len_axis):
+                raise IndexError("positional indexers are out-of-bounds")
+        else:
+            raise ValueError(f"Can only index by location with a [{self._valid_types}]")
 
-    See more at :ref:`Selection by Label <indexing.label>`
+    def _has_valid_setitem_indexer(self, indexer):
+        self._has_valid_positional_setitem_indexer(indexer)
 
-    Raises
-    ------
-    KeyError:
-        when any items are not found
+    def _has_valid_positional_setitem_indexer(self, indexer) -> bool:
+        """
+        Validate that a positional indexer cannot enlarge its target
+        will raise if needed, does not modify the indexer externally.
 
-    See Also
-    --------
-    DataFrame.at : Access a single value for a row/column label pair.
-    DataFrame.iloc : Access group of rows and columns by integer position(s).
-    DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the
-        Series/DataFrame.
-    Series.loc : Access group of values using labels.
+        Returns
+        -------
+        bool
+        """
+        if isinstance(indexer, dict):
+            raise IndexError(f"{self.name} cannot enlarge its target object")
+        else:
+            if not isinstance(indexer, tuple):
+                indexer = _tuplify(self.ndim, indexer)
+            for ax, i in zip(self.obj.axes, indexer):
+                if isinstance(i, slice):
+                    # should check the stop slice?
+                    pass
+                elif is_list_like_indexer(i):
+                    # should check the elements?
+                    pass
+                elif is_integer(i):
+                    if i >= len(ax):
+                        raise IndexError(
+                            f"{self.name} cannot enlarge its target object"
+                        )
+                elif isinstance(i, dict):
+                    raise IndexError(f"{self.name} cannot enlarge its target object")
 
-    Examples
-    --------
-    **Getting values**
+        return True
 
-    >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
-    ...      index=['cobra', 'viper', 'sidewinder'],
-    ...      columns=['max_speed', 'shield'])
-    >>> df
-                max_speed  shield
-    cobra               1       2
-    viper               4       5
-    sidewinder          7       8
+    def _is_scalar_access(self, key: Tuple) -> bool:
+        """
+        Returns
+        -------
+        bool
+        """
+        # this is a shortcut accessor to both .loc and .iloc
+        # that provide the equivalent access of .at and .iat
+        # a) avoid getting things via sections and (to minimize dtype changes)
+        # b) provide a performant path
+        if len(key) != self.ndim:
+            return False
 
-    Single label. Note this returns the row as a Series.
+        for i, k in enumerate(key):
+            if not is_integer(k):
+                return False
 
-    >>> df.loc['viper']
-    max_speed    4
-    shield       5
-    Name: viper, dtype: int64
+            ax = self.obj.axes[i]
+            if not ax.is_unique:
+                return False
 
-    List of labels. Note using ``[[]]`` returns a DataFrame.
+        return True
 
-    >>> df.loc[['viper', 'sidewinder']]
-                max_speed  shield
-    viper               4       5
-    sidewinder          7       8
+    def _validate_integer(self, key: int, axis: int) -> None:
+        """
+        Check that 'key' is a valid position in the desired axis.
 
-    Single label for row and column
+        Parameters
+        ----------
+        key : int
+            Requested position.
+        axis : int
+            Desired axis.
 
-    >>> df.loc['cobra', 'shield']
-    2
+        Raises
+        ------
+        IndexError
+            If 'key' is not a valid position in axis 'axis'.
+        """
+        len_axis = len(self.obj._get_axis(axis))
+        if key >= len_axis or key < -len_axis:
+            raise IndexError("single positional indexer is out-of-bounds")
 
-    Slice with labels for row and single label for column. As mentioned
-    above, note that both the start and stop of the slice are included.
+    # -------------------------------------------------------------------
 
-    >>> df.loc['cobra':'viper', 'max_speed']
-    cobra    1
-    viper    4
-    Name: max_speed, dtype: int64
+    def _getitem_tuple(self, tup: Tuple):
 
-    Boolean list with the same length as the row axis
-
-    >>> df.loc[[False, False, True]]
-                max_speed  shield
-    sidewinder          7       8
-
-    Conditional that returns a boolean Series
+        self._has_valid_tuple(tup)
+        try:
+            return self._getitem_lowerdim(tup)
+        except IndexingError:
+            pass
 
-    >>> df.loc[df['shield'] > 6]
-                max_speed  shield
-    sidewinder          7       8
+        retval = self.obj
+        axis = 0
+        for i, key in enumerate(tup):
+            if com.is_null_slice(key):
+                axis += 1
+                continue
 
-    Conditional that returns a boolean Series with column labels specified
+            retval = getattr(retval, self.name)._getitem_axis(key, axis=axis)
 
-    >>> df.loc[df['shield'] > 6, ['max_speed']]
-                max_speed
-    sidewinder          7
-
-    Callable that returns a boolean Series
+            # if the dim was reduced, then pass a lower-dim the next time
+            if retval.ndim < self.ndim:
+                # TODO: this is never reached in tests; can we confirm that
+                #  it is impossible?
+                axis -= 1
 
-    >>> df.loc[lambda df: df['shield'] == 8]
-                max_speed  shield
-    sidewinder          7       8
+            # try to get for the next axis
+            axis += 1
 
-    **Setting values**
-
-    Set value for all items matching the list of labels
+        return retval
 
-    >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50
-    >>> df
-                max_speed  shield
-    cobra               1       2
-    viper               4      50
-    sidewinder          7      50
+    def _get_list_axis(self, key, axis: int):
+        """
+        Return Series values by list or array of integers.
 
-    Set value for an entire row
+        Parameters
+        ----------
+        key : list-like positional indexer
+        axis : int
 
-    >>> df.loc['cobra'] = 10
-    >>> df
-                max_speed  shield
-    cobra              10      10
-    viper               4      50
-    sidewinder          7      50
+        Returns
+        -------
+        Series object
 
-    Set value for an entire column
+        Notes
+        -----
+        `axis` can only be zero.
+        """
+        try:
+            return self.obj._take_with_is_copy(key, axis=axis)
+        except IndexError:
+            # re-raise with different error message
+            raise IndexError("positional indexers are out-of-bounds")
 
-    >>> df.loc[:, 'max_speed'] = 30
-    >>> df
-                max_speed  shield
-    cobra              30      10
-    viper              30      50
-    sidewinder         30      50
+    def _getitem_axis(self, key, axis: int):
+        if isinstance(key, slice):
+            return self._get_slice_axis(key, axis=axis)
 
-    Set value for rows matching callable condition
+        if isinstance(key, list):
+            key = np.asarray(key)
 
-    >>> df.loc[df['shield'] > 35] = 0
-    >>> df
-                max_speed  shield
-    cobra              30      10
-    viper               0       0
-    sidewinder          0       0
-
-    **Getting values on a DataFrame with an index that has integer labels**
+        if com.is_bool_indexer(key):
+            self._validate_key(key, axis)
+            return self._getbool_axis(key, axis=axis)
 
-    Another example using integers for the index
-
-    >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
-    ...      index=[7, 8, 9], columns=['max_speed', 'shield'])
-    >>> df
-       max_speed  shield
-    7          1       2
-    8          4       5
-    9          7       8
+        # a list of integers
+        elif is_list_like_indexer(key):
+            return self._get_list_axis(key, axis=axis)
 
-    Slice with integer labels for rows. As mentioned above, note that both
-    the start and stop of the slice are included.
+        # a single integer
+        else:
+            key = item_from_zerodim(key)
+            if not is_integer(key):
+                raise TypeError("Cannot index by location index with a non-integer key")
 
-    >>> df.loc[7:9]
-       max_speed  shield
-    7          1       2
-    8          4       5
-    9          7       8
-
-    **Getting values with a MultiIndex**
+            # validate the location
+            self._validate_integer(key, axis)
 
-    A number of examples using a DataFrame with a MultiIndex
+            return self.obj._ixs(key, axis=axis)
 
-    >>> tuples = [
-    ...    ('cobra', 'mark i'), ('cobra', 'mark ii'),
-    ...    ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),
-    ...    ('viper', 'mark ii'), ('viper', 'mark iii')
-    ... ]
-    >>> index = pd.MultiIndex.from_tuples(tuples)
-    >>> values = [[12, 2], [0, 4], [10, 20],
-    ...         [1, 4], [7, 1], [16, 36]]
-    >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)
-    >>> df
-                         max_speed  shield
-    cobra      mark i           12       2
-               mark ii           0       4
-    sidewinder mark i           10      20
-               mark ii           1       4
-    viper      mark ii           7       1
-               mark iii         16      36
-
-    Single label. Note this returns a DataFrame with a single index.
-
-    >>> df.loc['cobra']
-             max_speed  shield
-    mark i          12       2
-    mark ii          0       4
-
-    Single index tuple. Note this returns a Series.
-
-    >>> df.loc[('cobra', 'mark ii')]
-    max_speed    0
-    shield       4
-    Name: (cobra, mark ii), dtype: int64
-
-    Single label for row and column. Similar to passing in a tuple, this
-    returns a Series.
-
-    >>> df.loc['cobra', 'mark i']
-    max_speed    12
-    shield        2
-    Name: (cobra, mark i), dtype: int64
-
-    Single tuple. Note using ``[[]]`` returns a DataFrame.
-
-    >>> df.loc[[('cobra', 'mark ii')]]
-                   max_speed  shield
-    cobra mark ii          0       4
-
-    Single tuple for the index with a single label for the column
-
-    >>> df.loc[('cobra', 'mark i'), 'shield']
-    2
-
-    Slice from index tuple to single label
-
-    >>> df.loc[('cobra', 'mark i'):'viper']
-                         max_speed  shield
-    cobra      mark i           12       2
-               mark ii           0       4
-    sidewinder mark i           10      20
-               mark ii           1       4
-    viper      mark ii           7       1
-               mark iii         16      36
-
-    Slice from index tuple to index tuple
-
-    >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]
-                        max_speed  shield
-    cobra      mark i          12       2
-               mark ii          0       4
-    sidewinder mark i          10      20
-               mark ii          1       4
-    viper      mark ii          7       1
-    """
+    def _get_slice_axis(self, slice_obj: slice, axis: int):
+        # caller is responsible for ensuring non-None axis
+        obj = self.obj
 
-    _valid_types = (
-        "labels (MUST BE IN THE INDEX), slices of labels (BOTH "
-        "endpoints included! Can be slices of integers if the "
-        "index is integers), listlike of labels, boolean"
-    )
-    _exception = KeyError
+        if not need_slice(slice_obj):
+            return obj.copy(deep=False)
 
-    @Appender(_NDFrameIndexer._validate_key.__doc__)
-    def _validate_key(self, key, axis: int):
+        labels = obj._get_axis(axis)
+        labels._validate_positional_slice(slice_obj)
+        return self.obj._slice(slice_obj, axis=axis)
 
-        # valid for a collection of labels (we check their presence later)
-        # slice of labels (where start-end in labels)
-        # slice of integers (only if in the labels)
-        # boolean
+    def _convert_to_indexer(self, key, axis: int, is_setter: bool = False):
+        """
+        Much simpler as we only have to deal with our valid types.
+        """
+        labels = self.obj._get_axis(axis)
 
+        # make need to convert a float key
         if isinstance(key, slice):
-            return
-
-        if com.is_bool_indexer(key):
-            return
-
-        if not is_list_like_indexer(key):
-            self._convert_scalar_indexer(key, axis)
+            labels._validate_positional_slice(key)
+            return key
 
-    def _is_scalar_access(self, key: Tuple):
-        # this is a shortcut accessor to both .loc and .iloc
-        # that provide the equivalent access of .at and .iat
-        # a) avoid getting things via sections and (to minimize dtype changes)
-        # b) provide a performant path
-        if len(key) != self.ndim:
-            return False
+        elif is_float(key):
+            labels._validate_indexer("positional", key, "iloc")
+            return key
 
-        for i, k in enumerate(key):
-            if not is_scalar(k):
-                return False
+        self._validate_key(key, axis)
+        return key
 
-            ax = self.obj.axes[i]
-            if isinstance(ax, ABCMultiIndex):
-                return False
+    # -------------------------------------------------------------------
 
-            if isinstance(k, str) and ax._supports_partial_string_indexing:
-                # partial string indexing, df.loc['2000', 'A']
-                # should not be considered scalar
-                return False
+    def _setitem_with_indexer(self, indexer, value):
 
-            if not ax.is_unique:
-                return False
+        # also has the side effect of consolidating in-place
+        from pandas import Series
 
-        return True
+        info_axis = self.obj._info_axis_number
 
-    def _getitem_scalar(self, key):
-        # a fast-path to scalar access
-        # if not, raise
-        values = self.obj._get_value(*key)
-        return values
+        # maybe partial set
+        take_split_path = self.obj._is_mixed_type
 
-    def _get_partial_string_timestamp_match_key(self, key, labels):
-        """Translate any partial string timestamp matches in key, returning the
-        new key (GH 10331)"""
-        if isinstance(labels, ABCMultiIndex):
-            if (
-                isinstance(key, str)
-                and labels.levels[0]._supports_partial_string_indexing
-            ):
-                # Convert key '2016-01-01' to
-                # ('2016-01-01'[, slice(None, None, None)]+)
-                key = tuple([key] + [slice(None)] * (len(labels.levels) - 1))
+        # if there is only one block/type, still have to take split path
+        # unless the block is one-dimensional or it can hold the value
+        if not take_split_path and self.obj._data.blocks:
+            (blk,) = self.obj._data.blocks
+            if 1 < blk.ndim:  # in case of dict, keys are indices
+                val = list(value.values()) if isinstance(value, dict) else value
+                take_split_path = not blk._can_hold_element(val)
 
-            if isinstance(key, tuple):
-                # Convert (..., '2016-01-01', ...) in tuple to
-                # (..., slice('2016-01-01', '2016-01-01', None), ...)
-                new_key = []
-                for i, component in enumerate(key):
-                    if (
-                        isinstance(component, str)
-                        and labels.levels[i]._supports_partial_string_indexing
-                    ):
-                        new_key.append(slice(component, component, None))
-                    else:
-                        new_key.append(component)
-                key = tuple(new_key)
+        # if we have any multi-indexes that have non-trivial slices
+        # (not null slices) then we must take the split path, xref
+        # GH 10360, GH 27841
+        if isinstance(indexer, tuple) and len(indexer) == len(self.obj.axes):
+            for i, ax in zip(indexer, self.obj.axes):
+                if isinstance(ax, ABCMultiIndex) and not (
+                    is_integer(i) or com.is_null_slice(i)
+                ):
+                    take_split_path = True
+                    break
 
-        return key
+        if isinstance(indexer, tuple):
+            nindexer = []
+            for i, idx in enumerate(indexer):
+                if isinstance(idx, dict):
 
-    def _getitem_axis(self, key, axis: int):
-        key = item_from_zerodim(key)
-        if is_iterator(key):
-            key = list(key)
+                    # reindex the axis to the new value
+                    # and set inplace
+                    key, _ = convert_missing_indexer(idx)
 
-        labels = self.obj._get_axis(axis)
-        key = self._get_partial_string_timestamp_match_key(key, labels)
+                    # if this is the items axes, then take the main missing
+                    # path first
+                    # this correctly sets the dtype and avoids cache issues
+                    # essentially this separates out the block that is needed
+                    # to possibly be modified
+                    if self.ndim > 1 and i == self.obj._info_axis_number:
 
-        if isinstance(key, slice):
-            self._validate_key(key, axis)
-            return self._get_slice_axis(key, axis=axis)
-        elif com.is_bool_indexer(key):
-            return self._getbool_axis(key, axis=axis)
-        elif is_list_like_indexer(key):
+                        # add the new item, and set the value
+                        # must have all defined axes if we have a scalar
+                        # or a list-like on the non-info axes if we have a
+                        # list-like
+                        len_non_info_axes = (
+                            len(_ax) for _i, _ax in enumerate(self.obj.axes) if _i != i
+                        )
+                        if any(not l for l in len_non_info_axes):
+                            if not is_list_like_indexer(value):
+                                raise ValueError(
+                                    "cannot set a frame with no "
+                                    "defined index and a scalar"
+                                )
+                            self.obj[key] = value
+                            return
 
-            # convert various list-like indexers
-            # to a list of keys
-            # we will use the *values* of the object
-            # and NOT the index if its a PandasObject
-            if isinstance(labels, ABCMultiIndex):
+                        # add a new item with the dtype setup
+                        self.obj[key] = _infer_fill_value(value)
 
-                if isinstance(key, (ABCSeries, np.ndarray)) and key.ndim <= 1:
-                    # Series, or 0,1 ndim ndarray
-                    # GH 14730
-                    key = list(key)
-                elif isinstance(key, ABCDataFrame):
-                    # GH 15438
-                    raise NotImplementedError(
-                        "Indexing a MultiIndex with a "
-                        "DataFrame key is not "
-                        "implemented"
-                    )
-                elif hasattr(key, "ndim") and key.ndim > 1:
-                    raise NotImplementedError(
-                        "Indexing a MultiIndex with a "
-                        "multidimensional key is not "
-                        "implemented"
-                    )
+                        new_indexer = convert_from_missing_indexer_tuple(
+                            indexer, self.obj.axes
+                        )
+                        self._setitem_with_indexer(new_indexer, value)
 
-                if (
-                    not isinstance(key, tuple)
-                    and len(key)
-                    and not isinstance(key[0], tuple)
-                ):
-                    key = tuple([key])
+                        return
 
-            # an iterable multi-selection
-            if not (isinstance(key, tuple) and isinstance(labels, ABCMultiIndex)):
+                    # reindex the axis
+                    # make sure to clear the cache because we are
+                    # just replacing the block manager here
+                    # so the object is the same
+                    index = self.obj._get_axis(i)
+                    labels = index.insert(len(index), key)
+                    self.obj._data = self.obj.reindex(labels, axis=i)._data
+                    self.obj._maybe_update_cacher(clear=True)
+                    self.obj._is_copy = None
 
-                if hasattr(key, "ndim") and key.ndim > 1:
-                    raise ValueError("Cannot index with multidimensional key")
+                    nindexer.append(labels.get_loc(key))
 
-                return self._getitem_iterable(key, axis=axis)
+                else:
+                    nindexer.append(idx)
 
-            # nested tuple slicing
-            if is_nested_tuple(key, labels):
-                locs = labels.get_locs(key)
-                indexer = [slice(None)] * self.ndim
-                indexer[axis] = locs
-                return self.obj.iloc[tuple(indexer)]
+            indexer = tuple(nindexer)
+        else:
 
-        # fall thru to straight lookup
-        self._validate_key(key, axis)
-        return self._get_label(key, axis=axis)
+            indexer, missing = convert_missing_indexer(indexer)
 
+            if missing:
+                self._setitem_with_indexer_missing(indexer, value)
+                return
 
-class _iLocIndexer(_LocationIndexer):
-    """
-    Purely integer-location based indexing for selection by position.
+        # set
+        item_labels = self.obj._get_axis(info_axis)
 
-    ``.iloc[]`` is primarily integer position based (from ``0`` to
-    ``length-1`` of the axis), but may also be used with a boolean
-    array.
+        # align and set the values
+        if take_split_path:
+            # Above we only set take_split_path to True for 2D cases
+            assert self.ndim == 2
+            assert info_axis == 1
 
-    Allowed inputs are:
+            if not isinstance(indexer, tuple):
+                indexer = _tuplify(self.ndim, indexer)
 
-    - An integer, e.g. ``5``.
-    - A list or array of integers, e.g. ``[4, 3, 0]``.
-    - A slice object with ints, e.g. ``1:7``.
-    - A boolean array.
-    - A ``callable`` function with one argument (the calling Series or
-      DataFrame) and that returns valid output for indexing (one of the above).
-      This is useful in method chains, when you don't have a reference to the
-      calling object, but would like to base your selection on some value.
+            if isinstance(value, ABCSeries):
+                value = self._align_series(indexer, value)
 
-    ``.iloc`` will raise ``IndexError`` if a requested indexer is
-    out-of-bounds, except *slice* indexers which allow out-of-bounds
-    indexing (this conforms with python/numpy *slice* semantics).
+            info_idx = indexer[info_axis]
+            if is_integer(info_idx):
+                info_idx = [info_idx]
+            labels = item_labels[info_idx]
 
-    See more at :ref:`Selection by Position <indexing.integer>`.
+            # if we have a partial multiindex, then need to adjust the plane
+            # indexer here
+            if len(labels) == 1 and isinstance(
+                self.obj[labels[0]].axes[0], ABCMultiIndex
+            ):
+                item = labels[0]
+                obj = self.obj[item]
+                index = obj.index
+                idx = indexer[:info_axis][0]
 
-    See Also
-    --------
-    DataFrame.iat : Fast integer location scalar accessor.
-    DataFrame.loc : Purely label-location based indexer for selection by label.
-    Series.iloc : Purely integer-location based indexing for
-                   selection by position.
+                plane_indexer = tuple([idx]) + indexer[info_axis + 1 :]
+                lplane_indexer = length_of_indexer(plane_indexer[0], index)
 
-    Examples
-    --------
+                # require that we are setting the right number of values that
+                # we are indexing
+                if (
+                    is_list_like_indexer(value)
+                    and np.iterable(value)
+                    and lplane_indexer != len(value)
+                ):
 
-    >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
-    ...           {'a': 100, 'b': 200, 'c': 300, 'd': 400},
-    ...           {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
-    >>> df = pd.DataFrame(mydict)
-    >>> df
-          a     b     c     d
-    0     1     2     3     4
-    1   100   200   300   400
-    2  1000  2000  3000  4000
+                    if len(obj[idx]) != len(value):
+                        raise ValueError(
+                            "cannot set using a multi-index "
+                            "selection indexer with a different "
+                            "length than the value"
+                        )
 
-    **Indexing just the rows**
+                    # make sure we have an ndarray
+                    value = getattr(value, "values", value).ravel()
 
-    With a scalar integer.
+                    # we can directly set the series here
+                    obj._consolidate_inplace()
+                    obj = obj.copy()
+                    obj._data = obj._data.setitem(indexer=tuple([idx]), value=value)
+                    self.obj[item] = obj
+                    return
 
-    >>> type(df.iloc[0])
-    <class 'pandas.core.series.Series'>
-    >>> df.iloc[0]
-    a    1
-    b    2
-    c    3
-    d    4
-    Name: 0, dtype: int64
+            # non-mi
+            else:
+                plane_indexer = indexer[:info_axis] + indexer[info_axis + 1 :]
+                plane_axis = self.obj.axes[:info_axis][0]
+                lplane_indexer = length_of_indexer(plane_indexer[0], plane_axis)
 
-    With a list of integers.
+            def setter(item, v):
+                s = self.obj[item]
+                pi = plane_indexer[0] if lplane_indexer == 1 else plane_indexer
 
-    >>> df.iloc[[0]]
-       a  b  c  d
-    0  1  2  3  4
-    >>> type(df.iloc[[0]])
-    <class 'pandas.core.frame.DataFrame'>
+                # perform the equivalent of a setitem on the info axis
+                # as we have a null slice or a slice with full bounds
+                # which means essentially reassign to the columns of a
+                # multi-dim object
+                # GH6149 (null slice), GH10408 (full bounds)
+                if isinstance(pi, tuple) and all(
+                    com.is_null_slice(idx) or com.is_full_slice(idx, len(self.obj))
+                    for idx in pi
+                ):
+                    s = v
+                else:
+                    # set the item, possibly having a dtype change
+                    s._consolidate_inplace()
+                    s = s.copy()
+                    s._data = s._data.setitem(indexer=pi, value=v)
+                    s._maybe_update_cacher(clear=True)
 
-    >>> df.iloc[[0, 1]]
-         a    b    c    d
-    0    1    2    3    4
-    1  100  200  300  400
+                # reset the sliced object if unique
+                self.obj[item] = s
 
-    With a `slice` object.
+            # we need an iterable, with a ndim of at least 1
+            # eg. don't pass through np.array(0)
+            if is_list_like_indexer(value) and getattr(value, "ndim", 1) > 0:
 
-    >>> df.iloc[:3]
-          a     b     c     d
-    0     1     2     3     4
-    1   100   200   300   400
-    2  1000  2000  3000  4000
+                # we have an equal len Frame
+                if isinstance(value, ABCDataFrame):
+                    sub_indexer = list(indexer)
+                    multiindex_indexer = isinstance(labels, ABCMultiIndex)
 
-    With a boolean mask the same length as the index.
+                    for item in labels:
+                        if item in value:
+                            sub_indexer[info_axis] = item
+                            v = self._align_series(
+                                tuple(sub_indexer), value[item], multiindex_indexer
+                            )
+                        else:
+                            v = np.nan
 
-    >>> df.iloc[[True, False, True]]
-          a     b     c     d
-    0     1     2     3     4
-    2  1000  2000  3000  4000
+                        setter(item, v)
 
-    With a callable, useful in method chains. The `x` passed
-    to the ``lambda`` is the DataFrame being sliced. This selects
-    the rows whose index label even.
+                # we have an equal len ndarray/convertible to our labels
+                # hasattr first, to avoid coercing to ndarray without reason.
+                # But we may be relying on the ndarray coercion to check ndim.
+                # Why not just convert to an ndarray earlier on if needed?
+                elif np.ndim(value) == 2:
 
-    >>> df.iloc[lambda x: x.index % 2 == 0]
-          a     b     c     d
-    0     1     2     3     4
-    2  1000  2000  3000  4000
+                    # note that this coerces the dtype if we are mixed
+                    # GH 7551
+                    value = np.array(value, dtype=object)
+                    if len(labels) != value.shape[1]:
+                        raise ValueError(
+                            "Must have equal len keys and value "
+                            "when setting with an ndarray"
+                        )
 
-    **Indexing both axes**
+                    for i, item in enumerate(labels):
 
-    You can mix the indexer types for the index and columns. Use ``:`` to
-    select the entire axis.
+                        # setting with a list, recoerces
+                        setter(item, value[:, i].tolist())
 
-    With scalar integers.
+                # we have an equal len list/ndarray
+                elif _can_do_equal_len(
+                    labels, value, plane_indexer, lplane_indexer, self.obj
+                ):
+                    setter(labels[0], value)
 
-    >>> df.iloc[0, 1]
-    2
+                # per label values
+                else:
 
-    With lists of integers.
+                    if len(labels) != len(value):
+                        raise ValueError(
+                            "Must have equal len keys and value "
+                            "when setting with an iterable"
+                        )
 
-    >>> df.iloc[[0, 2], [1, 3]]
-          b     d
-    0     2     4
-    2  2000  4000
+                    for item, v in zip(labels, value):
+                        setter(item, v)
+            else:
 
-    With `slice` objects.
+                # scalar
+                for item in labels:
+                    setter(item, value)
 
-    >>> df.iloc[1:3, 0:3]
-          a     b     c
-    1   100   200   300
-    2  1000  2000  3000
+        else:
+            if isinstance(indexer, tuple):
+                indexer = maybe_convert_ix(*indexer)
 
-    With a boolean array whose length matches the columns.
+                # if we are setting on the info axis ONLY
+                # set using those methods to avoid block-splitting
+                # logic here
+                if (
+                    len(indexer) > info_axis
+                    and is_integer(indexer[info_axis])
+                    and all(
+                        com.is_null_slice(idx)
+                        for i, idx in enumerate(indexer)
+                        if i != info_axis
+                    )
+                    and item_labels.is_unique
+                ):
+                    self.obj[item_labels[indexer[info_axis]]] = value
+                    return
 
-    >>> df.iloc[:, [True, False, True, False]]
-          a     c
-    0     1     3
-    1   100   300
-    2  1000  3000
+            if isinstance(value, (ABCSeries, dict)):
+                # TODO(EA): ExtensionBlock.setitem this causes issues with
+                # setting for extensionarrays that store dicts. Need to decide
+                # if it's worth supporting that.
+                value = self._align_series(indexer, Series(value))
 
-    With a callable function that expects the Series or DataFrame.
+            elif isinstance(value, ABCDataFrame):
+                value = self._align_frame(indexer, value)
 
-    >>> df.iloc[:, lambda df: [0, 2]]
-          a     c
-    0     1     3
-    1   100   300
-    2  1000  3000
-    """
+            # check for chained assignment
+            self.obj._check_is_chained_assignment_possible()
 
-    _valid_types = (
-        "integer, integer slice (START point is INCLUDED, END "
-        "point is EXCLUDED), listlike of integers, boolean array"
-    )
-    _exception = IndexError
-    _get_slice_axis = _NDFrameIndexer._get_slice_axis
+            # actually do the set
+            self.obj._consolidate_inplace()
+            self.obj._data = self.obj._data.setitem(indexer=indexer, value=value)
+            self.obj._maybe_update_cacher(clear=True)
 
-    def _validate_key(self, key, axis: int):
-        if com.is_bool_indexer(key):
-            if hasattr(key, "index") and isinstance(key.index, Index):
-                if key.index.inferred_type == "integer":
-                    raise NotImplementedError(
-                        "iLocation based boolean "
-                        "indexing on an integer type "
-                        "is not available"
-                    )
-                raise ValueError(
-                    "iLocation based boolean indexing cannot use "
-                    "an indexable as a mask"
-                )
-            return
+    def _setitem_with_indexer_missing(self, indexer, value):
+        """
+        Insert new row(s) or column(s) into the Series or DataFrame.
+        """
+        from pandas import Series
 
-        if isinstance(key, slice):
-            return
-        elif is_integer(key):
-            self._validate_integer(key, axis)
-        elif isinstance(key, tuple):
-            # a tuple should already have been caught by this point
-            # so don't treat a tuple as a valid indexer
-            raise IndexingError("Too many indexers")
-        elif is_list_like_indexer(key):
-            arr = np.array(key)
-            len_axis = len(self.obj._get_axis(axis))
+        # reindex the axis to the new value
+        # and set inplace
+        if self.ndim == 1:
+            index = self.obj.index
+            new_index = index.insert(len(index), indexer)
 
-            # check that the key has a numeric dtype
-            if not is_numeric_dtype(arr.dtype):
-                raise IndexError(
-                    ".iloc requires numeric indexers, got {arr}".format(arr=arr)
-                )
+            # we have a coerced indexer, e.g. a float
+            # that matches in an Int64Index, so
+            # we will not create a duplicate index, rather
+            # index to that element
+            # e.g. 0.0 -> 0
+            # GH#12246
+            if index.is_unique:
+                new_indexer = index.get_indexer([new_index[-1]])
+                if (new_indexer != -1).any():
+                    return self._setitem_with_indexer(new_indexer, value)
 
-            # check that the key does not exceed the maximum size of the index
-            if len(arr) and (arr.max() >= len_axis or arr.min() < -len_axis):
-                raise IndexError("positional indexers are out-of-bounds")
-        else:
-            raise ValueError(
-                "Can only index by location with "
-                "a [{types}]".format(types=self._valid_types)
-            )
+            # this preserves dtype of the value
+            new_values = Series([value])._values
+            if len(self.obj._values):
+                # GH#22717 handle casting compatibility that np.concatenate
+                #  does incorrectly
+                new_values = concat_compat([self.obj._values, new_values])
+            self.obj._data = self.obj._constructor(
+                new_values, index=new_index, name=self.obj.name
+            )._data
+            self.obj._maybe_update_cacher(clear=True)
 
-    def _has_valid_setitem_indexer(self, indexer):
-        self._has_valid_positional_setitem_indexer(indexer)
+        elif self.ndim == 2:
 
-    def _is_scalar_access(self, key: Tuple):
-        # this is a shortcut accessor to both .loc and .iloc
-        # that provide the equivalent access of .at and .iat
-        # a) avoid getting things via sections and (to minimize dtype changes)
-        # b) provide a performant path
-        if len(key) != self.ndim:
-            return False
+            if not len(self.obj.columns):
+                # no columns and scalar
+                raise ValueError("cannot set a frame with no defined columns")
 
-        for i, k in enumerate(key):
-            if not is_integer(k):
-                return False
+            if isinstance(value, ABCSeries):
+                # append a Series
+                value = value.reindex(index=self.obj.columns, copy=True)
+                value.name = indexer
 
-            ax = self.obj.axes[i]
-            if not ax.is_unique:
-                return False
+            else:
+                # a list-list
+                if is_list_like_indexer(value):
+                    # must have conforming columns
+                    if len(value) != len(self.obj.columns):
+                        raise ValueError("cannot set a row with mismatched columns")
 
-        return True
+                value = Series(value, index=self.obj.columns, name=indexer)
 
-    def _getitem_scalar(self, key):
-        # a fast-path to scalar access
-        # if not, raise
-        values = self.obj._get_value(*key, takeable=True)
-        return values
+            self.obj._data = self.obj.append(value)._data
+            self.obj._maybe_update_cacher(clear=True)
 
-    def _validate_integer(self, key: int, axis: int):
+    def _align_series(self, indexer, ser: ABCSeries, multiindex_indexer: bool = False):
         """
-        Check that 'key' is a valid position in the desired axis.
-
         Parameters
         ----------
-        key : int
-            Requested position
-        axis : int
-            Desired axis
+        indexer : tuple, slice, scalar
+            Indexer used to get the locations that will be set to `ser`.
+        ser : pd.Series
+            Values to assign to the locations specified by `indexer`.
+        multiindex_indexer : boolean, optional
+            Defaults to False. Should be set to True if `indexer` was from
+            a `pd.MultiIndex`, to avoid unnecessary broadcasting.
 
         Returns
         -------
-        None
-
-        Raises
-        ------
-        IndexError
-            If 'key' is not a valid position in axis 'axis'
+        `np.array` of `ser` broadcast to the appropriate shape for assignment
+        to the locations selected by `indexer`
         """
+        if isinstance(indexer, (slice, np.ndarray, list, Index)):
+            indexer = tuple([indexer])
 
-        len_axis = len(self.obj._get_axis(axis))
-        if key >= len_axis or key < -len_axis:
-            raise IndexError("single positional indexer is out-of-bounds")
+        if isinstance(indexer, tuple):
 
-    def _getitem_tuple(self, tup: Tuple):
+            # flatten np.ndarray indexers
+            def ravel(i):
+                return i.ravel() if isinstance(i, np.ndarray) else i
 
-        self._has_valid_tuple(tup)
-        try:
-            return self._getitem_lowerdim(tup)
-        except IndexingError:
-            pass
+            indexer = tuple(map(ravel, indexer))
 
-        retval = self.obj
-        axis = 0
-        for i, key in enumerate(tup):
-            if com.is_null_slice(key):
-                axis += 1
-                continue
+            aligners = [not com.is_null_slice(idx) for idx in indexer]
+            sum_aligners = sum(aligners)
+            single_aligner = sum_aligners == 1
+            is_frame = self.ndim == 2
+            obj = self.obj
 
-            retval = getattr(retval, self.name)._getitem_axis(key, axis=axis)
+            # are we a single alignable value on a non-primary
+            # dim (e.g. panel: 1,2, or frame: 0) ?
+            # hence need to align to a single axis dimension
+            # rather that find all valid dims
 
-            # if the dim was reduced, then pass a lower-dim the next time
-            if retval.ndim < self.ndim:
-                # TODO: this is never reached in tests; can we confirm that
-                #  it is impossible?
-                axis -= 1
+            # frame
+            if is_frame:
+                single_aligner = single_aligner and aligners[0]
 
-            # try to get for the next axis
-            axis += 1
+            # we have a frame, with multiple indexers on both axes; and a
+            # series, so need to broadcast (see GH5206)
+            if sum_aligners == self.ndim and all(is_sequence(_) for _ in indexer):
+                ser = ser.reindex(obj.axes[0][indexer[0]], copy=True)._values
 
-        return retval
+                # single indexer
+                if len(indexer) > 1 and not multiindex_indexer:
+                    len_indexer = len(indexer[1])
+                    ser = np.tile(ser, len_indexer).reshape(len_indexer, -1).T
 
-    def _get_list_axis(self, key, axis: int):
-        """
-        Return Series values by list or array of integers
+                return ser
 
-        Parameters
-        ----------
-        key : list-like positional indexer
-        axis : int (can only be zero)
+            for i, idx in enumerate(indexer):
+                ax = obj.axes[i]
 
-        Returns
-        -------
-        Series object
-        """
-        try:
-            return self.obj.take(key, axis=axis)
-        except IndexError:
-            # re-raise with different error message
-            raise IndexError("positional indexers are out-of-bounds")
+                # multiple aligners (or null slices)
+                if is_sequence(idx) or isinstance(idx, slice):
+                    if single_aligner and com.is_null_slice(idx):
+                        continue
+                    new_ix = ax[idx]
+                    if not is_list_like_indexer(new_ix):
+                        new_ix = Index([new_ix])
+                    else:
+                        new_ix = Index(new_ix)
+                    if ser.index.equals(new_ix) or not len(new_ix):
+                        return ser._values.copy()
 
-    def _getitem_axis(self, key, axis: int):
-        if isinstance(key, slice):
-            return self._get_slice_axis(key, axis=axis)
+                    return ser.reindex(new_ix)._values
 
-        if isinstance(key, list):
-            key = np.asarray(key)
+                # 2 dims
+                elif single_aligner:
 
-        if com.is_bool_indexer(key):
-            self._validate_key(key, axis)
-            return self._getbool_axis(key, axis=axis)
+                    # reindex along index
+                    ax = self.obj.axes[1]
+                    if ser.index.equals(ax) or not len(ax):
+                        return ser._values.copy()
+                    return ser.reindex(ax)._values
 
-        # a list of integers
-        elif is_list_like_indexer(key):
-            return self._get_list_axis(key, axis=axis)
+        elif is_scalar(indexer):
+            ax = self.obj._get_axis(1)
 
-        # a single integer
-        else:
-            key = item_from_zerodim(key)
-            if not is_integer(key):
-                raise TypeError("Cannot index by location index with a non-integer key")
+            if ser.index.equals(ax):
+                return ser._values.copy()
 
-            # validate the location
-            self._validate_integer(key, axis)
+            return ser.reindex(ax)._values
 
-            return self._get_loc(key, axis=axis)
+        raise ValueError("Incompatible indexer with Series")
 
-    # raise_missing is included for compat with the parent class signature
-    def _convert_to_indexer(self, obj, axis: int, raise_missing: bool = False):
-        """ much simpler as we only have to deal with our valid types """
+    def _align_frame(self, indexer, df: ABCDataFrame):
+        is_frame = self.ndim == 2
 
-        # make need to convert a float key
-        if isinstance(obj, slice):
-            return self._convert_slice_indexer(obj, axis)
+        if isinstance(indexer, tuple):
+
+            idx, cols = None, None
+            sindexers = []
+            for i, ix in enumerate(indexer):
+                ax = self.obj.axes[i]
+                if is_sequence(ix) or isinstance(ix, slice):
+                    if isinstance(ix, np.ndarray):
+                        ix = ix.ravel()
+                    if idx is None:
+                        idx = ax[ix]
+                    elif cols is None:
+                        cols = ax[ix]
+                    else:
+                        break
+                else:
+                    sindexers.append(i)
 
-        elif is_float(obj):
-            return self._convert_scalar_indexer(obj, axis)
+            if idx is not None and cols is not None:
 
-        try:
-            self._validate_key(obj, axis)
-            return obj
-        except ValueError:
-            raise ValueError(
-                "Can only index by location with "
-                "a [{types}]".format(types=self._valid_types)
-            )
+                if df.index.equals(idx) and df.columns.equals(cols):
+                    val = df.copy()._values
+                else:
+                    val = df.reindex(idx, columns=cols)._values
+                return val
+
+        elif (isinstance(indexer, slice) or is_list_like_indexer(indexer)) and is_frame:
+            ax = self.obj.index[indexer]
+            if df.index.equals(ax):
+                val = df.copy()._values
+            else:
+
+                # we have a multi-index and are trying to align
+                # with a particular, level GH3738
+                if (
+                    isinstance(ax, ABCMultiIndex)
+                    and isinstance(df.index, ABCMultiIndex)
+                    and ax.nlevels != df.index.nlevels
+                ):
+                    raise TypeError(
+                        "cannot align on a multi-index with out "
+                        "specifying the join levels"
+                    )
+
+                val = df.reindex(index=ax)._values
+            return val
+
+        raise ValueError("Incompatible indexer with DataFrame")
 
 
 class _ScalarAccessIndexer(_NDFrameIndexerBase):
-    """ access scalars quickly """
+    """
+    Access scalars quickly.
+    """
 
     def _convert_key(self, key, is_setter: bool = False):
         raise AbstractMethodError(self)
@@ -2192,142 +2084,44 @@ def __setitem__(self, key, value):
         if len(key) != self.ndim:
             raise ValueError("Not enough indexers for scalar access (setting)!")
         key = list(self._convert_key(key, is_setter=True))
-        key.append(value)
-        self.obj._set_value(*key, takeable=self._takeable)
+        self.obj._set_value(*key, value=value, takeable=self._takeable)
 
 
+@Appender(IndexingMixin.at.__doc__)
 class _AtIndexer(_ScalarAccessIndexer):
-    """
-    Access a single value for a row/column label pair.
-
-    Similar to ``loc``, in that both provide label-based lookups. Use
-    ``at`` if you only need to get or set a single value in a DataFrame
-    or Series.
-
-    Raises
-    ------
-    KeyError
-        When label does not exist in DataFrame
-
-    See Also
-    --------
-    DataFrame.iat : Access a single value for a row/column pair by integer
-        position.
-    DataFrame.loc : Access a group of rows and columns by label(s).
-    Series.at : Access a single value using a label.
-
-    Examples
-    --------
-    >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
-    ...                   index=[4, 5, 6], columns=['A', 'B', 'C'])
-    >>> df
-        A   B   C
-    4   0   2   3
-    5   0   4   1
-    6  10  20  30
-
-    Get value at specified row/column pair
-
-    >>> df.at[4, 'B']
-    2
-
-    Set value at specified row/column pair
-
-    >>> df.at[4, 'B'] = 10
-    >>> df.at[4, 'B']
-    10
-
-    Get value within a Series
-
-    >>> df.loc[5].at['B']
-    4
-    """
-
     _takeable = False
 
     def _convert_key(self, key, is_setter: bool = False):
-        """ require they keys to be the same type as the index (so we don't
+        """
+        Require they keys to be the same type as the index. (so we don't
         fallback)
         """
-
         # allow arbitrary setting
         if is_setter:
             return list(key)
 
-        for ax, i in zip(self.obj.axes, key):
-            if ax.is_integer():
-                if not is_integer(i):
-                    raise ValueError(
-                        "At based indexing on an integer index "
-                        "can only have integer indexers"
-                    )
-            else:
-                if is_integer(i) and not ax.holds_integer():
-                    raise ValueError(
-                        "At based indexing on an non-integer "
-                        "index can only have non-integer "
-                        "indexers"
-                    )
-        return key
-
-
-class _iAtIndexer(_ScalarAccessIndexer):
-    """
-    Access a single value for a row/column pair by integer position.
-
-    Similar to ``iloc``, in that both provide integer-based lookups. Use
-    ``iat`` if you only need to get or set a single value in a DataFrame
-    or Series.
-
-    Raises
-    ------
-    IndexError
-        When integer position is out of bounds
-
-    See Also
-    --------
-    DataFrame.at : Access a single value for a row/column label pair.
-    DataFrame.loc : Access a group of rows and columns by label(s).
-    DataFrame.iloc : Access a group of rows and columns by integer position(s).
-
-    Examples
-    --------
-    >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
-    ...                   columns=['A', 'B', 'C'])
-    >>> df
-        A   B   C
-    0   0   2   3
-    1   0   4   1
-    2  10  20  30
-
-    Get value at specified row/column pair
-
-    >>> df.iat[1, 2]
-    1
+        lkey = list(key)
+        for n, (ax, i) in enumerate(zip(self.obj.axes, key)):
+            lkey[n] = ax._convert_scalar_indexer(i, kind="loc")
 
-    Set value at specified row/column pair
+        return tuple(lkey)
 
-    >>> df.iat[1, 2] = 10
-    >>> df.iat[1, 2]
-    10
-
-    Get value within a series
-
-    >>> df.loc[0].iat[1]
-    2
-    """
 
+@Appender(IndexingMixin.iat.__doc__)
+class _iAtIndexer(_ScalarAccessIndexer):
     _takeable = True
 
     def _convert_key(self, key, is_setter: bool = False):
-        """ require integer args (and convert to label arguments) """
+        """
+        Require integer args. (and convert to label arguments)
+        """
         for a, i in zip(self.obj.axes, key):
             if not is_integer(i):
                 raise ValueError("iAt based indexing can only have integer indexers")
         return key
 
 
-def _tuplify(ndim: int, loc) -> tuple:
+def _tuplify(ndim: int, loc: Hashable) -> Tuple[Union[Hashable, slice], ...]:
     """
     Given an indexer for the first dimension, create an equivalent tuple
     for indexing over all dimensions.
@@ -2341,14 +2135,15 @@ def _tuplify(ndim: int, loc) -> tuple:
     -------
     tuple
     """
-    tup = [slice(None, None) for _ in range(ndim)]
-    tup[0] = loc
-    return tuple(tup)
+    _tup: List[Union[Hashable, slice]]
+    _tup = [slice(None, None) for _ in range(ndim)]
+    _tup[0] = loc
+    return tuple(_tup)
 
 
 def convert_to_index_sliceable(obj, key):
     """
-    if we are index sliceable, then return my slicer, otherwise return None
+    If we are index sliceable, then return my slicer, otherwise return None.
     """
     idx = obj.index
     if isinstance(key, slice):
@@ -2381,23 +2176,21 @@ def check_bool_indexer(index: Index, key) -> np.ndarray:
     Parameters
     ----------
     index : Index
-        Index of the object on which the indexing is done
+        Index of the object on which the indexing is done.
     key : list-like
-        Boolean indexer to check
+        Boolean indexer to check.
 
     Returns
     -------
-    result: np.array
-        Resulting key
+    np.array
+        Resulting key.
 
     Raises
     ------
     IndexError
-        If the key does not have the same length as index
-
+        If the key does not have the same length as index.
     IndexingError
-        If the index of the key is unalignable to index
-
+        If the index of the key is unalignable to index.
     """
     result = key
     if isinstance(key, ABCSeries) and not key.index.equals(index):
@@ -2411,25 +2204,18 @@ def check_bool_indexer(index: Index, key) -> np.ndarray:
             )
         result = result.astype(bool)._values
     else:
-        if is_sparse(result):
-            result = result.to_dense()
+        # key might be sparse / object-dtype bool, check_array_indexer needs bool array
         result = np.asarray(result, dtype=bool)
-
-        # GH26658
-        if len(result) != len(index):
-            raise IndexError(
-                "Item wrong length {} instead of {}.".format(len(result), len(index))
-            )
+        result = check_array_indexer(index, result)
 
     return result
 
 
 def convert_missing_indexer(indexer):
     """
-    reverse convert a missing indexer, which is a dict
+    Reverse convert a missing indexer, which is a dict
     return the scalar indexer and a boolean indicating if we converted
     """
-
     if isinstance(indexer, dict):
 
         # a missing key (but not a tuple indexer)
@@ -2444,7 +2230,7 @@ def convert_missing_indexer(indexer):
 
 def convert_from_missing_indexer_tuple(indexer, axes):
     """
-    create a filtered indexer that doesn't have any missing indexers
+    Create a filtered indexer that doesn't have any missing indexers.
     """
 
     def get_indexer(_i, _idx):
@@ -2455,9 +2241,8 @@ def get_indexer(_i, _idx):
 
 def maybe_convert_ix(*args):
     """
-    We likely want to take the cross-product
+    We likely want to take the cross-product.
     """
-
     ixify = True
     for arg in args:
         if not isinstance(arg, (np.ndarray, list, ABCSeries, Index)):
@@ -2469,7 +2254,12 @@ def maybe_convert_ix(*args):
         return args
 
 
-def is_nested_tuple(tup, labels):
+def is_nested_tuple(tup, labels) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     # check for a compatible nested tuple and multiindexes among the axes
     if not isinstance(tup, tuple):
         return False
@@ -2482,12 +2272,22 @@ def is_nested_tuple(tup, labels):
     return False
 
 
-def is_label_like(key):
+def is_label_like(key) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     # select a label or row
     return not isinstance(key, slice) and not is_list_like_indexer(key)
 
 
-def need_slice(obj):
+def need_slice(obj) -> bool:
+    """
+    Returns
+    -------
+    bool
+    """
     return (
         obj.start is not None
         or obj.stop is not None
@@ -2508,7 +2308,14 @@ def _non_reducing_slice(slice_):
     if isinstance(slice_, kinds):
         slice_ = IndexSlice[:, slice_]
 
-    def pred(part):
+    def pred(part) -> bool:
+        """
+        Returns
+        -------
+        bool
+            True if slice does *not* reduce,
+            False if `part` is a tuple.
+        """
         # true when slice does *not* reduce, False when part is a tuple,
         # i.e. MultiIndex slice
         return (isinstance(part, slice) or is_list_like(part)) and not isinstance(
@@ -2529,7 +2336,7 @@ def pred(part):
 
 def _maybe_numeric_slice(df, slice_, include_bool=False):
     """
-    want nice defaults for background_gradient that don't break
+    Want nice defaults for background_gradient that don't break
     with non-numeric data. But if slice_ is passed go with that.
     """
     if slice_ is None:
@@ -2540,8 +2347,13 @@ def _maybe_numeric_slice(df, slice_, include_bool=False):
     return slice_
 
 
-def _can_do_equal_len(labels, value, plane_indexer, lplane_indexer, obj):
-    """ return True if we have an equal len settable """
+def _can_do_equal_len(labels, value, plane_indexer, lplane_indexer, obj) -> bool:
+    """
+    Returns
+    -------
+    bool
+        True if we have an equal len settable.
+    """
     if not len(labels) == 1 or not np.iterable(value) or is_scalar(plane_indexer[0]):
         return False
 
diff --git a/pandas/core/internals/__init__.py b/pandas/core/internals/__init__.py
index 8ac0df2fa4e0a..37a3405554745 100644
--- a/pandas/core/internals/__init__.py
+++ b/pandas/core/internals/__init__.py
@@ -1,4 +1,4 @@
-from .blocks import (  # noqa: F401
+from pandas.core.internals.blocks import (  # io.pytables, io.packers
     Block,
     BoolBlock,
     CategoricalBlock,
@@ -10,19 +10,38 @@
     IntBlock,
     ObjectBlock,
     TimeDeltaBlock,
+    _block_shape,
+    _safe_reshape,
+    make_block,
 )
-from .managers import (  # noqa: F401
+from pandas.core.internals.managers import (
     BlockManager,
     SingleBlockManager,
-    create_block_manager_from_arrays,
-    create_block_manager_from_blocks,
-)
-
-from .blocks import _safe_reshape  # noqa: F401; io.packers
-from .blocks import make_block  # noqa: F401; io.pytables, io.packers
-from .managers import (  # noqa: F401; reshape.concat, reshape.merge
     _transform_index,
     concatenate_block_managers,
+    create_block_manager_from_arrays,
+    create_block_manager_from_blocks,
 )
 
-from .blocks import _block_shape  # noqa:F401; io.pytables
+__all__ = [
+    "Block",
+    "BoolBlock",
+    "CategoricalBlock",
+    "ComplexBlock",
+    "DatetimeBlock",
+    "DatetimeTZBlock",
+    "ExtensionBlock",
+    "FloatBlock",
+    "IntBlock",
+    "ObjectBlock",
+    "TimeDeltaBlock",
+    "_safe_reshape",
+    "make_block",
+    "_block_shape",
+    "BlockManager",
+    "SingleBlockManager",
+    "_transform_index",
+    "concatenate_block_managers",
+    "create_block_manager_from_arrays",
+    "create_block_manager_from_blocks",
+]
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 29d225443d18a..536aa53c95fba 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1,4 +1,4 @@
-from datetime import date, datetime, timedelta
+from datetime import datetime, timedelta
 import functools
 import inspect
 import re
@@ -7,7 +7,7 @@
 
 import numpy as np
 
-from pandas._libs import NaT, Timestamp, lib, tslib, writers
+from pandas._libs import NaT, Timestamp, algos as libalgos, lib, tslib, writers
 import pandas._libs.internals as libinternals
 from pandas._libs.tslibs import Timedelta, conversion
 from pandas._libs.tslibs.timezones import tz_compare
@@ -15,6 +15,7 @@
 
 from pandas.core.dtypes.cast import (
     astype_nansafe,
+    convert_scalar_for_putitemlike,
     find_common_type,
     infer_dtype_from,
     infer_dtype_from_scalar,
@@ -36,7 +37,6 @@
     is_datetime64tz_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
-    is_extension_type,
     is_float_dtype,
     is_integer,
     is_integer_dtype,
@@ -54,7 +54,6 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
-    ABCDatetimeIndex,
     ABCExtensionArray,
     ABCPandasArray,
     ABCSeries,
@@ -64,11 +63,17 @@
     array_equivalent,
     is_valid_nat_for_dtype,
     isna,
-    notna,
 )
 
 import pandas.core.algorithms as algos
-from pandas.core.arrays import Categorical, DatetimeArray, PandasDtype, TimedeltaArray
+from pandas.core.arrays import (
+    Categorical,
+    DatetimeArray,
+    ExtensionArray,
+    PandasArray,
+    PandasDtype,
+    TimedeltaArray,
+)
 from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.construction import extract_array
@@ -117,8 +122,8 @@ def __init__(self, values, placement, ndim=None):
 
         if self._validate_ndim and self.ndim and len(self.mgr_locs) != len(self.values):
             raise ValueError(
-                "Wrong number of items passed {val}, placement implies "
-                "{mgr}".format(val=len(self.values), mgr=len(self.mgr_locs))
+                f"Wrong number of items passed {len(self.values)}, "
+                f"placement implies {len(self.mgr_locs)}"
             )
 
     def _check_ndim(self, values, ndim):
@@ -146,9 +151,10 @@ def _check_ndim(self, values, ndim):
             ndim = values.ndim
 
         if self._validate_ndim and values.ndim != ndim:
-            msg = "Wrong number of dimensions. values.ndim != ndim [{} != {}]"
-            raise ValueError(msg.format(values.ndim, ndim))
-
+            raise ValueError(
+                "Wrong number of dimensions. "
+                f"values.ndim != ndim [{values.ndim} != {ndim}]"
+            )
         return ndim
 
     @property
@@ -186,23 +192,36 @@ def is_categorical_astype(self, dtype):
         if dtype is Categorical or dtype is CategoricalDtype:
             # this is a pd.Categorical, but is not
             # a valid type for astypeing
-            raise TypeError("invalid type {0} for astype".format(dtype))
+            raise TypeError(f"invalid type {dtype} for astype")
 
         elif is_categorical_dtype(dtype):
             return True
 
         return False
 
-    def external_values(self, dtype=None):
-        """ return an outside world format, currently just the ndarray """
+    def external_values(self):
+        """
+        The array that Series.values returns (public attribute).
+
+        This has some historical constraints, and is overridden in block
+        subclasses to return the correct array (e.g. period returns
+        object ndarray and datetimetz a datetime64[ns] ndarray instead of
+        proper extension array).
+        """
         return self.values
 
-    def internal_values(self, dtype=None):
-        """ return an internal format, currently just the ndarray
-        this should be the pure internal API format
+    def internal_values(self):
+        """
+        The array that Series._values returns (internal values).
         """
         return self.values
 
+    def array_values(self) -> ExtensionArray:
+        """
+        The array that Series.array returns. Always an ExtensionArray.
+        """
+        return PandasArray(self.values)
+
     def get_values(self, dtype=None):
         """
         return an internal format, currently just the ndarray
@@ -243,7 +262,7 @@ def array_dtype(self):
         """
         return self.dtype
 
-    def make_block(self, values, placement=None):
+    def make_block(self, values, placement=None) -> "Block":
         """
         Create a new block, with type inference propagate any values that are
         not specified
@@ -253,44 +272,32 @@ def make_block(self, values, placement=None):
 
         return make_block(values, placement=placement, ndim=self.ndim)
 
-    def make_block_same_class(self, values, placement=None, ndim=None, dtype=None):
+    def make_block_same_class(self, values, placement=None, ndim=None):
         """ Wrap given values in a block of same type as self. """
-        if dtype is not None:
-            # issue 19431 fastparquet is passing this
-            warnings.warn(
-                "dtype argument is deprecated, will be removed in a future release.",
-                FutureWarning,
-            )
         if placement is None:
             placement = self.mgr_locs
         if ndim is None:
             ndim = self.ndim
-        return make_block(
-            values, placement=placement, ndim=ndim, klass=self.__class__, dtype=dtype
-        )
+        return make_block(values, placement=placement, ndim=ndim, klass=type(self))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # don't want to print out all of the items here
-        name = pprint_thing(self.__class__.__name__)
+        name = type(self).__name__
         if self._is_single_block:
 
-            result = "{name}: {len} dtype: {dtype}".format(
-                name=name, len=len(self), dtype=self.dtype
-            )
+            result = f"{name}: {len(self)} dtype: {self.dtype}"
 
         else:
 
             shape = " x ".join(pprint_thing(s) for s in self.shape)
-            result = "{name}: {index}, {shape}, dtype: {dtype}".format(
-                name=name,
-                index=pprint_thing(self.mgr_locs.indexer),
-                shape=shape,
-                dtype=self.dtype,
+            result = (
+                f"{name}: {pprint_thing(self.mgr_locs.indexer)}, "
+                f"{shape}, dtype: {self.dtype}"
             )
 
         return result
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.values)
 
     def __getstate__(self):
@@ -339,7 +346,7 @@ def ftype(self):
             dtype = self.dtype.subtype
         else:
             dtype = self.dtype
-        return "{dtype}:{ftype}".format(dtype=dtype, ftype=self._ftype)
+        return f"{dtype}:{self._ftype}"
 
     def merge(self, other):
         return _merge_blocks([self, other])
@@ -375,16 +382,31 @@ def delete(self, loc):
         self.values = np.delete(self.values, loc, 0)
         self.mgr_locs = self.mgr_locs.delete(loc)
 
-    def apply(self, func, **kwargs):
+    def apply(self, func, **kwargs) -> List["Block"]:
         """ apply the function to my values; return a block if we are not
         one
         """
         with np.errstate(all="ignore"):
             result = func(self.values, **kwargs)
+
+        return self._split_op_result(result)
+
+    def _split_op_result(self, result) -> List["Block"]:
+        # See also: split_and_operate
+        if is_extension_array_dtype(result) and result.ndim > 1:
+            # if we get a 2D ExtensionArray, we need to split it into 1D pieces
+            nbs = []
+            for i, loc in enumerate(self.mgr_locs):
+                vals = result[i]
+                nv = _block_shape(vals, ndim=self.ndim)
+                block = self.make_block(values=nv, placement=[loc])
+                nbs.append(block)
+            return nbs
+
         if not isinstance(result, Block):
             result = self.make_block(values=_block_shape(result, ndim=self.ndim))
 
-        return result
+        return [result]
 
     def fillna(self, value, limit=None, inplace=False, downcast=None):
         """ fillna on the block with the value. If we fail, then convert to
@@ -394,10 +416,7 @@ def fillna(self, value, limit=None, inplace=False, downcast=None):
 
         mask = isna(self.values)
         if limit is not None:
-            if not is_integer(limit):
-                raise ValueError("Limit must be an integer")
-            if limit < 1:
-                raise ValueError("Limit must be greater than 0")
+            limit = libalgos._validate_limit(None, limit=limit)
             mask[mask.cumsum(self.ndim - 1) > limit] = False
 
         if not self._can_hold_na:
@@ -536,16 +555,14 @@ def f(mask, val, idx):
 
         return self.split_and_operate(None, f, False)
 
-    def astype(self, dtype, copy=False, errors="raise", **kwargs):
-        return self._astype(dtype, copy=copy, errors=errors, **kwargs)
-
-    def _astype(self, dtype, copy=False, errors="raise", **kwargs):
-        """Coerce to the new type
+    def astype(self, dtype, copy: bool = False, errors: str = "raise"):
+        """
+        Coerce to the new dtype.
 
         Parameters
         ----------
         dtype : str, dtype convertible
-        copy : boolean, default False
+        copy : bool, default False
             copy if indicated
         errors : str, {'raise', 'ignore'}, default 'ignore'
             - ``raise`` : allow exceptions to be raised
@@ -559,33 +576,21 @@ def _astype(self, dtype, copy=False, errors="raise", **kwargs):
 
         if errors not in errors_legal_values:
             invalid_arg = (
-                "Expected value of kwarg 'errors' to be one of {}. "
-                "Supplied value is '{}'".format(list(errors_legal_values), errors)
+                "Expected value of kwarg 'errors' to be one of "
+                f"{list(errors_legal_values)}. Supplied value is '{errors}'"
             )
             raise ValueError(invalid_arg)
 
         if inspect.isclass(dtype) and issubclass(dtype, ExtensionDtype):
             msg = (
-                "Expected an instance of {}, but got the class instead. "
-                "Try instantiating 'dtype'.".format(dtype.__name__)
+                f"Expected an instance of {dtype.__name__}, "
+                "but got the class instead. Try instantiating 'dtype'."
             )
             raise TypeError(msg)
 
         # may need to convert to categorical
         if self.is_categorical_astype(dtype):
 
-            # deprecated 17636
-            for deprecated_arg in ("categories", "ordered"):
-                if deprecated_arg in kwargs:
-                    raise ValueError(
-                        "Got an unexpected argument: {}".format(deprecated_arg)
-                    )
-
-            categories = kwargs.get("categories", None)
-            ordered = kwargs.get("ordered", None)
-            if com.any_not_none(categories, ordered):
-                dtype = CategoricalDtype(categories, ordered)
-
             if is_categorical_dtype(self.values):
                 # GH 10696/18593: update an existing categorical efficiently
                 return self.make_block(self.values.astype(dtype, copy=copy))
@@ -600,54 +605,49 @@ def _astype(self, dtype, copy=False, errors="raise", **kwargs):
                 return self.copy()
             return self
 
-        try:
-            # force the copy here
-            if self.is_extension:
-                values = self.values.astype(dtype)
-            else:
-                if issubclass(dtype.type, str):
-
-                    # use native type formatting for datetime/tz/timedelta
-                    if self.is_datelike:
-                        values = self.to_native_types()
+        # force the copy here
+        if self.is_extension:
+            # TODO: Should we try/except this astype?
+            values = self.values.astype(dtype)
+        else:
+            if issubclass(dtype.type, str):
 
-                    # astype formatting
-                    else:
-                        values = self.get_values()
+                # use native type formatting for datetime/tz/timedelta
+                if self.is_datelike:
+                    values = self.to_native_types()
 
+                # astype formatting
                 else:
-                    values = self.get_values(dtype=dtype)
-
-                # _astype_nansafe works fine with 1-d only
-                vals1d = values.ravel()
-                values = astype_nansafe(vals1d, dtype, copy=True, **kwargs)
+                    values = self.get_values()
 
-            # TODO(extension)
-            # should we make this attribute?
-            if isinstance(values, np.ndarray):
-                values = values.reshape(self.shape)
+            else:
+                values = self.get_values(dtype=dtype)
 
-        except Exception:
-            # e.g. astype_nansafe can fail on object-dtype of strings
-            #  trying to convert to float
-            if errors == "raise":
-                raise
-            newb = self.copy() if copy else self
-        else:
-            newb = make_block(values, placement=self.mgr_locs, ndim=self.ndim)
+            # _astype_nansafe works fine with 1-d only
+            vals1d = values.ravel()
+            try:
+                values = astype_nansafe(vals1d, dtype, copy=True)
+            except (ValueError, TypeError):
+                # e.g. astype_nansafe can fail on object-dtype of strings
+                #  trying to convert to float
+                if errors == "raise":
+                    raise
+                newb = self.copy() if copy else self
+                return newb
+
+        # TODO(extension)
+        # should we make this attribute?
+        if isinstance(values, np.ndarray):
+            values = values.reshape(self.shape)
+
+        newb = make_block(values, placement=self.mgr_locs, ndim=self.ndim)
 
         if newb.is_numeric and self.is_numeric:
             if newb.shape != self.shape:
                 raise TypeError(
-                    "cannot set astype for copy = [{copy}] for dtype "
-                    "({dtype} [{shape}]) to different shape "
-                    "({newb_dtype} [{newb_shape}])".format(
-                        copy=copy,
-                        dtype=self.dtype.name,
-                        shape=self.shape,
-                        newb_dtype=newb.dtype.name,
-                        newb_shape=newb.shape,
-                    )
+                    f"cannot set astype for copy = [{copy}] for dtype "
+                    f"({self.dtype.name} [{self.shape}]) to different shape "
+                    f"({newb.dtype.name} [{newb.shape}])"
                 )
         return newb
 
@@ -674,40 +674,20 @@ def _can_hold_element(self, element: Any) -> bool:
             return issubclass(tipo.type, dtype)
         return isinstance(element, dtype)
 
-    def _try_coerce_args(self, other):
-        """ provide coercion to our input arguments """
-
-        if np.any(notna(other)) and not self._can_hold_element(other):
-            # coercion issues
-            # let higher levels handle
-            raise TypeError(
-                "cannot convert {} to an {}".format(
-                    type(other).__name__,
-                    type(self).__name__.lower().replace("Block", ""),
-                )
-            )
-        if np.any(isna(other)) and not self._can_hold_na:
-            raise TypeError(
-                "cannot convert {} to an {}".format(
-                    type(other).__name__,
-                    type(self).__name__.lower().replace("Block", ""),
-                )
-            )
-
-        return other
-
     def to_native_types(self, slicer=None, na_rep="nan", quoting=None, **kwargs):
         """ convert to our native types format, slicing if desired """
-
         values = self.get_values()
 
         if slicer is not None:
             values = values[:, slicer]
         mask = isna(values)
+        itemsize = writers.word_len(na_rep)
 
-        if not self.is_object and not quoting:
-            itemsize = writers.word_len(na_rep)
-            values = values.astype("<U{size}".format(size=itemsize))
+        if not self.is_object and not quoting and itemsize:
+            values = values.astype(str)
+            if values.dtype.itemsize / np.dtype("U1").itemsize < itemsize:
+                # enlarge for the na_rep
+                values = values.astype(f"<U{itemsize}")
         else:
             values = np.array(values, dtype="object")
 
@@ -778,7 +758,11 @@ def replace(
             )
 
         values = self.values
-        to_replace = self._try_coerce_args(to_replace)
+        if lib.is_scalar(to_replace) and isinstance(values, np.ndarray):
+            # The only non-DatetimeLike class that also has a non-trivial
+            #  try_coerce_args is ObjectBlock, but that overrides replace,
+            #  so does not get here.
+            to_replace = convert_scalar_for_putitemlike(to_replace, values.dtype)
 
         mask = missing.mask_missing(values, to_replace)
         if filter is not None:
@@ -825,7 +809,8 @@ def _replace_single(self, *args, **kwargs):
         return self if kwargs["inplace"] else self.copy()
 
     def setitem(self, indexer, value):
-        """Set the value inplace, returning a a maybe different typed block.
+        """
+        Set the value inplace, returning a a maybe different typed block.
 
         Parameters
         ----------
@@ -845,6 +830,9 @@ def setitem(self, indexer, value):
         """
         transpose = self.ndim == 2
 
+        if isinstance(indexer, np.ndarray) and indexer.ndim > self.ndim:
+            raise ValueError(f"Cannot set values with ndim > {self.ndim}")
+
         # coerce None values, if appropriate
         if value is None:
             if self.is_numeric:
@@ -853,7 +841,10 @@ def setitem(self, indexer, value):
         # coerce if block dtype can store value
         values = self.values
         if self._can_hold_element(value):
-            value = self._try_coerce_args(value)
+            # We only get here for non-Extension Blocks, so _try_coerce_args
+            #  is only relevant for DatetimeBlock and TimedeltaBlock
+            if lib.is_scalar(value):
+                value = convert_scalar_for_putitemlike(value, values.dtype)
 
         else:
             # current dtype cannot store value, coerce to common dtype
@@ -874,7 +865,12 @@ def setitem(self, indexer, value):
                     return b.setitem(indexer, value)
 
         # value must be storeable at this moment
-        arr_value = np.array(value)
+        if is_extension_array_dtype(getattr(value, "dtype", None)):
+            # We need to be careful not to allow through strings that
+            #  can be parsed to EADtypes
+            arr_value = value
+        else:
+            arr_value = np.array(value)
 
         # cast the values to a type that can hold nan (if necessary)
         if not self._can_hold_element(value):
@@ -886,7 +882,11 @@ def setitem(self, indexer, value):
 
         # length checking
         check_setitem_lengths(indexer, value, values)
-
+        exact_match = (
+            len(arr_value.shape)
+            and arr_value.shape[0] == values.shape[0]
+            and arr_value.size == values.size
+        )
         if is_empty_indexer(indexer, arr_value):
             # GH#8669 empty indexers
             pass
@@ -896,14 +896,21 @@ def setitem(self, indexer, value):
             #  be e.g. a list; see GH#6043
             values[indexer] = value
 
-        # if we are an exact match (ex-broadcasting),
-        # then use the resultant dtype
         elif (
-            len(arr_value.shape)
-            and arr_value.shape[0] == values.shape[0]
-            and arr_value.size == values.size
+            exact_match
+            and is_categorical_dtype(arr_value.dtype)
+            and not is_categorical_dtype(values)
         ):
+            # GH25495 - If the current dtype is not categorical,
+            # we need to create a new categorical block
             values[indexer] = value
+            return self.make_block(Categorical(self.values, dtype=arr_value.dtype))
+
+        # if we are an exact match (ex-broadcasting),
+        # then use the resultant dtype
+        elif exact_match:
+            values[indexer] = value
+
             try:
                 values = values.astype(arr_value.dtype)
             except ValueError:
@@ -950,7 +957,10 @@ def putmask(self, mask, new, align=True, inplace=False, axis=0, transpose=False)
             new = self.fill_value
 
         if self._can_hold_element(new):
-            new = self._try_coerce_args(new)
+            # We only get here for non-Extension Blocks, so _try_coerce_args
+            #  is only relevant for DatetimeBlock and TimedeltaBlock
+            if lib.is_scalar(new):
+                new = convert_scalar_for_putitemlike(new, new_values.dtype)
 
             if transpose:
                 new_values = new_values.T
@@ -974,15 +984,20 @@ def putmask(self, mask, new, align=True, inplace=False, axis=0, transpose=False)
                 and np.any(mask[mask])
                 and getattr(new, "ndim", 1) == 1
             ):
-
-                if not (
-                    mask.shape[-1] == len(new)
-                    or mask[mask].shape[-1] == len(new)
-                    or len(new) == 1
-                ):
+                if mask[mask].shape[-1] == len(new):
+                    # GH 30567
+                    # If length of ``new`` is less than the length of ``new_values``,
+                    # `np.putmask` would first repeat the ``new`` array and then
+                    # assign the masked values hence produces incorrect result.
+                    # `np.place` on the other hand uses the ``new`` values at it is
+                    # to place in the masked locations of ``new_values``
+                    np.place(new_values, mask, new)
+                elif mask.shape[-1] == len(new) or len(new) == 1:
+                    np.putmask(new_values, mask, new)
+                else:
                     raise ValueError("cannot assign mismatch length to masked array")
-
-            np.putmask(new_values, mask, new)
+            else:
+                np.putmask(new_values, mask, new)
 
         # maybe upcast me
         elif mask.any():
@@ -1078,8 +1093,7 @@ def coerce_to_target_dtype(self, other):
                 return self.astype(object)
 
             raise AssertionError(
-                "possible recursion in "
-                "coerce_to_target_dtype: {} {}".format(self, other)
+                f"possible recursion in coerce_to_target_dtype: {self} {other}"
             )
 
         elif self.is_timedelta or is_timedelta64_dtype(dtype):
@@ -1089,8 +1103,7 @@ def coerce_to_target_dtype(self, other):
                 return self.astype(object)
 
             raise AssertionError(
-                "possible recursion in "
-                "coerce_to_target_dtype: {} {}".format(self, other)
+                f"possible recursion in coerce_to_target_dtype: {self} {other}"
             )
 
         try:
@@ -1111,7 +1124,7 @@ def interpolate(
         fill_value=None,
         coerce=False,
         downcast=None,
-        **kwargs
+        **kwargs,
     ):
 
         inplace = validate_bool_kwarg(inplace, "inplace")
@@ -1161,7 +1174,7 @@ def check_int_bool(self, inplace):
             fill_value=fill_value,
             inplace=inplace,
             downcast=downcast,
-            **kwargs
+            **kwargs,
         )
 
     def _interpolate_with_fill(
@@ -1188,7 +1201,10 @@ def _interpolate_with_fill(
                     return [self.copy()]
 
         values = self.values if inplace else self.values.copy()
-        fill_value = self._try_coerce_args(fill_value)
+
+        # We only get here for non-ExtensionBlock
+        fill_value = convert_scalar_for_putitemlike(fill_value, self.values.dtype)
+
         values = missing.interpolate_2d(
             values,
             method=method,
@@ -1213,7 +1229,7 @@ def _interpolate(
         limit_area=None,
         inplace=False,
         downcast=None,
-        **kwargs
+        **kwargs,
     ):
         """ interpolate using scipy wrappers """
 
@@ -1232,8 +1248,7 @@ def _interpolate(
         if method in ("krogh", "piecewise_polynomial", "pchip"):
             if not index.is_monotonic:
                 raise ValueError(
-                    "{0} interpolation requires that the "
-                    "index be monotonic.".format(method)
+                    f"{method} interpolation requires that the index be monotonic."
                 )
         # process 1-d slices in the axis direction
 
@@ -1251,7 +1266,7 @@ def func(x):
                 limit_area=limit_area,
                 fill_value=fill_value,
                 bounds_error=False,
-                **kwargs
+                **kwargs,
             )
 
         # interp each column independently
@@ -1296,7 +1311,10 @@ def take_nd(self, indexer, axis, new_mgr_locs=None, fill_tuple=None):
 
     def diff(self, n: int, axis: int = 1) -> List["Block"]:
         """ return block for the diff of the values """
-        new_values = algos.diff(self.values, n, axis=axis)
+        new_values = algos.diff(self.values, n, axis=axis, stacklevel=7)
+        # We use block_shape for ExtensionBlock subclasses, which may call here
+        # via a super.
+        new_values = _block_shape(new_values, ndim=self.ndim)
         return [self.make_block(values=new_values)]
 
     def shift(self, periods, axis=0, fill_value=None):
@@ -1378,8 +1396,7 @@ def where(
         if not hasattr(cond, "shape"):
             raise ValueError("where must have a condition that is ndarray like")
 
-        # our where function
-        def func(cond, values, other):
+        def where_func(cond, values, other):
 
             if not (
                 (self.is_integer or self.is_bool)
@@ -1387,8 +1404,14 @@ def func(cond, values, other):
                 and np.isnan(other)
             ):
                 # np.where will cast integer array to floats in this case
-                other = self._try_coerce_args(other)
-
+                if not self._can_hold_element(other):
+                    raise TypeError
+                if lib.is_scalar(other) and isinstance(values, np.ndarray):
+                    # convert datetime to datetime64, timedelta to timedelta64
+                    other = convert_scalar_for_putitemlike(other, values.dtype)
+
+            # By the time we get here, we should have all Series/Index
+            #  args extracted to  ndarray
             fastres = expressions.where(cond, values, other)
             return fastres
 
@@ -1398,7 +1421,7 @@ def func(cond, values, other):
             # see if we can operate on the entire block, or need item-by-item
             # or if we are a single block (ndim == 1)
             try:
-                result = func(cond, values, other)
+                result = where_func(cond, values, other)
             except TypeError:
 
                 # we cannot coerce, return a compat dtype
@@ -1488,7 +1511,7 @@ def quantile(self, qs, interpolation="linear", axis=0):
         -------
         Block
         """
-        # We should always have ndim == 2 becase Series dispatches to DataFrame
+        # We should always have ndim == 2 because Series dispatches to DataFrame
         assert self.ndim == 2
 
         values = self.get_values()
@@ -1612,7 +1635,7 @@ def iget(self, col):
         if self.ndim == 2 and isinstance(col, tuple):
             col, loc = col
             if not com.is_null_slice(col) and col != 0:
-                raise IndexError("{0} only contains one item".format(self))
+                raise IndexError(f"{self} only contains one item")
             elif isinstance(col, slice):
                 if col != slice(None):
                     raise NotImplementedError(col)
@@ -1620,7 +1643,7 @@ def iget(self, col):
             return self.values[loc]
         else:
             if col != 0:
-                raise IndexError("{0} only contains one item".format(self))
+                raise IndexError(f"{self} only contains one item")
             return self.values
 
     def should_store(self, value):
@@ -1653,7 +1676,6 @@ def putmask(self, mask, new, align=True, inplace=False, axis=0, transpose=False)
         # use block's copy logic.
         # .values may be an Index which does shallow copy by default
         new_values = self.values if inplace else self.copy().values
-        new = self._try_coerce_args(new)
 
         if isinstance(new, np.ndarray) and len(new) == len(mask):
             new = new[mask]
@@ -1791,9 +1813,25 @@ def get_values(self, dtype=None):
             values = values.reshape((1,) + values.shape)
         return values
 
+    def array_values(self) -> ExtensionArray:
+        return self.values
+
     def to_dense(self):
         return np.asarray(self.values)
 
+    def to_native_types(self, slicer=None, na_rep="nan", quoting=None, **kwargs):
+        """override to use ExtensionArray astype for the conversion"""
+        values = self.values
+        if slicer is not None:
+            values = values[slicer]
+        mask = isna(values)
+
+        values = np.asarray(values.astype(object))
+        values[mask] = na_rep
+
+        # we are expected to return a 2-d ndarray
+        return values.reshape(1, len(values))
+
     def take_nd(self, indexer, axis=0, new_mgr_locs=None, fill_tuple=None):
         """
         Take values according to indexer and return them as a block.
@@ -1861,6 +1899,12 @@ def interpolate(
             placement=self.mgr_locs,
         )
 
+    def diff(self, n: int, axis: int = 1) -> List["Block"]:
+        if axis == 1:
+            # we are by definition 1D.
+            axis = 0
+        return super().diff(n, axis)
+
     def shift(
         self,
         periods: int,
@@ -1973,7 +2017,7 @@ class ObjectValuesExtensionBlock(ExtensionBlock):
     Series[T].values is an ndarray of objects.
     """
 
-    def external_values(self, dtype=None):
+    def external_values(self):
         return self.values.astype(object)
 
 
@@ -2017,7 +2061,7 @@ def to_native_types(
         float_format=None,
         decimal=".",
         quoting=None,
-        **kwargs
+        **kwargs,
     ):
         """ convert to our native types format, slicing if desired """
 
@@ -2113,6 +2157,20 @@ def get_values(self, dtype=None):
             return result.reshape(self.values.shape)
         return self.values
 
+    def internal_values(self):
+        # Override to return DatetimeArray and TimedeltaArray
+        return self.array_values()
+
+    def iget(self, key):
+        # GH#31649 we need to wrap scalars in Timestamp/Timedelta
+        # TODO: this can be removed if we ever have 2D EA
+        result = super().iget(key)
+        if isinstance(result, np.datetime64):
+            result = Timestamp(result)
+        elif isinstance(result, np.timedelta64):
+            result = Timedelta(result)
+        return result
+
 
 class DatetimeBlock(DatetimeLikeBlockMixin, Block):
     __slots__ = ()
@@ -2127,7 +2185,8 @@ def _can_hold_na(self):
         return True
 
     def _maybe_coerce_values(self, values):
-        """Input validation for values passed to __init__. Ensure that
+        """
+        Input validation for values passed to __init__. Ensure that
         we have datetime64ns, coercing if necessary.
 
         Parameters
@@ -2150,7 +2209,7 @@ def _maybe_coerce_values(self, values):
         assert isinstance(values, np.ndarray), type(values)
         return values
 
-    def _astype(self, dtype, **kwargs):
+    def astype(self, dtype, copy: bool = False, errors: str = "raise"):
         """
         these automatically copy, so copy=True has no effect
         raise on an except if raise == True
@@ -2166,7 +2225,7 @@ def _astype(self, dtype, **kwargs):
             return self.make_block(values)
 
         # delegate
-        return super()._astype(dtype=dtype, **kwargs)
+        return super().astype(dtype=dtype, copy=copy, errors=errors)
 
     def _can_hold_element(self, element: Any) -> bool:
         tipo = maybe_infer_dtype_type(element)
@@ -2188,38 +2247,6 @@ def _can_hold_element(self, element: Any) -> bool:
 
         return is_valid_nat_for_dtype(element, self.dtype)
 
-    def _try_coerce_args(self, other):
-        """
-        Coerce other to dtype 'i8'. NaN and NaT convert to
-        the smallest i8, and will correctly round-trip to NaT if converted
-        back in _try_coerce_result. values is always ndarray-like, other
-        may not be
-
-        Parameters
-        ----------
-        other : ndarray-like or scalar
-
-        Returns
-        -------
-        base-type other
-        """
-        if is_valid_nat_for_dtype(other, self.dtype):
-            other = np.datetime64("NaT", "ns")
-        elif isinstance(other, (datetime, np.datetime64, date)):
-            other = Timestamp(other)
-            if other.tz is not None:
-                raise TypeError("cannot coerce a Timestamp with a tz on a naive Block")
-            other = other.asm8
-        elif hasattr(other, "dtype") and is_datetime64_dtype(other):
-            # TODO: can we get here with non-nano?
-            pass
-        else:
-            # coercion issues
-            # let higher levels handle
-            raise TypeError(other)
-
-        return other
-
     def to_native_types(
         self, slicer=None, na_rep=None, date_format=None, quoting=None, **kwargs
     ):
@@ -2266,6 +2293,9 @@ def set(self, locs, values):
     def external_values(self):
         return np.asarray(self.values.astype("datetime64[ns]", copy=False))
 
+    def array_values(self) -> ExtensionArray:
+        return DatetimeArray._simple_new(self.values)
+
 
 class DatetimeTZBlock(ExtensionBlock, DatetimeBlock):
     """ implement a datetime64 block with a tz attribute """
@@ -2274,7 +2304,9 @@ class DatetimeTZBlock(ExtensionBlock, DatetimeBlock):
     is_datetimetz = True
     is_extension = True
 
+    internal_values = Block.internal_values
     _can_hold_element = DatetimeBlock._can_hold_element
+    to_native_types = DatetimeBlock.to_native_types
     fill_value = np.datetime64("NaT", "ns")
 
     @property
@@ -2353,14 +2385,10 @@ def _slice(self, slicer):
         if isinstance(slicer, tuple):
             col, loc = slicer
             if not com.is_null_slice(col) and col != 0:
-                raise IndexError("{0} only contains one item".format(self))
+                raise IndexError(f"{self} only contains one item")
             return self.values[loc]
         return self.values[slicer]
 
-    def _try_coerce_args(self, other):
-        # DatetimeArray handles this for us
-        return other
-
     def diff(self, n: int, axis: int = 0) -> List["Block"]:
         """
         1st discrete difference.
@@ -2487,45 +2515,13 @@ def fillna(self, value, **kwargs):
         # interpreted as nanoseconds
         if is_integer(value):
             # Deprecation GH#24694, GH#19233
-            warnings.warn(
-                "Passing integers to fillna is deprecated, will "
-                "raise a TypeError in a future version.  To retain "
-                "the old behavior, pass pd.Timedelta(seconds=n) "
-                "instead.",
-                FutureWarning,
-                stacklevel=6,
+            raise TypeError(
+                "Passing integers to fillna for timedelta64[ns] dtype is no "
+                "longer supported.  To obtain the old behavior, pass "
+                "`pd.Timedelta(seconds=n)` instead."
             )
-            value = Timedelta(value, unit="s")
         return super().fillna(value, **kwargs)
 
-    def _try_coerce_args(self, other):
-        """
-        Coerce values and other to datetime64[ns], with null values
-        converted to datetime64("NaT", "ns").
-
-        Parameters
-        ----------
-        other : ndarray-like or scalar
-
-        Returns
-        -------
-        base-type other
-        """
-
-        if is_valid_nat_for_dtype(other, self.dtype):
-            other = np.timedelta64("NaT", "ns")
-        elif isinstance(other, (timedelta, np.timedelta64)):
-            other = Timedelta(other).to_timedelta64()
-        elif hasattr(other, "dtype") and is_timedelta64_dtype(other):
-            # TODO: can we get here with non-nano dtype?
-            pass
-        else:
-            # coercion issues
-            # let higher levels handle
-            raise TypeError(other)
-
-        return other
-
     def should_store(self, value):
         return issubclass(
             value.dtype.type, np.timedelta64
@@ -2555,9 +2551,12 @@ def to_native_types(self, slicer=None, na_rep=None, quoting=None, **kwargs):
         )
         return rvalues
 
-    def external_values(self, dtype=None):
+    def external_values(self):
         return np.asarray(self.values.astype("timedelta64[ns]", copy=False))
 
+    def array_values(self) -> ExtensionArray:
+        return TimedeltaArray._simple_new(self.values)
+
 
 class BoolBlock(NumericBlock):
     __slots__ = ()
@@ -2661,31 +2660,12 @@ def _maybe_downcast(self, blocks: List["Block"], downcast=None) -> List["Block"]
     def _can_hold_element(self, element: Any) -> bool:
         return True
 
-    def _try_coerce_args(self, other):
-        """ provide coercion to our input arguments """
-
-        if isinstance(other, ABCDatetimeIndex):
-            # May get a DatetimeIndex here. Unbox it.
-            other = other.array
-
-        if isinstance(other, DatetimeArray):
-            # hit in pandas/tests/indexing/test_coercion.py
-            # ::TestWhereCoercion::test_where_series_datetime64[datetime64tz]
-            # when falling back to ObjectBlock.where
-            other = other.astype(object)
-
-        return other
-
     def should_store(self, value):
         return not (
             issubclass(
                 value.dtype.type,
                 (np.integer, np.floating, np.complexfloating, np.datetime64, np.bool_),
             )
-            or
-            # TODO(ExtensionArray): remove is_extension_type
-            # when all extension arrays have been ported.
-            is_extension_type(value)
             or is_extension_array_dtype(value)
         )
 
@@ -2907,6 +2887,8 @@ def _replace_coerce(
             if convert:
                 block = [b.convert(numeric=False, copy=True) for b in block]
             return block
+        if convert:
+            return [self.convert(numeric=False, copy=True)]
         return self
 
 
@@ -2975,36 +2957,29 @@ def concat_same_type(self, to_concat, placement=None):
             values, placement=placement or slice(0, len(values), 1), ndim=self.ndim
         )
 
-    def where(
+    def replace(
         self,
-        other,
-        cond,
-        align=True,
-        errors="raise",
-        try_cast: bool = False,
-        axis: int = 0,
-    ) -> List["Block"]:
-        # TODO(CategoricalBlock.where):
-        # This can all be deleted in favor of ExtensionBlock.where once
-        # we enforce the deprecation.
-        object_msg = (
-            "Implicitly converting categorical to object-dtype ndarray. "
-            "One or more of the values in 'other' are not present in this "
-            "categorical's categories. A future version of pandas will raise "
-            "a ValueError when 'other' contains different categories.\n\n"
-            "To preserve the current behavior, add the new categories to "
-            "the categorical before calling 'where', or convert the "
-            "categorical to a different dtype."
-        )
-        try:
-            # Attempt to do preserve categorical dtype.
-            result = super().where(other, cond, align, errors, try_cast, axis)
-        except (TypeError, ValueError):
-            warnings.warn(object_msg, FutureWarning, stacklevel=6)
-            result = self.astype(object).where(
-                other, cond, align=align, errors=errors, try_cast=try_cast, axis=axis
+        to_replace,
+        value,
+        inplace: bool = False,
+        filter=None,
+        regex: bool = False,
+        convert: bool = True,
+    ):
+        inplace = validate_bool_kwarg(inplace, "inplace")
+        result = self if inplace else self.copy()
+        if filter is None:  # replace was called on a series
+            result.values.replace(to_replace, value, inplace=True)
+            if convert:
+                return result.convert(numeric=False, copy=not inplace)
+            else:
+                return result
+        else:  # replace was called on a DataFrame
+            if not isna(value):
+                result.values.add_categories(value, inplace=True)
+            return super(CategoricalBlock, result).replace(
+                to_replace, value, inplace, filter, regex, convert
             )
-        return result
 
 
 # -----------------------------------------------------------------
@@ -3057,7 +3032,7 @@ def get_block_type(values, dtype=None):
     return cls
 
 
-def make_block(values, placement, klass=None, ndim=None, dtype=None, fastpath=None):
+def make_block(values, placement, klass=None, ndim=None, dtype=None):
     # Ensure that we don't allow PandasArray / PandasDtype in internals.
     # For now, blocks should be backed by ndarrays when possible.
     if isinstance(values, ABCPandasArray):
@@ -3068,12 +3043,6 @@ def make_block(values, placement, klass=None, ndim=None, dtype=None, fastpath=No
     if isinstance(dtype, PandasDtype):
         dtype = dtype.numpy_dtype
 
-    if fastpath is not None:
-        # GH#19265 pyarrow is passing this
-        warnings.warn(
-            "fastpath argument is deprecated, will be removed in a future release.",
-            FutureWarning,
-        )
     if klass is None:
         dtype = dtype or values.dtype
         klass = get_block_type(values, dtype)
@@ -3090,8 +3059,7 @@ def make_block(values, placement, klass=None, ndim=None, dtype=None, fastpath=No
 
 
 def _extend_blocks(result, blocks=None):
-    """ return a new extended blocks, givin the result """
-    from pandas.core.internals import BlockManager
+    """ return a new extended blocks, given the result """
 
     if blocks is None:
         blocks = []
@@ -3101,9 +3069,8 @@ def _extend_blocks(result, blocks=None):
                 blocks.extend(r)
             else:
                 blocks.append(r)
-    elif isinstance(result, BlockManager):
-        blocks.extend(result.blocks)
     else:
+        assert isinstance(result, Block), type(result)
         blocks.append(result)
     return blocks
 
@@ -3131,7 +3098,6 @@ def _merge_blocks(blocks, dtype=None, _can_consolidate=True):
         if dtype is None:
             if len({b.dtype for b in blocks}) != 1:
                 raise AssertionError("_merge_blocks are invalid!")
-            dtype = blocks[0].dtype
 
         # FIXME: optimization potential in case all mgrs contain slices and
         # combination of those slices is a slice, too.
@@ -3245,7 +3211,7 @@ def _putmask_preserve(nv, n):
     # change the dtype if needed
     dtype, _ = maybe_promote(n.dtype)
 
-    if is_extension_type(v.dtype) and is_object_dtype(dtype):
+    if is_extension_array_dtype(v.dtype) and is_object_dtype(dtype):
         v = v._internal_get_values(dtype)
     else:
         v = v.astype(dtype)
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 121c61d8d3623..c75373b82305c 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -61,9 +61,7 @@ def get_mgr_concatenation_plan(mgr, indexers):
         blklocs = mgr._blklocs
 
     plan = []
-    for blkno, placements in libinternals.get_blkno_placements(
-        blknos, mgr.nblocks, group=False
-    ):
+    for blkno, placements in libinternals.get_blkno_placements(blknos, group=False):
 
         assert placements.is_slice_like
 
@@ -122,10 +120,8 @@ def __init__(self, block, shape, indexers=None):
         self.indexers = indexers
         self.shape = shape
 
-    def __repr__(self):
-        return "{name}({block!r}, {indexers})".format(
-            name=self.__class__.__name__, block=self.block, indexers=self.indexers
-        )
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({repr(self.block)}, {self.indexers})"
 
     @cache_readonly
     def needs_filling(self):
@@ -199,7 +195,6 @@ def get_reindexed_values(self, empty_dtype, upcasted_na):
                         return array(
                             np.full(self.shape[1], fill_value.value), dtype=empty_dtype
                         )
-                    pass
                 elif getattr(self.block, "is_categorical", False):
                     pass
                 elif getattr(self.block, "is_extension", False):
@@ -246,7 +241,7 @@ def concatenate_join_units(join_units, concat_axis, copy):
         # Concatenating join units along ax0 is handled in _merge_blocks.
         raise AssertionError("Concatenating join units along axis0")
 
-    empty_dtype, upcasted_na = get_empty_dtype_and_na(join_units)
+    empty_dtype, upcasted_na = _get_empty_dtype_and_na(join_units)
 
     to_concat = [
         ju.get_reindexed_values(empty_dtype=empty_dtype, upcasted_na=upcasted_na)
@@ -270,7 +265,7 @@ def concatenate_join_units(join_units, concat_axis, copy):
     return concat_values
 
 
-def get_empty_dtype_and_na(join_units):
+def _get_empty_dtype_and_na(join_units):
     """
     Return dtype and N/A values to use when concatenating specified units.
 
@@ -286,8 +281,8 @@ def get_empty_dtype_and_na(join_units):
         if blk is None:
             return np.float64, np.nan
 
-    if is_uniform_reindex(join_units):
-        # XXX: integrate property
+    if _is_uniform_reindex(join_units):
+        # FIXME: integrate property
         empty_dtype = join_units[0].block.dtype
         upcasted_na = join_units[0].block.fill_value
         return empty_dtype, upcasted_na
@@ -338,6 +333,7 @@ def get_empty_dtype_and_na(join_units):
     if not upcast_classes:
         upcast_classes = null_upcast_classes
 
+    # TODO: de-duplicate with maybe_promote?
     # create the result
     if "object" in upcast_classes:
         return np.dtype(np.object_), np.nan
@@ -354,9 +350,9 @@ def get_empty_dtype_and_na(join_units):
         dtype = upcast_classes["datetimetz"]
         return dtype[0], tslibs.NaT
     elif "datetime" in upcast_classes:
-        return np.dtype("M8[ns]"), tslibs.iNaT
+        return np.dtype("M8[ns]"), np.datetime64("NaT", "ns")
     elif "timedelta" in upcast_classes:
-        return np.dtype("m8[ns]"), tslibs.iNaT
+        return np.dtype("m8[ns]"), np.timedelta64("NaT", "ns")
     else:  # pragma
         try:
             g = np.find_common_type(upcast_classes, [])
@@ -399,7 +395,7 @@ def is_uniform_join_units(join_units):
     )
 
 
-def is_uniform_reindex(join_units):
+def _is_uniform_reindex(join_units) -> bool:
     return (
         # TODO: should this be ju.block._can_hold_na?
         all(ju.block and ju.block.is_extension for ju in join_units)
@@ -407,7 +403,7 @@ def is_uniform_reindex(join_units):
     )
 
 
-def trim_join_unit(join_unit, length):
+def _trim_join_unit(join_unit, length):
     """
     Reduce join_unit's shape along item axis to length.
 
@@ -487,9 +483,9 @@ def _next_or_none(seq):
                 for i, (plc, unit) in enumerate(next_items):
                     yielded_units[i] = unit
                     if len(plc) > min_len:
-                        # trim_join_unit updates unit in place, so only
+                        # _trim_join_unit updates unit in place, so only
                         # placement needs to be sliced to skip min_len.
-                        next_items[i] = (plc[min_len:], trim_join_unit(unit, min_len))
+                        next_items[i] = (plc[min_len:], _trim_join_unit(unit, min_len))
                     else:
                         yielded_placement = plc
                         next_items[i] = _next_or_none(plans[i])
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 3126b9d9d3e2e..798386825d802 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -2,14 +2,12 @@
 Functions for preparing various inputs passed to the DataFrame or Series
 constructors before passing them to a BlockManager.
 """
-from collections import OrderedDict, abc
+from collections import abc
 
 import numpy as np
 import numpy.ma as ma
 
 from pandas._libs import lib
-import pandas.compat as compat
-from pandas.compat import PY36, raise_with_traceback
 
 from pandas.core.dtypes.cast import (
     construct_1d_arraylike_from_scalar,
@@ -39,13 +37,13 @@
 from pandas.core import algorithms, common as com
 from pandas.core.arrays import Categorical
 from pandas.core.construction import sanitize_array
-from pandas.core.index import (
+from pandas.core.indexes import base as ibase
+from pandas.core.indexes.api import (
     Index,
-    _get_objs_combined_axis,
-    _union_indexes,
     ensure_index,
+    get_objs_combined_axis,
+    union_indexes,
 )
-from pandas.core.indexes import base as ibase
 from pandas.core.internals import (
     create_block_manager_from_arrays,
     create_block_manager_from_blocks,
@@ -76,7 +74,7 @@ def arrays_to_mgr(arrays, arr_names, index, columns, dtype=None):
     return create_block_manager_from_arrays(arrays, arr_names, axes)
 
 
-def masked_rec_array_to_mgr(data, index, columns, dtype, copy):
+def masked_rec_array_to_mgr(data, index, columns, dtype, copy: bool):
     """
     Extract from a masked rec array and create the manager.
     """
@@ -97,6 +95,9 @@ def masked_rec_array_to_mgr(data, index, columns, dtype, copy):
     # fill if needed
     new_arrays = []
     for fv, arr, col in zip(fill_value, arrays, arr_columns):
+        # TODO: numpy docs suggest fv must be scalar, but could it be
+        #  non-scalar for object dtype?
+        assert lib.is_scalar(fv), fv
         mask = ma.getmaskarray(data[col])
         if mask.any():
             arr, fv = maybe_upcast(arr, fill_value=fv, copy=True)
@@ -142,33 +143,40 @@ def init_ndarray(values, index, columns, dtype=None, copy=False):
     ):
 
         if not hasattr(values, "dtype"):
-            values = prep_ndarray(values, copy=copy)
+            values = _prep_ndarray(values, copy=copy)
             values = values.ravel()
         elif copy:
             values = values.copy()
 
         index, columns = _get_axes(len(values), 1, index, columns)
         return arrays_to_mgr([values], columns, index, columns, dtype=dtype)
-    elif is_extension_array_dtype(values):
+    elif is_extension_array_dtype(values) or is_extension_array_dtype(dtype):
         # GH#19157
+
+        if isinstance(values, np.ndarray) and values.ndim > 1:
+            # GH#12513 a EA dtype passed with a 2D array, split into
+            #  multiple EAs that view the values
+            values = [values[:, n] for n in range(values.shape[1])]
+        else:
+            values = [values]
+
         if columns is None:
-            columns = [0]
-        return arrays_to_mgr([values], columns, index, columns, dtype=dtype)
+            columns = list(range(len(values)))
+        return arrays_to_mgr(values, columns, index, columns, dtype=dtype)
 
     # by definition an array here
     # the dtypes will be coerced to a single dtype
-    values = prep_ndarray(values, copy=copy)
+    values = _prep_ndarray(values, copy=copy)
 
     if dtype is not None:
         if not is_dtype_equal(values.dtype, dtype):
             try:
                 values = values.astype(dtype)
             except Exception as orig:
-                e = ValueError(
-                    "failed to cast to '{dtype}' (Exception "
-                    "was: {orig})".format(dtype=dtype, orig=orig)
-                )
-                raise_with_traceback(e)
+                # e.g. ValueError when trying to cast object dtype to float64
+                raise ValueError(
+                    f"failed to cast to '{dtype}' (Exception was: {orig})"
+                ) from orig
 
     index, columns = _get_axes(*values.shape, index=index, columns=columns)
     values = values.T
@@ -232,7 +240,7 @@ def init_dict(data, index, columns, dtype=None):
             arrays.loc[missing] = [val] * missing.sum()
 
     else:
-        keys = com.dict_keys_to_ordered_list(data)
+        keys = list(data.keys())
         columns = data_names = Index(keys)
         arrays = (com.maybe_iterable_to_list(data[k]) for k in keys)
         # GH#24096 need copy to be deep for datetime64tz case
@@ -249,10 +257,13 @@ def init_dict(data, index, columns, dtype=None):
 # ---------------------------------------------------------------------
 
 
-def prep_ndarray(values, copy=True):
+def _prep_ndarray(values, copy: bool = True) -> np.ndarray:
     if not isinstance(values, (np.ndarray, ABCSeries, Index)):
         if len(values) == 0:
             return np.empty((0, 0), dtype=object)
+        elif isinstance(values, range):
+            arr = np.arange(values.start, values.stop, values.step, dtype="int64")
+            return arr[..., np.newaxis]
 
         def convert(v):
             return maybe_convert_platform(v)
@@ -328,7 +339,6 @@ def extract_index(data):
         have_raw_arrays = False
         have_series = False
         have_dicts = False
-        have_ordered = False
 
         for val in data:
             if isinstance(val, ABCSeries):
@@ -336,8 +346,6 @@ def extract_index(data):
                 indexes.append(val.index)
             elif isinstance(val, dict):
                 have_dicts = True
-                if isinstance(val, OrderedDict):
-                    have_ordered = True
                 indexes.append(list(val.keys()))
             elif is_list_like(val) and getattr(val, "ndim", 1) == 1:
                 have_raw_arrays = True
@@ -347,9 +355,9 @@ def extract_index(data):
             raise ValueError("If using all scalar values, you must pass an index")
 
         if have_series:
-            index = _union_indexes(indexes)
+            index = union_indexes(indexes)
         elif have_dicts:
-            index = _union_indexes(indexes, sort=not (compat.PY36 or have_ordered))
+            index = union_indexes(indexes, sort=False)
 
         if have_raw_arrays:
             lengths = list(set(raw_lengths))
@@ -364,8 +372,8 @@ def extract_index(data):
             if have_series:
                 if lengths[0] != len(index):
                     msg = (
-                        "array length {length} does not match index "
-                        "length {idx_len}".format(length=lengths[0], idx_len=len(index))
+                        f"array length {lengths[0]} does not match index "
+                        f"length {len(index)}"
                     )
                     raise ValueError(msg)
             else:
@@ -400,7 +408,7 @@ def get_names_from_index(data):
         if n is not None:
             index[i] = n
         else:
-            index[i] = "Unnamed {count}".format(count=count)
+            index[i] = f"Unnamed {count}"
             count += 1
 
     return index
@@ -495,7 +503,9 @@ def _list_to_arrays(data, columns, coerce_float=False, dtype=None):
 
 def _list_of_series_to_arrays(data, columns, coerce_float=False, dtype=None):
     if columns is None:
-        columns = _get_objs_combined_axis(data, sort=False)
+        # We know pass_data is non-empty because data[0] is a Series
+        pass_data = [x for x in data if isinstance(x, (ABCSeries, ABCDataFrame))]
+        columns = get_objs_combined_axis(pass_data, sort=False)
 
     indexer_cache = {}
 
@@ -528,7 +538,7 @@ def _list_of_dict_to_arrays(data, columns, coerce_float=False, dtype=None):
     """Convert list of dicts to numpy arrays
 
     if `columns` is not passed, column names are inferred from the records
-    - for OrderedDict and (on Python>=3.6) dicts, the column names match
+    - for OrderedDict and dicts, the column names match
       the key insertion-order from the first record to the last.
     - For other kinds of dict-likes, the keys are lexically sorted.
 
@@ -545,10 +555,10 @@ def _list_of_dict_to_arrays(data, columns, coerce_float=False, dtype=None):
     tuple
         arrays, columns
     """
+
     if columns is None:
         gen = (list(x.keys()) for x in data)
-        types = (dict, OrderedDict) if PY36 else OrderedDict
-        sort = not any(isinstance(d, types) for d in data)
+        sort = not any(isinstance(d, dict) for d in data)
         columns = lib.fast_unique_multiple_list_gen(gen, sort=sort)
 
     # assure that they are of the base dict class and not of derived
@@ -568,8 +578,8 @@ def _convert_object_array(content, columns, coerce_float=False, dtype=None):
         if len(columns) != len(content):  # pragma: no cover
             # caller's responsibility to check for this...
             raise AssertionError(
-                "{col:d} columns passed, passed data had "
-                "{con} columns".format(col=len(columns), con=len(content))
+                f"{len(columns)} columns passed, passed data had "
+                f"{len(content)} columns"
             )
 
     # provide soft conversion of object dtypes
@@ -588,29 +598,24 @@ def convert(arr):
 # Series-Based
 
 
-def sanitize_index(data, index, copy=False):
+def sanitize_index(data, index: Index):
     """
     Sanitize an index type to return an ndarray of the underlying, pass
     through a non-Index.
     """
 
-    if index is None:
-        return data
-
     if len(data) != len(index):
         raise ValueError("Length of values does not match length of index")
 
-    if isinstance(data, ABCIndexClass) and not copy:
+    if isinstance(data, ABCIndexClass):
         pass
     elif isinstance(data, (ABCPeriodIndex, ABCDatetimeIndex)):
         data = data._values
-        if copy:
-            data = data.copy()
 
     elif isinstance(data, np.ndarray):
 
         # coerce datetimelike types
         if data.dtype.kind in ["M", "m"]:
-            data = sanitize_array(data, index, copy=copy)
+            data = sanitize_array(data, index, copy=False)
 
     return data
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 1c31542daa5de..08ae0b02169d4 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -3,7 +3,7 @@
 import itertools
 import operator
 import re
-from typing import List, Optional, Sequence, Tuple, Union
+from typing import Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
@@ -20,7 +20,6 @@
     _NS_DTYPE,
     is_datetimelike_v_numeric,
     is_extension_array_dtype,
-    is_extension_type,
     is_list_like,
     is_numeric_v_string_like,
     is_scalar,
@@ -33,12 +32,9 @@
 
 import pandas.core.algorithms as algos
 from pandas.core.base import PandasObject
-from pandas.core.index import Index, MultiIndex, ensure_index
 from pandas.core.indexers import maybe_convert_indices
-
-from pandas.io.formats.printing import pprint_thing
-
-from .blocks import (
+from pandas.core.indexes.api import Index, MultiIndex, ensure_index
+from pandas.core.internals.blocks import (
     Block,
     CategoricalBlock,
     DatetimeTZBlock,
@@ -50,13 +46,15 @@
     get_block_type,
     make_block,
 )
-from .concat import (  # all for concatenate_block_managers
+from pandas.core.internals.concat import (  # all for concatenate_block_managers
     combine_concat_plans,
     concatenate_join_units,
     get_mgr_concatenation_plan,
     is_uniform_join_units,
 )
 
+from pandas.io.formats.printing import pprint_thing
+
 # TODO: flexible with index=None and/or items=None
 
 
@@ -82,9 +80,7 @@ class BlockManager(PandasObject):
     copy(deep=True)
 
     get_dtype_counts
-    get_ftype_counts
     get_dtypes
-    get_ftypes
 
     apply(func, axes, block_filter_fn)
 
@@ -130,13 +126,13 @@ def __init__(
         do_integrity_check: bool = True,
     ):
         self.axes = [ensure_index(ax) for ax in axes]
-        self.blocks = tuple(blocks)  # type: Tuple[Block, ...]
+        self.blocks: Tuple[Block, ...] = tuple(blocks)
 
         for block in blocks:
             if self.ndim != block.ndim:
                 raise AssertionError(
-                    "Number of Block dimensions ({block}) must equal "
-                    "number of axes ({self})".format(block=block.ndim, self=self.ndim)
+                    f"Number of Block dimensions ({block.ndim}) must equal "
+                    f"number of axes ({self.ndim})"
                 )
 
         if do_integrity_check:
@@ -156,7 +152,7 @@ def make_empty(self, axes=None):
             blocks = np.array([], dtype=self.array_dtype)
         else:
             blocks = []
-        return self.__class__(blocks, axes)
+        return type(self)(blocks, axes)
 
     def __nonzero__(self):
         return True
@@ -169,7 +165,7 @@ def shape(self):
         return tuple(len(ax) for ax in self.axes)
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         return len(self.axes)
 
     def set_axis(self, axis, new_labels):
@@ -179,13 +175,13 @@ def set_axis(self, axis, new_labels):
 
         if new_len != old_len:
             raise ValueError(
-                "Length mismatch: Expected axis has {old} elements, new "
-                "values have {new} elements".format(old=old_len, new=new_len)
+                f"Length mismatch: Expected axis has {old_len} elements, new "
+                f"values have {new_len} elements"
             )
 
         self.axes[axis] = new_labels
 
-    def rename_axis(self, mapper, axis, copy=True, level=None):
+    def rename_axis(self, mapper, axis, copy: bool = True, level=None):
         """
         Rename one of axes.
 
@@ -193,7 +189,7 @@ def rename_axis(self, mapper, axis, copy=True, level=None):
         ----------
         mapper : unary callable
         axis : int
-        copy : boolean, default True
+        copy : bool, default True
         level : int, default None
         """
         obj = self.copy(deep=copy)
@@ -201,7 +197,7 @@ def rename_axis(self, mapper, axis, copy=True, level=None):
         return obj
 
     @property
-    def _is_single_block(self):
+    def _is_single_block(self) -> bool:
         if self.ndim == 1:
             return True
 
@@ -249,21 +245,14 @@ def _get_counts(self, f):
     def get_dtype_counts(self):
         return self._get_counts(lambda b: b.dtype.name)
 
-    def get_ftype_counts(self):
-        return self._get_counts(lambda b: b.ftype)
-
     def get_dtypes(self):
         dtypes = np.array([blk.dtype for blk in self.blocks])
         return algos.take_1d(dtypes, self._blknos, allow_fill=False)
 
-    def get_ftypes(self):
-        ftypes = np.array([blk.ftype for blk in self.blocks])
-        return algos.take_1d(ftypes, self._blknos, allow_fill=False)
-
     def __getstate__(self):
         block_values = [b.values for b in self.blocks]
         block_items = [self.items[b.mgr_locs.indexer] for b in self.blocks]
-        axes_array = [ax for ax in self.axes]
+        axes_array = list(self.axes)
 
         extra_state = {
             "0.14.1": {
@@ -290,30 +279,7 @@ def unpickle_block(values, mgr_locs):
                 unpickle_block(b["values"], b["mgr_locs"]) for b in state["blocks"]
             )
         else:
-            # discard anything after 3rd, support beta pickling format for a
-            # little while longer
-            ax_arrays, bvalues, bitems = state[:3]
-
-            self.axes = [ensure_index(ax) for ax in ax_arrays]
-
-            if len(bitems) == 1 and self.axes[0].equals(bitems[0]):
-                # This is a workaround for pre-0.14.1 pickles that didn't
-                # support unpickling multi-block frames/panels with non-unique
-                # columns/items, because given a manager with items ["a", "b",
-                # "a"] there's no way of knowing which block's "a" is where.
-                #
-                # Single-block case can be supported under the assumption that
-                # block items corresponded to manager items 1-to-1.
-                all_mgr_locs = [slice(0, len(bitems[0]))]
-            else:
-                all_mgr_locs = [
-                    self.axes[0].get_indexer(blk_items) for blk_items in bitems
-                ]
-
-            self.blocks = tuple(
-                unpickle_block(values, mgr_locs)
-                for values, mgr_locs in zip(bvalues, all_mgr_locs)
-            )
+            raise NotImplementedError("pre-0.14.1 pickles are no longer supported")
 
         self._post_setstate()
 
@@ -322,19 +288,19 @@ def _post_setstate(self):
         self._known_consolidated = False
         self._rebuild_blknos_and_blklocs()
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.items)
 
-    def __repr__(self):
-        output = pprint_thing(self.__class__.__name__)
+    def __repr__(self) -> str:
+        output = type(self).__name__
         for i, ax in enumerate(self.axes):
             if i == 0:
-                output += "\nItems: {ax}".format(ax=ax)
+                output += f"\nItems: {ax}"
             else:
-                output += "\nAxis {i}: {ax}".format(i=i, ax=ax)
+                output += f"\nAxis {i}: {ax}"
 
         for block in self.blocks:
-            output += "\n{block}".format(block=pprint_thing(block))
+            output += f"\n{pprint_thing(block)}"
         return output
 
     def _verify_integrity(self):
@@ -346,37 +312,50 @@ def _verify_integrity(self):
         if len(self.items) != tot_items:
             raise AssertionError(
                 "Number of manager items must equal union of "
-                "block items\n# manager items: {0}, # "
-                "tot_items: {1}".format(len(self.items), tot_items)
+                f"block items\n# manager items: {len(self.items)}, # "
+                f"tot_items: {tot_items}"
             )
 
-    def apply(
-        self,
-        f,
-        axes=None,
-        filter=None,
-        do_integrity_check=False,
-        consolidate=True,
-        **kwargs
-    ):
+    def reduce(self, func, *args, **kwargs):
+        # If 2D, we assume that we're operating column-wise
+        if self.ndim == 1:
+            # we'll be returning a scalar
+            blk = self.blocks[0]
+            return func(blk.values, *args, **kwargs)
+
+        res = {}
+        for blk in self.blocks:
+            bres = func(blk.values, *args, **kwargs)
+
+            if np.ndim(bres) == 0:
+                # EA
+                assert blk.shape[0] == 1
+                new_res = zip(blk.mgr_locs.as_array, [bres])
+            else:
+                assert bres.ndim == 1, bres.shape
+                assert blk.shape[0] == len(bres), (blk.shape, bres.shape, args, kwargs)
+                new_res = zip(blk.mgr_locs.as_array, bres)
+
+            nr = dict(new_res)
+            assert not any(key in res for key in nr)
+            res.update(nr)
+
+        return res
+
+    def apply(self, f, filter=None, **kwargs):
         """
-        iterate over the blocks, collect and create a new block manager
+        Iterate over the blocks, collect and create a new BlockManager.
 
         Parameters
         ----------
-        f : the callable or function name to operate on at the block level
-        axes : optional (if not supplied, use self.axes)
+        f : str or callable
+            Name of the Block method to apply.
         filter : list, if supplied, only call the block if the filter is in
                  the block
-        do_integrity_check : boolean, default False. Do the block manager
-            integrity check
-        consolidate: boolean, default True. Join together blocks having same
-            dtype
 
         Returns
         -------
-        Block Manager (new object)
-
+        BlockManager
         """
 
         result_blocks = []
@@ -390,8 +369,7 @@ def apply(
             else:
                 kwargs["filter"] = filter_locs
 
-        if consolidate:
-            self._consolidate_inplace()
+        self._consolidate_inplace()
 
         if f == "where":
             align_copy = True
@@ -432,18 +410,18 @@ def apply(
                 b_items = self.items[b.mgr_locs.indexer]
 
                 for k, obj in aligned_args.items():
-                    axis = getattr(obj, "_info_axis_number", 0)
+                    axis = obj._info_axis_number
                     kwargs[k] = obj.reindex(b_items, axis=axis, copy=align_copy)
 
-            applied = getattr(b, f)(**kwargs)
+            if callable(f):
+                applied = b.apply(f, **kwargs)
+            else:
+                applied = getattr(b, f)(**kwargs)
             result_blocks = _extend_blocks(applied, result_blocks)
 
         if len(result_blocks) == 0:
-            return self.make_empty(axes or self.axes)
-        bm = self.__class__(
-            result_blocks, axes or self.axes, do_integrity_check=do_integrity_check
-        )
-        bm._consolidate_inplace()
+            return self.make_empty(self.axes)
+        bm = type(self)(result_blocks, self.axes, do_integrity_check=False)
         return bm
 
     def quantile(
@@ -463,9 +441,9 @@ def quantile(
         Parameters
         ----------
         axis: reduction axis, default 0
-        consolidate: boolean, default True. Join together blocks having same
+        consolidate: bool, default True. Join together blocks having same
             dtype
-        transposed: boolean, default False
+        transposed: bool, default False
             we are holding transposed data
         interpolation : type of interpolation, default 'linear'
         qs : a scalar or list of the quantiles to be computed
@@ -529,7 +507,7 @@ def get_axe(block, qs, axes):
                     for b in blocks
                 ]
 
-            return self.__class__(blocks, new_axes)
+            return type(self)(blocks, new_axes)
 
         # single block, i.e. ndim == {1}
         values = concat_compat([b.values for b in blocks])
@@ -547,11 +525,13 @@ def get_axe(block, qs, axes):
             values = values.take(indexer)
 
         return SingleBlockManager(
-            [make_block(values, ndim=1, placement=np.arange(len(values)))], axes[0]
+            make_block(values, ndim=1, placement=np.arange(len(values))),
+            axes[0],
+            fastpath=True,
         )
 
-    def isna(self, func, **kwargs):
-        return self.apply("apply", func=func, **kwargs)
+    def isna(self, func):
+        return self.apply("apply", func=func)
 
     def where(self, **kwargs):
         return self.apply("where", **kwargs)
@@ -577,8 +557,8 @@ def fillna(self, **kwargs):
     def downcast(self, **kwargs):
         return self.apply("downcast", **kwargs)
 
-    def astype(self, dtype, **kwargs):
-        return self.apply("astype", dtype=dtype, **kwargs)
+    def astype(self, dtype, copy: bool = False, errors: str = "raise"):
+        return self.apply("astype", dtype=dtype, copy=copy, errors=errors)
 
     def convert(self, **kwargs):
         return self.apply("convert", **kwargs)
@@ -632,14 +612,14 @@ def comp(s, regex=False):
                         convert=convert,
                         regex=regex,
                     )
-                    if m.any():
+                    if m.any() or convert:
                         new_rb = _extend_blocks(result, new_rb)
                     else:
                         new_rb.append(b)
                 rb = new_rb
             result_blocks.extend(rb)
 
-        bm = self.__class__(result_blocks, self.axes)
+        bm = type(self)(result_blocks, self.axes)
         bm._consolidate_inplace()
         return bm
 
@@ -657,30 +637,24 @@ def _consolidate_check(self):
         self._known_consolidated = True
 
     @property
-    def is_mixed_type(self):
+    def is_mixed_type(self) -> bool:
         # Warning, consolidation needs to get checked upstairs
         self._consolidate_inplace()
         return len(self.blocks) > 1
 
     @property
-    def is_numeric_mixed_type(self):
+    def is_numeric_mixed_type(self) -> bool:
         # Warning, consolidation needs to get checked upstairs
         self._consolidate_inplace()
         return all(block.is_numeric for block in self.blocks)
 
     @property
-    def is_datelike_mixed_type(self):
-        # Warning, consolidation needs to get checked upstairs
-        self._consolidate_inplace()
-        return any(block.is_datelike for block in self.blocks)
-
-    @property
-    def any_extension_types(self):
+    def any_extension_types(self) -> bool:
         """Whether any of the blocks in this manager are extension blocks"""
         return any(block.is_extension for block in self.blocks)
 
     @property
-    def is_view(self):
+    def is_view(self) -> bool:
         """ return a boolean if we are a single block and are a view """
         if len(self.blocks) == 1:
             return self.blocks[0].is_view
@@ -694,21 +668,21 @@ def is_view(self):
 
         return False
 
-    def get_bool_data(self, copy=False):
+    def get_bool_data(self, copy: bool = False):
         """
         Parameters
         ----------
-        copy : boolean, default False
+        copy : bool, default False
             Whether to copy the blocks
         """
         self._consolidate_inplace()
         return self.combine([b for b in self.blocks if b.is_bool], copy)
 
-    def get_numeric_data(self, copy=False):
+    def get_numeric_data(self, copy: bool = False):
         """
         Parameters
         ----------
-        copy : boolean, default False
+        copy : bool, default False
             Whether to copy the blocks
         """
         self._consolidate_inplace()
@@ -734,32 +708,32 @@ def combine(self, blocks, copy=True):
         axes = list(self.axes)
         axes[0] = self.items.take(indexer)
 
-        return self.__class__(new_blocks, axes, do_integrity_check=False)
+        return type(self)(new_blocks, axes, do_integrity_check=False)
 
-    def get_slice(self, slobj, axis=0):
+    def get_slice(self, slobj: slice, axis: int = 0):
         if axis >= self.ndim:
             raise IndexError("Requested axis not found in manager")
 
         if axis == 0:
             new_blocks = self._slice_take_blocks_ax0(slobj)
         else:
-            slicer = [slice(None)] * (axis + 1)
-            slicer[axis] = slobj
-            slicer = tuple(slicer)
+            _slicer = [slice(None)] * (axis + 1)
+            _slicer[axis] = slobj
+            slicer = tuple(_slicer)
             new_blocks = [blk.getitem_block(slicer) for blk in self.blocks]
 
         new_axes = list(self.axes)
         new_axes[axis] = new_axes[axis][slobj]
 
-        bm = self.__class__(new_blocks, new_axes, do_integrity_check=False)
+        bm = type(self)(new_blocks, new_axes, do_integrity_check=False)
         bm._consolidate_inplace()
         return bm
 
-    def __contains__(self, item):
+    def __contains__(self, item) -> bool:
         return item in self.items
 
     @property
-    def nblocks(self):
+    def nblocks(self) -> int:
         return len(self.blocks)
 
     def copy(self, deep=True):
@@ -768,35 +742,40 @@ def copy(self, deep=True):
 
         Parameters
         ----------
-        deep : boolean o rstring, default True
+        deep : bool or string, default True
             If False, return shallow copy (do not copy data)
             If 'all', copy data and a deep copy of the index
 
         Returns
         -------
-        copy : BlockManager
+        BlockManager
         """
         # this preserves the notion of view copying of axes
         if deep:
-            if deep == "all":
-                copy = lambda ax: ax.copy(deep=True)
-            else:
-                copy = lambda ax: ax.view()
-            new_axes = [copy(ax) for ax in self.axes]
+            # hit in e.g. tests.io.json.test_pandas
+
+            def copy_func(ax):
+                if deep == "all":
+                    return ax.copy(deep=True)
+                else:
+                    return ax.view()
+
+            new_axes = [copy_func(ax) for ax in self.axes]
         else:
             new_axes = list(self.axes)
-        return self.apply("copy", axes=new_axes, deep=deep, do_integrity_check=False)
 
-    def as_array(self, transpose=False, items=None):
-        """Convert the blockmanager data into an numpy array.
+        res = self.apply("copy", deep=deep)
+        res.axes = new_axes
+        return res
+
+    def as_array(self, transpose: bool = False) -> np.ndarray:
+        """
+        Convert the blockmanager data into an numpy array.
 
         Parameters
         ----------
-        transpose : boolean, default False
-            If True, transpose the return array
-        items : list of strings or None
-            Names of block items that will be included in the returned
-            array. ``None`` means that all block items will be used
+        transpose : bool, default False
+            If True, transpose the return array,
 
         Returns
         -------
@@ -806,10 +785,7 @@ def as_array(self, transpose=False, items=None):
             arr = np.empty(self.shape, dtype=float)
             return arr.transpose() if transpose else arr
 
-        if items is not None:
-            mgr = self.reindex_axis(items, axis=0)
-        else:
-            mgr = self
+        mgr = self
 
         if self._is_single_block and mgr.blocks[0].is_datetimetz:
             # TODO(Block.get_values): Make DatetimeTZBlock.get_values
@@ -851,13 +827,13 @@ def _interleave(self):
 
         return result
 
-    def to_dict(self, copy=True):
+    def to_dict(self, copy: bool = True):
         """
         Return a dict of str(dtype) -> BlockManager
 
         Parameters
         ----------
-        copy : boolean, default True
+        copy : bool, default True
 
         Returns
         -------
@@ -869,7 +845,7 @@ def to_dict(self, copy=True):
         """
         self._consolidate_inplace()
 
-        bd = {}
+        bd: Dict[str, List[Block]] = {}
         for b in self.blocks:
             bd.setdefault(str(b.dtype), []).append(b)
 
@@ -927,7 +903,7 @@ def consolidate(self):
         if self.is_consolidated():
             return self
 
-        bm = self.__class__(self.blocks, self.axes)
+        bm = type(self)(self.blocks, self.axes)
         bm._is_consolidated = False
         bm._consolidate_inplace()
         return bm
@@ -970,21 +946,18 @@ def get(self, item):
 
     def iget(self, i):
         """
-        Return the data as a SingleBlockManager if possible
-
-        Otherwise return as a ndarray
+        Return the data as a SingleBlockManager.
         """
         block = self.blocks[self._blknos[i]]
         values = block.iget(self._blklocs[i])
 
         # shortcut for select a single-dim from a 2-dim BM
         return SingleBlockManager(
-            [
-                block.make_block_same_class(
-                    values, placement=slice(0, len(values)), ndim=1
-                )
-            ],
+            block.make_block_same_class(
+                values, placement=slice(0, len(values)), ndim=1
+            ),
             self.axes[1],
+            fastpath=True,
         )
 
     def delete(self, item):
@@ -1034,11 +1007,7 @@ def set(self, item, value):
         # FIXME: refactor, clearly separate broadcasting & zip-like assignment
         #        can prob also fix the various if tests for sparse/categorical
 
-        # TODO(EA): Remove an is_extension_ when all extension types satisfy
-        # the interface
-        value_is_extension_type = is_extension_type(value) or is_extension_array_dtype(
-            value
-        )
+        value_is_extension_type = is_extension_array_dtype(value)
 
         # categorical/sparse/datetimetz
         if value_is_extension_type:
@@ -1079,9 +1048,7 @@ def value_getitem(placement):
         unfit_mgr_locs = []
         unfit_val_locs = []
         removed_blknos = []
-        for blkno, val_locs in libinternals.get_blkno_placements(
-            blknos, self.nblocks, group=True
-        ):
+        for blkno, val_locs in libinternals.get_blkno_placements(blknos, group=True):
             blk = self.blocks[blkno]
             blk_locs = blklocs[val_locs.indexer]
             if blk.should_store(value):
@@ -1168,7 +1135,7 @@ def insert(self, loc: int, item, value, allow_duplicates: bool = False):
         """
         if not allow_duplicates and item in self.items:
             # Should this be a different kind of error??
-            raise ValueError("cannot insert {}, already exists".format(item))
+            raise ValueError(f"cannot insert {item}, already exists")
 
         if not isinstance(loc, int):
             raise TypeError("loc must be int")
@@ -1267,7 +1234,7 @@ def reindex_indexer(
 
         new_axes = list(self.axes)
         new_axes[axis] = new_axis
-        return self.__class__(new_blocks, new_axes)
+        return type(self)(new_blocks, new_axes)
 
     def _slice_take_blocks_ax0(self, slice_or_indexer, fill_tuple=None):
         """
@@ -1278,7 +1245,6 @@ def _slice_take_blocks_ax0(self, slice_or_indexer, fill_tuple=None):
         Returns
         -------
         new_blocks : list of Block
-
         """
 
         allow_fill = fill_tuple is not None
@@ -1323,9 +1289,7 @@ def _slice_take_blocks_ax0(self, slice_or_indexer, fill_tuple=None):
         # FIXME: mgr_groupby_blknos must return mgr_locs in ascending order,
         # pytables serialization will break otherwise.
         blocks = []
-        for blkno, mgr_locs in libinternals.get_blkno_placements(
-            blknos, self.nblocks, group=True
-        ):
+        for blkno, mgr_locs in libinternals.get_blkno_placements(blknos, group=True):
             if blkno == -1:
                 # If we've got here, fill_tuple was not None.
                 fill_value = fill_tuple[0]
@@ -1342,7 +1306,7 @@ def _slice_take_blocks_ax0(self, slice_or_indexer, fill_tuple=None):
                     # only one item and each mgr loc is a copy of that single
                     # item.
                     for mgr_loc in mgr_locs:
-                        newblk = blk.copy(deep=True)
+                        newblk = blk.copy(deep=False)
                         newblk.mgr_locs = slice(mgr_loc, mgr_loc + 1)
                         blocks.append(newblk)
 
@@ -1395,7 +1359,7 @@ def take(self, indexer, axis=1, verify=True, convert=True):
             new_axis=new_labels, indexer=indexer, axis=axis, allow_dups=True
         )
 
-    def equals(self, other):
+    def equals(self, other) -> bool:
         self_axes, other_axes = self.axes, other.axes
         if len(self_axes) != len(other_axes):
             return False
@@ -1406,12 +1370,12 @@ def equals(self, other):
         if len(self.blocks) != len(other.blocks):
             return False
 
-        # canonicalize block order, using a tuple combining the type
-        # name and then mgr_locs because there might be unconsolidated
+        # canonicalize block order, using a tuple combining the mgr_locs
+        # then type name because there might be unconsolidated
         # blocks (say, Categorical) which can only be distinguished by
         # the iteration order
         def canonicalize(block):
-            return (block.dtype.name, block.mgr_locs.as_array.tolist())
+            return (block.mgr_locs.as_array.tolist(), block.dtype.name)
 
         self_blocks = sorted(self.blocks, key=canonicalize)
         other_blocks = sorted(other.blocks, key=canonicalize)
@@ -1420,7 +1384,8 @@ def canonicalize(block):
         )
 
     def unstack(self, unstacker_func, fill_value):
-        """Return a blockmanager with all blocks unstacked.
+        """
+        Return a BlockManager with all blocks unstacked..
 
         Parameters
         ----------
@@ -1540,18 +1505,12 @@ def get_slice(self, slobj, axis=0):
         if axis >= self.ndim:
             raise IndexError("Requested axis not found in manager")
 
-        return self.__class__(
-            self._block._slice(slobj), self.index[slobj], fastpath=True
-        )
+        return type(self)(self._block._slice(slobj), self.index[slobj], fastpath=True,)
 
     @property
     def index(self):
         return self.axes[0]
 
-    def convert(self, **kwargs):
-        """ convert the whole block as one """
-        return self.apply("convert", **kwargs)
-
     @property
     def dtype(self):
         return self._block.dtype
@@ -1560,26 +1519,18 @@ def dtype(self):
     def array_dtype(self):
         return self._block.array_dtype
 
-    @property
-    def ftype(self):
-        return self._block.ftype
-
     def get_dtype_counts(self):
         return {self.dtype.name: 1}
 
-    def get_ftype_counts(self):
-        return {self.ftype: 1}
-
     def get_dtypes(self):
         return np.array([self._block.dtype])
 
-    def get_ftypes(self):
-        return np.array([self._block.ftype])
-
     def external_values(self):
+        """The array that Series.values returns"""
         return self._block.external_values()
 
     def internal_values(self):
+        """The array that Series._values returns"""
         return self._block.internal_values()
 
     def get_values(self):
@@ -1587,7 +1538,7 @@ def get_values(self):
         return np.array(self._block.to_dense(), copy=False)
 
     @property
-    def _can_hold_na(self):
+    def _can_hold_na(self) -> bool:
         return self._block._can_hold_na
 
     def is_consolidated(self):
@@ -1614,9 +1565,9 @@ def fast_xs(self, loc):
         fast path for getting a cross-section
         return a view of the data
         """
-        return self._block.values[loc]
+        raise NotImplementedError("Use series._values[loc] instead")
 
-    def concat(self, to_concat, new_axis):
+    def concat(self, to_concat, new_axis) -> "SingleBlockManager":
         """
         Concatenate a list of SingleBlockManagers into a single
         SingleBlockManager.
@@ -1631,7 +1582,6 @@ def concat(self, to_concat, new_axis):
         Returns
         -------
         SingleBlockManager
-
         """
         non_empties = [x for x in to_concat if len(x) > 0]
 
@@ -1708,9 +1658,7 @@ def construction_error(tot_items, block_shape, axes, e=None):
         raise e
     if block_shape[0] == 0:
         raise ValueError("Empty data passed with indices specified.")
-    raise ValueError(
-        "Shape of passed values is {0}, indices imply {1}".format(passed, implied)
-    )
+    raise ValueError(f"Shape of passed values is {passed}, indices imply {implied}")
 
 
 # -----------------------------------------------------------------------
@@ -1872,7 +1820,7 @@ def _shape_compat(x):
 
 
 def _interleaved_dtype(
-    blocks: List[Block]
+    blocks: List[Block],
 ) -> Optional[Union[np.dtype, ExtensionDtype]]:
     """Find the common dtype for `blocks`.
 
@@ -1936,12 +1884,8 @@ def _compare_or_regex_search(a, b, regex=False):
     is_a_array = isinstance(a, np.ndarray)
     is_b_array = isinstance(b, np.ndarray)
 
-    # numpy deprecation warning to have i8 vs integer comparisons
-    if is_datetimelike_v_numeric(a, b):
-        result = False
-
-    # numpy deprecation warning if comparing numeric vs string-like
-    elif is_numeric_v_string_like(a, b):
+    if is_datetimelike_v_numeric(a, b) or is_numeric_v_string_like(a, b):
+        # GH#29553 avoid deprecation warnings from numpy
         result = False
     else:
         result = op(a)
@@ -1950,15 +1894,13 @@ def _compare_or_regex_search(a, b, regex=False):
         type_names = [type(a).__name__, type(b).__name__]
 
         if is_a_array:
-            type_names[0] = "ndarray(dtype={dtype})".format(dtype=a.dtype)
+            type_names[0] = f"ndarray(dtype={a.dtype})"
 
         if is_b_array:
-            type_names[1] = "ndarray(dtype={dtype})".format(dtype=b.dtype)
+            type_names[1] = f"ndarray(dtype={b.dtype})"
 
         raise TypeError(
-            "Cannot compare types {a!r} and {b!r}".format(
-                a=type_names[0], b=type_names[1]
-            )
+            f"Cannot compare types {repr(type_names[0])} and {repr(type_names[1])}"
         )
     return result
 
@@ -2035,7 +1977,7 @@ def concatenate_block_managers(mgrs_indexers, axes, concat_axis, copy):
             values = b.values
             if copy:
                 values = values.copy()
-            elif not copy:
+            else:
                 values = values.view()
             b = b.make_block_same_class(values, placement=placement)
         elif is_uniform_join_units(join_units):
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index bc81fbb7e1ce0..b30a7a24f3495 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -1,6 +1,7 @@
 """
 Routines for filling missing data.
 """
+
 import numpy as np
 
 from pandas._libs import algos, lib
@@ -11,7 +12,6 @@
     ensure_float64,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
-    is_integer,
     is_integer_dtype,
     is_numeric_v_string_like,
     is_scalar,
@@ -40,9 +40,8 @@ def mask_missing(arr, values_to_mask):
     mask = None
     for x in nonna:
         if mask is None:
-
-            # numpy elementwise comparison warning
             if is_numeric_v_string_like(arr, x):
+                # GH#29553 prevent numpy deprecation warnings
                 mask = False
             else:
                 mask = arr == x
@@ -52,9 +51,8 @@ def mask_missing(arr, values_to_mask):
             if is_scalar(mask):
                 mask = np.zeros(arr.shape, dtype=bool)
         else:
-
-            # numpy elementwise comparison warning
             if is_numeric_v_string_like(arr, x):
+                # GH#29553 prevent numpy deprecation warnings
                 mask |= False
             else:
                 mask |= arr == x
@@ -90,10 +88,7 @@ def clean_fill_method(method, allow_nearest=False):
         valid_methods.append("nearest")
         expecting = "pad (ffill), backfill (bfill) or nearest"
     if method not in valid_methods:
-        msg = "Invalid fill method. Expecting {expecting}. Got {method}".format(
-            expecting=expecting, method=method
-        )
-        raise ValueError(msg)
+        raise ValueError(f"Invalid fill method. Expecting {expecting}. Got {method}")
     return method
 
 
@@ -121,14 +116,48 @@ def clean_interp_method(method, **kwargs):
     if method in ("spline", "polynomial") and order is None:
         raise ValueError("You must specify the order of the spline or polynomial.")
     if method not in valid:
-        raise ValueError(
-            "method must be one of {valid}. Got '{method}' "
-            "instead.".format(valid=valid, method=method)
-        )
+        raise ValueError(f"method must be one of {valid}. Got '{method}' instead.")
 
     return method
 
 
+def find_valid_index(values, how: str):
+    """
+    Retrieves the index of the first valid value.
+
+    Parameters
+    ----------
+    values : ndarray or ExtensionArray
+    how : {'first', 'last'}
+        Use this parameter to change between the first or last valid index.
+
+    Returns
+    -------
+    int or None
+    """
+    assert how in ["first", "last"]
+
+    if len(values) == 0:  # early stop
+        return None
+
+    is_valid = ~isna(values)
+
+    if values.ndim == 2:
+        is_valid = is_valid.any(1)  # reduce axis 1
+
+    if how == "first":
+        idxpos = is_valid[::].argmax()
+
+    if how == "last":
+        idxpos = len(values) - 1 - is_valid[::-1].argmax()
+
+    chk_notna = is_valid[idxpos]
+
+    if not chk_notna:
+        return None
+    return idxpos
+
+
 def interpolate_1d(
     xvalues,
     yvalues,
@@ -139,7 +168,7 @@ def interpolate_1d(
     fill_value=None,
     bounds_error=False,
     order=None,
-    **kwargs
+    **kwargs,
 ):
     """
     Logic for the 1-d interpolation.  The result should be 1-d, inputs
@@ -176,9 +205,9 @@ def interpolate_1d(
     valid_limit_directions = ["forward", "backward", "both"]
     limit_direction = limit_direction.lower()
     if limit_direction not in valid_limit_directions:
-        msg = "Invalid limit_direction: expecting one of {valid!r}, got {invalid!r}."
         raise ValueError(
-            msg.format(valid=valid_limit_directions, invalid=limit_direction)
+            "Invalid limit_direction: expecting one of "
+            f"{valid_limit_directions}, got '{limit_direction}'."
         )
 
     if limit_area is not None:
@@ -186,27 +215,17 @@ def interpolate_1d(
         limit_area = limit_area.lower()
         if limit_area not in valid_limit_areas:
             raise ValueError(
-                "Invalid limit_area: expecting one of {}, got "
-                "{}.".format(valid_limit_areas, limit_area)
+                f"Invalid limit_area: expecting one of {valid_limit_areas}, got "
+                f"{limit_area}."
             )
 
     # default limit is unlimited GH #16282
-    if limit is None:
-        # limit = len(xvalues)
-        pass
-    elif not is_integer(limit):
-        raise ValueError("Limit must be an integer")
-    elif limit < 1:
-        raise ValueError("Limit must be greater than 0")
-
-    from pandas import Series
-
-    ys = Series(yvalues)
+    limit = algos._validate_limit(nobs=None, limit=limit)
 
     # These are sets of index pointers to invalid values... i.e. {0, 1, etc...
     all_nans = set(np.flatnonzero(invalid))
-    start_nans = set(range(ys.first_valid_index()))
-    end_nans = set(range(1 + ys.last_valid_index(), len(valid)))
+    start_nans = set(range(find_valid_index(yvalues, "first")))
+    end_nans = set(range(1 + find_valid_index(yvalues, "last"), len(valid)))
     mid_nans = all_nans - start_nans - end_nans
 
     # Like the sets above, preserve_nans contains indices of invalid values,
@@ -252,7 +271,11 @@ def interpolate_1d(
                 inds = lib.maybe_convert_objects(inds)
         else:
             inds = xvalues
-        result[invalid] = np.interp(inds[invalid], inds[valid], yvalues[valid])
+        # np.interp requires sorted X values, #21037
+        indexer = np.argsort(inds[valid])
+        result[invalid] = np.interp(
+            inds[invalid], inds[valid][indexer], yvalues[valid][indexer]
+        )
         result[preserve_nans] = np.nan
         return result
 
@@ -285,7 +308,7 @@ def interpolate_1d(
             fill_value=fill_value,
             bounds_error=bounds_error,
             order=order,
-            **kwargs
+            **kwargs,
         )
         result[preserve_nans] = np.nan
         return result
@@ -299,7 +322,7 @@ def _interpolate_scipy_wrapper(
     Returns an array interpolated at new_x.  Add any new methods to
     the list in _clean_interp_method.
     """
-    extra = "{method} interpolation requires SciPy.".format(method=method)
+    extra = f"{method} interpolation requires SciPy."
     import_optional_dependency("scipy", extra=extra)
     from scipy import interpolate
 
@@ -314,7 +337,7 @@ def _interpolate_scipy_wrapper(
     }
 
     if getattr(x, "is_all_dates", False):
-        # GH 5975, scipy.interp1d can't hande datetime64s
+        # GH 5975, scipy.interp1d can't handle datetime64s
         x, new_x = x._values.astype("i8"), new_x.astype("i8")
 
     if method == "pchip":
@@ -346,8 +369,7 @@ def _interpolate_scipy_wrapper(
         # GH #10633, #24014
         if isna(order) or (order <= 0):
             raise ValueError(
-                "order needs to be specified and greater than 0; "
-                "got order: {}".format(order)
+                f"order needs to be specified and greater than 0; got order: {order}"
             )
         terp = interpolate.UnivariateSpline(x, y, k=order, **kwargs)
         new_y = terp(new_x)
@@ -420,7 +442,7 @@ def _akima_interpolate(xi, yi, x, der=0, axis=0):
     ----------
     xi : array_like
         A sorted list of x-coordinates, of length N.
-    yi :  array_like
+    yi : array_like
         A 1-D array of real values.  `yi`'s length along the interpolation
         axis must be equal to the length of `xi`. If N-D array, use axis
         parameter to select correct axis.
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 4db0f75586ead..2bf2be082f639 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -7,7 +7,8 @@
 
 from pandas._config import get_option
 
-from pandas._libs import iNaT, lib, tslibs
+from pandas._libs import NaT, Timedelta, Timestamp, iNaT, lib
+from pandas._typing import Dtype, Scalar
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.dtypes.cast import _int64_max, maybe_upcast_putmask
@@ -16,7 +17,6 @@
     is_any_int_dtype,
     is_bool_dtype,
     is_complex,
-    is_complex_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
@@ -38,7 +38,7 @@
 _USE_BOTTLENECK = False
 
 
-def set_use_bottleneck(v=True):
+def set_use_bottleneck(v: bool = True) -> None:
     # set/unset to use bottleneck
     global _USE_BOTTLENECK
     if _BOTTLENECK_INSTALLED:
@@ -53,7 +53,7 @@ def __init__(self, *dtypes):
         super().__init__()
         self.dtypes = tuple(pandas_dtype(dtype).type for dtype in dtypes)
 
-    def check(self, obj):
+    def check(self, obj) -> bool:
         return hasattr(obj, "dtype") and issubclass(obj.dtype.type, self.dtypes)
 
     def __call__(self, f):
@@ -61,8 +61,10 @@ def __call__(self, f):
         def _f(*args, **kwargs):
             obj_iter = itertools.chain(args, kwargs.values())
             if any(self.check(obj) for obj in obj_iter):
-                msg = "reduction operation {name!r} not allowed for this dtype"
-                raise TypeError(msg.format(name=f.__name__.replace("nan", "")))
+                f_name = f.__name__.replace("nan", "")
+                raise TypeError(
+                    f"reduction operation '{f_name}' not allowed for this dtype"
+                )
             try:
                 with np.errstate(invalid="ignore"):
                     return f(*args, **kwargs)
@@ -92,22 +94,28 @@ def __call__(self, alt):
             bn_func = None
 
         @functools.wraps(alt)
-        def f(values, axis=None, skipna=True, **kwds):
+        def f(
+            values: np.ndarray, axis: Optional[int] = None, skipna: bool = True, **kwds
+        ):
             if len(self.kwargs) > 0:
                 for k, v in self.kwargs.items():
                     if k not in kwds:
                         kwds[k] = v
-            try:
-                if values.size == 0 and kwds.get("min_count") is None:
-                    # We are empty, returning NA for our type
-                    # Only applies for the default `min_count` of None
-                    # since that affects how empty arrays are handled.
-                    # TODO(GH-18976) update all the nanops methods to
-                    # correctly handle empty inputs and remove this check.
-                    # It *may* just be `var`
-                    return _na_for_min_count(values, axis)
-
-                if _USE_BOTTLENECK and skipna and _bn_ok_dtype(values.dtype, bn_name):
+
+            if values.size == 0 and kwds.get("min_count") is None:
+                # We are empty, returning NA for our type
+                # Only applies for the default `min_count` of None
+                # since that affects how empty arrays are handled.
+                # TODO(GH-18976) update all the nanops methods to
+                # correctly handle empty inputs and remove this check.
+                # It *may* just be `var`
+                return _na_for_min_count(values, axis)
+
+            if _USE_BOTTLENECK and skipna and _bn_ok_dtype(values.dtype, bn_name):
+                if kwds.get("mask", None) is None:
+                    # `mask` is not recognised by bottleneck, would raise
+                    #  TypeError if called
+                    kwds.pop("mask", None)
                     result = bn_func(values, axis=axis, **kwds)
 
                     # prefer to treat inf/-inf as NA, but must compute the func
@@ -116,28 +124,18 @@ def f(values, axis=None, skipna=True, **kwds):
                         result = alt(values, axis=axis, skipna=skipna, **kwds)
                 else:
                     result = alt(values, axis=axis, skipna=skipna, **kwds)
-            except Exception:
-                try:
-                    result = alt(values, axis=axis, skipna=skipna, **kwds)
-                except ValueError as e:
-                    # we want to transform an object array
-                    # ValueError message to the more typical TypeError
-                    # e.g. this is normally a disallowed function on
-                    # object arrays that contain strings
-
-                    if is_object_dtype(values):
-                        raise TypeError(e)
-                    raise
+            else:
+                result = alt(values, axis=axis, skipna=skipna, **kwds)
 
             return result
 
         return f
 
 
-def _bn_ok_dtype(dt, name):
+def _bn_ok_dtype(dtype: Dtype, name: str) -> bool:
     # Bottleneck chokes on datetime64
-    if not is_object_dtype(dt) and not (
-        is_datetime_or_timedelta_dtype(dt) or is_datetime64tz_dtype(dt)
+    if not is_object_dtype(dtype) and not (
+        is_datetime_or_timedelta_dtype(dtype) or is_datetime64tz_dtype(dtype)
     ):
 
         # GH 15507
@@ -155,7 +153,7 @@ def _bn_ok_dtype(dt, name):
     return False
 
 
-def _has_infs(result):
+def _has_infs(result) -> bool:
     if isinstance(result, np.ndarray):
         if result.dtype == "f8":
             return lib.has_infs_f8(result.ravel())
@@ -168,7 +166,9 @@ def _has_infs(result):
         return False
 
 
-def _get_fill_value(dtype, fill_value=None, fill_value_typ=None):
+def _get_fill_value(
+    dtype: Dtype, fill_value: Optional[Scalar] = None, fill_value_typ=None
+):
     """ return the correct fill value for the dtype of the values """
     if fill_value is not None:
         return fill_value
@@ -182,19 +182,22 @@ def _get_fill_value(dtype, fill_value=None, fill_value_typ=None):
                 return -np.inf
     else:
         if fill_value_typ is None:
-            return tslibs.iNaT
+            return iNaT
         else:
             if fill_value_typ == "+inf":
                 # need the max int here
                 return _int64_max
             else:
-                return tslibs.iNaT
+                return iNaT
 
 
 def _maybe_get_mask(
     values: np.ndarray, skipna: bool, mask: Optional[np.ndarray]
 ) -> Optional[np.ndarray]:
-    """ This function will compute a mask iff it is necessary. Otherwise,
+    """
+    Compute a mask if and only if necessary.
+
+    This function will compute a mask iff it is necessary. Otherwise,
     return the provided mask (potentially None) when a mask does not need to be
     computed.
 
@@ -220,7 +223,6 @@ def _maybe_get_mask(
     Returns
     -------
     Optional[np.ndarray]
-
     """
 
     if mask is None:
@@ -241,7 +243,8 @@ def _get_values(
     fill_value_typ: Optional[str] = None,
     mask: Optional[np.ndarray] = None,
 ) -> Tuple[np.ndarray, Optional[np.ndarray], np.dtype, np.dtype, Any]:
-    """ Utility to get the values view, mask, dtype, dtype_max, and fill_value.
+    """
+    Utility to get the values view, mask, dtype, dtype_max, and fill_value.
 
     If both mask and fill_value/fill_value_typ are not None and skipna is True,
     the values array will be copied.
@@ -276,6 +279,12 @@ def _get_values(
     fill_value : Any
         fill value used
     """
+
+    # In _get_values is only called from within nanops, and in all cases
+    #  with scalar fill_value.  This guarantee is important for the
+    #  maybe_upcast_putmask call below
+    assert is_scalar(fill_value)
+
     mask = _maybe_get_mask(values, skipna, mask)
 
     if is_datetime64tz_dtype(values):
@@ -310,7 +319,7 @@ def _get_values(
 
         # promote if needed
         else:
-            values, changed = maybe_upcast_putmask(values, mask, fill_value)
+            values, _ = maybe_upcast_putmask(values, mask, fill_value)
 
     # return a platform independent precision dtype
     dtype_max = dtype
@@ -322,25 +331,12 @@ def _get_values(
     return values, mask, dtype, dtype_max, fill_value
 
 
-def _isfinite(values):
-    if is_datetime_or_timedelta_dtype(values):
-        return isna(values)
-    if (
-        is_complex_dtype(values)
-        or is_float_dtype(values)
-        or is_integer_dtype(values)
-        or is_bool_dtype(values)
-    ):
-        return ~np.isfinite(values)
-    return ~np.isfinite(values.astype("float64"))
-
-
-def _na_ok_dtype(dtype):
+def _na_ok_dtype(dtype) -> bool:
     # TODO: what about datetime64tz?  PeriodDtype?
     return not issubclass(dtype.type, (np.integer, np.timedelta64, np.datetime64))
 
 
-def _wrap_results(result, dtype, fill_value=None):
+def _wrap_results(result, dtype: Dtype, fill_value=None):
     """ wrap our results if needed """
 
     if is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype):
@@ -352,7 +348,7 @@ def _wrap_results(result, dtype, fill_value=None):
             assert not isna(fill_value), "Expected non-null fill_value"
             if result == fill_value:
                 result = np.nan
-            result = tslibs.Timestamp(result, tz=tz)
+            result = Timestamp(result, tz=tz)
         else:
             result = result.view(dtype)
     elif is_timedelta64_dtype(dtype):
@@ -364,21 +360,24 @@ def _wrap_results(result, dtype, fill_value=None):
             if np.fabs(result) > _int64_max:
                 raise ValueError("overflow in timedelta operation")
 
-            result = tslibs.Timedelta(result, unit="ns")
+            result = Timedelta(result, unit="ns")
         else:
-            result = result.astype("i8").view(dtype)
+            result = result.astype("m8[ns]").view(dtype)
 
     return result
 
 
-def _na_for_min_count(values, axis):
-    """Return the missing value for `values`
+def _na_for_min_count(
+    values: np.ndarray, axis: Optional[int]
+) -> Union[Scalar, np.ndarray]:
+    """
+    Return the missing value for `values`.
 
     Parameters
     ----------
     values : ndarray
     axis : int or None
-        axis for the reduction
+        axis for the reduction, required if values.ndim > 1.
 
     Returns
     -------
@@ -394,13 +393,19 @@ def _na_for_min_count(values, axis):
     if values.ndim == 1:
         return fill_value
     else:
+        assert axis is not None  # assertion to make mypy happy
         result_shape = values.shape[:axis] + values.shape[axis + 1 :]
         result = np.empty(result_shape, dtype=values.dtype)
         result.fill(fill_value)
         return result
 
 
-def nanany(values, axis=None, skipna=True, mask=None):
+def nanany(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> bool:
     """
     Check if any elements along an axis evaluate to True.
 
@@ -432,7 +437,12 @@ def nanany(values, axis=None, skipna=True, mask=None):
     return values.any(axis)
 
 
-def nanall(values, axis=None, skipna=True, mask=None):
+def nanall(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> bool:
     """
     Check if all elements along an axis evaluate to True.
 
@@ -465,7 +475,13 @@ def nanall(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("M8")
-def nansum(values, axis=None, skipna=True, min_count=0, mask=None):
+def nansum(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    min_count: int = 0,
+    mask: Optional[np.ndarray] = None,
+) -> float:
     """
     Sum the elements along an axis ignoring NaNs
 
@@ -636,7 +652,7 @@ def _get_counts_nanvar(
     mask: Optional[np.ndarray],
     axis: Optional[int],
     ddof: int,
-    dtype=float,
+    dtype: Dtype = float,
 ) -> Tuple[Union[int, np.ndarray], Union[int, np.ndarray]]:
     """ Get the count of non-null values along an axis, accounting
     for degrees of freedom.
@@ -669,7 +685,7 @@ def _get_counts_nanvar(
             count = np.nan
             d = np.nan
     else:
-        mask2 = count <= ddof  # type: np.ndarray
+        mask2: np.ndarray = count <= ddof
         if mask2.any():
             np.putmask(d, mask2, np.nan)
             np.putmask(count, mask2, np.nan)
@@ -706,11 +722,14 @@ def nanstd(values, axis=None, skipna=True, ddof=1, mask=None):
     >>> nanops.nanstd(s)
     1.0
     """
+    orig_dtype = values.dtype
+    values, mask, dtype, dtype_max, fill_value = _get_values(values, skipna, mask=mask)
+
     result = np.sqrt(nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask))
-    return _wrap_results(result, values.dtype)
+    return _wrap_results(result, orig_dtype)
 
 
-@disallow("M8")
+@disallow("M8", "m8")
 @bottleneck_switch(ddof=1)
 def nanvar(values, axis=None, skipna=True, ddof=1, mask=None):
     """
@@ -780,7 +799,13 @@ def nanvar(values, axis=None, skipna=True, ddof=1, mask=None):
 
 
 @disallow("M8", "m8")
-def nansem(values, axis=None, skipna=True, ddof=1, mask=None):
+def nansem(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    ddof: int = 1,
+    mask: Optional[np.ndarray] = None,
+) -> float:
     """
     Compute the standard error in the mean along given axis while ignoring NaNs
 
@@ -825,7 +850,12 @@ def nansem(values, axis=None, skipna=True, ddof=1, mask=None):
 
 def _nanminmax(meth, fill_value_typ):
     @bottleneck_switch(name="nan" + meth)
-    def reduction(values, axis=None, skipna=True, mask=None):
+    def reduction(
+        values: np.ndarray,
+        axis: Optional[int] = None,
+        skipna: bool = True,
+        mask: Optional[np.ndarray] = None,
+    ) -> Dtype:
 
         values, mask, dtype, dtype_max, fill_value = _get_values(
             values, skipna, fill_value_typ=fill_value_typ, mask=mask
@@ -835,7 +865,7 @@ def reduction(values, axis=None, skipna=True, mask=None):
             try:
                 result = getattr(values, meth)(axis, dtype=dtype_max)
                 result.fill(np.nan)
-            except (AttributeError, TypeError, ValueError, np.core._internal.AxisError):
+            except (AttributeError, TypeError, ValueError):
                 result = np.nan
         else:
             result = getattr(values, meth)(axis)
@@ -851,7 +881,12 @@ def reduction(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("O")
-def nanargmax(values, axis=None, skipna=True, mask=None):
+def nanargmax(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> int:
     """
     Parameters
     ----------
@@ -882,7 +917,12 @@ def nanargmax(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("O")
-def nanargmin(values, axis=None, skipna=True, mask=None):
+def nanargmin(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> int:
     """
     Parameters
     ----------
@@ -913,7 +953,12 @@ def nanargmin(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("M8", "m8")
-def nanskew(values, axis=None, skipna=True, mask=None):
+def nanskew(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> float:
     """ Compute the sample skewness.
 
     The statistic computed here is the adjusted Fisher-Pearson standardized
@@ -991,7 +1036,12 @@ def nanskew(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("M8", "m8")
-def nankurt(values, axis=None, skipna=True, mask=None):
+def nankurt(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    mask: Optional[np.ndarray] = None,
+) -> float:
     """
     Compute the sample excess kurtosis
 
@@ -1079,7 +1129,13 @@ def nankurt(values, axis=None, skipna=True, mask=None):
 
 
 @disallow("M8", "m8")
-def nanprod(values, axis=None, skipna=True, min_count=0, mask=None):
+def nanprod(
+    values: np.ndarray,
+    axis: Optional[int] = None,
+    skipna: bool = True,
+    min_count: int = 0,
+    mask: Optional[np.ndarray] = None,
+) -> float:
     """
     Parameters
     ----------
@@ -1092,7 +1148,8 @@ def nanprod(values, axis=None, skipna=True, min_count=0, mask=None):
 
     Returns
     -------
-    result : dtype
+    Dtype
+        The product of all elements on a given axis. ( NaNs are treated as 1)
 
     Examples
     --------
@@ -1100,10 +1157,6 @@ def nanprod(values, axis=None, skipna=True, min_count=0, mask=None):
     >>> s = pd.Series([1, 2, 3, np.nan])
     >>> nanops.nanprod(s)
     6.0
-
-    Returns
-    -------
-    The product of all elements on a given axis. ( NaNs are treated as 1)
     """
     mask = _maybe_get_mask(values, skipna, mask)
 
@@ -1142,7 +1195,7 @@ def _get_counts(
     values_shape: Tuple[int],
     mask: Optional[np.ndarray],
     axis: Optional[int],
-    dtype=float,
+    dtype: Dtype = float,
 ) -> Union[int, np.ndarray]:
     """ Get the count of non-null values along an axis
 
@@ -1188,7 +1241,13 @@ def _maybe_null_out(
     mask: Optional[np.ndarray],
     shape: Tuple,
     min_count: int = 1,
-) -> np.ndarray:
+) -> float:
+    """
+    Returns
+    -------
+    Dtype
+        The product of all elements on a given axis. ( NaNs are treated as 1)
+    """
     if mask is not None and axis is not None and getattr(result, "ndim", False):
         null_mask = (mask.shape[axis] - mask.sum(axis) - min_count) < 0
         if np.any(null_mask):
@@ -1201,7 +1260,7 @@ def _maybe_null_out(
             else:
                 # GH12941, use None to auto cast null
                 result[null_mask] = None
-    elif result is not tslibs.NaT:
+    elif result is not NaT:
         if mask is not None:
             null_mask = mask.size - mask.sum()
         else:
@@ -1222,7 +1281,9 @@ def _zero_out_fperr(arg):
 
 
 @disallow("M8", "m8")
-def nancorr(a, b, method="pearson", min_periods=None):
+def nancorr(
+    a: np.ndarray, b: np.ndarray, method="pearson", min_periods: Optional[int] = None,
+):
     """
     a, b: ndarrays
     """
@@ -1247,17 +1308,22 @@ def nancorr(a, b, method="pearson", min_periods=None):
 def get_corr_func(method):
     if method in ["kendall", "spearman"]:
         from scipy.stats import kendalltau, spearmanr
+    elif method in ["pearson"]:
+        pass
     elif callable(method):
         return method
+    else:
+        raise ValueError(
+            f"Unkown method '{method}', expected one of 'kendall', 'spearman'"
+        )
 
     def _pearson(a, b):
         return np.corrcoef(a, b)[0, 1]
 
     def _kendall(a, b):
+        # kendallttau returns a tuple of the tau statistic and pvalue
         rs = kendalltau(a, b)
-        if isinstance(rs, tuple):
-            return rs[0]
-        return rs
+        return rs[0]
 
     def _spearman(a, b):
         return spearmanr(a, b)[0]
@@ -1267,7 +1333,7 @@ def _spearman(a, b):
 
 
 @disallow("M8", "m8")
-def nancov(a, b, min_periods=None):
+def nancov(a: np.ndarray, b: np.ndarray, min_periods: Optional[int] = None):
     if len(a) != len(b):
         raise AssertionError("Operands to nancov must have same size")
 
@@ -1300,13 +1366,13 @@ def _ensure_numeric(x):
     elif not (is_float(x) or is_integer(x) or is_complex(x)):
         try:
             x = float(x)
-        except Exception:
+        except ValueError:
+            # e.g. "1+1j" or "foo"
             try:
                 x = complex(x)
-            except Exception:
-                raise TypeError(
-                    "Could not convert {value!s} to numeric".format(value=x)
-                )
+            except ValueError:
+                # e.g. "foo"
+                raise TypeError(f"Could not convert {x} to numeric")
     return x
 
 
@@ -1340,9 +1406,11 @@ def f(x, y):
 nanne = make_nancomp(operator.ne)
 
 
-def _nanpercentile_1d(values, mask, q, na_value, interpolation):
+def _nanpercentile_1d(
+    values: np.ndarray, mask: np.ndarray, q, na_value: Scalar, interpolation
+) -> Union[Scalar, np.ndarray]:
     """
-    Wraper for np.percentile that skips missing values, specialized to
+    Wrapper for np.percentile that skips missing values, specialized to
     1-dimensional case.
 
     Parameters
@@ -1371,9 +1439,17 @@ def _nanpercentile_1d(values, mask, q, na_value, interpolation):
     return np.percentile(values, q, interpolation=interpolation)
 
 
-def nanpercentile(values, q, axis, na_value, mask, ndim, interpolation):
+def nanpercentile(
+    values: np.ndarray,
+    q,
+    axis: int,
+    na_value,
+    mask: np.ndarray,
+    ndim: int,
+    interpolation,
+):
     """
-    Wraper for np.percentile that skips missing values.
+    Wrapper for np.percentile that skips missing values.
 
     Parameters
     ----------
diff --git a/pandas/core/ops/__init__.py b/pandas/core/ops/__init__.py
index 0151dba756d54..0312c11a6d590 100644
--- a/pandas/core/ops/__init__.py
+++ b/pandas/core/ops/__init__.py
@@ -5,53 +5,43 @@
 """
 import datetime
 import operator
-from typing import Any, Callable, Tuple, Union
+from typing import Optional, Set, Tuple, Union
 
 import numpy as np
 
-from pandas._libs import Timedelta, Timestamp, lib, ops as libops
-from pandas.errors import NullFrequencyError
+from pandas._libs import Timedelta, Timestamp, lib
+from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op  # noqa:F401
+from pandas._typing import Level
 from pandas.util._decorators import Appender
 
-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
-from pandas.core.dtypes.common import (
-    ensure_object,
-    is_bool_dtype,
-    is_datetime64_dtype,
-    is_extension_array_dtype,
-    is_integer_dtype,
-    is_list_like,
-    is_object_dtype,
-    is_scalar,
-    is_timedelta64_dtype,
-)
+from pandas.core.dtypes.common import is_list_like, is_timedelta64_dtype
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
-    ABCDatetimeArray,
-    ABCDatetimeIndex,
     ABCExtensionArray,
     ABCIndexClass,
     ABCSeries,
-    ABCSparseSeries,
-    ABCTimedeltaArray,
-    ABCTimedeltaIndex,
 )
-from pandas.core.dtypes.missing import isna, notna
+from pandas.core.dtypes.missing import isna
 
-from pandas._typing import ArrayLike
-from pandas.core.construction import array, extract_array
+from pandas.core.construction import extract_array
 from pandas.core.ops.array_ops import (
-    comp_method_OBJECT_ARRAY,
+    arithmetic_op,
+    comparison_op,
     define_na_arithmetic_op,
-    na_arithmetic_op,
+    get_array_op,
+    logical_op,
 )
+from pandas.core.ops.array_ops import comp_method_OBJECT_ARRAY  # noqa:F401
+from pandas.core.ops.common import unpack_zerodim_and_defer
+from pandas.core.ops.dispatch import should_series_dispatch
 from pandas.core.ops.docstrings import (
     _arith_doc_FRAME,
     _flex_comp_doc_FRAME,
     _make_flex_doc,
     _op_descriptions,
 )
-from pandas.core.ops.invalid import invalid_comparison
+from pandas.core.ops.invalid import invalid_comparison  # noqa:F401
+from pandas.core.ops.mask_ops import kleene_and, kleene_or, kleene_xor  # noqa: F401
 from pandas.core.ops.methods import (  # noqa:F401
     add_flex_arithmetic_methods,
     add_special_arithmetic_methods,
@@ -71,6 +61,37 @@
     rxor,
 )
 
+# -----------------------------------------------------------------------------
+# constants
+ARITHMETIC_BINOPS: Set[str] = {
+    "add",
+    "sub",
+    "mul",
+    "pow",
+    "mod",
+    "floordiv",
+    "truediv",
+    "divmod",
+    "radd",
+    "rsub",
+    "rmul",
+    "rpow",
+    "rmod",
+    "rfloordiv",
+    "rtruediv",
+    "rdivmod",
+}
+
+
+COMPARISON_BINOPS: Set[str] = {
+    "eq",
+    "ne",
+    "lt",
+    "gt",
+    "le",
+    "ge",
+}
+
 # -----------------------------------------------------------------------------
 # Ops Wrapping Utilities
 
@@ -195,41 +216,6 @@ def maybe_upcast_for_op(obj, shape: Tuple[int, ...]):
 # -----------------------------------------------------------------------------
 
 
-def _gen_eval_kwargs(name):
-    """
-    Find the keyword arguments to pass to numexpr for the given operation.
-
-    Parameters
-    ----------
-    name : str
-
-    Returns
-    -------
-    eval_kwargs : dict
-
-    Examples
-    --------
-    >>> _gen_eval_kwargs("__add__")
-    {}
-
-    >>> _gen_eval_kwargs("rtruediv")
-    {'reversed': True, 'truediv': True}
-    """
-    kwargs = {}
-
-    # Series appear to only pass __add__, __radd__, ...
-    # but DataFrame gets both these dunder names _and_ non-dunder names
-    # add, radd, ...
-    name = name.replace("__", "")
-
-    if name.startswith("r"):
-        if name not in ["radd", "rand", "ror", "rxor"]:
-            # Exclude commutative operations
-            kwargs["reversed"] = True
-
-    return kwargs
-
-
 def _get_frame_op_default_axis(name):
     """
     Only DataFrame cares about default_axis, specifically:
@@ -280,7 +266,7 @@ def _get_opstr(op):
         rtruediv: "/",
         operator.floordiv: "//",
         rfloordiv: "//",
-        operator.mod: None,  # TODO: Why None for mod but '%' for rmod?
+        operator.mod: "%",
         rmod: "%",
         operator.pow: "**",
         rpow: "**",
@@ -317,7 +303,7 @@ def _get_op_name(op, special):
     """
     opname = op.__name__.strip("_")
     if special:
-        opname = "__{opname}__".format(opname=opname)
+        opname = f"__{opname}__"
     return opname
 
 
@@ -344,123 +330,32 @@ def fill_binop(left, right, fill_value):
 
     Notes
     -----
-    Makes copies if fill_value is not None
+    Makes copies if fill_value is not None and NAs are present.
     """
-    # TODO: can we make a no-copy implementation?
     if fill_value is not None:
         left_mask = isna(left)
         right_mask = isna(right)
-        left = left.copy()
-        right = right.copy()
 
         # one but not both
         mask = left_mask ^ right_mask
-        left[left_mask & mask] = fill_value
-        right[right_mask & mask] = fill_value
-    return left, right
-
 
-def mask_cmp_op(x, y, op):
-    """
-    Apply the function `op` to only non-null points in x and y.
+        if left_mask.any():
+            # Avoid making a copy if we can
+            left = left.copy()
+            left[left_mask & mask] = fill_value
 
-    Parameters
-    ----------
-    x : array-like
-    y : array-like
-    op : binary operation
+        if right_mask.any():
+            # Avoid making a copy if we can
+            right = right.copy()
+            right[right_mask & mask] = fill_value
 
-    Returns
-    -------
-    result : ndarray[bool]
-    """
-    xrav = x.ravel()
-    result = np.empty(x.size, dtype=bool)
-    if isinstance(y, (np.ndarray, ABCSeries)):
-        yrav = y.ravel()
-        mask = notna(xrav) & notna(yrav)
-        result[mask] = op(np.array(list(xrav[mask])), np.array(list(yrav[mask])))
-    else:
-        mask = notna(xrav)
-        result[mask] = op(np.array(list(xrav[mask])), y)
-
-    if op == operator.ne:  # pragma: no cover
-        np.putmask(result, ~mask, True)
-    else:
-        np.putmask(result, ~mask, False)
-    result = result.reshape(x.shape)
-    return result
+    return left, right
 
 
 # -----------------------------------------------------------------------------
 # Dispatch logic
 
 
-def should_extension_dispatch(left: ABCSeries, right: Any) -> bool:
-    """
-    Identify cases where Series operation should use dispatch_to_extension_op.
-
-    Parameters
-    ----------
-    left : Series
-    right : object
-
-    Returns
-    -------
-    bool
-    """
-    if (
-        is_extension_array_dtype(left.dtype)
-        or is_datetime64_dtype(left.dtype)
-        or is_timedelta64_dtype(left.dtype)
-    ):
-        return True
-
-    if not is_scalar(right) and is_extension_array_dtype(right):
-        # GH#22378 disallow scalar to exclude e.g. "category", "Int64"
-        return True
-
-    return False
-
-
-def should_series_dispatch(left, right, op):
-    """
-    Identify cases where a DataFrame operation should dispatch to its
-    Series counterpart.
-
-    Parameters
-    ----------
-    left : DataFrame
-    right : DataFrame
-    op : binary operator
-
-    Returns
-    -------
-    override : bool
-    """
-    if left._is_mixed_type or right._is_mixed_type:
-        return True
-
-    if not len(left.columns) or not len(right.columns):
-        # ensure obj.dtypes[0] exists for each obj
-        return False
-
-    ldtype = left.dtypes.iloc[0]
-    rdtype = right.dtypes.iloc[0]
-
-    if (is_timedelta64_dtype(ldtype) and is_integer_dtype(rdtype)) or (
-        is_timedelta64_dtype(rdtype) and is_integer_dtype(ldtype)
-    ):
-        # numpy integer dtypes as timedelta64 dtypes in this scenario
-        return True
-
-    if is_datetime64_dtype(ldtype) and is_object_dtype(rdtype):
-        # in particular case where right is an array of DateOffsets
-        return True
-
-    return False
-
-
 def dispatch_to_series(left, right, func, str_rep=None, axis=None):
     """
     Evaluate the frame operation func(left, right) by evaluating
@@ -485,8 +380,10 @@ def dispatch_to_series(left, right, func, str_rep=None, axis=None):
     right = lib.item_from_zerodim(right)
     if lib.is_scalar(right) or np.ndim(right) == 0:
 
-        def column_op(a, b):
-            return {i: func(a.iloc[:, i], b) for i in range(len(a.columns))}
+        # Get the appropriate array-op to apply to each block's values.
+        array_op = get_array_op(func, str_rep=str_rep)
+        bm = left._data.apply(array_op, right=right)
+        return type(left)(bm)
 
     elif isinstance(right, ABCDataFrame):
         assert right._indexed_same(left)
@@ -495,12 +392,23 @@ def column_op(a, b):
             return {i: func(a.iloc[:, i], b.iloc[:, i]) for i in range(len(a.columns))}
 
     elif isinstance(right, ABCSeries) and axis == "columns":
-        # We only get here if called via left._combine_match_columns,
+        # We only get here if called via _combine_series_frame,
         # in which case we specifically want to operate row-by-row
         assert right.index.equals(left.columns)
 
-        def column_op(a, b):
-            return {i: func(a.iloc[:, i], b.iloc[i]) for i in range(len(a.columns))}
+        if right.dtype == "timedelta64[ns]":
+            # ensure we treat NaT values as the correct dtype
+            # Note: we do not do this unconditionally as it may be lossy or
+            #  expensive for EA dtypes.
+            right = np.asarray(right)
+
+            def column_op(a, b):
+                return {i: func(a.iloc[:, i], b[i]) for i in range(len(a.columns))}
+
+        else:
+
+            def column_op(a, b):
+                return {i: func(a.iloc[:, i], b.iloc[i]) for i in range(len(a.columns))}
 
     elif isinstance(right, ABCSeries):
         assert right.index.equals(left.index)  # Handle other cases later
@@ -513,64 +421,7 @@ def column_op(a, b):
         raise NotImplementedError(right)
 
     new_data = expressions.evaluate(column_op, str_rep, left, right)
-
-    result = left._constructor(new_data, index=left.index, copy=False)
-    # Pin columns instead of passing to constructor for compat with
-    # non-unique columns case
-    result.columns = left.columns
-    return result
-
-
-def dispatch_to_extension_op(
-    op,
-    left: Union[ABCExtensionArray, np.ndarray],
-    right: Any,
-    keep_null_freq: bool = False,
-):
-    """
-    Assume that left or right is a Series backed by an ExtensionArray,
-    apply the operator defined by op.
-
-    Parameters
-    ----------
-    op : binary operator
-    left : ExtensionArray or np.ndarray
-    right : object
-    keep_null_freq : bool, default False
-        Whether to re-raise a NullFrequencyError unchanged, as opposed to
-        catching and raising TypeError.
-
-    Returns
-    -------
-    ExtensionArray or np.ndarray
-        2-tuple of these if op is divmod or rdivmod
-    """
-    # NB: left and right should already be unboxed, so neither should be
-    #  a Series or Index.
-
-    if left.dtype.kind in "mM" and isinstance(left, np.ndarray):
-        # We need to cast datetime64 and timedelta64 ndarrays to
-        #  DatetimeArray/TimedeltaArray.  But we avoid wrapping others in
-        #  PandasArray as that behaves poorly with e.g. IntegerArray.
-        left = array(left)
-
-    # The op calls will raise TypeError if the op is not defined
-    # on the ExtensionArray
-
-    try:
-        res_values = op(left, right)
-    except NullFrequencyError:
-        # DatetimeIndex and TimedeltaIndex with freq == None raise ValueError
-        # on add/sub of integers (or int-like).  We re-raise as a TypeError.
-        if keep_null_freq:
-            # TODO: remove keep_null_freq after Timestamp+int deprecation
-            #  GH#22535 is enforced
-            raise
-        raise TypeError(
-            "incompatible type for a datetime/timedelta "
-            "operation [{name}]".format(name=op.__name__)
-        )
-    return res_values
+    return new_data
 
 
 # -----------------------------------------------------------------------------
@@ -598,27 +449,45 @@ def _align_method_SERIES(left, right, align_asobject=False):
     return left, right
 
 
-def _construct_result(left, result, index, name, dtype=None):
-    """
-    If the raw op result has a non-None name (e.g. it is an Index object) and
-    the name argument is None, then passing name to the constructor will
-    not be enough; we still need to override the name attribute.
+def _construct_result(
+    left: ABCSeries,
+    result: Union[np.ndarray, ABCExtensionArray],
+    index: ABCIndexClass,
+    name,
+):
     """
-    out = left._constructor(result, index=index, dtype=dtype)
+    Construct an appropriately-labelled Series from the result of an op.
+
+    Parameters
+    ----------
+    left : Series
+    result : ndarray or ExtensionArray
+    index : Index
+    name : object
+
+    Returns
+    -------
+    Series
+        In the case of __divmod__ or __rdivmod__, a 2-tuple of Series.
+    """
+    if isinstance(result, tuple):
+        # produced by divmod or rdivmod
+        return (
+            _construct_result(left, result[0], index=index, name=name),
+            _construct_result(left, result[1], index=index, name=name),
+        )
+
+    # We do not pass dtype to ensure that the Series constructor
+    #  does inference in the case where `result` has object-dtype.
+    out = left._constructor(result, index=index)
     out = out.__finalize__(left)
+
+    # Set the result's name after __finalize__ is called because __finalize__
+    #  would set it back to self.name
     out.name = name
     return out
 
 
-def _construct_divmod_result(left, result, index, name, dtype=None):
-    """divmod returns a tuple of like indexed series instead of a single series.
-    """
-    return (
-        _construct_result(left, result[0], index=index, name=name, dtype=dtype),
-        _construct_result(left, result[1], index=index, name=name, dtype=dtype),
-    )
-
-
 def _arith_method_SERIES(cls, op, special):
     """
     Wrapper function for Series arithmetic operations, to avoid
@@ -626,46 +495,18 @@ def _arith_method_SERIES(cls, op, special):
     """
     str_rep = _get_opstr(op)
     op_name = _get_op_name(op, special)
-    eval_kwargs = _gen_eval_kwargs(op_name)
-    construct_result = (
-        _construct_divmod_result if op in [divmod, rdivmod] else _construct_result
-    )
 
+    @unpack_zerodim_and_defer(op_name)
     def wrapper(left, right):
-        if isinstance(right, ABCDataFrame):
-            return NotImplemented
 
         left, right = _align_method_SERIES(left, right)
         res_name = get_op_result_name(left, right)
 
-        keep_null_freq = isinstance(
-            right,
-            (
-                ABCDatetimeIndex,
-                ABCDatetimeArray,
-                ABCTimedeltaIndex,
-                ABCTimedeltaArray,
-                Timestamp,
-            ),
-        )
-
         lvalues = extract_array(left, extract_numpy=True)
         rvalues = extract_array(right, extract_numpy=True)
+        result = arithmetic_op(lvalues, rvalues, op, str_rep)
 
-        rvalues = maybe_upcast_for_op(rvalues, lvalues.shape)
-
-        if should_extension_dispatch(left, rvalues) or isinstance(
-            rvalues, (ABCTimedeltaArray, ABCDatetimeArray, Timestamp)
-        ):
-            result = dispatch_to_extension_op(op, lvalues, rvalues, keep_null_freq)
-
-        else:
-            with np.errstate(all="ignore"):
-                result = na_arithmetic_op(lvalues, rvalues, op, str_rep, eval_kwargs)
-
-        # We do not pass dtype to ensure that the Series constructor
-        #  does inference in the case where `result` has object-dtype.
-        return construct_result(left, result, index=left.index, name=res_name)
+        return _construct_result(left, result, index=left.index, name=res_name)
 
     wrapper.__name__ = op_name
     return wrapper
@@ -678,73 +519,20 @@ def _comp_method_SERIES(cls, op, special):
     """
     op_name = _get_op_name(op, special)
 
+    @unpack_zerodim_and_defer(op_name)
     def wrapper(self, other):
 
         res_name = get_op_result_name(self, other)
 
-        # TODO: shouldn't we be applying finalize whenever
-        #  not isinstance(other, ABCSeries)?
-        finalizer = (
-            lambda x: x.__finalize__(self)
-            if isinstance(other, (np.ndarray, ABCIndexClass))
-            else x
-        )
-
-        if isinstance(other, ABCDataFrame):  # pragma: no cover
-            # Defer to DataFrame implementation; fail early
-            return NotImplemented
-
         if isinstance(other, ABCSeries) and not self._indexed_same(other):
             raise ValueError("Can only compare identically-labeled Series objects")
 
-        other = lib.item_from_zerodim(other)
-        if isinstance(other, list):
-            # TODO: same for tuples?
-            other = np.asarray(other)
-
-        if isinstance(other, (np.ndarray, ABCExtensionArray, ABCIndexClass)):
-            # TODO: make this treatment consistent across ops and classes.
-            #  We are not catching all listlikes here (e.g. frozenset, tuple)
-            #  The ambiguous case is object-dtype.  See GH#27803
-            if len(self) != len(other):
-                raise ValueError("Lengths must match to compare")
-
         lvalues = extract_array(self, extract_numpy=True)
         rvalues = extract_array(other, extract_numpy=True)
 
-        if should_extension_dispatch(lvalues, rvalues):
-            res_values = dispatch_to_extension_op(op, lvalues, rvalues)
+        res_values = comparison_op(lvalues, rvalues, op)
 
-        elif is_scalar(rvalues) and isna(rvalues):
-            # numpy does not like comparisons vs None
-            if op is operator.ne:
-                res_values = np.ones(len(lvalues), dtype=bool)
-            else:
-                res_values = np.zeros(len(lvalues), dtype=bool)
-
-        elif is_object_dtype(lvalues.dtype):
-            res_values = comp_method_OBJECT_ARRAY(op, lvalues, rvalues)
-
-        else:
-            op_name = "__{op}__".format(op=op.__name__)
-            method = getattr(lvalues, op_name)
-            with np.errstate(all="ignore"):
-                res_values = method(rvalues)
-
-            if res_values is NotImplemented:
-                res_values = invalid_comparison(lvalues, rvalues, op)
-            if is_scalar(res_values):
-                raise TypeError(
-                    "Could not compare {typ} type with Series".format(typ=type(rvalues))
-                )
-
-        result = self._constructor(res_values, index=self.index)
-        result = finalizer(result)
-
-        # Set the result's name after finalizer is called because finalizer
-        #  would set it back to self.name
-        result.name = res_name
-        return result
+        return _construct_result(self, res_values, index=self.index, name=res_name)
 
     wrapper.__name__ = op_name
     return wrapper
@@ -757,102 +545,16 @@ def _bool_method_SERIES(cls, op, special):
     """
     op_name = _get_op_name(op, special)
 
-    def na_op(x, y):
-        try:
-            result = op(x, y)
-        except TypeError:
-            assert not isinstance(y, (list, ABCSeries, ABCIndexClass))
-            if isinstance(y, np.ndarray):
-                # bool-bool dtype operations should be OK, should not get here
-                assert not (is_bool_dtype(x.dtype) and is_bool_dtype(y.dtype))
-                x = ensure_object(x)
-                y = ensure_object(y)
-                result = libops.vec_binop(x, y, op)
-            else:
-                # let null fall thru
-                assert lib.is_scalar(y)
-                if not isna(y):
-                    y = bool(y)
-                try:
-                    result = libops.scalar_binop(x, y, op)
-                except (
-                    TypeError,
-                    ValueError,
-                    AttributeError,
-                    OverflowError,
-                    NotImplementedError,
-                ):
-                    raise TypeError(
-                        "cannot compare a dtyped [{dtype}] array "
-                        "with a scalar of type [{typ}]".format(
-                            dtype=x.dtype, typ=type(y).__name__
-                        )
-                    )
-
-        return result
-
-    fill_int = lambda x: x
-
-    def fill_bool(x, left=None):
-        # if `left` is specifically not-boolean, we do not cast to bool
-        if x.dtype.kind in ["c", "f", "O"]:
-            # dtypes that can hold NA
-            mask = isna(x)
-            if mask.any():
-                x = x.astype(object)
-                x[mask] = False
-
-        if left is None or is_bool_dtype(left.dtype):
-            x = x.astype(bool)
-        return x
-
+    @unpack_zerodim_and_defer(op_name)
     def wrapper(self, other):
-        is_self_int_dtype = is_integer_dtype(self.dtype)
-
         self, other = _align_method_SERIES(self, other, align_asobject=True)
         res_name = get_op_result_name(self, other)
 
-        # TODO: shouldn't we be applying finalize whenever
-        #  not isinstance(other, ABCSeries)?
-        finalizer = (
-            lambda x: x.__finalize__(self)
-            if not isinstance(other, (ABCSeries, ABCIndexClass))
-            else x
-        )
-
-        if isinstance(other, ABCDataFrame):
-            # Defer to DataFrame implementation; fail early
-            return NotImplemented
-
-        other = lib.item_from_zerodim(other)
-        if is_list_like(other) and not hasattr(other, "dtype"):
-            # e.g. list, tuple
-            other = construct_1d_object_array_from_listlike(other)
-
         lvalues = extract_array(self, extract_numpy=True)
         rvalues = extract_array(other, extract_numpy=True)
 
-        if should_extension_dispatch(self, rvalues):
-            res_values = dispatch_to_extension_op(op, lvalues, rvalues)
-
-        else:
-            if isinstance(rvalues, (ABCSeries, ABCIndexClass, np.ndarray)):
-                is_other_int_dtype = is_integer_dtype(rvalues.dtype)
-                rvalues = rvalues if is_other_int_dtype else fill_bool(rvalues, lvalues)
-
-            else:
-                # i.e. scalar
-                is_other_int_dtype = lib.is_integer(rvalues)
-
-            # For int vs int `^`, `|`, `&` are bitwise operators and return
-            #   integer dtypes.  Otherwise these are boolean ops
-            filler = fill_int if is_self_int_dtype and is_other_int_dtype else fill_bool
-
-            res_values = na_op(lvalues, rvalues)
-            res_values = filler(res_values)
-
-        result = self._constructor(res_values, index=self.index, name=res_name)
-        return finalizer(result)
+        res_values = logical_op(lvalues, rvalues, op)
+        return _construct_result(self, res_values, index=self.index, name=res_name)
 
     wrapper.__name__ = op_name
     return wrapper
@@ -867,6 +569,7 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
         # validate axis
         if axis is not None:
             self._get_axis_number(axis)
+
         if isinstance(other, ABCSeries):
             return self._binop(other, op, level=level, fill_value=fill_value)
         elif isinstance(other, (np.ndarray, list, tuple)):
@@ -878,7 +581,7 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
             if fill_value is not None:
                 self = self.fillna(fill_value)
 
-            return self._constructor(op(self, other), self.index).__finalize__(self)
+            return op(self, other)
 
     flex_wrapper.__name__ = name
     return flex_wrapper
@@ -888,51 +591,52 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
 # DataFrame
 
 
-def _combine_series_frame(self, other, func, fill_value=None, axis=None, level=None):
+def _combine_series_frame(left, right, func, axis: int):
     """
     Apply binary operator `func` to self, other using alignment and fill
-    conventions determined by the fill_value, axis, and level kwargs.
+    conventions determined by the axis argument.
 
     Parameters
     ----------
-    self : DataFrame
-    other : Series
+    left : DataFrame
+    right : Series
     func : binary operator
-    fill_value : object, default None
-    axis : {0, 1, 'columns', 'index', None}, default None
-    level : int or None, default None
+    axis : {0, 1}
 
     Returns
     -------
     result : DataFrame
     """
-    if fill_value is not None:
-        raise NotImplementedError(
-            "fill_value {fill} not supported.".format(fill=fill_value)
-        )
-
-    if axis is not None:
-        axis = self._get_axis_number(axis)
-        if axis == 0:
-            return self._combine_match_index(other, func, level=level)
-        else:
-            return self._combine_match_columns(other, func, level=level)
+    # We assume that self.align(other, ...) has already been called
+    if axis == 0:
+        new_data = left._combine_match_index(right, func)
     else:
-        if not len(other):
-            return self * np.nan
+        new_data = dispatch_to_series(left, right, func, axis="columns")
 
-        if not len(self):
-            # Ambiguous case, use _series so works with DataFrame
-            return self._constructor(
-                data=self._series, index=self.index, columns=self.columns
-            )
+    return left._construct_result(new_data)
 
-        # default axis is columns
-        return self._combine_match_columns(other, func, level=level)
 
+def _align_method_FRAME(
+    left, right, axis, flex: Optional[bool] = False, level: Level = None
+):
+    """
+    Convert rhs to meet lhs dims if input is list, tuple or np.ndarray.
 
-def _align_method_FRAME(left, right, axis):
-    """ convert rhs to meet lhs dims if input is list, tuple or np.ndarray """
+    Parameters
+    ----------
+    left : DataFrame
+    right : Any
+    axis: int, str, or None
+    flex: bool or None, default False
+        Whether this is a flex op, in which case we reindex.
+        None indicates not to check for alignment.
+    level : int or level name, default None
+
+    Returns
+    -------
+    left : DataFrame
+    right : Any
+    """
 
     def to_series(right):
         msg = "Unable to coerce to Series, length must be {req_len}: given {given_len}"
@@ -971,31 +675,43 @@ def to_series(right):
             else:
                 raise ValueError(
                     "Unable to coerce to DataFrame, shape "
-                    "must be {req_shape}: given {given_shape}".format(
-                        req_shape=left.shape, given_shape=right.shape
-                    )
+                    f"must be {left.shape}: given {right.shape}"
                 )
 
         elif right.ndim > 2:
             raise ValueError(
-                "Unable to coerce to Series/DataFrame, dim "
-                "must be <= 2: {dim}".format(dim=right.shape)
+                f"Unable to coerce to Series/DataFrame, dim must be <= 2: {right.shape}"
             )
 
     elif is_list_like(right) and not isinstance(right, (ABCSeries, ABCDataFrame)):
         # GH17901
         right = to_series(right)
 
-    return right
+    if flex is not None and isinstance(right, ABCDataFrame):
+        if not left._indexed_same(right):
+            if flex:
+                left, right = left.align(right, join="outer", level=level, copy=False)
+            else:
+                raise ValueError(
+                    "Can only compare identically-labeled DataFrame objects"
+                )
+    elif isinstance(right, ABCSeries):
+        # axis=1 is default for DataFrame-with-Series op
+        axis = left._get_axis_number(axis) if axis is not None else 1
+        left, right = left.align(
+            right, join="outer", axis=axis, level=level, copy=False
+        )
+
+    return left, right
 
 
 def _arith_method_FRAME(cls, op, special):
     str_rep = _get_opstr(op)
     op_name = _get_op_name(op, special)
-    eval_kwargs = _gen_eval_kwargs(op_name)
     default_axis = _get_frame_op_default_axis(op_name)
 
-    na_op = define_na_arithmetic_op(op, str_rep, eval_kwargs)
+    na_op = define_na_arithmetic_op(op, str_rep)
+    is_logical = str_rep in ["&", "|", "^"]
 
     if op_name in _op_descriptions:
         # i.e. include "add" but not "__add__"
@@ -1006,25 +722,34 @@ def _arith_method_FRAME(cls, op, special):
     @Appender(doc)
     def f(self, other, axis=default_axis, level=None, fill_value=None):
 
-        other = _align_method_FRAME(self, other, axis)
+        self, other = _align_method_FRAME(self, other, axis, flex=True, level=level)
 
         if isinstance(other, ABCDataFrame):
             # Another DataFrame
             pass_op = op if should_series_dispatch(self, other, op) else na_op
-            return self._combine_frame(other, pass_op, fill_value, level)
+            pass_op = pass_op if not is_logical else op
+
+            new_data = self._combine_frame(other, pass_op, fill_value)
+            return self._construct_result(new_data)
+
         elif isinstance(other, ABCSeries):
             # For these values of `axis`, we end up dispatching to Series op,
             # so do not want the masked op.
             pass_op = op if axis in [0, "columns", None] else na_op
-            return _combine_series_frame(
-                self, other, pass_op, fill_value=fill_value, axis=axis, level=level
-            )
+            pass_op = pass_op if not is_logical else op
+
+            if fill_value is not None:
+                raise NotImplementedError(f"fill_value {fill_value} not supported.")
+
+            axis = self._get_axis_number(axis) if axis is not None else 1
+            return _combine_series_frame(self, other, pass_op, axis=axis)
         else:
             # in this case we always have `np.ndim(other) == 0`
             if fill_value is not None:
                 self = self.fillna(fill_value)
 
-            return self._combine_const(other, op)
+            new_data = dispatch_to_series(self, other, op, str_rep)
+            return self._construct_result(new_data)
 
     f.__name__ = op_name
 
@@ -1036,14 +761,6 @@ def _flex_comp_method_FRAME(cls, op, special):
     op_name = _get_op_name(op, special)
     default_axis = _get_frame_op_default_axis(op_name)
 
-    def na_op(x, y):
-        try:
-            with np.errstate(invalid="ignore"):
-                result = op(x, y)
-        except TypeError:
-            result = mask_cmp_op(x, y, op)
-        return result
-
     doc = _flex_comp_doc_FRAME.format(
         op_name=op_name, desc=_op_descriptions[op_name]["desc"]
     )
@@ -1051,216 +768,52 @@ def na_op(x, y):
     @Appender(doc)
     def f(self, other, axis=default_axis, level=None):
 
-        other = _align_method_FRAME(self, other, axis)
+        self, other = _align_method_FRAME(self, other, axis, flex=True, level=level)
 
         if isinstance(other, ABCDataFrame):
             # Another DataFrame
-            if not self._indexed_same(other):
-                self, other = self.align(other, "outer", level=level, copy=False)
-            return dispatch_to_series(self, other, na_op, str_rep)
+            new_data = dispatch_to_series(self, other, op, str_rep)
+            return self._construct_result(new_data)
 
         elif isinstance(other, ABCSeries):
-            return _combine_series_frame(
-                self, other, na_op, fill_value=None, axis=axis, level=level
-            )
+            axis = self._get_axis_number(axis) if axis is not None else 1
+            return _combine_series_frame(self, other, op, axis=axis)
         else:
             # in this case we always have `np.ndim(other) == 0`
-            return self._combine_const(other, na_op)
+            new_data = dispatch_to_series(self, other, op)
+            return self._construct_result(new_data)
 
     f.__name__ = op_name
 
     return f
 
 
-def _comp_method_FRAME(cls, func, special):
-    str_rep = _get_opstr(func)
-    op_name = _get_op_name(func, special)
+def _comp_method_FRAME(cls, op, special):
+    str_rep = _get_opstr(op)
+    op_name = _get_op_name(op, special)
 
-    @Appender("Wrapper for comparison method {name}".format(name=op_name))
+    @Appender(f"Wrapper for comparison method {op_name}")
     def f(self, other):
 
-        other = _align_method_FRAME(self, other, axis=None)
+        self, other = _align_method_FRAME(
+            self, other, axis=None, level=None, flex=False
+        )
 
         if isinstance(other, ABCDataFrame):
             # Another DataFrame
-            if not self._indexed_same(other):
-                raise ValueError(
-                    "Can only compare identically-labeled DataFrame objects"
-                )
-            return dispatch_to_series(self, other, func, str_rep)
+            new_data = dispatch_to_series(self, other, op, str_rep)
 
         elif isinstance(other, ABCSeries):
-            return _combine_series_frame(
-                self, other, func, fill_value=None, axis=None, level=None
-            )
+            new_data = dispatch_to_series(self, other, op, axis="columns")
+
         else:
 
             # straight boolean comparisons we want to allow all columns
             # (regardless of dtype to pass thru) See #4537 for discussion.
-            res = self._combine_const(other, func)
-            return res
+            new_data = dispatch_to_series(self, other, op)
+
+        return self._construct_result(new_data)
 
     f.__name__ = op_name
 
     return f
-
-
-# -----------------------------------------------------------------------------
-# Sparse
-
-
-def _cast_sparse_series_op(left, right, opname):
-    """
-    For SparseSeries operation, coerce to float64 if the result is expected
-    to have NaN or inf values
-
-    Parameters
-    ----------
-    left : SparseArray
-    right : SparseArray
-    opname : str
-
-    Returns
-    -------
-    left : SparseArray
-    right : SparseArray
-    """
-    from pandas.core.sparse.api import SparseDtype
-
-    opname = opname.strip("_")
-
-    # TODO: This should be moved to the array?
-    if is_integer_dtype(left) and is_integer_dtype(right):
-        # series coerces to float64 if result should have NaN/inf
-        if opname in ("floordiv", "mod") and (right.to_dense() == 0).any():
-            left = left.astype(SparseDtype(np.float64, left.fill_value))
-            right = right.astype(SparseDtype(np.float64, right.fill_value))
-        elif opname in ("rfloordiv", "rmod") and (left.to_dense() == 0).any():
-            left = left.astype(SparseDtype(np.float64, left.fill_value))
-            right = right.astype(SparseDtype(np.float64, right.fill_value))
-
-    return left, right
-
-
-def _arith_method_SPARSE_SERIES(cls, op, special):
-    """
-    Wrapper function for Series arithmetic operations, to avoid
-    code duplication.
-    """
-    op_name = _get_op_name(op, special)
-
-    def wrapper(self, other):
-        if isinstance(other, ABCDataFrame):
-            return NotImplemented
-        elif isinstance(other, ABCSeries):
-            if not isinstance(other, ABCSparseSeries):
-                other = other.to_sparse(fill_value=self.fill_value)
-            return _sparse_series_op(self, other, op, op_name)
-        elif is_scalar(other):
-            with np.errstate(all="ignore"):
-                new_values = op(self.values, other)
-            return self._constructor(new_values, index=self.index, name=self.name)
-        else:  # pragma: no cover
-            raise TypeError(
-                "operation with {other} not supported".format(other=type(other))
-            )
-
-    wrapper.__name__ = op_name
-    return wrapper
-
-
-def _sparse_series_op(left, right, op, name):
-    left, right = left.align(right, join="outer", copy=False)
-    new_index = left.index
-    new_name = get_op_result_name(left, right)
-
-    from pandas.core.arrays.sparse import _sparse_array_op
-
-    lvalues, rvalues = _cast_sparse_series_op(left.values, right.values, name)
-    result = _sparse_array_op(lvalues, rvalues, op, name)
-    return left._constructor(result, index=new_index, name=new_name)
-
-
-def maybe_dispatch_ufunc_to_dunder_op(
-    self: ArrayLike, ufunc: Callable, method: str, *inputs: ArrayLike, **kwargs: Any
-):
-    """
-    Dispatch a ufunc to the equivalent dunder method.
-
-    Parameters
-    ----------
-    self : ArrayLike
-        The array whose dunder method we dispatch to
-    ufunc : Callable
-        A NumPy ufunc
-    method : {'reduce', 'accumulate', 'reduceat', 'outer', 'at', '__call__'}
-    inputs : ArrayLike
-        The input arrays.
-    kwargs : Any
-        The additional keyword arguments, e.g. ``out``.
-
-    Returns
-    -------
-    result : Any
-        The result of applying the ufunc
-    """
-    # special has the ufuncs we dispatch to the dunder op on
-    special = {
-        "add",
-        "sub",
-        "mul",
-        "pow",
-        "mod",
-        "floordiv",
-        "truediv",
-        "divmod",
-        "eq",
-        "ne",
-        "lt",
-        "gt",
-        "le",
-        "ge",
-        "remainder",
-        "matmul",
-    }
-    aliases = {
-        "subtract": "sub",
-        "multiply": "mul",
-        "floor_divide": "floordiv",
-        "true_divide": "truediv",
-        "power": "pow",
-        "remainder": "mod",
-        "divide": "div",
-        "equal": "eq",
-        "not_equal": "ne",
-        "less": "lt",
-        "less_equal": "le",
-        "greater": "gt",
-        "greater_equal": "ge",
-    }
-
-    # For op(., Array) -> Array.__r{op}__
-    flipped = {
-        "lt": "__gt__",
-        "le": "__ge__",
-        "gt": "__lt__",
-        "ge": "__le__",
-        "eq": "__eq__",
-        "ne": "__ne__",
-    }
-
-    op_name = ufunc.__name__
-    op_name = aliases.get(op_name, op_name)
-
-    def not_implemented(*args, **kwargs):
-        return NotImplemented
-
-    if method == "__call__" and op_name in special and kwargs.get("out") is None:
-        if isinstance(inputs[0], type(self)):
-            name = "__{}__".format(op_name)
-            return getattr(self, name, not_implemented)(inputs[1])
-        else:
-            name = flipped.get(op_name, "__r{}__".format(op_name))
-            return getattr(self, name, not_implemented)(inputs[0])
-    else:
-        return NotImplemented
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index d8b00bc629d44..3302ed9c219e6 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -2,20 +2,40 @@
 Functions for arithmetic and comparison operations on NumPy arrays and
 ExtensionArrays.
 """
+from functools import partial
+import operator
+from typing import Any, Optional, Union
+
 import numpy as np
 
-from pandas._libs import ops as libops
+from pandas._libs import Timedelta, Timestamp, lib, ops as libops
 
 from pandas.core.dtypes.cast import (
     construct_1d_object_array_from_listlike,
     find_common_type,
     maybe_upcast_putmask,
 )
-from pandas.core.dtypes.common import is_object_dtype, is_scalar
-from pandas.core.dtypes.generic import ABCIndex, ABCSeries
-from pandas.core.dtypes.missing import notna
+from pandas.core.dtypes.common import (
+    ensure_object,
+    is_bool_dtype,
+    is_integer_dtype,
+    is_list_like,
+    is_object_dtype,
+    is_scalar,
+)
+from pandas.core.dtypes.generic import (
+    ABCDatetimeArray,
+    ABCExtensionArray,
+    ABCIndex,
+    ABCIndexClass,
+    ABCSeries,
+    ABCTimedeltaArray,
+)
+from pandas.core.dtypes.missing import isna, notna
 
 from pandas.core.ops import missing
+from pandas.core.ops.dispatch import dispatch_to_extension_op, should_extension_dispatch
+from pandas.core.ops.invalid import invalid_comparison
 from pandas.core.ops.roperator import rpow
 
 
@@ -32,10 +52,10 @@ def comp_method_OBJECT_ARRAY(op, x, y):
         if isinstance(y, (ABCSeries, ABCIndex)):
             y = y.values
 
-        result = libops.vec_compare(x, y, op)
+        result = libops.vec_compare(x.ravel(), y, op)
     else:
-        result = libops.scalar_compare(x, y, op)
-    return result
+        result = libops.scalar_compare(x.ravel(), y, op)
+    return result.reshape(x.shape)
 
 
 def masked_arith_op(x, y, op):
@@ -75,7 +95,9 @@ def masked_arith_op(x, y, op):
 
     else:
         if not is_scalar(y):
-            raise TypeError(type(y))
+            raise TypeError(
+                f"Cannot broadcast np.ndarray with operand of type { type(y) }"
+            )
 
         # mask is only meaningful for x
         result = np.empty(x.size, dtype=x.dtype)
@@ -91,19 +113,19 @@ def masked_arith_op(x, y, op):
             with np.errstate(all="ignore"):
                 result[mask] = op(xrav[mask], y)
 
-    result, changed = maybe_upcast_putmask(result, ~mask, np.nan)
+    result, _ = maybe_upcast_putmask(result, ~mask, np.nan)
     result = result.reshape(x.shape)  # 2D compat
     return result
 
 
-def define_na_arithmetic_op(op, str_rep, eval_kwargs):
+def define_na_arithmetic_op(op, str_rep: str):
     def na_op(x, y):
-        return na_arithmetic_op(x, y, op, str_rep, eval_kwargs)
+        return na_arithmetic_op(x, y, op, str_rep)
 
     return na_op
 
 
-def na_arithmetic_op(left, right, op, str_rep, eval_kwargs):
+def na_arithmetic_op(left, right, op, str_rep: str):
     """
     Return the result of evaluating op on the passed in values.
 
@@ -114,7 +136,6 @@ def na_arithmetic_op(left, right, op, str_rep, eval_kwargs):
     left : np.ndarray
     right : np.ndarray or scalar
     str_rep : str or None
-    eval_kwargs : kwargs to pass to expressions
 
     Returns
     -------
@@ -127,8 +148,248 @@ def na_arithmetic_op(left, right, op, str_rep, eval_kwargs):
     import pandas.core.computation.expressions as expressions
 
     try:
-        result = expressions.evaluate(op, str_rep, left, right, **eval_kwargs)
+        result = expressions.evaluate(op, str_rep, left, right)
     except TypeError:
         result = masked_arith_op(left, right, op)
 
     return missing.dispatch_fill_zeros(op, left, right, result)
+
+
+def arithmetic_op(
+    left: Union[np.ndarray, ABCExtensionArray], right: Any, op, str_rep: str
+):
+    """
+    Evaluate an arithmetic operation `+`, `-`, `*`, `/`, `//`, `%`, `**`, ...
+
+    Parameters
+    ----------
+    left : np.ndarray or ExtensionArray
+    right : object
+        Cannot be a DataFrame or Index.  Series is *not* excluded.
+    op : {operator.add, operator.sub, ...}
+        Or one of the reversed variants from roperator.
+    str_rep : str
+
+    Returns
+    -------
+    ndarrray or ExtensionArray
+        Or a 2-tuple of these in the case of divmod or rdivmod.
+    """
+
+    from pandas.core.ops import maybe_upcast_for_op
+
+    # NB: We assume that extract_array has already been called
+    #  on `left` and `right`.
+    lvalues = left
+    rvalues = right
+
+    rvalues = maybe_upcast_for_op(rvalues, lvalues.shape)
+
+    if should_extension_dispatch(left, rvalues) or isinstance(
+        rvalues, (ABCTimedeltaArray, ABCDatetimeArray, Timestamp, Timedelta)
+    ):
+        # TimedeltaArray, DatetimeArray, and Timestamp are included here
+        #  because they have `freq` attribute which is handled correctly
+        #  by dispatch_to_extension_op.
+        # Timedelta is included because numexpr will fail on it, see GH#31457
+        res_values = dispatch_to_extension_op(op, lvalues, rvalues)
+
+    else:
+        with np.errstate(all="ignore"):
+            res_values = na_arithmetic_op(lvalues, rvalues, op, str_rep)
+
+    return res_values
+
+
+def comparison_op(
+    left: Union[np.ndarray, ABCExtensionArray], right: Any, op
+) -> Union[np.ndarray, ABCExtensionArray]:
+    """
+    Evaluate a comparison operation `=`, `!=`, `>=`, `>`, `<=`, or `<`.
+
+    Parameters
+    ----------
+    left : np.ndarray or ExtensionArray
+    right : object
+        Cannot be a DataFrame, Series, or Index.
+    op : {operator.eq, operator.ne, operator.gt, operator.ge, operator.lt, operator.le}
+
+    Returns
+    -------
+    ndarrray or ExtensionArray
+    """
+
+    # NB: We assume extract_array has already been called on left and right
+    lvalues = left
+    rvalues = right
+
+    rvalues = lib.item_from_zerodim(rvalues)
+    if isinstance(rvalues, list):
+        # TODO: same for tuples?
+        rvalues = np.asarray(rvalues)
+
+    if isinstance(rvalues, (np.ndarray, ABCExtensionArray, ABCIndexClass)):
+        # TODO: make this treatment consistent across ops and classes.
+        #  We are not catching all listlikes here (e.g. frozenset, tuple)
+        #  The ambiguous case is object-dtype.  See GH#27803
+        if len(lvalues) != len(rvalues):
+            raise ValueError("Lengths must match to compare")
+
+    if should_extension_dispatch(lvalues, rvalues):
+        res_values = dispatch_to_extension_op(op, lvalues, rvalues)
+
+    elif is_scalar(rvalues) and isna(rvalues):
+        # numpy does not like comparisons vs None
+        if op is operator.ne:
+            res_values = np.ones(lvalues.shape, dtype=bool)
+        else:
+            res_values = np.zeros(lvalues.shape, dtype=bool)
+
+    elif is_object_dtype(lvalues.dtype):
+        res_values = comp_method_OBJECT_ARRAY(op, lvalues, rvalues)
+
+    else:
+        op_name = f"__{op.__name__}__"
+        method = getattr(lvalues, op_name)
+        with np.errstate(all="ignore"):
+            res_values = method(rvalues)
+
+        if res_values is NotImplemented:
+            res_values = invalid_comparison(lvalues, rvalues, op)
+        if is_scalar(res_values):
+            typ = type(rvalues)
+            raise TypeError(f"Could not compare {typ} type with Series")
+
+    return res_values
+
+
+def na_logical_op(x: np.ndarray, y, op):
+    try:
+        # For exposition, write:
+        #  yarr = isinstance(y, np.ndarray)
+        #  yint = is_integer(y) or (yarr and y.dtype.kind == "i")
+        #  ybool = is_bool(y) or (yarr and y.dtype.kind == "b")
+        #  xint = x.dtype.kind == "i"
+        #  xbool = x.dtype.kind == "b"
+        # Then Cases where this goes through without raising include:
+        #  (xint or xbool) and (yint or bool)
+        result = op(x, y)
+    except TypeError:
+        if isinstance(y, np.ndarray):
+            # bool-bool dtype operations should be OK, should not get here
+            assert not (is_bool_dtype(x.dtype) and is_bool_dtype(y.dtype))
+            x = ensure_object(x)
+            y = ensure_object(y)
+            result = libops.vec_binop(x.ravel(), y.ravel(), op)
+        else:
+            # let null fall thru
+            assert lib.is_scalar(y)
+            if not isna(y):
+                y = bool(y)
+            try:
+                result = libops.scalar_binop(x, y, op)
+            except (
+                TypeError,
+                ValueError,
+                AttributeError,
+                OverflowError,
+                NotImplementedError,
+            ):
+                typ = type(y).__name__
+                raise TypeError(
+                    f"Cannot perform '{op.__name__}' with a dtyped [{x.dtype}] array "
+                    f"and scalar of type [{typ}]"
+                )
+
+    return result.reshape(x.shape)
+
+
+def logical_op(
+    left: Union[np.ndarray, ABCExtensionArray], right: Any, op
+) -> Union[np.ndarray, ABCExtensionArray]:
+    """
+    Evaluate a logical operation `|`, `&`, or `^`.
+
+    Parameters
+    ----------
+    left : np.ndarray or ExtensionArray
+    right : object
+        Cannot be a DataFrame, Series, or Index.
+    op : {operator.and_, operator.or_, operator.xor}
+        Or one of the reversed variants from roperator.
+
+    Returns
+    -------
+    ndarrray or ExtensionArray
+    """
+
+    fill_int = lambda x: x
+
+    def fill_bool(x, left=None):
+        # if `left` is specifically not-boolean, we do not cast to bool
+        if x.dtype.kind in ["c", "f", "O"]:
+            # dtypes that can hold NA
+            mask = isna(x)
+            if mask.any():
+                x = x.astype(object)
+                x[mask] = False
+
+        if left is None or is_bool_dtype(left.dtype):
+            x = x.astype(bool)
+        return x
+
+    is_self_int_dtype = is_integer_dtype(left.dtype)
+
+    right = lib.item_from_zerodim(right)
+    if is_list_like(right) and not hasattr(right, "dtype"):
+        # e.g. list, tuple
+        right = construct_1d_object_array_from_listlike(right)
+
+    # NB: We assume extract_array has already been called on left and right
+    lvalues = left
+    rvalues = right
+
+    if should_extension_dispatch(lvalues, rvalues):
+        res_values = dispatch_to_extension_op(op, lvalues, rvalues)
+
+    else:
+        if isinstance(rvalues, np.ndarray):
+            is_other_int_dtype = is_integer_dtype(rvalues.dtype)
+            rvalues = rvalues if is_other_int_dtype else fill_bool(rvalues, lvalues)
+
+        else:
+            # i.e. scalar
+            is_other_int_dtype = lib.is_integer(rvalues)
+
+        # For int vs int `^`, `|`, `&` are bitwise operators and return
+        #   integer dtypes.  Otherwise these are boolean ops
+        filler = fill_int if is_self_int_dtype and is_other_int_dtype else fill_bool
+
+        res_values = na_logical_op(lvalues, rvalues, op)
+        res_values = filler(res_values)  # type: ignore
+
+    return res_values
+
+
+def get_array_op(op, str_rep: Optional[str] = None):
+    """
+    Return a binary array operation corresponding to the given operator op.
+
+    Parameters
+    ----------
+    op : function
+        Binary operator from operator or roperator module.
+    str_rep : str or None, default None
+        str_rep to pass to arithmetic_op
+
+    Returns
+    -------
+    function
+    """
+    op_name = op.__name__.strip("_")
+    if op_name in {"eq", "ne", "lt", "le", "gt", "ge"}:
+        return partial(comparison_op, op=op)
+    elif op_name in {"and", "or", "xor", "rand", "ror", "rxor"}:
+        return partial(logical_op, op=op)
+    else:
+        return partial(arithmetic_op, op=op, str_rep=str_rep)
diff --git a/pandas/core/ops/common.py b/pandas/core/ops/common.py
new file mode 100644
index 0000000000000..f4b16cf4a0cf2
--- /dev/null
+++ b/pandas/core/ops/common.py
@@ -0,0 +1,66 @@
+"""
+Boilerplate functions used in defining binary operations.
+"""
+from functools import wraps
+
+from pandas._libs.lib import item_from_zerodim
+
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
+
+
+def unpack_zerodim_and_defer(name: str):
+    """
+    Boilerplate for pandas conventions in arithmetic and comparison methods.
+
+    Parameters
+    ----------
+    name : str
+
+    Returns
+    -------
+    decorator
+    """
+
+    def wrapper(method):
+        return _unpack_zerodim_and_defer(method, name)
+
+    return wrapper
+
+
+def _unpack_zerodim_and_defer(method, name: str):
+    """
+    Boilerplate for pandas conventions in arithmetic and comparison methods.
+
+    Ensure method returns NotImplemented when operating against "senior"
+    classes.  Ensure zero-dimensional ndarrays are always unpacked.
+
+    Parameters
+    ----------
+    method : binary method
+    name : str
+
+    Returns
+    -------
+    method
+    """
+
+    is_cmp = name.strip("__") in {"eq", "ne", "lt", "le", "gt", "ge"}
+
+    @wraps(method)
+    def new_method(self, other):
+
+        if is_cmp and isinstance(self, ABCIndexClass) and isinstance(other, ABCSeries):
+            # For comparison ops, Index does *not* defer to Series
+            pass
+        else:
+            for cls in [ABCDataFrame, ABCSeries, ABCIndexClass]:
+                if isinstance(self, cls):
+                    break
+                if isinstance(other, cls):
+                    return NotImplemented
+
+        other = item_from_zerodim(other)
+
+        return method(self, other)
+
+    return new_method
diff --git a/pandas/core/ops/dispatch.py b/pandas/core/ops/dispatch.py
new file mode 100644
index 0000000000000..61a3032c7a02c
--- /dev/null
+++ b/pandas/core/ops/dispatch.py
@@ -0,0 +1,126 @@
+"""
+Functions for defining unary operations.
+"""
+from typing import Any, Union
+
+import numpy as np
+
+from pandas.core.dtypes.common import (
+    is_datetime64_dtype,
+    is_extension_array_dtype,
+    is_integer_dtype,
+    is_object_dtype,
+    is_scalar,
+    is_timedelta64_dtype,
+)
+from pandas.core.dtypes.generic import ABCExtensionArray, ABCSeries
+
+from pandas.core.construction import array
+
+
+def should_extension_dispatch(left: ABCSeries, right: Any) -> bool:
+    """
+    Identify cases where Series operation should use dispatch_to_extension_op.
+
+    Parameters
+    ----------
+    left : Series
+    right : object
+
+    Returns
+    -------
+    bool
+    """
+    if (
+        is_extension_array_dtype(left.dtype)
+        or is_datetime64_dtype(left.dtype)
+        or is_timedelta64_dtype(left.dtype)
+    ):
+        return True
+
+    if not is_scalar(right) and is_extension_array_dtype(right):
+        # GH#22378 disallow scalar to exclude e.g. "category", "Int64"
+        return True
+
+    return False
+
+
+def should_series_dispatch(left, right, op):
+    """
+    Identify cases where a DataFrame operation should dispatch to its
+    Series counterpart.
+
+    Parameters
+    ----------
+    left : DataFrame
+    right : DataFrame or Series
+    op : binary operator
+
+    Returns
+    -------
+    override : bool
+    """
+    if left._is_mixed_type or right._is_mixed_type:
+        return True
+
+    if op.__name__.strip("_") in ["and", "or", "xor", "rand", "ror", "rxor"]:
+        # TODO: GH references for what this fixes
+        # Note: this check must come before the check for nonempty columns.
+        return True
+
+    if right.ndim == 1:
+        # operating with Series, short-circuit checks that would fail
+        #  with AttributeError.
+        return False
+
+    if not len(left.columns) or not len(right.columns):
+        # ensure obj.dtypes[0] exists for each obj
+        return False
+
+    ldtype = left.dtypes.iloc[0]
+    rdtype = right.dtypes.iloc[0]
+
+    if (is_timedelta64_dtype(ldtype) and is_integer_dtype(rdtype)) or (
+        is_timedelta64_dtype(rdtype) and is_integer_dtype(ldtype)
+    ):
+        # numpy integer dtypes as timedelta64 dtypes in this scenario
+        return True
+
+    if is_datetime64_dtype(ldtype) and is_object_dtype(rdtype):
+        # in particular case where right is an array of DateOffsets
+        return True
+
+    return False
+
+
+def dispatch_to_extension_op(
+    op, left: Union[ABCExtensionArray, np.ndarray], right: Any,
+):
+    """
+    Assume that left or right is a Series backed by an ExtensionArray,
+    apply the operator defined by op.
+
+    Parameters
+    ----------
+    op : binary operator
+    left : ExtensionArray or np.ndarray
+    right : object
+
+    Returns
+    -------
+    ExtensionArray or np.ndarray
+        2-tuple of these if op is divmod or rdivmod
+    """
+    # NB: left and right should already be unboxed, so neither should be
+    #  a Series or Index.
+
+    if left.dtype.kind in "mM" and isinstance(left, np.ndarray):
+        # We need to cast datetime64 and timedelta64 ndarrays to
+        #  DatetimeArray/TimedeltaArray.  But we avoid wrapping others in
+        #  PandasArray as that behaves poorly with e.g. IntegerArray.
+        left = array(left)
+
+    # The op calls will raise TypeError if the op is not defined
+    # on the ExtensionArray
+    res_values = op(left, right)
+    return res_values
diff --git a/pandas/core/ops/docstrings.py b/pandas/core/ops/docstrings.py
index 93f197366cf32..203ea3946d1b2 100644
--- a/pandas/core/ops/docstrings.py
+++ b/pandas/core/ops/docstrings.py
@@ -34,6 +34,7 @@ def _make_flex_doc(op_name, typ):
             op_name=op_name,
             equiv=equiv,
             reverse=op_desc["reverse"],
+            series_returns=op_desc["series_returns"],
         )
         if op_desc["series_examples"]:
             doc = doc_no_examples + op_desc["series_examples"]
@@ -233,25 +234,32 @@ def _make_flex_doc(op_name, typ):
 dtype: float64
 """
 
-_op_descriptions = {
+_returns_series = """Series\n    The result of the operation."""
+
+_returns_tuple = """2-Tuple of Series\n    The result of the operation."""
+
+_op_descriptions: Dict[str, Dict[str, Optional[str]]] = {
     # Arithmetic Operators
     "add": {
         "op": "+",
         "desc": "Addition",
         "reverse": "radd",
         "series_examples": _add_example_SERIES,
+        "series_returns": _returns_series,
     },
     "sub": {
         "op": "-",
         "desc": "Subtraction",
         "reverse": "rsub",
         "series_examples": _sub_example_SERIES,
+        "series_returns": _returns_series,
     },
     "mul": {
         "op": "*",
         "desc": "Multiplication",
         "reverse": "rmul",
         "series_examples": _mul_example_SERIES,
+        "series_returns": _returns_series,
         "df_examples": None,
     },
     "mod": {
@@ -259,12 +267,14 @@ def _make_flex_doc(op_name, typ):
         "desc": "Modulo",
         "reverse": "rmod",
         "series_examples": _mod_example_SERIES,
+        "series_returns": _returns_series,
     },
     "pow": {
         "op": "**",
         "desc": "Exponential power",
         "reverse": "rpow",
         "series_examples": _pow_example_SERIES,
+        "series_returns": _returns_series,
         "df_examples": None,
     },
     "truediv": {
@@ -272,6 +282,7 @@ def _make_flex_doc(op_name, typ):
         "desc": "Floating division",
         "reverse": "rtruediv",
         "series_examples": _div_example_SERIES,
+        "series_returns": _returns_series,
         "df_examples": None,
     },
     "floordiv": {
@@ -279,6 +290,7 @@ def _make_flex_doc(op_name, typ):
         "desc": "Integer division",
         "reverse": "rfloordiv",
         "series_examples": _floordiv_example_SERIES,
+        "series_returns": _returns_series,
         "df_examples": None,
     },
     "divmod": {
@@ -286,31 +298,53 @@ def _make_flex_doc(op_name, typ):
         "desc": "Integer division and modulo",
         "reverse": "rdivmod",
         "series_examples": None,
+        "series_returns": _returns_tuple,
         "df_examples": None,
     },
     # Comparison Operators
-    "eq": {"op": "==", "desc": "Equal to", "reverse": None, "series_examples": None},
+    "eq": {
+        "op": "==",
+        "desc": "Equal to",
+        "reverse": None,
+        "series_examples": None,
+        "series_returns": _returns_series,
+    },
     "ne": {
         "op": "!=",
         "desc": "Not equal to",
         "reverse": None,
         "series_examples": None,
+        "series_returns": _returns_series,
+    },
+    "lt": {
+        "op": "<",
+        "desc": "Less than",
+        "reverse": None,
+        "series_examples": None,
+        "series_returns": _returns_series,
     },
-    "lt": {"op": "<", "desc": "Less than", "reverse": None, "series_examples": None},
     "le": {
         "op": "<=",
         "desc": "Less than or equal to",
         "reverse": None,
         "series_examples": None,
+        "series_returns": _returns_series,
+    },
+    "gt": {
+        "op": ">",
+        "desc": "Greater than",
+        "reverse": None,
+        "series_examples": None,
+        "series_returns": _returns_series,
     },
-    "gt": {"op": ">", "desc": "Greater than", "reverse": None, "series_examples": None},
     "ge": {
         "op": ">=",
         "desc": "Greater than or equal to",
         "reverse": None,
         "series_examples": None,
+        "series_returns": _returns_series,
     },
-}  # type: Dict[str, Dict[str, Optional[str]]]
+}
 
 _op_names = list(_op_descriptions.keys())
 for key in _op_names:
@@ -339,8 +373,7 @@ def _make_flex_doc(op_name, typ):
 
 Returns
 -------
-Series
-    The result of the operation.
+{series_returns}
 
 See Also
 --------
@@ -387,7 +420,7 @@ def _make_flex_doc(op_name, typ):
 ----------
 other : scalar, sequence, Series, or DataFrame
     Any single or multiple element data structure, or list-like object.
-axis :  {{0 or 'index', 1 or 'columns'}}
+axis : {{0 or 'index', 1 or 'columns'}}
     Whether to compare by the index (0 or 'index') or columns
     (1 or 'columns'). For Series input, axis to match Series index on.
 level : int or label
@@ -541,7 +574,7 @@ def _make_flex_doc(op_name, typ):
 ----------
 other : scalar, sequence, Series, or DataFrame
     Any single or multiple element data structure, or list-like object.
-axis :  {{0 or 'index', 1 or 'columns'}}, default 'columns'
+axis : {{0 or 'index', 1 or 'columns'}}, default 'columns'
     Whether to compare by the index (0 or 'index') or columns
     (1 or 'columns').
 level : int or label
diff --git a/pandas/core/ops/invalid.py b/pandas/core/ops/invalid.py
index 013ff7689b221..cc4a1f11edd2b 100644
--- a/pandas/core/ops/invalid.py
+++ b/pandas/core/ops/invalid.py
@@ -30,11 +30,8 @@ def invalid_comparison(left, right, op):
     elif op is operator.ne:
         res_values = np.ones(left.shape, dtype=bool)
     else:
-        raise TypeError(
-            "Invalid comparison between dtype={dtype} and {typ}".format(
-                dtype=left.dtype, typ=type(right).__name__
-            )
-        )
+        typ = type(right).__name__
+        raise TypeError(f"Invalid comparison between dtype={left.dtype} and {typ}")
     return res_values
 
 
@@ -52,10 +49,8 @@ def make_invalid_op(name: str):
     """
 
     def invalid_op(self, other=None):
-        raise TypeError(
-            "cannot perform {name} with this index type: "
-            "{typ}".format(name=name, typ=type(self).__name__)
-        )
+        typ = type(self).__name__
+        raise TypeError(f"cannot perform {name} with this index type: {typ}")
 
     invalid_op.__name__ = name
     return invalid_op
diff --git a/pandas/core/ops/mask_ops.py b/pandas/core/ops/mask_ops.py
new file mode 100644
index 0000000000000..8fb81faf313d7
--- /dev/null
+++ b/pandas/core/ops/mask_ops.py
@@ -0,0 +1,178 @@
+"""
+Ops for masked arrays.
+"""
+from typing import Optional, Union
+
+import numpy as np
+
+from pandas._libs import lib, missing as libmissing
+
+
+def kleene_or(
+    left: Union[bool, np.ndarray],
+    right: Union[bool, np.ndarray],
+    left_mask: Optional[np.ndarray],
+    right_mask: Optional[np.ndarray],
+):
+    """
+    Boolean ``or`` using Kleene logic.
+
+    Values are NA where we have ``NA | NA`` or ``NA | False``.
+    ``NA | True`` is considered True.
+
+    Parameters
+    ----------
+    left, right : ndarray, NA, or bool
+        The values of the array.
+    left_mask, right_mask : ndarray, optional
+        The masks. Only one of these may be None, which implies that
+        the associated `left` or `right` value is a scalar.
+
+    Returns
+    -------
+    result, mask: ndarray[bool]
+        The result of the logical or, and the new mask.
+    """
+    # To reduce the number of cases, we ensure that `left` & `left_mask`
+    # always come from an array, not a scalar. This is safe, since because
+    # A | B == B | A
+    if left_mask is None:
+        return kleene_or(right, left, right_mask, left_mask)
+
+    assert isinstance(left, np.ndarray)
+
+    raise_for_nan(right, method="or")
+
+    if right is libmissing.NA:
+        result = left.copy()
+    else:
+        result = left | right
+
+    if right_mask is not None:
+        # output is unknown where (False & NA), (NA & False), (NA & NA)
+        left_false = ~(left | left_mask)
+        right_false = ~(right | right_mask)
+        mask = (
+            (left_false & right_mask)
+            | (right_false & left_mask)
+            | (left_mask & right_mask)
+        )
+    else:
+        if right is True:
+            mask = np.zeros_like(left_mask)
+        elif right is libmissing.NA:
+            mask = (~left & ~left_mask) | left_mask
+        else:
+            # False
+            mask = left_mask.copy()
+
+    return result, mask
+
+
+def kleene_xor(
+    left: Union[bool, np.ndarray],
+    right: Union[bool, np.ndarray],
+    left_mask: Optional[np.ndarray],
+    right_mask: Optional[np.ndarray],
+):
+    """
+    Boolean ``xor`` using Kleene logic.
+
+    This is the same as ``or``, with the following adjustments
+
+    * True, True -> False
+    * True, NA   -> NA
+
+    Parameters
+    ----------
+    left, right : ndarray, NA, or bool
+        The values of the array.
+    left_mask, right_mask : ndarray, optional
+        The masks. Only one of these may be None, which implies that
+        the associated `left` or `right` value is a scalar.
+
+    Returns
+    -------
+    result, mask: ndarray[bool]
+        The result of the logical xor, and the new mask.
+    """
+    if left_mask is None:
+        return kleene_xor(right, left, right_mask, left_mask)
+
+    raise_for_nan(right, method="xor")
+    if right is libmissing.NA:
+        result = np.zeros_like(left)
+    else:
+        result = left ^ right
+
+    if right_mask is None:
+        if right is libmissing.NA:
+            mask = np.ones_like(left_mask)
+        else:
+            mask = left_mask.copy()
+    else:
+        mask = left_mask | right_mask
+
+    return result, mask
+
+
+def kleene_and(
+    left: Union[bool, libmissing.NAType, np.ndarray],
+    right: Union[bool, libmissing.NAType, np.ndarray],
+    left_mask: Optional[np.ndarray],
+    right_mask: Optional[np.ndarray],
+):
+    """
+    Boolean ``and`` using Kleene logic.
+
+    Values are ``NA`` for ``NA & NA`` or ``True & NA``.
+
+    Parameters
+    ----------
+    left, right : ndarray, NA, or bool
+        The values of the array.
+    left_mask, right_mask : ndarray, optional
+        The masks. Only one of these may be None, which implies that
+        the associated `left` or `right` value is a scalar.
+
+    Returns
+    -------
+    result, mask: ndarray[bool]
+        The result of the logical xor, and the new mask.
+    """
+    # To reduce the number of cases, we ensure that `left` & `left_mask`
+    # always come from an array, not a scalar. This is safe, since because
+    # A | B == B | A
+    if left_mask is None:
+        return kleene_and(right, left, right_mask, left_mask)
+
+    assert isinstance(left, np.ndarray)
+    raise_for_nan(right, method="and")
+
+    if right is libmissing.NA:
+        result = np.zeros_like(left)
+    else:
+        result = left & right
+
+    if right_mask is None:
+        # Scalar `right`
+        if right is libmissing.NA:
+            mask = (left & ~left_mask) | left_mask
+
+        else:
+            mask = left_mask.copy()
+            if right is False:
+                # unmask everything
+                mask[:] = False
+    else:
+        # unmask where either left or right is False
+        left_false = ~(left | left_mask)
+        right_false = ~(right | right_mask)
+        mask = (left_mask & ~right_false) | (right_mask & ~left_false)
+
+    return result, mask
+
+
+def raise_for_nan(value, method):
+    if lib.is_float(value) and np.isnan(value):
+        raise ValueError(f"Cannot perform logical '{method}' with floating NaN")
diff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py
index eba0a797a791f..c04658565f235 100644
--- a/pandas/core/ops/methods.py
+++ b/pandas/core/ops/methods.py
@@ -3,12 +3,7 @@
 """
 import operator
 
-from pandas.core.dtypes.generic import (
-    ABCDataFrame,
-    ABCSeries,
-    ABCSparseArray,
-    ABCSparseSeries,
-)
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries, ABCSparseArray
 
 from pandas.core.ops.roperator import (
     radd,
@@ -51,7 +46,6 @@ def _get_method_wrappers(cls):
     from pandas.core.ops import (
         _arith_method_FRAME,
         _arith_method_SERIES,
-        _arith_method_SPARSE_SERIES,
         _bool_method_SERIES,
         _comp_method_FRAME,
         _comp_method_SERIES,
@@ -59,24 +53,14 @@ def _get_method_wrappers(cls):
         _flex_method_SERIES,
     )
 
-    if issubclass(cls, ABCSparseSeries):
-        # Be sure to catch this before ABCSeries and ABCSparseArray,
-        # as they will both come see SparseSeries as a subclass
-        arith_flex = _flex_method_SERIES
-        comp_flex = _flex_method_SERIES
-        arith_special = _arith_method_SPARSE_SERIES
-        comp_special = _arith_method_SPARSE_SERIES
-        bool_special = _bool_method_SERIES
-        # TODO: I don't think the functions defined by bool_method are tested
-    elif issubclass(cls, ABCSeries):
-        # Just Series; SparseSeries is caught above
+    if issubclass(cls, ABCSeries):
+        # Just Series
         arith_flex = _flex_method_SERIES
         comp_flex = _flex_method_SERIES
         arith_special = _arith_method_SERIES
         comp_special = _comp_method_SERIES
         bool_special = _bool_method_SERIES
     elif issubclass(cls, ABCDataFrame):
-        # Same for DataFrame and SparseDataFrame
         arith_flex = _arith_method_FRAME
         comp_flex = _flex_comp_method_FRAME
         arith_special = _arith_method_FRAME
@@ -118,7 +102,8 @@ def f(self, other):
 
             return self
 
-        f.__name__ = "__i{name}__".format(name=method.__name__.strip("__"))
+        name = method.__name__.strip("__")
+        f.__name__ = f"__i{name}__"
         return f
 
     new_methods.update(
@@ -176,9 +161,8 @@ def _create_methods(cls, arith_method, comp_method, bool_method, special):
     # constructors.
 
     have_divmod = issubclass(cls, ABCSeries)
-    # divmod is available for Series and SparseSeries
+    # divmod is available for Series
 
-    # yapf: disable
     new_methods = dict(
         add=arith_method(cls, operator.add, special),
         radd=arith_method(cls, radd, special),
@@ -197,8 +181,8 @@ def _create_methods(cls, arith_method, comp_method, bool_method, special):
         rtruediv=arith_method(cls, rtruediv, special),
         rfloordiv=arith_method(cls, rfloordiv, special),
         rpow=arith_method(cls, rpow, special),
-        rmod=arith_method(cls, rmod, special))
-    # yapf: enable
+        rmod=arith_method(cls, rmod, special),
+    )
     new_methods["div"] = new_methods["truediv"]
     new_methods["rdiv"] = new_methods["rtruediv"]
     if have_divmod:
@@ -231,7 +215,7 @@ def _create_methods(cls, arith_method, comp_method, bool_method, special):
         )
 
     if special:
-        dunderize = lambda x: "__{name}__".format(name=x.strip("_"))
+        dunderize = lambda x: f"__{x.strip('_')}__"
     else:
         dunderize = lambda x: x
     new_methods = {dunderize(k): v for k, v in new_methods.items()}
diff --git a/pandas/core/ops/missing.py b/pandas/core/ops/missing.py
index 4fe69f64bd0ae..854d6072eea36 100644
--- a/pandas/core/ops/missing.py
+++ b/pandas/core/ops/missing.py
@@ -1,7 +1,7 @@
 """
 Missing data handling for arithmetic operations.
 
-In particular, pandas conventions regarding divison by zero differ
+In particular, pandas conventions regarding division by zero differ
 from numpy in the following ways:
     1) np.array([-1, 0, 1], dtype=dtype1) // np.array([0, 0, 0], dtype=dtype2)
        gives [nan, nan, nan] for most dtype combinations, and [0, 0, 0] for
@@ -27,7 +27,7 @@
 
 from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype, is_scalar
 
-from .roperator import rdivmod, rfloordiv, rmod
+from pandas.core.ops.roperator import rdivmod, rfloordiv, rmod
 
 
 def fill_zeros(result, x, y):
@@ -109,26 +109,23 @@ def mask_zero_div_zero(x, y, result):
         return result
 
     if zmask.any():
-        shape = result.shape
 
         # Flip sign if necessary for -0.0
         zneg_mask = zmask & np.signbit(y)
         zpos_mask = zmask & ~zneg_mask
 
-        nan_mask = (zmask & (x == 0)).ravel()
+        nan_mask = zmask & (x == 0)
         with np.errstate(invalid="ignore"):
-            neginf_mask = ((zpos_mask & (x < 0)) | (zneg_mask & (x > 0))).ravel()
-            posinf_mask = ((zpos_mask & (x > 0)) | (zneg_mask & (x < 0))).ravel()
+            neginf_mask = (zpos_mask & (x < 0)) | (zneg_mask & (x > 0))
+            posinf_mask = (zpos_mask & (x > 0)) | (zneg_mask & (x < 0))
 
         if nan_mask.any() or neginf_mask.any() or posinf_mask.any():
             # Fill negative/0 with -inf, positive/0 with +inf, 0/0 with NaN
-            result = result.astype("float64", copy=False).ravel()
-
-            np.putmask(result, nan_mask, np.nan)
-            np.putmask(result, posinf_mask, np.inf)
-            np.putmask(result, neginf_mask, -np.inf)
+            result = result.astype("float64", copy=False)
 
-            result = result.reshape(shape)
+            result[nan_mask] = np.nan
+            result[posinf_mask] = np.inf
+            result[neginf_mask] = -np.inf
 
     return result
 
@@ -168,7 +165,7 @@ def dispatch_fill_zeros(op, left, right, result):
         # Note: no need to do this for truediv; in py3 numpy behaves the way
         #  we want.
         result = mask_zero_div_zero(left, right, result)
-    elif op is op is rfloordiv:
+    elif op is rfloordiv:
         # Note: no need to do this for rtruediv; in py3 numpy behaves the way
         #  we want.
         result = mask_zero_div_zero(right, left, result)
diff --git a/pandas/core/ops/roperator.py b/pandas/core/ops/roperator.py
index 4cb02238aea16..e6691ddf8984e 100644
--- a/pandas/core/ops/roperator.py
+++ b/pandas/core/ops/roperator.py
@@ -34,9 +34,8 @@ def rmod(left, right):
     # formatting operation; this is a TypeError
     # otherwise perform the op
     if isinstance(right, str):
-        raise TypeError(
-            "{typ} cannot perform the operation mod".format(typ=type(left).__name__)
-        )
+        typ = type(left).__name__
+        raise TypeError(f"{typ} cannot perform the operation mod")
 
     return right % left
 
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index a5d0e2cb3b58f..94ff1f0056663 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -2,7 +2,6 @@
 from datetime import timedelta
 from textwrap import dedent
 from typing import Dict, no_type_check
-import warnings
 
 import numpy as np
 
@@ -17,12 +16,14 @@
 from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
 
 import pandas.core.algorithms as algos
+from pandas.core.base import DataError, ShallowMixin
 from pandas.core.generic import _shared_docs
 from pandas.core.groupby.base import GroupByMixin
 from pandas.core.groupby.generic import SeriesGroupBy
-from pandas.core.groupby.groupby import GroupBy, _GroupBy, _pipe_template, groupby
+from pandas.core.groupby.groupby import GroupBy, _GroupBy, _pipe_template, get_groupby
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.groupby.ops import BinGrouper
+from pandas.core.indexes.api import Index
 from pandas.core.indexes.datetimes import DatetimeIndex, date_range
 from pandas.core.indexes.period import PeriodIndex, period_range
 from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
@@ -30,10 +31,10 @@
 from pandas.tseries.frequencies import to_offset
 from pandas.tseries.offsets import DateOffset, Day, Nano, Tick
 
-_shared_docs_kwargs = dict()  # type: Dict[str, str]
+_shared_docs_kwargs: Dict[str, str] = dict()
 
 
-class Resampler(_GroupBy):
+class Resampler(_GroupBy, ShallowMixin):
     """
     Class for resampling datetimelike data, a groupby-like operation.
     See aggregate, transform, and apply functions on this object.
@@ -85,20 +86,18 @@ def __init__(self, obj, groupby=None, axis=0, kind=None, **kwargs):
         if self.groupby is not None:
             self.groupby._set_grouper(self._convert_obj(obj), sort=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Provide a nice str repr of our rolling object.
         """
         attrs = (
-            "{k}={v}".format(k=k, v=getattr(self.groupby, k))
+            f"{k}={getattr(self.groupby, k)}"
             for k in self._attributes
             if getattr(self.groupby, k, None) is not None
         )
-        return "{klass} [{attrs}]".format(
-            klass=self.__class__.__name__, attrs=", ".join(attrs)
-        )
+        return f"{type(self).__name__} [{', '.join(attrs)}]"
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str):
         if attr in self._internal_names_set:
             return object.__getattribute__(self, attr)
         if attr in self._attributes:
@@ -133,7 +132,7 @@ def ax(self):
         return self.groupby.ax
 
     @property
-    def _typ(self):
+    def _typ(self) -> str:
         """
         Masquerade for compat as a Series or a DataFrame.
         """
@@ -142,7 +141,7 @@ def _typ(self):
         return "dataframe"
 
     @property
-    def _from_selection(self):
+    def _from_selection(self) -> bool:
         """
         Is the resampling from a DataFrame column or MultiIndex level.
         """
@@ -186,6 +185,7 @@ def _get_binner(self):
         """
 
         binner, bins, binlabels = self._get_binner_for_time()
+        assert len(bins) == len(binlabels)
         bin_grouper = BinGrouper(bins, binlabels, indexer=self.groupby.indexer)
         return binner, bin_grouper
 
@@ -317,7 +317,7 @@ def _downsample(self, f):
     def _upsample(self, f, limit=None, fill_value=None):
         raise AbstractMethodError(self)
 
-    def _gotitem(self, key, ndim, subset=None):
+    def _gotitem(self, key, ndim: int, subset=None):
         """
         Sub-classes to define. Return a sliced object.
 
@@ -333,7 +333,7 @@ def _gotitem(self, key, ndim, subset=None):
         grouper = self.grouper
         if subset is None:
             subset = self.obj
-        grouped = groupby(subset, by=None, grouper=grouper, axis=self.axis)
+        grouped = get_groupby(subset, by=None, grouper=grouper, axis=self.axis)
 
         # try the key selection
         try:
@@ -352,7 +352,7 @@ def _groupby_and_aggregate(self, how, grouper=None, *args, **kwargs):
 
         obj = self._selected_obj
 
-        grouped = groupby(obj, by=None, grouper=grouper, axis=self.axis)
+        grouped = get_groupby(obj, by=None, grouper=grouper, axis=self.axis)
 
         try:
             if isinstance(obj, ABCDataFrame) and callable(how):
@@ -360,7 +360,23 @@ def _groupby_and_aggregate(self, how, grouper=None, *args, **kwargs):
                 result = grouped._aggregate_item_by_item(how, *args, **kwargs)
             else:
                 result = grouped.aggregate(how, *args, **kwargs)
-        except Exception:
+        except DataError:
+            # we have a non-reducing function; try to evaluate
+            result = grouped.apply(how, *args, **kwargs)
+        except ValueError as err:
+            if "Must produce aggregated value" in str(err):
+                # raised in _aggregate_named
+                pass
+            elif "len(index) != len(labels)" in str(err):
+                # raised in libgroupby validation
+                pass
+            elif "No objects to concatenate" in str(err):
+                # raised in concat call
+                #  In tests this is reached via either
+                #  _apply_to_column_groupbys (ohlc) or DataFrameGroupBy.nunique
+                pass
+            else:
+                raise
 
             # we have a non-reducing function
             # try to evaluate
@@ -409,10 +425,7 @@ def _wrap_result(self, result):
 
         if isinstance(result, ABCSeries) and result.empty:
             obj = self.obj
-            if isinstance(obj.index, PeriodIndex):
-                result.index = obj.index.asfreq(self.freq)
-            else:
-                result.index = obj.index._shallow_copy(freq=self.freq)
+            result.index = _asfreq_compat(obj.index, freq=self.freq)
             result.name = getattr(obj, "name", None)
 
         return result
@@ -423,8 +436,8 @@ def pad(self, limit=None):
 
         Parameters
         ----------
-        limit : integer, optional
-            limit of how many values to fill
+        limit : int, optional
+            Limit of how many values to fill.
 
         Returns
         -------
@@ -514,7 +527,7 @@ def backfill(self, limit=None):
 
         Parameters
         ----------
-        limit : integer, optional
+        limit : int, optional
             Limit of how many values to fill.
 
         Returns
@@ -628,7 +641,7 @@ def fillna(self, method, limit=None):
             * 'backfill' or 'bfill': use next valid observation to fill gap.
             * 'nearest': use nearest valid observation to fill gap.
 
-        limit : integer, optional
+        limit : int, optional
             Limit of how many consecutive missing values to fill.
 
         Returns
@@ -776,7 +789,7 @@ def interpolate(
         limit_direction="forward",
         limit_area=None,
         downcast=None,
-        **kwargs
+        **kwargs,
     ):
         """
         Interpolate values according to different methods.
@@ -790,7 +803,7 @@ def interpolate(
             limit_direction=limit_direction,
             limit_area=limit_area,
             downcast=downcast,
-            **kwargs
+            **kwargs,
         )
 
     def asfreq(self, fill_value=None):
@@ -803,8 +816,6 @@ def asfreq(self, fill_value=None):
             Value to use for missing values, applied during upsampling (note
             this does not fill NaNs that already were present).
 
-            .. versionadded:: 0.20.0
-
         Returns
         -------
         DataFrame or Series
@@ -823,7 +834,7 @@ def std(self, ddof=1, *args, **kwargs):
 
         Parameters
         ----------
-        ddof : integer, default 1
+        ddof : int, default 1
             Degrees of freedom.
 
         Returns
@@ -840,8 +851,8 @@ def var(self, ddof=1, *args, **kwargs):
 
         Parameters
         ----------
-        ddof : integer, default 1
-            degrees of freedom
+        ddof : int, default 1
+            Degrees of freedom.
 
         Returns
         -------
@@ -853,13 +864,32 @@ def var(self, ddof=1, *args, **kwargs):
 
     @Appender(GroupBy.size.__doc__)
     def size(self):
-        # It's a special case as higher level does return
-        # a copy of 0-len objects. GH14962
         result = self._downsample("size")
-        if not len(self.ax) and isinstance(self._selected_obj, ABCDataFrame):
+        if not len(self.ax):
             from pandas import Series
 
-            result = Series([], index=result.index, dtype="int64")
+            if self._selected_obj.ndim == 1:
+                name = self._selected_obj.name
+            else:
+                name = None
+            result = Series([], index=result.index, dtype="int64", name=name)
+        return result
+
+    @Appender(GroupBy.count.__doc__)
+    def count(self):
+        result = self._downsample("count")
+        if not len(self.ax):
+            if self._selected_obj.ndim == 1:
+                result = type(self._selected_obj)(
+                    [], index=result.index, dtype="int64", name=self._selected_obj.name
+                )
+            else:
+                from pandas import DataFrame
+
+                result = DataFrame(
+                    [], index=result.index, columns=result.columns, dtype="int64"
+                )
+
         return result
 
     def quantile(self, q=0.5, **kwargs):
@@ -907,14 +937,6 @@ def g(self, _method=method, *args, **kwargs):
     g.__doc__ = getattr(GroupBy, method).__doc__
     setattr(Resampler, method, g)
 
-# groupby & aggregate methods
-for method in ["count"]:
-
-    def h(self, _method=method):
-        return self._downsample(_method)
-
-    h.__doc__ = getattr(GroupBy, method).__doc__
-    setattr(Resampler, method, h)
 
 # series only methods
 for method in ["nunique"]:
@@ -926,58 +948,6 @@ def h(self, _method=method):
     setattr(Resampler, method, h)
 
 
-def _maybe_process_deprecations(r, how=None, fill_method=None, limit=None):
-    """
-    Potentially we might have a deprecation warning, show it
-    but call the appropriate methods anyhow.
-    """
-
-    if how is not None:
-
-        # .resample(..., how='sum')
-        if isinstance(how, str):
-            method = "{0}()".format(how)
-
-            # .resample(..., how=lambda x: ....)
-        else:
-            method = ".apply(<func>)"
-
-        # if we have both a how and fill_method, then show
-        # the following warning
-        if fill_method is None:
-            warnings.warn(
-                "how in .resample() is deprecated\n"
-                "the new syntax is "
-                ".resample(...).{method}".format(method=method),
-                FutureWarning,
-                stacklevel=3,
-            )
-        r = r.aggregate(how)
-
-    if fill_method is not None:
-
-        # show the prior function call
-        method = "." + method if how is not None else ""
-
-        args = "limit={0}".format(limit) if limit is not None else ""
-        warnings.warn(
-            "fill_method is deprecated to .resample()\n"
-            "the new syntax is .resample(...){method}"
-            ".{fill_method}({args})".format(
-                method=method, fill_method=fill_method, args=args
-            ),
-            FutureWarning,
-            stacklevel=3,
-        )
-
-        if how is not None:
-            r = getattr(r, fill_method)(limit=limit)
-        else:
-            r = r.aggregate(fill_method, limit=limit)
-
-    return r
-
-
 class _GroupByMixin(GroupByMixin):
     """
     Provide the groupby facilities.
@@ -1053,7 +1023,7 @@ def _downsample(self, how, **kwargs):
         if not len(ax):
             # reset to the new freq
             obj = obj.copy()
-            obj.index.freq = self.freq
+            obj.index._set_freq(self.freq)
             return obj
 
         # do we have a regular frequency
@@ -1104,10 +1074,9 @@ def _upsample(self, method, limit=None, fill_value=None):
             raise AssertionError("axis must be 0")
         if self._from_selection:
             raise ValueError(
-                "Upsampling from level= or on= selection"
-                " is not supported, use .set_index(...)"
-                " to explicitly set index to"
-                " datetime-like"
+                "Upsampling from level= or on= selection "
+                "is not supported, use .set_index(...) "
+                "to explicitly set index to datetime-like"
             )
 
         ax = self.ax
@@ -1163,9 +1132,9 @@ def _convert_obj(self, obj):
         if self._from_selection:
             # see GH 14008, GH 12871
             msg = (
-                "Resampling from level= or on= selection"
-                " with a PeriodIndex is not currently supported,"
-                " use .set_index(...) to explicitly set index"
+                "Resampling from level= or on= selection "
+                "with a PeriodIndex is not currently supported, "
+                "use .set_index(...) to explicitly set index"
             )
             raise NotImplementedError(msg)
 
@@ -1213,8 +1182,8 @@ def _downsample(self, how, **kwargs):
             return self.asfreq()
 
         raise IncompatibleFrequency(
-            "Frequency {} cannot be resampled to {}, as they are not "
-            "sub or super periods".format(ax.freq, self.freq)
+            f"Frequency {ax.freq} cannot be resampled to {self.freq}, "
+            "as they are not sub or super periods"
         )
 
     def _upsample(self, method, limit=None, fill_value=None):
@@ -1222,11 +1191,11 @@ def _upsample(self, method, limit=None, fill_value=None):
         Parameters
         ----------
         method : string {'backfill', 'bfill', 'pad', 'ffill'}
-            method for upsampling
+            Method for upsampling.
         limit : int, default None
-            Maximum size gap to fill when reindexing
+            Maximum size gap to fill when reindexing.
         fill_value : scalar, default None
-            Value to use for missing values
+            Value to use for missing values.
 
         See Also
         --------
@@ -1291,7 +1260,7 @@ def _constructor(self):
         return TimedeltaIndexResampler
 
 
-def resample(obj, kind=None, **kwds):
+def get_resampler(obj, kind=None, **kwds):
     """
     Create a TimeGrouper and return our resampler.
     """
@@ -1299,7 +1268,7 @@ def resample(obj, kind=None, **kwds):
     return tg._get_resampler(obj, kind=kind)
 
 
-resample.__doc__ = Resampler.__doc__
+get_resampler.__doc__ = Resampler.__doc__
 
 
 def get_resampler_for_grouping(
@@ -1314,8 +1283,7 @@ def get_resampler_for_grouping(
 
     tg = TimeGrouper(freq=rule, **kwargs)
     resampler = tg._get_resampler(groupby.obj, kind=kind)
-    r = resampler._get_resampler_for_grouping(groupby=groupby)
-    return _maybe_process_deprecations(r, how=how, fill_method=fill_method, limit=limit)
+    return resampler._get_resampler_for_grouping(groupby=groupby)
 
 
 class TimeGrouper(Grouper):
@@ -1354,16 +1322,16 @@ def __init__(
         kind=None,
         convention=None,
         base=0,
-        **kwargs
+        **kwargs,
     ):
         # Check for correctness of the keyword arguments which would
         # otherwise silently use the default if misspelled
         if label not in {None, "left", "right"}:
-            raise ValueError("Unsupported value {} for `label`".format(label))
+            raise ValueError(f"Unsupported value {label} for `label`")
         if closed not in {None, "left", "right"}:
-            raise ValueError("Unsupported value {} for `closed`".format(closed))
+            raise ValueError(f"Unsupported value {closed} for `closed`")
         if convention not in {None, "start", "end", "e", "s"}:
-            raise ValueError("Unsupported value {} for `convention`".format(convention))
+            raise ValueError(f"Unsupported value {convention} for `convention`")
 
         freq = to_offset(freq)
 
@@ -1433,10 +1401,10 @@ def _get_resampler(self, obj, kind=None):
         raise TypeError(
             "Only valid with DatetimeIndex, "
             "TimedeltaIndex or PeriodIndex, "
-            "but got an instance of %r" % type(ax).__name__
+            f"but got an instance of '{type(ax).__name__}'"
         )
 
-    def _get_grouper(self, obj, validate=True):
+    def _get_grouper(self, obj, validate: bool = True):
         # create the resampler and return our binner
         r = self._get_resampler(obj)
         r._set_binner()
@@ -1446,7 +1414,7 @@ def _get_time_bins(self, ax):
         if not isinstance(ax, DatetimeIndex):
             raise TypeError(
                 "axis must be a DatetimeIndex, but got "
-                "an instance of %r" % type(ax).__name__
+                f"an instance of {type(ax).__name__}"
             )
 
         if len(ax) == 0:
@@ -1522,7 +1490,7 @@ def _get_time_delta_bins(self, ax):
         if not isinstance(ax, TimedeltaIndex):
             raise TypeError(
                 "axis must be a TimedeltaIndex, but got "
-                "an instance of %r" % type(ax).__name__
+                f"an instance of {type(ax).__name__}"
             )
 
         if not len(ax):
@@ -1547,7 +1515,7 @@ def _get_time_period_bins(self, ax):
         if not isinstance(ax, DatetimeIndex):
             raise TypeError(
                 "axis must be a DatetimeIndex, but got "
-                "an instance of %r" % type(ax).__name__
+                f"an instance of {type(ax).__name__}"
             )
 
         freq = self.freq
@@ -1569,7 +1537,7 @@ def _get_period_bins(self, ax):
         if not isinstance(ax, PeriodIndex):
             raise TypeError(
                 "axis must be a PeriodIndex, but got "
-                "an instance of %r" % type(ax).__name__
+                f"an instance of {type(ax).__name__}"
             )
 
         memb = ax.asfreq(self.freq, how=self.convention)
@@ -1616,7 +1584,10 @@ def _get_period_bins(self, ax):
         rng += freq_mult
         # adjust bin edge indexes to account for base
         rng -= bin_shift
-        bins = memb.searchsorted(rng, side="left")
+
+        # Wrap in PeriodArray for PeriodArray.searchsorted
+        prng = type(memb._data)(rng, dtype=memb.dtype)
+        bins = memb.searchsorted(prng, side="left")
 
         if nat_count > 0:
             # NaT handling as in pandas._lib.lib.generate_bins_dt64()
@@ -1728,8 +1699,8 @@ def _get_period_range_edges(first, last, offset, closed="left", base=0):
     # GH 23882
     first = first.to_timestamp()
     last = last.to_timestamp()
-    adjust_first = not offset.onOffset(first)
-    adjust_last = offset.onOffset(last)
+    adjust_first = not offset.is_on_offset(first)
+    adjust_last = offset.is_on_offset(last)
 
     first, last = _get_timestamp_range_edges(
         first, last, offset, closed=closed, base=base
@@ -1814,8 +1785,8 @@ def asfreq(obj, freq, method=None, how=None, normalize=False, fill_value=None):
 
     elif len(obj.index) == 0:
         new_obj = obj.copy()
-        new_obj.index = obj.index._shallow_copy(freq=to_offset(freq))
 
+        new_obj.index = _asfreq_compat(obj.index, freq)
     else:
         dti = date_range(obj.index[0], obj.index[-1], freq=freq)
         dti.name = obj.index.name
@@ -1824,3 +1795,28 @@ def asfreq(obj, freq, method=None, how=None, normalize=False, fill_value=None):
             new_obj.index = new_obj.index.normalize()
 
     return new_obj
+
+
+def _asfreq_compat(index, freq):
+    """
+    Helper to mimic asfreq on (empty) DatetimeIndex and TimedeltaIndex.
+
+    Parameters
+    ----------
+    index : PeriodIndex, DatetimeIndex, or TimedeltaIndex
+    freq : DateOffset
+
+    Returns
+    -------
+    same type as index
+    """
+    if len(index) != 0:
+        # This should never be reached, always checked by the caller
+        raise ValueError(
+            "Can only set arbitrary freq for empty DatetimeIndex or TimedeltaIndex"
+        )
+    if isinstance(index, PeriodIndex):
+        new_index = index.asfreq(freq=freq)
+    else:
+        new_index = Index([], dtype=index.dtype, freq=freq, name=index.name)
+    return new_index
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 4446f27da6be0..d9f21f0b274ac 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -1,25 +1,27 @@
 """
-concat routines
+Concat routines.
 """
 
-import warnings
+from typing import Hashable, Iterable, List, Mapping, Optional, Union, overload
 
 import numpy as np
 
-from pandas.core.dtypes.generic import ABCSparseDataFrame
+from pandas._typing import FrameOrSeriesUnion
+
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
 
 from pandas import DataFrame, Index, MultiIndex, Series
-from pandas.core import common as com
 from pandas.core.arrays.categorical import (
-    _factorize_from_iterable,
-    _factorize_from_iterables,
+    factorize_from_iterable,
+    factorize_from_iterables,
 )
+import pandas.core.common as com
 from pandas.core.generic import NDFrame
-from pandas.core.index import (
-    _all_indexes_same,
-    _get_consensus_names,
-    _get_objs_combined_axis,
+from pandas.core.indexes.api import (
+    all_indexes_same,
     ensure_index,
+    get_consensus_names,
+    get_objs_combined_axis,
 )
 import pandas.core.indexes.base as ibase
 from pandas.core.internals import concatenate_block_managers
@@ -28,19 +30,54 @@
 # Concatenate DataFrame objects
 
 
+@overload
+def concat(
+    objs: Union[Iterable["DataFrame"], Mapping[Optional[Hashable], "DataFrame"]],
+    axis=0,
+    join: str = "outer",
+    ignore_index: bool = False,
+    keys=None,
+    levels=None,
+    names=None,
+    verify_integrity: bool = False,
+    sort: bool = False,
+    copy: bool = True,
+) -> "DataFrame":
+    ...
+
+
+@overload
 def concat(
-    objs,
+    objs: Union[
+        Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]
+    ],
+    axis=0,
+    join: str = "outer",
+    ignore_index: bool = False,
+    keys=None,
+    levels=None,
+    names=None,
+    verify_integrity: bool = False,
+    sort: bool = False,
+    copy: bool = True,
+) -> FrameOrSeriesUnion:
+    ...
+
+
+def concat(
+    objs: Union[
+        Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]
+    ],
     axis=0,
     join="outer",
-    join_axes=None,
-    ignore_index=False,
+    ignore_index: bool = False,
     keys=None,
     levels=None,
     names=None,
-    verify_integrity=False,
-    sort=None,
-    copy=True,
-):
+    verify_integrity: bool = False,
+    sort: bool = False,
+    copy: bool = True,
+) -> FrameOrSeriesUnion:
     """
     Concatenate pandas objects along a particular axis with optional set logic
     along the other axes.
@@ -60,12 +97,6 @@ def concat(
         The axis to concatenate along.
     join : {'inner', 'outer'}, default 'outer'
         How to handle indexes on other axis (or axes).
-    join_axes : list of Index objects
-        .. deprecated:: 0.25.0
-
-        Specific indexes to use for the other n - 1 axes instead of performing
-        inner/outer set logic. Use .reindex() before or after concatenation
-        as a replacement.
     ignore_index : bool, default False
         If True, do not use the index values along the concatenation axis. The
         resulting axis will be labeled 0, ..., n - 1. This is useful if you are
@@ -83,18 +114,16 @@ def concat(
     verify_integrity : bool, default False
         Check whether the new concatenated axis contains duplicates. This can
         be very expensive relative to the actual data concatenation.
-    sort : bool, default None
+    sort : bool, default False
         Sort non-concatenation axis if it is not already aligned when `join`
-        is 'outer'. The current default of sorting is deprecated and will
-        change to not-sorting in a future version of pandas.
-
-        Explicitly pass ``sort=True`` to silence the warning and sort.
-        Explicitly pass ``sort=False`` to silence the warning and not sort.
-
+        is 'outer'.
         This has no effect when ``join='inner'``, which already preserves
         the order of the non-concatenation axis.
 
         .. versionadded:: 0.23.0
+        .. versionchanged:: 1.0.0
+
+           Changed to not sort by default.
 
     copy : bool, default True
         If False, do not copy data unnecessarily.
@@ -120,7 +149,7 @@ def concat(
 
     A walkthrough of how this method fits in with other tools for combining
     pandas objects can be found `here
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html>`__.
 
     Examples
     --------
@@ -246,7 +275,6 @@ def concat(
         axis=axis,
         ignore_index=ignore_index,
         join=join,
-        join_axes=join_axes,
         keys=keys,
         levels=levels,
         names=names,
@@ -267,21 +295,19 @@ def __init__(
         self,
         objs,
         axis=0,
-        join="outer",
-        join_axes=None,
+        join: str = "outer",
         keys=None,
         levels=None,
         names=None,
-        ignore_index=False,
-        verify_integrity=False,
-        copy=True,
+        ignore_index: bool = False,
+        verify_integrity: bool = False,
+        copy: bool = True,
         sort=False,
     ):
         if isinstance(objs, (NDFrame, str)):
             raise TypeError(
                 "first argument must be an iterable of pandas "
-                "objects, you passed an object of type "
-                '"{name}"'.format(name=type(objs).__name__)
+                f'objects, you passed an object of type "{type(objs).__name__}"'
             )
 
         if join == "outer":
@@ -295,7 +321,7 @@ def __init__(
 
         if isinstance(objs, dict):
             if keys is None:
-                keys = com.dict_keys_to_ordered_list(objs)
+                keys = list(objs.keys())
             objs = [objs[k] for k in keys]
         else:
             objs = list(objs)
@@ -326,8 +352,8 @@ def __init__(
         for obj in objs:
             if not isinstance(obj, (Series, DataFrame)):
                 msg = (
-                    "cannot concatenate object of type '{}';"
-                    " only Series and DataFrame objs are valid".format(type(obj))
+                    f"cannot concatenate object of type '{type(obj)}'; "
+                    "only Series and DataFrame objs are valid"
                 )
                 raise TypeError(msg)
 
@@ -370,15 +396,14 @@ def __init__(
             axis = sample._get_axis_number(axis)
 
         # Need to flip BlockManager axis in the DataFrame special case
-        self._is_frame = isinstance(sample, DataFrame)
+        self._is_frame = isinstance(sample, ABCDataFrame)
         if self._is_frame:
             axis = 1 if axis == 0 else 0
 
-        self._is_series = isinstance(sample, Series)
+        self._is_series = isinstance(sample, ABCSeries)
         if not 0 <= axis <= sample.ndim:
             raise AssertionError(
-                "axis must be between 0 and {ndim}, input was"
-                " {axis}".format(ndim=sample.ndim, axis=axis)
+                f"axis must be between 0 and {sample.ndim}, input was {axis}"
             )
 
         # if we have mixed ndims, then convert to highest ndim
@@ -415,7 +440,6 @@ def __init__(
 
         # note: this is the BlockManager axis (since DataFrame is transposed)
         self.axis = axis
-        self.join_axes = join_axes
         self.keys = keys
         self.names = names or getattr(keys, "names", None)
         self.levels = levels
@@ -439,13 +463,13 @@ def get_result(self):
                 mgr = self.objs[0]._data.concat(
                     [x._data for x in self.objs], self.new_axes
                 )
-                cons = _get_series_result_type(mgr, self.objs)
+                cons = self.objs[0]._constructor
                 return cons(mgr, name=name).__finalize__(self, method="concat")
 
             # combine as columns in a frame
             else:
                 data = dict(zip(range(len(self.objs)), self.objs))
-                cons = _get_series_result_type(data)
+                cons = DataFrame
 
                 index, columns = self.new_axes
                 df = cons(data, index=index)
@@ -475,64 +499,33 @@ def get_result(self):
             if not self.copy:
                 new_data._consolidate_inplace()
 
-            cons = _get_frame_result_type(new_data, self.objs)
-            return cons._from_axes(new_data, self.new_axes).__finalize__(
-                self, method="concat"
-            )
+            cons = self.objs[0]._constructor
+            return cons(new_data).__finalize__(self, method="concat")
 
-    def _get_result_dim(self):
+    def _get_result_dim(self) -> int:
         if self._is_series and self.axis == 1:
             return 2
         else:
             return self.objs[0].ndim
 
-    def _get_new_axes(self):
+    def _get_new_axes(self) -> List[Index]:
         ndim = self._get_result_dim()
-        new_axes = [None] * ndim
-
-        if self.join_axes is None:
-            for i in range(ndim):
-                if i == self.axis:
-                    continue
-                new_axes[i] = self._get_comb_axis(i)
-
-        else:
-            # GH 21951
-            warnings.warn(
-                "The join_axes-keyword is deprecated. Use .reindex or "
-                ".reindex_like on the result to achieve the same "
-                "functionality.",
-                FutureWarning,
-                stacklevel=4,
-            )
-
-            if len(self.join_axes) != ndim - 1:
-                raise AssertionError(
-                    "length of join_axes must be equal "
-                    "to {length}".format(length=ndim - 1)
-                )
-
-            # ufff...
-            indices = list(range(ndim))
-            indices.remove(self.axis)
-
-            for i, ax in zip(indices, self.join_axes):
-                new_axes[i] = ax
-
-        new_axes[self.axis] = self._get_concat_axis()
-        return new_axes
+        return [
+            self._get_concat_axis() if i == self.axis else self._get_comb_axis(i)
+            for i in range(ndim)
+        ]
 
-    def _get_comb_axis(self, i):
+    def _get_comb_axis(self, i: int) -> Index:
         data_axis = self.objs[0]._get_block_manager_axis(i)
-        try:
-            return _get_objs_combined_axis(
-                self.objs, axis=data_axis, intersect=self.intersect, sort=self.sort
-            )
-        except IndexError:
-            types = [type(x).__name__ for x in self.objs]
-            raise TypeError("Cannot concatenate list of {types}".format(types=types))
+        return get_objs_combined_axis(
+            self.objs,
+            axis=data_axis,
+            intersect=self.intersect,
+            sort=self.sort,
+            copy=self.copy,
+        )
 
-    def _get_concat_axis(self):
+    def _get_concat_axis(self) -> Index:
         """
         Return index to be used along concatenation axis.
         """
@@ -543,14 +536,14 @@ def _get_concat_axis(self):
                 idx = ibase.default_index(len(self.objs))
                 return idx
             elif self.keys is None:
-                names = [None] * len(self.objs)
+                names: List[Optional[Hashable]] = [None] * len(self.objs)
                 num = 0
                 has_names = False
                 for i, x in enumerate(self.objs):
                     if not isinstance(x, Series):
                         raise TypeError(
-                            "Cannot concatenate type 'Series' "
-                            "with object of type {type!r}".format(type=type(x).__name__)
+                            f"Cannot concatenate type 'Series' with "
+                            f"object of type '{type(x).__name__}'"
                         )
                     if x.name is not None:
                         names[i] = x.name
@@ -582,21 +575,18 @@ def _get_concat_axis(self):
 
         return concat_axis
 
-    def _maybe_check_integrity(self, concat_index):
+    def _maybe_check_integrity(self, concat_index: Index):
         if self.verify_integrity:
             if not concat_index.is_unique:
                 overlap = concat_index[concat_index.duplicated()].unique()
-                raise ValueError(
-                    "Indexes have overlapping values: "
-                    "{overlap!s}".format(overlap=overlap)
-                )
+                raise ValueError(f"Indexes have overlapping values: {overlap}")
 
 
-def _concat_indexes(indexes):
+def _concat_indexes(indexes) -> Index:
     return indexes[0].append(indexes[1:])
 
 
-def _make_concat_multiindex(indexes, keys, levels=None, names=None):
+def _make_concat_multiindex(indexes, keys, levels=None, names=None) -> MultiIndex:
 
     if (levels is None and isinstance(keys[0], tuple)) or (
         levels is not None and len(levels) > 1
@@ -606,7 +596,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
             names = [None] * len(zipped)
 
         if levels is None:
-            _, levels = _factorize_from_iterables(zipped)
+            _, levels = factorize_from_iterables(zipped)
         else:
             levels = [ensure_index(x) for x in levels]
     else:
@@ -619,7 +609,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
         else:
             levels = [ensure_index(x) for x in levels]
 
-    if not _all_indexes_same(indexes):
+    if not all_indexes_same(indexes):
         codes_list = []
 
         # things are potentially different sizes, so compute the exact codes
@@ -631,11 +621,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
                 try:
                     i = level.get_loc(key)
                 except KeyError:
-                    raise ValueError(
-                        "Key {key!s} not in level {level!s}".format(
-                            key=key, level=level
-                        )
-                    )
+                    raise ValueError(f"Key {key} not in level {level}")
 
                 to_concat.append(np.repeat(i, len(index)))
             codes_list.append(np.concatenate(to_concat))
@@ -647,7 +633,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
             levels.extend(concat_index.levels)
             codes_list.extend(concat_index.codes)
         else:
-            codes, categories = _factorize_from_iterable(concat_index)
+            codes, categories = factorize_from_iterable(concat_index)
             levels.append(categories)
             codes_list.append(codes)
 
@@ -657,12 +643,11 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
             # make sure that all of the passed indices have the same nlevels
             if not len({idx.nlevels for idx in indexes}) == 1:
                 raise AssertionError(
-                    "Cannot concat indices that do"
-                    " not have the same number of levels"
+                    "Cannot concat indices that do not have the same number of levels"
                 )
 
             # also copies
-            names = names + _get_consensus_names(indexes)
+            names = names + get_consensus_names(indexes)
 
         return MultiIndex(
             levels=levels, codes=codes_list, names=names, verify_integrity=False
@@ -687,11 +672,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
 
         mask = mapped == -1
         if mask.any():
-            raise ValueError(
-                "Values not found in passed level: {hlevel!s}".format(
-                    hlevel=hlevel[mask]
-                )
-            )
+            raise ValueError(f"Values not found in passed level: {hlevel[mask]!s}")
 
         new_codes.append(np.repeat(mapped, n))
 
@@ -708,37 +689,3 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
     return MultiIndex(
         levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False
     )
-
-
-def _get_series_result_type(result, objs=None):
-    """
-    return appropriate class of Series concat
-    input is either dict or array-like
-    """
-    from pandas import SparseSeries, SparseDataFrame, DataFrame
-
-    # concat Series with axis 1
-    if isinstance(result, dict):
-        # concat Series with axis 1
-        if all(isinstance(c, (SparseSeries, SparseDataFrame)) for c in result.values()):
-            return SparseDataFrame
-        else:
-            return DataFrame
-
-    # otherwise it is a SingleBlockManager (axis = 0)
-    return objs[0]._constructor
-
-
-def _get_frame_result_type(result, objs):
-    """
-    return appropriate class of DataFrame-like concat
-    if all blocks are sparse, return SparseDataFrame
-    otherwise, return 1st obj
-    """
-
-    if result.blocks and (any(isinstance(obj, ABCSparseDataFrame) for obj in objs)):
-        from pandas.core.sparse.api import SparseDataFrame
-
-        return SparseDataFrame
-    else:
-        return next(obj for obj in objs if not isinstance(obj, ABCSparseDataFrame))
diff --git a/pandas/core/reshape/melt.py b/pandas/core/reshape/melt.py
index 6f2e264f1a4d0..782b8043430e1 100644
--- a/pandas/core/reshape/melt.py
+++ b/pandas/core/reshape/melt.py
@@ -1,16 +1,18 @@
 import re
+from typing import List
 
 import numpy as np
 
-from pandas.util._decorators import Appender
+from pandas.util._decorators import Appender, deprecate_kwarg
 
-from pandas.core.dtypes.common import is_extension_type, is_list_like
+from pandas.core.dtypes.common import is_extension_array_dtype, is_list_like
 from pandas.core.dtypes.concat import concat_compat
 from pandas.core.dtypes.generic import ABCMultiIndex
 from pandas.core.dtypes.missing import notna
 
 from pandas.core.arrays import Categorical
-from pandas.core.frame import _shared_docs
+import pandas.core.common as com
+from pandas.core.frame import DataFrame, _shared_docs
 from pandas.core.indexes.base import Index
 from pandas.core.reshape.concat import concat
 from pandas.core.tools.numeric import to_numeric
@@ -21,13 +23,13 @@
     % dict(caller="pd.melt(df, ", versionadded="", other="DataFrame.melt")
 )
 def melt(
-    frame,
+    frame: DataFrame,
     id_vars=None,
     value_vars=None,
     var_name=None,
     value_name="value",
     col_level=None,
-):
+) -> DataFrame:
     # TODO: what about the existing index?
     # If multiindex, gather names of columns on all level for checking presence
     # of `id_vars` and `value_vars`
@@ -35,6 +37,7 @@ def melt(
         cols = [x for c in frame.columns for x in c]
     else:
         cols = list(frame.columns)
+
     if id_vars is not None:
         if not is_list_like(id_vars):
             id_vars = [id_vars]
@@ -45,12 +48,11 @@ def melt(
         else:
             # Check that `id_vars` are in frame
             id_vars = list(id_vars)
-            missing = Index(np.ravel(id_vars)).difference(cols)
+            missing = Index(com.flatten(id_vars)).difference(cols)
             if not missing.empty:
                 raise KeyError(
-                    "The following 'id_vars' are not present"
-                    " in the DataFrame: {missing}"
-                    "".format(missing=list(missing))
+                    "The following 'id_vars' are not present "
+                    f"in the DataFrame: {list(missing)}"
                 )
     else:
         id_vars = []
@@ -67,12 +69,11 @@ def melt(
         else:
             value_vars = list(value_vars)
             # Check that `value_vars` are in frame
-            missing = Index(np.ravel(value_vars)).difference(cols)
+            missing = Index(com.flatten(value_vars)).difference(cols)
             if not missing.empty:
                 raise KeyError(
-                    "The following 'value_vars' are not present in"
-                    " the DataFrame: {missing}"
-                    "".format(missing=list(missing))
+                    "The following 'value_vars' are not present in "
+                    f"the DataFrame: {list(missing)}"
                 )
         frame = frame.loc[:, id_vars + value_vars]
     else:
@@ -87,9 +88,7 @@ def melt(
             if len(frame.columns.names) == len(set(frame.columns.names)):
                 var_name = frame.columns.names
             else:
-                var_name = [
-                    "variable_{i}".format(i=i) for i in range(len(frame.columns.names))
-                ]
+                var_name = [f"variable_{i}" for i in range(len(frame.columns.names))]
         else:
             var_name = [
                 frame.columns.name if frame.columns.name is not None else "variable"
@@ -103,7 +102,7 @@ def melt(
     mdata = {}
     for col in id_vars:
         id_data = frame.pop(col)
-        if is_extension_type(id_data):
+        if is_extension_array_dtype(id_data):
             id_data = concat([id_data] * K, ignore_index=True)
         else:
             id_data = np.tile(id_data.values, K)
@@ -119,7 +118,8 @@ def melt(
     return frame._constructor(mdata, columns=mcolumns)
 
 
-def lreshape(data, groups, dropna=True, label=None):
+@deprecate_kwarg(old_arg_name="label", new_arg_name=None)
+def lreshape(data: DataFrame, groups, dropna: bool = True, label=None) -> DataFrame:
     """
     Reshape long-format data to wide. Generalized inverse of DataFrame.pivot
 
@@ -188,7 +188,9 @@ def lreshape(data, groups, dropna=True, label=None):
     return data._constructor(mdata, columns=id_cols + pivot_cols)
 
 
-def wide_to_long(df, stubnames, i, j, sep="", suffix=r"\d+"):
+def wide_to_long(
+    df: DataFrame, stubnames, i, j, sep: str = "", suffix: str = r"\d+"
+) -> DataFrame:
     r"""
     Wide panel to long format. Less flexible but more user-friendly than melt.
 
@@ -206,12 +208,12 @@ def wide_to_long(df, stubnames, i, j, sep="", suffix=r"\d+"):
     Parameters
     ----------
     df : DataFrame
-        The wide-format DataFrame
+        The wide-format DataFrame.
     stubnames : str or list-like
         The stub name(s). The wide format variables are assumed to
         start with the stub names.
     i : str or list-like
-        Column(s) to use as id variable(s)
+        Column(s) to use as id variable(s).
     j : str
         The name of the sub-observation variable. What you wish to name your
         suffix in the long format.
@@ -219,19 +221,14 @@ def wide_to_long(df, stubnames, i, j, sep="", suffix=r"\d+"):
         A character indicating the separation of the variable names
         in the wide format, to be stripped from the names in the long format.
         For example, if your column names are A-suffix1, A-suffix2, you
-        can strip the hyphen by specifying `sep='-'`
-
-        .. versionadded:: 0.20.0
-
+        can strip the hyphen by specifying `sep='-'`.
     suffix : str, default '\\d+'
         A regular expression capturing the wanted suffixes. '\\d+' captures
         numeric suffixes. Suffixes with no numbers could be specified with the
         negated character class '\\D+'. You can also further disambiguate
         suffixes, for example, if your wide variables are of the form
         A-one, B-two,.., and you have an unrelated column A-rating, you can
-        ignore the last one by specifying `suffix='(!?one|two)'`
-
-        .. versionadded:: 0.20.0
+        ignore the last one by specifying `suffix='(!?one|two)'`.
 
         .. versionchanged:: 0.23.0
             When all suffixes are numeric, they are cast to int64/float64.
@@ -365,7 +362,7 @@ def wide_to_long(df, stubnames, i, j, sep="", suffix=r"\d+"):
 
     >>> stubnames = sorted(
     ...     set([match[0] for match in df.columns.str.findall(
-    ...         r'[A-B]\(.*\)').values if match != [] ])
+    ...         r'[A-B]\(.*\)').values if match != []])
     ... )
     >>> list(stubnames)
     ['A(weekly)', 'B(weekly)']
@@ -417,14 +414,12 @@ def wide_to_long(df, stubnames, i, j, sep="", suffix=r"\d+"):
                 two  2.9
     """
 
-    def get_var_names(df, stub, sep, suffix):
-        regex = r"^{stub}{sep}{suffix}$".format(
-            stub=re.escape(stub), sep=re.escape(sep), suffix=suffix
-        )
+    def get_var_names(df, stub: str, sep: str, suffix: str) -> List[str]:
+        regex = fr"^{re.escape(stub)}{re.escape(sep)}{suffix}$"
         pattern = re.compile(regex)
         return [col for col in df.columns if pattern.match(col)]
 
-    def melt_stub(df, stub, i, j, value_vars, sep):
+    def melt_stub(df, stub: str, i, j, value_vars, sep: str):
         newdf = melt(
             df,
             id_vars=i,
@@ -461,8 +456,8 @@ def melt_stub(df, stub, i, j, value_vars, sep):
     value_vars_flattened = [e for sublist in value_vars for e in sublist]
     id_vars = list(set(df.columns.tolist()).difference(value_vars_flattened))
 
-    melted = [melt_stub(df, s, i, j, v, sep) for s, v in zip(stubnames, value_vars)]
-    melted = melted[0].join(melted[1:], how="outer")
+    _melted = [melt_stub(df, s, i, j, v, sep) for s, v in zip(stubnames, value_vars)]
+    melted = _melted[0].join(_melted[1:], how="outer")
 
     if len(i) == 1:
         new = df[id_vars].set_index(i).join(melted)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index d7fbe464cb1e5..480c5279ad3f6 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -3,14 +3,17 @@
 """
 
 import copy
+import datetime
 from functools import partial
 import string
+from typing import TYPE_CHECKING, Optional, Tuple, Union
 import warnings
 
 import numpy as np
 
-from pandas._libs import hashtable as libhashtable, lib
+from pandas._libs import Timedelta, hashtable as libhashtable, lib
 import pandas._libs.join as libjoin
+from pandas._typing import FrameOrSeries
 from pandas.errors import MergeError
 from pandas.util._decorators import Appender, Substitution
 
@@ -23,11 +26,9 @@
     is_bool_dtype,
     is_categorical_dtype,
     is_datetime64tz_dtype,
-    is_datetimelike,
     is_dtype_equal,
     is_extension_array_dtype,
     is_float_dtype,
-    is_int64_dtype,
     is_integer,
     is_integer_dtype,
     is_list_like,
@@ -36,35 +37,39 @@
     is_object_dtype,
     needs_i8_conversion,
 )
-from pandas.core.dtypes.missing import isnull, na_value_for_dtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import isna, na_value_for_dtype
 
-from pandas import Categorical, DataFrame, Index, MultiIndex, Series, Timedelta
+from pandas import Categorical, Index, MultiIndex
+from pandas.core import groupby
 import pandas.core.algorithms as algos
 from pandas.core.arrays.categorical import _recode_for_categories
 import pandas.core.common as com
 from pandas.core.frame import _merge_doc
 from pandas.core.internals import _transform_index, concatenate_block_managers
-import pandas.core.sorting as sorting
 from pandas.core.sorting import is_int64_overflow_possible
 
+if TYPE_CHECKING:
+    from pandas import DataFrame, Series  # noqa:F401
+
 
 @Substitution("\nleft : DataFrame")
 @Appender(_merge_doc, indents=0)
 def merge(
     left,
     right,
-    how="inner",
+    how: str = "inner",
     on=None,
     left_on=None,
     right_on=None,
-    left_index=False,
-    right_index=False,
-    sort=False,
+    left_index: bool = False,
+    right_index: bool = False,
+    sort: bool = False,
     suffixes=("_x", "_y"),
-    copy=True,
-    indicator=False,
+    copy: bool = True,
+    indicator: bool = False,
     validate=None,
-):
+) -> "DataFrame":
     op = _MergeOperation(
         left,
         right,
@@ -87,7 +92,9 @@ def merge(
     merge.__doc__ = _merge_doc % "\nleft : DataFrame"
 
 
-def _groupby_and_merge(by, on, left, right, _merge_pieces, check_duplicates=True):
+def _groupby_and_merge(
+    by, on, left, right: "DataFrame", _merge_pieces, check_duplicates: bool = True
+):
     """
     groupby & merge; we are always performing a left-by type operation
 
@@ -98,7 +105,7 @@ def _groupby_and_merge(by, on, left, right, _merge_pieces, check_duplicates=True
     left: left frame
     right: right frame
     _merge_pieces: function for merging
-    check_duplicates: boolean, default True
+    check_duplicates: bool, default True
         should we check & clean duplicates
     """
 
@@ -107,23 +114,27 @@ def _groupby_and_merge(by, on, left, right, _merge_pieces, check_duplicates=True
         by = [by]
 
     lby = left.groupby(by, sort=False)
+    rby: Optional[groupby.DataFrameGroupBy] = None
 
     # if we can groupby the rhs
     # then we can get vastly better perf
-    try:
-
-        # we will check & remove duplicates if indicated
-        if check_duplicates:
-            if on is None:
-                on = []
-            elif not isinstance(on, (list, tuple)):
-                on = [on]
 
-            if right.duplicated(by + on).any():
-                right = right.drop_duplicates(by + on, keep="last")
+    # we will check & remove duplicates if indicated
+    if check_duplicates:
+        if on is None:
+            on = []
+        elif not isinstance(on, (list, tuple)):
+            on = [on]
+
+        if right.duplicated(by + on).any():
+            _right = right.drop_duplicates(by + on, keep="last")
+            # TODO: use overload to refine return type of drop_duplicates
+            assert _right is not None  # needed for mypy
+            right = _right
+    try:
         rby = right.groupby(by, sort=False)
     except KeyError:
-        rby = None
+        pass
 
     for key, lhs in lby:
 
@@ -173,12 +184,13 @@ def merge_ordered(
     right_by=None,
     fill_method=None,
     suffixes=("_x", "_y"),
-    how="outer",
-):
+    how: str = "outer",
+) -> "DataFrame":
     """
-    Perform merge with optional filling/interpolation designed for ordered
-    data like time series data. Optionally perform group-wise merge (see
-    examples).
+    Perform merge with optional filling/interpolation.
+
+    Designed for ordered data like time series data. Optionally
+    perform group-wise merge (see examples).
 
     Parameters
     ----------
@@ -189,18 +201,18 @@ def merge_ordered(
     left_on : label or list, or array-like
         Field names to join on in left DataFrame. Can be a vector or list of
         vectors of the length of the DataFrame to use a particular vector as
-        the join key instead of columns
+        the join key instead of columns.
     right_on : label or list, or array-like
         Field names to join on in right DataFrame or vector/list of vectors per
-        left_on docs
+        left_on docs.
     left_by : column name or list of column names
         Group left DataFrame by group columns and merge piece by piece with
-        right DataFrame
+        right DataFrame.
     right_by : column name or list of column names
         Group right DataFrame by group columns and merge piece by piece with
-        left DataFrame
+        left DataFrame.
     fill_method : {'ffill', None}, default None
-        Interpolation method for data
+        Interpolation method for data.
     suffixes : Sequence, default is ("_x", "_y")
         A length-2 sequence where each element is optionally a string
         indicating the suffix to add to overlapping column names in
@@ -214,13 +226,13 @@ def merge_ordered(
         * left: use only keys from left frame (SQL: left outer join)
         * right: use only keys from right frame (SQL: right outer join)
         * outer: use union of keys from both frames (SQL: full outer join)
-        * inner: use intersection of keys from both frames (SQL: inner join)
+        * inner: use intersection of keys from both frames (SQL: inner join).
 
     Returns
     -------
-    merged : DataFrame
-        The output type will the be same as 'left', if it is a subclass
-        of DataFrame.
+    DataFrame
+        The merged DataFrame output type will the be same as
+        'left', if it is a subclass of DataFrame.
 
     See Also
     --------
@@ -229,15 +241,21 @@ def merge_ordered(
 
     Examples
     --------
-    >>> A                      >>> B
-          key  lvalue group        key  rvalue
-    0   a       1     a        0     b       1
-    1   c       2     a        1     c       2
-    2   e       3     a        2     d       3
+    >>> A
+          key  lvalue group
+    0   a       1     a
+    1   c       2     a
+    2   e       3     a
     3   a       1     b
     4   c       2     b
     5   e       3     b
 
+    >>> B
+        Key  rvalue
+    0     b       1
+    1     c       2
+    2     d       3
+
     >>> merge_ordered(A, B, fill_method='ffill', left_by='group')
       group key  lvalue  rvalue
     0     a   a       1     NaN
@@ -292,16 +310,16 @@ def merge_asof(
     on=None,
     left_on=None,
     right_on=None,
-    left_index=False,
-    right_index=False,
+    left_index: bool = False,
+    right_index: bool = False,
     by=None,
     left_by=None,
     right_by=None,
     suffixes=("_x", "_y"),
     tolerance=None,
-    allow_exact_matches=True,
-    direction="backward",
-):
+    allow_exact_matches: bool = True,
+    direction: str = "backward",
+) -> "DataFrame":
     """
     Perform an asof merge. This is similar to a left-join except that we
     match on nearest key rather than equal keys.
@@ -338,9 +356,9 @@ def merge_asof(
         Field name to join on in left DataFrame.
     right_on : label
         Field name to join on in right DataFrame.
-    left_index : boolean
+    left_index : bool
         Use the index of the left DataFrame as the join key.
-    right_index : boolean
+    right_index : bool
         Use the index of the right DataFrame as the join key.
     by : column name or list of column names
         Match on these columns before performing merge operation.
@@ -351,21 +369,19 @@ def merge_asof(
     suffixes : 2-length sequence (tuple, list, ...)
         Suffix to apply to overlapping column names in the left and right
         side, respectively.
-    tolerance : integer or Timedelta, optional, default None
+    tolerance : int or Timedelta, optional, default None
         Select asof tolerance within this range; must be compatible
         with the merge index.
-    allow_exact_matches : boolean, default True
+    allow_exact_matches : bool, default True
 
         - If True, allow matching with the same 'on' value
           (i.e. less-than-or-equal-to / greater-than-or-equal-to)
         - If False, don't match the same 'on' value
-          (i.e., strictly less-than / strictly greater-than)
+          (i.e., strictly less-than / strictly greater-than).
 
     direction : 'backward' (default), 'forward', or 'nearest'
         Whether to search for prior, subsequent, or closest matches.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
     merged : DataFrame
@@ -529,33 +545,33 @@ def merge_asof(
 # TODO: only copy DataFrames when modification necessary
 class _MergeOperation:
     """
-    Perform a database (SQL) merge operation between two DataFrame objects
-    using either columns as keys or their row indexes
+    Perform a database (SQL) merge operation between two DataFrame or Series
+    objects using either columns as keys or their row indexes
     """
 
     _merge_type = "merge"
 
     def __init__(
         self,
-        left,
-        right,
-        how="inner",
+        left: Union["Series", "DataFrame"],
+        right: Union["Series", "DataFrame"],
+        how: str = "inner",
         on=None,
         left_on=None,
         right_on=None,
         axis=1,
-        left_index=False,
-        right_index=False,
-        sort=True,
+        left_index: bool = False,
+        right_index: bool = False,
+        sort: bool = True,
         suffixes=("_x", "_y"),
-        copy=True,
-        indicator=False,
+        copy: bool = True,
+        indicator: bool = False,
         validate=None,
     ):
-        left = validate_operand(left)
-        right = validate_operand(right)
-        self.left = self.orig_left = left
-        self.right = self.orig_right = right
+        _left = _validate_operand(left)
+        _right = _validate_operand(right)
+        self.left = self.orig_left = _left
+        self.right = self.orig_right = _right
         self.how = how
         self.axis = axis
 
@@ -572,6 +588,7 @@ def __init__(
 
         self.indicator = indicator
 
+        self.indicator_name: Optional[str]
         if isinstance(self.indicator, str):
             self.indicator_name = self.indicator
         elif isinstance(self.indicator, bool):
@@ -583,21 +600,20 @@ def __init__(
 
         if not is_bool(left_index):
             raise ValueError(
-                "left_index parameter must be of type bool, not "
-                "{left_index}".format(left_index=type(left_index))
+                f"left_index parameter must be of type bool, not {type(left_index)}"
             )
         if not is_bool(right_index):
             raise ValueError(
-                "right_index parameter must be of type bool, not "
-                "{right_index}".format(right_index=type(right_index))
+                f"right_index parameter must be of type bool, not {type(right_index)}"
             )
 
         # warn user when merging between different levels
-        if left.columns.nlevels != right.columns.nlevels:
+        if _left.columns.nlevels != _right.columns.nlevels:
             msg = (
                 "merging between different levels can give an unintended "
-                "result ({left} levels on the left, {right} on the right)"
-            ).format(left=left.columns.nlevels, right=right.columns.nlevels)
+                f"result ({left.columns.nlevels} levels on the left,"
+                f"{right.columns.nlevels} on the right)"
+            )
             warnings.warn(msg, UserWarning)
 
         self._validate_specification()
@@ -654,7 +670,9 @@ def get_result(self):
 
         return result
 
-    def _indicator_pre_merge(self, left, right):
+    def _indicator_pre_merge(
+        self, left: "DataFrame", right: "DataFrame"
+    ) -> Tuple["DataFrame", "DataFrame"]:
 
         columns = left.columns.union(right.columns)
 
@@ -662,7 +680,7 @@ def _indicator_pre_merge(self, left, right):
             if i in columns:
                 raise ValueError(
                     "Cannot use `indicator=True` option when "
-                    "data contains a column named {name}".format(name=i)
+                    f"data contains a column named {i}"
                 )
         if self.indicator_name in columns:
             raise ValueError(
@@ -814,7 +832,7 @@ def _maybe_add_join_keys(self, result, left_indexer, right_indexer):
                     else:
                         result.index = Index(key_col, name=name)
                 else:
-                    result.insert(i, name or "key_{i}".format(i=i), key_col)
+                    result.insert(i, name or f"key_{i}", key_col)
 
     def _get_join_indexers(self):
         """ return the join indexers """
@@ -874,7 +892,12 @@ def _get_join_info(self):
         return join_index, left_indexer, right_indexer
 
     def _create_join_index(
-        self, index, other_index, indexer, other_indexer, how="left"
+        self,
+        index: Index,
+        other_index: Index,
+        indexer,
+        other_indexer,
+        how: str = "left",
     ):
         """
         Create a join index by rearranging one index to match another
@@ -1008,7 +1031,7 @@ def _get_merge_keys(self):
                     )
                 ]
             else:
-                left_keys = [self.left.index.values]
+                left_keys = [self.left.index._values]
 
         if left_drop:
             self.left = self.left._drop_labels_or_levels(left_drop)
@@ -1049,9 +1072,8 @@ def _maybe_coerce_merge_keys(self):
                 continue
 
             msg = (
-                "You are trying to merge on {lk_dtype} and "
-                "{rk_dtype} columns. If you wish to proceed "
-                "you should use pd.concat".format(lk_dtype=lk.dtype, rk_dtype=rk.dtype)
+                f"You are trying to merge on {lk.dtype} and "
+                f"{rk.dtype} columns. If you wish to proceed you should use pd.concat"
             )
 
             # if we are numeric, then allow differing
@@ -1068,8 +1090,7 @@ def _maybe_coerce_merge_keys(self):
                         warnings.warn(
                             "You are merging on int and float "
                             "columns where the float values "
-                            "are not equal to their int "
-                            "representation",
+                            "are not equal to their int representation",
                             UserWarning,
                         )
                     continue
@@ -1079,8 +1100,7 @@ def _maybe_coerce_merge_keys(self):
                         warnings.warn(
                             "You are merging on int and float "
                             "columns where the float values "
-                            "are not equal to their int "
-                            "representation",
+                            "are not equal to their int representation",
                             UserWarning,
                         )
                     continue
@@ -1122,9 +1142,9 @@ def _maybe_coerce_merge_keys(self):
                     raise ValueError(msg)
 
             # datetimelikes must match exactly
-            elif is_datetimelike(lk) and not is_datetimelike(rk):
+            elif needs_i8_conversion(lk) and not needs_i8_conversion(rk):
                 raise ValueError(msg)
-            elif not is_datetimelike(lk) and is_datetimelike(rk):
+            elif not needs_i8_conversion(lk) and needs_i8_conversion(rk):
                 raise ValueError(msg)
             elif is_datetime64tz_dtype(lk) and not is_datetime64tz_dtype(rk):
                 raise ValueError(msg)
@@ -1166,18 +1186,13 @@ def _validate_specification(self):
                 if len(common_cols) == 0:
                     raise MergeError(
                         "No common columns to perform merge on. "
-                        "Merge options: left_on={lon}, right_on={ron}, "
-                        "left_index={lidx}, right_index={ridx}".format(
-                            lon=self.left_on,
-                            ron=self.right_on,
-                            lidx=self.left_index,
-                            ridx=self.right_index,
-                        )
+                        f"Merge options: left_on={self.left_on}, "
+                        f"right_on={self.right_on}, "
+                        f"left_index={self.left_index}, "
+                        f"right_index={self.right_index}"
                     )
                 if not common_cols.is_unique:
-                    raise MergeError(
-                        "Data columns not unique: {common!r}".format(common=common_cols)
-                    )
+                    raise MergeError(f"Data columns not unique: {repr(common_cols)}")
                 self.left_on = self.right_on = common_cols
         elif self.on is not None:
             if self.left_on is not None or self.right_on is not None:
@@ -1207,7 +1222,7 @@ def _validate_specification(self):
         if len(self.right_on) != len(self.left_on):
             raise ValueError("len(right_on) must equal len(left_on)")
 
-    def _validate(self, validate):
+    def _validate(self, validate: str):
 
         # Check uniqueness of each
         if self.left_index:
@@ -1224,32 +1239,29 @@ def _validate(self, validate):
         if validate in ["one_to_one", "1:1"]:
             if not left_unique and not right_unique:
                 raise MergeError(
-                    "Merge keys are not unique in either left"
-                    " or right dataset; not a one-to-one merge"
+                    "Merge keys are not unique in either left "
+                    "or right dataset; not a one-to-one merge"
                 )
             elif not left_unique:
                 raise MergeError(
-                    "Merge keys are not unique in left dataset;"
-                    " not a one-to-one merge"
+                    "Merge keys are not unique in left dataset; not a one-to-one merge"
                 )
             elif not right_unique:
                 raise MergeError(
-                    "Merge keys are not unique in right dataset;"
-                    " not a one-to-one merge"
+                    "Merge keys are not unique in right dataset; not a one-to-one merge"
                 )
 
         elif validate in ["one_to_many", "1:m"]:
             if not left_unique:
                 raise MergeError(
-                    "Merge keys are not unique in left dataset;"
-                    " not a one-to-many merge"
+                    "Merge keys are not unique in left dataset; not a one-to-many merge"
                 )
 
         elif validate in ["many_to_one", "m:1"]:
             if not right_unique:
                 raise MergeError(
-                    "Merge keys are not unique in right dataset;"
-                    " not a many-to-one merge"
+                    "Merge keys are not unique in right dataset; "
+                    "not a many-to-one merge"
                 )
 
         elif validate in ["many_to_many", "m:m"]:
@@ -1259,14 +1271,16 @@ def _validate(self, validate):
             raise ValueError("Not a valid argument for validate")
 
 
-def _get_join_indexers(left_keys, right_keys, sort=False, how="inner", **kwargs):
+def _get_join_indexers(
+    left_keys, right_keys, sort: bool = False, how: str = "inner", **kwargs
+):
     """
 
     Parameters
     ----------
     left_keys: ndarray, Index, Series
     right_keys: ndarray, Index, Series
-    sort: boolean, default False
+    sort: bool, default False
     how: string {'inner', 'outer', 'left', 'right'}, default 'inner'
 
     Returns
@@ -1279,11 +1293,13 @@ def _get_join_indexers(left_keys, right_keys, sort=False, how="inner", **kwargs)
         right_keys
     ), "left_key and right_keys must be the same length"
 
-    # bind `sort` arg. of _factorize_keys
-    fkeys = partial(_factorize_keys, sort=sort)
-
     # get left & right join labels and num. of levels at each location
-    llab, rlab, shape = map(list, zip(*map(fkeys, left_keys, right_keys)))
+    mapped = (
+        _factorize_keys(left_keys[n], right_keys[n], sort=sort)
+        for n in range(len(left_keys))
+    )
+    zipped = zip(*mapped)
+    llab, rlab, shape = [list(x) for x in zipped]
 
     # get flat i8 keys from label lists
     lkey, rkey = _get_join_keys(llab, rlab, shape, sort)
@@ -1291,7 +1307,7 @@ def _get_join_indexers(left_keys, right_keys, sort=False, how="inner", **kwargs)
     # factorize keys to a dense i8 space
     # `count` is the num. of unique keys
     # set(lkey) | set(rkey) == range(count)
-    lkey, rkey, count = fkeys(lkey, rkey)
+    lkey, rkey, count = _factorize_keys(lkey, rkey, sort=sort)
 
     # preserve left frame order if how == 'left' and sort == False
     kwargs = copy.copy(kwargs)
@@ -1303,7 +1319,12 @@ def _get_join_indexers(left_keys, right_keys, sort=False, how="inner", **kwargs)
 
 
 def _restore_dropped_levels_multijoin(
-    left, right, dropped_level_names, join_index, lindexer, rindexer
+    left: MultiIndex,
+    right: MultiIndex,
+    dropped_level_names,
+    join_index,
+    lindexer,
+    rindexer,
 ):
     """
     *this is an internal non-public method*
@@ -1341,7 +1362,7 @@ def _restore_dropped_levels_multijoin(
 
     """
 
-    def _convert_to_mulitindex(index):
+    def _convert_to_mulitindex(index) -> MultiIndex:
         if isinstance(index, MultiIndex):
             return index
         else:
@@ -1401,13 +1422,13 @@ def __init__(
         on=None,
         left_on=None,
         right_on=None,
-        left_index=False,
-        right_index=False,
+        left_index: bool = False,
+        right_index: bool = False,
         axis=1,
         suffixes=("_x", "_y"),
-        copy=True,
+        copy: bool = True,
         fill_method=None,
-        how="outer",
+        how: str = "outer",
     ):
 
         self.fill_method = fill_method
@@ -1462,13 +1483,13 @@ def get_result(self):
         return result
 
 
-def _asof_function(direction):
-    name = "asof_join_{dir}".format(dir=direction)
+def _asof_function(direction: str):
+    name = f"asof_join_{direction}"
     return getattr(libjoin, name, None)
 
 
-def _asof_by_function(direction):
-    name = "asof_join_{dir}_on_X_by_Y".format(dir=direction)
+def _asof_by_function(direction: str):
+    name = f"asof_join_{direction}_on_X_by_Y"
     return getattr(libjoin, name, None)
 
 
@@ -1499,19 +1520,19 @@ def __init__(
         on=None,
         left_on=None,
         right_on=None,
-        left_index=False,
-        right_index=False,
+        left_index: bool = False,
+        right_index: bool = False,
         by=None,
         left_by=None,
         right_by=None,
         axis=1,
         suffixes=("_x", "_y"),
-        copy=True,
+        copy: bool = True,
         fill_method=None,
-        how="asof",
+        how: str = "asof",
         tolerance=None,
-        allow_exact_matches=True,
-        direction="backward",
+        allow_exact_matches: bool = True,
+        direction: str = "backward",
     ):
 
         self.by = by
@@ -1578,9 +1599,7 @@ def _validate_specification(self):
 
         # check 'direction' is valid
         if self.direction not in ["backward", "forward", "nearest"]:
-            raise MergeError(
-                "direction invalid: {direction}".format(direction=self.direction)
-            )
+            raise MergeError(f"direction invalid: {self.direction}")
 
     @property
     def _asof_key(self):
@@ -1605,21 +1624,17 @@ def _get_merge_keys(self):
                     # later with a ValueError, so we don't *need* to check
                     # for them here.
                     msg = (
-                        "incompatible merge keys [{i}] {lkdtype} and "
-                        "{rkdtype}, both sides category, but not equal ones".format(
-                            i=i, lkdtype=repr(lk.dtype), rkdtype=repr(rk.dtype)
-                        )
+                        f"incompatible merge keys [{i}] {repr(lk.dtype)} and "
+                        f"{repr(rk.dtype)}, both sides category, but not equal ones"
                     )
                 else:
                     msg = (
-                        "incompatible merge keys [{i}] {lkdtype} and "
-                        "{rkdtype}, must be the same type".format(
-                            i=i, lkdtype=repr(lk.dtype), rkdtype=repr(rk.dtype)
-                        )
+                        f"incompatible merge keys [{i}] {repr(lk.dtype)} and "
+                        f"{repr(rk.dtype)}, must be the same type"
                     )
                 raise MergeError(msg)
 
-        # validate tolerance; must be a Timedelta if we have a DTI
+        # validate tolerance; datetime.timedelta or Timedelta if we have a DTI
         if self.tolerance is not None:
 
             if self.left_index:
@@ -1628,19 +1643,17 @@ def _get_merge_keys(self):
                 lt = left_join_keys[-1]
 
             msg = (
-                "incompatible tolerance {tolerance}, must be compat "
-                "with type {lkdtype}".format(
-                    tolerance=type(self.tolerance), lkdtype=repr(lt.dtype)
-                )
+                f"incompatible tolerance {self.tolerance}, must be compat "
+                f"with type {repr(lk.dtype)}"
             )
 
-            if is_datetimelike(lt):
-                if not isinstance(self.tolerance, Timedelta):
+            if needs_i8_conversion(lt):
+                if not isinstance(self.tolerance, datetime.timedelta):
                     raise MergeError(msg)
                 if self.tolerance < Timedelta(0):
                     raise MergeError("tolerance must be positive")
 
-            elif is_int64_dtype(lt):
+            elif is_integer_dtype(lt):
                 if not is_integer(self.tolerance):
                     raise MergeError(msg)
                 if self.tolerance < 0:
@@ -1657,8 +1670,11 @@ def _get_merge_keys(self):
 
         # validate allow_exact_matches
         if not is_bool(self.allow_exact_matches):
-            msg = "allow_exact_matches must be boolean, passed {passed}"
-            raise MergeError(msg.format(passed=self.allow_exact_matches))
+            msg = (
+                "allow_exact_matches must be boolean, "
+                f"passed {self.allow_exact_matches}"
+            )
+            raise MergeError(msg)
 
         return left_join_keys, right_join_keys, join_names
 
@@ -1689,13 +1705,13 @@ def flip(xs):
         msg_missings = "Merge keys contain null values on {side} side"
 
         if not Index(left_values).is_monotonic:
-            if isnull(left_values).any():
+            if isna(left_values).any():
                 raise ValueError(msg_missings.format(side="left"))
             else:
                 raise ValueError(msg_sorted.format(side="left"))
 
         if not Index(right_values).is_monotonic:
-            if isnull(right_values).any():
+            if isna(right_values).any():
                 raise ValueError(msg_missings.format(side="right"))
             else:
                 raise ValueError(msg_sorted.format(side="right"))
@@ -1705,6 +1721,7 @@ def flip(xs):
             left_values = left_values.view("i8")
             right_values = right_values.view("i8")
             if tolerance is not None:
+                tolerance = Timedelta(tolerance)
                 tolerance = tolerance.value
 
         # a "by" parameter requires special handling
@@ -1747,13 +1764,15 @@ def flip(xs):
             return func(left_values, right_values, self.allow_exact_matches, tolerance)
 
 
-def _get_multiindex_indexer(join_keys, index, sort):
-
-    # bind `sort` argument
-    fkeys = partial(_factorize_keys, sort=sort)
+def _get_multiindex_indexer(join_keys, index: MultiIndex, sort: bool):
 
     # left & right join labels and num. of levels at each location
-    rcodes, lcodes, shape = map(list, zip(*map(fkeys, index.levels, join_keys)))
+    mapped = (
+        _factorize_keys(index.levels[n], join_keys[n], sort=sort)
+        for n in range(index.nlevels)
+    )
+    zipped = zip(*mapped)
+    rcodes, lcodes, shape = [list(x) for x in zipped]
     if sort:
         rcodes = list(map(np.take, rcodes, index.codes))
     else:
@@ -1776,12 +1795,12 @@ def _get_multiindex_indexer(join_keys, index, sort):
     lkey, rkey = _get_join_keys(lcodes, rcodes, shape, sort)
 
     # factorize keys to a dense i8 space
-    lkey, rkey, count = fkeys(lkey, rkey)
+    lkey, rkey, count = _factorize_keys(lkey, rkey, sort=sort)
 
     return libjoin.left_outer_join(lkey, rkey, count, sort=sort)
 
 
-def _get_single_indexer(join_key, index, sort=False):
+def _get_single_indexer(join_key, index, sort: bool = False):
     left_key, right_key, count = _factorize_keys(join_key, index, sort=sort)
 
     left_indexer, right_indexer = libjoin.left_outer_join(
@@ -1791,7 +1810,7 @@ def _get_single_indexer(join_key, index, sort=False):
     return left_indexer, right_indexer
 
 
-def _left_join_on_index(left_ax, right_ax, join_keys, sort=False):
+def _left_join_on_index(left_ax: Index, right_ax: Index, join_keys, sort: bool = False):
     if len(join_keys) > 1:
         if not (
             (isinstance(right_ax, MultiIndex) and len(join_keys) == right_ax.nlevels)
@@ -1799,8 +1818,7 @@ def _left_join_on_index(left_ax, right_ax, join_keys, sort=False):
             raise AssertionError(
                 "If more than one join key is given then "
                 "'right_ax' must be a MultiIndex and the "
-                "number of join keys must be the number of "
-                "levels in right_ax"
+                "number of join keys must be the number of levels in right_ax"
             )
 
         left_indexer, right_indexer = _get_multiindex_indexer(
@@ -1905,7 +1923,7 @@ def _factorize_keys(lk, rk, sort=True):
     return llab, rlab, count
 
 
-def _sort_labels(uniques, left, right):
+def _sort_labels(uniques: np.ndarray, left, right):
     if not isinstance(uniques, np.ndarray):
         # tuplesafe
         uniques = Index(uniques).values
@@ -1913,14 +1931,14 @@ def _sort_labels(uniques, left, right):
     llength = len(left)
     labels = np.concatenate([left, right])
 
-    _, new_labels = sorting.safe_sort(uniques, labels, na_sentinel=-1)
+    _, new_labels = algos.safe_sort(uniques, labels, na_sentinel=-1)
     new_labels = ensure_int64(new_labels)
     new_left, new_right = new_labels[:llength], new_labels[llength:]
 
     return new_left, new_right
 
 
-def _get_join_keys(llab, rlab, shape, sort):
+def _get_join_keys(llab, rlab, shape, sort: bool):
 
     # how many levels can be done without overflow
     pred = lambda i: not is_int64_overflow_possible(shape[:i])
@@ -1950,32 +1968,31 @@ def _get_join_keys(llab, rlab, shape, sort):
     return _get_join_keys(llab, rlab, shape, sort)
 
 
-def _should_fill(lname, rname):
+def _should_fill(lname, rname) -> bool:
     if not isinstance(lname, str) or not isinstance(rname, str):
         return True
     return lname == rname
 
 
-def _any(x):
+def _any(x) -> bool:
     return x is not None and com.any_not_none(*x)
 
 
-def validate_operand(obj):
-    if isinstance(obj, DataFrame):
+def _validate_operand(obj: FrameOrSeries) -> "DataFrame":
+    if isinstance(obj, ABCDataFrame):
         return obj
-    elif isinstance(obj, Series):
+    elif isinstance(obj, ABCSeries):
         if obj.name is None:
             raise ValueError("Cannot merge a Series without a name")
         else:
             return obj.to_frame()
     else:
         raise TypeError(
-            "Can only merge Series or DataFrame objects, "
-            "a {obj} was passed".format(obj=type(obj))
+            f"Can only merge Series or DataFrame objects, a {type(obj)} was passed"
         )
 
 
-def _items_overlap_with_suffix(left, lsuffix, right, rsuffix):
+def _items_overlap_with_suffix(left: Index, lsuffix, right: Index, rsuffix):
     """
     If two indices overlap, add suffixes to overlapping entries.
 
@@ -1987,10 +2004,7 @@ def _items_overlap_with_suffix(left, lsuffix, right, rsuffix):
         return left, right
 
     if not lsuffix and not rsuffix:
-        raise ValueError(
-            "columns overlap but no suffix specified: "
-            "{rename}".format(rename=to_rename)
-        )
+        raise ValueError(f"columns overlap but no suffix specified: {to_rename}")
 
     def renamer(x, suffix):
         """
@@ -2009,7 +2023,7 @@ def renamer(x, suffix):
         x : renamed column name
         """
         if x in to_rename and suffix is not None:
-            return "{x}{suffix}".format(x=x, suffix=suffix)
+            return f"{x}{suffix}"
         return x
 
     lrenamer = partial(renamer, suffix=lsuffix)
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index d653dd87308cf..b047e163c5565 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING, Callable, Dict, List, Tuple, Union
+
 import numpy as np
 
 from pandas.util._decorators import Appender, Substitution
@@ -9,11 +11,14 @@
 import pandas.core.common as com
 from pandas.core.frame import _shared_docs
 from pandas.core.groupby import Grouper
-from pandas.core.index import Index, MultiIndex, _get_objs_combined_axis
+from pandas.core.indexes.api import Index, MultiIndex, get_objs_combined_axis
 from pandas.core.reshape.concat import concat
 from pandas.core.reshape.util import cartesian_product
 from pandas.core.series import Series
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
 # Note: We need to make sure `frame` is imported before `pivot`, otherwise
 # _shared_docs['pivot_table'] will not yet exist.  TODO: Fix this dependency
@@ -30,12 +35,12 @@ def pivot_table(
     dropna=True,
     margins_name="All",
     observed=False,
-):
+) -> "DataFrame":
     index = _convert_by(index)
     columns = _convert_by(columns)
 
     if isinstance(aggfunc, list):
-        pieces = []
+        pieces: List[DataFrame] = []
         keys = []
         for func in aggfunc:
             table = pivot_table(
@@ -112,7 +117,9 @@ def pivot_table(
                 agged[v] = maybe_downcast_to_dtype(agged[v], data[v].dtype)
 
     table = agged
-    if table.index.nlevels > 1:
+
+    # GH17038, this check should only happen if index is defined (not None)
+    if table.index.nlevels > 1 and index:
         # Related GH #17123
         # If index_names are integers, determine whether the integers refer
         # to the level position or name.
@@ -127,13 +134,13 @@ def pivot_table(
         table = agged.unstack(to_unstack)
 
     if not dropna:
-        if table.index.nlevels > 1:
+        if isinstance(table.index, MultiIndex):
             m = MultiIndex.from_arrays(
                 cartesian_product(table.index.levels), names=table.index.names
             )
             table = table.reindex(m, axis=0)
 
-        if table.columns.nlevels > 1:
+        if isinstance(table.columns, MultiIndex):
             m = MultiIndex.from_arrays(
                 cartesian_product(table.columns.levels), names=table.columns.names
             )
@@ -143,7 +150,7 @@ def pivot_table(
         table = table.sort_index(axis=1)
 
     if fill_value is not None:
-        table = table.fillna(value=fill_value, downcast="infer")
+        table = table._ensure_type(table.fillna(fill_value, downcast="infer"))
 
     if margins:
         if dropna:
@@ -180,32 +187,33 @@ def pivot_table(
 
 
 def _add_margins(
-    table,
+    table: Union["Series", "DataFrame"],
     data,
     values,
     rows,
     cols,
     aggfunc,
     observed=None,
-    margins_name="All",
+    margins_name: str = "All",
     fill_value=None,
 ):
     if not isinstance(margins_name, str):
         raise ValueError("margins_name argument must be a string")
 
-    msg = 'Conflicting name "{name}" in margins'.format(name=margins_name)
+    msg = f'Conflicting name "{margins_name}" in margins'
     for level in table.index.names:
         if margins_name in table.index.get_level_values(level):
             raise ValueError(msg)
 
     grand_margin = _compute_grand_margin(data, values, aggfunc, margins_name)
 
-    # could be passed a Series object with no 'columns'
-    if hasattr(table, "columns"):
+    if table.ndim == 2:
+        # i.e. DataFramae
         for level in table.columns.names[1:]:
             if margins_name in table.columns.get_level_values(level):
                 raise ValueError(msg)
 
+    key: Union[str, Tuple[str, ...]]
     if len(rows) > 1:
         key = (margins_name,) + ("",) * (len(rows) - 1)
     else:
@@ -216,28 +224,23 @@ def _add_margins(
         # one column in the data. Compute grand margin and return it.
         return table.append(Series({key: grand_margin[margins_name]}))
 
-    if values:
+    elif values:
         marginal_result_set = _generate_marginal_results(
-            table,
-            data,
-            values,
-            rows,
-            cols,
-            aggfunc,
-            observed,
-            grand_margin,
-            margins_name,
+            table, data, values, rows, cols, aggfunc, observed, margins_name,
         )
         if not isinstance(marginal_result_set, tuple):
             return marginal_result_set
         result, margin_keys, row_margin = marginal_result_set
     else:
+        # no values, and table is a DataFrame
+        assert isinstance(table, ABCDataFrame)
         marginal_result_set = _generate_marginal_results_without_values(
             table, data, rows, cols, aggfunc, observed, margins_name
         )
         if not isinstance(marginal_result_set, tuple):
             return marginal_result_set
         result, margin_keys, row_margin = marginal_result_set
+
     row_margin = row_margin.reindex(result.columns, fill_value=fill_value)
     # populate grand margin
     for k in margin_keys:
@@ -252,9 +255,12 @@ def _add_margins(
 
     row_names = result.index.names
     try:
+        # check the result column and leave floats
         for dtype in set(result.dtypes):
             cols = result.select_dtypes([dtype]).columns
-            margin_dummy[cols] = margin_dummy[cols].astype(dtype)
+            margin_dummy[cols] = margin_dummy[cols].apply(
+                maybe_downcast_to_dtype, args=(dtype,)
+            )
         result = result.append(margin_dummy)
     except TypeError:
 
@@ -266,7 +272,7 @@ def _add_margins(
     return result
 
 
-def _compute_grand_margin(data, values, aggfunc, margins_name="All"):
+def _compute_grand_margin(data, values, aggfunc, margins_name: str = "All"):
 
     if values:
         grand_margin = {}
@@ -289,7 +295,7 @@ def _compute_grand_margin(data, values, aggfunc, margins_name="All"):
 
 
 def _generate_marginal_results(
-    table, data, values, rows, cols, aggfunc, observed, grand_margin, margins_name="All"
+    table, data, values, rows, cols, aggfunc, observed, margins_name: str = "All",
 ):
     if len(cols) > 0:
         # need to "interleave" the margins
@@ -323,12 +329,22 @@ def _all_key(key):
                 table_pieces.append(piece)
                 margin_keys.append(all_key)
         else:
-            margin = grand_margin
+            from pandas import DataFrame
+
             cat_axis = 0
             for key, piece in table.groupby(level=0, axis=cat_axis, observed=observed):
-                all_key = _all_key(key)
+                if len(cols) > 1:
+                    all_key = _all_key(key)
+                else:
+                    all_key = margins_name
                 table_pieces.append(piece)
-                table_pieces.append(Series(margin[key], index=[all_key]))
+                # GH31016 this is to calculate margin for each group, and assign
+                # corresponded key as index
+                transformed_piece = DataFrame(piece.apply(aggfunc)).T
+                transformed_piece.index = Index([all_key], name=piece.index.name)
+
+                # append piece for margin into table_piece
+                table_pieces.append(transformed_piece)
                 margin_keys.append(all_key)
 
         result = concat(table_pieces, axis=cat_axis)
@@ -353,11 +369,11 @@ def _all_key(key):
 
 
 def _generate_marginal_results_without_values(
-    table, data, rows, cols, aggfunc, observed, margins_name="All"
+    table: "DataFrame", data, rows, cols, aggfunc, observed, margins_name: str = "All"
 ):
     if len(cols) > 0:
         # need to "interleave" the margins
-        margin_keys = []
+        margin_keys: Union[List, Index] = []
 
         def _all_key():
             if len(cols) == 1:
@@ -406,17 +422,34 @@ def _convert_by(by):
 
 @Substitution("\ndata : DataFrame")
 @Appender(_shared_docs["pivot"], indents=1)
-def pivot(data, index=None, columns=None, values=None):
+def pivot(data: "DataFrame", index=None, columns=None, values=None) -> "DataFrame":
+    if columns is None:
+        raise TypeError("pivot() missing 1 required argument: 'columns'")
+    columns = columns if is_list_like(columns) else [columns]
+
     if values is None:
-        cols = [columns] if index is None else [index, columns]
+        cols: List[str] = []
+        if index is None:
+            pass
+        elif is_list_like(index):
+            cols = list(index)
+        else:
+            cols = [index]
+        cols.extend(columns)
+
         append = index is None
         indexed = data.set_index(cols, append=append)
     else:
         if index is None:
-            index = data.index
+            index = [Series(data.index, name=data.index.name)]
+        elif is_list_like(index):
+            index = [data[idx] for idx in index]
         else:
-            index = data[index]
-        index = MultiIndex.from_arrays([index, data[columns]])
+            index = [data[index]]
+
+        data_columns = [data[col] for col in columns]
+        index.extend(data_columns)
+        index = MultiIndex.from_arrays(index)
 
         if is_list_like(values) and not isinstance(values, tuple):
             # Exclude tuple because it is seen as a single column name
@@ -436,10 +469,10 @@ def crosstab(
     colnames=None,
     aggfunc=None,
     margins=False,
-    margins_name="All",
-    dropna=True,
+    margins_name: str = "All",
+    dropna: bool = True,
     normalize=False,
-):
+) -> "DataFrame":
     """
     Compute a simple cross tabulation of two (or more) factors. By default
     computes a frequency table of the factors unless an array of values and an
@@ -541,9 +574,12 @@ def crosstab(
     rownames = _get_names(index, rownames, prefix="row")
     colnames = _get_names(columns, colnames, prefix="col")
 
-    common_idx = _get_objs_combined_axis(index + columns, intersect=True, sort=False)
+    common_idx = None
+    pass_objs = [x for x in index + columns if isinstance(x, (ABCSeries, ABCDataFrame))]
+    if pass_objs:
+        common_idx = get_objs_combined_axis(pass_objs, intersect=True, sort=False)
 
-    data = {}
+    data: Dict = {}
     data.update(zip(rownames, index))
     data.update(zip(colnames, columns))
 
@@ -556,6 +592,8 @@ def crosstab(
     from pandas import DataFrame
 
     df = DataFrame(data, index=common_idx)
+    original_df_cols = df.columns
+
     if values is None:
         df["__dummy__"] = 0
         kwargs = {"aggfunc": len, "fill_value": 0}
@@ -564,15 +602,21 @@ def crosstab(
         kwargs = {"aggfunc": aggfunc}
 
     table = df.pivot_table(
-        "__dummy__",
+        ["__dummy__"],
         index=rownames,
         columns=colnames,
         margins=margins,
         margins_name=margins_name,
         dropna=dropna,
-        **kwargs
+        **kwargs,
     )
 
+    # GH18321, after pivoting, an extra top level of column index of `__dummy__` is
+    # created, and this extra level should not be included in the further steps
+    if not table.empty:
+        cols_diff = df.columns.difference(original_df_cols)[0]
+        table = table[cols_diff]
+
     # Post-process
     if normalize is not False:
         table = _normalize(
@@ -582,7 +626,7 @@ def crosstab(
     return table
 
 
-def _normalize(table, normalize, margins, margins_name="All"):
+def _normalize(table, normalize, margins: bool, margins_name="All"):
 
     if not isinstance(normalize, (bool, str)):
         axis_subs = {0: "index", 1: "columns"}
@@ -594,7 +638,7 @@ def _normalize(table, normalize, margins, margins_name="All"):
     if margins is False:
 
         # Actual Normalizations
-        normalizers = {
+        normalizers: Dict[Union[bool, str], Callable] = {
             "all": lambda x: x / x.sum(axis=1).sum(axis=0),
             "columns": lambda x: x / x.sum(),
             "index": lambda x: x.div(x.sum(axis=1), axis=0),
@@ -620,7 +664,7 @@ def _normalize(table, normalize, margins, margins_name="All"):
         if (margins_name not in table.iloc[-1, :].name) | (
             margins_name != table.iloc[:, -1].name
         ):
-            raise ValueError("{} not in pivoted DataFrame".format(margins_name))
+            raise ValueError(f"{margins_name} not in pivoted DataFrame")
         column_margin = table.iloc[:-1, -1]
         index_margin = table.iloc[-1, :-1]
 
@@ -663,14 +707,14 @@ def _normalize(table, normalize, margins, margins_name="All"):
     return table
 
 
-def _get_names(arrs, names, prefix="row"):
+def _get_names(arrs, names, prefix: str = "row"):
     if names is None:
         names = []
         for i, arr in enumerate(arrs):
             if isinstance(arr, ABCSeries) and arr.name is not None:
                 names.append(arr.name)
             else:
-                names.append("{prefix}_{i}".format(prefix=prefix, i=i))
+                names.append(f"{prefix}_{i}")
     else:
         if len(names) != len(arrs):
             raise AssertionError("arrays and names must have the same length")
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index c32ca47c19160..359e5b956f8a5 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -1,5 +1,6 @@
 from functools import partial
 import itertools
+from typing import List, Optional, Union
 
 import numpy as np
 
@@ -22,10 +23,10 @@
 
 import pandas.core.algorithms as algos
 from pandas.core.arrays import SparseArray
-from pandas.core.arrays.categorical import _factorize_from_iterable
+from pandas.core.arrays.categorical import factorize_from_iterable
 from pandas.core.construction import extract_array
 from pandas.core.frame import DataFrame
-from pandas.core.index import Index, MultiIndex
+from pandas.core.indexes.api import Index, MultiIndex
 from pandas.core.series import Series
 from pandas.core.sorting import (
     compress_group_index,
@@ -57,7 +58,7 @@ class _Unstacker:
         float and missing values will be set to NaN.
     constructor : object
         Pandas ``DataFrame`` or subclass used to create unstacked
-        response.  If None, DataFrame or SparseDataFrame will be used.
+        response.  If None, DataFrame will be used.
 
     Examples
     --------
@@ -88,7 +89,7 @@ class _Unstacker:
 
     def __init__(
         self,
-        values,
+        values: np.ndarray,
         index,
         level=-1,
         value_columns=None,
@@ -230,17 +231,14 @@ def get_new_values(self):
         if needs_i8_conversion(values):
             sorted_values = sorted_values.view("i8")
             new_values = new_values.view("i8")
-            name = "int64"
         elif is_bool_dtype(values):
             sorted_values = sorted_values.astype("object")
             new_values = new_values.astype("object")
-            name = "object"
         else:
             sorted_values = sorted_values.astype(name, copy=False)
 
         # fill in our values & mask
-        f = getattr(libreshape, "unstack_{name}".format(name=name))
-        f(
+        libreshape.unstack(
             sorted_values,
             mask.view("u1"),
             stride,
@@ -259,10 +257,10 @@ def get_new_values(self):
     def get_new_columns(self):
         if self.value_columns is None:
             if self.lift == 0:
-                return self.removed_level
+                return self.removed_level._shallow_copy(name=self.removed_name)
 
-            lev = self.removed_level
-            return lev.insert(0, lev._na_value)
+            lev = self.removed_level.insert(0, item=self.removed_level._na_value)
+            return lev.rename(self.removed_name)
 
         stride = len(self.removed_level) + self.lift
         width = len(self.value_columns)
@@ -298,10 +296,10 @@ def get_new_index(self):
 
         # construct the new index
         if len(self.new_index_levels) == 1:
-            lev, lab = self.new_index_levels[0], result_codes[0]
-            if (lab == -1).any():
-                lev = lev.insert(len(lev), lev._na_value)
-            return lev.take(lab)
+            level, level_codes = self.new_index_levels[0], result_codes[0]
+            if (level_codes == -1).any():
+                level = level.insert(len(level), level._na_value)
+            return level.take(level_codes).rename(self.new_index_names[0])
 
         return MultiIndex(
             levels=self.new_index_levels,
@@ -319,6 +317,10 @@ def _unstack_multiple(data, clocs, fill_value=None):
 
     index = data.index
 
+    # GH 19966 Make sure if MultiIndexed index has tuple name, they will be
+    # recognised as a whole
+    if clocs in index.names:
+        clocs = [clocs]
     clocs = [index._get_level_number(i) for i in clocs]
 
     rlocs = [i for i in range(index.nlevels) if i not in clocs]
@@ -360,7 +362,7 @@ def _unstack_multiple(data, clocs, fill_value=None):
             result = data
             for i in range(len(clocs)):
                 val = clocs[i]
-                result = result.unstack(val)
+                result = result.unstack(val, fill_value=fill_value)
                 clocs = [v if i > v else v - 1 for v in clocs]
 
             return result
@@ -373,6 +375,7 @@ def _unstack_multiple(data, clocs, fill_value=None):
             unstcols = unstacked.index
         else:
             unstcols = unstacked.columns
+        assert isinstance(unstcols, MultiIndex)  # for mypy
         new_levels = [unstcols.levels[0]] + clevels
         new_names = [data.columns.name] + cnames
 
@@ -431,15 +434,14 @@ def _unstack_frame(obj, level, fill_value=None):
         blocks = obj._data.unstack(unstacker, fill_value=fill_value)
         return obj._constructor(blocks)
     else:
-        unstacker = _Unstacker(
+        return _Unstacker(
             obj.values,
             obj.index,
             level=level,
             value_columns=obj.columns,
             fill_value=fill_value,
             constructor=obj._constructor,
-        )
-        return unstacker.get_result()
+        ).get_result()
 
 
 def _unstack_extension_series(series, level, fill_value):
@@ -505,7 +507,7 @@ def stack(frame, level=-1, dropna=True):
     def factorize(index):
         if index.is_unique:
             return index, np.arange(len(index))
-        codes, categories = _factorize_from_iterable(index)
+        codes, categories = factorize_from_iterable(index)
         return categories, codes
 
     N, K = frame.shape
@@ -661,7 +663,8 @@ def _convert_level_number(level_num, columns):
         new_names = this.columns.names[:-1]
         new_columns = MultiIndex.from_tuples(unique_groups, names=new_names)
     else:
-        new_columns = unique_groups = this.columns.levels[0]
+        new_columns = this.columns.levels[0]._shallow_copy(name=this.columns.names[0])
+        unique_groups = new_columns
 
     # time to ravel the values
     new_data = {}
@@ -725,7 +728,7 @@ def _convert_level_number(level_num, columns):
         new_names = list(this.index.names)
         new_codes = [lab.repeat(levsize) for lab in this.index.codes]
     else:
-        old_codes, old_levels = _factorize_from_iterable(this.index)
+        old_codes, old_levels = factorize_from_iterable(this.index)
         new_levels = [old_levels]
         new_codes = [old_codes.repeat(levsize)]
         new_names = [this.index.name]  # something better?
@@ -757,7 +760,7 @@ def get_dummies(
     sparse=False,
     drop_first=False,
     dtype=None,
-):
+) -> "DataFrame":
     """
     Convert categorical variable into dummy/indicator variables.
 
@@ -863,20 +866,20 @@ def get_dummies(
         # determine columns being encoded
         if columns is None:
             data_to_encode = data.select_dtypes(include=dtypes_to_encode)
+        elif not is_list_like(columns):
+            raise TypeError("Input must be a list-like for parameter `columns`")
         else:
             data_to_encode = data[columns]
 
         # validate prefixes and separator to avoid silently dropping cols
         def check_len(item, name):
-            len_msg = (
-                "Length of '{name}' ({len_item}) did not match the "
-                "length of the columns being encoded ({len_enc})."
-            )
 
             if is_list_like(item):
                 if not len(item) == data_to_encode.shape[1]:
-                    len_msg = len_msg.format(
-                        name=name, len_item=len(item), len_enc=data_to_encode.shape[1]
+                    len_msg = (
+                        f"Length of '{name}' ({len(item)}) did not match the "
+                        "length of the columns being encoded "
+                        f"({data_to_encode.shape[1]})."
                     )
                     raise ValueError(len_msg)
 
@@ -897,6 +900,7 @@ def check_len(item, name):
         elif isinstance(prefix_sep, dict):
             prefix_sep = [prefix_sep[col] for col in data_to_encode.columns]
 
+        with_dummies: List[DataFrame]
         if data_to_encode.shape == data.shape:
             # Encoding the entire df, do not prepend any dropped columns
             with_dummies = []
@@ -947,7 +951,7 @@ def _get_dummies_1d(
     from pandas.core.reshape.concat import concat
 
     # Series avoids inconsistent NaN handling
-    codes, levels = _factorize_from_iterable(Series(data))
+    codes, levels = factorize_from_iterable(Series(data))
 
     if dtype is None:
         dtype = np.uint8
@@ -956,7 +960,7 @@ def _get_dummies_1d(
     if is_object_dtype(dtype):
         raise ValueError("dtype=object is not a valid dtype for get_dummies")
 
-    def get_empty_frame(data):
+    def get_empty_frame(data) -> DataFrame:
         if isinstance(data, Series):
             index = data.index
         else:
@@ -983,12 +987,12 @@ def get_empty_frame(data):
     else:
 
         # PY2 embedded unicode, gh-22084
-        def _make_col_name(prefix, prefix_sep, level):
-            fstr = "{prefix}{prefix_sep}{level}"
-            return fstr.format(prefix=prefix, prefix_sep=prefix_sep, level=level)
+        def _make_col_name(prefix, prefix_sep, level) -> str:
+            return f"{prefix}{prefix_sep}{level}"
 
         dummy_cols = [_make_col_name(prefix, prefix_sep, level) for level in levels]
 
+    index: Optional[Index]
     if isinstance(data, Series):
         index = data.index
     else:
@@ -996,6 +1000,7 @@ def _make_col_name(prefix, prefix_sep, level):
 
     if sparse:
 
+        fill_value: Union[bool, float, int]
         if is_integer_dtype(dtype):
             fill_value = 0
         elif dtype == bool:
@@ -1005,7 +1010,7 @@ def _make_col_name(prefix, prefix_sep, level):
 
         sparse_series = []
         N = len(data)
-        sp_indices = [[] for _ in range(len(dummy_cols))]
+        sp_indices: List[List] = [[] for _ in range(len(dummy_cols))]
         mask = codes != -1
         codes = codes[mask]
         n_idx = np.arange(N)[mask]
@@ -1044,43 +1049,7 @@ def _make_col_name(prefix, prefix_sep, level):
         return DataFrame(dummy_mat, index=index, columns=dummy_cols)
 
 
-def make_axis_dummies(frame, axis="minor", transform=None):
-    """
-    Construct 1-0 dummy variables corresponding to designated axis
-    labels
-
-    Parameters
-    ----------
-    frame : DataFrame
-    axis : {'major', 'minor'}, default 'minor'
-    transform : function, default None
-        Function to apply to axis labels first. For example, to
-        get "day of week" dummies in a time series regression
-        you might call::
-
-            make_axis_dummies(panel, axis='major',
-                              transform=lambda d: d.weekday())
-    Returns
-    -------
-    dummies : DataFrame
-        Column names taken from chosen axis
-    """
-    numbers = {"major": 0, "minor": 1}
-    num = numbers.get(axis, axis)
-
-    items = frame.index.levels[num]
-    codes = frame.index.codes[num]
-    if transform is not None:
-        mapped_items = items.map(transform)
-        codes, items = _factorize_from_iterable(mapped_items.take(codes))
-
-    values = np.eye(len(items), dtype=float)
-    values = values.take(codes, axis=0)
-
-    return DataFrame(values, columns=items, index=frame.index)
-
-
-def _reorder_for_extension_array_stack(arr, n_rows, n_columns):
+def _reorder_for_extension_array_stack(arr, n_rows: int, n_columns: int):
     """
     Re-orders the values when stacking multiple extension-arrays.
 
diff --git a/pandas/core/reshape/tile.py b/pandas/core/reshape/tile.py
index ab354a21a33df..a18b45a077be0 100644
--- a/pandas/core/reshape/tile.py
+++ b/pandas/core/reshape/tile.py
@@ -1,8 +1,6 @@
 """
 Quantilization functions and related stuff
 """
-from functools import partial
-
 import numpy as np
 
 from pandas._libs import Timedelta, Timestamp
@@ -11,25 +9,22 @@
 from pandas.core.dtypes.common import (
     _NS_DTYPE,
     ensure_int64,
+    is_bool_dtype,
     is_categorical_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
+    is_extension_array_dtype,
     is_integer,
+    is_integer_dtype,
+    is_list_like,
     is_scalar,
     is_timedelta64_dtype,
 )
+from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import isna
 
-from pandas import (
-    Categorical,
-    Index,
-    Interval,
-    IntervalIndex,
-    Series,
-    to_datetime,
-    to_timedelta,
-)
+from pandas import Categorical, Index, IntervalIndex, to_datetime, to_timedelta
 import pandas.core.algorithms as algos
 import pandas.core.nanops as nanops
 
@@ -37,12 +32,12 @@
 def cut(
     x,
     bins,
-    right=True,
+    right: bool = True,
     labels=None,
-    retbins=False,
-    precision=3,
-    include_lowest=False,
-    duplicates="raise",
+    retbins: bool = False,
+    precision: int = 3,
+    include_lowest: bool = False,
+    duplicates: str = "raise",
 ):
     """
     Bin values into discrete intervals.
@@ -73,11 +68,12 @@ def cut(
         ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``
         indicate (1,2], (2,3], (3,4]. This argument is ignored when
         `bins` is an IntervalIndex.
-    labels : array or bool, optional
+    labels : array or False, default None
         Specifies the labels for the returned bins. Must be the same length as
         the resulting bins. If False, returns only integer indicators of the
         bins. This affects the type of the output container (see below).
-        This argument is ignored when `bins` is an IntervalIndex.
+        This argument is ignored when `bins` is an IntervalIndex. If True,
+        raises an error.
     retbins : bool, default False
         Whether to return the bins or not. Useful when bins is provided
         as a scalar.
@@ -206,8 +202,8 @@ def cut(
     """
     # NOTE: this binning code is changed a bit from histogram for var(x) == 0
 
-    # for handling the cut for datetime and timedelta objects
-    x_is_series, series_index, name, x = _preprocess_for_cut(x)
+    original = x
+    x = _preprocess_for_cut(x)
     x, dtype = _coerce_to_type(x)
 
     if not np.iterable(bins):
@@ -269,38 +265,42 @@ def cut(
         duplicates=duplicates,
     )
 
-    return _postprocess_for_cut(
-        fac, bins, retbins, x_is_series, series_index, name, dtype
-    )
+    return _postprocess_for_cut(fac, bins, retbins, dtype, original)
 
 
-def qcut(x, q, labels=None, retbins=False, precision=3, duplicates="raise"):
+def qcut(
+    x,
+    q,
+    labels=None,
+    retbins: bool = False,
+    precision: int = 3,
+    duplicates: str = "raise",
+):
     """
-    Quantile-based discretization function. Discretize variable into
-    equal-sized buckets based on rank or based on sample quantiles. For example
-    1000 values for 10 quantiles would produce a Categorical object indicating
-    quantile membership for each data point.
+    Quantile-based discretization function.
+
+    Discretize variable into equal-sized buckets based on rank or based
+    on sample quantiles. For example 1000 values for 10 quantiles would
+    produce a Categorical object indicating quantile membership for each data point.
 
     Parameters
     ----------
     x : 1d ndarray or Series
-    q : integer or array of quantiles
+    q : int or list-like of int
         Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
-        array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles
-    labels : array or boolean, default None
+        array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
+    labels : array or False, default None
         Used as labels for the resulting bins. Must be of the same length as
         the resulting bins. If False, return only integer indicators of the
-        bins.
+        bins. If True, raises an error.
     retbins : bool, optional
         Whether to return the (bins, labels) or not. Can be useful if bins
         is given as a scalar.
     precision : int, optional
-        The precision at which to store and display the bins labels
+        The precision at which to store and display the bins labels.
     duplicates : {default 'raise', 'drop'}, optional
         If bin edges are not unique, raise ValueError or drop non-uniques.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
     out : Categorical or Series or array of integers if labels is False
@@ -329,8 +329,8 @@ def qcut(x, q, labels=None, retbins=False, precision=3, duplicates="raise"):
     >>> pd.qcut(range(5), 4, labels=False)
     array([0, 0, 1, 2, 3])
     """
-    x_is_series, series_index, name, x = _preprocess_for_cut(x)
-
+    original = x
+    x = _preprocess_for_cut(x)
     x, dtype = _coerce_to_type(x)
 
     if is_integer(q):
@@ -348,26 +348,23 @@ def qcut(x, q, labels=None, retbins=False, precision=3, duplicates="raise"):
         duplicates=duplicates,
     )
 
-    return _postprocess_for_cut(
-        fac, bins, retbins, x_is_series, series_index, name, dtype
-    )
+    return _postprocess_for_cut(fac, bins, retbins, dtype, original)
 
 
 def _bins_to_cuts(
     x,
     bins,
-    right=True,
+    right: bool = True,
     labels=None,
-    precision=3,
-    include_lowest=False,
+    precision: int = 3,
+    include_lowest: bool = False,
     dtype=None,
-    duplicates="raise",
+    duplicates: str = "raise",
 ):
 
     if duplicates not in ["raise", "drop"]:
         raise ValueError(
-            "invalid value for 'duplicates' parameter, "
-            "valid options are: raise, drop"
+            "invalid value for 'duplicates' parameter, valid options are: raise, drop"
         )
 
     if isinstance(bins, IntervalIndex):
@@ -380,9 +377,8 @@ def _bins_to_cuts(
     if len(unique_bins) < len(bins) and len(bins) != 2:
         if duplicates == "raise":
             raise ValueError(
-                "Bin edges must be unique: {bins!r}.\nYou "
-                "can drop duplicate edges by setting "
-                "the 'duplicates' kwarg".format(bins=bins)
+                f"Bin edges must be unique: {repr(bins)}.\n"
+                f"You can drop duplicate edges by setting the 'duplicates' kwarg"
             )
         else:
             bins = unique_bins
@@ -397,15 +393,23 @@ def _bins_to_cuts(
     has_nas = na_mask.any()
 
     if labels is not False:
-        if labels is None:
+        if not (labels is None or is_list_like(labels)):
+            raise ValueError(
+                "Bin labels must either be False, None or passed in as a "
+                "list-like argument"
+            )
+
+        elif labels is None:
             labels = _format_labels(
                 bins, precision, right=right, include_lowest=include_lowest, dtype=dtype
             )
+
         else:
             if len(labels) != len(bins) - 1:
                 raise ValueError(
                     "Bin labels must be one fewer than the number of bin edges"
                 )
+
         if not is_categorical_dtype(labels):
             labels = Categorical(labels, categories=labels, ordered=True)
 
@@ -423,8 +427,8 @@ def _bins_to_cuts(
 
 def _coerce_to_type(x):
     """
-    if the passed data is of datetime/timedelta type,
-    this method converts it to numeric so that cut method can
+    if the passed data is of datetime/timedelta, bool or nullable int type,
+    this method converts it to numeric so that cut or qcut method can
     handle it
     """
     dtype = None
@@ -437,6 +441,15 @@ def _coerce_to_type(x):
     elif is_timedelta64_dtype(x):
         x = to_timedelta(x)
         dtype = np.dtype("timedelta64[ns]")
+    elif is_bool_dtype(x):
+        # GH 20303
+        x = x.astype(np.int64)
+    # To support cut and qcut for IntegerArray we convert to float dtype.
+    # Will properly support in the future.
+    # https://github.com/pandas-dev/pandas/pull/31290
+    # https://github.com/pandas-dev/pandas/issues/31389
+    elif is_extension_array_dtype(x) and is_integer_dtype(x):
+        x = x.to_numpy(dtype=np.float64, na_value=np.nan)
 
     if dtype is not None:
         # GH 19768: force NaT to NaN during integer conversion
@@ -496,13 +509,15 @@ def _convert_bin_to_datelike_type(bins, dtype):
     return bins
 
 
-def _format_labels(bins, precision, right=True, include_lowest=False, dtype=None):
+def _format_labels(
+    bins, precision: int, right: bool = True, include_lowest: bool = False, dtype=None
+):
     """ based on the dtype, return our labels """
 
     closed = "right" if right else "left"
 
     if is_datetime64tz_dtype(dtype):
-        formatter = partial(Timestamp, tz=dtype.tz)
+        formatter = lambda x: Timestamp(x, tz=dtype.tz)
         adjust = lambda x: x - Timedelta("1ns")
     elif is_datetime64_dtype(dtype):
         formatter = Timestamp
@@ -516,17 +531,11 @@ def _format_labels(bins, precision, right=True, include_lowest=False, dtype=None
         adjust = lambda x: x - 10 ** (-precision)
 
     breaks = [formatter(b) for b in bins]
-    labels = IntervalIndex.from_breaks(breaks, closed=closed)
-
     if right and include_lowest:
-        # we will adjust the left hand side by precision to
-        # account that we are all right closed
-        v = adjust(labels[0].left)
+        # adjust lhs of first interval by precision to account for being right closed
+        breaks[0] = adjust(breaks[0])
 
-        i = IntervalIndex([Interval(v, labels[0].right, closed="right")])
-        labels = i.append(labels[1:])
-
-    return labels
+    return IntervalIndex.from_breaks(breaks, closed=closed)
 
 
 def _preprocess_for_cut(x):
@@ -535,13 +544,6 @@ def _preprocess_for_cut(x):
     input to array, strip the index information and store it
     separately
     """
-    x_is_series = isinstance(x, Series)
-    series_index = None
-    name = None
-
-    if x_is_series:
-        series_index = x.index
-        name = x.name
 
     # Check that the passed array is a Pandas or Numpy object
     # We don't want to strip away a Pandas data-type here (e.g. datetimetz)
@@ -551,17 +553,17 @@ def _preprocess_for_cut(x):
     if x.ndim != 1:
         raise ValueError("Input array must be 1 dimensional")
 
-    return x_is_series, series_index, name, x
+    return x
 
 
-def _postprocess_for_cut(fac, bins, retbins, x_is_series, series_index, name, dtype):
+def _postprocess_for_cut(fac, bins, retbins: bool, dtype, original):
     """
     handles post processing for the cut method where
     we combine the index information if the originally passed
     datatype was a series
     """
-    if x_is_series:
-        fac = Series(fac, index=series_index, name=name)
+    if isinstance(original, ABCSeries):
+        fac = original._constructor(fac, index=original.index, name=original.name)
 
     if not retbins:
         return fac
@@ -571,7 +573,7 @@ def _postprocess_for_cut(fac, bins, retbins, x_is_series, series_index, name, dt
     return fac, bins
 
 
-def _round_frac(x, precision):
+def _round_frac(x, precision: int):
     """
     Round the fractional part of the given number
     """
@@ -586,7 +588,7 @@ def _round_frac(x, precision):
         return np.around(x, digits)
 
 
-def _infer_precision(base_precision, bins):
+def _infer_precision(base_precision: int, bins) -> int:
     """Infer an appropriate precision for _round_frac
     """
     for precision in range(base_precision, 20):
diff --git a/pandas/core/reshape/util.py b/pandas/core/reshape/util.py
index 044e058904dce..d8652c9b4fac9 100644
--- a/pandas/core/reshape/util.py
+++ b/pandas/core/reshape/util.py
@@ -2,7 +2,7 @@
 
 from pandas.core.dtypes.common import is_list_like
 
-from pandas.core import common as com
+import pandas.core.common as com
 
 
 def cartesian_product(X):
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 922977bc04d63..7d74d32bf5e14 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1,51 +1,58 @@
 """
 Data structure for 1-dimensional cross-sectional and time series data
 """
-from collections import OrderedDict
 from io import StringIO
 from shutil import get_terminal_size
 from textwrap import dedent
-from typing import Any, Callable
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Hashable,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+)
 import warnings
 
 import numpy as np
 
 from pandas._config import get_option
 
-from pandas._libs import index as libindex, lib, reshape, tslibs
-from pandas.compat import PY36
+from pandas._libs import lib, properties, reshape, tslibs
+from pandas._typing import Label
 from pandas.compat.numpy import function as nv
-from pandas.util._decorators import Appender, Substitution, deprecate
-from pandas.util._validators import validate_bool_kwarg
+from pandas.util._decorators import Appender, Substitution
+from pandas.util._validators import validate_bool_kwarg, validate_percentile
 
+from pandas.core.dtypes.cast import convert_dtypes, validate_numeric_casting
 from pandas.core.dtypes.common import (
     _is_unorderable_exception,
     ensure_platform_int,
     is_bool,
-    is_categorical,
     is_categorical_dtype,
     is_datetime64_dtype,
-    is_datetimelike,
     is_dict_like,
     is_extension_array_dtype,
-    is_extension_type,
-    is_hashable,
     is_integer,
     is_iterator,
     is_list_like,
     is_object_dtype,
     is_scalar,
-    is_string_like,
     is_timedelta64_dtype,
 )
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
-    ABCDatetimeArray,
     ABCDatetimeIndex,
+    ABCMultiIndex,
+    ABCPeriodIndex,
     ABCSeries,
     ABCSparseArray,
-    ABCSparseSeries,
 )
+from pandas.core.dtypes.inference import is_hashable
 from pandas.core.dtypes.missing import (
     isna,
     na_value_for_dtype,
@@ -56,20 +63,26 @@
 import pandas as pd
 from pandas.core import algorithms, base, generic, nanops, ops
 from pandas.core.accessor import CachedAccessor
-from pandas.core.arrays import ExtensionArray, SparseArray
+from pandas.core.arrays import ExtensionArray, try_cast_to_ea
 from pandas.core.arrays.categorical import Categorical, CategoricalAccessor
 from pandas.core.arrays.sparse import SparseAccessor
 import pandas.core.common as com
-from pandas.core.construction import extract_array, sanitize_array
-from pandas.core.index import (
+from pandas.core.construction import (
+    create_series_with_explicit_dtype,
+    extract_array,
+    is_empty_data,
+    sanitize_array,
+)
+from pandas.core.indexers import maybe_convert_indices
+from pandas.core.indexes.accessors import CombinedDatetimelikeProperties
+from pandas.core.indexes.api import (
     Float64Index,
     Index,
+    IntervalIndex,
     InvalidIndexError,
     MultiIndex,
     ensure_index,
 )
-from pandas.core.indexers import maybe_convert_indices
-from pandas.core.indexes.accessors import CombinedDatetimelikeProperties
 import pandas.core.indexes.base as ibase
 from pandas.core.indexes.datetimes import DatetimeIndex
 from pandas.core.indexes.period import PeriodIndex
@@ -82,6 +95,10 @@
 import pandas.io.formats.format as fmt
 import pandas.plotting
 
+if TYPE_CHECKING:
+    from pandas.core.frame import DataFrame
+    from pandas.core.groupby.generic import SeriesGroupBy
+
 __all__ = ["Series"]
 
 _shared_doc_kwargs = dict(
@@ -102,23 +119,6 @@
 )
 
 
-# see gh-16971
-def remove_na(arr):
-    """
-    Remove null values from array like structure.
-
-    .. deprecated:: 0.21.0
-        Use s[s.notnull()] instead.
-    """
-
-    warnings.warn(
-        "remove_na is deprecated and is a private function. Do not use.",
-        FutureWarning,
-        stacklevel=2,
-    )
-    return remove_na_arraylike(arr)
-
-
 def _coerce_method(converter):
     """
     Install the scalar coercion methods.
@@ -127,9 +127,9 @@ def _coerce_method(converter):
     def wrapper(self):
         if len(self) == 1:
             return converter(self.iloc[0])
-        raise TypeError("cannot convert the series to {0}".format(str(converter)))
+        raise TypeError(f"cannot convert the series to {converter}")
 
-    wrapper.__name__ = "__{name}__".format(name=converter.__name__)
+    wrapper.__name__ = f"__{converter.__name__}__"
     return wrapper
 
 
@@ -170,22 +170,31 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
         Data type for the output Series. If not specified, this will be
         inferred from `data`.
         See the :ref:`user guide <basics.dtypes>` for more usages.
+    name : str, optional
+        The name to give to the Series.
     copy : bool, default False
         Copy input data.
     """
 
-    _metadata = ["name"]
+    _typ = "series"
+
+    _name: Optional[Hashable]
+    _metadata: List[str] = ["name"]
+    _internal_names_set = {"index"} | generic.NDFrame._internal_names_set
     _accessors = {"dt", "cat", "str", "sparse"}
-    # tolist is not actually deprecated, just suppressed in the __dir__
-    _deprecations = generic.NDFrame._deprecations | frozenset(
-        ["asobject", "reshape", "valid", "tolist"]
+    _deprecations = (
+        base.IndexOpsMixin._deprecations
+        | generic.NDFrame._deprecations
+        | frozenset(["compress", "ptp"])
     )
 
     # Override cache_readonly bc Series is mutable
     hasnans = property(
         base.IndexOpsMixin.hasnans.func, doc=base.IndexOpsMixin.hasnans.__doc__
     )
-    _data = None  # type: SingleBlockManager
+    _data: SingleBlockManager
+    div: Callable[["Series", Any], "Series"]
+    rdiv: Callable[["Series", Any], "Series"]
 
     # ----------------------------------------------------------------------
     # Constructors
@@ -207,21 +216,26 @@ def __init__(
 
         else:
 
+            name = ibase.maybe_extract_name(name, data, type(self))
+
+            if is_empty_data(data) and dtype is None:
+                # gh-17261
+                warnings.warn(
+                    "The default dtype for empty Series will be 'object' instead "
+                    "of 'float64' in a future version. Specify a dtype explicitly "
+                    "to silence this warning.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                # uncomment the line below when removing the DeprecationWarning
+                # dtype = np.dtype(object)
+
             if index is not None:
                 index = ensure_index(index)
 
             if data is None:
                 data = {}
             if dtype is not None:
-                # GH 26336: explicitly handle 'category' to avoid warning
-                # TODO: Remove after CategoricalDtype defaults to ordered=False
-                if (
-                    isinstance(dtype, str)
-                    and dtype == "category"
-                    and is_categorical(data)
-                ):
-                    dtype = data.dtype
-
                 dtype = self._validate_dtype(dtype)
 
             if isinstance(data, MultiIndex):
@@ -229,8 +243,6 @@ def __init__(
                     "initializing a Series from a MultiIndex is not supported"
                 )
             elif isinstance(data, Index):
-                if name is None:
-                    name = data.name
 
                 if dtype is not None:
                     # astype copies
@@ -245,16 +257,21 @@ def __init__(
                 copy = False
 
             elif isinstance(data, np.ndarray):
+                if len(data.dtype):
+                    # GH#13296 we are dealing with a compound dtype, which
+                    #  should be treated as 2D
+                    raise ValueError(
+                        "Cannot construct a Series from an ndarray with "
+                        "compound dtype.  Use DataFrame instead."
+                    )
                 pass
-            elif isinstance(data, (ABCSeries, ABCSparseSeries)):
-                if name is None:
-                    name = data.name
+            elif isinstance(data, ABCSeries):
                 if index is None:
                     index = data.index
                 else:
                     data = data.reindex(index, copy=copy)
                 data = data._data
-            elif isinstance(data, dict):
+            elif is_dict_like(data):
                 data, index = self._init_dict(data, index, dtype)
                 dtype = None
                 copy = False
@@ -267,16 +284,13 @@ def __init__(
                     raise AssertionError(
                         "Cannot pass both SingleBlockManager "
                         "`data` argument and a different "
-                        "`index` argument.  `copy` must "
-                        "be False."
+                        "`index` argument. `copy` must be False."
                     )
 
             elif is_extension_array_dtype(data):
                 pass
             elif isinstance(data, (set, frozenset)):
-                raise TypeError(
-                    "{0!r} type is unordered".format(data.__class__.__name__)
-                )
+                raise TypeError(f"'{type(data).__name__}' type is unordered")
             elif isinstance(data, ABCSparseArray):
                 # handle sparse passed here (and force conversion)
                 data = data.to_dense()
@@ -294,8 +308,8 @@ def __init__(
                 try:
                     if len(index) != len(data):
                         raise ValueError(
-                            "Length of passed values is {val}, "
-                            "index implies {ind}".format(val=len(data), ind=len(index))
+                            f"Length of passed values is {len(data)}, "
+                            f"index implies {len(index)}."
                         )
                 except TypeError:
                     pass
@@ -312,7 +326,6 @@ def __init__(
                 data = SingleBlockManager(data, index, fastpath=True)
 
         generic.NDFrame.__init__(self, data, fastpath=True)
-
         self.name = name
         self._set_axis(0, index, fastpath=True)
 
@@ -324,11 +337,11 @@ def _init_dict(self, data, index=None, dtype=None):
         Parameters
         ----------
         data : dict or dict-like
-            Data used to populate the new Series
+            Data used to populate the new Series.
         index : Index or index-like, default None
-            index for the new Series: if None, use dict keys
+            Index for the new Series: if None, use dict keys.
         dtype : dtype, default None
-            dtype for the new Series: if None, infer from data
+            The dtype for the new Series: if None, infer from data.
 
         Returns
         -------
@@ -349,58 +362,25 @@ def _init_dict(self, data, index=None, dtype=None):
             keys, values = [], []
 
         # Input is now list-like, so rely on "standard" construction:
-        s = Series(values, index=keys, dtype=dtype)
+
+        # TODO: passing np.float64 to not break anything yet. See GH-17261
+        s = create_series_with_explicit_dtype(
+            values, index=keys, dtype=dtype, dtype_if_empty=np.float64
+        )
 
         # Now we just make sure the order is respected, if any
         if data and index is not None:
             s = s.reindex(index, copy=False)
-        elif not PY36 and not isinstance(data, OrderedDict) and data:
-            # Need the `and data` to avoid sorting Series(None, index=[...])
-            # since that isn't really dict-like
-            try:
-                s = s.sort_index()
-            except TypeError:
-                pass
         return s._data, s.index
 
-    @classmethod
-    def from_array(
-        cls, arr, index=None, name=None, dtype=None, copy=False, fastpath=False
-    ):
-        """
-        Construct Series from array.
-
-        .. deprecated:: 0.23.0
-            Use pd.Series(..) constructor instead.
-
-        Returns
-        -------
-        Series
-            Constructed Series.
-        """
-        warnings.warn(
-            "'from_array' is deprecated and will be removed in a "
-            "future version. Please use the pd.Series(..) "
-            "constructor instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        if isinstance(arr, ABCSparseArray):
-            from pandas.core.sparse.series import SparseSeries
-
-            cls = SparseSeries
-        return cls(
-            arr, index=index, name=name, dtype=dtype, copy=copy, fastpath=fastpath
-        )
-
     # ----------------------------------------------------------------------
 
     @property
-    def _constructor(self):
+    def _constructor(self) -> Type["Series"]:
         return Series
 
     @property
-    def _constructor_expanddim(self):
+    def _constructor_expanddim(self) -> Type["DataFrame"]:
         from pandas.core.frame import DataFrame
 
         return DataFrame
@@ -412,7 +392,7 @@ def _can_hold_na(self):
 
     _index = None
 
-    def _set_axis(self, axis, labels, fastpath=False):
+    def _set_axis(self, axis, labels, fastpath: bool = False) -> None:
         """
         Override generic, we want to set the _typ here.
         """
@@ -433,35 +413,14 @@ def _set_axis(self, axis, labels, fastpath=False):
                     # or not be a DatetimeIndex
                     pass
 
-        self._set_subtyp(is_all_dates)
-
         object.__setattr__(self, "_index", labels)
         if not fastpath:
             self._data.set_axis(axis, labels)
 
-    def _set_subtyp(self, is_all_dates):
-        if is_all_dates:
-            object.__setattr__(self, "_subtyp", "time_series")
-        else:
-            object.__setattr__(self, "_subtyp", "series")
-
     def _update_inplace(self, result, **kwargs):
         # we want to call the generic version and not the IndexOpsMixin
         return generic.NDFrame._update_inplace(self, result, **kwargs)
 
-    @property
-    def name(self):
-        """
-        Return name of the Series.
-        """
-        return self._name
-
-    @name.setter
-    def name(self, value):
-        if value is not None and not is_hashable(value):
-            raise TypeError("Series.name must be a hashable type")
-        object.__setattr__(self, "_name", value)
-
     # ndarray compatibility
     @property
     def dtype(self):
@@ -478,40 +437,14 @@ def dtypes(self):
         return self._data.dtype
 
     @property
-    def ftype(self):
-        """
-        Return if the data is sparse|dense.
-
-        .. deprecated:: 0.25.0
-           Use :func:`dtype` instead.
-        """
-        warnings.warn(
-            "Series.ftype is deprecated and will "
-            "be removed in a future version. "
-            "Use Series.dtype instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-
-        return self._data.ftype
-
-    @property
-    def ftypes(self):
-        """
-        Return if the data is sparse|dense.
-
-        .. deprecated:: 0.25.0
-           Use :func:`dtypes` instead.
-        """
-        warnings.warn(
-            "Series.ftypes is deprecated and will "
-            "be removed in a future version. "
-            "Use Series.dtype instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
+    def name(self) -> Optional[Hashable]:
+        return self._name
 
-        return self._data.ftype
+    @name.setter
+    def name(self, value: Optional[Hashable]) -> None:
+        if not is_hashable(value):
+            raise TypeError("Series.name must be a hashable type")
+        object.__setattr__(self, "_name", value)
 
     @property
     def values(self):
@@ -558,51 +491,58 @@ def values(self):
     @property
     def _values(self):
         """
-        Return the internal repr of this data.
+        Return the internal repr of this data (defined by Block.interval_values).
+        This are the values as stored in the Block (ndarray or ExtensionArray
+        depending on the Block class), with datetime64[ns] and timedelta64[ns]
+        wrapped in ExtensionArrays to match Index._values behavior.
+
+        Differs from the public ``.values`` for certain data types, because of
+        historical backwards compatibility of the public attribute (e.g. period
+        returns object ndarray and datetimetz a datetime64[ns] ndarray for
+        ``.values`` while it returns an ExtensionArray for ``._values`` in those
+        cases).
+
+        Differs from ``.array`` in that this still returns the numpy array if
+        the Block is backed by a numpy array (except for datetime64 and
+        timedelta64 dtypes), while ``.array`` ensures to always return an
+        ExtensionArray.
+
+        Differs from ``._ndarray_values``, as that ensures to always return a
+        numpy array (it will call ``_ndarray_values`` on the ExtensionArray, if
+        the Series was backed by an ExtensionArray).
+
+        Overview:
+
+        dtype       | values        | _values       | array         | _ndarray_values |
+        ----------- | ------------- | ------------- | ------------- | --------------- |
+        Numeric     | ndarray       | ndarray       | PandasArray   | ndarray         |
+        Category    | Categorical   | Categorical   | Categorical   | ndarray[int]    |
+        dt64[ns]    | ndarray[M8ns] | DatetimeArray | DatetimeArray | ndarray[M8ns]   |
+        dt64[ns tz] | ndarray[M8ns] | DatetimeArray | DatetimeArray | ndarray[M8ns]   |
+        td64[ns]    | ndarray[m8ns] | TimedeltaArray| ndarray[m8ns] | ndarray[m8ns]   |
+        Period      | ndarray[obj]  | PeriodArray   | PeriodArray   | ndarray[int]    |
+        Nullable    | EA            | EA            | EA            | ndarray         |
+
         """
         return self._data.internal_values()
 
-    def get_values(self):
+    @Appender(base.IndexOpsMixin.array.__doc__)  # type: ignore
+    @property
+    def array(self) -> ExtensionArray:
+        return self._data._block.array_values()
+
+    def _internal_get_values(self):
         """
         Same as values (but handles sparseness conversions); is a view.
 
-        .. deprecated:: 0.25.0
-            Use :meth:`Series.to_numpy` or :attr:`Series.array` instead.
-
         Returns
         -------
         numpy.ndarray
             Data of the Series.
         """
-        warnings.warn(
-            "The 'get_values' method is deprecated and will be removed in a "
-            "future version. Use '.to_numpy()' or '.array' instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self._internal_get_values()
 
-    def _internal_get_values(self):
         return self._data.get_values()
 
-    @property
-    def asobject(self):
-        """
-        Return object Series which contains boxed values.
-
-        .. deprecated:: 0.23.0
-
-           Use ``astype(object)`` instead.
-
-        *this is an internal non-public method*
-        """
-        warnings.warn(
-            "'asobject' is deprecated. Use 'astype(object)' instead",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.astype(object).values
-
     # ops
     def ravel(self, order="C"):
         """
@@ -619,103 +559,13 @@ def ravel(self, order="C"):
         """
         return self._values.ravel(order=order)
 
-    def compress(self, condition, *args, **kwargs):
-        """
-        Return selected slices of an array along given axis as a Series.
-
-        .. deprecated:: 0.24.0
-
-        Returns
-        -------
-        Series
-            Series without the slices for which condition is false.
-
-        See Also
-        --------
-        numpy.ndarray.compress
-        """
-        msg = (
-            "Series.compress(condition) is deprecated. "
-            "Use 'Series[condition]' or "
-            "'np.asarray(series).compress(condition)' instead."
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        nv.validate_compress(args, kwargs)
-        return self[condition]
-
-    def nonzero(self):
-        """
-        Return the *integer* indices of the elements that are non-zero.
-
-        .. deprecated:: 0.24.0
-           Please use .to_numpy().nonzero() as a replacement.
-
-        This method is equivalent to calling `numpy.nonzero` on the
-        series data. For compatibility with NumPy, the return value is
-        the same (a tuple with an array of indices for each dimension),
-        but it will always be a one-item tuple because series only have
-        one dimension.
-
-        Returns
-        -------
-        numpy.ndarray
-            Indices of elements that are non-zero.
-
-        See Also
-        --------
-        numpy.nonzero
-
-        Examples
-        --------
-        >>> s = pd.Series([0, 3, 0, 4])
-        >>> s.nonzero()
-        (array([1, 3]),)
-        >>> s.iloc[s.nonzero()[0]]
-        1    3
-        3    4
-        dtype: int64
-
-        # same return although index of s is different
-        >>> s = pd.Series([0, 3, 0, 4], index=['a', 'b', 'c', 'd'])
-        >>> s.nonzero()
-        (array([1, 3]),)
-        >>> s.iloc[s.nonzero()[0]]
-        b    3
-        d    4
-        dtype: int64
-        """
-        msg = (
-            "Series.nonzero() is deprecated "
-            "and will be removed in a future version."
-            "Use Series.to_numpy().nonzero() instead"
-        )
-        warnings.warn(msg, FutureWarning, stacklevel=2)
-        return self._values.nonzero()
-
-    def put(self, *args, **kwargs):
-        """
-        Apply the `put` method to its `values` attribute if it has one.
-
-        .. deprecated:: 0.25.0
-
-        See Also
-        --------
-        numpy.ndarray.put
-        """
-        warnings.warn(
-            "`put` has been deprecated and will be removed in a future version.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        self._values.put(*args, **kwargs)
-
-    def __len__(self):
+    def __len__(self) -> int:
         """
         Return the length of the Series.
         """
         return len(self._data)
 
-    def view(self, dtype=None):
+    def view(self, dtype=None) -> "Series":
         """
         Create a new view of the Series.
 
@@ -841,9 +691,10 @@ def __array_ufunc__(
 
         inputs = tuple(extract_array(x, extract_numpy=True) for x in inputs)
         result = getattr(ufunc, method)(*inputs, **kwargs)
+
+        name: Optional[Hashable]
         if len(set(names)) == 1:
-            # we require names to be hashable, right?
-            name = names[0]  # type: Any
+            name = names[0]
         else:
             name = None
 
@@ -853,14 +704,8 @@ def construct_return(result):
             elif result.ndim > 1:
                 # e.g. np.subtract.outer
                 if method == "outer":
-                    msg = (
-                        "outer method for ufunc {} is not implemented on "
-                        "pandas objects. Returning an ndarray, but in the "
-                        "future this will raise a 'NotImplementedError'. "
-                        "Consider explicitly converting the Series "
-                        "to an array with '.array' first."
-                    )
-                    warnings.warn(msg.format(ufunc), FutureWarning, stacklevel=3)
+                    # GH#27198
+                    raise NotImplementedError
                 return result
             return self._constructor(result, index=index, name=name, copy=False)
 
@@ -873,7 +718,7 @@ def construct_return(result):
         else:
             return construct_return(result)
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None) -> np.ndarray:
         """
         Return the values as a NumPy array.
 
@@ -889,7 +734,7 @@ def __array__(self, dtype=None):
         Returns
         -------
         numpy.ndarray
-            The values in the series converted to a :class:`numpy.ndarary`
+            The values in the series converted to a :class:`numpy.ndarray`
             with the specified `dtype`.
 
         See Also
@@ -913,73 +758,18 @@ def __array__(self, dtype=None):
                Timestamp('2000-01-02 00:00:00+0100', tz='CET', freq='D')],
               dtype=object)
 
-        Or the values may be localized to UTC and the tzinfo discared with
+        Or the values may be localized to UTC and the tzinfo discarded with
         ``dtype='datetime64[ns]'``
 
         >>> np.asarray(tzser, dtype="datetime64[ns]")  # doctest: +ELLIPSIS
         array(['1999-12-31T23:00:00.000000000', ...],
               dtype='datetime64[ns]')
         """
-        if (
-            dtype is None
-            and isinstance(self.array, ABCDatetimeArray)
-            and getattr(self.dtype, "tz", None)
-        ):
-            msg = (
-                "Converting timezone-aware DatetimeArray to timezone-naive "
-                "ndarray with 'datetime64[ns]' dtype. In the future, this "
-                "will return an ndarray with 'object' dtype where each "
-                "element is a 'pandas.Timestamp' with the correct 'tz'.\n\t"
-                "To accept the future behavior, pass 'dtype=object'.\n\t"
-                "To keep the old behavior, pass 'dtype=\"datetime64[ns]\"'."
-            )
-            warnings.warn(msg, FutureWarning, stacklevel=3)
-            dtype = "M8[ns]"
         return np.asarray(self.array, dtype)
 
     # ----------------------------------------------------------------------
     # Unary Methods
 
-    @property
-    def real(self):
-        """
-        Return the real value of vector.
-
-        .. deprecated:: 0.25.0
-        """
-        warnings.warn(
-            "`real` is deprecated and will be removed in a future version. "
-            "To eliminate this warning for a Series `ser`, use "
-            "`np.real(ser.to_numpy())` or `ser.to_numpy().real`.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.real
-
-    @real.setter
-    def real(self, v):
-        self.values.real = v
-
-    @property
-    def imag(self):
-        """
-        Return imag value of vector.
-
-        .. deprecated:: 0.25.0
-        """
-        warnings.warn(
-            "`imag` is deprecated and will be removed in a future version. "
-            "To eliminate this warning for a Series `ser`, use "
-            "`np.imag(ser.to_numpy())` or `ser.to_numpy().imag`.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.values.imag
-
-    @imag.setter
-    def imag(self, v):
-        self.values.imag = v
-
     # coercion
     __float__ = _coerce_method(float)
     __long__ = _coerce_method(int)
@@ -987,38 +777,9 @@ def imag(self, v):
 
     # ----------------------------------------------------------------------
 
-    def _unpickle_series_compat(self, state):
-        if isinstance(state, dict):
-            self._data = state["_data"]
-            self.name = state["name"]
-            self.index = self._data.index
-
-        elif isinstance(state, tuple):
-
-            # < 0.12 series pickle
-
-            nd_state, own_state = state
-
-            # recreate the ndarray
-            data = np.empty(nd_state[1], dtype=nd_state[2])
-            np.ndarray.__setstate__(data, nd_state)
-
-            # backwards compat
-            index, name = own_state[0], None
-            if len(own_state) > 1:
-                name = own_state[1]
-
-            # recreate
-            self._data = SingleBlockManager(data, index, fastpath=True)
-            self._index = index
-            self.name = name
-
-        else:
-            raise Exception("cannot unpickle legacy formats -> [%s]" % state)
-
     # indexers
     @property
-    def axes(self):
+    def axes(self) -> List[Index]:
         """
         Return a list of the row axis labels.
         """
@@ -1028,7 +789,14 @@ def axes(self):
     # Indexing Methods
 
     @Appender(generic.NDFrame.take.__doc__)
-    def take(self, indices, axis=0, is_copy=False, **kwargs):
+    def take(self, indices, axis=0, is_copy=None, **kwargs) -> "Series":
+        if is_copy is not None:
+            warnings.warn(
+                "is_copy is deprecated and will be removed in a future version. "
+                "'take' always returns a copy, so there is no need to specify this.",
+                FutureWarning,
+                stacklevel=2,
+            )
         nv.validate_take(tuple(), kwargs)
 
         indices = ensure_platform_int(indices)
@@ -1043,16 +811,20 @@ def take(self, indices, axis=0, is_copy=False, **kwargs):
             kwargs = {}
         new_values = self._values.take(indices, **kwargs)
 
-        result = self._constructor(
+        return self._constructor(
             new_values, index=new_index, fastpath=True
         ).__finalize__(self)
 
-        # Maybe set copy if we didn't actually change the index.
-        if is_copy:
-            if not result._get_axis(axis).equals(self._get_axis(axis)):
-                result._set_is_copy(self)
+    def _take_with_is_copy(self, indices, axis=0, **kwargs):
+        """
+        Internal version of the `take` method that sets the `_is_copy`
+        attribute to keep track of the parent dataframe (using in indexing
+        for the SettingWithCopyWarning). For Series this does the same
+        as the public take (it never sets `_is_copy`).
 
-        return result
+        See the docstring of `take` for full explanation of the parameters.
+        """
+        return self.take(indices=indices, axis=axis, **kwargs)
 
     def _ixs(self, i: int, axis: int = 0):
         """
@@ -1066,66 +838,58 @@ def _ixs(self, i: int, axis: int = 0):
         -------
         scalar (int) or Series (slice, sequence)
         """
+        return self._values[i]
 
-        # dispatch to the values if we need
-        values = self._values
-        if isinstance(values, np.ndarray):
-            return libindex.get_value_at(values, i)
-        else:
-            return values[i]
-
-    def _slice(self, slobj: slice, axis: int = 0, kind=None):
-        slobj = self.index._convert_slice_indexer(slobj, kind=kind or "getitem")
+    def _slice(self, slobj: slice, axis: int = 0) -> "Series":
+        # axis kwarg is retained for compat with NDFrame method
+        #  _slice is *always* positional
         return self._get_values(slobj)
 
     def __getitem__(self, key):
         key = com.apply_if_callable(key, self)
-        try:
-            result = self.index.get_value(self, key)
-
-            if not is_scalar(result):
-                if is_list_like(result) and not isinstance(result, Series):
-
-                    # we need to box if loc of the key isn't scalar here
-                    # otherwise have inline ndarray/lists
-                    try:
-                        if not is_scalar(self.index.get_loc(key)):
-                            result = self._constructor(
-                                result, index=[key] * len(result), dtype=self.dtype
-                            ).__finalize__(self)
-                    except KeyError:
-                        pass
-            return result
-        except InvalidIndexError:
-            pass
-        except (KeyError, ValueError):
-            if isinstance(key, tuple) and isinstance(self.index, MultiIndex):
-                # kludge
-                pass
-            elif key is Ellipsis:
-                return self
-            elif com.is_bool_indexer(key):
-                pass
-            else:
 
-                # we can try to coerce the indexer (or this will raise)
-                new_key = self.index._convert_scalar_indexer(key, kind="getitem")
-                if type(new_key) != type(key):
-                    return self.__getitem__(new_key)
-                raise
+        if key is Ellipsis:
+            return self
 
-        if is_iterator(key):
-            key = list(key)
+        key_is_scalar = is_scalar(key)
+        if key_is_scalar:
+            key = self.index._convert_scalar_indexer(key, kind="getitem")
+
+        if key_is_scalar or isinstance(self.index, MultiIndex):
+            # Otherwise index.get_value will raise InvalidIndexError
+            try:
+                result = self.index.get_value(self, key)
+
+                return result
+            except InvalidIndexError:
+                if not isinstance(self.index, MultiIndex):
+                    raise
 
-        if com.is_bool_indexer(key):
-            key = check_bool_indexer(self.index, key)
+            except (KeyError, ValueError):
+                if isinstance(key, tuple) and isinstance(self.index, MultiIndex):
+                    # kludge
+                    pass
+                else:
+                    raise
+
+        if not key_is_scalar:
+            # avoid expensive checks if we know we have a scalar
+            if is_iterator(key):
+                key = list(key)
+
+            if com.is_bool_indexer(key):
+                key = check_bool_indexer(self.index, key)
+                return self._get_values(key)
 
         return self._get_with(key)
 
     def _get_with(self, key):
         # other: fancy integer or otherwise
         if isinstance(key, slice):
-            return self._slice(key)
+            # _convert_slice_indexer to determing if this slice is positional
+            #  or label based, and if the latter, convert to positional
+            slobj = self.index._convert_slice_indexer(key, kind="getitem")
+            return self._slice(slobj)
         elif isinstance(key, ABCDataFrame):
             raise TypeError(
                 "Indexing a Series with DataFrame is not "
@@ -1134,14 +898,16 @@ def _get_with(self, key):
         elif isinstance(key, tuple):
             try:
                 return self._get_values_tuple(key)
-            except Exception:
+            except ValueError:
+                # if we don't have a MultiIndex, we may still be able to handle
+                #  a 1-tuple.  see test_1tuple_without_multiindex
                 if len(key) == 1:
                     key = key[0]
                     if isinstance(key, slice):
                         return self._get_values(key)
                 raise
 
-        if not isinstance(key, (list, np.ndarray, Series, Index)):
+        if not isinstance(key, (list, np.ndarray, ExtensionArray, Series, Index)):
             key = list(key)
 
         if isinstance(key, Index):
@@ -1149,13 +915,17 @@ def _get_with(self, key):
         else:
             key_type = lib.infer_dtype(key, skipna=False)
 
+        # Note: The key_type == "boolean" case should be caught by the
+        #  com.is_bool_indexer check in __getitem__
         if key_type == "integer":
+            # We need to decide whether to treat this as a positional indexer
+            #  (i.e. self.iloc) or label-based (i.e. self.loc)
             if self.index.is_integer() or self.index.is_floating():
                 return self.loc[key]
+            elif isinstance(self.index, IntervalIndex):
+                return self.loc[key]
             else:
-                return self._get_values(key)
-        elif key_type == "boolean":
-            return self._get_values(key)
+                return self.iloc[key]
 
         if isinstance(key, (list, tuple)):
             # TODO: de-dup with tuple case handled above?
@@ -1164,6 +934,17 @@ def _get_with(self, key):
                 # [slice(0, 5, None)] will break if you convert to ndarray,
                 # e.g. as requested by np.median
                 # FIXME: hack
+                if isinstance(key, list):
+                    # GH#31299
+                    warnings.warn(
+                        "Indexing with a single-item list containing a "
+                        "slice is deprecated and will raise in a future "
+                        "version.  Pass a tuple instead.",
+                        FutureWarning,
+                        stacklevel=3,
+                    )
+                    # TODO: use a message more like numpy's?
+                    key = tuple(key)
                 return self._get_values(key)
 
             return self.loc[key]
@@ -1173,7 +954,13 @@ def _get_with(self, key):
     def _get_values_tuple(self, key):
         # mpl hackaround
         if com.any_none(*key):
-            return self._get_values(key)
+            # suppress warning from slicing the index with a 2d indexer.
+            # eventually we'll want Series itself to warn.
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore", "Support for multi-dim", DeprecationWarning
+                )
+                return self._get_values(key)
 
         if not isinstance(self.index, MultiIndex):
             raise ValueError("Can only tuple-index with a MultiIndex")
@@ -1189,7 +976,9 @@ def _get_values(self, indexer):
             return self._constructor(
                 self._data.get_slice(indexer), fastpath=True
             ).__finalize__(self)
-        except Exception:
+        except ValueError:
+            # mpl compat if we look up e.g. ser[:, np.newaxis];
+            #  see tests.series.timeseries.test_mpl_compat_hack
             return self._values[indexer]
 
     def _get_value(self, label, takeable: bool = False):
@@ -1206,8 +995,11 @@ def _get_value(self, label, takeable: bool = False):
         scalar value
         """
         if takeable:
-            return com.maybe_box_datetimelike(self._values[label])
-        return self.index.get_value(self._values, label)
+            return self._values[label]
+
+        # We assume that _convert_scalar_indexer has already been called,
+        #  with kind="loc", if necessary, by the time we get here
+        return self.index.get_value(self, label)
 
     def __setitem__(self, key, value):
         key = com.apply_if_callable(key, self)
@@ -1215,8 +1007,6 @@ def __setitem__(self, key, value):
 
         try:
             self._set_with_engine(key, value)
-        except com.SettingWithCopyError:
-            raise
         except (KeyError, ValueError):
             values = self._values
             if is_integer(key) and not self.index.inferred_type == "integer":
@@ -1248,17 +1038,10 @@ def __setitem__(self, key, value):
             self._maybe_update_cacher()
 
     def _set_with_engine(self, key, value):
-        values = self._values
-        if is_extension_array_dtype(values.dtype):
-            # The cython indexing engine does not support ExtensionArrays.
-            values[self.index.get_loc(key)] = value
-            return
-        try:
-            self.index._engine.set_value(values, key, value)
-            return
-        except KeyError:
-            values[self.index.get_loc(key)] = value
-            return
+        # fails with AttributeError for IntervalIndex
+        loc = self.index._engine.get_loc(key)
+        validate_numeric_casting(self.dtype, value)
+        self._values[loc] = value
 
     def _set_with(self, key, value):
         # other: fancy integer or otherwise
@@ -1276,17 +1059,13 @@ def _set_with(self, key, value):
         else:
             if isinstance(key, tuple):
                 try:
+                    # TODO: no test cases that get here
                     self._set_values(key, value)
                 except Exception:
                     pass
 
             if is_scalar(key):
                 key = [key]
-            elif not isinstance(key, (list, Series, np.ndarray)):
-                try:
-                    key = list(key)
-                except Exception:
-                    key = [key]
 
             if isinstance(key, Index):
                 key_type = key.inferred_type
@@ -1306,10 +1085,10 @@ def _set_with(self, key, value):
 
     def _set_labels(self, key, value):
         key = com.asarray_tuplesafe(key)
-        indexer = self.index.get_indexer(key)
+        indexer: np.ndarray = self.index.get_indexer(key)
         mask = indexer == -1
         if mask.any():
-            raise ValueError("%s not contained in the index" % str(key[mask]))
+            raise ValueError(f"{key[mask]} not contained in the index")
         self._set_values(indexer, value)
 
     def _set_values(self, key, value):
@@ -1328,29 +1107,23 @@ def _set_value(self, label, value, takeable: bool = False):
         Parameters
         ----------
         label : object
-            Partial indexing with MultiIndex not allowed
+            Partial indexing with MultiIndex not allowed.
         value : object
-            Scalar value
+            Scalar value.
         takeable : interpret the index as indexers, default False
-
-        Returns
-        -------
-        Series
-            If label is contained, will be reference to calling Series,
-            otherwise a new object.
         """
         try:
             if takeable:
                 self._values[label] = value
             else:
-                self.index._engine.set_value(self._values, label, value)
-        except (KeyError, TypeError):
+                loc = self.index.get_loc(label)
+                validate_numeric_casting(self.dtype, value)
+                self._values[loc] = value
+        except KeyError:
 
             # set using a non-recursive method
             self.loc[label] = value
 
-        return self
-
     # ----------------------------------------------------------------------
     # Unsorted
 
@@ -1358,7 +1131,7 @@ def _set_value(self, label, value, takeable: bool = False):
     def _is_mixed_type(self):
         return False
 
-    def repeat(self, repeats, axis=None):
+    def repeat(self, repeats, axis=None) -> "Series":
         """
         Repeat elements of a Series.
 
@@ -1552,7 +1325,7 @@ def reset_index(self, level=None, drop=False, name=None, inplace=False):
     # ----------------------------------------------------------------------
     # Rendering Methods
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Return a string representation for a particular Series.
         """
@@ -1647,9 +1420,8 @@ def to_string(
         # catch contract violations
         if not isinstance(result, str):
             raise AssertionError(
-                "result must be of type unicode, type"
-                " of result is {0!r}"
-                "".format(result.__class__.__name__)
+                "result must be of type str, type "
+                f"of result is {repr(type(result).__name__)}"
             )
 
         if buf is None:
@@ -1661,9 +1433,30 @@ def to_string(
                 with open(buf, "w") as f:
                     f.write(result)
 
+    @Appender(
+        """
+        Examples
+        --------
+        >>> s = pd.Series(["elk", "pig", "dog", "quetzal"], name="animal")
+        >>> print(s.to_markdown())
+        |    | animal   |
+        |---:|:---------|
+        |  0 | elk      |
+        |  1 | pig      |
+        |  2 | dog      |
+        |  3 | quetzal  |
+        """
+    )
+    @Substitution(klass="Series")
+    @Appender(generic._shared_docs["to_markdown"])
+    def to_markdown(
+        self, buf: Optional[IO[str]] = None, mode: Optional[str] = None, **kwargs
+    ) -> Optional[str]:
+        return self.to_frame().to_markdown(buf, mode, **kwargs)
+
     # ----------------------------------------------------------------------
 
-    def items(self):
+    def items(self) -> Iterable[Tuple[Label, Any]]:
         """
         Lazily iterate over (index, value) tuples.
 
@@ -1685,7 +1478,7 @@ def items(self):
         --------
         >>> s = pd.Series(['A', 'B', 'C'])
         >>> for index, value in s.items():
-        ...     print("Index : {}, Value : {}".format(index, value))
+        ...     print(f"Index : {index}, Value : {value}")
         Index : 0, Value : A
         Index : 1, Value : B
         Index : 2, Value : C
@@ -1693,13 +1486,13 @@ def items(self):
         return zip(iter(self.index), iter(self))
 
     @Appender(items.__doc__)
-    def iteritems(self):
+    def iteritems(self) -> Iterable[Tuple[Label, Any]]:
         return self.items()
 
     # ----------------------------------------------------------------------
     # Misc public methods
 
-    def keys(self):
+    def keys(self) -> Index:
         """
         Return alias for index.
 
@@ -1745,7 +1538,7 @@ def to_dict(self, into=dict):
         into_c = com.standardize_mapping(into)
         return into_c(self.items())
 
-    def to_frame(self, name=None):
+    def to_frame(self, name=None) -> "DataFrame":
         """
         Convert Series to DataFrame.
 
@@ -1777,39 +1570,7 @@ def to_frame(self, name=None):
 
         return df
 
-    def to_sparse(self, kind="block", fill_value=None):
-        """
-        Convert Series to SparseSeries.
-
-        .. deprecated:: 0.25.0
-
-        Parameters
-        ----------
-        kind : {'block', 'integer'}, default 'block'
-        fill_value : float, defaults to NaN (missing)
-            Value to use for filling NaN values.
-
-        Returns
-        -------
-        SparseSeries
-            Sparse representation of the Series.
-        """
-
-        warnings.warn(
-            "Series.to_sparse is deprecated and will be removed in a future version",
-            FutureWarning,
-            stacklevel=2,
-        )
-        from pandas.core.sparse.series import SparseSeries
-
-        values = SparseArray(self, kind=kind, fill_value=fill_value)
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", message="SparseSeries")
-            return SparseSeries(values, index=self.index, name=self.name).__finalize__(
-                self
-            )
-
-    def _set_name(self, name, inplace=False):
+    def _set_name(self, name, inplace=False) -> "Series":
         """
         Set the Series name.
 
@@ -1817,13 +1578,97 @@ def _set_name(self, name, inplace=False):
         ----------
         name : str
         inplace : bool
-            whether to modify `self` directly or return a copy
+            Whether to modify `self` directly or return a copy.
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
         ser = self if inplace else self.copy()
         ser.name = name
         return ser
 
+    @Appender(
+        """
+Examples
+--------
+>>> ser = pd.Series([390., 350., 30., 20.],
+...                 index=['Falcon', 'Falcon', 'Parrot', 'Parrot'], name="Max Speed")
+>>> ser
+Falcon    390.0
+Falcon    350.0
+Parrot     30.0
+Parrot     20.0
+Name: Max Speed, dtype: float64
+>>> ser.groupby(["a", "b", "a", "b"]).mean()
+a    210.0
+b    185.0
+Name: Max Speed, dtype: float64
+>>> ser.groupby(level=0).mean()
+Falcon    370.0
+Parrot     25.0
+Name: Max Speed, dtype: float64
+>>> ser.groupby(ser > 100).mean()
+Max Speed
+False     25.0
+True     370.0
+Name: Max Speed, dtype: float64
+
+**Grouping by Indexes**
+
+We can groupby different levels of a hierarchical index
+using the `level` parameter:
+
+>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
+...           ['Captive', 'Wild', 'Captive', 'Wild']]
+>>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
+>>> ser = pd.Series([390., 350., 30., 20.], index=index, name="Max Speed")
+>>> ser
+Animal  Type
+Falcon  Captive    390.0
+        Wild       350.0
+Parrot  Captive     30.0
+        Wild        20.0
+Name: Max Speed, dtype: float64
+>>> ser.groupby(level=0).mean()
+Animal
+Falcon    370.0
+Parrot     25.0
+Name: Max Speed, dtype: float64
+>>> ser.groupby(level="Type").mean()
+Type
+Captive    210.0
+Wild       185.0
+Name: Max Speed, dtype: float64
+"""
+    )
+    @Appender(generic._shared_docs["groupby"] % _shared_doc_kwargs)
+    def groupby(
+        self,
+        by=None,
+        axis=0,
+        level=None,
+        as_index: bool = True,
+        sort: bool = True,
+        group_keys: bool = True,
+        squeeze: bool = False,
+        observed: bool = False,
+    ) -> "SeriesGroupBy":
+        from pandas.core.groupby.generic import SeriesGroupBy
+
+        if level is None and by is None:
+            raise TypeError("You have to supply one of 'by' and 'level'")
+        axis = self._get_axis_number(axis)
+
+        return SeriesGroupBy(
+            obj=self,
+            keys=by,
+            axis=axis,
+            level=level,
+            as_index=as_index,
+            sort=sort,
+            group_keys=group_keys,
+            squeeze=squeeze,
+            observed=observed,
+        )
+
     # ----------------------------------------------------------------------
     # Statistics, overridden ndarray methods
 
@@ -1868,7 +1713,7 @@ def count(self, level=None):
         out = np.bincount(obs, minlength=len(lev) or None)
         return self._constructor(out, index=lev, dtype="int64").__finalize__(self)
 
-    def mode(self, dropna=True):
+    def mode(self, dropna=True) -> "Series":
         """
         Return the mode(s) of the dataset.
 
@@ -1953,16 +1798,19 @@ def unique(self):
         result = super().unique()
         return result
 
-    def drop_duplicates(self, keep="first", inplace=False):
+    def drop_duplicates(self, keep="first", inplace=False) -> "Series":
         """
         Return Series with duplicate values removed.
 
         Parameters
         ----------
         keep : {'first', 'last', ``False``}, default 'first'
+            Method to handle dropping duplicates:
+
             - 'first' : Drop duplicates except for the first occurrence.
             - 'last' : Drop duplicates except for the last occurrence.
             - ``False`` : Drop all duplicates.
+
         inplace : bool, default ``False``
             If ``True``, performs operation inplace and returns None.
 
@@ -2027,7 +1875,7 @@ def drop_duplicates(self, keep="first", inplace=False):
         """
         return super().drop_duplicates(keep=keep, inplace=inplace)
 
-    def duplicated(self, keep="first"):
+    def duplicated(self, keep="first") -> "Series":
         """
         Indicate duplicate Series values.
 
@@ -2038,6 +1886,8 @@ def duplicated(self, keep="first"):
         Parameters
         ----------
         keep : {'first', 'last', False}, default 'first'
+            Method to handle dropping duplicates:
+
             - 'first' : Mark duplicates as ``True`` except for the first
               occurrence.
             - 'last' : Mark duplicates as ``True`` except for the last
@@ -2112,15 +1962,15 @@ def idxmin(self, axis=0, skipna=True, *args, **kwargs):
 
         Parameters
         ----------
-        skipna : bool, default True
-            Exclude NA/null values. If the entire Series is NA, the result
-            will be NA.
         axis : int, default 0
             For compatibility with DataFrame.idxmin. Redundant for application
             on Series.
+        skipna : bool, default True
+            Exclude NA/null values. If the entire Series is NA, the result
+            will be NA.
         *args, **kwargs
-            Additional keywords have no effect but might be accepted
-            for compatibility with NumPy.
+            Additional arguments and keywords have no effect but might be
+            accepted for compatibility with NumPy.
 
         Returns
         -------
@@ -2182,15 +2032,15 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
 
         Parameters
         ----------
-        skipna : bool, default True
-            Exclude NA/null values. If the entire Series is NA, the result
-            will be NA.
         axis : int, default 0
             For compatibility with DataFrame.idxmax. Redundant for application
             on Series.
+        skipna : bool, default True
+            Exclude NA/null values. If the entire Series is NA, the result
+            will be NA.
         *args, **kwargs
-            Additional keywords have no effect but might be accepted
-            for compatibility with NumPy.
+            Additional arguments and keywords have no effect but might be
+            accepted for compatibility with NumPy.
 
         Returns
         -------
@@ -2244,46 +2094,15 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
             return np.nan
         return self.index[i]
 
-    # ndarray compat
-    argmin = deprecate(
-        "argmin",
-        idxmin,
-        "0.21.0",
-        msg=dedent(
-            """
-        The current behaviour of 'Series.argmin' is deprecated, use 'idxmin'
-        instead.
-        The behavior of 'argmin' will be corrected to return the positional
-        minimum in the future. For now, use 'series.values.argmin' or
-        'np.argmin(np.array(values))' to get the position of the minimum
-        row."""
-        ),
-    )
-    argmax = deprecate(
-        "argmax",
-        idxmax,
-        "0.21.0",
-        msg=dedent(
-            """
-        The current behaviour of 'Series.argmax' is deprecated, use 'idxmax'
-        instead.
-        The behavior of 'argmax' will be corrected to return the positional
-        maximum in the future. For now, use 'series.values.argmax' or
-        'np.argmax(np.array(values))' to get the position of the maximum
-        row."""
-        ),
-    )
-
-    def round(self, decimals=0, *args, **kwargs):
+    def round(self, decimals=0, *args, **kwargs) -> "Series":
         """
         Round each value in a Series to the given number of decimals.
 
         Parameters
         ----------
-        decimals : int
-            Number of decimal places to round to (default: 0).
-            If decimals is negative, it specifies the number of
-            positions to the left of the decimal point.
+        decimals : int, default 0
+            Number of decimal places to round to. If decimals is negative,
+            it specifies the number of positions to the left of the decimal point.
 
         Returns
         -------
@@ -2317,7 +2136,7 @@ def quantile(self, q=0.5, interpolation="linear"):
         Parameters
         ----------
         q : float or array-like, default 0.5 (50% quantile)
-            0 <= q <= 1, the quantile(s) to compute.
+            The quantile(s) to compute, which can lie in range: 0 <= q <= 1.
         interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
             This optional parameter specifies the interpolation method to use,
             when the desired quantile lies between two data points `i` and `j`:
@@ -2353,7 +2172,7 @@ def quantile(self, q=0.5, interpolation="linear"):
         dtype: float64
         """
 
-        self._check_percentile(q)
+        validate_percentile(q)
 
         # We dispatch to DataFrame so that core.internals only has to worry
         #  about 2D cases.
@@ -2370,7 +2189,7 @@ def quantile(self, q=0.5, interpolation="linear"):
             # scalar
             return result.iloc[0]
 
-    def corr(self, other, method="pearson", min_periods=None):
+    def corr(self, other, method="pearson", min_periods=None) -> float:
         """
         Compute correlation with `other` Series, excluding missing values.
 
@@ -2379,15 +2198,17 @@ def corr(self, other, method="pearson", min_periods=None):
         other : Series
             Series with which to compute the correlation.
         method : {'pearson', 'kendall', 'spearman'} or callable
-            * pearson : standard correlation coefficient
-            * kendall : Kendall Tau correlation coefficient
-            * spearman : Spearman rank correlation
-            * callable: callable with input two 1d ndarrays
-                and returning a float. Note that the returned matrix from corr
-                will have 1 along the diagonals and will be symmetric
-                regardless of the callable's behavior
-                .. versionadded:: 0.24.0
+            Method used to compute correlation:
+
+            - pearson : Standard correlation coefficient
+            - kendall : Kendall Tau correlation coefficient
+            - spearman : Spearman rank correlation
+            - callable: Callable with input two 1d ndarrays and returning a float.
 
+            .. versionadded:: 0.24.0
+                Note that the returned matrix from corr will have 1 along the
+                diagonals and will be symmetric regardless of the callable's
+                behavior.
         min_periods : int, optional
             Minimum number of observations needed to have a valid result.
 
@@ -2418,10 +2239,10 @@ def corr(self, other, method="pearson", min_periods=None):
         raise ValueError(
             "method must be either 'pearson', "
             "'spearman', 'kendall', or a callable, "
-            "'{method}' was supplied".format(method=method)
+            f"'{method}' was supplied"
         )
 
-    def cov(self, other, min_periods=None):
+    def cov(self, other, min_periods=None) -> float:
         """
         Compute covariance with Series, excluding missing values.
 
@@ -2450,7 +2271,7 @@ def cov(self, other, min_periods=None):
             return np.nan
         return nanops.nancov(this.values, other.values, min_periods=min_periods)
 
-    def diff(self, periods=1):
+    def diff(self, periods=1) -> "Series":
         """
         First discrete difference of element.
 
@@ -2475,6 +2296,11 @@ def diff(self, periods=1):
             optional time freq.
         DataFrame.diff: First discrete difference of object.
 
+        Notes
+        -----
+        For boolean dtypes, this uses :meth:`operator.xor` rather than
+        :meth:`operator.sub`.
+
         Examples
         --------
         Difference with previous row
@@ -2511,10 +2337,10 @@ def diff(self, periods=1):
         5    NaN
         dtype: float64
         """
-        result = algorithms.diff(com.values_from_object(self), periods)
+        result = algorithms.diff(self.array, periods)
         return self._constructor(result, index=self.index).__finalize__(self)
 
-    def autocorr(self, lag=1):
+    def autocorr(self, lag=1) -> float:
         """
         Compute the lag-N autocorrelation.
 
@@ -2623,7 +2449,7 @@ def dot(self, other):
             rvals = np.asarray(other)
             if lvals.shape[0] != rvals.shape[0]:
                 raise Exception(
-                    "Dot product shape mismatch, %s vs %s" % (lvals.shape, rvals.shape)
+                    f"Dot product shape mismatch, {lvals.shape} vs {rvals.shape}"
                 )
 
         if isinstance(other, ABCDataFrame):
@@ -2635,7 +2461,7 @@ def dot(self, other):
         elif isinstance(rvals, np.ndarray):
             return np.dot(lvals, rvals)
         else:  # pragma: no cover
-            raise TypeError("unsupported type: %s" % type(other))
+            raise TypeError(f"unsupported type: {type(other)}")
 
     def __matmul__(self, other):
         """
@@ -2748,10 +2574,10 @@ def _binop(self, other, func, level=None, fill_value=None):
         func : binary operator
         fill_value : float or object
             Value to substitute for NA/null values. If both Series are NA in a
-            location, the result will be NA regardless of the passed fill value
+            location, the result will be NA regardless of the passed fill value.
         level : int or level name, default None
             Broadcast across a level, matching Index values on the
-            passed MultiIndex level
+            passed MultiIndex level.
 
         Returns
         -------
@@ -2774,13 +2600,10 @@ def _binop(self, other, func, level=None, fill_value=None):
             result = func(this_vals, other_vals)
 
         name = ops.get_op_result_name(self, other)
-        if func.__name__ in ["divmod", "rdivmod"]:
-            ret = ops._construct_divmod_result(self, result, new_index, name)
-        else:
-            ret = ops._construct_result(self, result, new_index, name)
+        ret = ops._construct_result(self, result, new_index, name)
         return ret
 
-    def combine(self, other, func, fill_value=None):
+    def combine(self, other, func, fill_value=None) -> "Series":
         """
         Combine the Series with a Series or scalar according to `func`.
 
@@ -2874,17 +2697,10 @@ def combine(self, other, func, fill_value=None):
         elif is_extension_array_dtype(self.values):
             # The function can return something of any type, so check
             # if the type is compatible with the calling EA.
-            try:
-                new_values = self._values._from_sequence(new_values)
-            except Exception:
-                # https://github.com/pandas-dev/pandas/issues/22850
-                # pandas has no control over what 3rd-party ExtensionArrays
-                # do in _values_from_sequence. We still want ops to work
-                # though, so we catch any regular Exception.
-                pass
+            new_values = try_cast_to_ea(self._values, new_values)
         return self._constructor(new_values, index=new_index, name=new_name)
 
-    def combine_first(self, other):
+    def combine_first(self, other) -> "Series":
         """
         Combine Series values, choosing the calling Series's values first.
 
@@ -2919,12 +2735,12 @@ def combine_first(self, other):
         new_index = self.index.union(other.index)
         this = self.reindex(new_index, copy=False)
         other = other.reindex(new_index, copy=False)
-        if is_datetimelike(this) and not is_datetimelike(other):
+        if this.dtype.kind == "M" and other.dtype.kind != "M":
             other = to_datetime(other)
 
         return this.where(notna(this), other)
 
-    def update(self, other):
+    def update(self, other) -> None:
         """
         Modify Series in place using non-NA values from passed
         Series. Aligns on index.
@@ -2983,9 +2799,10 @@ def sort_values(
         self,
         axis=0,
         ascending=True,
-        inplace=False,
-        kind="quicksort",
-        na_position="last",
+        inplace: bool = False,
+        kind: str = "quicksort",
+        na_position: str = "last",
+        ignore_index: bool = False,
     ):
         """
         Sort by the values.
@@ -3008,6 +2825,10 @@ def sort_values(
         na_position : {'first' or 'last'}, default 'last'
             Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
             the end.
+        ignore_index : bool, default False
+             If True, the resulting axis will be labeled 0, 1, …, n - 1.
+
+             .. versionadded:: 1.0.0
 
         Returns
         -------
@@ -3113,7 +2934,7 @@ def _try_kind_sort(arr):
                 return arr.argsort(kind="quicksort")
 
         arr = self._values
-        sortedIdx = np.empty(len(self), dtype=np.int32)
+        sorted_index = np.empty(len(self), dtype=np.int32)
 
         bad = isna(arr)
 
@@ -3125,8 +2946,7 @@ def _try_kind_sort(arr):
         if is_list_like(ascending):
             if len(ascending) != 1:
                 raise ValueError(
-                    "Length of ascending (%d) must be 1 "
-                    "for Series" % (len(ascending))
+                    f"Length of ascending ({len(ascending)}) must be 1 for Series"
                 )
             ascending = ascending[0]
 
@@ -3138,16 +2958,19 @@ def _try_kind_sort(arr):
 
         if na_position == "last":
             n = good.sum()
-            sortedIdx[:n] = idx[good][argsorted]
-            sortedIdx[n:] = idx[bad]
+            sorted_index[:n] = idx[good][argsorted]
+            sorted_index[n:] = idx[bad]
         elif na_position == "first":
             n = bad.sum()
-            sortedIdx[n:] = idx[good][argsorted]
-            sortedIdx[:n] = idx[bad]
+            sorted_index[n:] = idx[good][argsorted]
+            sorted_index[:n] = idx[bad]
         else:
-            raise ValueError("invalid na_position: {!r}".format(na_position))
+            raise ValueError(f"invalid na_position: {na_position}")
 
-        result = self._constructor(arr[sortedIdx], index=self.index[sortedIdx])
+        result = self._constructor(arr[sorted_index], index=self.index[sorted_index])
+
+        if ignore_index:
+            result.index = ibase.default_index(len(sorted_index))
 
         if inplace:
             self._update_inplace(result)
@@ -3163,6 +2986,7 @@ def sort_index(
         kind="quicksort",
         na_position="last",
         sort_remaining=True,
+        ignore_index: bool = False,
     ):
         """
         Sort Series by index labels.
@@ -3191,6 +3015,10 @@ def sort_index(
         sort_remaining : bool, default True
             If True and sorting by level and index is multilevel, sort by other
             levels too (in order) after sorting by specified level.
+        ignore_index : bool, default False
+            If True, the resulting axis will be labeled 0, 1, …, n - 1.
+
+            .. versionadded:: 1.0.0
 
         Returns
         -------
@@ -3318,23 +3146,26 @@ def sort_index(
         new_values = self._values.take(indexer)
         result = self._constructor(new_values, index=new_index)
 
+        if ignore_index:
+            result.index = ibase.default_index(len(result))
+
         if inplace:
             self._update_inplace(result)
         else:
             return result.__finalize__(self)
 
-    def argsort(self, axis=0, kind="quicksort", order=None):
+    def argsort(self, axis=0, kind="quicksort", order=None) -> "Series":
         """
         Override ndarray.argsort. Argsorts the value, omitting NA/null values,
         and places the result in the same locations as the non-NA values.
 
         Parameters
         ----------
-        axis : int
+        axis : {0 or "index"}
             Has no effect but is accepted for compatibility with numpy.
         kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
             Choice of sorting algorithm. See np.sort for more
-            information. 'mergesort' is the only stable algorithm
+            information. 'mergesort' is the only stable algorithm.
         order : None
             Has no effect but is accepted for compatibility with numpy.
 
@@ -3361,7 +3192,7 @@ def argsort(self, axis=0, kind="quicksort", order=None):
                 np.argsort(values, kind=kind), index=self.index, dtype="int64"
             ).__finalize__(self)
 
-    def nlargest(self, n=5, keep="first"):
+    def nlargest(self, n=5, keep="first") -> "Series":
         """
         Return the largest `n` elements.
 
@@ -3459,7 +3290,7 @@ def nlargest(self, n=5, keep="first"):
         """
         return algorithms.SelectNSeries(self, n=n, keep=keep).nlargest()
 
-    def nsmallest(self, n=5, keep="first"):
+    def nsmallest(self, n=5, keep="first") -> "Series":
         """
         Return the smallest `n` elements.
 
@@ -3556,7 +3387,7 @@ def nsmallest(self, n=5, keep="first"):
         """
         return algorithms.SelectNSeries(self, n=n, keep=keep).nsmallest()
 
-    def swaplevel(self, i=-2, j=-1, copy=True):
+    def swaplevel(self, i=-2, j=-1, copy=True) -> "Series":
         """
         Swap levels i and j in a :class:`MultiIndex`.
 
@@ -3564,8 +3395,8 @@ def swaplevel(self, i=-2, j=-1, copy=True):
 
         Parameters
         ----------
-        i, j : int, str (can be mixed)
-            Level of index to be swapped. Can pass level name as string.
+        i, j : int, str
+            Level of the indices to be swapped. Can pass level name as string.
         copy : bool, default True
             Whether to copy underlying data.
 
@@ -3574,12 +3405,13 @@ def swaplevel(self, i=-2, j=-1, copy=True):
         Series
             Series with levels swapped in MultiIndex.
         """
+        assert isinstance(self.index, ABCMultiIndex)
         new_index = self.index.swaplevel(i, j)
         return self._constructor(self._values, index=new_index, copy=copy).__finalize__(
             self
         )
 
-    def reorder_levels(self, order):
+    def reorder_levels(self, order) -> "Series":
         """
         Rearrange index levels using input order.
 
@@ -3588,7 +3420,7 @@ def reorder_levels(self, order):
         Parameters
         ----------
         order : list of int representing new level order
-               (reference level by number or key)
+            Reference level by number or key.
 
         Returns
         -------
@@ -3598,6 +3430,7 @@ def reorder_levels(self, order):
             raise Exception("Can only reorder levels on a hierarchical axis.")
 
         result = self.copy()
+        assert isinstance(result.index, ABCMultiIndex)
         result.index = result.index.reorder_levels(order)
         return result
 
@@ -3659,7 +3492,7 @@ def explode(self) -> "Series":
 
     def unstack(self, level=-1, fill_value=None):
         """
-        Unstack, a.k.a. pivot, Series with MultiIndex to produce DataFrame.
+        Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
         The level involved will automatically get sorted.
 
         Parameters
@@ -3703,7 +3536,7 @@ def unstack(self, level=-1, fill_value=None):
     # ----------------------------------------------------------------------
     # function application
 
-    def map(self, arg, na_action=None):
+    def map(self, arg, na_action=None) -> "Series":
         """
         Map values of Series according to input correspondence.
 
@@ -3713,7 +3546,7 @@ def map(self, arg, na_action=None):
 
         Parameters
         ----------
-        arg : function, dict, or Series
+        arg : function, collections.abc.Mapping subclass or Series
             Mapping correspondence.
         na_action : {None, 'ignore'}, default None
             If 'ignore', propagate NaN values, without passing them to the
@@ -3781,7 +3614,7 @@ def map(self, arg, na_action=None):
         new_values = super()._map_values(arg, na_action=na_action)
         return self._constructor(new_values, index=self.index).__finalize__(self)
 
-    def _gotitem(self, key, ndim, subset=None):
+    def _gotitem(self, key, ndim, subset=None) -> "Series":
         """
         Sub-classes to define. Return a sliced object.
 
@@ -3789,9 +3622,9 @@ def _gotitem(self, key, ndim, subset=None):
         ----------
         key : string / list of selections
         ndim : 1,2
-            requested ndim of result
+            Requested ndim of result.
         subset : object, default None
-            subset to act on
+            Subset to act on.
         """
         return self
 
@@ -3830,7 +3663,7 @@ def _gotitem(self, key, ndim, subset=None):
         see_also=_agg_see_also_doc,
         examples=_agg_examples_doc,
         versionadded="\n.. versionadded:: 0.20.0\n",
-        **_shared_doc_kwargs
+        **_shared_doc_kwargs,
     )
     @Appender(generic._shared_docs["aggregate"])
     def aggregate(self, func, axis=0, *args, **kwargs):
@@ -3991,7 +3824,8 @@ def f(x):
                 return f(self)
 
             # row-wise access
-            if is_extension_type(self.dtype):
+            if is_extension_array_dtype(self.dtype) and hasattr(self._values, "map"):
+                # GH#23179 some EAs do not have `map`
                 mapped = self._values.map(f)
             else:
                 values = self.astype(object).values
@@ -4019,9 +3853,7 @@ def _reduce(
             self._get_axis_number(axis)
 
         if isinstance(delegate, Categorical):
-            # TODO deprecate numeric_only argument for Categorical and use
-            # skipna as well, see GH25303
-            return delegate._reduce(name, numeric_only=numeric_only, **kwds)
+            return delegate._reduce(name, skipna=skipna, **kwds)
         elif isinstance(delegate, ExtensionArray):
             # dispatch to ExtensionArray interface
             return delegate._reduce(name, skipna=skipna, **kwds)
@@ -4037,7 +3869,7 @@ def _reduce(
         elif isinstance(delegate, np.ndarray):
             if numeric_only:
                 raise NotImplementedError(
-                    "Series.{0} does not implement numeric_only.".format(name)
+                    f"Series.{name} does not implement numeric_only."
                 )
             with np.errstate(all="ignore"):
                 return op(delegate, skipna=skipna, **kwds)
@@ -4052,7 +3884,7 @@ def _reduce(
             skipna=skipna,
             numeric_only=numeric_only,
             filter_type=filter_type,
-            **kwds
+            **kwds,
         )
 
     def _reindex_indexer(self, new_index, indexer, copy):
@@ -4100,7 +3932,16 @@ def align(
             broadcast_axis=broadcast_axis,
         )
 
-    def rename(self, index=None, **kwargs):
+    def rename(
+        self,
+        index=None,
+        *,
+        axis=None,
+        copy=True,
+        inplace=False,
+        level=None,
+        errors="ignore",
+    ):
         """
         Alter Series index labels or name.
 
@@ -4114,19 +3955,17 @@ def rename(self, index=None, **kwargs):
 
         Parameters
         ----------
+        axis : {0 or "index"}
+            Unused. Accepted for compatability with DataFrame method only.
         index : scalar, hashable sequence, dict-like or function, optional
-            dict-like or functions are transformations to apply to
+            Functions or dict-like are transformations to apply to
             the index.
             Scalar or hashable sequence-like will alter the ``Series.name``
             attribute.
-        copy : bool, default True
-            Whether to copy underlying data.
-        inplace : bool, default False
-            Whether to return a new Series. If True then value of copy is
-            ignored.
-        level : int or level name, default None
-            In case of a MultiIndex, only rename labels in the specified
-            level.
+
+        **kwargs
+            Additional keyword arguments passed to the function. Only the
+            "inplace" keyword is used.
 
         Returns
         -------
@@ -4135,6 +3974,7 @@ def rename(self, index=None, **kwargs):
 
         See Also
         --------
+        DataFrame.rename : Corresponding DataFrame method.
         Series.rename_axis : Set the name of the axis.
 
         Examples
@@ -4161,12 +4001,38 @@ def rename(self, index=None, **kwargs):
         5    3
         dtype: int64
         """
-        kwargs["inplace"] = validate_bool_kwarg(kwargs.get("inplace", False), "inplace")
-
         if callable(index) or is_dict_like(index):
-            return super().rename(index=index, **kwargs)
+            return super().rename(
+                index, copy=copy, inplace=inplace, level=level, errors=errors
+            )
         else:
-            return self._set_name(index, inplace=kwargs.get("inplace"))
+            return self._set_name(index, inplace=inplace)
+
+    @Appender(
+        """
+        >>> s = pd.Series([1, 2, 3])
+        >>> s
+        0    1
+        1    2
+        2    3
+        dtype: int64
+
+        >>> s.set_axis(['a', 'b', 'c'], axis=0)
+        a    1
+        b    2
+        c    3
+        dtype: int64
+    """
+    )
+    @Substitution(
+        **_shared_doc_kwargs,
+        extended_summary_sub="",
+        axis_description_sub="",
+        see_also_sub="",
+    )
+    @Appender(generic.NDFrame.set_axis.__doc__)
+    def set_axis(self, labels, axis=0, inplace=False):
+        return super().set_axis(labels, axis=axis, inplace=inplace)
 
     @Substitution(**_shared_doc_kwargs)
     @Appender(generic.NDFrame.reindex.__doc__)
@@ -4182,7 +4048,7 @@ def drop(
         level=None,
         inplace=False,
         errors="raise",
-    ):
+    ) -> "Series":
         """
         Return Series with specified index labels removed.
 
@@ -4196,9 +4062,13 @@ def drop(
             Index labels to drop.
         axis : 0, default 0
             Redundant for application on Series.
-        index, columns : None
-            Redundant for application on Series, but index can be used instead
-            of labels.
+        index : single label or list-like
+            Redundant for application on Series, but 'index' can be used instead
+            of 'labels'.
+
+            .. versionadded:: 0.21.0
+        columns : single label or list-like
+            No change is made to the Series; use 'index' or 'labels' instead.
 
             .. versionadded:: 0.21.0
         level : int or level name, optional
@@ -4289,8 +4159,7 @@ def fillna(
         inplace=False,
         limit=None,
         downcast=None,
-        **kwargs
-    ):
+    ) -> Optional["Series"]:
         return super().fillna(
             value=value,
             method=method,
@@ -4298,7 +4167,6 @@ def fillna(
             inplace=inplace,
             limit=limit,
             downcast=downcast,
-            **kwargs
         )
 
     @Appender(generic._shared_docs["replace"] % _shared_doc_kwargs)
@@ -4321,7 +4189,7 @@ def replace(
         )
 
     @Appender(generic._shared_docs["shift"] % _shared_doc_kwargs)
-    def shift(self, periods=1, freq=None, axis=0, fill_value=None):
+    def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> "Series":
         return super().shift(
             periods=periods, freq=freq, axis=axis, fill_value=fill_value
         )
@@ -4380,7 +4248,7 @@ def memory_usage(self, index=True, deep=False):
             v += self.index.memory_usage(deep=deep)
         return v
 
-    def isin(self, values):
+    def isin(self, values) -> "Series":
         """
         Check whether `values` are contained in Series.
 
@@ -4436,7 +4304,7 @@ def isin(self, values):
         result = algorithms.isin(self, values)
         return self._constructor(result, index=self.index).__finalize__(self)
 
-    def between(self, left, right, inclusive=True):
+    def between(self, left, right, inclusive=True) -> "Series":
         """
         Return boolean Series equivalent to left <= series <= right.
 
@@ -4446,9 +4314,9 @@ def between(self, left, right, inclusive=True):
 
         Parameters
         ----------
-        left : scalar
+        left : scalar or list-like
             Left boundary.
-        right : scalar
+        right : scalar or list-like
             Right boundary.
         inclusive : bool, default True
             Include boundaries.
@@ -4511,118 +4379,51 @@ def between(self, left, right, inclusive=True):
 
         return lmask & rmask
 
-    @Appender(generic.NDFrame.to_csv.__doc__)
-    def to_csv(self, *args, **kwargs):
-
-        names = [
-            "path_or_buf",
-            "sep",
-            "na_rep",
-            "float_format",
-            "columns",
-            "header",
-            "index",
-            "index_label",
-            "mode",
-            "encoding",
-            "compression",
-            "quoting",
-            "quotechar",
-            "line_terminator",
-            "chunksize",
-            "date_format",
-            "doublequote",
-            "escapechar",
-            "decimal",
-        ]
-
-        old_names = [
-            "path_or_buf",
-            "index",
-            "sep",
-            "na_rep",
-            "float_format",
-            "header",
-            "index_label",
-            "mode",
-            "encoding",
-            "compression",
-            "date_format",
-            "decimal",
-        ]
-
-        if "path" in kwargs:
-            warnings.warn(
-                "The signature of `Series.to_csv` was aligned "
-                "to that of `DataFrame.to_csv`, and argument "
-                "'path' will be renamed to 'path_or_buf'.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            kwargs["path_or_buf"] = kwargs.pop("path")
-
-        if len(args) > 1:
-            # Either "index" (old signature) or "sep" (new signature) is being
-            # passed as second argument (while the first is the same)
-            maybe_sep = args[1]
-
-            if not (is_string_like(maybe_sep) and len(maybe_sep) == 1):
-                # old signature
-                warnings.warn(
-                    "The signature of `Series.to_csv` was aligned "
-                    "to that of `DataFrame.to_csv`. Note that the "
-                    "order of arguments changed, and the new one "
-                    "has 'sep' in first place, for which \"{}\" is "
-                    "not a valid value. The old order will cease to "
-                    "be supported in a future version. Please refer "
-                    "to the documentation for `DataFrame.to_csv` "
-                    "when updating your function "
-                    "calls.".format(maybe_sep),
-                    FutureWarning,
-                    stacklevel=2,
-                )
-                names = old_names
-
-        pos_args = dict(zip(names[: len(args)], args))
-
-        for key in pos_args:
-            if key in kwargs:
-                raise ValueError(
-                    "Argument given by name ('{}') and position "
-                    "({})".format(key, names.index(key))
-                )
-            kwargs[key] = pos_args[key]
-
-        if kwargs.get("header", None) is None:
-            warnings.warn(
-                "The signature of `Series.to_csv` was aligned "
-                "to that of `DataFrame.to_csv`, and argument "
-                "'header' will change its default value from False "
-                "to True: please pass an explicit value to suppress "
-                "this warning.",
-                FutureWarning,
-                stacklevel=2,
+    # ----------------------------------------------------------------------
+    # Convert to types that support pd.NA
+
+    def _convert_dtypes(
+        self: ABCSeries,
+        infer_objects: bool = True,
+        convert_string: bool = True,
+        convert_integer: bool = True,
+        convert_boolean: bool = True,
+    ) -> "Series":
+        input_series = self
+        if infer_objects:
+            input_series = input_series.infer_objects()
+            if is_object_dtype(input_series):
+                input_series = input_series.copy()
+
+        if convert_string or convert_integer or convert_boolean:
+            inferred_dtype = convert_dtypes(
+                input_series._values, convert_string, convert_integer, convert_boolean
             )
-            kwargs["header"] = False  # Backwards compatibility.
-        return self.to_frame().to_csv(**kwargs)
+            try:
+                result = input_series.astype(inferred_dtype)
+            except TypeError:
+                result = input_series.copy()
+        else:
+            result = input_series.copy()
+        return result
 
     @Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
-    def isna(self):
+    def isna(self) -> "Series":
         return super().isna()
 
     @Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
-    def isnull(self):
+    def isnull(self) -> "Series":
         return super().isnull()
 
     @Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
-    def notna(self):
+    def notna(self) -> "Series":
         return super().notna()
 
     @Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
-    def notnull(self):
+    def notnull(self) -> "Series":
         return super().notnull()
 
-    def dropna(self, axis=0, inplace=False, **kwargs):
+    def dropna(self, axis=0, inplace=False, how=None):
         """
         Return a new Series with missing values removed.
 
@@ -4635,8 +4436,8 @@ def dropna(self, axis=0, inplace=False, **kwargs):
             There is only one axis to drop values from.
         inplace : bool, default False
             If True, do operation inplace and return None.
-        **kwargs
-            Not in use.
+        how : str, optional
+            Not in use. Kept for compatibility.
 
         Returns
         -------
@@ -4694,12 +4495,6 @@ def dropna(self, axis=0, inplace=False, **kwargs):
         dtype: object
         """
         inplace = validate_bool_kwarg(inplace, "inplace")
-        kwargs.pop("how", None)
-        if kwargs:
-            raise TypeError(
-                "dropna() got an unexpected keyword "
-                'argument "{0}"'.format(list(kwargs.keys())[0])
-            )
         # Validate the axis parameter
         self._get_axis_number(axis or 0)
 
@@ -4716,30 +4511,10 @@ def dropna(self, axis=0, inplace=False, **kwargs):
             else:
                 return self.copy()
 
-    def valid(self, inplace=False, **kwargs):
-        """
-        Return Series without null values.
-
-        .. deprecated:: 0.23.0
-            Use :meth:`Series.dropna` instead.
-
-        Returns
-        -------
-        Series
-            Series without null values.
-        """
-        warnings.warn(
-            "Method .valid will be removed in a future version. "
-            "Use .dropna instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return self.dropna(inplace=inplace, **kwargs)
-
     # ----------------------------------------------------------------------
     # Time series-oriented methods
 
-    def to_timestamp(self, freq=None, how="start", copy=True):
+    def to_timestamp(self, freq=None, how="start", copy=True) -> "Series":
         """
         Cast to DatetimeIndex of Timestamps, at *beginning* of period.
 
@@ -4761,10 +4536,11 @@ def to_timestamp(self, freq=None, how="start", copy=True):
         if copy:
             new_values = new_values.copy()
 
+        assert isinstance(self.index, (ABCDatetimeIndex, ABCPeriodIndex))
         new_index = self.index.to_timestamp(freq=freq, how=how)
         return self._constructor(new_values, index=new_index).__finalize__(self)
 
-    def to_period(self, freq=None, copy=True):
+    def to_period(self, freq=None, copy=True) -> "Series":
         """
         Convert Series from DatetimeIndex to PeriodIndex with desired
         frequency (inferred from index if not passed).
@@ -4785,9 +4561,16 @@ def to_period(self, freq=None, copy=True):
         if copy:
             new_values = new_values.copy()
 
+        assert isinstance(self.index, ABCDatetimeIndex)
         new_index = self.index.to_period(freq=freq)
         return self._constructor(new_values, index=new_index).__finalize__(self)
 
+    # ----------------------------------------------------------------------
+    # Add index
+    index: "Index" = properties.AxisProperty(
+        axis=0, doc="The index (axis labels) of the Series."
+    )
+
     # ----------------------------------------------------------------------
     # Accessor Methods
     # ----------------------------------------------------------------------
@@ -4802,15 +4585,8 @@ def to_period(self, freq=None, copy=True):
     hist = pandas.plotting.hist_series
 
 
-Series._setup_axes(
-    ["index"],
-    info_axis=0,
-    stat_axis=0,
-    aliases={"rows": 0},
-    docs={"index": "The index (axis labels) of the Series."},
-)
+Series._setup_axes(["index"], docs={"index": "The index (axis labels) of the Series."})
 Series._add_numeric_operations()
-Series._add_series_only_operations()
 Series._add_series_or_dataframe_operations()
 
 # Add arithmetic!
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index e6edad656d430..51c154aa47518 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -4,13 +4,11 @@
 from pandas._libs import algos, hashtable, lib
 from pandas._libs.hashtable import unique_label_indices
 
-from pandas.core.dtypes.cast import infer_dtype_from_array
 from pandas.core.dtypes.common import (
     ensure_int64,
     ensure_platform_int,
     is_categorical_dtype,
     is_extension_array_dtype,
-    is_list_like,
 )
 from pandas.core.dtypes.missing import isna
 
@@ -20,7 +18,7 @@
 _INT64_MAX = np.iinfo(np.int64).max
 
 
-def get_group_index(labels, shape, sort, xnull):
+def get_group_index(labels, shape, sort: bool, xnull: bool):
     """
     For the particular label_list, gets the offsets into the hypothetical list
     representing the totally ordered cartesian product of all possible label
@@ -33,22 +31,27 @@ def get_group_index(labels, shape, sort, xnull):
 
     Parameters
     ----------
-    labels: sequence of arrays
+    labels : sequence of arrays
         Integers identifying levels at each location
-    shape: sequence of ints same length as labels
+    shape : sequence of ints
         Number of unique levels at each location
-    sort: boolean
+    sort : bool
         If the ranks of returned ids should match lexical ranks of labels
-    xnull: boolean
+    xnull : bool
         If true nulls are excluded. i.e. -1 values in the labels are
-        passed through
+        passed through.
+
     Returns
     -------
     An array of type int64 where two elements are equal if their corresponding
     labels are equal at all location.
+
+    Notes
+    -----
+    The length of `labels` and `shape` must be identical.
     """
 
-    def _int64_cut_off(shape):
+    def _int64_cut_off(shape) -> int:
         acc = 1
         for i, mul in enumerate(shape):
             acc *= int(mul)
@@ -106,7 +109,6 @@ def maybe_lift(lab, size):
 
 def get_compressed_ids(labels, sizes):
     """
-
     Group_index is offsets into cartesian product of all possible labels. This
     space can be huge, so this function compresses it, by computing offsets
     (comp_ids) into the list of unique labels (obs_group_ids).
@@ -119,13 +121,12 @@ def get_compressed_ids(labels, sizes):
     Returns
     -------
     tuple of (comp_ids, obs_group_ids)
-
     """
     ids = get_group_index(labels, sizes, sort=True, xnull=False)
     return compress_group_index(ids, sort=True)
 
 
-def is_int64_overflow_possible(shape):
+def is_int64_overflow_possible(shape) -> bool:
     the_prod = 1
     for x in shape:
         the_prod *= int(x)
@@ -153,16 +154,15 @@ def decons_group_index(comp_labels, shape):
     return label_list[::-1]
 
 
-def decons_obs_group_ids(comp_ids, obs_ids, shape, labels, xnull):
+def decons_obs_group_ids(comp_ids, obs_ids, shape, labels, xnull: bool):
     """
-    reconstruct labels from observed group ids
+    Reconstruct labels from observed group ids.
 
     Parameters
     ----------
-    xnull: boolean,
-        if nulls are excluded; i.e. -1 labels are passed through
+    xnull : bool
+        If nulls are excluded; i.e. -1 labels are passed through.
     """
-
     if not xnull:
         lift = np.fromiter(((a == -1).any() for a in labels), dtype="i8")
         shape = np.asarray(shape, dtype="i8") + lift
@@ -177,7 +177,7 @@ def decons_obs_group_ids(comp_ids, obs_ids, shape, labels, xnull):
     return [i8copy(lab[i]) for lab in labels]
 
 
-def indexer_from_factorized(labels, shape, compress=True):
+def indexer_from_factorized(labels, shape, compress: bool = True):
     ids = get_group_index(labels, shape, sort=True, xnull=False)
 
     if not compress:
@@ -189,7 +189,12 @@ def indexer_from_factorized(labels, shape, compress=True):
     return get_group_index_sorter(ids, ngroups)
 
 
-def lexsort_indexer(keys, orders=None, na_position="last"):
+def lexsort_indexer(keys, orders=None, na_position: str = "last"):
+    """
+    Parameters
+    ----------
+    na_position : {'first', 'last'}, default 'last'
+    """
     from pandas.core.arrays import Categorical
 
     labels = []
@@ -210,7 +215,7 @@ def lexsort_indexer(keys, orders=None, na_position="last"):
             cat = Categorical(key, ordered=True)
 
         if na_position not in ["last", "first"]:
-            raise ValueError("invalid na_position: {!r}".format(na_position))
+            raise ValueError(f"invalid na_position: {na_position}")
 
         n = len(cat.categories)
         codes = cat.codes.copy()
@@ -235,11 +240,21 @@ def lexsort_indexer(keys, orders=None, na_position="last"):
     return indexer_from_factorized(labels, shape)
 
 
-def nargsort(items, kind="quicksort", ascending=True, na_position="last"):
+def nargsort(
+    items, kind: str = "quicksort", ascending: bool = True, na_position: str = "last"
+):
     """
-    This is intended to be a drop-in replacement for np.argsort which
-    handles NaNs. It adds ascending and na_position parameters.
-    GH #6399, #5231
+    Intended to be a drop-in replacement for np.argsort which handles NaNs.
+
+    Adds ascending and na_position parameters.
+
+    (GH #6399, #5231)
+
+    Parameters
+    ----------
+    kind : str, default 'quicksort'
+    ascending : bool, default True
+    na_position : {'first', 'last'}, default 'last'
     """
     items = extract_array(items)
     mask = np.asarray(isna(items))
@@ -266,16 +281,16 @@ def nargsort(items, kind="quicksort", ascending=True, na_position="last"):
     elif na_position == "first":
         indexer = np.concatenate([nan_idx, indexer])
     else:
-        raise ValueError("invalid na_position: {!r}".format(na_position))
+        raise ValueError(f"invalid na_position: {na_position}")
     return indexer
 
 
 class _KeyMapper:
     """
-    Ease my suffering. Map compressed group id -> key tuple
+    Map compressed group id -> key tuple.
     """
 
-    def __init__(self, comp_ids, ngroups, levels, labels):
+    def __init__(self, comp_ids, ngroups: int, levels, labels):
         self.levels = levels
         self.labels = labels
         self.comp_ids = comp_ids.astype(np.int64)
@@ -303,8 +318,13 @@ def get_flattened_iterator(comp_ids, ngroups, levels, labels):
 
 
 def get_indexer_dict(label_list, keys):
-    """ return a diction of {labels} -> {indexers} """
-    shape = list(map(len, keys))
+    """
+    Returns
+    -------
+    dict
+        Labels mapped to indexers.
+    """
+    shape = [len(x) for x in keys]
 
     group_index = get_group_index(label_list, shape, sort=True, xnull=True)
     ngroups = (
@@ -325,7 +345,7 @@ def get_indexer_dict(label_list, keys):
 # sorting levels...cleverly?
 
 
-def get_group_index_sorter(group_index, ngroups):
+def get_group_index_sorter(group_index, ngroups: int):
     """
     algos.groupsort_indexer implements `counting sort` and it is at least
     O(ngroups), where
@@ -350,7 +370,7 @@ def get_group_index_sorter(group_index, ngroups):
         return group_index.argsort(kind="mergesort")
 
 
-def compress_group_index(group_index, sort=True):
+def compress_group_index(group_index, sort: bool = True):
     """
     Group_index is offsets into cartesian product of all possible labels. This
     space can be huge, so this function compresses it, by computing offsets
@@ -389,128 +409,3 @@ def _reorder_by_uniques(uniques, labels):
     uniques = algorithms.take_nd(uniques, sorter, allow_fill=False)
 
     return uniques, labels
-
-
-def safe_sort(values, labels=None, na_sentinel=-1, assume_unique=False, verify=True):
-    """
-    Sort ``values`` and reorder corresponding ``labels``.
-    ``values`` should be unique if ``labels`` is not None.
-    Safe for use with mixed types (int, str), orders ints before strs.
-
-    Parameters
-    ----------
-    values : list-like
-        Sequence; must be unique if ``labels`` is not None.
-    labels : list_like
-        Indices to ``values``. All out of bound indices are treated as
-        "not found" and will be masked with ``na_sentinel``.
-    na_sentinel : int, default -1
-        Value in ``labels`` to mark "not found".
-        Ignored when ``labels`` is None.
-    assume_unique : bool, default False
-        When True, ``values`` are assumed to be unique, which can speed up
-        the calculation. Ignored when ``labels`` is None.
-    verify : bool, default True
-        Check if labels are out of bound for the values and put out of bound
-        labels equal to na_sentinel. If ``verify=False``, it is assumed there
-        are no out of bound labels. Ignored when ``labels`` is None.
-
-        .. versionadded:: 0.25.0
-
-    Returns
-    -------
-    ordered : ndarray
-        Sorted ``values``
-    new_labels : ndarray
-        Reordered ``labels``; returned when ``labels`` is not None.
-
-    Raises
-    ------
-    TypeError
-        * If ``values`` is not list-like or if ``labels`` is neither None
-        nor list-like
-        * If ``values`` cannot be sorted
-    ValueError
-        * If ``labels`` is not None and ``values`` contain duplicates.
-    """
-    if not is_list_like(values):
-        raise TypeError(
-            "Only list-like objects are allowed to be passed to safe_sort as values"
-        )
-
-    if not isinstance(values, np.ndarray) and not is_extension_array_dtype(values):
-        # don't convert to string types
-        dtype, _ = infer_dtype_from_array(values)
-        values = np.asarray(values, dtype=dtype)
-
-    def sort_mixed(values):
-        # order ints before strings, safe in py3
-        str_pos = np.array([isinstance(x, str) for x in values], dtype=bool)
-        nums = np.sort(values[~str_pos])
-        strs = np.sort(values[str_pos])
-        return np.concatenate([nums, np.asarray(strs, dtype=object)])
-
-    sorter = None
-    if (
-        not is_extension_array_dtype(values)
-        and lib.infer_dtype(values, skipna=False) == "mixed-integer"
-    ):
-        # unorderable in py3 if mixed str/int
-        ordered = sort_mixed(values)
-    else:
-        try:
-            sorter = values.argsort()
-            ordered = values.take(sorter)
-        except TypeError:
-            # try this anyway
-            ordered = sort_mixed(values)
-
-    # labels:
-
-    if labels is None:
-        return ordered
-
-    if not is_list_like(labels):
-        raise TypeError(
-            "Only list-like objects or None are allowed to be"
-            "passed to safe_sort as labels"
-        )
-    labels = ensure_platform_int(np.asarray(labels))
-
-    from pandas import Index
-
-    if not assume_unique and not Index(values).is_unique:
-        raise ValueError("values should be unique if labels is not None")
-
-    if sorter is None:
-        # mixed types
-        (hash_klass, _), values = algorithms._get_data_algo(
-            values, algorithms._hashtables
-        )
-        t = hash_klass(len(values))
-        t.map_locations(values)
-        sorter = ensure_platform_int(t.lookup(ordered))
-
-    if na_sentinel == -1:
-        # take_1d is faster, but only works for na_sentinels of -1
-        order2 = sorter.argsort()
-        new_labels = algorithms.take_1d(order2, labels, fill_value=-1)
-        if verify:
-            mask = (labels < -len(values)) | (labels >= len(values))
-        else:
-            mask = None
-    else:
-        reverse_indexer = np.empty(len(sorter), dtype=np.int_)
-        reverse_indexer.put(sorter, np.arange(len(sorter)))
-        # Out of bound indices will be masked with `na_sentinel` next, so we
-        # may deal with them here without performance loss using `mode='wrap'`
-        new_labels = reverse_indexer.take(labels, mode="wrap")
-
-        mask = labels == na_sentinel
-        if verify:
-            mask = mask | (labels < -len(values)) | (labels >= len(values))
-
-    if mask is not None:
-        np.putmask(new_labels, mask, na_sentinel)
-
-    return ordered, ensure_platform_int(new_labels)
diff --git a/pandas/core/sparse/api.py b/pandas/core/sparse/api.py
index 6a00fa570b2ac..e7bf94cdc08ea 100644
--- a/pandas/core/sparse/api.py
+++ b/pandas/core/sparse/api.py
@@ -1,4 +1,3 @@
-# flake8: noqa
 from pandas.core.arrays.sparse import SparseArray, SparseDtype
-from pandas.core.sparse.frame import SparseDataFrame
-from pandas.core.sparse.series import SparseSeries
+
+__all__ = ["SparseArray", "SparseDtype"]
diff --git a/pandas/core/sparse/frame.py b/pandas/core/sparse/frame.py
deleted file mode 100644
index 3d6ba0b8d9774..0000000000000
--- a/pandas/core/sparse/frame.py
+++ /dev/null
@@ -1,1060 +0,0 @@
-"""
-Data structures for sparse float data. Life is made simpler by dealing only
-with float64 data
-"""
-import warnings
-
-import numpy as np
-
-from pandas._libs.lib import is_scalar, item_from_zerodim
-from pandas._libs.sparse import BlockIndex, get_blocks
-from pandas.compat.numpy import function as nv
-from pandas.util._decorators import Appender
-
-from pandas.core.dtypes.cast import maybe_upcast
-from pandas.core.dtypes.common import ensure_platform_int, is_scipy_sparse
-from pandas.core.dtypes.missing import isna, notna
-
-import pandas.core.algorithms as algos
-from pandas.core.arrays.sparse import SparseArray, SparseFrameAccessor
-import pandas.core.common as com
-from pandas.core.frame import DataFrame
-import pandas.core.generic as generic
-from pandas.core.index import Index, MultiIndex, ensure_index
-from pandas.core.internals import BlockManager, create_block_manager_from_arrays
-from pandas.core.internals.construction import extract_index, prep_ndarray
-import pandas.core.ops as ops
-from pandas.core.series import Series
-from pandas.core.sparse.series import SparseSeries
-
-_shared_doc_kwargs = dict(klass="SparseDataFrame")
-depr_msg = """\
-SparseDataFrame is deprecated and will be removed in a future version.
-Use a regular DataFrame whose columns are SparseArrays instead.
-
-See http://pandas.pydata.org/pandas-docs/stable/\
-user_guide/sparse.html#migrating for more.
-"""
-
-
-class SparseDataFrame(DataFrame):
-    """
-    DataFrame containing sparse floating point data in the form of SparseSeries
-    objects
-
-    .. deprecated:: 0.25.0
-
-       Use a DataFrame with sparse values instead.
-
-    Parameters
-    ----------
-    data : same types as can be passed to DataFrame or scipy.sparse.spmatrix
-        .. versionchanged:: 0.23.0
-           If data is a dict, argument order is maintained for Python 3.6
-           and later.
-
-    index : array-like, optional
-    column : array-like, optional
-    default_kind : {'block', 'integer'}, default 'block'
-        Default sparse kind for converting Series to SparseSeries. Will not
-        override SparseSeries passed into constructor
-    default_fill_value : float
-        Default fill_value for converting Series to SparseSeries
-        (default: nan). Will not override SparseSeries passed in.
-    """
-
-    _subtyp = "sparse_frame"
-
-    def __init__(
-        self,
-        data=None,
-        index=None,
-        columns=None,
-        default_kind=None,
-        default_fill_value=None,
-        dtype=None,
-        copy=False,
-    ):
-        if not is_scalar(default_fill_value):
-            raise ValueError("'default_fill_value' must be a scalar")
-
-        warnings.warn(depr_msg, FutureWarning, stacklevel=2)
-        # pick up the defaults from the Sparse structures
-        if isinstance(data, SparseDataFrame):
-            if index is None:
-                index = data.index
-            if columns is None:
-                columns = data.columns
-            if default_fill_value is None:
-                default_fill_value = data.default_fill_value
-            if default_kind is None:
-                default_kind = data.default_kind
-        elif isinstance(data, (SparseSeries, SparseArray)):
-            if index is None:
-                index = data.index
-            if default_fill_value is None:
-                default_fill_value = data.fill_value
-            if columns is None and hasattr(data, "name"):
-                columns = [data.name]
-            if columns is None:
-                raise Exception("cannot pass a series w/o a name or columns")
-            data = {columns[0]: data}
-
-        if default_fill_value is None:
-            default_fill_value = np.nan
-        if default_kind is None:
-            default_kind = "block"
-
-        self._default_kind = default_kind
-        self._default_fill_value = default_fill_value
-
-        if is_scipy_sparse(data):
-            mgr = self._init_spmatrix(
-                data, index, columns, dtype=dtype, fill_value=default_fill_value
-            )
-        elif isinstance(data, dict):
-            mgr = self._init_dict(data, index, columns, dtype=dtype)
-        elif isinstance(data, (np.ndarray, list)):
-            mgr = self._init_matrix(data, index, columns, dtype=dtype)
-        elif isinstance(data, SparseDataFrame):
-            mgr = self._init_mgr(
-                data._data, dict(index=index, columns=columns), dtype=dtype, copy=copy
-            )
-        elif isinstance(data, DataFrame):
-            mgr = self._init_dict(data, data.index, data.columns, dtype=dtype)
-        elif isinstance(data, Series):
-            mgr = self._init_dict(
-                data.to_frame(), data.index, columns=None, dtype=dtype
-            )
-        elif isinstance(data, BlockManager):
-            mgr = self._init_mgr(
-                data, axes=dict(index=index, columns=columns), dtype=dtype, copy=copy
-            )
-        elif data is None:
-            data = DataFrame()
-
-            if index is None:
-                index = Index([])
-            else:
-                index = ensure_index(index)
-
-            if columns is None:
-                columns = Index([])
-            else:
-                for c in columns:
-                    data[c] = SparseArray(
-                        self._default_fill_value,
-                        index=index,
-                        kind=self._default_kind,
-                        fill_value=self._default_fill_value,
-                    )
-            mgr = to_manager(data, columns, index)
-            if dtype is not None:
-                mgr = mgr.astype(dtype)
-        else:
-            msg = (
-                'SparseDataFrame called with unknown type "{data_type}" '
-                "for data argument"
-            )
-            raise TypeError(msg.format(data_type=type(data).__name__))
-
-        generic.NDFrame.__init__(self, mgr)
-
-    @property
-    def _constructor(self):
-        return SparseDataFrame
-
-    _constructor_sliced = SparseSeries
-
-    def _init_dict(self, data, index, columns, dtype=None):
-        # pre-filter out columns if we passed it
-        if columns is not None:
-            columns = ensure_index(columns)
-            data = {k: v for k, v in data.items() if k in columns}
-        else:
-            keys = com.dict_keys_to_ordered_list(data)
-            columns = Index(keys)
-
-        if index is None:
-            index = extract_index(list(data.values()))
-
-        def sp_maker(x):
-            return SparseArray(
-                x,
-                kind=self._default_kind,
-                fill_value=self._default_fill_value,
-                copy=True,
-                dtype=dtype,
-            )
-
-        sdict = {}
-        for k, v in data.items():
-            if isinstance(v, Series):
-                # Force alignment, no copy necessary
-                if not v.index.equals(index):
-                    v = v.reindex(index)
-
-                if not isinstance(v, SparseSeries):
-                    v = sp_maker(v.values)
-            elif isinstance(v, SparseArray):
-                v = v.copy()
-            else:
-                if isinstance(v, dict):
-                    v = [v.get(i, np.nan) for i in index]
-
-                v = sp_maker(v)
-
-            if index is not None and len(v) != len(index):
-                msg = "Length of passed values is {}, index implies {}"
-                raise ValueError(msg.format(len(v), len(index)))
-            sdict[k] = v
-
-        if len(columns.difference(sdict)):
-            # TODO: figure out how to handle this case, all nan's?
-            # add in any other columns we want to have (completeness)
-            nan_arr = np.empty(len(index), dtype="float64")
-            nan_arr.fill(np.nan)
-            nan_arr = SparseArray(
-                nan_arr,
-                kind=self._default_kind,
-                fill_value=self._default_fill_value,
-                copy=False,
-            )
-            sdict.update((c, nan_arr) for c in columns if c not in sdict)
-
-        return to_manager(sdict, columns, index)
-
-    def _init_matrix(self, data, index, columns, dtype=None):
-        """
-        Init self from ndarray or list of lists.
-        """
-        data = prep_ndarray(data, copy=False)
-        index, columns = SparseFrameAccessor._prep_index(data, index, columns)
-        data = {idx: data[:, i] for i, idx in enumerate(columns)}
-        return self._init_dict(data, index, columns, dtype)
-
-    def _init_spmatrix(self, data, index, columns, dtype=None, fill_value=None):
-        """
-        Init self from scipy.sparse matrix.
-        """
-        index, columns = SparseFrameAccessor._prep_index(data, index, columns)
-        data = data.tocoo()
-        N = len(index)
-
-        # Construct a dict of SparseSeries
-        sdict = {}
-        values = Series(data.data, index=data.row, copy=False)
-        for col, rowvals in values.groupby(data.col):
-            # get_blocks expects int32 row indices in sorted order
-            rowvals = rowvals.sort_index()
-            rows = rowvals.index.values.astype(np.int32)
-            blocs, blens = get_blocks(rows)
-
-            sdict[columns[col]] = SparseSeries(
-                rowvals.values,
-                index=index,
-                fill_value=fill_value,
-                sparse_index=BlockIndex(N, blocs, blens),
-            )
-
-        # Add any columns that were empty and thus not grouped on above
-        sdict.update(
-            {
-                column: SparseSeries(
-                    index=index,
-                    fill_value=fill_value,
-                    sparse_index=BlockIndex(N, [], []),
-                )
-                for column in columns
-                if column not in sdict
-            }
-        )
-
-        return self._init_dict(sdict, index, columns, dtype)
-
-    @Appender(SparseFrameAccessor.to_coo.__doc__)
-    def to_coo(self):
-        return SparseFrameAccessor(self).to_coo()
-
-    def __repr__(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "Sparse")
-            return super().__repr__()
-
-    def __getstate__(self):
-        # pickling
-        return dict(
-            _typ=self._typ,
-            _subtyp=self._subtyp,
-            _data=self._data,
-            _default_fill_value=self._default_fill_value,
-            _default_kind=self._default_kind,
-        )
-
-    def _unpickle_sparse_frame_compat(self, state):
-        """
-        Original pickle format
-        """
-        series, cols, idx, fv, kind = state
-
-        if not isinstance(cols, Index):  # pragma: no cover
-            from pandas.io.pickle import _unpickle_array
-
-            columns = _unpickle_array(cols)
-        else:
-            columns = cols
-
-        if not isinstance(idx, Index):  # pragma: no cover
-            from pandas.io.pickle import _unpickle_array
-
-            index = _unpickle_array(idx)
-        else:
-            index = idx
-
-        series_dict = DataFrame()
-        for col, (sp_index, sp_values) in series.items():
-            series_dict[col] = SparseSeries(
-                sp_values, sparse_index=sp_index, fill_value=fv
-            )
-
-        self._data = to_manager(series_dict, columns, index)
-        self._default_fill_value = fv
-        self._default_kind = kind
-
-    @Appender(SparseFrameAccessor.to_dense.__doc__)
-    def to_dense(self):
-        return SparseFrameAccessor(self).to_dense()
-
-    def _apply_columns(self, func):
-        """
-        Get new SparseDataFrame applying func to each columns
-        """
-
-        new_data = {col: func(series) for col, series in self.items()}
-
-        return self._constructor(
-            data=new_data,
-            index=self.index,
-            columns=self.columns,
-            default_fill_value=self.default_fill_value,
-        ).__finalize__(self)
-
-    def astype(self, dtype):
-        return self._apply_columns(lambda x: x.astype(dtype))
-
-    def copy(self, deep=True):
-        """
-        Make a copy of this SparseDataFrame
-        """
-        result = super().copy(deep=deep)
-        result._default_fill_value = self._default_fill_value
-        result._default_kind = self._default_kind
-        return result
-
-    @property
-    def default_fill_value(self):
-        return self._default_fill_value
-
-    @property
-    def default_kind(self):
-        return self._default_kind
-
-    @property
-    def density(self):
-        """
-        Ratio of non-sparse points to total (dense) data points
-        represented in the frame
-        """
-        tot_nonsparse = sum(ser.sp_index.npoints for _, ser in self.items())
-        tot = len(self.index) * len(self.columns)
-        return tot_nonsparse / float(tot)
-
-    def fillna(
-        self, value=None, method=None, axis=0, inplace=False, limit=None, downcast=None
-    ):
-        new_self = super().fillna(
-            value=value,
-            method=method,
-            axis=axis,
-            inplace=inplace,
-            limit=limit,
-            downcast=downcast,
-        )
-        if not inplace:
-            self = new_self
-
-        # set the fill value if we are filling as a scalar with nothing special
-        # going on
-        if value is not None and value == value and method is None and limit is None:
-            self._default_fill_value = value
-
-        if not inplace:
-            return self
-
-    # ----------------------------------------------------------------------
-    # Support different internal representation of SparseDataFrame
-
-    def _sanitize_column(self, key, value, **kwargs):
-        """
-        Creates a new SparseArray from the input value.
-
-        Parameters
-        ----------
-        key : object
-        value : scalar, Series, or array-like
-        kwargs : dict
-
-        Returns
-        -------
-        sanitized_column : SparseArray
-
-        """
-
-        def sp_maker(x, index=None):
-            return SparseArray(
-                x,
-                index=index,
-                fill_value=self._default_fill_value,
-                kind=self._default_kind,
-            )
-
-        if isinstance(value, SparseSeries):
-            clean = value.reindex(self.index).as_sparse_array(
-                fill_value=self._default_fill_value, kind=self._default_kind
-            )
-
-        elif isinstance(value, SparseArray):
-            if len(value) != len(self.index):
-                raise ValueError("Length of values does not match length of index")
-            clean = value
-
-        elif hasattr(value, "__iter__"):
-            if isinstance(value, Series):
-                clean = value.reindex(self.index)
-                if not isinstance(value, SparseSeries):
-                    clean = sp_maker(clean)
-            else:
-                if len(value) != len(self.index):
-                    raise ValueError("Length of values does not match length of index")
-                clean = sp_maker(value)
-
-        # Scalar
-        else:
-            clean = sp_maker(value, self.index)
-
-        # always return a SparseArray!
-        return clean
-
-    # ----------------------------------------------------------------------
-    # Indexing Methods
-
-    def _get_value(self, index, col, takeable=False):
-        """
-        Quickly retrieve single value at passed column and index
-
-        Please use .at[] or .iat[] accessors.
-
-        Parameters
-        ----------
-        index : row label
-        col : column label
-        takeable : interpret the index/col as indexers, default False
-
-        Returns
-        -------
-        value : scalar value
-        """
-        if takeable is True:
-            series = self._iget_item_cache(col)
-        else:
-            series = self._get_item_cache(col)
-
-        return series._get_value(index, takeable=takeable)
-
-    def _slice(self, slobj, axis=0, kind=None):
-        if axis == 0:
-            new_index = self.index[slobj]
-            new_columns = self.columns
-        else:
-            new_index = self.index
-            new_columns = self.columns[slobj]
-
-        return self.reindex(index=new_index, columns=new_columns)
-
-    def xs(self, key, axis=0, copy=False):
-        """
-        Returns a row (cross-section) from the SparseDataFrame as a Series
-        object.
-
-        Parameters
-        ----------
-        key : some index contained in the index
-
-        Returns
-        -------
-        xs : Series
-        """
-        if axis == 1:
-            data = self[key]
-            return data
-
-        i = self.index.get_loc(key)
-        data = self.take([i])._internal_get_values()[0]
-        return Series(data, index=self.columns)
-
-    def _set_value(self, index, col, value, takeable=False):
-        """
-        Put single value at passed column and index
-
-        Please use .at[] or .iat[] accessors.
-
-        Parameters
-        ----------
-        index : row label
-        col : column label
-        value : scalar value
-        takeable : interpret the index/col as indexers, default False
-
-        Notes
-        -----
-        This method *always* returns a new object. It is currently not
-        particularly efficient (and potentially very expensive) but is provided
-        for API compatibility with DataFrame
-
-        Returns
-        -------
-        frame : DataFrame
-        """
-        dense = self.to_dense()._set_value(index, col, value, takeable=takeable)
-        return dense.to_sparse(
-            kind=self._default_kind, fill_value=self._default_fill_value
-        )
-
-    # ----------------------------------------------------------------------
-    # Arithmetic-related methods
-
-    def _combine_frame(self, other, func, fill_value=None, level=None):
-        if level is not None:
-            raise NotImplementedError("'level' argument is not supported")
-
-        this, other = self.align(other, join="outer", level=level, copy=False)
-        new_index, new_columns = this.index, this.columns
-
-        if self.empty and other.empty:
-            return self._constructor(index=new_index).__finalize__(self)
-
-        new_data = {}
-        if fill_value is not None:
-            # TODO: be a bit more intelligent here
-            for col in new_columns:
-                if col in this and col in other:
-                    dleft = this[col].to_dense()
-                    dright = other[col].to_dense()
-                    result = dleft._binop(dright, func, fill_value=fill_value)
-                    result = result.to_sparse(fill_value=this[col].fill_value)
-                    new_data[col] = result
-        else:
-
-            for col in new_columns:
-                if col in this and col in other:
-                    new_data[col] = func(this[col], other[col])
-
-        new_fill_value = self._get_op_result_fill_value(other, func)
-
-        return self._constructor(
-            data=new_data,
-            index=new_index,
-            columns=new_columns,
-            default_fill_value=new_fill_value,
-        ).__finalize__(self)
-
-    def _combine_match_index(self, other, func, level=None):
-
-        if level is not None:
-            raise NotImplementedError("'level' argument is not supported")
-
-        this, other = self.align(other, join="outer", axis=0, level=level, copy=False)
-
-        new_data = {}
-        for col in this.columns:
-            new_data[col] = func(this[col], other)
-
-        fill_value = self._get_op_result_fill_value(other, func)
-
-        return self._constructor(
-            new_data,
-            index=this.index,
-            columns=self.columns,
-            default_fill_value=fill_value,
-        ).__finalize__(self)
-
-    def _combine_match_columns(self, other, func, level=None):
-        # patched version of DataFrame._combine_match_columns to account for
-        # NumPy circumventing __rsub__ with float64 types, e.g.: 3.0 - series,
-        # where 3.0 is numpy.float64 and series is a SparseSeries. Still
-        # possible for this to happen, which is bothersome
-
-        if level is not None:
-            raise NotImplementedError("'level' argument is not supported")
-
-        left, right = self.align(other, join="outer", axis=1, level=level, copy=False)
-        assert left.columns.equals(right.index)
-
-        new_data = {}
-
-        for col in left.columns:
-            new_data[col] = func(left[col], right[col])
-
-        return self._constructor(
-            new_data,
-            index=left.index,
-            columns=left.columns,
-            default_fill_value=self.default_fill_value,
-        ).__finalize__(self)
-
-    def _combine_const(self, other, func):
-        return self._apply_columns(lambda x: func(x, other))
-
-    def _get_op_result_fill_value(self, other, func):
-        own_default = self.default_fill_value
-
-        if isinstance(other, DataFrame):
-            # i.e. called from _combine_frame
-
-            other_default = getattr(other, "default_fill_value", np.nan)
-
-            # if the fill values are the same use them? or use a valid one
-            if own_default == other_default:
-                # TOOD: won't this evaluate as False if both are np.nan?
-                fill_value = own_default
-            elif np.isnan(own_default) and not np.isnan(other_default):
-                fill_value = other_default
-            elif not np.isnan(own_default) and np.isnan(other_default):
-                fill_value = own_default
-            else:
-                fill_value = None
-
-        elif isinstance(other, SparseSeries):
-            # i.e. called from _combine_match_index
-
-            # fill_value is a function of our operator
-            if isna(other.fill_value) or isna(own_default):
-                fill_value = np.nan
-            else:
-                fill_value = func(np.float64(own_default), np.float64(other.fill_value))
-                fill_value = item_from_zerodim(fill_value)
-        else:
-            raise NotImplementedError(type(other))
-
-        return fill_value
-
-    def _reindex_index(
-        self, index, method, copy, level, fill_value=np.nan, limit=None, takeable=False
-    ):
-        if level is not None:
-            raise TypeError("Reindex by level not supported for sparse")
-
-        if self.index.equals(index):
-            if copy:
-                return self.copy()
-            else:
-                return self
-
-        if len(self.index) == 0:
-            return self._constructor(index=index, columns=self.columns).__finalize__(
-                self
-            )
-
-        indexer = self.index.get_indexer(index, method, limit=limit)
-        indexer = ensure_platform_int(indexer)
-        mask = indexer == -1
-        need_mask = mask.any()
-
-        new_series = {}
-        for col, series in self.items():
-            if mask.all():
-                continue
-
-            values = series.values
-            # .take returns SparseArray
-            new = values.take(indexer)
-            if need_mask:
-                new = new.to_dense()
-                # convert integer to float if necessary. need to do a lot
-                # more than that, handle boolean etc also
-                new, fill_value = maybe_upcast(new, fill_value=fill_value)
-                np.putmask(new, mask, fill_value)
-
-            new_series[col] = new
-
-        return self._constructor(
-            new_series,
-            index=index,
-            columns=self.columns,
-            default_fill_value=self._default_fill_value,
-        ).__finalize__(self)
-
-    def _reindex_columns(
-        self, columns, method, copy, level, fill_value=None, limit=None, takeable=False
-    ):
-        if level is not None:
-            raise TypeError("Reindex by level not supported for sparse")
-
-        if notna(fill_value):
-            raise NotImplementedError("'fill_value' argument is not supported")
-
-        if limit:
-            raise NotImplementedError("'limit' argument is not supported")
-
-        if method is not None:
-            raise NotImplementedError("'method' argument is not supported")
-
-        # TODO: fill value handling
-        sdict = {k: v for k, v in self.items() if k in columns}
-        return self._constructor(
-            sdict,
-            index=self.index,
-            columns=columns,
-            default_fill_value=self._default_fill_value,
-        ).__finalize__(self)
-
-    def _reindex_with_indexers(
-        self,
-        reindexers,
-        method=None,
-        fill_value=None,
-        limit=None,
-        copy=False,
-        allow_dups=False,
-    ):
-
-        if method is not None or limit is not None:
-            raise NotImplementedError(
-                "cannot reindex with a method or limit with sparse"
-            )
-
-        if fill_value is None:
-            fill_value = np.nan
-
-        reindexers = {self._get_axis_number(a): val for (a, val) in reindexers.items()}
-
-        index, row_indexer = reindexers.get(0, (None, None))
-        columns, col_indexer = reindexers.get(1, (None, None))
-
-        if columns is None:
-            columns = self.columns
-
-        new_arrays = {}
-        for col in columns:
-            if col not in self:
-                continue
-            if row_indexer is not None:
-                new_arrays[col] = algos.take_1d(
-                    self[col]._internal_get_values(), row_indexer, fill_value=fill_value
-                )
-            else:
-                new_arrays[col] = self[col]
-
-        return self._constructor(new_arrays, index=index, columns=columns).__finalize__(
-            self
-        )
-
-    def _join_compat(
-        self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False
-    ):
-        if on is not None:
-            raise NotImplementedError("'on' keyword parameter is not yet implemented")
-        return self._join_index(other, how, lsuffix, rsuffix)
-
-    def _join_index(self, other, how, lsuffix, rsuffix):
-        if isinstance(other, Series):
-            if other.name is None:
-                raise ValueError("Other Series must have a name")
-
-            other = SparseDataFrame(
-                {other.name: other}, default_fill_value=self._default_fill_value
-            )
-
-        join_index = self.index.join(other.index, how=how)
-
-        this = self.reindex(join_index)
-        other = other.reindex(join_index)
-
-        this, other = this._maybe_rename_join(other, lsuffix, rsuffix)
-
-        from pandas import concat
-
-        return concat([this, other], axis=1, verify_integrity=True)
-
-    def _maybe_rename_join(self, other, lsuffix, rsuffix):
-        to_rename = self.columns.intersection(other.columns)
-        if len(to_rename) > 0:
-            if not lsuffix and not rsuffix:
-                raise ValueError(
-                    "columns overlap but no suffix specified: "
-                    "{to_rename}".format(to_rename=to_rename)
-                )
-
-            def lrenamer(x):
-                if x in to_rename:
-                    return "{x}{lsuffix}".format(x=x, lsuffix=lsuffix)
-                return x
-
-            def rrenamer(x):
-                if x in to_rename:
-                    return "{x}{rsuffix}".format(x=x, rsuffix=rsuffix)
-                return x
-
-            this = self.rename(columns=lrenamer)
-            other = other.rename(columns=rrenamer)
-        else:
-            this = self
-
-        return this, other
-
-    def transpose(self, *args, **kwargs):
-        """
-        Returns a DataFrame with the rows/columns switched.
-        """
-        nv.validate_transpose(args, kwargs)
-        return self._constructor(
-            self.values.T,
-            index=self.columns,
-            columns=self.index,
-            default_fill_value=self._default_fill_value,
-            default_kind=self._default_kind,
-        ).__finalize__(self)
-
-    T = property(transpose)
-
-    @Appender(DataFrame.count.__doc__)
-    def count(self, axis=0, **kwds):
-        if axis is None:
-            axis = self._stat_axis_number
-
-        return self.apply(lambda x: x.count(), axis=axis)
-
-    def cumsum(self, axis=0, *args, **kwargs):
-        """
-        Return SparseDataFrame of cumulative sums over requested axis.
-
-        Parameters
-        ----------
-        axis : {0, 1}
-            0 for row-wise, 1 for column-wise
-
-        Returns
-        -------
-        y : SparseDataFrame
-        """
-        nv.validate_cumsum(args, kwargs)
-
-        if axis is None:
-            axis = self._stat_axis_number
-
-        return self.apply(lambda x: x.cumsum(), axis=axis)
-
-    @Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
-    def isna(self):
-        return self._apply_columns(lambda x: x.isna())
-
-    isnull = isna
-
-    @Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
-    def notna(self):
-        return self._apply_columns(lambda x: x.notna())
-
-    notnull = notna
-
-    def apply(self, func, axis=0, broadcast=None, reduce=None, result_type=None):
-        """
-        Analogous to DataFrame.apply, for SparseDataFrame
-
-        Parameters
-        ----------
-        func : function
-            Function to apply to each column
-        axis : {0, 1, 'index', 'columns'}
-        broadcast : bool, default False
-            For aggregation functions, return object of same size with values
-            propagated
-
-            .. deprecated:: 0.23.0
-               This argument will be removed in a future version, replaced
-               by result_type='broadcast'.
-
-        reduce : boolean or None, default None
-            Try to apply reduction procedures. If the DataFrame is empty,
-            apply will use reduce to determine whether the result should be a
-            Series or a DataFrame. If reduce is None (the default), apply's
-            return value will be guessed by calling func an empty Series (note:
-            while guessing, exceptions raised by func will be ignored). If
-            reduce is True a Series will always be returned, and if False a
-            DataFrame will always be returned.
-
-            .. deprecated:: 0.23.0
-               This argument will be removed in a future version, replaced
-               by result_type='reduce'.
-
-        result_type : {'expand', 'reduce', 'broadcast, None}
-            These only act when axis=1 {columns}:
-
-            * 'expand' : list-like results will be turned into columns.
-            * 'reduce' : return a Series if possible rather than expanding
-              list-like results. This is the opposite to 'expand'.
-            * 'broadcast' : results will be broadcast to the original shape
-              of the frame, the original index & columns will be retained.
-
-            The default behaviour (None) depends on the return value of the
-            applied function: list-like results will be returned as a Series
-            of those. However if the apply function returns a Series these
-            are expanded to columns.
-
-            .. versionadded:: 0.23.0
-
-        Returns
-        -------
-        applied : Series or SparseDataFrame
-        """
-        if not len(self.columns):
-            return self
-        axis = self._get_axis_number(axis)
-
-        if isinstance(func, np.ufunc):
-            new_series = {}
-            for k, v in self.items():
-                applied = func(v)
-                applied.fill_value = func(v.fill_value)
-                new_series[k] = applied
-            return self._constructor(
-                new_series,
-                index=self.index,
-                columns=self.columns,
-                default_fill_value=self._default_fill_value,
-                default_kind=self._default_kind,
-            ).__finalize__(self)
-
-        from pandas.core.apply import frame_apply
-
-        op = frame_apply(
-            self,
-            func=func,
-            axis=axis,
-            reduce=reduce,
-            broadcast=broadcast,
-            result_type=result_type,
-        )
-        return op.get_result()
-
-    def applymap(self, func):
-        """
-        Apply a function to a DataFrame that is intended to operate
-        elementwise, i.e. like doing map(func, series) for each series in the
-        DataFrame
-
-        Parameters
-        ----------
-        func : function
-            Python function, returns a single value from a single value
-
-        Returns
-        -------
-        applied : DataFrame
-        """
-        return self.apply(lambda x: [func(y) for y in x])
-
-
-def to_manager(sdf, columns, index):
-    """ create and return the block manager from a dataframe of series,
-    columns, index
-    """
-
-    # from BlockManager perspective
-    axes = [ensure_index(columns), ensure_index(index)]
-
-    return create_block_manager_from_arrays([sdf[c] for c in columns], columns, axes)
-
-
-def stack_sparse_frame(frame):
-    """
-    Only makes sense when fill_value is NaN
-    """
-    lengths = [s.sp_index.npoints for _, s in frame.items()]
-    nobs = sum(lengths)
-
-    # this is pretty fast
-    minor_codes = np.repeat(np.arange(len(frame.columns)), lengths)
-
-    inds_to_concat = []
-    vals_to_concat = []
-    # TODO: Figure out whether this can be reached.
-    # I think this currently can't be reached because you can't build a
-    # SparseDataFrame with a non-np.NaN fill value (fails earlier).
-    for _, series in frame.items():
-        if not np.isnan(series.fill_value):
-            raise TypeError("This routine assumes NaN fill value")
-
-        int_index = series.sp_index.to_int_index()
-        inds_to_concat.append(int_index.indices)
-        vals_to_concat.append(series.sp_values)
-
-    major_codes = np.concatenate(inds_to_concat)
-    stacked_values = np.concatenate(vals_to_concat)
-    index = MultiIndex(
-        levels=[frame.index, frame.columns],
-        codes=[major_codes, minor_codes],
-        verify_integrity=False,
-    )
-
-    lp = DataFrame(stacked_values.reshape((nobs, 1)), index=index, columns=["foo"])
-    return lp.sort_index(level=0)
-
-
-def homogenize(series_dict):
-    """
-    Conform a set of SparseSeries (with NaN fill_value) to a common SparseIndex
-    corresponding to the locations where they all have data
-
-    Parameters
-    ----------
-    series_dict : dict or DataFrame
-
-    Notes
-    -----
-    Using the dumbest algorithm I could think of. Should put some more thought
-    into this
-
-    Returns
-    -------
-    homogenized : dict of SparseSeries
-    """
-    index = None
-
-    need_reindex = False
-
-    for _, series in series_dict.items():
-        if not np.isnan(series.fill_value):
-            raise TypeError("this method is only valid with NaN fill values")
-
-        if index is None:
-            index = series.sp_index
-        elif not series.sp_index.equals(index):
-            need_reindex = True
-            index = index.intersect(series.sp_index)
-
-    if need_reindex:
-        output = {}
-        for name, series in series_dict.items():
-            if not series.sp_index.equals(index):
-                series = series.sparse_reindex(index)
-
-            output[name] = series
-    else:
-        output = series_dict
-
-    return output
-
-
-# use unaccelerated ops for sparse objects
-ops.add_flex_arithmetic_methods(SparseDataFrame)
-ops.add_special_arithmetic_methods(SparseDataFrame)
diff --git a/pandas/core/sparse/series.py b/pandas/core/sparse/series.py
deleted file mode 100644
index 0c417133b0538..0000000000000
--- a/pandas/core/sparse/series.py
+++ /dev/null
@@ -1,635 +0,0 @@
-"""
-Data structures for sparse float data. Life is made simpler by dealing only
-with float64 data
-"""
-from collections import abc
-import warnings
-
-import numpy as np
-
-import pandas._libs.index as libindex
-import pandas._libs.sparse as splib
-from pandas._libs.sparse import BlockIndex, IntIndex
-from pandas.compat.numpy import function as nv
-from pandas.util._decorators import Appender, Substitution
-
-from pandas.core.dtypes.common import is_integer, is_scalar
-from pandas.core.dtypes.generic import ABCSeries, ABCSparseSeries
-from pandas.core.dtypes.missing import isna, notna
-
-from pandas.core import generic
-from pandas.core.arrays import SparseArray
-from pandas.core.arrays.sparse import SparseAccessor
-from pandas.core.internals import SingleBlockManager
-import pandas.core.ops as ops
-from pandas.core.series import Series
-from pandas.core.sparse.scipy_sparse import _coo_to_sparse_series, _sparse_series_to_coo
-
-_shared_doc_kwargs = dict(
-    axes="index",
-    klass="SparseSeries",
-    axes_single_arg="{0, 'index'}",
-    optional_labels="",
-    optional_axis="",
-)
-
-
-depr_msg = """\
-SparseSeries is deprecated and will be removed in a future version.
-Use a Series with sparse values instead.
-
-    >>> series = pd.Series(pd.SparseArray(...))
-
-See http://pandas.pydata.org/pandas-docs/stable/\
-user_guide/sparse.html#migrating for more.
-"""
-
-
-class SparseSeries(Series):
-    """Data structure for labeled, sparse floating point data
-
-    .. deprecated:: 0.25.0
-
-       Use a Series with sparse values instead.
-
-    Parameters
-    ----------
-    data : {array-like, Series, SparseSeries, dict}
-        .. versionchanged:: 0.23.0
-           If data is a dict, argument order is maintained for Python 3.6
-           and later.
-
-    kind : {'block', 'integer'}
-    fill_value : float
-        Code for missing value. Defaults depends on dtype.
-        0 for int dtype, False for bool dtype, and NaN for other dtypes
-    sparse_index : {BlockIndex, IntIndex}, optional
-        Only if you have one. Mainly used internally
-
-    Notes
-    -----
-    SparseSeries objects are immutable via the typical Python means. If you
-    must change values, convert to dense, make your changes, then convert back
-    to sparse
-    """
-
-    _subtyp = "sparse_series"
-
-    def __init__(
-        self,
-        data=None,
-        index=None,
-        sparse_index=None,
-        kind="block",
-        fill_value=None,
-        name=None,
-        dtype=None,
-        copy=False,
-        fastpath=False,
-    ):
-        warnings.warn(depr_msg, FutureWarning, stacklevel=2)
-        # TODO: Most of this should be refactored and shared with Series
-        # 1. BlockManager -> array
-        # 2. Series.index, Series.name, index, name reconciliation
-        # 3. Implicit reindexing
-        # 4. Implicit broadcasting
-        # 5. Dict construction
-        if data is None:
-            data = []
-        elif isinstance(data, SingleBlockManager):
-            index = data.index
-            data = data.blocks[0].values
-        elif isinstance(data, (ABCSeries, ABCSparseSeries)):
-            index = data.index if index is None else index
-            dtype = data.dtype if dtype is None else dtype
-            name = data.name if name is None else name
-
-            if index is not None:
-                data = data.reindex(index)
-
-        elif isinstance(data, abc.Mapping):
-            data, index = Series()._init_dict(data, index=index)
-
-        elif is_scalar(data) and index is not None:
-            data = np.full(len(index), fill_value=data)
-
-        if isinstance(data, SingleBlockManager):
-            # SparseArray doesn't accept SingleBlockManager
-            index = data.index
-            data = data.blocks[0].values
-
-        super().__init__(
-            SparseArray(
-                data,
-                sparse_index=sparse_index,
-                kind=kind,
-                dtype=dtype,
-                fill_value=fill_value,
-                copy=copy,
-            ),
-            index=index,
-            name=name,
-            copy=False,
-            fastpath=fastpath,
-        )
-
-    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
-        # avoid infinite recursion for other SparseSeries inputs
-        inputs = tuple(x.values if isinstance(x, type(self)) else x for x in inputs)
-        result = self.values.__array_ufunc__(ufunc, method, *inputs, **kwargs)
-        return self._constructor(
-            result,
-            index=self.index,
-            sparse_index=self.sp_index,
-            fill_value=result.fill_value,
-            copy=False,
-        ).__finalize__(self)
-
-    # unary ops
-    # TODO: See if this can be shared
-    def __pos__(self):
-        result = self.values.__pos__()
-        return self._constructor(
-            result,
-            index=self.index,
-            sparse_index=self.sp_index,
-            fill_value=result.fill_value,
-            copy=False,
-        ).__finalize__(self)
-
-    def __neg__(self):
-        result = self.values.__neg__()
-        return self._constructor(
-            result,
-            index=self.index,
-            sparse_index=self.sp_index,
-            fill_value=result.fill_value,
-            copy=False,
-        ).__finalize__(self)
-
-    def __invert__(self):
-        result = self.values.__invert__()
-        return self._constructor(
-            result,
-            index=self.index,
-            sparse_index=self.sp_index,
-            fill_value=result.fill_value,
-            copy=False,
-        ).__finalize__(self)
-
-    @property
-    def block(self):
-        warnings.warn("SparseSeries.block is deprecated.", FutureWarning, stacklevel=2)
-        return self._data._block
-
-    @property
-    def fill_value(self):
-        return self.values.fill_value
-
-    @fill_value.setter
-    def fill_value(self, v):
-        self.values.fill_value = v
-
-    @property
-    def sp_index(self):
-        return self.values.sp_index
-
-    @property
-    def sp_values(self):
-        return self.values.sp_values
-
-    @property
-    def npoints(self):
-        return self.values.npoints
-
-    @classmethod
-    def from_array(
-        cls, arr, index=None, name=None, copy=False, fill_value=None, fastpath=False
-    ):
-        """Construct SparseSeries from array.
-
-        .. deprecated:: 0.23.0
-            Use the pd.SparseSeries(..) constructor instead.
-        """
-        warnings.warn(
-            "'from_array' is deprecated and will be removed in a "
-            "future version. Please use the pd.SparseSeries(..) "
-            "constructor instead.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        return cls(
-            arr,
-            index=index,
-            name=name,
-            copy=copy,
-            fill_value=fill_value,
-            fastpath=fastpath,
-        )
-
-    @property
-    def _constructor(self):
-        return SparseSeries
-
-    @property
-    def _constructor_expanddim(self):
-        from pandas.core.sparse.api import SparseDataFrame
-
-        return SparseDataFrame
-
-    @property
-    def kind(self):
-        if isinstance(self.sp_index, BlockIndex):
-            return "block"
-        elif isinstance(self.sp_index, IntIndex):
-            return "integer"
-
-    def as_sparse_array(self, kind=None, fill_value=None, copy=False):
-        """ return my self as a sparse array, do not copy by default """
-
-        if fill_value is None:
-            fill_value = self.fill_value
-        if kind is None:
-            kind = self.kind
-        return SparseArray(
-            self.values,
-            sparse_index=self.sp_index,
-            fill_value=fill_value,
-            kind=kind,
-            copy=copy,
-        )
-
-    def __repr__(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "Sparse")
-            series_rep = Series.__repr__(self)
-            rep = "{series}\n{index!r}".format(series=series_rep, index=self.sp_index)
-            return rep
-
-    def _reduce(
-        self, op, name, axis=0, skipna=True, numeric_only=None, filter_type=None, **kwds
-    ):
-        """ perform a reduction operation """
-        return op(self.array.to_dense(), skipna=skipna, **kwds)
-
-    def __getstate__(self):
-        # pickling
-        return dict(
-            _typ=self._typ,
-            _subtyp=self._subtyp,
-            _data=self._data,
-            fill_value=self.fill_value,
-            name=self.name,
-        )
-
-    def _unpickle_series_compat(self, state):
-
-        nd_state, own_state = state
-
-        # recreate the ndarray
-        data = np.empty(nd_state[1], dtype=nd_state[2])
-        np.ndarray.__setstate__(data, nd_state)
-
-        index, fill_value, sp_index = own_state[:3]
-        name = None
-        if len(own_state) > 3:
-            name = own_state[3]
-
-        # create a sparse array
-        if not isinstance(data, SparseArray):
-            data = SparseArray(
-                data, sparse_index=sp_index, fill_value=fill_value, copy=False
-            )
-
-        # recreate
-        data = SingleBlockManager(data, index, fastpath=True)
-        generic.NDFrame.__init__(self, data)
-
-        self._set_axis(0, index)
-        self.name = name
-
-    def _set_subtyp(self, is_all_dates):
-        if is_all_dates:
-            object.__setattr__(self, "_subtyp", "sparse_time_series")
-        else:
-            object.__setattr__(self, "_subtyp", "sparse_series")
-
-    # ----------------------------------------------------------------------
-    # Indexing Methods
-
-    def _ixs(self, i: int, axis: int = 0):
-        """
-        Return the i-th value or values in the SparseSeries by location
-
-        Parameters
-        ----------
-        i : int
-        axis : int
-            default 0, ignored
-
-        Returns
-        -------
-        value : scalar (int) or Series (slice, sequence)
-        """
-        assert is_integer(i), i
-        # equiv: self._get_val_at(i) since we have an integer
-        return self.values[i]
-
-    def _get_val_at(self, loc):
-        """ forward to the array """
-        return self.values._get_val_at(loc)
-
-    def __getitem__(self, key):
-        # TODO: Document difference from Series.__getitem__, deprecate,
-        # and remove!
-        if is_integer(key) and key not in self.index:
-            return self._get_val_at(key)
-        else:
-            return super().__getitem__(key)
-
-    def _get_value(self, label, takeable=False):
-        """
-        Retrieve single value at passed index label
-
-        Please use .at[] or .iat[] accessors.
-
-        Parameters
-        ----------
-        index : label
-        takeable : interpret the index as indexers, default False
-
-        Returns
-        -------
-        value : scalar value
-        """
-        loc = label if takeable is True else self.index.get_loc(label)
-        return self._get_val_at(loc)
-
-    def _get_values(self, indexer):
-        try:
-            return self._constructor(
-                self._data.get_slice(indexer), fastpath=True
-            ).__finalize__(self)
-        except Exception:
-            return self[indexer]
-
-    def _set_with_engine(self, key, value):
-        return self._set_value(key, value)
-
-    def _set_value(self, label, value, takeable=False):
-        """
-        Quickly set single value at passed label. If label is not contained, a
-        new object is created with the label placed at the end of the result
-        index
-
-        .. deprecated:: 0.21.0
-
-        Please use .at[] or .iat[] accessors.
-
-        Parameters
-        ----------
-        label : object
-            Partial indexing with MultiIndex not allowed
-        value : object
-            Scalar value
-        takeable : interpret the index as indexers, default False
-
-        Notes
-        -----
-        This method *always* returns a new object. It is not particularly
-        efficient but is provided for API compatibility with Series
-
-        Returns
-        -------
-        series : SparseSeries
-        """
-        values = self.to_dense()
-
-        # if the label doesn't exist, we will create a new object here
-        # and possibly change the index
-        new_values = values._set_value(label, value, takeable=takeable)
-        if new_values is not None:
-            values = new_values
-        new_index = values.index
-        values = SparseArray(values, fill_value=self.fill_value, kind=self.kind)
-        self._data = SingleBlockManager(values, new_index)
-        self._index = new_index
-
-    def _set_values(self, key, value):
-
-        # this might be inefficient as we have to recreate the sparse array
-        # rather than setting individual elements, but have to convert
-        # the passed slice/boolean that's in dense space into a sparse indexer
-        # not sure how to do that!
-        if isinstance(key, Series):
-            key = key.values
-
-        values = self.values.to_dense()
-        values[key] = libindex.convert_scalar(values, value)
-        values = SparseArray(values, fill_value=self.fill_value, kind=self.kind)
-        self._data = SingleBlockManager(values, self.index)
-
-    # ----------------------------------------------------------------------
-    # Unsorted
-
-    def abs(self):
-        """
-        Return an object with absolute value taken. Only applicable to objects
-        that are all numeric
-
-        Returns
-        -------
-        abs: same type as caller
-        """
-        return self._constructor(np.abs(self.values), index=self.index).__finalize__(
-            self
-        )
-
-    def get(self, label, default=None):
-        """
-        Returns value occupying requested label, default to specified
-        missing value if not present. Analogous to dict.get
-
-        Parameters
-        ----------
-        label : object
-            Label value looking for
-        default : object, optional
-            Value to return if label not in index
-
-        Returns
-        -------
-        y : scalar
-        """
-        if label in self.index:
-            loc = self.index.get_loc(label)
-            return self._get_val_at(loc)
-        else:
-            return default
-
-    def to_dense(self):
-        """
-        Convert SparseSeries to a Series.
-
-        Returns
-        -------
-        s : Series
-        """
-        return Series(self.values.to_dense(), index=self.index, name=self.name)
-
-    @property
-    def density(self):
-        return self.values.density
-
-    def copy(self, deep=True):
-        """
-        Make a copy of the SparseSeries. Only the actual sparse values need to
-        be copied
-        """
-        # TODO: https://github.com/pandas-dev/pandas/issues/22314
-        # We skip the block manager till that is resolved.
-        new_data = self.values
-        if deep:
-            new_data = new_data.copy()
-        return self._constructor(
-            new_data,
-            sparse_index=self.sp_index,
-            fill_value=self.fill_value,
-            index=self.index.copy(),
-            name=self.name,
-        ).__finalize__(self)
-
-    @Substitution(**_shared_doc_kwargs)
-    @Appender(generic.NDFrame.reindex.__doc__)
-    def reindex(self, index=None, method=None, copy=True, limit=None, **kwargs):
-        # TODO: remove?
-        return super().reindex(
-            index=index, method=method, copy=copy, limit=limit, **kwargs
-        )
-
-    def sparse_reindex(self, new_index):
-        """
-        Conform sparse values to new SparseIndex
-
-        Parameters
-        ----------
-        new_index : {BlockIndex, IntIndex}
-
-        Returns
-        -------
-        reindexed : SparseSeries
-        """
-        if not isinstance(new_index, splib.SparseIndex):
-            raise TypeError("new index must be a SparseIndex")
-        values = self.values
-        values = values.sp_index.to_int_index().reindex(
-            values.sp_values.astype("float64"), values.fill_value, new_index
-        )
-        values = SparseArray(
-            values, sparse_index=new_index, fill_value=self.values.fill_value
-        )
-        return self._constructor(values, index=self.index).__finalize__(self)
-
-    def cumsum(self, axis=0, *args, **kwargs):
-        """
-        Cumulative sum of non-NA/null values.
-
-        When performing the cumulative summation, any non-NA/null values will
-        be skipped. The resulting SparseSeries will preserve the locations of
-        NaN values, but the fill value will be `np.nan` regardless.
-
-        Parameters
-        ----------
-        axis : {0}
-
-        Returns
-        -------
-        cumsum : SparseSeries
-        """
-        nv.validate_cumsum(args, kwargs)
-        # Validate axis
-        if axis is not None:
-            self._get_axis_number(axis)
-
-        new_array = self.values.cumsum()
-
-        return self._constructor(
-            new_array, index=self.index, sparse_index=new_array.sp_index
-        ).__finalize__(self)
-
-    # TODO: SparseSeries.isna is Sparse, while Series.isna is dense
-    @Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
-    def isna(self):
-        arr = SparseArray(
-            isna(self.values.sp_values),
-            sparse_index=self.values.sp_index,
-            fill_value=isna(self.fill_value),
-        )
-        return self._constructor(arr, index=self.index).__finalize__(self)
-
-    isnull = isna
-
-    @Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
-    def notna(self):
-        arr = SparseArray(
-            notna(self.values.sp_values),
-            sparse_index=self.values.sp_index,
-            fill_value=notna(self.fill_value),
-        )
-        return self._constructor(arr, index=self.index).__finalize__(self)
-
-    notnull = notna
-
-    def dropna(self, axis=0, inplace=False, **kwargs):
-        """
-        Analogous to Series.dropna. If fill_value=NaN, returns a dense Series
-        """
-        # TODO: make more efficient
-        # Validate axis
-        self._get_axis_number(axis or 0)
-        dense_valid = self.to_dense().dropna()
-        if inplace:
-            raise NotImplementedError(
-                "Cannot perform inplace dropna operations on a SparseSeries"
-            )
-        if isna(self.fill_value):
-            return dense_valid
-        else:
-            dense_valid = dense_valid[dense_valid != self.fill_value]
-            return dense_valid.to_sparse(fill_value=self.fill_value)
-
-    def combine_first(self, other):
-        """
-        Combine Series values, choosing the calling Series's values
-        first. Result index will be the union of the two indexes
-
-        Parameters
-        ----------
-        other : Series
-
-        Returns
-        -------
-        y : Series
-        """
-        if isinstance(other, SparseSeries):
-            other = other.to_dense()
-
-        dense_combined = self.to_dense().combine_first(other)
-        return dense_combined.to_sparse(fill_value=self.fill_value)
-
-    @Appender(SparseAccessor.to_coo.__doc__)
-    def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels=False):
-        A, rows, columns = _sparse_series_to_coo(
-            self, row_levels, column_levels, sort_labels=sort_labels
-        )
-        return A, rows, columns
-
-    @classmethod
-    @Appender(SparseAccessor.from_coo.__doc__)
-    def from_coo(cls, A, dense_index=False):
-        return _coo_to_sparse_series(A, dense_index=dense_index)
-
-
-# overwrite series methods with unaccelerated Sparse-specific versions
-ops.add_flex_arithmetic_methods(SparseSeries)
-ops.add_special_arithmetic_methods(SparseSeries)
diff --git a/pandas/core/strings.py b/pandas/core/strings.py
index 25350119f9df5..a4648186477d6 100644
--- a/pandas/core/strings.py
+++ b/pandas/core/strings.py
@@ -2,24 +2,29 @@
 from functools import wraps
 import re
 import textwrap
-from typing import Dict, List
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Type, Union
 import warnings
 
 import numpy as np
 
 import pandas._libs.lib as lib
+import pandas._libs.missing as libmissing
 import pandas._libs.ops as libops
-from pandas.util._decorators import Appender, deprecate_kwarg
+from pandas._typing import ArrayLike, Dtype
+from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
     ensure_object,
     is_bool_dtype,
     is_categorical_dtype,
+    is_extension_array_dtype,
     is_integer,
+    is_integer_dtype,
     is_list_like,
+    is_object_dtype,
     is_re,
     is_scalar,
-    is_string_like,
+    is_string_dtype,
 )
 from pandas.core.dtypes.generic import (
     ABCDataFrame,
@@ -32,6 +37,10 @@
 from pandas.core.algorithms import take_1d
 from pandas.core.base import NoNewAttributesMixin
 import pandas.core.common as com
+from pandas.core.construction import extract_array
+
+if TYPE_CHECKING:
+    from pandas.arrays import StringArray
 
 _cpython_optimized_encoders = (
     "utf-8",
@@ -44,7 +53,7 @@
 )
 _cpython_optimized_decoders = _cpython_optimized_encoders + ("utf-16", "utf-32")
 
-_shared_docs = dict()  # type: Dict[str, str]
+_shared_docs: Dict[str, str] = dict()
 
 
 def cat_core(list_of_columns: List, sep: str):
@@ -57,19 +66,21 @@ def cat_core(list_of_columns: List, sep: str):
         List of arrays to be concatenated with sep;
         these arrays may not contain NaNs!
     sep : string
-        The separator string for concatenating the columns
+        The separator string for concatenating the columns.
 
     Returns
     -------
     nd.array
-        The concatenation of list_of_columns with sep
+        The concatenation of list_of_columns with sep.
     """
     if sep == "":
         # no need to interleave sep if it is empty
-        return np.sum(list_of_columns, axis=0)
+        arr_of_cols = np.asarray(list_of_columns, dtype=object)
+        return np.sum(arr_of_cols, axis=0)
     list_with_sep = [sep] * (2 * len(list_of_columns) - 1)
     list_with_sep[::2] = list_of_columns
-    return np.sum(list_with_sep, axis=0)
+    arr_with_sep = np.asarray(list_with_sep, dtype=object)
+    return np.sum(arr_with_sep, axis=0)
 
 
 def cat_safe(list_of_columns: List, sep: str):
@@ -85,12 +96,12 @@ def cat_safe(list_of_columns: List, sep: str):
         List of arrays to be concatenated with sep;
         these arrays may not contain NaNs!
     sep : string
-        The separator string for concatenating the columns
+        The separator string for concatenating the columns.
 
     Returns
     -------
     nd.array
-        The concatenation of list_of_columns with sep
+        The concatenation of list_of_columns with sep.
     """
     try:
         result = cat_core(list_of_columns, sep)
@@ -103,17 +114,94 @@ def cat_safe(list_of_columns: List, sep: str):
                 raise TypeError(
                     "Concatenation requires list-likes containing only "
                     "strings (or missing values). Offending values found in "
-                    "column {}".format(dtype)
+                    f"column {dtype}"
                 ) from None
     return result
 
 
-def _na_map(f, arr, na_result=np.nan, dtype=object):
-    # should really _check_ for NA
-    return _map(f, arr, na_mask=True, na_value=na_result, dtype=dtype)
+def _na_map(f, arr, na_result=None, dtype=object):
+    if is_extension_array_dtype(arr.dtype):
+        if na_result is None:
+            na_result = libmissing.NA
+        # just StringDtype
+        arr = extract_array(arr)
+        return _map_stringarray(f, arr, na_value=na_result, dtype=dtype)
+    if na_result is None:
+        na_result = np.nan
+    return _map_object(f, arr, na_mask=True, na_value=na_result, dtype=dtype)
+
+
+def _map_stringarray(
+    func: Callable[[str], Any], arr: "StringArray", na_value: Any, dtype: Dtype
+) -> ArrayLike:
+    """
+    Map a callable over valid elements of a StringArrray.
+
+    Parameters
+    ----------
+    func : Callable[[str], Any]
+        Apply to each valid element.
+    arr : StringArray
+    na_value : Any
+        The value to use for missing values. By default, this is
+        the original value (NA).
+    dtype : Dtype
+        The result dtype to use. Specifying this avoids an intermediate
+        object-dtype allocation.
+
+    Returns
+    -------
+    ArrayLike
+        An ExtensionArray for integer or string dtypes, otherwise
+        an ndarray.
+
+    """
+    from pandas.arrays import IntegerArray, StringArray, BooleanArray
+
+    mask = isna(arr)
+
+    assert isinstance(arr, StringArray)
+    arr = np.asarray(arr)
+
+    if is_integer_dtype(dtype) or is_bool_dtype(dtype):
+        constructor: Union[Type[IntegerArray], Type[BooleanArray]]
+        if is_integer_dtype(dtype):
+            constructor = IntegerArray
+        else:
+            constructor = BooleanArray
+
+        na_value_is_na = isna(na_value)
+        if na_value_is_na:
+            na_value = 1
+        result = lib.map_infer_mask(
+            arr,
+            func,
+            mask.view("uint8"),
+            convert=False,
+            na_value=na_value,
+            dtype=np.dtype(dtype),
+        )
+
+        if not na_value_is_na:
+            mask[:] = False
+
+        return constructor(result, mask)
 
+    elif is_string_dtype(dtype) and not is_object_dtype(dtype):
+        # i.e. StringDtype
+        result = lib.map_infer_mask(
+            arr, func, mask.view("uint8"), convert=False, na_value=na_value
+        )
+        return StringArray(result)
+    else:
+        # This is when the result type is object. We reach this when
+        # -> We know the result type is truly object (e.g. .encode returns bytes
+        #    or .findall returns a list).
+        # -> We don't know the result type. E.g. `.get` can return anything.
+        return lib.map_infer_mask(arr, func, mask.view("uint8"))
 
-def _map(f, arr, na_mask=False, na_value=np.nan, dtype=object):
+
+def _map_object(f, arr, na_mask=False, na_value=np.nan, dtype=object):
     if not len(arr):
         return np.ndarray(0, dtype=dtype)
 
@@ -123,8 +211,8 @@ def _map(f, arr, na_mask=False, na_value=np.nan, dtype=object):
         arr = np.asarray(arr, dtype=object)
     if na_mask:
         mask = isna(arr)
+        convert = not np.all(mask)
         try:
-            convert = not all(mask)
             result = lib.map_infer_mask(arr, f, mask.view(np.uint8), convert)
         except (TypeError, AttributeError) as e:
             # Reraise the exception if callable `f` got wrong number of args.
@@ -135,6 +223,7 @@ def _map(f, arr, na_mask=False, na_value=np.nan, dtype=object):
             )
 
             if len(e.args) >= 1 and re.search(p_err, e.args[0]):
+                # FIXME: this should be totally avoidable
                 raise e
 
             def g(x):
@@ -143,7 +232,7 @@ def g(x):
                 except (TypeError, AttributeError):
                     return na_value
 
-            return _map(g, arr, dtype=dtype)
+            return _map_object(g, arr, dtype=dtype)
         if na_value is not np.nan:
             np.putmask(result, mask, na_value)
             if result.dtype == object:
@@ -219,7 +308,7 @@ def str_count(arr, pat, flags=0):
     """
     regex = re.compile(pat, flags=flags)
     f = lambda x: len(regex.findall(x))
-    return _na_map(f, arr, dtype=int)
+    return _na_map(f, arr, dtype="int64")
 
 
 def str_contains(arr, pat, case=True, flags=0, na=np.nan, regex=True):
@@ -353,8 +442,8 @@ def str_contains(arr, pat, case=True, flags=0, na=np.nan, regex=True):
 
         if regex.groups > 0:
             warnings.warn(
-                "This pattern has match groups. To actually get the"
-                " groups, use str.extract.",
+                "This pattern has match groups. To actually get the "
+                "groups, use str.extract.",
                 UserWarning,
                 stacklevel=3,
             )
@@ -491,28 +580,25 @@ def str_replace(arr, pat, repl, n=-1, case=None, flags=0, regex=True):
     ----------
     pat : str or compiled regex
         String can be a character sequence or regular expression.
-
-        .. versionadded:: 0.20.0
-            `pat` also accepts a compiled regex.
-
     repl : str or callable
         Replacement string or a callable. The callable is passed the regex
         match object and must return a replacement string to be used.
         See :func:`re.sub`.
-
-        .. versionadded:: 0.20.0
-            `repl` also accepts a callable.
-
     n : int, default -1 (all)
         Number of replacements to make from start.
     case : bool, default None
+        Determines if replace is case sensitive:
+
         - If True, case sensitive (the default if `pat` is a string)
         - Set to False for case insensitive
-        - Cannot be set if `pat` is a compiled regex
+        - Cannot be set if `pat` is a compiled regex.
+
     flags : int, default 0 (no flags)
-        - re module flags, e.g. re.IGNORECASE
-        - Cannot be set if `pat` is a compiled regex
+        Regex module flags, e.g. re.IGNORECASE. Cannot be set if `pat` is a compiled
+        regex.
     regex : bool, default True
+        Determines if assumes the passed-in pattern is a regular expression:
+
         - If True, assumes the passed-in pattern is a regular expression.
         - If False, treats the pattern as a literal string
         - Cannot be set to False if `pat` is a compiled regex or `repl` is
@@ -603,7 +689,7 @@ def str_replace(arr, pat, repl, n=-1, case=None, flags=0, regex=True):
     """
 
     # Check whether repl is valid (GH 13438, GH 15055)
-    if not (is_string_like(repl) or callable(repl)):
+    if not (isinstance(repl, str) or callable(repl)):
         raise TypeError("repl must be a string or callable")
 
     is_compiled_re = is_re(pat)
@@ -637,7 +723,7 @@ def str_replace(arr, pat, repl, n=-1, case=None, flags=0, regex=True):
             raise ValueError("Cannot use a callable replacement when regex=False")
         f = lambda x: x.replace(pat, repl, n)
 
-    return _na_map(f, arr)
+    return _na_map(f, arr, dtype=str)
 
 
 def str_repeat(arr, repeats):
@@ -688,7 +774,7 @@ def scalar_rep(x):
             except TypeError:
                 return str.__mul__(x, repeats)
 
-        return _na_map(scalar_rep, arr)
+        return _na_map(scalar_rep, arr, dtype=str)
     else:
 
         def rep(x, r):
@@ -713,7 +799,7 @@ def str_match(arr, pat, case=True, flags=0, na=np.nan):
     case : bool, default True
         If True, case sensitive.
     flags : int, default 0 (no flags)
-        re module flags, e.g. re.IGNORECASE.
+        Regex module flags, e.g. re.IGNORECASE.
     na : default NaN
         Fill value for missing values.
 
@@ -763,6 +849,16 @@ def f(x):
     return f
 
 
+def _result_dtype(arr):
+    # workaround #27953
+    # ideally we just pass `dtype=arr.dtype` unconditionally, but this fails
+    # when the list of values is empty.
+    if arr.dtype.name == "string":
+        return "string"
+    else:
+        return object
+
+
 def _str_extract_noexpand(arr, pat, flags=0):
     """
     Find groups in each string in the Series using passed regular
@@ -788,11 +884,12 @@ def _str_extract_noexpand(arr, pat, flags=0):
         if arr.empty:
             result = DataFrame(columns=columns, dtype=object)
         else:
+            dtype = _result_dtype(arr)
             result = DataFrame(
                 [groups_or_na(val) for val in arr],
                 columns=columns,
                 index=arr.index,
-                dtype=object,
+                dtype=dtype,
             )
     return result, name
 
@@ -817,11 +914,12 @@ def _str_extract_frame(arr, pat, flags=0):
         result_index = arr.index
     except AttributeError:
         result_index = None
+    dtype = _result_dtype(arr)
     return DataFrame(
         [groups_or_na(val) for val in arr],
         columns=columns,
         index=result_index,
-        dtype=object,
+        dtype=dtype,
     )
 
 
@@ -1019,8 +1117,11 @@ def str_extractall(arr, pat, flags=0):
     from pandas import MultiIndex
 
     index = MultiIndex.from_tuples(index_list, names=arr.index.names + ["match"])
+    dtype = _result_dtype(arr)
 
-    result = arr._constructor_expanddim(match_list, index=index, columns=columns)
+    result = arr._constructor_expanddim(
+        match_list, index=index, columns=columns, dtype=dtype
+    )
     return result
 
 
@@ -1073,7 +1174,7 @@ def str_get_dummies(arr, sep="|"):
 
     for i, t in enumerate(tags):
         pat = sep + t + sep
-        dummies[:, i] = lib.map_infer(arr.values, lambda x: pat in x)
+        dummies[:, i] = lib.map_infer(arr.to_numpy(), lambda x: pat in x)
     return dummies, tags
 
 
@@ -1139,7 +1240,7 @@ def str_join(arr, sep):
     4                    NaN
     dtype: object
     """
-    return _na_map(sep.join, arr)
+    return _na_map(sep.join, arr, dtype=str)
 
 
 def str_findall(arr, pat, flags=0):
@@ -1259,8 +1360,8 @@ def str_find(arr, sub, start=0, end=None, side="left"):
     """
 
     if not isinstance(sub, str):
-        msg = "expected a string object, not {0}"
-        raise TypeError(msg.format(type(sub).__name__))
+        msg = f"expected a string object, not {type(sub).__name__}"
+        raise TypeError(msg)
 
     if side == "left":
         method = "find"
@@ -1274,13 +1375,13 @@ def str_find(arr, sub, start=0, end=None, side="left"):
     else:
         f = lambda x: getattr(x, method)(sub, start, end)
 
-    return _na_map(f, arr, dtype=int)
+    return _na_map(f, arr, dtype="int64")
 
 
 def str_index(arr, sub, start=0, end=None, side="left"):
     if not isinstance(sub, str):
-        msg = "expected a string object, not {0}"
-        raise TypeError(msg.format(type(sub).__name__))
+        msg = f"expected a string object, not {type(sub).__name__}"
+        raise TypeError(msg)
 
     if side == "left":
         method = "index"
@@ -1294,7 +1395,7 @@ def str_index(arr, sub, start=0, end=None, side="left"):
     else:
         f = lambda x: getattr(x, method)(sub, start, end)
 
-    return _na_map(f, arr, dtype=int)
+    return _na_map(f, arr, dtype="int64")
 
 
 def str_pad(arr, width, side="left", fillchar=" "):
@@ -1324,7 +1425,7 @@ def str_pad(arr, width, side="left", fillchar=" "):
         character. Equivalent to ``Series.str.pad(side='right')``.
     Series.str.center : Fills boths sides of strings with an arbitrary
         character. Equivalent to ``Series.str.pad(side='both')``.
-    Series.str.zfill :  Pad strings in the Series/Index by prepending '0'
+    Series.str.zfill : Pad strings in the Series/Index by prepending '0'
         character. Equivalent to ``Series.str.pad(side='left', fillchar='0')``.
 
     Examples
@@ -1351,15 +1452,15 @@ def str_pad(arr, width, side="left", fillchar=" "):
     dtype: object
     """
     if not isinstance(fillchar, str):
-        msg = "fillchar must be a character, not {0}"
-        raise TypeError(msg.format(type(fillchar).__name__))
+        msg = f"fillchar must be a character, not {type(fillchar).__name__}"
+        raise TypeError(msg)
 
     if len(fillchar) != 1:
         raise TypeError("fillchar must be a character, not str")
 
     if not is_integer(width):
-        msg = "width must be of integer type, not {0}"
-        raise TypeError(msg.format(type(width).__name__))
+        msg = f"width must be of integer type, not {type(width).__name__}"
+        raise TypeError(msg)
 
     if side == "left":
         f = lambda x: x.rjust(width, fillchar)
@@ -1370,7 +1471,7 @@ def str_pad(arr, width, side="left", fillchar=" "):
     else:  # pragma: no cover
         raise ValueError("Invalid side")
 
-    return _na_map(f, arr)
+    return _na_map(f, arr, dtype=str)
 
 
 def str_split(arr, pat=None, n=None):
@@ -1476,7 +1577,7 @@ def str_slice(arr, start=None, stop=None, step=None):
     """
     obj = slice(start, stop, step)
     f = lambda x: x[obj]
-    return _na_map(f, arr)
+    return _na_map(f, arr, dtype=str)
 
 
 def str_slice_replace(arr, start=None, stop=None, repl=None):
@@ -1567,7 +1668,7 @@ def f(x):
             y += x[local_stop:]
         return y
 
-    return _na_map(f, arr)
+    return _na_map(f, arr, dtype=str)
 
 
 def str_strip(arr, to_strip=None, side="both"):
@@ -1592,7 +1693,7 @@ def str_strip(arr, to_strip=None, side="both"):
         f = lambda x: x.rstrip(to_strip)
     else:  # pragma: no cover
         raise ValueError("Invalid side")
-    return _na_map(f, arr)
+    return _na_map(f, arr, dtype=str)
 
 
 def str_wrap(arr, width, **kwargs):
@@ -1656,7 +1757,7 @@ def str_wrap(arr, width, **kwargs):
 
     tw = textwrap.TextWrapper(**kwargs)
 
-    return _na_map(lambda s: "\n".join(tw.wrap(s)), arr)
+    return _na_map(lambda s: "\n".join(tw.wrap(s)), arr, dtype=str)
 
 
 def str_translate(arr, table):
@@ -1667,7 +1768,7 @@ def str_translate(arr, table):
     Parameters
     ----------
     table : dict
-        table is a mapping of Unicode ordinals to Unicode ordinals, strings, or
+        Table is a mapping of Unicode ordinals to Unicode ordinals, strings, or
         None. Unmapped characters are left untouched.
         Characters mapped to None are deleted. :meth:`str.maketrans` is a
         helper function for making translation tables.
@@ -1676,7 +1777,7 @@ def str_translate(arr, table):
     -------
     Series or Index
     """
-    return _na_map(lambda x: x.translate(table), arr)
+    return _na_map(lambda x: x.translate(table), arr, dtype=str)
 
 
 def str_get(arr, i):
@@ -1844,10 +1945,8 @@ def _forbid_nonstring_types(func):
         def wrapper(self, *args, **kwargs):
             if self._inferred_dtype not in allowed_types:
                 msg = (
-                    "Cannot use .str.{name} with values of inferred dtype "
-                    "{inf_type!r}.".format(
-                        name=func_name, inf_type=self._inferred_dtype
-                    )
+                    f"Cannot use .str.{func_name} with values of "
+                    f"inferred dtype '{self._inferred_dtype}'."
                 )
                 raise TypeError(msg)
             return func(self, *args, **kwargs)
@@ -1858,11 +1957,18 @@ def wrapper(self, *args, **kwargs):
     return _forbid_nonstring_types
 
 
-def _noarg_wrapper(f, name=None, docstring=None, forbidden_types=["bytes"], **kargs):
+def _noarg_wrapper(
+    f,
+    name=None,
+    docstring=None,
+    forbidden_types=["bytes"],
+    returns_string=True,
+    **kargs,
+):
     @forbid_nonstring_types(forbidden_types, name=name)
     def wrapper(self):
         result = _na_map(f, self._parent, **kargs)
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=returns_string)
 
     wrapper.__name__ = f.__name__ if name is None else name
     if docstring is not None:
@@ -1874,22 +1980,28 @@ def wrapper(self):
 
 
 def _pat_wrapper(
-    f, flags=False, na=False, name=None, forbidden_types=["bytes"], **kwargs
+    f,
+    flags=False,
+    na=False,
+    name=None,
+    forbidden_types=["bytes"],
+    returns_string=True,
+    **kwargs,
 ):
     @forbid_nonstring_types(forbidden_types, name=name)
     def wrapper1(self, pat):
         result = f(self._parent, pat)
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=returns_string)
 
     @forbid_nonstring_types(forbidden_types, name=name)
     def wrapper2(self, pat, flags=0, **kwargs):
         result = f(self._parent, pat, flags=flags, **kwargs)
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=returns_string)
 
     @forbid_nonstring_types(forbidden_types, name=name)
     def wrapper3(self, pat, na=np.nan):
         result = f(self._parent, pat, na=na)
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=returns_string)
 
     wrapper = wrapper3 if na else wrapper2 if flags else wrapper1
 
@@ -1901,7 +2013,7 @@ def wrapper3(self, pat, na=np.nan):
 
 
 def copy(source):
-    "Copy a docstring from another source function (if present)"
+    """Copy a docstring from another source function (if present)"""
 
     def do_copy(target):
         if source.__doc__:
@@ -1926,6 +2038,7 @@ class StringMethods(NoNewAttributesMixin):
     def __init__(self, data):
         self._inferred_dtype = self._validate(data)
         self._is_categorical = is_categorical_dtype(data)
+        self._is_string = data.dtype.name == "string"
 
         # .values.categories works for both Series/Index
         self._parent = data.values.categories if self._is_categorical else data
@@ -1956,6 +2069,8 @@ def _validate(data):
         -------
         dtype : inferred dtype of data
         """
+        from pandas import StringDtype
+
         if isinstance(data, ABCMultiIndex):
             raise AttributeError(
                 "Can only use .str accessor with Index, not MultiIndex"
@@ -1967,6 +2082,10 @@ def _validate(data):
         values = getattr(data, "values", data)  # Series / Index
         values = getattr(values, "categories", values)  # categorical / normal
 
+        # explicitly allow StringDtype
+        if isinstance(values.dtype, StringDtype):
+            return "string"
+
         try:
             inferred_dtype = lib.infer_dtype(values, skipna=True)
         except ValueError:
@@ -1984,6 +2103,11 @@ def __getitem__(self, key):
             return self.get(key)
 
     def __iter__(self):
+        warnings.warn(
+            "Columnar iteration over characters will be deprecated in future releases.",
+            FutureWarning,
+            stacklevel=2,
+        )
         i = 0
         g = self.get(i)
         while g.notna().any():
@@ -1992,7 +2116,13 @@ def __iter__(self):
             g = self.get(i)
 
     def _wrap_result(
-        self, result, use_codes=True, name=None, expand=None, fill_value=np.nan
+        self,
+        result,
+        use_codes=True,
+        name=None,
+        expand=None,
+        fill_value=np.nan,
+        returns_string=True,
     ):
 
         from pandas import Index, Series, MultiIndex
@@ -2012,6 +2142,15 @@ def _wrap_result(
             return result
         assert result.ndim < 3
 
+        # We can be wrapping a string / object / categorical result, in which
+        # case we'll want to return the same dtype as the input.
+        # Or we can be wrapping a numeric output, in which case we don't want
+        # to return a StringArray.
+        if self._is_string and returns_string:
+            dtype = "string"
+        else:
+            dtype = None
+
         if expand is None:
             # infer from ndim if expand is not specified
             expand = result.ndim != 1
@@ -2069,11 +2208,12 @@ def cons_row(x):
             index = self._orig.index
             if expand:
                 cons = self._orig._constructor_expanddim
-                return cons(result, columns=name, index=index)
+                result = cons(result, columns=name, index=index, dtype=dtype)
             else:
                 # Must be a Series
                 cons = self._orig._constructor
-                return cons(result, name=name, index=index)
+                result = cons(result, name=name, index=index, dtype=dtype)
+            return result
 
     def _get_series_list(self, others):
         """
@@ -2084,11 +2224,12 @@ def _get_series_list(self, others):
         Parameters
         ----------
         others : Series, DataFrame, np.ndarray, list-like or list-like of
-            objects that are either Series, Index or np.ndarray (1-dim)
+            Objects that are either Series, Index or np.ndarray (1-dim).
 
         Returns
         -------
-        list : others transformed into list of Series
+        list of Series
+            Others transformed into list of Series.
         """
         from pandas import Series, DataFrame
 
@@ -2338,9 +2479,12 @@ def cat(self, others=None, sep=None, na_rep=None, join="left"):
             # add dtype for case that result is all-NA
             result = Index(result, dtype=object, name=self._orig.name)
         else:  # Series
-            result = Series(
-                result, dtype=object, index=data.index, name=self._orig.name
-            )
+            if is_categorical_dtype(self._orig.dtype):
+                # We need to infer the new categories.
+                dtype = None
+            else:
+                dtype = self._orig.dtype
+            result = Series(result, dtype=dtype, index=data.index, name=self._orig.name)
         return result
 
     _shared_docs[
@@ -2479,13 +2623,13 @@ def cat(self, others=None, sep=None, na_rep=None, join="left"):
     @forbid_nonstring_types(["bytes"])
     def split(self, pat=None, n=-1, expand=False):
         result = str_split(self._parent, pat, n=n)
-        return self._wrap_result(result, expand=expand)
+        return self._wrap_result(result, expand=expand, returns_string=expand)
 
     @Appender(_shared_docs["str_split"] % {"side": "end", "method": "rsplit"})
     @forbid_nonstring_types(["bytes"])
     def rsplit(self, pat=None, n=-1, expand=False):
         result = str_rsplit(self._parent, pat, n=n)
-        return self._wrap_result(result, expand=expand)
+        return self._wrap_result(result, expand=expand, returns_string=expand)
 
     _shared_docs[
         "str_partition"
@@ -2501,9 +2645,6 @@ def rsplit(self, pat=None, n=-1, expand=False):
     ----------
     sep : str, default whitespace
         String to split on.
-    pat : str, default whitespace
-        .. deprecated:: 0.24.0
-           Use ``sep`` instead
     expand : bool, default True
         If True, return DataFrame/MultiIndex expanding dimensionality.
         If False, return Series/Index.
@@ -2581,12 +2722,11 @@ def rsplit(self, pat=None, n=-1, expand=False):
             "also": "rpartition : Split the string at the last occurrence of `sep`.",
         }
     )
-    @deprecate_kwarg(old_arg_name="pat", new_arg_name="sep")
     @forbid_nonstring_types(["bytes"])
     def partition(self, sep=" ", expand=True):
         f = lambda x: x.partition(sep)
         result = _na_map(f, self._parent)
-        return self._wrap_result(result, expand=expand)
+        return self._wrap_result(result, expand=expand, returns_string=expand)
 
     @Appender(
         _shared_docs["str_partition"]
@@ -2597,12 +2737,11 @@ def partition(self, sep=" ", expand=True):
             "also": "partition : Split the string at the first occurrence of `sep`.",
         }
     )
-    @deprecate_kwarg(old_arg_name="pat", new_arg_name="sep")
     @forbid_nonstring_types(["bytes"])
     def rpartition(self, sep=" ", expand=True):
         f = lambda x: x.rpartition(sep)
         result = _na_map(f, self._parent)
-        return self._wrap_result(result, expand=expand)
+        return self._wrap_result(result, expand=expand, returns_string=expand)
 
     @copy(str_get)
     def get(self, i):
@@ -2621,13 +2760,13 @@ def contains(self, pat, case=True, flags=0, na=np.nan, regex=True):
         result = str_contains(
             self._parent, pat, case=case, flags=flags, na=na, regex=regex
         )
-        return self._wrap_result(result, fill_value=na)
+        return self._wrap_result(result, fill_value=na, returns_string=False)
 
     @copy(str_match)
     @forbid_nonstring_types(["bytes"])
     def match(self, pat, case=True, flags=0, na=np.nan):
         result = str_match(self._parent, pat, case=case, flags=flags, na=na)
-        return self._wrap_result(result, fill_value=na)
+        return self._wrap_result(result, fill_value=na, returns_string=False)
 
     @copy(str_replace)
     @forbid_nonstring_types(["bytes"])
@@ -2659,13 +2798,13 @@ def pad(self, width, side="left", fillchar=" "):
     ----------
     width : int
         Minimum width of resulting string; additional characters will be filled
-        with ``fillchar``
+        with ``fillchar``.
     fillchar : str
-        Additional character for filling, default is whitespace
+        Additional character for filling, default is whitespace.
 
     Returns
     -------
-    filled : Series/Index of objects
+    filled : Series/Index of objects.
     """
 
     @Appender(_shared_docs["str_pad"] % dict(side="left and right", method="center"))
@@ -2701,7 +2840,7 @@ def zfill(self, width):
 
         Returns
         -------
-        Series/Index of objects
+        Series/Index of objects.
 
         See Also
         --------
@@ -2762,13 +2901,14 @@ def slice_replace(self, start=None, stop=None, repl=None):
     def decode(self, encoding, errors="strict"):
         # need to allow bytes here
         result = str_decode(self._parent, encoding, errors)
-        return self._wrap_result(result)
+        # TODO: Not sure how to handle this.
+        return self._wrap_result(result, returns_string=False)
 
     @copy(str_encode)
     @forbid_nonstring_types(["bytes"])
     def encode(self, encoding, errors="strict"):
         result = str_encode(self._parent, encoding, errors)
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=False)
 
     _shared_docs[
         "str_strip"
@@ -2788,7 +2928,7 @@ def encode(self, encoding, errors="strict"):
 
     Returns
     -------
-    Series/Index of objects
+    Series or Index of object
 
     See Also
     --------
@@ -2869,7 +3009,11 @@ def get_dummies(self, sep="|"):
         data = self._orig.astype(str) if self._is_categorical else self._parent
         result, name = str_get_dummies(data, sep)
         return self._wrap_result(
-            result, use_codes=(not self._is_categorical), name=name, expand=True
+            result,
+            use_codes=(not self._is_categorical),
+            name=name,
+            expand=True,
+            returns_string=False,
         )
 
     @copy(str_translate)
@@ -2878,10 +3022,16 @@ def translate(self, table):
         result = str_translate(self._parent, table)
         return self._wrap_result(result)
 
-    count = _pat_wrapper(str_count, flags=True, name="count")
-    startswith = _pat_wrapper(str_startswith, na=True, name="startswith")
-    endswith = _pat_wrapper(str_endswith, na=True, name="endswith")
-    findall = _pat_wrapper(str_findall, flags=True, name="findall")
+    count = _pat_wrapper(str_count, flags=True, name="count", returns_string=False)
+    startswith = _pat_wrapper(
+        str_startswith, na=True, name="startswith", returns_string=False
+    )
+    endswith = _pat_wrapper(
+        str_endswith, na=True, name="endswith", returns_string=False
+    )
+    findall = _pat_wrapper(
+        str_findall, flags=True, name="findall", returns_string=False
+    )
 
     @copy(str_extract)
     @forbid_nonstring_types(["bytes"])
@@ -2903,15 +3053,15 @@ def extractall(self, pat, flags=0):
     Parameters
     ----------
     sub : str
-        Substring being searched
+        Substring being searched.
     start : int
-        Left edge index
+        Left edge index.
     end : int
-        Right edge index
+        Right edge index.
 
     Returns
     -------
-    found : Series/Index of integer values
+    Series or Index of int.
 
     See Also
     --------
@@ -2929,7 +3079,7 @@ def extractall(self, pat, flags=0):
     @forbid_nonstring_types(["bytes"])
     def find(self, sub, start=0, end=None):
         result = str_find(self._parent, sub, start=start, end=end, side="left")
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=False)
 
     @Appender(
         _shared_docs["find"]
@@ -2942,7 +3092,7 @@ def find(self, sub, start=0, end=None):
     @forbid_nonstring_types(["bytes"])
     def rfind(self, sub, start=0, end=None):
         result = str_find(self._parent, sub, start=start, end=end, side="right")
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=False)
 
     @forbid_nonstring_types(["bytes"])
     def normalize(self, form):
@@ -2954,7 +3104,7 @@ def normalize(self, form):
         Parameters
         ----------
         form : {'NFC', 'NFKC', 'NFD', 'NFKD'}
-            Unicode form
+            Unicode form.
 
         Returns
         -------
@@ -2963,7 +3113,7 @@ def normalize(self, form):
         import unicodedata
 
         f = lambda x: unicodedata.normalize(form, x)
-        result = _na_map(f, self._parent)
+        result = _na_map(f, self._parent, dtype=str)
         return self._wrap_result(result)
 
     _shared_docs[
@@ -2977,15 +3127,15 @@ def normalize(self, form):
     Parameters
     ----------
     sub : str
-        Substring being searched
+        Substring being searched.
     start : int
-        Left edge index
+        Left edge index.
     end : int
-        Right edge index
+        Right edge index.
 
     Returns
     -------
-    found : Series/Index of objects
+    Series or Index of object
 
     See Also
     --------
@@ -3004,7 +3154,7 @@ def normalize(self, form):
     @forbid_nonstring_types(["bytes"])
     def index(self, sub, start=0, end=None):
         result = str_index(self._parent, sub, start=start, end=end, side="left")
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=False)
 
     @Appender(
         _shared_docs["index"]
@@ -3018,7 +3168,7 @@ def index(self, sub, start=0, end=None):
     @forbid_nonstring_types(["bytes"])
     def rindex(self, sub, start=0, end=None):
         result = str_index(self._parent, sub, start=start, end=end, side="right")
-        return self._wrap_result(result)
+        return self._wrap_result(result, returns_string=False)
 
     _shared_docs[
         "len"
@@ -3067,7 +3217,11 @@ def rindex(self, sub, start=0, end=None):
     dtype: float64
     """
     len = _noarg_wrapper(
-        len, docstring=_shared_docs["len"], forbidden_types=None, dtype=int
+        len,
+        docstring=_shared_docs["len"],
+        forbidden_types=None,
+        dtype="int64",
+        returns_string=False,
     )
 
     _shared_docs[
@@ -3079,7 +3233,7 @@ def rindex(self, sub, start=0, end=None):
 
     Returns
     -------
-    Series/Index of objects
+    Series or Index of object
 
     See Also
     --------
@@ -3140,7 +3294,7 @@ def rindex(self, sub, start=0, end=None):
     """
 
     # _doc_args holds dict of strings to use in substituting casemethod docs
-    _doc_args = {}  # type: Dict[str, Dict[str, str]]
+    _doc_args: Dict[str, Dict[str, str]] = {}
     _doc_args["lower"] = dict(type="lowercase", method="lower", version="")
     _doc_args["upper"] = dict(type="uppercase", method="upper", version="")
     _doc_args["title"] = dict(type="titlecase", method="title", version="")
@@ -3157,31 +3311,37 @@ def rindex(self, sub, start=0, end=None):
         lambda x: x.lower(),
         name="lower",
         docstring=_shared_docs["casemethods"] % _doc_args["lower"],
+        dtype=str,
     )
     upper = _noarg_wrapper(
         lambda x: x.upper(),
         name="upper",
         docstring=_shared_docs["casemethods"] % _doc_args["upper"],
+        dtype=str,
     )
     title = _noarg_wrapper(
         lambda x: x.title(),
         name="title",
         docstring=_shared_docs["casemethods"] % _doc_args["title"],
+        dtype=str,
     )
     capitalize = _noarg_wrapper(
         lambda x: x.capitalize(),
         name="capitalize",
         docstring=_shared_docs["casemethods"] % _doc_args["capitalize"],
+        dtype=str,
     )
     swapcase = _noarg_wrapper(
         lambda x: x.swapcase(),
         name="swapcase",
         docstring=_shared_docs["casemethods"] % _doc_args["swapcase"],
+        dtype=str,
     )
     casefold = _noarg_wrapper(
         lambda x: x.casefold(),
         name="casefold",
         docstring=_shared_docs["casemethods"] % _doc_args["casefold"],
+        dtype=str,
     )
 
     _shared_docs[
@@ -3335,50 +3495,69 @@ def rindex(self, sub, start=0, end=None):
     _doc_args["istitle"] = dict(type="titlecase", method="istitle")
     _doc_args["isnumeric"] = dict(type="numeric", method="isnumeric")
     _doc_args["isdecimal"] = dict(type="decimal", method="isdecimal")
+    # force _noarg_wrapper return type with dtype=bool (GH 29624)
     isalnum = _noarg_wrapper(
         lambda x: x.isalnum(),
         name="isalnum",
         docstring=_shared_docs["ismethods"] % _doc_args["isalnum"],
+        returns_string=False,
+        dtype=bool,
     )
     isalpha = _noarg_wrapper(
         lambda x: x.isalpha(),
         name="isalpha",
         docstring=_shared_docs["ismethods"] % _doc_args["isalpha"],
+        returns_string=False,
+        dtype=bool,
     )
     isdigit = _noarg_wrapper(
         lambda x: x.isdigit(),
         name="isdigit",
         docstring=_shared_docs["ismethods"] % _doc_args["isdigit"],
+        returns_string=False,
+        dtype=bool,
     )
     isspace = _noarg_wrapper(
         lambda x: x.isspace(),
         name="isspace",
         docstring=_shared_docs["ismethods"] % _doc_args["isspace"],
+        returns_string=False,
+        dtype=bool,
     )
     islower = _noarg_wrapper(
         lambda x: x.islower(),
         name="islower",
         docstring=_shared_docs["ismethods"] % _doc_args["islower"],
+        returns_string=False,
+        dtype=bool,
     )
     isupper = _noarg_wrapper(
         lambda x: x.isupper(),
         name="isupper",
         docstring=_shared_docs["ismethods"] % _doc_args["isupper"],
+        returns_string=False,
+        dtype=bool,
     )
     istitle = _noarg_wrapper(
         lambda x: x.istitle(),
         name="istitle",
         docstring=_shared_docs["ismethods"] % _doc_args["istitle"],
+        returns_string=False,
+        dtype=bool,
     )
     isnumeric = _noarg_wrapper(
         lambda x: x.isnumeric(),
         name="isnumeric",
         docstring=_shared_docs["ismethods"] % _doc_args["isnumeric"],
+        returns_string=False,
+        dtype=bool,
     )
     isdecimal = _noarg_wrapper(
         lambda x: x.isdecimal(),
         name="isdecimal",
         docstring=_shared_docs["ismethods"] % _doc_args["isdecimal"],
+        returns_string=False,
+        dtype=bool,
     )
 
     @classmethod
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index b07647cf5b5fb..6d45ddd29d783 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -1,6 +1,7 @@
 from collections import abc
 from datetime import datetime, time
 from functools import partial
+from itertools import islice
 from typing import Optional, TypeVar, Union
 
 import numpy as np
@@ -11,10 +12,9 @@
     DateParseError,
     _format_is_iso,
     _guess_datetime_format,
-    parse_time_string,
 )
 from pandas._libs.tslibs.strptime import array_strptime
-from pandas.util._decorators import deprecate_kwarg
+from pandas._typing import ArrayLike
 
 from pandas.core.dtypes.common import (
     ensure_object,
@@ -37,20 +37,15 @@
 )
 from pandas.core.dtypes.missing import notna
 
-from pandas._typing import ArrayLike
+from pandas.arrays import DatetimeArray, IntegerArray
 from pandas.core import algorithms
 from pandas.core.algorithms import unique
+from pandas.core.arrays.datetimes import tz_to_dtype
 
 # ---------------------------------------------------------------------
 # types used in annotations
 
 ArrayConvertible = Union[list, tuple, ArrayLike, ABCSeries]
-
-# ---------------------------------------------------------------------
-
-# ---------------------------------------------------------------------
-# types used in annotations
-
 Scalar = Union[int, float, str]
 DatetimeScalar = TypeVar("DatetimeScalar", Scalar, datetime)
 DatetimeScalarOrArrayConvertible = Union[
@@ -118,7 +113,7 @@ def should_cache(
 
     assert 0 < unique_share < 1, "unique_share must be in next bounds: (0; 1)"
 
-    unique_elements = unique(arg[:check_count])
+    unique_elements = set(islice(arg, check_count))
     if len(unique_elements) > check_count * unique_share:
         do_caching = False
     return do_caching
@@ -145,7 +140,8 @@ def _maybe_cache(arg, format, cache, convert_listlike):
     """
     from pandas import Series
 
-    cache_array = Series()
+    cache_array = Series(dtype=object)
+
     if cache:
         # Perform a quicker unique check
         if not should_cache(arg):
@@ -153,7 +149,7 @@ def _maybe_cache(arg, format, cache, convert_listlike):
 
         unique_dates = unique(arg)
         if len(unique_dates) < len(arg):
-            cache_dates = convert_listlike(unique_dates, True, format)
+            cache_dates = convert_listlike(unique_dates, format)
             cache_array = Series(cache_dates, index=unique_dates)
     return cache_array
 
@@ -168,7 +164,7 @@ def _box_as_indexlike(
     Parameters
     ----------
     dt_array: 1-d array
-        array of datetimes to be boxed
+        Array of datetimes to be wrapped in an Index.
     tz : object
         None or 'utc'
     name : string, default None
@@ -191,37 +187,30 @@ def _box_as_indexlike(
 def _convert_and_box_cache(
     arg: DatetimeScalarOrArrayConvertible,
     cache_array: ABCSeries,
-    box: bool,
     name: Optional[str] = None,
-) -> Union[ABCIndex, np.ndarray]:
+) -> ABCIndexClass:
     """
-    Convert array of dates with a cache and box the result
+    Convert array of dates with a cache and wrap the result in an Index.
 
     Parameters
     ----------
     arg : integer, float, string, datetime, list, tuple, 1-d array, Series
     cache_array : Series
         Cache of converted, unique dates
-    box : boolean
-        True boxes result as an Index-like, False returns an ndarray
     name : string, default None
         Name for a DatetimeIndex
 
     Returns
     -------
-    result : datetime of converted dates
-        - Index-like if box=True
-        - ndarray if box=False
+    result : Index-like of converted dates
     """
     from pandas import Series
 
     result = Series(arg).map(cache_array)
-    if box:
-        return _box_as_indexlike(result, utc=None, name=name)
-    return result.values
+    return _box_as_indexlike(result, utc=None, name=name)
 
 
-def _return_parsed_timezone_results(result, timezones, box, tz, name):
+def _return_parsed_timezone_results(result, timezones, tz, name):
     """
     Return results from array_strptime if a %z or %Z directive was passed.
 
@@ -231,8 +220,6 @@ def _return_parsed_timezone_results(result, timezones, box, tz, name):
         int64 date representations of the dates
     timezones : ndarray
         pytz timezone objects
-    box : boolean
-        True boxes result as an Index-like, False returns an ndarray
     tz : object
         None or pytz timezone object
     name : string, default None
@@ -240,31 +227,22 @@ def _return_parsed_timezone_results(result, timezones, box, tz, name):
 
     Returns
     -------
-    tz_result : ndarray of parsed dates with timezone
-        Returns:
-
-        - Index-like if box=True
-        - ndarray of Timestamps if box=False
+    tz_result : Index-like of parsed dates with timezone
     """
     if tz is not None:
         raise ValueError(
-            "Cannot pass a tz argument when "
-            "parsing strings with timezone "
-            "information."
+            "Cannot pass a tz argument when parsing strings with timezone information."
         )
     tz_results = np.array(
         [Timestamp(res).tz_localize(zone) for res, zone in zip(result, timezones)]
     )
-    if box:
-        from pandas import Index
+    from pandas import Index
 
-        return Index(tz_results, name=name)
-    return tz_results
+    return Index(tz_results, name=name)
 
 
 def _convert_listlike_datetimes(
     arg,
-    box,
     format,
     name=None,
     tz=None,
@@ -283,8 +261,6 @@ def _convert_listlike_datetimes(
     ----------
     arg : list, tuple, ndarray, Series, Index
         date to be parced
-    box : boolean
-        True boxes result as an Index-like, False returns an ndarray
     name : object
         None or string for the Index name
     tz : object
@@ -304,14 +280,9 @@ def _convert_listlike_datetimes(
 
     Returns
     -------
-    ndarray of parsed dates
-        Returns:
-
-        - Index-like if box=True
-        - ndarray of Timestamps if box=False
+    Index-like of parsed dates
     """
     from pandas import DatetimeIndex
-    from pandas.core.arrays import DatetimeArray
     from pandas.core.arrays.datetimes import (
         maybe_convert_dtype,
         objects_to_datetime64ns,
@@ -329,7 +300,7 @@ def _convert_listlike_datetimes(
         return arg
 
     elif is_datetime64_ns_dtype(arg):
-        if box and not isinstance(arg, (DatetimeArray, DatetimeIndex)):
+        if not isinstance(arg, (DatetimeArray, DatetimeIndex)):
             try:
                 return DatetimeIndex(arg, tz=tz, name=name)
             except ValueError:
@@ -343,28 +314,40 @@ def _convert_listlike_datetimes(
     elif unit is not None:
         if format is not None:
             raise ValueError("cannot specify both format and unit")
-        arg = getattr(arg, "values", arg)
-        result, tz_parsed = tslib.array_with_unit_to_datetime(arg, unit, errors=errors)
-        if box:
-            if errors == "ignore":
-                from pandas import Index
+        arg = getattr(arg, "_values", arg)
+
+        # GH 30050 pass an ndarray to tslib.array_with_unit_to_datetime
+        # because it expects an ndarray argument
+        if isinstance(arg, IntegerArray):
+            # Explicitly pass NaT mask to array_with_unit_to_datetime
+            mask = arg.isna()
+            arg = arg._ndarray_values
+        else:
+            mask = None
+
+        result, tz_parsed = tslib.array_with_unit_to_datetime(
+            arg, mask, unit, errors=errors
+        )
+
+        if errors == "ignore":
+            from pandas import Index
 
-                result = Index(result, name=name)
+            result = Index(result, name=name)
+        else:
+            result = DatetimeIndex(result, name=name)
+        # GH 23758: We may still need to localize the result with tz
+        # GH 25546: Apply tz_parsed first (from arg), then tz (from caller)
+        # result will be naive but in UTC
+        try:
+            result = result.tz_localize("UTC").tz_convert(tz_parsed)
+        except AttributeError:
+            # Regular Index from 'ignore' path
+            return result
+        if tz is not None:
+            if result.tz is None:
+                result = result.tz_localize(tz)
             else:
-                result = DatetimeIndex(result, name=name)
-            # GH 23758: We may still need to localize the result with tz
-            # GH 25546: Apply tz_parsed first (from arg), then tz (from caller)
-            # result will be naive but in UTC
-            try:
-                result = result.tz_localize("UTC").tz_convert(tz_parsed)
-            except AttributeError:
-                # Regular Index from 'ignore' path
-                return result
-            if tz is not None:
-                if result.tz is None:
-                    result = result.tz_localize(tz)
-                else:
-                    result = result.tz_convert(tz)
+                result = result.tz_convert(tz)
         return result
     elif getattr(arg, "ndim", 1) > 1:
         raise TypeError(
@@ -415,7 +398,7 @@ def _convert_listlike_datetimes(
                     )
                     if "%Z" in format or "%z" in format:
                         return _return_parsed_timezone_results(
-                            result, timezones, box, tz, name
+                            result, timezones, tz, name
                         )
                 except tslibs.OutOfBoundsDatetime:
                     if errors == "raise":
@@ -444,7 +427,8 @@ def _convert_listlike_datetimes(
             #  datetime objects are found without passing `utc=True`
             try:
                 values, tz = conversion.datetime_to_datetime64(arg)
-                return DatetimeIndex._simple_new(values, name=name, tz=tz)
+                dta = DatetimeArray(values, dtype=tz_to_dtype(tz))
+                return DatetimeIndex._simple_new(dta, name=name)
             except (ValueError, TypeError):
                 raise e
 
@@ -462,20 +446,13 @@ def _convert_listlike_datetimes(
         )
 
     if tz_parsed is not None:
-        if box:
-            # We can take a shortcut since the datetime64 numpy array
-            # is in UTC
-            return DatetimeIndex._simple_new(result, name=name, tz=tz_parsed)
-        else:
-            # Convert the datetime64 numpy array to an numpy array
-            # of datetime objects
-            result = [Timestamp(ts, tz=tz_parsed).to_pydatetime() for ts in result]
-            return np.array(result, dtype=object)
+        # We can take a shortcut since the datetime64 numpy array
+        # is in UTC
+        dta = DatetimeArray(result, dtype=tz_to_dtype(tz_parsed))
+        return DatetimeIndex._simple_new(dta, name=name)
 
-    if box:
-        utc = tz == "utc"
-        return _box_as_indexlike(result, utc=utc, name=name)
-    return result
+    utc = tz == "utc"
+    return _box_as_indexlike(result, utc=utc, name=name)
 
 
 def _adjust_to_origin(arg, origin, unit):
@@ -511,8 +488,7 @@ def _adjust_to_origin(arg, origin, unit):
         j_min = Timestamp.min.to_julian_date() - j0
         if np.any(arg > j_max) or np.any(arg < j_min):
             raise tslibs.OutOfBoundsDatetime(
-                "{original} is Out of Bounds for "
-                "origin='julian'".format(original=original)
+                f"{original} is Out of Bounds for origin='julian'"
             )
     else:
         # arg must be numeric
@@ -521,27 +497,20 @@ def _adjust_to_origin(arg, origin, unit):
             or is_numeric_dtype(np.asarray(arg))
         ):
             raise ValueError(
-                "'{arg}' is not compatible with origin='{origin}'; "
-                "it must be numeric with a unit specified ".format(
-                    arg=arg, origin=origin
-                )
+                f"'{arg}' is not compatible with origin='{origin}'; "
+                "it must be numeric with a unit specified"
             )
 
         # we are going to offset back to unix / epoch time
         try:
             offset = Timestamp(origin)
         except tslibs.OutOfBoundsDatetime:
-            raise tslibs.OutOfBoundsDatetime(
-                "origin {origin} is Out of Bounds".format(origin=origin)
-            )
+            raise tslibs.OutOfBoundsDatetime(f"origin {origin} is Out of Bounds")
         except ValueError:
-            raise ValueError(
-                "origin {origin} cannot be converted "
-                "to a Timestamp".format(origin=origin)
-            )
+            raise ValueError(f"origin {origin} cannot be converted to a Timestamp")
 
         if offset.tz is not None:
-            raise ValueError("origin offset {} must be tz-naive".format(offset))
+            raise ValueError(f"origin offset {offset} must be tz-naive")
         offset -= Timestamp(0)
 
         # convert the offset to the unit of the arg
@@ -557,14 +526,12 @@ def _adjust_to_origin(arg, origin, unit):
     return arg
 
 
-@deprecate_kwarg(old_arg_name="box", new_arg_name=None)
 def to_datetime(
     arg,
     errors="raise",
     dayfirst=False,
     yearfirst=False,
     utc=None,
-    box=True,
     format=None,
     exact=True,
     unit=None,
@@ -577,21 +544,19 @@ def to_datetime(
 
     Parameters
     ----------
-    arg : integer, float, string, datetime, list, tuple, 1-d array, Series
-           or DataFrame/dict-like
-
+    arg : int, float, str, datetime, list, tuple, 1-d array, Series DataFrame/dict-like
+        The object to convert to a datetime.
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
-
-        - If 'raise', then invalid parsing will raise an exception
-        - If 'coerce', then invalid parsing will be set as NaT
-        - If 'ignore', then invalid parsing will return the input
-    dayfirst : boolean, default False
+        - If 'raise', then invalid parsing will raise an exception.
+        - If 'coerce', then invalid parsing will be set as NaT.
+        - If 'ignore', then invalid parsing will return the input.
+    dayfirst : bool, default False
         Specify a date parse order if `arg` is str or its list-likes.
         If True, parses dates with the day first, eg 10/11/12 is parsed as
         2012-11-10.
         Warning: dayfirst=True is not strict, but will prefer to parse
         with day first (this is a known bug, based on dateutil behavior).
-    yearfirst : boolean, default False
+    yearfirst : bool, default False
         Specify a date parse order if `arg` is str or its list-likes.
 
         - If True parses dates with the year first, eg 10/11/12 is parsed as
@@ -601,43 +566,30 @@ def to_datetime(
 
         Warning: yearfirst=True is not strict, but will prefer to parse
         with year first (this is a known bug, based on dateutil behavior).
-
-        .. versionadded:: 0.16.1
-
-    utc : boolean, default None
+    utc : bool, default None
         Return UTC DatetimeIndex if True (converting any tz-aware
         datetime.datetime objects as well).
-    box : boolean, default True
-
-        - If True returns a DatetimeIndex or Index-like object
-        - If False returns ndarray of values.
-
-        .. deprecated:: 0.25.0
-            Use :meth:`Series.to_numpy` or :meth:`Timestamp.to_datetime64`
-            instead to get an ndarray of values or numpy.datetime64,
-            respectively.
-
-    format : string, default None
-        strftime to parse time, eg "%d/%m/%Y", note that "%f" will parse
+    format : str, default None
+        The strftime to parse time, eg "%d/%m/%Y", note that "%f" will parse
         all the way up to nanoseconds.
         See strftime documentation for more information on choices:
-        https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior
-    exact : boolean, True by default
-
+        https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.
+    exact : bool, True by default
+        Behaves as:
         - If True, require an exact format match.
         - If False, allow the format to match anywhere in the target string.
 
-    unit : string, default 'ns'
-        unit of the arg (D,s,ms,us,ns) denote the unit, which is an
+    unit : str, default 'ns'
+        The unit of the arg (D,s,ms,us,ns) denote the unit, which is an
         integer or float number. This will be based off the origin.
         Example, with unit='ms' and origin='unix' (the default), this
         would calculate the number of milliseconds to the unix epoch start.
-    infer_datetime_format : boolean, default False
+    infer_datetime_format : bool, default False
         If True and no `format` is given, attempt to infer the format of the
         datetime strings, and if it can be inferred, switch to a faster
         method of parsing them. In some cases this can increase the parsing
         speed by ~5-10x.
-    origin : scalar, default is 'unix'
+    origin : scalar, default 'unix'
         Define the reference date. The numeric values would be parsed as number
         of units (defined by `unit`) since this reference date.
 
@@ -647,21 +599,22 @@ def to_datetime(
           at noon on January 1, 4713 BC.
         - If Timestamp convertible, origin is set to Timestamp identified by
           origin.
-
-        .. versionadded:: 0.20.0
-    cache : boolean, default True
+    cache : bool, default True
         If True, use a cache of unique, converted dates to apply the datetime
         conversion. May produce significant speed-up when parsing duplicate
-        date strings, especially ones with timezone offsets.
+        date strings, especially ones with timezone offsets. The cache is only
+        used when there are at least 50 values. The presence of out-of-bounds
+        values will render the cache unusable and may slow down parsing.
 
         .. versionadded:: 0.23.0
 
         .. versionchanged:: 0.25.0
-            - changed default value from False to True
+            - changed default value from False to True.
 
     Returns
     -------
-    ret : datetime if parsing succeeded.
+    datetime
+        If parsing succeeded.
         Return type depends on input:
 
         - list-like: DatetimeIndex
@@ -677,6 +630,7 @@ def to_datetime(
     --------
     DataFrame.astype : Cast argument to a specified dtype.
     to_timedelta : Convert argument to timedelta.
+    convert_dtypes : Convert dtypes.
 
     Examples
     --------
@@ -693,7 +647,7 @@ def to_datetime(
     dtype: datetime64[ns]
 
     If a date does not meet the `timestamp limitations
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
     #timeseries-timestamp-limits>`_, passing errors='ignore'
     will return the original input instead of raising any exception.
 
@@ -717,10 +671,10 @@ def to_datetime(
     4    3/12/2000
     dtype: object
 
-    >>> %timeit pd.to_datetime(s,infer_datetime_format=True)  # doctest: +SKIP
+    >>> %timeit pd.to_datetime(s, infer_datetime_format=True)  # doctest: +SKIP
     100 loops, best of 3: 10.4 ms per loop
 
-    >>> %timeit pd.to_datetime(s,infer_datetime_format=False)  # doctest: +SKIP
+    >>> %timeit pd.to_datetime(s, infer_datetime_format=False)  # doctest: +SKIP
     1 loop, best of 3: 471 ms per loop
 
     Using a unix epoch time
@@ -770,25 +724,35 @@ def to_datetime(
         if not cache_array.empty:
             result = arg.map(cache_array)
         else:
-            values = convert_listlike(arg._values, True, format)
+            values = convert_listlike(arg._values, format)
             result = arg._constructor(values, index=arg.index, name=arg.name)
     elif isinstance(arg, (ABCDataFrame, abc.MutableMapping)):
-        result = _assemble_from_unit_mappings(arg, errors, box, tz)
+        result = _assemble_from_unit_mappings(arg, errors, tz)
     elif isinstance(arg, ABCIndexClass):
         cache_array = _maybe_cache(arg, format, cache, convert_listlike)
         if not cache_array.empty:
-            result = _convert_and_box_cache(arg, cache_array, box, name=arg.name)
+            result = _convert_and_box_cache(arg, cache_array, name=arg.name)
         else:
             convert_listlike = partial(convert_listlike, name=arg.name)
-            result = convert_listlike(arg, box, format)
+            result = convert_listlike(arg, format)
     elif is_list_like(arg):
-        cache_array = _maybe_cache(arg, format, cache, convert_listlike)
+        try:
+            cache_array = _maybe_cache(arg, format, cache, convert_listlike)
+        except tslibs.OutOfBoundsDatetime:
+            # caching attempts to create a DatetimeIndex, which may raise
+            # an OOB. If that's the desired behavior, then just reraise...
+            if errors == "raise":
+                raise
+            # ... otherwise, continue without the cache.
+            from pandas import Series
+
+            cache_array = Series([], dtype=object)  # just an empty array
         if not cache_array.empty:
-            result = _convert_and_box_cache(arg, cache_array, box)
+            result = _convert_and_box_cache(arg, cache_array)
         else:
-            result = convert_listlike(arg, box, format)
+            result = convert_listlike(arg, format)
     else:
-        result = convert_listlike(np.array([arg]), box, format)[0]
+        result = convert_listlike(np.array([arg]), format)[0]
 
     return result
 
@@ -819,7 +783,7 @@ def to_datetime(
 }
 
 
-def _assemble_from_unit_mappings(arg, errors, box, tz):
+def _assemble_from_unit_mappings(arg, errors, tz):
     """
     assemble the unit specified fields from the arg (DataFrame)
     Return a Series for actual parsing
@@ -832,10 +796,6 @@ def _assemble_from_unit_mappings(arg, errors, box, tz):
         - If 'raise', then invalid parsing will raise an exception
         - If 'coerce', then invalid parsing will be set as NaT
         - If 'ignore', then invalid parsing will return the input
-    box : boolean
-
-        - If True, return a DatetimeIndex
-        - If False, return an array
     tz : None or 'utc'
 
     Returns
@@ -864,21 +824,20 @@ def f(value):
 
     # we require at least Ymd
     required = ["year", "month", "day"]
-    req = sorted(list(set(required) - set(unit_rev.keys())))
+    req = sorted(set(required) - set(unit_rev.keys()))
     if len(req):
+        required = ",".join(req)
         raise ValueError(
             "to assemble mappings requires at least that "
-            "[year, month, day] be specified: [{required}] "
-            "is missing".format(required=",".join(req))
+            f"[year, month, day] be specified: [{required}] is missing"
         )
 
     # keys we don't recognize
-    excess = sorted(list(set(unit_rev.keys()) - set(_unit_map.values())))
+    excess = sorted(set(unit_rev.keys()) - set(_unit_map.values()))
     if len(excess):
+        excess = ",".join(excess)
         raise ValueError(
-            "extra keys have been passed "
-            "to the datetime assemblage: "
-            "[{excess}]".format(excess=",".join(excess))
+            f"extra keys have been passed to the datetime assemblage: [{excess}]"
         )
 
     def coerce(values):
@@ -897,21 +856,16 @@ def coerce(values):
     )
     try:
         values = to_datetime(values, format="%Y%m%d", errors=errors, utc=tz)
-    except (TypeError, ValueError) as e:
-        raise ValueError("cannot assemble the datetimes: {error}".format(error=e))
+    except (TypeError, ValueError) as err:
+        raise ValueError(f"cannot assemble the datetimes: {err}")
 
     for u in ["h", "m", "s", "ms", "us", "ns"]:
         value = unit_rev.get(u)
         if value is not None and value in arg:
             try:
                 values += to_timedelta(coerce(arg[value]), unit=u, errors=errors)
-            except (TypeError, ValueError) as e:
-                raise ValueError(
-                    "cannot assemble the datetimes [{value}]: "
-                    "{error}".format(value=value, error=e)
-                )
-    if not box:
-        return values.values
+            except (TypeError, ValueError) as err:
+                raise ValueError(f"cannot assemble the datetimes [{value}]: {err}")
     return values
 
 
@@ -947,21 +901,21 @@ def calc_with_mask(carg, mask):
     # try intlike / strings that are ints
     try:
         return calc(arg.astype(np.int64))
-    except (ValueError, OverflowError):
+    except (ValueError, OverflowError, TypeError):
         pass
 
     # a float with actual np.nan
     try:
         carg = arg.astype(np.float64)
         return calc_with_mask(carg, notna(carg))
-    except (ValueError, OverflowError):
+    except (ValueError, OverflowError, TypeError):
         pass
 
     # string with NaN-like
     try:
         mask = ~algorithms.isin(arg, list(tslib.nat_strings))
         return calc_with_mask(arg, mask)
-    except (ValueError, OverflowError):
+    except (ValueError, OverflowError, TypeError):
         pass
 
     return None
@@ -1046,9 +1000,9 @@ def _convert_listlike(arg, format):
                 except (ValueError, TypeError):
                     if errors == "raise":
                         msg = (
-                            "Cannot convert {element} to a time with given "
-                            "format {format}"
-                        ).format(element=element, format=format)
+                            f"Cannot convert {element} to a time with given "
+                            f"format {format}"
+                        )
                         raise ValueError(msg)
                     elif errors == "ignore":
                         return arg
@@ -1074,9 +1028,7 @@ def _convert_listlike(arg, format):
                 if time_object is not None:
                     times.append(time_object)
                 elif errors == "raise":
-                    raise ValueError(
-                        "Cannot convert arg {arg} to a time".format(arg=arg)
-                    )
+                    raise ValueError(f"Cannot convert arg {arg} to a time")
                 elif errors == "ignore":
                     return arg
                 else:
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index a0e2c8d9cab65..4939cbfc9cc96 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -36,10 +36,10 @@ def to_numeric(arg, errors="raise", downcast=None):
     ----------
     arg : scalar, list, tuple, 1-d array, or Series
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
-        - If 'raise', then invalid parsing will raise an exception
-        - If 'coerce', then invalid parsing will be set as NaN
-        - If 'ignore', then invalid parsing will return the input
-    downcast : {'integer', 'signed', 'unsigned', 'float'} , default None
+        - If 'raise', then invalid parsing will raise an exception.
+        - If 'coerce', then invalid parsing will be set as NaN.
+        - If 'ignore', then invalid parsing will return the input.
+    downcast : {'integer', 'signed', 'unsigned', 'float'}, default None
         If not None, and if the data has been successfully cast to a
         numerical dtype (or if the data was numeric to begin with),
         downcast that resulting data to the smallest numerical dtype
@@ -70,6 +70,7 @@ def to_numeric(arg, errors="raise", downcast=None):
     to_datetime : Convert argument to datetime.
     to_timedelta : Convert argument to timedelta.
     numpy.ndarray.astype : Cast a numpy array to a specified type.
+    convert_dtypes : Convert dtypes.
 
     Examples
     --------
@@ -137,21 +138,20 @@ def to_numeric(arg, errors="raise", downcast=None):
     else:
         values = arg
 
-    try:
-        if is_numeric_dtype(values):
-            pass
-        elif is_datetime_or_timedelta_dtype(values):
-            values = values.astype(np.int64)
-        else:
-            values = ensure_object(values)
-            coerce_numeric = errors not in ("ignore", "raise")
+    if is_numeric_dtype(values):
+        pass
+    elif is_datetime_or_timedelta_dtype(values):
+        values = values.astype(np.int64)
+    else:
+        values = ensure_object(values)
+        coerce_numeric = errors not in ("ignore", "raise")
+        try:
             values = lib.maybe_convert_numeric(
                 values, set(), coerce_numeric=coerce_numeric
             )
-
-    except Exception:
-        if errors == "raise":
-            raise
+        except (ValueError, TypeError):
+            if errors == "raise":
+                raise
 
     # attempt downcast only if the data has been successfully converted
     # to a numerical dtype and if a downcast method has been specified
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index cc31317980ca8..3f0cfce39f6f9 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -2,13 +2,10 @@
 timedelta support tools
 """
 
-import warnings
-
 import numpy as np
 
 from pandas._libs.tslibs import NaT
 from pandas._libs.tslibs.timedeltas import Timedelta, parse_timedelta_unit
-from pandas.util._decorators import deprecate_kwarg
 
 from pandas.core.dtypes.common import is_list_like
 from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
@@ -16,8 +13,7 @@
 from pandas.core.arrays.timedeltas import sequence_to_td64ns
 
 
-@deprecate_kwarg(old_arg_name="box", new_arg_name=None)
-def to_timedelta(arg, unit="ns", box=True, errors="raise"):
+def to_timedelta(arg, unit="ns", errors="raise"):
     """
     Convert argument to timedelta.
 
@@ -38,15 +34,6 @@ def to_timedelta(arg, unit="ns", box=True, errors="raise"):
         'milli', 'millis', 'L', 'us', 'microseconds', 'microsecond',
         'micro', 'micros', 'U', 'ns', 'nanoseconds', 'nano', 'nanos',
         'nanosecond', 'N').
-    box : bool, default True
-        - If True returns a Timedelta/TimedeltaIndex of the results.
-        - If False returns a numpy.timedelta64 or numpy.darray of
-          values of dtype timedelta64[ns].
-
-        .. deprecated:: 0.25.0
-            Use :meth:`Series.to_numpy` or :meth:`Timedelta.to_timedelta64`
-            instead to get an ndarray of values or numpy.timedelta64,
-            respectively.
 
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
         - If 'raise', then invalid parsing will raise an exception.
@@ -62,6 +49,7 @@ def to_timedelta(arg, unit="ns", box=True, errors="raise"):
     --------
     DataFrame.astype : Cast argument to a specified dtype.
     to_datetime : Convert argument to datetime.
+    convert_dtypes : Convert dtypes.
 
     Examples
     --------
@@ -88,11 +76,6 @@ def to_timedelta(arg, unit="ns", box=True, errors="raise"):
     >>> pd.to_timedelta(np.arange(5), unit='d')
     TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
                    dtype='timedelta64[ns]', freq=None)
-
-    Returning an ndarray by using the 'box' keyword argument:
-
-    >>> pd.to_timedelta(np.arange(5), box=False)
-    array([0, 1, 2, 3, 4], dtype='timedelta64[ns]')
     """
     unit = parse_timedelta_unit(unit)
 
@@ -100,41 +83,37 @@ def to_timedelta(arg, unit="ns", box=True, errors="raise"):
         raise ValueError("errors must be one of 'ignore', 'raise', or 'coerce'}")
 
     if unit in {"Y", "y", "M"}:
-        warnings.warn(
-            "M and Y units are deprecated and will be removed in a future version.",
-            FutureWarning,
-            stacklevel=2,
+        raise ValueError(
+            "Units 'M' and 'Y' are no longer supported, as they do not "
+            "represent unambiguous timedelta values durations."
         )
 
     if arg is None:
         return arg
     elif isinstance(arg, ABCSeries):
-        values = _convert_listlike(arg._values, unit=unit, box=False, errors=errors)
+        values = _convert_listlike(arg._values, unit=unit, errors=errors)
         return arg._constructor(values, index=arg.index, name=arg.name)
     elif isinstance(arg, ABCIndexClass):
-        return _convert_listlike(arg, unit=unit, box=box, errors=errors, name=arg.name)
+        return _convert_listlike(arg, unit=unit, errors=errors, name=arg.name)
     elif isinstance(arg, np.ndarray) and arg.ndim == 0:
         # extract array scalar and process below
         arg = arg.item()
     elif is_list_like(arg) and getattr(arg, "ndim", 1) == 1:
-        return _convert_listlike(arg, unit=unit, box=box, errors=errors)
+        return _convert_listlike(arg, unit=unit, errors=errors)
     elif getattr(arg, "ndim", 1) > 1:
         raise TypeError(
             "arg must be a string, timedelta, list, tuple, 1-d array, or Series"
         )
 
     # ...so it must be a scalar value. Return scalar.
-    return _coerce_scalar_to_timedelta_type(arg, unit=unit, box=box, errors=errors)
+    return _coerce_scalar_to_timedelta_type(arg, unit=unit, errors=errors)
 
 
-def _coerce_scalar_to_timedelta_type(r, unit="ns", box=True, errors="raise"):
+def _coerce_scalar_to_timedelta_type(r, unit="ns", errors="raise"):
     """Convert string 'r' to a timedelta object."""
 
     try:
         result = Timedelta(r, unit)
-        if not box:
-            # explicitly view as timedelta64 for case when result is pd.NaT
-            result = result.asm8.view("timedelta64[ns]")
     except ValueError:
         if errors == "raise":
             raise
@@ -147,7 +126,7 @@ def _coerce_scalar_to_timedelta_type(r, unit="ns", box=True, errors="raise"):
     return result
 
 
-def _convert_listlike(arg, unit="ns", box=True, errors="raise", name=None):
+def _convert_listlike(arg, unit="ns", errors="raise", name=None):
     """Convert a list of objects to a timedelta index object."""
 
     if isinstance(arg, (list, tuple)) or not hasattr(arg, "dtype"):
@@ -172,8 +151,7 @@ def _convert_listlike(arg, unit="ns", box=True, errors="raise", name=None):
             # like to surface it.
             raise
 
-    if box:
-        from pandas import TimedeltaIndex
+    from pandas import TimedeltaIndex
 
-        value = TimedeltaIndex(value, unit="ns", name=name)
+    value = TimedeltaIndex(value, unit="ns", name=name)
     return value
diff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py
index bcdbf0855cbb4..3366f10b92604 100644
--- a/pandas/core/util/hashing.py
+++ b/pandas/core/util/hashing.py
@@ -2,11 +2,12 @@
 data hash pandas / numpy objects
 """
 import itertools
+from typing import Optional
 
 import numpy as np
 
+from pandas._libs import Timestamp
 import pandas._libs.hashing as hashing
-import pandas._libs.tslibs as tslibs
 
 from pandas.core.dtypes.cast import infer_dtype_from_scalar
 from pandas.core.dtypes.common import (
@@ -26,7 +27,7 @@
 _default_hash_key = "0123456789123456"
 
 
-def _combine_hash_arrays(arrays, num_items):
+def _combine_hash_arrays(arrays, num_items: int):
     """
     Parameters
     ----------
@@ -55,24 +56,27 @@ def _combine_hash_arrays(arrays, num_items):
 
 
 def hash_pandas_object(
-    obj, index=True, encoding="utf8", hash_key=None, categorize=True
+    obj,
+    index: bool = True,
+    encoding: str = "utf8",
+    hash_key: Optional[str] = _default_hash_key,
+    categorize: bool = True,
 ):
     """
     Return a data hash of the Index/Series/DataFrame.
 
     Parameters
     ----------
-    index : boolean, default True
-        include the index in the hash (if Series/DataFrame)
-    encoding : string, default 'utf8'
-        encoding for data & key when strings
-    hash_key : string key to encode, default to _default_hash_key
+    index : bool, default True
+        Include the index in the hash (if Series/DataFrame).
+    encoding : str, default 'utf8'
+        Encoding for data & key when strings.
+    hash_key : str, default _default_hash_key
+        Hash_key for string key to encode.
     categorize : bool, default True
         Whether to first categorize object arrays before hashing. This is more
         efficient when the array contains duplicate values.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
     Series of uint64, same length as the object
@@ -85,11 +89,12 @@ def hash_pandas_object(
     if isinstance(obj, ABCMultiIndex):
         return Series(hash_tuples(obj, encoding, hash_key), dtype="uint64", copy=False)
 
-    if isinstance(obj, ABCIndexClass):
+    elif isinstance(obj, ABCIndexClass):
         h = hash_array(obj.values, encoding, hash_key, categorize).astype(
             "uint64", copy=False
         )
         h = Series(h, index=obj, dtype="uint64", copy=False)
+
     elif isinstance(obj, ABCSeries):
         h = hash_array(obj.values, encoding, hash_key, categorize).astype(
             "uint64", copy=False
@@ -125,26 +130,27 @@ def hash_pandas_object(
                 for _ in [None]
             )
             num_items += 1
-            hashes = itertools.chain(hashes, index_hash_generator)
+
+            # keep `hashes` specifically a generator to keep mypy happy
+            _hashes = itertools.chain(hashes, index_hash_generator)
+            hashes = (x for x in _hashes)
         h = _combine_hash_arrays(hashes, num_items)
 
         h = Series(h, index=obj.index, dtype="uint64", copy=False)
     else:
-        raise TypeError("Unexpected type for hashing %s" % type(obj))
+        raise TypeError(f"Unexpected type for hashing {type(obj)}")
     return h
 
 
-def hash_tuples(vals, encoding="utf8", hash_key=None):
+def hash_tuples(vals, encoding="utf8", hash_key: str = _default_hash_key):
     """
     Hash an MultiIndex / list-of-tuples efficiently
 
-    .. versionadded:: 0.20.0
-
     Parameters
     ----------
     vals : MultiIndex, list-of-tuples, or single tuple
-    encoding : string, default 'utf8'
-    hash_key : string key to encode, default to _default_hash_key
+    encoding : str, default 'utf8'
+    hash_key : str, default _default_hash_key
 
     Returns
     -------
@@ -179,15 +185,15 @@ def hash_tuples(vals, encoding="utf8", hash_key=None):
     return h
 
 
-def hash_tuple(val, encoding="utf8", hash_key=None):
+def hash_tuple(val, encoding: str = "utf8", hash_key: str = _default_hash_key):
     """
     Hash a single tuple efficiently
 
     Parameters
     ----------
     val : single tuple
-    encoding : string, default 'utf8'
-    hash_key : string key to encode, default to _default_hash_key
+    encoding : str, default 'utf8'
+    hash_key : str, default _default_hash_key
 
     Returns
     -------
@@ -201,7 +207,7 @@ def hash_tuple(val, encoding="utf8", hash_key=None):
     return h
 
 
-def _hash_categorical(c, encoding, hash_key):
+def _hash_categorical(c, encoding: str, hash_key: str):
     """
     Hash a Categorical by hashing its categories, and then mapping the codes
     to the hashes
@@ -209,8 +215,8 @@ def _hash_categorical(c, encoding, hash_key):
     Parameters
     ----------
     c : Categorical
-    encoding : string, default 'utf8'
-    hash_key : string key to encode, default to _default_hash_key
+    encoding : str
+    hash_key : str
 
     Returns
     -------
@@ -239,22 +245,26 @@ def _hash_categorical(c, encoding, hash_key):
     return result
 
 
-def hash_array(vals, encoding="utf8", hash_key=None, categorize=True):
+def hash_array(
+    vals,
+    encoding: str = "utf8",
+    hash_key: str = _default_hash_key,
+    categorize: bool = True,
+):
     """
     Given a 1d array, return an array of deterministic integers.
 
     Parameters
     ----------
     vals : ndarray, Categorical
-    encoding : string, default 'utf8'
-        encoding for data & key when strings
-    hash_key : string key to encode, default to _default_hash_key
+    encoding : str, default 'utf8'
+        Encoding for data & key when strings.
+    hash_key : str, default _default_hash_key
+        Hash_key for string key to encode.
     categorize : bool, default True
         Whether to first categorize object arrays before hashing. This is more
         efficient when the array contains duplicate values.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
     1d uint64 numpy array of hash values, same length as the vals
@@ -264,9 +274,6 @@ def hash_array(vals, encoding="utf8", hash_key=None, categorize=True):
         raise TypeError("must pass a ndarray-like")
     dtype = vals.dtype
 
-    if hash_key is None:
-        hash_key = _default_hash_key
-
     # For categoricals, we hash the categories, then remap the codes to the
     # hash values. (This check is above the complex check so that we don't ask
     # numpy if categorical is a subdtype of complex, as it will choke).
@@ -317,9 +324,17 @@ def hash_array(vals, encoding="utf8", hash_key=None, categorize=True):
     return vals
 
 
-def _hash_scalar(val, encoding="utf8", hash_key=None):
+def _hash_scalar(
+    val, encoding: str = "utf8", hash_key: str = _default_hash_key
+) -> np.ndarray:
     """
-    Hash scalar value
+    Hash scalar value.
+
+    Parameters
+    ----------
+    val : scalar
+    encoding : str, default "utf8"
+    hash_key : str, default _default_hash_key
 
     Returns
     -------
@@ -334,8 +349,8 @@ def _hash_scalar(val, encoding="utf8", hash_key=None):
         # for tz-aware datetimes, we need the underlying naive UTC value and
         # not the tz aware object or pd extension type (as
         # infer_dtype_from_scalar would do)
-        if not isinstance(val, tslibs.Timestamp):
-            val = tslibs.Timestamp(val)
+        if not isinstance(val, Timestamp):
+            val = Timestamp(val)
         val = val.tz_convert(None)
 
     dtype, val = infer_dtype_from_scalar(val)
diff --git a/pandas/core/window/common.py b/pandas/core/window/common.py
index 0f2920b3558c9..ed0b816f64800 100644
--- a/pandas/core/window/common.py
+++ b/pandas/core/window/common.py
@@ -1,5 +1,6 @@
 """Common utility functions for rolling operations"""
 from collections import defaultdict
+from typing import Callable, Optional
 import warnings
 
 import numpy as np
@@ -10,7 +11,7 @@
 import pandas.core.common as com
 from pandas.core.generic import _shared_docs
 from pandas.core.groupby.base import GroupByMixin
-from pandas.core.index import MultiIndex
+from pandas.core.indexes.api import MultiIndex
 
 _shared_docs = dict(**_shared_docs)
 _doc_template = """
@@ -26,13 +27,29 @@
 """
 
 
-class _GroupByMixin(GroupByMixin):
+def _dispatch(name: str, *args, **kwargs):
+    """
+    Dispatch to apply.
+    """
+
+    def outer(self, *args, **kwargs):
+        def f(x):
+            x = self._shallow_copy(x, groupby=self._groupby)
+            return getattr(x, name)(*args, **kwargs)
+
+        return self._groupby.apply(f)
+
+    outer.__name__ = name
+    return outer
+
+
+class WindowGroupByMixin(GroupByMixin):
     """
     Provide the groupby facilities.
     """
 
     def __init__(self, obj, *args, **kwargs):
-        parent = kwargs.pop("parent", None)  # noqa
+        kwargs.pop("parent", None)
         groupby = kwargs.pop("groupby", None)
         if groupby is None:
             groupby, obj = obj, obj.obj
@@ -41,18 +58,28 @@ def __init__(self, obj, *args, **kwargs):
         self._groupby.grouper.mutated = True
         super().__init__(obj, *args, **kwargs)
 
-    count = GroupByMixin._dispatch("count")
-    corr = GroupByMixin._dispatch("corr", other=None, pairwise=None)
-    cov = GroupByMixin._dispatch("cov", other=None, pairwise=None)
+    count = _dispatch("count")
+    corr = _dispatch("corr", other=None, pairwise=None)
+    cov = _dispatch("cov", other=None, pairwise=None)
 
     def _apply(
-        self, func, name=None, window=None, center=None, check_minp=None, **kwargs
+        self,
+        func: Callable,
+        center: bool,
+        require_min_periods: int = 0,
+        floor: int = 1,
+        is_weighted: bool = False,
+        name: Optional[str] = None,
+        use_numba_cache: bool = False,
+        **kwargs,
     ):
         """
         Dispatch to apply; we are stripping all of the _apply kwargs and
         performing the original function call on the grouped object.
         """
+        kwargs.pop("floor", None)
 
+        # TODO: can we de-duplicate with _dispatch?
         def f(x, name=name, *args):
             x = self._shallow_copy(x)
 
@@ -71,14 +98,13 @@ def _flex_binary_moment(arg1, arg2, f, pairwise=False):
         and isinstance(arg2, (np.ndarray, ABCSeries, ABCDataFrame))
     ):
         raise TypeError(
-            "arguments to moment function must be of type "
-            "np.ndarray/Series/DataFrame"
+            "arguments to moment function must be of type np.ndarray/Series/DataFrame"
         )
 
     if isinstance(arg1, (np.ndarray, ABCSeries)) and isinstance(
         arg2, (np.ndarray, ABCSeries)
     ):
-        X, Y = _prep_binary(arg1, arg2)
+        X, Y = prep_binary(arg1, arg2)
         return f(X, Y)
 
     elif isinstance(arg1, ABCDataFrame):
@@ -125,7 +151,7 @@ def dataframe_from_int_dict(data, frame_template):
                             results[i][j] = results[j][i]
                         else:
                             results[i][j] = f(
-                                *_prep_binary(arg1.iloc[:, i], arg2.iloc[:, j])
+                                *prep_binary(arg1.iloc[:, i], arg2.iloc[:, j])
                             )
 
                 from pandas import concat
@@ -186,7 +212,7 @@ def dataframe_from_int_dict(data, frame_template):
                 raise ValueError("'pairwise' is not True/False")
         else:
             results = {
-                i: f(*_prep_binary(arg1.iloc[:, i], arg2))
+                i: f(*prep_binary(arg1.iloc[:, i], arg2))
                 for i, col in enumerate(arg1.columns)
             }
             return dataframe_from_int_dict(results, arg1)
@@ -223,34 +249,48 @@ def _get_center_of_mass(comass, span, halflife, alpha):
     return float(comass)
 
 
-def _offset(window, center):
+def calculate_center_offset(window):
     if not is_integer(window):
         window = len(window)
-    offset = (window - 1) / 2.0 if center else 0
-    try:
-        return int(offset)
-    except TypeError:
-        return offset.astype(int)
+    return int((window - 1) / 2.0)
 
 
-def _require_min_periods(p):
-    def _check_func(minp, window):
-        if minp is None:
-            return window
-        else:
-            return max(p, minp)
-
-    return _check_func
-
-
-def _use_window(minp, window):
-    if minp is None:
-        return window
+def calculate_min_periods(
+    window: int,
+    min_periods: Optional[int],
+    num_values: int,
+    required_min_periods: int,
+    floor: int,
+) -> int:
+    """
+    Calculates final minimum periods value for rolling aggregations.
+
+    Parameters
+    ----------
+    window : passed window value
+    min_periods : passed min periods value
+    num_values : total number of values
+    required_min_periods : required min periods per aggregation function
+    floor : required min periods per aggregation function
+
+    Returns
+    -------
+    min_periods : int
+    """
+    if min_periods is None:
+        min_periods = window
     else:
-        return minp
+        min_periods = max(required_min_periods, min_periods)
+    if min_periods > window:
+        raise ValueError(f"min_periods {min_periods} must be <= window {window}")
+    elif min_periods > num_values:
+        min_periods = num_values + 1
+    elif min_periods < 0:
+        raise ValueError("min_periods must be >= 0")
+    return max(min_periods, floor)
 
 
-def _zsqrt(x):
+def zsqrt(x):
     with np.errstate(all="ignore"):
         result = np.sqrt(x)
         mask = x < 0
@@ -265,7 +305,7 @@ def _zsqrt(x):
     return result
 
 
-def _prep_binary(arg1, arg2):
+def prep_binary(arg1, arg2):
     if not isinstance(arg2, type(arg1)):
         raise Exception("Input arrays must be of the same type!")
 
@@ -274,3 +314,12 @@ def _prep_binary(arg1, arg2):
     Y = arg2 + 0 * arg1
 
     return X, Y
+
+
+def get_weighted_roll_func(cfunc: Callable) -> Callable:
+    def func(arg, window, min_periods=None):
+        if min_periods is None:
+            min_periods = len(window)
+        return cfunc(arg, window, min_periods)
+
+    return func
diff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py
index 40e6c679ba72d..6da8b0c5ccadd 100644
--- a/pandas/core/window/ewm.py
+++ b/pandas/core/window/ewm.py
@@ -2,15 +2,20 @@
 
 import numpy as np
 
-import pandas._libs.window as libwindow
+import pandas._libs.window.aggregations as window_aggregations
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender, Substitution
 
 from pandas.core.dtypes.generic import ABCDataFrame
 
 from pandas.core.base import DataError
-from pandas.core.window.common import _doc_template, _get_center_of_mass, _shared_docs
-from pandas.core.window.rolling import _flex_binary_moment, _Rolling, _zsqrt
+from pandas.core.window.common import (
+    _doc_template,
+    _get_center_of_mass,
+    _shared_docs,
+    zsqrt,
+)
+from pandas.core.window.rolling import _flex_binary_moment, _Rolling
 
 _bias_template = """
         Parameters
@@ -21,25 +26,6 @@
             Arguments and keyword arguments to be passed into func.
 """
 
-_pairwise_template = """
-        Parameters
-        ----------
-        other : Series, DataFrame, or ndarray, optional
-            If not supplied then will default to self and produce pairwise
-            output.
-        pairwise : bool, default None
-            If False then only matching columns between self and other will be
-            used and the output will be a DataFrame.
-            If True then all pairwise combinations will be calculated and the
-            output will be a MultiIndex DataFrame in the case of DataFrame
-            inputs. In the case of missing elements, only complete pairwise
-            observations will be used.
-        bias : bool, default False
-           Use a standard estimation bias correction.
-        **kwargs
-           Keyword arguments to be passed into func.
-"""
-
 
 class EWM(_Rolling):
     r"""
@@ -108,7 +94,7 @@ class EWM(_Rolling):
     (if adjust is True), and 1-alpha and alpha (if adjust is False).
 
     More details can be found at
-    http://pandas.pydata.org/pandas-docs/stable/user_guide/computation.html#exponentially-weighted-windows
+    https://pandas.pydata.org/pandas-docs/stable/user_guide/computation.html#exponentially-weighted-windows
 
     Examples
     --------
@@ -130,6 +116,7 @@ class EWM(_Rolling):
     3  1.615385
     4  3.670213
     """
+
     _attributes = ["com", "min_periods", "adjust", "ignore_na", "axis"]
 
     def __init__(
@@ -247,11 +234,10 @@ def _apply(self, func, **kwargs):
 
             # if we have a string function name, wrap it
             if isinstance(func, str):
-                cfunc = getattr(libwindow, func, None)
+                cfunc = getattr(window_aggregations, func, None)
                 if cfunc is None:
                     raise ValueError(
-                        "we do not support this function "
-                        "in libwindow.{func}".format(func=func)
+                        f"we do not support this function in window_aggregations.{func}"
                     )
 
                 def func(arg):
@@ -289,7 +275,7 @@ def std(self, bias=False, *args, **kwargs):
         Exponential weighted moving stddev.
         """
         nv.validate_window_func("std", args, kwargs)
-        return _zsqrt(self.var(bias=bias, **kwargs))
+        return zsqrt(self.var(bias=bias, **kwargs))
 
     vol = std
 
@@ -303,7 +289,7 @@ def var(self, bias=False, *args, **kwargs):
         nv.validate_window_func("var", args, kwargs)
 
         def f(arg):
-            return libwindow.ewmcov(
+            return window_aggregations.ewmcov(
                 arg,
                 arg,
                 self.com,
@@ -317,10 +303,26 @@ def f(arg):
 
     @Substitution(name="ewm")
     @Appender(_doc_template)
-    @Appender(_pairwise_template)
     def cov(self, other=None, pairwise=None, bias=False, **kwargs):
         """
         Exponential weighted sample covariance.
+
+        Parameters
+        ----------
+        other : Series, DataFrame, or ndarray, optional
+            If not supplied then will default to self and produce pairwise
+            output.
+        pairwise : bool, default None
+            If False then only matching columns between self and other will be
+            used and the output will be a DataFrame.
+            If True then all pairwise combinations will be calculated and the
+            output will be a MultiIndex DataFrame in the case of DataFrame
+            inputs. In the case of missing elements, only complete pairwise
+            observations will be used.
+        bias : bool, default False
+            Use a standard estimation bias correction.
+        **kwargs
+           Keyword arguments to be passed into func.
         """
         if other is None:
             other = self._selected_obj
@@ -331,7 +333,7 @@ def cov(self, other=None, pairwise=None, bias=False, **kwargs):
         def _get_cov(X, Y):
             X = self._shallow_copy(X)
             Y = self._shallow_copy(Y)
-            cov = libwindow.ewmcov(
+            cov = window_aggregations.ewmcov(
                 X._prep_values(),
                 Y._prep_values(),
                 self.com,
@@ -348,10 +350,24 @@ def _get_cov(X, Y):
 
     @Substitution(name="ewm")
     @Appender(_doc_template)
-    @Appender(_pairwise_template)
     def corr(self, other=None, pairwise=None, **kwargs):
         """
         Exponential weighted sample correlation.
+
+        Parameters
+        ----------
+        other : Series, DataFrame, or ndarray, optional
+            If not supplied then will default to self and produce pairwise
+            output.
+        pairwise : bool, default None
+            If False then only matching columns between self and other will be
+            used and the output will be a DataFrame.
+            If True then all pairwise combinations will be calculated and the
+            output will be a MultiIndex DataFrame in the case of DataFrame
+            inputs. In the case of missing elements, only complete pairwise
+            observations will be used.
+        **kwargs
+           Keyword arguments to be passed into func.
         """
         if other is None:
             other = self._selected_obj
@@ -364,7 +380,7 @@ def _get_corr(X, Y):
             Y = self._shallow_copy(Y)
 
             def _cov(x, y):
-                return libwindow.ewmcov(
+                return window_aggregations.ewmcov(
                     x,
                     y,
                     self.com,
@@ -380,7 +396,7 @@ def _cov(x, y):
                 cov = _cov(x_values, y_values)
                 x_var = _cov(x_values, x_values)
                 y_var = _cov(y_values, y_values)
-                corr = cov / _zsqrt(x_var * y_var)
+                corr = cov / zsqrt(x_var * y_var)
             return X._wrap_result(corr)
 
         return _flex_binary_moment(
diff --git a/pandas/core/window/expanding.py b/pandas/core/window/expanding.py
index 47bd8f2ec593b..a0bf3376d2352 100644
--- a/pandas/core/window/expanding.py
+++ b/pandas/core/window/expanding.py
@@ -1,9 +1,10 @@
 from textwrap import dedent
+from typing import Dict, Optional
 
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender, Substitution
 
-from pandas.core.window.common import _doc_template, _GroupByMixin, _shared_docs
+from pandas.core.window.common import WindowGroupByMixin, _doc_template, _shared_docs
 from pandas.core.window.rolling import _Rolling_and_Expanding
 
 
@@ -148,8 +149,23 @@ def count(self, **kwargs):
 
     @Substitution(name="expanding")
     @Appender(_shared_docs["apply"])
-    def apply(self, func, raw=None, args=(), kwargs={}):
-        return super().apply(func, raw=raw, args=args, kwargs=kwargs)
+    def apply(
+        self,
+        func,
+        raw: bool = False,
+        engine: str = "cython",
+        engine_kwargs: Optional[Dict[str, bool]] = None,
+        args=None,
+        kwargs=None,
+    ):
+        return super().apply(
+            func,
+            raw=raw,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            args=args,
+            kwargs=kwargs,
+        )
 
     @Substitution(name="expanding")
     @Appender(_shared_docs["sum"])
@@ -181,13 +197,13 @@ def mean(self, *args, **kwargs):
     def median(self, **kwargs):
         return super().median(**kwargs)
 
-    @Substitution(name="expanding")
+    @Substitution(name="expanding", versionadded="")
     @Appender(_shared_docs["std"])
     def std(self, ddof=1, *args, **kwargs):
         nv.validate_expanding_func("std", args, kwargs)
         return super().std(ddof=ddof, **kwargs)
 
-    @Substitution(name="expanding")
+    @Substitution(name="expanding", versionadded="")
     @Appender(_shared_docs["var"])
     def var(self, ddof=1, *args, **kwargs):
         nv.validate_expanding_func("var", args, kwargs)
@@ -209,10 +225,9 @@ def skew(self, **kwargs):
 
     >>> arr = [1, 2, 3, 4, 999]
     >>> import scipy.stats
-    >>> fmt = "{0:.6f}"  # limit the printed precision to 6 digits
-    >>> print(fmt.format(scipy.stats.kurtosis(arr[:-1], bias=False)))
+    >>> print(f"{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}")
     -1.200000
-    >>> print(fmt.format(scipy.stats.kurtosis(arr, bias=False)))
+    >>> print(f"{scipy.stats.kurtosis(arr, bias=False):.6f}")
     4.999874
     >>> s = pd.Series(arr)
     >>> s.expanding(4).kurt()
@@ -250,7 +265,7 @@ def corr(self, other=None, pairwise=None, **kwargs):
         return super().corr(other=other, pairwise=pairwise, **kwargs)
 
 
-class ExpandingGroupby(_GroupByMixin, Expanding):
+class ExpandingGroupby(WindowGroupByMixin, Expanding):
     """
     Provide a expanding groupby implementation.
     """
diff --git a/pandas/core/window/indexers.py b/pandas/core/window/indexers.py
new file mode 100644
index 0000000000000..921cdb3c2523f
--- /dev/null
+++ b/pandas/core/window/indexers.py
@@ -0,0 +1,122 @@
+"""Indexer objects for computing start/end window bounds for rolling operations"""
+from typing import Optional, Tuple
+
+import numpy as np
+
+from pandas._libs.window.indexers import calculate_variable_window_bounds
+from pandas.util._decorators import Appender
+
+get_window_bounds_doc = """
+Computes the bounds of a window.
+
+Parameters
+----------
+num_values : int, default 0
+    number of values that will be aggregated over
+window_size : int, default 0
+    the number of rows in a window
+min_periods : int, default None
+    min_periods passed from the top level rolling API
+center : bool, default None
+    center passed from the top level rolling API
+closed : str, default None
+    closed passed from the top level rolling API
+win_type : str, default None
+    win_type passed from the top level rolling API
+
+Returns
+-------
+A tuple of ndarray[int64]s, indicating the boundaries of each
+window
+"""
+
+
+class BaseIndexer:
+    """Base class for window bounds calculations."""
+
+    def __init__(
+        self, index_array: Optional[np.ndarray] = None, window_size: int = 0, **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        **kwargs :
+            keyword arguments that will be available when get_window_bounds is called
+        """
+        self.index_array = index_array
+        self.window_size = window_size
+        # Set user defined kwargs as attributes that can be used in get_window_bounds
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(
+        self,
+        num_values: int = 0,
+        min_periods: Optional[int] = None,
+        center: Optional[bool] = None,
+        closed: Optional[str] = None,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+
+        raise NotImplementedError
+
+
+class FixedWindowIndexer(BaseIndexer):
+    """Creates window boundaries that are of fixed length."""
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(
+        self,
+        num_values: int = 0,
+        min_periods: Optional[int] = None,
+        center: Optional[bool] = None,
+        closed: Optional[str] = None,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+
+        start_s = np.zeros(self.window_size, dtype="int64")
+        start_e = (
+            np.arange(self.window_size, num_values, dtype="int64")
+            - self.window_size
+            + 1
+        )
+        start = np.concatenate([start_s, start_e])[:num_values]
+
+        end_s = np.arange(self.window_size, dtype="int64") + 1
+        end_e = start_e + self.window_size
+        end = np.concatenate([end_s, end_e])[:num_values]
+        return start, end
+
+
+class VariableWindowIndexer(BaseIndexer):
+    """Creates window boundaries that are of variable length, namely for time series."""
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(
+        self,
+        num_values: int = 0,
+        min_periods: Optional[int] = None,
+        center: Optional[bool] = None,
+        closed: Optional[str] = None,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+
+        return calculate_variable_window_bounds(
+            num_values, self.window_size, min_periods, center, closed, self.index_array,
+        )
+
+
+class ExpandingIndexer(BaseIndexer):
+    """Calculate expanding window bounds, mimicking df.expanding()"""
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(
+        self,
+        num_values: int = 0,
+        min_periods: Optional[int] = None,
+        center: Optional[bool] = None,
+        closed: Optional[str] = None,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+
+        return (
+            np.zeros(num_values, dtype=np.int64),
+            np.arange(1, num_values + 1, dtype=np.int64),
+        )
diff --git a/pandas/core/window/numba_.py b/pandas/core/window/numba_.py
new file mode 100644
index 0000000000000..127957943d2ff
--- /dev/null
+++ b/pandas/core/window/numba_.py
@@ -0,0 +1,127 @@
+import types
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import numpy as np
+
+from pandas._typing import Scalar
+from pandas.compat._optional import import_optional_dependency
+
+
+def make_rolling_apply(
+    func: Callable[..., Scalar],
+    args: Tuple,
+    nogil: bool,
+    parallel: bool,
+    nopython: bool,
+):
+    """
+    Creates a JITted rolling apply function with a JITted version of
+    the user's function.
+
+    Parameters
+    ----------
+    func : function
+        function to be applied to each window and will be JITed
+    args : tuple
+        *args to be passed into the function
+    nogil : bool
+        nogil parameter from engine_kwargs for numba.jit
+    parallel : bool
+        parallel parameter from engine_kwargs for numba.jit
+    nopython : bool
+        nopython parameter from engine_kwargs for numba.jit
+
+    Returns
+    -------
+    Numba function
+    """
+    numba = import_optional_dependency("numba")
+
+    if parallel:
+        loop_range = numba.prange
+    else:
+        loop_range = range
+
+    if isinstance(func, numba.targets.registry.CPUDispatcher):
+        # Don't jit a user passed jitted function
+        numba_func = func
+    else:
+
+        @numba.generated_jit(nopython=nopython, nogil=nogil, parallel=parallel)
+        def numba_func(window, *_args):
+            if getattr(np, func.__name__, False) is func or isinstance(
+                func, types.BuiltinFunctionType
+            ):
+                jf = func
+            else:
+                jf = numba.jit(func, nopython=nopython, nogil=nogil)
+
+            def impl(window, *_args):
+                return jf(window, *_args)
+
+            return impl
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def roll_apply(
+        values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int,
+    ) -> np.ndarray:
+        result = np.empty(len(begin))
+        for i in loop_range(len(result)):
+            start = begin[i]
+            stop = end[i]
+            window = values[start:stop]
+            count_nan = np.sum(np.isnan(window))
+            if len(window) - count_nan >= minimum_periods:
+                result[i] = numba_func(window, *args)
+            else:
+                result[i] = np.nan
+        return result
+
+    return roll_apply
+
+
+def generate_numba_apply_func(
+    args: Tuple,
+    kwargs: Dict[str, Any],
+    func: Callable[..., Scalar],
+    engine_kwargs: Optional[Dict[str, bool]],
+):
+    """
+    Generate a numba jitted apply function specified by values from engine_kwargs.
+
+    1. jit the user's function
+    2. Return a rolling apply function with the jitted function inline
+
+    Configurations specified in engine_kwargs apply to both the user's
+    function _AND_ the rolling apply function.
+
+    Parameters
+    ----------
+    args : tuple
+        *args to be passed into the function
+    kwargs : dict
+        **kwargs to be passed into the function
+    func : function
+        function to be applied to each window and will be JITed
+    engine_kwargs : dict
+        dictionary of arguments to be passed into numba.jit
+
+    Returns
+    -------
+    Numba function
+    """
+
+    if engine_kwargs is None:
+        engine_kwargs = {}
+
+    nopython = engine_kwargs.get("nopython", True)
+    nogil = engine_kwargs.get("nogil", False)
+    parallel = engine_kwargs.get("parallel", False)
+
+    if kwargs and nopython:
+        raise ValueError(
+            "numba does not support kwargs with nopython=True: "
+            "https://github.com/numba/numba/issues/2916"
+        )
+
+    return make_rolling_apply(func, args, nogil, parallel, nopython)
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 29ef2e917ae57..5c18796deb07a 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -3,13 +3,15 @@
 similar to how we have a Groupby object.
 """
 from datetime import timedelta
+from functools import partial
+import inspect
 from textwrap import dedent
-from typing import Callable, List, Optional, Set, Union
-import warnings
+from typing import Callable, Dict, List, Optional, Set, Tuple, Union
 
 import numpy as np
 
-import pandas._libs.window as libwindow
+import pandas._libs.window.aggregations as window_aggregations
+from pandas._typing import Axis, FrameOrSeries, Scalar
 from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender, Substitution, cache_readonly
@@ -22,7 +24,6 @@
     is_integer_dtype,
     is_list_like,
     is_scalar,
-    is_timedelta64_dtype,
     needs_i8_conversion,
 )
 from pandas.core.dtypes.generic import (
@@ -34,24 +35,29 @@
     ABCTimedeltaIndex,
 )
 
-from pandas._typing import Axis, FrameOrSeries, Scalar
-from pandas.core.base import DataError, PandasObject, SelectionMixin
+from pandas.core.base import DataError, PandasObject, SelectionMixin, ShallowMixin
 import pandas.core.common as com
-from pandas.core.index import Index, ensure_index
+from pandas.core.indexes.api import Index, ensure_index
 from pandas.core.window.common import (
+    WindowGroupByMixin,
     _doc_template,
     _flex_binary_moment,
-    _GroupByMixin,
-    _offset,
-    _require_min_periods,
     _shared_docs,
-    _use_window,
-    _zsqrt,
+    calculate_center_offset,
+    calculate_min_periods,
+    get_weighted_roll_func,
+    zsqrt,
+)
+from pandas.core.window.indexers import (
+    BaseIndexer,
+    FixedWindowIndexer,
+    VariableWindowIndexer,
 )
+from pandas.core.window.numba_ import generate_numba_apply_func
 
 
-class _Window(PandasObject, SelectionMixin):
-    _attributes = [
+class _Window(PandasObject, ShallowMixin, SelectionMixin):
+    _attributes: List[str] = [
         "window",
         "min_periods",
         "center",
@@ -59,8 +65,8 @@ class _Window(PandasObject, SelectionMixin):
         "axis",
         "on",
         "closed",
-    ]  # type: List[str]
-    exclusions = set()  # type: Set[str]
+    ]
+    exclusions: Set[str] = set()
 
     def __init__(
         self,
@@ -70,9 +76,9 @@ def __init__(
         center: Optional[bool] = False,
         win_type: Optional[str] = None,
         axis: Axis = 0,
-        on: Optional[str] = None,
+        on: Optional[Union[str, Index]] = None,
         closed: Optional[str] = None,
-        **kwargs
+        **kwargs,
     ):
 
         self.__dict__.update(kwargs)
@@ -86,6 +92,7 @@ def __init__(
         self.win_freq = None
         self.axis = obj._get_axis_number(axis) if axis is not None else None
         self.validate()
+        self._numba_func_cache: Dict[Optional[str], Callable] = dict()
 
     @property
     def _constructor(self):
@@ -103,7 +110,7 @@ def _on(self):
     def is_freq_type(self) -> bool:
         return self.win_type == "freq"
 
-    def validate(self):
+    def validate(self) -> None:
         if self.center is not None and not is_bool(self.center):
             raise ValueError("center must be a boolean")
         if self.min_periods is not None and not is_integer(self.min_periods):
@@ -116,7 +123,27 @@ def validate(self):
         ]:
             raise ValueError("closed must be 'right', 'left', 'both' or 'neither'")
         if not isinstance(self.obj, (ABCSeries, ABCDataFrame)):
-            raise TypeError("invalid type: {}".format(type(self)))
+            raise TypeError(f"invalid type: {type(self)}")
+        if isinstance(self.window, BaseIndexer):
+            self._validate_get_window_bounds_signature(self.window)
+
+    @staticmethod
+    def _validate_get_window_bounds_signature(window: BaseIndexer) -> None:
+        """
+        Validate that the passed BaseIndexer subclass has
+        a get_window_bounds with the correct signature.
+        """
+        get_window_bounds_signature = inspect.signature(
+            window.get_window_bounds
+        ).parameters.keys()
+        expected_signature = inspect.signature(
+            BaseIndexer().get_window_bounds
+        ).parameters.keys()
+        if get_window_bounds_signature != expected_signature:
+            raise ValueError(
+                f"{type(window).__name__} does not implement the correct signature for "
+                f"get_window_bounds"
+            )
 
     def _create_blocks(self):
         """
@@ -126,7 +153,7 @@ def _create_blocks(self):
         obj = self._selected_obj
 
         # filter out the on from the object
-        if self.on is not None:
+        if self.on is not None and not isinstance(self.on, Index):
             if obj.ndim == 2:
                 obj = obj.reindex(columns=obj.columns.difference([self.on]), copy=False)
         blocks = obj._to_dict_of_blocks(copy=False).values()
@@ -156,68 +183,73 @@ def _gotitem(self, key, ndim, subset=None):
                 self._selection = key
         return self
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str):
         if attr in self._internal_names_set:
             return object.__getattribute__(self, attr)
         if attr in self.obj:
             return self[attr]
 
         raise AttributeError(
-            "%r object has no attribute %r" % (type(self).__name__, attr)
+            f"'{type(self).__name__}' object has no attribute '{attr}'"
         )
 
     def _dir_additions(self):
         return self.obj._dir_additions()
 
-    def _get_window(self, other=None, **kwargs) -> int:
+    def _get_win_type(self, kwargs: Dict):
+        """
+        Exists for compatibility, overriden by subclass Window.
+
+        Parameters
+        ----------
+        kwargs : dict
+            ignored, exists for compatibility
+
+        Returns
+        -------
+        None
+        """
+        return None
+
+    def _get_window(self, other=None, win_type: Optional[str] = None) -> int:
         """
-        Returns window length
+        Return window length.
 
         Parameters
         ----------
-        other:
+        other :
+            ignored, exists for compatibility
+        win_type :
             ignored, exists for compatibility
 
         Returns
         -------
         window : int
         """
+        if isinstance(self.window, BaseIndexer):
+            return self.min_periods or 0
         return self.window
 
     @property
     def _window_type(self) -> str:
-        return self.__class__.__name__
+        return type(self).__name__
 
     def __repr__(self) -> str:
         """
         Provide a nice str repr of our rolling object.
         """
 
-        attrs = (
-            "{k}={v}".format(k=k, v=getattr(self, k))
-            for k in self._attributes
-            if getattr(self, k, None) is not None
-        )
-        return "{klass} [{attrs}]".format(
-            klass=self._window_type, attrs=",".join(attrs)
+        attrs_list = (
+            f"{attr_name}={getattr(self, attr_name)}"
+            for attr_name in self._attributes
+            if getattr(self, attr_name, None) is not None
         )
+        attrs = ",".join(attrs_list)
+        return f"{self._window_type} [{attrs}]"
 
     def __iter__(self):
         url = "https://github.com/pandas-dev/pandas/issues/11704"
-        raise NotImplementedError("See issue #11704 {url}".format(url=url))
-
-    def _get_index(self) -> Optional[np.ndarray]:
-        """
-        Return integer representations as an ndarray if index is frequency.
-
-        Returns
-        -------
-        None or ndarray
-        """
-
-        if self.is_freq_type:
-            return self._on.asi8
-        return None
+        raise NotImplementedError(f"See issue #11704 {url}")
 
     def _prep_values(self, values: Optional[np.ndarray] = None) -> np.ndarray:
         """Convert input to numpy arrays for Cython routines"""
@@ -232,15 +264,14 @@ def _prep_values(self, values: Optional[np.ndarray] = None) -> np.ndarray:
             values = ensure_float64(values)
         elif needs_i8_conversion(values.dtype):
             raise NotImplementedError(
-                "ops for {action} for this "
-                "dtype {dtype} are not "
-                "implemented".format(action=self._window_type, dtype=values.dtype)
+                f"ops for {self._window_type} for this "
+                f"dtype {values.dtype} are not implemented"
             )
         else:
             try:
                 values = ensure_float64(values)
             except (ValueError, TypeError):
-                raise TypeError("cannot handle this type -> {0}".format(values.dtype))
+                raise TypeError(f"cannot handle this type -> {values.dtype}")
 
         # Convert inf to nan for C funcs
         inf = np.isinf(values)
@@ -260,17 +291,6 @@ def _wrap_result(self, result, block=None, obj=None):
 
         if isinstance(result, np.ndarray):
 
-            # coerce if necessary
-            if block is not None:
-                if is_timedelta64_dtype(block.values.dtype):
-                    # TODO: do we know what result.dtype is at this point?
-                    #  i.e. can we just do an astype?
-                    from pandas import to_timedelta
-
-                    result = to_timedelta(result.ravel(), unit="ns").values.reshape(
-                        result.shape
-                    )
-
             if result.ndim == 1:
                 from pandas import Series
 
@@ -339,50 +359,63 @@ def _center_window(self, result, window) -> np.ndarray:
         if self.axis > result.ndim - 1:
             raise ValueError("Requested axis is larger then no. of argument dimensions")
 
-        offset = _offset(window, True)
+        offset = calculate_center_offset(window)
         if offset > 0:
-            if isinstance(result, (ABCSeries, ABCDataFrame)):
-                result = result.slice_shift(-offset, axis=self.axis)
-            else:
-                lead_indexer = [slice(None)] * result.ndim
-                lead_indexer[self.axis] = slice(offset, None)
-                result = np.copy(result[tuple(lead_indexer)])
+            lead_indexer = [slice(None)] * result.ndim
+            lead_indexer[self.axis] = slice(offset, None)
+            result = np.copy(result[tuple(lead_indexer)])
         return result
 
-    def _get_roll_func(
-        self, cfunc: Callable, check_minp: Callable, index: np.ndarray, **kwargs
-    ) -> Callable:
+    def _get_roll_func(self, func_name: str) -> Callable:
         """
         Wrap rolling function to check values passed.
 
         Parameters
         ----------
-        cfunc : callable
+        func_name : str
             Cython function used to calculate rolling statistics
-        check_minp : callable
-            function to check minimum period parameter
-        index : ndarray
-            used for variable window
 
         Returns
         -------
         func : callable
         """
+        window_func = getattr(window_aggregations, func_name, None)
+        if window_func is None:
+            raise ValueError(
+                f"we do not support this function in window_aggregations.{func_name}"
+            )
+        return window_func
 
-        def func(arg, window, min_periods=None, closed=None):
-            minp = check_minp(min_periods, window)
-            return cfunc(arg, window, minp, index, closed, **kwargs)
+    def _get_cython_func_type(self, func: str) -> Callable:
+        """
+        Return a variable or fixed cython function type.
 
-        return func
+        Variable algorithms do not use window while fixed do.
+        """
+        if self.is_freq_type or isinstance(self.window, BaseIndexer):
+            return self._get_roll_func(f"{func}_variable")
+        return partial(self._get_roll_func(f"{func}_fixed"), win=self._get_window())
+
+    def _get_window_indexer(self, window: int) -> BaseIndexer:
+        """
+        Return an indexer class that will compute the window start and end bounds
+        """
+        if isinstance(self.window, BaseIndexer):
+            return self.window
+        if self.is_freq_type:
+            return VariableWindowIndexer(index_array=self._on.asi8, window_size=window)
+        return FixedWindowIndexer(window_size=window)
 
     def _apply(
         self,
-        func: Union[str, Callable],
+        func: Callable,
+        center: bool,
+        require_min_periods: int = 0,
+        floor: int = 1,
+        is_weighted: bool = False,
         name: Optional[str] = None,
-        window: Optional[Union[int, str]] = None,
-        center: Optional[bool] = None,
-        check_minp: Optional[Callable] = None,
-        **kwargs
+        use_numba_cache: bool = False,
+        **kwargs,
     ):
         """
         Rolling statistical measure using supplied function.
@@ -391,13 +424,16 @@ def _apply(
 
         Parameters
         ----------
-        func : str/callable to apply
-        name : str, optional
-           name of this function
-        window : int/str, default to _get_window()
-            window length or offset
-        center : bool, default to self.center
-        check_minp : function, default to _use_window
+        func : callable function to apply
+        center : bool
+        require_min_periods : int
+        floor : int
+        is_weighted : bool
+        name : str,
+            compatibility with groupby.rolling
+        use_numba_cache : bool
+            whether to cache a numba compiled function. Only available for numba
+            enabled methods (so far only apply)
         **kwargs
             additional arguments for rolling function and window function
 
@@ -405,21 +441,15 @@ def _apply(
         -------
         y : type of input
         """
-        if center is None:
-            center = self.center
-
-        if check_minp is None:
-            check_minp = _use_window
-
-        if window is None:
-            window = self._get_window(**kwargs)
+        win_type = self._get_win_type(kwargs)
+        window = self._get_window(win_type=win_type)
 
         blocks, obj = self._create_blocks()
         block_list = list(blocks)
-        index_as_array = self._get_index()
+        window_indexer = self._get_window_indexer(window)
 
         results = []
-        exclude = []  # type: List[Scalar]
+        exclude: List[Scalar] = []
         for i, b in enumerate(blocks):
             try:
                 values = self._prep_values(b.values)
@@ -436,36 +466,39 @@ def _apply(
                 results.append(values.copy())
                 continue
 
-            # if we have a string function name, wrap it
-            if isinstance(func, str):
-                cfunc = getattr(libwindow, func, None)
-                if cfunc is None:
-                    raise ValueError(
-                        "we do not support this function "
-                        "in libwindow.{func}".format(func=func)
-                    )
-
-                func = self._get_roll_func(cfunc, check_minp, index_as_array, **kwargs)
-
             # calculation function
-            if center:
-                offset = _offset(window, center)
-                additional_nans = np.array([np.NaN] * offset)
+            offset = calculate_center_offset(window) if center else 0
+            additional_nans = np.array([np.nan] * offset)
+
+            if not is_weighted:
 
                 def calc(x):
-                    return func(
-                        np.concatenate((x, additional_nans)),
-                        window,
+                    x = np.concatenate((x, additional_nans))
+                    if not isinstance(window, BaseIndexer):
+                        min_periods = calculate_min_periods(
+                            window, self.min_periods, len(x), require_min_periods, floor
+                        )
+                    else:
+                        min_periods = calculate_min_periods(
+                            self.min_periods or 1,
+                            self.min_periods,
+                            len(x),
+                            require_min_periods,
+                            floor,
+                        )
+                    start, end = window_indexer.get_window_bounds(
+                        num_values=len(x),
                         min_periods=self.min_periods,
+                        center=self.center,
                         closed=self.closed,
                     )
+                    return func(x, start, end, min_periods)
 
             else:
 
                 def calc(x):
-                    return func(
-                        x, window, min_periods=self.min_periods, closed=self.closed
-                    )
+                    x = np.concatenate((x, additional_nans))
+                    return func(x, window, self.min_periods)
 
             with np.errstate(all="ignore"):
                 if values.ndim > 1:
@@ -474,6 +507,9 @@ def calc(x):
                     result = calc(values)
                     result = np.asarray(result)
 
+            if use_numba_cache:
+                self._numba_func_cache[name] = func
+
             if center:
                 result = self._center_window(result, window)
 
@@ -612,6 +648,126 @@ def aggregate(self, func, *args, **kwargs):
     """
     )
 
+    _shared_docs["var"] = dedent(
+        """
+    Calculate unbiased %(name)s variance.
+    %(versionadded)s
+    Normalized by N-1 by default. This can be changed using the `ddof`
+    argument.
+
+    Parameters
+    ----------
+    ddof : int, default 1
+        Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+    *args, **kwargs
+        For NumPy compatibility. No additional arguments are used.
+
+    Returns
+    -------
+    Series or DataFrame
+        Returns the same object type as the caller of the %(name)s calculation.
+
+    See Also
+    --------
+    Series.%(name)s : Calling object with Series data.
+    DataFrame.%(name)s : Calling object with DataFrames.
+    Series.var : Equivalent method for Series.
+    DataFrame.var : Equivalent method for DataFrame.
+    numpy.var : Equivalent method for Numpy array.
+
+    Notes
+    -----
+    The default `ddof` of 1 used in :meth:`Series.var` is different than the
+    default `ddof` of 0 in :func:`numpy.var`.
+
+    A minimum of 1 period is required for the rolling calculation.
+
+    Examples
+    --------
+    >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
+    >>> s.rolling(3).var()
+    0         NaN
+    1         NaN
+    2    0.333333
+    3    1.000000
+    4    1.000000
+    5    1.333333
+    6    0.000000
+    dtype: float64
+
+    >>> s.expanding(3).var()
+    0         NaN
+    1         NaN
+    2    0.333333
+    3    0.916667
+    4    0.800000
+    5    0.700000
+    6    0.619048
+    dtype: float64
+    """
+    )
+
+    _shared_docs["std"] = dedent(
+        """
+    Calculate %(name)s standard deviation.
+    %(versionadded)s
+    Normalized by N-1 by default. This can be changed using the `ddof`
+    argument.
+
+    Parameters
+    ----------
+    ddof : int, default 1
+        Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+    *args, **kwargs
+        For NumPy compatibility. No additional arguments are used.
+
+    Returns
+    -------
+    Series or DataFrame
+        Returns the same object type as the caller of the %(name)s calculation.
+
+    See Also
+    --------
+    Series.%(name)s : Calling object with Series data.
+    DataFrame.%(name)s : Calling object with DataFrames.
+    Series.std : Equivalent method for Series.
+    DataFrame.std : Equivalent method for DataFrame.
+    numpy.std : Equivalent method for Numpy array.
+
+    Notes
+    -----
+    The default `ddof` of 1 used in Series.std is different than the default
+    `ddof` of 0 in numpy.std.
+
+    A minimum of one period is required for the rolling calculation.
+
+    Examples
+    --------
+    >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
+    >>> s.rolling(3).std()
+    0         NaN
+    1         NaN
+    2    0.577350
+    3    1.000000
+    4    1.000000
+    5    1.154701
+    6    0.000000
+    dtype: float64
+
+    >>> s.expanding(3).std()
+    0         NaN
+    1         NaN
+    2    0.577350
+    3    0.957427
+    4    0.894427
+    5    0.836660
+    6    0.786796
+    dtype: float64
+    """
+    )
+
 
 class Window(_Window):
     """
@@ -619,13 +775,18 @@ class Window(_Window):
 
     Parameters
     ----------
-    window : int, or offset
+    window : int, offset, or BaseIndexer subclass
         Size of the moving window. This is the number of observations used for
         calculating the statistic. Each window will be a fixed size.
 
         If its an offset then this will be the time period of each window. Each
         window will be a variable sized based on the observations included in
         the time-period. This is only valid for datetimelike indexes.
+
+        If a BaseIndexer subclass is passed, calculates the window boundaries
+        based on the defined ``get_window_bounds`` method. Additional rolling
+        keyword arguments, namely `min_periods`, `center`, and
+        `closed` will be passed to `get_window_bounds`.
     min_periods : int, default None
         Minimum number of observations in window required to have a value
         (otherwise result is NA). For a window that is specified by an offset,
@@ -637,10 +798,10 @@ class Window(_Window):
         Provide a window type. If ``None``, all points are evenly weighted.
         See the notes below for further information.
     on : str, optional
-        For a DataFrame, a datetime-like column on which to calculate the rolling
-        window, rather than the DataFrame's index. Provided integer column is
-        ignored and excluded from result since an integer index is not used to
-        calculate the rolling window.
+        For a DataFrame, a datetime-like column or MultiIndex level on which
+        to calculate the rolling window, rather than the DataFrame's index.
+        Provided integer column is ignored and excluded from result since
+        an integer index is not used to calculate the rolling window.
     axis : int or str, default 0
     closed : str, default None
         Make the interval closed on the 'right', 'left', 'both' or
@@ -649,8 +810,6 @@ class Window(_Window):
         For fixed windows, defaults to 'both'. Remaining cases not implemented
         for fixed windows.
 
-        .. versionadded:: 0.20.0
-
     Returns
     -------
     a Window or Rolling sub-classed for the particular operation
@@ -666,7 +825,7 @@ class Window(_Window):
     changed to the center of the window by setting ``center=True``.
 
     To learn more about the offsets & frequency strings, please see `this link
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
 
     The recognized win_types are:
 
@@ -713,6 +872,17 @@ class Window(_Window):
     3  NaN
     4  NaN
 
+    Rolling sum with a window length of 2, using the 'gaussian'
+    window type (note how we need to specify std).
+
+    >>> df.rolling(2, win_type='gaussian').sum(std=3)
+              B
+    0       NaN
+    1  0.986207
+    2  2.958621
+    3       NaN
+    4       NaN
+
     Rolling sum with a window length of 2, min_periods defaults
     to the window length.
 
@@ -768,7 +938,11 @@ def validate(self):
         super().validate()
 
         window = self.window
-        if isinstance(window, (list, tuple, np.ndarray)):
+        if isinstance(window, BaseIndexer):
+            raise NotImplementedError(
+                "BaseIndexer subclasses not implemented with win_types."
+            )
+        elif isinstance(window, (list, tuple, np.ndarray)):
             pass
         elif is_integer(window):
             if window <= 0:
@@ -779,21 +953,68 @@ def validate(self):
             import scipy.signal as sig
 
             if not isinstance(self.win_type, str):
-                raise ValueError("Invalid win_type {0}".format(self.win_type))
+                raise ValueError(f"Invalid win_type {self.win_type}")
             if getattr(sig, self.win_type, None) is None:
-                raise ValueError("Invalid win_type {0}".format(self.win_type))
+                raise ValueError(f"Invalid win_type {self.win_type}")
         else:
-            raise ValueError("Invalid window {0}".format(window))
+            raise ValueError(f"Invalid window {window}")
 
-    def _get_window(self, other=None, **kwargs) -> np.ndarray:
+    def _get_win_type(self, kwargs: Dict) -> Union[str, Tuple]:
+        """
+        Extract arguments for the window type, provide validation for it
+        and return the validated window type.
+
+        Parameters
+        ----------
+        kwargs : dict
+
+        Returns
+        -------
+        win_type : str, or tuple
+        """
+        # the below may pop from kwargs
+        def _validate_win_type(win_type, kwargs):
+            arg_map = {
+                "kaiser": ["beta"],
+                "gaussian": ["std"],
+                "general_gaussian": ["power", "width"],
+                "slepian": ["width"],
+                "exponential": ["tau"],
+            }
+
+            if win_type in arg_map:
+                win_args = _pop_args(win_type, arg_map[win_type], kwargs)
+                if win_type == "exponential":
+                    # exponential window requires the first arg (center)
+                    # to be set to None (necessary for symmetric window)
+                    win_args.insert(0, None)
+
+                return tuple([win_type] + win_args)
+
+            return win_type
+
+        def _pop_args(win_type, arg_names, kwargs):
+            all_args = []
+            for n in arg_names:
+                if n not in kwargs:
+                    raise ValueError(f"{win_type} window requires {n}")
+                all_args.append(kwargs.pop(n))
+            return all_args
+
+        return _validate_win_type(self.win_type, kwargs)
+
+    def _get_window(
+        self, other=None, win_type: Optional[Union[str, Tuple]] = None
+    ) -> np.ndarray:
         """
-        Provide validation for the window type, return the window
-        which has already been validated.
+        Get the window, weights.
 
         Parameters
         ----------
-        other:
+        other :
             ignored, exists for compatibility
+        win_type : str, or tuple
+            type of window to create
 
         Returns
         -------
@@ -807,49 +1028,9 @@ def _get_window(self, other=None, **kwargs) -> np.ndarray:
         elif is_integer(window):
             import scipy.signal as sig
 
-            # the below may pop from kwargs
-            def _validate_win_type(win_type, kwargs):
-                arg_map = {
-                    "kaiser": ["beta"],
-                    "gaussian": ["std"],
-                    "general_gaussian": ["power", "width"],
-                    "slepian": ["width"],
-                    "exponential": ["tau"],
-                }
-
-                if win_type in arg_map:
-                    win_args = _pop_args(win_type, arg_map[win_type], kwargs)
-                    if win_type == "exponential":
-                        # exponential window requires the first arg (center)
-                        # to be set to None (necessary for symmetric window)
-                        win_args.insert(0, None)
-
-                    return tuple([win_type] + win_args)
-
-                return win_type
-
-            def _pop_args(win_type, arg_names, kwargs):
-                msg = "%s window requires %%s" % win_type
-                all_args = []
-                for n in arg_names:
-                    if n not in kwargs:
-                        raise ValueError(msg % n)
-                    all_args.append(kwargs.pop(n))
-                return all_args
-
-            win_type = _validate_win_type(self.win_type, kwargs)
             # GH #15662. `False` makes symmetric window, rather than periodic.
             return sig.get_window(win_type, window, False).astype(float)
 
-    def _get_roll_func(
-        self, cfunc: Callable, check_minp: Callable, index: np.ndarray, **kwargs
-    ) -> Callable:
-        def func(arg, window, min_periods=None, closed=None):
-            minp = check_minp(min_periods, len(window))
-            return cfunc(arg, window, minp)
-
-        return func
-
     _agg_see_also_doc = dedent(
         """
     See Also
@@ -916,13 +1097,38 @@ def aggregate(self, func, *args, **kwargs):
     @Appender(_shared_docs["sum"])
     def sum(self, *args, **kwargs):
         nv.validate_window_func("sum", args, kwargs)
-        return self._apply("roll_weighted_sum", **kwargs)
+        window_func = self._get_roll_func("roll_weighted_sum")
+        window_func = get_weighted_roll_func(window_func)
+        return self._apply(
+            window_func, center=self.center, is_weighted=True, name="sum", **kwargs
+        )
 
     @Substitution(name="window")
     @Appender(_shared_docs["mean"])
     def mean(self, *args, **kwargs):
         nv.validate_window_func("mean", args, kwargs)
-        return self._apply("roll_weighted_mean", **kwargs)
+        window_func = self._get_roll_func("roll_weighted_mean")
+        window_func = get_weighted_roll_func(window_func)
+        return self._apply(
+            window_func, center=self.center, is_weighted=True, name="mean", **kwargs
+        )
+
+    @Substitution(name="window", versionadded="\n.. versionadded:: 1.0.0\n")
+    @Appender(_shared_docs["var"])
+    def var(self, ddof=1, *args, **kwargs):
+        nv.validate_window_func("var", args, kwargs)
+        window_func = partial(self._get_roll_func("roll_weighted_var"), ddof=ddof)
+        window_func = get_weighted_roll_func(window_func)
+        kwargs.pop("name", None)
+        return self._apply(
+            window_func, center=self.center, is_weighted=True, name="var", **kwargs
+        )
+
+    @Substitution(name="window", versionadded="\n.. versionadded:: 1.0.0\n")
+    @Appender(_shared_docs["std"])
+    def std(self, ddof=1, *args, **kwargs):
+        nv.validate_window_func("std", args, kwargs)
+        return zsqrt(self.var(ddof=ddof, name="std", **kwargs))
 
 
 class _Rolling(_Window):
@@ -976,19 +1182,13 @@ class _Rolling_and_Expanding(_Rolling):
     def count(self):
 
         blocks, obj = self._create_blocks()
-        # Validate the index
-        self._get_index()
-
-        window = self._get_window()
-        window = min(window, len(obj)) if not self.center else window
-
         results = []
         for b in blocks:
             result = b.notna().astype(int)
             result = self._constructor(
                 result,
-                window=window,
-                min_periods=0,
+                window=self._get_window(),
+                min_periods=self.min_periods or 0,
                 center=self.center,
                 axis=self.axis,
                 closed=self.closed,
@@ -999,27 +1199,45 @@ def count(self):
 
     _shared_docs["apply"] = dedent(
         r"""
-    The %(name)s function's apply function.
+    Apply an arbitrary function to each %(name)s window.
 
     Parameters
     ----------
     func : function
         Must produce a single value from an ndarray input if ``raw=True``
-        or a single value from a Series if ``raw=False``.
+        or a single value from a Series if ``raw=False``. Can also accept a
+        Numba JIT function with ``engine='numba'`` specified.
+
+        .. versionchanged:: 1.0.0
+
     raw : bool, default None
         * ``False`` : passes each row or column as a Series to the
           function.
-        * ``True`` or ``None`` : the passed function will receive ndarray
+        * ``True`` : the passed function will receive ndarray
           objects instead.
           If you are just applying a NumPy reduction function this will
           achieve much better performance.
-
-        The `raw` parameter is required and will show a FutureWarning if
-        not passed. In the future `raw` will default to False.
-
-        .. versionadded:: 0.23.0
-    *args, **kwargs
-        Arguments and keyword arguments to be passed into func.
+    engine : str, default 'cython'
+        * ``'cython'`` : Runs rolling apply through C-extensions from cython.
+        * ``'numba'`` : Runs rolling apply through JIT compiled code from numba.
+          Only available when ``raw`` is set to ``True``.
+
+          .. versionadded:: 1.0.0
+
+    engine_kwargs : dict, default None
+        * For ``'cython'`` engine, there are no accepted ``engine_kwargs``
+        * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``
+          and ``parallel`` dictionary keys. The values must either be ``True`` or
+          ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is
+          ``{'nopython': True, 'nogil': False, 'parallel': False}`` and will be
+          applied to both the ``func`` and the ``apply`` rolling aggregation.
+
+          .. versionadded:: 1.0.0
+
+    args : tuple, default None
+        Positional arguments to be passed into func.
+    kwargs : dict, default None
+        Keyword arguments to be passed into func.
 
     Returns
     -------
@@ -1030,53 +1248,90 @@ def count(self):
     --------
     Series.%(name)s : Series %(name)s.
     DataFrame.%(name)s : DataFrame %(name)s.
+
+    Notes
+    -----
+    See :ref:`stats.rolling_apply` for extended documentation and performance
+    considerations for the Numba engine.
     """
     )
 
-    def apply(self, func, raw=None, args=(), kwargs={}):
-        from pandas import Series
-
+    def apply(
+        self,
+        func,
+        raw: bool = False,
+        engine: str = "cython",
+        engine_kwargs: Optional[Dict] = None,
+        args: Optional[Tuple] = None,
+        kwargs: Optional[Dict] = None,
+    ):
+        if args is None:
+            args = ()
+        if kwargs is None:
+            kwargs = {}
         kwargs.pop("_level", None)
+        kwargs.pop("floor", None)
         window = self._get_window()
-        offset = _offset(window, self.center)
-        index_as_array = self._get_index()
-
-        # TODO: default is for backward compat
-        # change to False in the future
-        if raw is None:
-            warnings.warn(
-                "Currently, 'apply' passes the values as ndarrays to the "
-                "applied function. In the future, this will change to passing "
-                "it as Series objects. You need to specify 'raw=True' to keep "
-                "the current behaviour, and you can pass 'raw=False' to "
-                "silence this warning",
-                FutureWarning,
-                stacklevel=3,
+        offset = calculate_center_offset(window) if self.center else 0
+        if not is_bool(raw):
+            raise ValueError("raw parameter must be `True` or `False`")
+
+        if engine == "cython":
+            if engine_kwargs is not None:
+                raise ValueError("cython engine does not accept engine_kwargs")
+            apply_func = self._generate_cython_apply_func(
+                args, kwargs, raw, offset, func
             )
-            raw = True
+        elif engine == "numba":
+            if raw is False:
+                raise ValueError("raw must be `True` when using the numba engine")
+            if func in self._numba_func_cache:
+                # Return an already compiled version of roll_apply if available
+                apply_func = self._numba_func_cache[func]
+            else:
+                apply_func = generate_numba_apply_func(
+                    args, kwargs, func, engine_kwargs
+                )
+        else:
+            raise ValueError("engine must be either 'numba' or 'cython'")
+
+        # TODO: Why do we always pass center=False?
+        # name=func & raw=raw for WindowGroupByMixin._apply
+        return self._apply(
+            apply_func,
+            center=False,
+            floor=0,
+            name=func,
+            use_numba_cache=engine == "numba",
+            raw=raw,
+        )
+
+    def _generate_cython_apply_func(self, args, kwargs, raw, offset, func):
+        from pandas import Series
 
-        def f(arg, window, min_periods, closed):
-            minp = _use_window(min_periods, window)
+        window_func = partial(
+            self._get_cython_func_type("roll_generic"),
+            args=args,
+            kwargs=kwargs,
+            raw=raw,
+            offset=offset,
+            func=func,
+        )
+
+        def apply_func(values, begin, end, min_periods, raw=raw):
             if not raw:
-                arg = Series(arg, index=self.obj.index)
-            return libwindow.roll_generic(
-                arg,
-                window,
-                minp,
-                index_as_array,
-                closed,
-                offset,
-                func,
-                raw,
-                args,
-                kwargs,
-            )
+                values = Series(values, index=self.obj.index)
+            return window_func(values, begin, end, min_periods)
 
-        return self._apply(f, func, args=args, kwargs=kwargs, center=False, raw=raw)
+        return apply_func
 
     def sum(self, *args, **kwargs):
         nv.validate_window_func("sum", args, kwargs)
-        return self._apply("roll_sum", "sum", **kwargs)
+        window_func = self._get_cython_func_type("roll_sum")
+        kwargs.pop("floor", None)
+        return self._apply(
+            window_func, center=self.center, floor=0, name="sum", **kwargs
+        )
 
     _shared_docs["max"] = dedent(
         """
@@ -1091,7 +1346,8 @@ def sum(self, *args, **kwargs):
 
     def max(self, *args, **kwargs):
         nv.validate_window_func("max", args, kwargs)
-        return self._apply("roll_max", "max", **kwargs)
+        window_func = self._get_cython_func_type("roll_max")
+        return self._apply(window_func, center=self.center, name="max", **kwargs)
 
     _shared_docs["min"] = dedent(
         """
@@ -1132,11 +1388,13 @@ def max(self, *args, **kwargs):
 
     def min(self, *args, **kwargs):
         nv.validate_window_func("min", args, kwargs)
-        return self._apply("roll_min", "min", **kwargs)
+        window_func = self._get_cython_func_type("roll_min")
+        return self._apply(window_func, center=self.center, name="min", **kwargs)
 
     def mean(self, *args, **kwargs):
         nv.validate_window_func("mean", args, kwargs)
-        return self._apply("roll_mean", "mean", **kwargs)
+        window_func = self._get_cython_func_type("roll_mean")
+        return self._apply(window_func, center=self.center, name="mean", **kwargs)
 
     _shared_docs["median"] = dedent(
         """
@@ -1176,147 +1434,40 @@ def mean(self, *args, **kwargs):
     )
 
     def median(self, **kwargs):
-        return self._apply("roll_median_c", "median", **kwargs)
-
-    _shared_docs["std"] = dedent(
-        """
-    Calculate %(name)s standard deviation.
-
-    Normalized by N-1 by default. This can be changed using the `ddof`
-    argument.
-
-    Parameters
-    ----------
-    ddof : int, default 1
-        Delta Degrees of Freedom.  The divisor used in calculations
-        is ``N - ddof``, where ``N`` represents the number of elements.
-    *args, **kwargs
-        For NumPy compatibility. No additional arguments are used.
-
-    Returns
-    -------
-    Series or DataFrame
-        Returns the same object type as the caller of the %(name)s calculation.
-
-    See Also
-    --------
-    Series.%(name)s : Calling object with Series data.
-    DataFrame.%(name)s : Calling object with DataFrames.
-    Series.std : Equivalent method for Series.
-    DataFrame.std : Equivalent method for DataFrame.
-    numpy.std : Equivalent method for Numpy array.
-
-    Notes
-    -----
-    The default `ddof` of 1 used in Series.std is different than the default
-    `ddof` of 0 in numpy.std.
-
-    A minimum of one period is required for the rolling calculation.
-
-    Examples
-    --------
-    >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
-    >>> s.rolling(3).std()
-    0         NaN
-    1         NaN
-    2    0.577350
-    3    1.000000
-    4    1.000000
-    5    1.154701
-    6    0.000000
-    dtype: float64
-
-    >>> s.expanding(3).std()
-    0         NaN
-    1         NaN
-    2    0.577350
-    3    0.957427
-    4    0.894427
-    5    0.836660
-    6    0.786796
-    dtype: float64
-    """
-    )
+        window_func = self._get_roll_func("roll_median_c")
+        window_func = partial(window_func, win=self._get_window())
+        return self._apply(window_func, center=self.center, name="median", **kwargs)
 
     def std(self, ddof=1, *args, **kwargs):
         nv.validate_window_func("std", args, kwargs)
-        window = self._get_window()
-        index_as_array = self._get_index()
+        kwargs.pop("require_min_periods", None)
+        window_func = self._get_cython_func_type("roll_var")
 
-        def f(arg, *args, **kwargs):
-            minp = _require_min_periods(1)(self.min_periods, window)
-            return _zsqrt(
-                libwindow.roll_var(arg, window, minp, index_as_array, self.closed, ddof)
-            )
+        def zsqrt_func(values, begin, end, min_periods):
+            return zsqrt(window_func(values, begin, end, min_periods, ddof=ddof))
 
+        # ddof passed again for compat with groupby.rolling
         return self._apply(
-            f, "std", check_minp=_require_min_periods(1), ddof=ddof, **kwargs
+            zsqrt_func,
+            center=self.center,
+            require_min_periods=1,
+            name="std",
+            ddof=ddof,
+            **kwargs,
         )
 
-    _shared_docs["var"] = dedent(
-        """
-    Calculate unbiased %(name)s variance.
-
-    Normalized by N-1 by default. This can be changed using the `ddof`
-    argument.
-
-    Parameters
-    ----------
-    ddof : int, default 1
-        Delta Degrees of Freedom.  The divisor used in calculations
-        is ``N - ddof``, where ``N`` represents the number of elements.
-    *args, **kwargs
-        For NumPy compatibility. No additional arguments are used.
-
-    Returns
-    -------
-    Series or DataFrame
-        Returns the same object type as the caller of the %(name)s calculation.
-
-    See Also
-    --------
-    Series.%(name)s : Calling object with Series data.
-    DataFrame.%(name)s : Calling object with DataFrames.
-    Series.var : Equivalent method for Series.
-    DataFrame.var : Equivalent method for DataFrame.
-    numpy.var : Equivalent method for Numpy array.
-
-    Notes
-    -----
-    The default `ddof` of 1 used in :meth:`Series.var` is different than the
-    default `ddof` of 0 in :func:`numpy.var`.
-
-    A minimum of 1 period is required for the rolling calculation.
-
-    Examples
-    --------
-    >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
-    >>> s.rolling(3).var()
-    0         NaN
-    1         NaN
-    2    0.333333
-    3    1.000000
-    4    1.000000
-    5    1.333333
-    6    0.000000
-    dtype: float64
-
-    >>> s.expanding(3).var()
-    0         NaN
-    1         NaN
-    2    0.333333
-    3    0.916667
-    4    0.800000
-    5    0.700000
-    6    0.619048
-    dtype: float64
-    """
-    )
-
     def var(self, ddof=1, *args, **kwargs):
         nv.validate_window_func("var", args, kwargs)
+        kwargs.pop("require_min_periods", None)
+        window_func = partial(self._get_cython_func_type("roll_var"), ddof=ddof)
+        # ddof passed again for compat with groupby.rolling
         return self._apply(
-            "roll_var", "var", check_minp=_require_min_periods(1), ddof=ddof, **kwargs
+            window_func,
+            center=self.center,
+            require_min_periods=1,
+            name="var",
+            ddof=ddof,
+            **kwargs,
         )
 
     _shared_docs[
@@ -1331,8 +1482,14 @@ def var(self, ddof=1, *args, **kwargs):
     """
 
     def skew(self, **kwargs):
+        window_func = self._get_cython_func_type("roll_skew")
+        kwargs.pop("require_min_periods", None)
         return self._apply(
-            "roll_skew", "skew", check_minp=_require_min_periods(3), **kwargs
+            window_func,
+            center=self.center,
+            require_min_periods=3,
+            name="skew",
+            **kwargs,
         )
 
     _shared_docs["kurt"] = dedent(
@@ -1368,8 +1525,14 @@ def skew(self, **kwargs):
     )
 
     def kurt(self, **kwargs):
+        window_func = self._get_cython_func_type("roll_kurt")
+        kwargs.pop("require_min_periods", None)
         return self._apply(
-            "roll_kurt", "kurt", check_minp=_require_min_periods(4), **kwargs
+            window_func,
+            center=self.center,
+            require_min_periods=4,
+            name="kurt",
+            **kwargs,
         )
 
     _shared_docs["quantile"] = dedent(
@@ -1392,7 +1555,7 @@ def kurt(self, **kwargs):
             * higher: `j`.
             * nearest: `i` or `j` whichever is nearest.
             * midpoint: (`i` + `j`) / 2.
-    **kwargs:
+    **kwargs
         For compatibility with other %(name)s methods. Has no effect on
         the result.
 
@@ -1429,31 +1592,22 @@ def kurt(self, **kwargs):
     )
 
     def quantile(self, quantile, interpolation="linear", **kwargs):
-        window = self._get_window()
-        index_as_array = self._get_index()
-
-        def f(arg, *args, **kwargs):
-            minp = _use_window(self.min_periods, window)
-            if quantile == 1.0:
-                return libwindow.roll_max(
-                    arg, window, minp, index_as_array, self.closed
-                )
-            elif quantile == 0.0:
-                return libwindow.roll_min(
-                    arg, window, minp, index_as_array, self.closed
-                )
-            else:
-                return libwindow.roll_quantile(
-                    arg,
-                    window,
-                    minp,
-                    index_as_array,
-                    self.closed,
-                    quantile,
-                    interpolation,
-                )
+        if quantile == 1.0:
+            window_func = self._get_cython_func_type("roll_max")
+        elif quantile == 0.0:
+            window_func = self._get_cython_func_type("roll_min")
+        else:
+            window_func = partial(
+                self._get_roll_func("roll_quantile"),
+                win=self._get_window(),
+                quantile=quantile,
+                interpolation=interpolation,
+            )
 
-        return self._apply(f, "quantile", quantile=quantile, **kwargs)
+        # Pass through for groupby.rolling
+        kwargs["quantile"] = quantile
+        kwargs["interpolation"] = interpolation
+        return self._apply(window_func, center=self.center, name="quantile", **kwargs)
 
     _shared_docs[
         "cov"
@@ -1500,7 +1654,11 @@ def _get_cov(X, Y):
             mean = lambda x: x.rolling(
                 window, self.min_periods, center=self.center
             ).mean(**kwargs)
-            count = (X + Y).rolling(window=window, center=self.center).count(**kwargs)
+            count = (
+                (X + Y)
+                .rolling(window=window, min_periods=0, center=self.center)
+                .count(**kwargs)
+            )
             bias_adj = count / (count - ddof)
             return (mean(X * Y) - mean(X) * mean(Y)) * bias_adj
 
@@ -1568,12 +1726,11 @@ def _get_cov(X, Y):
 
     >>> v1 = [3, 3, 3, 5, 8]
     >>> v2 = [3, 4, 4, 4, 8]
-    >>> fmt = "{0:.6f}"  # limit the printed precision to 6 digits
     >>> # numpy returns a 2X2 array, the correlation coefficient
     >>> # is the number at entry [0][1]
-    >>> print(fmt.format(np.corrcoef(v1[:-1], v2[:-1])[0][1]))
+    >>> print(f"{np.corrcoef(v1[:-1], v2[:-1])[0][1]:.6f}")
     0.333333
-    >>> print(fmt.format(np.corrcoef(v1[1:], v2[1:])[0][1]))
+    >>> print(f"{np.corrcoef(v1[1:], v2[1:])[0][1]:.6f}")
     0.916949
     >>> s1 = pd.Series(v1)
     >>> s2 = pd.Series(v2)
@@ -1625,7 +1782,7 @@ def corr(self, other=None, pairwise=None, **kwargs):
             # only default unset
             pairwise = True if pairwise is None else pairwise
         other = self._shallow_copy(other)
-        window = self._get_window(other)
+        window = self._get_window(other) if not self.is_freq_type else self.win_freq
 
         def _get_corr(a, b):
             a = a.rolling(
@@ -1644,26 +1801,27 @@ def _get_corr(a, b):
 
 class Rolling(_Rolling_and_Expanding):
     @cache_readonly
-    def is_datetimelike(self):
+    def is_datetimelike(self) -> bool:
         return isinstance(
             self._on, (ABCDatetimeIndex, ABCTimedeltaIndex, ABCPeriodIndex)
         )
 
     @cache_readonly
-    def _on(self):
-
+    def _on(self) -> Index:
         if self.on is None:
             if self.axis == 0:
                 return self.obj.index
-            elif self.axis == 1:
+            else:
+                # i.e. self.axis == 1
                 return self.obj.columns
+        elif isinstance(self.on, Index):
+            return self.on
         elif isinstance(self.obj, ABCDataFrame) and self.on in self.obj.columns:
             return Index(self.obj[self.on])
         else:
             raise ValueError(
-                "invalid on specified as {0}, "
-                "must be a column (if DataFrame) "
-                "or None".format(self.on)
+                f"invalid on specified as {self.on}, "
+                "must be a column (of DataFrame), an Index or None"
             )
 
     def validate(self):
@@ -1680,9 +1838,8 @@ def validate(self):
             # we don't allow center
             if self.center:
                 raise NotImplementedError(
-                    "center is not implemented "
-                    "for datetimelike and offset "
-                    "based windows"
+                    "center is not implemented for "
+                    "datetimelike and offset based windows"
                 )
 
             # this will raise ValueError on non-fixed freqs
@@ -1694,6 +1851,9 @@ def validate(self):
             if self.min_periods is None:
                 self.min_periods = 1
 
+        elif isinstance(self.window, BaseIndexer):
+            # Passed BaseIndexer subclass should handle all other rolling kwargs
+            return
         elif not is_integer(self.window):
             raise ValueError("window must be an integer")
         elif self.window < 0:
@@ -1706,11 +1866,13 @@ def validate(self):
 
     def _validate_monotonic(self):
         """
-        Validate on is_monotonic.
+        Validate monotonic (increasing or decreasing).
         """
-        if not self._on.is_monotonic:
-            formatted = self.on or "index"
-            raise ValueError("{0} must be monotonic".format(formatted))
+        if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):
+            formatted = self.on
+            if self.on is None:
+                formatted = "index"
+            raise ValueError(f"{formatted} must be monotonic")
 
     def _validate_freq(self):
         """
@@ -1722,9 +1884,8 @@ def _validate_freq(self):
             return to_offset(self.window)
         except (TypeError, ValueError):
             raise ValueError(
-                "passed window {0} is not "
-                "compatible with a datetimelike "
-                "index".format(self.window)
+                f"passed window {self.window} is not "
+                "compatible with a datetimelike index"
             )
 
     _agg_see_also_doc = dedent(
@@ -1802,14 +1963,30 @@ def count(self):
 
         # different impl for freq counting
         if self.is_freq_type:
-            return self._apply("roll_count", "count")
+            window_func = self._get_roll_func("roll_count")
+            return self._apply(window_func, center=self.center, name="count")
 
         return super().count()
 
     @Substitution(name="rolling")
     @Appender(_shared_docs["apply"])
-    def apply(self, func, raw=None, args=(), kwargs={}):
-        return super().apply(func, raw=raw, args=args, kwargs=kwargs)
+    def apply(
+        self,
+        func,
+        raw=False,
+        engine="cython",
+        engine_kwargs=None,
+        args=None,
+        kwargs=None,
+    ):
+        return super().apply(
+            func,
+            raw=raw,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+            args=args,
+            kwargs=kwargs,
+        )
 
     @Substitution(name="rolling")
     @Appender(_shared_docs["sum"])
@@ -1841,13 +2018,13 @@ def mean(self, *args, **kwargs):
     def median(self, **kwargs):
         return super().median(**kwargs)
 
-    @Substitution(name="rolling")
+    @Substitution(name="rolling", versionadded="")
     @Appender(_shared_docs["std"])
     def std(self, ddof=1, *args, **kwargs):
         nv.validate_rolling_func("std", args, kwargs)
         return super().std(ddof=ddof, **kwargs)
 
-    @Substitution(name="rolling")
+    @Substitution(name="rolling", versionadded="")
     @Appender(_shared_docs["var"])
     def var(self, ddof=1, *args, **kwargs):
         nv.validate_rolling_func("var", args, kwargs)
@@ -1868,11 +2045,10 @@ def skew(self, **kwargs):
     four matching the equivalent function call using `scipy.stats`.
 
     >>> arr = [1, 2, 3, 4, 999]
-    >>> fmt = "{0:.6f}"  # limit the printed precision to 6 digits
     >>> import scipy.stats
-    >>> print(fmt.format(scipy.stats.kurtosis(arr[:-1], bias=False)))
+    >>> print(f"{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}")
     -1.200000
-    >>> print(fmt.format(scipy.stats.kurtosis(arr[1:], bias=False)))
+    >>> print(f"{scipy.stats.kurtosis(arr[1:], bias=False):.6f}")
     3.999946
     >>> s = pd.Series(arr)
     >>> s.rolling(4).kurt()
@@ -1913,7 +2089,7 @@ def corr(self, other=None, pairwise=None, **kwargs):
 Rolling.__doc__ = Window.__doc__
 
 
-class RollingGroupby(_GroupByMixin, Rolling):
+class RollingGroupby(WindowGroupByMixin, Rolling):
     """
     Provide a rolling groupby implementation.
     """
diff --git a/pandas/errors/__init__.py b/pandas/errors/__init__.py
index a85fc8bfb1414..ebe9a3d5bf472 100644
--- a/pandas/errors/__init__.py
+++ b/pandas/errors/__init__.py
@@ -25,8 +25,6 @@ class UnsortedIndexError(KeyError):
     """
     Error raised when attempting to get a slice of a MultiIndex,
     and the index has not been lexsorted. Subclass of `KeyError`.
-
-    .. versionadded:: 0.20.0
     """
 
 
@@ -158,28 +156,29 @@ class MergeError(ValueError):
 
 
 class AccessorRegistrationWarning(Warning):
-    """Warning for attribute conflicts in accessor registration."""
+    """
+    Warning for attribute conflicts in accessor registration.
+    """
 
 
 class AbstractMethodError(NotImplementedError):
-    """Raise this error instead of NotImplementedError for abstract methods
+    """
+    Raise this error instead of NotImplementedError for abstract methods
     while keeping compatibility with Python 2 and Python 3.
     """
 
     def __init__(self, class_instance, methodtype="method"):
         types = {"method", "classmethod", "staticmethod", "property"}
         if methodtype not in types:
-            msg = "methodtype must be one of {}, got {} instead.".format(
-                methodtype, types
+            raise ValueError(
+                f"methodtype must be one of {methodtype}, got {types} instead."
             )
-            raise ValueError(msg)
         self.methodtype = methodtype
         self.class_instance = class_instance
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.methodtype == "classmethod":
             name = self.class_instance.__name__
         else:
-            name = self.class_instance.__class__.__name__
-        msg = "This {methodtype} must be defined in the concrete class {name}"
-        return msg.format(methodtype=self.methodtype, name=name)
+            name = type(self.class_instance).__name__
+        return f"This {self.methodtype} must be defined in the concrete class {name}"
diff --git a/pandas/io/api.py b/pandas/io/api.py
index 725e82604ca7f..2d25ffe5f8a6b 100644
--- a/pandas/io/api.py
+++ b/pandas/io/api.py
@@ -10,7 +10,7 @@
 from pandas.io.gbq import read_gbq
 from pandas.io.html import read_html
 from pandas.io.json import read_json
-from pandas.io.packers import read_msgpack, to_msgpack
+from pandas.io.orc import read_orc
 from pandas.io.parquet import read_parquet
 from pandas.io.parsers import read_csv, read_fwf, read_table
 from pandas.io.pickle import read_pickle, to_pickle
diff --git a/pandas/io/clipboard/__init__.py b/pandas/io/clipboard/__init__.py
index caa928731fb3a..6d76d7de407b1 100644
--- a/pandas/io/clipboard/__init__.py
+++ b/pandas/io/clipboard/__init__.py
@@ -1,7 +1,8 @@
 """
 Pyperclip
 
-A cross-platform clipboard module for Python. (only handles plain text for now)
+A cross-platform clipboard module for Python,
+with copy & paste functions for plain text.
 By Al Sweigart al@inventwithpython.com
 BSD License
 
@@ -10,102 +11,584 @@
   pyperclip.copy('The text to be copied to the clipboard.')
   spam = pyperclip.paste()
 
-  if not pyperclip.copy:
+  if not pyperclip.is_available():
     print("Copy functionality unavailable!")
 
 On Windows, no additional modules are needed.
-On Mac, the module uses pbcopy and pbpaste, which should come with the os.
+On Mac, the pyobjc module is used, falling back to the pbcopy and pbpaste cli
+    commands. (These commands should come with OS X.).
 On Linux, install xclip or xsel via package manager. For example, in Debian:
-sudo apt-get install xclip
+    sudo apt-get install xclip
+    sudo apt-get install xsel
 
-Otherwise on Linux, you will need the qtpy or PyQt modules installed.
-qtpy also requires a python-qt-bindings module: PyQt4, PyQt5, PySide, PySide2
+Otherwise on Linux, you will need the PyQt5 modules installed.
 
 This module does not work with PyGObject yet.
+
+Cygwin is currently not supported.
+
+Security Note: This module runs programs with these names:
+    - which
+    - where
+    - pbcopy
+    - pbpaste
+    - xclip
+    - xsel
+    - klipper
+    - qdbus
+A malicious user could rename or add programs with these names, tricking
+Pyperclip into running them with whatever permissions the Python process has.
+
 """
-__version__ = "1.5.27"
+__version__ = "1.7.0"
 
+import contextlib
+import ctypes
+from ctypes import c_size_t, c_wchar, c_wchar_p, get_errno, sizeof
 import os
 import platform
 import subprocess
+import time
+import warnings
 
-from .clipboards import (
-    init_klipper_clipboard,
-    init_no_clipboard,
-    init_osx_clipboard,
-    init_qt_clipboard,
-    init_xclip_clipboard,
-    init_xsel_clipboard,
-)
-from .windows import init_windows_clipboard
-
-# `import qtpy` sys.exit()s if DISPLAY is not in the environment.
+# `import PyQt4` sys.exit()s if DISPLAY is not in the environment.
 # Thus, we need to detect the presence of $DISPLAY manually
-# and not load qtpy if it is absent.
+# and not load PyQt4 if it is absent.
 HAS_DISPLAY = os.getenv("DISPLAY", False)
-CHECK_CMD = "where" if platform.system() == "Windows" else "which"
+
+EXCEPT_MSG = """
+    Pyperclip could not find a copy/paste mechanism for your system.
+    For more information, please visit
+    https://pyperclip.readthedocs.io/en/latest/introduction.html#not-implemented-error
+    """
+
+ENCODING = "utf-8"
+
+# The "which" unix command finds where a command is.
+if platform.system() == "Windows":
+    WHICH_CMD = "where"
+else:
+    WHICH_CMD = "which"
 
 
 def _executable_exists(name):
     return (
         subprocess.call(
-            [CHECK_CMD, name], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            [WHICH_CMD, name], stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
         == 0
     )
 
 
+# Exceptions
+class PyperclipException(RuntimeError):
+    pass
+
+
+class PyperclipWindowsException(PyperclipException):
+    def __init__(self, message):
+        message += f" ({ctypes.WinError()})"
+        super().__init__(message)
+
+
+def _stringifyText(text) -> str:
+    acceptedTypes = (str, int, float, bool)
+    if not isinstance(text, acceptedTypes):
+        raise PyperclipException(
+            f"only str, int, float, and bool values "
+            f"can be copied to the clipboard, not {type(text).__name__}"
+        )
+    return str(text)
+
+
+def init_osx_pbcopy_clipboard():
+    def copy_osx_pbcopy(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        p = subprocess.Popen(["pbcopy", "w"], stdin=subprocess.PIPE, close_fds=True)
+        p.communicate(input=text.encode(ENCODING))
+
+    def paste_osx_pbcopy():
+        p = subprocess.Popen(["pbpaste", "r"], stdout=subprocess.PIPE, close_fds=True)
+        stdout, stderr = p.communicate()
+        return stdout.decode(ENCODING)
+
+    return copy_osx_pbcopy, paste_osx_pbcopy
+
+
+def init_osx_pyobjc_clipboard():
+    def copy_osx_pyobjc(text):
+        """Copy string argument to clipboard"""
+        text = _stringifyText(text)  # Converts non-str values to str.
+        newStr = Foundation.NSString.stringWithString_(text).nsstring()
+        newData = newStr.dataUsingEncoding_(Foundation.NSUTF8StringEncoding)
+        board = AppKit.NSPasteboard.generalPasteboard()
+        board.declareTypes_owner_([AppKit.NSStringPboardType], None)
+        board.setData_forType_(newData, AppKit.NSStringPboardType)
+
+    def paste_osx_pyobjc():
+        """Returns contents of clipboard"""
+        board = AppKit.NSPasteboard.generalPasteboard()
+        content = board.stringForType_(AppKit.NSStringPboardType)
+        return content
+
+    return copy_osx_pyobjc, paste_osx_pyobjc
+
+
+def init_qt_clipboard():
+    global QApplication
+    # $DISPLAY should exist
+
+    # Try to import from qtpy, but if that fails try PyQt5 then PyQt4
+    try:
+        from qtpy.QtWidgets import QApplication
+    except ImportError:
+        try:
+            from PyQt5.QtWidgets import QApplication
+        except ImportError:
+            from PyQt4.QtGui import QApplication
+
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication([])
+
+    def copy_qt(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        cb = app.clipboard()
+        cb.setText(text)
+
+    def paste_qt() -> str:
+        cb = app.clipboard()
+        return str(cb.text())
+
+    return copy_qt, paste_qt
+
+
+def init_xclip_clipboard():
+    DEFAULT_SELECTION = "c"
+    PRIMARY_SELECTION = "p"
+
+    def copy_xclip(text, primary=False):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        p = subprocess.Popen(
+            ["xclip", "-selection", selection], stdin=subprocess.PIPE, close_fds=True
+        )
+        p.communicate(input=text.encode(ENCODING))
+
+    def paste_xclip(primary=False):
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        p = subprocess.Popen(
+            ["xclip", "-selection", selection, "-o"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            close_fds=True,
+        )
+        stdout, stderr = p.communicate()
+        # Intentionally ignore extraneous output on stderr when clipboard is empty
+        return stdout.decode(ENCODING)
+
+    return copy_xclip, paste_xclip
+
+
+def init_xsel_clipboard():
+    DEFAULT_SELECTION = "-b"
+    PRIMARY_SELECTION = "-p"
+
+    def copy_xsel(text, primary=False):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        p = subprocess.Popen(
+            ["xsel", selection_flag, "-i"], stdin=subprocess.PIPE, close_fds=True
+        )
+        p.communicate(input=text.encode(ENCODING))
+
+    def paste_xsel(primary=False):
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        p = subprocess.Popen(
+            ["xsel", selection_flag, "-o"], stdout=subprocess.PIPE, close_fds=True
+        )
+        stdout, stderr = p.communicate()
+        return stdout.decode(ENCODING)
+
+    return copy_xsel, paste_xsel
+
+
+def init_klipper_clipboard():
+    def copy_klipper(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        p = subprocess.Popen(
+            [
+                "qdbus",
+                "org.kde.klipper",
+                "/klipper",
+                "setClipboardContents",
+                text.encode(ENCODING),
+            ],
+            stdin=subprocess.PIPE,
+            close_fds=True,
+        )
+        p.communicate(input=None)
+
+    def paste_klipper():
+        p = subprocess.Popen(
+            ["qdbus", "org.kde.klipper", "/klipper", "getClipboardContents"],
+            stdout=subprocess.PIPE,
+            close_fds=True,
+        )
+        stdout, stderr = p.communicate()
+
+        # Workaround for https://bugs.kde.org/show_bug.cgi?id=342874
+        # TODO: https://github.com/asweigart/pyperclip/issues/43
+        clipboardContents = stdout.decode(ENCODING)
+        # even if blank, Klipper will append a newline at the end
+        assert len(clipboardContents) > 0
+        # make sure that newline is there
+        assert clipboardContents.endswith("\n")
+        if clipboardContents.endswith("\n"):
+            clipboardContents = clipboardContents[:-1]
+        return clipboardContents
+
+    return copy_klipper, paste_klipper
+
+
+def init_dev_clipboard_clipboard():
+    def copy_dev_clipboard(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        if text == "":
+            warnings.warn(
+                "Pyperclip cannot copy a blank string to the clipboard on Cygwin."
+                "This is effectively a no-op."
+            )
+        if "\r" in text:
+            warnings.warn("Pyperclip cannot handle \\r characters on Cygwin.")
+
+        with open("/dev/clipboard", "wt") as fo:
+            fo.write(text)
+
+    def paste_dev_clipboard() -> str:
+        with open("/dev/clipboard", "rt") as fo:
+            content = fo.read()
+        return content
+
+    return copy_dev_clipboard, paste_dev_clipboard
+
+
+def init_no_clipboard():
+    class ClipboardUnavailable:
+        def __call__(self, *args, **kwargs):
+            raise PyperclipException(EXCEPT_MSG)
+
+        def __bool__(self) -> bool:
+            return False
+
+    return ClipboardUnavailable(), ClipboardUnavailable()
+
+
+# Windows-related clipboard functions:
+class CheckedCall:
+    def __init__(self, f):
+        super().__setattr__("f", f)
+
+    def __call__(self, *args):
+        ret = self.f(*args)
+        if not ret and get_errno():
+            raise PyperclipWindowsException("Error calling " + self.f.__name__)
+        return ret
+
+    def __setattr__(self, key, value):
+        setattr(self.f, key, value)
+
+
+def init_windows_clipboard():
+    global HGLOBAL, LPVOID, DWORD, LPCSTR, INT
+    global HWND, HINSTANCE, HMENU, BOOL, UINT, HANDLE
+    from ctypes.wintypes import (
+        HGLOBAL,
+        LPVOID,
+        DWORD,
+        LPCSTR,
+        INT,
+        HWND,
+        HINSTANCE,
+        HMENU,
+        BOOL,
+        UINT,
+        HANDLE,
+    )
+
+    windll = ctypes.windll
+    msvcrt = ctypes.CDLL("msvcrt")
+
+    safeCreateWindowExA = CheckedCall(windll.user32.CreateWindowExA)
+    safeCreateWindowExA.argtypes = [
+        DWORD,
+        LPCSTR,
+        LPCSTR,
+        DWORD,
+        INT,
+        INT,
+        INT,
+        INT,
+        HWND,
+        HMENU,
+        HINSTANCE,
+        LPVOID,
+    ]
+    safeCreateWindowExA.restype = HWND
+
+    safeDestroyWindow = CheckedCall(windll.user32.DestroyWindow)
+    safeDestroyWindow.argtypes = [HWND]
+    safeDestroyWindow.restype = BOOL
+
+    OpenClipboard = windll.user32.OpenClipboard
+    OpenClipboard.argtypes = [HWND]
+    OpenClipboard.restype = BOOL
+
+    safeCloseClipboard = CheckedCall(windll.user32.CloseClipboard)
+    safeCloseClipboard.argtypes = []
+    safeCloseClipboard.restype = BOOL
+
+    safeEmptyClipboard = CheckedCall(windll.user32.EmptyClipboard)
+    safeEmptyClipboard.argtypes = []
+    safeEmptyClipboard.restype = BOOL
+
+    safeGetClipboardData = CheckedCall(windll.user32.GetClipboardData)
+    safeGetClipboardData.argtypes = [UINT]
+    safeGetClipboardData.restype = HANDLE
+
+    safeSetClipboardData = CheckedCall(windll.user32.SetClipboardData)
+    safeSetClipboardData.argtypes = [UINT, HANDLE]
+    safeSetClipboardData.restype = HANDLE
+
+    safeGlobalAlloc = CheckedCall(windll.kernel32.GlobalAlloc)
+    safeGlobalAlloc.argtypes = [UINT, c_size_t]
+    safeGlobalAlloc.restype = HGLOBAL
+
+    safeGlobalLock = CheckedCall(windll.kernel32.GlobalLock)
+    safeGlobalLock.argtypes = [HGLOBAL]
+    safeGlobalLock.restype = LPVOID
+
+    safeGlobalUnlock = CheckedCall(windll.kernel32.GlobalUnlock)
+    safeGlobalUnlock.argtypes = [HGLOBAL]
+    safeGlobalUnlock.restype = BOOL
+
+    wcslen = CheckedCall(msvcrt.wcslen)
+    wcslen.argtypes = [c_wchar_p]
+    wcslen.restype = UINT
+
+    GMEM_MOVEABLE = 0x0002
+    CF_UNICODETEXT = 13
+
+    @contextlib.contextmanager
+    def window():
+        """
+        Context that provides a valid Windows hwnd.
+        """
+        # we really just need the hwnd, so setting "STATIC"
+        # as predefined lpClass is just fine.
+        hwnd = safeCreateWindowExA(
+            0, b"STATIC", None, 0, 0, 0, 0, 0, None, None, None, None
+        )
+        try:
+            yield hwnd
+        finally:
+            safeDestroyWindow(hwnd)
+
+    @contextlib.contextmanager
+    def clipboard(hwnd):
+        """
+        Context manager that opens the clipboard and prevents
+        other applications from modifying the clipboard content.
+        """
+        # We may not get the clipboard handle immediately because
+        # some other application is accessing it (?)
+        # We try for at least 500ms to get the clipboard.
+        t = time.time() + 0.5
+        success = False
+        while time.time() < t:
+            success = OpenClipboard(hwnd)
+            if success:
+                break
+            time.sleep(0.01)
+        if not success:
+            raise PyperclipWindowsException("Error calling OpenClipboard")
+
+        try:
+            yield
+        finally:
+            safeCloseClipboard()
+
+    def copy_windows(text):
+        # This function is heavily based on
+        # http://msdn.com/ms649016#_win32_Copying_Information_to_the_Clipboard
+
+        text = _stringifyText(text)  # Converts non-str values to str.
+
+        with window() as hwnd:
+            # http://msdn.com/ms649048
+            # If an application calls OpenClipboard with hwnd set to NULL,
+            # EmptyClipboard sets the clipboard owner to NULL;
+            # this causes SetClipboardData to fail.
+            # => We need a valid hwnd to copy something.
+            with clipboard(hwnd):
+                safeEmptyClipboard()
+
+                if text:
+                    # http://msdn.com/ms649051
+                    # If the hMem parameter identifies a memory object,
+                    # the object must have been allocated using the
+                    # function with the GMEM_MOVEABLE flag.
+                    count = wcslen(text) + 1
+                    handle = safeGlobalAlloc(GMEM_MOVEABLE, count * sizeof(c_wchar))
+                    locked_handle = safeGlobalLock(handle)
+
+                    ctypes.memmove(
+                        c_wchar_p(locked_handle),
+                        c_wchar_p(text),
+                        count * sizeof(c_wchar),
+                    )
+
+                    safeGlobalUnlock(handle)
+                    safeSetClipboardData(CF_UNICODETEXT, handle)
+
+    def paste_windows():
+        with clipboard(None):
+            handle = safeGetClipboardData(CF_UNICODETEXT)
+            if not handle:
+                # GetClipboardData may return NULL with errno == NO_ERROR
+                # if the clipboard is empty.
+                # (Also, it may return a handle to an empty buffer,
+                # but technically that's not empty)
+                return ""
+            return c_wchar_p(handle).value
+
+    return copy_windows, paste_windows
+
+
+def init_wsl_clipboard():
+    def copy_wsl(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        p = subprocess.Popen(["clip.exe"], stdin=subprocess.PIPE, close_fds=True)
+        p.communicate(input=text.encode(ENCODING))
+
+    def paste_wsl():
+        p = subprocess.Popen(
+            ["powershell.exe", "-command", "Get-Clipboard"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            close_fds=True,
+        )
+        stdout, stderr = p.communicate()
+        # WSL appends "\r\n" to the contents.
+        return stdout[:-2].decode(ENCODING)
+
+    return copy_wsl, paste_wsl
+
+
+# Automatic detection of clipboard mechanisms
+# and importing is done in deteremine_clipboard():
 def determine_clipboard():
-    # Determine the OS/platform and set
-    # the copy() and paste() functions accordingly.
-    if "cygwin" in platform.system().lower():
+    """
+    Determine the OS/platform and set the copy() and paste() functions
+    accordingly.
+    """
+
+    global Foundation, AppKit, qtpy, PyQt4, PyQt5
+
+    # Setup for the CYGWIN platform:
+    if (
+        "cygwin" in platform.system().lower()
+    ):  # Cygwin has a variety of values returned by platform.system(),
+        # such as 'CYGWIN_NT-6.1'
         # FIXME: pyperclip currently does not support Cygwin,
         # see https://github.com/asweigart/pyperclip/issues/55
-        pass
+        if os.path.exists("/dev/clipboard"):
+            warnings.warn(
+                "Pyperclip's support for Cygwin is not perfect,"
+                "see https://github.com/asweigart/pyperclip/issues/55"
+            )
+            return init_dev_clipboard_clipboard()
+
+    # Setup for the WINDOWS platform:
     elif os.name == "nt" or platform.system() == "Windows":
         return init_windows_clipboard()
+
+    if platform.system() == "Linux":
+        with open("/proc/version", "r") as f:
+            if "Microsoft" in f.read():
+                return init_wsl_clipboard()
+
+    # Setup for the MAC OS X platform:
     if os.name == "mac" or platform.system() == "Darwin":
-        return init_osx_clipboard()
+        try:
+            import Foundation  # check if pyobjc is installed
+            import AppKit
+        except ImportError:
+            return init_osx_pbcopy_clipboard()
+        else:
+            return init_osx_pyobjc_clipboard()
+
+    # Setup for the LINUX platform:
     if HAS_DISPLAY:
-        # Determine which command/module is installed, if any.
+        if _executable_exists("xsel"):
+            return init_xsel_clipboard()
+        if _executable_exists("xclip"):
+            return init_xclip_clipboard()
+        if _executable_exists("klipper") and _executable_exists("qdbus"):
+            return init_klipper_clipboard()
+
         try:
-            # qtpy is a small abstraction layer that lets you write
-            # applications using a single api call to either PyQt or PySide
-            # https://pypi.org/project/QtPy
-            import qtpy  # noqa
+            # qtpy is a small abstraction layer that lets you write applications
+            # using a single api call to either PyQt or PySide.
+            # https://pypi.python.org/project/QtPy
+            import qtpy  # check if qtpy is installed
         except ImportError:
-            # If qtpy isn't installed, fall back on importing PyQt5, or PyQt5
+            # If qtpy isn't installed, fall back on importing PyQt4.
             try:
-                import PyQt5  # noqa
+                import PyQt5  # check if PyQt5 is installed
             except ImportError:
                 try:
-                    import PyQt4  # noqa
+                    import PyQt4  # check if PyQt4 is installed
                 except ImportError:
-                    pass  # fail fast for all non-ImportError exceptions.
+                    pass  # We want to fail fast for all non-ImportError exceptions.
                 else:
                     return init_qt_clipboard()
             else:
                 return init_qt_clipboard()
-            pass
         else:
             return init_qt_clipboard()
 
-        if _executable_exists("xclip"):
-            return init_xclip_clipboard()
-        if _executable_exists("xsel"):
-            return init_xsel_clipboard()
-        if _executable_exists("klipper") and _executable_exists("qdbus"):
-            return init_klipper_clipboard()
-
     return init_no_clipboard()
 
 
 def set_clipboard(clipboard):
+    """
+    Explicitly sets the clipboard mechanism. The "clipboard mechanism" is how
+    the copy() and paste() functions interact with the operating system to
+    implement the copy/paste feature. The clipboard parameter must be one of:
+        - pbcopy
+        - pbobjc (default on Mac OS X)
+        - qt
+        - xclip
+        - xsel
+        - klipper
+        - windows (default on Windows)
+        - no (this is what is set when no clipboard mechanism can be found)
+    """
     global copy, paste
 
     clipboard_types = {
-        "osx": init_osx_clipboard,
-        "qt": init_qt_clipboard,
+        "pbcopy": init_osx_pbcopy_clipboard,
+        "pyobjc": init_osx_pyobjc_clipboard,
+        "qt": init_qt_clipboard,  # TODO - split this into 'qtpy', 'pyqt4', and 'pyqt5'
         "xclip": init_xclip_clipboard,
         "xsel": init_xsel_clipboard,
         "klipper": init_klipper_clipboard,
@@ -113,13 +596,71 @@ def set_clipboard(clipboard):
         "no": init_no_clipboard,
     }
 
+    if clipboard not in clipboard_types:
+        allowed_clipboard_types = [repr(_) for _ in clipboard_types.keys()]
+        raise ValueError(
+            f"Argument must be one of {', '.join(allowed_clipboard_types)}"
+        )
+
+    # Sets pyperclip's copy() and paste() functions:
     copy, paste = clipboard_types[clipboard]()
 
 
-copy, paste = determine_clipboard()
+def lazy_load_stub_copy(text):
+    """
+    A stub function for copy(), which will load the real copy() function when
+    called so that the real copy() function is used for later calls.
+
+    This allows users to import pyperclip without having determine_clipboard()
+    automatically run, which will automatically select a clipboard mechanism.
+    This could be a problem if it selects, say, the memory-heavy PyQt4 module
+    but the user was just going to immediately call set_clipboard() to use a
+    different clipboard mechanism.
+
+    The lazy loading this stub function implements gives the user a chance to
+    call set_clipboard() to pick another clipboard mechanism. Or, if the user
+    simply calls copy() or paste() without calling set_clipboard() first,
+    will fall back on whatever clipboard mechanism that determine_clipboard()
+    automatically chooses.
+    """
+    global copy, paste
+    copy, paste = determine_clipboard()
+    return copy(text)
+
+
+def lazy_load_stub_paste():
+    """
+    A stub function for paste(), which will load the real paste() function when
+    called so that the real paste() function is used for later calls.
+
+    This allows users to import pyperclip without having determine_clipboard()
+    automatically run, which will automatically select a clipboard mechanism.
+    This could be a problem if it selects, say, the memory-heavy PyQt4 module
+    but the user was just going to immediately call set_clipboard() to use a
+    different clipboard mechanism.
+
+    The lazy loading this stub function implements gives the user a chance to
+    call set_clipboard() to pick another clipboard mechanism. Or, if the user
+    simply calls copy() or paste() without calling set_clipboard() first,
+    will fall back on whatever clipboard mechanism that determine_clipboard()
+    automatically chooses.
+    """
+    global copy, paste
+    copy, paste = determine_clipboard()
+    return paste()
+
+
+def is_available() -> bool:
+    return copy != lazy_load_stub_copy and paste != lazy_load_stub_paste
+
+
+# Initially, copy() and paste() are set to lazy loading wrappers which will
+# set `copy` and `paste` to real functions the first time they're used, unless
+# set_clipboard() or determine_clipboard() is called first.
+copy, paste = lazy_load_stub_copy, lazy_load_stub_paste
 
-__all__ = ["copy", "paste"]
 
+__all__ = ["copy", "paste", "set_clipboard", "determine_clipboard"]
 
 # pandas aliases
 clipboard_get = paste
diff --git a/pandas/io/clipboard/clipboards.py b/pandas/io/clipboard/clipboards.py
deleted file mode 100644
index cb4ed8ed549d0..0000000000000
--- a/pandas/io/clipboard/clipboards.py
+++ /dev/null
@@ -1,129 +0,0 @@
-import subprocess
-
-from .exceptions import PyperclipException
-
-EXCEPT_MSG = """
-    Pyperclip could not find a copy/paste mechanism for your system.
-    For more information, please visit https://pyperclip.readthedocs.org """
-
-
-def init_osx_clipboard():
-    def copy_osx(text):
-        p = subprocess.Popen(["pbcopy", "w"], stdin=subprocess.PIPE, close_fds=True)
-        p.communicate(input=text.encode("utf-8"))
-
-    def paste_osx():
-        p = subprocess.Popen(["pbpaste", "r"], stdout=subprocess.PIPE, close_fds=True)
-        stdout, stderr = p.communicate()
-        return stdout.decode("utf-8")
-
-    return copy_osx, paste_osx
-
-
-def init_qt_clipboard():
-    # $DISPLAY should exist
-
-    # Try to import from qtpy, but if that fails try PyQt5 then PyQt4
-    try:
-        from qtpy.QtWidgets import QApplication
-    except ImportError:
-        try:
-            from PyQt5.QtWidgets import QApplication
-        except ImportError:
-            from PyQt4.QtGui import QApplication
-
-    app = QApplication.instance()
-    if app is None:
-        app = QApplication([])
-
-    def copy_qt(text):
-        cb = app.clipboard()
-        cb.setText(text)
-
-    def paste_qt():
-        cb = app.clipboard()
-        return str(cb.text())
-
-    return copy_qt, paste_qt
-
-
-def init_xclip_clipboard():
-    def copy_xclip(text):
-        p = subprocess.Popen(
-            ["xclip", "-selection", "c"], stdin=subprocess.PIPE, close_fds=True
-        )
-        p.communicate(input=text.encode("utf-8"))
-
-    def paste_xclip():
-        p = subprocess.Popen(
-            ["xclip", "-selection", "c", "-o"], stdout=subprocess.PIPE, close_fds=True
-        )
-        stdout, stderr = p.communicate()
-        return stdout.decode("utf-8")
-
-    return copy_xclip, paste_xclip
-
-
-def init_xsel_clipboard():
-    def copy_xsel(text):
-        p = subprocess.Popen(
-            ["xsel", "-b", "-i"], stdin=subprocess.PIPE, close_fds=True
-        )
-        p.communicate(input=text.encode("utf-8"))
-
-    def paste_xsel():
-        p = subprocess.Popen(
-            ["xsel", "-b", "-o"], stdout=subprocess.PIPE, close_fds=True
-        )
-        stdout, stderr = p.communicate()
-        return stdout.decode("utf-8")
-
-    return copy_xsel, paste_xsel
-
-
-def init_klipper_clipboard():
-    def copy_klipper(text):
-        p = subprocess.Popen(
-            [
-                "qdbus",
-                "org.kde.klipper",
-                "/klipper",
-                "setClipboardContents",
-                text.encode("utf-8"),
-            ],
-            stdin=subprocess.PIPE,
-            close_fds=True,
-        )
-        p.communicate(input=None)
-
-    def paste_klipper():
-        p = subprocess.Popen(
-            ["qdbus", "org.kde.klipper", "/klipper", "getClipboardContents"],
-            stdout=subprocess.PIPE,
-            close_fds=True,
-        )
-        stdout, stderr = p.communicate()
-
-        # Workaround for https://bugs.kde.org/show_bug.cgi?id=342874
-        # TODO: https://github.com/asweigart/pyperclip/issues/43
-        clipboardContents = stdout.decode("utf-8")
-        # even if blank, Klipper will append a newline at the end
-        assert len(clipboardContents) > 0
-        # make sure that newline is there
-        assert clipboardContents.endswith("\n")
-        if clipboardContents.endswith("\n"):
-            clipboardContents = clipboardContents[:-1]
-        return clipboardContents
-
-    return copy_klipper, paste_klipper
-
-
-def init_no_clipboard():
-    class ClipboardUnavailable:
-        def __call__(self, *args, **kwargs):
-            raise PyperclipException(EXCEPT_MSG)
-
-        def __bool__(self):
-            return False
-
-    return ClipboardUnavailable(), ClipboardUnavailable()
diff --git a/pandas/io/clipboard/exceptions.py b/pandas/io/clipboard/exceptions.py
deleted file mode 100644
index eaf5578b5cd1b..0000000000000
--- a/pandas/io/clipboard/exceptions.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import ctypes
-
-
-class PyperclipException(RuntimeError):
-    pass
-
-
-class PyperclipWindowsException(PyperclipException):
-    def __init__(self, message):
-        message += " ({err})".format(err=ctypes.WinError())
-        super().__init__(message)
diff --git a/pandas/io/clipboard/windows.py b/pandas/io/clipboard/windows.py
deleted file mode 100644
index 2935dfdc2ae19..0000000000000
--- a/pandas/io/clipboard/windows.py
+++ /dev/null
@@ -1,184 +0,0 @@
-"""
-This module implements clipboard handling on Windows using ctypes.
-"""
-import contextlib
-import ctypes
-from ctypes import c_size_t, c_wchar, c_wchar_p, get_errno, sizeof
-import time
-
-from .exceptions import PyperclipWindowsException
-
-
-class CheckedCall:
-    def __init__(self, f):
-        super().__setattr__("f", f)
-
-    def __call__(self, *args):
-        ret = self.f(*args)
-        if not ret and get_errno():
-            raise PyperclipWindowsException("Error calling " + self.f.__name__)
-        return ret
-
-    def __setattr__(self, key, value):
-        setattr(self.f, key, value)
-
-
-def init_windows_clipboard():
-    from ctypes.wintypes import (
-        HGLOBAL,
-        LPVOID,
-        DWORD,
-        LPCSTR,
-        INT,
-        HWND,
-        HINSTANCE,
-        HMENU,
-        BOOL,
-        UINT,
-        HANDLE,
-    )
-
-    windll = ctypes.windll
-    msvcrt = ctypes.CDLL("msvcrt")
-
-    safeCreateWindowExA = CheckedCall(windll.user32.CreateWindowExA)
-    safeCreateWindowExA.argtypes = [
-        DWORD,
-        LPCSTR,
-        LPCSTR,
-        DWORD,
-        INT,
-        INT,
-        INT,
-        INT,
-        HWND,
-        HMENU,
-        HINSTANCE,
-        LPVOID,
-    ]
-    safeCreateWindowExA.restype = HWND
-
-    safeDestroyWindow = CheckedCall(windll.user32.DestroyWindow)
-    safeDestroyWindow.argtypes = [HWND]
-    safeDestroyWindow.restype = BOOL
-
-    OpenClipboard = windll.user32.OpenClipboard
-    OpenClipboard.argtypes = [HWND]
-    OpenClipboard.restype = BOOL
-
-    safeCloseClipboard = CheckedCall(windll.user32.CloseClipboard)
-    safeCloseClipboard.argtypes = []
-    safeCloseClipboard.restype = BOOL
-
-    safeEmptyClipboard = CheckedCall(windll.user32.EmptyClipboard)
-    safeEmptyClipboard.argtypes = []
-    safeEmptyClipboard.restype = BOOL
-
-    safeGetClipboardData = CheckedCall(windll.user32.GetClipboardData)
-    safeGetClipboardData.argtypes = [UINT]
-    safeGetClipboardData.restype = HANDLE
-
-    safeSetClipboardData = CheckedCall(windll.user32.SetClipboardData)
-    safeSetClipboardData.argtypes = [UINT, HANDLE]
-    safeSetClipboardData.restype = HANDLE
-
-    safeGlobalAlloc = CheckedCall(windll.kernel32.GlobalAlloc)
-    safeGlobalAlloc.argtypes = [UINT, c_size_t]
-    safeGlobalAlloc.restype = HGLOBAL
-
-    safeGlobalLock = CheckedCall(windll.kernel32.GlobalLock)
-    safeGlobalLock.argtypes = [HGLOBAL]
-    safeGlobalLock.restype = LPVOID
-
-    safeGlobalUnlock = CheckedCall(windll.kernel32.GlobalUnlock)
-    safeGlobalUnlock.argtypes = [HGLOBAL]
-    safeGlobalUnlock.restype = BOOL
-
-    wcslen = CheckedCall(msvcrt.wcslen)
-    wcslen.argtypes = [c_wchar_p]
-    wcslen.restype = UINT
-
-    GMEM_MOVEABLE = 0x0002
-    CF_UNICODETEXT = 13
-
-    @contextlib.contextmanager
-    def window():
-        """
-        Context that provides a valid Windows hwnd.
-        """
-        # we really just need the hwnd, so setting "STATIC"
-        # as predefined lpClass is just fine.
-        hwnd = safeCreateWindowExA(
-            0, b"STATIC", None, 0, 0, 0, 0, 0, None, None, None, None
-        )
-        try:
-            yield hwnd
-        finally:
-            safeDestroyWindow(hwnd)
-
-    @contextlib.contextmanager
-    def clipboard(hwnd):
-        """
-        Context manager that opens the clipboard and prevents
-        other applications from modifying the clipboard content.
-        """
-        # We may not get the clipboard handle immediately because
-        # some other application is accessing it (?)
-        # We try for at least 500ms to get the clipboard.
-        t = time.time() + 0.5
-        success = False
-        while time.time() < t:
-            success = OpenClipboard(hwnd)
-            if success:
-                break
-            time.sleep(0.01)
-        if not success:
-            raise PyperclipWindowsException("Error calling OpenClipboard")
-
-        try:
-            yield
-        finally:
-            safeCloseClipboard()
-
-    def copy_windows(text):
-        # This function is heavily based on
-        # http://msdn.com/ms649016#_win32_Copying_Information_to_the_Clipboard
-        with window() as hwnd:
-            # http://msdn.com/ms649048
-            # If an application calls OpenClipboard with hwnd set to NULL,
-            # EmptyClipboard sets the clipboard owner to NULL;
-            # this causes SetClipboardData to fail.
-            # => We need a valid hwnd to copy something.
-            with clipboard(hwnd):
-                safeEmptyClipboard()
-
-                if text:
-                    # http://msdn.com/ms649051
-                    # If the hMem parameter identifies a memory object,
-                    # the object must have been allocated using the
-                    # function with the GMEM_MOVEABLE flag.
-                    count = wcslen(text) + 1
-                    handle = safeGlobalAlloc(GMEM_MOVEABLE, count * sizeof(c_wchar))
-                    locked_handle = safeGlobalLock(handle)
-
-                    ctypes.memmove(
-                        c_wchar_p(locked_handle),
-                        c_wchar_p(text),
-                        count * sizeof(c_wchar),
-                    )
-
-                    safeGlobalUnlock(handle)
-                    safeSetClipboardData(CF_UNICODETEXT, handle)
-
-    def paste_windows():
-        with clipboard(None):
-            handle = safeGetClipboardData(CF_UNICODETEXT)
-            if not handle:
-                # GetClipboardData may return NULL with errno == NO_ERROR
-                # if the clipboard is empty.
-                # (Also, it may return a handle to an empty buffer,
-                # but technically that's not empty)
-                return ""
-            return c_wchar_p(handle).value
-
-    return copy_windows, paste_windows
diff --git a/pandas/io/clipboards.py b/pandas/io/clipboards.py
index 76c01535a26e7..97178261bdf72 100644
--- a/pandas/io/clipboards.py
+++ b/pandas/io/clipboards.py
@@ -69,8 +69,7 @@ def read_clipboard(sep=r"\s+", **kwargs):  # pragma: no cover
         kwargs["engine"] = "python"
     elif len(sep) > 1 and kwargs.get("engine") == "c":
         warnings.warn(
-            "read_clipboard with regex separator does not work"
-            " properly with c engine"
+            "read_clipboard with regex separator does not work properly with c engine"
         )
 
     return read_csv(StringIO(text), sep=sep, **kwargs)
@@ -131,7 +130,7 @@ def to_clipboard(obj, excel=True, sep=None, **kwargs):  # pragma: no cover
 
     if isinstance(obj, ABCDataFrame):
         # str(df) has various unhelpful defaults, like truncation
-        with option_context("display.max_colwidth", 999999):
+        with option_context("display.max_colwidth", None):
             objstr = obj.to_string(**kwargs)
     else:
         objstr = str(obj)
diff --git a/pandas/io/common.py b/pandas/io/common.py
index 2ca2007e2925f..c4772895afd1e 100644
--- a/pandas/io/common.py
+++ b/pandas/io/common.py
@@ -1,22 +1,21 @@
 """Common IO api utilities"""
 
 import bz2
-import codecs
-import csv
+from collections import abc
 import gzip
-from io import BufferedIOBase, BytesIO
+from io import BufferedIOBase, BytesIO, RawIOBase
 import mmap
 import os
 import pathlib
 from typing import (
     IO,
+    TYPE_CHECKING,
     Any,
     AnyStr,
-    BinaryIO,
     Dict,
     List,
+    Mapping,
     Optional,
-    TextIO,
     Tuple,
     Type,
     Union,
@@ -31,6 +30,7 @@
 )
 import zipfile
 
+from pandas._typing import FilePathOrBuffer
 from pandas.compat import _get_lzma_file, _import_lzma
 from pandas.errors import (  # noqa
     AbstractMethodError,
@@ -42,54 +42,18 @@
 
 from pandas.core.dtypes.common import is_file_like
 
-from pandas._typing import FilePathOrBuffer
-
 lzma = _import_lzma()
 
-# gh-12665: Alias for now and remove later.
-CParserError = ParserError
-
-# common NA values
-# no longer excluding inf representations
-# '1.#INF','-1.#INF', '1.#INF000000',
-_NA_VALUES = {
-    "-1.#IND",
-    "1.#QNAN",
-    "1.#IND",
-    "-1.#QNAN",
-    "#N/A N/A",
-    "#N/A",
-    "N/A",
-    "n/a",
-    "NA",
-    "#NA",
-    "NULL",
-    "null",
-    "NaN",
-    "-NaN",
-    "nan",
-    "-nan",
-    "",
-}
-
 
 _VALID_URLS = set(uses_relative + uses_netloc + uses_params)
 _VALID_URLS.discard("")
 
 
-class BaseIterator:
-    """Subclass this and provide a "__next__()" method to obtain an iterator.
-    Useful only when the object being iterated is non-reusable (e.g. OK for a
-    parser, not for an in-memory table, yes for its iterator)."""
-
-    def __iter__(self) -> "BaseIterator":
-        return self
-
-    def __next__(self):
-        raise AbstractMethodError(self)
+if TYPE_CHECKING:
+    from io import IOBase  # noqa: F401
 
 
-def _is_url(url) -> bool:
+def is_url(url) -> bool:
     """
     Check to see if a URL has a valid protocol.
 
@@ -108,7 +72,7 @@ def _is_url(url) -> bool:
 
 
 def _expand_user(
-    filepath_or_buffer: FilePathOrBuffer[AnyStr]
+    filepath_or_buffer: FilePathOrBuffer[AnyStr],
 ) -> FilePathOrBuffer[AnyStr]:
     """Return the argument with an initial component of ~ or ~user
        replaced by that user's home directory.
@@ -127,18 +91,17 @@ def _expand_user(
     return filepath_or_buffer
 
 
-def _validate_header_arg(header) -> None:
+def validate_header_arg(header) -> None:
     if isinstance(header, bool):
         raise TypeError(
-            "Passing a bool to header is invalid. "
-            "Use header=None for no header or "
+            "Passing a bool to header is invalid. Use header=None for no header or "
             "header=int or list-like of ints to specify "
             "the row(s) making up the column names"
         )
 
 
-def _stringify_path(
-    filepath_or_buffer: FilePathOrBuffer[AnyStr]
+def stringify_path(
+    filepath_or_buffer: FilePathOrBuffer[AnyStr],
 ) -> FilePathOrBuffer[AnyStr]:
     """Attempt to convert a path-like object to a string.
 
@@ -213,14 +176,13 @@ def get_filepath_or_buffer(
 
     Returns
     -------
-    tuple of ({a filepath_ or buffer or S3File instance},
-              encoding, str,
-              compression, str,
-              should_close, bool)
+    Tuple[FilePathOrBuffer, str, str, bool]
+        Tuple containing the filepath or buffer, the encoding, the compression
+        and should_close.
     """
-    filepath_or_buffer = _stringify_path(filepath_or_buffer)
+    filepath_or_buffer = stringify_path(filepath_or_buffer)
 
-    if isinstance(filepath_or_buffer, str) and _is_url(filepath_or_buffer):
+    if isinstance(filepath_or_buffer, str) and is_url(filepath_or_buffer):
         req = urlopen(filepath_or_buffer)
         content_encoding = req.headers.get("Content-Encoding", None)
         if content_encoding == "gzip":
@@ -248,8 +210,8 @@ def get_filepath_or_buffer(
         return _expand_user(filepath_or_buffer), None, compression, False
 
     if not is_file_like(filepath_or_buffer):
-        msg = "Invalid file path or buffer object type: {_type}"
-        raise ValueError(msg.format(_type=type(filepath_or_buffer)))
+        msg = f"Invalid file path or buffer object type: {type(filepath_or_buffer)}"
+        raise ValueError(msg)
 
     return filepath_or_buffer, None, compression, False
 
@@ -275,17 +237,17 @@ def file_path_to_url(path: str) -> str:
 _compression_to_extension = {"gzip": ".gz", "bz2": ".bz2", "zip": ".zip", "xz": ".xz"}
 
 
-def _get_compression_method(
-    compression: Optional[Union[str, Dict[str, str]]]
+def get_compression_method(
+    compression: Optional[Union[str, Mapping[str, str]]]
 ) -> Tuple[Optional[str], Dict[str, str]]:
     """
     Simplifies a compression argument to a compression method string and
-    a dict containing additional arguments.
+    a mapping containing additional arguments.
 
     Parameters
     ----------
-    compression : str or dict
-        If string, specifies the compression method. If dict, value at key
+    compression : str or mapping
+        If string, specifies the compression method. If mapping, value at key
         'method' specifies compression method.
 
     Returns
@@ -295,21 +257,20 @@ def _get_compression_method(
 
     Raises
     ------
-    ValueError on dict missing 'method' key
+    ValueError on mapping missing 'method' key
     """
-    # Handle dict
-    if isinstance(compression, dict):
-        compression_args = compression.copy()
+    if isinstance(compression, Mapping):
+        compression_args = dict(compression)
         try:
             compression = compression_args.pop("method")
         except KeyError:
-            raise ValueError("If dict, compression must have key 'method'")
+            raise ValueError("If mapping, compression must have key 'method'")
     else:
         compression_args = {}
     return compression, compression_args
 
 
-def _infer_compression(
+def infer_compression(
     filepath_or_buffer: FilePathOrBuffer, compression: Optional[str]
 ) -> Optional[str]:
     """
@@ -343,7 +304,7 @@ def _infer_compression(
     # Infer compression
     if compression == "infer":
         # Convert all path types (e.g. pathlib.Path) to strings
-        filepath_or_buffer = _stringify_path(filepath_or_buffer)
+        filepath_or_buffer = stringify_path(filepath_or_buffer)
         if not isinstance(filepath_or_buffer, str):
             # Cannot infer compression of a buffer, assume no compression
             return None
@@ -358,17 +319,17 @@ def _infer_compression(
     if compression in _compression_to_extension:
         return compression
 
-    msg = "Unrecognized compression type: {}".format(compression)
+    msg = f"Unrecognized compression type: {compression}"
     valid = ["infer", None] + sorted(_compression_to_extension)
-    msg += "\nValid compression types are {}".format(valid)
+    msg += f"\nValid compression types are {valid}"
     raise ValueError(msg)
 
 
-def _get_handle(
+def get_handle(
     path_or_buf,
     mode: str,
     encoding=None,
-    compression: Optional[Union[str, Dict[str, Any]]] = None,
+    compression: Optional[Union[str, Mapping[str, Any]]] = None,
     memory_map: bool = False,
     is_text: bool = True,
 ):
@@ -411,23 +372,24 @@ def _get_handle(
     handles : list of file-like objects
         A list of file-like object that were opened in this function.
     """
+    need_text_wrapping: Tuple[Type["IOBase"], ...]
     try:
         from s3fs import S3File
 
-        need_text_wrapping = (BufferedIOBase, S3File)
+        need_text_wrapping = (BufferedIOBase, RawIOBase, S3File)
     except ImportError:
-        need_text_wrapping = BufferedIOBase  # type: ignore
+        need_text_wrapping = (BufferedIOBase, RawIOBase)
 
-    handles = list()  # type: List[IO]
+    handles: List[IO] = list()
     f = path_or_buf
 
     # Convert pathlib.Path/py.path.local or string
-    path_or_buf = _stringify_path(path_or_buf)
+    path_or_buf = stringify_path(path_or_buf)
     is_path = isinstance(path_or_buf, str)
 
-    compression, compression_args = _get_compression_method(compression)
+    compression, compression_args = get_compression_method(compression)
     if is_path:
-        compression = _infer_compression(path_or_buf, compression)
+        compression = infer_compression(path_or_buf, compression)
 
     if compression:
 
@@ -447,7 +409,7 @@ def _get_handle(
 
         # ZIP Compression
         elif compression == "zip":
-            zf = BytesZipFile(path_or_buf, mode, **compression_args)
+            zf = _BytesZipFile(path_or_buf, mode, **compression_args)
             # Ensure the container is closed as well.
             handles.append(zf)
             if zf.mode == "w":
@@ -457,13 +419,11 @@ def _get_handle(
                 if len(zip_names) == 1:
                     f = zf.open(zip_names.pop())
                 elif len(zip_names) == 0:
-                    raise ValueError(
-                        "Zero files found in ZIP file {}".format(path_or_buf)
-                    )
+                    raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
                 else:
                     raise ValueError(
-                        "Multiple files found in ZIP file."
-                        " Only one file per ZIP: {}".format(zip_names)
+                        "Multiple files found in ZIP file. "
+                        f"Only one file per ZIP: {zip_names}"
                     )
 
         # XZ Compression
@@ -472,7 +432,7 @@ def _get_handle(
 
         # Unrecognized Compression
         else:
-            msg = "Unrecognized compression type: {}".format(compression)
+            msg = f"Unrecognized compression type: {compression}"
             raise ValueError(msg)
 
         handles.append(f)
@@ -494,13 +454,13 @@ def _get_handle(
         from io import TextIOWrapper
 
         g = TextIOWrapper(f, encoding=encoding, newline="")
-        if not isinstance(f, BufferedIOBase):
+        if not isinstance(f, (BufferedIOBase, RawIOBase)):
             handles.append(g)
         f = g
 
     if memory_map and hasattr(f, "fileno"):
         try:
-            wrapped = MMapWrapper(f)
+            wrapped = _MMapWrapper(f)
             f.close()
             f = wrapped
         except Exception:
@@ -513,7 +473,7 @@ def _get_handle(
     return f, handles
 
 
-class BytesZipFile(zipfile.ZipFile, BytesIO):  # type: ignore
+class _BytesZipFile(zipfile.ZipFile, BytesIO):  # type: ignore
     """
     Wrapper for standard library class ZipFile and allow the returned file-like
     handle to accept byte strings via `write` method.
@@ -528,7 +488,7 @@ def __init__(
         file: FilePathOrBuffer,
         mode: str,
         archive_name: Optional[str] = None,
-        **kwargs
+        **kwargs,
     ):
         if mode in ["wb", "rb"]:
             mode = mode.replace("b", "")
@@ -546,7 +506,7 @@ def closed(self):
         return self.fp is None
 
 
-class MMapWrapper(BaseIterator):
+class _MMapWrapper(abc.Iterator):
     """
     Wrapper for the Python's mmap class so that it can be properly read in
     by Python's csv.reader class.
@@ -565,15 +525,15 @@ def __init__(self, f: IO):
     def __getattr__(self, name: str):
         return getattr(self.mmap, name)
 
-    def __iter__(self) -> "MMapWrapper":
+    def __iter__(self) -> "_MMapWrapper":
         return self
 
     def __next__(self) -> str:
-        newline = self.mmap.readline()
+        newbytes = self.mmap.readline()
 
         # readline returns bytes, not str, but Python's CSV reader
         # expects str, so convert the output to str before continuing
-        newline = newline.decode("utf-8")
+        newline = newbytes.decode("utf-8")
 
         # mmap doesn't raise if reading past the allocated
         # data but instead returns an empty string, so raise
@@ -581,37 +541,3 @@ def __next__(self) -> str:
         if newline == "":
             raise StopIteration
         return newline
-
-
-class UTF8Recoder(BaseIterator):
-    """
-    Iterator that reads an encoded stream and re-encodes the input to UTF-8
-    """
-
-    def __init__(self, f: BinaryIO, encoding: str):
-        self.reader = codecs.getreader(encoding)(f)
-
-    def read(self, bytes: int = -1) -> bytes:
-        return self.reader.read(bytes).encode("utf-8")
-
-    def readline(self) -> bytes:
-        return self.reader.readline().encode("utf-8")
-
-    def next(self) -> bytes:
-        return next(self.reader).encode("utf-8")
-
-    def close(self):
-        self.reader.close()
-
-
-# Keeping these class for now because it provides a necessary convenience
-# for "dropping" the "encoding" argument from our I/O arguments when
-# creating a Unicode I/O object.
-def UnicodeReader(f, dialect=csv.excel, encoding="utf-8", **kwds):
-    return csv.reader(f, dialect=dialect, **kwds)
-
-
-def UnicodeWriter(
-    f: TextIO, dialect: Type[csv.Dialect] = csv.excel, encoding: str = "utf-8", **kwds
-):
-    return csv.writer(f, dialect=dialect, **kwds)
diff --git a/pandas/io/date_converters.py b/pandas/io/date_converters.py
index ab64bc14344f1..07919dbda63ae 100644
--- a/pandas/io/date_converters.py
+++ b/pandas/io/date_converters.py
@@ -57,8 +57,7 @@ def _check_columns(cols):
     for i, n in enumerate(map(len, tail)):
         if n != N:
             raise AssertionError(
-                "All columns must have the same length: {0}; "
-                "column {1} has length {2}".format(N, i, n)
+                f"All columns must have the same length: {N}; column {i} has length {n}"
             )
 
     return N
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index 6dba5e042562b..70c09151258ff 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -1,5 +1,4 @@
 import abc
-from collections import OrderedDict
 from datetime import date, datetime, timedelta
 from io import BytesIO
 import os
@@ -7,20 +6,20 @@
 
 from pandas._config import config
 
+from pandas._libs.parsers import STR_NA_VALUES
 from pandas.errors import EmptyDataError
-from pandas.util._decorators import Appender, deprecate_kwarg
+from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import is_bool, is_float, is_integer, is_list_like
 
 from pandas.core.frame import DataFrame
 
 from pandas.io.common import (
-    _NA_VALUES,
-    _is_url,
-    _stringify_path,
-    _validate_header_arg,
     get_filepath_or_buffer,
+    is_url,
+    stringify_path,
     urlopen,
+    validate_header_arg,
 )
 from pandas.io.excel._util import (
     _fill_mi_header,
@@ -36,12 +35,13 @@
     """
 Read an Excel file into a pandas DataFrame.
 
-Support both `xls` and `xlsx` file extensions from a local filesystem or URL.
-Support an option to read a single sheet or a list of sheets.
+Supports `xls`, `xlsx`, `xlsm`, `xlsb`, and `odf` file extensions
+read from a local filesystem or URL. Supports an option to read
+a single sheet or a list of sheets.
 
 Parameters
 ----------
-io : str, ExcelFile, xlrd.Book, path object or file-like object
+io : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object
     Any valid string path is acceptable. The string could be a URL. Valid
     URL schemes include http, ftp, s3, and file. For file URLs, a host is
     expected. A local file could be: ``file://localhost/path/to/table.xlsx``.
@@ -79,14 +79,7 @@
     subset of data is selected with ``usecols``, index_col
     is based on the subset.
 usecols : int, str, list-like, or callable default None
-    Return a subset of the columns.
-
     * If None, then parse all columns.
-    * If int, then indicates last column to be parsed.
-
-      .. deprecated:: 0.24.0
-         Pass in a list of int instead from 0 to `usecols` inclusive.
-
     * If str, then indicates comma separated list of Excel column letters
       and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of
       both sides.
@@ -98,6 +91,8 @@
     * If callable, then evaluate each column name against it and parse the
       column if the callable returns ``True``.
 
+    Returns a subset of the columns according to behavior above.
+
       .. versionadded:: 0.24.0
 
 squeeze : bool, default False
@@ -107,9 +102,6 @@
     Use `object` to preserve data as stored in Excel and not interpret dtype.
     If converters are specified, they will be applied INSTEAD
     of dtype conversion.
-
-    .. versionadded:: 0.20.0
-
 engine : str, default None
     If io is not a buffer or path, this must be set to identify io.
     Acceptable values are None, "xlrd", "openpyxl" or "odf".
@@ -133,11 +125,27 @@
     Additional strings to recognize as NA/NaN. If dict passed, specific
     per-column NA values. By default the following values are interpreted
     as NaN: '"""
-    + fill("', '".join(sorted(_NA_VALUES)), 70, subsequent_indent="    ")
+    + fill("', '".join(sorted(STR_NA_VALUES)), 70, subsequent_indent="    ")
     + """'.
 keep_default_na : bool, default True
-    If na_values are specified and keep_default_na is False the default NaN
-    values are overridden, otherwise they're appended to.
+    Whether or not to include the default NaN values when parsing the data.
+    Depending on whether `na_values` is passed in, the behavior is as follows:
+
+    * If `keep_default_na` is True, and `na_values` are specified, `na_values`
+      is appended to the default NaN values used for parsing.
+    * If `keep_default_na` is True, and `na_values` are not specified, only
+      the default NaN values are used for parsing.
+    * If `keep_default_na` is False, and `na_values` are specified, only
+      the NaN values specified `na_values` are used for parsing.
+    * If `keep_default_na` is False, and `na_values` are not specified, no
+      strings will be parsed as NaN.
+
+    Note that if `na_filter` is passed in as False, the `keep_default_na` and
+    `na_values` parameters will be ignored.
+na_filter : bool, default True
+    Detect missing value markers (empty strings and the value of na_values). In
+    data without any NAs, passing na_filter=False can improve the performance
+    of reading a large file.
 verbose : bool, default False
     Indicate number of NA values placed in non-numeric columns.
 parse_dates : bool, list-like, or dict, default False
@@ -152,8 +160,9 @@
       result 'foo'
 
     If a column or index contains an unparseable date, the entire column or
-    index will be returned unaltered as an object data type. For non-standard
-    datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.
+    index will be returned unaltered as an object data type. If you don`t want to
+    parse some cells as date just change their type in Excel to "Text".
+    For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.
 
     Note: A fast-path exists for iso8601-formatted dates.
 date_parser : function, optional
@@ -175,11 +184,6 @@
     Comments out remainder of line. Pass a character or characters to this
     argument to indicate comments in the input file. Any data between the
     comment string and the end of the current line is ignored.
-skip_footer : int, default 0
-    Alias of `skipfooter`.
-
-    .. deprecated:: 0.23.0
-       Use `skipfooter` instead.
 skipfooter : int, default 0
     Rows at the end to skip (0-indexed).
 convert_float : bool, default True
@@ -201,8 +205,8 @@
 
 See Also
 --------
-to_excel : Write DataFrame to an Excel file.
-to_csv : Write DataFrame to a comma-separated values (csv) file.
+DataFrame.to_excel : Write DataFrame to an Excel file.
+DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
 read_csv : Read a comma-separated values (csv) file into DataFrame.
 read_fwf : Read a table of fixed-width formatted lines into DataFrame.
 
@@ -264,7 +268,6 @@
 
 
 @Appender(_read_excel_doc)
-@deprecate_kwarg("skip_footer", "skipfooter")
 def read_excel(
     io,
     sheet_name=0,
@@ -287,18 +290,15 @@ def read_excel(
     date_parser=None,
     thousands=None,
     comment=None,
-    skip_footer=0,
     skipfooter=0,
     convert_float=True,
     mangle_dupe_cols=True,
-    **kwds
+    **kwds,
 ):
 
     for arg in ("sheet", "sheetname", "parse_cols"):
         if arg in kwds:
-            raise TypeError(
-                "read_excel() got an unexpected keyword argument `{}`".format(arg)
-            )
+            raise TypeError(f"read_excel() got an unexpected keyword argument `{arg}`")
 
     if not isinstance(io, ExcelFile):
         io = ExcelFile(io, engine=engine)
@@ -331,14 +331,14 @@ def read_excel(
         skipfooter=skipfooter,
         convert_float=convert_float,
         mangle_dupe_cols=mangle_dupe_cols,
-        **kwds
+        **kwds,
     )
 
 
 class _BaseExcelReader(metaclass=abc.ABCMeta):
     def __init__(self, filepath_or_buffer):
         # If filepath_or_buffer is a url, load the data into a BytesIO
-        if _is_url(filepath_or_buffer):
+        if is_url(filepath_or_buffer):
             filepath_or_buffer = BytesIO(urlopen(filepath_or_buffer).read())
         elif not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):
             filepath_or_buffer, _, _, _ = get_filepath_or_buffer(filepath_or_buffer)
@@ -351,6 +351,8 @@ def __init__(self, filepath_or_buffer):
             self.book = self.load_workbook(filepath_or_buffer)
         elif isinstance(filepath_or_buffer, str):
             self.book = self.load_workbook(filepath_or_buffer)
+        elif isinstance(filepath_or_buffer, bytes):
+            self.book = self.load_workbook(BytesIO(filepath_or_buffer))
         else:
             raise ValueError(
                 "Must explicitly set engine if not passing in buffer or path for io."
@@ -404,10 +406,10 @@ def parse(
         skipfooter=0,
         convert_float=True,
         mangle_dupe_cols=True,
-        **kwds
+        **kwds,
     ):
 
-        _validate_header_arg(header)
+        validate_header_arg(header)
 
         ret_dict = False
 
@@ -422,13 +424,13 @@ def parse(
             sheets = [sheet_name]
 
         # handle same-type duplicates.
-        sheets = list(OrderedDict.fromkeys(sheets).keys())
+        sheets = list(dict.fromkeys(sheets).keys())
 
-        output = OrderedDict()
+        output = {}
 
         for asheetname in sheets:
             if verbose:
-                print("Reading sheet {sheet}".format(sheet=asheetname))
+                print(f"Reading sheet {asheetname}")
 
             if isinstance(asheetname, str):
                 sheet = self.get_sheet_by_name(asheetname)
@@ -504,7 +506,7 @@ def parse(
                     skipfooter=skipfooter,
                     usecols=usecols,
                     mangle_dupe_cols=mangle_dupe_cols,
-                    **kwds
+                    **kwds,
                 )
 
                 output[asheetname] = parser.read(nrows=nrows)
@@ -527,22 +529,24 @@ def parse(
 
 class ExcelWriter(metaclass=abc.ABCMeta):
     """
-    Class for writing DataFrame objects into excel sheets, default is to use
-    xlwt for xls, openpyxl for xlsx.  See DataFrame.to_excel for typical usage.
+    Class for writing DataFrame objects into excel sheets.
+
+    Default is to use xlwt for xls, openpyxl for xlsx.
+    See DataFrame.to_excel for typical usage.
 
     Parameters
     ----------
-    path : string
+    path : str
         Path to xls or xlsx file.
-    engine : string (optional)
+    engine : str (optional)
         Engine to use for writing. If None, defaults to
         ``io.excel.<extension>.writer``.  NOTE: can only be passed as a keyword
         argument.
-    date_format : string, default None
-        Format string for dates written into Excel files (e.g. 'YYYY-MM-DD')
-    datetime_format : string, default None
-        Format string for datetime objects written into Excel files
-        (e.g. 'YYYY-MM-DD HH:MM:SS')
+    date_format : str, default None
+        Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+    datetime_format : str, default None
+        Format string for datetime objects written into Excel files.
+        (e.g. 'YYYY-MM-DD HH:MM:SS').
     mode : {'w', 'a'}, default 'w'
         File mode to use (write or append).
 
@@ -621,11 +625,11 @@ def __new__(cls, path, engine=None, **kwargs):
                     ext = "xlsx"
 
                 try:
-                    engine = config.get_option("io.excel.{ext}.writer".format(ext=ext))
+                    engine = config.get_option(f"io.excel.{ext}.writer")
                     if engine == "auto":
                         engine = _get_default_writer(ext)
                 except KeyError:
-                    raise ValueError("No engine for filetype: '{ext}'".format(ext=ext))
+                    raise ValueError(f"No engine for filetype: '{ext}'")
             cls = get_writer(engine)
 
         return object.__new__(cls)
@@ -658,11 +662,11 @@ def write_cells(
         ----------
         cells : generator
             cell of formatted data to save to Excel sheet
-        sheet_name : string, default None
+        sheet_name : str, default None
             Name of Excel sheet, if None, then use self.cur_sheet
         startrow : upper left cell row to dump data frame
         startcol : upper left cell column to dump data frame
-        freeze_panes: integer tuple of length 2
+        freeze_panes: int tuple of length 2
             contains the bottom-most row and right-most column to freeze
         """
         pass
@@ -681,7 +685,7 @@ def __init__(
         date_format=None,
         datetime_format=None,
         mode="w",
-        **engine_kwargs
+        **engine_kwargs,
     ):
         # validate that this engine can handle the extension
         if isinstance(path, str):
@@ -707,7 +711,7 @@ def __init__(
         self.mode = mode
 
     def __fspath__(self):
-        return _stringify_path(self.path)
+        return stringify_path(self.path)
 
     def _get_sheet_name(self, sheet_name):
         if sheet_name is None:
@@ -752,13 +756,13 @@ def _value_with_fmt(self, val):
     @classmethod
     def check_extension(cls, ext):
         """checks that path's extension against the Writer's supported
-        extensions.  If it isn't supported, raises UnsupportedFiletypeError."""
+        extensions.  If it isn't supported, raises UnsupportedFiletypeError.
+        """
         if ext.startswith("."):
             ext = ext[1:]
         if not any(ext in extension for extension in cls.supported_extensions):
-            msg = "Invalid extension for engine '{engine}': '{ext}'".format(
-                engine=pprint_thing(cls.engine), ext=pprint_thing(ext)
-            )
+            msg = "Invalid extension for engine"
+            f"'{pprint_thing(cls.engine)}': '{pprint_thing(ext)}'"
             raise ValueError(msg)
         else:
             return True
@@ -782,32 +786,38 @@ class ExcelFile:
 
     Parameters
     ----------
-    io : string, path object (pathlib.Path or py._path.local.LocalPath),
+    io : str, path object (pathlib.Path or py._path.local.LocalPath),
         a file-like object, xlrd workbook or openpypl workbook.
         If a string or path object, expected to be a path to xls, xlsx or odf file.
-    engine : string, default None
+    engine : str, default None
         If io is not a buffer or path, this must be set to identify io.
-        Acceptable values are None, ``xlrd``, ``openpyxl`` or ``odf``.
+        Acceptable values are None, ``xlrd``, ``openpyxl``,  ``odf``, or ``pyxlsb``.
         Note that ``odf`` reads tables out of OpenDocument formatted files.
     """
 
     from pandas.io.excel._odfreader import _ODFReader
     from pandas.io.excel._openpyxl import _OpenpyxlReader
     from pandas.io.excel._xlrd import _XlrdReader
+    from pandas.io.excel._pyxlsb import _PyxlsbReader
 
-    _engines = {"xlrd": _XlrdReader, "openpyxl": _OpenpyxlReader, "odf": _ODFReader}
+    _engines = {
+        "xlrd": _XlrdReader,
+        "openpyxl": _OpenpyxlReader,
+        "odf": _ODFReader,
+        "pyxlsb": _PyxlsbReader,
+    }
 
     def __init__(self, io, engine=None):
         if engine is None:
             engine = "xlrd"
         if engine not in self._engines:
-            raise ValueError("Unknown engine: {engine}".format(engine=engine))
+            raise ValueError(f"Unknown engine: {engine}")
 
         self.engine = engine
         # could be a str, ExcelFile, Book, etc.
         self.io = io
         # Always a string
-        self._io = _stringify_path(io)
+        self._io = stringify_path(io)
 
         self._reader = self._engines[engine](self._io)
 
@@ -835,7 +845,7 @@ def parse(
         skipfooter=0,
         convert_float=True,
         mangle_dupe_cols=True,
-        **kwds
+        **kwds,
     ):
         """
         Parse specified sheet(s) into a DataFrame.
@@ -873,7 +883,7 @@ def parse(
             skipfooter=skipfooter,
             convert_float=convert_float,
             mangle_dupe_cols=mangle_dupe_cols,
-            **kwds
+            **kwds,
         )
 
     @property
@@ -886,6 +896,12 @@ def sheet_names(self):
 
     def close(self):
         """close io if necessary"""
+        if self.engine == "openpyxl":
+            # https://stackoverflow.com/questions/31416842/
+            #  openpyxl-does-not-close-excel-workbook-in-read-only-mode
+            wb = self.book
+            wb._archive.close()
+
         if hasattr(self.io, "close"):
             self.io.close()
 
@@ -894,3 +910,11 @@ def __enter__(self):
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.close()
+
+    def __del__(self):
+        # Ensure we don't leak file descriptors, but put in try/except in case
+        # attributes are already deleted
+        try:
+            self.close()
+        except AttributeError:
+            pass
diff --git a/pandas/io/excel/_odfreader.py b/pandas/io/excel/_odfreader.py
index 3be36663bac79..ec5f6fcb17ff8 100644
--- a/pandas/io/excel/_odfreader.py
+++ b/pandas/io/excel/_odfreader.py
@@ -1,15 +1,16 @@
 from typing import List
 
+from pandas._typing import FilePathOrBuffer, Scalar
 from pandas.compat._optional import import_optional_dependency
 
 import pandas as pd
-from pandas._typing import FilePathOrBuffer, Scalar
 
 from pandas.io.excel._base import _BaseExcelReader
 
 
 class _ODFReader(_BaseExcelReader):
-    """Read tables out of OpenDocument formatted files
+    """
+    Read tables out of OpenDocument formatted files.
 
     Parameters
     ----------
@@ -60,7 +61,7 @@ def get_sheet_by_name(self, name: str):
             if table.getAttribute("name") == name:
                 return table
 
-        raise ValueError("sheet {name} not found".format(name))
+        raise ValueError(f"sheet {name} not found")
 
     def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
         """Parse an ODF Table into a list of lists
@@ -75,12 +76,12 @@ def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
         empty_rows = 0
         max_row_len = 0
 
-        table = []  # type: List[List[Scalar]]
+        table: List[List[Scalar]] = []
 
         for i, sheet_row in enumerate(sheet_rows):
             sheet_cells = [x for x in sheet_row.childNodes if x.qname in cell_names]
             empty_cells = 0
-            table_row = []  # type: List[Scalar]
+            table_row: List[Scalar] = []
 
             for j, sheet_cell in enumerate(sheet_cells):
                 if sheet_cell.qname == table_cell_name:
@@ -155,7 +156,7 @@ def _get_cell_value(self, cell, convert_float: bool) -> Scalar:
             # GH5394
             cell_value = float(cell.attributes.get((OFFICENS, "value")))
 
-            if cell_value == 0.0 and str(cell) != cell_value:  # NA handling
+            if cell_value == 0.0:  # NA handling
                 return str(cell)
 
             if convert_float:
@@ -177,4 +178,4 @@ def _get_cell_value(self, cell, convert_float: bool) -> Scalar:
         elif cell_type == "time":
             return pd.to_datetime(str(cell)).time()
         else:
-            raise ValueError("Unrecognized type {}".format(cell_type))
+            raise ValueError(f"Unrecognized type {cell_type}")
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index d8f5da5ab5bc6..be52523e486af 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -2,9 +2,8 @@
 
 import numpy as np
 
-from pandas.compat._optional import import_optional_dependency
-
 from pandas._typing import FilePathOrBuffer, Scalar
+from pandas.compat._optional import import_optional_dependency
 
 from pandas.io.excel._base import ExcelWriter, _BaseExcelReader
 from pandas.io.excel._util import _validate_freeze_panes
@@ -46,7 +45,8 @@ def save(self):
     @classmethod
     def _convert_to_style(cls, style_dict):
         """
-        converts a style_dict to an openpyxl style object
+        Converts a style_dict to an openpyxl style object.
+
         Parameters
         ----------
         style_dict : style dictionary to convert
@@ -72,7 +72,8 @@ def _convert_to_style(cls, style_dict):
     def _convert_to_style_kwargs(cls, style_dict):
         """
         Convert a style_dict to a set of kwargs suitable for initializing
-        or updating-on-copy an openpyxl v2 style object
+        or updating-on-copy an openpyxl v2 style object.
+
         Parameters
         ----------
         style_dict : dict
@@ -83,6 +84,7 @@ def _convert_to_style_kwargs(cls, style_dict):
                 'alignment'
                 'number_format'
                 'protection'
+
         Returns
         -------
         style_kwargs : dict
@@ -97,7 +99,7 @@ def _convert_to_style_kwargs(cls, style_dict):
         for k, v in style_dict.items():
             if k in _style_key_map:
                 k = _style_key_map[k]
-            _conv_to_x = getattr(cls, "_convert_to_{k}".format(k=k), lambda x: None)
+            _conv_to_x = getattr(cls, f"_convert_to_{k}", lambda x: None)
             new_v = _conv_to_x(v)
             if new_v:
                 style_kwargs[k] = new_v
@@ -107,7 +109,8 @@ def _convert_to_style_kwargs(cls, style_dict):
     @classmethod
     def _convert_to_color(cls, color_spec):
         """
-        Convert ``color_spec`` to an openpyxl v2 Color object
+        Convert ``color_spec`` to an openpyxl v2 Color object.
+
         Parameters
         ----------
         color_spec : str, dict
@@ -120,6 +123,7 @@ def _convert_to_color(cls, color_spec):
                 'tint'
                 'index'
                 'type'
+
         Returns
         -------
         color : openpyxl.styles.Color
@@ -135,7 +139,8 @@ def _convert_to_color(cls, color_spec):
     @classmethod
     def _convert_to_font(cls, font_dict):
         """
-        Convert ``font_dict`` to an openpyxl v2 Font object
+        Convert ``font_dict`` to an openpyxl v2 Font object.
+
         Parameters
         ----------
         font_dict : dict
@@ -154,6 +159,7 @@ def _convert_to_font(cls, font_dict):
                 'outline'
                 'shadow'
                 'condense'
+
         Returns
         -------
         font : openpyxl.styles.Font
@@ -185,11 +191,13 @@ def _convert_to_stop(cls, stop_seq):
         """
         Convert ``stop_seq`` to a list of openpyxl v2 Color objects,
         suitable for initializing the ``GradientFill`` ``stop`` parameter.
+
         Parameters
         ----------
         stop_seq : iterable
             An iterable that yields objects suitable for consumption by
             ``_convert_to_color``.
+
         Returns
         -------
         stop : list of openpyxl.styles.Color
@@ -200,7 +208,8 @@ def _convert_to_stop(cls, stop_seq):
     @classmethod
     def _convert_to_fill(cls, fill_dict):
         """
-        Convert ``fill_dict`` to an openpyxl v2 Fill object
+        Convert ``fill_dict`` to an openpyxl v2 Fill object.
+
         Parameters
         ----------
         fill_dict : dict
@@ -216,6 +225,7 @@ def _convert_to_fill(cls, fill_dict):
                 'top'
                 'bottom'
                 'stop'
+
         Returns
         -------
         fill : openpyxl.styles.Fill
@@ -262,7 +272,8 @@ def _convert_to_fill(cls, fill_dict):
     @classmethod
     def _convert_to_side(cls, side_spec):
         """
-        Convert ``side_spec`` to an openpyxl v2 Side object
+        Convert ``side_spec`` to an openpyxl v2 Side object.
+
         Parameters
         ----------
         side_spec : str, dict
@@ -270,6 +281,7 @@ def _convert_to_side(cls, side_spec):
             of the following keys (or their synonyms).
                 'style' ('border_style')
                 'color'
+
         Returns
         -------
         side : openpyxl.styles.Side
@@ -295,7 +307,8 @@ def _convert_to_side(cls, side_spec):
     @classmethod
     def _convert_to_border(cls, border_dict):
         """
-        Convert ``border_dict`` to an openpyxl v2 Border object
+        Convert ``border_dict`` to an openpyxl v2 Border object.
+
         Parameters
         ----------
         border_dict : dict
@@ -311,6 +324,7 @@ def _convert_to_border(cls, border_dict):
                 'diagonalUp' ('diagonalup')
                 'diagonalDown' ('diagonaldown')
                 'outline'
+
         Returns
         -------
         border : openpyxl.styles.Border
@@ -335,7 +349,8 @@ def _convert_to_border(cls, border_dict):
     @classmethod
     def _convert_to_alignment(cls, alignment_dict):
         """
-        Convert ``alignment_dict`` to an openpyxl v2 Alignment object
+        Convert ``alignment_dict`` to an openpyxl v2 Alignment object.
+
         Parameters
         ----------
         alignment_dict : dict
@@ -515,7 +530,7 @@ def _convert_cell(self, cell, convert_float: bool) -> Scalar:
         return cell.value
 
     def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
-        data = []  # type: List[List[Scalar]]
+        data: List[List[Scalar]] = []
         for row in sheet.rows:
             data.append([self._convert_cell(cell, convert_float) for cell in row])
 
diff --git a/pandas/io/excel/_pyxlsb.py b/pandas/io/excel/_pyxlsb.py
new file mode 100644
index 0000000000000..0d96c8c4acdb8
--- /dev/null
+++ b/pandas/io/excel/_pyxlsb.py
@@ -0,0 +1,69 @@
+from typing import List
+
+from pandas._typing import FilePathOrBuffer, Scalar
+from pandas.compat._optional import import_optional_dependency
+
+from pandas.io.excel._base import _BaseExcelReader
+
+
+class _PyxlsbReader(_BaseExcelReader):
+    def __init__(self, filepath_or_buffer: FilePathOrBuffer):
+        """
+        Reader using pyxlsb engine.
+
+        Parameters
+        ----------
+        filepath_or_buffer: str, path object, or Workbook
+            Object to be parsed.
+        """
+        import_optional_dependency("pyxlsb")
+        # This will call load_workbook on the filepath or buffer
+        # And set the result to the book-attribute
+        super().__init__(filepath_or_buffer)
+
+    @property
+    def _workbook_class(self):
+        from pyxlsb import Workbook
+
+        return Workbook
+
+    def load_workbook(self, filepath_or_buffer: FilePathOrBuffer):
+        from pyxlsb import open_workbook
+
+        # TODO: hack in buffer capability
+        # This might need some modifications to the Pyxlsb library
+        # Actual work for opening it is in xlsbpackage.py, line 20-ish
+
+        return open_workbook(filepath_or_buffer)
+
+    @property
+    def sheet_names(self) -> List[str]:
+        return self.book.sheets
+
+    def get_sheet_by_name(self, name: str):
+        return self.book.get_sheet(name)
+
+    def get_sheet_by_index(self, index: int):
+        # pyxlsb sheets are indexed from 1 onwards
+        # There's a fix for this in the source, but the pypi package doesn't have it
+        return self.book.get_sheet(index + 1)
+
+    def _convert_cell(self, cell, convert_float: bool) -> Scalar:
+        # TODO: there is no way to distinguish between floats and datetimes in pyxlsb
+        # This means that there is no way to read datetime types from an xlsb file yet
+        if cell.v is None:
+            return ""  # Prevents non-named columns from not showing up as Unnamed: i
+        if isinstance(cell.v, float) and convert_float:
+            val = int(cell.v)
+            if val == cell.v:
+                return val
+            else:
+                return float(cell.v)
+
+        return cell.v
+
+    def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
+        return [
+            [self._convert_cell(c, convert_float) for c in r]
+            for r in sheet.rows(sparse=False)
+        ]
diff --git a/pandas/io/excel/_util.py b/pandas/io/excel/_util.py
index 2ba3842d5c0c9..9d284c8031840 100644
--- a/pandas/io/excel/_util.py
+++ b/pandas/io/excel/_util.py
@@ -1,5 +1,3 @@
-import warnings
-
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.dtypes.common import is_integer, is_list_like
@@ -50,7 +48,7 @@ def get_writer(engine_name):
     try:
         return _writers[engine_name]
     except KeyError:
-        raise ValueError("No Excel writer '{engine}'".format(engine=engine_name))
+        raise ValueError(f"No Excel writer '{engine_name}'")
 
 
 def _excel2num(x):
@@ -78,7 +76,7 @@ def _excel2num(x):
         cp = ord(c)
 
         if cp < ord("A") or cp > ord("Z"):
-            raise ValueError("Invalid column name: {x}".format(x=x))
+            raise ValueError(f"Invalid column name: {x}")
 
         index = index * 26 + cp - ord("A") + 1
 
@@ -136,16 +134,10 @@ def _maybe_convert_usecols(usecols):
         return usecols
 
     if is_integer(usecols):
-        warnings.warn(
-            (
-                "Passing in an integer for `usecols` has been "
-                "deprecated. Please pass in a list of int from "
-                "0 to `usecols` inclusive instead."
-            ),
-            FutureWarning,
-            stacklevel=2,
+        raise ValueError(
+            "Passing an integer for `usecols` is no longer supported.  "
+            "Please pass in a list of int from 0 to `usecols` inclusive instead."
         )
-        return list(range(usecols + 1))
 
     if isinstance(usecols, str):
         return _range2cols(usecols)
@@ -161,8 +153,8 @@ def _validate_freeze_panes(freeze_panes):
             return True
 
         raise ValueError(
-            "freeze_panes must be of form (row, column)"
-            " where row and column are integers"
+            "freeze_panes must be of form (row, column) "
+            "where row and column are integers"
         )
 
     # freeze_panes wasn't specified, return False so it won't be applied
diff --git a/pandas/io/excel/_xlrd.py b/pandas/io/excel/_xlrd.py
index be1b78eeb146e..e7a132b73e076 100644
--- a/pandas/io/excel/_xlrd.py
+++ b/pandas/io/excel/_xlrd.py
@@ -57,8 +57,9 @@ def get_sheet_data(self, sheet, convert_float):
         epoch1904 = self.book.datemode
 
         def _parse_cell(cell_contents, cell_typ):
-            """converts the contents of the cell into a pandas
-               appropriate object"""
+            """
+            converts the contents of the cell into a pandas appropriate object
+            """
 
             if cell_typ == XL_CELL_DATE:
 
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index 07bf265da4863..6d9ff9be5249a 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -168,7 +168,7 @@ def __init__(
         date_format=None,
         datetime_format=None,
         mode="w",
-        **engine_kwargs
+        **engine_kwargs,
     ):
         # Use the xlsxwriter module as the Excel writer.
         import xlsxwriter
@@ -182,7 +182,7 @@ def __init__(
             date_format=date_format,
             datetime_format=datetime_format,
             mode=mode,
-            **engine_kwargs
+            **engine_kwargs,
         )
 
         self.book = xlsxwriter.Workbook(path, **engine_kwargs)
diff --git a/pandas/io/excel/_xlwt.py b/pandas/io/excel/_xlwt.py
index fe3d0a208de6a..d102a885cef0a 100644
--- a/pandas/io/excel/_xlwt.py
+++ b/pandas/io/excel/_xlwt.py
@@ -77,7 +77,9 @@ def write_cells(
                 wks.write(startrow + cell.row, startcol + cell.col, val, style)
 
     @classmethod
-    def _style_to_xlwt(cls, item, firstlevel=True, field_sep=",", line_sep=";"):
+    def _style_to_xlwt(
+        cls, item, firstlevel: bool = True, field_sep=",", line_sep=";"
+    ) -> str:
         """helper which recursively generate an xlwt easy style string
         for example:
 
@@ -95,20 +97,20 @@ def _style_to_xlwt(cls, item, firstlevel=True, field_sep=",", line_sep=";"):
         if hasattr(item, "items"):
             if firstlevel:
                 it = [
-                    "{key}: {val}".format(key=key, val=cls._style_to_xlwt(value, False))
+                    f"{key}: {cls._style_to_xlwt(value, False)}"
                     for key, value in item.items()
                 ]
-                out = "{sep} ".format(sep=(line_sep).join(it))
+                out = f"{(line_sep).join(it)} "
                 return out
             else:
                 it = [
-                    "{key} {val}".format(key=key, val=cls._style_to_xlwt(value, False))
+                    f"{key} {cls._style_to_xlwt(value, False)}"
                     for key, value in item.items()
                 ]
-                out = "{sep} ".format(sep=(field_sep).join(it))
+                out = f"{(field_sep).join(it)} "
                 return out
         else:
-            item = "{item}".format(item=item)
+            item = f"{item}"
             item = item.replace("True", "on")
             item = item.replace("False", "off")
             return item
@@ -117,6 +119,7 @@ def _style_to_xlwt(cls, item, firstlevel=True, field_sep=",", line_sep=";"):
     def _convert_to_style(cls, style_dict, num_format_str=None):
         """
         converts a style_dict to an xlwt style object
+
         Parameters
         ----------
         style_dict : style dictionary to convert
diff --git a/pandas/io/feather_format.py b/pandas/io/feather_format.py
index 25a6db675265d..5d4925620e75f 100644
--- a/pandas/io/feather_format.py
+++ b/pandas/io/feather_format.py
@@ -1,16 +1,13 @@
 """ feather-format compat """
 
-from distutils.version import LooseVersion
-
 from pandas.compat._optional import import_optional_dependency
-from pandas.util._decorators import deprecate_kwarg
 
 from pandas import DataFrame, Int64Index, RangeIndex
 
-from pandas.io.common import _stringify_path
+from pandas.io.common import stringify_path
 
 
-def to_feather(df, path):
+def to_feather(df: DataFrame, path):
     """
     Write a DataFrame to the feather-format
 
@@ -23,7 +20,7 @@ def to_feather(df, path):
     import_optional_dependency("pyarrow")
     from pyarrow import feather
 
-    path = _stringify_path(path)
+    path = stringify_path(path)
 
     if not isinstance(df, DataFrame):
         raise ValueError("feather only support IO with DataFrames")
@@ -37,18 +34,16 @@ def to_feather(df, path):
     # raise on anything else as we don't serialize the index
 
     if not isinstance(df.index, Int64Index):
+        typ = type(df.index)
         raise ValueError(
-            "feather does not support serializing {} "
-            "for the index; you can .reset_index() "
-            "to make the index into column(s)".format(type(df.index))
+            f"feather does not support serializing {typ} "
+            "for the index; you can .reset_index() to make the index into column(s)"
         )
 
     if not df.index.equals(RangeIndex.from_range(range(len(df)))):
         raise ValueError(
-            "feather does not support serializing a "
-            "non-default index for the index; you "
-            "can .reset_index() to make the index "
-            "into column(s)"
+            "feather does not support serializing a non-default index for the index; "
+            "you can .reset_index() to make the index into column(s)"
         )
 
     if df.index.name is not None:
@@ -66,13 +61,10 @@ def to_feather(df, path):
     feather.write_feather(df, path)
 
 
-@deprecate_kwarg(old_arg_name="nthreads", new_arg_name="use_threads")
-def read_feather(path, columns=None, use_threads=True):
+def read_feather(path, columns=None, use_threads: bool = True):
     """
     Load a feather-format object from the file path.
 
-    .. versionadded:: 0.20.0
-
     Parameters
     ----------
     path : str, path object or file-like object
@@ -91,11 +83,6 @@ def read_feather(path, columns=None, use_threads=True):
         If not provided, all columns are read.
 
         .. versionadded:: 0.24.0
-    nthreads : int, default 1
-        Number of CPU threads to use when reading to pandas.DataFrame.
-
-       .. versionadded:: 0.21.0
-       .. deprecated:: 0.24.0
     use_threads : bool, default True
         Whether to parallelize reading using multiple threads.
 
@@ -105,15 +92,9 @@ def read_feather(path, columns=None, use_threads=True):
     -------
     type of object stored in file
     """
-    pyarrow = import_optional_dependency("pyarrow")
+    import_optional_dependency("pyarrow")
     from pyarrow import feather
 
-    path = _stringify_path(path)
-
-    if LooseVersion(pyarrow.__version__) < LooseVersion("0.11.0"):
-        int_use_threads = int(use_threads)
-        if int_use_threads < 1:
-            int_use_threads = 1
-        return feather.read_feather(path, columns=columns, nthreads=int_use_threads)
+    path = stringify_path(path)
 
     return feather.read_feather(path, columns=columns, use_threads=bool(use_threads))
diff --git a/pandas/io/formats/console.py b/pandas/io/formats/console.py
index 7f8f2fbea2352..bed29e1fd4792 100644
--- a/pandas/io/formats/console.py
+++ b/pandas/io/formats/console.py
@@ -6,14 +6,14 @@
 
 
 def get_console_size():
-    """Return console size as tuple = (width, height).
+    """
+    Return console size as tuple = (width, height).
 
     Returns (None,None) in non-interactive session.
     """
     from pandas import get_option
 
     display_width = get_option("display.width")
-    # deprecated.
     display_height = get_option("display.max_rows")
 
     # Consider
@@ -51,9 +51,13 @@ def get_console_size():
 
 
 def in_interactive_session():
-    """ check if we're running in an interactive shell
+    """
+    Check if we're running in an interactive shell.
 
-    returns True if running under python/ipython interactive shell
+    Returns
+    -------
+    bool
+        True if running under python/ipython interactive shell.
     """
     from pandas import get_option
 
@@ -72,7 +76,11 @@ def check_main():
 
 def in_ipython_frontend():
     """
-    check if we're inside an an IPython zmq frontend
+    Check if we're inside an an IPython zmq frontend.
+
+    Returns
+    -------
+    bool
     """
     try:
         ip = get_ipython()  # noqa
diff --git a/pandas/io/formats/css.py b/pandas/io/formats/css.py
index 92fe87cddb35b..b40d2a57b8106 100644
--- a/pandas/io/formats/css.py
+++ b/pandas/io/formats/css.py
@@ -1,4 +1,5 @@
-"""Utilities for interpreting CSS from Stylers for formatting non-HTML outputs
+"""
+Utilities for interpreting CSS from Stylers for formatting non-HTML outputs.
 """
 
 import re
@@ -6,18 +7,37 @@
 
 
 class CSSWarning(UserWarning):
-    """This CSS syntax cannot currently be parsed"""
+    """
+    This CSS syntax cannot currently be parsed.
+    """
 
     pass
 
 
-class CSSResolver:
-    """A callable for parsing and resolving CSS to atomic properties
+def _side_expander(prop_fmt: str):
+    def expand(self, prop, value: str):
+        tokens = value.split()
+        try:
+            mapping = self.SIDE_SHORTHANDS[len(tokens)]
+        except KeyError:
+            warnings.warn(
+                f'Could not expand "{prop}: {value}"', CSSWarning,
+            )
+            return
+        for key, idx in zip(self.SIDES, mapping):
+            yield prop_fmt.format(key), tokens[idx]
 
+    return expand
+
+
+class CSSResolver:
+    """
+    A callable for parsing and resolving CSS to atomic properties.
     """
 
     def __call__(self, declarations_str, inherited=None):
-        """ the given declarations to atomic properties
+        """
+        The given declarations to atomic properties.
 
         Parameters
         ----------
@@ -30,8 +50,8 @@ def __call__(self, declarations_str, inherited=None):
 
         Returns
         -------
-        props : dict
-            Atomic CSS 2.2 properties
+        dict
+            Atomic CSS 2.2 properties.
 
         Examples
         --------
@@ -53,7 +73,6 @@ def __call__(self, declarations_str, inherited=None):
          ('font-size', '24pt'),
          ('font-weight', 'bold')]
         """
-
         props = dict(self.atomize(self.parse(declarations_str)))
         if inherited is None:
             inherited = {}
@@ -93,14 +112,14 @@ def __call__(self, declarations_str, inherited=None):
 
         # 3. TODO: resolve other font-relative units
         for side in self.SIDES:
-            prop = "border-{side}-width".format(side=side)
+            prop = f"border-{side}-width"
             if prop in props:
                 props[prop] = self.size_to_pt(
                     props[prop], em_pt=font_size, conversions=self.BORDER_WIDTH_RATIOS
                 )
             for prop in [
-                "margin-{side}".format(side=side),
-                "padding-{side}".format(side=side),
+                f"margin-{side}",
+                f"padding-{side}",
             ]:
                 if prop in props:
                     # TODO: support %
@@ -156,7 +175,7 @@ def __call__(self, declarations_str, inherited=None):
 
     def size_to_pt(self, in_val, em_pt=None, conversions=UNIT_RATIOS):
         def _error():
-            warnings.warn("Unhandled size: {val!r}".format(val=in_val), CSSWarning)
+            warnings.warn(f"Unhandled size: {repr(in_val)}", CSSWarning)
             return self.size_to_pt("1!!default", conversions=conversions)
 
         try:
@@ -189,9 +208,9 @@ def _error():
 
         val = round(val, 5)
         if int(val) == val:
-            size_fmt = "{fmt:d}pt".format(fmt=int(val))
+            size_fmt = f"{int(val):d}pt"
         else:
-            size_fmt = "{fmt:f}pt".format(fmt=val)
+            size_fmt = f"{val:f}pt"
         return size_fmt
 
     def atomize(self, declarations):
@@ -213,32 +232,21 @@ def atomize(self, declarations):
     }
     SIDES = ("top", "right", "bottom", "left")
 
-    def _side_expander(prop_fmt):
-        def expand(self, prop, value):
-            tokens = value.split()
-            try:
-                mapping = self.SIDE_SHORTHANDS[len(tokens)]
-            except KeyError:
-                warnings.warn(
-                    'Could not expand "{prop}: {val}"'.format(prop=prop, val=value),
-                    CSSWarning,
-                )
-                return
-            for key, idx in zip(self.SIDES, mapping):
-                yield prop_fmt.format(key), tokens[idx]
-
-        return expand
-
     expand_border_color = _side_expander("border-{:s}-color")
     expand_border_style = _side_expander("border-{:s}-style")
     expand_border_width = _side_expander("border-{:s}-width")
     expand_margin = _side_expander("margin-{:s}")
     expand_padding = _side_expander("padding-{:s}")
 
-    def parse(self, declarations_str):
-        """Generates (prop, value) pairs from declarations
+    def parse(self, declarations_str: str):
+        """
+        Generates (prop, value) pairs from declarations.
 
         In a future version may generate parsed tokens from tinycss/tinycss2
+
+        Parameters
+        ----------
+        declarations_str : str
         """
         for decl in declarations_str.split(";"):
             if not decl.strip():
@@ -251,7 +259,6 @@ def parse(self, declarations_str):
                 yield prop, val
             else:
                 warnings.warn(
-                    "Ill-formatted attribute: expected a colon "
-                    "in {decl!r}".format(decl=decl),
+                    f"Ill-formatted attribute: expected a colon in {repr(decl)}",
                     CSSWarning,
                 )
diff --git a/pandas/io/formats/csvs.py b/pandas/io/formats/csvs.py
index e25862537cbfc..0d581f30e50e7 100644
--- a/pandas/io/formats/csvs.py
+++ b/pandas/io/formats/csvs.py
@@ -5,12 +5,14 @@
 import csv as csvlib
 from io import StringIO
 import os
+from typing import Hashable, List, Mapping, Optional, Sequence, Union
 import warnings
 from zipfile import ZipFile
 
 import numpy as np
 
 from pandas._libs import writers as libwriters
+from pandas._typing import FilePathOrBuffer
 
 from pandas.core.dtypes.generic import (
     ABCDatetimeIndex,
@@ -21,11 +23,10 @@
 from pandas.core.dtypes.missing import notna
 
 from pandas.io.common import (
-    UnicodeWriter,
-    _get_compression_method,
-    _get_handle,
-    _infer_compression,
+    get_compression_method,
     get_filepath_or_buffer,
+    get_handle,
+    infer_compression,
 )
 
 
@@ -33,34 +34,33 @@ class CSVFormatter:
     def __init__(
         self,
         obj,
-        path_or_buf=None,
-        sep=",",
-        na_rep="",
-        float_format=None,
+        path_or_buf: Optional[FilePathOrBuffer[str]] = None,
+        sep: str = ",",
+        na_rep: str = "",
+        float_format: Optional[str] = None,
         cols=None,
-        header=True,
-        index=True,
-        index_label=None,
-        mode="w",
-        encoding=None,
-        compression="infer",
-        quoting=None,
+        header: Union[bool, Sequence[Hashable]] = True,
+        index: bool = True,
+        index_label: Optional[Union[bool, Hashable, Sequence[Hashable]]] = None,
+        mode: str = "w",
+        encoding: Optional[str] = None,
+        compression: Union[str, Mapping[str, str], None] = "infer",
+        quoting: Optional[int] = None,
         line_terminator="\n",
-        chunksize=None,
+        chunksize: Optional[int] = None,
         quotechar='"',
-        date_format=None,
-        doublequote=True,
-        escapechar=None,
+        date_format: Optional[str] = None,
+        doublequote: bool = True,
+        escapechar: Optional[str] = None,
         decimal=".",
     ):
-
         self.obj = obj
 
         if path_or_buf is None:
             path_or_buf = StringIO()
 
         # Extract compression mode as given, if dict
-        compression, self.compression_args = _get_compression_method(compression)
+        compression, self.compression_args = get_compression_method(compression)
 
         self.path_or_buf, _, _, _ = get_filepath_or_buffer(
             path_or_buf, encoding=encoding, compression=compression, mode=mode
@@ -77,7 +77,7 @@ def __init__(
         if encoding is None:
             encoding = "utf-8"
         self.encoding = encoding
-        self.compression = _infer_compression(self.path_or_buf, compression)
+        self.compression = infer_compression(self.path_or_buf, compression)
 
         if quoting is None:
             quoting = csvlib.QUOTE_MINIMAL
@@ -154,14 +154,17 @@ def __init__(
         if not index:
             self.nlevels = 0
 
-    def save(self):
+    def save(self) -> None:
         """
-        Create the writer & save
+        Create the writer & save.
         """
         # GH21227 internal compression is not used when file-like passed.
         if self.compression and hasattr(self.path_or_buf, "write"):
-            msg = "compression has no effect when passing file-like object as input."
-            warnings.warn(msg, RuntimeWarning, stacklevel=2)
+            warnings.warn(
+                "compression has no effect when passing file-like object as input.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
 
         # when zip compression is called.
         is_zip = isinstance(self.path_or_buf, ZipFile) or (
@@ -178,7 +181,7 @@ def save(self):
             f = self.path_or_buf
             close = False
         else:
-            f, handles = _get_handle(
+            f, handles = get_handle(
                 self.path_or_buf,
                 self.mode,
                 encoding=self.encoding,
@@ -187,7 +190,9 @@ def save(self):
             close = True
 
         try:
-            writer_kwargs = dict(
+            # Note: self.encoding is irrelevant here
+            self.writer = csvlib.writer(
+                f,
                 lineterminator=self.line_terminator,
                 delimiter=self.sep,
                 quoting=self.quoting,
@@ -195,11 +200,6 @@ def save(self):
                 escapechar=self.escapechar,
                 quotechar=self.quotechar,
             )
-            if self.encoding == "ascii":
-                self.writer = csvlib.writer(f, **writer_kwargs)
-            else:
-                writer_kwargs["encoding"] = self.encoding
-                self.writer = UnicodeWriter(f, **writer_kwargs)
 
             self._save()
 
@@ -212,7 +212,7 @@ def save(self):
                 else:
                     compression = dict(self.compression_args, method=self.compression)
 
-                    f, handles = _get_handle(
+                    f, handles = get_handle(
                         self.path_or_buf,
                         self.mode,
                         encoding=self.encoding,
@@ -226,14 +226,13 @@ def save(self):
                     _fh.close()
 
     def _save_header(self):
-
         writer = self.writer
         obj = self.obj
         index_label = self.index_label
         cols = self.cols
         has_mi_columns = self.has_mi_columns
         header = self.header
-        encoded_labels = []
+        encoded_labels: List[str] = []
 
         has_aliases = isinstance(header, (tuple, list, np.ndarray, ABCIndexClass))
         if not (has_aliases or self.header):
@@ -241,10 +240,7 @@ def _save_header(self):
         if has_aliases:
             if len(header) != len(cols):
                 raise ValueError(
-                    (
-                        "Writing {ncols} cols but got {nalias} "
-                        "aliases".format(ncols=len(cols), nalias=len(header))
-                    )
+                    f"Writing {len(cols)} cols but got {len(header)} aliases"
                 )
             else:
                 write_cols = header
@@ -309,8 +305,7 @@ def _save_header(self):
                 encoded_labels.extend([""] * len(columns))
                 writer.writerow(encoded_labels)
 
-    def _save(self):
-
+    def _save(self) -> None:
         self._save_header()
 
         nrows = len(self.data_index)
@@ -327,8 +322,7 @@ def _save(self):
 
             self._save_chunk(start_i, end_i)
 
-    def _save_chunk(self, start_i, end_i):
-
+    def _save_chunk(self, start_i: int, end_i: int) -> None:
         data_index = self.data_index
 
         # create the data for a chunk
diff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py
index b9c847ad64c57..28a069bc9fc1b 100644
--- a/pandas/io/formats/excel.py
+++ b/pandas/io/formats/excel.py
@@ -1,20 +1,25 @@
-"""Utilities for conversion to writer-agnostic Excel representation
+"""
+Utilities for conversion to writer-agnostic Excel representation.
 """
 
 from functools import reduce
 import itertools
 import re
+from typing import Callable, Dict, Optional, Sequence, Union
 import warnings
 
 import numpy as np
 
+from pandas._typing import Label
+
 from pandas.core.dtypes import missing
 from pandas.core.dtypes.common import is_float, is_scalar
-from pandas.core.dtypes.generic import ABCMultiIndex, ABCPeriodIndex
+from pandas.core.dtypes.generic import ABCIndex, ABCMultiIndex, ABCPeriodIndex
 
 from pandas import Index
 import pandas.core.common as com
 
+from pandas.io.common import stringify_path
 from pandas.io.formats.css import CSSResolver, CSSWarning
 from pandas.io.formats.format import get_level_lengths
 from pandas.io.formats.printing import pprint_thing
@@ -24,7 +29,9 @@ class ExcelCell:
     __fields__ = ("row", "col", "val", "style", "mergestart", "mergeend")
     __slots__ = __fields__
 
-    def __init__(self, row, col, val, style=None, mergestart=None, mergeend=None):
+    def __init__(
+        self, row: int, col: int, val, style=None, mergestart=None, mergeend=None
+    ):
         self.row = row
         self.col = col
         self.val = val
@@ -55,7 +62,7 @@ class CSSToExcelConverter:
     #     instancemethods so that users can easily experiment with extensions
     #     without monkey-patching.
 
-    def __init__(self, inherited=None):
+    def __init__(self, inherited: Optional[str] = None):
         if inherited is not None:
             inherited = self.compute_css(inherited)
 
@@ -63,8 +70,9 @@ def __init__(self, inherited=None):
 
     compute_css = CSSResolver()
 
-    def __call__(self, declarations_str):
-        """Convert CSS declarations to ExcelWriter style
+    def __call__(self, declarations_str: str) -> Dict[str, Dict[str, str]]:
+        """
+        Convert CSS declarations to ExcelWriter style.
 
         Parameters
         ----------
@@ -82,7 +90,7 @@ def __call__(self, declarations_str):
         properties = self.compute_css(declarations_str, self.inherited)
         return self.build_xlstyle(properties)
 
-    def build_xlstyle(self, props):
+    def build_xlstyle(self, props: Dict[str, str]) -> Dict[str, Dict[str, str]]:
         out = {
             "alignment": self.build_alignment(props),
             "border": self.build_border(props),
@@ -90,9 +98,10 @@ def build_xlstyle(self, props):
             "font": self.build_font(props),
             "number_format": self.build_number_format(props),
         }
+
         # TODO: handle cell width and height: needs support in pandas.io.excel
 
-        def remove_none(d):
+        def remove_none(d: Dict[str, str]) -> None:
             """Remove key where value is None, through nested dicts"""
             for k, v in list(d.items()):
                 if v is None:
@@ -115,7 +124,7 @@ def remove_none(d):
         # OpenXML also has 'justify', 'distributed'
     }
 
-    def build_alignment(self, props):
+    def build_alignment(self, props) -> Dict[str, Optional[Union[bool, str]]]:
         # TODO: text-indent, padding-left -> alignment.indent
         return {
             "horizontal": props.get("text-align"),
@@ -127,21 +136,19 @@ def build_alignment(self, props):
             ),
         }
 
-    def build_border(self, props):
+    def build_border(self, props: Dict) -> Dict[str, Dict[str, str]]:
         return {
             side: {
                 "style": self._border_style(
-                    props.get("border-{side}-style".format(side=side)),
-                    props.get("border-{side}-width".format(side=side)),
-                ),
-                "color": self.color_to_excel(
-                    props.get("border-{side}-color".format(side=side))
+                    props.get(f"border-{side}-style"),
+                    props.get(f"border-{side}-width"),
                 ),
+                "color": self.color_to_excel(props.get(f"border-{side}-color")),
             }
             for side in ["top", "right", "bottom", "left"]
         }
 
-    def _border_style(self, style, width):
+    def _border_style(self, style: Optional[str], width):
         # convert styles and widths to openxml, one of:
         #       'dashDot'
         #       'dashDotDot'
@@ -190,7 +197,7 @@ def _border_style(self, style, width):
                 return "dashed"
             return "mediumDashed"
 
-    def build_fill(self, props):
+    def build_fill(self, props: Dict[str, str]):
         # TODO: perhaps allow for special properties
         #       -excel-pattern-bgcolor and -excel-pattern-type
         fill_color = props.get("background-color")
@@ -214,7 +221,7 @@ def build_fill(self, props):
     }
     ITALIC_MAP = {"normal": False, "italic": True, "oblique": True}
 
-    def build_font(self, props):
+    def build_font(self, props) -> Dict[str, Optional[Union[bool, int, str]]]:
         size = props.get("font-size")
         if size is not None:
             assert size.endswith("pt")
@@ -279,6 +286,7 @@ def build_font(self, props):
                 if "text-shadow" in props
                 else None
             ),
+            # FIXME: dont leave commented-out
             # 'vertAlign':,
             # 'charset': ,
             # 'scheme': ,
@@ -309,7 +317,7 @@ def build_font(self, props):
         "white": "FFFFFF",
     }
 
-    def color_to_excel(self, val):
+    def color_to_excel(self, val: Optional[str]):
         if val is None:
             return None
         if val.startswith("#") and len(val) == 7:
@@ -319,9 +327,9 @@ def color_to_excel(self, val):
         try:
             return self.NAMED_COLORS[val]
         except KeyError:
-            warnings.warn("Unhandled color format: {val!r}".format(val=val), CSSWarning)
+            warnings.warn(f"Unhandled color format: {repr(val)}", CSSWarning)
 
-    def build_number_format(self, props):
+    def build_number_format(self, props: Dict) -> Dict[str, Optional[str]]:
         return {"format_code": props.get("number-format")}
 
 
@@ -364,15 +372,15 @@ class ExcelFormatter:
     def __init__(
         self,
         df,
-        na_rep="",
-        float_format=None,
-        cols=None,
-        header=True,
-        index=True,
-        index_label=None,
-        merge_cells=False,
-        inf_rep="inf",
-        style_converter=None,
+        na_rep: str = "",
+        float_format: Optional[str] = None,
+        cols: Optional[Sequence[Label]] = None,
+        header: Union[Sequence[Label], bool] = True,
+        index: bool = True,
+        index_label: Optional[Union[Label, Sequence[Label]]] = None,
+        merge_cells: bool = False,
+        inf_rep: str = "inf",
+        style_converter: Optional[Callable] = None,
     ):
         self.rowcounter = 0
         self.na_rep = na_rep
@@ -391,16 +399,12 @@ def __init__(
             if not len(Index(cols) & df.columns):
                 raise KeyError("passes columns are not ALL present dataframe")
 
-            # deprecatedin gh-17295
-            # 1 missing is ok (for now)
             if len(Index(cols) & df.columns) != len(cols):
-                warnings.warn(
-                    "Not all names specified in 'columns' are found; "
-                    "this will raise a KeyError in the future",
-                    FutureWarning,
-                )
+                # Deprecated in GH#17295, enforced in 1.0.0
+                raise KeyError("Not all names specified in 'columns' are found")
 
             self.df = df.reindex(columns=cols)
+
         self.columns = self.df.columns
         self.float_format = float_format
         self.index = index
@@ -429,7 +433,7 @@ def _format_value(self, val):
             if missing.isposinf_scalar(val):
                 val = self.inf_rep
             elif missing.isneginf_scalar(val):
-                val = "-{inf}".format(inf=self.inf_rep)
+                val = f"-{self.inf_rep}"
             elif self.float_format is not None:
                 val = float(self.float_format % val)
         if getattr(val, "tzinfo", None) is not None:
@@ -444,13 +448,11 @@ def _format_header_mi(self):
         if self.columns.nlevels > 1:
             if not self.index:
                 raise NotImplementedError(
-                    "Writing to Excel with MultiIndex"
-                    " columns and no index "
-                    "('index'=False) is not yet "
-                    "implemented."
+                    "Writing to Excel with MultiIndex columns and no "
+                    "index ('index'=False) is not yet implemented."
                 )
 
-        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, Index))
+        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, ABCIndex))
         if not (has_aliases or self.header):
             return
 
@@ -498,7 +500,7 @@ def _format_header_mi(self):
         self.rowcounter = lnum
 
     def _format_header_regular(self):
-        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, Index))
+        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, ABCIndex))
         if has_aliases or self.header:
             coloffset = 0
 
@@ -511,8 +513,8 @@ def _format_header_regular(self):
             if has_aliases:
                 if len(self.header) != len(self.columns):
                     raise ValueError(
-                        "Writing {cols} cols but got {alias} "
-                        "aliases".format(cols=len(self.columns), alias=len(self.header))
+                        f"Writing {len(self.columns)} cols but got {len(self.header)} "
+                        "aliases"
                     )
                 else:
                     colnames = self.header
@@ -542,14 +544,13 @@ def _format_header(self):
         return itertools.chain(gen, gen2)
 
     def _format_body(self):
-
         if isinstance(self.df.index, ABCMultiIndex):
             return self._format_hierarchical_rows()
         else:
             return self._format_regular_rows()
 
     def _format_regular_rows(self):
-        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, Index))
+        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, ABCIndex))
         if has_aliases or self.header:
             self.rowcounter += 1
 
@@ -589,7 +590,7 @@ def _format_regular_rows(self):
             yield cell
 
     def _format_hierarchical_rows(self):
-        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, Index))
+        has_aliases = isinstance(self.header, (tuple, list, np.ndarray, ABCIndex))
         if has_aliases or self.header:
             self.rowcounter += 1
 
@@ -665,7 +666,7 @@ def _format_hierarchical_rows(self):
         for cell in self._generate_body(gcolidx):
             yield cell
 
-    def _generate_body(self, coloffset):
+    def _generate_body(self, coloffset: int):
         if self.styler is None:
             styles = None
         else:
@@ -714,20 +715,18 @@ def write(
             and ``io.excel.xlsm.writer``.
         """
         from pandas.io.excel import ExcelWriter
-        from pandas.io.common import _stringify_path
 
         num_rows, num_cols = self.df.shape
         if num_rows > self.max_rows or num_cols > self.max_cols:
             raise ValueError(
-                "This sheet is too large! Your sheet size is: "
-                + "{}, {} ".format(num_rows, num_cols)
-                + "Max sheet size is: {}, {}".format(self.max_rows, self.max_cols)
+                f"This sheet is too large! Your sheet size is: {num_rows}, {num_cols} "
+                f"Max sheet size is: {self.max_rows}, {self.max_cols}"
             )
 
         if isinstance(writer, ExcelWriter):
             need_save = False
         else:
-            writer = ExcelWriter(_stringify_path(writer), engine=engine)
+            writer = ExcelWriter(stringify_path(writer), engine=engine)
             need_save = True
 
         formatted_cells = self.get_formatted_cells()
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 4a66ad48d1318..35a6870c1194b 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -3,7 +3,6 @@
 and latex files. This module also applies to display formatting.
 """
 
-import codecs
 from contextlib import contextmanager
 from datetime import tzinfo
 import decimal
@@ -20,7 +19,9 @@
     Dict,
     Iterable,
     List,
+    Mapping,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -33,9 +34,11 @@
 from pandas._config.config import get_option, set_option
 
 from pandas._libs import lib
+from pandas._libs.missing import NA
 from pandas._libs.tslib import format_array_from_datetime
 from pandas._libs.tslibs import NaT, Timedelta, Timestamp, iNaT
 from pandas._libs.tslibs.nattype import NaTType
+from pandas._typing import FilePathOrBuffer
 from pandas.errors import AbstractMethodError
 
 from pandas.core.dtypes.common import (
@@ -54,30 +57,32 @@
     is_timedelta64_dtype,
 )
 from pandas.core.dtypes.generic import (
+    ABCDatetimeIndex,
     ABCIndexClass,
     ABCMultiIndex,
+    ABCPeriodIndex,
     ABCSeries,
     ABCSparseArray,
+    ABCTimedeltaIndex,
 )
 from pandas.core.dtypes.missing import isna, notna
 
-from pandas._typing import FilePathOrBuffer
 from pandas.core.arrays.datetimes import DatetimeArray
 from pandas.core.arrays.timedeltas import TimedeltaArray
 from pandas.core.base import PandasObject
 import pandas.core.common as com
-from pandas.core.index import Index, ensure_index
+from pandas.core.indexes.api import Index, ensure_index
 from pandas.core.indexes.datetimes import DatetimeIndex
 from pandas.core.indexes.timedeltas import TimedeltaIndex
 
-from pandas.io.common import _stringify_path
+from pandas.io.common import stringify_path
 from pandas.io.formats.printing import adjoin, justify, pprint_thing
 
 if TYPE_CHECKING:
     from pandas import Series, DataFrame, Categorical
 
 formatters_type = Union[
-    List[Callable], Tuple[Callable, ...], Dict[Union[str, int], Callable]
+    List[Callable], Tuple[Callable, ...], Mapping[Union[str, int], Callable]
 ]
 float_format_type = Union[str, Callable, "EngFormatter"]
 
@@ -90,7 +95,7 @@
             The subset of columns to write. Writes all columns by default.
         col_space : %(col_space_type)s, optional
             %(col_space)s.
-        header : bool, optional
+        header : %(header_type)s, optional
             %(header)s.
         index : bool, optional, default True
             Whether to print index (row) labels.
@@ -229,7 +234,7 @@ def __init__(
         self,
         series: "Series",
         buf: Optional[IO[str]] = None,
-        length: bool = True,
+        length: Union[bool, str] = True,
         header: bool = True,
         index: bool = True,
         na_rep: str = "NaN",
@@ -260,6 +265,8 @@ def __init__(
     def _chk_truncate(self) -> None:
         from pandas.core.reshape.concat import concat
 
+        self.tr_row_num: Optional[int]
+
         min_rows = self.min_rows
         max_rows = self.max_rows
         # truncation determined by max_rows, actual truncated number of rows
@@ -277,8 +284,10 @@ def _chk_truncate(self) -> None:
                 series = series.iloc[:max_rows]
             else:
                 row_num = max_rows // 2
-                series = concat((series.iloc[:row_num], series.iloc[-row_num:]))
-            self.tr_row_num = row_num  # type: Optional[int]
+                series = series._ensure_type(
+                    concat((series.iloc[:row_num], series.iloc[-row_num:]))
+                )
+            self.tr_row_num = row_num
         else:
             self.tr_row_num = None
         self.tr_series = series
@@ -289,6 +298,9 @@ def _get_footer(self) -> str:
         footer = ""
 
         if getattr(self.series.index, "freq", None) is not None:
+            assert isinstance(
+                self.series.index, (ABCDatetimeIndex, ABCPeriodIndex, ABCTimedeltaIndex)
+            )
             footer += "Freq: {freq}".format(freq=self.series.index.freqstr)
 
         if self.name is not False and name is not None:
@@ -348,7 +360,7 @@ def to_string(self) -> str:
 
         if len(series) == 0:
             return "{name}([], {footer})".format(
-                name=self.series.__class__.__name__, footer=footer
+                name=type(self.series).__name__, footer=footer
             )
 
         fmt_index, have_header = self._get_formatted_index()
@@ -406,7 +418,7 @@ def __init__(self):
             self.ambiguous_width = 1
 
         # Definition of East Asian Width
-        # http://unicode.org/reports/tr11/
+        # https://unicode.org/reports/tr11/
         # Ambiguous width can be changed by option
         self._EAW_MAP = {"Na": 1, "N": 1, "W": 2, "F": 2, "H": 1}
 
@@ -446,13 +458,13 @@ def _get_adjustment() -> TextAdjustment:
 
 class TableFormatter:
 
-    show_dimensions = None  # type: bool
-    is_truncated = None  # type: bool
-    formatters = None  # type: formatters_type
-    columns = None  # type: Index
+    show_dimensions: Union[bool, str]
+    is_truncated: bool
+    formatters: formatters_type
+    columns: Index
 
     @property
-    def should_show_dimensions(self) -> Optional[bool]:
+    def should_show_dimensions(self) -> bool:
         return self.show_dimensions is True or (
             self.show_dimensions == "truncate" and self.is_truncated
         )
@@ -478,17 +490,23 @@ def get_buffer(
         objects, otherwise yield buf unchanged.
         """
         if buf is not None:
-            buf = _stringify_path(buf)
+            buf = stringify_path(buf)
         else:
             buf = StringIO()
 
         if encoding is None:
             encoding = "utf-8"
+        elif not isinstance(buf, str):
+            raise ValueError("buf is not a file name and encoding is specified.")
 
         if hasattr(buf, "write"):
             yield buf
         elif isinstance(buf, str):
-            with codecs.open(buf, "w", encoding=encoding) as f:
+            with open(buf, "w", encoding=encoding, newline="") as f:
+                # GH#30034 open instead of codecs.open prevents a file leak
+                #  if we have an invalid encoding argument.
+                # newline="" is needed to roundtrip correctly on
+                #  windows test_to_latex_filename
                 yield f
         else:
             raise TypeError("buf is not a file name and it has no write method")
@@ -530,9 +548,9 @@ class DataFrameFormatter(TableFormatter):
     def __init__(
         self,
         frame: "DataFrame",
-        columns: Optional[List[str]] = None,
+        columns: Optional[Sequence[str]] = None,
         col_space: Optional[Union[str, int]] = None,
-        header: Union[bool, List[str]] = True,
+        header: Union[bool, Sequence[str]] = True,
         index: bool = True,
         na_rep: str = "NaN",
         formatters: Optional[formatters_type] = None,
@@ -544,7 +562,7 @@ def __init__(
         max_rows: Optional[int] = None,
         min_rows: Optional[int] = None,
         max_cols: Optional[int] = None,
-        show_dimensions: bool = False,
+        show_dimensions: Union[bool, str] = False,
         decimal: str = ".",
         table_id: Optional[str] = None,
         render_links: bool = False,
@@ -560,7 +578,17 @@ def __init__(
         self.sparsify = sparsify
 
         self.float_format = float_format
-        self.formatters = formatters if formatters is not None else {}
+        if formatters is None:
+            self.formatters = {}
+        elif len(frame.columns) == len(formatters) or isinstance(formatters, dict):
+            self.formatters = formatters
+        else:
+            raise ValueError(
+                (
+                    "Formatters length({flen}) should match "
+                    "DataFrame number of columns({dlen})"
+                ).format(flen=len(formatters), dlen=len(frame.columns))
+            )
         self.na_rep = na_rep
         self.decimal = decimal
         self.col_space = col_space
@@ -602,6 +630,8 @@ def _chk_truncate(self) -> None:
         # Cut the data to the information actually printed
         max_cols = self.max_cols
         max_rows = self.max_rows
+        self.max_rows_adj: Optional[int]
+        max_rows_adj: Optional[int]
 
         if max_cols == 0 or max_rows == 0:  # assume we are in the terminal
             (w, h) = get_terminal_size()
@@ -617,7 +647,7 @@ def _chk_truncate(self) -> None:
                 self.header = cast(bool, self.header)
                 n_add_rows = self.header + dot_row + show_dimension_rows + prompt_row
                 # rows available to fill with actual data
-                max_rows_adj = self.h - n_add_rows  # type: Optional[int]
+                max_rows_adj = self.h - n_add_rows
                 self.max_rows_adj = max_rows_adj
 
             # Format only rows and columns that could potentially fit the
@@ -657,6 +687,13 @@ def _chk_truncate(self) -> None:
                 frame = concat(
                     (frame.iloc[:, :col_num], frame.iloc[:, -col_num:]), axis=1
                 )
+                # truncate formatter
+                if isinstance(self.formatters, (list, tuple)):
+                    truncate_fmt = self.formatters
+                    self.formatters = [
+                        *truncate_fmt[:col_num],
+                        *truncate_fmt[-col_num:],
+                    ]
             self.tr_col_num = col_num
         if truncate_v:
             # cast here since if truncate_v is True, max_rows_adj is not None
@@ -706,12 +743,8 @@ def _to_str_columns(self) -> List[List[str]]:
                 self.header = cast(List[str], self.header)
                 if len(self.header) != len(self.columns):
                     raise ValueError(
-                        (
-                            "Writing {ncols} cols but got {nalias} "
-                            "aliases".format(
-                                ncols=len(self.columns), nalias=len(self.header)
-                            )
-                        )
+                        f"Writing {len(self.columns)} cols "
+                        f"but got {len(self.header)} aliases"
                     )
                 str_columns = [[label] for label in self.header]
             else:
@@ -850,6 +883,8 @@ def _join_multiline(self, *args) -> str:
             np.array([self.adj.len(x) for x in col]).max() if len(col) > 0 else 0
             for col in strcols
         ]
+
+        assert lwidth is not None
         col_bins = _binify(col_widths, lwidth)
         nbins = len(col_bins)
 
@@ -875,8 +910,12 @@ def _join_multiline(self, *args) -> str:
             st = ed
         return "\n\n".join(str_lst)
 
-    def to_string(self, buf: Optional[FilePathOrBuffer[str]] = None) -> Optional[str]:
-        return self.get_result(buf=buf)
+    def to_string(
+        self,
+        buf: Optional[FilePathOrBuffer[str]] = None,
+        encoding: Optional[str] = None,
+    ) -> Optional[str]:
+        return self.get_result(buf=buf, encoding=encoding)
 
     def to_latex(
         self,
@@ -922,6 +961,7 @@ def _format_col(self, i: int) -> List[str]:
     def to_html(
         self,
         buf: Optional[FilePathOrBuffer[str]] = None,
+        encoding: Optional[str] = None,
         classes: Optional[Union[str, List, Tuple]] = None,
         notebook: bool = False,
         border: Optional[int] = None,
@@ -939,14 +979,16 @@ def to_html(
         border : int
             A ``border=border`` attribute is included in the opening
             ``<table>`` tag. Default ``pd.options.display.html.border``.
-         """
+        """
         from pandas.io.formats.html import HTMLFormatter, NotebookFormatter
 
         Klass = NotebookFormatter if notebook else HTMLFormatter
-        return Klass(self, classes=classes, border=border).get_result(buf=buf)
+        return Klass(self, classes=classes, border=border).get_result(
+            buf=buf, encoding=encoding
+        )
 
     def _get_formatted_column_labels(self, frame: "DataFrame") -> List[List[str]]:
-        from pandas.core.index import _sparsify
+        from pandas.core.indexes.multi import _sparsify
 
         columns = frame.columns
 
@@ -1043,7 +1085,7 @@ def _get_formatted_index(self, frame: "DataFrame") -> List[str]:
             return adjoined
 
     def _get_column_name_list(self) -> List[str]:
-        names = []  # type: List[str]
+        names: List[str] = []
         columns = self.frame.columns
         if isinstance(columns, ABCMultiIndex):
             names.extend("" if name is None else name for name in columns.names)
@@ -1094,8 +1136,9 @@ def format_array(
     List[str]
     """
 
+    fmt_klass: Type[GenericArrayFormatter]
     if is_datetime64_dtype(values.dtype):
-        fmt_klass = Datetime64Formatter  # type: Type[GenericArrayFormatter]
+        fmt_klass = Datetime64Formatter
     elif is_datetime64tz_dtype(values):
         fmt_klass = Datetime64TZFormatter
     elif is_timedelta64_dtype(values.dtype):
@@ -1188,6 +1231,8 @@ def _format(x):
                     # determine na_rep if x is None or NaT-like
                     if x is None:
                         return "None"
+                    elif x is NA:
+                        return str(NA)
                     elif x is NaT or np.isnat(x):
                         return "NaT"
                 except (TypeError, ValueError):
@@ -1235,7 +1280,7 @@ class FloatArrayFormatter(GenericArrayFormatter):
     """
 
     def __init__(self, *args, **kwargs):
-        GenericArrayFormatter.__init__(self, *args, **kwargs)
+        super().__init__(*args, **kwargs)
 
         # float_format is expected to be a string
         # formatter should be used to pass a function
@@ -1345,11 +1390,12 @@ def format_values_with(float_format):
 
         # There is a special default string when we are fixed-width
         # The default is otherwise to use str instead of a formatting string
+        float_format: Optional[float_format_type]
         if self.float_format is None:
             if self.fixed_width:
                 float_format = partial(
                     "{value: .{digits:d}f}".format, digits=self.digits
-                )  # type: Optional[float_format_type]
+                )
             else:
                 float_format = self.float_format
         else:
@@ -1407,7 +1453,7 @@ def __init__(
         values: Union[np.ndarray, "Series", DatetimeIndex, DatetimeArray],
         nat_rep: str = "NaT",
         date_format: None = None,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(values, **kwargs)
         self.nat_rep = nat_rep
@@ -1598,7 +1644,7 @@ def _get_format_datetime64_from_values(
     """ given values and a date_format, return a string format """
 
     if isinstance(values, np.ndarray) and values.ndim > 1:
-        # We don't actaully care about the order of values, and DatetimeIndex
+        # We don't actually care about the order of values, and DatetimeIndex
         #  only accepts 1D values
         values = values.ravel()
 
@@ -1628,7 +1674,7 @@ def __init__(
         values: Union[np.ndarray, TimedeltaIndex],
         nat_rep: str = "NaT",
         box: bool = False,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(values, **kwargs)
         self.nat_rep = nat_rep
@@ -1872,7 +1918,7 @@ def set_eng_float_format(accuracy: int = 3, use_eng_prefix: bool = False) -> Non
     set_option("display.column_space", max(12, accuracy + 9))
 
 
-def _binify(cols: List[np.int32], line_width: Union[np.int32, int]) -> List[int]:
+def _binify(cols: List[int], line_width: int) -> List[int]:
     adjoin_width = 1
     bins = []
     curr_width = 0
diff --git a/pandas/io/formats/html.py b/pandas/io/formats/html.py
index 8c4a7f4a1213d..e3161415fe2bc 100644
--- a/pandas/io/formats/html.py
+++ b/pandas/io/formats/html.py
@@ -2,17 +2,18 @@
 Module for formatting output data in HTML.
 """
 
-from collections import OrderedDict
 from textwrap import dedent
-from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union, cast
+from typing import IO, Any, Dict, Iterable, List, Mapping, Optional, Tuple, Union, cast
 
 from pandas._config import get_option
 
+from pandas._libs import lib
+
 from pandas.core.dtypes.generic import ABCMultiIndex
 
 from pandas import option_context
 
-from pandas.io.common import _is_url
+from pandas.io.common import is_url
 from pandas.io.formats.format import (
     DataFrameFormatter,
     TableFormatter,
@@ -45,7 +46,7 @@ def __init__(
 
         self.frame = self.fmt.frame
         self.columns = self.fmt.tr_frame.columns
-        self.elements = []  # type: List[str]
+        self.elements: List[str] = []
         self.bold_rows = self.fmt.bold_rows
         self.escape = self.fmt.escape
         self.show_dimensions = self.fmt.show_dimensions
@@ -109,12 +110,12 @@ def write_th(
         ----------
         s : object
             The data to be written inside the cell.
-        header : boolean, default False
+        header : bool, default False
             Set to True if the <th> is for use inside <thead>.  This will
             cause min-width to be set if there is one.
         indent : int, default 0
             The indentation level of the cell.
-        tags : string, default None
+        tags : str, default None
             Tags to include in the cell.
 
         Returns
@@ -140,15 +141,13 @@ def _write_cell(
 
         if self.escape:
             # escape & first to prevent double escaping of &
-            esc = OrderedDict(
-                [("&", r"&amp;"), ("<", r"&lt;"), (">", r"&gt;")]
-            )  # type: Union[OrderedDict[str, str], Dict]
+            esc = {"&": r"&amp;", "<": r"&lt;", ">": r"&gt;"}
         else:
             esc = {}
 
         rs = pprint_thing(s, escape_chars=esc).strip()
 
-        if self.render_links and _is_url(rs):
+        if self.render_links and is_url(rs):
             rs_unescaped = pprint_thing(s, escape_chars={}).strip()
             start_tag += '<a href="{url}" target="_blank">'.format(url=rs_unescaped)
             end_a = "</a>"
@@ -217,8 +216,8 @@ def _write_table(self, indent: int = 0) -> None:
                 self.classes = self.classes.split()
             if not isinstance(self.classes, (list, tuple)):
                 raise TypeError(
-                    "classes must be a string, list, or tuple, "
-                    "not {typ}".format(typ=type(self.classes))
+                    "classes must be a string, list, "
+                    f"or tuple, not {type(self.classes)}"
                 )
             _classes.extend(self.classes)
 
@@ -248,7 +247,7 @@ def _write_col_header(self, indent: int) -> None:
 
             if self.fmt.sparsify:
                 # GH3547
-                sentinel = object()
+                sentinel = lib.no_default
             else:
                 sentinel = False
             levels = self.columns.format(sparsify=sentinel, adjoin=False, names=False)
@@ -377,7 +376,7 @@ def _write_header(self, indent: int) -> None:
         self.write("</thead>", indent)
 
     def _get_formatted_values(self) -> Dict[int, List[str]]:
-        with option_context("display.max_colwidth", 999999):
+        with option_context("display.max_colwidth", None):
             fmt_values = {i: self.fmt._format_col(i) for i in range(self.ncols)}
         return fmt_values
 
@@ -394,7 +393,7 @@ def _write_body(self, indent: int) -> None:
         self.write("</tbody>", indent)
 
     def _write_regular_rows(
-        self, fmt_values: Dict[int, List[str]], indent: int
+        self, fmt_values: Mapping[int, List[str]], indent: int
     ) -> None:
         truncate_h = self.fmt.truncate_h
         truncate_v = self.fmt.truncate_v
@@ -408,7 +407,7 @@ def _write_regular_rows(
             else:
                 index_values = self.fmt.tr_frame.index.format()
 
-        row = []  # type: List[str]
+        row: List[str] = []
         for i in range(nrows):
 
             if truncate_v and i == (self.fmt.tr_row_num):
@@ -440,7 +439,7 @@ def _write_regular_rows(
             )
 
     def _write_hierarchical_rows(
-        self, fmt_values: Dict[int, List[str]], indent: int
+        self, fmt_values: Mapping[int, List[str]], indent: int
     ) -> None:
         template = 'rowspan="{span}" valign="top"'
 
@@ -454,7 +453,7 @@ def _write_hierarchical_rows(
 
         if self.fmt.sparsify:
             # GH3547
-            sentinel = object()
+            sentinel = lib.no_default
             levels = frame.index.format(sparsify=sentinel, adjoin=False, names=False)
 
             level_lengths = get_level_lengths(levels, sentinel)
diff --git a/pandas/io/formats/latex.py b/pandas/io/formats/latex.py
index ca9db88ae7be4..8ab56437d5c05 100644
--- a/pandas/io/formats/latex.py
+++ b/pandas/io/formats/latex.py
@@ -11,8 +11,8 @@
 
 
 class LatexFormatter(TableFormatter):
-    """ Used to render a DataFrame to a LaTeX tabular/longtable environment
-    output.
+    """
+    Used to render a DataFrame to a LaTeX tabular/longtable environment output.
 
     Parameters
     ----------
@@ -106,18 +106,18 @@ def pad_empties(x):
             # Get rid of old multiindex column and add new ones
             strcols = out + strcols[1:]
 
-        column_format = self.column_format
-        if column_format is None:
+        if self.column_format is None:
             dtypes = self.frame.dtypes._values
             column_format = "".join(map(get_col_type, dtypes))
             if self.fmt.index:
                 index_format = "l" * self.frame.index.nlevels
                 column_format = index_format + column_format
-        elif not isinstance(column_format, str):  # pragma: no cover
+        elif not isinstance(self.column_format, str):  # pragma: no cover
             raise AssertionError(
-                "column_format must be str or unicode, "
-                "not {typ}".format(typ=type(column_format))
+                f"column_format must be str or unicode, not {type(column_format)}"
             )
+        else:
+            column_format = self.column_format
 
         if self.longtable:
             self._write_longtable_begin(buf, column_format)
@@ -132,7 +132,7 @@ def pad_empties(x):
         if self.fmt.has_index_names and self.fmt.show_index_names:
             nlevels += 1
         strrows = list(zip(*strcols))
-        self.clinebuf = []  # type: List[List[int]]
+        self.clinebuf: List[List[int]] = []
 
         for i, row in enumerate(strrows):
             if i == nlevels and self.fmt.header:
@@ -265,7 +265,7 @@ def _format_multirow(
 
     def _print_cline(self, buf: IO[str], i: int, icol: int) -> None:
         """
-        Print clines after multirow-blocks are finished
+        Print clines after multirow-blocks are finished.
         """
         for cl in self.clinebuf:
             if cl[0] == i:
@@ -273,7 +273,7 @@ def _print_cline(self, buf: IO[str], i: int, icol: int) -> None:
         # remove entries that have been written to buffer
         self.clinebuf = [x for x in self.clinebuf if x[0] != i]
 
-    def _write_tabular_begin(self, buf, column_format):
+    def _write_tabular_begin(self, buf, column_format: str):
         """
         Write the beginning of a tabular environment or
         nested table/tabular environments including caption and label.
@@ -283,11 +283,10 @@ def _write_tabular_begin(self, buf, column_format):
         buf : string or file handle
             File path or object. If not specified, the result is returned as
             a string.
-        column_format : str, default None
+        column_format : str
             The columns format as specified in `LaTeX table format
             <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g 'rcl'
             for 3 columns
-
         """
         if self.caption is not None or self.label is not None:
             # then write output in a nested table/tabular environment
@@ -327,7 +326,7 @@ def _write_tabular_end(self, buf):
         else:
             pass
 
-    def _write_longtable_begin(self, buf, column_format):
+    def _write_longtable_begin(self, buf, column_format: str):
         """
         Write the beginning of a longtable environment including caption and
         label if provided by user.
@@ -337,11 +336,10 @@ def _write_longtable_begin(self, buf, column_format):
         buf : string or file handle
             File path or object. If not specified, the result is returned as
             a string.
-        column_format : str, default None
+        column_format : str
             The columns format as specified in `LaTeX table format
             <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g 'rcl'
             for 3 columns
-
         """
         buf.write("\\begin{{longtable}}{{{fmt}}}\n".format(fmt=column_format))
 
diff --git a/pandas/io/formats/printing.py b/pandas/io/formats/printing.py
index ead51693da791..13b18a0b5fb6f 100644
--- a/pandas/io/formats/printing.py
+++ b/pandas/io/formats/printing.py
@@ -1,15 +1,29 @@
 """
-printing tools
+Printing tools.
 """
 
 import sys
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+)
 
 from pandas._config import get_option
 
 from pandas.core.dtypes.inference import is_sequence
 
-EscapeChars = Union[Dict[str, str], Iterable[str]]
+EscapeChars = Union[Mapping[str, str], Iterable[str]]
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
 
 
 def adjoin(space: int, *lists: List[str], **kwargs) -> str:
@@ -64,7 +78,7 @@ def justify(texts: Iterable[str], max_len: int, mode: str = "right") -> List[str
 #
 # pprinting utility functions for generating Unicode text or
 # bytes(3.x)/str(2.x) representations of objects.
-# Try to use these as much as possible rather then rolling your own.
+# Try to use these as much as possible rather than rolling your own.
 #
 # When to use
 # -----------
@@ -88,7 +102,7 @@ def _pprint_seq(
 ) -> str:
     """
     internal. pprinter for iterables. you should probably use pprint_thing()
-    rather then calling this directly.
+    rather than calling this directly.
 
     bounds length of printed sequence, depending on options
     """
@@ -119,11 +133,11 @@ def _pprint_seq(
 
 
 def _pprint_dict(
-    seq: Dict, _nest_lvl: int = 0, max_seq_items: Optional[int] = None, **kwds
+    seq: Mapping, _nest_lvl: int = 0, max_seq_items: Optional[int] = None, **kwds
 ) -> str:
     """
     internal. pprinter for iterables. you should probably use pprint_thing()
-    rather then calling this directly.
+    rather than calling this directly.
     """
     fmt = "{{{things}}}"
     pairs = []
@@ -172,13 +186,12 @@ def pprint_thing(
         replacements
     default_escapes : bool, default False
         Whether the input escape characters replaces or adds to the defaults
-    max_seq_items : False, int, default None
-        Pass thru to other pretty printers to limit sequence printing
+    max_seq_items : int or None, default None
+        Pass through to other pretty printers to limit sequence printing
 
     Returns
     -------
     str
-
     """
 
     def as_escaped_string(
@@ -302,7 +315,6 @@ def format_object_summary(
     Returns
     -------
     summary string
-
     """
     from pandas.io.formats.console import get_console_size
     from pandas.io.formats.format import _get_adjustment
@@ -311,12 +323,12 @@ def format_object_summary(
     if display_width is None:
         display_width = get_option("display.width") or 80
     if name is None:
-        name = obj.__class__.__name__
+        name = type(obj).__name__
 
     if indent_for_name:
         name_len = len(name)
-        space1 = "\n%s" % (" " * (name_len + 1))
-        space2 = "\n%s" % (" " * (name_len + 2))
+        space1 = f'\n{(" " * (name_len + 1))}'
+        space2 = f'\n{(" " * (name_len + 2))}'
     else:
         space1 = "\n"
         space2 = "\n "  # space for the opening '['
@@ -336,7 +348,9 @@ def format_object_summary(
     # adj can optionally handle unicode eastern asian width
     adj = _get_adjustment()
 
-    def _extend_line(s, line, value, display_width, next_line_prefix):
+    def _extend_line(
+        s: str, line: str, value: str, display_width: int, next_line_prefix: str
+    ) -> Tuple[str, str]:
 
         if adj.len(line.rstrip()) + adj.len(value.rstrip()) >= display_width:
             s += line.rstrip()
@@ -344,7 +358,7 @@ def _extend_line(s, line, value, display_width, next_line_prefix):
         line += value
         return s, line
 
-    def best_len(values):
+    def best_len(values: List[str]) -> int:
         if values:
             return max(adj.len(x) for x in values)
         else:
@@ -353,14 +367,14 @@ def best_len(values):
     close = ", "
 
     if n == 0:
-        summary = "[]{}".format(close)
+        summary = f"[]{close}"
     elif n == 1 and not line_break_each_value:
         first = formatter(obj[0])
-        summary = "[{}]{}".format(first, close)
+        summary = f"[{first}]{close}"
     elif n == 2 and not line_break_each_value:
         first = formatter(obj[0])
         last = formatter(obj[-1])
-        summary = "[{}, {}]{}".format(first, last, close)
+        summary = f"[{first}, {last}]{close}"
     else:
 
         if n > max_seq_items:
@@ -503,10 +517,10 @@ def format_object_attrs(
     list of 2-tuple
 
     """
-    attrs = []  # type: List[Tuple[str, Union[str, int]]]
+    attrs: List[Tuple[str, Union[str, int]]] = []
     if hasattr(obj, "dtype") and include_dtype:
         # error: "Sequence[Any]" has no attribute "dtype"
-        attrs.append(("dtype", "'{}'".format(obj.dtype)))  # type: ignore
+        attrs.append(("dtype", f"'{obj.dtype}'"))  # type: ignore
     if getattr(obj, "name", None) is not None:
         # error: "Sequence[Any]" has no attribute "name"
         attrs.append(("name", default_pprint(obj.name)))  # type: ignore
@@ -518,3 +532,10 @@ def format_object_attrs(
     if len(obj) > max_seq_items:
         attrs.append(("length", len(obj)))
     return attrs
+
+
+class PrettyDict(Dict[_KT, _VT]):
+    """Dict extension to support abbreviated __repr__"""
+
+    def __repr__(self) -> str:
+        return pprint_thing(self)
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 033d93d1456c8..565752e269d79 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -1,6 +1,5 @@
 """
-Module for applying conditional formatting to
-DataFrames and Series.
+Module for applying conditional formatting to DataFrames and Series.
 """
 
 from collections import defaultdict
@@ -8,21 +7,34 @@
 import copy
 from functools import partial
 from itertools import product
+from typing import (
+    Any,
+    Callable,
+    DefaultDict,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
 from uuid import uuid1
 
 import numpy as np
 
 from pandas._config import get_option
 
+from pandas._libs import lib
+from pandas._typing import Axis, FrameOrSeries, FrameOrSeriesUnion, Label
 from pandas.compat._optional import import_optional_dependency
 from pandas.util._decorators import Appender
 
-from pandas.core.dtypes.common import is_float, is_string_like
-from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.common import is_float
 
 import pandas as pd
 from pandas.api.types import is_dict_like, is_list_like
 import pandas.core.common as com
+from pandas.core.frame import DataFrame
 from pandas.core.generic import _shared_docs
 from pandas.core.indexing import _maybe_numeric_slice, _non_reducing_slice
 
@@ -40,7 +52,7 @@
 
 
 @contextmanager
-def _mpl(func):
+def _mpl(func: Callable):
     if has_mpl:
         yield plt, colors
     else:
@@ -54,19 +66,28 @@ class Styler:
     Parameters
     ----------
     data : Series or DataFrame
+        Data to be styled - either a Series or DataFrame.
     precision : int
-        precision to round floats to, defaults to pd.options.display.precision
+        Precision to round floats to, defaults to pd.options.display.precision.
     table_styles : list-like, default None
-        list of {selector: (attr, value)} dicts; see Notes
+        List of {selector: (attr, value)} dicts; see Notes.
     uuid : str, default None
-        a unique identifier to avoid CSS collisions; generated automatically
+        A unique identifier to avoid CSS collisions; generated automatically.
     caption : str, default None
-        caption to attach to the table
+        Caption to attach to the table.
+    table_attributes : str, default None
+        Items that show up in the opening ``<table>`` tag
+        in addition to automatic (by default) id.
     cell_ids : bool, default True
         If True, each cell will have an ``id`` attribute in their HTML tag.
         The ``id`` takes the form ``T_<uuid>_row<num_row>_col<num_col>``
         where ``<uuid>`` is the unique identifier, ``<num_row>`` is the row
         number and ``<num_col>`` is the column number.
+    na_rep : str, optional
+        Representation for missing values.
+        If ``na_rep`` is None, no special formatting is applied
+
+        .. versionadded:: 1.0.0
 
     Attributes
     ----------
@@ -76,7 +97,8 @@ class Styler:
 
     See Also
     --------
-    DataFrame.style
+    DataFrame.style : Return a Styler object containing methods for building
+        a styled HTML representation for the DataFrame.
 
     Notes
     -----
@@ -114,16 +136,17 @@ class Styler:
 
     def __init__(
         self,
-        data,
-        precision=None,
-        table_styles=None,
-        uuid=None,
-        caption=None,
-        table_attributes=None,
-        cell_ids=True,
+        data: FrameOrSeriesUnion,
+        precision: Optional[int] = None,
+        table_styles: Optional[List[Dict[str, List[Tuple[str, str]]]]] = None,
+        uuid: Optional[str] = None,
+        caption: Optional[str] = None,
+        table_attributes: Optional[str] = None,
+        cell_ids: bool = True,
+        na_rep: Optional[str] = None,
     ):
-        self.ctx = defaultdict(list)
-        self._todo = []
+        self.ctx: DefaultDict[Tuple[int, int], List[str]] = defaultdict(list)
+        self._todo: List[Tuple[Callable, Tuple, Dict]] = []
 
         if not isinstance(data, (pd.Series, pd.DataFrame)):
             raise TypeError("``data`` must be a Series or DataFrame")
@@ -144,20 +167,26 @@ def __init__(
         self.precision = precision
         self.table_attributes = table_attributes
         self.hidden_index = False
-        self.hidden_columns = []
+        self.hidden_columns: Sequence[int] = []
         self.cell_ids = cell_ids
+        self.na_rep = na_rep
 
         # display_funcs maps (row, col) -> formatting function
 
         def default_display_func(x):
-            if is_float(x):
-                return "{:>.{precision}g}".format(x, precision=self.precision)
+            if self.na_rep is not None and pd.isna(x):
+                return self.na_rep
+            elif is_float(x):
+                display_format = f"{x:.{self.precision}f}"
+                return display_format
             else:
                 return x
 
-        self._display_funcs = defaultdict(lambda: default_display_func)
+        self._display_funcs: DefaultDict[
+            Tuple[int, int], Callable[[Any], str]
+        ] = defaultdict(lambda: default_display_func)
 
-    def _repr_html_(self):
+    def _repr_html_(self) -> str:
         """
         Hooks into Jupyter notebook rich display system.
         """
@@ -178,22 +207,22 @@ def _repr_html_(self):
     def to_excel(
         self,
         excel_writer,
-        sheet_name="Sheet1",
-        na_rep="",
-        float_format=None,
-        columns=None,
-        header=True,
-        index=True,
-        index_label=None,
-        startrow=0,
-        startcol=0,
-        engine=None,
-        merge_cells=True,
-        encoding=None,
-        inf_rep="inf",
-        verbose=True,
-        freeze_panes=None,
-    ):
+        sheet_name: str = "Sheet1",
+        na_rep: str = "",
+        float_format: Optional[str] = None,
+        columns: Optional[Sequence[Label]] = None,
+        header: Union[Sequence[Label], bool] = True,
+        index: bool = True,
+        index_label: Optional[Union[Label, Sequence[Label]]] = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        engine: Optional[str] = None,
+        merge_cells: bool = True,
+        encoding: Optional[str] = None,
+        inf_rep: str = "inf",
+        verbose: bool = True,
+        freeze_panes: Optional[Tuple[int, int]] = None,
+    ) -> None:
 
         from pandas.io.formats.excel import ExcelFormatter
 
@@ -238,7 +267,7 @@ def _translate(self):
         BLANK_VALUE = ""
 
         def format_attr(pair):
-            return "{key}={value}".format(**pair)
+            return f"{pair['key']}={pair['value']}"
 
         # for sparsifying a MultiIndex
         idx_lengths = _get_level_lengths(self.index)
@@ -257,7 +286,7 @@ def format_attr(pair):
             clabels = [[x] for x in clabels]
         clabels = list(zip(*clabels))
 
-        cellstyle = []
+        cellstyle_map = defaultdict(list)
         head = []
 
         for r in range(n_clvls):
@@ -276,7 +305,7 @@ def format_attr(pair):
             name = self.data.columns.names[r]
             cs = [
                 BLANK_CLASS if name is None else INDEX_NAME_CLASS,
-                "level{lvl}".format(lvl=r),
+                f"level{r}",
             ]
             name = BLANK_VALUE if name is None else name
             row_es.append(
@@ -293,8 +322,8 @@ def format_attr(pair):
                 for c, value in enumerate(clabels[r]):
                     cs = [
                         COL_HEADING_CLASS,
-                        "level{lvl}".format(lvl=r),
-                        "col{col}".format(col=c),
+                        f"level{r}",
+                        f"col{c}",
                     ]
                     cs.extend(
                         cell_context.get("col_headings", {}).get(r, {}).get(c, [])
@@ -322,7 +351,7 @@ def format_attr(pair):
             index_header_row = []
 
             for c, name in enumerate(self.data.index.names):
-                cs = [INDEX_NAME_CLASS, "level{lvl}".format(lvl=c)]
+                cs = [INDEX_NAME_CLASS, f"level{c}"]
                 name = "" if name is None else name
                 index_header_row.append(
                     {"type": "th", "value": name, "class": " ".join(cs)}
@@ -341,8 +370,8 @@ def format_attr(pair):
             for c, value in enumerate(rlabels[r]):
                 rid = [
                     ROW_HEADING_CLASS,
-                    "level{lvl}".format(lvl=c),
-                    "row{row}".format(row=r),
+                    f"level{c}",
+                    f"row{r}",
                 ]
                 es = {
                     "type": "th",
@@ -360,7 +389,7 @@ def format_attr(pair):
                 row_es.append(es)
 
             for c, col in enumerate(self.data.columns):
-                cs = [DATA_CLASS, "row{row}".format(row=r), "col{col}".format(col=c)]
+                cs = [DATA_CLASS, f"row{r}", f"col{c}"]
                 cs.extend(cell_context.get("data", {}).get(r, {}).get(c, []))
                 formatter = self._display_funcs[(r, c)]
                 value = self.data.iloc[r, c]
@@ -379,17 +408,17 @@ def format_attr(pair):
                 for x in ctx[r, c]:
                     # have to handle empty styles like ['']
                     if x.count(":"):
-                        props.append(x.split(":"))
+                        props.append(tuple(x.split(":")))
                     else:
-                        props.append(["", ""])
-                cellstyle.append(
-                    {
-                        "props": props,
-                        "selector": "row{row}_col{col}".format(row=r, col=c),
-                    }
-                )
+                        props.append(("", ""))
+                cellstyle_map[tuple(props)].append(f"row{r}_col{c}")
             body.append(row_es)
 
+        cellstyle = [
+            {"props": list(props), "selectors": selectors}
+            for props, selectors in cellstyle_map.items()
+        ]
+
         table_attr = self.table_attributes
         use_mathjax = get_option("display.html.use_mathjax")
         if not use_mathjax:
@@ -410,16 +439,22 @@ def format_attr(pair):
             table_attributes=table_attr,
         )
 
-    def format(self, formatter, subset=None):
+    def format(self, formatter, subset=None, na_rep: Optional[str] = None) -> "Styler":
         """
         Format the text display value of cells.
 
         Parameters
         ----------
-        formatter : str, callable, or dict
+        formatter : str, callable, dict or None
+            If ``formatter`` is None, the default formatter is used
         subset : IndexSlice
             An argument to ``DataFrame.loc`` that restricts which elements
             ``formatter`` is applied to.
+        na_rep : str, optional
+            Representation for missing values.
+            If ``na_rep`` is None, no special formatting is applied
+
+            .. versionadded:: 1.0.0
 
         Returns
         -------
@@ -445,6 +480,10 @@ def format(self, formatter, subset=None):
         >>> df['c'] = ['a', 'b', 'c', 'd']
         >>> df.style.format({'c': str.upper})
         """
+        if formatter is None:
+            assert self._display_funcs.default_factory is not None
+            formatter = self._display_funcs.default_factory()
+
         if subset is None:
             row_locs = range(len(self.data))
             col_locs = range(len(self.data.columns))
@@ -460,20 +499,20 @@ def format(self, formatter, subset=None):
         if is_dict_like(formatter):
             for col, col_formatter in formatter.items():
                 # formatter must be callable, so '{}' are converted to lambdas
-                col_formatter = _maybe_wrap_formatter(col_formatter)
+                col_formatter = _maybe_wrap_formatter(col_formatter, na_rep)
                 col_num = self.data.columns.get_indexer_for([col])[0]
 
                 for row_num in row_locs:
                     self._display_funcs[(row_num, col_num)] = col_formatter
         else:
             # single scalar to format all cells with
+            formatter = _maybe_wrap_formatter(formatter, na_rep)
             locs = product(*(row_locs, col_locs))
             for i, j in locs:
-                formatter = _maybe_wrap_formatter(formatter)
                 self._display_funcs[(i, j)] = formatter
         return self
 
-    def render(self, **kwargs):
+    def render(self, **kwargs) -> str:
         """
         Render the built up styles to HTML.
 
@@ -485,8 +524,6 @@ def render(self, **kwargs):
             This is useful when you need to provide
             additional variables for a custom template.
 
-            .. versionadded:: 0.20
-
         Returns
         -------
         rendered : str
@@ -524,16 +561,18 @@ def render(self, **kwargs):
         d.update(kwargs)
         return self.template.render(**d)
 
-    def _update_ctx(self, attrs):
+    def _update_ctx(self, attrs: DataFrame) -> None:
         """
         Update the state of the Styler.
 
         Collects a mapping of {index_label: ['<property>: <value>']}.
 
-        attrs : Series or DataFrame
-        should contain strings of '<property>: <value>;<prop2>: <val2>'
-        Whitespace shouldn't matter and the final trailing ';' shouldn't
-        matter.
+        Parameters
+        ----------
+        attrs : DataFrame
+            should contain strings of '<property>: <value>;<prop2>: <val2>'
+            Whitespace shouldn't matter and the final trailing ';' shouldn't
+            matter.
         """
         for row_label, v in attrs.iterrows():
             for col_label, col in v.items():
@@ -542,13 +581,14 @@ def _update_ctx(self, attrs):
                 for pair in col.rstrip(";").split(";"):
                     self.ctx[(i, j)].append(pair)
 
-    def _copy(self, deepcopy=False):
+    def _copy(self, deepcopy: bool = False) -> "Styler":
         styler = Styler(
             self.data,
             precision=self.precision,
             caption=self.caption,
             uuid=self.uuid,
             table_styles=self.table_styles,
+            na_rep=self.na_rep,
         )
         if deepcopy:
             styler.ctx = copy.deepcopy(self.ctx)
@@ -558,18 +598,19 @@ def _copy(self, deepcopy=False):
             styler._todo = self._todo
         return styler
 
-    def __copy__(self):
+    def __copy__(self) -> "Styler":
         """
         Deep copy by default.
         """
         return self._copy(deepcopy=False)
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo) -> "Styler":
         return self._copy(deepcopy=True)
 
-    def clear(self):
+    def clear(self) -> None:
         """
         Reset the styler, removing any previously applied styles.
+
         Returns None.
         """
         self.ctx.clear()
@@ -589,7 +630,13 @@ def _compute(self):
             r = func(self)(*args, **kwargs)
         return r
 
-    def _apply(self, func, axis=0, subset=None, **kwargs):
+    def _apply(
+        self,
+        func: Callable[..., "Styler"],
+        axis: Optional[Axis] = 0,
+        subset=None,
+        **kwargs,
+    ) -> "Styler":
         subset = slice(None) if subset is None else subset
         subset = _non_reducing_slice(subset)
         data = self.data.loc[subset]
@@ -600,36 +647,39 @@ def _apply(self, func, axis=0, subset=None, **kwargs):
             result = func(data, **kwargs)
             if not isinstance(result, pd.DataFrame):
                 raise TypeError(
-                    "Function {func!r} must return a DataFrame when "
-                    "passed to `Styler.apply` with axis=None".format(func=func)
+                    f"Function {repr(func)} must return a DataFrame when "
+                    f"passed to `Styler.apply` with axis=None"
                 )
             if not (
                 result.index.equals(data.index) and result.columns.equals(data.columns)
             ):
-                msg = (
-                    "Result of {func!r} must have identical index and "
-                    "columns as the input".format(func=func)
+                raise ValueError(
+                    f"Result of {repr(func)} must have identical "
+                    f"index and columns as the input"
                 )
-                raise ValueError(msg)
 
         result_shape = result.shape
         expected_shape = self.data.loc[subset].shape
         if result_shape != expected_shape:
-            msg = (
-                "Function {func!r} returned the wrong shape.\n"
-                "Result has shape: {res}\n"
-                "Expected shape:   {expect}".format(
-                    func=func, res=result.shape, expect=expected_shape
-                )
+            raise ValueError(
+                f"Function {repr(func)} returned the wrong shape.\n"
+                f"Result has shape: {result.shape}\n"
+                f"Expected shape:   {expected_shape}"
             )
-            raise ValueError(msg)
         self._update_ctx(result)
         return self
 
-    def apply(self, func, axis=0, subset=None, **kwargs):
+    def apply(
+        self,
+        func: Callable[..., "Styler"],
+        axis: Optional[Axis] = 0,
+        subset=None,
+        **kwargs,
+    ) -> "Styler":
         """
-        Apply a function column-wise, row-wise, or table-wise,
-        updating the HTML representation with the result.
+        Apply a function column-wise, row-wise, or table-wise.
+
+        Updates the HTML representation with the result.
 
         Parameters
         ----------
@@ -637,16 +687,16 @@ def apply(self, func, axis=0, subset=None, **kwargs):
             ``func`` should take a Series or DataFrame (depending
             on ``axis``), and return an object with the same shape.
             Must return a DataFrame with identical index and
-            column labels when ``axis=None``
+            column labels when ``axis=None``.
         axis : {0 or 'index', 1 or 'columns', None}, default 0
-            apply to each column (``axis=0`` or ``'index'``), to each row
+            Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         subset : IndexSlice
-            a valid indexer to limit ``data`` to *before* applying the
-            function. Consider using a pandas.IndexSlice
-        kwargs : dict
-            pass along to ``func``
+            A valid indexer to limit ``data`` to *before* applying the
+            function. Consider using a pandas.IndexSlice.
+        **kwargs : dict
+            Pass along to ``func``.
 
         Returns
         -------
@@ -676,7 +726,7 @@ def apply(self, func, axis=0, subset=None, **kwargs):
         )
         return self
 
-    def _applymap(self, func, subset=None, **kwargs):
+    def _applymap(self, func: Callable, subset=None, **kwargs) -> "Styler":
         func = partial(func, **kwargs)  # applymap doesn't take kwargs?
         if subset is None:
             subset = pd.IndexSlice[:]
@@ -685,20 +735,21 @@ def _applymap(self, func, subset=None, **kwargs):
         self._update_ctx(result)
         return self
 
-    def applymap(self, func, subset=None, **kwargs):
+    def applymap(self, func: Callable, subset=None, **kwargs) -> "Styler":
         """
-        Apply a function elementwise, updating the HTML
-        representation with the result.
+        Apply a function elementwise.
+
+        Updates the HTML representation with the result.
 
         Parameters
         ----------
         func : function
-            ``func`` should take a scalar and return a scalar
+            ``func`` should take a scalar and return a scalar.
         subset : IndexSlice
-            a valid indexer to limit ``data`` to *before* applying the
-            function. Consider using a pandas.IndexSlice
-        kwargs : dict
-            pass along to ``func``
+            A valid indexer to limit ``data`` to *before* applying the
+            function. Consider using a pandas.IndexSlice.
+        **kwargs : dict
+            Pass along to ``func``.
 
         Returns
         -------
@@ -713,27 +764,35 @@ def applymap(self, func, subset=None, **kwargs):
         )
         return self
 
-    def where(self, cond, value, other=None, subset=None, **kwargs):
+    def where(
+        self,
+        cond: Callable,
+        value: str,
+        other: Optional[str] = None,
+        subset=None,
+        **kwargs,
+    ) -> "Styler":
         """
-        Apply a function elementwise, updating the HTML
-        representation with a style which is selected in
-        accordance with the return value of a function.
+        Apply a function elementwise.
+
+        Updates the HTML representation with a style which is
+        selected in accordance with the return value of a function.
 
         .. versionadded:: 0.21.0
 
         Parameters
         ----------
         cond : callable
-            ``cond`` should take a scalar and return a boolean
+            ``cond`` should take a scalar and return a boolean.
         value : str
-            applied when ``cond`` returns true
+            Applied when ``cond`` returns true.
         other : str
-            applied when ``cond`` returns false
+            Applied when ``cond`` returns false.
         subset : IndexSlice
-            a valid indexer to limit ``data`` to *before* applying the
-            function. Consider using a pandas.IndexSlice
-        kwargs : dict
-            pass along to ``cond``
+            A valid indexer to limit ``data`` to *before* applying the
+            function. Consider using a pandas.IndexSlice.
+        **kwargs : dict
+            Pass along to ``cond``.
 
         Returns
         -------
@@ -751,7 +810,7 @@ def where(self, cond, value, other=None, subset=None, **kwargs):
             lambda val: value if cond(val) else other, subset=subset, **kwargs
         )
 
-    def set_precision(self, precision):
+    def set_precision(self, precision: int) -> "Styler":
         """
         Set the precision used to render.
 
@@ -766,7 +825,7 @@ def set_precision(self, precision):
         self.precision = precision
         return self
 
-    def set_table_attributes(self, attributes):
+    def set_table_attributes(self, attributes: str) -> "Styler":
         """
         Set the table attributes.
 
@@ -775,7 +834,7 @@ def set_table_attributes(self, attributes):
 
         Parameters
         ----------
-        attributes : string
+        attributes : str
 
         Returns
         -------
@@ -790,7 +849,7 @@ def set_table_attributes(self, attributes):
         self.table_attributes = attributes
         return self
 
-    def export(self):
+    def export(self) -> List[Tuple[Callable, Tuple, Dict]]:
         """
         Export the styles to applied to the current Styler.
 
@@ -806,15 +865,16 @@ def export(self):
         """
         return self._todo
 
-    def use(self, styles):
+    def use(self, styles: List[Tuple[Callable, Tuple, Dict]]) -> "Styler":
         """
-        Set the styles on the current Styler, possibly using styles
-        from ``Styler.export``.
+        Set the styles on the current Styler.
+
+        Possibly uses styles from ``Styler.export``.
 
         Parameters
         ----------
         styles : list
-            list of style functions
+            List of style functions.
 
         Returns
         -------
@@ -827,7 +887,7 @@ def use(self, styles):
         self._todo.extend(styles)
         return self
 
-    def set_uuid(self, uuid):
+    def set_uuid(self, uuid: str) -> "Styler":
         """
         Set the uuid for a Styler.
 
@@ -842,9 +902,9 @@ def set_uuid(self, uuid):
         self.uuid = uuid
         return self
 
-    def set_caption(self, caption):
+    def set_caption(self, caption: str) -> "Styler":
         """
-        Set the caption on a Styler
+        Set the caption on a Styler.
 
         Parameters
         ----------
@@ -857,7 +917,7 @@ def set_caption(self, caption):
         self.caption = caption
         return self
 
-    def set_table_styles(self, table_styles):
+    def set_table_styles(self, table_styles) -> "Styler":
         """
         Set the table styles on a Styler.
 
@@ -887,7 +947,24 @@ def set_table_styles(self, table_styles):
         self.table_styles = table_styles
         return self
 
-    def hide_index(self):
+    def set_na_rep(self, na_rep: str) -> "Styler":
+        """
+        Set the missing data representation on a Styler.
+
+        .. versionadded:: 1.0.0
+
+        Parameters
+        ----------
+        na_rep : str
+
+        Returns
+        -------
+        self : Styler
+        """
+        self.na_rep = na_rep
+        return self
+
+    def hide_index(self) -> "Styler":
         """
         Hide any indices from rendering.
 
@@ -900,7 +977,7 @@ def hide_index(self):
         self.hidden_index = True
         return self
 
-    def hide_columns(self, subset):
+    def hide_columns(self, subset) -> "Styler":
         """
         Hide columns from rendering.
 
@@ -926,12 +1003,10 @@ def hide_columns(self, subset):
     # -----------------------------------------------------------------------
 
     @staticmethod
-    def _highlight_null(v, null_color):
-        return (
-            "background-color: {color}".format(color=null_color) if pd.isna(v) else ""
-        )
+    def _highlight_null(v, null_color: str) -> str:
+        return f"background-color: {null_color}" if pd.isna(v) else ""
 
-    def highlight_null(self, null_color="red"):
+    def highlight_null(self, null_color: str = "red") -> "Styler":
         """
         Shade the background ``null_color`` for missing values.
 
@@ -949,37 +1024,53 @@ def highlight_null(self, null_color="red"):
     def background_gradient(
         self,
         cmap="PuBu",
-        low=0,
-        high=0,
-        axis=0,
+        low: float = 0,
+        high: float = 0,
+        axis: Optional[Axis] = 0,
         subset=None,
-        text_color_threshold=0.408,
-    ):
+        text_color_threshold: float = 0.408,
+        vmin: Optional[float] = None,
+        vmax: Optional[float] = None,
+    ) -> "Styler":
         """
-        Color the background in a gradient according to
-        the data in each column (optionally row).
+        Color the background in a gradient style.
 
-        Requires matplotlib.
+        The background color is determined according
+        to the data in each column (optionally row). Requires matplotlib.
 
         Parameters
         ----------
         cmap : str or colormap
-            matplotlib colormap
-        low, high : float
-            compress the range by these values.
+            Matplotlib colormap.
+        low : float
+            Compress the range by the low.
+        high : float
+            Compress the range by the high.
         axis : {0 or 'index', 1 or 'columns', None}, default 0
-            apply to each column (``axis=0`` or ``'index'``), to each row
+            Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         subset : IndexSlice
-            a valid slice for ``data`` to limit the style application to.
+            A valid slice for ``data`` to limit the style application to.
         text_color_threshold : float or int
-            luminance threshold for determining text color. Facilitates text
+            Luminance threshold for determining text color. Facilitates text
             visibility across varying background colors. From 0 to 1.
             0 = all text is dark colored, 1 = all text is light colored.
 
             .. versionadded:: 0.24.0
 
+        vmin : float, optional
+            Minimum data value that corresponds to colormap minimum value.
+            When None (default): the minimum value of the data will be used.
+
+            .. versionadded:: 1.0.0
+
+        vmax : float, optional
+            Maximum data value that corresponds to colormap maximum value.
+            When None (default): the maximum value of the data will be used.
+
+            .. versionadded:: 1.0.0
+
         Returns
         -------
         self : Styler
@@ -1006,11 +1097,21 @@ def background_gradient(
             low=low,
             high=high,
             text_color_threshold=text_color_threshold,
+            vmin=vmin,
+            vmax=vmax,
         )
         return self
 
     @staticmethod
-    def _background_gradient(s, cmap="PuBu", low=0, high=0, text_color_threshold=0.408):
+    def _background_gradient(
+        s,
+        cmap="PuBu",
+        low: float = 0,
+        high: float = 0,
+        text_color_threshold: float = 0.408,
+        vmin: Optional[float] = None,
+        vmax: Optional[float] = None,
+    ):
         """
         Color background in a range according to the data.
         """
@@ -1022,16 +1123,16 @@ def _background_gradient(s, cmap="PuBu", low=0, high=0, text_color_threshold=0.4
             raise ValueError(msg)
 
         with _mpl(Styler.background_gradient) as (plt, colors):
-            smin = s.values.min()
-            smax = s.values.max()
+            smin = np.nanmin(s.to_numpy()) if vmin is None else vmin
+            smax = np.nanmax(s.to_numpy()) if vmax is None else vmax
             rng = smax - smin
             # extend lower / upper bounds, compresses color range
             norm = colors.Normalize(smin - (rng * low), smax + (rng * high))
             # matplotlib colors.Normalize modifies inplace?
             # https://github.com/matplotlib/matplotlib/issues/5427
-            rgbas = plt.cm.get_cmap(cmap)(norm(s.values))
+            rgbas = plt.cm.get_cmap(cmap)(norm(s.to_numpy(dtype=float)))
 
-            def relative_luminance(rgba):
+            def relative_luminance(rgba) -> float:
                 """
                 Calculate relative luminance of a color.
 
@@ -1053,12 +1154,10 @@ def relative_luminance(rgba):
                 )
                 return 0.2126 * r + 0.7152 * g + 0.0722 * b
 
-            def css(rgba):
+            def css(rgba) -> str:
                 dark = relative_luminance(rgba) < text_color_threshold
                 text_color = "#f1f1f1" if dark else "#000000"
-                return "background-color: {b};color: {c};".format(
-                    b=colors.rgb2hex(rgba), c=text_color
-                )
+                return f"background-color: {colors.rgb2hex(rgba)};color: {text_color};"
 
             if s.ndim == 1:
                 return [css(rgba) for rgba in rgbas]
@@ -1069,17 +1168,16 @@ def css(rgba):
                     columns=s.columns,
                 )
 
-    def set_properties(self, subset=None, **kwargs):
+    def set_properties(self, subset=None, **kwargs) -> "Styler":
         """
-        Convenience method for setting one or more non-data dependent
-        properties or each cell.
+        Method to set one or more non-data dependent properties or each cell.
 
         Parameters
         ----------
         subset : IndexSlice
-            a valid slice for ``data`` to limit the style application to
-        kwargs : dict
-            property: value pairs to be set for each cell
+            A valid slice for ``data`` to limit the style application to.
+        **kwargs : dict
+            A dictionary of property, value pairs to be set for each cell.
 
         Returns
         -------
@@ -1091,22 +1189,25 @@ def set_properties(self, subset=None, **kwargs):
         >>> df.style.set_properties(color="white", align="right")
         >>> df.style.set_properties(**{'background-color': 'yellow'})
         """
-        values = ";".join("{p}: {v}".format(p=p, v=v) for p, v in kwargs.items())
+        values = ";".join(f"{p}: {v}" for p, v in kwargs.items())
         f = lambda x: values
         return self.applymap(f, subset=subset)
 
     @staticmethod
-    def _bar(s, align, colors, width=100, vmin=None, vmax=None):
+    def _bar(
+        s,
+        align: str,
+        colors: List[str],
+        width: float = 100,
+        vmin: Optional[float] = None,
+        vmax: Optional[float] = None,
+    ):
         """
         Draw bar chart in dataframe cells.
         """
         # Get input value range.
-        smin = s.min() if vmin is None else vmin
-        if isinstance(smin, ABCSeries):
-            smin = smin.min()
-        smax = s.max() if vmax is None else vmax
-        if isinstance(smax, ABCSeries):
-            smax = smax.max()
+        smin = np.nanmin(s.to_numpy()) if vmin is None else vmin
+        smax = np.nanmax(s.to_numpy()) if vmax is None else vmax
         if align == "mid":
             smin = min(0, smin)
             smax = max(0, smax)
@@ -1115,10 +1216,10 @@ def _bar(s, align, colors, width=100, vmin=None, vmax=None):
             smax = max(abs(smin), abs(smax))
             smin = -smax
         # Transform to percent-range of linear-gradient
-        normed = width * (s.values - smin) / (smax - smin + 1e-12)
+        normed = width * (s.to_numpy(dtype=float) - smin) / (smax - smin + 1e-12)
         zero = -width * smin / (smax - smin + 1e-12)
 
-        def css_bar(start, end, color):
+        def css_bar(start: float, end: float, color: str) -> str:
             """
             Generate CSS code to draw a bar from start to end.
             """
@@ -1126,12 +1227,9 @@ def css_bar(start, end, color):
             if end > start:
                 css += "background: linear-gradient(90deg,"
                 if start > 0:
-                    css += " transparent {s:.1f}%, {c} {s:.1f}%, ".format(
-                        s=start, c=color
-                    )
-                css += "{c} {e:.1f}%, transparent {e:.1f}%)".format(
-                    e=min(end, width), c=color
-                )
+                    css += f" transparent {start:.1f}%, {color} {start:.1f}%, "
+                e = min(end, width)
+                css += f"{color} {e:.1f}%, transparent {e:.1f}%)"
             return css
 
         def css(x):
@@ -1158,13 +1256,13 @@ def css(x):
     def bar(
         self,
         subset=None,
-        axis=0,
+        axis: Optional[Axis] = 0,
         color="#d65f5f",
-        width=100,
-        align="left",
-        vmin=None,
-        vmax=None,
-    ):
+        width: float = 100,
+        align: str = "left",
+        vmin: Optional[float] = None,
+        vmax: Optional[float] = None,
+    ) -> "Styler":
         """
         Draw bar chart in the cell backgrounds.
 
@@ -1173,7 +1271,7 @@ def bar(
         subset : IndexSlice, optional
             A valid slice for `data` to limit the style application to.
         axis : {0 or 'index', 1 or 'columns', None}, default 0
-            apply to each column (``axis=0`` or ``'index'``), to each row
+            Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
         color : str or 2-tuple/list
@@ -1192,9 +1290,6 @@ def bar(
             - 'mid' : the center of the cell is at (max-min)/2, or
               if values are all negative (positive) the zero is aligned
               at the right (left) of the cell.
-
-              .. versionadded:: 0.20.0
-
         vmin : float, optional
             Minimum bar value, defining the left hand limit
             of the bar drawing range, lower values are clipped to `vmin`.
@@ -1222,9 +1317,9 @@ def bar(
             color = [color[0], color[0]]
         elif len(color) > 2:
             raise ValueError(
-                "`color` must be string or a list-like"
-                " of length 2: [`color_neg`, `color_pos`]"
-                " (eg: color=['#d65f5f', '#5fba7d'])"
+                "`color` must be string or a list-like "
+                "of length 2: [`color_neg`, `color_pos`] "
+                "(eg: color=['#d65f5f', '#5fba7d'])"
             )
 
         subset = _maybe_numeric_slice(self.data, subset)
@@ -1242,17 +1337,19 @@ def bar(
 
         return self
 
-    def highlight_max(self, subset=None, color="yellow", axis=0):
+    def highlight_max(
+        self, subset=None, color: str = "yellow", axis: Optional[Axis] = 0
+    ) -> "Styler":
         """
         Highlight the maximum by shading the background.
 
         Parameters
         ----------
         subset : IndexSlice, default None
-            a valid slice for ``data`` to limit the style application to.
+            A valid slice for ``data`` to limit the style application to.
         color : str, default 'yellow'
         axis : {0 or 'index', 1 or 'columns', None}, default 0
-            apply to each column (``axis=0`` or ``'index'``), to each row
+            Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
 
@@ -1262,17 +1359,19 @@ def highlight_max(self, subset=None, color="yellow", axis=0):
         """
         return self._highlight_handler(subset=subset, color=color, axis=axis, max_=True)
 
-    def highlight_min(self, subset=None, color="yellow", axis=0):
+    def highlight_min(
+        self, subset=None, color: str = "yellow", axis: Optional[Axis] = 0
+    ) -> "Styler":
         """
         Highlight the minimum by shading the background.
 
         Parameters
         ----------
         subset : IndexSlice, default None
-            a valid slice for ``data`` to limit the style application to.
+            A valid slice for ``data`` to limit the style application to.
         color : str, default 'yellow'
         axis : {0 or 'index', 1 or 'columns', None}, default 0
-            apply to each column (``axis=0`` or ``'index'``), to each row
+            Apply to each column (``axis=0`` or ``'index'``), to each row
             (``axis=1`` or ``'columns'``), or to the entire DataFrame at once
             with ``axis=None``.
 
@@ -1284,7 +1383,13 @@ def highlight_min(self, subset=None, color="yellow", axis=0):
             subset=subset, color=color, axis=axis, max_=False
         )
 
-    def _highlight_handler(self, subset=None, color="yellow", axis=None, max_=True):
+    def _highlight_handler(
+        self,
+        subset=None,
+        color: str = "yellow",
+        axis: Optional[Axis] = None,
+        max_: bool = True,
+    ) -> "Styler":
         subset = _non_reducing_slice(_maybe_numeric_slice(self.data, subset))
         self.apply(
             self._highlight_extrema, color=color, axis=axis, subset=subset, max_=max_
@@ -1292,22 +1397,22 @@ def _highlight_handler(self, subset=None, color="yellow", axis=None, max_=True):
         return self
 
     @staticmethod
-    def _highlight_extrema(data, color="yellow", max_=True):
+    def _highlight_extrema(
+        data: FrameOrSeries, color: str = "yellow", max_: bool = True
+    ):
         """
         Highlight the min or max in a Series or DataFrame.
         """
-        attr = "background-color: {0}".format(color)
+        attr = f"background-color: {color}"
+
+        if max_:
+            extrema = data == np.nanmax(data.to_numpy())
+        else:
+            extrema = data == np.nanmin(data.to_numpy())
+
         if data.ndim == 1:  # Series from .apply
-            if max_:
-                extrema = data == data.max()
-            else:
-                extrema = data == data.min()
             return [attr if v else "" for v in extrema]
         else:  # DataFrame from .tee
-            if max_:
-                extrema = data == data.max().max()
-            else:
-                extrema = data == data.min().min()
             return pd.DataFrame(
                 np.where(extrema, attr, ""), index=data.index, columns=data.columns
             )
@@ -1315,15 +1420,16 @@ def _highlight_extrema(data, color="yellow", max_=True):
     @classmethod
     def from_custom_template(cls, searchpath, name):
         """
-        Factory function for creating a subclass of ``Styler``
-        with a custom template and Jinja environment.
+        Factory function for creating a subclass of ``Styler``.
+
+        Uses a custom template and Jinja environment.
 
         Parameters
         ----------
         searchpath : str or list
-            Path or paths of directories containing the templates
+            Path or paths of directories containing the templates.
         name : str
-            Name of your custom template to use for rendering
+            Name of your custom template to use for rendering.
 
         Returns
         -------
@@ -1338,7 +1444,7 @@ class MyStyler(cls):
 
         return MyStyler
 
-    def pipe(self, func, *args, **kwargs):
+    def pipe(self, func: Callable, *args, **kwargs):
         """
         Apply ``func(self, *args, **kwargs)``, and return the result.
 
@@ -1350,8 +1456,10 @@ def pipe(self, func, *args, **kwargs):
             Function to apply to the Styler.  Alternatively, a
             ``(callable, keyword)`` tuple where ``keyword`` is a string
             indicating the keyword of ``callable`` that expects the Styler.
-        *args, **kwargs :
+        *args : optional
             Arguments passed to `func`.
+        **kwargs : optional
+            A dictionary of keyword arguments passed into ``func``.
 
         Returns
         -------
@@ -1408,7 +1516,7 @@ def pipe(self, func, *args, **kwargs):
         return com.pipe(self, func, *args, **kwargs)
 
 
-def _is_visible(idx_row, idx_col, lengths):
+def _is_visible(idx_row, idx_col, lengths) -> bool:
     """
     Index -> {(idx_row, idx_col): bool}).
     """
@@ -1422,10 +1530,9 @@ def _get_level_lengths(index, hidden_elements=None):
     Optional argument is a list of index positions which
     should not be visible.
 
-    Result is a dictionary of (level, inital_position): span
+    Result is a dictionary of (level, initial_position): span
     """
-    sentinel = object()
-    levels = index.format(sparsify=sentinel, adjoin=False, names=False)
+    levels = index.format(sparsify=lib.no_default, adjoin=False, names=False)
 
     if hidden_elements is None:
         hidden_elements = []
@@ -1441,10 +1548,10 @@ def _get_level_lengths(index, hidden_elements=None):
         for j, row in enumerate(lvl):
             if not get_option("display.multi_sparse"):
                 lengths[(i, j)] = 1
-            elif (row != sentinel) and (j not in hidden_elements):
+            elif (row is not lib.no_default) and (j not in hidden_elements):
                 last_label = j
                 lengths[(i, last_label)] = 1
-            elif row != sentinel:
+            elif row is not lib.no_default:
                 # even if its hidden, keep track of it in case
                 # length >1 and later elements are visible
                 last_label = j
@@ -1459,14 +1566,21 @@ def _get_level_lengths(index, hidden_elements=None):
     return non_zero_lengths
 
 
-def _maybe_wrap_formatter(formatter):
-    if is_string_like(formatter):
-        return lambda x: formatter.format(x)
+def _maybe_wrap_formatter(
+    formatter: Union[Callable, str], na_rep: Optional[str]
+) -> Callable:
+    if isinstance(formatter, str):
+        formatter_func = lambda x: formatter.format(x)
     elif callable(formatter):
-        return formatter
+        formatter_func = formatter
     else:
-        msg = (
-            "Expected a template string or callable, got {formatter} "
-            "instead".format(formatter=formatter)
-        )
+        msg = f"Expected a template string or callable, got {formatter} instead"
+        raise TypeError(msg)
+
+    if na_rep is None:
+        return formatter_func
+    elif isinstance(na_rep, str):
+        return lambda x: na_rep if pd.isna(x) else formatter_func(x)
+    else:
+        msg = f"Expected a string, got {na_rep} instead"
         raise TypeError(msg)
diff --git a/pandas/io/formats/templates/html.tpl b/pandas/io/formats/templates/html.tpl
index 15feafcea6864..97bfda9af089d 100644
--- a/pandas/io/formats/templates/html.tpl
+++ b/pandas/io/formats/templates/html.tpl
@@ -14,7 +14,7 @@
 {% block before_cellstyle %}{% endblock before_cellstyle %}
 {% block cellstyle %}
 {%- for s in cellstyle %}
-    #T_{{uuid}}{{s.selector}} {
+    {%- for selector in s.selectors -%}{%- if not loop.first -%},{%- endif -%}#T_{{uuid}}{{selector}}{%- endfor -%} {
     {% for p,val in s.props %}
         {{p}}: {{val}};
     {% endfor %}
diff --git a/pandas/io/gbq.py b/pandas/io/gbq.py
index d29078cad9318..405bf27cac02d 100644
--- a/pandas/io/gbq.py
+++ b/pandas/io/gbq.py
@@ -1,6 +1,11 @@
 """ Google BigQuery support """
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
 from pandas.compat._optional import import_optional_dependency
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 
 def _try_import():
     # since pandas is a dependency of pandas-gbq
@@ -14,20 +19,21 @@ def _try_import():
 
 
 def read_gbq(
-    query,
-    project_id=None,
-    index_col=None,
-    col_order=None,
-    reauth=False,
-    auth_local_webserver=False,
-    dialect=None,
-    location=None,
-    configuration=None,
+    query: str,
+    project_id: Optional[str] = None,
+    index_col: Optional[str] = None,
+    col_order: Optional[List[str]] = None,
+    reauth: bool = False,
+    auth_local_webserver: bool = False,
+    dialect: Optional[str] = None,
+    location: Optional[str] = None,
+    configuration: Optional[Dict[str, Any]] = None,
     credentials=None,
-    use_bqstorage_api=None,
+    use_bqstorage_api: Optional[bool] = None,
     private_key=None,
     verbose=None,
-):
+    progress_bar_type: Optional[str] = None,
+) -> "DataFrame":
     """
     Load data from Google BigQuery.
 
@@ -50,21 +56,21 @@ def read_gbq(
     col_order : list(str), optional
         List of BigQuery column names in the desired order for results
         DataFrame.
-    reauth : boolean, default False
+    reauth : bool, default False
         Force Google BigQuery to re-authenticate the user. This is useful
         if multiple accounts are used.
-    auth_local_webserver : boolean, default False
+    auth_local_webserver : bool, default False
         Use the `local webserver flow`_ instead of the `console flow`_
         when getting user credentials.
 
         .. _local webserver flow:
-            http://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
+            https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
         .. _console flow:
-            http://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
+            https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
 
         *New in version 0.2.0 of pandas-gbq*.
     dialect : str, default 'legacy'
-        Note: The default value is changing to 'standard' in a future verion.
+        Note: The default value is changing to 'standard' in a future version.
 
         SQL syntax dialect to use. Value can be one of:
 
@@ -119,21 +125,30 @@ def read_gbq(
         ``fastavro`` packages.
 
         .. versionadded:: 0.25.0
-    private_key : str, deprecated
-        Deprecated in pandas-gbq version 0.8.0. Use the ``credentials``
-        parameter and
-        :func:`google.oauth2.service_account.Credentials.from_service_account_info`
-        or
-        :func:`google.oauth2.service_account.Credentials.from_service_account_file`
-        instead.
-
-        Service account private key in JSON format. Can be file path
-        or string contents. This is useful for remote server
-        authentication (eg. Jupyter/IPython notebook on remote host).
-    verbose : None, deprecated
-        Deprecated in pandas-gbq version 0.4.0. Use the `logging module to
-        adjust verbosity instead
-        <https://pandas-gbq.readthedocs.io/en/latest/intro.html#logging>`__.
+    progress_bar_type : Optional, str
+        If set, use the `tqdm <https://tqdm.github.io/>`__ library to
+        display a progress bar while the data downloads. Install the
+        ``tqdm`` package to use this feature.
+
+        Possible values of ``progress_bar_type`` include:
+
+        ``None``
+            No progress bar.
+        ``'tqdm'``
+            Use the :func:`tqdm.tqdm` function to print a progress bar
+            to :data:`sys.stderr`.
+        ``'tqdm_notebook'``
+            Use the :func:`tqdm.tqdm_notebook` function to display a
+            progress bar as a Jupyter notebook widget.
+        ``'tqdm_gui'``
+            Use the :func:`tqdm.tqdm_gui` function to display a
+            progress bar as a graphical dialog box.
+
+        Note that his feature requires version 0.12.0 or later of the
+        ``pandas-gbq`` package. And it requires the ``tqdm`` package. Slightly
+        different than ``pandas-gbq``, here the default is ``None``.
+
+        .. versionadded:: 1.0.0
 
     Returns
     -------
@@ -147,20 +162,15 @@ def read_gbq(
     """
     pandas_gbq = _try_import()
 
-    kwargs = {}
+    kwargs: Dict[str, Union[str, bool]] = {}
 
     # START: new kwargs.  Don't populate unless explicitly set.
     if use_bqstorage_api is not None:
         kwargs["use_bqstorage_api"] = use_bqstorage_api
-    # END: new kwargs
 
-    # START: deprecated kwargs.  Don't populate unless explicitly set.
-    if verbose is not None:
-        kwargs["verbose"] = verbose
-
-    if private_key is not None:
-        kwargs["private_key"] = private_key
-    # END: deprecated kwargs
+    if progress_bar_type is not None:
+        kwargs["progress_bar_type"] = progress_bar_type
+    # END: new kwargs
 
     return pandas_gbq.read_gbq(
         query,
@@ -173,25 +183,25 @@ def read_gbq(
         location=location,
         configuration=configuration,
         credentials=credentials,
-        **kwargs
+        **kwargs,
     )
 
 
 def to_gbq(
-    dataframe,
-    destination_table,
-    project_id=None,
-    chunksize=None,
-    reauth=False,
-    if_exists="fail",
-    auth_local_webserver=False,
-    table_schema=None,
-    location=None,
-    progress_bar=True,
+    dataframe: "DataFrame",
+    destination_table: str,
+    project_id: Optional[str] = None,
+    chunksize: Optional[int] = None,
+    reauth: bool = False,
+    if_exists: str = "fail",
+    auth_local_webserver: bool = False,
+    table_schema: Optional[List[Dict[str, str]]] = None,
+    location: Optional[str] = None,
+    progress_bar: bool = True,
     credentials=None,
     verbose=None,
     private_key=None,
-):
+) -> None:
     pandas_gbq = _try_import()
     pandas_gbq.to_gbq(
         dataframe,
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 490c574463b9b..c676bfb1f0c74 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -9,15 +9,14 @@
 import os
 import re
 
-from pandas.compat import raise_with_traceback
 from pandas.compat._optional import import_optional_dependency
 from pandas.errors import AbstractMethodError, EmptyDataError
 
 from pandas.core.dtypes.common import is_list_like
 
-from pandas import Series
+from pandas.core.construction import create_series_with_explicit_dtype
 
-from pandas.io.common import _is_url, _validate_header_arg, urlopen
+from pandas.io.common import is_url, urlopen, validate_header_arg
 from pandas.io.formats.printing import pprint_thing
 from pandas.io.parsers import TextParser
 
@@ -58,7 +57,7 @@ def _importers():
 _RE_WHITESPACE = re.compile(r"[\r\n]+|\s{2,}")
 
 
-def _remove_whitespace(s, regex=_RE_WHITESPACE):
+def _remove_whitespace(s: str, regex=_RE_WHITESPACE) -> str:
     """
     Replace extra whitespace inside of a string with a single space.
 
@@ -66,8 +65,7 @@ def _remove_whitespace(s, regex=_RE_WHITESPACE):
     ----------
     s : str or unicode
         The string from which to remove extra whitespace.
-
-    regex : regex
+    regex : re.Pattern
         The regular expression to use to remove extra whitespace.
 
     Returns
@@ -104,9 +102,7 @@ def _get_skiprows(skiprows):
         return skiprows
     elif skiprows is None:
         return 0
-    raise TypeError(
-        "%r is not a valid type for skipping rows" % type(skiprows).__name__
-    )
+    raise TypeError(f"{type(skiprows).__name__} is not a valid type for skipping rows")
 
 
 def _read(obj):
@@ -121,7 +117,7 @@ def _read(obj):
     -------
     raw_text : str
     """
-    if _is_url(obj):
+    if is_url(obj):
         with urlopen(obj) as url:
             text = url.read()
     elif hasattr(obj, "read"):
@@ -135,7 +131,7 @@ def _read(obj):
         except (TypeError, ValueError):
             pass
     else:
-        raise TypeError("Cannot read object of type %r" % type(obj).__name__)
+        raise TypeError(f"Cannot read object of type '{type(obj).__name__}'")
     return text
 
 
@@ -254,7 +250,8 @@ def _text_getter(self, obj):
         raise AbstractMethodError(self)
 
     def _parse_td(self, obj):
-        """Return the td elements from a row element.
+        """
+        Return the td elements from a row element.
 
         Parameters
         ----------
@@ -561,9 +558,7 @@ def _parse_tables(self, doc, match, attrs):
             unique_tables.add(table)
 
         if not result:
-            raise ValueError(
-                "No tables found matching pattern {patt!r}".format(patt=match.pattern)
-            )
+            raise ValueError(f"No tables found matching pattern {repr(match.pattern)}")
         return result
 
     def _text_getter(self, obj):
@@ -590,18 +585,23 @@ def _parse_tfoot_tr(self, table):
     def _setup_build_doc(self):
         raw_text = _read(self.io)
         if not raw_text:
-            raise ValueError("No text parsed from document: {doc}".format(doc=self.io))
+            raise ValueError(f"No text parsed from document: {self.io}")
         return raw_text
 
     def _build_doc(self):
         from bs4 import BeautifulSoup
 
-        return BeautifulSoup(
-            self._setup_build_doc(), features="html5lib", from_encoding=self.encoding
-        )
+        bdoc = self._setup_build_doc()
+        if isinstance(bdoc, bytes) and self.encoding is not None:
+            udoc = bdoc.decode(self.encoding)
+            from_encoding = None
+        else:
+            udoc = bdoc
+            from_encoding = self.encoding
+        return BeautifulSoup(udoc, features="html5lib", from_encoding=from_encoding)
 
 
-def _build_xpath_expr(attrs):
+def _build_xpath_expr(attrs) -> str:
     """Build an xpath expression to simulate bs4's ability to pass in kwargs to
     search for attributes when using the lxml parser.
 
@@ -619,8 +619,8 @@ def _build_xpath_expr(attrs):
     if "class_" in attrs:
         attrs["class"] = attrs.pop("class_")
 
-    s = ["@{key}={val!r}".format(key=k, val=v) for k, v in attrs.items()]
-    return "[{expr}]".format(expr=" and ".join(s))
+    s = " and ".join([f"@{k}={repr(v)}" for k, v in attrs.items()])
+    return f"[{s}]"
 
 
 _re_namespace = {"re": "http://exslt.org/regular-expressions"}
@@ -662,8 +662,7 @@ def _parse_tables(self, doc, match, kwargs):
 
         # 1. check all descendants for the given pattern and only search tables
         # 2. go up the tree until we find a table
-        query = "//table//*[re:test(text(), {patt!r})]/ancestor::table"
-        xpath_expr = query.format(patt=pattern)
+        xpath_expr = f"//table//*[re:test(text(), {repr(pattern)})]/ancestor::table"
 
         # if any table attributes were given build an xpath expression to
         # search for them
@@ -683,9 +682,7 @@ def _parse_tables(self, doc, match, kwargs):
                         elem.getparent().remove(elem)
 
         if not tables:
-            raise ValueError(
-                "No tables found matching regex {patt!r}".format(patt=pattern)
-            )
+            raise ValueError(f"No tables found matching regex {repr(pattern)}")
         return tables
 
     def _equals_tag(self, obj, tag):
@@ -713,7 +710,7 @@ def _build_doc(self):
         parser = HTMLParser(recover=True, encoding=self.encoding)
 
         try:
-            if _is_url(self.io):
+            if is_url(self.io):
                 with urlopen(self.io) as f:
                     r = parse(f, parser=parser)
             else:
@@ -725,7 +722,7 @@ def _build_doc(self):
                 pass
         except (UnicodeDecodeError, IOError) as e:
             # if the input is a blob of html goop
-            if not _is_url(self.io):
+            if not is_url(self.io):
                 r = fromstring(self.io, parser=parser)
 
                 try:
@@ -768,7 +765,8 @@ def _parse_tfoot_tr(self, table):
 
 
 def _expand_elements(body):
-    lens = Series([len(elem) for elem in body])
+    data = [len(elem) for elem in body]
+    lens = create_series_with_explicit_dtype(data, dtype_if_empty=object)
     lens_max = lens.max()
     not_max = lens[lens != lens_max]
 
@@ -811,7 +809,8 @@ def _data_to_frame(**kwargs):
 
 
 def _parser_dispatch(flavor):
-    """Choose the parser based on the input flavor.
+    """
+    Choose the parser based on the input flavor.
 
     Parameters
     ----------
@@ -833,8 +832,7 @@ def _parser_dispatch(flavor):
     valid_parsers = list(_valid_parsers.keys())
     if flavor not in valid_parsers:
         raise ValueError(
-            "{invalid!r} is not a valid flavor, valid flavors "
-            "are {valid}".format(invalid=flavor, valid=valid_parsers)
+            f"{repr(flavor)} is not a valid flavor, valid flavors are {valid_parsers}"
         )
 
     if flavor in ("bs4", "html5lib"):
@@ -851,8 +849,9 @@ def _parser_dispatch(flavor):
     return _valid_parsers[flavor]
 
 
-def _print_as_set(s):
-    return "{" + "{arg}".format(arg=", ".join(pprint_thing(el) for el in s)) + "}"
+def _print_as_set(s) -> str:
+    arg = ", ".join(pprint_thing(el) for el in s)
+    return f"{{{arg}}}"
 
 
 def _validate_flavor(flavor):
@@ -863,13 +862,13 @@ def _validate_flavor(flavor):
     elif isinstance(flavor, abc.Iterable):
         if not all(isinstance(flav, str) for flav in flavor):
             raise TypeError(
-                "Object of type {typ!r} is not an iterable of "
-                "strings".format(typ=type(flavor).__name__)
+                f"Object of type {repr(type(flavor).__name__)} "
+                f"is not an iterable of strings"
             )
     else:
-        fmt = "{flavor!r}" if isinstance(flavor, str) else "{flavor}"
-        fmt += " is not a valid flavor"
-        raise ValueError(fmt.format(flavor=flavor))
+        msg = repr(flavor) if isinstance(flavor, str) else str(flavor)
+        msg += " is not a valid flavor"
+        raise ValueError(msg)
 
     flavor = tuple(flavor)
     valid_flavors = set(_valid_parsers)
@@ -877,10 +876,8 @@ def _validate_flavor(flavor):
 
     if not flavor_set & valid_flavors:
         raise ValueError(
-            "{invalid} is not a valid set of flavors, valid "
-            "flavors are {valid}".format(
-                invalid=_print_as_set(flavor_set), valid=_print_as_set(valid_flavors)
-            )
+            f"{_print_as_set(flavor_set)} is not a valid set of flavors, valid "
+            f"flavors are {_print_as_set(valid_flavors)}"
         )
     return flavor
 
@@ -889,7 +886,6 @@ def _parse(flavor, io, match, attrs, encoding, displayed_only, **kwargs):
     flavor = _validate_flavor(flavor)
     compiled_match = re.compile(match)  # you can pass a compiled regex here
 
-    # hack around python 3 deleting the exception variable
     retained = None
     for flav in flavor:
         parser = _parser_dispatch(flav)
@@ -897,7 +893,7 @@ def _parse(flavor, io, match, attrs, encoding, displayed_only, **kwargs):
 
         try:
             tables = p.parse_tables()
-        except Exception as caught:
+        except ValueError as caught:
             # if `io` is an io-like object, check if it's seekable
             # and try to rewind it before trying the next parser
             if hasattr(io, "seekable") and io.seekable():
@@ -905,18 +901,17 @@ def _parse(flavor, io, match, attrs, encoding, displayed_only, **kwargs):
             elif hasattr(io, "seekable") and not io.seekable():
                 # if we couldn't rewind it, let the user know
                 raise ValueError(
-                    "The flavor {} failed to parse your input. "
+                    f"The flavor {flav} failed to parse your input. "
                     "Since you passed a non-rewindable file "
                     "object, we can't rewind it to try "
-                    "another parser. Try read_html() with a "
-                    "different flavor.".format(flav)
+                    "another parser. Try read_html() with a different flavor."
                 )
 
             retained = caught
         else:
             break
     else:
-        raise_with_traceback(retained)
+        raise retained
 
     ret = []
     for table in tables:
@@ -962,7 +957,7 @@ def read_html(
         This value is converted to a regular expression so that there is
         consistent behavior between Beautiful Soup and lxml.
 
-    flavor : str or None, container of strings
+    flavor : str or None
         The parsing engine to use. 'bs4' and 'html5lib' are synonymous with
         each other, they are both there for backwards compatibility. The
         default of ``None`` tries to use ``lxml`` to parse and if that fails it
@@ -976,7 +971,7 @@ def read_html(
         The column (or list of columns) to use to create the index.
 
     skiprows : int or list-like or slice or None, optional
-        0-based. Number of rows to skip after parsing the column integer. If a
+        Number of rows to skip after parsing the column integer. 0-based. If a
         sequence of integers or a slice is given, will skip the rows indexed by
         that sequence.  Note that a single element sequence means 'skip the nth
         row' whereas an integer means 'skip n rows'.
@@ -991,7 +986,7 @@ def read_html(
 
         is a valid attribute dictionary because the 'id' HTML tag attribute is
         a valid HTML attribute for *any* HTML tag as per `this document
-        <http://www.w3.org/TR/html-markup/global-attributes.html>`__. ::
+        <https://html.spec.whatwg.org/multipage/dom.html#global-attributes>`__. ::
 
             attrs = {'asdf': 'table'}
 
@@ -1000,7 +995,7 @@ def read_html(
         table attributes can be found `here
         <http://www.w3.org/TR/REC-html40/struct/tables.html#h-11.2>`__. A
         working draft of the HTML 5 spec can be found `here
-        <http://www.w3.org/TR/html-markup/table.html>`__. It contains the
+        <https://html.spec.whatwg.org/multipage/tables.html>`__. It contains the
         latest information on table attributes for the modern web.
 
     parse_dates : bool, optional
@@ -1026,18 +1021,19 @@ def read_html(
         transformed content.
 
     na_values : iterable, default None
-        Custom NA values
+        Custom NA values.
 
     keep_default_na : bool, default True
         If na_values are specified and keep_default_na is False the default NaN
-        values are overridden, otherwise they're appended to
+        values are overridden, otherwise they're appended to.
 
     displayed_only : bool, default True
-        Whether elements with "display: none" should be parsed
+        Whether elements with "display: none" should be parsed.
 
     Returns
     -------
-    dfs : list of DataFrames
+    dfs
+        A list of DataFrames.
 
     See Also
     --------
@@ -1084,7 +1080,7 @@ def read_html(
             "cannot skip rows starting from the end of the "
             "data (you passed a negative value)"
         )
-    _validate_header_arg(header)
+    validate_header_arg(header)
     return _parse(
         flavor=flavor,
         io=io,
diff --git a/pandas/io/json/__init__.py b/pandas/io/json/__init__.py
index 2382d993df96b..48febb086c302 100644
--- a/pandas/io/json/__init__.py
+++ b/pandas/io/json/__init__.py
@@ -1,5 +1,5 @@
 from pandas.io.json._json import dumps, loads, read_json, to_json
-from pandas.io.json._normalize import json_normalize
+from pandas.io.json._normalize import _json_normalize, json_normalize
 from pandas.io.json._table_schema import build_table_schema
 
 __all__ = [
@@ -7,6 +7,7 @@
     "loads",
     "read_json",
     "to_json",
+    "_json_normalize",
     "json_normalize",
     "build_table_schema",
 ]
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index a00499287ac8f..04fd17a00041b 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -1,31 +1,29 @@
+from collections import abc
+import functools
 from io import StringIO
 from itertools import islice
 import os
+from typing import Any, Callable, Optional, Type
 
 import numpy as np
 
 import pandas._libs.json as json
 from pandas._libs.tslibs import iNaT
+from pandas._typing import JSONSerializable
 from pandas.errors import AbstractMethodError
+from pandas.util._decorators import deprecate_kwarg
 
 from pandas.core.dtypes.common import ensure_str, is_period_dtype
 
 from pandas import DataFrame, MultiIndex, Series, isna, to_datetime
+from pandas.core.construction import create_series_with_explicit_dtype
 from pandas.core.reshape.concat import concat
 
-from pandas.io.common import (
-    BaseIterator,
-    _get_handle,
-    _infer_compression,
-    _stringify_path,
-    get_filepath_or_buffer,
-)
-from pandas.io.formats.printing import pprint_thing
+from pandas.io.common import get_filepath_or_buffer, get_handle, infer_compression
+from pandas.io.json._normalize import convert_to_line_delimits
+from pandas.io.json._table_schema import build_table_schema, parse_table_schema
 from pandas.io.parsers import _validate_integer
 
-from ._normalize import convert_to_line_delimits
-from ._table_schema import build_table_schema, parse_table_schema
-
 loads = json.loads
 dumps = json.dumps
 
@@ -36,28 +34,35 @@
 def to_json(
     path_or_buf,
     obj,
-    orient=None,
-    date_format="epoch",
-    double_precision=10,
-    force_ascii=True,
-    date_unit="ms",
-    default_handler=None,
-    lines=False,
-    compression="infer",
-    index=True,
+    orient: Optional[str] = None,
+    date_format: str = "epoch",
+    double_precision: int = 10,
+    force_ascii: bool = True,
+    date_unit: str = "ms",
+    default_handler: Optional[Callable[[Any], JSONSerializable]] = None,
+    lines: bool = False,
+    compression: Optional[str] = "infer",
+    index: bool = True,
+    indent: int = 0,
 ):
 
     if not index and orient not in ["split", "table"]:
         raise ValueError(
-            "'index=False' is only valid when 'orient' is " "'split' or 'table'"
+            "'index=False' is only valid when 'orient' is 'split' or 'table'"
+        )
+
+    if path_or_buf is not None:
+        path_or_buf, _, _, _ = get_filepath_or_buffer(
+            path_or_buf, compression=compression, mode="w"
         )
 
-    path_or_buf = _stringify_path(path_or_buf)
     if lines and orient != "records":
         raise ValueError("'lines' keyword only valid when 'orient' is records")
 
     if orient == "table" and isinstance(obj, Series):
         obj = obj.to_frame(name=obj.name or "values")
+
+    writer: Type["Writer"]
     if orient == "table" and isinstance(obj, DataFrame):
         writer = JSONTableWriter
     elif isinstance(obj, Series):
@@ -76,13 +81,14 @@ def to_json(
         date_unit=date_unit,
         default_handler=default_handler,
         index=index,
+        indent=indent,
     ).write()
 
     if lines:
         s = convert_to_line_delimits(s)
 
     if isinstance(path_or_buf, str):
-        fh, handles = _get_handle(path_or_buf, "w", compression=compression)
+        fh, handles = get_handle(path_or_buf, "w", compression=compression)
         try:
             fh.write(s)
         finally:
@@ -97,18 +103,19 @@ class Writer:
     def __init__(
         self,
         obj,
-        orient,
-        date_format,
-        double_precision,
-        ensure_ascii,
-        date_unit,
-        index,
-        default_handler=None,
+        orient: Optional[str],
+        date_format: str,
+        double_precision: int,
+        ensure_ascii: bool,
+        date_unit: str,
+        index: bool,
+        default_handler: Optional[Callable[[Any], JSONSerializable]] = None,
+        indent: int = 0,
     ):
         self.obj = obj
 
         if orient is None:
-            orient = self._default_orient
+            orient = self._default_orient  # type: ignore
 
         self.orient = orient
         self.date_format = date_format
@@ -117,6 +124,7 @@ def __init__(
         self.date_unit = date_unit
         self.default_handler = default_handler
         self.index = index
+        self.indent = indent
 
         self.is_copy = None
         self._format_axes()
@@ -133,17 +141,19 @@ def write(self):
             self.date_unit,
             self.date_format == "iso",
             self.default_handler,
+            self.indent,
         )
 
     def _write(
         self,
         obj,
-        orient,
-        double_precision,
-        ensure_ascii,
-        date_unit,
-        iso_dates,
-        default_handler,
+        orient: Optional[str],
+        double_precision: int,
+        ensure_ascii: bool,
+        date_unit: str,
+        iso_dates: bool,
+        default_handler: Optional[Callable[[Any], JSONSerializable]],
+        indent: int,
     ):
         return dumps(
             obj,
@@ -153,6 +163,7 @@ def _write(
             date_unit=date_unit,
             iso_dates=iso_dates,
             default_handler=default_handler,
+            indent=indent,
         )
 
 
@@ -161,20 +172,18 @@ class SeriesWriter(Writer):
 
     def _format_axes(self):
         if not self.obj.index.is_unique and self.orient == "index":
-            raise ValueError(
-                "Series index must be unique for orient="
-                "'{orient}'".format(orient=self.orient)
-            )
+            raise ValueError(f"Series index must be unique for orient='{self.orient}'")
 
     def _write(
         self,
         obj,
-        orient,
-        double_precision,
-        ensure_ascii,
-        date_unit,
-        iso_dates,
-        default_handler,
+        orient: Optional[str],
+        double_precision: int,
+        ensure_ascii: bool,
+        date_unit: str,
+        iso_dates: bool,
+        default_handler: Optional[Callable[[Any], JSONSerializable]],
+        indent: int,
     ):
         if not self.index and orient == "split":
             obj = {"name": obj.name, "data": obj.values}
@@ -186,6 +195,7 @@ def _write(
             date_unit,
             iso_dates,
             default_handler,
+            indent,
         )
 
 
@@ -198,8 +208,7 @@ def _format_axes(self):
         """
         if not self.obj.index.is_unique and self.orient in ("index", "columns"):
             raise ValueError(
-                "DataFrame index must be unique for orient="
-                "'{orient}'.".format(orient=self.orient)
+                f"DataFrame index must be unique for orient='{self.orient}'."
             )
         if not self.obj.columns.is_unique and self.orient in (
             "index",
@@ -207,19 +216,19 @@ def _format_axes(self):
             "records",
         ):
             raise ValueError(
-                "DataFrame columns must be unique for orient="
-                "'{orient}'.".format(orient=self.orient)
+                f"DataFrame columns must be unique for orient='{self.orient}'."
             )
 
     def _write(
         self,
         obj,
-        orient,
-        double_precision,
-        ensure_ascii,
-        date_unit,
-        iso_dates,
-        default_handler,
+        orient: Optional[str],
+        double_precision: int,
+        ensure_ascii: bool,
+        date_unit: str,
+        iso_dates: bool,
+        default_handler: Optional[Callable[[Any], JSONSerializable]],
+        indent: int,
     ):
         if not self.index and orient == "split":
             obj = obj.to_dict(orient="split")
@@ -232,6 +241,7 @@ def _write(
             date_unit,
             iso_dates,
             default_handler,
+            indent,
         )
 
 
@@ -241,13 +251,14 @@ class JSONTableWriter(FrameWriter):
     def __init__(
         self,
         obj,
-        orient,
-        date_format,
-        double_precision,
-        ensure_ascii,
-        date_unit,
-        index,
-        default_handler=None,
+        orient: Optional[str],
+        date_format: str,
+        double_precision: int,
+        ensure_ascii: bool,
+        date_unit: str,
+        index: bool,
+        default_handler: Optional[Callable[[Any], JSONSerializable]] = None,
+        indent: int = 0,
     ):
         """
         Adds a `schema` attribute with the Table Schema, resets
@@ -255,6 +266,7 @@ def __init__(
         to know what the index is, forces orient to records, and forces
         date_format to 'iso'.
         """
+
         super().__init__(
             obj,
             orient,
@@ -264,13 +276,14 @@ def __init__(
             date_unit,
             index,
             default_handler=default_handler,
+            indent=indent,
         )
 
         if date_format != "iso":
             msg = (
                 "Trying to write with `orient='table'` and "
-                "`date_format='{fmt}'`. Table Schema requires dates "
-                "to be formatted with `date_format='iso'`".format(fmt=date_format)
+                f"`date_format='{date_format}'`. Table Schema requires dates "
+                "to be formatted with `date_format='iso'`"
             )
             raise ValueError(msg)
 
@@ -293,7 +306,7 @@ def __init__(
         timedeltas = obj.select_dtypes(include=["timedelta"]).columns
         if len(timedeltas):
             obj[timedeltas] = obj[timedeltas].applymap(lambda x: x.isoformat())
-        # Convert PeriodIndex to datetimes before serialzing
+        # Convert PeriodIndex to datetimes before serializing
         if is_period_dtype(obj.index):
             obj.index = obj.index.to_timestamp()
 
@@ -315,22 +328,24 @@ def _write(
         date_unit,
         iso_dates,
         default_handler,
+        indent,
     ):
-        data = super()._write(
-            obj,
+        table_obj = {"schema": self.schema, "data": obj}
+        serialized = super()._write(
+            table_obj,
             orient,
             double_precision,
             ensure_ascii,
             date_unit,
             iso_dates,
             default_handler,
+            indent,
         )
-        serialized = '{{"schema": {schema}, "data": {data}}}'.format(
-            schema=dumps(self.schema), data=data
-        )
+
         return serialized
 
 
+@deprecate_kwarg(old_arg_name="numpy", new_arg_name=None)
 def read_json(
     path_or_buf=None,
     orient=None,
@@ -364,7 +379,7 @@ def read_json(
         By file-like object, we refer to objects with a ``read()`` method,
         such as a file handler (e.g. via builtin ``open`` function)
         or ``StringIO``.
-    orient : string,
+    orient : str
         Indication of expected JSON string format.
         Compatible JSON strings can be produced by ``to_json()`` with a
         corresponding orient value.
@@ -423,8 +438,17 @@ def read_json(
            Not applicable for ``orient='table'``.
 
     convert_dates : bool or list of str, default True
-        List of columns to parse for dates. If True, then try to parse
-        datelike columns. A column label is datelike if
+        If True then default datelike columns may be converted (depending on
+        keep_default_dates).
+        If False, no dates will be converted.
+        If a list of column names, then those columns will be converted and
+        default datelike columns may also be converted (depending on
+        keep_default_dates).
+
+    keep_default_dates : bool, default True
+        If parsing dates (convert_dates is not False), then try to parse the
+        default datelike columns.
+        A column label is datelike if
 
         * it ends with ``'_at'``,
 
@@ -436,14 +460,13 @@ def read_json(
 
         * it is ``'date'``.
 
-    keep_default_dates : bool, default True
-        If parsing dates, then parse the default datelike columns.
-
     numpy : bool, default False
         Direct decoding to numpy arrays. Supports numeric data only, but
         non-numeric column and index labels are supported. Note also that the
         JSON ordering MUST be the same for each term if numpy=True.
 
+        .. deprecated:: 1.0.0
+
     precise_float : bool, default False
         Set to enable usage of higher precision (strtod) function when
         decoding string to double values. Default (False) is to use fast but
@@ -464,7 +487,7 @@ def read_json(
     chunksize : int, optional
         Return JsonReader object for iteration.
         See the `line-delimited json docs
-        <http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#line-delimited-json>`_
+        <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#line-delimited-json>`_
         for more information on ``chunksize``.
         This can only be passed if `lines=True`.
         If this is None, the file will be read into memory all at once.
@@ -559,8 +582,10 @@ def read_json(
         dtype = True
     if convert_axes is None and orient != "table":
         convert_axes = True
+    if encoding is None:
+        encoding = "utf-8"
 
-    compression = _infer_compression(path_or_buf, compression)
+    compression = infer_compression(path_or_buf, compression)
     filepath_or_buffer, _, compression, should_close = get_filepath_or_buffer(
         path_or_buf, encoding=encoding, compression=compression
     )
@@ -592,7 +617,7 @@ def read_json(
     return result
 
 
-class JsonReader(BaseIterator):
+class JsonReader(abc.Iterator):
     """
     JsonReader provides an interface for reading in a JSON file.
 
@@ -680,7 +705,7 @@ def _get_data_from_filepath(self, filepath_or_buffer):
                 pass
 
         if exists or self.compression is not None:
-            data, _ = _get_handle(
+            data, _ = get_handle(
                 filepath_or_buffer,
                 "r",
                 encoding=self.encoding,
@@ -691,7 +716,7 @@ def _get_data_from_filepath(self, filepath_or_buffer):
 
         return data
 
-    def _combine_lines(self, lines):
+    def _combine_lines(self, lines) -> str:
         """
         Combines a list of JSON objects into one JSON object.
         """
@@ -804,9 +829,7 @@ def __init__(
         if date_unit is not None:
             date_unit = date_unit.lower()
             if date_unit not in self._STAMP_UNITS:
-                raise ValueError(
-                    "date_unit must be one of {units}".format(units=self._STAMP_UNITS)
-                )
+                raise ValueError(f"date_unit must be one of {self._STAMP_UNITS}")
             self.min_stamp = self._MIN_STAMPS[date_unit]
         else:
             self.min_stamp = self._MIN_STAMPS["s"]
@@ -826,11 +849,7 @@ def check_keys_split(self, decoded):
         bad_keys = set(decoded.keys()).difference(set(self._split_keys))
         if bad_keys:
             bad_keys = ", ".join(bad_keys)
-            raise ValueError(
-                "JSON data had unexpected key(s): {bad_keys}".format(
-                    bad_keys=pprint_thing(bad_keys)
-                )
-            )
+            raise ValueError(f"JSON data had unexpected key(s): {bad_keys}")
 
     def parse(self):
 
@@ -922,7 +941,7 @@ def _try_convert_data(self, name, data, use_dtypes=True, convert_dates=True):
                 if (new_data == data).all():
                     data = new_data
                     result = True
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, OverflowError):
                 pass
 
         # coerce ints to 64
@@ -984,44 +1003,34 @@ class SeriesParser(Parser):
     _split_keys = ("name", "index", "data")
 
     def _parse_no_numpy(self):
+        data = loads(self.json, precise_float=self.precise_float)
 
-        json = self.json
-        orient = self.orient
-        if orient == "split":
-            decoded = {
-                str(k): v
-                for k, v in loads(json, precise_float=self.precise_float).items()
-            }
+        if self.orient == "split":
+            decoded = {str(k): v for k, v in data.items()}
             self.check_keys_split(decoded)
-            self.obj = Series(dtype=None, **decoded)
+            self.obj = create_series_with_explicit_dtype(**decoded)
         else:
-            self.obj = Series(loads(json, precise_float=self.precise_float), dtype=None)
+            self.obj = create_series_with_explicit_dtype(data, dtype_if_empty=object)
 
     def _parse_numpy(self):
+        load_kwargs = {
+            "dtype": None,
+            "numpy": True,
+            "precise_float": self.precise_float,
+        }
+        if self.orient in ["columns", "index"]:
+            load_kwargs["labelled"] = True
+        loads_ = functools.partial(loads, **load_kwargs)
+        data = loads_(self.json)
 
-        json = self.json
-        orient = self.orient
-        if orient == "split":
-            decoded = loads(
-                json, dtype=None, numpy=True, precise_float=self.precise_float
-            )
-            decoded = {str(k): v for k, v in decoded.items()}
+        if self.orient == "split":
+            decoded = {str(k): v for k, v in data.items()}
             self.check_keys_split(decoded)
-            self.obj = Series(**decoded)
-        elif orient == "columns" or orient == "index":
-            self.obj = Series(
-                *loads(
-                    json,
-                    dtype=None,
-                    numpy=True,
-                    labelled=True,
-                    precise_float=self.precise_float,
-                )
-            )
+            self.obj = create_series_with_explicit_dtype(**decoded)
+        elif self.orient in ["columns", "index"]:
+            self.obj = create_series_with_explicit_dtype(*data, dtype_if_empty=object)
         else:
-            self.obj = Series(
-                loads(json, dtype=None, numpy=True, precise_float=self.precise_float)
-            )
+            self.obj = create_series_with_explicit_dtype(data, dtype_if_empty=object)
 
     def _try_convert_types(self):
         if self.obj is None:
@@ -1092,14 +1101,10 @@ def _parse_no_numpy(self):
             self.check_keys_split(decoded)
             self.obj = DataFrame(dtype=None, **decoded)
         elif orient == "index":
-            self.obj = (
-                DataFrame.from_dict(
-                    loads(json, precise_float=self.precise_float),
-                    dtype=None,
-                    orient="index",
-                )
-                .sort_index(axis="columns")
-                .sort_index(axis="index")
+            self.obj = DataFrame.from_dict(
+                loads(json, precise_float=self.precise_float),
+                dtype=None,
+                orient="index",
             )
         elif orient == "table":
             self.obj = parse_table_schema(json, precise_float=self.precise_float)
@@ -1153,7 +1158,7 @@ def _try_convert_dates(self):
             convert_dates = []
         convert_dates = set(convert_dates)
 
-        def is_ok(col):
+        def is_ok(col) -> bool:
             """
             Return if this col is ok to try for a date parse.
             """
diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index 24a255c78f3c0..b638bdc0bc1eb 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -3,12 +3,14 @@
 
 from collections import defaultdict
 import copy
-from typing import DefaultDict, Dict, List, Optional, Union
+from typing import Any, DefaultDict, Dict, Iterable, List, Optional, Union
 
 import numpy as np
 
 from pandas._libs.writers import convert_json_to_lines
+from pandas.util._decorators import deprecate
 
+import pandas as pd
 from pandas import DataFrame
 
 
@@ -46,9 +48,6 @@ def nested_to_record(
     sep : str, default '.'
         Nested records will generate names separated by sep,
         e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar
-
-        .. versionadded:: 0.20.0
-
     level: int, optional, default: 0
         The number of levels in the json string.
 
@@ -111,16 +110,16 @@ def nested_to_record(
     return new_ds
 
 
-def json_normalize(
+def _json_normalize(
     data: Union[Dict, List[Dict]],
     record_path: Optional[Union[str, List]] = None,
-    meta: Optional[Union[str, List]] = None,
+    meta: Optional[Union[str, List[Union[str, List[str]]]]] = None,
     meta_prefix: Optional[str] = None,
     record_prefix: Optional[str] = None,
-    errors: Optional[str] = "raise",
+    errors: str = "raise",
     sep: str = ".",
     max_level: Optional[int] = None,
-):
+) -> "DataFrame":
     """
     Normalize semi-structured JSON data into a flat table.
 
@@ -146,15 +145,9 @@ def json_normalize(
           always present.
         * 'raise' : will raise KeyError if keys listed in meta are not
           always present.
-
-        .. versionadded:: 0.20.0
-
     sep : str, default '.'
         Nested records will generate names separated by sep.
         e.g., for sep='.', {'foo': {'bar': 0}} -> foo.bar.
-
-        .. versionadded:: 0.20.0
-
     max_level : int, default None
         Max number of levels(depth of dict) to normalize.
         if None, normalizes all levels.
@@ -192,7 +185,7 @@ def json_normalize(
     1   {'height': 130, 'weight': 60}  NaN    Mose Reg
     2   {'height': 130, 'weight': 60}  2.0  Faye Raker
 
-    Normalizes nested data upto level 1.
+    Normalizes nested data up to level 1.
 
     >>> data = [{'id': 1,
     ...          'name': "Cole Volk",
@@ -237,14 +230,23 @@ def json_normalize(
     Returns normalized data with columns prefixed with the given string.
     """
 
-    def _pull_field(js, spec):
-        result = js
+    def _pull_field(js: Dict[str, Any], spec: Union[List, str]) -> Iterable:
+        result = js  # type: ignore
         if isinstance(spec, list):
             for field in spec:
                 result = result[field]
         else:
             result = result[spec]
 
+        if not isinstance(result, Iterable):
+            if pd.isnull(result):
+                result = []  # type: ignore
+            else:
+                raise TypeError(
+                    f"{js} has non iterable value {result} for path {spec}. "
+                    "Must be iterable or null."
+                )
+
         return result
 
     if isinstance(data, list) and not data:
@@ -273,21 +275,21 @@ def _pull_field(js, spec):
     elif not isinstance(meta, list):
         meta = [meta]
 
-    meta = [m if isinstance(m, list) else [m] for m in meta]
+    _meta = [m if isinstance(m, list) else [m] for m in meta]
 
     # Disastrously inefficient for now
-    records = []  # type: List
+    records: List = []
     lengths = []
 
-    meta_vals = defaultdict(list)  # type: DefaultDict
-    meta_keys = [sep.join(val) for val in meta]
+    meta_vals: DefaultDict = defaultdict(list)
+    meta_keys = [sep.join(val) for val in _meta]
 
     def _recursive_extract(data, path, seen_meta, level=0):
         if isinstance(data, dict):
             data = [data]
         if len(path) > 1:
             for obj in data:
-                for val, key in zip(meta, meta_keys):
+                for val, key in zip(_meta, meta_keys):
                     if level + 1 == len(val):
                         seen_meta[key] = _pull_field(obj, val[-1])
 
@@ -304,7 +306,7 @@ def _recursive_extract(data, path, seen_meta, level=0):
 
                 # For repeating the metadata later
                 lengths.append(len(recs))
-                for val, key in zip(meta, meta_keys):
+                for val, key in zip(_meta, meta_keys):
                     if level + 1 > len(val):
                         meta_val = seen_meta[key]
                     else:
@@ -315,9 +317,8 @@ def _recursive_extract(data, path, seen_meta, level=0):
                                 meta_val = np.nan
                             else:
                                 raise KeyError(
-                                    "Try running with "
-                                    "errors='ignore' as key "
-                                    "{err} is not always present".format(err=e)
+                                    "Try running with errors='ignore' as key "
+                                    f"{e} is not always present"
                                 )
                     meta_vals[key].append(meta_val)
                 records.extend(recs)
@@ -327,7 +328,7 @@ def _recursive_extract(data, path, seen_meta, level=0):
     result = DataFrame(records)
 
     if record_prefix is not None:
-        result = result.rename(columns=lambda x: "{p}{c}".format(p=record_prefix, c=x))
+        result = result.rename(columns=lambda x: f"{record_prefix}{x}")
 
     # Data types, a problem
     for k, v in meta_vals.items():
@@ -336,8 +337,12 @@ def _recursive_extract(data, path, seen_meta, level=0):
 
         if k in result:
             raise ValueError(
-                "Conflicting metadata name {name}, "
-                "need distinguishing prefix ".format(name=k)
+                f"Conflicting metadata name {k}, need distinguishing prefix "
             )
         result[k] = np.array(v, dtype=object).repeat(lengths)
     return result
+
+
+json_normalize = deprecate(
+    "pandas.io.json.json_normalize", _json_normalize, "1.0.0", "pandas.json_normalize"
+)
diff --git a/pandas/io/json/_table_schema.py b/pandas/io/json/_table_schema.py
index b142dbf76e6b3..4e42533ca2744 100644
--- a/pandas/io/json/_table_schema.py
+++ b/pandas/io/json/_table_schema.py
@@ -1,7 +1,7 @@
 """
 Table Schema builders
 
-http://specs.frictionlessdata.io/json-table-schema/
+https://specs.frictionlessdata.io/json-table-schema/
 """
 import warnings
 
@@ -18,9 +18,9 @@
     is_string_dtype,
     is_timedelta64_dtype,
 )
+from pandas.core.dtypes.dtypes import CategoricalDtype
 
 from pandas import DataFrame
-from pandas.api.types import CategoricalDtype
 import pandas.core.common as com
 
 loads = json.loads
@@ -81,15 +81,13 @@ def set_default_names(data):
         if len(nms) == 1 and data.index.name == "index":
             warnings.warn("Index name of 'index' is not round-trippable")
         elif len(nms) > 1 and any(x.startswith("level_") for x in nms):
-            warnings.warn(
-                "Index names beginning with 'level_' are not " "round-trippable"
-            )
+            warnings.warn("Index names beginning with 'level_' are not round-trippable")
         return data
 
     data = data.copy()
     if data.index.nlevels > 1:
         names = [
-            name if name is not None else "level_{}".format(i)
+            name if name is not None else f"level_{i}"
             for i, name in enumerate(data.index.names)
         ]
         data.index.names = names
@@ -175,7 +173,7 @@ def convert_json_field_to_pandas_type(field):
         return "timedelta64"
     elif typ == "datetime":
         if field.get("tz"):
-            return "datetime64[ns, {tz}]".format(tz=field["tz"])
+            return f"datetime64[ns, {field['tz']}]"
         else:
             return "datetime64[ns]"
     elif typ == "any":
@@ -186,7 +184,7 @@ def convert_json_field_to_pandas_type(field):
         else:
             return "object"
 
-    raise ValueError("Unsupported or invalid field type: {}".format(typ))
+    raise ValueError(f"Unsupported or invalid field type: {typ}")
 
 
 def build_table_schema(data, index=True, primary_key=None, version=True):
@@ -199,7 +197,7 @@ def build_table_schema(data, index=True, primary_key=None, version=True):
     index : bool, default True
         Whether to include ``data.index`` in the schema.
     primary_key : bool or None, default True
-        column names to designate as the primary key.
+        Column names to designate as the primary key.
         The default `None` will set `'primaryKey'` to the index
         level or levels if the index is unique.
     version : bool, default True
@@ -243,8 +241,10 @@ def build_table_schema(data, index=True, primary_key=None, version=True):
 
     if index:
         if data.index.nlevels > 1:
-            for level in data.index.levels:
-                fields.append(convert_pandas_type_to_json_field(level))
+            for level, name in zip(data.index.levels, data.index.names):
+                new_field = convert_pandas_type_to_json_field(level)
+                new_field["name"] = name
+                fields.append(new_field)
         else:
             fields.append(convert_pandas_type_to_json_field(data.index))
 
@@ -315,12 +315,12 @@ def parse_table_schema(json, precise_float):
 
     # Cannot directly use as_type with timezone data on object; raise for now
     if any(str(x).startswith("datetime64[ns, ") for x in dtypes.values()):
-        raise NotImplementedError('table="orient" can not yet read timezone ' "data")
+        raise NotImplementedError('table="orient" can not yet read timezone data')
 
     # No ISO constructor for Timedelta as of yet, so need to raise
     if "timedelta64" in dtypes.values():
         raise NotImplementedError(
-            'table="orient" can not yet read ' "ISO-formatted Timedelta data"
+            'table="orient" can not yet read ISO-formatted Timedelta data'
         )
 
     df = df.astype(dtypes)
diff --git a/pandas/io/msgpack/__init__.py b/pandas/io/msgpack/__init__.py
deleted file mode 100644
index 7107263c180cb..0000000000000
--- a/pandas/io/msgpack/__init__.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# coding: utf-8
-
-from collections import namedtuple
-
-from pandas.io.msgpack.exceptions import *  # noqa: F401,F403 isort:skip
-from pandas.io.msgpack._version import version  # noqa: F401 isort:skip
-
-
-class ExtType(namedtuple("ExtType", "code data")):
-    """ExtType represents ext type in msgpack."""
-
-    def __new__(cls, code, data):
-        if not isinstance(code, int):
-            raise TypeError("code must be int")
-        if not isinstance(data, bytes):
-            raise TypeError("data must be bytes")
-        if not 0 <= code <= 127:
-            raise ValueError("code must be 0~127")
-        return super().__new__(cls, code, data)
-
-
-import os  # noqa: F401,E402 isort:skip
-
-from pandas.io.msgpack._unpacker import (  # noqa: F401,E402 isort:skip
-    Unpacker,
-    unpack,
-    unpackb,
-)
-from pandas.io.msgpack._packer import Packer  # noqa: E402 isort:skip
-
-
-def pack(o, stream, **kwargs):
-    """
-    Pack object `o` and write it to `stream`
-
-    See :class:`Packer` for options.
-    """
-    packer = Packer(**kwargs)
-    stream.write(packer.pack(o))
-
-
-def packb(o, **kwargs):
-    """
-    Pack object `o` and return packed bytes
-
-    See :class:`Packer` for options.
-    """
-    return Packer(**kwargs).pack(o)
-
-
-# alias for compatibility to simplejson/marshal/pickle.
-load = unpack
-loads = unpackb
-
-dump = pack
-dumps = packb
diff --git a/pandas/io/msgpack/_packer.pyi b/pandas/io/msgpack/_packer.pyi
deleted file mode 100644
index e95a1622c5615..0000000000000
--- a/pandas/io/msgpack/_packer.pyi
+++ /dev/null
@@ -1,22 +0,0 @@
-# flake8: noqa
-
-class Packer:
-    def __cinit__(self): ...
-    def __init__(
-        self,
-        default=...,
-        encoding=...,
-        unicode_errors=...,
-        use_single_float=...,
-        autoreset: int = ...,
-        use_bin_type: int = ...,
-    ): ...
-    def __dealloc__(self): ...
-    def _pack(self, o, nest_limit: int = ...) -> int: ...
-    def pack(self, obj): ...
-    def pack_ext_type(self, typecode, data): ...
-    def pack_array_header(self, size): ...
-    def pack_map_header(self, size): ...
-    def pack_map_pairs(self, pairs): ...
-    def reset(self) -> None: ...
-    def bytes(self): ...
diff --git a/pandas/io/msgpack/_packer.pyx b/pandas/io/msgpack/_packer.pyx
deleted file mode 100644
index 19307e2334f1e..0000000000000
--- a/pandas/io/msgpack/_packer.pyx
+++ /dev/null
@@ -1,312 +0,0 @@
-# coding: utf-8
-# cython: embedsignature=True
-
-from cpython.bytes cimport (PyBytes_Check, PyBytes_AsString,
-                            PyBytes_FromStringAndSize)
-from cpython.dict cimport PyDict_Check, PyDict_CheckExact
-from cpython.float cimport PyFloat_Check
-from cpython.int cimport PyInt_Check
-from cpython.list cimport PyList_Check
-from cpython.long cimport PyLong_Check
-from cpython.object cimport PyCallable_Check
-from cpython.tuple cimport PyTuple_Check
-from cpython.unicode cimport PyUnicode_Check, PyUnicode_AsEncodedString
-
-from libc.stdlib cimport free, malloc
-
-from pandas.io.msgpack.exceptions import PackValueError
-from pandas.io.msgpack import ExtType
-import numpy as np
-
-
-cdef extern from "../../src/msgpack/pack.h":
-    struct msgpack_packer:
-        char* buf
-        size_t length
-        size_t buf_size
-        bint use_bin_type
-
-    int msgpack_pack_int(msgpack_packer* pk, int d)
-    int msgpack_pack_nil(msgpack_packer* pk)
-    int msgpack_pack_true(msgpack_packer* pk)
-    int msgpack_pack_false(msgpack_packer* pk)
-    int msgpack_pack_long(msgpack_packer* pk, long d)
-    int msgpack_pack_long_long(msgpack_packer* pk, long long d)
-    int msgpack_pack_unsigned_long_long(msgpack_packer* pk,
-                                        unsigned long long d)
-    int msgpack_pack_float(msgpack_packer* pk, float d)
-    int msgpack_pack_double(msgpack_packer* pk, double d)
-    int msgpack_pack_array(msgpack_packer* pk, size_t l)
-    int msgpack_pack_map(msgpack_packer* pk, size_t l)
-    int msgpack_pack_raw(msgpack_packer* pk, size_t l)
-    int msgpack_pack_bin(msgpack_packer* pk, size_t l)
-    int msgpack_pack_raw_body(msgpack_packer* pk, char* body, size_t l)
-    int msgpack_pack_ext(msgpack_packer* pk, char typecode, size_t l)
-
-cdef int DEFAULT_RECURSE_LIMIT=511
-
-
-cdef class Packer:
-    """
-    MessagePack Packer
-
-    usage::
-
-        packer = Packer()
-        astream.write(packer.pack(a))
-        astream.write(packer.pack(b))
-
-    Packer's constructor has some keyword arguments:
-
-    :param callable default:
-        Convert user type to builtin type that Packer supports.
-        See also simplejson's document.
-    :param str encoding:
-        Convert unicode to bytes with this encoding. (default: 'utf-8')
-    :param str unicode_errors:
-        Error handler for encoding unicode. (default: 'strict')
-    :param bool use_single_float:
-        Use single precision float type for float. (default: False)
-    :param bool autoreset:
-        Reset buffer after each pack and return it's
-        content as `bytes`. (default: True).
-        If set this to false, use `bytes()` to get
-        content and `.reset()` to clear buffer.
-    :param bool use_bin_type:
-        Use bin type introduced in msgpack spec 2.0 for bytes.
-        It also enable str8 type for unicode.
-    """
-    cdef:
-        msgpack_packer pk
-        object _default
-        object _bencoding
-        object _berrors
-        char *encoding
-        char *unicode_errors
-        bint use_float
-        bint autoreset
-
-    def __cinit__(self):
-        cdef int buf_size = 1024 * 1024
-        self.pk.buf = <char*> malloc(buf_size)
-        if self.pk.buf == NULL:
-            raise MemoryError("Unable to allocate internal buffer.")
-        self.pk.buf_size = buf_size
-        self.pk.length = 0
-
-    def __init__(self, default=None, encoding='utf-8',
-                 unicode_errors='strict', use_single_float=False,
-                 bint autoreset=1, bint use_bin_type=0):
-        """
-        """
-        self.use_float = use_single_float
-        self.autoreset = autoreset
-        self.pk.use_bin_type = use_bin_type
-        if default is not None:
-            if not PyCallable_Check(default):
-                raise TypeError("default must be a callable.")
-        self._default = default
-        if encoding is None:
-            self.encoding = NULL
-            self.unicode_errors = NULL
-        else:
-            if isinstance(encoding, unicode):
-                self._bencoding = encoding.encode('ascii')
-            else:
-                self._bencoding = encoding
-            self.encoding = PyBytes_AsString(self._bencoding)
-            if isinstance(unicode_errors, unicode):
-                self._berrors = unicode_errors.encode('ascii')
-            else:
-                self._berrors = unicode_errors
-            self.unicode_errors = PyBytes_AsString(self._berrors)
-
-    def __dealloc__(self):
-        free(self.pk.buf);
-
-    cdef int _pack(self, object o,
-                   int nest_limit=DEFAULT_RECURSE_LIMIT) except -1:
-        cdef:
-            long long llval
-            unsigned long long ullval
-            long longval
-            float fval
-            double dval
-            char* rawval
-            int ret
-            dict d
-            size_t L
-            int default_used = 0
-
-        if nest_limit < 0:
-            raise PackValueError("recursion limit exceeded.")
-
-        while True:
-            if o is None:
-                ret = msgpack_pack_nil(&self.pk)
-            elif isinstance(o, (bool, np.bool_)):
-                if o:
-                    ret = msgpack_pack_true(&self.pk)
-                else:
-                    ret = msgpack_pack_false(&self.pk)
-            elif PyLong_Check(o):
-                # PyInt_Check(long) is True for Python 3.
-                # Sow we should test long before int.
-                if o > 0:
-                    ullval = o
-                    ret = msgpack_pack_unsigned_long_long(&self.pk, ullval)
-                else:
-                    llval = o
-                    ret = msgpack_pack_long_long(&self.pk, llval)
-            elif PyInt_Check(o):
-                longval = o
-                ret = msgpack_pack_long(&self.pk, longval)
-            elif PyFloat_Check(o):
-                if self.use_float:
-                    fval = o
-                    ret = msgpack_pack_float(&self.pk, fval)
-                else:
-                    dval = o
-                    ret = msgpack_pack_double(&self.pk, dval)
-            elif PyBytes_Check(o):
-                L = len(o)
-                if L > (2**32) - 1:
-                    raise ValueError("bytes is too large")
-                rawval = o
-                ret = msgpack_pack_bin(&self.pk, L)
-                if ret == 0:
-                    ret = msgpack_pack_raw_body(&self.pk, rawval, L)
-            elif PyUnicode_Check(o):
-                if not self.encoding:
-                    raise TypeError("Can't encode unicode string: "
-                                    "no encoding is specified")
-                o = PyUnicode_AsEncodedString(o, self.encoding,
-                                              self.unicode_errors)
-                L = len(o)
-                if L > (2**32) - 1:
-                    raise ValueError("dict is too large")
-                rawval = o
-                ret = msgpack_pack_raw(&self.pk, len(o))
-                if ret == 0:
-                    ret = msgpack_pack_raw_body(&self.pk, rawval, len(o))
-            elif PyDict_CheckExact(o):
-                d = <dict>o
-                L = len(d)
-                if L > (2**32) - 1:
-                    raise ValueError("dict is too large")
-                ret = msgpack_pack_map(&self.pk, L)
-                if ret == 0:
-                    for k, v in d.items():
-                        ret = self._pack(k, nest_limit - 1)
-                        if ret != 0: break
-                        ret = self._pack(v, nest_limit - 1)
-                        if ret != 0: break
-            elif PyDict_Check(o):
-                L = len(o)
-                if L > (2**32) - 1:
-                    raise ValueError("dict is too large")
-                ret = msgpack_pack_map(&self.pk, L)
-                if ret == 0:
-                    for k, v in o.items():
-                        ret = self._pack(k, nest_limit - 1)
-                        if ret != 0: break
-                        ret = self._pack(v, nest_limit - 1)
-                        if ret != 0: break
-            elif isinstance(o, ExtType):
-                # This should be before Tuple because ExtType is namedtuple.
-                longval = o.code
-                rawval = o.data
-                L = len(o.data)
-                if L > (2**32) - 1:
-                    raise ValueError("EXT data is too large")
-                ret = msgpack_pack_ext(&self.pk, longval, L)
-                ret = msgpack_pack_raw_body(&self.pk, rawval, L)
-            elif PyTuple_Check(o) or PyList_Check(o):
-                L = len(o)
-                if L > (2**32) - 1:
-                    raise ValueError("list is too large")
-                ret = msgpack_pack_array(&self.pk, L)
-                if ret == 0:
-                    for v in o:
-                        ret = self._pack(v, nest_limit - 1)
-                        if ret != 0: break
-            elif not default_used and self._default:
-                o = self._default(o)
-                default_used = 1
-                continue
-            else:
-                raise TypeError("can't serialize {thing!r}".format(thing=o))
-            return ret
-
-    cpdef pack(self, object obj):
-        cdef int ret
-        ret = self._pack(obj, DEFAULT_RECURSE_LIMIT)
-        if ret == -1:
-            raise MemoryError
-        elif ret:  # should not happen.
-            raise TypeError
-        if self.autoreset:
-            buf = PyBytes_FromStringAndSize(self.pk.buf, self.pk.length)
-            self.pk.length = 0
-            return buf
-
-    def pack_ext_type(self, typecode, data):
-        msgpack_pack_ext(&self.pk, typecode, len(data))
-        msgpack_pack_raw_body(&self.pk, data, len(data))
-
-    def pack_array_header(self, size_t size):
-        if size > (2**32) - 1:
-            raise ValueError
-        cdef int ret = msgpack_pack_array(&self.pk, size)
-        if ret == -1:
-            raise MemoryError
-        elif ret:  # should not happen
-            raise TypeError
-        if self.autoreset:
-            buf = PyBytes_FromStringAndSize(self.pk.buf, self.pk.length)
-            self.pk.length = 0
-            return buf
-
-    def pack_map_header(self, size_t size):
-        if size > (2**32) - 1:
-            raise ValueError
-        cdef int ret = msgpack_pack_map(&self.pk, size)
-        if ret == -1:
-            raise MemoryError
-        elif ret:  # should not happen
-            raise TypeError
-        if self.autoreset:
-            buf = PyBytes_FromStringAndSize(self.pk.buf, self.pk.length)
-            self.pk.length = 0
-            return buf
-
-    def pack_map_pairs(self, object pairs):
-        """
-        Pack *pairs* as msgpack map type.
-
-        *pairs* should sequence of pair.
-        (`len(pairs)` and `for k, v in pairs:` should be supported.)
-        """
-        cdef int ret = msgpack_pack_map(&self.pk, len(pairs))
-        if ret == 0:
-            for k, v in pairs:
-                ret = self._pack(k)
-                if ret != 0: break
-                ret = self._pack(v)
-                if ret != 0: break
-        if ret == -1:
-            raise MemoryError
-        elif ret:  # should not happen
-            raise TypeError
-        if self.autoreset:
-            buf = PyBytes_FromStringAndSize(self.pk.buf, self.pk.length)
-            self.pk.length = 0
-            return buf
-
-    def reset(self):
-        """Clear internal buffer."""
-        self.pk.length = 0
-
-    def bytes(self):
-        """Return buffer content."""
-        return PyBytes_FromStringAndSize(self.pk.buf, self.pk.length)
diff --git a/pandas/io/msgpack/_unpacker.pyi b/pandas/io/msgpack/_unpacker.pyi
deleted file mode 100644
index 9910895947fb6..0000000000000
--- a/pandas/io/msgpack/_unpacker.pyi
+++ /dev/null
@@ -1,59 +0,0 @@
-# flake8: noqa
-
-def unpackb(
-    packed,
-    object_hook=...,
-    list_hook=...,
-    use_list=...,
-    encoding=...,
-    unicode_errors=...,
-    object_pairs_hook=...,
-    ext_hook=...,
-    max_str_len=...,
-    max_bin_len=...,
-    max_array_len=...,
-    max_map_len=...,
-    max_ext_len=...,
-): ...
-def unpack(
-    stream,
-    object_hook=...,
-    list_hook=...,
-    use_list=...,
-    encoding=...,
-    unicode_errors=...,
-    object_pairs_hook=...,
-): ...
-
-class Unpacker:
-    def __cinit__(self): ...
-    def __dealloc__(self): ...
-    def __init__(
-        self,
-        file_like=...,
-        read_size=...,
-        use_list=...,
-        object_hook=...,
-        object_pairs_hook=...,
-        list_hook=...,
-        encoding=...,
-        unicode_errors=...,
-        max_buffer_size: int = ...,
-        ext_hook=...,
-        max_str_len=...,
-        max_bin_len=...,
-        max_array_len=...,
-        max_map_len=...,
-        max_ext_len=...,
-    ): ...
-    def feed(self, next_bytes): ...
-    def append_buffer(self, _buf, _buf_len): ...
-    def read_from_file(self): ...
-    def _unpack(self, execute, write_bytes, iter=...): ...
-    def read_bytes(self, nbytes): ...
-    def unpack(self, write_bytes=...): ...
-    def skip(self, write_bytes=...): ...
-    def read_array_header(self, write_bytes=...): ...
-    def read_map_header(self, write_bytes=...): ...
-    def __iter__(self): ...
-    def __next__(self): ...
diff --git a/pandas/io/msgpack/_unpacker.pyx b/pandas/io/msgpack/_unpacker.pyx
deleted file mode 100644
index d7ebb194ef5c5..0000000000000
--- a/pandas/io/msgpack/_unpacker.pyx
+++ /dev/null
@@ -1,496 +0,0 @@
-# coding: utf-8
-# cython: embedsignature=True
-
-from cython cimport Py_ssize_t
-
-from cpython.buffer cimport (PyBUF_SIMPLE, PyObject_GetBuffer,
-                             PyBuffer_Release, Py_buffer)
-from cpython.bytes cimport (PyBytes_Size, PyBytes_AsString,
-                            PyBytes_FromStringAndSize)
-from cpython.object cimport PyCallable_Check
-
-cdef extern from "Python.h":
-    ctypedef struct PyObject
-
-from libc.stdlib cimport free, malloc
-from libc.string cimport memcpy, memmove
-from libc.limits cimport INT_MAX
-
-from pandas.io.msgpack.exceptions import (BufferFull, OutOfData,
-                                          UnpackValueError, ExtraData)
-from pandas.io.msgpack import ExtType
-
-
-cdef extern from "../../src/msgpack/unpack.h":
-    ctypedef struct msgpack_user:
-        bint use_list
-        PyObject* object_hook
-        bint has_pairs_hook  # call object_hook with k-v pairs
-        PyObject* list_hook
-        PyObject* ext_hook
-        char *encoding
-        char *unicode_errors
-        Py_ssize_t max_str_len
-        Py_ssize_t max_bin_len
-        Py_ssize_t max_array_len
-        Py_ssize_t max_map_len
-        Py_ssize_t max_ext_len
-
-    ctypedef struct unpack_context:
-        msgpack_user user
-        PyObject* obj
-        size_t count
-
-    ctypedef int (*execute_fn)(unpack_context* ctx, const char* data,
-                               size_t len, size_t* off) except? -1
-    execute_fn unpack_construct
-    execute_fn unpack_skip
-    execute_fn read_array_header
-    execute_fn read_map_header
-    void unpack_init(unpack_context* ctx)
-    object unpack_data(unpack_context* ctx)
-
-cdef inline init_ctx(unpack_context *ctx,
-                     object object_hook, object object_pairs_hook,
-                     object list_hook, object ext_hook,
-                     bint use_list, char* encoding, char* unicode_errors,
-                     Py_ssize_t max_str_len, Py_ssize_t max_bin_len,
-                     Py_ssize_t max_array_len, Py_ssize_t max_map_len,
-                     Py_ssize_t max_ext_len):
-    unpack_init(ctx)
-    ctx.user.use_list = use_list
-    ctx.user.object_hook = ctx.user.list_hook = <PyObject*>NULL
-    ctx.user.max_str_len = max_str_len
-    ctx.user.max_bin_len = max_bin_len
-    ctx.user.max_array_len = max_array_len
-    ctx.user.max_map_len = max_map_len
-    ctx.user.max_ext_len = max_ext_len
-
-    if object_hook is not None and object_pairs_hook is not None:
-        raise TypeError("object_pairs_hook and object_hook "
-                        "are mutually exclusive.")
-
-    if object_hook is not None:
-        if not PyCallable_Check(object_hook):
-            raise TypeError("object_hook must be a callable.")
-        ctx.user.object_hook = <PyObject*>object_hook
-
-    if object_pairs_hook is None:
-        ctx.user.has_pairs_hook = False
-    else:
-        if not PyCallable_Check(object_pairs_hook):
-            raise TypeError("object_pairs_hook must be a callable.")
-        ctx.user.object_hook = <PyObject*>object_pairs_hook
-        ctx.user.has_pairs_hook = True
-
-    if list_hook is not None:
-        if not PyCallable_Check(list_hook):
-            raise TypeError("list_hook must be a callable.")
-        ctx.user.list_hook = <PyObject*>list_hook
-
-    if ext_hook is not None:
-        if not PyCallable_Check(ext_hook):
-            raise TypeError("ext_hook must be a callable.")
-        ctx.user.ext_hook = <PyObject*>ext_hook
-
-    ctx.user.encoding = encoding
-    ctx.user.unicode_errors = unicode_errors
-
-
-def default_read_extended_type(typecode, data):
-    raise NotImplementedError("Cannot decode extended type "
-                              "with typecode={code}".format(code=typecode))
-
-
-def unpackb(object packed, object object_hook=None, object list_hook=None,
-            bint use_list=1, encoding=None, unicode_errors="strict",
-            object_pairs_hook=None, ext_hook=ExtType,
-            Py_ssize_t max_str_len=2147483647,  # 2**32-1
-            Py_ssize_t max_bin_len=2147483647,
-            Py_ssize_t max_array_len=2147483647,
-            Py_ssize_t max_map_len=2147483647,
-            Py_ssize_t max_ext_len=2147483647):
-    """
-    Unpack packed_bytes to object. Returns an unpacked object.
-
-    Raises `ValueError` when `packed` contains extra bytes.
-
-    See :class:`Unpacker` for options.
-    """
-    cdef:
-        unpack_context ctx
-        size_t off = 0
-        int ret
-
-        char* buf
-        Py_ssize_t buf_len
-        char* cenc = NULL
-        char* cerr = NULL
-        Py_buffer view
-        bytes extra_bytes
-
-    # GH#26769 Effectively re-implement deprecated PyObject_AsReadBuffer;
-    # based on https://xpra.org/trac/ticket/1884
-    PyObject_GetBuffer(packed, &view, PyBUF_SIMPLE)
-    buf = <char*>view.buf
-    buf_len = view.len
-
-    if encoding is not None:
-        if isinstance(encoding, unicode):
-            encoding = encoding.encode('ascii')
-        cenc = PyBytes_AsString(encoding)
-
-    if unicode_errors is not None:
-        if isinstance(unicode_errors, unicode):
-            unicode_errors = unicode_errors.encode('ascii')
-        cerr = PyBytes_AsString(unicode_errors)
-
-    init_ctx(&ctx, object_hook, object_pairs_hook, list_hook, ext_hook,
-             use_list, cenc, cerr,
-             max_str_len, max_bin_len, max_array_len, max_map_len, max_ext_len)
-    ret = unpack_construct(&ctx, buf, buf_len, &off)
-    if ret == 1:
-        obj = unpack_data(&ctx)
-        if <Py_ssize_t> off < buf_len:
-            extra_bytes = PyBytes_FromStringAndSize(buf + off, buf_len - off)
-            PyBuffer_Release(&view)
-            raise ExtraData(obj, extra_bytes)
-        PyBuffer_Release(&view)
-        return obj
-    else:
-        PyBuffer_Release(&view)
-        raise UnpackValueError("Unpack failed: error = {ret}".format(ret=ret))
-
-
-def unpack(object stream, object object_hook=None, object list_hook=None,
-           bint use_list=1, encoding=None, unicode_errors="strict",
-           object_pairs_hook=None,
-           ):
-    """
-    Unpack an object from `stream`.
-
-    Raises `ValueError` when `stream` has extra bytes.
-
-    See :class:`Unpacker` for options.
-    """
-    return unpackb(stream.read(), use_list=use_list,
-                   object_hook=object_hook,
-                   object_pairs_hook=object_pairs_hook, list_hook=list_hook,
-                   encoding=encoding, unicode_errors=unicode_errors)
-
-
-cdef class Unpacker:
-    """Streaming unpacker.
-
-    arguments:
-
-    :param file_like:
-        File-like object having `.read(n)` method.
-        If specified, unpacker reads serialized data from it and
-        :meth:`feed()` is not usable.
-
-    :param int read_size:
-        Used as `file_like.read(read_size)`. (default:
-        `min(1024**2, max_buffer_size)`)
-
-    :param bool use_list:
-        If true, unpack msgpack array to Python list.
-        Otherwise, unpack to Python tuple. (default: True)
-
-    :param callable object_hook:
-        When specified, it should be callable.
-        Unpacker calls it with a dict argument after unpacking msgpack map.
-        (See also simplejson)
-
-    :param callable object_pairs_hook:
-        When specified, it should be callable. Unpacker calls it with a list
-        of key-value pairs after unpacking msgpack map. (See also simplejson)
-
-    :param str encoding:
-        Encoding used for decoding msgpack raw.
-        If it is None (default), msgpack raw is deserialized to Python bytes.
-
-    :param str unicode_errors:
-        Used for decoding msgpack raw with *encoding*.
-        (default: `'strict'`)
-
-    :param int max_buffer_size:
-        Limits size of data waiting unpacked.  0 means system's
-        INT_MAX  (default). Raises `BufferFull` exception when it
-        is insufficient. You should set this parameter when unpacking
-        data from untrasted source.
-
-    :param int max_str_len:
-        Limits max length of str. (default: 2**31-1)
-
-    :param int max_bin_len:
-        Limits max length of bin. (default: 2**31-1)
-
-    :param int max_array_len:
-        Limits max length of array. (default: 2**31-1)
-
-    :param int max_map_len:
-        Limits max length of map. (default: 2**31-1)
-
-
-    example of streaming deserialize from file-like object::
-
-        unpacker = Unpacker(file_like)
-        for o in unpacker:
-            process(o)
-
-    example of streaming deserialize from socket::
-
-        unpacker = Unpacker()
-        while True:
-            buf = sock.recv(1024**2)
-            if not buf:
-                break
-            unpacker.feed(buf)
-            for o in unpacker:
-                process(o)
-    """
-    cdef:
-        unpack_context ctx
-        char* buf
-        size_t buf_size, buf_head, buf_tail
-        object file_like
-        object file_like_read
-        Py_ssize_t read_size
-        # To maintain refcnt.
-        object object_hook, object_pairs_hook, list_hook, ext_hook
-        object encoding, unicode_errors
-        size_t max_buffer_size
-
-    def __cinit__(self):
-        self.buf = NULL
-
-    def __dealloc__(self):
-        free(self.buf)
-        self.buf = NULL
-
-    def __init__(self, file_like=None, Py_ssize_t read_size=0, bint use_list=1,
-                 object object_hook=None, object object_pairs_hook=None,
-                 object list_hook=None, encoding=None, unicode_errors='strict',
-                 int max_buffer_size=0, object ext_hook=ExtType,
-                 Py_ssize_t max_str_len=2147483647,  # 2**32-1
-                 Py_ssize_t max_bin_len=2147483647,
-                 Py_ssize_t max_array_len=2147483647,
-                 Py_ssize_t max_map_len=2147483647,
-                 Py_ssize_t max_ext_len=2147483647):
-        cdef:
-            char *cenc=NULL,
-            char *cerr=NULL
-
-        self.object_hook = object_hook
-        self.object_pairs_hook = object_pairs_hook
-        self.list_hook = list_hook
-        self.ext_hook = ext_hook
-
-        self.file_like = file_like
-        if file_like:
-            self.file_like_read = file_like.read
-            if not PyCallable_Check(self.file_like_read):
-                raise TypeError("`file_like.read` must be a callable.")
-        if not max_buffer_size:
-            max_buffer_size = INT_MAX
-        if read_size > max_buffer_size:
-            raise ValueError("read_size should be less or "
-                             "equal to max_buffer_size")
-        if not read_size:
-            read_size = min(max_buffer_size, 1024**2)
-        self.max_buffer_size = max_buffer_size
-        self.read_size = read_size
-        self.buf = <char*>malloc(read_size)
-        if self.buf == NULL:
-            raise MemoryError("Unable to allocate internal buffer.")
-        self.buf_size = read_size
-        self.buf_head = 0
-        self.buf_tail = 0
-
-        if encoding is not None:
-            if isinstance(encoding, unicode):
-                self.encoding = encoding.encode('ascii')
-            elif isinstance(encoding, bytes):
-                self.encoding = encoding
-            else:
-                raise TypeError("encoding should be bytes or unicode")
-            cenc = PyBytes_AsString(self.encoding)
-
-        if unicode_errors is not None:
-            if isinstance(unicode_errors, unicode):
-                self.unicode_errors = unicode_errors.encode('ascii')
-            elif isinstance(unicode_errors, bytes):
-                self.unicode_errors = unicode_errors
-            else:
-                raise TypeError("unicode_errors should be bytes or unicode")
-            cerr = PyBytes_AsString(self.unicode_errors)
-
-        init_ctx(&self.ctx, object_hook, object_pairs_hook, list_hook,
-                 ext_hook, use_list, cenc, cerr,
-                 max_str_len, max_bin_len, max_array_len,
-                 max_map_len, max_ext_len)
-
-    def feed(self, object next_bytes):
-        """Append `next_bytes` to internal buffer."""
-        cdef Py_buffer pybuff
-        if self.file_like is not None:
-            raise AssertionError("unpacker.feed() is not be able "
-                                 "to use with `file_like`.")
-        PyObject_GetBuffer(next_bytes, &pybuff, PyBUF_SIMPLE)
-        try:
-            self.append_buffer(<char*>pybuff.buf, pybuff.len)
-        finally:
-            PyBuffer_Release(&pybuff)
-
-    cdef append_buffer(self, void* _buf, Py_ssize_t _buf_len):
-        cdef:
-            char* buf = self.buf
-            char* new_buf
-            size_t head = self.buf_head
-            size_t tail = self.buf_tail
-            size_t buf_size = self.buf_size
-            size_t new_size
-
-        if tail + _buf_len > buf_size:
-            if ((tail - head) + _buf_len) <= buf_size:
-                # move to front.
-                memmove(buf, buf + head, tail - head)
-                tail -= head
-                head = 0
-            else:
-                # expand buffer.
-                new_size = (tail - head) + _buf_len
-                if new_size > self.max_buffer_size:
-                    raise BufferFull
-                new_size = min(new_size * 2, self.max_buffer_size)
-                new_buf = <char*>malloc(new_size)
-                if new_buf == NULL:
-                    # self.buf still holds old buffer and will be freed during
-                    # obj destruction
-                    raise MemoryError("Unable to enlarge internal buffer.")
-                memcpy(new_buf, buf + head, tail - head)
-                free(buf)
-
-                buf = new_buf
-                buf_size = new_size
-                tail -= head
-                head = 0
-
-        memcpy(buf + tail, <char*>(_buf), _buf_len)
-        self.buf = buf
-        self.buf_head = head
-        self.buf_size = buf_size
-        self.buf_tail = tail + _buf_len
-
-    cdef read_from_file(self):
-        # Assume self.max_buffer_size - (self.buf_tail - self.buf_head) >= 0
-        next_bytes = self.file_like_read(
-            min(self.read_size,
-                <Py_ssize_t>(self.max_buffer_size -
-                             (self.buf_tail - self.buf_head))))
-        if next_bytes:
-            self.append_buffer(PyBytes_AsString(next_bytes),
-                               PyBytes_Size(next_bytes))
-        else:
-            self.file_like = None
-
-    cdef object _unpack(self, execute_fn execute,
-                        object write_bytes, bint iter=0):
-        cdef:
-            int ret
-            object obj
-            size_t prev_head
-
-        if self.buf_head >= self.buf_tail and self.file_like is not None:
-            self.read_from_file()
-
-        while 1:
-            prev_head = self.buf_head
-            if prev_head >= self.buf_tail:
-                if iter:
-                    raise StopIteration("No more data to unpack.")
-                else:
-                    raise OutOfData("No more data to unpack.")
-
-            ret = execute(&self.ctx, self.buf, self.buf_tail, &self.buf_head)
-            if write_bytes is not None:
-                write_bytes(PyBytes_FromStringAndSize(
-                    self.buf + prev_head, self.buf_head - prev_head))
-
-            if ret == 1:
-                obj = unpack_data(&self.ctx)
-                unpack_init(&self.ctx)
-                return obj
-            elif ret == 0:
-                if self.file_like is not None:
-                    self.read_from_file()
-                    continue
-                if iter:
-                    raise StopIteration("No more data to unpack.")
-                else:
-                    raise OutOfData("No more data to unpack.")
-            else:
-                raise ValueError("Unpack failed: error = {ret}"
-                                 .format(ret=ret))
-
-    def read_bytes(self, Py_ssize_t nbytes):
-        """Read a specified number of raw bytes from the stream"""
-        cdef size_t nread
-
-        # Assume that self.buf_tail - self.buf_head >= 0
-        nread = min(<Py_ssize_t>(self.buf_tail - self.buf_head), nbytes)
-        ret = PyBytes_FromStringAndSize(self.buf + self.buf_head, nread)
-        self.buf_head += nread
-        if len(ret) < nbytes and self.file_like is not None:
-            ret += self.file_like.read(nbytes - len(ret))
-        return ret
-
-    def unpack(self, object write_bytes=None):
-        """Unpack one object
-
-        If write_bytes is not None, it will be called with parts of the raw
-        message as it is unpacked.
-
-        Raises `OutOfData` when there are no more bytes to unpack.
-        """
-        return self._unpack(unpack_construct, write_bytes)
-
-    def skip(self, object write_bytes=None):
-        """Read and ignore one object, returning None
-
-        If write_bytes is not None, it will be called with parts of the raw
-        message as it is unpacked.
-
-        Raises `OutOfData` when there are no more bytes to unpack.
-        """
-        return self._unpack(unpack_skip, write_bytes)
-
-    def read_array_header(self, object write_bytes=None):
-        """assuming the next object is an array, return its size n, such that
-        the next n unpack() calls will iterate over its contents.
-
-        Raises `OutOfData` when there are no more bytes to unpack.
-        """
-        return self._unpack(read_array_header, write_bytes)
-
-    def read_map_header(self, object write_bytes=None):
-        """assuming the next object is a map, return its size n, such that the
-        next n * 2 unpack() calls will iterate over its key-value pairs.
-
-        Raises `OutOfData` when there are no more bytes to unpack.
-        """
-        return self._unpack(read_map_header, write_bytes)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self._unpack(unpack_construct, None, 1)
-
-    # for debug.
-    # def _buf(self):
-    #    return PyString_FromStringAndSize(self.buf, self.buf_tail)
-
-    # def _off(self):
-    #    return self.buf_head
diff --git a/pandas/io/msgpack/_version.py b/pandas/io/msgpack/_version.py
deleted file mode 100644
index 2c1c96c0759a1..0000000000000
--- a/pandas/io/msgpack/_version.py
+++ /dev/null
@@ -1 +0,0 @@
-version = (0, 4, 6)
diff --git a/pandas/io/msgpack/exceptions.py b/pandas/io/msgpack/exceptions.py
deleted file mode 100644
index 40f5a8af8f583..0000000000000
--- a/pandas/io/msgpack/exceptions.py
+++ /dev/null
@@ -1,31 +0,0 @@
-class UnpackException(Exception):
-    pass
-
-
-class BufferFull(UnpackException):
-    pass
-
-
-class OutOfData(UnpackException):
-    pass
-
-
-class UnpackValueError(UnpackException, ValueError):
-    pass
-
-
-class ExtraData(ValueError):
-    def __init__(self, unpacked, extra):
-        self.unpacked = unpacked
-        self.extra = extra
-
-    def __str__(self):
-        return "unpack(b) received extra data."
-
-
-class PackException(Exception):
-    pass
-
-
-class PackValueError(PackException, ValueError):
-    pass
diff --git a/pandas/io/orc.py b/pandas/io/orc.py
new file mode 100644
index 0000000000000..bbefe447cb7fe
--- /dev/null
+++ b/pandas/io/orc.py
@@ -0,0 +1,57 @@
+""" orc compat """
+
+import distutils
+from typing import TYPE_CHECKING, List, Optional
+
+from pandas._typing import FilePathOrBuffer
+
+from pandas.io.common import get_filepath_or_buffer
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+
+def read_orc(
+    path: FilePathOrBuffer, columns: Optional[List[str]] = None, **kwargs,
+) -> "DataFrame":
+    """
+    Load an ORC object from the file path, returning a DataFrame.
+
+    .. versionadded:: 1.0.0
+
+    Parameters
+    ----------
+    path : str, path object or file-like object
+        Any valid string path is acceptable. The string could be a URL. Valid
+        URL schemes include http, ftp, s3, and file. For file URLs, a host is
+        expected. A local file could be:
+        ``file://localhost/path/to/table.orc``.
+
+        If you want to pass in a path object, pandas accepts any
+        ``os.PathLike``.
+
+        By file-like object, we refer to objects with a ``read()`` method,
+        such as a file handler (e.g. via builtin ``open`` function)
+        or ``StringIO``.
+    columns : list, default None
+        If not None, only these columns will be read from the file.
+    **kwargs
+        Any additional kwargs are passed to pyarrow.
+
+    Returns
+    -------
+    DataFrame
+    """
+
+    # we require a newer version of pyarrow than we support for parquet
+    import pyarrow
+
+    if distutils.version.LooseVersion(pyarrow.__version__) < "0.13.0":
+        raise ImportError("pyarrow must be >= 0.13.0 for read_orc")
+
+    import pyarrow.orc
+
+    path, _, _, _ = get_filepath_or_buffer(path)
+    orc_file = pyarrow.orc.ORCFile(path)
+    result = orc_file.read(columns=columns, **kwargs).to_pandas()
+    return result
diff --git a/pandas/io/packers.py b/pandas/io/packers.py
deleted file mode 100644
index ad47ba23b9221..0000000000000
--- a/pandas/io/packers.py
+++ /dev/null
@@ -1,890 +0,0 @@
-"""
-Msgpack serializer support for reading and writing pandas data structures
-to disk
-
-portions of msgpack_numpy package, by Lev Givon were incorporated
-into this module (and tests_packers.py)
-
-License
-=======
-
-Copyright (c) 2013, Lev Givon.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-* Neither the name of Lev Givon nor the names of any
-  contributors may be used to endorse or promote products derived
-  from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-from datetime import date, datetime, timedelta
-from io import BytesIO
-import os
-import warnings
-
-from dateutil.parser import parse
-import numpy as np
-
-from pandas.compat._optional import import_optional_dependency
-from pandas.errors import PerformanceWarning
-from pandas.util._move import (
-    BadMove as _BadMove,
-    move_into_mutable_buffer as _move_into_mutable_buffer,
-)
-
-from pandas.core.dtypes.common import (
-    is_categorical_dtype,
-    is_datetime64tz_dtype,
-    is_object_dtype,
-    needs_i8_conversion,
-    pandas_dtype,
-)
-
-from pandas import (  # noqa:F401
-    Categorical,
-    CategoricalIndex,
-    DataFrame,
-    DatetimeIndex,
-    Float64Index,
-    Index,
-    Int64Index,
-    Interval,
-    IntervalIndex,
-    MultiIndex,
-    NaT,
-    Period,
-    PeriodIndex,
-    RangeIndex,
-    Series,
-    TimedeltaIndex,
-    Timestamp,
-)
-from pandas.core import internals
-from pandas.core.arrays import DatetimeArray, IntervalArray, PeriodArray
-from pandas.core.arrays.sparse import BlockIndex, IntIndex
-from pandas.core.generic import NDFrame
-from pandas.core.internals import BlockManager, _safe_reshape, make_block
-from pandas.core.sparse.api import SparseDataFrame, SparseSeries
-
-from pandas.io.common import _stringify_path, get_filepath_or_buffer
-from pandas.io.msgpack import ExtType, Packer as _Packer, Unpacker as _Unpacker
-
-# until we can pass this into our conversion functions,
-# this is pretty hacky
-compressor = None
-
-
-def to_msgpack(path_or_buf, *args, **kwargs):
-    """
-    msgpack (serialize) object to input file path
-
-    .. deprecated:: 0.25.0
-
-    to_msgpack is deprecated and will be removed in a future version.
-    It is recommended to use pyarrow for on-the-wire transmission of
-    pandas objects.
-
-    Parameters
-    ----------
-    path_or_buf : string File path, buffer-like, or None
-                  if None, return generated bytes
-    args : an object or objects to serialize
-    encoding : encoding for unicode objects
-    append : boolean whether to append to an existing msgpack
-             (default is False)
-    compress : type of compressor (zlib or blosc), default to None (no
-               compression)
-    """
-    warnings.warn(
-        "to_msgpack is deprecated and will be removed in a "
-        "future version.\n"
-        "It is recommended to use pyarrow for on-the-wire "
-        "transmission of pandas objects.",
-        FutureWarning,
-        stacklevel=3,
-    )
-
-    global compressor
-    compressor = kwargs.pop("compress", None)
-    append = kwargs.pop("append", None)
-    if append:
-        mode = "a+b"
-    else:
-        mode = "wb"
-
-    def writer(fh):
-        for a in args:
-            fh.write(pack(a, **kwargs))
-
-    path_or_buf = _stringify_path(path_or_buf)
-    if isinstance(path_or_buf, str):
-        try:
-            with open(path_or_buf, mode) as fh:
-                writer(fh)
-        except FileNotFoundError:
-            msg = "File b'{}' does not exist".format(path_or_buf)
-            raise FileNotFoundError(msg)
-    elif path_or_buf is None:
-        buf = BytesIO()
-        writer(buf)
-        return buf.getvalue()
-    else:
-        writer(path_or_buf)
-
-
-def read_msgpack(path_or_buf, encoding="utf-8", iterator=False, **kwargs):
-    """
-    Load msgpack pandas object from the specified
-    file path.
-
-    .. deprecated:: 0.25.0
-
-    read_msgpack is deprecated and will be removed in a future version.
-    It is recommended to use pyarrow for on-the-wire transmission of
-    pandas objects.
-
-    Parameters
-    ----------
-    path_or_buf : str, path object or file-like object
-        Any valid string path is acceptable. The string could be a URL. Valid
-        URL schemes include http, ftp, s3, and file. For file URLs, a host is
-        expected.
-
-        If you want to pass in a path object, pandas accepts any
-        ``os.PathLike``.
-
-        By file-like object, we refer to objects with a ``read()`` method,
-        such as a file handler (e.g. via builtin ``open`` function) or
-        ``StringIO``.
-    encoding : Encoding for decoding msgpack str type
-    iterator : boolean, if True, return an iterator to the unpacker
-               (default is False)
-
-    Returns
-    -------
-    obj : same type as object stored in file
-
-    Notes
-    -----
-    read_msgpack is only guaranteed to be backwards compatible to pandas
-    0.20.3.
-    """
-    warnings.warn(
-        "The read_msgpack is deprecated and will be removed in a "
-        "future version.\n"
-        "It is recommended to use pyarrow for on-the-wire "
-        "transmission of pandas objects.",
-        FutureWarning,
-        stacklevel=3,
-    )
-
-    path_or_buf, _, _, should_close = get_filepath_or_buffer(path_or_buf)
-    if iterator:
-        return Iterator(path_or_buf)
-
-    def read(fh):
-        unpacked_obj = list(unpack(fh, encoding=encoding, **kwargs))
-        if len(unpacked_obj) == 1:
-            return unpacked_obj[0]
-
-        if should_close:
-            try:
-                path_or_buf.close()
-            except IOError:
-                pass
-        return unpacked_obj
-
-    # see if we have an actual file
-    if isinstance(path_or_buf, str):
-        try:
-            with open(path_or_buf, "rb") as fh:
-                return read(fh)
-        except FileNotFoundError:
-            msg = "File b'{}' does not exist".format(path_or_buf)
-            raise FileNotFoundError(msg)
-
-    if isinstance(path_or_buf, bytes):
-        # treat as a binary-like
-        fh = None
-        try:
-            fh = BytesIO(path_or_buf)
-            return read(fh)
-        finally:
-            if fh is not None:
-                fh.close()
-    elif hasattr(path_or_buf, "read") and callable(path_or_buf.read):
-        # treat as a buffer like
-        return read(path_or_buf)
-
-    raise ValueError("path_or_buf needs to be a string file path or file-like")
-
-
-dtype_dict = {
-    21: np.dtype("M8[ns]"),
-    "datetime64[ns]": np.dtype("M8[ns]"),
-    "datetime64[us]": np.dtype("M8[us]"),
-    22: np.dtype("m8[ns]"),
-    "timedelta64[ns]": np.dtype("m8[ns]"),
-    "timedelta64[us]": np.dtype("m8[us]"),
-    # this is platform int, which we need to remap to np.int64
-    # for compat on windows platforms
-    7: np.dtype("int64"),
-    "category": "category",
-}
-
-
-def dtype_for(t):
-    """ return my dtype mapping, whether number or name """
-    if t in dtype_dict:
-        return dtype_dict[t]
-    return np.typeDict.get(t, t)
-
-
-c2f_dict = {"complex": np.float64, "complex128": np.float64, "complex64": np.float32}
-
-# windows (32 bit) compat
-if hasattr(np, "float128"):
-    c2f_dict["complex256"] = np.float128
-
-
-def c2f(r, i, ctype_name):
-    """
-    Convert strings to complex number instance with specified numpy type.
-    """
-
-    ftype = c2f_dict[ctype_name]
-    return np.typeDict[ctype_name](ftype(r) + 1j * ftype(i))
-
-
-def convert(values):
-    """ convert the numpy values to a list """
-
-    dtype = values.dtype
-
-    if is_categorical_dtype(values):
-        return values
-
-    elif is_object_dtype(dtype):
-        return values.ravel().tolist()
-
-    if needs_i8_conversion(dtype):
-        values = values.view("i8")
-    v = values.ravel()
-
-    if compressor == "zlib":
-        zlib = import_optional_dependency(
-            "zlib", extra="zlib is required when `compress='zlib'`."
-        )
-
-        # return string arrays like they are
-        if dtype == np.object_:
-            return v.tolist()
-
-        # convert to a bytes array
-        v = v.tostring()
-        return ExtType(0, zlib.compress(v))
-
-    elif compressor == "blosc":
-        blosc = import_optional_dependency(
-            "blosc", extra="zlib is required when `compress='blosc'`."
-        )
-
-        # return string arrays like they are
-        if dtype == np.object_:
-            return v.tolist()
-
-        # convert to a bytes array
-        v = v.tostring()
-        return ExtType(0, blosc.compress(v, typesize=dtype.itemsize))
-
-    # ndarray (on original dtype)
-    return ExtType(0, v.tostring())
-
-
-def unconvert(values, dtype, compress=None):
-
-    as_is_ext = isinstance(values, ExtType) and values.code == 0
-
-    if as_is_ext:
-        values = values.data
-
-    if is_categorical_dtype(dtype):
-        return values
-
-    elif is_object_dtype(dtype):
-        return np.array(values, dtype=object)
-
-    dtype = pandas_dtype(dtype).base
-
-    if not as_is_ext:
-        values = values.encode("latin1")
-
-    if compress:
-        if compress == "zlib":
-            zlib = import_optional_dependency(
-                "zlib", extra="zlib is required when `compress='zlib'`."
-            )
-            decompress = zlib.decompress
-        elif compress == "blosc":
-            blosc = import_optional_dependency(
-                "blosc", extra="zlib is required when `compress='blosc'`."
-            )
-            decompress = blosc.decompress
-        else:
-            raise ValueError("compress must be one of 'zlib' or 'blosc'")
-
-        try:
-            return np.frombuffer(
-                _move_into_mutable_buffer(decompress(values)), dtype=dtype
-            )
-        except _BadMove as e:
-            # Pull the decompressed data off of the `_BadMove` exception.
-            # We don't just store this in the locals because we want to
-            # minimize the risk of giving users access to a `bytes` object
-            # whose data is also given to a mutable buffer.
-            values = e.args[0]
-            if len(values) > 1:
-                # The empty string and single characters are memoized in many
-                # string creating functions in the capi. This case should not
-                # warn even though we need to make a copy because we are only
-                # copying at most 1 byte.
-                warnings.warn(
-                    "copying data after decompressing; this may mean that"
-                    " decompress is caching its result",
-                    PerformanceWarning,
-                )
-                # fall through to copying `np.fromstring`
-
-    # Copy the bytes into a numpy array.
-    buf = np.frombuffer(values, dtype=dtype)
-    buf = buf.copy()  # required to not mutate the original data
-    buf.flags.writeable = True
-    return buf
-
-
-def encode(obj):
-    """
-    Data encoder
-    """
-    tobj = type(obj)
-    if isinstance(obj, Index):
-        if isinstance(obj, RangeIndex):
-            return {
-                "typ": "range_index",
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "start": obj._range.start,
-                "stop": obj._range.stop,
-                "step": obj._range.step,
-            }
-        elif isinstance(obj, PeriodIndex):
-            return {
-                "typ": "period_index",
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "freq": getattr(obj, "freqstr", None),
-                "dtype": obj.dtype.name,
-                "data": convert(obj.asi8),
-                "compress": compressor,
-            }
-        elif isinstance(obj, DatetimeIndex):
-            tz = getattr(obj, "tz", None)
-
-            # store tz info and data as UTC
-            if tz is not None:
-                tz = tz.zone
-                obj = obj.tz_convert("UTC")
-            return {
-                "typ": "datetime_index",
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "dtype": obj.dtype.name,
-                "data": convert(obj.asi8),
-                "freq": getattr(obj, "freqstr", None),
-                "tz": tz,
-                "compress": compressor,
-            }
-        elif isinstance(obj, (IntervalIndex, IntervalArray)):
-            if isinstance(obj, IntervalIndex):
-                typ = "interval_index"
-            else:
-                typ = "interval_array"
-            return {
-                "typ": typ,
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "left": getattr(obj, "left", None),
-                "right": getattr(obj, "right", None),
-                "closed": getattr(obj, "closed", None),
-            }
-        elif isinstance(obj, MultiIndex):
-            return {
-                "typ": "multi_index",
-                "klass": obj.__class__.__name__,
-                "names": getattr(obj, "names", None),
-                "dtype": obj.dtype.name,
-                "data": convert(obj.values),
-                "compress": compressor,
-            }
-        else:
-            return {
-                "typ": "index",
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "dtype": obj.dtype.name,
-                "data": convert(obj.values),
-                "compress": compressor,
-            }
-
-    elif isinstance(obj, Categorical):
-        return {
-            "typ": "category",
-            "klass": obj.__class__.__name__,
-            "name": getattr(obj, "name", None),
-            "codes": obj.codes,
-            "categories": obj.categories,
-            "ordered": obj.ordered,
-            "compress": compressor,
-        }
-
-    elif isinstance(obj, Series):
-        if isinstance(obj, SparseSeries):
-            raise NotImplementedError("msgpack sparse series is not implemented")
-            # d = {'typ': 'sparse_series',
-            #     'klass': obj.__class__.__name__,
-            #     'dtype': obj.dtype.name,
-            #     'index': obj.index,
-            #     'sp_index': obj.sp_index,
-            #     'sp_values': convert(obj.sp_values),
-            #     'compress': compressor}
-            # for f in ['name', 'fill_value', 'kind']:
-            #    d[f] = getattr(obj, f, None)
-            # return d
-        else:
-            return {
-                "typ": "series",
-                "klass": obj.__class__.__name__,
-                "name": getattr(obj, "name", None),
-                "index": obj.index,
-                "dtype": obj.dtype.name,
-                "data": convert(obj.values),
-                "compress": compressor,
-            }
-    elif issubclass(tobj, NDFrame):
-        if isinstance(obj, SparseDataFrame):
-            raise NotImplementedError("msgpack sparse frame is not implemented")
-            # d = {'typ': 'sparse_dataframe',
-            #     'klass': obj.__class__.__name__,
-            #     'columns': obj.columns}
-            # for f in ['default_fill_value', 'default_kind']:
-            #    d[f] = getattr(obj, f, None)
-            # d['data'] = dict([(name, ss)
-            #                 for name, ss in obj.items()])
-            # return d
-        else:
-
-            data = obj._data
-            if not data.is_consolidated():
-                data = data.consolidate()
-
-            # the block manager
-            return {
-                "typ": "block_manager",
-                "klass": obj.__class__.__name__,
-                "axes": data.axes,
-                "blocks": [
-                    {
-                        "locs": b.mgr_locs.as_array,
-                        "values": convert(b.values),
-                        "shape": b.values.shape,
-                        "dtype": b.dtype.name,
-                        "klass": b.__class__.__name__,
-                        "compress": compressor,
-                    }
-                    for b in data.blocks
-                ],
-            }
-
-    elif (
-        isinstance(obj, (datetime, date, np.datetime64, timedelta, np.timedelta64))
-        or obj is NaT
-    ):
-        if isinstance(obj, Timestamp):
-            tz = obj.tzinfo
-            if tz is not None:
-                tz = tz.zone
-            freq = obj.freq
-            if freq is not None:
-                freq = freq.freqstr
-            return {"typ": "timestamp", "value": obj.value, "freq": freq, "tz": tz}
-        if obj is NaT:
-            return {"typ": "nat"}
-        elif isinstance(obj, np.timedelta64):
-            return {"typ": "timedelta64", "data": obj.view("i8")}
-        elif isinstance(obj, timedelta):
-            return {
-                "typ": "timedelta",
-                "data": (obj.days, obj.seconds, obj.microseconds),
-            }
-        elif isinstance(obj, np.datetime64):
-            return {"typ": "datetime64", "data": str(obj)}
-        elif isinstance(obj, datetime):
-            return {"typ": "datetime", "data": obj.isoformat()}
-        elif isinstance(obj, date):
-            return {"typ": "date", "data": obj.isoformat()}
-        raise Exception("cannot encode this datetimelike object: {obj}".format(obj=obj))
-    elif isinstance(obj, Period):
-        return {"typ": "period", "ordinal": obj.ordinal, "freq": obj.freqstr}
-    elif isinstance(obj, Interval):
-        return {
-            "typ": "interval",
-            "left": obj.left,
-            "right": obj.right,
-            "closed": obj.closed,
-        }
-    elif isinstance(obj, BlockIndex):
-        return {
-            "typ": "block_index",
-            "klass": obj.__class__.__name__,
-            "blocs": obj.blocs,
-            "blengths": obj.blengths,
-            "length": obj.length,
-        }
-    elif isinstance(obj, IntIndex):
-        return {
-            "typ": "int_index",
-            "klass": obj.__class__.__name__,
-            "indices": obj.indices,
-            "length": obj.length,
-        }
-    elif isinstance(obj, np.ndarray):
-        return {
-            "typ": "ndarray",
-            "shape": obj.shape,
-            "ndim": obj.ndim,
-            "dtype": obj.dtype.name,
-            "data": convert(obj),
-            "compress": compressor,
-        }
-    elif isinstance(obj, np.number):
-        if np.iscomplexobj(obj):
-            return {
-                "typ": "np_scalar",
-                "sub_typ": "np_complex",
-                "dtype": obj.dtype.name,
-                "real": np.real(obj).__repr__(),
-                "imag": np.imag(obj).__repr__(),
-            }
-        else:
-            return {"typ": "np_scalar", "dtype": obj.dtype.name, "data": obj.__repr__()}
-    elif isinstance(obj, complex):
-        return {
-            "typ": "np_complex",
-            "real": np.real(obj).__repr__(),
-            "imag": np.imag(obj).__repr__(),
-        }
-
-    return obj
-
-
-def decode(obj):
-    """
-    Decoder for deserializing numpy data types.
-    """
-
-    typ = obj.get("typ")
-    if typ is None:
-        return obj
-    elif typ == "timestamp":
-        freq = obj["freq"] if "freq" in obj else obj["offset"]
-        return Timestamp(obj["value"], tz=obj["tz"], freq=freq)
-    elif typ == "nat":
-        return NaT
-    elif typ == "period":
-        return Period(ordinal=obj["ordinal"], freq=obj["freq"])
-    elif typ == "index":
-        dtype = dtype_for(obj["dtype"])
-        data = unconvert(obj["data"], dtype, obj.get("compress"))
-        return Index(data, dtype=dtype, name=obj["name"])
-    elif typ == "range_index":
-        return RangeIndex(obj["start"], obj["stop"], obj["step"], name=obj["name"])
-    elif typ == "multi_index":
-        dtype = dtype_for(obj["dtype"])
-        data = unconvert(obj["data"], dtype, obj.get("compress"))
-        data = [tuple(x) for x in data]
-        return MultiIndex.from_tuples(data, names=obj["names"])
-    elif typ == "period_index":
-        data = unconvert(obj["data"], np.int64, obj.get("compress"))
-        d = dict(name=obj["name"], freq=obj["freq"])
-        freq = d.pop("freq", None)
-        return PeriodIndex(PeriodArray(data, freq), **d)
-
-    elif typ == "datetime_index":
-        data = unconvert(obj["data"], np.int64, obj.get("compress"))
-        d = dict(name=obj["name"], freq=obj["freq"])
-        result = DatetimeIndex(data, **d)
-        tz = obj["tz"]
-
-        # reverse tz conversion
-        if tz is not None:
-            result = result.tz_localize("UTC").tz_convert(tz)
-        return result
-
-    elif typ in ("interval_index", "interval_array"):
-        return globals()[obj["klass"]].from_arrays(
-            obj["left"], obj["right"], obj["closed"], name=obj["name"]
-        )
-    elif typ == "category":
-        from_codes = globals()[obj["klass"]].from_codes
-        return from_codes(
-            codes=obj["codes"], categories=obj["categories"], ordered=obj["ordered"]
-        )
-
-    elif typ == "interval":
-        return Interval(obj["left"], obj["right"], obj["closed"])
-    elif typ == "series":
-        dtype = dtype_for(obj["dtype"])
-        index = obj["index"]
-        data = unconvert(obj["data"], dtype, obj["compress"])
-        return Series(data, index=index, dtype=dtype, name=obj["name"])
-
-    elif typ == "block_manager":
-        axes = obj["axes"]
-
-        def create_block(b):
-            values = _safe_reshape(
-                unconvert(b["values"], dtype_for(b["dtype"]), b["compress"]), b["shape"]
-            )
-
-            # locs handles duplicate column names, and should be used instead
-            # of items; see GH 9618
-            if "locs" in b:
-                placement = b["locs"]
-            else:
-                placement = axes[0].get_indexer(b["items"])
-
-            if is_datetime64tz_dtype(b["dtype"]):
-                assert isinstance(values, np.ndarray), type(values)
-                assert values.dtype == "M8[ns]", values.dtype
-                values = DatetimeArray(values, dtype=b["dtype"])
-
-            return make_block(
-                values=values,
-                klass=getattr(internals, b["klass"]),
-                placement=placement,
-                dtype=b["dtype"],
-            )
-
-        blocks = [create_block(b) for b in obj["blocks"]]
-        return globals()[obj["klass"]](BlockManager(blocks, axes))
-    elif typ == "datetime":
-        return parse(obj["data"])
-    elif typ == "datetime64":
-        return np.datetime64(parse(obj["data"]))
-    elif typ == "date":
-        return parse(obj["data"]).date()
-    elif typ == "timedelta":
-        return timedelta(*obj["data"])
-    elif typ == "timedelta64":
-        return np.timedelta64(int(obj["data"]))
-    # elif typ == 'sparse_series':
-    #    dtype = dtype_for(obj['dtype'])
-    #    return SparseSeries(
-    #        unconvert(obj['sp_values'], dtype, obj['compress']),
-    #        sparse_index=obj['sp_index'], index=obj['index'],
-    #        fill_value=obj['fill_value'], kind=obj['kind'], name=obj['name'])
-    # elif typ == 'sparse_dataframe':
-    #    return SparseDataFrame(
-    #        obj['data'], columns=obj['columns'],
-    #        default_fill_value=obj['default_fill_value'],
-    #        default_kind=obj['default_kind']
-    #    )
-    elif typ == "block_index":
-        return globals()[obj["klass"]](obj["length"], obj["blocs"], obj["blengths"])
-    elif typ == "int_index":
-        return globals()[obj["klass"]](obj["length"], obj["indices"])
-    elif typ == "ndarray":
-        return unconvert(
-            obj["data"], np.typeDict[obj["dtype"]], obj.get("compress")
-        ).reshape(obj["shape"])
-    elif typ == "np_scalar":
-        if obj.get("sub_typ") == "np_complex":
-            return c2f(obj["real"], obj["imag"], obj["dtype"])
-        else:
-            dtype = dtype_for(obj["dtype"])
-            try:
-                return dtype(obj["data"])
-            except (ValueError, TypeError):
-                return dtype.type(obj["data"])
-    elif typ == "np_complex":
-        return complex(obj["real"] + "+" + obj["imag"] + "j")
-    elif isinstance(obj, (dict, list, set)):
-        return obj
-    else:
-        return obj
-
-
-def pack(
-    o,
-    default=encode,
-    encoding="utf-8",
-    unicode_errors="strict",
-    use_single_float=False,
-    autoreset=1,
-    use_bin_type=1,
-):
-    """
-    Pack an object and return the packed bytes.
-    """
-
-    return Packer(
-        default=default,
-        encoding=encoding,
-        unicode_errors=unicode_errors,
-        use_single_float=use_single_float,
-        autoreset=autoreset,
-        use_bin_type=use_bin_type,
-    ).pack(o)
-
-
-def unpack(
-    packed,
-    object_hook=decode,
-    list_hook=None,
-    use_list=False,
-    encoding="utf-8",
-    unicode_errors="strict",
-    object_pairs_hook=None,
-    max_buffer_size=0,
-    ext_hook=ExtType,
-):
-    """
-    Unpack a packed object, return an iterator
-    Note: packed lists will be returned as tuples
-    """
-
-    return Unpacker(
-        packed,
-        object_hook=object_hook,
-        list_hook=list_hook,
-        use_list=use_list,
-        encoding=encoding,
-        unicode_errors=unicode_errors,
-        object_pairs_hook=object_pairs_hook,
-        max_buffer_size=max_buffer_size,
-        ext_hook=ext_hook,
-    )
-
-
-class Packer(_Packer):
-    def __init__(
-        self,
-        default=encode,
-        encoding="utf-8",
-        unicode_errors="strict",
-        use_single_float=False,
-        autoreset=1,
-        use_bin_type=1,
-    ):
-        super().__init__(
-            default=default,
-            encoding=encoding,
-            unicode_errors=unicode_errors,
-            use_single_float=use_single_float,
-            autoreset=autoreset,
-            use_bin_type=use_bin_type,
-        )
-
-
-class Unpacker(_Unpacker):
-    def __init__(
-        self,
-        file_like=None,
-        read_size=0,
-        use_list=False,
-        object_hook=decode,
-        object_pairs_hook=None,
-        list_hook=None,
-        encoding="utf-8",
-        unicode_errors="strict",
-        max_buffer_size=0,
-        ext_hook=ExtType,
-    ):
-        super().__init__(
-            file_like=file_like,
-            read_size=read_size,
-            use_list=use_list,
-            object_hook=object_hook,
-            object_pairs_hook=object_pairs_hook,
-            list_hook=list_hook,
-            encoding=encoding,
-            unicode_errors=unicode_errors,
-            max_buffer_size=max_buffer_size,
-            ext_hook=ext_hook,
-        )
-
-
-class Iterator:
-    """ manage the unpacking iteration,
-        close the file on completion """
-
-    def __init__(self, path, **kwargs):
-        self.path = path
-        self.kwargs = kwargs
-
-    def __iter__(self):
-
-        needs_closing = True
-        try:
-
-            # see if we have an actual file
-            if isinstance(self.path, str):
-
-                try:
-                    path_exists = os.path.exists(self.path)
-                except TypeError:
-                    path_exists = False
-
-                if path_exists:
-                    fh = open(self.path, "rb")
-                else:
-                    fh = BytesIO(self.path)
-
-            else:
-
-                if not hasattr(self.path, "read"):
-                    fh = BytesIO(self.path)
-
-                else:
-
-                    # a file-like
-                    needs_closing = False
-                    fh = self.path
-
-            unpacker = unpack(fh)
-            for o in unpacker:
-                yield o
-        finally:
-            if needs_closing:
-                fh.close()
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index 334fb592cb0c1..926635062d853 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -1,5 +1,6 @@
 """ parquet compat """
 
+from typing import Any, Dict, Optional
 from warnings import catch_warnings
 
 from pandas.compat._optional import import_optional_dependency
@@ -7,10 +8,10 @@
 
 from pandas import DataFrame, get_option
 
-from pandas.io.common import get_filepath_or_buffer, is_s3_url
+from pandas.io.common import get_filepath_or_buffer, is_gcs_url, is_s3_url
 
 
-def get_engine(engine):
+def get_engine(engine: str) -> "BaseImpl":
     """ return our implementation """
 
     if engine == "auto":
@@ -31,31 +32,26 @@ def get_engine(engine):
         raise ImportError(
             "Unable to find a usable engine; "
             "tried using: 'pyarrow', 'fastparquet'.\n"
-            "pyarrow or fastparquet is required for parquet "
-            "support"
+            "pyarrow or fastparquet is required for parquet support"
         )
 
-    if engine not in ["pyarrow", "fastparquet"]:
-        raise ValueError("engine must be one of 'pyarrow', 'fastparquet'")
-
     if engine == "pyarrow":
         return PyArrowImpl()
     elif engine == "fastparquet":
         return FastParquetImpl()
 
+    raise ValueError("engine must be one of 'pyarrow', 'fastparquet'")
 
-class BaseImpl:
-
-    api = None  # module
 
+class BaseImpl:
     @staticmethod
-    def validate_dataframe(df):
+    def validate_dataframe(df: DataFrame):
 
         if not isinstance(df, DataFrame):
             raise ValueError("to_parquet only supports IO with DataFrames")
 
         # must have value column names (strings only)
-        if df.columns.inferred_type not in {"string", "unicode", "empty"}:
+        if df.columns.inferred_type not in {"string", "empty"}:
             raise ValueError("parquet must have string column names")
 
         # index level names must be strings
@@ -65,7 +61,7 @@ def validate_dataframe(df):
         if not valid_names:
             raise ValueError("Index level names must be strings")
 
-    def write(self, df, path, compression, **kwargs):
+    def write(self, df: DataFrame, path, compression, **kwargs):
         raise AbstractMethodError(self)
 
     def read(self, path, columns=None, **kwargs):
@@ -74,47 +70,44 @@ def read(self, path, columns=None, **kwargs):
 
 class PyArrowImpl(BaseImpl):
     def __init__(self):
-        pyarrow = import_optional_dependency(
+        import_optional_dependency(
             "pyarrow", extra="pyarrow is required for parquet support."
         )
         import pyarrow.parquet
 
+        # import utils to register the pyarrow extension types
+        import pandas.core.arrays._arrow_utils  # noqa
+
         self.api = pyarrow
 
     def write(
         self,
-        df,
+        df: DataFrame,
         path,
         compression="snappy",
-        coerce_timestamps="ms",
-        index=None,
+        index: Optional[bool] = None,
         partition_cols=None,
-        **kwargs
+        **kwargs,
     ):
         self.validate_dataframe(df)
         path, _, _, _ = get_filepath_or_buffer(path, mode="wb")
 
-        if index is None:
-            from_pandas_kwargs = {}
-        else:
-            from_pandas_kwargs = {"preserve_index": index}
+        from_pandas_kwargs: Dict[str, Any] = {"schema": kwargs.pop("schema", None)}
+        if index is not None:
+            from_pandas_kwargs["preserve_index"] = index
+
         table = self.api.Table.from_pandas(df, **from_pandas_kwargs)
         if partition_cols is not None:
             self.api.parquet.write_to_dataset(
                 table,
                 path,
                 compression=compression,
-                coerce_timestamps=coerce_timestamps,
                 partition_cols=partition_cols,
-                **kwargs
+                **kwargs,
             )
         else:
             self.api.parquet.write_table(
-                table,
-                path,
-                compression=compression,
-                coerce_timestamps=coerce_timestamps,
-                **kwargs
+                table, path, compression=compression, **kwargs,
             )
 
     def read(self, path, columns=None, **kwargs):
@@ -140,7 +133,13 @@ def __init__(self):
         self.api = fastparquet
 
     def write(
-        self, df, path, compression="snappy", index=None, partition_cols=None, **kwargs
+        self,
+        df: DataFrame,
+        path,
+        compression="snappy",
+        index=None,
+        partition_cols=None,
+        **kwargs,
     ):
         self.validate_dataframe(df)
         # thriftpy/protocol/compact.py:339:
@@ -150,8 +149,7 @@ def write(
         if "partition_on" in kwargs and partition_cols is not None:
             raise ValueError(
                 "Cannot use both partition_on and "
-                "partition_cols. Use partition_cols for "
-                "partitioning data"
+                "partition_cols. Use partition_cols for partitioning data"
             )
         elif "partition_on" in kwargs:
             partition_cols = kwargs.pop("partition_on")
@@ -159,12 +157,12 @@ def write(
         if partition_cols is not None:
             kwargs["file_scheme"] = "hive"
 
-        if is_s3_url(path):
-            # path is s3:// so we need to open the s3file in 'wb' mode.
+        if is_s3_url(path) or is_gcs_url(path):
+            # if path is s3:// or gs:// we need to open the file in 'wb' mode.
             # TODO: Support 'ab'
 
             path, _, _, _ = get_filepath_or_buffer(path, mode="wb")
-            # And pass the opened s3file to the fastparquet internal impl.
+            # And pass the opened file to the fastparquet internal impl.
             kwargs["open_with"] = lambda path, _: path
         else:
             path, _, _, _ = get_filepath_or_buffer(path)
@@ -176,7 +174,7 @@ def write(
                 compression=compression,
                 write_index=index,
                 partition_on=partition_cols,
-                **kwargs
+                **kwargs,
             )
 
     def read(self, path, columns=None, **kwargs):
@@ -199,19 +197,20 @@ def read(self, path, columns=None, **kwargs):
 
 
 def to_parquet(
-    df,
+    df: DataFrame,
     path,
-    engine="auto",
+    engine: str = "auto",
     compression="snappy",
-    index=None,
+    index: Optional[bool] = None,
     partition_cols=None,
-    **kwargs
+    **kwargs,
 ):
     """
     Write a DataFrame to the parquet format.
 
     Parameters
     ----------
+    df : DataFrame
     path : str
         File path or Root Directory path. Will be used as Root Directory path
         while writing a partitioned dataset.
@@ -227,12 +226,16 @@ def to_parquet(
         Name of the compression to use. Use ``None`` for no compression.
     index : bool, default None
         If ``True``, include the dataframe's index(es) in the file output. If
-        ``False``, they will not be written to the file. If ``None``, the
-        engine's default behavior will be used.
+        ``False``, they will not be written to the file.
+        If ``None``, similar to ``True`` the dataframe's index(es)
+        will be saved. However, instead of being saved as values,
+        the RangeIndex will be stored as a range in the metadata so it
+        doesn't require much space and is faster. Other indexes will
+        be included as columns in the file output.
 
         .. versionadded:: 0.24.0
 
-    partition_cols : list, optional, default None
+    partition_cols : str or list, optional, default None
         Column names by which to partition the dataset
         Columns are partitioned in the order they are given
 
@@ -241,6 +244,8 @@ def to_parquet(
     kwargs
         Additional keyword arguments passed to the engine
     """
+    if isinstance(partition_cols, str):
+        partition_cols = [partition_cols]
     impl = get_engine(engine)
     return impl.write(
         df,
@@ -248,11 +253,11 @@ def to_parquet(
         compression=compression,
         index=index,
         partition_cols=partition_cols,
-        **kwargs
+        **kwargs,
     )
 
 
-def read_parquet(path, engine="auto", columns=None, **kwargs):
+def read_parquet(path, engine: str = "auto", columns=None, **kwargs):
     """
     Load a parquet object from the file path, returning a DataFrame.
 
@@ -265,6 +270,10 @@ def read_parquet(path, engine="auto", columns=None, **kwargs):
         URL schemes include http, ftp, s3, and file. For file URLs, a host is
         expected. A local file could be:
         ``file://localhost/path/to/table.parquet``.
+        A file URL can also be a path to a directory that contains multiple
+        partitioned parquet files. Both pyarrow and fastparquet support
+        paths to directories as well as file URLs. A directory path could be:
+        ``file://localhost/path/to/tables``
 
         If you want to pass in a path object, pandas accepts any
         ``os.PathLike``.
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 72f1adf0aad3d..5f754aa07a5e1 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -2,10 +2,10 @@
 Module contains tools for processing files into DataFrames or other objects
 """
 
-from collections import defaultdict
+from collections import abc, defaultdict
 import csv
 import datetime
-from io import StringIO
+from io import BufferedIOBase, RawIOBase, StringIO, TextIOWrapper
 import re
 import sys
 from textwrap import fill
@@ -17,7 +17,9 @@
 import pandas._libs.lib as lib
 import pandas._libs.ops as libops
 import pandas._libs.parsers as parsers
+from pandas._libs.parsers import STR_NA_VALUES
 from pandas._libs.tslibs import parsing
+from pandas._typing import FilePathOrBuffer
 from pandas.errors import (
     AbstractMethodError,
     EmptyDataError,
@@ -34,6 +36,7 @@
     is_categorical_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
+    is_file_like,
     is_float,
     is_integer,
     is_integer_dtype,
@@ -46,24 +49,23 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype
 from pandas.core.dtypes.missing import isna
 
-from pandas._typing import FilePathOrBuffer
 from pandas.core import algorithms
 from pandas.core.arrays import Categorical
 from pandas.core.frame import DataFrame
-from pandas.core.index import Index, MultiIndex, RangeIndex, ensure_index_from_sequences
+from pandas.core.indexes.api import (
+    Index,
+    MultiIndex,
+    RangeIndex,
+    ensure_index_from_sequences,
+)
 from pandas.core.series import Series
 from pandas.core.tools import datetimes as tools
 
 from pandas.io.common import (
-    _NA_VALUES,
-    BaseIterator,
-    UnicodeReader,
-    UTF8Recoder,
-    _get_handle,
-    _infer_compression,
-    _validate_header_arg,
     get_filepath_or_buffer,
-    is_file_like,
+    get_handle,
+    infer_compression,
+    validate_header_arg,
 )
 from pandas.io.date_converters import generic_parser
 
@@ -81,13 +83,13 @@
 into chunks.
 
 Additional help can be found in the online docs for
-`IO Tools <http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
+`IO Tools <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
 
 Parameters
 ----------
 filepath_or_buffer : str, path object or file-like object
     Any valid string path is acceptable. The string could be a URL. Valid
-    URL schemes include http, ftp, s3, and file. For file URLs, a host is
+    URL schemes include http, ftp, s3, gs, and file. For file URLs, a host is
     expected. A local file could be: file://localhost/path/to/table.csv.
 
     If you want to pass in a path object, pandas accepts any ``os.PathLike``.
@@ -119,9 +121,9 @@
     ``skip_blank_lines=True``, so ``header=0`` denotes the first line of
     data rather than the first line of the file.
 names : array-like, optional
-    List of column names to use. If file contains no header row, then you
-    should explicitly pass ``header=None``. Duplicates in this list are not
-    allowed.
+    List of column names to use. If the file contains a header row,
+    then you should explicitly pass ``header=0`` to override the column names.
+    Duplicates in this list are not allowed.
 index_col : int, str, sequence of int / str, or False, default ``None``
   Column(s) to use as the row labels of the ``DataFrame``, either given as
   string name or column index. If a sequence of int / str is given, a
@@ -190,7 +192,7 @@
     Additional strings to recognize as NA/NaN. If dict passed, specific
     per-column NA values.  By default the following values are interpreted as
     NaN: '"""
-    + fill("', '".join(sorted(_NA_VALUES)), 70, subsequent_indent="    ")
+    + fill("', '".join(sorted(STR_NA_VALUES)), 70, subsequent_indent="    ")
     + """'.
 keep_default_na : bool, default True
     Whether or not to include the default NaN values when parsing the data.
@@ -257,7 +259,7 @@
     arguments.
 dayfirst : bool, default False
     DD/MM format dates, international and European format.
-cache_dates : boolean, default True
+cache_dates : bool, default True
     If True, use a cache of unique, converted dates to apply the datetime
     conversion. May produce significant speed-up when parsing duplicate
     date strings, especially ones with timezone offsets.
@@ -269,7 +271,7 @@
 chunksize : int, optional
     Return TextFileReader object for iteration.
     See the `IO Tools docs
-    <http://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_
+    <https://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_
     for more information on ``iterator`` and ``chunksize``.
 compression : {{'infer', 'gzip', 'bz2', 'zip', 'xz', None}}, default 'infer'
     For on-the-fly decompression of on-disk data. If 'infer' and
@@ -351,7 +353,7 @@
 
 See Also
 --------
-to_csv : Write DataFrame to a comma-separated values (csv) file.
+DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
 read_csv : Read a comma-separated values (csv) file into DataFrame.
 read_fwf : Read a table of fixed-width formatted lines into DataFrame.
 
@@ -378,9 +380,7 @@ def _validate_integer(name, val, min_val=0):
     min_val : int
         Minimum allowed value (val < min_val will result in a ValueError)
     """
-    msg = "'{name:s}' must be an integer >={min_val:d}".format(
-        name=name, min_val=min_val
-    )
+    msg = f"'{name:s}' must be an integer >={min_val:d}"
 
     if val is not None:
         if is_float(val):
@@ -395,25 +395,22 @@ def _validate_integer(name, val, min_val=0):
 
 def _validate_names(names):
     """
-    Check if the `names` parameter contains duplicates.
-
-    If duplicates are found, we issue a warning before returning.
+    Raise ValueError if the `names` parameter contains duplicates.
 
     Parameters
     ----------
     names : array-like or None
         An array containing a list of the names used for the output DataFrame.
 
-    Returns
-    -------
-    names : array-like or None
-        The original `names` parameter.
+    Raises
+    ------
+    ValueError
+        If names are not unique.
     """
 
     if names is not None:
         if len(names) != len(set(names)):
             raise ValueError("Duplicate names are not allowed.")
-    return names
 
 
 def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
@@ -424,7 +421,7 @@ def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
         kwds["encoding"] = encoding
 
     compression = kwds.get("compression", "infer")
-    compression = _infer_compression(filepath_or_buffer, compression)
+    compression = infer_compression(filepath_or_buffer, compression)
 
     # TODO: get_filepath_or_buffer could return
     # Union[FilePathOrBuffer, s3fs.S3File, gcsfs.GCSFile]
@@ -491,7 +488,7 @@ def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
     "cache_dates": True,
     "thousands": None,
     "comment": None,
-    "decimal": b".",
+    "decimal": ".",
     # 'engine': 'c',
     "parse_dates": False,
     "keep_date_col": False,
@@ -525,8 +522,8 @@ def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
 _c_unsupported = {"skipfooter"}
 _python_unsupported = {"low_memory", "float_precision"}
 
-_deprecated_defaults = {}  # type: Dict[str, Any]
-_deprecated_args = set()  # type: Set[str]
+_deprecated_defaults: Dict[str, Any] = {}
+_deprecated_args: Set[str] = set()
 
 
 def _make_parser_function(name, default_sep=","):
@@ -571,7 +568,7 @@ def parser_f(
         # Quoting, Compression, and File Format
         compression="infer",
         thousands=None,
-        decimal=b".",
+        decimal: str = ".",
         lineterminator=None,
         quotechar='"',
         quoting=csv.QUOTE_MINIMAL,
@@ -614,9 +611,8 @@ def parser_f(
 
         if delim_whitespace and delimiter != default_sep:
             raise ValueError(
-                "Specified a delimiter with both sep and"
-                " delim_whitespace=True; you can only"
-                " specify one."
+                "Specified a delimiter with both sep and "
+                "delim_whitespace=True; you can only specify one."
             )
 
         if engine is not None:
@@ -687,7 +683,7 @@ def parser_f(
 read_csv = Appender(
     _doc_read_csv_and_table.format(
         func_name="read_csv",
-        summary=("Read a comma-separated values (csv) file into DataFrame."),
+        summary="Read a comma-separated values (csv) file into DataFrame.",
         _default_sep="','",
     )
 )(read_csv)
@@ -707,9 +703,8 @@ def read_fwf(
     colspecs="infer",
     widths=None,
     infer_nrows=100,
-    **kwds
+    **kwds,
 ):
-
     r"""
     Read a table of fixed-width formatted lines into DataFrame.
 
@@ -717,7 +712,7 @@ def read_fwf(
     into chunks.
 
     Additional help can be found in the `online docs for IO Tools
-    <http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
 
     Parameters
     ----------
@@ -758,7 +753,7 @@ def read_fwf(
 
     See Also
     --------
-    to_csv : Write DataFrame to a comma-separated values (csv) file.
+    DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
     read_csv : Read a comma-separated values (csv) file into DataFrame.
 
     Examples
@@ -785,7 +780,7 @@ def read_fwf(
     return _read(filepath_or_buffer, kwds)
 
 
-class TextFileReader(BaseIterator):
+class TextFileReader(abc.Iterator):
     """
 
     Passed dialect overrides any of the related parser options
@@ -822,11 +817,7 @@ def __init__(self, f, engine=None, **kwds):
                 try:
                     dialect_val = getattr(dialect, param)
                 except AttributeError:
-                    raise ValueError(
-                        "Invalid dialect '{dialect}' provided".format(
-                            dialect=kwds["dialect"]
-                        )
-                    )
+                    raise ValueError(f"Invalid dialect {kwds['dialect']} provided")
                 parser_default = _parser_defaults[param]
                 provided = kwds.get(param, parser_default)
 
@@ -838,11 +829,9 @@ def __init__(self, f, engine=None, **kwds):
                 # even if it conflicts with the dialect (gh-23761).
                 if provided != parser_default and provided != dialect_val:
                     msg = (
-                        "Conflicting values for '{param}': '{val}' was "
-                        "provided, but the dialect specifies '{diaval}'. "
-                        "Using the dialect-specified value.".format(
-                            param=param, val=provided, diaval=dialect_val
-                        )
+                        f"Conflicting values for '{param}': '{provided}' was "
+                        f"provided, but the dialect specifies '{dialect_val}'. "
+                        "Using the dialect-specified value."
                     )
 
                     # Annoying corner case for not warning about
@@ -916,8 +905,8 @@ def _get_options_with_defaults(self, engine):
                         pass
                     else:
                         raise ValueError(
-                            "The %r option is not supported with the"
-                            " %r engine" % (argname, engine)
+                            f"The {repr(argname)} option is not supported with the "
+                            f"{repr(engine)} engine"
                         )
             else:
                 value = _deprecated_defaults.get(argname, default)
@@ -964,8 +953,8 @@ def _clean_options(self, options, engine):
         if sep is None and not delim_whitespace:
             if engine == "c":
                 fallback_reason = (
-                    "the 'c' engine does not support"
-                    " sep=None with delim_whitespace=False"
+                    "the 'c' engine does not support "
+                    "sep=None with delim_whitespace=False"
                 )
                 engine = "python"
         elif sep is not None and len(sep) > 1:
@@ -975,10 +964,9 @@ def _clean_options(self, options, engine):
             elif engine not in ("python", "python-fwf"):
                 # wait until regex engine integrated
                 fallback_reason = (
-                    "the 'c' engine does not support"
-                    " regex separators (separators > 1 char and"
-                    r" different from '\s+' are"
-                    " interpreted as regex)"
+                    "the 'c' engine does not support "
+                    "regex separators (separators > 1 char and "
+                    r"different from '\s+' are interpreted as regex)"
                 )
                 engine = "python"
         elif delim_whitespace:
@@ -993,9 +981,9 @@ def _clean_options(self, options, engine):
                 encodeable = False
             if not encodeable and engine not in ("python", "python-fwf"):
                 fallback_reason = (
-                    "the separator encoded in {encoding}"
-                    " is > 1 char long, and the 'c' engine"
-                    " does not support such separators".format(encoding=encoding)
+                    f"the separator encoded in {encoding} "
+                    "is > 1 char long, and the 'c' engine "
+                    "does not support such separators"
                 )
                 engine = "python"
 
@@ -1009,8 +997,7 @@ def _clean_options(self, options, engine):
                 fallback_reason = (
                     "ord(quotechar) > 127, meaning the "
                     "quotechar is larger than one byte, "
-                    "and the 'c' engine does not support "
-                    "such quotechars"
+                    "and the 'c' engine does not support such quotechars"
                 )
                 engine = "python"
 
@@ -1024,22 +1011,20 @@ def _clean_options(self, options, engine):
         if "python" in engine:
             for arg in _python_unsupported:
                 if fallback_reason and result[arg] != _c_parser_defaults[arg]:
-                    msg = (
-                        "Falling back to the 'python' engine because"
-                        " {reason}, but this causes {option!r} to be"
-                        " ignored as it is not supported by the 'python'"
-                        " engine."
-                    ).format(reason=fallback_reason, option=arg)
-                    raise ValueError(msg)
+                    raise ValueError(
+                        "Falling back to the 'python' engine because "
+                        f"{fallback_reason}, but this causes {repr(arg)} to be "
+                        "ignored as it is not supported by the 'python' engine."
+                    )
                 del result[arg]
 
         if fallback_reason:
             warnings.warn(
                 (
-                    "Falling back to the 'python' engine because"
-                    " {0}; you can avoid this warning by specifying"
-                    " engine='python'."
-                ).format(fallback_reason),
+                    "Falling back to the 'python' engine because "
+                    f"{fallback_reason}; you can avoid this warning by specifying "
+                    "engine='python'."
+                ),
                 ParserWarning,
                 stacklevel=5,
             )
@@ -1050,7 +1035,7 @@ def _clean_options(self, options, engine):
         na_values = options["na_values"]
         skiprows = options["skiprows"]
 
-        _validate_header_arg(options["header"])
+        validate_header_arg(options["header"])
 
         depr_warning = ""
 
@@ -1059,8 +1044,8 @@ def _clean_options(self, options, engine):
             depr_default = _deprecated_defaults[arg]
 
             msg = (
-                "The '{arg}' argument has been deprecated "
-                "and will be removed in a future version.".format(arg=arg)
+                f"The {repr(arg)} argument has been deprecated and will be "
+                "removed in a future version."
             )
 
             if result.get(arg, depr_default) != depr_default:
@@ -1084,9 +1069,8 @@ def _clean_options(self, options, engine):
         if converters is not None:
             if not isinstance(converters, dict):
                 raise TypeError(
-                    "Type converters must be a dict or"
-                    " subclass, input was "
-                    "a {0!r}".format(type(converters).__name__)
+                    "Type converters must be a dict or subclass, "
+                    f"input was a {type(converters).__name__}"
                 )
         else:
             converters = {}
@@ -1131,9 +1115,8 @@ def _make_engine(self, engine="c"):
                 klass = FixedWidthFieldParser
             else:
                 raise ValueError(
-                    "Unknown engine: {engine} (valid options are"
-                    ' "c", "python", or'
-                    ' "python-fwf")'.format(engine=engine)
+                    f"Unknown engine: {engine} (valid options "
+                    'are "c", "python", or "python-fwf")'
                 )
             self._engine = klass(self.f, **self.options)
 
@@ -1242,8 +1225,7 @@ def _validate_usecols_names(usecols, names):
     missing = [c for c in usecols if c not in names]
     if len(missing) > 0:
         raise ValueError(
-            "Usecols do not match columns, "
-            "columns expected but not found: {missing}".format(missing=missing)
+            f"Usecols do not match columns, columns expected but not found: {missing}"
         )
 
     return usecols
@@ -1321,7 +1303,7 @@ def _validate_usecols_arg(usecols):
 
         usecols_dtype = lib.infer_dtype(usecols, skipna=False)
 
-        if usecols_dtype not in ("empty", "integer", "string", "unicode"):
+        if usecols_dtype not in ("empty", "integer", "string"):
             raise ValueError(msg)
 
         usecols = set(usecols)
@@ -1337,8 +1319,7 @@ def _validate_parse_dates_arg(parse_dates):
     that is the case.
     """
     msg = (
-        "Only booleans, lists, and "
-        "dictionaries are accepted "
+        "Only booleans, lists, and dictionaries are accepted "
         "for the 'parse_dates' parameter"
     )
 
@@ -1417,17 +1398,21 @@ def __init__(self, kwds):
                         "index_col must only contain row numbers "
                         "when specifying a multi-index header"
                     )
-
-        # GH 16338
-        elif self.header is not None and not is_integer(self.header):
-            raise ValueError("header must be integer or list of integers")
-
-        # GH 27779
-        elif self.header is not None and self.header < 0:
-            raise ValueError(
-                "Passing negative integer to header is invalid. "
-                "For no header, use header=None instead"
-            )
+        elif self.header is not None:
+            # GH 27394
+            if self.prefix is not None:
+                raise ValueError(
+                    "Argument prefix must be None if argument header is not None"
+                )
+            # GH 16338
+            elif not is_integer(self.header):
+                raise ValueError("header must be integer or list of integers")
+            # GH 27779
+            elif self.header < 0:
+                raise ValueError(
+                    "Passing negative integer to header is invalid. "
+                    "For no header, use header=None instead"
+                )
 
         self._name_processed = False
 
@@ -1471,8 +1456,10 @@ def _should_parse_dates(self, i):
     def _extract_multi_indexer_columns(
         self, header, index_names, col_names, passed_names=False
     ):
-        """ extract and return the names, index_names, col_names
-            header is a list-of-lists returned from the parsers """
+        """
+        extract and return the names, index_names, col_names
+        header is a list-of-lists returned from the parsers
+        """
         if len(header) < 2:
             return header[0], index_names, col_names, passed_names
 
@@ -1544,11 +1531,9 @@ def _maybe_dedup_names(self, names):
                     counts[col] = cur_count + 1
 
                     if is_potential_mi:
-                        col = col[:-1] + (
-                            "{column}.{count}".format(column=col[-1], count=cur_count),
-                        )
+                        col = col[:-1] + (f"{col[-1]}.{cur_count}",)
                     else:
-                        col = "{column}.{count}".format(column=col, count=cur_count)
+                        col = f"{col}.{cur_count}"
                     cur_count = counts[col]
 
                 names[i] = col
@@ -1594,7 +1579,7 @@ def _get_simple_index(self, data, columns):
         def ix(col):
             if not isinstance(col, str):
                 return col
-            raise ValueError("Index {col} invalid".format(col=col))
+            raise ValueError(f"Index {col} invalid")
 
         to_remove = []
         index = []
@@ -1605,7 +1590,7 @@ def ix(col):
 
         # remove index items from content and columns, don't pop in
         # loop
-        for i in reversed(sorted(to_remove)):
+        for i in sorted(to_remove, reverse=True):
             data.pop(i)
             if not self._implicit_index:
                 columns.pop(i)
@@ -1618,11 +1603,7 @@ def _get_name(icol):
                 return icol
 
             if col_names is None:
-                raise ValueError(
-                    ("Must supply column order to use {icol!s} as index").format(
-                        icol=icol
-                    )
-                )
+                raise ValueError(f"Must supply column order to use {icol!s} as index")
 
             for i, c in enumerate(col_names):
                 if i == icol:
@@ -1637,7 +1618,7 @@ def _get_name(icol):
 
         # remove index items from content and columns, don't pop in
         # loop
-        for c in reversed(sorted(to_remove)):
+        for c in sorted(to_remove, reverse=True):
             data.pop(c)
             col_names.remove(c)
 
@@ -1698,9 +1679,8 @@ def _convert_to_ndarrays(
                     warnings.warn(
                         (
                             "Both a converter and dtype were specified "
-                            "for column {0} - only the converter will "
-                            "be used"
-                        ).format(c),
+                            f"for column {c} - only the converter will be used"
+                        ),
                         ParserWarning,
                         stacklevel=7,
                     )
@@ -1738,10 +1718,7 @@ def _convert_to_ndarrays(
                             and not is_categorical_dtype(cast_type)
                             and na_count > 0
                         ):
-                            raise ValueError(
-                                "Bool column has NA values in "
-                                "column {column}".format(column=c)
-                            )
+                            raise ValueError(f"Bool column has NA values in column {c}")
                     except (AttributeError, TypeError):
                         # invalid input to is_bool_dtype
                         pass
@@ -1749,11 +1726,7 @@ def _convert_to_ndarrays(
 
             result[c] = cvals
             if verbose and na_count:
-                print(
-                    "Filled {count} NA values in column {c!s}".format(
-                        count=na_count, c=c
-                    )
-                )
+                print(f"Filled {na_count} NA values in column {c!s}")
         return result
 
     def _infer_types(self, values, na_values, try_num_bool=True):
@@ -1782,14 +1755,17 @@ def _infer_types(self, values, na_values, try_num_bool=True):
                 np.putmask(values, mask, np.nan)
             return values, na_count
 
-        if try_num_bool:
+        if try_num_bool and is_object_dtype(values.dtype):
+            # exclude e.g DatetimeIndex here
             try:
                 result = lib.maybe_convert_numeric(values, na_values, False)
-                na_count = isna(result).sum()
-            except Exception:
+            except (ValueError, TypeError):
+                # e.g. encountering datetime string gets ValueError
+                #  TypeError can be raised in floatify
                 result = values
-                if values.dtype == np.object_:
-                    na_count = parsers.sanitize_objects(result, na_values, False)
+                na_count = parsers.sanitize_objects(result, na_values, False)
+            else:
+                na_count = isna(result).sum()
         else:
             result = values
             if values.dtype == np.object_:
@@ -1847,9 +1823,8 @@ def _cast_types(self, values, cast_type, column):
                 return array_type._from_sequence_of_strings(values, dtype=cast_type)
             except NotImplementedError:
                 raise NotImplementedError(
-                    "Extension Array: {ea} must implement "
-                    "_from_sequence_of_strings in order "
-                    "to be used in parser methods".format(ea=array_type)
+                    f"Extension Array: {array_type} must implement "
+                    "_from_sequence_of_strings in order to be used in parser methods"
                 )
 
         else:
@@ -1857,8 +1832,7 @@ def _cast_types(self, values, cast_type, column):
                 values = astype_nansafe(values, cast_type, copy=True, skipna=True)
             except ValueError:
                 raise ValueError(
-                    "Unable to convert column {column} to type "
-                    "{cast_type}".format(column=column, cast_type=cast_type)
+                    f"Unable to convert column {column} to type {cast_type}"
                 )
         return values
 
@@ -1890,12 +1864,18 @@ def __init__(self, src, **kwds):
 
         ParserBase.__init__(self, kwds)
 
-        if kwds.get("compression") is None and "utf-16" in (kwds.get("encoding") or ""):
-            # if source is utf-16 plain text, convert source to utf-8
+        encoding = kwds.get("encoding")
+
+        if kwds.get("compression") is None and encoding:
             if isinstance(src, str):
                 src = open(src, "rb")
                 self.handles.append(src)
-            src = UTF8Recoder(src, kwds["encoding"])
+
+            # Handle the file object with universal line mode enabled.
+            # We will handle the newline character ourselves later on.
+            if isinstance(src, (BufferedIOBase, RawIOBase)):
+                src = TextIOWrapper(src, encoding=encoding, newline="")
+
             kwds["encoding"] = "utf-8"
 
         # #2442
@@ -1915,7 +1895,12 @@ def __init__(self, src, **kwds):
         else:
             if len(self._reader.header) > 1:
                 # we have a multi index in the columns
-                self.names, self.index_names, self.col_names, passed_names = self._extract_multi_indexer_columns(  # noqa: E501
+                (
+                    self.names,
+                    self.index_names,
+                    self.col_names,
+                    passed_names,
+                ) = self._extract_multi_indexer_columns(
                     self._reader.header, self.index_names, self.col_names, passed_names
                 )
             else:
@@ -1924,8 +1909,7 @@ def __init__(self, src, **kwds):
         if self.names is None:
             if self.prefix:
                 self.names = [
-                    "{prefix}{i}".format(prefix=self.prefix, i=i)
-                    for i in range(self._reader.table_width)
+                    f"{self.prefix}{i}" for i in range(self._reader.table_width)
                 ]
             else:
                 self.names = list(range(self._reader.table_width))
@@ -2222,8 +2206,6 @@ class PythonParser(ParserBase):
     def __init__(self, f, **kwds):
         """
         Workhorse function for processing nested list into DataFrame
-
-        Should be replaced by np.genfromtxt eventually?
         """
         ParserBase.__init__(self, kwds)
 
@@ -2276,7 +2258,7 @@ def __init__(self, f, **kwds):
         self.comment = kwds["comment"]
         self._comment_lines = []
 
-        f, handles = _get_handle(
+        f, handles = get_handle(
             f,
             "r",
             encoding=self.encoding,
@@ -2304,7 +2286,12 @@ def __init__(self, f, **kwds):
         # The original set is stored in self.original_columns.
         if len(self.columns) > 1:
             # we are processing a multi index column
-            self.columns, self.index_names, self.col_names, _ = self._extract_multi_indexer_columns(  # noqa: E501
+            (
+                self.columns,
+                self.index_names,
+                self.col_names,
+                _,
+            ) = self._extract_multi_indexer_columns(
                 self.columns, self.index_names, self.col_names
             )
             # Update list of original names to include all indices.
@@ -2335,15 +2322,9 @@ def __init__(self, f, **kwds):
             raise ValueError("Only length-1 decimal markers supported")
 
         if self.thousands is None:
-            self.nonnum = re.compile(
-                r"[^-^0-9^{decimal}]+".format(decimal=self.decimal)
-            )
+            self.nonnum = re.compile(fr"[^-^0-9^{self.decimal}]+")
         else:
-            self.nonnum = re.compile(
-                r"[^-^0-9^{thousands}^{decimal}]+".format(
-                    thousands=self.thousands, decimal=self.decimal
-                )
-            )
+            self.nonnum = re.compile(fr"[^-^0-9^{self.thousands}^{self.decimal}]+")
 
     def _set_no_thousands_columns(self):
         # Create a set of column ids that are not to be stripped of thousands
@@ -2419,23 +2400,13 @@ class MyDialect(csv.Dialect):
                 self.line_pos += 1
                 sniffed = csv.Sniffer().sniff(line)
                 dia.delimiter = sniffed.delimiter
-                if self.encoding is not None:
-                    self.buf.extend(
-                        list(
-                            UnicodeReader(
-                                StringIO(line), dialect=dia, encoding=self.encoding
-                            )
-                        )
-                    )
-                else:
-                    self.buf.extend(list(csv.reader(StringIO(line), dialect=dia)))
 
-            if self.encoding is not None:
-                reader = UnicodeReader(
-                    f, dialect=dia, encoding=self.encoding, strict=True
-                )
-            else:
-                reader = csv.reader(f, dialect=dia, strict=True)
+                # Note: self.encoding is irrelevant here
+                line_rdr = csv.reader(StringIO(line), dialect=dia)
+                self.buf.extend(list(line_rdr))
+
+            # Note: self.encoding is irrelevant here
+            reader = csv.reader(f, dialect=dia, strict=True)
 
         else:
 
@@ -2518,7 +2489,7 @@ def get_chunk(self, size=None):
     def _convert_data(self, data):
         # apply converters
         def _clean_mapping(mapping):
-            "converts col numbers to names"
+            """converts col numbers to names"""
             clean = {}
             for col, v in mapping.items():
                 if isinstance(col, int) and col not in self.orig_names:
@@ -2589,8 +2560,8 @@ def _infer_columns(self):
                 except StopIteration:
                     if self.line_pos < hr:
                         raise ValueError(
-                            "Passed header={hr} but only {pos} lines in "
-                            "file".format(hr=hr, pos=(self.line_pos + 1))
+                            f"Passed header={hr} but only {self.line_pos + 1} lines in "
+                            "file"
                         )
 
                     # We have an empty file, so check
@@ -2613,11 +2584,9 @@ def _infer_columns(self):
                 for i, c in enumerate(line):
                     if c == "":
                         if have_mi_columns:
-                            col_name = "Unnamed: {i}_level_{level}".format(
-                                i=i, level=level
-                            )
+                            col_name = f"Unnamed: {i}_level_{level}"
                         else:
-                            col_name = "Unnamed: {i}".format(i=i)
+                            col_name = f"Unnamed: {i}"
 
                         this_unnamed_cols.append(i)
                         this_columns.append(col_name)
@@ -2632,7 +2601,7 @@ def _infer_columns(self):
 
                         while cur_count > 0:
                             counts[col] = cur_count + 1
-                            col = "{column}.{count}".format(column=col, count=cur_count)
+                            col = f"{col}.{cur_count}"
                             cur_count = counts[col]
 
                         this_columns[i] = col
@@ -2697,12 +2666,7 @@ def _infer_columns(self):
 
             if not names:
                 if self.prefix:
-                    columns = [
-                        [
-                            "{prefix}{idx}".format(prefix=self.prefix, idx=i)
-                            for i in range(ncols)
-                        ]
-                    ]
+                    columns = [[f"{self.prefix}{i}" for i in range(ncols)]]
                 else:
                     columns = [list(range(ncols))]
                 columns = self._handle_usecols(columns, columns[0])
@@ -2904,7 +2868,7 @@ def _alert_malformed(self, msg, row_num):
         if self.error_bad_lines:
             raise ParserError(msg)
         elif self.warn_bad_lines:
-            base = "Skipping line {row_num}: ".format(row_num=row_num)
+            base = f"Skipping line {row_num}: "
             sys.stderr.write(base + msg + "\n")
 
     def _next_iter_line(self, row_num):
@@ -2926,7 +2890,7 @@ def _next_iter_line(self, row_num):
             if self.warn_bad_lines or self.error_bad_lines:
                 msg = str(e)
 
-                if "NULL byte" in msg:
+                if "NULL byte" in msg or "line contains NUL" in msg:
                     msg = (
                         "NULL byte detected. This byte "
                         "cannot be processed in Python's "
@@ -3128,10 +3092,8 @@ def _rows_to_cols(self, content):
 
             for row_num, actual_len in bad_lines:
                 msg = (
-                    "Expected {col_len} fields in line {line}, saw "
-                    "{length}".format(
-                        col_len=col_len, line=(row_num + 1), length=actual_len
-                    )
+                    f"Expected {col_len} fields in line {row_num + 1}, saw "
+                    f"{actual_len}"
                 )
                 if (
                     self.delimiter
@@ -3329,9 +3291,7 @@ def _isindex(colspec):
                     converter, colspec, data_dict, orig_names
                 )
                 if new_name in data_dict:
-                    raise ValueError(
-                        "New date column already in dict {name}".format(name=new_name)
-                    )
+                    raise ValueError(f"New date column already in dict {new_name}")
                 new_data[new_name] = col
                 new_cols.append(new_name)
                 date_cols.update(old_names)
@@ -3340,9 +3300,7 @@ def _isindex(colspec):
         # dict of new name to column list
         for new_name, colspec in parse_spec.items():
             if new_name in data_dict:
-                raise ValueError(
-                    "Date column {name} already in dict".format(name=new_name)
-                )
+                raise ValueError(f"Date column {new_name} already in dict")
 
             _, col, old_names = _try_convert_dates(
                 converter, colspec, data_dict, orig_names
@@ -3386,7 +3344,7 @@ def _clean_na_values(na_values, keep_default_na=True):
 
     if na_values is None:
         if keep_default_na:
-            na_values = _NA_VALUES
+            na_values = STR_NA_VALUES
         else:
             na_values = set()
         na_fvalues = set()
@@ -3403,7 +3361,7 @@ def _clean_na_values(na_values, keep_default_na=True):
                 v = [v]
 
             if keep_default_na:
-                v = set(v) | _NA_VALUES
+                v = set(v) | STR_NA_VALUES
 
             na_values[k] = v
         na_fvalues = {k: _floatify_na_values(v) for k, v in na_values.items()}
@@ -3412,7 +3370,7 @@ def _clean_na_values(na_values, keep_default_na=True):
             na_values = [na_values]
         na_values = _stringify_na_values(na_values)
         if keep_default_na:
-            na_values = na_values | _NA_VALUES
+            na_values = na_values | STR_NA_VALUES
 
         na_fvalues = _floatify_na_values(na_values)
 
@@ -3480,7 +3438,7 @@ def _get_empty_meta(columns, index_col, index_names, dtype=None):
     # 2) index_names (column names)
     #
     # Both must be non-null to ensure a successful construction. Otherwise,
-    # we have to create a generic emtpy Index.
+    # we have to create a generic empty Index.
     if (index_col is None or index_col is False) or index_names is None:
         index = Index([])
     else:
@@ -3521,7 +3479,7 @@ def _stringify_na_values(na_values):
             # we are like 999 here
             if v == int(v):
                 v = int(v)
-                result.append("{value}.0".format(value=v))
+                result.append(f"{v}.0")
                 result.append(str(v))
 
             result.append(v)
@@ -3563,7 +3521,7 @@ def _get_na_values(col, na_values, na_fvalues, keep_default_na):
             return na_values[col], na_fvalues[col]
         else:
             if keep_default_na:
-                return _NA_VALUES, set()
+                return STR_NA_VALUES, set()
 
             return set(), set()
     else:
@@ -3581,7 +3539,7 @@ def _get_col_names(colspec, columns):
     return colnames
 
 
-class FixedWidthReader(BaseIterator):
+class FixedWidthReader(abc.Iterator):
     """
     A reader of fixed-width lines.
     """
@@ -3601,7 +3559,7 @@ def __init__(self, f, colspecs, delimiter, comment, skiprows=None, infer_nrows=1
         if not isinstance(self.colspecs, (tuple, list)):
             raise TypeError(
                 "column specifications must be a list or tuple, "
-                "input was a %r" % type(colspecs).__name__
+                f"input was a {type(colspecs).__name__}"
             )
 
         for colspec in self.colspecs:
diff --git a/pandas/io/pickle.py b/pandas/io/pickle.py
index 4b9a52a1fb8f3..e51f24b551f31 100644
--- a/pandas/io/pickle.py
+++ b/pandas/io/pickle.py
@@ -1,16 +1,20 @@
 """ pickle compat """
-from io import BytesIO
 import pickle
+from typing import Any, Optional
 import warnings
 
-from numpy.lib.format import read_array
-
+from pandas._typing import FilePathOrBuffer
 from pandas.compat import pickle_compat as pc
 
-from pandas.io.common import _get_handle, _stringify_path
+from pandas.io.common import get_filepath_or_buffer, get_handle
 
 
-def to_pickle(obj, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL):
+def to_pickle(
+    obj: Any,
+    filepath_or_buffer: FilePathOrBuffer,
+    compression: Optional[str] = "infer",
+    protocol: int = pickle.HIGHEST_PROTOCOL,
+):
     """
     Pickle (serialize) object to file.
 
@@ -18,13 +22,17 @@ def to_pickle(obj, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL):
     ----------
     obj : any object
         Any python object.
-    path : str
-        File path where the pickled object will be stored.
-    compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
-        A string representing the compression to use in the output file. By
-        default, infers from the file extension in specified path.
+    filepath_or_buffer : str, path object or file-like object
+        File path, URL, or buffer where the pickled object will be stored.
 
-        .. versionadded:: 0.20.0
+        .. versionchanged:: 1.0.0
+           Accept URL. URL has to be of S3 or GCS.
+
+    compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
+        If 'infer' and 'path_or_url' is path-like, then detect compression from
+        the following extensions: '.gz', '.bz2', '.zip', or '.xz' (otherwise no
+        compression) If 'infer' and 'path_or_url' is not path-like, then use
+        None (= no decompression).
     protocol : int
         Int which indicates which protocol should be used by the pickler,
         default HIGHEST_PROTOCOL (see [1], paragraph 12.1.2). The possible
@@ -68,8 +76,12 @@ def to_pickle(obj, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL):
     >>> import os
     >>> os.remove("./dummy.pkl")
     """
-    path = _stringify_path(path)
-    f, fh = _get_handle(path, "wb", compression=compression, is_text=False)
+    fp_or_buf, _, compression, should_close = get_filepath_or_buffer(
+        filepath_or_buffer, compression=compression, mode="wb"
+    )
+    if not isinstance(fp_or_buf, str) and compression == "infer":
+        compression = None
+    f, fh = get_handle(fp_or_buf, "wb", compression=compression, is_text=False)
     if protocol < 0:
         protocol = pickle.HIGHEST_PROTOCOL
     try:
@@ -78,9 +90,16 @@ def to_pickle(obj, path, compression="infer", protocol=pickle.HIGHEST_PROTOCOL):
         f.close()
         for _f in fh:
             _f.close()
+        if should_close:
+            try:
+                fp_or_buf.close()
+            except ValueError:
+                pass
 
 
-def read_pickle(path, compression="infer"):
+def read_pickle(
+    filepath_or_buffer: FilePathOrBuffer, compression: Optional[str] = "infer"
+):
     """
     Load pickled pandas object (or any object) from file.
 
@@ -91,15 +110,17 @@ def read_pickle(path, compression="infer"):
 
     Parameters
     ----------
-    path : str
-        File path where the pickled object will be loaded.
-    compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
-        For on-the-fly decompression of on-disk data. If 'infer', then use
-        gzip, bz2, xz or zip if path ends in '.gz', '.bz2', '.xz',
-        or '.zip' respectively, and no decompression otherwise.
-        Set to None for no decompression.
+    filepath_or_buffer : str, path object or file-like object
+        File path, URL, or buffer where the pickled object will be loaded from.
+
+        .. versionchanged:: 1.0.0
+           Accept URL. URL is not limited to S3 and GCS.
 
-        .. versionadded:: 0.20.0
+    compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
+        If 'infer' and 'path_or_url' is path-like, then detect compression from
+        the following extensions: '.gz', '.bz2', '.zip', or '.xz' (otherwise no
+        compression) If 'infer' and 'path_or_url' is not path-like, then use
+        None (= no decompression).
 
     Returns
     -------
@@ -141,33 +162,37 @@ def read_pickle(path, compression="infer"):
     >>> import os
     >>> os.remove("./dummy.pkl")
     """
-    path = _stringify_path(path)
-    f, fh = _get_handle(path, "rb", compression=compression, is_text=False)
-
-    # 1) try standard libary Pickle
+    fp_or_buf, _, compression, should_close = get_filepath_or_buffer(
+        filepath_or_buffer, compression=compression
+    )
+    if not isinstance(fp_or_buf, str) and compression == "infer":
+        compression = None
+    f, fh = get_handle(fp_or_buf, "rb", compression=compression, is_text=False)
+
+    # 1) try standard library Pickle
     # 2) try pickle_compat (older pandas version) to handle subclass changes
-    # 3) try pickle_compat with latin1 encoding
+
+    excs_to_catch = (AttributeError, ImportError, ModuleNotFoundError)
 
     try:
         with warnings.catch_warnings(record=True):
             # We want to silence any warnings about, e.g. moved modules.
             warnings.simplefilter("ignore", Warning)
             return pickle.load(f)
-    except Exception:
-        try:
-            return pc.load(f, encoding=None)
-        except Exception:
-            return pc.load(f, encoding="latin1")
+    except excs_to_catch:
+        # e.g.
+        #  "No module named 'pandas.core.sparse.series'"
+        #  "Can't get attribute '__nat_unpickle' on <module 'pandas._libs.tslib"
+        return pc.load(f, encoding=None)
+    except UnicodeDecodeError:
+        # e.g. can occur for files written in py27; see GH#28645
+        return pc.load(f, encoding="latin-1")
     finally:
         f.close()
         for _f in fh:
             _f.close()
-
-
-# compat with sparse pickle / unpickle
-
-
-def _unpickle_array(bytes):
-    arr = read_array(BytesIO(bytes))
-
-    return arr
+        if should_close:
+            try:
+                fp_or_buf.close()
+            except ValueError:
+                pass
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 4f3f639de5cb1..570d1f9a89159 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -4,12 +4,21 @@
 """
 
 import copy
-from datetime import date, datetime
+from datetime import date, tzinfo
 import itertools
 import os
 import re
-import time
-from typing import List, Optional, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Hashable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 import warnings
 
 import numpy as np
@@ -18,18 +27,23 @@
 
 from pandas._libs import lib, writers as libwriters
 from pandas._libs.tslibs import timezones
+from pandas._typing import ArrayLike, FrameOrSeries
 from pandas.compat._optional import import_optional_dependency
 from pandas.errors import PerformanceWarning
+from pandas.util._decorators import cache_readonly
 
 from pandas.core.dtypes.common import (
     ensure_object,
     is_categorical_dtype,
+    is_complex_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
-    is_extension_type,
+    is_extension_array_dtype,
     is_list_like,
+    is_string_dtype,
     is_timedelta64_dtype,
 )
+from pandas.core.dtypes.generic import ABCExtensionArray
 from pandas.core.dtypes.missing import array_equivalent
 
 from pandas import (
@@ -40,23 +54,22 @@
     MultiIndex,
     PeriodIndex,
     Series,
-    SparseDataFrame,
-    SparseSeries,
     TimedeltaIndex,
     concat,
     isna,
-    to_datetime,
 )
-from pandas.core.arrays.categorical import Categorical
-from pandas.core.arrays.sparse import BlockIndex, IntIndex
+from pandas.core.arrays import Categorical, DatetimeArray, PeriodArray
 import pandas.core.common as com
-from pandas.core.computation.pytables import Expr, maybe_expression
-from pandas.core.index import ensure_index
-from pandas.core.internals import BlockManager, _block_shape, make_block
+from pandas.core.computation.pytables import PyTablesExpr, maybe_expression
+from pandas.core.indexes.api import ensure_index
 
-from pandas.io.common import _stringify_path
+from pandas.io.common import stringify_path
 from pandas.io.formats.printing import adjoin, pprint_thing
 
+if TYPE_CHECKING:
+    from tables import File, Node, Col  # noqa:F401
+
+
 # versioning attribute
 _version = "0.15.2"
 
@@ -91,10 +104,10 @@ def _ensure_str(name):
     return name
 
 
-Term = Expr
+Term = PyTablesExpr
 
 
-def _ensure_term(where, scope_level):
+def _ensure_term(where, scope_level: int):
     """
     ensure that the where is a Term or a list of Term
     this makes sure that we are capturing the scope of variables
@@ -163,44 +176,6 @@ class DuplicateWarning(Warning):
 # formats
 _FORMAT_MAP = {"f": "fixed", "fixed": "fixed", "t": "table", "table": "table"}
 
-format_deprecate_doc = """
-the table keyword has been deprecated
-use the format='fixed(f)|table(t)' keyword instead
-  fixed(f) : specifies the Fixed format
-             and is the default for put operations
-  table(t) : specifies the Table format
-             and is the default for append operations
-"""
-
-# map object types
-_TYPE_MAP = {
-    Series: "series",
-    SparseSeries: "sparse_series",
-    DataFrame: "frame",
-    SparseDataFrame: "sparse_frame",
-}
-
-# storer class map
-_STORER_MAP = {
-    "Series": "LegacySeriesFixed",
-    "DataFrame": "LegacyFrameFixed",
-    "DataMatrix": "LegacyFrameFixed",
-    "series": "SeriesFixed",
-    "sparse_series": "SparseSeriesFixed",
-    "frame": "FrameFixed",
-    "sparse_frame": "SparseFrameFixed",
-}
-
-# table class map
-_TABLE_MAP = {
-    "generic_table": "GenericTable",
-    "appendable_series": "AppendableSeriesTable",
-    "appendable_multiseries": "AppendableMultiSeriesTable",
-    "appendable_frame": "AppendableFrameTable",
-    "appendable_multiframe": "AppendableMultiFrameTable",
-    "worm": "WORMTable",
-}
-
 # axes map
 _AXES_MAP = {DataFrame: [0]}
 
@@ -255,22 +230,51 @@ def _tables():
 
 def to_hdf(
     path_or_buf,
-    key,
-    value,
-    mode=None,
-    complevel=None,
-    complib=None,
-    append=None,
-    **kwargs
+    key: str,
+    value: FrameOrSeries,
+    mode: str = "a",
+    complevel: Optional[int] = None,
+    complib: Optional[str] = None,
+    append: bool = False,
+    format: Optional[str] = None,
+    index: bool = True,
+    min_itemsize: Optional[Union[int, Dict[str, int]]] = None,
+    nan_rep=None,
+    dropna: Optional[bool] = None,
+    data_columns: Optional[List[str]] = None,
+    errors: str = "strict",
+    encoding: str = "UTF-8",
 ):
     """ store this object, close it if we opened it """
 
     if append:
-        f = lambda store: store.append(key, value, **kwargs)
+        f = lambda store: store.append(
+            key,
+            value,
+            format=format,
+            index=index,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            dropna=dropna,
+            data_columns=data_columns,
+            errors=errors,
+            encoding=encoding,
+        )
     else:
-        f = lambda store: store.put(key, value, **kwargs)
+        # NB: dropna is not passed to `put`
+        f = lambda store: store.put(
+            key,
+            value,
+            format=format,
+            index=index,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            data_columns=data_columns,
+            errors=errors,
+            encoding=encoding,
+        )
 
-    path_or_buf = _stringify_path(path_or_buf)
+    path_or_buf = stringify_path(path_or_buf)
     if isinstance(path_or_buf, str):
         with HDFStore(
             path_or_buf, mode=mode, complevel=complevel, complib=complib
@@ -280,7 +284,19 @@ def to_hdf(
         f(path_or_buf)
 
 
-def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
+def read_hdf(
+    path_or_buf,
+    key=None,
+    mode: str = "r",
+    errors: str = "strict",
+    where=None,
+    start: Optional[int] = None,
+    stop: Optional[int] = None,
+    columns=None,
+    iterator=False,
+    chunksize: Optional[int] = None,
+    **kwargs,
+):
     """
     Read from the store, close it if we opened it.
 
@@ -308,7 +324,7 @@ def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
     key : object, optional
         The group identifier in the store. Can be omitted if the HDF file
         contains a single pandas object.
-    mode : {'r', 'r+', 'a'}, optional
+    mode : {'r', 'r+', 'a'}, default 'r'
         Mode to use when opening the file. Ignored if path_or_buf is a
         :class:`pandas.HDFStore`. Default is 'r'.
     where : list, optional
@@ -349,12 +365,12 @@ def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
 
     if mode not in ["r", "r+", "a"]:
         raise ValueError(
-            "mode {0} is not allowed while performing a read. "
-            "Allowed modes are r, r+ and a.".format(mode)
+            f"mode {mode} is not allowed while performing a read. "
+            f"Allowed modes are r, r+ and a."
         )
     # grab the scope
-    if "where" in kwargs:
-        kwargs["where"] = _ensure_term(kwargs["where"], scope_level=1)
+    if where is not None:
+        where = _ensure_term(where, scope_level=1)
 
     if isinstance(path_or_buf, HDFStore):
         if not path_or_buf.is_open:
@@ -363,7 +379,7 @@ def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
         store = path_or_buf
         auto_close = False
     else:
-        path_or_buf = _stringify_path(path_or_buf)
+        path_or_buf = stringify_path(path_or_buf)
         if not isinstance(path_or_buf, str):
             raise NotImplementedError(
                 "Support for generic buffers has not been implemented."
@@ -376,11 +392,9 @@ def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
             exists = False
 
         if not exists:
-            raise FileNotFoundError(
-                "File {path} does not exist".format(path=path_or_buf)
-            )
+            raise FileNotFoundError(f"File {path_or_buf} does not exist")
 
-        store = HDFStore(path_or_buf, mode=mode, **kwargs)
+        store = HDFStore(path_or_buf, mode=mode, errors=errors, **kwargs)
         # can't auto open/close if we are using an iterator
         # so delegate to the iterator
         auto_close = True
@@ -399,22 +413,32 @@ def read_hdf(path_or_buf, key=None, mode="r", **kwargs):
             for group_to_check in groups[1:]:
                 if not _is_metadata_of(group_to_check, candidate_only_group):
                     raise ValueError(
-                        "key must be provided when HDF5 file "
-                        "contains multiple datasets."
+                        "key must be provided when HDF5 "
+                        "file contains multiple datasets."
                     )
             key = candidate_only_group._v_pathname
-        return store.select(key, auto_close=auto_close, **kwargs)
+        return store.select(
+            key,
+            where=where,
+            start=start,
+            stop=stop,
+            columns=columns,
+            iterator=iterator,
+            chunksize=chunksize,
+            auto_close=auto_close,
+        )
     except (ValueError, TypeError, KeyError):
-        # if there is an error, close the store
-        try:
-            store.close()
-        except AttributeError:
-            pass
+        if not isinstance(path_or_buf, HDFStore):
+            # if there is an error, close the store if we opened it.
+            try:
+                store.close()
+            except AttributeError:
+                pass
 
         raise
 
 
-def _is_metadata_of(group, parent_group):
+def _is_metadata_of(group: "Node", parent_group: "Node") -> bool:
     """Check if a given group is a metadata group for a given parent_group."""
     if group._v_depth <= parent_group._v_depth:
         return False
@@ -473,8 +497,19 @@ class HDFStore:
     >>> store.close()
     """
 
+    _handle: Optional["File"]
+    _mode: str
+    _complevel: int
+    _fletcher32: bool
+
     def __init__(
-        self, path, mode=None, complevel=None, complib=None, fletcher32=False, **kwargs
+        self,
+        path,
+        mode: str = "a",
+        complevel: Optional[int] = None,
+        complib=None,
+        fletcher32: bool = False,
+        **kwargs,
     ):
 
         if "format" in kwargs:
@@ -484,15 +519,13 @@ def __init__(
 
         if complib is not None and complib not in tables.filters.all_complibs:
             raise ValueError(
-                "complib only supports {libs} compression.".format(
-                    libs=tables.filters.all_complibs
-                )
+                f"complib only supports {tables.filters.all_complibs} compression."
             )
 
         if complib is None and complevel is not None:
             complib = tables.filters.default_complib
 
-        self._path = _stringify_path(path)
+        self._path = stringify_path(path)
         if mode is None:
             mode = "a"
         self._mode = mode
@@ -516,31 +549,30 @@ def root(self):
     def filename(self):
         return self._path
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str):
         return self.get(key)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: str, value):
         self.put(key, value)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: str):
         return self.remove(key)
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str):
         """ allow attribute access to get stores """
         try:
             return self.get(name)
         except (KeyError, ClosedFileError):
             pass
         raise AttributeError(
-            "'{object}' object has no attribute '{name}'".format(
-                object=type(self).__name__, name=name
-            )
+            f"'{type(self).__name__}' object has no attribute '{name}'"
         )
 
-    def __contains__(self, key):
-        """ check for existence of this key
-              can match the exact pathname or the pathnm w/o the leading '/'
-              """
+    def __contains__(self, key: str) -> bool:
+        """
+        check for existence of this key
+        can match the exact pathname or the pathnm w/o the leading '/'
+        """
         node = self.get_node(key)
         if node is not None:
             name = node._v_pathname
@@ -548,13 +580,12 @@ def __contains__(self, key):
                 return True
         return False
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.groups())
 
-    def __repr__(self):
-        return "{type}\nFile path: {path}\n".format(
-            type=type(self), path=pprint_thing(self._path)
-        )
+    def __repr__(self) -> str:
+        pstr = pprint_thing(self._path)
+        return f"{type(self)}\nFile path: {pstr}\n"
 
     def __enter__(self):
         return self
@@ -562,7 +593,7 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_value, traceback):
         self.close()
 
-    def keys(self):
+    def keys(self) -> List[str]:
         """
         Return a list of keys corresponding to objects stored in HDFStore.
 
@@ -585,7 +616,7 @@ def items(self):
 
     iteritems = items
 
-    def open(self, mode="a", **kwargs):
+    def open(self, mode: str = "a", **kwargs):
         """
         Open the file in the specified mode
 
@@ -606,8 +637,8 @@ def open(self, mode="a", **kwargs):
                 # this would truncate, raise here
                 if self.is_open:
                     raise PossibleDataLossError(
-                        "Re-opening the file [{0}] with mode [{1}] "
-                        "will delete the current file!".format(self._path, self._mode)
+                        f"Re-opening the file [{self._path}] with mode [{self._mode}] "
+                        "will delete the current file!"
                     )
 
             self._mode = mode
@@ -623,40 +654,38 @@ def open(self, mode="a", **kwargs):
 
         try:
             self._handle = tables.open_file(self._path, self._mode, **kwargs)
-        except (IOError) as e:  # pragma: no cover
-            if "can not be written" in str(e):
-                print("Opening {path} in read-only mode".format(path=self._path))
+        except IOError as err:  # pragma: no cover
+            if "can not be written" in str(err):
+                print(f"Opening {self._path} in read-only mode")
                 self._handle = tables.open_file(self._path, "r", **kwargs)
             else:
                 raise
 
-        except (ValueError) as e:
+        except ValueError as err:
 
             # trap PyTables >= 3.1 FILE_OPEN_POLICY exception
             # to provide an updated message
-            if "FILE_OPEN_POLICY" in str(e):
-                e = ValueError(
-                    "PyTables [{version}] no longer supports opening multiple "
-                    "files\n"
+            if "FILE_OPEN_POLICY" in str(err):
+                hdf_version = tables.get_hdf5_version()
+                err = ValueError(
+                    f"PyTables [{tables.__version__}] no longer supports "
+                    "opening multiple files\n"
                     "even in read-only mode on this HDF5 version "
-                    "[{hdf_version}]. You can accept this\n"
+                    f"[{hdf_version}]. You can accept this\n"
                     "and not open the same file multiple times at once,\n"
                     "upgrade the HDF5 version, or downgrade to PyTables 3.0.0 "
                     "which allows\n"
-                    "files to be opened multiple times at once\n".format(
-                        version=tables.__version__,
-                        hdf_version=tables.get_hdf5_version(),
-                    )
+                    "files to be opened multiple times at once\n"
                 )
 
-            raise e
+            raise err
 
-        except (Exception) as e:
+        except Exception as err:
 
             # trying to read from a non-existent file causes an error which
             # is not part of IOError, make it one
-            if self._mode == "r" and "Unable to open/create file" in str(e):
-                raise IOError(str(e))
+            if self._mode == "r" and "Unable to open/create file" in str(err):
+                raise IOError(str(err))
             raise
 
     def close(self):
@@ -668,7 +697,7 @@ def close(self):
         self._handle = None
 
     @property
-    def is_open(self):
+    def is_open(self) -> bool:
         """
         return a boolean indicating whether the file is open
         """
@@ -676,7 +705,7 @@ def is_open(self):
             return False
         return bool(self._handle.isopen)
 
-    def flush(self, fsync=False):
+    def flush(self, fsync: bool = False):
         """
         Force all buffered modifications to be written to disk.
 
@@ -700,13 +729,13 @@ def flush(self, fsync=False):
                 except OSError:
                     pass
 
-    def get(self, key):
+    def get(self, key: str):
         """
         Retrieve pandas object stored in file.
 
         Parameters
         ----------
-        key : object
+        key : str
 
         Returns
         -------
@@ -715,27 +744,26 @@ def get(self, key):
         """
         group = self.get_node(key)
         if group is None:
-            raise KeyError("No object named {key} in the file".format(key=key))
+            raise KeyError(f"No object named {key} in the file")
         return self._read_group(group)
 
     def select(
         self,
-        key,
+        key: str,
         where=None,
         start=None,
         stop=None,
         columns=None,
         iterator=False,
         chunksize=None,
-        auto_close=False,
-        **kwargs
+        auto_close: bool = False,
     ):
         """
         Retrieve pandas object stored in file, optionally based on where criteria.
 
         Parameters
         ----------
-        key : object
+        key : str
                 Object being retrieved from file.
         where : list, default None
                 List of Term (or convertible) objects, optional.
@@ -759,7 +787,7 @@ def select(
         """
         group = self.get_node(key)
         if group is None:
-            raise KeyError("No object named {key} in the file".format(key=key))
+            raise KeyError(f"No object named {key} in the file")
 
         # create the storer and axes
         where = _ensure_term(where, scope_level=1)
@@ -786,31 +814,47 @@ def func(_start, _stop, _where):
 
         return it.get_result()
 
-    def select_as_coordinates(self, key, where=None, start=None, stop=None, **kwargs):
+    def select_as_coordinates(
+        self,
+        key: str,
+        where=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         """
         return the selection as an Index
 
         Parameters
         ----------
-        key : object
+        key : str
         where : list of Term (or convertible) objects, optional
         start : integer (defaults to None), row number to start selection
         stop  : integer (defaults to None), row number to stop selection
         """
         where = _ensure_term(where, scope_level=1)
-        return self.get_storer(key).read_coordinates(
-            where=where, start=start, stop=stop, **kwargs
-        )
+        tbl = self.get_storer(key)
+        if not isinstance(tbl, Table):
+            raise TypeError("can only read_coordinates with a table")
+        return tbl.read_coordinates(where=where, start=start, stop=stop)
 
-    def select_column(self, key, column, **kwargs):
+    def select_column(
+        self,
+        key: str,
+        column: str,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         """
         return a single column from the table. This is generally only useful to
         select an indexable
 
         Parameters
         ----------
-        key : object
-        column: the column of interest
+        key : str
+        column : str
+            The column of interest.
+        start : int or None, default None
+        stop : int or None, default None
 
         Raises
         ------
@@ -820,7 +864,10 @@ def select_column(self, key, column, **kwargs):
             is part of a data block)
 
         """
-        return self.get_storer(key).read_column(column=column, **kwargs)
+        tbl = self.get_storer(key)
+        if not isinstance(tbl, Table):
+            raise TypeError("can only read_column with a table")
+        return tbl.read_column(column=column, start=start, stop=stop)
 
     def select_as_multiple(
         self,
@@ -832,10 +879,10 @@ def select_as_multiple(
         stop=None,
         iterator=False,
         chunksize=None,
-        auto_close=False,
-        **kwargs
+        auto_close: bool = False,
     ):
-        """ Retrieve pandas objects from multiple tables
+        """
+        Retrieve pandas objects from multiple tables.
 
         Parameters
         ----------
@@ -847,6 +894,8 @@ def select_as_multiple(
         stop  : integer (defaults to None), row number to stop selection
         iterator : boolean, return an iterator, default False
         chunksize : nrows to include in iteration, return an iterator
+        auto_close : bool, default False
+            Should automatically close the store when finished.
 
         Raises
         ------
@@ -868,7 +917,7 @@ def select_as_multiple(
                 stop=stop,
                 iterator=iterator,
                 chunksize=chunksize,
-                **kwargs
+                auto_close=auto_close,
             )
 
         if not isinstance(keys, (list, tuple)):
@@ -888,11 +937,11 @@ def select_as_multiple(
         nrows = None
         for t, k in itertools.chain([(s, selector)], zip(tbls, keys)):
             if t is None:
-                raise KeyError("Invalid table [{key}]".format(key=k))
+                raise KeyError(f"Invalid table [{k}]")
             if not t.is_table:
                 raise TypeError(
-                    "object [{obj}] is not a table, and cannot be used in all "
-                    "select as multiple".format(obj=t.pathname)
+                    f"object [{t.pathname}] is not a table, and cannot be used in all "
+                    "select as multiple"
                 )
 
             if nrows is None:
@@ -900,17 +949,19 @@ def select_as_multiple(
             elif t.nrows != nrows:
                 raise ValueError("all tables must have exactly the same nrows!")
 
+        # The isinstance checks here are redundant with the check above,
+        #  but necessary for mypy; see GH#29757
+        _tbls = [x for x in tbls if isinstance(x, Table)]
+
         # axis is the concentration axes
-        axis = list({t.non_index_axes[0][0] for t in tbls})[0]
+        axis = list({t.non_index_axes[0][0] for t in _tbls})[0]
 
         def func(_start, _stop, _where):
 
             # retrieve the objs, _where is always passed as a set of
             # coordinates here
             objs = [
-                t.read(
-                    where=_where, columns=columns, start=_start, stop=_stop, **kwargs
-                )
+                t.read(where=_where, columns=columns, start=_start, stop=_stop)
                 for t in tbls
             ]
 
@@ -933,13 +984,27 @@ def func(_start, _stop, _where):
 
         return it.get_result(coordinates=True)
 
-    def put(self, key, value, format=None, append=False, **kwargs):
+    def put(
+        self,
+        key: str,
+        value: FrameOrSeries,
+        format=None,
+        index=True,
+        append=False,
+        complib=None,
+        complevel: Optional[int] = None,
+        min_itemsize: Optional[Union[int, Dict[str, int]]] = None,
+        nan_rep=None,
+        data_columns: Optional[List[str]] = None,
+        encoding=None,
+        errors: str = "strict",
+    ):
         """
         Store object in HDFStore.
 
         Parameters
         ----------
-        key : object
+        key : str
         value : {Series, DataFrame}
         format : 'fixed(f)|table(t)', default is 'fixed'
             fixed(f) : Fixed format
@@ -954,7 +1019,7 @@ def put(self, key, value, format=None, append=False, **kwargs):
         data_columns : list, default None
             List of columns to create as data columns, or True to
             use all columns. See `here
-            <http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
+            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
         encoding : str, default None
             Provide an encoding for strings.
         dropna   : bool, default False, do not write an ALL nan row to
@@ -962,10 +1027,23 @@ def put(self, key, value, format=None, append=False, **kwargs):
         """
         if format is None:
             format = get_option("io.hdf.default_format") or "fixed"
-        kwargs = self._validate_format(format, kwargs)
-        self._write_to_group(key, value, append=append, **kwargs)
+        format = self._validate_format(format)
+        self._write_to_group(
+            key,
+            value,
+            format=format,
+            index=index,
+            append=append,
+            complib=complib,
+            complevel=complevel,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            data_columns=data_columns,
+            encoding=encoding,
+            errors=errors,
+        )
 
-    def remove(self, key, where=None, start=None, stop=None):
+    def remove(self, key: str, where=None, start=None, stop=None):
         """
         Remove pandas object partially by specifying the where condition
 
@@ -992,7 +1070,12 @@ def remove(self, key, where=None, start=None, stop=None):
         except KeyError:
             # the key is not a valid store, re-raising KeyError
             raise
+        except AssertionError:
+            # surface any assertion errors for e.g. debugging
+            raise
         except Exception:
+            # In tests we get here with ClosedFileError, TypeError, and
+            #  _table_mod.NoSuchNodeError.  TODO: Catch only these?
 
             if where is not None:
                 raise ValueError(
@@ -1000,9 +1083,9 @@ def remove(self, key, where=None, start=None, stop=None):
                 )
 
             # we are actually trying to remove a node (with children)
-            s = self.get_node(key)
-            if s is not None:
-                s._f_remove(recursive=True)
+            node = self.get_node(key)
+            if node is not None:
+                node._f_remove(recursive=True)
                 return None
 
         # remove the node
@@ -1018,7 +1101,24 @@ def remove(self, key, where=None, start=None, stop=None):
             return s.delete(where=where, start=start, stop=stop)
 
     def append(
-        self, key, value, format=None, append=True, columns=None, dropna=None, **kwargs
+        self,
+        key: str,
+        value: FrameOrSeries,
+        format=None,
+        axes=None,
+        index=True,
+        append=True,
+        complib=None,
+        complevel: Optional[int] = None,
+        columns=None,
+        min_itemsize: Optional[Union[int, Dict[str, int]]] = None,
+        nan_rep=None,
+        chunksize=None,
+        expectedrows=None,
+        dropna: Optional[bool] = None,
+        data_columns: Optional[List[str]] = None,
+        encoding=None,
+        errors: str = "strict",
     ):
         """
         Append to Table in file. Node must already exist and be Table
@@ -1026,27 +1126,28 @@ def append(
 
         Parameters
         ----------
-        key : object
+        key : str
         value : {Series, DataFrame}
         format : 'table' is the default
             table(t) : table format
                        Write as a PyTables Table structure which may perform
                        worse but allow more flexible operations like searching
-                       / selecting subsets of the data
-        append       : boolean, default True, append the input data to the
-            existing
-        data_columns :  list of columns, or True, default None
+                       / selecting subsets of the data.
+        append       : bool, default True
+            Append the input data to the existing.
+        data_columns : list of columns, or True, default None
             List of columns to create as indexed data columns for on-disk
             queries, or True to use all columns. By default only the axes
             of the object are indexed. See `here
-            <http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
-        min_itemsize : dict of columns that specify minimum string sizes
-        nan_rep      : string to use as string nan representation
+            <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#query-via-data-columns>`__.
+        min_itemsize : dict of columns that specify minimum str sizes
+        nan_rep      : str to use as str nan representation
         chunksize    : size to chunk the writing
         expectedrows : expected TOTAL row size of this table
-        encoding     : default None, provide an encoding for strings
-        dropna       : boolean, default False, do not write an ALL nan row to
-            the store settable by the option 'io.hdf.dropna_table'
+        encoding     : default None, provide an encoding for str
+        dropna : bool, default False
+            Do not write an ALL nan row to the store settable
+            by the option 'io.hdf.dropna_table'.
 
         Notes
         -----
@@ -1062,11 +1163,35 @@ def append(
             dropna = get_option("io.hdf.dropna_table")
         if format is None:
             format = get_option("io.hdf.default_format") or "table"
-        kwargs = self._validate_format(format, kwargs)
-        self._write_to_group(key, value, append=append, dropna=dropna, **kwargs)
+        format = self._validate_format(format)
+        self._write_to_group(
+            key,
+            value,
+            format=format,
+            axes=axes,
+            index=index,
+            append=append,
+            complib=complib,
+            complevel=complevel,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            chunksize=chunksize,
+            expectedrows=expectedrows,
+            dropna=dropna,
+            data_columns=data_columns,
+            encoding=encoding,
+            errors=errors,
+        )
 
     def append_to_multiple(
-        self, d, value, selector, data_columns=None, axes=None, dropna=False, **kwargs
+        self,
+        d: Dict,
+        value,
+        selector,
+        data_columns=None,
+        axes=None,
+        dropna=False,
+        **kwargs,
     ):
         """
         Append to multiple tables
@@ -1091,9 +1216,8 @@ def append_to_multiple(
         """
         if axes is not None:
             raise TypeError(
-                "axes is currently not accepted as a parameter to"
-                " append_to_multiple; you can create the "
-                "tables independently instead"
+                "axes is currently not accepted as a parameter to append_to_multiple; "
+                "you can create the tables independently instead"
             )
 
         if not isinstance(d, dict):
@@ -1112,13 +1236,12 @@ def append_to_multiple(
 
         # figure out how to split the value
         remain_key = None
-        remain_values = []
+        remain_values: List = []
         for k, v in d.items():
             if v is None:
                 if remain_key is not None:
                     raise ValueError(
-                        "append_to_multiple can only have one value in d that "
-                        "is None"
+                        "append_to_multiple can only have one value in d that is None"
                     )
                 remain_key = k
             else:
@@ -1150,16 +1273,35 @@ def append_to_multiple(
 
             self.append(k, val, data_columns=dc, **kwargs)
 
-    def create_table_index(self, key, **kwargs):
-        """ Create a pytables index on the table
+    def create_table_index(
+        self,
+        key: str,
+        columns=None,
+        optlevel: Optional[int] = None,
+        kind: Optional[str] = None,
+    ):
+        """
+        Create a pytables index on the table.
+
         Parameters
         ----------
-        key : object (the node to index)
+        key : str
+        columns : None, bool, or listlike[str]
+            Indicate which columns to create an index on.
+
+            * False : Do not create any indexes.
+            * True : Create indexes on all columns.
+            * None : Create indexes on all columns.
+            * listlike : Create indexes on the given columns.
+
+        optlevel : int or None, default None
+            Optimization level, if None, pytables defaults to 6.
+        kind : str or None, default None
+            Kind of index, if None, pytables defaults to "medium".
 
         Raises
         ------
-        raises if the node is not a table
-
+        TypeError: raises if the node is not a table
         """
 
         # version requirements
@@ -1168,9 +1310,9 @@ def create_table_index(self, key, **kwargs):
         if s is None:
             return
 
-        if not s.is_table:
+        if not isinstance(s, Table):
             raise TypeError("cannot create table index on a Fixed format store")
-        s.create_index(**kwargs)
+        s.create_index(columns=columns, optlevel=optlevel, kind=kind)
 
     def groups(self):
         """
@@ -1245,21 +1387,27 @@ def walk(self, where="/"):
 
             yield (g._v_pathname.rstrip("/"), groups, leaves)
 
-    def get_node(self, key):
+    def get_node(self, key: str) -> Optional["Node"]:
         """ return the node with the key or None if it does not exist """
         self._check_if_open()
+        if not key.startswith("/"):
+            key = "/" + key
+
+        assert self._handle is not None
+        assert _table_mod is not None  # for mypy
         try:
-            if not key.startswith("/"):
-                key = "/" + key
-            return self._handle.get_node(self.root, key)
+            node = self._handle.get_node(self.root, key)
         except _table_mod.exceptions.NoSuchNodeError:
             return None
 
-    def get_storer(self, key):
+        assert isinstance(node, _table_mod.Node), type(node)
+        return node
+
+    def get_storer(self, key: str) -> Union["GenericFixed", "Table"]:
         """ return the storer object for a key, raise if not in the file """
         group = self.get_node(key)
         if group is None:
-            raise KeyError("No object named {key} in the file".format(key=key))
+            raise KeyError(f"No object named {key} in the file")
 
         s = self._create_storer(group)
         s.infer_axes()
@@ -1269,27 +1417,28 @@ def copy(
         self,
         file,
         mode="w",
-        propindexes=True,
+        propindexes: bool = True,
         keys=None,
         complib=None,
-        complevel=None,
-        fletcher32=False,
+        complevel: Optional[int] = None,
+        fletcher32: bool = False,
         overwrite=True,
     ):
-        """ copy the existing store to a new file, upgrading in place
-
-            Parameters
-            ----------
-            propindexes: restore indexes in copied file (defaults to True)
-            keys       : list of keys to include in the copy (defaults to all)
-            overwrite  : overwrite (remove and replace) existing nodes in the
-                new store (default is True)
-            mode, complib, complevel, fletcher32 same as in HDFStore.__init__
+        """
+        Copy the existing store to a new file, updating in place.
 
-            Returns
-            -------
-            open file handle of the new store
+        Parameters
+        ----------
+        propindexes: bool, default True
+            Restore indexes in copied file.
+        keys       : list of keys to include in the copy (defaults to all)
+        overwrite  : overwrite (remove and replace) existing nodes in the
+            new store (default is True)
+        mode, complib, complevel, fletcher32 same as in HDFStore.__init__
 
+        Returns
+        -------
+        open file handle of the new store
         """
         new_store = HDFStore(
             file, mode=mode, complib=complib, complevel=complevel, fletcher32=fletcher32
@@ -1307,9 +1456,9 @@ def copy(
                         new_store.remove(k)
 
                 data = self.select(k)
-                if s.is_table:
+                if isinstance(s, Table):
 
-                    index = False
+                    index: Union[bool, List[str]] = False
                     if propindexes:
                         index = [a.name for a in s.axes if a.is_indexed]
                     new_store.append(
@@ -1324,7 +1473,7 @@ def copy(
 
         return new_store
 
-    def info(self):
+    def info(self) -> str:
         """
         Print detailed information on the store.
 
@@ -1334,11 +1483,11 @@ def info(self):
         -------
         str
         """
-        output = "{type}\nFile path: {path}\n".format(
-            type=type(self), path=pprint_thing(self._path)
-        )
+        path = pprint_thing(self._path)
+        output = f"{type(self)}\nFile path: {path}\n"
+
         if self.is_open:
-            lkeys = sorted(list(self.keys()))
+            lkeys = sorted(self.keys())
             if len(lkeys):
                 keys = []
                 values = []
@@ -1349,13 +1498,13 @@ def info(self):
                         if s is not None:
                             keys.append(pprint_thing(s.pathname or k))
                             values.append(pprint_thing(s or "invalid_HDFStore node"))
+                    except AssertionError:
+                        # surface any assertion errors for e.g. debugging
+                        raise
                     except Exception as detail:
                         keys.append(k)
-                        values.append(
-                            "[invalid_HDFStore node: {detail}]".format(
-                                detail=pprint_thing(detail)
-                            )
-                        )
+                        dstr = pprint_thing(detail)
+                        values.append(f"[invalid_HDFStore node: {dstr}]")
 
                 output += adjoin(12, keys, values)
             else:
@@ -1365,38 +1514,44 @@ def info(self):
 
         return output
 
-    # private methods ######
+    # ------------------------------------------------------------------------
+    # private methods
+
     def _check_if_open(self):
         if not self.is_open:
-            raise ClosedFileError("{0} file is not open!".format(self._path))
+            raise ClosedFileError(f"{self._path} file is not open!")
 
-    def _validate_format(self, format, kwargs):
-        """ validate / deprecate formats; return the new kwargs """
-        kwargs = kwargs.copy()
+    def _validate_format(self, format: str) -> str:
+        """ validate / deprecate formats """
 
         # validate
         try:
-            kwargs["format"] = _FORMAT_MAP[format.lower()]
+            format = _FORMAT_MAP[format.lower()]
         except KeyError:
-            raise TypeError("invalid HDFStore format specified [{0}]".format(format))
+            raise TypeError(f"invalid HDFStore format specified [{format}]")
 
-        return kwargs
+        return format
 
-    def _create_storer(self, group, format=None, value=None, append=False, **kwargs):
+    def _create_storer(
+        self,
+        group,
+        format=None,
+        value: Optional[FrameOrSeries] = None,
+        encoding: str = "UTF-8",
+        errors: str = "strict",
+    ) -> Union["GenericFixed", "Table"]:
         """ return a suitable class to operate """
 
+        cls: Union[Type["GenericFixed"], Type["Table"]]
+
+        if value is not None and not isinstance(value, (Series, DataFrame)):
+            raise TypeError("value must be None, Series, or DataFrame")
+
         def error(t):
-            raise TypeError(
-                "cannot properly create the storer for: [{t}] [group->"
-                "{group},value->{value},format->{format},append->{append},"
-                "kwargs->{kwargs}]".format(
-                    t=t,
-                    group=group,
-                    value=type(value),
-                    format=format,
-                    append=append,
-                    kwargs=kwargs,
-                )
+            # return instead of raising so mypy can tell where we are raising
+            return TypeError(
+                f"cannot properly create the storer for: [{t}] [group->"
+                f"{group},value->{type(value)},format->{format}"
             )
 
         pt = _ensure_decoded(getattr(group._v_attrs, "pandas_type", None))
@@ -1407,6 +1562,7 @@ def error(t):
             if value is None:
 
                 _tables()
+                assert _table_mod is not None  # for mypy
                 if getattr(group, "table", None) or isinstance(
                     group, _table_mod.table.Table
                 ):
@@ -1418,11 +1574,8 @@ def error(t):
                         "nor a value are passed"
                     )
             else:
-
-                try:
-                    pt = _TYPE_MAP[type(value)]
-                except KeyError:
-                    error("_TYPE_MAP")
+                _TYPE_MAP = {Series: "series", DataFrame: "frame"}
+                pt = _TYPE_MAP[type(value)]
 
                 # we are actually a table
                 if format == "table":
@@ -1430,10 +1583,12 @@ def error(t):
 
         # a storer node
         if "table" not in pt:
+            _STORER_MAP = {"series": SeriesFixed, "frame": FrameFixed}
             try:
-                return globals()[_STORER_MAP[pt]](self, group, **kwargs)
+                cls = _STORER_MAP[pt]
             except KeyError:
-                error("_STORER_MAP")
+                raise error("_STORER_MAP")
+            return cls(self, group, encoding=encoding, errors=errors)
 
         # existing node (and must be a table)
         if tt is None:
@@ -1455,46 +1610,54 @@ def error(t):
                             tt = "appendable_frame"
                         elif index.nlevels > 1:
                             tt = "appendable_multiframe"
-                elif pt == "wide_table":
-                    tt = "appendable_panel"
-                elif pt == "ndim_table":
-                    tt = "appendable_ndim"
-
-            else:
-
-                # distinguish between a frame/table
-                tt = "legacy_panel"
-                try:
-                    fields = group.table._v_attrs.fields
-                    if len(fields) == 1 and fields[0] == "value":
-                        tt = "legacy_frame"
-                except IndexError:
-                    pass
 
+        _TABLE_MAP = {
+            "generic_table": GenericTable,
+            "appendable_series": AppendableSeriesTable,
+            "appendable_multiseries": AppendableMultiSeriesTable,
+            "appendable_frame": AppendableFrameTable,
+            "appendable_multiframe": AppendableMultiFrameTable,
+            "worm": WORMTable,
+        }
         try:
-            return globals()[_TABLE_MAP[tt]](self, group, **kwargs)
+            cls = _TABLE_MAP[tt]
         except KeyError:
-            error("_TABLE_MAP")
+            raise error("_TABLE_MAP")
+
+        return cls(self, group, encoding=encoding, errors=errors)
 
     def _write_to_group(
         self,
-        key,
-        value,
+        key: str,
+        value: FrameOrSeries,
         format,
+        axes=None,
         index=True,
         append=False,
         complib=None,
+        complevel: Optional[int] = None,
+        fletcher32=None,
+        min_itemsize: Optional[Union[int, Dict[str, int]]] = None,
+        chunksize=None,
+        expectedrows=None,
+        dropna=False,
+        nan_rep=None,
+        data_columns=None,
         encoding=None,
-        **kwargs
+        errors: str = "strict",
     ):
         group = self.get_node(key)
 
+        # we make this assertion for mypy; the get_node call will already
+        #  have raised if this is incorrect
+        assert self._handle is not None
+
         # remove the node if we are not appending
         if group is not None and not append:
             self._handle.remove_node(group, recursive=True)
             group = None
 
-        # we don't want to store a table node at all if are object is 0-len
+        # we don't want to store a table node at all if our object is 0-len
         # as there are not dtypes
         if getattr(value, "empty", None) and (format == "table" or append):
             return
@@ -1516,9 +1679,7 @@ def _write_to_group(
                     group = self._handle.create_group(path, p)
                 path = new_path
 
-        s = self._create_storer(
-            group, format, value, append=append, encoding=encoding, **kwargs
-        )
+        s = self._create_storer(group, format, value, encoding=encoding, errors=errors)
         if append:
             # raise if we are trying to append to a Fixed format,
             #       or a table that exists (and we are putting)
@@ -1533,49 +1694,66 @@ def _write_to_group(
             raise ValueError("Compression not supported on Fixed format stores")
 
         # write the object
-        s.write(obj=value, append=append, complib=complib, **kwargs)
+        s.write(
+            obj=value,
+            axes=axes,
+            append=append,
+            complib=complib,
+            complevel=complevel,
+            fletcher32=fletcher32,
+            min_itemsize=min_itemsize,
+            chunksize=chunksize,
+            expectedrows=expectedrows,
+            dropna=dropna,
+            nan_rep=nan_rep,
+            data_columns=data_columns,
+        )
 
-        if s.is_table and index:
+        if isinstance(s, Table) and index:
             s.create_index(columns=index)
 
-    def _read_group(self, group, **kwargs):
+    def _read_group(self, group: "Node"):
         s = self._create_storer(group)
         s.infer_axes()
-        return s.read(**kwargs)
+        return s.read()
 
 
 class TableIterator:
-    """ define the iteration interface on a table
+    """
+    Define the iteration interface on a table
 
-        Parameters
-        ----------
+    Parameters
+    ----------
+    store : HDFStore
+    s     : the referred storer
+    func  : the function to execute the query
+    where : the where of the query
+    nrows : the rows to iterate on
+    start : the passed start value (default is None)
+    stop  : the passed stop value (default is None)
+    iterator : bool, default False
+        Whether to use the default iterator.
+    chunksize : the passed chunking value (default is 100000)
+    auto_close : bool, default False
+        Whether to automatically close the store at the end of iteration.
+    """
 
-        store : the reference store
-        s     : the referred storer
-        func  : the function to execute the query
-        where : the where of the query
-        nrows : the rows to iterate on
-        start : the passed start value (default is None)
-        stop  : the passed stop value (default is None)
-        iterator : boolean, whether to use the default iterator
-        chunksize : the passed chunking value (default is 50000)
-        auto_close : boolean, automatically close the store at the end of
-            iteration, default is False
-        kwargs : the passed kwargs
-        """
+    chunksize: Optional[int]
+    store: HDFStore
+    s: Union["GenericFixed", "Table"]
 
     def __init__(
         self,
-        store,
-        s,
+        store: HDFStore,
+        s: Union["GenericFixed", "Table"],
         func,
         where,
         nrows,
         start=None,
         stop=None,
-        iterator=False,
-        chunksize=None,
-        auto_close=False,
+        iterator: bool = False,
+        chunksize: Optional[int] = None,
+        auto_close: bool = False,
     ):
         self.store = store
         self.s = s
@@ -1626,11 +1804,11 @@ def close(self):
         if self.auto_close:
             self.store.close()
 
-    def get_result(self, coordinates=False):
+    def get_result(self, coordinates: bool = False):
 
         #  return the actual iterator
         if self.chunksize is not None:
-            if not self.s.is_table:
+            if not isinstance(self.s, Table):
                 raise TypeError("can only use an iterator or chunksize on a table")
 
             self.coordinates = self.s.read_coordinates(where=self.where)
@@ -1639,6 +1817,8 @@ def get_result(self, coordinates=False):
 
         # if specified read via coordinates (necessary for multiple selections
         if coordinates:
+            if not isinstance(self.s, Table):
+                raise TypeError("can only read_coordinates on a table")
             where = self.s.read_coordinates(
                 where=self.where, start=self.start, stop=self.stop
             )
@@ -1652,161 +1832,152 @@ def get_result(self, coordinates=False):
 
 
 class IndexCol:
-    """ an index column description class
+    """
+    an index column description class
 
-        Parameters
-        ----------
+    Parameters
+    ----------
 
-        axis   : axis which I reference
-        values : the ndarray like converted values
-        kind   : a string description of this type
-        typ    : the pytables type
-        pos    : the position in the pytables
+    axis   : axis which I reference
+    values : the ndarray like converted values
+    kind   : a string description of this type
+    typ    : the pytables type
+    pos    : the position in the pytables
 
-        """
+    """
 
     is_an_indexable = True
     is_data_indexable = True
     _info_fields = ["freq", "tz", "index_name"]
 
+    name: str
+    cname: str
+
     def __init__(
         self,
+        name: str,
         values=None,
         kind=None,
         typ=None,
-        cname=None,
-        itemsize=None,
-        name=None,
+        cname: Optional[str] = None,
         axis=None,
-        kind_attr=None,
         pos=None,
         freq=None,
         tz=None,
         index_name=None,
-        **kwargs
+        ordered=None,
+        table=None,
+        meta=None,
+        metadata=None,
     ):
+
+        if not isinstance(name, str):
+            raise ValueError("`name` must be a str.")
+
         self.values = values
         self.kind = kind
         self.typ = typ
-        self.itemsize = itemsize
         self.name = name
-        self.cname = cname
-        self.kind_attr = kind_attr
+        self.cname = cname or name
         self.axis = axis
         self.pos = pos
         self.freq = freq
         self.tz = tz
         self.index_name = index_name
-        self.table = None
-        self.meta = None
-        self.metadata = None
+        self.ordered = ordered
+        self.table = table
+        self.meta = meta
+        self.metadata = metadata
 
-        if name is not None:
-            self.set_name(name, kind_attr)
         if pos is not None:
             self.set_pos(pos)
 
-    def set_name(self, name, kind_attr=None):
-        """ set the name of this indexer """
-        self.name = name
-        self.kind_attr = kind_attr or "{name}_kind".format(name=name)
-        if self.cname is None:
-            self.cname = name
-
-        return self
+        # These are ensured as long as the passed arguments match the
+        #  constructor annotations.
+        assert isinstance(self.name, str)
+        assert isinstance(self.cname, str)
 
-    def set_axis(self, axis):
-        """ set the axis over which I index """
-        self.axis = axis
+    @property
+    def itemsize(self) -> int:
+        # Assumes self.typ has already been initialized
+        return self.typ.itemsize
 
-        return self
+    @property
+    def kind_attr(self) -> str:
+        return f"{self.name}_kind"
 
-    def set_pos(self, pos):
+    def set_pos(self, pos: int):
         """ set the position of this column in the Table """
         self.pos = pos
         if pos is not None and self.typ is not None:
             self.typ._v_pos = pos
-        return self
-
-    def set_table(self, table):
-        self.table = table
-        return self
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         temp = tuple(
             map(pprint_thing, (self.name, self.cname, self.axis, self.pos, self.kind))
         )
         return ",".join(
             (
-                "{key}->{value}".format(key=key, value=value)
+                f"{key}->{value}"
                 for key, value in zip(["name", "cname", "axis", "pos", "kind"], temp)
             )
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         """ compare 2 col items """
         return all(
             getattr(self, a, None) == getattr(other, a, None)
             for a in ["name", "cname", "axis", "pos"]
         )
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         return not self.__eq__(other)
 
     @property
-    def is_indexed(self):
+    def is_indexed(self) -> bool:
         """ return whether I am an indexed column """
-        try:
-            return getattr(self.table.cols, self.cname).is_indexed
-        except AttributeError:
-            False
-
-    def copy(self):
-        new_self = copy.copy(self)
-        return new_self
-
-    def infer(self, handler):
-        """infer this column from the table: create and return a new object"""
-        table = handler.table
-        new_self = self.copy()
-        new_self.set_table(table)
-        new_self.get_attr()
-        new_self.read_metadata(handler)
-        return new_self
+        if not hasattr(self.table, "cols"):
+            # e.g. if infer hasn't been called yet, self.table will be None.
+            return False
+        # GH#29692 mypy doesn't recognize self.table as having a "cols" attribute
+        #  'error: "None" has no attribute "cols"'
+        return getattr(self.table.cols, self.cname).is_indexed  # type: ignore
 
-    def convert(self, values, nan_rep, encoding, errors, start=None, stop=None):
-        """ set the values from this selection: take = take ownership """
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
+        """
+        Convert the data from this selection to the appropriate pandas type.
+        """
+        assert isinstance(values, np.ndarray), type(values)
 
         # values is a recarray
         if values.dtype.fields is not None:
             values = values[self.cname]
 
-        values = _maybe_convert(values, self.kind, encoding, errors)
+        val_kind = _ensure_decoded(self.kind)
+        values = _maybe_convert(values, val_kind, encoding, errors)
 
         kwargs = dict()
+        kwargs["name"] = _ensure_decoded(self.index_name)
+
         if self.freq is not None:
             kwargs["freq"] = _ensure_decoded(self.freq)
-        if self.index_name is not None:
-            kwargs["name"] = _ensure_decoded(self.index_name)
+
         # making an Index instance could throw a number of different errors
         try:
-            self.values = Index(values, **kwargs)
-        except Exception:
-
+            new_pd_index = Index(values, **kwargs)
+        except ValueError:
             # if the output freq is different that what we recorded,
             # it should be None (see also 'doc example part 2')
             if "freq" in kwargs:
                 kwargs["freq"] = None
-            self.values = Index(values, **kwargs)
+            new_pd_index = Index(values, **kwargs)
 
-        self.values = _set_tz(self.values, self.tz)
-
-        return self
+        new_pd_index = _set_tz(new_pd_index, self.tz)
+        return new_pd_index, new_pd_index
 
     def take_data(self):
-        """ return the values & release the memory """
-        self.values, values = None, self.values
-        return values
+        """ return the values"""
+        return self.values
 
     @property
     def attrs(self):
@@ -1830,9 +2001,11 @@ def __iter__(self):
         return iter(self.values)
 
     def maybe_set_size(self, min_itemsize=None):
-        """ maybe set a string col itemsize:
-               min_itemsize can be an integer or a dict with this columns name
-               with an integer size """
+        """
+        maybe set a string col itemsize:
+            min_itemsize can be an integer or a dict with this columns name
+            with an integer size
+        """
         if _ensure_decoded(self.kind) == "string":
 
             if isinstance(min_itemsize, dict):
@@ -1841,14 +2014,11 @@ def maybe_set_size(self, min_itemsize=None):
             if min_itemsize is not None and self.typ.itemsize < min_itemsize:
                 self.typ = _tables().StringCol(itemsize=min_itemsize, pos=self.pos)
 
-    def validate(self, handler, append):
-        self.validate_names()
-
     def validate_names(self):
         pass
 
-    def validate_and_set(self, handler, append):
-        self.set_table(handler.table)
+    def validate_and_set(self, handler: "AppendableTable", append: bool):
+        self.table = handler.table
         self.validate_col()
         self.validate_attr(append)
         self.validate_metadata(handler)
@@ -1866,35 +2036,34 @@ def validate_col(self, itemsize=None):
                     itemsize = self.itemsize
                 if c.itemsize < itemsize:
                     raise ValueError(
-                        "Trying to store a string with len [{itemsize}] in "
-                        "[{cname}] column but\nthis column has a limit of "
-                        "[{c_itemsize}]!\nConsider using min_itemsize to "
-                        "preset the sizes on these columns".format(
-                            itemsize=itemsize, cname=self.cname, c_itemsize=c.itemsize
-                        )
+                        f"Trying to store a string with len [{itemsize}] in "
+                        f"[{self.cname}] column but\nthis column has a limit of "
+                        f"[{c.itemsize}]!\nConsider using min_itemsize to "
+                        "preset the sizes on these columns"
                     )
                 return c.itemsize
 
         return None
 
-    def validate_attr(self, append):
+    def validate_attr(self, append: bool):
         # check for backwards incompatibility
         if append:
             existing_kind = getattr(self.attrs, self.kind_attr, None)
             if existing_kind is not None and existing_kind != self.kind:
                 raise TypeError(
-                    "incompatible kind in col [{existing} - "
-                    "{self_kind}]".format(existing=existing_kind, self_kind=self.kind)
+                    f"incompatible kind in col [{existing_kind} - {self.kind}]"
                 )
 
     def update_info(self, info):
-        """ set/update the info for this indexable with the key/value
-            if there is a conflict raise/warn as needed """
+        """
+        set/update the info for this indexable with the key/value
+        if there is a conflict raise/warn as needed
+        """
 
         for key in self._info_fields:
 
             value = getattr(self, key, None)
-            idx = _get_info(info, self.name)
+            idx = info.setdefault(self.name, {})
 
             existing_value = idx.get(key)
             if key in idx and value is not None and existing_value != value:
@@ -1910,40 +2079,25 @@ def update_info(self, info):
 
                 else:
                     raise ValueError(
-                        "invalid info for [{name}] for [{key}], "
-                        "existing_value [{existing_value}] conflicts with "
-                        "new value [{value}]".format(
-                            name=self.name,
-                            key=key,
-                            existing_value=existing_value,
-                            value=value,
-                        )
+                        f"invalid info for [{self.name}] for [{key}], "
+                        f"existing_value [{existing_value}] conflicts with "
+                        f"new value [{value}]"
                     )
             else:
                 if value is not None or existing_value is not None:
                     idx[key] = value
 
-        return self
-
     def set_info(self, info):
         """ set my state from the passed info """
         idx = info.get(self.name)
         if idx is not None:
             self.__dict__.update(idx)
 
-    def get_attr(self):
-        """ set the kind for this column """
-        self.kind = getattr(self.attrs, self.kind_attr, None)
-
     def set_attr(self):
         """ set the kind for this column """
         setattr(self.attrs, self.kind_attr, self.kind)
 
-    def read_metadata(self, handler):
-        """ retrieve the metadata for this columns """
-        self.metadata = handler.read_metadata(self.cname)
-
-    def validate_metadata(self, handler):
+    def validate_metadata(self, handler: "AppendableTable"):
         """ validate that kind=category does not change the categories """
         if self.meta == "category":
             new_metadata = self.metadata
@@ -1958,7 +2112,7 @@ def validate_metadata(self, handler):
                     "different categories to the existing"
                 )
 
-    def write_metadata(self, handler):
+    def write_metadata(self, handler: "AppendableTable"):
         """ set the meta data """
         if self.metadata is not None:
             handler.write_metadata(self.cname, self.metadata)
@@ -1968,98 +2122,88 @@ class GenericIndexCol(IndexCol):
     """ an index which is not represented in the data of the table """
 
     @property
-    def is_indexed(self):
+    def is_indexed(self) -> bool:
         return False
 
-    def convert(self, values, nan_rep, encoding, errors, start=None, stop=None):
-        """ set the values from this selection: take = take ownership
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
+        """
+        Convert the data from this selection to the appropriate pandas type.
 
         Parameters
         ----------
-
         values : np.ndarray
         nan_rep : str
         encoding : str
         errors : str
-        start : int, optional
-            Table row number: the start of the sub-selection.
-        stop : int, optional
-            Table row number: the end of the sub-selection. Values larger than
-            the underlying table's row count are normalized to that.
         """
+        assert isinstance(values, np.ndarray), type(values)
 
-        start = start if start is not None else 0
-        stop = min(stop, self.table.nrows) if stop is not None else self.table.nrows
-        self.values = Int64Index(np.arange(stop - start))
-
-        return self
-
-    def get_attr(self):
-        pass
+        values = Int64Index(np.arange(len(values)))
+        return values, values
 
     def set_attr(self):
         pass
 
 
 class DataCol(IndexCol):
-    """ a data holding column, by definition this is not indexable
+    """
+    a data holding column, by definition this is not indexable
 
-        Parameters
-        ----------
+    Parameters
+    ----------
 
-        data   : the actual data
-        cname  : the column name in the table to hold the data (typically
-                 values)
-        meta   : a string description of the metadata
-        metadata : the actual metadata
-        """
+    data   : the actual data
+    cname  : the column name in the table to hold the data (typically
+                values)
+    meta   : a string description of the metadata
+    metadata : the actual metadata
+    """
 
     is_an_indexable = False
     is_data_indexable = False
     _info_fields = ["tz", "ordered"]
 
-    @classmethod
-    def create_for_block(cls, i=None, name=None, cname=None, version=None, **kwargs):
-        """ return a new datacol with the block i """
-
-        if cname is None:
-            cname = name or "values_block_{idx}".format(idx=i)
-        if name is None:
-            name = cname
-
-        # prior to 0.10.1, we named values blocks like: values_block_0 an the
-        # name values_0
-        try:
-            if version[0] == 0 and version[1] <= 10 and version[2] == 0:
-                m = re.search(r"values_block_(\d+)", name)
-                if m:
-                    name = "values_{group}".format(group=m.groups()[0])
-        except IndexError:
-            pass
-
-        return cls(name=name, cname=cname, **kwargs)
-
     def __init__(
         self,
+        name: str,
         values=None,
         kind=None,
         typ=None,
         cname=None,
-        data=None,
+        pos=None,
+        tz=None,
+        ordered=None,
+        table=None,
         meta=None,
         metadata=None,
-        block=None,
-        **kwargs
+        dtype=None,
+        data=None,
     ):
-        super().__init__(values=values, kind=kind, typ=typ, cname=cname, **kwargs)
-        self.dtype = None
-        self.dtype_attr = "{name}_dtype".format(name=self.name)
-        self.meta = meta
-        self.meta_attr = "{name}_meta".format(name=self.name)
-        self.set_data(data)
-        self.set_metadata(metadata)
+        super().__init__(
+            name=name,
+            values=values,
+            kind=kind,
+            typ=typ,
+            pos=pos,
+            cname=cname,
+            tz=tz,
+            ordered=ordered,
+            table=table,
+            meta=meta,
+            metadata=metadata,
+        )
+        self.dtype = dtype
+        self.data = data
+
+    @property
+    def dtype_attr(self) -> str:
+        return f"{self.name}_dtype"
+
+    @property
+    def meta_attr(self) -> str:
+        return f"{self.name}_meta"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         temp = tuple(
             map(
                 pprint_thing, (self.name, self.cname, self.dtype, self.kind, self.shape)
@@ -2067,274 +2211,98 @@ def __repr__(self):
         )
         return ",".join(
             (
-                "{key}->{value}".format(key=key, value=value)
+                f"{key}->{value}"
                 for key, value in zip(["name", "cname", "dtype", "kind", "shape"], temp)
             )
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         """ compare 2 col items """
         return all(
             getattr(self, a, None) == getattr(other, a, None)
             for a in ["name", "cname", "dtype", "pos"]
         )
 
-    def set_data(self, data, dtype=None):
+    def set_data(self, data: Union[np.ndarray, ABCExtensionArray]):
+        assert data is not None
+        assert self.dtype is None
+
+        data, dtype_name = _get_data_and_dtype_name(data)
+
         self.data = data
-        if data is not None:
-            if dtype is not None:
-                self.dtype = dtype
-                self.set_kind()
-            elif self.dtype is None:
-                self.dtype = data.dtype.name
-                self.set_kind()
+        self.dtype = dtype_name
+        self.kind = _dtype_to_kind(dtype_name)
 
     def take_data(self):
-        """ return the data & release the memory """
-        self.data, data = None, self.data
-        return data
-
-    def set_metadata(self, metadata):
-        """ record the metadata """
-        if metadata is not None:
-            metadata = np.array(metadata, copy=False).ravel()
-        self.metadata = metadata
-
-    def set_kind(self):
-        # set my kind if we can
-
-        if self.dtype is not None:
-            dtype = _ensure_decoded(self.dtype)
-
-            if dtype.startswith("string") or dtype.startswith("bytes"):
-                self.kind = "string"
-            elif dtype.startswith("float"):
-                self.kind = "float"
-            elif dtype.startswith("complex"):
-                self.kind = "complex"
-            elif dtype.startswith("int") or dtype.startswith("uint"):
-                self.kind = "integer"
-            elif dtype.startswith("date"):
-                self.kind = "datetime"
-            elif dtype.startswith("timedelta"):
-                self.kind = "timedelta"
-            elif dtype.startswith("bool"):
-                self.kind = "bool"
-            else:
-                raise AssertionError(
-                    "cannot interpret dtype of [{dtype}] in [{obj}]".format(
-                        dtype=dtype, obj=self
-                    )
-                )
+        """ return the data """
+        return self.data
 
-            # set my typ if we need
-            if self.typ is None:
-                self.typ = getattr(self.description, self.cname, None)
+    @classmethod
+    def _get_atom(cls, values: Union[np.ndarray, ABCExtensionArray]) -> "Col":
+        """
+        Get an appropriately typed and shaped pytables.Col object for values.
+        """
 
-    def set_atom(
-        self,
-        block,
-        block_items,
-        existing_col,
-        min_itemsize,
-        nan_rep,
-        info,
-        encoding=None,
-        errors="strict",
-    ):
-        """ create and setup my atom from the block b """
-
-        self.values = list(block_items)
-
-        # short-cut certain block types
-        if block.is_categorical:
-            return self.set_atom_categorical(block, items=block_items, info=info)
-        elif block.is_datetimetz:
-            return self.set_atom_datetime64tz(block, info=info)
-        elif block.is_datetime:
-            return self.set_atom_datetime64(block)
-        elif block.is_timedelta:
-            return self.set_atom_timedelta64(block)
-        elif block.is_complex:
-            return self.set_atom_complex(block)
-
-        dtype = block.dtype.name
-        inferred_type = lib.infer_dtype(block.values, skipna=False)
-
-        if inferred_type == "date":
-            raise TypeError("[date] is not implemented as a table column")
-        elif inferred_type == "datetime":
-            # after 8260
-            # this only would be hit for a mutli-timezone dtype
-            # which is an error
+        dtype = values.dtype
+        itemsize = dtype.itemsize
 
-            raise TypeError(
-                "too many timezones in this block, create separate data columns"
-            )
-        elif inferred_type == "unicode":
-            raise TypeError("[unicode] is not implemented as a table column")
-
-        # this is basically a catchall; if say a datetime64 has nans then will
-        # end up here ###
-        elif inferred_type == "string" or dtype == "object":
-            self.set_atom_string(
-                block,
-                block_items,
-                existing_col,
-                min_itemsize,
-                nan_rep,
-                encoding,
-                errors,
-            )
+        shape = values.shape
+        if values.ndim == 1:
+            # EA, use block shape pretending it is 2D
+            shape = (1, values.size)
 
-        # set as a data block
-        else:
-            self.set_atom_data(block)
+        if is_categorical_dtype(dtype):
+            codes = values.codes
+            atom = cls.get_atom_data(shape, kind=codes.dtype.name)
+        elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype):
+            atom = cls.get_atom_datetime64(shape)
+        elif is_timedelta64_dtype(dtype):
+            atom = cls.get_atom_timedelta64(shape)
+        elif is_complex_dtype(dtype):
+            atom = _tables().ComplexCol(itemsize=itemsize, shape=shape[0])
 
-    def get_atom_string(self, block, itemsize):
-        return _tables().StringCol(itemsize=itemsize, shape=block.shape[0])
+        elif is_string_dtype(dtype):
+            atom = cls.get_atom_string(shape, itemsize)
 
-    def set_atom_string(
-        self, block, block_items, existing_col, min_itemsize, nan_rep, encoding, errors
-    ):
-        # fill nan items with myself, don't disturb the blocks by
-        # trying to downcast
-        block = block.fillna(nan_rep, downcast=False)
-        if isinstance(block, list):
-            block = block[0]
-        data = block.values
-
-        # see if we have a valid string type
-        inferred_type = lib.infer_dtype(data.ravel(), skipna=False)
-        if inferred_type != "string":
-
-            # we cannot serialize this data, so report an exception on a column
-            # by column basis
-            for i, item in enumerate(block_items):
-
-                col = block.iget(i)
-                inferred_type = lib.infer_dtype(col.ravel(), skipna=False)
-                if inferred_type != "string":
-                    raise TypeError(
-                        "Cannot serialize the column [{item}] because\n"
-                        "its data contents are [{type}] object dtype".format(
-                            item=item, type=inferred_type
-                        )
-                    )
+        else:
+            atom = cls.get_atom_data(shape, kind=dtype.name)
 
-        # itemsize is the maximum length of a string (along any dimension)
-        data_converted = _convert_string_array(data, encoding, errors)
-        itemsize = data_converted.itemsize
+        return atom
 
-        # specified min_itemsize?
-        if isinstance(min_itemsize, dict):
-            min_itemsize = int(
-                min_itemsize.get(self.name) or min_itemsize.get("values") or 0
-            )
-        itemsize = max(min_itemsize or 0, itemsize)
-
-        # check for column in the values conflicts
-        if existing_col is not None:
-            eci = existing_col.validate_col(itemsize)
-            if eci > itemsize:
-                itemsize = eci
-
-        self.itemsize = itemsize
-        self.kind = "string"
-        self.typ = self.get_atom_string(block, itemsize)
-        self.set_data(
-            data_converted.astype("|S{size}".format(size=itemsize), copy=False)
-        )
+    @classmethod
+    def get_atom_string(cls, shape, itemsize):
+        return _tables().StringCol(itemsize=itemsize, shape=shape[0])
 
-    def get_atom_coltype(self, kind=None):
+    @classmethod
+    def get_atom_coltype(cls, kind: str) -> Type["Col"]:
         """ return the PyTables column class for this column """
-        if kind is None:
-            kind = self.kind
-        if self.kind.startswith("uint"):
-            col_name = "UInt{name}Col".format(name=kind[4:])
+        if kind.startswith("uint"):
+            k4 = kind[4:]
+            col_name = f"UInt{k4}Col"
+        elif kind.startswith("period"):
+            # we store as integer
+            col_name = "Int64Col"
         else:
-            col_name = "{name}Col".format(name=kind.capitalize())
+            kcap = kind.capitalize()
+            col_name = f"{kcap}Col"
 
         return getattr(_tables(), col_name)
 
-    def get_atom_data(self, block, kind=None):
-        return self.get_atom_coltype(kind=kind)(shape=block.shape[0])
-
-    def set_atom_complex(self, block):
-        self.kind = block.dtype.name
-        itemsize = int(self.kind.split("complex")[-1]) // 8
-        self.typ = _tables().ComplexCol(itemsize=itemsize, shape=block.shape[0])
-        self.set_data(block.values.astype(self.typ.type, copy=False))
-
-    def set_atom_data(self, block):
-        self.kind = block.dtype.name
-        self.typ = self.get_atom_data(block)
-        self.set_data(block.values.astype(self.typ.type, copy=False))
-
-    def set_atom_categorical(self, block, items, info=None, values=None):
-        # currently only supports a 1-D categorical
-        # in a 1-D block
-
-        values = block.values
-        codes = values.codes
-        self.kind = "integer"
-        self.dtype = codes.dtype.name
-        if values.ndim > 1:
-            raise NotImplementedError("only support 1-d categoricals")
-        if len(items) > 1:
-            raise NotImplementedError("only support single block categoricals")
-
-        # write the codes; must be in a block shape
-        self.ordered = values.ordered
-        self.typ = self.get_atom_data(block, kind=codes.dtype.name)
-        self.set_data(_block_shape(codes))
-
-        # write the categories
-        self.meta = "category"
-        self.set_metadata(block.values.categories)
-
-        # update the info
-        self.update_info(info)
-
-    def get_atom_datetime64(self, block):
-        return _tables().Int64Col(shape=block.shape[0])
-
-    def set_atom_datetime64(self, block, values=None):
-        self.kind = "datetime64"
-        self.typ = self.get_atom_datetime64(block)
-        if values is None:
-            values = block.values.view("i8")
-        self.set_data(values, "datetime64")
-
-    def set_atom_datetime64tz(self, block, info, values=None):
-
-        if values is None:
-            values = block.values
-
-        # convert this column to i8 in UTC, and save the tz
-        values = values.asi8.reshape(block.shape)
-
-        # store a converted timezone
-        self.tz = _get_tz(block.values.tz)
-        self.update_info(info)
-
-        self.kind = "datetime64"
-        self.typ = self.get_atom_datetime64(block)
-        self.set_data(values, "datetime64")
-
-    def get_atom_timedelta64(self, block):
-        return _tables().Int64Col(shape=block.shape[0])
-
-    def set_atom_timedelta64(self, block, values=None):
-        self.kind = "timedelta64"
-        self.typ = self.get_atom_timedelta64(block)
-        if values is None:
-            values = block.values.view("i8")
-        self.set_data(values, "timedelta64")
+    @classmethod
+    def get_atom_data(cls, shape, kind: str) -> "Col":
+        return cls.get_atom_coltype(kind=kind)(shape=shape[0])
 
-    @property
-    def shape(self):
-        return getattr(self.data, "shape", None)
+    @classmethod
+    def get_atom_datetime64(cls, shape):
+        return _tables().Int64Col(shape=shape[0])
+
+    @classmethod
+    def get_atom_timedelta64(cls, shape):
+        return _tables().Int64Col(shape=shape[0])
+
+    @property
+    def shape(self):
+        return getattr(self.data, "shape", None)
 
     @property
     def cvalues(self):
@@ -2351,103 +2319,118 @@ def validate_attr(self, append):
             existing_dtype = getattr(self.attrs, self.dtype_attr, None)
             if existing_dtype is not None and existing_dtype != self.dtype:
                 raise ValueError(
-                    "appended items dtype do not match existing "
-                    "items dtype in table!"
+                    "appended items dtype do not match existing items dtype in table!"
                 )
 
-    def convert(self, values, nan_rep, encoding, errors, start=None, stop=None):
-        """set the data from this selection (and convert to the correct dtype
-        if we can)
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
         """
+        Convert the data from this selection to the appropriate pandas type.
+
+        Parameters
+        ----------
+        values : np.ndarray
+        nan_rep :
+        encoding : str
+        errors : str
+
+        Returns
+        -------
+        index : listlike to become an Index
+        data : ndarraylike to become a column
+        """
+        assert isinstance(values, np.ndarray), type(values)
 
         # values is a recarray
         if values.dtype.fields is not None:
             values = values[self.cname]
 
-        self.set_data(values)
+        assert self.typ is not None
+        if self.dtype is None:
+            # Note: in tests we never have timedelta64 or datetime64,
+            #  so the _get_data_and_dtype_name may be unnecessary
+            converted, dtype_name = _get_data_and_dtype_name(values)
+            kind = _dtype_to_kind(dtype_name)
+        else:
+            converted = values
+            dtype_name = self.dtype
+            kind = self.kind
+
+        assert isinstance(converted, np.ndarray)  # for mypy
 
         # use the meta if needed
         meta = _ensure_decoded(self.meta)
+        metadata = self.metadata
+        ordered = self.ordered
+        tz = self.tz
 
+        assert dtype_name is not None
         # convert to the correct dtype
-        if self.dtype is not None:
-            dtype = _ensure_decoded(self.dtype)
+        dtype = _ensure_decoded(dtype_name)
 
-            # reverse converts
-            if dtype == "datetime64":
+        # reverse converts
+        if dtype == "datetime64":
 
-                # recreate with tz if indicated
-                self.data = _set_tz(self.data, self.tz, coerce=True)
+            # recreate with tz if indicated
+            converted = _set_tz(converted, tz, coerce=True)
 
-            elif dtype == "timedelta64":
-                self.data = np.asarray(self.data, dtype="m8[ns]")
-            elif dtype == "date":
-                try:
-                    self.data = np.asarray(
-                        [date.fromordinal(v) for v in self.data], dtype=object
-                    )
-                except ValueError:
-                    self.data = np.asarray(
-                        [date.fromtimestamp(v) for v in self.data], dtype=object
-                    )
-            elif dtype == "datetime":
-                self.data = np.asarray(
-                    [datetime.fromtimestamp(v) for v in self.data], dtype=object
+        elif dtype == "timedelta64":
+            converted = np.asarray(converted, dtype="m8[ns]")
+        elif dtype == "date":
+            try:
+                converted = np.asarray(
+                    [date.fromordinal(v) for v in converted], dtype=object
                 )
-
-            elif meta == "category":
-
-                # we have a categorical
-                categories = self.metadata
-                codes = self.data.ravel()
-
-                # if we have stored a NaN in the categories
-                # then strip it; in theory we could have BOTH
-                # -1s in the codes and nulls :<
-                if categories is None:
-                    # Handle case of NaN-only categorical columns in which case
-                    # the categories are an empty array; when this is stored,
-                    # pytables cannot write a zero-len array, so on readback
-                    # the categories would be None and `read_hdf()` would fail.
-                    categories = Index([], dtype=np.float64)
-                else:
-                    mask = isna(categories)
-                    if mask.any():
-                        categories = categories[~mask]
-                        codes[codes != -1] -= mask.astype(int).cumsum().values
-
-                self.data = Categorical.from_codes(
-                    codes, categories=categories, ordered=self.ordered
+            except ValueError:
+                converted = np.asarray(
+                    [date.fromtimestamp(v) for v in converted], dtype=object
                 )
 
+        elif meta == "category":
+
+            # we have a categorical
+            categories = metadata
+            codes = converted.ravel()
+
+            # if we have stored a NaN in the categories
+            # then strip it; in theory we could have BOTH
+            # -1s in the codes and nulls :<
+            if categories is None:
+                # Handle case of NaN-only categorical columns in which case
+                # the categories are an empty array; when this is stored,
+                # pytables cannot write a zero-len array, so on readback
+                # the categories would be None and `read_hdf()` would fail.
+                categories = Index([], dtype=np.float64)
             else:
+                mask = isna(categories)
+                if mask.any():
+                    categories = categories[~mask]
+                    codes[codes != -1] -= mask.astype(int).cumsum().values
 
-                try:
-                    self.data = self.data.astype(dtype, copy=False)
-                except TypeError:
-                    self.data = self.data.astype("O", copy=False)
+            converted = Categorical.from_codes(
+                codes, categories=categories, ordered=ordered
+            )
+
+        else:
+
+            try:
+                converted = converted.astype(dtype, copy=False)
+            except TypeError:
+                converted = converted.astype("O", copy=False)
 
         # convert nans / decode
-        if _ensure_decoded(self.kind) == "string":
-            self.data = _unconvert_string_array(
-                self.data, nan_rep=nan_rep, encoding=encoding, errors=errors
+        if _ensure_decoded(kind) == "string":
+            converted = _unconvert_string_array(
+                converted, nan_rep=nan_rep, encoding=encoding, errors=errors
             )
 
-        return self
-
-    def get_attr(self):
-        """ get the data for this column """
-        self.values = getattr(self.attrs, self.kind_attr, None)
-        self.dtype = getattr(self.attrs, self.dtype_attr, None)
-        self.meta = getattr(self.attrs, self.meta_attr, None)
-        self.set_kind()
+        return self.values, converted
 
     def set_attr(self):
         """ set the data for this column """
         setattr(self.attrs, self.kind_attr, self.values)
         setattr(self.attrs, self.meta_attr, self.meta)
-        if self.dtype is not None:
-            setattr(self.attrs, self.dtype_attr, self.dtype)
+        assert self.dtype is not None
+        setattr(self.attrs, self.dtype_attr, self.dtype)
 
 
 class DataIndexableCol(DataCol):
@@ -2457,100 +2440,110 @@ class DataIndexableCol(DataCol):
 
     def validate_names(self):
         if not Index(self.values).is_object():
+            # TODO: should the message here be more specifically non-str?
             raise ValueError("cannot have non-object label DataIndexableCol")
 
-    def get_atom_string(self, block, itemsize):
+    @classmethod
+    def get_atom_string(cls, shape, itemsize):
         return _tables().StringCol(itemsize=itemsize)
 
-    def get_atom_data(self, block, kind=None):
-        return self.get_atom_coltype(kind=kind)()
+    @classmethod
+    def get_atom_data(cls, shape, kind: str) -> "Col":
+        return cls.get_atom_coltype(kind=kind)()
 
-    def get_atom_datetime64(self, block):
+    @classmethod
+    def get_atom_datetime64(cls, shape):
         return _tables().Int64Col()
 
-    def get_atom_timedelta64(self, block):
+    @classmethod
+    def get_atom_timedelta64(cls, shape):
         return _tables().Int64Col()
 
 
 class GenericDataIndexableCol(DataIndexableCol):
     """ represent a generic pytables data column """
 
-    def get_attr(self):
-        pass
+    pass
 
 
 class Fixed:
-    """ represent an object in my store
-        facilitate read/write of various types of objects
-        this is an abstract base class
-
-        Parameters
-        ----------
+    """
+    represent an object in my store
+    facilitate read/write of various types of objects
+    this is an abstract base class
 
-        parent : my parent HDFStore
-        group  : the group node where the table resides
-        """
+    Parameters
+    ----------
+    parent : HDFStore
+    group : Node
+        The group node where the table resides.
+    """
 
-    pandas_kind = None  # type: str
-    obj_type = None  # type: Type[Union[DataFrame, Series]]
-    ndim = None  # type: int
+    pandas_kind: str
+    format_type: str = "fixed"  # GH#30962 needed by dask
+    obj_type: Type[Union[DataFrame, Series]]
+    ndim: int
+    encoding: str
+    parent: HDFStore
+    group: "Node"
+    errors: str
     is_table = False
 
-    def __init__(self, parent, group, encoding=None, errors="strict", **kwargs):
+    def __init__(
+        self,
+        parent: HDFStore,
+        group: "Node",
+        encoding: str = "UTF-8",
+        errors: str = "strict",
+    ):
+        assert isinstance(parent, HDFStore), type(parent)
+        assert _table_mod is not None  # needed for mypy
+        assert isinstance(group, _table_mod.Node), type(group)
         self.parent = parent
         self.group = group
         self.encoding = _ensure_encoding(encoding)
         self.errors = errors
-        self.set_version()
 
     @property
-    def is_old_version(self):
+    def is_old_version(self) -> bool:
         return self.version[0] <= 0 and self.version[1] <= 10 and self.version[2] < 1
 
-    def set_version(self):
+    @property
+    def version(self) -> Tuple[int, int, int]:
         """ compute and set our version """
         version = _ensure_decoded(getattr(self.group._v_attrs, "pandas_version", None))
         try:
-            self.version = tuple(int(x) for x in version.split("."))
-            if len(self.version) == 2:
-                self.version = self.version + (0,)
+            version = tuple(int(x) for x in version.split("."))
+            if len(version) == 2:
+                version = version + (0,)
         except AttributeError:
-            self.version = (0, 0, 0)
+            version = (0, 0, 0)
+        return version
 
     @property
     def pandas_type(self):
         return _ensure_decoded(getattr(self.group._v_attrs, "pandas_type", None))
 
-    @property
-    def format_type(self):
-        return "fixed"
-
-    def __repr__(self):
+    def __repr__(self) -> str:
         """ return a pretty representation of myself """
         self.infer_axes()
         s = self.shape
         if s is not None:
             if isinstance(s, (list, tuple)):
-                s = "[{shape}]".format(shape=",".join(pprint_thing(x) for x in s))
-            return "{type:12.12} (shape->{shape})".format(
-                type=self.pandas_type, shape=s
-            )
+                jshape = ",".join(pprint_thing(x) for x in s)
+                s = f"[{jshape}]"
+            return f"{self.pandas_type:12.12} (shape->{s})"
         return self.pandas_type
 
     def set_object_info(self):
         """ set my pandas type & version """
         self.attrs.pandas_type = str(self.pandas_kind)
         self.attrs.pandas_version = str(_version)
-        self.set_version()
 
     def copy(self):
         new_self = copy.copy(self)
         return new_self
 
-    @property
-    def storage_obj_type(self):
-        return self.obj_type
-
     @property
     def shape(self):
         return self.nrows
@@ -2568,17 +2561,13 @@ def _filters(self):
         return self.parent._filters
 
     @property
-    def _complevel(self):
+    def _complevel(self) -> int:
         return self.parent._complevel
 
     @property
-    def _fletcher32(self):
+    def _fletcher32(self) -> bool:
         return self.parent._fletcher32
 
-    @property
-    def _complib(self):
-        return self.parent._complib
-
     @property
     def attrs(self):
         return self.group._v_attrs
@@ -2597,7 +2586,7 @@ def storable(self):
         return self.group
 
     @property
-    def is_exists(self):
+    def is_exists(self) -> bool:
         return False
 
     @property
@@ -2615,8 +2604,10 @@ def validate_version(self, where=None):
         return True
 
     def infer_axes(self):
-        """ infer the axes of my storer
-              return a boolean indicating if we have a valid storer or not """
+        """
+        infer the axes of my storer
+        return a boolean indicating if we have a valid storer or not
+        """
 
         s = self.storable
         if s is None:
@@ -2624,17 +2615,25 @@ def infer_axes(self):
         self.get_attrs()
         return True
 
-    def read(self, **kwargs):
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         raise NotImplementedError(
             "cannot read on an abstract storer: subclasses should implement"
         )
 
     def write(self, **kwargs):
         raise NotImplementedError(
-            "cannot write on an abstract storer: sublcasses should implement"
+            "cannot write on an abstract storer: subclasses should implement"
         )
 
-    def delete(self, where=None, start=None, stop=None, **kwargs):
+    def delete(
+        self, where=None, start: Optional[int] = None, stop: Optional[int] = None
+    ):
         """
         support fully deleting the node in its entirety (only) - where
         specification must be None
@@ -2651,10 +2650,10 @@ class GenericFixed(Fixed):
 
     _index_type_map = {DatetimeIndex: "datetime", PeriodIndex: "period"}
     _reverse_index_map = {v: k for k, v in _index_type_map.items()}
-    attributes = []  # type: List[str]
+    attributes: List[str] = []
 
     # indexer helpders
-    def _class_to_alias(self, cls):
+    def _class_to_alias(self, cls) -> str:
         return self._index_type_map.get(cls, "")
 
     def _alias_to_class(self, alias):
@@ -2668,7 +2667,8 @@ def _get_index_factory(self, klass):
 
             def f(values, freq=None, tz=None):
                 # data are already in UTC, localize and convert if tz present
-                result = DatetimeIndex._simple_new(values.values, name=None, freq=freq)
+                dta = DatetimeArray._simple_new(values.values, freq=freq)
+                result = DatetimeIndex._simple_new(dta, name=None)
                 if tz is not None:
                     result = result.tz_localize("UTC").tz_convert(tz)
                 return result
@@ -2677,37 +2677,30 @@ def f(values, freq=None, tz=None):
         elif klass == PeriodIndex:
 
             def f(values, freq=None, tz=None):
-                return PeriodIndex._simple_new(values, name=None, freq=freq)
+                parr = PeriodArray._simple_new(values, freq=freq)
+                return PeriodIndex._simple_new(parr, name=None)
 
             return f
 
         return klass
 
-    def validate_read(self, kwargs):
+    def validate_read(self, columns, where):
         """
-        remove table keywords from kwargs and return
         raise if any keywords are passed which are not-None
         """
-        kwargs = copy.copy(kwargs)
-
-        columns = kwargs.pop("columns", None)
         if columns is not None:
             raise TypeError(
                 "cannot pass a column specification when reading "
-                "a Fixed format store. this store must be "
-                "selected in its entirety"
+                "a Fixed format store. this store must be selected in its entirety"
             )
-        where = kwargs.pop("where", None)
         if where is not None:
             raise TypeError(
                 "cannot pass a where specification when reading "
-                "from a Fixed format store. this store must be "
-                "selected in its entirety"
+                "from a Fixed format store. this store must be selected in its entirety"
             )
-        return kwargs
 
     @property
-    def is_exists(self):
+    def is_exists(self) -> bool:
         return True
 
     def set_attrs(self):
@@ -2725,7 +2718,9 @@ def get_attrs(self):
     def write(self, obj, **kwargs):
         self.set_attrs()
 
-    def read_array(self, key, start=None, stop=None):
+    def read_array(
+        self, key: str, start: Optional[int] = None, stop: Optional[int] = None
+    ):
         """ read an array for the specified node (off of group """
         import tables
 
@@ -2737,7 +2732,7 @@ def read_array(self, key, start=None, stop=None):
         if isinstance(node, tables.VLArray):
             ret = node[0][start:stop]
         else:
-            dtype = getattr(attrs, "value_type", None)
+            dtype = _ensure_decoded(getattr(attrs, "value_type", None))
             shape = getattr(attrs, "shape", None)
 
             if shape is not None:
@@ -2749,7 +2744,8 @@ def read_array(self, key, start=None, stop=None):
             if dtype == "datetime64":
 
                 # reconstruct a timezone if indicated
-                ret = _set_tz(ret, getattr(attrs, "tz", None), coerce=True)
+                tz = getattr(attrs, "tz", None)
+                ret = _set_tz(ret, tz, coerce=True)
 
             elif dtype == "timedelta64":
                 ret = np.asarray(ret, dtype="m8[ns]")
@@ -2759,38 +2755,27 @@ def read_array(self, key, start=None, stop=None):
         else:
             return ret
 
-    def read_index(self, key, **kwargs):
-        variety = _ensure_decoded(getattr(self.attrs, "{key}_variety".format(key=key)))
+    def read_index(
+        self, key: str, start: Optional[int] = None, stop: Optional[int] = None
+    ) -> Index:
+        variety = _ensure_decoded(getattr(self.attrs, f"{key}_variety"))
 
         if variety == "multi":
-            return self.read_multi_index(key, **kwargs)
-        elif variety == "block":
-            return self.read_block_index(key, **kwargs)
-        elif variety == "sparseint":
-            return self.read_sparse_intindex(key, **kwargs)
+            return self.read_multi_index(key, start=start, stop=stop)
         elif variety == "regular":
-            _, index = self.read_index_node(getattr(self.group, key), **kwargs)
+            node = getattr(self.group, key)
+            index = self.read_index_node(node, start=start, stop=stop)
             return index
         else:  # pragma: no cover
-            raise TypeError(
-                "unrecognized index variety: {variety}".format(variety=variety)
-            )
+            raise TypeError(f"unrecognized index variety: {variety}")
 
-    def write_index(self, key, index):
+    def write_index(self, key: str, index: Index):
         if isinstance(index, MultiIndex):
-            setattr(self.attrs, "{key}_variety".format(key=key), "multi")
+            setattr(self.attrs, f"{key}_variety", "multi")
             self.write_multi_index(key, index)
-        elif isinstance(index, BlockIndex):
-            setattr(self.attrs, "{key}_variety".format(key=key), "block")
-            self.write_block_index(key, index)
-        elif isinstance(index, IntIndex):
-            setattr(self.attrs, "{key}_variety".format(key=key), "sparseint")
-            self.write_sparse_intindex(key, index)
         else:
-            setattr(self.attrs, "{key}_variety".format(key=key), "regular")
-            converted = _convert_index(
-                index, self.encoding, self.errors, self.format_type
-            ).set_name("index")
+            setattr(self.attrs, f"{key}_variety", "regular")
+            converted = _convert_index("index", index, self.encoding, self.errors)
 
             self.write_array(key, converted.values)
 
@@ -2801,90 +2786,68 @@ def write_index(self, key, index):
             if isinstance(index, (DatetimeIndex, PeriodIndex)):
                 node._v_attrs.index_class = self._class_to_alias(type(index))
 
-            if hasattr(index, "freq"):
+            if isinstance(index, (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
                 node._v_attrs.freq = index.freq
 
-            if hasattr(index, "tz") and index.tz is not None:
+            if isinstance(index, DatetimeIndex) and index.tz is not None:
                 node._v_attrs.tz = _get_tz(index.tz)
 
-    def write_block_index(self, key, index):
-        self.write_array("{key}_blocs".format(key=key), index.blocs)
-        self.write_array("{key}_blengths".format(key=key), index.blengths)
-        setattr(self.attrs, "{key}_length".format(key=key), index.length)
-
-    def read_block_index(self, key, **kwargs):
-        length = getattr(self.attrs, "{key}_length".format(key=key))
-        blocs = self.read_array("{key}_blocs".format(key=key), **kwargs)
-        blengths = self.read_array("{key}_blengths".format(key=key), **kwargs)
-        return BlockIndex(length, blocs, blengths)
-
-    def write_sparse_intindex(self, key, index):
-        self.write_array("{key}_indices".format(key=key), index.indices)
-        setattr(self.attrs, "{key}_length".format(key=key), index.length)
-
-    def read_sparse_intindex(self, key, **kwargs):
-        length = getattr(self.attrs, "{key}_length".format(key=key))
-        indices = self.read_array("{key}_indices".format(key=key), **kwargs)
-        return IntIndex(length, indices)
-
-    def write_multi_index(self, key, index):
-        setattr(self.attrs, "{key}_nlevels".format(key=key), index.nlevels)
+    def write_multi_index(self, key: str, index: MultiIndex):
+        setattr(self.attrs, f"{key}_nlevels", index.nlevels)
 
         for i, (lev, level_codes, name) in enumerate(
             zip(index.levels, index.codes, index.names)
         ):
             # write the level
-            if is_extension_type(lev):
+            if is_extension_array_dtype(lev):
                 raise NotImplementedError(
                     "Saving a MultiIndex with an extension dtype is not supported."
                 )
-            level_key = "{key}_level{idx}".format(key=key, idx=i)
-            conv_level = _convert_index(
-                lev, self.encoding, self.errors, self.format_type
-            ).set_name(level_key)
+            level_key = f"{key}_level{i}"
+            conv_level = _convert_index(level_key, lev, self.encoding, self.errors)
             self.write_array(level_key, conv_level.values)
             node = getattr(self.group, level_key)
             node._v_attrs.kind = conv_level.kind
             node._v_attrs.name = name
 
             # write the name
-            setattr(node._v_attrs, "{key}_name{name}".format(key=key, name=name), name)
+            setattr(node._v_attrs, f"{key}_name{name}", name)
 
             # write the labels
-            label_key = "{key}_label{idx}".format(key=key, idx=i)
+            label_key = f"{key}_label{i}"
             self.write_array(label_key, level_codes)
 
-    def read_multi_index(self, key, **kwargs):
-        nlevels = getattr(self.attrs, "{key}_nlevels".format(key=key))
+    def read_multi_index(
+        self, key: str, start: Optional[int] = None, stop: Optional[int] = None
+    ) -> MultiIndex:
+        nlevels = getattr(self.attrs, f"{key}_nlevels")
 
         levels = []
         codes = []
-        names = []
+        names: List[Optional[Hashable]] = []
         for i in range(nlevels):
-            level_key = "{key}_level{idx}".format(key=key, idx=i)
-            name, lev = self.read_index_node(getattr(self.group, level_key), **kwargs)
+            level_key = f"{key}_level{i}"
+            node = getattr(self.group, level_key)
+            lev = self.read_index_node(node, start=start, stop=stop)
             levels.append(lev)
-            names.append(name)
+            names.append(lev.name)
 
-            label_key = "{key}_label{idx}".format(key=key, idx=i)
-            level_codes = self.read_array(label_key, **kwargs)
+            label_key = f"{key}_label{i}"
+            level_codes = self.read_array(label_key, start=start, stop=stop)
             codes.append(level_codes)
 
         return MultiIndex(
             levels=levels, codes=codes, names=names, verify_integrity=True
         )
 
-    def read_index_node(self, node, start=None, stop=None):
+    def read_index_node(
+        self, node: "Node", start: Optional[int] = None, stop: Optional[int] = None
+    ) -> Index:
         data = node[start:stop]
         # If the index was an empty array write_array_empty() will
         # have written a sentinel. Here we relace it with the original.
-        if "shape" in node._v_attrs and self._is_empty_array(
-            getattr(node._v_attrs, "shape")
-        ):
-            data = np.empty(
-                getattr(node._v_attrs, "shape"),
-                dtype=getattr(node._v_attrs, "value_type"),
-            )
+        if "shape" in node._v_attrs and np.prod(node._v_attrs.shape) == 0:
+            data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type,)
         kind = _ensure_decoded(node._v_attrs.kind)
         name = None
 
@@ -2909,51 +2872,52 @@ def read_index_node(self, node, start=None, stop=None):
                 # created by python3
                 kwargs["tz"] = node._v_attrs["tz"]
 
-        if kind in ("date", "datetime"):
+        if kind == "date":
             index = factory(
                 _unconvert_index(
                     data, kind, encoding=self.encoding, errors=self.errors
                 ),
                 dtype=object,
-                **kwargs
+                **kwargs,
             )
         else:
             index = factory(
                 _unconvert_index(
                     data, kind, encoding=self.encoding, errors=self.errors
                 ),
-                **kwargs
+                **kwargs,
             )
 
         index.name = name
 
-        return name, index
+        return index
 
-    def write_array_empty(self, key, value):
+    def write_array_empty(self, key: str, value: ArrayLike):
         """ write a 0-len array """
 
         # ugly hack for length 0 axes
         arr = np.empty((1,) * value.ndim)
         self._handle.create_array(self.group, key, arr)
-        getattr(self.group, key)._v_attrs.value_type = str(value.dtype)
-        getattr(self.group, key)._v_attrs.shape = value.shape
+        node = getattr(self.group, key)
+        node._v_attrs.value_type = str(value.dtype)
+        node._v_attrs.shape = value.shape
 
-    def _is_empty_array(self, shape):
-        """Returns true if any axis is zero length."""
-        return any(x == 0 for x in shape)
+    def write_array(self, key: str, value: ArrayLike, items: Optional[Index] = None):
+        # TODO: we only have one test that gets here, the only EA
+        #  that gets passed is DatetimeArray, and we never have
+        #  both self._filters and EA
+        assert isinstance(value, (np.ndarray, ABCExtensionArray)), type(value)
 
-    def write_array(self, key, value, items=None):
         if key in self.group:
             self._handle.remove_node(self.group, key)
 
         # Transform needed to interface with pytables row/col notation
-        empty_array = self._is_empty_array(value.shape)
+        empty_array = value.size == 0
         transposed = False
 
         if is_categorical_dtype(value):
             raise NotImplementedError(
-                "Cannot store a category dtype in "
-                "a HDF5 dataset that uses format="
+                "Cannot store a category dtype in a HDF5 dataset that uses format="
                 '"fixed". Use format="table".'
             )
         if not empty_array:
@@ -2962,29 +2926,29 @@ def write_array(self, key, value, items=None):
                 value = value.T
                 transposed = True
 
+        atom = None
         if self._filters is not None:
-            atom = None
             try:
                 # get the atom for this datatype
                 atom = _tables().Atom.from_dtype(value.dtype)
             except ValueError:
                 pass
 
-            if atom is not None:
-                # create an empty chunked array and fill it from value
-                if not empty_array:
-                    ca = self._handle.create_carray(
-                        self.group, key, atom, value.shape, filters=self._filters
-                    )
-                    ca[:] = value
-                    getattr(self.group, key)._v_attrs.transposed = transposed
+        if atom is not None:
+            # We only get here if self._filters is non-None and
+            #  the Atom.from_dtype call succeeded
 
-                else:
-                    self.write_array_empty(key, value)
+            # create an empty chunked array and fill it from value
+            if not empty_array:
+                ca = self._handle.create_carray(
+                    self.group, key, atom, value.shape, filters=self._filters
+                )
+                ca[:] = value
 
-                return
+            else:
+                self.write_array_empty(key, value)
 
-        if value.dtype.type == np.object_:
+        elif value.dtype.type == np.object_:
 
             # infer the type, warn if we have a non-string type here (for
             # performance)
@@ -2994,81 +2958,57 @@ def write_array(self, key, value, items=None):
             elif inferred_type == "string":
                 pass
             else:
-                try:
-                    items = list(items)
-                except TypeError:
-                    pass
                 ws = performance_doc % (inferred_type, key, items)
                 warnings.warn(ws, PerformanceWarning, stacklevel=7)
 
             vlarr = self._handle.create_vlarray(self.group, key, _tables().ObjectAtom())
             vlarr.append(value)
-        else:
-            if empty_array:
-                self.write_array_empty(key, value)
-            else:
-                if is_datetime64_dtype(value.dtype):
-                    self._handle.create_array(self.group, key, value.view("i8"))
-                    getattr(self.group, key)._v_attrs.value_type = "datetime64"
-                elif is_datetime64tz_dtype(value.dtype):
-                    # store as UTC
-                    # with a zone
-                    self._handle.create_array(self.group, key, value.asi8)
-
-                    node = getattr(self.group, key)
-                    node._v_attrs.tz = _get_tz(value.tz)
-                    node._v_attrs.value_type = "datetime64"
-                elif is_timedelta64_dtype(value.dtype):
-                    self._handle.create_array(self.group, key, value.view("i8"))
-                    getattr(self.group, key)._v_attrs.value_type = "timedelta64"
-                else:
-                    self._handle.create_array(self.group, key, value)
-
-        getattr(self.group, key)._v_attrs.transposed = transposed
 
+        elif empty_array:
+            self.write_array_empty(key, value)
+        elif is_datetime64_dtype(value.dtype):
+            self._handle.create_array(self.group, key, value.view("i8"))
+            getattr(self.group, key)._v_attrs.value_type = "datetime64"
+        elif is_datetime64tz_dtype(value.dtype):
+            # store as UTC
+            # with a zone
+            self._handle.create_array(self.group, key, value.asi8)
 
-class LegacyFixed(GenericFixed):
-    def read_index_legacy(self, key, start=None, stop=None):
-        node = getattr(self.group, key)
-        data = node[start:stop]
-        kind = node._v_attrs.kind
-        return _unconvert_index_legacy(
-            data, kind, encoding=self.encoding, errors=self.errors
-        )
-
-
-class LegacySeriesFixed(LegacyFixed):
-    def read(self, **kwargs):
-        kwargs = self.validate_read(kwargs)
-        index = self.read_index_legacy("index")
-        values = self.read_array("values")
-        return Series(values, index=index)
-
+            node = getattr(self.group, key)
+            node._v_attrs.tz = _get_tz(value.tz)
+            node._v_attrs.value_type = "datetime64"
+        elif is_timedelta64_dtype(value.dtype):
+            self._handle.create_array(self.group, key, value.view("i8"))
+            getattr(self.group, key)._v_attrs.value_type = "timedelta64"
+        else:
+            self._handle.create_array(self.group, key, value)
 
-class LegacyFrameFixed(LegacyFixed):
-    def read(self, **kwargs):
-        kwargs = self.validate_read(kwargs)
-        index = self.read_index_legacy("index")
-        columns = self.read_index_legacy("columns")
-        values = self.read_array("values")
-        return DataFrame(values, index=index, columns=columns)
+        getattr(self.group, key)._v_attrs.transposed = transposed
 
 
 class SeriesFixed(GenericFixed):
     pandas_kind = "series"
     attributes = ["name"]
 
+    name: Optional[Hashable]
+
     @property
     def shape(self):
         try:
-            return (len(getattr(self.group, "values")),)
+            return (len(self.group.values),)
         except (TypeError, AttributeError):
             return None
 
-    def read(self, **kwargs):
-        kwargs = self.validate_read(kwargs)
-        index = self.read_index("index", **kwargs)
-        values = self.read_array("values", **kwargs)
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
+        self.validate_read(columns, where)
+        index = self.read_index("index", start=start, stop=stop)
+        values = self.read_array("values", start=start, stop=stop)
         return Series(values, index=index, name=self.name)
 
     def write(self, obj, **kwargs):
@@ -3078,86 +3018,10 @@ def write(self, obj, **kwargs):
         self.attrs.name = obj.name
 
 
-class SparseFixed(GenericFixed):
-    def validate_read(self, kwargs):
-        """
-        we don't support start, stop kwds in Sparse
-        """
-        kwargs = super().validate_read(kwargs)
-        if "start" in kwargs or "stop" in kwargs:
-            raise NotImplementedError(
-                "start and/or stop are not supported in fixed Sparse reading"
-            )
-        return kwargs
-
-
-class SparseSeriesFixed(SparseFixed):
-    pandas_kind = "sparse_series"
-    attributes = ["name", "fill_value", "kind"]
-
-    def read(self, **kwargs):
-        kwargs = self.validate_read(kwargs)
-        index = self.read_index("index")
-        sp_values = self.read_array("sp_values")
-        sp_index = self.read_index("sp_index")
-        return SparseSeries(
-            sp_values,
-            index=index,
-            sparse_index=sp_index,
-            kind=self.kind or "block",
-            fill_value=self.fill_value,
-            name=self.name,
-        )
-
-    def write(self, obj, **kwargs):
-        super().write(obj, **kwargs)
-        self.write_index("index", obj.index)
-        self.write_index("sp_index", obj.sp_index)
-        self.write_array("sp_values", obj.sp_values)
-        self.attrs.name = obj.name
-        self.attrs.fill_value = obj.fill_value
-        self.attrs.kind = obj.kind
-
-
-class SparseFrameFixed(SparseFixed):
-    pandas_kind = "sparse_frame"
-    attributes = ["default_kind", "default_fill_value"]
-
-    def read(self, **kwargs):
-        kwargs = self.validate_read(kwargs)
-        columns = self.read_index("columns")
-        sdict = {}
-        for c in columns:
-            key = "sparse_series_{columns}".format(columns=c)
-            s = SparseSeriesFixed(self.parent, getattr(self.group, key))
-            s.infer_axes()
-            sdict[c] = s.read()
-        return SparseDataFrame(
-            sdict,
-            columns=columns,
-            default_kind=self.default_kind,
-            default_fill_value=self.default_fill_value,
-        )
-
-    def write(self, obj, **kwargs):
-        """ write it as a collection of individual sparse series """
-        super().write(obj, **kwargs)
-        for name, ss in obj.items():
-            key = "sparse_series_{name}".format(name=name)
-            if key not in self.group._v_children:
-                node = self._handle.create_group(self.group, key)
-            else:
-                node = getattr(self.group, key)
-            s = SparseSeriesFixed(self.parent, node)
-            s.write(ss)
-        self.attrs.default_fill_value = obj.default_fill_value
-        self.attrs.default_kind = obj.default_kind
-        self.write_index("columns", obj.columns)
-
-
 class BlockManagerFixed(GenericFixed):
     attributes = ["ndim", "nblocks"]
-    is_shape_reversed = False
+
+    nblocks: int
 
     @property
     def shape(self):
@@ -3167,13 +3031,13 @@ def shape(self):
             # items
             items = 0
             for i in range(self.nblocks):
-                node = getattr(self.group, "block{idx}_items".format(idx=i))
+                node = getattr(self.group, f"block{i}_items")
                 shape = getattr(node, "shape", None)
                 if shape is not None:
                     items += shape[0]
 
             # data shape
-            node = getattr(self.group, "block0_values")
+            node = self.group.block0_values
             shape = getattr(node, "shape", None)
             if shape is not None:
                 shape = list(shape[0 : (ndim - 1)])
@@ -3182,41 +3046,46 @@ def shape(self):
 
             shape.append(items)
 
-            # hacky - this works for frames, but is reversed for panels
-            if self.is_shape_reversed:
-                shape = shape[::-1]
-
             return shape
         except AttributeError:
             return None
 
-    def read(self, start=None, stop=None, **kwargs):
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         # start, stop applied to rows, so 0th axis only
-
-        kwargs = self.validate_read(kwargs)
+        self.validate_read(columns, where)
         select_axis = self.obj_type()._get_block_manager_axis(0)
 
         axes = []
         for i in range(self.ndim):
 
             _start, _stop = (start, stop) if i == select_axis else (None, None)
-            ax = self.read_index("axis{idx}".format(idx=i), start=_start, stop=_stop)
+            ax = self.read_index(f"axis{i}", start=_start, stop=_stop)
             axes.append(ax)
 
         items = axes[0]
-        blocks = []
+        dfs = []
+
         for i in range(self.nblocks):
 
-            blk_items = self.read_index("block{idx}_items".format(idx=i))
-            values = self.read_array(
-                "block{idx}_values".format(idx=i), start=_start, stop=_stop
-            )
-            blk = make_block(
-                values, placement=items.get_indexer(blk_items), ndim=len(axes)
-            )
-            blocks.append(blk)
+            blk_items = self.read_index(f"block{i}_items")
+            values = self.read_array(f"block{i}_values", start=_start, stop=_stop)
+
+            columns = items[items.get_indexer(blk_items)]
+            df = DataFrame(values.T, columns=columns, index=axes[1])
+            dfs.append(df)
+
+        if len(dfs) > 0:
+            out = concat(dfs, axis=1)
+            out = out.reindex(columns=items, copy=False)
+            return out
 
-        return self.obj_type(BlockManager(blocks, axes))
+        return DataFrame(columns=axes[0], index=axes[1])
 
     def write(self, obj, **kwargs):
         super().write(obj, **kwargs)
@@ -3229,17 +3098,15 @@ def write(self, obj, **kwargs):
             if i == 0:
                 if not ax.is_unique:
                     raise ValueError("Columns index has to be unique for fixed format")
-            self.write_index("axis{idx}".format(idx=i), ax)
+            self.write_index(f"axis{i}", ax)
 
         # Supporting mixed-type DataFrame objects...nontrivial
         self.attrs.nblocks = len(data.blocks)
         for i, blk in enumerate(data.blocks):
             # I have no idea why, but writing values before items fixed #2299
             blk_items = data.items.take(blk.mgr_locs)
-            self.write_array(
-                "block{idx}_values".format(idx=i), blk.values, items=blk_items
-            )
-            self.write_index("block{idx}_items".format(idx=i), blk_items)
+            self.write_array(f"block{i}_values", blk.values, items=blk_items)
+            self.write_index(f"block{i}_items", blk_items)
 
 
 class FrameFixed(BlockManagerFixed):
@@ -3248,80 +3115,87 @@ class FrameFixed(BlockManagerFixed):
 
 
 class Table(Fixed):
-    """ represent a table:
-          facilitate read/write of various types of tables
-
-        Attrs in Table Node
-        -------------------
-        These are attributes that are store in the main table node, they are
-        necessary to recreate these tables when read back in.
-
-        index_axes    : a list of tuples of the (original indexing axis and
-            index column)
-        non_index_axes: a list of tuples of the (original index axis and
-            columns on a non-indexing axis)
-        values_axes   : a list of the columns which comprise the data of this
-            table
-        data_columns  : a list of the columns that we are allowing indexing
-            (these become single columns in values_axes), or True to force all
-            columns
-        nan_rep       : the string to use for nan representations for string
-            objects
-        levels        : the names of levels
-        metadata      : the names of the metadata columns
-
-        """
+    """
+    represent a table:
+        facilitate read/write of various types of tables
+
+    Attrs in Table Node
+    -------------------
+    These are attributes that are store in the main table node, they are
+    necessary to recreate these tables when read back in.
+
+    index_axes    : a list of tuples of the (original indexing axis and
+        index column)
+    non_index_axes: a list of tuples of the (original index axis and
+        columns on a non-indexing axis)
+    values_axes   : a list of the columns which comprise the data of this
+        table
+    data_columns  : a list of the columns that we are allowing indexing
+        (these become single columns in values_axes), or True to force all
+        columns
+    nan_rep       : the string to use for nan representations for string
+        objects
+    levels        : the names of levels
+    metadata      : the names of the metadata columns
+    """
 
     pandas_kind = "wide_table"
-    table_type = None  # type: str
+    format_type: str = "table"  # GH#30962 needed by dask
+    table_type: str
     levels = 1
     is_table = True
-    is_shape_reversed = False
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.index_axes = []
-        self.non_index_axes = []
-        self.values_axes = []
-        self.data_columns = []
-        self.metadata = []
-        self.info = dict()
-        self.nan_rep = None
-        self.selection = None
+    index_axes: List[IndexCol]
+    non_index_axes: List[Tuple[int, Any]]
+    values_axes: List[DataCol]
+    data_columns: List
+    metadata: List
+    info: Dict
 
-    @property
-    def table_type_short(self):
-        return self.table_type.split("_")[0]
+    def __init__(
+        self,
+        parent: HDFStore,
+        group: "Node",
+        encoding=None,
+        errors: str = "strict",
+        index_axes=None,
+        non_index_axes=None,
+        values_axes=None,
+        data_columns=None,
+        info=None,
+        nan_rep=None,
+    ):
+        super().__init__(parent, group, encoding=encoding, errors=errors)
+        self.index_axes = index_axes or []
+        self.non_index_axes = non_index_axes or []
+        self.values_axes = values_axes or []
+        self.data_columns = data_columns or []
+        self.info = info or dict()
+        self.nan_rep = nan_rep
 
     @property
-    def format_type(self):
-        return "table"
+    def table_type_short(self) -> str:
+        return self.table_type.split("_")[0]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """ return a pretty representation of myself """
         self.infer_axes()
-        dc = ",dc->[{columns}]".format(
-            columns=(",".join(self.data_columns) if len(self.data_columns) else "")
-        )
+        jdc = ",".join(self.data_columns) if len(self.data_columns) else ""
+        dc = f",dc->[{jdc}]"
 
         ver = ""
         if self.is_old_version:
-            ver = "[{version}]".format(version=".".join(str(x) for x in self.version))
+            jver = ".".join(str(x) for x in self.version)
+            ver = f"[{jver}]"
 
+        jindex_axes = ",".join(a.name for a in self.index_axes)
         return (
-            "{pandas_type:12.12}{ver} (typ->{table_type},nrows->{nrows},"
-            "ncols->{ncols},indexers->[{index_axes}]{dc})".format(
-                pandas_type=self.pandas_type,
-                ver=ver,
-                table_type=self.table_type_short,
-                nrows=self.nrows,
-                ncols=self.ncols,
-                index_axes=(",".join(a.name for a in self.index_axes)),
-                dc=dc,
-            )
+            f"{self.pandas_type:12.12}{ver} "
+            f"(typ->{self.table_type_short},nrows->{self.nrows},"
+            f"ncols->{self.ncols},indexers->[{jindex_axes}]{dc})"
         )
 
-    def __getitem__(self, c):
+    def __getitem__(self, c: str):
         """ return the axis for c """
         for a in self.axes:
             if c == a.name:
@@ -3336,9 +3210,7 @@ def validate(self, other):
         if other.table_type != self.table_type:
             raise TypeError(
                 "incompatible table_type with existing "
-                "[{other} - {self}]".format(
-                    other=other.table_type, self=self.table_type
-                )
+                f"[{other.table_type} - {self.table_type}]"
             )
 
         for c in ["index_axes", "non_index_axes", "values_axes"]:
@@ -3351,34 +3223,27 @@ def validate(self, other):
                     oax = ov[i]
                     if sax != oax:
                         raise ValueError(
-                            "invalid combinate of [{c}] on appending data "
-                            "[{sax}] vs current table [{oax}]".format(
-                                c=c, sax=sax, oax=oax
-                            )
+                            f"invalid combination of [{c}] on appending data "
+                            f"[{sax}] vs current table [{oax}]"
                         )
 
                 # should never get here
                 raise Exception(
-                    "invalid combinate of [{c}] on appending data [{sv}] vs "
-                    "current table [{ov}]".format(c=c, sv=sv, ov=ov)
+                    f"invalid combination of [{c}] on appending data [{sv}] vs "
+                    f"current table [{ov}]"
                 )
 
     @property
-    def is_multi_index(self):
+    def is_multi_index(self) -> bool:
         """the levels attribute is 1 or a list in the case of a multi-index"""
         return isinstance(self.levels, list)
 
-    def validate_metadata(self, existing):
-        """ create / validate metadata """
-        self.metadata = [c.name for c in self.values_axes if c.metadata is not None]
-
     def validate_multiindex(self, obj):
         """validate that we can store the multi-index; reset and return the
         new object
         """
         levels = [
-            l if l is not None else "level_{0}".format(i)
-            for i, l in enumerate(obj.index.names)
+            l if l is not None else f"level_{i}" for i, l in enumerate(obj.index.names)
         ]
         try:
             return obj.reset_index(), levels
@@ -3388,12 +3253,12 @@ def validate_multiindex(self, obj):
             )
 
     @property
-    def nrows_expected(self):
+    def nrows_expected(self) -> int:
         """ based on our axes, compute the expected nrows """
         return np.prod([i.cvalues.shape[0] for i in self.index_axes])
 
     @property
-    def is_exists(self):
+    def is_exists(self) -> bool:
         """ has this table been created """
         return "table" in self.group
 
@@ -3419,12 +3284,12 @@ def axes(self):
         return itertools.chain(self.index_axes, self.values_axes)
 
     @property
-    def ncols(self):
+    def ncols(self) -> int:
         """ the number of total columns in the values axes """
         return sum(len(a.values) for a in self.values_axes)
 
     @property
-    def is_transposed(self):
+    def is_transposed(self) -> bool:
         return False
 
     @property
@@ -3437,44 +3302,45 @@ def data_orientation(self):
             )
         )
 
-    def queryables(self):
+    def queryables(self) -> Dict[str, Any]:
         """ return a dict of the kinds allowable columns for this object """
 
+        # mypy doesn't recognize DataFrame._AXIS_NAMES, so we re-write it here
+        axis_names = {0: "index", 1: "columns"}
+
         # compute the values_axes queryables
-        return dict(
-            [(a.cname, a) for a in self.index_axes]
-            + [
-                (self.storage_obj_type._AXIS_NAMES[axis], None)
-                for axis, values in self.non_index_axes
-            ]
-            + [
-                (v.cname, v)
-                for v in self.values_axes
-                if v.name in set(self.data_columns)
-            ]
-        )
+        d1 = [(a.cname, a) for a in self.index_axes]
+        d2 = [(axis_names[axis], None) for axis, values in self.non_index_axes]
+        d3 = [
+            (v.cname, v) for v in self.values_axes if v.name in set(self.data_columns)
+        ]
+
+        return dict(d1 + d2 + d3)  # type: ignore
+        # error: List comprehension has incompatible type
+        #  List[Tuple[Any, None]]; expected List[Tuple[str, IndexCol]]
 
     def index_cols(self):
         """ return a list of my index cols """
+        # Note: each `i.cname` below is assured to be a str.
         return [(i.axis, i.cname) for i in self.index_axes]
 
-    def values_cols(self):
+    def values_cols(self) -> List[str]:
         """ return a list of my values cols """
         return [i.cname for i in self.values_axes]
 
-    def _get_metadata_path(self, key):
+    def _get_metadata_path(self, key: str) -> str:
         """ return the metadata pathname for this key """
-        return "{group}/meta/{key}/meta".format(group=self.group._v_pathname, key=key)
+        group = self.group._v_pathname
+        return f"{group}/meta/{key}/meta"
 
-    def write_metadata(self, key, values):
+    def write_metadata(self, key: str, values: np.ndarray):
         """
-        write out a meta data array to the key as a fixed-format Series
+        Write out a metadata array to the key as a fixed-format Series.
 
         Parameters
         ----------
-        key : string
+        key : str
         values : ndarray
-
         """
         values = Series(values)
         self.parent.put(
@@ -3486,16 +3352,12 @@ def write_metadata(self, key, values):
             nan_rep=self.nan_rep,
         )
 
-    def read_metadata(self, key):
+    def read_metadata(self, key: str):
         """ return the meta data array for this key """
         if getattr(getattr(self.group, "meta", None), key, None) is not None:
             return self.parent.select(self._get_metadata_path(key))
         return None
 
-    def set_info(self):
-        """ update our table index info """
-        self.attrs.info = self.info
-
     def set_attrs(self):
         """ set our table type & indexables """
         self.attrs.table_type = str(self.table_type)
@@ -3507,8 +3369,7 @@ def set_attrs(self):
         self.attrs.encoding = self.encoding
         self.attrs.errors = self.errors
         self.attrs.levels = self.levels
-        self.attrs.metadata = self.metadata
-        self.set_info()
+        self.attrs.info = self.info
 
     def get_attrs(self):
         """ retrieve our attributes """
@@ -3519,11 +3380,8 @@ def get_attrs(self):
         self.encoding = _ensure_encoding(getattr(self.attrs, "encoding", None))
         self.errors = _ensure_decoded(getattr(self.attrs, "errors", "strict"))
         self.levels = getattr(self.attrs, "levels", None) or []
-        self.index_axes = [a.infer(self) for a in self.indexables if a.is_an_indexable]
-        self.values_axes = [
-            a.infer(self) for a in self.indexables if not a.is_an_indexable
-        ]
-        self.metadata = getattr(self.attrs, "metadata", None) or []
+        self.index_axes = [a for a in self.indexables if a.is_an_indexable]
+        self.values_axes = [a for a in self.indexables if not a.is_an_indexable]
 
     def validate_version(self, where=None):
         """ are we trying to operate on an old version? """
@@ -3549,60 +3407,111 @@ def validate_min_itemsize(self, min_itemsize):
                 continue
             if k not in q:
                 raise ValueError(
-                    "min_itemsize has the key [{key}] which is not an axis or "
-                    "data_column".format(key=k)
+                    f"min_itemsize has the key [{k}] which is not an axis or "
+                    "data_column"
                 )
 
-    @property
+    @cache_readonly
     def indexables(self):
         """ create/cache the indexables if they don't exist """
-        if self._indexables is None:
-
-            self._indexables = []
-
-            # index columns
-            self._indexables.extend(
-                [
-                    IndexCol(name=name, axis=axis, pos=i)
-                    for i, (axis, name) in enumerate(self.attrs.index_cols)
-                ]
+        _indexables = []
+
+        desc = self.description
+        table_attrs = self.table.attrs
+
+        # Note: each of the `name` kwargs below are str, ensured
+        #  by the definition in index_cols.
+        # index columns
+        for i, (axis, name) in enumerate(self.attrs.index_cols):
+            atom = getattr(desc, name)
+            md = self.read_metadata(name)
+            meta = "category" if md is not None else None
+
+            kind_attr = f"{name}_kind"
+            kind = getattr(table_attrs, kind_attr, None)
+
+            index_col = IndexCol(
+                name=name,
+                axis=axis,
+                pos=i,
+                kind=kind,
+                typ=atom,
+                table=self.table,
+                meta=meta,
+                metadata=md,
             )
+            _indexables.append(index_col)
 
-            # values columns
-            dc = set(self.data_columns)
-            base_pos = len(self._indexables)
+        # values columns
+        dc = set(self.data_columns)
+        base_pos = len(_indexables)
 
-            def f(i, c):
-                klass = DataCol
-                if c in dc:
-                    klass = DataIndexableCol
-                return klass.create_for_block(
-                    i=i, name=c, pos=base_pos + i, version=self.version
-                )
+        def f(i, c):
+            assert isinstance(c, str)
+            klass = DataCol
+            if c in dc:
+                klass = DataIndexableCol
 
-            self._indexables.extend(
-                [f(i, c) for i, c in enumerate(self.attrs.values_cols)]
+            atom = getattr(desc, c)
+            adj_name = _maybe_adjust_name(c, self.version)
+
+            # TODO: why kind_attr here?
+            values = getattr(table_attrs, f"{adj_name}_kind", None)
+            dtype = getattr(table_attrs, f"{adj_name}_dtype", None)
+            kind = _dtype_to_kind(dtype)
+
+            md = self.read_metadata(c)
+            # TODO: figure out why these two versions of `meta` dont always match.
+            #  meta = "category" if md is not None else None
+            meta = getattr(table_attrs, f"{adj_name}_meta", None)
+
+            obj = klass(
+                name=adj_name,
+                cname=c,
+                values=values,
+                kind=kind,
+                pos=base_pos + i,
+                typ=atom,
+                table=self.table,
+                meta=meta,
+                metadata=md,
+                dtype=dtype,
             )
+            return obj
+
+        # Note: the definition of `values_cols` ensures that each
+        #  `c` below is a str.
+        _indexables.extend([f(i, c) for i, c in enumerate(self.attrs.values_cols)])
 
-        return self._indexables
+        return _indexables
 
-    def create_index(self, columns=None, optlevel=None, kind=None):
+    def create_index(self, columns=None, optlevel=None, kind: Optional[str] = None):
         """
-        Create a pytables index on the specified columns
-          note: cannot index Time64Col() or ComplexCol currently;
-          PyTables must be >= 3.0
+        Create a pytables index on the specified columns.
 
         Parameters
         ----------
-        columns : False (don't create an index), True (create all columns
-            index), None or list_like (the indexers to index)
-        optlevel: optimization level (defaults to 6)
-        kind    : kind of index (defaults to 'medium')
+        columns : None, bool, or listlike[str]
+            Indicate which columns to create an index on.
+
+            * False : Do not create any indexes.
+            * True : Create indexes on all columns.
+            * None : Create indexes on all columns.
+            * listlike : Create indexes on the given columns.
+
+        optlevel : int or None, default None
+            Optimization level, if None, pytables defaults to 6.
+        kind : str or None, default None
+            Kind of index, if None, pytables defaults to "medium".
 
         Raises
         ------
-        raises if the node is not a table
+        TypeError if trying to create an index on a complex-type column.
 
+        Notes
+        -----
+        Cannot index Time64Col or ComplexCol.
+        Pytables must be >= 3.0.
         """
 
         if not self.infer_axes():
@@ -3647,65 +3556,68 @@ def create_index(self, columns=None, optlevel=None, kind=None):
                 if not v.is_indexed:
                     if v.type.startswith("complex"):
                         raise TypeError(
-                            "Columns containing complex values can be stored "
-                            "but cannot"
-                            " be indexed when using table format. Either use "
+                            "Columns containing complex values can be stored but "
+                            "cannot be indexed when using table format. Either use "
                             "fixed format, set index=False, or do not include "
                             "the columns containing complex values to "
                             "data_columns when initializing the table."
                         )
                     v.create_index(**kw)
 
-    def read_axes(self, where, **kwargs):
-        """create and return the axes sniffed from the table: return boolean
-        for success
+    def _read_axes(
+        self, where, start: Optional[int] = None, stop: Optional[int] = None
+    ) -> List[Tuple[ArrayLike, ArrayLike]]:
         """
+        Create the axes sniffed from the table.
 
-        # validate the version
-        self.validate_version(where)
+        Parameters
+        ----------
+        where : ???
+        start : int or None, default None
+        stop : int or None, default None
 
-        # infer the data kind
-        if not self.infer_axes():
-            return False
+        Returns
+        -------
+        List[Tuple[index_values, column_values]]
+        """
 
         # create the selection
-        self.selection = Selection(self, where=where, **kwargs)
-        values = self.selection.select()
+        selection = Selection(self, where=where, start=start, stop=stop)
+        values = selection.select()
 
+        results = []
         # convert the data
         for a in self.axes:
             a.set_info(self.info)
-            # `kwargs` may contain `start` and `stop` arguments if passed to
-            # `store.select()`. If set they determine the index size.
-            a.convert(
+            res = a.convert(
                 values,
                 nan_rep=self.nan_rep,
                 encoding=self.encoding,
                 errors=self.errors,
-                start=kwargs.get("start"),
-                stop=kwargs.get("stop"),
             )
+            results.append(res)
 
-        return True
+        return results
 
-    def get_object(self, obj):
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
         """ return the data for this obj """
         return obj
 
-    def validate_data_columns(self, data_columns, min_itemsize):
+    def validate_data_columns(self, data_columns, min_itemsize, non_index_axes):
         """take the input data_columns and min_itemize and create a data
         columns spec
         """
 
-        if not len(self.non_index_axes):
+        if not len(non_index_axes):
             return []
 
-        axis, axis_labels = self.non_index_axes[0]
+        axis, axis_labels = non_index_axes[0]
         info = self.info.get(axis, dict())
         if info.get("type") == "MultiIndex" and data_columns:
             raise ValueError(
-                "cannot use a multi-index on axis [{0}] with "
-                "data_columns {1}".format(axis, data_columns)
+                f"cannot use a multi-index on axis [{axis}] with "
+                f"data_columns {data_columns}"
             )
 
         # evaluate the passed data_columns, True == use all columns
@@ -3719,6 +3631,7 @@ def validate_data_columns(self, data_columns, min_itemsize):
         if isinstance(min_itemsize, dict):
 
             existing_data_columns = set(data_columns)
+            data_columns = list(data_columns)  # ensure we do not modify
             data_columns.extend(
                 [
                     k
@@ -3730,61 +3643,66 @@ def validate_data_columns(self, data_columns, min_itemsize):
         # return valid columns in the order of our axis
         return [c for c in data_columns if c in axis_labels]
 
-    def create_axes(
+    def _create_axes(
         self,
         axes,
-        obj,
-        validate=True,
+        obj: DataFrame,
+        validate: bool = True,
         nan_rep=None,
         data_columns=None,
         min_itemsize=None,
-        **kwargs
     ):
-        """ create and return the axes
-        legacy tables create an indexable column, indexable index,
-        non-indexable fields
-
-            Parameters
-            ----------
-            axes: a list of the axes in order to create (names or numbers of
-                the axes)
-            obj : the object to create axes on
-            validate: validate the obj against an existing object already
-                written
-            min_itemsize: a dict of the min size for a column in bytes
-            nan_rep : a values to use for string column nan_rep
-            encoding : the encoding for string values
-            data_columns : a list of columns that we want to create separate to
-                allow indexing (or True will force all columns)
+        """
+        Create and return the axes.
 
+        Parameters
+        ----------
+        axes: list or None
+            The names or numbers of the axes to create.
+        obj : DataFrame
+            The object to create axes on.
+        validate: bool, default True
+            Whether to validate the obj against an existing object already written.
+        nan_rep :
+            A value to use for string column nan_rep.
+        data_columns : List[str], True, or None, default None
+            Specify the columns that we want to create to allow indexing on.
+
+            * True : Use all available columns.
+            * None : Use no columns.
+            * List[str] : Use the specified columns.
+
+        min_itemsize: Dict[str, int] or None, default None
+            The min itemsize for a column in bytes.
         """
 
+        if not isinstance(obj, DataFrame):
+            group = self.group._v_name
+            raise TypeError(
+                f"cannot properly create the storer for: [group->{group},"
+                f"value->{type(obj)}]"
+            )
+
         # set the default axes if needed
         if axes is None:
-            try:
-                axes = _AXES_MAP[type(obj)]
-            except KeyError:
-                raise TypeError(
-                    "cannot properly create the storer for: [group->{group},"
-                    "value->{value}]".format(group=self.group._v_name, value=type(obj))
-                )
+            axes = [0]
 
         # map axes to numbers
         axes = [obj._get_axis_number(a) for a in axes]
 
         # do we have an existing table (if so, use its axes & data_columns)
         if self.infer_axes():
-            existing_table = self.copy()
-            existing_table.infer_axes()
-            axes = [a.axis for a in existing_table.index_axes]
-            data_columns = existing_table.data_columns
-            nan_rep = existing_table.nan_rep
-            self.encoding = existing_table.encoding
-            self.errors = existing_table.errors
-            self.info = copy.copy(existing_table.info)
+            table_exists = True
+            axes = [a.axis for a in self.index_axes]
+            data_columns = list(self.data_columns)
+            nan_rep = self.nan_rep
+            # TODO: do we always have validate=True here?
         else:
-            existing_table = None
+            table_exists = False
 
+        new_info = self.info
+
+        assert self.ndim == 2  # with next check, we must have len(axes) == 1
         # currently support on ndim-1 axes
         if len(axes) != self.ndim - 1:
             raise ValueError(
@@ -3792,114 +3710,76 @@ def create_axes(
             )
 
         # create according to the new data
-        self.non_index_axes = []
-        self.data_columns = []
+        new_non_index_axes: List = []
 
         # nan_representation
         if nan_rep is None:
             nan_rep = "nan"
 
-        self.nan_rep = nan_rep
+        # We construct the non-index-axis first, since that alters new_info
+        idx = [x for x in [0, 1] if x not in axes][0]
 
-        # create axes to index and non_index
-        index_axes_map = dict()
-        for i, a in enumerate(obj.axes):
+        a = obj.axes[idx]
+        # we might be able to change the axes on the appending data if necessary
+        append_axis = list(a)
+        if table_exists:
+            indexer = len(new_non_index_axes)  # i.e. 0
+            exist_axis = self.non_index_axes[indexer][1]
+            if not array_equivalent(np.array(append_axis), np.array(exist_axis)):
 
-            if i in axes:
-                name = obj._AXIS_NAMES[i]
-                index_axes_map[i] = (
-                    _convert_index(a, self.encoding, self.errors, self.format_type)
-                    .set_name(name)
-                    .set_axis(i)
-                )
-            else:
+                # ahah! -> reindex
+                if array_equivalent(
+                    np.array(sorted(append_axis)), np.array(sorted(exist_axis))
+                ):
+                    append_axis = exist_axis
 
-                # we might be able to change the axes on the appending data if
-                # necessary
-                append_axis = list(a)
-                if existing_table is not None:
-                    indexer = len(self.non_index_axes)
-                    exist_axis = existing_table.non_index_axes[indexer][1]
-                    if not array_equivalent(
-                        np.array(append_axis), np.array(exist_axis)
-                    ):
-
-                        # ahah! -> reindex
-                        if array_equivalent(
-                            np.array(sorted(append_axis)), np.array(sorted(exist_axis))
-                        ):
-                            append_axis = exist_axis
+        # the non_index_axes info
+        info = new_info.setdefault(idx, {})
+        info["names"] = list(a.names)
+        info["type"] = type(a).__name__
 
-                # the non_index_axes info
-                info = _get_info(self.info, i)
-                info["names"] = list(a.names)
-                info["type"] = a.__class__.__name__
+        new_non_index_axes.append((idx, append_axis))
 
-                self.non_index_axes.append((i, append_axis))
+        # Now we can construct our new index axis
+        idx = axes[0]
+        a = obj.axes[idx]
+        axis_name = obj._AXIS_NAMES[idx]
+        new_index = _convert_index(axis_name, a, self.encoding, self.errors)
+        new_index.axis = idx
 
-        # set axis positions (based on the axes)
-        self.index_axes = [
-            index_axes_map[a].set_pos(j).update_info(self.info)
-            for j, a in enumerate(axes)
-        ]
-        j = len(self.index_axes)
+        # Because we are always 2D, there is only one new_index, so
+        #  we know it will have pos=0
+        new_index.set_pos(0)
+        new_index.update_info(new_info)
+        new_index.maybe_set_size(min_itemsize)  # check for column conflicts
 
-        # check for column conflicts
-        for a in self.axes:
-            a.maybe_set_size(min_itemsize=min_itemsize)
+        new_index_axes = [new_index]
+        j = len(new_index_axes)  # i.e. 1
+        assert j == 1
 
         # reindex by our non_index_axes & compute data_columns
-        for a in self.non_index_axes:
+        assert len(new_non_index_axes) == 1
+        for a in new_non_index_axes:
             obj = _reindex_axis(obj, a[0], a[1])
 
         def get_blk_items(mgr, blocks):
             return [mgr.items.take(blk.mgr_locs) for blk in blocks]
 
+        transposed = new_index.axis == 1
+
         # figure out data_columns and get out blocks
-        block_obj = self.get_object(obj)._consolidate()
-        blocks = block_obj._data.blocks
-        blk_items = get_blk_items(block_obj._data, blocks)
-        if len(self.non_index_axes):
-            axis, axis_labels = self.non_index_axes[0]
-            data_columns = self.validate_data_columns(data_columns, min_itemsize)
-            if len(data_columns):
-                mgr = block_obj.reindex(
-                    Index(axis_labels).difference(Index(data_columns)), axis=axis
-                )._data
-
-                blocks = list(mgr.blocks)
-                blk_items = get_blk_items(mgr, blocks)
-                for c in data_columns:
-                    mgr = block_obj.reindex([c], axis=axis)._data
-                    blocks.extend(mgr.blocks)
-                    blk_items.extend(get_blk_items(mgr, mgr.blocks))
-
-        # reorder the blocks in the same order as the existing_table if we can
-        if existing_table is not None:
-            by_items = {
-                tuple(b_items.tolist()): (b, b_items)
-                for b, b_items in zip(blocks, blk_items)
-            }
-            new_blocks = []
-            new_blk_items = []
-            for ea in existing_table.values_axes:
-                items = tuple(ea.values)
-                try:
-                    b, b_items = by_items.pop(items)
-                    new_blocks.append(b)
-                    new_blk_items.append(b_items)
-                except (IndexError, KeyError):
-                    raise ValueError(
-                        "cannot match existing table structure for [{items}] "
-                        "on appending data".format(
-                            items=(",".join(pprint_thing(item) for item in items))
-                        )
-                    )
-            blocks = new_blocks
-            blk_items = new_blk_items
+        data_columns = self.validate_data_columns(
+            data_columns, min_itemsize, new_non_index_axes
+        )
+
+        block_obj = self.get_object(obj, transposed)._consolidate()
+
+        blocks, blk_items = self._get_blocks_and_items(
+            block_obj, table_exists, new_non_index_axes, self.values_axes, data_columns
+        )
 
         # add my values
-        self.values_axes = []
+        vaxes = []
         for i, (b, b_items) in enumerate(zip(blocks, blk_items)):
 
             # shape of the data column are the indexable axes
@@ -3910,60 +3790,144 @@ def get_blk_items(mgr, blocks):
             if data_columns and len(b_items) == 1 and b_items[0] in data_columns:
                 klass = DataIndexableCol
                 name = b_items[0]
-                self.data_columns.append(name)
+                if not (name is None or isinstance(name, str)):
+                    # TODO: should the message here be more specifically non-str?
+                    raise ValueError("cannot have non-object label DataIndexableCol")
 
             # make sure that we match up the existing columns
             # if we have an existing table
-            if existing_table is not None and validate:
+            existing_col: Optional[DataCol]
+
+            if table_exists and validate:
                 try:
-                    existing_col = existing_table.values_axes[i]
+                    existing_col = self.values_axes[i]
                 except (IndexError, KeyError):
                     raise ValueError(
-                        "Incompatible appended table [{blocks}]"
-                        "with existing table [{table}]".format(
-                            blocks=blocks, table=existing_table.values_axes
-                        )
+                        f"Incompatible appended table [{blocks}]"
+                        f"with existing table [{self.values_axes}]"
                     )
             else:
                 existing_col = None
 
-            try:
-                col = klass.create_for_block(i=i, name=name, version=self.version)
-                col.set_atom(
-                    block=b,
-                    block_items=b_items,
-                    existing_col=existing_col,
-                    min_itemsize=min_itemsize,
-                    nan_rep=nan_rep,
-                    encoding=self.encoding,
-                    errors=self.errors,
-                    info=self.info,
-                )
-                col.set_pos(j)
+            new_name = name or f"values_block_{i}"
+            data_converted = _maybe_convert_for_string_atom(
+                new_name,
+                b,
+                existing_col=existing_col,
+                min_itemsize=min_itemsize,
+                nan_rep=nan_rep,
+                encoding=self.encoding,
+                errors=self.errors,
+            )
+            adj_name = _maybe_adjust_name(new_name, self.version)
+
+            typ = klass._get_atom(data_converted)
+            kind = _dtype_to_kind(data_converted.dtype.name)
+            tz = _get_tz(data_converted.tz) if hasattr(data_converted, "tz") else None
+
+            meta = metadata = ordered = None
+            if is_categorical_dtype(data_converted):
+                ordered = data_converted.ordered
+                meta = "category"
+                metadata = np.array(data_converted.categories, copy=False).ravel()
+
+            data, dtype_name = _get_data_and_dtype_name(data_converted)
+
+            col = klass(
+                name=adj_name,
+                cname=new_name,
+                values=list(b_items),
+                typ=typ,
+                pos=j,
+                kind=kind,
+                tz=tz,
+                ordered=ordered,
+                meta=meta,
+                metadata=metadata,
+                dtype=dtype_name,
+                data=data,
+            )
+            col.update_info(new_info)
+
+            vaxes.append(col)
 
-                self.values_axes.append(col)
-            except (NotImplementedError, ValueError, TypeError) as e:
-                raise e
-            except Exception as detail:
-                raise Exception(
-                    "cannot find the correct atom type -> "
-                    "[dtype->{name},items->{items}] {detail!s}".format(
-                        name=b.dtype.name, items=b_items, detail=detail
-                    )
-                )
             j += 1
 
-        # validate our min_itemsize
-        self.validate_min_itemsize(min_itemsize)
+        dcs = [col.name for col in vaxes if col.is_data_indexable]
+
+        new_table = type(self)(
+            parent=self.parent,
+            group=self.group,
+            encoding=self.encoding,
+            errors=self.errors,
+            index_axes=new_index_axes,
+            non_index_axes=new_non_index_axes,
+            values_axes=vaxes,
+            data_columns=dcs,
+            info=new_info,
+            nan_rep=nan_rep,
+        )
+        if hasattr(self, "levels"):
+            # TODO: get this into constructor, only for appropriate subclass
+            new_table.levels = self.levels
+
+        new_table.validate_min_itemsize(min_itemsize)
+
+        if validate and table_exists:
+            new_table.validate(self)
 
-        # validate our metadata
-        self.validate_metadata(existing_table)
+        return new_table
 
-        # validate the axes if we have an existing table
-        if validate:
-            self.validate(existing_table)
+    @staticmethod
+    def _get_blocks_and_items(
+        block_obj, table_exists, new_non_index_axes, values_axes, data_columns
+    ):
+        # Helper to clarify non-state-altering parts of _create_axes
+
+        def get_blk_items(mgr, blocks):
+            return [mgr.items.take(blk.mgr_locs) for blk in blocks]
+
+        blocks = block_obj._data.blocks
+        blk_items = get_blk_items(block_obj._data, blocks)
+
+        if len(data_columns):
+            axis, axis_labels = new_non_index_axes[0]
+            new_labels = Index(axis_labels).difference(Index(data_columns))
+            mgr = block_obj.reindex(new_labels, axis=axis)._data
 
-    def process_axes(self, obj, columns=None):
+            blocks = list(mgr.blocks)
+            blk_items = get_blk_items(mgr, blocks)
+            for c in data_columns:
+                mgr = block_obj.reindex([c], axis=axis)._data
+                blocks.extend(mgr.blocks)
+                blk_items.extend(get_blk_items(mgr, mgr.blocks))
+
+        # reorder the blocks in the same order as the existing table if we can
+        if table_exists:
+            by_items = {
+                tuple(b_items.tolist()): (b, b_items)
+                for b, b_items in zip(blocks, blk_items)
+            }
+            new_blocks = []
+            new_blk_items = []
+            for ea in values_axes:
+                items = tuple(ea.values)
+                try:
+                    b, b_items = by_items.pop(items)
+                    new_blocks.append(b)
+                    new_blk_items.append(b_items)
+                except (IndexError, KeyError):
+                    jitems = ",".join(pprint_thing(item) for item in items)
+                    raise ValueError(
+                        f"cannot match existing table structure for [{jitems}] "
+                        "on appending data"
+                    )
+            blocks = new_blocks
+            blk_items = new_blk_items
+
+        return blocks, blk_items
+
+    def process_axes(self, obj, selection: "Selection", columns=None):
         """ process axes filters """
 
         # make a copy to avoid side effects
@@ -3972,6 +3936,7 @@ def process_axes(self, obj, columns=None):
 
         # make sure to include levels if we have them
         if columns is not None and self.is_multi_index:
+            assert isinstance(self.levels, list)  # assured by is_multi_index
             for n in self.levels:
                 if n not in columns:
                     columns.insert(0, n)
@@ -3981,8 +3946,8 @@ def process_axes(self, obj, columns=None):
             obj = _reindex_axis(obj, axis, labels, columns)
 
         # apply the selection filters (but keep in the same order)
-        if self.selection.filter is not None:
-            for field, op, filt in self.selection.filter.format():
+        if selection.filter is not None:
+            for field, op, filt in selection.filter.format():
 
                 def process_filter(field, filt):
 
@@ -4015,18 +3980,19 @@ def process_filter(field, filt):
                             takers = op(values, filt)
                             return obj.loc(axis=axis_number)[takers]
 
-                    raise ValueError(
-                        "cannot find the field [{field}] for "
-                        "filtering!".format(field=field)
-                    )
+                    raise ValueError(f"cannot find the field [{field}] for filtering!")
 
                 obj = process_filter(field, filt)
 
         return obj
 
     def create_description(
-        self, complib=None, complevel=None, fletcher32=False, expectedrows=None
-    ):
+        self,
+        complib,
+        complevel: Optional[int],
+        fletcher32: bool,
+        expectedrows: Optional[int],
+    ) -> Dict[str, Any]:
         """ create the description of the table from the axes & values """
 
         # provided expected rows if its passed
@@ -4052,7 +4018,9 @@ def create_description(
 
         return d
 
-    def read_coordinates(self, where=None, start=None, stop=None, **kwargs):
+    def read_coordinates(
+        self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+    ):
         """select coordinates (row numbers) from a table; return the
         coordinates object
         """
@@ -4065,10 +4033,10 @@ def read_coordinates(self, where=None, start=None, stop=None, **kwargs):
             return False
 
         # create the selection
-        self.selection = Selection(self, where=where, start=start, stop=stop, **kwargs)
-        coords = self.selection.select_coords()
-        if self.selection.filter is not None:
-            for field, op, filt in self.selection.filter.format():
+        selection = Selection(self, where=where, start=start, stop=stop)
+        coords = selection.select_coords()
+        if selection.filter is not None:
+            for field, op, filt in selection.filter.format():
                 data = self.read_column(
                     field, start=coords.min(), stop=coords.max() + 1
                 )
@@ -4076,7 +4044,13 @@ def read_coordinates(self, where=None, start=None, stop=None, **kwargs):
 
         return Index(coords)
 
-    def read_column(self, column, where=None, start=None, stop=None):
+    def read_column(
+        self,
+        column: str,
+        where=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         """return a single column from the table, generally only indexables
         are interesting
         """
@@ -4097,83 +4071,57 @@ def read_column(self, column, where=None, start=None, stop=None):
 
                 if not a.is_data_indexable:
                     raise ValueError(
-                        "column [{column}] can not be extracted individually; "
-                        "it is not data indexable".format(column=column)
+                        f"column [{column}] can not be extracted individually; "
+                        "it is not data indexable"
                     )
 
                 # column must be an indexable or a data column
                 c = getattr(self.table.cols, column)
                 a.set_info(self.info)
-                return Series(
-                    _set_tz(
-                        a.convert(
-                            c[start:stop],
-                            nan_rep=self.nan_rep,
-                            encoding=self.encoding,
-                            errors=self.errors,
-                        ).take_data(),
-                        a.tz,
-                        True,
-                    ),
-                    name=column,
+                col_values = a.convert(
+                    c[start:stop],
+                    nan_rep=self.nan_rep,
+                    encoding=self.encoding,
+                    errors=self.errors,
                 )
+                return Series(_set_tz(col_values[1], a.tz), name=column)
 
-        raise KeyError("column [{column}] not found in the table".format(column=column))
+        raise KeyError(f"column [{column}] not found in the table")
 
 
 class WORMTable(Table):
-    """ a write-once read-many table: this format DOES NOT ALLOW appending to a
-         table. writing is a one-time operation the data are stored in a format
-         that allows for searching the data on disk
-         """
+    """
+    a write-once read-many table: this format DOES NOT ALLOW appending to a
+    table. writing is a one-time operation the data are stored in a format
+    that allows for searching the data on disk
+    """
 
     table_type = "worm"
 
-    def read(self, **kwargs):
-        """ read the indices and the indexing array, calculate offset rows and
-        return """
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
+        """
+        read the indices and the indexing array, calculate offset rows and return
+        """
         raise NotImplementedError("WORMTable needs to implement read")
 
     def write(self, **kwargs):
-        """ write in a format that we can search later on (but cannot append
-               to): write out the indices and the values using _write_array
-               (e.g. a CArray) create an indexing table so that we can search
         """
-        raise NotImplementedError("WORKTable needs to implement write")
-
-
-class LegacyTable(Table):
-    """ an appendable table: allow append/query/delete operations to a
-          (possibly) already existing appendable table this table ALLOWS
-          append (but doesn't require them), and stores the data in a format
-          that can be easily searched
-
-    """
-
-    _indexables = [
-        IndexCol(name="index", axis=1, pos=0),
-        IndexCol(name="column", axis=2, pos=1, index_kind="columns_kind"),
-        DataCol(name="fields", cname="values", kind_attr="fields", pos=2),
-    ]  # type: Optional[List[IndexCol]]
-    table_type = "legacy"
-    ndim = 3
-
-    def write(self, **kwargs):
-        raise TypeError("write operations are not allowed on legacy tables!")
-
-    def read(self, where=None, columns=None, **kwargs):
-        """we have n indexable columns, with an arbitrary number of data
-        axes
+        write in a format that we can search later on (but cannot append
+        to): write out the indices and the values using _write_array
+        (e.g. a CArray) create an indexing table so that we can search
         """
-
-        if not self.read_axes(where=where, **kwargs):
-            return None
+        raise NotImplementedError("WORMTable needs to implement write")
 
 
-class AppendableTable(LegacyTable):
+class AppendableTable(Table):
     """ support the new appendable table formats """
 
-    _indexables = None
     table_type = "appendable"
 
     def write(
@@ -4188,24 +4136,30 @@ def write(
         chunksize=None,
         expectedrows=None,
         dropna=False,
-        **kwargs
+        nan_rep=None,
+        data_columns=None,
     ):
 
         if not append and self.is_exists:
             self._handle.remove_node(self.group, "table")
 
         # create the axes
-        self.create_axes(
-            axes=axes, obj=obj, validate=append, min_itemsize=min_itemsize, **kwargs
+        table = self._create_axes(
+            axes=axes,
+            obj=obj,
+            validate=append,
+            min_itemsize=min_itemsize,
+            nan_rep=nan_rep,
+            data_columns=data_columns,
         )
 
-        for a in self.axes:
-            a.validate(self, append)
+        for a in table.axes:
+            a.validate_names()
 
-        if not self.is_exists:
+        if not table.is_exists:
 
             # create the table
-            options = self.create_description(
+            options = table.create_description(
                 complib=complib,
                 complevel=complevel,
                 fletcher32=fletcher32,
@@ -4213,27 +4167,25 @@ def write(
             )
 
             # set the table attributes
-            self.set_attrs()
+            table.set_attrs()
 
             # create the table
-            self._handle.create_table(self.group, **options)
-        else:
-            pass
-            # table = self.table
+            table._handle.create_table(table.group, **options)
 
         # update my info
-        self.set_info()
+        table.attrs.info = table.info
 
         # validate the axes and set the kinds
-        for a in self.axes:
-            a.validate_and_set(self, append)
+        for a in table.axes:
+            a.validate_and_set(table, append)
 
         # add the rows
-        self.write_data(chunksize, dropna=dropna)
+        table.write_data(chunksize, dropna=dropna)
 
-    def write_data(self, chunksize, dropna=False):
-        """ we form the data into a 2-d including indexes,values,mask
-            write chunk-by-chunk """
+    def write_data(self, chunksize: Optional[int], dropna: bool = False):
+        """
+        we form the data into a 2-d including indexes,values,mask write chunk-by-chunk
+        """
 
         names = self.dtype.names
         nrows = self.nrows_expected
@@ -4262,21 +4214,7 @@ def write_data(self, chunksize, dropna=False):
         # broadcast the indexes if needed
         indexes = [a.cvalues for a in self.index_axes]
         nindexes = len(indexes)
-        bindexes = []
-        for i, idx in enumerate(indexes):
-
-            # broadcast to all other indexes except myself
-            if i > 0 and i < nindexes:
-                repeater = np.prod([indexes[bi].shape[0] for bi in range(0, i)])
-                idx = np.tile(idx, repeater)
-
-            if i < nindexes - 1:
-                repeater = np.prod(
-                    [indexes[bi].shape[0] for bi in range(i + 1, nindexes)]
-                )
-                idx = np.repeat(idx, repeater)
-
-            bindexes.append(idx)
+        assert nindexes == 1, nindexes  # ensures we dont need to broadcast
 
         # transpose the values so first dimension is last
         # reshape the values if needed
@@ -4301,12 +4239,18 @@ def write_data(self, chunksize, dropna=False):
 
             self.write_data_chunk(
                 rows,
-                indexes=[a[start_i:end_i] for a in bindexes],
+                indexes=[a[start_i:end_i] for a in indexes],
                 mask=mask[start_i:end_i] if mask is not None else None,
                 values=[v[start_i:end_i] for v in bvalues],
             )
 
-    def write_data_chunk(self, rows, indexes, mask, values):
+    def write_data_chunk(
+        self,
+        rows: np.ndarray,
+        indexes: List[np.ndarray],
+        mask: Optional[np.ndarray],
+        values: List[np.ndarray],
+    ):
         """
         Parameters
         ----------
@@ -4321,40 +4265,33 @@ def write_data_chunk(self, rows, indexes, mask, values):
             if not np.prod(v.shape):
                 return
 
-        try:
-            nrows = indexes[0].shape[0]
-            if nrows != len(rows):
-                rows = np.empty(nrows, dtype=self.dtype)
-            names = self.dtype.names
-            nindexes = len(indexes)
-
-            # indexes
-            for i, idx in enumerate(indexes):
-                rows[names[i]] = idx
+        nrows = indexes[0].shape[0]
+        if nrows != len(rows):
+            rows = np.empty(nrows, dtype=self.dtype)
+        names = self.dtype.names
+        nindexes = len(indexes)
 
-            # values
-            for i, v in enumerate(values):
-                rows[names[i + nindexes]] = v
+        # indexes
+        for i, idx in enumerate(indexes):
+            rows[names[i]] = idx
 
-            # mask
-            if mask is not None:
-                m = ~mask.ravel().astype(bool, copy=False)
-                if not m.all():
-                    rows = rows[m]
+        # values
+        for i, v in enumerate(values):
+            rows[names[i + nindexes]] = v
 
-        except Exception as detail:
-            raise Exception("cannot create row-data -> {detail}".format(detail=detail))
+        # mask
+        if mask is not None:
+            m = ~mask.ravel().astype(bool, copy=False)
+            if not m.all():
+                rows = rows[m]
 
-        try:
-            if len(rows):
-                self.table.append(rows)
-                self.table.flush()
-        except Exception as detail:
-            raise TypeError(
-                "tables cannot write this data -> {detail}".format(detail=detail)
-            )
+        if len(rows):
+            self.table.append(rows)
+            self.table.flush()
 
-    def delete(self, where=None, start=None, stop=None, **kwargs):
+    def delete(
+        self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+    ):
 
         # delete all rows (and return the nrows)
         if where is None or not len(where):
@@ -4375,8 +4312,8 @@ def delete(self, where=None, start=None, stop=None, **kwargs):
 
         # create the selection
         table = self.table
-        self.selection = Selection(self, where, start=start, stop=stop, **kwargs)
-        values = self.selection.select_coords()
+        selection = Selection(self, where, start=start, stop=stop)
+        values = selection.select_coords()
 
         # delete the rows in reverse order
         sorted_series = Series(values).sort_values()
@@ -4421,48 +4358,71 @@ class AppendableFrameTable(AppendableTable):
     pandas_kind = "frame_table"
     table_type = "appendable_frame"
     ndim = 2
-    obj_type = DataFrame  # type: Type[Union[DataFrame, Series]]
+    obj_type: Type[Union[DataFrame, Series]] = DataFrame
 
     @property
-    def is_transposed(self):
+    def is_transposed(self) -> bool:
         return self.index_axes[0].axis == 1
 
-    def get_object(self, obj):
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
         """ these are written transposed """
-        if self.is_transposed:
+        if transposed:
             obj = obj.T
         return obj
 
-    def read(self, where=None, columns=None, **kwargs):
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
 
-        if not self.read_axes(where=where, **kwargs):
+        # validate the version
+        self.validate_version(where)
+
+        # infer the data kind
+        if not self.infer_axes():
             return None
 
+        result = self._read_axes(where=where, start=start, stop=stop)
+
         info = (
             self.info.get(self.non_index_axes[0][0], dict())
             if len(self.non_index_axes)
             else dict()
         )
-        index = self.index_axes[0].values
+
+        inds = [i for i, ax in enumerate(self.axes) if ax is self.index_axes[0]]
+        assert len(inds) == 1
+        ind = inds[0]
+
+        index = result[ind][0]
+
         frames = []
-        for a in self.values_axes:
+        for i, a in enumerate(self.axes):
+            if a not in self.values_axes:
+                continue
+            index_vals, cvalues = result[i]
 
             # we could have a multi-index constructor here
             # ensure_index doesn't recognized our list-of-tuples here
             if info.get("type") == "MultiIndex":
-                cols = MultiIndex.from_tuples(a.values)
+                cols = MultiIndex.from_tuples(index_vals)
             else:
-                cols = Index(a.values)
+                cols = Index(index_vals)
+
             names = info.get("names")
             if names is not None:
                 cols.set_names(names, inplace=True)
 
             if self.is_transposed:
-                values = a.cvalues
+                values = cvalues
                 index_ = cols
                 cols_ = Index(index, name=getattr(index, "name", None))
             else:
-                values = a.cvalues.T
+                values = cvalues.T
                 index_ = Index(index, name=getattr(index, "name", None))
                 cols_ = cols
 
@@ -4470,17 +4430,24 @@ def read(self, where=None, columns=None, **kwargs):
             if values.ndim == 1 and isinstance(values, np.ndarray):
                 values = values.reshape((1, values.shape[0]))
 
-            block = make_block(values, placement=np.arange(len(cols_)), ndim=2)
-            mgr = BlockManager([block], [cols_, index_])
-            frames.append(DataFrame(mgr))
+            if isinstance(values, np.ndarray):
+                df = DataFrame(values.T, columns=cols_, index=index_)
+            elif isinstance(values, Index):
+                df = DataFrame(values, columns=cols_, index=index_)
+            else:
+                # Categorical
+                df = DataFrame([values], columns=cols_, index=index_)
+            assert (df.dtypes == values.dtype).all(), (df.dtypes, values.dtype)
+            frames.append(df)
 
         if len(frames) == 1:
             df = frames[0]
         else:
             df = concat(frames, axis=1)
 
+        selection = Selection(self, where=where, start=start, stop=stop)
         # apply the selection filters & axis orderings
-        df = self.process_axes(df, columns=columns)
+        df = self.process_axes(df, selection=selection, columns=columns)
 
         return df
 
@@ -4492,31 +4459,37 @@ class AppendableSeriesTable(AppendableFrameTable):
     table_type = "appendable_series"
     ndim = 2
     obj_type = Series
-    storage_obj_type = DataFrame
 
     @property
-    def is_transposed(self):
+    def is_transposed(self) -> bool:
         return False
 
-    def get_object(self, obj):
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
         return obj
 
     def write(self, obj, data_columns=None, **kwargs):
         """ we are going to write this as a frame table """
         if not isinstance(obj, DataFrame):
             name = obj.name or "values"
-            obj = DataFrame({name: obj}, index=obj.index)
-            obj.columns = [name]
+            obj = obj.to_frame(name)
         return super().write(obj=obj, data_columns=obj.columns.tolist(), **kwargs)
 
-    def read(self, columns=None, **kwargs):
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ) -> Series:
 
         is_multi_index = self.is_multi_index
         if columns is not None and is_multi_index:
+            assert isinstance(self.levels, list)  # needed for mypy
             for n in self.levels:
                 if n not in columns:
                     columns.insert(0, n)
-        s = super().read(columns=columns, **kwargs)
+        s = super().read(where=where, columns=columns, start=start, stop=stop)
         if is_multi_index:
             s.set_index(self.levels, inplace=True)
 
@@ -4553,7 +4526,7 @@ class GenericTable(AppendableFrameTable):
     obj_type = DataFrame
 
     @property
-    def pandas_type(self):
+    def pandas_type(self) -> str:
         return self.pandas_kind
 
     @property
@@ -4566,30 +4539,44 @@ def get_attrs(self):
         self.nan_rep = None
         self.levels = []
 
-        self.index_axes = [a.infer(self) for a in self.indexables if a.is_an_indexable]
-        self.values_axes = [
-            a.infer(self) for a in self.indexables if not a.is_an_indexable
-        ]
+        self.index_axes = [a for a in self.indexables if a.is_an_indexable]
+        self.values_axes = [a for a in self.indexables if not a.is_an_indexable]
         self.data_columns = [a.name for a in self.values_axes]
 
-    @property
+    @cache_readonly
     def indexables(self):
         """ create the indexables from the table description """
-        if self._indexables is None:
-
-            d = self.description
-
-            # the index columns is just a simple index
-            self._indexables = [GenericIndexCol(name="index", axis=0)]
-
-            for i, n in enumerate(d._v_names):
+        d = self.description
+
+        # TODO: can we get a typ for this?  AFAICT it is the only place
+        #  where we aren't passing one
+        # the index columns is just a simple index
+        md = self.read_metadata("index")
+        meta = "category" if md is not None else None
+        index_col = GenericIndexCol(
+            name="index", axis=0, table=self.table, meta=meta, metadata=md
+        )
 
-                dc = GenericDataIndexableCol(
-                    name=n, pos=i, values=[n], version=self.version
-                )
-                self._indexables.append(dc)
+        _indexables = [index_col]
+
+        for i, n in enumerate(d._v_names):
+            assert isinstance(n, str)
+
+            atom = getattr(d, n)
+            md = self.read_metadata(n)
+            meta = "category" if md is not None else None
+            dc = GenericDataIndexableCol(
+                name=n,
+                pos=i,
+                values=[n],
+                typ=atom,
+                table=self.table,
+                meta=meta,
+                metadata=md,
+            )
+            _indexables.append(dc)
 
-        return self._indexables
+        return _indexables
 
     def write(self, **kwargs):
         raise NotImplementedError("cannot write on an generic table")
@@ -4604,7 +4591,7 @@ class AppendableMultiFrameTable(AppendableFrameTable):
     _re_levels = re.compile(r"^level_\d+$")
 
     @property
-    def table_type_short(self):
+    def table_type_short(self) -> str:
         return "appendable_multi"
 
     def write(self, obj, data_columns=None, **kwargs):
@@ -4618,9 +4605,15 @@ def write(self, obj, data_columns=None, **kwargs):
                 data_columns.insert(0, n)
         return super().write(obj=obj, data_columns=data_columns, **kwargs)
 
-    def read(self, **kwargs):
+    def read(
+        self,
+        where=None,
+        columns=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
 
-        df = super().read(**kwargs)
+        df = super().read(where=where, columns=columns, start=start, stop=stop)
         df = df.set_index(self.levels)
 
         # remove names for 'level_%d'
@@ -4631,7 +4624,7 @@ def read(self, **kwargs):
         return df
 
 
-def _reindex_axis(obj, axis, labels, other=None):
+def _reindex_axis(obj: DataFrame, axis: int, labels: Index, other=None) -> DataFrame:
     ax = obj._get_axis(axis)
     labels = ensure_index(labels)
 
@@ -4646,182 +4639,122 @@ def _reindex_axis(obj, axis, labels, other=None):
     if other is not None:
         labels = ensure_index(other.unique()).intersection(labels, sort=False)
     if not labels.equals(ax):
-        slicer = [slice(None, None)] * obj.ndim
+        slicer: List[Union[slice, Index]] = [slice(None, None)] * obj.ndim
         slicer[axis] = labels
         obj = obj.loc[tuple(slicer)]
     return obj
 
 
-def _get_info(info, name):
-    """ get/create the info for this name """
-    try:
-        idx = info[name]
-    except KeyError:
-        idx = info[name] = dict()
-    return idx
-
-
 # tz to/from coercion
 
 
-def _get_tz(tz):
+def _get_tz(tz: tzinfo) -> Union[str, tzinfo]:
     """ for a tz-aware type, return an encoded zone """
     zone = timezones.get_timezone(tz)
-    if zone is None:
-        zone = tz.utcoffset().total_seconds()
     return zone
 
 
-def _set_tz(values, tz, preserve_UTC=False, coerce=False):
+def _set_tz(
+    values: Union[np.ndarray, Index],
+    tz: Optional[Union[str, tzinfo]],
+    coerce: bool = False,
+) -> Union[np.ndarray, DatetimeIndex]:
     """
     coerce the values to a DatetimeIndex if tz is set
     preserve the input shape if possible
 
     Parameters
     ----------
-    values : ndarray
-    tz : string/pickled tz object
-    preserve_UTC : boolean,
-        preserve the UTC of the result
+    values : ndarray or Index
+    tz : str or tzinfo
     coerce : if we do not have a passed timezone, coerce to M8[ns] ndarray
     """
+    if isinstance(values, DatetimeIndex):
+        # If values is tzaware, the tz gets dropped in the values.ravel()
+        #  call below (which returns an ndarray).  So we are only non-lossy
+        #  if `tz` matches `values.tz`.
+        assert values.tz is None or values.tz == tz
+
     if tz is not None:
         name = getattr(values, "name", None)
         values = values.ravel()
         tz = timezones.get_timezone(_ensure_decoded(tz))
         values = DatetimeIndex(values, name=name)
-        if values.tz is None:
-            values = values.tz_localize("UTC").tz_convert(tz)
-        if preserve_UTC:
-            if tz == "UTC":
-                values = list(values)
+        values = values.tz_localize("UTC").tz_convert(tz)
     elif coerce:
         values = np.asarray(values, dtype="M8[ns]")
 
     return values
 
 
-def _convert_index(index, encoding=None, errors="strict", format_type=None):
-    index_name = getattr(index, "name", None)
+def _convert_index(name: str, index: Index, encoding: str, errors: str) -> IndexCol:
+    assert isinstance(name, str)
+
+    index_name = index.name
+    converted, dtype_name = _get_data_and_dtype_name(index)
+    kind = _dtype_to_kind(dtype_name)
+    atom = DataIndexableCol._get_atom(converted)
 
-    if isinstance(index, DatetimeIndex):
-        converted = index.asi8
+    if isinstance(index, Int64Index):
+        # Includes Int64Index, RangeIndex, DatetimeIndex, TimedeltaIndex, PeriodIndex,
+        #  in which case "kind" is "integer", "integer", "datetime64",
+        #  "timedelta64", and "integer", respectively.
         return IndexCol(
-            converted,
-            "datetime64",
-            _tables().Int64Col(),
+            name,
+            values=converted,
+            kind=kind,
+            typ=atom,
             freq=getattr(index, "freq", None),
             tz=getattr(index, "tz", None),
             index_name=index_name,
         )
-    elif isinstance(index, TimedeltaIndex):
-        converted = index.asi8
-        return IndexCol(
-            converted,
-            "timedelta64",
-            _tables().Int64Col(),
-            freq=getattr(index, "freq", None),
-            index_name=index_name,
-        )
-    elif isinstance(index, (Int64Index, PeriodIndex)):
-        atom = _tables().Int64Col()
-        # avoid to store ndarray of Period objects
-        return IndexCol(
-            index._ndarray_values,
-            "integer",
-            atom,
-            freq=getattr(index, "freq", None),
-            index_name=index_name,
-        )
 
     if isinstance(index, MultiIndex):
         raise TypeError("MultiIndex not supported here!")
 
     inferred_type = lib.infer_dtype(index, skipna=False)
+    # we wont get inferred_type of "datetime64" or "timedelta64" as these
+    #  would go through the DatetimeIndex/TimedeltaIndex paths above
 
     values = np.asarray(index)
 
-    if inferred_type == "datetime64":
-        converted = values.view("i8")
-        return IndexCol(
-            converted,
-            "datetime64",
-            _tables().Int64Col(),
-            freq=getattr(index, "freq", None),
-            tz=getattr(index, "tz", None),
-            index_name=index_name,
-        )
-    elif inferred_type == "timedelta64":
-        converted = values.view("i8")
-        return IndexCol(
-            converted,
-            "timedelta64",
-            _tables().Int64Col(),
-            freq=getattr(index, "freq", None),
-            index_name=index_name,
-        )
-    elif inferred_type == "datetime":
-        converted = np.asarray(
-            [(time.mktime(v.timetuple()) + v.microsecond / 1e6) for v in values],
-            dtype=np.float64,
-        )
+    if inferred_type == "date":
+        converted = np.asarray([v.toordinal() for v in values], dtype=np.int32)
         return IndexCol(
-            converted, "datetime", _tables().Time64Col(), index_name=index_name
+            name, converted, "date", _tables().Time32Col(), index_name=index_name,
         )
-    elif inferred_type == "date":
-        converted = np.asarray([v.toordinal() for v in values], dtype=np.int32)
-        return IndexCol(converted, "date", _tables().Time32Col(), index_name=index_name)
     elif inferred_type == "string":
-        # atom = _tables().ObjectAtom()
-        # return np.asarray(values, dtype='O'), 'object', atom
 
         converted = _convert_string_array(values, encoding, errors)
         itemsize = converted.dtype.itemsize
         return IndexCol(
+            name,
             converted,
             "string",
             _tables().StringCol(itemsize),
-            itemsize=itemsize,
             index_name=index_name,
         )
-    elif inferred_type == "unicode":
-        if format_type == "fixed":
-            atom = _tables().ObjectAtom()
-            return IndexCol(
-                np.asarray(values, dtype="O"), "object", atom, index_name=index_name
-            )
-        raise TypeError(
-            "[unicode] is not supported as a in index type for [{0}] formats".format(
-                format_type
-            )
-        )
 
-    elif inferred_type == "integer":
-        # take a guess for now, hope the values fit
-        atom = _tables().Int64Col()
-        return IndexCol(
-            np.asarray(values, dtype=np.int64), "integer", atom, index_name=index_name
-        )
-    elif inferred_type == "floating":
-        atom = _tables().Float64Col()
+    elif inferred_type in ["integer", "floating"]:
         return IndexCol(
-            np.asarray(values, dtype=np.float64), "float", atom, index_name=index_name
+            name, values=converted, kind=kind, typ=atom, index_name=index_name,
         )
-    else:  # pragma: no cover
+    else:
+        assert isinstance(converted, np.ndarray) and converted.dtype == object
+        assert kind == "object", kind
         atom = _tables().ObjectAtom()
-        return IndexCol(
-            np.asarray(values, dtype="O"), "object", atom, index_name=index_name
-        )
+        return IndexCol(name, converted, kind, atom, index_name=index_name,)
 
 
-def _unconvert_index(data, kind, encoding=None, errors="strict"):
-    kind = _ensure_decoded(kind)
+def _unconvert_index(
+    data, kind: str, encoding: str, errors: str
+) -> Union[np.ndarray, Index]:
+    index: Union[Index, np.ndarray]
+
     if kind == "datetime64":
         index = DatetimeIndex(data)
     elif kind == "timedelta64":
         index = TimedeltaIndex(data)
-    elif kind == "datetime":
-        index = np.asarray([datetime.fromtimestamp(v) for v in data], dtype=object)
     elif kind == "date":
         try:
             index = np.asarray([date.fromordinal(v) for v in data], dtype=object)
@@ -4836,83 +4769,132 @@ def _unconvert_index(data, kind, encoding=None, errors="strict"):
     elif kind == "object":
         index = np.asarray(data[0])
     else:  # pragma: no cover
-        raise ValueError("unrecognized index type {kind}".format(kind=kind))
+        raise ValueError(f"unrecognized index type {kind}")
     return index
 
 
-def _unconvert_index_legacy(data, kind, legacy=False, encoding=None, errors="strict"):
-    kind = _ensure_decoded(kind)
-    if kind == "datetime":
-        index = to_datetime(data)
-    elif kind in ("integer"):
-        index = np.asarray(data, dtype=object)
-    elif kind in ("string"):
-        index = _unconvert_string_array(
-            data, nan_rep=None, encoding=encoding, errors=errors
+def _maybe_convert_for_string_atom(
+    name: str, block, existing_col, min_itemsize, nan_rep, encoding, errors
+):
+
+    if not block.is_object:
+        return block.values
+
+    dtype_name = block.dtype.name
+    inferred_type = lib.infer_dtype(block.values, skipna=False)
+
+    if inferred_type == "date":
+        raise TypeError("[date] is not implemented as a table column")
+    elif inferred_type == "datetime":
+        # after GH#8260
+        # this only would be hit for a multi-timezone dtype which is an error
+        raise TypeError(
+            "too many timezones in this block, create separate data columns"
         )
-    else:  # pragma: no cover
-        raise ValueError("unrecognized index type {kind}".format(kind=kind))
-    return index
 
+    elif not (inferred_type == "string" or dtype_name == "object"):
+        return block.values
 
-def _convert_string_array(data, encoding, errors, itemsize=None):
+    block = block.fillna(nan_rep, downcast=False)
+    if isinstance(block, list):
+        # Note: because block is always object dtype, fillna goes
+        #  through a path such that the result is always a 1-element list
+        block = block[0]
+    data = block.values
+
+    # see if we have a valid string type
+    inferred_type = lib.infer_dtype(data.ravel(), skipna=False)
+    if inferred_type != "string":
+
+        # we cannot serialize this data, so report an exception on a column
+        # by column basis
+        for i in range(len(block.shape[0])):
+
+            col = block.iget(i)
+            inferred_type = lib.infer_dtype(col.ravel(), skipna=False)
+            if inferred_type != "string":
+                iloc = block.mgr_locs.indexer[i]
+                raise TypeError(
+                    f"Cannot serialize the column [{iloc}] because\n"
+                    f"its data contents are [{inferred_type}] object dtype"
+                )
+
+    # itemsize is the maximum length of a string (along any dimension)
+    data_converted = _convert_string_array(data, encoding, errors).reshape(data.shape)
+    assert data_converted.shape == block.shape, (data_converted.shape, block.shape)
+    itemsize = data_converted.itemsize
+
+    # specified min_itemsize?
+    if isinstance(min_itemsize, dict):
+        min_itemsize = int(min_itemsize.get(name) or min_itemsize.get("values") or 0)
+    itemsize = max(min_itemsize or 0, itemsize)
+
+    # check for column in the values conflicts
+    if existing_col is not None:
+        eci = existing_col.validate_col(itemsize)
+        if eci > itemsize:
+            itemsize = eci
+
+    data_converted = data_converted.astype(f"|S{itemsize}", copy=False)
+    return data_converted
+
+
+def _convert_string_array(data: np.ndarray, encoding: str, errors: str) -> np.ndarray:
     """
-    we take a string-like that is object dtype and coerce to a fixed size
-    string type
+    Take a string-like that is object dtype and coerce to a fixed size string type.
 
     Parameters
     ----------
-    data : a numpy array of object dtype
-    encoding : None or string-encoding
-    errors : handler for encoding errors
-    itemsize : integer, optional, defaults to the max length of the strings
+    data : np.ndarray[object]
+    encoding : str
+    errors : str
+        Handler for encoding errors.
 
     Returns
     -------
-    data in a fixed-length string dtype, encoded to bytes if needed
+    np.ndarray[fixed-length-string]
     """
 
     # encode if needed
-    if encoding is not None and len(data):
+    if len(data):
         data = (
             Series(data.ravel()).str.encode(encoding, errors).values.reshape(data.shape)
         )
 
     # create the sized dtype
-    if itemsize is None:
-        ensured = ensure_object(data.ravel())
-        itemsize = max(1, libwriters.max_len_string_array(ensured))
+    ensured = ensure_object(data.ravel())
+    itemsize = max(1, libwriters.max_len_string_array(ensured))
 
-    data = np.asarray(data, dtype="S{size}".format(size=itemsize))
+    data = np.asarray(data, dtype=f"S{itemsize}")
     return data
 
 
-def _unconvert_string_array(data, nan_rep=None, encoding=None, errors="strict"):
+def _unconvert_string_array(
+    data: np.ndarray, nan_rep, encoding: str, errors: str
+) -> np.ndarray:
     """
-    inverse of _convert_string_array
+    Inverse of _convert_string_array.
 
     Parameters
     ----------
-    data : fixed length string dtyped array
-    nan_rep : the storage repr of NaN, optional
-    encoding : the encoding of the data, optional
-    errors : handler for encoding errors, default 'strict'
+    data : np.ndarray[fixed-length-string]
+    nan_rep : the storage repr of NaN
+    encoding : str
+    errors : str
+        Handler for encoding errors.
 
     Returns
     -------
-    an object array of the decoded data
-
+    np.ndarray[object]
+        Decoded data.
     """
     shape = data.shape
     data = np.asarray(data.ravel(), dtype=object)
 
-    # guard against a None encoding (because of a legacy
-    # where the passed encoding is actually None)
-    encoding = _ensure_encoding(encoding)
-    if encoding is not None and len(data):
+    if len(data):
 
         itemsize = libwriters.max_len_string_array(ensure_object(data))
-        dtype = "U{0}".format(itemsize)
+        dtype = f"U{itemsize}"
 
         if isinstance(data[0], bytes):
             data = Series(data).str.decode(encoding, errors=errors).values
@@ -4926,33 +4908,111 @@ def _unconvert_string_array(data, nan_rep=None, encoding=None, errors="strict"):
     return data.reshape(shape)
 
 
-def _maybe_convert(values, val_kind, encoding, errors):
+def _maybe_convert(values: np.ndarray, val_kind: str, encoding: str, errors: str):
+    assert isinstance(val_kind, str), type(val_kind)
     if _need_convert(val_kind):
         conv = _get_converter(val_kind, encoding, errors)
-        # conv = np.frompyfunc(conv, 1, 1)
         values = conv(values)
     return values
 
 
-def _get_converter(kind, encoding, errors):
-    kind = _ensure_decoded(kind)
+def _get_converter(kind: str, encoding: str, errors: str):
     if kind == "datetime64":
         return lambda x: np.asarray(x, dtype="M8[ns]")
-    elif kind == "datetime":
-        return lambda x: to_datetime(x, cache=True).to_pydatetime()
     elif kind == "string":
-        return lambda x: _unconvert_string_array(x, encoding=encoding, errors=errors)
+        return lambda x: _unconvert_string_array(
+            x, nan_rep=None, encoding=encoding, errors=errors
+        )
     else:  # pragma: no cover
-        raise ValueError("invalid kind {kind}".format(kind=kind))
+        raise ValueError(f"invalid kind {kind}")
 
 
-def _need_convert(kind):
-    kind = _ensure_decoded(kind)
-    if kind in ("datetime", "datetime64", "string"):
+def _need_convert(kind: str) -> bool:
+    if kind in ("datetime64", "string"):
         return True
     return False
 
 
+def _maybe_adjust_name(name: str, version) -> str:
+    """
+    Prior to 0.10.1, we named values blocks like: values_block_0 an the
+    name values_0, adjust the given name if necessary.
+
+    Parameters
+    ----------
+    name : str
+    version : Tuple[int, int, int]
+
+    Returns
+    -------
+    str
+    """
+    try:
+        if version[0] == 0 and version[1] <= 10 and version[2] == 0:
+            m = re.search(r"values_block_(\d+)", name)
+            if m:
+                grp = m.groups()[0]
+                name = f"values_{grp}"
+    except IndexError:
+        pass
+    return name
+
+
+def _dtype_to_kind(dtype_str: str) -> str:
+    """
+    Find the "kind" string describing the given dtype name.
+    """
+    dtype_str = _ensure_decoded(dtype_str)
+
+    if dtype_str.startswith("string") or dtype_str.startswith("bytes"):
+        kind = "string"
+    elif dtype_str.startswith("float"):
+        kind = "float"
+    elif dtype_str.startswith("complex"):
+        kind = "complex"
+    elif dtype_str.startswith("int") or dtype_str.startswith("uint"):
+        kind = "integer"
+    elif dtype_str.startswith("datetime64"):
+        kind = "datetime64"
+    elif dtype_str.startswith("timedelta"):
+        kind = "timedelta64"
+    elif dtype_str.startswith("bool"):
+        kind = "bool"
+    elif dtype_str.startswith("category"):
+        kind = "category"
+    elif dtype_str.startswith("period"):
+        # We store the `freq` attr so we can restore from integers
+        kind = "integer"
+    elif dtype_str == "object":
+        kind = "object"
+    else:
+        raise ValueError(f"cannot interpret dtype of [{dtype_str}]")
+
+    return kind
+
+
+def _get_data_and_dtype_name(data: Union[np.ndarray, ABCExtensionArray]):
+    """
+    Convert the passed data into a storable form and a dtype string.
+    """
+    if is_categorical_dtype(data.dtype):
+        data = data.codes
+
+    # For datetime64tz we need to drop the TZ in tests TODO: why?
+    dtype_name = data.dtype.name.split("[")[0]
+
+    if data.dtype.kind in ["m", "M"]:
+        data = np.asarray(data.view("i8"))
+        # TODO: we used to reshape for the dt64tz case, but no longer
+        #  doing that doesn't seem to break anything.  why?
+
+    elif isinstance(data, PeriodIndex):
+        data = data.asi8
+
+    data = np.asarray(data)
+    return data, dtype_name
+
+
 class Selection:
     """
     Carries out a selection operation on a tables.Table object.
@@ -4965,7 +5025,13 @@ class Selection:
 
     """
 
-    def __init__(self, table, where=None, start=None, stop=None):
+    def __init__(
+        self,
+        table: Table,
+        where=None,
+        start: Optional[int] = None,
+        stop: Optional[int] = None,
+    ):
         self.table = table
         self.where = where
         self.start = start
@@ -5016,20 +5082,19 @@ def generate(self, where):
 
         q = self.table.queryables()
         try:
-            return Expr(where, queryables=q, encoding=self.table.encoding)
+            return PyTablesExpr(where, queryables=q, encoding=self.table.encoding)
         except NameError:
             # raise a nice message, suggesting that the user should use
             # data_columns
+            qkeys = ",".join(q.keys())
             raise ValueError(
-                "The passed where expression: {0}\n"
+                f"The passed where expression: {where}\n"
                 "            contains an invalid variable reference\n"
                 "            all of the variable references must be a "
                 "reference to\n"
                 "            an axis (e.g. 'index' or 'columns'), or a "
                 "data_column\n"
-                "            The currently defined references are: {1}\n".format(
-                    where, ",".join(q.keys())
-                )
+                f"            The currently defined references are: {qkeys}\n"
             )
 
     def select(self):
diff --git a/pandas/io/s3.py b/pandas/io/s3.py
index 7e0a37e8cba20..976c319f89d47 100644
--- a/pandas/io/s3.py
+++ b/pandas/io/s3.py
@@ -2,9 +2,8 @@
 from typing import IO, Any, Optional, Tuple
 from urllib.parse import urlparse as parse_url
 
-from pandas.compat._optional import import_optional_dependency
-
 from pandas._typing import FilePathOrBuffer
+from pandas.compat._optional import import_optional_dependency
 
 s3fs = import_optional_dependency(
     "s3fs", extra="The s3fs package is required to handle s3 files."
diff --git a/pandas/io/sas/__init__.py b/pandas/io/sas/__init__.py
index fa6b29a1a3fcc..8f81352e6aecb 100644
--- a/pandas/io/sas/__init__.py
+++ b/pandas/io/sas/__init__.py
@@ -1 +1 @@
-from .sasreader import read_sas  # noqa
+from pandas.io.sas.sasreader import read_sas  # noqa
diff --git a/pandas/io/sas/sas.pyx b/pandas/io/sas/sas.pyx
index 6378198225516..40fea0aaf0d07 100644
--- a/pandas/io/sas/sas.pyx
+++ b/pandas/io/sas/sas.pyx
@@ -13,8 +13,7 @@ ctypedef unsigned short     uint16_t
 # algorithm.  It is partially documented here:
 #
 # https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf
-cdef const uint8_t[:] rle_decompress(int result_length,
-                                     const uint8_t[:] inbuff):
+cdef const uint8_t[:] rle_decompress(int result_length, const uint8_t[:] inbuff):
 
     cdef:
         uint8_t control_byte, x
@@ -33,7 +32,7 @@ cdef const uint8_t[:] rle_decompress(int result_length,
                 raise ValueError("Unexpected non-zero end_of_first_byte")
             nbytes = <int>(inbuff[ipos]) + 64
             ipos += 1
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = inbuff[ipos]
                 rpos += 1
                 ipos += 1
@@ -42,20 +41,20 @@ cdef const uint8_t[:] rle_decompress(int result_length,
             nbytes = end_of_first_byte * 16
             nbytes += <int>(inbuff[ipos])
             ipos += 1
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = inbuff[ipos]
                 rpos += 1
             ipos += 1
         elif control_byte == 0x60:
             nbytes = end_of_first_byte * 256 + <int>(inbuff[ipos]) + 17
             ipos += 1
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = 0x20
                 rpos += 1
         elif control_byte == 0x70:
             nbytes = end_of_first_byte * 256 + <int>(inbuff[ipos]) + 17
             ipos += 1
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = 0x00
                 rpos += 1
         elif control_byte == 0x80:
@@ -86,32 +85,30 @@ cdef const uint8_t[:] rle_decompress(int result_length,
             nbytes = end_of_first_byte + 3
             x = inbuff[ipos]
             ipos += 1
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = x
                 rpos += 1
         elif control_byte == 0xD0:
             nbytes = end_of_first_byte + 2
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = 0x40
                 rpos += 1
         elif control_byte == 0xE0:
             nbytes = end_of_first_byte + 2
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = 0x20
                 rpos += 1
         elif control_byte == 0xF0:
             nbytes = end_of_first_byte + 2
-            for i in range(nbytes):
+            for _ in range(nbytes):
                 result[rpos] = 0x00
                 rpos += 1
         else:
-            raise ValueError("unknown control byte: {byte}"
-                             .format(byte=control_byte))
+            raise ValueError(f"unknown control byte: {control_byte}")
 
     # In py37 cython/clang sees `len(outbuff)` as size_t and not Py_ssize_t
     if <Py_ssize_t>len(result) != <Py_ssize_t>result_length:
-        raise ValueError("RLE: {got} != {expect}".format(got=len(result),
-                                                         expect=result_length))
+        raise ValueError(f"RLE: {len(result)} != {result_length}")
 
     return np.asarray(result)
 
@@ -119,8 +116,7 @@ cdef const uint8_t[:] rle_decompress(int result_length,
 # rdc_decompress decompresses data using the Ross Data Compression algorithm:
 #
 # http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
-cdef const uint8_t[:] rdc_decompress(int result_length,
-                                     const uint8_t[:] inbuff):
+cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff):
 
     cdef:
         uint8_t cmd
@@ -194,8 +190,7 @@ cdef const uint8_t[:] rdc_decompress(int result_length,
 
     # In py37 cython/clang sees `len(outbuff)` as size_t and not Py_ssize_t
     if <Py_ssize_t>len(outbuff) != <Py_ssize_t>result_length:
-        raise ValueError("RDC: {got} != {expect}\n"
-                         .format(got=len(outbuff), expect=result_length))
+        raise ValueError(f"RDC: {len(outbuff)} != {result_length}\n")
 
     return np.asarray(outbuff)
 
@@ -236,8 +231,7 @@ cdef class Parser:
         int subheader_pointer_length
         int current_page_type
         bint is_little_endian
-        const uint8_t[:] (*decompress)(int result_length,
-                                       const uint8_t[:] inbuff)
+        const uint8_t[:] (*decompress)(int result_length, const uint8_t[:] inbuff)
         object parser
 
     def __init__(self, object parser):
@@ -270,9 +264,7 @@ cdef class Parser:
             elif column_types[j] == b's':
                 self.column_types[j] = column_type_string
             else:
-                raise ValueError("unknown column type: "
-                                 "{typ}"
-                                 .format(typ=self.parser.columns[j].ctype))
+                raise ValueError(f"unknown column type: {self.parser.columns[j].ctype}")
 
         # compression
         if parser.compression == const.rle_compression:
@@ -292,15 +284,14 @@ cdef class Parser:
             bint done
             int i
 
-        for i in range(nrows):
+        for _ in range(nrows):
             done = self.readline()
             if done:
                 break
 
         # update the parser
         self.parser._current_row_on_page_index = self.current_row_on_page_index
-        self.parser._current_row_in_chunk_index =\
-            self.current_row_in_chunk_index
+        self.parser._current_row_in_chunk_index = self.current_row_in_chunk_index
         self.parser._current_row_in_file_index = self.current_row_in_file_index
 
     cdef bint read_next_page(self):
@@ -321,9 +312,9 @@ cdef class Parser:
         self.current_page_type = self.parser._current_page_type
         self.current_page_block_count = self.parser._current_page_block_count
         self.current_page_data_subheader_pointers_len = len(
-            self.parser._current_page_data_subheader_pointers)
-        self.current_page_subheaders_count =\
-            self.parser._current_page_subheaders_count
+            self.parser._current_page_data_subheader_pointers
+        )
+        self.current_page_subheaders_count = self.parser._current_page_subheaders_count
 
     cdef readline(self):
 
@@ -361,19 +352,18 @@ cdef class Parser:
                 return False
             elif (self.current_page_type == page_mix_types_0 or
                     self.current_page_type == page_mix_types_1):
-                align_correction = (bit_offset + subheader_pointers_offset +
-                                    self.current_page_subheaders_count *
-                                    subheader_pointer_length)
+                align_correction = (
+                    bit_offset
+                    + subheader_pointers_offset
+                    + self.current_page_subheaders_count * subheader_pointer_length
+                )
                 align_correction = align_correction % 8
                 offset = bit_offset + align_correction
                 offset += subheader_pointers_offset
-                offset += (self.current_page_subheaders_count *
-                           subheader_pointer_length)
+                offset += self.current_page_subheaders_count * subheader_pointer_length
                 offset += self.current_row_on_page_index * self.row_length
-                self.process_byte_array_with_data(offset,
-                                                  self.row_length)
-                mn = min(self.parser.row_count,
-                         self.parser._mix_page_row_count)
+                self.process_byte_array_with_data(offset, self.row_length)
+                mn = min(self.parser.row_count, self.parser._mix_page_row_count)
                 if self.current_row_on_page_index == mn:
                     done = self.read_next_page()
                     if done:
@@ -381,19 +371,19 @@ cdef class Parser:
                 return False
             elif self.current_page_type & page_data_type == page_data_type:
                 self.process_byte_array_with_data(
-                    bit_offset + subheader_pointers_offset +
-                    self.current_row_on_page_index * self.row_length,
-                    self.row_length)
-                flag = (self.current_row_on_page_index ==
-                        self.current_page_block_count)
+                    bit_offset
+                    + subheader_pointers_offset
+                    + self.current_row_on_page_index * self.row_length,
+                    self.row_length,
+                )
+                flag = self.current_row_on_page_index == self.current_page_block_count
                 if flag:
                     done = self.read_next_page()
                     if done:
                         return True
                 return False
             else:
-                raise ValueError("unknown page type: {typ}"
-                                 .format(typ=self.current_page_type))
+                raise ValueError(f"unknown page type: {self.current_page_type}")
 
     cdef void process_byte_array_with_data(self, int offset, int length):
 
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 7cc9dc11a8ccc..d47dd2c71b86f 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -13,6 +13,7 @@
 Reference for binary data compression:
   http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
 """
+from collections import abc
 from datetime import datetime
 import struct
 
@@ -22,7 +23,7 @@
 
 import pandas as pd
 
-from pandas.io.common import BaseIterator, get_filepath_or_buffer
+from pandas.io.common import get_filepath_or_buffer
 from pandas.io.sas._sas import Parser
 import pandas.io.sas.sas_constants as const
 
@@ -36,7 +37,7 @@ class _column:
 
 
 # SAS7BDAT represents a SAS data file in SAS7BDAT format.
-class SAS7BDATReader(BaseIterator):
+class SAS7BDATReader(abc.Iterator):
     """
     Read SAS files in SAS7BDAT format.
 
@@ -119,8 +120,10 @@ def column_data_offsets(self):
         return np.asarray(self._column_data_offsets, dtype=np.int64)
 
     def column_types(self):
-        """Returns a numpy character array of the column types:
-           s (string) or d (double)"""
+        """
+        Returns a numpy character array of the column types:
+           s (string) or d (double)
+        """
         return np.asarray(self._column_types, dtype=np.dtype("S1"))
 
     def close(self):
@@ -169,7 +172,7 @@ def _get_properties(self):
         if buf in const.encoding_names:
             self.file_encoding = const.encoding_names[buf]
         else:
-            self.file_encoding = "unknown (code={name!s})".format(name=buf)
+            self.file_encoding = f"unknown (code={buf})"
 
         # Get platform information
         buf = self._read_bytes(const.platform_offset, const.platform_length)
@@ -293,8 +296,8 @@ def _read_bytes(self, offset, length):
             buf = self._path_or_buf.read(length)
             if len(buf) < length:
                 self.close()
-                msg = "Unable to read {:d} bytes from file position {:d}."
-                raise ValueError(msg.format(length, offset))
+                msg = f"Unable to read {length:d} bytes from file position {offset:d}."
+                raise ValueError(msg)
             return buf
         else:
             if offset + length > len(self._cached_page):
@@ -457,12 +460,8 @@ def _process_columnsize_subheader(self, offset, length):
         self.column_count = self._read_int(offset, int_len)
         if self.col_count_p1 + self.col_count_p2 != self.column_count:
             print(
-                "Warning: column count mismatch ({p1} + {p2} != "
-                "{column_count})\n".format(
-                    p1=self.col_count_p1,
-                    p2=self.col_count_p2,
-                    column_count=self.column_count,
-                )
+                f"Warning: column count mismatch ({self.col_count_p1} + "
+                f"{self.col_count_p2} != {self.column_count})\n"
             )
 
     # Unknown purpose
@@ -672,8 +671,11 @@ def _read_next_page(self):
             return True
         elif len(self._cached_page) != self._page_length:
             self.close()
-            msg = "failed to read complete page from file " "(read {:d} of {:d} bytes)"
-            raise ValueError(msg.format(len(self._cached_page), self._page_length))
+            msg = (
+                "failed to read complete page from file (read "
+                f"{len(self._cached_page):d} of {self._page_length:d} bytes)"
+            )
+            raise ValueError(msg)
 
         self._read_page_header()
         page_type = self._current_page_type
@@ -725,8 +727,6 @@ def _chunk_to_dataframe(self):
                 js += 1
             else:
                 self.close()
-                raise ValueError(
-                    "unknown column type {type}".format(type=self._column_types[j])
-                )
+                raise ValueError(f"unknown column type {self._column_types[j]}")
 
         return rslt
diff --git a/pandas/io/sas/sas_xport.py b/pandas/io/sas/sas_xport.py
index ea26a9b8efdbf..3cf7fd885e564 100644
--- a/pandas/io/sas/sas_xport.py
+++ b/pandas/io/sas/sas_xport.py
@@ -7,7 +7,7 @@
 
 https://support.sas.com/techsup/technote/ts140.pdf
 """
-
+from collections import abc
 from datetime import datetime
 from io import BytesIO
 import struct
@@ -19,7 +19,7 @@
 
 import pandas as pd
 
-from pandas.io.common import BaseIterator, get_filepath_or_buffer
+from pandas.io.common import get_filepath_or_buffer
 
 _correct_line1 = (
     "HEADER RECORD*******LIBRARY HEADER RECORD!!!!!!!"
@@ -143,7 +143,7 @@
 """
 
 
-def _parse_date(datestr):
+def _parse_date(datestr: str) -> datetime:
     """ Given a date in xport format, return Python date. """
     try:
         # e.g. "16FEB11:10:07:55"
@@ -152,11 +152,11 @@ def _parse_date(datestr):
         return pd.NaT
 
 
-def _split_line(s, parts):
+def _split_line(s: str, parts):
     """
     Parameters
     ----------
-    s: string
+    s: str
         Fixed-length string to split
     parts: list of (name, length) pairs
         Used to break up string, name '_' will be filtered from output.
@@ -251,7 +251,7 @@ def _parse_float_vec(vec):
     return ieee
 
 
-class XportReader(BaseIterator):
+class XportReader(abc.Iterator):
     __doc__ = _xport_reader_doc
 
     def __init__(
@@ -367,8 +367,8 @@ def _read_header(self):
             fl = field["field_length"]
             if field["ntype"] == "numeric" and ((fl < 2) or (fl > 8)):
                 self.close()
-                msg = "Floating field width {0} is not between 2 and 8."
-                raise TypeError(msg.format(fl))
+                msg = f"Floating field width {fl} is not between 2 and 8."
+                raise TypeError(msg)
 
             for k, v in field.items():
                 try:
@@ -402,7 +402,7 @@ def _read_header(self):
     def __next__(self):
         return self.read(nrows=self._chunksize or 1)
 
-    def _record_count(self):
+    def _record_count(self) -> int:
         """
         Get number of records in file.
 
@@ -482,7 +482,7 @@ def read(self, nrows=None):
 
         df = pd.DataFrame(index=range(read_lines))
         for j, x in enumerate(self.columns):
-            vec = data["s%d" % j]
+            vec = data["s" + str(j)]
             ntype = self.fields[j]["ntype"]
             if ntype == "numeric":
                 vec = _handle_truncated_float_vec(vec, self.fields[j]["field_length"])
diff --git a/pandas/io/sas/sasreader.py b/pandas/io/sas/sasreader.py
index 571c544d48b29..27d56d4ede403 100644
--- a/pandas/io/sas/sasreader.py
+++ b/pandas/io/sas/sasreader.py
@@ -1,7 +1,7 @@
 """
 Read SAS sas7bdat or xport files.
 """
-from pandas.io.common import _stringify_path
+from pandas.io.common import stringify_path
 
 
 def read_sas(
@@ -29,12 +29,12 @@ def read_sas(
         By file-like object, we refer to objects with a ``read()`` method,
         such as a file handler (e.g. via builtin ``open`` function)
         or ``StringIO``.
-    format : string {'xport', 'sas7bdat'} or None
+    format : str {'xport', 'sas7bdat'} or None
         If None, file format is inferred from file extension. If 'xport' or
         'sas7bdat', uses the corresponding format.
     index : identifier of index column, defaults to None
         Identifier of column that should be used as index of the DataFrame.
-    encoding : string, default is None
+    encoding : str, default is None
         Encoding for text data.  If None, text data are stored as raw bytes.
     chunksize : int
         Read file `chunksize` lines at a time, returns iterator.
@@ -49,10 +49,9 @@ def read_sas(
     if format is None:
         buffer_error_msg = (
             "If this is a buffer object rather "
-            "than a string name, you must specify "
-            "a format string"
+            "than a string name, you must specify a format string"
         )
-        filepath_or_buffer = _stringify_path(filepath_or_buffer)
+        filepath_or_buffer = stringify_path(filepath_or_buffer)
         if not isinstance(filepath_or_buffer, str):
             raise ValueError(buffer_error_msg)
         fname = filepath_or_buffer.lower()
diff --git a/pandas/io/spss.py b/pandas/io/spss.py
index 4f13349a819c3..9605faeb36590 100644
--- a/pandas/io/spss.py
+++ b/pandas/io/spss.py
@@ -3,7 +3,8 @@
 
 from pandas.compat._optional import import_optional_dependency
 
-from pandas.api.types import is_list_like
+from pandas.core.dtypes.inference import is_list_like
+
 from pandas.core.api import DataFrame
 
 
@@ -19,8 +20,8 @@ def read_spss(
 
     Parameters
     ----------
-    path : string or Path
-        File path
+    path : str or Path
+        File path.
     usecols : list-like, optional
         Return a subset of the columns. If None, return all columns.
     convert_categoricals : bool, default is True
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 44cb399336d62..36291b2faeed0 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -12,7 +12,6 @@
 import numpy as np
 
 import pandas._libs.lib as lib
-from pandas.compat import raise_with_traceback
 
 from pandas.core.dtypes.common import is_datetime64tz_dtype, is_dict_like, is_list_like
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
@@ -242,7 +241,7 @@ def read_sql_table(
     try:
         meta.reflect(only=[table_name], views=True)
     except sqlalchemy.exc.InvalidRequestError:
-        raise ValueError("Table {name} not found".format(name=table_name))
+        raise ValueError(f"Table {table_name} not found")
 
     pandas_sql = SQLDatabase(con, meta=meta)
     table = pandas_sql.read_table(
@@ -257,7 +256,7 @@ def read_sql_table(
     if table is not None:
         return table
     else:
-        raise ValueError("Table {name} not found".format(name=table_name), con)
+        raise ValueError(f"Table {table_name} not found", con)
 
 
 def read_sql_query(
@@ -278,16 +277,16 @@ def read_sql_query(
 
     Parameters
     ----------
-    sql : string SQL query or SQLAlchemy Selectable (select or text object)
+    sql : str SQL query or SQLAlchemy Selectable (select or text object)
         SQL query to be executed.
-    con : SQLAlchemy connectable(engine/connection), database string URI,
+    con : SQLAlchemy connectable(engine/connection), database str URI,
         or sqlite3 DBAPI2 connection
         Using SQLAlchemy makes it possible to use any DB supported by that
         library.
         If a DBAPI2 object, only sqlite3 is supported.
-    index_col : string or list of strings, optional, default: None
+    index_col : str or list of str, optional, default: None
         Column(s) to set as index(MultiIndex).
-    coerce_float : boolean, default True
+    coerce_float : bool, default True
         Attempts to convert values of non-string, non-numeric objects (like
         decimal.Decimal) to floating point. Useful for SQL result sets.
     params : list, tuple or dict, optional, default: None
@@ -295,7 +294,7 @@ def read_sql_query(
         to pass parameters is database driver dependent. Check your
         database driver documentation for which of the five syntax styles,
         described in PEP 249's paramstyle, is supported.
-        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}
+        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
     parse_dates : list or dict, default: None
         - List of column names to parse as dates.
         - Dict of ``{column_name: format string}`` where format string is
@@ -356,16 +355,18 @@ def read_sql(
 
     Parameters
     ----------
-    sql : string or SQLAlchemy Selectable (select or text object)
+    sql : str or SQLAlchemy Selectable (select or text object)
         SQL query to be executed or a table name.
-    con : SQLAlchemy connectable (engine/connection) or database string URI
-        or DBAPI2 connection (fallback mode)
+    con : SQLAlchemy connectable (engine/connection) or database str URI
+        or DBAPI2 connection (fallback mode)'
 
         Using SQLAlchemy makes it possible to use any DB supported by that
-        library. If a DBAPI2 object, only sqlite3 is supported.
-    index_col : string or list of strings, optional, default: None
+        library. If a DBAPI2 object, only sqlite3 is supported. The user is responsible
+        for engine disposal and connection closure for the SQLAlchemy connectable. See
+        `here <https://docs.sqlalchemy.org/en/13/core/connections.html>`_
+    index_col : str or list of str, optional, default: None
         Column(s) to set as index(MultiIndex).
-    coerce_float : boolean, default True
+    coerce_float : bool, default True
         Attempts to convert values of non-string, non-numeric objects (like
         decimal.Decimal) to floating point, useful for SQL result sets.
     params : list, tuple or dict, optional, default: None
@@ -373,7 +374,7 @@ def read_sql(
         to pass parameters is database driver dependent. Check your
         database driver documentation for which of the five syntax styles,
         described in PEP 249's paramstyle, is supported.
-        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}
+        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
     parse_dates : list or dict, default: None
         - List of column names to parse as dates.
         - Dict of ``{column_name: format string}`` where format string is
@@ -497,7 +498,7 @@ def to_sql(
         .. versionadded:: 0.24.0
     """
     if if_exists not in ("fail", "replace", "append"):
-        raise ValueError("'{0}' is not valid for if_exists".format(if_exists))
+        raise ValueError(f"'{if_exists}' is not valid for if_exists")
 
     pandas_sql = pandasSQL_builder(con, schema=schema)
 
@@ -624,7 +625,7 @@ def __init__(
             self.table = self.pd_sql.get_table(self.name, self.schema)
 
         if self.table is None:
-            raise ValueError("Could not init table '{name}'".format(name=name))
+            raise ValueError(f"Could not init table '{name}'")
 
     def exists(self):
         return self.pd_sql.has_table(self.name, self.schema)
@@ -642,18 +643,14 @@ def _execute_create(self):
     def create(self):
         if self.exists():
             if self.if_exists == "fail":
-                raise ValueError(
-                    "Table '{name}' already exists.".format(name=self.name)
-                )
+                raise ValueError(f"Table '{self.name}' already exists.")
             elif self.if_exists == "replace":
                 self.pd_sql.drop_table(self.name, self.schema)
                 self._execute_create()
             elif self.if_exists == "append":
                 pass
             else:
-                raise ValueError(
-                    "'{0}' is not valid for if_exists".format(self.if_exists)
-                )
+                raise ValueError(f"'{self.if_exists}' is not valid for if_exists")
         else:
             self._execute_create()
 
@@ -688,7 +685,7 @@ def insert_data(self):
             try:
                 temp.reset_index(inplace=True)
             except ValueError as err:
-                raise ValueError("duplicate name in index/columns: {0}".format(err))
+                raise ValueError(f"duplicate name in index/columns: {err}")
         else:
             temp = self.frame
 
@@ -731,7 +728,7 @@ def insert(self, chunksize=None, method=None):
         elif callable(method):
             exec_insert = partial(method, self)
         else:
-            raise ValueError("Invalid parameter `method`: {}".format(method))
+            raise ValueError(f"Invalid parameter `method`: {method}")
 
         keys, data_list = self.insert_data()
 
@@ -785,7 +782,8 @@ def read(self, coerce_float=True, parse_dates=None, columns=None, chunksize=None
 
             cols = [self.table.c[n] for n in columns]
             if self.index is not None:
-                [cols.insert(0, self.table.c[idx]) for idx in self.index[::-1]]
+                for idx in self.index[::-1]:
+                    cols.insert(0, self.table.c[idx])
             sql_select = select(cols)
         else:
             sql_select = self.table.select()
@@ -825,7 +823,7 @@ def _index_name(self, index, index_label):
                 if len(index_label) != nlevels:
                     raise ValueError(
                         "Length of 'index_label' should match number of "
-                        "levels, which is {0}".format(nlevels)
+                        f"levels, which is {nlevels}"
                     )
                 else:
                     return index_label
@@ -838,7 +836,7 @@ def _index_name(self, index, index_label):
                 return ["index"]
             else:
                 return [
-                    l if l is not None else "level_{0}".format(i)
+                    l if l is not None else f"level_{i}"
                     for i, l in enumerate(self.frame.index.names)
                 ]
 
@@ -979,8 +977,7 @@ def _sqlalchemy_type(self, col):
         if col_type == "timedelta64":
             warnings.warn(
                 "the 'timedelta' type is not supported, and will be "
-                "written as integer values (ns frequency) to the "
-                "database.",
+                "written as integer values (ns frequency) to the database.",
                 UserWarning,
                 stacklevel=8,
             )
@@ -1303,10 +1300,7 @@ def to_sql(
 
             for col, my_type in dtype.items():
                 if not isinstance(to_instance(my_type), TypeEngine):
-                    raise ValueError(
-                        "The type of {column} is not a "
-                        "SQLAlchemy type ".format(column=col)
-                    )
+                    raise ValueError(f"The type of {col} is not a SQLAlchemy type")
 
         table = SQLTable(
             name,
@@ -1330,11 +1324,11 @@ def to_sql(
                 )
             if name not in table_names:
                 msg = (
-                    "The provided table name '{0}' is not found exactly as "
+                    f"The provided table name '{name}' is not found exactly as "
                     "such in the database after writing the table, possibly "
                     "due to case sensitivity issues. Consider using lower "
                     "case table names."
-                ).format(name)
+                )
                 warnings.warn(msg, UserWarning)
 
     @property
@@ -1394,14 +1388,12 @@ def _get_unicode_name(name):
     try:
         uname = str(name).encode("utf-8", "strict").decode("utf-8")
     except UnicodeError:
-        raise ValueError(
-            "Cannot convert identifier to UTF-8: '{name}'".format(name=name)
-        )
+        raise ValueError(f"Cannot convert identifier to UTF-8: '{name}'")
     return uname
 
 
 def _get_valid_sqlite_name(name):
-    # See http://stackoverflow.com/questions/6514274/how-do-you-escape-strings\
+    # See https://stackoverflow.com/questions/6514274/how-do-you-escape-strings\
     # -for-sqlite-table-column-names-in-python
     # Ensure the string can be encoded as UTF-8.
     # Ensure the string does not include any NUL characters.
@@ -1420,8 +1412,7 @@ def _get_valid_sqlite_name(name):
 
 _SAFE_NAMES_WARNING = (
     "The spaces in these column names will not be changed. "
-    "In pandas versions < 0.14, spaces were converted to "
-    "underscores."
+    "In pandas versions < 0.14, spaces were converted to underscores."
 )
 
 
@@ -1449,25 +1440,33 @@ def _execute_create(self):
             for stmt in self.table:
                 conn.execute(stmt)
 
-    def insert_statement(self):
+    def insert_statement(self, *, num_rows):
         names = list(map(str, self.frame.columns))
         wld = "?"  # wildcard char
         escape = _get_valid_sqlite_name
 
         if self.index is not None:
-            [names.insert(0, idx) for idx in self.index[::-1]]
+            for idx in self.index[::-1]:
+                names.insert(0, idx)
 
         bracketed_names = [escape(column) for column in names]
         col_names = ",".join(bracketed_names)
-        wildcards = ",".join([wld] * len(names))
-        insert_statement = "INSERT INTO {table} ({columns}) VALUES ({wld})".format(
-            table=escape(self.name), columns=col_names, wld=wildcards
+
+        row_wildcards = ",".join([wld] * len(names))
+        wildcards = ",".join(f"({row_wildcards})" for _ in range(num_rows))
+        insert_statement = (
+            f"INSERT INTO {escape(self.name)} ({col_names}) VALUES {wildcards}"
         )
         return insert_statement
 
     def _execute_insert(self, conn, keys, data_iter):
         data_list = list(data_iter)
-        conn.executemany(self.insert_statement(), data_list)
+        conn.executemany(self.insert_statement(num_rows=1), data_list)
+
+    def _execute_insert_multi(self, conn, keys, data_iter):
+        data_list = list(data_iter)
+        flattened_data = [x for row in data_list for x in row]
+        conn.execute(self.insert_statement(num_rows=len(data_list)), flattened_data)
 
     def _create_table_setup(self):
         """
@@ -1495,9 +1494,7 @@ def _create_table_setup(self):
                 keys = self.keys
             cnames_br = ", ".join(escape(c) for c in keys)
             create_tbl_stmts.append(
-                "CONSTRAINT {tbl}_pk PRIMARY KEY ({cnames_br})".format(
-                    tbl=self.name, cnames_br=cnames_br
-                )
+                f"CONSTRAINT {self.name}_pk PRIMARY KEY ({cnames_br})"
             )
 
         create_stmts = [
@@ -1536,8 +1533,7 @@ def _sql_type_name(self, col):
         if col_type == "timedelta64":
             warnings.warn(
                 "the 'timedelta' type is not supported, and will be "
-                "written as integer values (ns frequency) to the "
-                "database.",
+                "written as integer values (ns frequency) to the database.",
                 UserWarning,
                 stacklevel=8,
             )
@@ -1591,25 +1587,19 @@ def execute(self, *args, **kwargs):
         else:
             cur = self.con.cursor()
         try:
-            if kwargs:
-                cur.execute(*args, **kwargs)
-            else:
-                cur.execute(*args)
+            cur.execute(*args, **kwargs)
             return cur
         except Exception as exc:
             try:
                 self.con.rollback()
-            except Exception:  # pragma: no cover
+            except Exception as inner_exc:  # pragma: no cover
                 ex = DatabaseError(
-                    "Execution failed on sql: {sql}\n{exc}\nunable "
-                    "to rollback".format(sql=args[0], exc=exc)
+                    f"Execution failed on sql: {args[0]}\n{exc}\nunable to rollback"
                 )
-                raise_with_traceback(ex)
+                raise ex from inner_exc
 
-            ex = DatabaseError(
-                "Execution failed on sql '{sql}': {exc}".format(sql=args[0], exc=exc)
-            )
-            raise_with_traceback(ex)
+            ex = DatabaseError(f"Execution failed on sql '{args[0]}': {exc}")
+            raise ex from exc
 
     @staticmethod
     def _query_iterator(
@@ -1733,11 +1723,7 @@ def to_sql(
         if dtype is not None:
             for col, my_type in dtype.items():
                 if not isinstance(my_type, str):
-                    raise ValueError(
-                        "{column} ({type!s}) not a string".format(
-                            column=col, type=my_type
-                        )
-                    )
+                    raise ValueError(f"{col} ({my_type}) not a string")
 
         table = SQLiteTable(
             name,
@@ -1757,9 +1743,7 @@ def has_table(self, name, schema=None):
         # esc_name = escape(name)
 
         wld = "?"
-        query = (
-            "SELECT name FROM sqlite_master WHERE type='table' AND name={wld};"
-        ).format(wld=wld)
+        query = f"SELECT name FROM sqlite_master WHERE type='table' AND name={wld};"
 
         return len(self.execute(query, [name]).fetchall()) > 0
 
@@ -1767,7 +1751,7 @@ def get_table(self, table_name, schema=None):
         return None  # not supported in fallback mode
 
     def drop_table(self, name, schema=None):
-        drop_sql = "DROP TABLE {name}".format(name=_get_valid_sqlite_name(name))
+        drop_sql = f"DROP TABLE {_get_valid_sqlite_name(name)}"
         self.execute(drop_sql)
 
     def _create_sql_schema(self, frame, table_name, keys=None, dtype=None):
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 31fdaa5cc6735..4e1fcb97e7891 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -7,15 +7,16 @@
 a once again improved version.
 
 You can find more information on http://presbrey.mit.edu/PyDTA and
-http://www.statsmodels.org/devel/
+https://www.statsmodels.org/devel/
 """
-
-from collections import OrderedDict
+from collections import abc
 import datetime
-from io import BytesIO
+from io import BytesIO, IOBase
 import os
+from pathlib import Path
 import struct
 import sys
+from typing import Any, AnyStr, BinaryIO, Dict, List, Optional, Sequence, Tuple, Union
 import warnings
 
 from dateutil.relativedelta import relativedelta
@@ -23,7 +24,8 @@
 
 from pandas._libs.lib import infer_dtype
 from pandas._libs.writers import max_len_string_array
-from pandas.util._decorators import Appender, deprecate_kwarg
+from pandas._typing import FilePathOrBuffer, Label
+from pandas.util._decorators import Appender
 
 from pandas.core.dtypes.common import (
     ensure_object,
@@ -42,42 +44,40 @@
     to_timedelta,
 )
 from pandas.core.frame import DataFrame
+from pandas.core.indexes.base import Index
 from pandas.core.series import Series
 
-from pandas.io.common import BaseIterator, _stringify_path, get_filepath_or_buffer
+from pandas.io.common import get_filepath_or_buffer, stringify_path
 
 _version_error = (
-    "Version of given Stata file is not 104, 105, 108, "
-    "111 (Stata 7SE), 113 (Stata 8/9), 114 (Stata 10/11), "
-    "115 (Stata 12), 117 (Stata 13), or 118 (Stata 14)"
+    "Version of given Stata file is {version}. pandas supports importing "
+    "versions 104, 105, 108, 111 (Stata 7SE), 113 (Stata 8/9), "
+    "114 (Stata 10/11), 115 (Stata 12), 117 (Stata 13), 118 (Stata 14/15/16),"
+    "and 119 (Stata 15/16, over 32,767 variables)."
 )
 
 _statafile_processing_params1 = """\
-convert_dates : boolean, defaults to True
+convert_dates : bool, default True
     Convert date variables to DataFrame time values.
-convert_categoricals : boolean, defaults to True
+convert_categoricals : bool, default True
     Read value labels and convert columns to Categorical/Factor variables."""
 
-_encoding_params = """\
-encoding : string, None or encoding
-    Encoding used to parse the files. None defaults to latin-1."""
-
 _statafile_processing_params2 = """\
-index_col : string, optional, default: None
+index_col : str, optional
     Column to set as index.
-convert_missing : boolean, defaults to False
+convert_missing : bool, default False
     Flag indicating whether to convert missing values to their Stata
     representations.  If False, missing values are replaced with nan.
     If True, columns containing missing values are returned with
     object data types and missing values are represented by
     StataMissingValue objects.
-preserve_dtypes : boolean, defaults to True
+preserve_dtypes : bool, default True
     Preserve Stata datatypes. If False, numeric data are upcast to pandas
     default types for foreign data (float64 or int64).
 columns : list or None
     Columns to retain.  Columns will be returned in the given order.  None
     returns all columns.
-order_categoricals : boolean, defaults to True
+order_categoricals : bool, default True
     Flag indicating whether converted categorical data are ordered."""
 
 _chunksize_params = """\
@@ -86,10 +86,10 @@
     given number of lines."""
 
 _iterator_params = """\
-iterator : boolean, default False
+iterator : bool, default False
     Return StataReader object."""
 
-_read_stata_doc = """
+_read_stata_doc = f"""
 Read Stata file into DataFrame.
 
 Parameters
@@ -104,11 +104,10 @@
     By file-like object, we refer to objects with a ``read()`` method,
     such as a file handler (e.g. via builtin ``open`` function)
     or ``StringIO``.
-%s
-%s
-%s
-%s
-%s
+{_statafile_processing_params1}
+{_statafile_processing_params2}
+{_chunksize_params}
+{_iterator_params}
 
 Returns
 -------
@@ -130,53 +129,24 @@
 >>> itr = pd.read_stata('filename.dta', chunksize=10000)
 >>> for chunk in itr:
 ...     do_something(chunk)
-""" % (
-    _statafile_processing_params1,
-    _encoding_params,
-    _statafile_processing_params2,
-    _chunksize_params,
-    _iterator_params,
-)
-
-_data_method_doc = """
-Read observations from Stata file, converting them into a dataframe
-
-.. deprecated::
-    This is a legacy method.  Use `read` in new code.
-
-Parameters
-----------
-%s
-%s
-
-Returns
--------
-DataFrame
-""" % (
-    _statafile_processing_params1,
-    _statafile_processing_params2,
-)
+"""
 
-_read_method_doc = """\
+_read_method_doc = f"""\
 Reads observations from Stata file, converting them into a dataframe
 
 Parameters
 ----------
 nrows : int
     Number of lines to read from data file, if None read whole file.
-%s
-%s
+{_statafile_processing_params1}
+{_statafile_processing_params2}
 
 Returns
 -------
 DataFrame
-""" % (
-    _statafile_processing_params1,
-    _statafile_processing_params2,
-)
-
+"""
 
-_stata_reader_doc = """\
+_stata_reader_doc = f"""\
 Class for reading Stata dta files.
 
 Parameters
@@ -186,55 +156,10 @@
     implementing a binary read() functions.
 
     .. versionadded:: 0.23.0 support for pathlib, py.path.
-%s
-%s
-%s
-%s
-""" % (
-    _statafile_processing_params1,
-    _statafile_processing_params2,
-    _encoding_params,
-    _chunksize_params,
-)
-
-
-@Appender(_read_stata_doc)
-@deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
-@deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
-def read_stata(
-    filepath_or_buffer,
-    convert_dates=True,
-    convert_categoricals=True,
-    encoding=None,
-    index_col=None,
-    convert_missing=False,
-    preserve_dtypes=True,
-    columns=None,
-    order_categoricals=True,
-    chunksize=None,
-    iterator=False,
-):
-
-    reader = StataReader(
-        filepath_or_buffer,
-        convert_dates=convert_dates,
-        convert_categoricals=convert_categoricals,
-        index_col=index_col,
-        convert_missing=convert_missing,
-        preserve_dtypes=preserve_dtypes,
-        columns=columns,
-        order_categoricals=order_categoricals,
-        chunksize=chunksize,
-    )
-
-    if iterator or chunksize:
-        data = reader
-    else:
-        try:
-            data = reader.read()
-        finally:
-            reader.close()
-    return data
+{_statafile_processing_params1}
+{_statafile_processing_params2}
+{_chunksize_params}
+"""
 
 
 _date_formats = ["%tc", "%tC", "%td", "%d", "%tw", "%tm", "%tq", "%th", "%ty"]
@@ -243,9 +168,12 @@ def read_stata(
 stata_epoch = datetime.datetime(1960, 1, 1)
 
 
-def _stata_elapsed_date_to_datetime_vec(dates, fmt):
+# TODO: Add typing. As of January 2020 it is not possible to type this function since
+#  mypy doesn't understand that a Series and an int can be combined using mathematical
+#  operations. (+, -).
+def _stata_elapsed_date_to_datetime_vec(dates, fmt) -> Series:
     """
-    Convert from SIF to datetime. http://www.stata.com/help.cgi?datetime
+    Convert from SIF to datetime. https://www.stata.com/help.cgi?datetime
 
     Parameters
     ----------
@@ -288,9 +216,6 @@ def _stata_elapsed_date_to_datetime_vec(dates, fmt):
         half-years since 1960h1 yearly
     date - ty
         years since 0000
-
-    If you don't have pandas with datetime support, then you can't do
-    milliseconds accurately.
     """
     MIN_YEAR, MAX_YEAR = Timestamp.min.year, Timestamp.max.year
     MAX_DAY_DELTA = (Timestamp.max - datetime.datetime(1960, 1, 1)).days
@@ -298,7 +223,7 @@ def _stata_elapsed_date_to_datetime_vec(dates, fmt):
     MIN_MS_DELTA = MIN_DAY_DELTA * 24 * 3600 * 1000
     MAX_MS_DELTA = MAX_DAY_DELTA * 24 * 3600 * 1000
 
-    def convert_year_month_safe(year, month):
+    def convert_year_month_safe(year, month) -> Series:
         """
         Convert year and month to datetimes, using pandas vectorized versions
         when the date range falls within the range supported by pandas.
@@ -313,7 +238,7 @@ def convert_year_month_safe(year, month):
                 [datetime.datetime(y, m, 1) for y, m in zip(year, month)], index=index
             )
 
-    def convert_year_days_safe(year, days):
+    def convert_year_days_safe(year, days) -> Series:
         """
         Converts year (e.g. 1999) and days since the start of the year to a
         datetime or datetime64 Series
@@ -328,7 +253,7 @@ def convert_year_days_safe(year, days):
             ]
             return Series(value, index=index)
 
-    def convert_delta_safe(base, deltas, unit):
+    def convert_delta_safe(base, deltas, unit) -> Series:
         """
         Convert base dates and deltas to datetimes, using pandas vectorized
         versions if the deltas satisfy restrictions required to be expressed
@@ -389,18 +314,18 @@ def convert_delta_safe(base, deltas, unit):
         conv_dates = convert_year_month_safe(year, month)
     elif fmt.startswith(("%tq", "tq")):  # Delta quarters relative to base
         year = stata_epoch.year + dates // 4
-        month = (dates % 4) * 3 + 1
-        conv_dates = convert_year_month_safe(year, month)
+        quarter_month = (dates % 4) * 3 + 1
+        conv_dates = convert_year_month_safe(year, quarter_month)
     elif fmt.startswith(("%th", "th")):  # Delta half-years relative to base
         year = stata_epoch.year + dates // 2
         month = (dates % 2) * 6 + 1
         conv_dates = convert_year_month_safe(year, month)
     elif fmt.startswith(("%ty", "ty")):  # Years -- not delta
         year = dates
-        month = np.ones_like(dates)
-        conv_dates = convert_year_month_safe(year, month)
+        first_month = np.ones_like(dates)
+        conv_dates = convert_year_month_safe(year, first_month)
     else:
-        raise ValueError("Date fmt {fmt} not understood".format(fmt=fmt))
+        raise ValueError(f"Date fmt {fmt} not understood")
 
     if has_bad_values:  # Restore NaT for bad values
         conv_dates[bad_locs] = NaT
@@ -408,9 +333,9 @@ def convert_delta_safe(base, deltas, unit):
     return conv_dates
 
 
-def _datetime_to_stata_elapsed_vec(dates, fmt):
+def _datetime_to_stata_elapsed_vec(dates: Series, fmt: str) -> Series:
     """
-    Convert from datetime to SIF. http://www.stata.com/help.cgi?datetime
+    Convert from datetime to SIF. https://www.stata.com/help.cgi?datetime
 
     Parameters
     ----------
@@ -428,21 +353,26 @@ def parse_dates_safe(dates, delta=False, year=False, days=False):
         d = {}
         if is_datetime64_dtype(dates.values):
             if delta:
-                delta = dates - stata_epoch
-                d["delta"] = delta.values.astype(np.int64) // 1000  # microseconds
+                time_delta = dates - stata_epoch
+                d["delta"] = time_delta.values.astype(np.int64) // 1000  # microseconds
             if days or year:
-                dates = DatetimeIndex(dates)
-                d["year"], d["month"] = dates.year, dates.month
+                # ignore since mypy reports that DatetimeIndex has no year/month
+                date_index = DatetimeIndex(dates)
+                d["year"] = date_index.year  # type: ignore
+                d["month"] = date_index.month  # type: ignore
             if days:
-                days = dates.astype(np.int64) - to_datetime(
+                days_in_ns = dates.astype(np.int64) - to_datetime(
                     d["year"], format="%Y"
                 ).astype(np.int64)
-                d["days"] = days // NS_PER_DAY
+                d["days"] = days_in_ns // NS_PER_DAY
 
         elif infer_dtype(dates, skipna=False) == "datetime":
             if delta:
                 delta = dates.values - stata_epoch
-                f = lambda x: US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
+
+                def f(x: datetime.timedelta) -> float:
+                    return US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
+
                 v = np.vectorize(f)
                 d["delta"] = v(delta)
             if year:
@@ -450,8 +380,11 @@ def parse_dates_safe(dates, delta=False, year=False, days=False):
                 d["year"] = year_month.values // 100
                 d["month"] = year_month.values - d["year"] * 100
             if days:
-                f = lambda x: (x - datetime.datetime(x.year, 1, 1)).days
-                v = np.vectorize(f)
+
+                def g(x: datetime.datetime) -> int:
+                    return (x - datetime.datetime(x.year, 1, 1)).days
+
+                v = np.vectorize(g)
                 d["days"] = v(dates)
         else:
             raise ValueError(
@@ -495,9 +428,7 @@ def parse_dates_safe(dates, delta=False, year=False, days=False):
         d = parse_dates_safe(dates, year=True)
         conv_dates = d.year
     else:
-        raise ValueError(
-            "Format {fmt} is not a known Stata date format".format(fmt=fmt)
-        )
+        raise ValueError(f"Format {fmt} is not a known Stata date format")
 
     conv_dates = Series(conv_dates, dtype=np.float64)
     missing_value = struct.unpack("<d", b"\x00\x00\x00\x00\x00\x00\xe0\x7f")[0]
@@ -508,7 +439,7 @@ def parse_dates_safe(dates, delta=False, year=False, days=False):
 
 excessive_string_length_error = """
 Fixed width strings in Stata .dta files are limited to 244 (or fewer)
-characters.  Column '%s' does not satisfy this restriction. Use the
+characters.  Column '{0}' does not satisfy this restriction. Use the
 'version=117' parameter to write the newer (Stata 13 and later) format.
 """
 
@@ -550,7 +481,7 @@ class InvalidColumnName(Warning):
 """
 
 
-def _cast_to_stata_types(data):
+def _cast_to_stata_types(data: DataFrame) -> DataFrame:
     """Checks the dtypes of the columns of a pandas DataFrame for
     compatibility with the data types and ranges supported by Stata, and
     converts if necessary.
@@ -598,7 +529,7 @@ def _cast_to_stata_types(data):
                     dtype = c_data[2]
                 if c_data[2] == np.float64:  # Warn if necessary
                     if data[col].max() >= 2 ** 53:
-                        ws = precision_loss_doc % ("uint64", "float64")
+                        ws = precision_loss_doc.format("uint64", "float64")
 
                 data[col] = data[col].astype(dtype)
 
@@ -614,26 +545,22 @@ def _cast_to_stata_types(data):
                 data[col] = data[col].astype(np.int32)
             else:
                 data[col] = data[col].astype(np.float64)
-                if data[col].max() >= 2 ** 53 or data[col].min() <= -2 ** 53:
-                    ws = precision_loss_doc % ("int64", "float64")
+                if data[col].max() >= 2 ** 53 or data[col].min() <= -(2 ** 53):
+                    ws = precision_loss_doc.format("int64", "float64")
         elif dtype in (np.float32, np.float64):
             value = data[col].max()
             if np.isinf(value):
                 raise ValueError(
-                    "Column {col} has a maximum value of "
-                    "infinity which is outside the range "
-                    "supported by Stata.".format(col=col)
+                    f"Column {col} has a maximum value of infinity which is outside "
+                    "the range supported by Stata."
                 )
             if dtype == np.float32 and value > float32_max:
                 data[col] = data[col].astype(np.float64)
             elif dtype == np.float64:
                 if value > float64_max:
                     raise ValueError(
-                        "Column {col} has a maximum value "
-                        "({val}) outside the range supported by "
-                        "Stata ({float64_max})".format(
-                            col=col, val=value, float64_max=float64_max
-                        )
+                        f"Column {col} has a maximum value ({value}) outside the range "
+                        f"supported by Stata ({float64_max})"
                     )
 
     if ws:
@@ -648,33 +575,25 @@ class StataValueLabel:
 
     Parameters
     ----------
-    value : int8, int16, int32, float32 or float64
-        The Stata missing value code
-
-    Attributes
-    ----------
-    string : string
-        String representation of the Stata missing value
-    value : int8, int16, int32, float32 or float64
-        The original encoded missing value
-
-    Methods
-    -------
-    generate_value_label
-
+    catarray : Series
+        Categorical Series to encode
+    encoding : {"latin-1", "utf-8"}
+        Encoding to use for value labels.
     """
 
-    def __init__(self, catarray):
+    def __init__(self, catarray: Series, encoding: str = "latin-1"):
 
+        if encoding not in ("latin-1", "utf-8"):
+            raise ValueError("Only latin-1 and utf-8 are supported.")
         self.labname = catarray.name
-
+        self._encoding = encoding
         categories = catarray.cat.categories
         self.value_labels = list(zip(np.arange(len(categories)), categories))
         self.value_labels.sort(key=lambda x: x[0])
-        self.text_len = np.int32(0)
-        self.off = []
-        self.val = []
-        self.txt = []
+        self.text_len = 0
+        self.off: List[int] = []
+        self.val: List[int] = []
+        self.txt: List[bytes] = []
         self.n = 0
 
         # Compute lengths and setup lists of offsets and labels
@@ -686,7 +605,7 @@ def __init__(self, catarray):
                     value_label_mismatch_doc.format(catarray.name),
                     ValueLabelTypeMismatch,
                 )
-
+            category = category.encode(encoding)
             self.off.append(self.text_len)
             self.text_len += len(category) + 1  # +1 for the padding
             self.val.append(vl[0])
@@ -696,8 +615,7 @@ def __init__(self, catarray):
         if self.text_len > 32000:
             raise ValueError(
                 "Stata value labels for a single variable must "
-                "have a combined length less than 32,000 "
-                "characters."
+                "have a combined length less than 32,000 characters."
             )
 
         # Ensure int32
@@ -707,37 +625,31 @@ def __init__(self, catarray):
         # Total length
         self.len = 4 + 4 + 4 * self.n + 4 * self.n + self.text_len
 
-    def _encode(self, s):
+    def generate_value_label(self, byteorder: str) -> bytes:
         """
-        Python 3 compatibility shim
-        """
-        return s.encode(self._encoding)
+        Generate the binary representation of the value labals.
 
-    def generate_value_label(self, byteorder, encoding):
-        """
         Parameters
         ----------
         byteorder : str
             Byte order of the output
-        encoding : str
-            File encoding
 
         Returns
         -------
         value_label : bytes
             Bytes containing the formatted value label
         """
-
-        self._encoding = encoding
+        encoding = self._encoding
         bio = BytesIO()
-        null_string = "\x00"
         null_byte = b"\x00"
 
         # len
         bio.write(struct.pack(byteorder + "i", self.len))
 
         # labname
-        labname = self._encode(_pad_bytes(self.labname[:32], 33))
+        labname = str(self.labname)[:32].encode(encoding)
+        lab_len = 32 if encoding not in ("utf-8", "utf8") else 128
+        labname = _pad_bytes(labname, lab_len + 1)
         bio.write(labname)
 
         # padding - 3 bytes
@@ -761,7 +673,7 @@ def generate_value_label(self, byteorder, encoding):
 
         # txt - Text labels, null terminated
         for text in self.txt:
-            bio.write(self._encode(text + null_string))
+            bio.write(text + null_byte)
 
         bio.seek(0)
         return bio.read()
@@ -773,19 +685,12 @@ class StataMissingValue:
 
     Parameters
     ----------
-    value : int8, int16, int32, float32 or float64
+    value : {int, float}
         The Stata missing value code
 
-    Attributes
-    ----------
-    string : string
-        String representation of the Stata missing value
-    value : int8, int16, int32, float32 or float64
-        The original encoded missing value
-
     Notes
     -----
-    More information: <http://www.stata.com/help.cgi?missing>
+    More information: <https://www.stata.com/help.cgi?missing>
 
     Integer missing values make the code '.', '.a', ..., '.z' to the ranges
     101 ... 127 (for int8), 32741 ... 32767  (for int16) and 2147483621 ...
@@ -812,7 +717,7 @@ class StataMissingValue:
     """
 
     # Construct a dictionary of missing values
-    MISSING_VALUES = {}
+    MISSING_VALUES: Dict[float, str] = {}
     bases = (101, 32741, 2147483621)
     for b in bases:
         # Conversion to long to avoid hash issues on 32 bit platforms #8968
@@ -823,21 +728,21 @@ class StataMissingValue:
     float32_base = b"\x00\x00\x00\x7f"
     increment = struct.unpack("<i", b"\x00\x08\x00\x00")[0]
     for i in range(27):
-        value = struct.unpack("<f", float32_base)[0]
-        MISSING_VALUES[value] = "."
+        key = struct.unpack("<f", float32_base)[0]
+        MISSING_VALUES[key] = "."
         if i > 0:
-            MISSING_VALUES[value] += chr(96 + i)
-        int_value = struct.unpack("<i", struct.pack("<f", value))[0] + increment
+            MISSING_VALUES[key] += chr(96 + i)
+        int_value = struct.unpack("<i", struct.pack("<f", key))[0] + increment
         float32_base = struct.pack("<i", int_value)
 
     float64_base = b"\x00\x00\x00\x00\x00\x00\xe0\x7f"
     increment = struct.unpack("q", b"\x00\x00\x00\x00\x00\x01\x00\x00")[0]
     for i in range(27):
-        value = struct.unpack("<d", float64_base)[0]
-        MISSING_VALUES[value] = "."
+        key = struct.unpack("<d", float64_base)[0]
+        MISSING_VALUES[key] = "."
         if i > 0:
-            MISSING_VALUES[value] += chr(96 + i)
-        int_value = struct.unpack("q", struct.pack("<d", value))[0] + increment
+            MISSING_VALUES[key] += chr(96 + i)
+        int_value = struct.unpack("q", struct.pack("<d", key))[0] + increment
         float64_base = struct.pack("q", int_value)
 
     BASE_MISSING_VALUES = {
@@ -848,36 +753,51 @@ class StataMissingValue:
         "float64": struct.unpack("<d", float64_base)[0],
     }
 
-    def __init__(self, value):
+    def __init__(self, value: Union[int, float]):
         self._value = value
         # Conversion to int to avoid hash issues on 32 bit platforms #8968
         value = int(value) if value < 2147483648 else float(value)
         self._str = self.MISSING_VALUES[value]
 
-    string = property(
-        lambda self: self._str,
-        doc="The Stata representation of the missing value: '.', '.a'..'.z'",
-    )
-    value = property(
-        lambda self: self._value, doc="The binary representation of the missing value."
-    )
+    @property
+    def string(self) -> str:
+        """
+        The Stata representation of the missing value: '.', '.a'..'.z'
+
+        Returns
+        -------
+        str
+            The representation of the missing value.
+        """
+        return self._str
+
+    @property
+    def value(self) -> Union[int, float]:
+        """
+        The binary representation of the missing value.
+
+        Returns
+        -------
+        {int, float}
+            The binary representation of the missing value.
+        """
+        return self._value
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.string
 
-    def __repr__(self):
-        # not perfect :-/
-        return "{cls}({obj})".format(cls=self.__class__, obj=self)
+    def __repr__(self) -> str:
+        return f"{type(self)}({self})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return (
-            isinstance(other, self.__class__)
+            isinstance(other, type(self))
             and self.string == other.string
             and self.value == other.value
         )
 
     @classmethod
-    def get_base_missing_value(cls, dtype):
+    def get_base_missing_value(cls, dtype: np.dtype) -> Union[int, float]:
         if dtype == np.int8:
             value = cls.BASE_MISSING_VALUES["int8"]
         elif dtype == np.int16:
@@ -1038,29 +958,42 @@ def __init__(self):
             "typedef",
             "typename",
             "virtual",
+            "_all",
+            "_N",
+            "_skip",
+            "_b",
+            "_pi",
+            "str#",
+            "in",
+            "_pred",
+            "strL",
+            "_coef",
+            "_rc",
+            "using",
+            "_cons",
+            "_se",
+            "with",
+            "_n",
         )
 
 
-class StataReader(StataParser, BaseIterator):
+class StataReader(StataParser, abc.Iterator):
     __doc__ = _stata_reader_doc
 
-    @deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
-    @deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
     def __init__(
         self,
-        path_or_buf,
-        convert_dates=True,
-        convert_categoricals=True,
-        index_col=None,
-        convert_missing=False,
-        preserve_dtypes=True,
-        columns=None,
-        order_categoricals=True,
-        encoding=None,
-        chunksize=None,
+        path_or_buf: FilePathOrBuffer,
+        convert_dates: bool = True,
+        convert_categoricals: bool = True,
+        index_col: Optional[str] = None,
+        convert_missing: bool = False,
+        preserve_dtypes: bool = True,
+        columns: Optional[Sequence[str]] = None,
+        order_categoricals: bool = True,
+        chunksize: Optional[int] = None,
     ):
         super().__init__()
-        self.col_sizes = ()
+        self.col_sizes: List[int] = []
 
         # Arguments to the reader (can be temporarily overridden in
         # calls to read).
@@ -1071,7 +1004,7 @@ def __init__(
         self._preserve_dtypes = preserve_dtypes
         self._columns = columns
         self._order_categoricals = order_categoricals
-        self._encoding = None
+        self._encoding = ""
         self._chunksize = chunksize
 
         # State variables for the file
@@ -1085,13 +1018,13 @@ def __init__(
         self._lines_read = 0
 
         self._native_byteorder = _set_endianness(sys.byteorder)
-        path_or_buf = _stringify_path(path_or_buf)
+        path_or_buf = stringify_path(path_or_buf)
         if isinstance(path_or_buf, str):
             path_or_buf, encoding, _, should_close = get_filepath_or_buffer(path_or_buf)
 
         if isinstance(path_or_buf, (str, bytes)):
             self.path_or_buf = open(path_or_buf, "rb")
-        else:
+        elif isinstance(path_or_buf, IOBase):
             # Copy to BytesIO, and ensure no encoding
             contents = path_or_buf.read()
             self.path_or_buf = BytesIO(contents)
@@ -1099,22 +1032,22 @@ def __init__(
         self._read_header()
         self._setup_dtype()
 
-    def __enter__(self):
+    def __enter__(self) -> "StataReader":
         """ enter context manager """
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         """ exit context manager """
         self.close()
 
-    def close(self):
+    def close(self) -> None:
         """ close the handle if its open """
         try:
             self.path_or_buf.close()
         except IOError:
             pass
 
-    def _set_encoding(self):
+    def _set_encoding(self) -> None:
         """
         Set string encoding which depends on file version
         """
@@ -1123,10 +1056,10 @@ def _set_encoding(self):
         else:
             self._encoding = "utf-8"
 
-    def _read_header(self):
+    def _read_header(self) -> None:
         first_char = self.path_or_buf.read(1)
         if struct.unpack("c", first_char)[0] == b"<":
-            self._read_new_header(first_char)
+            self._read_new_header()
         else:
             self._read_old_header(first_char)
 
@@ -1135,17 +1068,21 @@ def _read_header(self):
         # calculate size of a data record
         self.col_sizes = [self._calcsize(typ) for typ in self.typlist]
 
-    def _read_new_header(self, first_char):
-        # The first part of the header is common to 117 and 118.
+    def _read_new_header(self) -> None:
+        # The first part of the header is common to 117 - 119.
         self.path_or_buf.read(27)  # stata_dta><header><release>
         self.format_version = int(self.path_or_buf.read(3))
-        if self.format_version not in [117, 118]:
-            raise ValueError(_version_error)
+        if self.format_version not in [117, 118, 119]:
+            raise ValueError(_version_error.format(version=self.format_version))
         self._set_encoding()
         self.path_or_buf.read(21)  # </release><byteorder>
         self.byteorder = self.path_or_buf.read(3) == b"MSF" and ">" or "<"
         self.path_or_buf.read(15)  # </byteorder><K>
-        self.nvar = struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
+        nvar_type = "H" if self.format_version <= 118 else "I"
+        nvar_size = 2 if self.format_version <= 118 else 4
+        self.nvar = struct.unpack(
+            self.byteorder + nvar_type, self.path_or_buf.read(nvar_size)
+        )[0]
         self.path_or_buf.read(7)  # </K><N>
 
         self.nobs = self._get_nobs()
@@ -1207,48 +1144,47 @@ def _read_new_header(self, first_char):
         self.path_or_buf.seek(self._seek_variable_labels)
         self._variable_labels = self._get_variable_labels()
 
-    # Get data type information, works for versions 117-118.
-    def _get_dtypes(self, seek_vartypes):
+    # Get data type information, works for versions 117-119.
+    def _get_dtypes(
+        self, seek_vartypes: int
+    ) -> Tuple[List[Union[int, str]], List[Union[int, np.dtype]]]:
 
         self.path_or_buf.seek(seek_vartypes)
         raw_typlist = [
             struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
-            for i in range(self.nvar)
+            for _ in range(self.nvar)
         ]
 
-        def f(typ):
+        def f(typ: int) -> Union[int, str]:
             if typ <= 2045:
                 return typ
             try:
                 return self.TYPE_MAP_XML[typ]
             except KeyError:
-                raise ValueError("cannot convert stata types [{0}]".format(typ))
+                raise ValueError(f"cannot convert stata types [{typ}]")
 
         typlist = [f(x) for x in raw_typlist]
 
-        def f(typ):
+        def g(typ: int) -> Union[str, np.dtype]:
             if typ <= 2045:
                 return str(typ)
             try:
                 return self.DTYPE_MAP_XML[typ]
             except KeyError:
-                raise ValueError("cannot convert stata dtype [{0}]".format(typ))
+                raise ValueError(f"cannot convert stata dtype [{typ}]")
 
-        dtyplist = [f(x) for x in raw_typlist]
+        dtyplist = [g(x) for x in raw_typlist]
 
         return typlist, dtyplist
 
-    def _get_varlist(self):
-        if self.format_version == 117:
-            b = 33
-        elif self.format_version == 118:
-            b = 129
-
-        return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
+    def _get_varlist(self) -> List[str]:
+        # 33 in order formats, 129 in formats 118 and 119
+        b = 33 if self.format_version < 118 else 129
+        return [self._decode(self.path_or_buf.read(b)) for _ in range(self.nvar)]
 
     # Returns the format list
-    def _get_fmtlist(self):
-        if self.format_version == 118:
+    def _get_fmtlist(self) -> List[str]:
+        if self.format_version >= 118:
             b = 57
         elif self.format_version > 113:
             b = 49
@@ -1257,41 +1193,41 @@ def _get_fmtlist(self):
         else:
             b = 7
 
-        return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
+        return [self._decode(self.path_or_buf.read(b)) for _ in range(self.nvar)]
 
     # Returns the label list
-    def _get_lbllist(self):
+    def _get_lbllist(self) -> List[str]:
         if self.format_version >= 118:
             b = 129
         elif self.format_version > 108:
             b = 33
         else:
             b = 9
-        return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
+        return [self._decode(self.path_or_buf.read(b)) for _ in range(self.nvar)]
 
-    def _get_variable_labels(self):
-        if self.format_version == 118:
+    def _get_variable_labels(self) -> List[str]:
+        if self.format_version >= 118:
             vlblist = [
-                self._decode(self.path_or_buf.read(321)) for i in range(self.nvar)
+                self._decode(self.path_or_buf.read(321)) for _ in range(self.nvar)
             ]
         elif self.format_version > 105:
             vlblist = [
-                self._decode(self.path_or_buf.read(81)) for i in range(self.nvar)
+                self._decode(self.path_or_buf.read(81)) for _ in range(self.nvar)
             ]
         else:
             vlblist = [
-                self._decode(self.path_or_buf.read(32)) for i in range(self.nvar)
+                self._decode(self.path_or_buf.read(32)) for _ in range(self.nvar)
             ]
         return vlblist
 
-    def _get_nobs(self):
-        if self.format_version == 118:
+    def _get_nobs(self) -> int:
+        if self.format_version >= 118:
             return struct.unpack(self.byteorder + "Q", self.path_or_buf.read(8))[0]
         else:
             return struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
 
-    def _get_data_label(self):
-        if self.format_version == 118:
+    def _get_data_label(self) -> str:
+        if self.format_version >= 118:
             strlen = struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
             return self._decode(self.path_or_buf.read(strlen))
         elif self.format_version == 117:
@@ -1302,8 +1238,8 @@ def _get_data_label(self):
         else:
             return self._decode(self.path_or_buf.read(32))
 
-    def _get_time_stamp(self):
-        if self.format_version == 118:
+    def _get_time_stamp(self) -> str:
+        if self.format_version >= 118:
             strlen = struct.unpack("b", self.path_or_buf.read(1))[0]
             return self.path_or_buf.read(strlen).decode("utf-8")
         elif self.format_version == 117:
@@ -1314,22 +1250,22 @@ def _get_time_stamp(self):
         else:
             raise ValueError()
 
-    def _get_seek_variable_labels(self):
+    def _get_seek_variable_labels(self) -> int:
         if self.format_version == 117:
-            self.path_or_buf.read(8)  # <variable_lables>, throw away
+            self.path_or_buf.read(8)  # <variable_labels>, throw away
             # Stata 117 data files do not follow the described format.  This is
             # a work around that uses the previous label, 33 bytes for each
             # variable, 20 for the closing tag and 17 for the opening tag
             return self._seek_value_label_names + (33 * self.nvar) + 20 + 17
-        elif self.format_version == 118:
+        elif self.format_version >= 118:
             return struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 17
         else:
             raise ValueError()
 
-    def _read_old_header(self, first_char):
+    def _read_old_header(self, first_char: bytes) -> None:
         self.format_version = struct.unpack("b", first_char)[0]
         if self.format_version not in [104, 105, 108, 111, 113, 114, 115]:
-            raise ValueError(_version_error)
+            raise ValueError(_version_error.format(version=self.format_version))
         self._set_encoding()
         self.byteorder = (
             struct.unpack("b", self.path_or_buf.read(1))[0] == 0x1 and ">" or "<"
@@ -1346,7 +1282,7 @@ def _read_old_header(self, first_char):
 
         # descriptors
         if self.format_version > 108:
-            typlist = [ord(self.path_or_buf.read(1)) for i in range(self.nvar)]
+            typlist = [ord(self.path_or_buf.read(1)) for _ in range(self.nvar)]
         else:
             buf = self.path_or_buf.read(self.nvar)
             typlistb = np.frombuffer(buf, dtype=np.uint8)
@@ -1360,27 +1296,21 @@ def _read_old_header(self, first_char):
         try:
             self.typlist = [self.TYPE_MAP[typ] for typ in typlist]
         except ValueError:
-            raise ValueError(
-                "cannot convert stata types [{0}]".format(
-                    ",".join(str(x) for x in typlist)
-                )
-            )
+            invalid_types = ",".join(str(x) for x in typlist)
+            raise ValueError(f"cannot convert stata types [{invalid_types}]")
         try:
             self.dtyplist = [self.DTYPE_MAP[typ] for typ in typlist]
         except ValueError:
-            raise ValueError(
-                "cannot convert stata dtypes [{0}]".format(
-                    ",".join(str(x) for x in typlist)
-                )
-            )
+            invalid_dtypes = ",".join(str(x) for x in typlist)
+            raise ValueError(f"cannot convert stata dtypes [{invalid_dtypes}]")
 
         if self.format_version > 108:
             self.varlist = [
-                self._decode(self.path_or_buf.read(33)) for i in range(self.nvar)
+                self._decode(self.path_or_buf.read(33)) for _ in range(self.nvar)
             ]
         else:
             self.varlist = [
-                self._decode(self.path_or_buf.read(9)) for i in range(self.nvar)
+                self._decode(self.path_or_buf.read(9)) for _ in range(self.nvar)
             ]
         self.srtlist = struct.unpack(
             self.byteorder + ("h" * (self.nvar + 1)),
@@ -1418,26 +1348,27 @@ def _read_old_header(self, first_char):
         # necessary data to continue parsing
         self.data_location = self.path_or_buf.tell()
 
-    def _setup_dtype(self):
+    def _setup_dtype(self) -> np.dtype:
         """Map between numpy and state dtypes"""
         if self._dtype is not None:
             return self._dtype
 
-        dtype = []  # Convert struct data types to numpy data type
+        dtypes = []  # Convert struct data types to numpy data type
         for i, typ in enumerate(self.typlist):
             if typ in self.NUMPY_TYPE_MAP:
-                dtype.append(("s" + str(i), self.byteorder + self.NUMPY_TYPE_MAP[typ]))
+                dtypes.append(("s" + str(i), self.byteorder + self.NUMPY_TYPE_MAP[typ]))
             else:
-                dtype.append(("s" + str(i), "S" + str(typ)))
-        dtype = np.dtype(dtype)
-        self._dtype = dtype
+                dtypes.append(("s" + str(i), "S" + str(typ)))
+        self._dtype = np.dtype(dtypes)
 
         return self._dtype
 
-    def _calcsize(self, fmt):
-        return type(fmt) is int and fmt or struct.calcsize(self.byteorder + fmt)
+    def _calcsize(self, fmt: Union[int, str]) -> int:
+        if isinstance(fmt, int):
+            return fmt
+        return struct.calcsize(self.byteorder + fmt)
 
-    def _decode(self, s):
+    def _decode(self, s: bytes) -> str:
         # have bytes not strings, so must decode
         s = s.partition(b"\0")[0]
         try:
@@ -1445,32 +1376,34 @@ def _decode(self, s):
         except UnicodeDecodeError:
             # GH 25960, fallback to handle incorrect format produced when 117
             # files are converted to 118 files in Stata
-            msg = """
+            encoding = self._encoding
+            msg = f"""
 One or more strings in the dta file could not be decoded using {encoding}, and
 so the fallback encoding of latin-1 is being used.  This can happen when a file
 has been incorrectly encoded by Stata or some other software. You should verify
 the string values returned are correct."""
-            warnings.warn(msg.format(encoding=self._encoding), UnicodeWarning)
+            warnings.warn(msg, UnicodeWarning)
             return s.decode("latin-1")
 
-    def _read_value_labels(self):
+    def _read_value_labels(self) -> None:
         if self._value_labels_read:
             # Don't read twice
             return
         if self.format_version <= 108:
             # Value labels are not supported in version 108 and earlier.
             self._value_labels_read = True
-            self.value_label_dict = dict()
+            self.value_label_dict: Dict[str, Dict[Union[float, int], str]] = {}
             return
 
         if self.format_version >= 117:
             self.path_or_buf.seek(self.seek_value_labels)
         else:
+            assert self._dtype is not None
             offset = self.nobs * self._dtype.itemsize
             self.path_or_buf.seek(self.data_location + offset)
 
         self._value_labels_read = True
-        self.value_label_dict = dict()
+        self.value_label_dict = {}
 
         while True:
             if self.format_version >= 117:
@@ -1506,7 +1439,7 @@ def _read_value_labels(self):
                 self.path_or_buf.read(6)  # </lbl>
         self._value_labels_read = True
 
-    def _read_strls(self):
+    def _read_strls(self) -> None:
         self.path_or_buf.seek(self.seek_strls)
         # Wrap v_o in a string to allow uint64 values as keys on 32bit OS
         self.GSO = {"0": ""}
@@ -1519,35 +1452,28 @@ def _read_strls(self):
             else:
                 buf = self.path_or_buf.read(12)
                 # Only tested on little endian file on little endian machine.
+                v_size = 2 if self.format_version == 118 else 3
                 if self.byteorder == "<":
-                    buf = buf[0:2] + buf[4:10]
+                    buf = buf[0:v_size] + buf[4 : (12 - v_size)]
                 else:
-                    buf = buf[0:2] + buf[6:]
+                    # This path may not be correct, impossible to test
+                    buf = buf[0:v_size] + buf[(4 + v_size) :]
                 v_o = struct.unpack("Q", buf)[0]
             typ = struct.unpack("B", self.path_or_buf.read(1))[0]
             length = struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
             va = self.path_or_buf.read(length)
             if typ == 130:
-                va = va[0:-1].decode(self._encoding)
-            # Wrap v_o in a string to allow uint64 values as keys on 32bit OS
-            self.GSO[str(v_o)] = va
-
-    # legacy
-    @Appender(_data_method_doc)
-    def data(self, **kwargs):
-
-        warnings.warn("'data' is deprecated, use 'read' instead")
-
-        if self._data_read:
-            raise Exception("Data has already been read.")
-        self._data_read = True
-
-        return self.read(None, **kwargs)
+                decoded_va = va[0:-1].decode(self._encoding)
+            else:
+                # Stata says typ 129 can be binary, so use str
+                decoded_va = str(va)
+                # Wrap v_o in a string to allow uint64 values as keys on 32bit OS
+            self.GSO[str(v_o)] = decoded_va
 
-    def __next__(self):
+    def __next__(self) -> DataFrame:
         return self.read(nrows=self._chunksize or 1)
 
-    def get_chunk(self, size=None):
+    def get_chunk(self, size: Optional[int] = None) -> DataFrame:
         """
         Reads lines from Stata file and returns as dataframe
 
@@ -1565,18 +1491,17 @@ def get_chunk(self, size=None):
         return self.read(nrows=size)
 
     @Appender(_read_method_doc)
-    @deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
     def read(
         self,
-        nrows=None,
-        convert_dates=None,
-        convert_categoricals=None,
-        index_col=None,
-        convert_missing=None,
-        preserve_dtypes=None,
-        columns=None,
-        order_categoricals=None,
-    ):
+        nrows: Optional[int] = None,
+        convert_dates: Optional[bool] = None,
+        convert_categoricals: Optional[bool] = None,
+        index_col: Optional[str] = None,
+        convert_missing: Optional[bool] = None,
+        preserve_dtypes: Optional[bool] = None,
+        columns: Optional[Sequence[str]] = None,
+        order_categoricals: Optional[bool] = None,
+    ) -> DataFrame:
         # Handle empty file or chunk.  If reading incrementally raise
         # StopIteration.  If reading the whole thing return an empty
         # data frame.
@@ -1610,6 +1535,7 @@ def read(
             self._read_strls()
 
         # Read data
+        assert self._dtype is not None
         dtype = self._dtype
         max_read_len = (self.nobs - self._lines_read) * dtype.itemsize
         read_len = nrows * dtype.itemsize
@@ -1683,7 +1609,7 @@ def read(
                 else:
                     data_formatted.append((col, data[col]))
         if requires_type_conversion:
-            data = DataFrame.from_dict(OrderedDict(data_formatted))
+            data = DataFrame.from_dict(dict(data_formatted))
         del data_formatted
 
         data = self._do_convert_missing(data, convert_missing)
@@ -1722,14 +1648,14 @@ def any_startswith(x: str) -> bool:
                     convert = True
                 retyped_data.append((col, data[col].astype(dtype)))
             if convert:
-                data = DataFrame.from_dict(OrderedDict(retyped_data))
+                data = DataFrame.from_dict(dict(retyped_data))
 
         if index_col is not None:
             data = data.set_index(data.pop(index_col))
 
         return data
 
-    def _do_convert_missing(self, data, convert_missing):
+    def _do_convert_missing(self, data: DataFrame, convert_missing: bool) -> DataFrame:
         # Check for missing values, and replace if found
         replacements = {}
         for i, colname in enumerate(data):
@@ -1745,8 +1671,7 @@ def _do_convert_missing(self, data, convert_missing):
                 continue
 
             if convert_missing:  # Replacement follows Stata notation
-
-                missing_loc = np.argwhere(missing._ndarray_values)
+                missing_loc = np.nonzero(missing._ndarray_values)[0]
                 umissing, umissing_loc = np.unique(series[missing], return_inverse=True)
                 replacement = Series(series, dtype=np.object)
                 for j, um in enumerate(umissing):
@@ -1763,12 +1688,12 @@ def _do_convert_missing(self, data, convert_missing):
             replacements[colname] = replacement
         if replacements:
             columns = data.columns
-            replacements = DataFrame(replacements)
-            data = concat([data.drop(replacements.columns, 1), replacements], 1)
-            data = data[columns]
+            replacement_df = DataFrame(replacements)
+            replaced = concat([data.drop(replacement_df.columns, 1), replacement_df], 1)
+            data = replaced[columns]
         return data
 
-    def _insert_strls(self, data):
+    def _insert_strls(self, data: DataFrame) -> DataFrame:
         if not hasattr(self, "GSO") or len(self.GSO) == 0:
             return data
         for i, typ in enumerate(self.typlist):
@@ -1778,7 +1703,7 @@ def _insert_strls(self, data):
             data.iloc[:, i] = [self.GSO[str(k)] for k in data.iloc[:, i]]
         return data
 
-    def _do_select_columns(self, data, columns):
+    def _do_select_columns(self, data: DataFrame, columns: Sequence[str]) -> DataFrame:
 
         if not self._column_selector_set:
             column_set = set(columns)
@@ -1786,9 +1711,10 @@ def _do_select_columns(self, data, columns):
                 raise ValueError("columns contains duplicate entries")
             unmatched = column_set.difference(data.columns)
             if unmatched:
+                joined = ", ".join(list(unmatched))
                 raise ValueError(
-                    "The following columns were not found in the "
-                    "Stata data set: " + ", ".join(list(unmatched))
+                    "The following columns were not "
+                    f"found in the Stata data set: {joined}"
                 )
             # Copy information for retained columns for later processing
             dtyplist = []
@@ -1810,9 +1736,13 @@ def _do_select_columns(self, data, columns):
 
         return data[columns]
 
+    @staticmethod
     def _do_convert_categoricals(
-        self, data, value_label_dict, lbllist, order_categoricals
-    ):
+        data: DataFrame,
+        value_label_dict: Dict[str, Dict[Union[float, int], str]],
+        lbllist: Sequence[str],
+        order_categoricals: bool,
+    ) -> DataFrame:
         """
         Converts categorical columns to Categorical type.
         """
@@ -1832,10 +1762,10 @@ def _do_convert_categoricals(
                     cat_data.categories = categories
                 except ValueError:
                     vc = Series(categories).value_counts()
-                    repeats = list(vc.index[vc > 1])
-                    repeats = "-" * 80 + "\n" + "\n".join(repeats)
+                    repeated_cats = list(vc.index[vc > 1])
+                    repeats = "-" * 80 + "\n" + "\n".join(repeated_cats)
                     # GH 25772
-                    msg = """
+                    msg = f"""
 Value labels for column {col} are not unique. These cannot be converted to
 pandas categoricals.
 
@@ -1846,23 +1776,23 @@ def _do_convert_categoricals(
 The repeated labels are:
 {repeats}
 """
-                    raise ValueError(msg.format(col=col, repeats=repeats))
+                    raise ValueError(msg)
                 # TODO: is the next line needed above in the data(...) method?
-                cat_data = Series(cat_data, index=data.index)
-                cat_converted_data.append((col, cat_data))
+                cat_series = Series(cat_data, index=data.index)
+                cat_converted_data.append((col, cat_series))
             else:
                 cat_converted_data.append((col, data[col]))
-        data = DataFrame.from_dict(OrderedDict(cat_converted_data))
+        data = DataFrame.from_dict(dict(cat_converted_data))
         return data
 
     @property
-    def data_label(self):
+    def data_label(self) -> str:
         """
         Return data label of Stata file.
         """
         return self._data_label
 
-    def variable_labels(self):
+    def variable_labels(self) -> Dict[str, str]:
         """
         Return variable labels as a dict, associating each variable name
         with corresponding label.
@@ -1873,7 +1803,7 @@ def variable_labels(self):
         """
         return dict(zip(self.varlist, self._variable_labels))
 
-    def value_labels(self):
+    def value_labels(self) -> Dict[str, Dict[Union[float, int], str]]:
         """
         Return a dict, associating each variable name a dict, associating
         each value its corresponding label.
@@ -1888,7 +1818,43 @@ def value_labels(self):
         return self.value_label_dict
 
 
-def _open_file_binary_write(fname):
+@Appender(_read_stata_doc)
+def read_stata(
+    filepath_or_buffer: FilePathOrBuffer,
+    convert_dates: bool = True,
+    convert_categoricals: bool = True,
+    index_col: Optional[str] = None,
+    convert_missing: bool = False,
+    preserve_dtypes: bool = True,
+    columns: Optional[Sequence[str]] = None,
+    order_categoricals: bool = True,
+    chunksize: Optional[int] = None,
+    iterator: bool = False,
+) -> Union[DataFrame, StataReader]:
+
+    reader = StataReader(
+        filepath_or_buffer,
+        convert_dates=convert_dates,
+        convert_categoricals=convert_categoricals,
+        index_col=index_col,
+        convert_missing=convert_missing,
+        preserve_dtypes=preserve_dtypes,
+        columns=columns,
+        order_categoricals=order_categoricals,
+        chunksize=chunksize,
+    )
+
+    if iterator or chunksize:
+        return reader
+
+    try:
+        data = reader.read()
+    finally:
+        reader.close()
+    return data
+
+
+def _open_file_binary_write(fname: FilePathOrBuffer) -> Tuple[BinaryIO, bool]:
     """
     Open a binary file or no-op if file-like.
 
@@ -1904,28 +1870,33 @@ def _open_file_binary_write(fname):
         True if the file was created, otherwise False
     """
     if hasattr(fname, "write"):
-        # if 'b' not in fname.mode:
-        return fname, False
-    return open(fname, "wb"), True
+        # See https://github.com/python/mypy/issues/1424 for hasattr challenges
+        return fname, False  # type: ignore
+    elif isinstance(fname, (str, Path)):
+        return open(fname, "wb"), True
+    else:
+        raise TypeError("fname must be a binary file, buffer or path-like.")
 
 
-def _set_endianness(endianness):
+def _set_endianness(endianness: str) -> str:
     if endianness.lower() in ["<", "little"]:
         return "<"
     elif endianness.lower() in [">", "big"]:
         return ">"
     else:  # pragma : no cover
-        raise ValueError("Endianness {endian} not understood".format(endian=endianness))
+        raise ValueError(f"Endianness {endianness} not understood")
 
 
-def _pad_bytes(name, length):
+def _pad_bytes(name: AnyStr, length: int) -> AnyStr:
     """
     Take a char string and pads it with null bytes until it's length chars.
     """
+    if isinstance(name, bytes):
+        return name + b"\x00" * (length - len(name))
     return name + "\x00" * (length - len(name))
 
 
-def _convert_datetime_to_stata_type(fmt):
+def _convert_datetime_to_stata_type(fmt: str) -> np.dtype:
     """
     Convert from one of the stata date formats to a type in TYPE_MAP.
     """
@@ -1947,10 +1918,10 @@ def _convert_datetime_to_stata_type(fmt):
     ]:
         return np.float64  # Stata expects doubles for SIFs
     else:
-        raise NotImplementedError("Format {fmt} not implemented".format(fmt=fmt))
+        raise NotImplementedError(f"Format {fmt} not implemented")
 
 
-def _maybe_convert_to_int_keys(convert_dates, varlist):
+def _maybe_convert_to_int_keys(convert_dates: Dict, varlist: List[Label]) -> Dict:
     new_dict = {}
     for key in convert_dates:
         if not convert_dates[key].startswith("%"):  # make sure proper fmts
@@ -1964,7 +1935,7 @@ def _maybe_convert_to_int_keys(convert_dates, varlist):
     return new_dict
 
 
-def _dtype_to_stata_type(dtype, column):
+def _dtype_to_stata_type(dtype: np.dtype, column: Series) -> int:
     """
     Convert dtype types to stata types. Returns the byte of the given ordinal.
     See TYPE_MAP and comments for an explanation. This is also explained in
@@ -1997,12 +1968,12 @@ def _dtype_to_stata_type(dtype, column):
     elif dtype == np.int8:
         return 251
     else:  # pragma : no cover
-        raise NotImplementedError(
-            "Data type {dtype} not supported.".format(dtype=dtype)
-        )
+        raise NotImplementedError(f"Data type {dtype} not supported.")
 
 
-def _dtype_to_default_stata_fmt(dtype, column, dta_version=114, force_strl=False):
+def _dtype_to_default_stata_fmt(
+    dtype, column: Series, dta_version: int = 114, force_strl: bool = False
+) -> str:
     """
     Map numpy dtype to stata's default format for this type. Not terribly
     important since users can change this in Stata. Semantics are
@@ -2026,24 +1997,12 @@ def _dtype_to_default_stata_fmt(dtype, column, dta_version=114, force_strl=False
         if force_strl:
             return "%9s"
     if dtype.type == np.object_:
-        inferred_dtype = infer_dtype(column, skipna=True)
-        if not (inferred_dtype in ("string", "unicode") or len(column) == 0):
-            raise ValueError(
-                "Column `{col}` cannot be exported.\n\nOnly "
-                "string-like object arrays containing all "
-                "strings or a mix of strings and None can be "
-                "exported. Object arrays containing only null "
-                "values are prohibited. Other object types"
-                "cannot be exported and must first be converted "
-                "to one of the supported "
-                "types.".format(col=column.name)
-            )
         itemsize = max_len_string_array(ensure_object(column.values))
         if itemsize > max_str_len:
             if dta_version >= 117:
                 return "%9s"
             else:
-                raise ValueError(excessive_string_length_error % column.name)
+                raise ValueError(excessive_string_length_error.format(column.name))
         return "%" + str(max(itemsize, 1)) + "s"
     elif dtype == np.float64:
         return "%10.0g"
@@ -2054,9 +2013,7 @@ def _dtype_to_default_stata_fmt(dtype, column, dta_version=114, force_strl=False
     elif dtype == np.int8 or dtype == np.int16:
         return "%8.0g"
     else:  # pragma : no cover
-        raise NotImplementedError(
-            "Data type {dtype} not supported.".format(dtype=dtype)
-        )
+        raise NotImplementedError(f"Data type {dtype} not supported.")
 
 
 class StataWriter(StataParser):
@@ -2084,8 +2041,6 @@ class StataWriter(StataParser):
         timezone information
     write_index : bool
         Write the index to Stata dataset.
-    encoding : str
-        Default is latin-1. Only latin-1 and ascii are supported.
     byteorder : str
         Can be ">", "<", "little", or "big". default is `sys.byteorder`
     time_stamp : datetime
@@ -2127,24 +2082,22 @@ class StataWriter(StataParser):
     """
 
     _max_string_length = 244
+    _encoding = "latin-1"
 
-    @deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
     def __init__(
         self,
-        fname,
-        data,
-        convert_dates=None,
-        write_index=True,
-        encoding="latin-1",
-        byteorder=None,
-        time_stamp=None,
-        data_label=None,
-        variable_labels=None,
+        fname: FilePathOrBuffer,
+        data: DataFrame,
+        convert_dates: Optional[Dict[Label, str]] = None,
+        write_index: bool = True,
+        byteorder: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+        data_label: Optional[str] = None,
+        variable_labels: Optional[Dict[Label, str]] = None,
     ):
         super().__init__()
         self._convert_dates = {} if convert_dates is None else convert_dates
         self._write_index = write_index
-        self._encoding = "latin-1"
         self._time_stamp = time_stamp
         self._data_label = data_label
         self._variable_labels = variable_labels
@@ -2155,23 +2108,33 @@ def __init__(
         if byteorder is None:
             byteorder = sys.byteorder
         self._byteorder = _set_endianness(byteorder)
-        self._fname = _stringify_path(fname)
+        self._fname = stringify_path(fname)
         self.type_converters = {253: np.int32, 252: np.int16, 251: np.int8}
-        self._converted_names = {}
+        self._converted_names: Dict[Label, str] = {}
+        self._file: Optional[BinaryIO] = None
 
-    def _write(self, to_write):
+    def _write(self, to_write: str) -> None:
         """
         Helper to call encode before writing to file for Python 3 compat.
         """
-        self._file.write(to_write.encode(self._encoding or self._default_encoding))
+        assert self._file is not None
+        self._file.write(to_write.encode(self._encoding))
 
-    def _prepare_categoricals(self, data):
+    def _write_bytes(self, value: bytes) -> None:
+        """
+        Helper to assert file is open before writing.
+        """
+        assert self._file is not None
+        self._file.write(value)
+
+    def _prepare_categoricals(self, data: DataFrame) -> DataFrame:
         """Check for categorical columns, retain categorical information for
-        Stata file and convert categorical data to int"""
+        Stata file and convert categorical data to int
+        """
 
         is_cat = [is_categorical_dtype(data[col]) for col in data]
         self._is_col_cat = is_cat
-        self._value_labels = []
+        self._value_labels: List[StataValueLabel] = []
         if not any(is_cat):
             return data
 
@@ -2179,7 +2142,8 @@ def _prepare_categoricals(self, data):
         data_formatted = []
         for col, col_is_cat in zip(data, is_cat):
             if col_is_cat:
-                self._value_labels.append(StataValueLabel(data[col]))
+                svl = StataValueLabel(data[col], encoding=self._encoding)
+                self._value_labels.append(svl)
                 dtype = data[col].cat.codes.dtype
                 if dtype == np.int64:
                     raise ValueError(
@@ -2203,12 +2167,13 @@ def _prepare_categoricals(self, data):
                 data_formatted.append((col, values))
             else:
                 data_formatted.append((col, data[col]))
-        return DataFrame.from_dict(OrderedDict(data_formatted))
+        return DataFrame.from_dict(dict(data_formatted))
 
-    def _replace_nans(self, data):
+    def _replace_nans(self, data: DataFrame) -> DataFrame:
         # return data
         """Checks floating point data columns for nans, and replaces these with
-        the generic Stata for missing value (.)"""
+        the generic Stata for missing value (.)
+        """
         for c in data:
             dtype = data[c].dtype
             if dtype in (np.float32, np.float64):
@@ -2220,11 +2185,41 @@ def _replace_nans(self, data):
 
         return data
 
-    def _update_strl_names(self):
+    def _update_strl_names(self) -> None:
         """No-op, forward compatibility"""
         pass
 
-    def _check_column_names(self, data):
+    def _validate_variable_name(self, name: str) -> str:
+        """
+        Validate variable names for Stata export.
+
+        Parameters
+        ----------
+        name : str
+            Variable name
+
+        Returns
+        -------
+        str
+            The validated name with invalid characters replaced with
+            underscores.
+
+        Notes
+        -----
+        Stata 114 and 117 support ascii characters in a-z, A-Z, 0-9
+        and _.
+        """
+        for c in name:
+            if (
+                (c < "A" or c > "Z")
+                and (c < "a" or c > "z")
+                and (c < "0" or c > "9")
+                and c != "_"
+            ):
+                name = name.replace(c, "_")
+        return name
+
+    def _check_column_names(self, data: DataFrame) -> DataFrame:
         """
         Checks column names to ensure that they are valid Stata column names.
         This includes checks for:
@@ -2237,8 +2232,8 @@ def _check_column_names(self, data):
         dates are exported, the variable name is propagated to the date
         conversion dictionary
         """
-        converted_names = {}
-        columns = list(data.columns)
+        converted_names: Dict[Label, str] = {}
+        columns: List[Label] = list(data.columns)
         original_columns = columns[:]
 
         duplicate_var_id = 0
@@ -2247,21 +2242,14 @@ def _check_column_names(self, data):
             if not isinstance(name, str):
                 name = str(name)
 
-            for c in name:
-                if (
-                    (c < "A" or c > "Z")
-                    and (c < "a" or c > "z")
-                    and (c < "0" or c > "9")
-                    and c != "_"
-                ):
-                    name = name.replace(c, "_")
+            name = self._validate_variable_name(name)
 
             # Variable name must not be a reserved word
             if name in self.RESERVED_WORDS:
                 name = "_" + name
 
             # Variable name may not start with a number
-            if name[0] >= "0" and name[0] <= "9":
+            if "0" <= name[0] <= "9":
                 name = "_" + name
 
             name = name[: min(len(name), 32)]
@@ -2277,7 +2265,7 @@ def _check_column_names(self, data):
 
             columns[j] = name
 
-        data.columns = columns
+        data.columns = Index(columns)
 
         # Check date conversion, and fix key if needed
         if self._convert_dates:
@@ -2289,12 +2277,7 @@ def _check_column_names(self, data):
         if converted_names:
             conversion_warning = []
             for orig_name, name in converted_names.items():
-                # need to possibly encode the orig name if its unicode
-                try:
-                    orig_name = orig_name.encode("utf-8")
-                except (UnicodeDecodeError, AttributeError):
-                    pass
-                msg = "{0}   ->   {1}".format(orig_name, name)
+                msg = f"{orig_name}   ->   {name}"
                 conversion_warning.append(msg)
 
             ws = invalid_name_doc.format("\n    ".join(conversion_warning))
@@ -2305,21 +2288,23 @@ def _check_column_names(self, data):
 
         return data
 
-    def _set_formats_and_types(self, data, dtypes):
-        self.typlist = []
-        self.fmtlist = []
+    def _set_formats_and_types(self, dtypes: Series) -> None:
+        self.fmtlist: List[str] = []
+        self.typlist: List[int] = []
         for col, dtype in dtypes.items():
-            self.fmtlist.append(_dtype_to_default_stata_fmt(dtype, data[col]))
-            self.typlist.append(_dtype_to_stata_type(dtype, data[col]))
+            self.fmtlist.append(_dtype_to_default_stata_fmt(dtype, self.data[col]))
+            self.typlist.append(_dtype_to_stata_type(dtype, self.data[col]))
 
-    def _prepare_pandas(self, data):
+    def _prepare_pandas(self, data: DataFrame) -> None:
         # NOTE: we might need a different API / class for pandas objects so
         # we can set different semantics - handle this with a PR to pandas.io
 
         data = data.copy()
 
         if self._write_index:
-            data = data.reset_index()
+            temp = data.reset_index()
+            if isinstance(temp, DataFrame):
+                data = temp
 
         # Ensure column names are strings
         data = self._check_column_names(data)
@@ -2354,17 +2339,58 @@ def _prepare_pandas(self, data):
             new_type = _convert_datetime_to_stata_type(self._convert_dates[key])
             dtypes[key] = np.dtype(new_type)
 
-        self._set_formats_and_types(data, dtypes)
+        # Verify object arrays are strings and encode to bytes
+        self._encode_strings()
+
+        self._set_formats_and_types(dtypes)
 
         # set the given format for the datetime cols
         if self._convert_dates is not None:
             for key in self._convert_dates:
-                self.fmtlist[key] = self._convert_dates[key]
+                if isinstance(key, int):
+                    self.fmtlist[key] = self._convert_dates[key]
 
-    def write_file(self):
+    def _encode_strings(self) -> None:
+        """
+        Encode strings in dta-specific encoding
+
+        Do not encode columns marked for date conversion or for strL
+        conversion. The strL converter independently handles conversion and
+        also accepts empty string arrays.
+        """
+        convert_dates = self._convert_dates
+        # _convert_strl is not available in dta 114
+        convert_strl = getattr(self, "_convert_strl", [])
+        for i, col in enumerate(self.data):
+            # Skip columns marked for date conversion or strl conversion
+            if i in convert_dates or col in convert_strl:
+                continue
+            column = self.data[col]
+            dtype = column.dtype
+            if dtype.type == np.object_:
+                inferred_dtype = infer_dtype(column, skipna=True)
+                if not ((inferred_dtype == "string") or len(column) == 0):
+                    col = column.name
+                    raise ValueError(
+                        f"""\
+Column `{col}` cannot be exported.\n\nOnly string-like object arrays
+containing all strings or a mix of strings and None can be exported.
+Object arrays containing only null values are prohibited. Other object
+types cannot be exported and must first be converted to one of the
+supported types."""
+                    )
+                encoded = self.data[col].str.encode(self._encoding)
+                # If larger than _max_string_length do nothing
+                if (
+                    max_len_string_array(ensure_object(encoded.values))
+                    <= self._max_string_length
+                ):
+                    self.data[col] = encoded
+
+    def write_file(self) -> None:
         self._file, self._own_file = _open_file_binary_write(self._fname)
         try:
-            self._write_header(time_stamp=self._time_stamp, data_label=self._data_label)
+            self._write_header(data_label=self._data_label, time_stamp=self._time_stamp)
             self._write_map()
             self._write_variable_types()
             self._write_varnames()
@@ -2374,29 +2400,29 @@ def write_file(self):
             self._write_variable_labels()
             self._write_expansion_fields()
             self._write_characteristics()
-            self._prepare_data()
-            self._write_data()
+            records = self._prepare_data()
+            self._write_data(records)
             self._write_strls()
             self._write_value_labels()
             self._write_file_close_tag()
             self._write_map()
         except Exception as exc:
             self._close()
-            try:
-                if self._own_file:
-                    os.unlink(self._fname)
-            except Exception:
-                warnings.warn(
-                    "This save was not successful but {0} could not "
-                    "be deleted.  This file is not "
-                    "valid.".format(self._fname),
-                    ResourceWarning,
-                )
+            if self._own_file:
+                try:
+                    if isinstance(self._fname, (str, Path)):
+                        os.unlink(self._fname)
+                except OSError:
+                    warnings.warn(
+                        f"This save was not successful but {self._fname} could not "
+                        "be deleted.  This file is not valid.",
+                        ResourceWarning,
+                    )
             raise exc
         else:
             self._close()
 
-    def _close(self):
+    def _close(self) -> None:
         """
         Close the file if it was created by the writer.
 
@@ -2406,6 +2432,7 @@ def _close(self):
         (if supported)
         """
         # Some file-like objects might not support flush
+        assert self._file is not None
         try:
             self._file.flush()
         except AttributeError:
@@ -2413,34 +2440,38 @@ def _close(self):
         if self._own_file:
             self._file.close()
 
-    def _write_map(self):
+    def _write_map(self) -> None:
         """No-op, future compatibility"""
         pass
 
-    def _write_file_close_tag(self):
+    def _write_file_close_tag(self) -> None:
         """No-op, future compatibility"""
         pass
 
-    def _write_characteristics(self):
+    def _write_characteristics(self) -> None:
         """No-op, future compatibility"""
         pass
 
-    def _write_strls(self):
+    def _write_strls(self) -> None:
         """No-op, future compatibility"""
         pass
 
-    def _write_expansion_fields(self):
+    def _write_expansion_fields(self) -> None:
         """Write 5 zeros for expansion fields"""
         self._write(_pad_bytes("", 5))
 
-    def _write_value_labels(self):
+    def _write_value_labels(self) -> None:
         for vl in self._value_labels:
-            self._file.write(vl.generate_value_label(self._byteorder, self._encoding))
+            self._write_bytes(vl.generate_value_label(self._byteorder))
 
-    def _write_header(self, data_label=None, time_stamp=None):
+    def _write_header(
+        self,
+        data_label: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+    ) -> None:
         byteorder = self._byteorder
         # ds_format - just use 114
-        self._file.write(struct.pack("b", 114))
+        self._write_bytes(struct.pack("b", 114))
         # byteorder
         self._write(byteorder == ">" and "\x01" or "\x02")
         # filetype
@@ -2448,14 +2479,16 @@ def _write_header(self, data_label=None, time_stamp=None):
         # unused
         self._write("\x00")
         # number of vars, 2 bytes
-        self._file.write(struct.pack(byteorder + "h", self.nvar)[:2])
+        self._write_bytes(struct.pack(byteorder + "h", self.nvar)[:2])
         # number of obs, 4 bytes
-        self._file.write(struct.pack(byteorder + "i", self.nobs)[:4])
+        self._write_bytes(struct.pack(byteorder + "i", self.nobs)[:4])
         # data label 81 bytes, char, null terminated
         if data_label is None:
-            self._file.write(self._null_terminate(_pad_bytes("", 80)))
+            self._write_bytes(self._null_terminate_bytes(_pad_bytes("", 80)))
         else:
-            self._file.write(self._null_terminate(_pad_bytes(data_label[:80], 80)))
+            self._write_bytes(
+                self._null_terminate_bytes(_pad_bytes(data_label[:80], 80))
+            )
         # time stamp, 18 bytes, char, null terminated
         # format dd Mon yyyy hh:mm
         if time_stamp is None:
@@ -2484,43 +2517,43 @@ def _write_header(self, data_label=None, time_stamp=None):
             + month_lookup[time_stamp.month]
             + time_stamp.strftime(" %Y %H:%M")
         )
-        self._file.write(self._null_terminate(ts))
+        self._write_bytes(self._null_terminate_bytes(ts))
 
-    def _write_variable_types(self):
+    def _write_variable_types(self) -> None:
         for typ in self.typlist:
-            self._file.write(struct.pack("B", typ))
+            self._write_bytes(struct.pack("B", typ))
 
-    def _write_varnames(self):
+    def _write_varnames(self) -> None:
         # varlist names are checked by _check_column_names
         # varlist, requires null terminated
         for name in self.varlist:
-            name = self._null_terminate(name, True)
+            name = self._null_terminate_str(name)
             name = _pad_bytes(name[:32], 33)
             self._write(name)
 
-    def _write_sortlist(self):
+    def _write_sortlist(self) -> None:
         # srtlist, 2*(nvar+1), int array, encoded by byteorder
         srtlist = _pad_bytes("", 2 * (self.nvar + 1))
         self._write(srtlist)
 
-    def _write_formats(self):
+    def _write_formats(self) -> None:
         # fmtlist, 49*nvar, char array
         for fmt in self.fmtlist:
             self._write(_pad_bytes(fmt, 49))
 
-    def _write_value_label_names(self):
+    def _write_value_label_names(self) -> None:
         # lbllist, 33*nvar, char array
         for i in range(self.nvar):
             # Use variable name when categorical
             if self._is_col_cat[i]:
                 name = self.varlist[i]
-                name = self._null_terminate(name, True)
+                name = self._null_terminate_str(name)
                 name = _pad_bytes(name[:32], 33)
                 self._write(name)
             else:  # Default is empty label
                 self._write(_pad_bytes("", 33))
 
-    def _write_variable_labels(self):
+    def _write_variable_labels(self) -> None:
         # Missing labels are 80 blank characters plus null termination
         blank = _pad_bytes("", 81)
 
@@ -2537,19 +2570,18 @@ def _write_variable_labels(self):
                 is_latin1 = all(ord(c) < 256 for c in label)
                 if not is_latin1:
                     raise ValueError(
-                        "Variable labels must contain only "
-                        "characters that can be encoded in "
-                        "Latin-1"
+                        "Variable labels must contain only characters that "
+                        "can be encoded in Latin-1"
                     )
                 self._write(_pad_bytes(label, 81))
             else:
                 self._write(blank)
 
-    def _convert_strls(self, data):
+    def _convert_strls(self, data: DataFrame) -> DataFrame:
         """No-op, future compatibility"""
         return data
 
-    def _prepare_data(self):
+    def _prepare_data(self) -> np.recarray:
         data = self.data
         typlist = self.typlist
         convert_dates = self._convert_dates
@@ -2570,32 +2602,30 @@ def _prepare_data(self):
             typ = typlist[i]
             if typ <= self._max_string_length:
                 data[col] = data[col].fillna("").apply(_pad_bytes, args=(typ,))
-                stype = "S{type}".format(type=typ)
+                stype = f"S{typ}"
                 dtypes[col] = stype
-                data[col] = data[col].str.encode(self._encoding).astype(stype)
+                data[col] = data[col].astype(stype)
             else:
                 dtype = data[col].dtype
                 if not native_byteorder:
                     dtype = dtype.newbyteorder(self._byteorder)
                 dtypes[col] = dtype
 
-        self.data = data.to_records(index=False, column_dtypes=dtypes)
-
-    def _write_data(self):
-        data = self.data
-        self._file.write(data.tobytes())
-
-    def _null_terminate(self, s, as_string=False):
-        null_byte = "\x00"
-        s += null_byte
+        return data.to_records(index=False, column_dtypes=dtypes)
 
-        if not as_string:
-            s = s.encode(self._encoding)
+    def _write_data(self, records: np.recarray) -> None:
+        self._write_bytes(records.tobytes())
 
+    @staticmethod
+    def _null_terminate_str(s: str) -> str:
+        s += "\x00"
         return s
 
+    def _null_terminate_bytes(self, s: str) -> bytes:
+        return self._null_terminate_str(s).encode(self._encoding)
+
 
-def _dtype_to_stata_type_117(dtype, column, force_strl):
+def _dtype_to_stata_type_117(dtype: np.dtype, column: Series, force_strl: bool) -> int:
     """
     Converts dtype types to stata types. Returns the byte of the given ordinal.
     See TYPE_MAP and comments for an explanation. This is also explained in
@@ -2634,10 +2664,10 @@ def _dtype_to_stata_type_117(dtype, column, force_strl):
     elif dtype == np.int8:
         return 65530
     else:  # pragma : no cover
-        raise NotImplementedError("Data type %s not supported." % dtype)
+        raise NotImplementedError(f"Data type {dtype} not supported.")
 
 
-def _pad_bytes_new(name, length):
+def _pad_bytes_new(name: Union[str, bytes], length: int) -> bytes:
     """
     Takes a bytes instance and pads it with null bytes until it's length chars.
     """
@@ -2657,7 +2687,7 @@ class StataStrLWriter:
     ----------
     df : DataFrame
         DataFrame to convert
-    columns : list
+    columns : Sequence[str]
         List of columns names to convert to StrL
     version : int, optional
         dta version.  Currently supports 117, 118 and 119
@@ -2675,14 +2705,20 @@ class StataStrLWriter:
     characters.
     """
 
-    def __init__(self, df, columns, version=117, byteorder=None):
+    def __init__(
+        self,
+        df: DataFrame,
+        columns: Sequence[str],
+        version: int = 117,
+        byteorder: Optional[str] = None,
+    ):
         if version not in (117, 118, 119):
             raise ValueError("Only dta versions 117, 118 and 119 supported")
         self._dta_ver = version
 
         self.df = df
         self.columns = columns
-        self._gso_table = OrderedDict((("", (0, 0)),))
+        self._gso_table = {"": (0, 0)}
         if byteorder is None:
             byteorder = sys.byteorder
         self._byteorder = _set_endianness(byteorder)
@@ -2702,17 +2738,17 @@ def __init__(self, df, columns, version=117, byteorder=None):
         self._gso_o_type = gso_o_type
         self._gso_v_type = gso_v_type
 
-    def _convert_key(self, key):
+    def _convert_key(self, key: Tuple[int, int]) -> int:
         v, o = key
         return v + self._o_offet * o
 
-    def generate_table(self):
+    def generate_table(self) -> Tuple[Dict[str, Tuple[int, int]], DataFrame]:
         """
-        Generates the GSO lookup table for the DataFRame
+        Generates the GSO lookup table for the DataFrame
 
         Returns
         -------
-        gso_table : OrderedDict
+        gso_table : dict
             Ordered dictionary using the string found as keys
             and their lookup position (v,o) as values
         gso_df : DataFrame
@@ -2724,7 +2760,7 @@ def generate_table(self):
         Modifies the DataFrame in-place.
 
         The DataFrame returned encodes the (v,o) values as uint64s. The
-        encoding depends on teh dta version, and can be expressed as
+        encoding depends on the dta version, and can be expressed as
 
         enc = v + o * 2 ** (o_size * 8)
 
@@ -2758,19 +2794,13 @@ def generate_table(self):
 
         return gso_table, gso_df
 
-    def _encode(self, s):
-        """
-        Python 3 compatibility shim
-        """
-        return s.encode(self._encoding)
-
-    def generate_blob(self, gso_table):
+    def generate_blob(self, gso_table: Dict[str, Tuple[int, int]]) -> bytes:
         """
         Generates the binary blob of GSOs that is written to the dta file.
 
         Parameters
         ----------
-        gso_table : OrderedDict
+        gso_table : dict
             Ordered dictionary (str, vo)
 
         Returns
@@ -2853,8 +2883,6 @@ class StataWriter117(StataWriter):
         timezone information
     write_index : bool
         Write the index to Stata dataset.
-    encoding : str
-        Default is latin-1. Only latin-1 and ascii are supported.
     byteorder : str
         Can be ">", "<", "little", or "big". default is `sys.byteorder`
     time_stamp : datetime
@@ -2905,23 +2933,24 @@ class StataWriter117(StataWriter):
     """
 
     _max_string_length = 2045
+    _dta_version = 117
 
-    @deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
     def __init__(
         self,
-        fname,
-        data,
-        convert_dates=None,
-        write_index=True,
-        encoding="latin-1",
-        byteorder=None,
-        time_stamp=None,
-        data_label=None,
-        variable_labels=None,
-        convert_strl=None,
+        fname: FilePathOrBuffer,
+        data: DataFrame,
+        convert_dates: Optional[Dict[Label, str]] = None,
+        write_index: bool = True,
+        byteorder: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+        data_label: Optional[str] = None,
+        variable_labels: Optional[Dict[Label, str]] = None,
+        convert_strl: Optional[Sequence[Label]] = None,
     ):
-        # Shallow copy since convert_strl might be modified later
-        self._convert_strl = [] if convert_strl is None else convert_strl[:]
+        # Copy to new list since convert_strl might be modified later
+        self._convert_strl: List[Label] = []
+        if convert_strl is not None:
+            self._convert_strl.extend(convert_strl)
 
         super().__init__(
             fname,
@@ -2933,39 +2962,47 @@ def __init__(
             data_label=data_label,
             variable_labels=variable_labels,
         )
-        self._map = None
-        self._strl_blob = None
+        self._map: Dict[str, int] = {}
+        self._strl_blob = b""
 
     @staticmethod
-    def _tag(val, tag):
+    def _tag(val: Union[str, bytes], tag: str) -> bytes:
         """Surround val with <tag></tag>"""
         if isinstance(val, str):
             val = bytes(val, "utf-8")
         return bytes("<" + tag + ">", "utf-8") + val + bytes("</" + tag + ">", "utf-8")
 
-    def _update_map(self, tag):
+    def _update_map(self, tag: str) -> None:
         """Update map location for tag with file position"""
+        assert self._file is not None
         self._map[tag] = self._file.tell()
 
-    def _write_header(self, data_label=None, time_stamp=None):
+    def _write_header(
+        self,
+        data_label: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+    ) -> None:
         """Write the file header"""
         byteorder = self._byteorder
-        self._file.write(bytes("<stata_dta>", "utf-8"))
+        self._write_bytes(bytes("<stata_dta>", "utf-8"))
         bio = BytesIO()
         # ds_format - 117
-        bio.write(self._tag(bytes("117", "utf-8"), "release"))
+        bio.write(self._tag(bytes(str(self._dta_version), "utf-8"), "release"))
         # byteorder
         bio.write(self._tag(byteorder == ">" and "MSF" or "LSF", "byteorder"))
-        # number of vars, 2 bytes
-        assert self.nvar < 2 ** 16
-        bio.write(self._tag(struct.pack(byteorder + "H", self.nvar), "K"))
-        # number of obs, 4 bytes
-        bio.write(self._tag(struct.pack(byteorder + "I", self.nobs), "N"))
+        # number of vars, 2 bytes in 117 and 118, 4 byte in 119
+        nvar_type = "H" if self._dta_version <= 118 else "I"
+        bio.write(self._tag(struct.pack(byteorder + nvar_type, self.nvar), "K"))
+        # 117 uses 4 bytes, 118 uses 8
+        nobs_size = "I" if self._dta_version == 117 else "Q"
+        bio.write(self._tag(struct.pack(byteorder + nobs_size, self.nobs), "N"))
         # data label 81 bytes, char, null terminated
         label = data_label[:80] if data_label is not None else ""
-        label_len = struct.pack(byteorder + "B", len(label))
-        label = label_len + bytes(label, "utf-8")
-        bio.write(self._tag(label, "label"))
+        encoded_label = label.encode(self._encoding)
+        label_size = "B" if self._dta_version == 117 else "H"
+        label_len = struct.pack(byteorder + label_size, len(encoded_label))
+        encoded_label = label_len + encoded_label
+        bio.write(self._tag(encoded_label, "label"))
         # time stamp, 18 bytes, char, null terminated
         # format dd Mon yyyy hh:mm
         if time_stamp is None:
@@ -2994,17 +3031,19 @@ def _write_header(self, data_label=None, time_stamp=None):
             + time_stamp.strftime(" %Y %H:%M")
         )
         # '\x11' added due to inspection of Stata file
-        ts = b"\x11" + bytes(ts, "utf8")
-        bio.write(self._tag(ts, "timestamp"))
+        stata_ts = b"\x11" + bytes(ts, "utf-8")
+        bio.write(self._tag(stata_ts, "timestamp"))
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "header"))
+        self._write_bytes(self._tag(bio.read(), "header"))
 
-    def _write_map(self):
+    def _write_map(self) -> None:
         """Called twice during file write. The first populates the values in
         the map with 0s.  The second call writes the final map locations when
-        all blocks have been written."""
-        if self._map is None:
-            self._map = OrderedDict(
+        all blocks have been written.
+        """
+        assert self._file is not None
+        if not self._map:
+            self._map = dict(
                 (
                     ("stata_data", 0),
                     ("map", self._file.tell()),
@@ -3028,63 +3067,71 @@ def _write_map(self):
         for val in self._map.values():
             bio.write(struct.pack(self._byteorder + "Q", val))
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "map"))
+        self._write_bytes(self._tag(bio.read(), "map"))
 
-    def _write_variable_types(self):
+    def _write_variable_types(self) -> None:
         self._update_map("variable_types")
         bio = BytesIO()
         for typ in self.typlist:
             bio.write(struct.pack(self._byteorder + "H", typ))
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "variable_types"))
+        self._write_bytes(self._tag(bio.read(), "variable_types"))
 
-    def _write_varnames(self):
+    def _write_varnames(self) -> None:
         self._update_map("varnames")
         bio = BytesIO()
+        # 118 scales by 4 to accommodate utf-8 data worst case encoding
+        vn_len = 32 if self._dta_version == 117 else 128
         for name in self.varlist:
-            name = self._null_terminate(name, True)
-            name = _pad_bytes_new(name[:32], 33)
+            name = self._null_terminate_str(name)
+            name = _pad_bytes_new(name[:32].encode(self._encoding), vn_len + 1)
             bio.write(name)
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "varnames"))
+        self._write_bytes(self._tag(bio.read(), "varnames"))
 
-    def _write_sortlist(self):
+    def _write_sortlist(self) -> None:
         self._update_map("sortlist")
-        self._file.write(self._tag(b"\x00\00" * (self.nvar + 1), "sortlist"))
+        sort_size = 2 if self._dta_version < 119 else 4
+        self._write_bytes(self._tag(b"\x00" * sort_size * (self.nvar + 1), "sortlist"))
 
-    def _write_formats(self):
+    def _write_formats(self) -> None:
         self._update_map("formats")
         bio = BytesIO()
+        fmt_len = 49 if self._dta_version == 117 else 57
         for fmt in self.fmtlist:
-            bio.write(_pad_bytes_new(fmt, 49))
+            bio.write(_pad_bytes_new(fmt.encode(self._encoding), fmt_len))
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "formats"))
+        self._write_bytes(self._tag(bio.read(), "formats"))
 
-    def _write_value_label_names(self):
+    def _write_value_label_names(self) -> None:
         self._update_map("value_label_names")
         bio = BytesIO()
+        # 118 scales by 4 to accommodate utf-8 data worst case encoding
+        vl_len = 32 if self._dta_version == 117 else 128
         for i in range(self.nvar):
             # Use variable name when categorical
             name = ""  # default name
             if self._is_col_cat[i]:
                 name = self.varlist[i]
-            name = self._null_terminate(name, True)
-            name = _pad_bytes_new(name[:32], 33)
-            bio.write(name)
+            name = self._null_terminate_str(name)
+            encoded_name = _pad_bytes_new(name[:32].encode(self._encoding), vl_len + 1)
+            bio.write(encoded_name)
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "value_label_names"))
+        self._write_bytes(self._tag(bio.read(), "value_label_names"))
 
-    def _write_variable_labels(self):
+    def _write_variable_labels(self) -> None:
         # Missing labels are 80 blank characters plus null termination
         self._update_map("variable_labels")
         bio = BytesIO()
-        blank = _pad_bytes_new("", 81)
+        # 118 scales by 4 to accommodate utf-8 data worst case encoding
+        vl_len = 80 if self._dta_version == 117 else 320
+        blank = _pad_bytes_new("", vl_len + 1)
 
         if self._variable_labels is None:
             for _ in range(self.nvar):
                 bio.write(blank)
             bio.seek(0)
-            self._file.write(self._tag(bio.read(), "variable_labels"))
+            self._write_bytes(self._tag(bio.read(), "variable_labels"))
             return
 
         for col in self.data:
@@ -3092,68 +3139,67 @@ def _write_variable_labels(self):
                 label = self._variable_labels[col]
                 if len(label) > 80:
                     raise ValueError("Variable labels must be 80 characters or fewer")
-                is_latin1 = all(ord(c) < 256 for c in label)
-                if not is_latin1:
+                try:
+                    encoded = label.encode(self._encoding)
+                except UnicodeEncodeError:
                     raise ValueError(
-                        "Variable labels must contain only "
-                        "characters that can be encoded in "
-                        "Latin-1"
+                        "Variable labels must contain only characters that "
+                        f"can be encoded in {self._encoding}"
                     )
-                bio.write(_pad_bytes_new(label, 81))
+
+                bio.write(_pad_bytes_new(encoded, vl_len + 1))
             else:
                 bio.write(blank)
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "variable_labels"))
+        self._write_bytes(self._tag(bio.read(), "variable_labels"))
 
-    def _write_characteristics(self):
+    def _write_characteristics(self) -> None:
         self._update_map("characteristics")
-        self._file.write(self._tag(b"", "characteristics"))
+        self._write_bytes(self._tag(b"", "characteristics"))
 
-    def _write_data(self):
+    def _write_data(self, records) -> None:
         self._update_map("data")
-        data = self.data
-        self._file.write(b"<data>")
-        self._file.write(data.tobytes())
-        self._file.write(b"</data>")
+        self._write_bytes(b"<data>")
+        self._write_bytes(records.tobytes())
+        self._write_bytes(b"</data>")
 
-    def _write_strls(self):
+    def _write_strls(self) -> None:
         self._update_map("strls")
-        strls = b""
-        if self._strl_blob is not None:
-            strls = self._strl_blob
-        self._file.write(self._tag(strls, "strls"))
+        self._write_bytes(self._tag(self._strl_blob, "strls"))
 
-    def _write_expansion_fields(self):
+    def _write_expansion_fields(self) -> None:
         """No-op in dta 117+"""
         pass
 
-    def _write_value_labels(self):
+    def _write_value_labels(self) -> None:
         self._update_map("value_labels")
         bio = BytesIO()
         for vl in self._value_labels:
-            lab = vl.generate_value_label(self._byteorder, self._encoding)
+            lab = vl.generate_value_label(self._byteorder)
             lab = self._tag(lab, "lbl")
             bio.write(lab)
         bio.seek(0)
-        self._file.write(self._tag(bio.read(), "value_labels"))
+        self._write_bytes(self._tag(bio.read(), "value_labels"))
 
-    def _write_file_close_tag(self):
+    def _write_file_close_tag(self) -> None:
         self._update_map("stata_data_close")
-        self._file.write(bytes("</stata_dta>", "utf-8"))
+        self._write_bytes(bytes("</stata_dta>", "utf-8"))
         self._update_map("end-of-file")
 
-    def _update_strl_names(self):
+    def _update_strl_names(self) -> None:
         """Update column names for conversion to strl if they might have been
-        changed to comply with Stata naming rules"""
+        changed to comply with Stata naming rules
+        """
         # Update convert_strl if names changed
         for orig, new in self._converted_names.items():
             if orig in self._convert_strl:
                 idx = self._convert_strl.index(orig)
                 self._convert_strl[idx] = new
 
-    def _convert_strls(self, data):
+    def _convert_strls(self, data: DataFrame) -> DataFrame:
         """Convert columns to StrLs if either very large or in the
-        convert_strl variable"""
+        convert_strl variable
+        """
         convert_cols = [
             col
             for i, col in enumerate(data)
@@ -3161,19 +3207,181 @@ def _convert_strls(self, data):
         ]
 
         if convert_cols:
-            ssw = StataStrLWriter(data, convert_cols)
+            ssw = StataStrLWriter(data, convert_cols, version=self._dta_version)
             tab, new_data = ssw.generate_table()
             data = new_data
             self._strl_blob = ssw.generate_blob(tab)
         return data
 
-    def _set_formats_and_types(self, data, dtypes):
+    def _set_formats_and_types(self, dtypes: Series) -> None:
         self.typlist = []
         self.fmtlist = []
         for col, dtype in dtypes.items():
             force_strl = col in self._convert_strl
             fmt = _dtype_to_default_stata_fmt(
-                dtype, data[col], dta_version=117, force_strl=force_strl
+                dtype,
+                self.data[col],
+                dta_version=self._dta_version,
+                force_strl=force_strl,
             )
             self.fmtlist.append(fmt)
-            self.typlist.append(_dtype_to_stata_type_117(dtype, data[col], force_strl))
+            self.typlist.append(
+                _dtype_to_stata_type_117(dtype, self.data[col], force_strl)
+            )
+
+
+class StataWriterUTF8(StataWriter117):
+    """
+    Stata binary dta file writing in Stata 15 (118) and 16 (119) formats
+
+    DTA 118 and 119 format files support unicode string data (both fixed
+    and strL) format. Unicode is also supported in value labels, variable
+    labels and the dataset label. Format 119 is automatically used if the
+    file contains more than 32,767 variables.
+
+    .. versionadded:: 1.0.0
+
+    Parameters
+    ----------
+    fname : path (string), buffer or path object
+        string, path object (pathlib.Path or py._path.local.LocalPath) or
+        object implementing a binary write() functions. If using a buffer
+        then the buffer will not be automatically closed after the file
+        is written.
+    data : DataFrame
+        Input to save
+    convert_dates : dict, default None
+        Dictionary mapping columns containing datetime types to stata internal
+        format to use when writing the dates. Options are 'tc', 'td', 'tm',
+        'tw', 'th', 'tq', 'ty'. Column can be either an integer or a name.
+        Datetime columns that do not have a conversion type specified will be
+        converted to 'tc'. Raises NotImplementedError if a datetime column has
+        timezone information
+    write_index : bool, default True
+        Write the index to Stata dataset.
+    byteorder : str, default None
+        Can be ">", "<", "little", or "big". default is `sys.byteorder`
+    time_stamp : datetime, default None
+        A datetime to use as file creation date.  Default is the current time
+    data_label : str, default None
+        A label for the data set.  Must be 80 characters or smaller.
+    variable_labels : dict, default None
+        Dictionary containing columns as keys and variable labels as values.
+        Each label must be 80 characters or smaller.
+    convert_strl : list, default None
+        List of columns names to convert to Stata StrL format.  Columns with
+        more than 2045 characters are automatically written as StrL.
+        Smaller columns can be converted by including the column name.  Using
+        StrLs can reduce output file size when strings are longer than 8
+        characters, and either frequently repeated or sparse.
+    version : int, default None
+        The dta version to use. By default, uses the size of data to determine
+        the version. 118 is used if data.shape[1] <= 32767, and 119 is used
+        for storing larger DataFrames.
+
+    Returns
+    -------
+    StataWriterUTF8
+        The instance has a write_file method, which will write the file to the
+        given `fname`.
+
+    Raises
+    ------
+    NotImplementedError
+        * If datetimes contain timezone information
+    ValueError
+        * Columns listed in convert_dates are neither datetime64[ns]
+          or datetime.datetime
+        * Column dtype is not representable in Stata
+        * Column listed in convert_dates is not in DataFrame
+        * Categorical label contains more than 32,000 characters
+
+    Examples
+    --------
+    Using Unicode data and column names
+
+    >>> from pandas.io.stata import StataWriterUTF8
+    >>> data = pd.DataFrame([[1.0, 1, 'ᴬ']], columns=['a', 'β', 'ĉ'])
+    >>> writer = StataWriterUTF8('./data_file.dta', data)
+    >>> writer.write_file()
+
+    Or with long strings stored in strl format
+
+    >>> data = pd.DataFrame([['ᴀ relatively long ŝtring'], [''], ['']],
+    ...                     columns=['strls'])
+    >>> writer = StataWriterUTF8('./data_file_with_long_strings.dta', data,
+    ...                          convert_strl=['strls'])
+    >>> writer.write_file()
+    """
+
+    _encoding = "utf-8"
+
+    def __init__(
+        self,
+        fname: FilePathOrBuffer,
+        data: DataFrame,
+        convert_dates: Optional[Dict[Label, str]] = None,
+        write_index: bool = True,
+        byteorder: Optional[str] = None,
+        time_stamp: Optional[datetime.datetime] = None,
+        data_label: Optional[str] = None,
+        variable_labels: Optional[Dict[Label, str]] = None,
+        convert_strl: Optional[Sequence[Label]] = None,
+        version: Optional[int] = None,
+    ):
+        if version is None:
+            version = 118 if data.shape[1] <= 32767 else 119
+        elif version not in (118, 119):
+            raise ValueError("version must be either 118 or 119.")
+        elif version == 118 and data.shape[1] > 32767:
+            raise ValueError(
+                "You must use version 119 for data sets containing more than"
+                "32,767 variables"
+            )
+
+        super().__init__(
+            fname,
+            data,
+            convert_dates=convert_dates,
+            write_index=write_index,
+            byteorder=byteorder,
+            time_stamp=time_stamp,
+            data_label=data_label,
+            variable_labels=variable_labels,
+            convert_strl=convert_strl,
+        )
+        # Override version set in StataWriter117 init
+        self._dta_version = version
+
+    def _validate_variable_name(self, name: str) -> str:
+        """
+        Validate variable names for Stata export.
+
+        Parameters
+        ----------
+        name : str
+            Variable name
+
+        Returns
+        -------
+        str
+            The validated name with invalid characters replaced with
+            underscores.
+
+        Notes
+        -----
+        Stata 118+ support most unicode characters. The only limitation is in
+        the ascii range where the characters supported are a-z, A-Z, 0-9 and _.
+        """
+        # High code points appear to be acceptable
+        for c in name:
+            if (
+                ord(c) < 128
+                and (c < "A" or c > "Z")
+                and (c < "a" or c > "z")
+                and (c < "0" or c > "9")
+                and c != "_"
+            ) or 128 <= ord(c) < 256:
+                name = name.replace(c, "_")
+
+        return name
diff --git a/pandas/plotting/__init__.py b/pandas/plotting/__init__.py
index ebe047c58b889..55c861e384d67 100644
--- a/pandas/plotting/__init__.py
+++ b/pandas/plotting/__init__.py
@@ -38,7 +38,6 @@
 - hist_series and hist_frame (for `Series.hist` and `DataFrame.hist`)
 - boxplot (`pandas.plotting.boxplot(df)` equivalent to `DataFrame.boxplot`)
 - boxplot_frame and boxplot_frame_groupby
-- tsplot (deprecated)
 - register and deregister (register converters for the tick formats)
 - Plots not called as `Series` and `DataFrame` methods:
   - table
diff --git a/pandas/plotting/_core.py b/pandas/plotting/_core.py
index 837b01974be93..1fe383706f74d 100644
--- a/pandas/plotting/_core.py
+++ b/pandas/plotting/_core.py
@@ -1,21 +1,14 @@
 import importlib
-import warnings
 
 from pandas._config import get_option
 
-from pandas.compat._optional import import_optional_dependency
-from pandas.util._decorators import Appender
+from pandas.util._decorators import Appender, Substitution
 
 from pandas.core.dtypes.common import is_integer, is_list_like
 from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
 
 from pandas.core.base import PandasObject
 
-# Trigger matplotlib import, which implicitly registers our
-# converts. Implicit registration is deprecated, and when enforced
-# we can lazily import matplotlib.
-import_optional_dependency("pandas.plotting._matplotlib", raise_on_missing=False)
-
 
 def hist_series(
     self,
@@ -28,7 +21,8 @@ def hist_series(
     yrot=None,
     figsize=None,
     bins=10,
-    **kwds
+    backend=None,
+    **kwargs,
 ):
     """
     Draw histogram of the input series using matplotlib.
@@ -36,28 +30,36 @@ def hist_series(
     Parameters
     ----------
     by : object, optional
-        If passed, then used to form histograms for separate groups
+        If passed, then used to form histograms for separate groups.
     ax : matplotlib axis object
-        If not passed, uses gca()
+        If not passed, uses gca().
     grid : bool, default True
-        Whether to show axis grid lines
+        Whether to show axis grid lines.
     xlabelsize : int, default None
-        If specified changes the x-axis label size
+        If specified changes the x-axis label size.
     xrot : float, default None
-        rotation of x axis labels
+        Rotation of x axis labels.
     ylabelsize : int, default None
-        If specified changes the y-axis label size
+        If specified changes the y-axis label size.
     yrot : float, default None
-        rotation of y axis labels
+        Rotation of y axis labels.
     figsize : tuple, default None
-        figure size in inches by default
+        Figure size in inches by default.
     bins : int or sequence, default 10
         Number of histogram bins to be used. If an integer is given, bins + 1
         bin edges are calculated and returned. If bins is a sequence, gives
         bin edges, including left edge of first bin and right edge of last
         bin. In this case, bins is returned unmodified.
-    `**kwds` : keywords
-        To be passed to the actual plotting function
+    backend : str, default None
+        Backend to use instead of the backend specified in the option
+        ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to
+        specify the ``plotting.backend`` for the whole session, set
+        ``pd.options.plotting.backend``.
+
+        .. versionadded:: 1.0.0
+
+    **kwargs
+        To be passed to the actual plotting function.
 
     Returns
     -------
@@ -68,7 +70,7 @@ def hist_series(
     --------
     matplotlib.axes.Axes.hist : Plot a histogram using matplotlib.
     """
-    plot_backend = _get_plot_backend()
+    plot_backend = _get_plot_backend(backend)
     return plot_backend.hist_series(
         self,
         by=by,
@@ -80,7 +82,7 @@ def hist_series(
         yrot=yrot,
         figsize=figsize,
         bins=bins,
-        **kwds
+        **kwargs,
     )
 
 
@@ -99,7 +101,8 @@ def hist_frame(
     figsize=None,
     layout=None,
     bins=10,
-    **kwds
+    backend=None,
+    **kwargs,
 ):
     """
     Make a histogram of the DataFrame's.
@@ -151,7 +154,15 @@ def hist_frame(
         bin edges are calculated and returned. If bins is a sequence, gives
         bin edges, including left edge of first bin and right edge of last
         bin. In this case, bins is returned unmodified.
-    **kwds
+    backend : str, default None
+        Backend to use instead of the backend specified in the option
+        ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to
+        specify the ``plotting.backend`` for the whole session, set
+        ``pd.options.plotting.backend``.
+
+        .. versionadded:: 1.0.0
+
+    **kwargs
         All other plotting keyword arguments to be passed to
         :meth:`matplotlib.pyplot.hist`.
 
@@ -178,7 +189,7 @@ def hist_frame(
         ...     }, index=['pig', 'rabbit', 'duck', 'chicken', 'horse'])
         >>> hist = df.hist(bins=3)
     """
-    plot_backend = _get_plot_backend()
+    plot_backend = _get_plot_backend(backend)
     return plot_backend.hist_frame(
         data,
         column=column,
@@ -194,185 +205,240 @@ def hist_frame(
         figsize=figsize,
         layout=layout,
         bins=bins,
-        **kwds
+        **kwargs,
     )
 
 
-def boxplot(
-    data,
-    column=None,
-    by=None,
-    ax=None,
-    fontsize=None,
-    rot=0,
-    grid=True,
-    figsize=None,
-    layout=None,
-    return_type=None,
-    **kwds
-):
-    """
-    Make a box plot from DataFrame columns.
-
-    Make a box-and-whisker plot from DataFrame columns, optionally grouped
-    by some other columns. A box plot is a method for graphically depicting
-    groups of numerical data through their quartiles.
-    The box extends from the Q1 to Q3 quartile values of the data,
-    with a line at the median (Q2). The whiskers extend from the edges
-    of box to show the range of the data. The position of the whiskers
-    is set by default to `1.5 * IQR (IQR = Q3 - Q1)` from the edges of the box.
-    Outlier points are those past the end of the whiskers.
-
-    For further details see
-    Wikipedia's entry for `boxplot <https://en.wikipedia.org/wiki/Box_plot>`_.
-
-    Parameters
-    ----------
-    column : str or list of str, optional
-        Column name or list of names, or vector.
-        Can be any valid input to :meth:`pandas.DataFrame.groupby`.
-    by : str or array-like, optional
-        Column in the DataFrame to :meth:`pandas.DataFrame.groupby`.
-        One box-plot will be done per value of columns in `by`.
-    ax : object of class matplotlib.axes.Axes, optional
-        The matplotlib axes to be used by boxplot.
-    fontsize : float or str
-        Tick label font size in points or as a string (e.g., `large`).
-    rot : int or float, default 0
-        The rotation angle of labels (in degrees)
-        with respect to the screen coordinate system.
-    grid : bool, default True
-        Setting this to True will show the grid.
-    figsize : A tuple (width, height) in inches
-        The size of the figure to create in matplotlib.
-    layout : tuple (rows, columns), optional
-        For example, (3, 5) will display the subplots
-        using 3 columns and 5 rows, starting from the top-left.
-    return_type : {'axes', 'dict', 'both'} or None, default 'axes'
-        The kind of object to return. The default is ``axes``.
-
-        * 'axes' returns the matplotlib axes the boxplot is drawn on.
-        * 'dict' returns a dictionary whose values are the matplotlib
-          Lines of the boxplot.
-        * 'both' returns a namedtuple with the axes and dict.
-        * when grouping with ``by``, a Series mapping columns to
-          ``return_type`` is returned.
-
-          If ``return_type`` is `None`, a NumPy array
-          of axes with the same shape as ``layout`` is returned.
-    **kwds
-        All other plotting keyword arguments to be passed to
-        :func:`matplotlib.pyplot.boxplot`.
+_boxplot_doc = """
+Make a box plot from DataFrame columns.
+
+Make a box-and-whisker plot from DataFrame columns, optionally grouped
+by some other columns. A box plot is a method for graphically depicting
+groups of numerical data through their quartiles.
+The box extends from the Q1 to Q3 quartile values of the data,
+with a line at the median (Q2). The whiskers extend from the edges
+of box to show the range of the data. The position of the whiskers
+is set by default to `1.5 * IQR (IQR = Q3 - Q1)` from the edges of the box.
+Outlier points are those past the end of the whiskers.
+
+For further details see
+Wikipedia's entry for `boxplot <https://en.wikipedia.org/wiki/Box_plot>`_.
+
+Parameters
+----------
+column : str or list of str, optional
+    Column name or list of names, or vector.
+    Can be any valid input to :meth:`pandas.DataFrame.groupby`.
+by : str or array-like, optional
+    Column in the DataFrame to :meth:`pandas.DataFrame.groupby`.
+    One box-plot will be done per value of columns in `by`.
+ax : object of class matplotlib.axes.Axes, optional
+    The matplotlib axes to be used by boxplot.
+fontsize : float or str
+    Tick label font size in points or as a string (e.g., `large`).
+rot : int or float, default 0
+    The rotation angle of labels (in degrees)
+    with respect to the screen coordinate system.
+grid : bool, default True
+    Setting this to True will show the grid.
+figsize : A tuple (width, height) in inches
+    The size of the figure to create in matplotlib.
+layout : tuple (rows, columns), optional
+    For example, (3, 5) will display the subplots
+    using 3 columns and 5 rows, starting from the top-left.
+return_type : {'axes', 'dict', 'both'} or None, default 'axes'
+    The kind of object to return. The default is ``axes``.
+
+    * 'axes' returns the matplotlib axes the boxplot is drawn on.
+    * 'dict' returns a dictionary whose values are the matplotlib
+      Lines of the boxplot.
+    * 'both' returns a namedtuple with the axes and dict.
+    * when grouping with ``by``, a Series mapping columns to
+      ``return_type`` is returned.
+
+      If ``return_type`` is `None`, a NumPy array
+      of axes with the same shape as ``layout`` is returned.
+%(backend)s\
+
+**kwargs
+    All other plotting keyword arguments to be passed to
+    :func:`matplotlib.pyplot.boxplot`.
+
+Returns
+-------
+result
+    See Notes.
+
+See Also
+--------
+Series.plot.hist: Make a histogram.
+matplotlib.pyplot.boxplot : Matplotlib equivalent plot.
+
+Notes
+-----
+The return type depends on the `return_type` parameter:
+
+* 'axes' : object of class matplotlib.axes.Axes
+* 'dict' : dict of matplotlib.lines.Line2D objects
+* 'both' : a namedtuple with structure (ax, lines)
+
+For data grouped with ``by``, return a Series of the above or a numpy
+array:
+
+* :class:`~pandas.Series`
+* :class:`~numpy.array` (for ``return_type = None``)
+
+Use ``return_type='dict'`` when you want to tweak the appearance
+of the lines after plotting. In this case a dict containing the Lines
+making up the boxes, caps, fliers, medians, and whiskers is returned.
+
+Examples
+--------
+
+Boxplots can be created for every column in the dataframe
+by ``df.boxplot()`` or indicating the columns to be used:
+
+.. plot::
+    :context: close-figs
+
+    >>> np.random.seed(1234)
+    >>> df = pd.DataFrame(np.random.randn(10, 4),
+    ...                   columns=['Col1', 'Col2', 'Col3', 'Col4'])
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2', 'Col3'])
+
+Boxplots of variables distributions grouped by the values of a third
+variable can be created using the option ``by``. For instance:
+
+.. plot::
+    :context: close-figs
+
+    >>> df = pd.DataFrame(np.random.randn(10, 2),
+    ...                   columns=['Col1', 'Col2'])
+    >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
+    ...                      'B', 'B', 'B', 'B', 'B'])
+    >>> boxplot = df.boxplot(by='X')
+
+A list of strings (i.e. ``['X', 'Y']``) can be passed to boxplot
+in order to group the data by combination of the variables in the x-axis:
+
+.. plot::
+    :context: close-figs
+
+    >>> df = pd.DataFrame(np.random.randn(10, 3),
+    ...                   columns=['Col1', 'Col2', 'Col3'])
+    >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
+    ...                      'B', 'B', 'B', 'B', 'B'])
+    >>> df['Y'] = pd.Series(['A', 'B', 'A', 'B', 'A',
+    ...                      'B', 'A', 'B', 'A', 'B'])
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by=['X', 'Y'])
+
+The layout of boxplot can be adjusted giving a tuple to ``layout``:
+
+.. plot::
+    :context: close-figs
+
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
+    ...                      layout=(2, 1))
 
-    Returns
-    -------
-    result
-        See Notes.
-
-    See Also
-    --------
-    Series.plot.hist: Make a histogram.
-    matplotlib.pyplot.boxplot : Matplotlib equivalent plot.
-
-    Notes
-    -----
-    The return type depends on the `return_type` parameter:
+Additional formatting can be done to the boxplot, like suppressing the grid
+(``grid=False``), rotating the labels in the x-axis (i.e. ``rot=45``)
+or changing the fontsize (i.e. ``fontsize=15``):
 
-    * 'axes' : object of class matplotlib.axes.Axes
-    * 'dict' : dict of matplotlib.lines.Line2D objects
-    * 'both' : a namedtuple with structure (ax, lines)
+.. plot::
+    :context: close-figs
 
-    For data grouped with ``by``, return a Series of the above or a numpy
-    array:
+    >>> boxplot = df.boxplot(grid=False, rot=45, fontsize=15)
 
-    * :class:`~pandas.Series`
-    * :class:`~numpy.array` (for ``return_type = None``)
+The parameter ``return_type`` can be used to select the type of element
+returned by `boxplot`.  When ``return_type='axes'`` is selected,
+the matplotlib axes on which the boxplot is drawn are returned:
 
-    Use ``return_type='dict'`` when you want to tweak the appearance
-    of the lines after plotting. In this case a dict containing the Lines
-    making up the boxes, caps, fliers, medians, and whiskers is returned.
-
-    Examples
-    --------
-
-    Boxplots can be created for every column in the dataframe
-    by ``df.boxplot()`` or indicating the columns to be used:
-
-    .. plot::
-        :context: close-figs
-
-        >>> np.random.seed(1234)
-        >>> df = pd.DataFrame(np.random.randn(10,4),
-        ...                   columns=['Col1', 'Col2', 'Col3', 'Col4'])
-        >>> boxplot = df.boxplot(column=['Col1', 'Col2', 'Col3'])
-
-    Boxplots of variables distributions grouped by the values of a third
-    variable can be created using the option ``by``. For instance:
-
-    .. plot::
-        :context: close-figs
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], return_type='axes')
+    >>> type(boxplot)
+    <class 'matplotlib.axes._subplots.AxesSubplot'>
 
-        >>> df = pd.DataFrame(np.random.randn(10, 2),
-        ...                   columns=['Col1', 'Col2'])
-        >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
-        ...                      'B', 'B', 'B', 'B', 'B'])
-        >>> boxplot = df.boxplot(by='X')
+When grouping with ``by``, a Series mapping columns to ``return_type``
+is returned:
 
-    A list of strings (i.e. ``['X', 'Y']``) can be passed to boxplot
-    in order to group the data by combination of the variables in the x-axis:
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
+    ...                      return_type='axes')
+    >>> type(boxplot)
+    <class 'pandas.core.series.Series'>
 
-    .. plot::
-        :context: close-figs
+If ``return_type`` is `None`, a NumPy array of axes with the same shape
+as ``layout`` is returned:
 
-        >>> df = pd.DataFrame(np.random.randn(10,3),
-        ...                   columns=['Col1', 'Col2', 'Col3'])
-        >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
-        ...                      'B', 'B', 'B', 'B', 'B'])
-        >>> df['Y'] = pd.Series(['A', 'B', 'A', 'B', 'A',
-        ...                      'B', 'A', 'B', 'A', 'B'])
-        >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by=['X', 'Y'])
+    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
+    ...                      return_type=None)
+    >>> type(boxplot)
+    <class 'numpy.ndarray'>
+"""
 
-    The layout of boxplot can be adjusted giving a tuple to ``layout``:
+_backend_doc = """\
+backend : str, default None
+    Backend to use instead of the backend specified in the option
+    ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to
+    specify the ``plotting.backend`` for the whole session, set
+    ``pd.options.plotting.backend``.
 
-    .. plot::
-        :context: close-figs
+    .. versionadded:: 1.0.0
+"""
 
-        >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
-        ...                      layout=(2, 1))
 
-    Additional formatting can be done to the boxplot, like suppressing the grid
-    (``grid=False``), rotating the labels in the x-axis (i.e. ``rot=45``)
-    or changing the fontsize (i.e. ``fontsize=15``):
+_bar_or_line_doc = """
+        Parameters
+        ----------
+        x : label or position, optional
+            Allows plotting of one column versus another. If not specified,
+            the index of the DataFrame is used.
+        y : label or position, optional
+            Allows plotting of one column versus another. If not specified,
+            all numerical columns are used.
+        color : str, array_like, or dict, optional
+            The color for each of the DataFrame's columns. Possible values are:
 
-    .. plot::
-        :context: close-figs
+            - A single color string referred to by name, RGB or RGBA code,
+                for instance 'red' or '#a98d19'.
 
-        >>> boxplot = df.boxplot(grid=False, rot=45, fontsize=15)
+            - A sequence of color strings referred to by name, RGB or RGBA
+                code, which will be used for each column recursively. For
+                instance ['green','yellow'] each column's %(kind)s will be filled in
+                green or yellow, alternatively.
 
-    The parameter ``return_type`` can be used to select the type of element
-    returned by `boxplot`.  When ``return_type='axes'`` is selected,
-    the matplotlib axes on which the boxplot is drawn are returned:
+            - A dict of the form {column name : color}, so that each column will be
+                colored accordingly. For example, if your columns are called `a` and
+                `b`, then passing {'a': 'green', 'b': 'red'} will color %(kind)ss for
+                column `a` in green and %(kind)ss for column `b` in red.
 
-        >>> boxplot = df.boxplot(column=['Col1','Col2'], return_type='axes')
-        >>> type(boxplot)
-        <class 'matplotlib.axes._subplots.AxesSubplot'>
+            .. versionadded:: 1.1.0
 
-    When grouping with ``by``, a Series mapping columns to ``return_type``
-    is returned:
+        **kwargs
+            Additional keyword arguments are documented in
+            :meth:`DataFrame.plot`.
 
-        >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
-        ...                      return_type='axes')
-        >>> type(boxplot)
-        <class 'pandas.core.series.Series'>
+        Returns
+        -------
+        matplotlib.axes.Axes or np.ndarray of them
+            An ndarray is returned with one :class:`matplotlib.axes.Axes`
+            per column when ``subplots=True``.
+"""
 
-    If ``return_type`` is `None`, a NumPy array of axes with the same shape
-    as ``layout`` is returned:
 
-        >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
-        ...                      return_type=None)
-        >>> type(boxplot)
-        <class 'numpy.ndarray'>
-    """
+@Substitution(backend="")
+@Appender(_boxplot_doc)
+def boxplot(
+    data,
+    column=None,
+    by=None,
+    ax=None,
+    fontsize=None,
+    rot=0,
+    grid=True,
+    figsize=None,
+    layout=None,
+    return_type=None,
+    **kwargs,
+):
     plot_backend = _get_plot_backend("matplotlib")
     return plot_backend.boxplot(
         data,
@@ -385,11 +451,12 @@ def boxplot(
         figsize=figsize,
         layout=layout,
         return_type=return_type,
-        **kwds
+        **kwargs,
     )
 
 
-@Appender(boxplot.__doc__)
+@Substitution(backend=_backend_doc)
+@Appender(_boxplot_doc)
 def boxplot_frame(
     self,
     column=None,
@@ -401,9 +468,10 @@ def boxplot_frame(
     figsize=None,
     layout=None,
     return_type=None,
-    **kwds
+    backend=None,
+    **kwargs,
 ):
-    plot_backend = _get_plot_backend()
+    plot_backend = _get_plot_backend(backend)
     return plot_backend.boxplot_frame(
         self,
         column=column,
@@ -415,7 +483,7 @@ def boxplot_frame(
         figsize=figsize,
         layout=layout,
         return_type=return_type,
-        **kwds
+        **kwargs,
     )
 
 
@@ -431,7 +499,8 @@ def boxplot_frame_groupby(
     layout=None,
     sharex=False,
     sharey=True,
-    **kwds
+    backend=None,
+    **kwargs,
 ):
     """
     Make box plots from DataFrameGroupBy data.
@@ -441,27 +510,36 @@ def boxplot_frame_groupby(
     grouped : Grouped DataFrame
     subplots : bool
         * ``False`` - no subplots will be used
-        * ``True`` - create a subplot for each group
+        * ``True`` - create a subplot for each group.
+
     column : column name or list of names, or vector
-        Can be any valid input to groupby
+        Can be any valid input to groupby.
     fontsize : int or str
     rot : label rotation angle
     grid : Setting this to True will show the grid
     ax : Matplotlib axis object, default None
     figsize : A tuple (width, height) in inches
     layout : tuple (optional)
-        (rows, columns) for the layout of the plot
+        The layout of the plot: (rows, columns).
     sharex : bool, default False
-        Whether x-axes will be shared among subplots
+        Whether x-axes will be shared among subplots.
 
         .. versionadded:: 0.23.1
     sharey : bool, default True
-        Whether y-axes will be shared among subplots
+        Whether y-axes will be shared among subplots.
 
         .. versionadded:: 0.23.1
-    `**kwds` : Keyword Arguments
+    backend : str, default None
+        Backend to use instead of the backend specified in the option
+        ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to
+        specify the ``plotting.backend`` for the whole session, set
+        ``pd.options.plotting.backend``.
+
+        .. versionadded:: 1.0.0
+
+    **kwargs
         All other plotting keyword arguments to be passed to
-        matplotlib's boxplot function
+        matplotlib's boxplot function.
 
     Returns
     -------
@@ -482,7 +560,7 @@ def boxplot_frame_groupby(
     >>> grouped = df.unstack(level='lvl1').groupby(level=0, axis=1)
     >>> boxplot_frame_groupby(grouped, subplots=False)
     """
-    plot_backend = _get_plot_backend()
+    plot_backend = _get_plot_backend(backend)
     return plot_backend.boxplot_frame_groupby(
         grouped,
         subplots=subplots,
@@ -495,25 +573,29 @@ def boxplot_frame_groupby(
         layout=layout,
         sharex=sharex,
         sharey=sharey,
-        **kwds
+        **kwargs,
     )
 
 
 class PlotAccessor(PandasObject):
     """
-    Make plots of Series or DataFrame using the backend specified by the
+    Make plots of Series or DataFrame.
+
+    Uses the backend specified by the
     option ``plotting.backend``. By default, matplotlib is used.
 
     Parameters
     ----------
     data : Series or DataFrame
-        The object for which the method is called
+        The object for which the method is called.
     x : label or position, default None
         Only used if data is a DataFrame.
     y : label, position or list of label, positions, default None
         Allows plotting of one column versus another. Only used if data is a
         DataFrame.
     kind : str
+        The kind of plot to produce:
+
         - 'line' : line plot (default)
         - 'bar' : vertical bar plot
         - 'barh' : horizontal bar plot
@@ -524,30 +606,31 @@ class PlotAccessor(PandasObject):
         - 'area' : area plot
         - 'pie' : pie plot
         - 'scatter' : scatter plot
-        - 'hexbin' : hexbin plot
+        - 'hexbin' : hexbin plot.
+
     figsize : a tuple (width, height) in inches
     use_index : bool, default True
-        Use index as ticks for x axis
+        Use index as ticks for x axis.
     title : str or list
         Title to use for the plot. If a string is passed, print the string
         at the top of the figure. If a list is passed and `subplots` is
         True, print each item in the list above the corresponding subplot.
     grid : bool, default None (matlab style default)
-        Axis grid lines
-    legend : False/True/'reverse'
-        Place legend on axis subplots
+        Axis grid lines.
+    legend : bool or {'reverse'}
+        Place legend on axis subplots.
     style : list or dict
-        matplotlib line style per column
+        The matplotlib line style per column.
     logx : bool or 'sym', default False
-        Use log scaling or symlog scaling on x axis
+        Use log scaling or symlog scaling on x axis.
         .. versionchanged:: 0.25.0
 
     logy : bool or 'sym' default False
-        Use log scaling or symlog scaling on y axis
+        Use log scaling or symlog scaling on y axis.
         .. versionchanged:: 0.25.0
 
     loglog : bool or 'sym', default False
-        Use log scaling or symlog scaling on both x and y axes
+        Use log scaling or symlog scaling on both x and y axes.
         .. versionchanged:: 0.25.0
 
     xticks : sequence
@@ -558,7 +641,7 @@ class PlotAccessor(PandasObject):
     ylim : 2-tuple/list
     rot : int, default None
         Rotation for ticks (xticks for vertical, yticks for horizontal
-        plots)
+        plots).
     fontsize : int, default None
         Font size for xticks and yticks.
     colormap : str or matplotlib colormap object, default None
@@ -566,11 +649,11 @@ class PlotAccessor(PandasObject):
         name from matplotlib.
     colorbar : bool, optional
         If True, plot colorbar (only relevant for 'scatter' and 'hexbin'
-        plots)
+        plots).
     position : float
         Specify relative alignments for bar plot layout.
         From 0 (left/bottom-end) to 1 (right/top-end). Default is 0.5
-        (center)
+        (center).
     table : bool, Series or DataFrame, default False
         If True, draw a table using the data in the DataFrame and the data
         will be transposed to meet matplotlib's default layout.
@@ -583,10 +666,18 @@ class PlotAccessor(PandasObject):
         Equivalent to yerr.
     mark_right : bool, default True
         When using a secondary_y axis, automatically mark the column
-        labels with "(right)" in the legend
+        labels with "(right)" in the legend.
     include_bool : bool, default is False
         If True, boolean values can be plotted.
-    `**kwds` : keywords
+    backend : str, default None
+        Backend to use instead of the backend specified in the option
+        ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to
+        specify the ``plotting.backend`` for the whole session, set
+        ``pd.options.plotting.backend``.
+
+        .. versionadded:: 1.0.0
+
+    **kwargs
         Options to pass to matplotlib plotting method.
 
     Returns
@@ -682,26 +773,23 @@ def _get_call_args(backend_name, data, args, kwargs):
             ]
         else:
             raise TypeError(
-                (
-                    "Called plot accessor for type {}, expected " "Series or DataFrame"
-                ).format(type(data).__name__)
+                f"Called plot accessor for type {type(data).__name__}, "
+                "expected Series or DataFrame"
             )
 
         if args and isinstance(data, ABCSeries):
+            positional_args = str(args)[1:-1]
+            keyword_args = ", ".join(
+                f"{name}={repr(value)}" for (name, default), value in zip(arg_def, args)
+            )
             msg = (
                 "`Series.plot()` should not be called with positional "
                 "arguments, only keyword arguments. The order of "
                 "positional arguments will change in the future. "
-                "Use `Series.plot({})` instead of `Series.plot({})`."
-            )
-            positional_args = str(args)[1:-1]
-            keyword_args = ", ".join(
-                "{}={!r}".format(name, value)
-                for (name, default), value in zip(arg_def, args)
-            )
-            warnings.warn(
-                msg.format(keyword_args, positional_args), FutureWarning, stacklevel=3
+                f"Use `Series.plot({keyword_args})` instead of "
+                f"`Series.plot({positional_args})`."
             )
+            raise TypeError(msg)
 
         pos_args = {name: value for value, (name, _) in zip(args, arg_def)}
         if backend_name == "pandas.plotting._matplotlib":
@@ -715,15 +803,20 @@ def _get_call_args(backend_name, data, args, kwargs):
         return x, y, kind, kwargs
 
     def __call__(self, *args, **kwargs):
-        plot_backend = _get_plot_backend()
+        plot_backend = _get_plot_backend(kwargs.pop("backend", None))
 
         x, y, kind, kwargs = self._get_call_args(
             plot_backend.__name__, self._parent, args, kwargs
         )
 
         kind = self._kind_aliases.get(kind, kind)
+
+        # when using another backend, get out of the way
+        if plot_backend.__name__ != "pandas.plotting._matplotlib":
+            return plot_backend.plot(self._parent, x=x, y=y, kind=kind, **kwargs)
+
         if kind not in self._all_kinds:
-            raise ValueError("{} is not a valid plot kind".format(kind))
+            raise ValueError(f"{kind} is not a valid plot kind")
 
         # The original data structured can be transformed before passed to the
         # backend. For example, for DataFrame is common to set the index as the
@@ -737,14 +830,13 @@ def __call__(self, *args, **kwargs):
             if isinstance(data, ABCDataFrame):
                 return plot_backend.plot(data, x=x, y=y, kind=kind, **kwargs)
             else:
-                raise ValueError(
-                    ("plot kind {} can only be used for " "data frames").format(kind)
-                )
+                raise ValueError(f"plot kind {kind} can only be used for data frames")
         elif kind in self._series_kinds:
             if isinstance(data, ABCDataFrame):
                 if y is None and kwargs.get("subplots") is False:
-                    msg = "{} requires either y column or 'subplots=True'"
-                    raise ValueError(msg.format(kind))
+                    raise ValueError(
+                        f"{kind} requires either y column or 'subplots=True'"
+                    )
                 elif y is not None:
                     if is_integer(y) and not data.columns.holds_integer():
                         y = data.columns[y]
@@ -793,31 +885,10 @@ def __call__(self, *args, **kwargs):
 
         return plot_backend.plot(data, kind=kind, **kwargs)
 
-    def line(self, x=None, y=None, **kwargs):
-        """
-        Plot Series or DataFrame as lines.
-
-        This function is useful to plot lines using DataFrame's values
-        as coordinates.
-
-        Parameters
-        ----------
-        x : int or str, optional
-            Columns to use for the horizontal axis.
-            Either the location or the label of the columns to be used.
-            By default, it will use the DataFrame indices.
-        y : int, str, or list of them, optional
-            The values to be plotted.
-            Either the location or the label of the columns to be used.
-            By default, it will use the remaining DataFrame numeric columns.
-        **kwds
-            Keyword arguments to pass on to :meth:`DataFrame.plot`.
-
-        Returns
-        -------
-        :class:`matplotlib.axes.Axes` or :class:`numpy.ndarray`
-            Return an ndarray when ``subplots=True``.
+    __call__.__doc__ = __doc__
 
+    @Appender(
+        """
         See Also
         --------
         matplotlib.pyplot.plot : Plot y versus x as lines and/or markers.
@@ -852,6 +923,16 @@ def line(self, x=None, y=None, **kwargs):
            >>> type(axes)
            <class 'numpy.ndarray'>
 
+        .. plot::
+           :context: close-figs
+
+           Let's repeat the same example, but specifying colors for
+           each column (in this case, for each animal).
+
+           >>> axes = df.plot.line(
+           ...     subplots=True, color={"pig": "pink", "horse": "#742802"}
+           ... )
+
         .. plot::
             :context: close-figs
 
@@ -860,36 +941,20 @@ def line(self, x=None, y=None, **kwargs):
 
             >>> lines = df.plot.line(x='pig', y='horse')
         """
-        return self(kind="line", x=x, y=y, **kwargs)
-
-    def bar(self, x=None, y=None, **kwargs):
+    )
+    @Substitution(kind="line")
+    @Appender(_bar_or_line_doc)
+    def line(self, x=None, y=None, **kwargs):
         """
-        Vertical bar plot.
-
-        A bar plot is a plot that presents categorical data with
-        rectangular bars with lengths proportional to the values that they
-        represent. A bar plot shows comparisons among discrete categories. One
-        axis of the plot shows the specific categories being compared, and the
-        other axis represents a measured value.
-
-        Parameters
-        ----------
-        x : label or position, optional
-            Allows plotting of one column versus another. If not specified,
-            the index of the DataFrame is used.
-        y : label or position, optional
-            Allows plotting of one column versus another. If not specified,
-            all numerical columns are used.
-        **kwds
-            Additional keyword arguments are documented in
-            :meth:`DataFrame.plot`.
+        Plot Series or DataFrame as lines.
 
-        Returns
-        -------
-        matplotlib.axes.Axes or np.ndarray of them
-            An ndarray is returned with one :class:`matplotlib.axes.Axes`
-            per column when ``subplots=True``.
+        This function is useful to plot lines using DataFrame's values
+        as coordinates.
+        """
+        return self(kind="line", x=x, y=y, **kwargs)
 
+    @Appender(
+        """
         See Also
         --------
         DataFrame.plot.barh : Horizontal bar plot.
@@ -931,6 +996,17 @@ def bar(self, x=None, y=None, **kwargs):
             >>> axes = df.plot.bar(rot=0, subplots=True)
             >>> axes[1].legend(loc=2)  # doctest: +SKIP
 
+        If you don't like the default colours, you can specify how you'd
+        like each column to be colored.
+
+        .. plot::
+            :context: close-figs
+
+            >>> axes = df.plot.bar(
+            ...     rot=0, subplots=True, color={"speed": "red", "lifespan": "green"}
+            ... )
+            >>> axes[1].legend(loc=2)  # doctest: +SKIP
+
         Plot a single column.
 
         .. plot::
@@ -944,32 +1020,24 @@ def bar(self, x=None, y=None, **kwargs):
             :context: close-figs
 
             >>> ax = df.plot.bar(x='lifespan', rot=0)
+    """
+    )
+    @Substitution(kind="bar")
+    @Appender(_bar_or_line_doc)
+    def bar(self, x=None, y=None, **kwargs):
         """
-        return self(kind="bar", x=x, y=y, **kwargs)
-
-    def barh(self, x=None, y=None, **kwargs):
-        """
-        Make a horizontal bar plot.
+        Vertical bar plot.
 
-        A horizontal bar plot is a plot that presents quantitative data with
+        A bar plot is a plot that presents categorical data with
         rectangular bars with lengths proportional to the values that they
         represent. A bar plot shows comparisons among discrete categories. One
         axis of the plot shows the specific categories being compared, and the
         other axis represents a measured value.
+        """
+        return self(kind="bar", x=x, y=y, **kwargs)
 
-        Parameters
-        ----------
-        x : label or position, default DataFrame.index
-            Column to be used for categories.
-        y : label or position, default All numeric columns in dataframe
-            Columns to be plotted from the DataFrame.
-        **kwds
-            Keyword arguments to pass on to :meth:`DataFrame.plot`.
-
-        Returns
-        -------
-        :class:`matplotlib.axes.Axes` or numpy.ndarray of them
-
+    @Appender(
+        """
         See Also
         --------
         DataFrame.plot.bar: Vertical bar plot.
@@ -999,6 +1067,13 @@ def barh(self, x=None, y=None, **kwargs):
             ...                    'lifespan': lifespan}, index=index)
             >>> ax = df.plot.barh()
 
+        We can specify colors for each column
+
+        .. plot::
+            :context: close-figs
+
+            >>> ax = df.plot.barh(color={"speed": "red", "lifespan": "green"})
+
         Plot a column of the DataFrame to a horizontal bar plot
 
         .. plot::
@@ -1024,6 +1099,19 @@ def barh(self, x=None, y=None, **kwargs):
             >>> df = pd.DataFrame({'speed': speed,
             ...                    'lifespan': lifespan}, index=index)
             >>> ax = df.plot.barh(x='lifespan')
+    """
+    )
+    @Substitution(kind="bar")
+    @Appender(_bar_or_line_doc)
+    def barh(self, x=None, y=None, **kwargs):
+        """
+        Make a horizontal bar plot.
+
+        A horizontal bar plot is a plot that presents quantitative data with
+        rectangular bars with lengths proportional to the values that they
+        represent. A bar plot shows comparisons among discrete categories. One
+        axis of the plot shows the specific categories being compared, and the
+        other axis represents a measured value.
         """
         return self(kind="barh", x=x, y=y, **kwargs)
 
@@ -1049,7 +1137,7 @@ def box(self, by=None, **kwargs):
         ----------
         by : str or sequence
             Column in the DataFrame to group by.
-        **kwds : optional
+        **kwargs
             Additional keywords are documented in
             :meth:`DataFrame.plot`.
 
@@ -1092,7 +1180,7 @@ def hist(self, by=None, bins=10, **kwargs):
             Column in the DataFrame to group by.
         bins : int, default 10
             Number of histogram bins to be used.
-        **kwds
+        **kwargs
             Additional keyword arguments are documented in
             :meth:`DataFrame.plot`.
 
@@ -1143,12 +1231,12 @@ def kde(self, bw_method=None, ind=None, **kwargs):
             'scott', 'silverman', a scalar constant or a callable.
             If None (default), 'scott' is used.
             See :class:`scipy.stats.gaussian_kde` for more information.
-        ind : NumPy array or integer, optional
+        ind : NumPy array or int, optional
             Evaluation points for the estimated PDF. If None (default),
             1000 equally spaced points are used. If `ind` is a NumPy array, the
             KDE is evaluated at the points passed. If `ind` is an integer,
             `ind` number of equally spaced points are used.
-        **kwds : optional
+        **kwargs
             Additional keyword arguments are documented in
             :meth:`pandas.%(this-datatype)s.plot`.
 
@@ -1250,7 +1338,7 @@ def area(self, x=None, y=None, **kwargs):
         stacked : bool, default True
             Area plots are stacked by default. Set to False to create a
             unstacked plot.
-        **kwds : optional
+        **kwargs
             Additional keyword arguments are documented in
             :meth:`DataFrame.plot`.
 
@@ -1322,7 +1410,7 @@ def pie(self, **kwargs):
         y : int or label, optional
             Label or position of the column to plot.
             If not provided, ``subplots=True`` argument must be passed.
-        **kwds
+        **kwargs
             Keyword arguments to pass on to :meth:`DataFrame.plot`.
 
         Returns
@@ -1338,7 +1426,7 @@ def pie(self, **kwargs):
         Examples
         --------
         In the example below we have a DataFrame with the information about
-        planet's mass and radius. We pass the the 'mass' column to the
+        planet's mass and radius. We pass the 'mass' column to the
         pie function to get a pie plot.
 
         .. plot::
@@ -1404,7 +1492,7 @@ def scatter(self, x, y, s=None, c=None, **kwargs):
             - A column name or position whose values will be used to color the
               marker points according to a colormap.
 
-        **kwds
+        **kwargs
             Keyword arguments to pass on to :meth:`DataFrame.plot`.
 
         Returns
@@ -1476,7 +1564,7 @@ def hexbin(self, x, y, C=None, reduce_C_function=None, gridsize=None, **kwargs):
             Alternatively, gridsize can be a tuple with two elements
             specifying the number of hexagons in the x-direction and the
             y-direction.
-        **kwds
+        **kwargs
             Additional keyword arguments are documented in
             :meth:`DataFrame.plot`.
 
@@ -1580,12 +1668,11 @@ def _find_backend(backend: str):
                 _backends[backend] = module
                 return module
 
-    msg = (
-        "Could not find plotting backend '{name}'. Ensure that you've installed the "
-        "package providing the '{name}' entrypoint, or that the package has a"
+    raise ValueError(
+        f"Could not find plotting backend '{backend}'. Ensure that you've installed "
+        f"the package providing the '{backend}' entrypoint, or that the package has a "
         "top-level `.plot` method."
     )
-    raise ValueError(msg.format(name=backend))
 
 
 def _get_plot_backend(backend=None):
diff --git a/pandas/plotting/_matplotlib/__init__.py b/pandas/plotting/_matplotlib/__init__.py
index d3b7a34b6c923..27b1d55fe1bd6 100644
--- a/pandas/plotting/_matplotlib/__init__.py
+++ b/pandas/plotting/_matplotlib/__init__.py
@@ -1,4 +1,4 @@
-from pandas._config import get_option
+from typing import TYPE_CHECKING, Dict, Type
 
 from pandas.plotting._matplotlib.boxplot import (
     BoxPlot,
@@ -26,10 +26,12 @@
     radviz,
     scatter_matrix,
 )
-from pandas.plotting._matplotlib.timeseries import tsplot
 from pandas.plotting._matplotlib.tools import table
 
-PLOT_CLASSES = {
+if TYPE_CHECKING:
+    from pandas.plotting._matplotlib.core import MPLPlot  # noqa: F401
+
+PLOT_CLASSES: Dict[str, Type["MPLPlot"]] = {
     "line": LinePlot,
     "bar": BarPlot,
     "barh": BarhPlot,
@@ -42,9 +44,6 @@
     "hexbin": HexBinPlot,
 }
 
-if get_option("plotting.matplotlib.register_converters"):
-    register(explicit=False)
-
 
 def plot(data, kind, **kwargs):
     # Importing pyplot at the top of the file (before the converters are
@@ -71,7 +70,6 @@ def plot(data, kind, **kwargs):
     "boxplot",
     "boxplot_frame",
     "boxplot_frame_groupby",
-    "tsplot",
     "table",
     "andrews_curves",
     "autocorrelation_plot",
diff --git a/pandas/plotting/_matplotlib/boxplot.py b/pandas/plotting/_matplotlib/boxplot.py
index 8ff7441df5354..e36696dc23a87 100644
--- a/pandas/plotting/_matplotlib/boxplot.py
+++ b/pandas/plotting/_matplotlib/boxplot.py
@@ -4,13 +4,13 @@
 from matplotlib.artist import setp
 import numpy as np
 
+from pandas.core.dtypes.common import is_dict_like
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import remove_na_arraylike
 
 import pandas as pd
 
 from pandas.io.formats.printing import pprint_thing
-from pandas.plotting._matplotlib import converter
 from pandas.plotting._matplotlib.core import LinePlot, MPLPlot
 from pandas.plotting._matplotlib.style import _get_standard_colors
 from pandas.plotting._matplotlib.tools import _flatten, _subplots
@@ -74,9 +74,8 @@ def _validate_color_args(self):
                 for key, values in self.color.items():
                     if key not in valid_keys:
                         raise ValueError(
-                            "color dict contains invalid "
-                            "key '{0}' "
-                            "The key must be either {1}".format(key, valid_keys)
+                            f"color dict contains invalid key '{key}'. "
+                            f"The key must be either {valid_keys}"
                         )
         else:
             self.color = None
@@ -108,14 +107,20 @@ def maybe_color_bp(self, bp):
             medians = self.color or self._medians_c
             caps = self.color or self._caps_c
 
-        setp(bp["boxes"], color=boxes, alpha=1)
-        setp(bp["whiskers"], color=whiskers, alpha=1)
-        setp(bp["medians"], color=medians, alpha=1)
-        setp(bp["caps"], color=caps, alpha=1)
+        # GH 30346, when users specifying those arguments explicitly, our defaults
+        # for these four kwargs should be overridden; if not, use Pandas settings
+        if not self.kwds.get("boxprops"):
+            setp(bp["boxes"], color=boxes, alpha=1)
+        if not self.kwds.get("whiskerprops"):
+            setp(bp["whiskers"], color=whiskers, alpha=1)
+        if not self.kwds.get("medianprops"):
+            setp(bp["medians"], color=medians, alpha=1)
+        if not self.kwds.get("capprops"):
+            setp(bp["caps"], color=caps, alpha=1)
 
     def _make_plot(self):
         if self.subplots:
-            self._return_obj = pd.Series()
+            self._return_obj = pd.Series(dtype=object)
 
             for i, (label, y) in enumerate(self._iter_data()):
                 ax = self._get_ax(i)
@@ -184,7 +189,7 @@ def _grouped_plot_by_column(
     ax=None,
     layout=None,
     return_type=None,
-    **kwargs
+    **kwargs,
 ):
     grouped = data.groupby(by)
     if columns is None:
@@ -217,7 +222,7 @@ def _grouped_plot_by_column(
         result = axes
 
     byline = by[0] if len(by) == 1 else by
-    fig.suptitle("Boxplot grouped by {byline}".format(byline=byline))
+    fig.suptitle(f"Boxplot grouped by {byline}")
     fig.subplots_adjust(bottom=0.15, top=0.9, left=0.1, right=0.9, wspace=0.2)
 
     return result
@@ -234,7 +239,7 @@ def boxplot(
     figsize=None,
     layout=None,
     return_type=None,
-    **kwds
+    **kwds,
 ):
 
     import matplotlib.pyplot as plt
@@ -250,13 +255,43 @@ def boxplot(
     def _get_colors():
         #  num_colors=3 is required as method maybe_color_bp takes the colors
         #  in positions 0 and 2.
-        return _get_standard_colors(color=kwds.get("color"), num_colors=3)
+        #  if colors not provided, use same defaults as DataFrame.plot.box
+        result = _get_standard_colors(num_colors=3)
+        result = np.take(result, [0, 0, 2])
+        result = np.append(result, "k")
+
+        colors = kwds.pop("color", None)
+        if colors:
+            if is_dict_like(colors):
+                # replace colors in result array with user-specified colors
+                # taken from the colors dict parameter
+                # "boxes" value placed in position 0, "whiskers" in 1, etc.
+                valid_keys = ["boxes", "whiskers", "medians", "caps"]
+                key_to_index = dict(zip(valid_keys, range(4)))
+                for key, value in colors.items():
+                    if key in valid_keys:
+                        result[key_to_index[key]] = value
+                    else:
+                        raise ValueError(
+                            f"color dict contains invalid key '{key}'. "
+                            f"The key must be either {valid_keys}"
+                        )
+            else:
+                result.fill(colors)
 
-    def maybe_color_bp(bp):
-        if "color" not in kwds:
+        return result
+
+    def maybe_color_bp(bp, **kwds):
+        # GH 30346, when users specifying those arguments explicitly, our defaults
+        # for these four kwargs should be overridden; if not, use Pandas settings
+        if not kwds.get("boxprops"):
             setp(bp["boxes"], color=colors[0], alpha=1)
-            setp(bp["whiskers"], color=colors[0], alpha=1)
+        if not kwds.get("whiskerprops"):
+            setp(bp["whiskers"], color=colors[1], alpha=1)
+        if not kwds.get("medianprops"):
             setp(bp["medians"], color=colors[2], alpha=1)
+        if not kwds.get("capprops"):
+            setp(bp["caps"], color=colors[3], alpha=1)
 
     def plot_group(keys, values, ax):
         keys = [pprint_thing(x) for x in keys]
@@ -268,7 +303,7 @@ def plot_group(keys, values, ax):
             ax.set_xticklabels(keys, rotation=rot)
         else:
             ax.set_yticklabels(keys, rotation=rot)
-        maybe_color_bp(bp)
+        maybe_color_bp(bp, **kwds)
 
         # Return axes in multiplot case, maybe revisit later # 985
         if return_type == "dict":
@@ -305,9 +340,7 @@ def plot_group(keys, values, ax):
         if return_type is None:
             return_type = "axes"
         if layout is not None:
-            raise ValueError(
-                "The 'layout' keyword is not supported when " "'by' is None"
-            )
+            raise ValueError("The 'layout' keyword is not supported when 'by' is None")
 
         if ax is None:
             rc = {"figure.figsize": figsize} if figsize is not None else {}
@@ -336,11 +369,10 @@ def boxplot_frame(
     figsize=None,
     layout=None,
     return_type=None,
-    **kwds
+    **kwds,
 ):
     import matplotlib.pyplot as plt
 
-    converter._WARN = False  # no warning for pandas plots
     ax = boxplot(
         self,
         column=column,
@@ -352,7 +384,7 @@ def boxplot_frame(
         figsize=figsize,
         layout=layout,
         return_type=return_type,
-        **kwds
+        **kwds,
     )
     plt.draw_if_interactive()
     return ax
@@ -370,9 +402,8 @@ def boxplot_frame_groupby(
     layout=None,
     sharex=False,
     sharey=True,
-    **kwds
+    **kwds,
 ):
-    converter._WARN = False  # no warning for pandas plots
     if subplots is True:
         naxes = len(grouped)
         fig, axes = _subplots(
@@ -386,7 +417,8 @@ def boxplot_frame_groupby(
         )
         axes = _flatten(axes)
 
-        ret = pd.Series()
+        ret = pd.Series(dtype=object)
+
         for (key, group), ax in zip(grouped, axes):
             d = group.boxplot(
                 ax=ax, column=column, fontsize=fontsize, rot=rot, grid=grid, **kwds
@@ -411,6 +443,6 @@ def boxplot_frame_groupby(
             ax=ax,
             figsize=figsize,
             layout=layout,
-            **kwds
+            **kwds,
         )
     return ret
diff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py
index 446350cb5d915..770f89324badb 100644
--- a/pandas/plotting/_matplotlib/converter.py
+++ b/pandas/plotting/_matplotlib/converter.py
@@ -1,6 +1,7 @@
+import contextlib
 import datetime as pydt
 from datetime import datetime, timedelta
-import warnings
+import functools
 
 from dateutil.relativedelta import relativedelta
 import matplotlib.dates as dates
@@ -23,8 +24,8 @@
 )
 from pandas.core.dtypes.generic import ABCSeries
 
+from pandas import Index, get_option
 import pandas.core.common as com
-from pandas.core.index import Index
 from pandas.core.indexes.datetimes import date_range
 from pandas.core.indexes.period import Period, PeriodIndex, period_range
 import pandas.core.tools.datetimes as tools
@@ -39,7 +40,6 @@
 
 MUSEC_PER_DAY = 1e6 * SEC_PER_DAY
 
-_WARN = True  # Global for whether pandas has registered the units explicitly
 _mpl_units = {}  # Cache for units overwritten by us
 
 
@@ -55,13 +55,42 @@ def get_pairs():
     return pairs
 
 
-def register(explicit=True):
-    # Renamed in pandas.plotting.__init__
-    global _WARN
+def register_pandas_matplotlib_converters(func):
+    """
+    Decorator applying pandas_converters.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with pandas_converters():
+            return func(*args, **kwargs)
+
+    return wrapper
 
-    if explicit:
-        _WARN = False
 
+@contextlib.contextmanager
+def pandas_converters():
+    """
+    Context manager registering pandas' converters for a plot.
+
+    See Also
+    --------
+    register_pandas_matplotlib_converters : Decorator that applies this.
+    """
+    value = get_option("plotting.matplotlib.register_converters")
+
+    if value:
+        # register for True or "auto"
+        register()
+    try:
+        yield
+    finally:
+        if value == "auto":
+            # only deregister for "auto"
+            deregister()
+
+
+def register():
     pairs = get_pairs()
     for type_, cls in pairs:
         # Cache previous converter if present
@@ -86,24 +115,6 @@ def deregister():
             units.registry[unit] = formatter
 
 
-def _check_implicitly_registered():
-    global _WARN
-
-    if _WARN:
-        msg = (
-            "Using an implicitly registered datetime converter for a "
-            "matplotlib plotting method. The converter was registered "
-            "by pandas on import. Future versions of pandas will require "
-            "you to explicitly register matplotlib converters.\n\n"
-            "To register the converters:\n\t"
-            ">>> from pandas.plotting import register_matplotlib_converters"
-            "\n\t"
-            ">>> register_matplotlib_converters()"
-        )
-        warnings.warn(msg, FutureWarning)
-        _WARN = False
-
-
 def _to_ordinalf(tm):
     tot_sec = tm.hour * 3600 + tm.minute * 60 + tm.second + float(tm.microsecond / 1e6)
     return tot_sec
@@ -113,7 +124,7 @@ def time2num(d):
     if isinstance(d, str):
         parsed = tools.to_datetime(d)
         if not isinstance(parsed, datetime):
-            raise ValueError("Could not parse time {d}".format(d=d))
+            raise ValueError(f"Could not parse time {d}")
         return _to_ordinalf(parsed.time())
     if isinstance(d, pydt.time):
         return _to_ordinalf(d)
@@ -232,7 +243,7 @@ def get_datevalue(date, freq):
         return date
     elif date is None:
         return None
-    raise ValueError("Unrecognizable date '{date}'".format(date=date))
+    raise ValueError(f"Unrecognizable date '{date}'")
 
 
 def _dt_to_float_ordinal(dt):
@@ -253,7 +264,6 @@ class DatetimeConverter(dates.DateConverter):
     @staticmethod
     def convert(values, unit, axis):
         # values might be a 1-d array, or a list-like of arrays.
-        _check_implicitly_registered()
         if is_nested_list_like(values):
             values = [DatetimeConverter._convert_1d(v, unit, axis) for v in values]
         else:
@@ -330,7 +340,6 @@ def __init__(self, locator, tz=None, defaultfmt="%Y-%m-%d"):
 class PandasAutoDateLocator(dates.AutoDateLocator):
     def get_locator(self, dmin, dmax):
         """Pick the best locator based on a distance."""
-        _check_implicitly_registered()
         delta = relativedelta(dmax, dmin)
 
         num_days = (delta.years * 12.0 + delta.months) * 31.0 + delta.days
@@ -372,18 +381,17 @@ def get_unit_generic(freq):
 
     def __call__(self):
         # if no data have been set, this will tank with a ValueError
-        _check_implicitly_registered()
         try:
             dmin, dmax = self.viewlim_to_dt()
         except ValueError:
             return []
 
-        if dmin > dmax:
-            dmax, dmin = dmin, dmax
         # We need to cap at the endpoints of valid datetime
 
         # FIXME: dont leave commented-out
         # TODO(wesm) unused?
+        # if dmin > dmax:
+        #     dmax, dmin = dmin, dmax
         # delta = relativedelta(dmax, dmin)
         # try:
         #     start = dmin - delta
@@ -412,15 +420,13 @@ def __call__(self):
 
         if estimate > self.MAXTICKS * 2:
             raise RuntimeError(
-                (
-                    "MillisecondLocator estimated to generate "
-                    "{estimate:d} ticks from {dmin} to {dmax}: "
-                    "exceeds Locator.MAXTICKS"
-                    "* 2 ({arg:d}) "
-                ).format(estimate=estimate, dmin=dmin, dmax=dmax, arg=self.MAXTICKS * 2)
+                "MillisecondLocator estimated to generate "
+                f"{estimate:d} ticks from {dmin} to {dmax}: exceeds Locator.MAXTICKS"
+                f"* 2 ({self.MAXTICKS * 2:d}) "
             )
 
-        freq = "%dL" % self._get_interval()
+        interval = self._get_interval()
+        freq = f"{interval}L"
         tz = self.tz.tzname(None)
         st = _from_ordinal(dates.date2num(dmin))  # strip tz
         ed = _from_ordinal(dates.date2num(dmax))
@@ -572,7 +578,7 @@ def _daily_finder(vmin, vmax, freq):
         elif freq == FreqGroup.FR_HR:
             periodsperday = 24
         else:  # pragma: no cover
-            raise ValueError("unexpected frequency: {freq}".format(freq=freq))
+            raise ValueError(f"unexpected frequency: {freq}")
         periodsperyear = 365 * periodsperday
         periodspermonth = 28 * periodsperday
 
@@ -931,8 +937,7 @@ def get_finder(freq):
     elif (freq >= FreqGroup.FR_BUS) or fgroup == FreqGroup.FR_WK:
         return _daily_finder
     else:  # pragma: no cover
-        errmsg = "Unsupported frequency: {freq}".format(freq=freq)
-        raise NotImplementedError(errmsg)
+        raise NotImplementedError(f"Unsupported frequency: {freq}")
 
 
 class TimeSeries_DateLocator(Locator):
@@ -976,7 +981,7 @@ def __init__(
         self.finder = get_finder(freq)
 
     def _get_default_locs(self, vmin, vmax):
-        "Returns the default locations of ticks."
+        """Returns the default locations of ticks."""
 
         if self.plot_obj.date_axis_info is None:
             self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
@@ -988,9 +993,8 @@ def _get_default_locs(self, vmin, vmax):
         return np.compress(locator["maj"], locator["val"])
 
     def __call__(self):
-        "Return the locations of the ticks."
+        """Return the locations of the ticks."""
         # axis calls Locator.set_axis inside set_m<xxxx>_formatter
-        _check_implicitly_registered()
 
         vi = tuple(self.axis.get_view_interval())
         if vi != self.plot_obj.view_interval:
@@ -1058,7 +1062,7 @@ def __init__(self, freq, minor_locator=False, dynamic_mode=True, plot_obj=None):
         self.finder = get_finder(freq)
 
     def _set_default_format(self, vmin, vmax):
-        "Returns the default ticks spacing."
+        """Returns the default ticks spacing."""
 
         if self.plot_obj.date_axis_info is None:
             self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
@@ -1072,10 +1076,9 @@ def _set_default_format(self, vmin, vmax):
         return self.formatdict
 
     def set_locs(self, locs):
-        "Sets the locations of the ticks"
+        """Sets the locations of the ticks"""
         # don't actually use the locs. This is just needed to work with
         # matplotlib. Force to use vmin, vmax
-        _check_implicitly_registered()
 
         self.locs = locs
 
@@ -1088,12 +1091,13 @@ def set_locs(self, locs):
         self._set_default_format(vmin, vmax)
 
     def __call__(self, x, pos=0):
-        _check_implicitly_registered()
 
         if self.formatdict is None:
             return ""
         else:
             fmt = self.formatdict.pop(x, "")
+            if isinstance(fmt, np.bytes_):
+                fmt = fmt.decode("utf-8")
             return Period(ordinal=int(x), freq=self.freq).strftime(fmt)
 
 
@@ -1112,15 +1116,14 @@ def format_timedelta_ticks(x, pos, n_decimals):
         h, m = divmod(m, 60)
         d, h = divmod(h, 24)
         decimals = int(ns * 10 ** (n_decimals - 9))
-        s = r"{:02d}:{:02d}:{:02d}".format(int(h), int(m), int(s))
+        s = f"{int(h):02d}:{int(m):02d}:{int(s):02d}"
         if n_decimals > 0:
-            s += ".{{:0{:0d}d}}".format(n_decimals).format(decimals)
+            s += f".{decimals:0{n_decimals}d}"
         if d != 0:
-            s = "{:d} days ".format(int(d)) + s
+            s = f"{int(d):d} days {s}"
         return s
 
     def __call__(self, x, pos=0):
-        _check_implicitly_registered()
         (vmin, vmax) = tuple(self.axis.get_view_interval())
         n_decimals = int(np.ceil(np.log10(100 * 1e9 / (vmax - vmin))))
         if n_decimals > 9:
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index 3c9256e629740..3f47d325d86ef 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -4,8 +4,6 @@
 
 import numpy as np
 
-from pandas._config import get_option
-
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import cache_readonly
 
@@ -28,8 +26,8 @@
 import pandas.core.common as com
 
 from pandas.io.formats.printing import pprint_thing
-from pandas.plotting._matplotlib import converter
 from pandas.plotting._matplotlib.compat import _mpl_ge_3_0_0
+from pandas.plotting._matplotlib.converter import register_pandas_matplotlib_converters
 from pandas.plotting._matplotlib.style import _get_standard_colors
 from pandas.plotting._matplotlib.tools import (
     _flatten,
@@ -41,9 +39,6 @@
     table,
 )
 
-if get_option("plotting.matplotlib.register_converters"):
-    converter.register(explicit=False)
-
 
 class MPLPlot:
     """
@@ -62,7 +57,7 @@ def _kind(self):
 
     _layout_type = "vertical"
     _default_rot = 0
-    orientation = None  # type: Optional[str]
+    orientation: Optional[str] = None
     _pop_attributes = [
         "label",
         "style",
@@ -107,12 +102,11 @@ def __init__(
         table=False,
         layout=None,
         include_bool=False,
-        **kwds
+        **kwds,
     ):
 
         import matplotlib.pyplot as plt
 
-        converter._WARN = False  # no warning for pandas plots
         self.data = data
         self.by = by
 
@@ -199,15 +193,7 @@ def __init__(
         self._validate_color_args()
 
     def _validate_color_args(self):
-        if "color" not in self.kwds and "colors" in self.kwds:
-            warnings.warn(
-                (
-                    "'colors' is being deprecated. Please use 'color'"
-                    "instead of 'colors'"
-                )
-            )
-            colors = self.kwds.pop("colors")
-            self.kwds["color"] = colors
+        import matplotlib.colors
 
         if (
             "color" in self.kwds
@@ -230,7 +216,7 @@ def _validate_color_args(self):
             "color" in self.kwds or "colors" in self.kwds
         ) and self.colormap is not None:
             warnings.warn(
-                "'color' and 'colormap' cannot be used " "simultaneously. Using 'color'"
+                "'color' and 'colormap' cannot be used simultaneously. Using 'color'"
             )
 
         if "color" in self.kwds and self.style is not None:
@@ -240,13 +226,13 @@ def _validate_color_args(self):
                 styles = [self.style]
             # need only a single match
             for s in styles:
-                if re.match("^[a-z]+?", s) is not None:
-                    raise ValueError(
-                        "Cannot pass 'style' string with a color "
-                        "symbol and 'color' keyword argument. Please"
-                        " use one or the other or pass 'style' "
-                        "without a color symbol"
-                    )
+                for char in s:
+                    if char in matplotlib.colors.BASE_COLORS:
+                        raise ValueError(
+                            "Cannot pass 'style' string with a color symbol and "
+                            "'color' keyword argument. Please use one or the other or "
+                            "pass 'style' without a color symbol"
+                        )
 
     def _iter_data(self, data=None, keep_index=False, fillna=None):
         if data is None:
@@ -254,12 +240,6 @@ def _iter_data(self, data=None, keep_index=False, fillna=None):
         if fillna is not None:
             data = data.fillna(fillna)
 
-        # TODO: unused?
-        # if self.sort_columns:
-        #     columns = com.try_sort(data.columns)
-        # else:
-        #     columns = data.columns
-
         for col, values in data.items():
             if keep_index is True:
                 yield col, values
@@ -352,8 +332,7 @@ def _setup_subplots(self):
         if input_log - valid_log:
             invalid_log = next(iter((input_log - valid_log)))
             raise ValueError(
-                "Boolean, None and 'sym' are valid options,"
-                " '{}' is given.".format(invalid_log)
+                f"Boolean, None and 'sym' are valid options, '{invalid_log}' is given."
             )
 
         if self.logx is True or self.loglog is True:
@@ -415,6 +394,10 @@ def _compute_plot_data(self):
             include_type = [np.number]
             exclude_type = ["timedelta"]
 
+        # GH 18755, include object and category type for scatter plot
+        if self._kind == "scatter":
+            include_type.extend(["object", "category"])
+
         numeric_data = data.select_dtypes(include=include_type, exclude=exclude_type)
 
         try:
@@ -504,14 +487,13 @@ def _adorn_subplots(self):
             if self.subplots:
                 if is_list_like(self.title):
                     if len(self.title) != self.nseries:
-                        msg = (
+                        raise ValueError(
                             "The length of `title` must equal the number "
                             "of columns if using `title` of type `list` "
                             "and `subplots=True`.\n"
-                            "length of title = {}\n"
-                            "number of columns = {}"
-                        ).format(len(self.title), self.nseries)
-                        raise ValueError(msg)
+                            f"length of title = {len(self.title)}\n"
+                            f"number of columns = {self.nseries}"
+                        )
 
                     for (ax, title) in zip(self.axes, self.title):
                         ax.set_title(title)
@@ -527,10 +509,11 @@ def _adorn_subplots(self):
                 self.axes[0].set_title(self.title)
 
     def _apply_axis_properties(self, axis, rot=None, fontsize=None):
-        """ Tick creation within matplotlib is reasonably expensive and is
-            internally deferred until accessed as Ticks are created/destroyed
-            multiple times per draw. It's therefore beneficial for us to avoid
-            accessing unless we will act on the Tick.
+        """
+        Tick creation within matplotlib is reasonably expensive and is
+        internally deferred until accessed as Ticks are created/destroyed
+        multiple times per draw. It's therefore beneficial for us to avoid
+        accessing unless we will act on the Tick.
         """
 
         if rot is not None or fontsize is not None:
@@ -648,6 +631,7 @@ def _get_xticks(self, convert_period=False):
         return x
 
     @classmethod
+    @register_pandas_matplotlib_converters
     def _plot(cls, ax, x, y, style=None, is_errorbar=False, **kwds):
         mask = isna(y)
         if mask.any():
@@ -743,7 +727,10 @@ def _apply_style_colors(self, colors, kwds, col_num, label):
         has_color = "color" in kwds or self.colormap is not None
         nocolor_style = style is None or re.match("[a-z]+", style) is None
         if (has_color or self.subplots) and nocolor_style:
-            kwds["color"] = colors[col_num % len(colors)]
+            if isinstance(colors, dict):
+                kwds["color"] = colors[label]
+            else:
+                kwds["color"] = colors[col_num % len(colors)]
         return style, kwds
 
     def _get_colors(self, num_colors=None, color_kwds="color"):
@@ -815,11 +802,10 @@ def match_labels(data, e):
                     or (err_shape[1] != 2)
                     or (err_shape[2] != len(self.data))
                 ):
-                    msg = (
+                    raise ValueError(
                         "Asymmetrical error bars should be provided "
-                        + "with the shape (%u, 2, %u)" % (self.nseries, len(self.data))
+                        f"with the shape ({self.nseries}, 2, {len(self.data)})"
                     )
-                    raise ValueError(msg)
 
             # broadcast errors to each data series
             if len(err) == 1:
@@ -829,7 +815,7 @@ def match_labels(data, e):
             err = np.tile([err], (self.nseries, len(self.data)))
 
         else:
-            msg = "No valid {label} detected".format(label=label)
+            msg = f"No valid {label} detected"
             raise ValueError(msg)
 
         return err
@@ -887,10 +873,13 @@ def __init__(self, data, x, y, **kwargs):
             x = self.data.columns[x]
         if is_integer(y) and not self.data.columns.holds_integer():
             y = self.data.columns[y]
-        if len(self.data[x]._get_numeric_data()) == 0:
-            raise ValueError(self._kind + " requires x column to be numeric")
-        if len(self.data[y]._get_numeric_data()) == 0:
-            raise ValueError(self._kind + " requires y column to be numeric")
+
+        # Scatter plot allows to plot objects data
+        if self._kind == "hexbin":
+            if len(self.data[x]._get_numeric_data()) == 0:
+                raise ValueError(self._kind + " requires x column to be numeric")
+            if len(self.data[y]._get_numeric_data()) == 0:
+                raise ValueError(self._kind + " requires y column to be numeric")
 
         self.x = x
         self.y = y
@@ -987,7 +976,7 @@ def _make_plot(self):
             c=c_values,
             label=label,
             cmap=cmap,
-            **self.kwds
+            **self.kwds,
         )
         if cb:
             cbar_label = c if c_is_column else ""
@@ -1097,7 +1086,7 @@ def _make_plot(self):
                 column_num=i,
                 stacking_id=stacking_id,
                 is_errorbar=is_errorbar,
-                **kwds
+                **kwds,
             )
             self._add_legend_handle(newlines[0], label, index=i)
 
@@ -1180,7 +1169,7 @@ def _get_stacked_values(cls, ax, stacking_id, values, label):
         raise ValueError(
             "When stacked is True, each column must be either "
             "all positive or negative."
-            "{0} contains both positive and negative values".format(label)
+            f"{label} contains both positive and negative values"
         )
 
     @classmethod
@@ -1252,7 +1241,7 @@ def _plot(
         column_num=None,
         stacking_id=None,
         is_errorbar=False,
-        **kwds
+        **kwds,
     ):
 
         if column_num == 0:
@@ -1362,6 +1351,8 @@ def _make_plot(self):
             kwds = self.kwds.copy()
             if self._is_series:
                 kwds["color"] = colors
+            elif isinstance(colors, dict):
+                kwds["color"] = colors[label]
             else:
                 kwds["color"] = colors[i % ncolors]
 
@@ -1388,7 +1379,7 @@ def _make_plot(self):
                     start=start,
                     label=label,
                     log=self.log,
-                    **kwds
+                    **kwds,
                 )
                 ax.set_title(label)
             elif self.stacked:
@@ -1403,7 +1394,7 @@ def _make_plot(self):
                     start=start,
                     label=label,
                     log=self.log,
-                    **kwds
+                    **kwds,
                 )
                 pos_prior = pos_prior + np.where(mask, y, 0)
                 neg_prior = neg_prior + np.where(mask, 0, y)
@@ -1417,7 +1408,7 @@ def _make_plot(self):
                     start=start,
                     label=label,
                     log=self.log,
-                    **kwds
+                    **kwds,
                 )
             self._add_legend_handle(rect, label, index=i)
 
@@ -1435,8 +1426,13 @@ def _post_plot_logic(self, ax, data):
 
     def _decorate_ticks(self, ax, name, ticklabels, start_edge, end_edge):
         ax.set_xlim((start_edge, end_edge))
-        ax.set_xticks(self.tick_pos)
-        ax.set_xticklabels(ticklabels)
+
+        if self.xticks is not None:
+            ax.set_xticks(np.array(self.xticks))
+        else:
+            ax.set_xticks(self.tick_pos)
+            ax.set_xticklabels(ticklabels)
+
         if name is not None and self.use_index:
             ax.set_xlabel(name)
 
@@ -1470,7 +1466,7 @@ class PiePlot(MPLPlot):
     def __init__(self, data, kind=None, **kwargs):
         data = data.fillna(value=0)
         if (data < 0).any().any():
-            raise ValueError("{0} doesn't allow negative values".format(kind))
+            raise ValueError(f"{kind} doesn't allow negative values")
         MPLPlot.__init__(self, data, kind=kind, **kwargs)
 
     def _args_adjust(self):
diff --git a/pandas/plotting/_matplotlib/hist.py b/pandas/plotting/_matplotlib/hist.py
index 5213e09f14067..d54fc73b495ba 100644
--- a/pandas/plotting/_matplotlib/hist.py
+++ b/pandas/plotting/_matplotlib/hist.py
@@ -1,5 +1,3 @@
-import warnings
-
 import numpy as np
 
 from pandas.core.dtypes.common import is_integer, is_list_like
@@ -9,7 +7,6 @@
 import pandas.core.common as com
 
 from pandas.io.formats.printing import pprint_thing
-from pandas.plotting._matplotlib import converter
 from pandas.plotting._matplotlib.core import LinePlot, MPLPlot
 from pandas.plotting._matplotlib.tools import _flatten, _set_ticks_props, _subplots
 
@@ -30,7 +27,7 @@ def _args_adjust(self):
             values = np.ravel(values)
             values = values[~isna(values)]
 
-            hist, self.bins = np.histogram(
+            _, self.bins = np.histogram(
                 values,
                 bins=self.bins,
                 range=self.kwds.get("range", None),
@@ -50,7 +47,7 @@ def _plot(
         bottom=0,
         column_num=0,
         stacking_id=None,
-        **kwds
+        **kwds,
     ):
         if column_num == 0:
             cls._initialize_stacker(ax, stacking_id, len(bins) - 1)
@@ -146,7 +143,7 @@ def _plot(
         ind=None,
         column_num=None,
         stacking_id=None,
-        **kwds
+        **kwds,
     ):
         from scipy.stats import gaussian_kde
 
@@ -178,17 +175,15 @@ def _grouped_plot(
     layout=None,
     rot=0,
     ax=None,
-    **kwargs
+    **kwargs,
 ):
 
     if figsize == "default":
         # allowed to specify mpl default with 'default'
-        warnings.warn(
-            "figsize='default' is deprecated. Specify figure " "size by tuple instead",
-            FutureWarning,
-            stacklevel=5,
+        raise ValueError(
+            "figsize='default' is no longer supported. "
+            "Specify figure size by tuple instead"
         )
-        figsize = None
 
     grouped = data.groupby(by)
     if column is not None:
@@ -227,7 +222,7 @@ def _grouped_hist(
     xrot=None,
     ylabelsize=None,
     yrot=None,
-    **kwargs
+    **kwargs,
 ):
     """
     Grouped histogram
@@ -255,8 +250,8 @@ def _grouped_hist(
     def plot_group(group, ax):
         ax.hist(group.dropna().values, bins=bins, **kwargs)
 
-    converter._WARN = False  # no warning for pandas plots
-    xrot = xrot or rot
+    if xrot is None:
+        xrot = rot
 
     fig, axes = _grouped_plot(
         plot_group,
@@ -292,15 +287,13 @@ def hist_series(
     yrot=None,
     figsize=None,
     bins=10,
-    **kwds
+    **kwds,
 ):
     import matplotlib.pyplot as plt
 
     if by is None:
         if kwds.get("layout", None) is not None:
-            raise ValueError(
-                "The 'layout' keyword is not supported when " "'by' is None"
-            )
+            raise ValueError("The 'layout' keyword is not supported when 'by' is None")
         # hack until the plotting interface is a bit more unified
         fig = kwds.pop(
             "figure", plt.gcf() if plt.get_fignums() else plt.figure(figsize=figsize)
@@ -325,8 +318,7 @@ def hist_series(
         if "figure" in kwds:
             raise ValueError(
                 "Cannot pass 'figure' when using the "
-                "'by' argument, since a new 'Figure' instance "
-                "will be created"
+                "'by' argument, since a new 'Figure' instance will be created"
             )
         axes = _grouped_hist(
             self,
@@ -339,7 +331,7 @@ def hist_series(
             xrot=xrot,
             ylabelsize=ylabelsize,
             yrot=yrot,
-            **kwds
+            **kwds,
         )
 
     if hasattr(axes, "ndim"):
@@ -363,9 +355,8 @@ def hist_frame(
     figsize=None,
     layout=None,
     bins=10,
-    **kwds
+    **kwds,
 ):
-    converter._WARN = False  # no warning for pandas plots
     if by is not None:
         axes = _grouped_hist(
             data,
@@ -382,7 +373,7 @@ def hist_frame(
             xrot=xrot,
             ylabelsize=ylabelsize,
             yrot=yrot,
-            **kwds
+            **kwds,
         )
         return axes
 
@@ -394,7 +385,7 @@ def hist_frame(
     naxes = len(data.columns)
 
     if naxes == 0:
-        raise ValueError("hist method requires numerical columns, " "nothing to plot.")
+        raise ValueError("hist method requires numerical columns, nothing to plot.")
 
     fig, axes = _subplots(
         naxes=naxes,
diff --git a/pandas/plotting/_matplotlib/misc.py b/pandas/plotting/_matplotlib/misc.py
index 6d5a94c4d5ff8..0720f544203f7 100644
--- a/pandas/plotting/_matplotlib/misc.py
+++ b/pandas/plotting/_matplotlib/misc.py
@@ -22,7 +22,7 @@ def scatter_matrix(
     density_kwds=None,
     hist_kwds=None,
     range_padding=0.05,
-    **kwds
+    **kwds,
 ):
     df = frame._get_numeric_data()
     n = df.columns.size
@@ -160,7 +160,7 @@ def normalize(series):
             to_plot[kls][1],
             color=colors[i],
             label=pprint_thing(kls),
-            **kwds
+            **kwds,
         )
     ax.legend()
 
@@ -315,7 +315,7 @@ def parallel_coordinates(
     axvlines=True,
     axvlines_kwds=None,
     sort_labels=False,
-    **kwds
+    **kwds,
 ):
     import matplotlib.pyplot as plt
 
@@ -395,7 +395,7 @@ def lag_plot(series, lag=1, ax=None, **kwds):
     if ax is None:
         ax = plt.gca()
     ax.set_xlabel("y(t)")
-    ax.set_ylabel("y(t + {lag})".format(lag=lag))
+    ax.set_ylabel(f"y(t + {lag})")
     ax.scatter(y1, y2, **kwds)
     return ax
 
diff --git a/pandas/plotting/_matplotlib/style.py b/pandas/plotting/_matplotlib/style.py
index e1bba5856e271..7990bff4f517c 100644
--- a/pandas/plotting/_matplotlib/style.py
+++ b/pandas/plotting/_matplotlib/style.py
@@ -20,14 +20,18 @@ def _get_standard_colors(
             cmap = colormap
             colormap = cm.get_cmap(colormap)
             if colormap is None:
-                raise ValueError("Colormap {0} is not recognized".format(cmap))
+                raise ValueError(f"Colormap {cmap} is not recognized")
         colors = [colormap(num) for num in np.linspace(0, 1, num=num_colors)]
     elif color is not None:
         if colormap is not None:
             warnings.warn(
-                "'color' and 'colormap' cannot be used " "simultaneously. Using 'color'"
+                "'color' and 'colormap' cannot be used simultaneously. Using 'color'"
             )
-        colors = list(color) if is_list_like(color) else color
+        colors = (
+            list(color)
+            if is_list_like(color) and not isinstance(color, dict)
+            else color
+        )
     else:
         if color_type == "default":
             # need to call list() on the result to copy so we don't
diff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py
index f160e50d8d99b..3abce690cbe6b 100644
--- a/pandas/plotting/_matplotlib/timeseries.py
+++ b/pandas/plotting/_matplotlib/timeseries.py
@@ -1,7 +1,6 @@
 # TODO: Use the fact that axis can have units to simplify the process
 
 import functools
-import warnings
 
 import numpy as np
 
@@ -33,48 +32,6 @@
 # Plotting functions and monkey patches
 
 
-def tsplot(series, plotf, ax=None, **kwargs):
-    """
-    Plots a Series on the given Matplotlib axes or the current axes
-
-    Parameters
-    ----------
-    axes : Axes
-    series : Series
-
-    Notes
-    _____
-    Supports same kwargs as Axes.plot
-
-
-    .. deprecated:: 0.23.0
-       Use Series.plot() instead
-    """
-    import matplotlib.pyplot as plt
-
-    warnings.warn(
-        "'tsplot' is deprecated and will be removed in a "
-        "future version. Please use Series.plot() instead.",
-        FutureWarning,
-        stacklevel=2,
-    )
-
-    # Used inferred freq is possible, need a test case for inferred
-    if ax is None:
-        ax = plt.gca()
-
-    freq, series = _maybe_resample(series, ax, kwargs)
-
-    # Set ax with freq info
-    _decorate_axes(ax, freq, kwargs)
-    ax._plot_data.append((series, plotf, kwargs))
-    lines = plotf(ax, series.index._mpl_repr(), series.values, **kwargs)
-
-    # set date formatter, locators and rescale limits
-    format_dateaxis(ax, ax.freq, series.index)
-    return lines
-
-
 def _maybe_resample(series, ax, kwargs):
     # resample against axes freq if necessary
     freq, ax_freq = _get_freq(ax, series)
@@ -294,7 +251,7 @@ def _maybe_convert_index(ax, data):
         freq = frequencies.get_period_alias(freq)
 
         if isinstance(data.index, ABCDatetimeIndex):
-            data = data.to_period(freq=freq)
+            data = data.tz_localize(None).to_period(freq=freq)
         elif isinstance(data.index, ABCPeriodIndex):
             data.index = data.index.asfreq(freq=freq)
     return data
@@ -305,7 +262,8 @@ def _maybe_convert_index(ax, data):
 
 
 def _format_coord(freq, t, y):
-    return "t = {0}  y = {1:8f}".format(Period(ordinal=int(t), freq=freq), y)
+    time_period = Period(ordinal=int(t), freq=freq)
+    return f"t = {time_period}  y = {y:8f}"
 
 
 def format_dateaxis(subplot, freq, index):
diff --git a/pandas/plotting/_matplotlib/tools.py b/pandas/plotting/_matplotlib/tools.py
index 67fa79ad5da8c..d7732c86911b8 100644
--- a/pandas/plotting/_matplotlib/tools.py
+++ b/pandas/plotting/_matplotlib/tools.py
@@ -12,14 +12,11 @@
 
 def format_date_labels(ax, rot):
     # mini version of autofmt_xdate
-    try:
-        for label in ax.get_xticklabels():
-            label.set_ha("right")
-            label.set_rotation(rot)
-        fig = ax.get_figure()
-        fig.subplots_adjust(bottom=0.2)
-    except Exception:  # pragma: no cover
-        pass
+    for label in ax.get_xticklabels():
+        label.set_ha("right")
+        label.set_rotation(rot)
+    fig = ax.get_figure()
+    fig.subplots_adjust(bottom=0.2)
 
 
 def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
@@ -63,10 +60,7 @@ def _get_layout(nplots, layout=None, layout_type="box"):
 
         if nrows * ncols < nplots:
             raise ValueError(
-                "Layout of {nrows}x{ncols} must be larger "
-                "than required size {nplots}".format(
-                    nrows=nrows, ncols=ncols, nplots=nplots
-                )
+                f"Layout of {nrows}x{ncols} must be larger than required size {nplots}"
             )
 
         return layout
@@ -104,7 +98,7 @@ def _subplots(
     ax=None,
     layout=None,
     layout_type="box",
-    **fig_kw
+    **fig_kw,
 ):
     """Create a figure with a set of subplots already made.
 
@@ -191,14 +185,12 @@ def _subplots(
             ax = _flatten(ax)
             if layout is not None:
                 warnings.warn(
-                    "When passing multiple axes, layout keyword is " "ignored",
-                    UserWarning,
+                    "When passing multiple axes, layout keyword is ignored", UserWarning
                 )
             if sharex or sharey:
                 warnings.warn(
                     "When passing multiple axes, sharex and sharey "
-                    "are ignored. These settings must be specified "
-                    "when creating axes",
+                    "are ignored. These settings must be specified when creating axes",
                     UserWarning,
                     stacklevel=4,
                 )
@@ -207,8 +199,8 @@ def _subplots(
                 return fig, ax
             else:
                 raise ValueError(
-                    "The number of passed axes must be {0}, the "
-                    "same as the output plot".format(naxes)
+                    f"The number of passed axes must be {naxes}, the "
+                    "same as the output plot"
                 )
 
         fig = ax.get_figure()
@@ -281,17 +273,15 @@ def _remove_labels_from_axis(axis):
     for t in axis.get_majorticklabels():
         t.set_visible(False)
 
-    try:
-        # set_visible will not be effective if
-        # minor axis has NullLocator and NullFormattor (default)
-        if isinstance(axis.get_minor_locator(), ticker.NullLocator):
-            axis.set_minor_locator(ticker.AutoLocator())
-        if isinstance(axis.get_minor_formatter(), ticker.NullFormatter):
-            axis.set_minor_formatter(ticker.FormatStrFormatter(""))
-        for t in axis.get_minorticklabels():
-            t.set_visible(False)
-    except Exception:  # pragma no cover
-        raise
+    # set_visible will not be effective if
+    # minor axis has NullLocator and NullFormattor (default)
+    if isinstance(axis.get_minor_locator(), ticker.NullLocator):
+        axis.set_minor_locator(ticker.AutoLocator())
+    if isinstance(axis.get_minor_formatter(), ticker.NullFormatter):
+        axis.set_minor_formatter(ticker.FormatStrFormatter(""))
+    for t in axis.get_minorticklabels():
+        t.set_visible(False)
+
     axis.get_label().set_visible(False)
 
 
diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index a8e86d9dfa997..1369adcd80269 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -1,22 +1,19 @@
 from contextlib import contextmanager
-import warnings
-
-from pandas.util._decorators import deprecate_kwarg
 
 from pandas.plotting._core import _get_plot_backend
 
 
 def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
     """
-    Helper function to convert DataFrame and Series to matplotlib.table
+    Helper function to convert DataFrame and Series to matplotlib.table.
 
     Parameters
     ----------
     ax : Matplotlib axes object
     data : DataFrame or Series
-        data for table contents
-    kwargs : keywords, optional
-        keyword arguments which passed to matplotlib.table.table.
+        Data for table contents.
+    **kwargs
+        Keyword arguments to be passed to matplotlib.table.table.
         If `rowLabels` or `colLabels` is not specified, data index or column
         name will be used.
 
@@ -30,9 +27,9 @@ def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
     )
 
 
-def register(explicit=True):
+def register():
     """
-    Register Pandas Formatters and Converters with matplotlib
+    Register Pandas Formatters and Converters with matplotlib.
 
     This function modifies the global ``matplotlib.units.registry``
     dictionary. Pandas adds custom converters for
@@ -49,12 +46,12 @@ def register(explicit=True):
     deregister_matplotlib_converters
     """
     plot_backend = _get_plot_backend("matplotlib")
-    plot_backend.register(explicit=explicit)
+    plot_backend.register()
 
 
 def deregister():
     """
-    Remove pandas' formatters and converters
+    Remove pandas' formatters and converters.
 
     Removes the custom converters added by :func:`register`. This
     attempts to set the state of the registry back to the state before
@@ -82,7 +79,7 @@ def scatter_matrix(
     density_kwds=None,
     hist_kwds=None,
     range_padding=0.05,
-    **kwds
+    **kwargs,
 ):
     """
     Draw a matrix of scatter plots.
@@ -91,28 +88,26 @@ def scatter_matrix(
     ----------
     frame : DataFrame
     alpha : float, optional
-        amount of transparency applied
+        Amount of transparency applied.
     figsize : (float,float), optional
-        a tuple (width, height) in inches
+        A tuple (width, height) in inches.
     ax : Matplotlib axis object, optional
     grid : bool, optional
-        setting this to True will show the grid
+        Setting this to True will show the grid.
     diagonal : {'hist', 'kde'}
-        pick between 'kde' and 'hist' for
-        either Kernel Density Estimation or Histogram
-        plot in the diagonal
+        Pick between 'kde' and 'hist' for either Kernel Density Estimation or
+        Histogram plot in the diagonal.
     marker : str, optional
-        Matplotlib marker type, default '.'
-    hist_kwds : other plotting keyword arguments
-        To be passed to hist function
-    density_kwds : other plotting keyword arguments
-        To be passed to kernel density estimate plot
-    range_padding : float, optional
-        relative extension of axis range in x and y
-        with respect to (x_max - x_min) or (y_max - y_min),
-        default 0.05
-    kwds : other plotting keyword arguments
-        To be passed to scatter function
+        Matplotlib marker type, default '.'.
+    density_kwds : keywords
+        Keyword arguments to be passed to kernel density estimate plot.
+    hist_kwds : keywords
+        Keyword arguments to be passed to hist function.
+    range_padding : float, default 0.05
+        Relative extension of axis range in x and y with respect to
+        (x_max - x_min) or (y_max - y_min).
+    **kwargs
+        Keyword arguments to be passed to scatter function.
 
     Returns
     -------
@@ -136,7 +131,7 @@ def scatter_matrix(
         density_kwds=density_kwds,
         hist_kwds=hist_kwds,
         range_padding=range_padding,
-        **kwds
+        **kwargs,
     )
 
 
@@ -154,7 +149,7 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
     influence of all dimensions.
 
     More info available at the `original article
-    <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.135.889>`_
+    <https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.135.889>`_
     describing RadViz.
 
     Parameters
@@ -170,7 +165,7 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
     colormap : str or :class:`matplotlib.colors.Colormap`, default None
         Colormap to select colors from. If string, load colormap with that
         name from matplotlib.
-    kwds : optional
+    **kwds
         Options to pass to matplotlib scatter plotting method.
 
     Returns
@@ -209,13 +204,12 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
         ax=ax,
         color=color,
         colormap=colormap,
-        **kwds
+        **kwds,
     )
 
 
-@deprecate_kwarg(old_arg_name="data", new_arg_name="frame")
 def andrews_curves(
-    frame, class_column, ax=None, samples=200, color=None, colormap=None, **kwds
+    frame, class_column, ax=None, samples=200, color=None, colormap=None, **kwargs
 ):
     """
     Generate a matplotlib plot of Andrews curves, for visualising clusters of
@@ -233,17 +227,17 @@ def andrews_curves(
     Parameters
     ----------
     frame : DataFrame
-        Data to be plotted, preferably normalized to (0.0, 1.0)
+        Data to be plotted, preferably normalized to (0.0, 1.0).
     class_column : Name of the column containing class names
     ax : matplotlib axes object, default None
     samples : Number of points to plot in each curve
     color : list or tuple, optional
-        Colors to use for the different classes
+        Colors to use for the different classes.
     colormap : str or matplotlib colormap object, default None
         Colormap to select colors from. If string, load colormap with that name
         from matplotlib.
-    kwds : keywords
-        Options to pass to matplotlib plotting method
+    **kwargs
+        Options to pass to matplotlib plotting method.
 
     Returns
     -------
@@ -257,7 +251,7 @@ def andrews_curves(
         samples=samples,
         color=color,
         colormap=colormap,
-        **kwds
+        **kwargs,
     )
 
 
@@ -285,7 +279,7 @@ def bootstrap_plot(series, fig=None, size=50, samples=500, **kwds):
         greater or equal than the length of the `series`.
     samples : int, default 500
         Number of times the bootstrap procedure is performed.
-    **kwds :
+    **kwds
         Options to pass to matplotlib plotting method.
 
     Returns
@@ -313,8 +307,6 @@ def bootstrap_plot(series, fig=None, size=50, samples=500, **kwds):
     )
 
 
-@deprecate_kwarg(old_arg_name="colors", new_arg_name="color")
-@deprecate_kwarg(old_arg_name="data", new_arg_name="frame", stacklevel=3)
 def parallel_coordinates(
     frame,
     class_column,
@@ -327,7 +319,7 @@ def parallel_coordinates(
     axvlines=True,
     axvlines_kwds=None,
     sort_labels=False,
-    **kwds
+    **kwargs,
 ):
     """
     Parallel coordinates plotting.
@@ -336,30 +328,27 @@ def parallel_coordinates(
     ----------
     frame : DataFrame
     class_column : str
-        Column name containing class names
+        Column name containing class names.
     cols : list, optional
-        A list of column names to use
+        A list of column names to use.
     ax : matplotlib.axis, optional
-        matplotlib axis object
+        Matplotlib axis object.
     color : list or tuple, optional
-        Colors to use for the different classes
+        Colors to use for the different classes.
     use_columns : bool, optional
-        If true, columns will be used as xticks
+        If true, columns will be used as xticks.
     xticks : list or tuple, optional
-        A list of values to use for xticks
+        A list of values to use for xticks.
     colormap : str or matplotlib colormap, default None
         Colormap to use for line colors.
     axvlines : bool, optional
-        If true, vertical lines will be added at each xtick
+        If true, vertical lines will be added at each xtick.
     axvlines_kwds : keywords, optional
-        Options to be passed to axvline method for vertical lines
-    sort_labels : bool, False
-        Sort class_column labels, useful when assigning colors
-
-        .. versionadded:: 0.20.0
-
-    kwds : keywords
-        Options to pass to matplotlib plotting method
+        Options to be passed to axvline method for vertical lines.
+    sort_labels : bool, default False
+        Sort class_column labels, useful when assigning colors.
+    **kwargs
+        Options to pass to matplotlib plotting method.
 
     Returns
     -------
@@ -369,7 +358,7 @@ def parallel_coordinates(
     --------
     >>> from matplotlib import pyplot as plt
     >>> df = pd.read_csv('https://raw.github.com/pandas-dev/pandas/master'
-                        '/pandas/tests/data/iris.csv')
+                        '/pandas/tests/data/csv/iris.csv')
     >>> pd.plotting.parallel_coordinates(
             df, 'Name',
             color=('#556270', '#4ECDC4', '#C7F464'))
@@ -388,7 +377,7 @@ def parallel_coordinates(
         axvlines=axvlines,
         axvlines_kwds=axvlines_kwds,
         sort_labels=sort_labels,
-        **kwds
+        **kwargs,
     )
 
 
@@ -401,7 +390,8 @@ def lag_plot(series, lag=1, ax=None, **kwds):
     series : Time series
     lag : lag of the scatter plot, default 1
     ax : Matplotlib axis object, optional
-    kwds : Matplotlib scatter method keyword arguments, optional
+    **kwds
+        Matplotlib scatter method keyword arguments.
 
     Returns
     -------
@@ -411,7 +401,7 @@ def lag_plot(series, lag=1, ax=None, **kwds):
     return plot_backend.lag_plot(series=series, lag=lag, ax=ax, **kwds)
 
 
-def autocorrelation_plot(series, ax=None, **kwds):
+def autocorrelation_plot(series, ax=None, **kwargs):
     """
     Autocorrelation plot for time series.
 
@@ -419,50 +409,24 @@ def autocorrelation_plot(series, ax=None, **kwds):
     ----------
     series : Time series
     ax : Matplotlib axis object, optional
-    kwds : keywords
-        Options to pass to matplotlib plotting method
+    **kwargs
+        Options to pass to matplotlib plotting method.
 
     Returns
     -------
     class:`matplotlib.axis.Axes`
     """
     plot_backend = _get_plot_backend("matplotlib")
-    return plot_backend.autocorrelation_plot(series=series, ax=ax, **kwds)
-
-
-def tsplot(series, plotf, ax=None, **kwargs):
-    """
-    Plots a Series on the given Matplotlib axes or the current axes
-
-    Parameters
-    ----------
-    axes : Axes
-    series : Series
-
-    Notes
-    _____
-    Supports same kwargs as Axes.plot
-
-
-    .. deprecated:: 0.23.0
-       Use Series.plot() instead
-    """
-    warnings.warn(
-        "'tsplot' is deprecated and will be removed in a "
-        "future version. Please use Series.plot() instead.",
-        FutureWarning,
-        stacklevel=2,
-    )
-    plot_backend = _get_plot_backend("matplotlib")
-    return plot_backend.tsplot(series=series, plotf=plotf, ax=ax, **kwargs)
+    return plot_backend.autocorrelation_plot(series=series, ax=ax, **kwargs)
 
 
 class _Options(dict):
     """
     Stores pandas plotting options.
+
     Allows for parameter aliasing so you can just use parameter names that are
     the same as the plot function parameters, but is stored in a canonical
-    format that makes it easy to breakdown into groups later
+    format that makes it easy to breakdown into groups later.
     """
 
     # alias so the names are same as plotting method parameter names
@@ -471,15 +435,12 @@ class _Options(dict):
 
     def __init__(self, deprecated=False):
         self._deprecated = deprecated
-        # self['xaxis.compat'] = False
         super().__setitem__("xaxis.compat", False)
 
     def __getitem__(self, key):
         key = self._get_canonical_key(key)
         if key not in self:
-            raise ValueError(
-                "{key} is not a valid pandas plotting option".format(key=key)
-            )
+            raise ValueError(f"{key} is not a valid pandas plotting option")
         return super().__getitem__(key)
 
     def __setitem__(self, key, value):
@@ -489,10 +450,10 @@ def __setitem__(self, key, value):
     def __delitem__(self, key):
         key = self._get_canonical_key(key)
         if key in self._DEFAULT_KEYS:
-            raise ValueError("Cannot remove default parameter {key}".format(key=key))
+            raise ValueError(f"Cannot remove default parameter {key}")
         return super().__delitem__(key)
 
-    def __contains__(self, key):
+    def __contains__(self, key) -> bool:
         key = self._get_canonical_key(key)
         return super().__contains__(key)
 
diff --git a/pandas/testing.py b/pandas/testing.py
index acae47367d997..0445fa5b5efc0 100644
--- a/pandas/testing.py
+++ b/pandas/testing.py
@@ -1,11 +1,17 @@
-# flake8: noqa
-
 """
 Public testing utility functions.
 """
 
-from pandas.util.testing import (
+from pandas._testing import (
+    assert_extension_array_equal,
     assert_frame_equal,
     assert_index_equal,
     assert_series_equal,
 )
+
+__all__ = [
+    "assert_extension_array_equal",
+    "assert_frame_equal",
+    "assert_series_equal",
+    "assert_index_equal",
+]
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index 326bef7f4b480..406d5f055797d 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -1,6 +1,12 @@
+import subprocess
+import sys
+from typing import List
+
+import pytest
+
 import pandas as pd
 from pandas import api, compat
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class Base:
@@ -11,14 +17,13 @@ def check(self, namespace, expected, ignored=None):
 
         result = sorted(f for f in dir(namespace) if not f.startswith("__"))
         if ignored is not None:
-            result = sorted(list(set(result) - set(ignored)))
+            result = sorted(set(result) - set(ignored))
 
         expected = sorted(expected)
         tm.assert_almost_equal(result, expected)
 
 
 class TestPDApi(Base):
-
     # these are optionally imported based on testing
     # & need to be ignored
     ignored = ["tests", "locale", "conftest"]
@@ -41,10 +46,10 @@ class TestPDApi(Base):
     ]
 
     # these are already deprecated; awaiting removal
-    deprecated_modules = []
+    deprecated_modules: List[str] = ["np", "datetime"]
 
     # misc
-    misc = ["IndexSlice", "NaT"]
+    misc = ["IndexSlice", "NaT", "NA"]
 
     # top-level classes
     classes = [
@@ -66,10 +71,8 @@ class TestPDApi(Base):
         "RangeIndex",
         "UInt64Index",
         "Series",
-        "SparseArray",
-        "SparseDataFrame",
         "SparseDtype",
-        "SparseSeries",
+        "StringDtype",
         "Timedelta",
         "TimedeltaIndex",
         "Timestamp",
@@ -79,6 +82,7 @@ class TestPDApi(Base):
         "PeriodDtype",
         "IntervalDtype",
         "DatetimeTZDtype",
+        "BooleanDtype",
         "Int8Dtype",
         "Int16Dtype",
         "Int32Dtype",
@@ -89,17 +93,20 @@ class TestPDApi(Base):
         "UInt64Dtype",
         "NamedAgg",
     ]
-    if not compat.PY37:
-        classes.append("Panel")
 
     # these are already deprecated; awaiting removal
-    deprecated_classes = []
+    deprecated_classes: List[str] = []
 
     # these should be deprecated in the future
-    deprecated_classes_in_future = []
+    deprecated_classes_in_future: List[str] = ["SparseArray"]
+
+    if not compat.PY37:
+        classes.extend(["Panel", "SparseSeries", "SparseDataFrame"])
+        # deprecated_modules.extend(["np", "datetime"])
+        # deprecated_classes_in_future.extend(["SparseArray"])
 
     # external modules exposed in pandas namespace
-    modules = ["np", "datetime"]
+    modules: List[str] = []
 
     # top-level functions
     funcs = [
@@ -155,7 +162,6 @@ class TestPDApi(Base):
         "read_hdf",
         "read_html",
         "read_json",
-        "read_msgpack",
         "read_pickle",
         "read_sas",
         "read_sql",
@@ -165,17 +171,21 @@ class TestPDApi(Base):
         "read_table",
         "read_feather",
         "read_parquet",
+        "read_orc",
         "read_spss",
     ]
 
+    # top-level json funcs
+    funcs_json = ["json_normalize"]
+
     # top-level to_* funcs
-    funcs_to = ["to_datetime", "to_msgpack", "to_numeric", "to_pickle", "to_timedelta"]
+    funcs_to = ["to_datetime", "to_numeric", "to_pickle", "to_timedelta"]
 
     # top-level to deprecate in the future
-    deprecated_funcs_in_future = []
+    deprecated_funcs_in_future: List[str] = []
 
     # these are already deprecated; awaiting removal
-    deprecated_funcs = []
+    deprecated_funcs: List[str] = []
 
     # private modules in pandas namespace
     private_modules = [
@@ -187,6 +197,8 @@ class TestPDApi(Base):
         "_np_version_under1p15",
         "_np_version_under1p16",
         "_np_version_under1p17",
+        "_np_version_under1p18",
+        "_testing",
         "_tslib",
         "_typing",
         "_version",
@@ -194,41 +206,126 @@ class TestPDApi(Base):
 
     def test_api(self):
 
-        self.check(
-            pd,
+        checkthese = (
             self.lib
             + self.misc
             + self.modules
-            + self.deprecated_modules
             + self.classes
-            + self.deprecated_classes
-            + self.deprecated_classes_in_future
             + self.funcs
             + self.funcs_option
             + self.funcs_read
+            + self.funcs_json
             + self.funcs_to
-            + self.deprecated_funcs_in_future
+            + self.private_modules
+        )
+        if not compat.PY37:
+            checkthese.extend(
+                self.deprecated_modules
+                + self.deprecated_classes
+                + self.deprecated_classes_in_future
+                + self.deprecated_funcs_in_future
+                + self.deprecated_funcs
+            )
+        self.check(pd, checkthese, self.ignored)
+
+    def test_depr(self):
+        deprecated_list = (
+            self.deprecated_modules
+            + self.deprecated_classes
+            + self.deprecated_classes_in_future
             + self.deprecated_funcs
-            + self.private_modules,
-            self.ignored,
+            + self.deprecated_funcs_in_future
         )
+        for depr in deprecated_list:
+            with tm.assert_produces_warning(FutureWarning):
+                deprecated = getattr(pd, depr)
+                if not compat.PY37:
+                    if depr == "datetime":
+                        deprecated.__getattr__(dir(pd.datetime.datetime)[-1])
+                    elif depr == "SparseArray":
+                        deprecated([])
+                    else:
+                        deprecated.__getattr__(dir(deprecated)[-1])
 
 
-class TestApi(Base):
+def test_datetime():
+    from datetime import datetime
+    import warnings
 
-    allowed = ["types", "extensions"]
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", FutureWarning)
+        assert datetime(2015, 1, 2, 0, 0) == pd.datetime(2015, 1, 2, 0, 0)
 
-    def test_api(self):
+        assert isinstance(pd.datetime(2015, 1, 2, 0, 0), pd.datetime)
 
+
+def test_sparsearray():
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", FutureWarning)
+        assert isinstance(pd.array([1, 2, 3], dtype="Sparse"), pd.SparseArray)
+
+
+def test_np():
+    import numpy as np
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", FutureWarning)
+        assert (pd.np.arange(0, 10) == np.arange(0, 10)).all()
+
+
+class TestApi(Base):
+    allowed = ["types", "extensions", "indexers"]
+
+    def test_api(self):
         self.check(api, self.allowed)
 
 
 class TestTesting(Base):
-
-    funcs = ["assert_frame_equal", "assert_series_equal", "assert_index_equal"]
+    funcs = [
+        "assert_frame_equal",
+        "assert_series_equal",
+        "assert_index_equal",
+        "assert_extension_array_equal",
+    ]
 
     def test_testing(self):
-
         from pandas import testing
 
         self.check(testing, self.funcs)
+
+    def test_util_testing_deprecated(self):
+        # avoid cache state affecting the test
+        sys.modules.pop("pandas.util.testing", None)
+
+        with tm.assert_produces_warning(FutureWarning) as m:
+            import pandas.util.testing  # noqa: F401
+
+        assert "pandas.util.testing is deprecated" in str(m[0].message)
+        assert "pandas.testing instead" in str(m[0].message)
+
+    def test_util_testing_deprecated_direct(self):
+        # avoid cache state affecting the test
+        sys.modules.pop("pandas.util.testing", None)
+        with tm.assert_produces_warning(FutureWarning) as m:
+            from pandas.util.testing import assert_series_equal  # noqa: F401
+
+        assert "pandas.util.testing is deprecated" in str(m[0].message)
+        assert "pandas.testing instead" in str(m[0].message)
+
+    def test_util_in_top_level(self):
+        # in a subprocess to avoid import caching issues
+        out = subprocess.check_output(
+            [
+                sys.executable,
+                "-c",
+                "import pandas; pandas.util.testing.assert_series_equal",
+            ],
+            stderr=subprocess.STDOUT,
+        ).decode()
+        assert "pandas.util.testing is deprecated" in out
+
+        with pytest.raises(AttributeError, match="foo"):
+            pd.util.foo
diff --git a/pandas/tests/api/test_types.py b/pandas/tests/api/test_types.py
index e2ff77715e301..31423c03dee34 100644
--- a/pandas/tests/api/test_types.py
+++ b/pandas/tests/api/test_types.py
@@ -1,5 +1,5 @@
+import pandas._testing as tm
 from pandas.api import types
-from pandas.util import testing as tm
 
 from .test_api import Base
 
@@ -18,7 +18,6 @@ class TestTypes(Base):
         "is_datetime64_ns_dtype",
         "is_datetime64tz_dtype",
         "is_dtype_equal",
-        "is_extension_type",
         "is_float",
         "is_float_dtype",
         "is_int64_dtype",
@@ -51,7 +50,7 @@ class TestTypes(Base):
         "infer_dtype",
         "is_extension_array_dtype",
     ]
-    deprecated = ["is_period", "is_datetimetz"]
+    deprecated = ["is_extension_type"]
     dtypes = ["CategoricalDtype", "DatetimeTZDtype", "PeriodDtype", "IntervalDtype"]
 
     def test_types(self):
diff --git a/pandas/tests/arithmetic/common.py b/pandas/tests/arithmetic/common.py
new file mode 100644
index 0000000000000..83d19b8a20ac3
--- /dev/null
+++ b/pandas/tests/arithmetic/common.py
@@ -0,0 +1,89 @@
+"""
+Assertion helpers for arithmetic tests.
+"""
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Index, Series
+import pandas._testing as tm
+
+
+def assert_invalid_addsub_type(left, right, msg=None):
+    """
+    Helper to assert that left and right can be neither added nor subtracted.
+
+    Parameters
+    ---------
+    left : object
+    right : object
+    msg : str or None, default None
+    """
+    with pytest.raises(TypeError, match=msg):
+        left + right
+    with pytest.raises(TypeError, match=msg):
+        right + left
+    with pytest.raises(TypeError, match=msg):
+        left - right
+    with pytest.raises(TypeError, match=msg):
+        right - left
+
+
+def get_upcast_box(box, vector):
+    """
+    Given two box-types, find the one that takes priority
+    """
+    if box is DataFrame or isinstance(vector, DataFrame):
+        return DataFrame
+    if box is Series or isinstance(vector, Series):
+        return Series
+    if box is Index or isinstance(vector, Index):
+        return Index
+    return box
+
+
+def assert_invalid_comparison(left, right, box):
+    """
+    Assert that comparison operations with mismatched types behave correctly.
+
+    Parameters
+    ----------
+    left : np.ndarray, ExtensionArray, Index, or Series
+    right : object
+    box : {pd.DataFrame, pd.Series, pd.Index, tm.to_array}
+    """
+    # Not for tznaive-tzaware comparison
+
+    # Note: not quite the same as how we do this for tm.box_expected
+    xbox = box if box is not Index else np.array
+
+    result = left == right
+    expected = xbox(np.zeros(result.shape, dtype=np.bool_))
+
+    tm.assert_equal(result, expected)
+
+    result = right == left
+    tm.assert_equal(result, expected)
+
+    result = left != right
+    tm.assert_equal(result, ~expected)
+
+    result = right != left
+    tm.assert_equal(result, ~expected)
+
+    msg = "Invalid comparison between|Cannot compare type|not supported between"
+    with pytest.raises(TypeError, match=msg):
+        left < right
+    with pytest.raises(TypeError, match=msg):
+        left <= right
+    with pytest.raises(TypeError, match=msg):
+        left > right
+    with pytest.raises(TypeError, match=msg):
+        left >= right
+    with pytest.raises(TypeError, match=msg):
+        right < left
+    with pytest.raises(TypeError, match=msg):
+        right <= left
+    with pytest.raises(TypeError, match=msg):
+        right > left
+    with pytest.raises(TypeError, match=msg):
+        right >= left
diff --git a/pandas/tests/arithmetic/conftest.py b/pandas/tests/arithmetic/conftest.py
index 774ff14398bdb..577093c0f2967 100644
--- a/pandas/tests/arithmetic/conftest.py
+++ b/pandas/tests/arithmetic/conftest.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 # ------------------------------------------------------------------
 # Helper Functions
@@ -21,7 +21,24 @@ def id_func(x):
 
 @pytest.fixture(params=[1, np.array(1, dtype=np.int64)])
 def one(request):
-    # zero-dim integer array behaves like an integer
+    """
+    Several variants of integer value 1. The zero-dim integer array
+    behaves like an integer.
+
+    This fixture can be used to check that datetimelike indexes handle
+    addition and subtraction of integers and zero-dimensional arrays
+    of integers.
+
+    Examples
+    --------
+    >>> dti = pd.date_range('2016-01-01', periods=2, freq='H')
+    >>> dti
+    DatetimeIndex(['2016-01-01 00:00:00', '2016-01-01 01:00:00'],
+    dtype='datetime64[ns]', freq='H')
+    >>> dti + one
+    DatetimeIndex(['2016-01-01 01:00:00', '2016-01-01 02:00:00'],
+    dtype='datetime64[ns]', freq='H')
+    """
     return request.param
 
 
@@ -40,8 +57,21 @@ def one(request):
 
 @pytest.fixture(params=zeros)
 def zero(request):
-    # For testing division by (or of) zero for Index with length 5, this
-    # gives several scalar-zeros and length-5 vector-zeros
+    """
+    Several types of scalar zeros and length 5 vectors of zeros.
+
+    This fixture can be used to check that numeric-dtype indexes handle
+    division by any zero numeric-dtype.
+
+    Uses vector of length 5 for broadcasting with `numeric_idx` fixture,
+    which creates numeric-dtype vectors also of length 5.
+
+    Examples
+    --------
+    >>> arr = pd.RangeIndex(5)
+    >>> arr / zeros
+    Float64Index([nan, inf, inf, inf, inf], dtype='float64')
+    """
     return request.param
 
 
@@ -205,25 +235,6 @@ def box_df_fail(request):
     return request.param
 
 
-@pytest.fixture(
-    params=[
-        (pd.Index, False),
-        (pd.Series, False),
-        (pd.DataFrame, False),
-        pytest.param((pd.DataFrame, True), marks=pytest.mark.xfail),
-        (tm.to_array, False),
-    ],
-    ids=id_func,
-)
-def box_transpose_fail(request):
-    """
-    Fixture similar to `box` but testing both transpose cases for DataFrame,
-    with the tranpose=True case xfailed.
-    """
-    # GH#23620
-    return request.param
-
-
 @pytest.fixture(params=[pd.Index, pd.Series, pd.DataFrame, tm.to_array], ids=id_func)
 def box_with_array(request):
     """
diff --git a/pandas/tests/arithmetic/test_array_ops.py b/pandas/tests/arithmetic/test_array_ops.py
new file mode 100644
index 0000000000000..d8aaa3183a1c6
--- /dev/null
+++ b/pandas/tests/arithmetic/test_array_ops.py
@@ -0,0 +1,21 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas._testing as tm
+from pandas.core.ops.array_ops import na_logical_op
+
+
+def test_na_logical_op_2d():
+    left = np.arange(8).reshape(4, 2)
+    right = left.astype(object)
+    right[0, 0] = np.nan
+
+    # Check that we fall back to the vec_binop branch
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        operator.or_(left, right)
+
+    result = na_logical_op(left, right, operator.or_)
+    expected = right
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index bc7b979d2c7d0..d3f9ac4f3f8b2 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -13,7 +13,7 @@
 from pandas._libs.tslibs.conversion import localize_pydatetime
 from pandas._libs.tslibs.offsets import shift_months
 from pandas.compat.numpy import np_datetime64_compat
-from pandas.errors import NullFrequencyError, PerformanceWarning
+from pandas.errors import PerformanceWarning
 
 import pandas as pd
 from pandas import (
@@ -26,68 +26,13 @@
     Timestamp,
     date_range,
 )
-from pandas.core.indexes.datetimes import _to_M8
-import pandas.util.testing as tm
-
-
-def assert_invalid_comparison(left, right, box):
-    """
-    Assert that comparison operations with mismatched types behave correctly.
-
-    Parameters
-    ----------
-    left : np.ndarray, ExtensionArray, Index, or Series
-    right : object
-    box : {pd.DataFrame, pd.Series, pd.Index, tm.to_array}
-    """
-    # Not for tznaive-tzaware comparison
-
-    # Note: not quite the same as how we do this for tm.box_expected
-    xbox = box if box is not pd.Index else np.array
-
-    result = left == right
-    expected = xbox(np.zeros(result.shape, dtype=np.bool_))
-
-    tm.assert_equal(result, expected)
-
-    result = right == left
-    tm.assert_equal(result, expected)
-
-    result = left != right
-    tm.assert_equal(result, ~expected)
-
-    result = right != left
-    tm.assert_equal(result, ~expected)
-
-    msg = "Invalid comparison between"
-    with pytest.raises(TypeError, match=msg):
-        left < right
-    with pytest.raises(TypeError, match=msg):
-        left <= right
-    with pytest.raises(TypeError, match=msg):
-        left > right
-    with pytest.raises(TypeError, match=msg):
-        left >= right
-    with pytest.raises(TypeError, match=msg):
-        right < left
-    with pytest.raises(TypeError, match=msg):
-        right <= left
-    with pytest.raises(TypeError, match=msg):
-        right > left
-    with pytest.raises(TypeError, match=msg):
-        right >= left
-
-
-def assert_all(obj):
-    """
-    Test helper to call call obj.all() the appropriate number of times on
-    a Series or DataFrame.
-    """
-    if isinstance(obj, pd.DataFrame):
-        assert obj.all().all()
-    else:
-        assert obj.all()
-
+import pandas._testing as tm
+from pandas.core.ops import roperator
+from pandas.tests.arithmetic.common import (
+    assert_invalid_addsub_type,
+    assert_invalid_comparison,
+    get_upcast_box,
+)
 
 # ------------------------------------------------------------------
 # Comparisons
@@ -113,19 +58,24 @@ def test_compare_zerodim(self, tz_naive_fixture, box_with_array):
         expected = tm.box_expected(expected, xbox)
         tm.assert_equal(result, expected)
 
-    def test_dt64arr_cmp_date_invalid(self, tz_naive_fixture, box_with_array):
-        # GH#19800, GH#19301 datetime.date comparison raises to
-        #  match DatetimeIndex/Timestamp.  This also matches the behavior
-        #  of stdlib datetime.datetime
-        tz = tz_naive_fixture
-
-        dti = pd.date_range("20010101", periods=10, tz=tz)
-        date = dti[0].to_pydatetime().date()
-
-        dtarr = tm.box_expected(dti, box_with_array)
-        assert_invalid_comparison(dtarr, date, box_with_array)
-
-    @pytest.mark.parametrize("other", ["foo", -1, 99, 4.0, object(), timedelta(days=2)])
+    @pytest.mark.parametrize(
+        "other",
+        [
+            "foo",
+            -1,
+            99,
+            4.0,
+            object(),
+            timedelta(days=2),
+            # GH#19800, GH#19301 datetime.date comparison raises to
+            #  match DatetimeIndex/Timestamp.  This also matches the behavior
+            #  of stdlib datetime.datetime
+            datetime(2001, 1, 1).date(),
+            # GH#19301 None and NaN are *not* cast to NaT for comparisons
+            None,
+            np.nan,
+        ],
+    )
     def test_dt64arr_cmp_scalar_invalid(self, other, tz_naive_fixture, box_with_array):
         # GH#22074, GH#15966
         tz = tz_naive_fixture
@@ -134,15 +84,51 @@ def test_dt64arr_cmp_scalar_invalid(self, other, tz_naive_fixture, box_with_arra
         dtarr = tm.box_expected(rng, box_with_array)
         assert_invalid_comparison(dtarr, other, box_with_array)
 
-    @pytest.mark.parametrize("other", [None, np.nan])
-    def test_dt64arr_cmp_na_scalar_invalid(
-        self, other, tz_naive_fixture, box_with_array
-    ):
-        # GH#19301
+    @pytest.mark.parametrize(
+        "other",
+        [
+            list(range(10)),
+            np.arange(10),
+            np.arange(10).astype(np.float32),
+            np.arange(10).astype(object),
+            pd.timedelta_range("1ns", periods=10).array,
+            np.array(pd.timedelta_range("1ns", periods=10)),
+            list(pd.timedelta_range("1ns", periods=10)),
+            pd.timedelta_range("1 Day", periods=10).astype(object),
+            pd.period_range("1971-01-01", freq="D", periods=10).array,
+            pd.period_range("1971-01-01", freq="D", periods=10).astype(object),
+        ],
+    )
+    def test_dt64arr_cmp_arraylike_invalid(self, other, tz_naive_fixture):
+        # We don't parametrize this over box_with_array because listlike
+        #  other plays poorly with assert_invalid_comparison reversed checks
         tz = tz_naive_fixture
-        dti = pd.date_range("2016-01-01", periods=2, tz=tz)
-        dtarr = tm.box_expected(dti, box_with_array)
-        assert_invalid_comparison(dtarr, other, box_with_array)
+
+        dta = date_range("1970-01-01", freq="ns", periods=10, tz=tz)._data
+        assert_invalid_comparison(dta, other, tm.to_array)
+
+    def test_dt64arr_cmp_mixed_invalid(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+
+        dta = date_range("1970-01-01", freq="h", periods=5, tz=tz)._data
+
+        other = np.array([0, 1, 2, dta[3], pd.Timedelta(days=1)])
+        result = dta == other
+        expected = np.array([False, False, False, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = dta != other
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        msg = "Invalid comparison between|Cannot compare type|not supported between"
+        with pytest.raises(TypeError, match=msg):
+            dta < other
+        with pytest.raises(TypeError, match=msg):
+            dta > other
+        with pytest.raises(TypeError, match=msg):
+            dta <= other
+        with pytest.raises(TypeError, match=msg):
+            dta >= other
 
     def test_dt64arr_nat_comparison(self, tz_naive_fixture, box_with_array):
         # GH#22242, GH#22163 DataFrame considered NaT == ts incorrectly
@@ -185,9 +171,9 @@ class TestDatetime64SeriesComparison:
         ],
     )
     @pytest.mark.parametrize("reverse", [True, False])
-    @pytest.mark.parametrize("box", [Series, pd.Index])
     @pytest.mark.parametrize("dtype", [None, object])
-    def test_nat_comparisons(self, dtype, box, reverse, pair):
+    def test_nat_comparisons(self, dtype, index_or_series, reverse, pair):
+        box = index_or_series
         l, r = pair
         if reverse:
             # add lhs / rhs switched data
@@ -269,15 +255,10 @@ def test_nat_comparisons_scalar(self, dtype, data, box_with_array):
         tm.assert_equal(left >= NaT, expected)
         tm.assert_equal(NaT <= left, expected)
 
-    def test_series_comparison_scalars(self):
+    @pytest.mark.parametrize("val", [datetime(2000, 1, 4), datetime(2000, 1, 5)])
+    def test_series_comparison_scalars(self, val):
         series = Series(date_range("1/1/2000", periods=10))
 
-        val = datetime(2000, 1, 4)
-        result = series > val
-        expected = Series([x > val for x in series])
-        tm.assert_series_equal(result, expected)
-
-        val = series[5]
         result = series > val
         expected = Series([x > val for x in series])
         tm.assert_series_equal(result, expected)
@@ -359,7 +340,7 @@ class TestDatetimeIndexComparisons:
     def test_comparators(self, op):
         index = tm.makeDateIndex(100)
         element = index[len(index) // 2]
-        element = _to_M8(element)
+        element = Timestamp(element).to_datetime64()
 
         arr = np.array(index)
         arr_result = op(arr, element)
@@ -578,17 +559,17 @@ def test_comparison_tzawareness_compat(self, op, box_df_fail):
             op(dz, np.array(list(dr), dtype=object))
 
         # The aware==aware and naive==naive comparisons should *not* raise
-        assert_all(dr == dr)
-        assert_all(dr == list(dr))
-        assert_all(list(dr) == dr)
-        assert_all(np.array(list(dr), dtype=object) == dr)
-        assert_all(dr == np.array(list(dr), dtype=object))
-
-        assert_all(dz == dz)
-        assert_all(dz == list(dz))
-        assert_all(list(dz) == dz)
-        assert_all(np.array(list(dz), dtype=object) == dz)
-        assert_all(dz == np.array(list(dz), dtype=object))
+        assert np.all(dr == dr)
+        assert np.all(dr == list(dr))
+        assert np.all(list(dr) == dr)
+        assert np.all(np.array(list(dr), dtype=object) == dr)
+        assert np.all(dr == np.array(list(dr), dtype=object))
+
+        assert np.all(dz == dz)
+        assert np.all(dz == list(dz))
+        assert np.all(list(dz) == dz)
+        assert np.all(np.array(list(dz), dtype=object) == dz)
+        assert np.all(dz == np.array(list(dz), dtype=object))
 
     @pytest.mark.parametrize(
         "op",
@@ -606,12 +587,12 @@ def test_comparison_tzawareness_compat_scalars(self, op, box_with_array):
         ts = pd.Timestamp("2000-03-14 01:59")
         ts_tz = pd.Timestamp("2000-03-14 01:59", tz="Europe/Amsterdam")
 
-        assert_all(dr > ts)
+        assert np.all(dr > ts)
         msg = "Cannot compare tz-naive and tz-aware"
         with pytest.raises(TypeError, match=msg):
             op(dr, ts_tz)
 
-        assert_all(dz > ts_tz)
+        assert np.all(dz > ts_tz)
         with pytest.raises(TypeError, match=msg):
             op(dz, ts)
 
@@ -898,7 +879,7 @@ def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array):
 
         result = dtarr - tdarr
         tm.assert_equal(result, expected)
-        msg = "cannot subtract|bad operand type for unary -"
+        msg = "cannot subtract|(bad|unsupported) operand type for unary"
         with pytest.raises(TypeError, match=msg):
             tdarr - dtarr
 
@@ -1031,25 +1012,28 @@ def test_dt64arr_add_timestamp_raises(self, box_with_array):
     # -------------------------------------------------------------
     # Other Invalid Addition/Subtraction
 
-    @pytest.mark.parametrize("other", [3.14, np.array([2.0, 3.0])])
-    def test_dt64arr_add_sub_float(self, other, box_with_array):
-        dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq="D")
+    @pytest.mark.parametrize(
+        "other",
+        [
+            3.14,
+            np.array([2.0, 3.0]),
+            # GH#13078 datetime +/- Period is invalid
+            pd.Period("2011-01-01", freq="D"),
+        ],
+    )
+    @pytest.mark.parametrize("dti_freq", [None, "D"])
+    def test_dt64arr_add_sub_invalid(self, dti_freq, other, box_with_array):
+        dti = DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq)
         dtarr = tm.box_expected(dti, box_with_array)
         msg = "|".join(
             [
                 "unsupported operand type",
                 "cannot (add|subtract)",
+                "cannot use operands with types",
                 "ufunc '?(add|subtract)'? cannot use operands with types",
             ]
         )
-        with pytest.raises(TypeError, match=msg):
-            dtarr + other
-        with pytest.raises(TypeError, match=msg):
-            other + dtarr
-        with pytest.raises(TypeError, match=msg):
-            dtarr - other
-        with pytest.raises(TypeError, match=msg):
-            other - dtarr
+        assert_invalid_addsub_type(dtarr, other, msg)
 
     @pytest.mark.parametrize("pi_freq", ["D", "W", "Q", "H"])
     @pytest.mark.parametrize("dti_freq", [None, "D"])
@@ -1070,32 +1054,7 @@ def test_dt64arr_add_sub_parr(
                 "ufunc.*cannot use operands",
             ]
         )
-        with pytest.raises(TypeError, match=msg):
-            dtarr + parr
-        with pytest.raises(TypeError, match=msg):
-            parr + dtarr
-        with pytest.raises(TypeError, match=msg):
-            dtarr - parr
-        with pytest.raises(TypeError, match=msg):
-            parr - dtarr
-
-    @pytest.mark.parametrize("dti_freq", [None, "D"])
-    def test_dt64arr_add_sub_period_scalar(self, dti_freq, box_with_array):
-        # GH#13078
-        # not supported, check TypeError
-        per = pd.Period("2011-01-01", freq="D")
-
-        idx = pd.DatetimeIndex(["2011-01-01", "2011-01-02"], freq=dti_freq)
-        dtarr = tm.box_expected(idx, box_with_array)
-        msg = "|".join(["unsupported operand type", "cannot (add|subtract)"])
-        with pytest.raises(TypeError, match=msg):
-            dtarr + per
-        with pytest.raises(TypeError, match=msg):
-            per + dtarr
-        with pytest.raises(TypeError, match=msg):
-            dtarr - per
-        with pytest.raises(TypeError, match=msg):
-            per - dtarr
+        assert_invalid_addsub_type(dtarr, parr, msg)
 
 
 class TestDatetime64DateOffsetArithmetic:
@@ -1137,7 +1096,7 @@ def test_dt64arr_series_sub_tick_DateOffset(self, box_with_array):
 
         result2 = -pd.offsets.Second(5) + ser
         tm.assert_equal(result2, expected)
-        msg = "bad operand type for unary"
+        msg = "(bad|unsupported) operand type for unary"
         with pytest.raises(TypeError, match=msg):
             pd.offsets.Second(5) - ser
 
@@ -1231,7 +1190,7 @@ def test_dt64arr_add_sub_relativedelta_offsets(self, box_with_array):
             expected = DatetimeIndex([x - off for x in vec_items])
             expected = tm.box_expected(expected, box_with_array)
             tm.assert_equal(expected, vec - off)
-            msg = "bad operand type for unary"
+            msg = "(bad|unsupported) operand type for unary"
             with pytest.raises(TypeError, match=msg):
                 off - vec
 
@@ -1347,7 +1306,7 @@ def test_dt64arr_add_sub_DateOffsets(
             expected = DatetimeIndex([offset + x for x in vec_items])
             expected = tm.box_expected(expected, box_with_array)
             tm.assert_equal(expected, offset + vec)
-            msg = "bad operand type for unary"
+            msg = "(bad|unsupported) operand type for unary"
             with pytest.raises(TypeError, match=msg):
                 offset - vec
 
@@ -1417,7 +1376,7 @@ def test_dt64arr_add_mixed_offset_array(self, box_with_array):
         s = tm.box_expected(s, box_with_array)
 
         warn = None if box_with_array is pd.DataFrame else PerformanceWarning
-        with tm.assert_produces_warning(warn, clear=[pd.core.arrays.datetimelike]):
+        with tm.assert_produces_warning(warn):
             other = pd.Index([pd.offsets.DateOffset(years=1), pd.offsets.MonthEnd()])
             other = tm.box_expected(other, box_with_array)
             result = s + other
@@ -1446,7 +1405,7 @@ def test_dt64arr_add_sub_offset_ndarray(self, tz_naive_fixture, box_with_array):
         other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
 
         warn = None if box_with_array is pd.DataFrame else PerformanceWarning
-        with tm.assert_produces_warning(warn, clear=[pd.core.arrays.datetimelike]):
+        with tm.assert_produces_warning(warn):
             res = dtarr + other
         expected = DatetimeIndex(
             [dti[n] + other[n] for n in range(len(dti))], name=dti.name, freq="infer"
@@ -1454,11 +1413,11 @@ def test_dt64arr_add_sub_offset_ndarray(self, tz_naive_fixture, box_with_array):
         expected = tm.box_expected(expected, box_with_array)
         tm.assert_equal(res, expected)
 
-        with tm.assert_produces_warning(warn, clear=[pd.core.arrays.datetimelike]):
+        with tm.assert_produces_warning(warn):
             res2 = other + dtarr
         tm.assert_equal(res2, expected)
 
-        with tm.assert_produces_warning(warn, clear=[pd.core.arrays.datetimelike]):
+        with tm.assert_produces_warning(warn):
             res = dtarr - other
         expected = DatetimeIndex(
             [dti[n] - other[n] for n in range(len(dti))], name=dti.name, freq="infer"
@@ -1871,6 +1830,7 @@ def test_dt64_mul_div_numeric_invalid(self, one, dt64_series):
         with pytest.raises(TypeError, match=msg):
             one / dt64_series
 
+    # TODO: parametrize over box
     @pytest.mark.parametrize("op", ["__add__", "__radd__", "__sub__", "__rsub__"])
     @pytest.mark.parametrize("tz", [None, "Asia/Tokyo"])
     def test_dt64_series_add_intlike(self, tz, op):
@@ -1883,10 +1843,8 @@ def test_dt64_series_add_intlike(self, tz, op):
         method = getattr(ser, op)
         msg = "|".join(
             [
-                "incompatible type for a .* operation",
-                "cannot evaluate a numeric op",
-                "ufunc .* cannot use operands",
-                "cannot (add|subtract)",
+                "Addition/subtraction of integers and integer-arrays",
+                "cannot subtract .* from ndarray",
             ]
         )
         with pytest.raises(TypeError, match=msg):
@@ -1931,7 +1889,7 @@ def test_operators_datetimelike_with_timezones(self):
         result = dt1 - td1[0]
         exp = (dt1.dt.tz_localize(None) - td1[0]).dt.tz_localize(tz)
         tm.assert_series_equal(result, exp)
-        msg = "bad operand type for unary"
+        msg = "(bad|unsupported) operand type for unary"
         with pytest.raises(TypeError, match=msg):
             td1[0] - dt1
 
@@ -1968,38 +1926,20 @@ class TestDatetimeIndexArithmetic:
     # -------------------------------------------------------------
     # Binary operations DatetimeIndex and int
 
-    def test_dti_add_int(self, tz_naive_fixture, one):
+    def test_dti_addsub_int(self, tz_naive_fixture, one):
         # Variants of `one` for #19012
         tz = tz_naive_fixture
         rng = pd.date_range("2000-01-01 09:00", freq="H", periods=10, tz=tz)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = rng + one
-        expected = pd.date_range("2000-01-01 10:00", freq="H", periods=10, tz=tz)
-        tm.assert_index_equal(result, expected)
+        msg = "Addition/subtraction of integers"
 
-    def test_dti_iadd_int(self, tz_naive_fixture, one):
-        tz = tz_naive_fixture
-        rng = pd.date_range("2000-01-01 09:00", freq="H", periods=10, tz=tz)
-        expected = pd.date_range("2000-01-01 10:00", freq="H", periods=10, tz=tz)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(TypeError, match=msg):
+            rng + one
+        with pytest.raises(TypeError, match=msg):
             rng += one
-        tm.assert_index_equal(rng, expected)
-
-    def test_dti_sub_int(self, tz_naive_fixture, one):
-        tz = tz_naive_fixture
-        rng = pd.date_range("2000-01-01 09:00", freq="H", periods=10, tz=tz)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = rng - one
-        expected = pd.date_range("2000-01-01 08:00", freq="H", periods=10, tz=tz)
-        tm.assert_index_equal(result, expected)
-
-    def test_dti_isub_int(self, tz_naive_fixture, one):
-        tz = tz_naive_fixture
-        rng = pd.date_range("2000-01-01 09:00", freq="H", periods=10, tz=tz)
-        expected = pd.date_range("2000-01-01 08:00", freq="H", periods=10, tz=tz)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(TypeError, match=msg):
+            rng - one
+        with pytest.raises(TypeError, match=msg):
             rng -= one
-        tm.assert_index_equal(rng, expected)
 
     # -------------------------------------------------------------
     # __add__/__sub__ with integer arrays
@@ -2011,14 +1951,8 @@ def test_dti_add_intarray_tick(self, int_holder, freq):
         dti = pd.date_range("2016-01-01", periods=2, freq=freq)
         other = int_holder([4, -1])
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
-            result = dti + other
-        tm.assert_index_equal(result, expected)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = other + dti
-        tm.assert_index_equal(result, expected)
+        msg = "Addition/subtraction of integers|cannot subtract DatetimeArray from"
+        assert_invalid_addsub_type(dti, other, msg)
 
     @pytest.mark.parametrize("freq", ["W", "M", "MS", "Q"])
     @pytest.mark.parametrize("int_holder", [np.array, pd.Index])
@@ -2027,37 +1961,18 @@ def test_dti_add_intarray_non_tick(self, int_holder, freq):
         dti = pd.date_range("2016-01-01", periods=2, freq=freq)
         other = int_holder([4, -1])
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
-
-        # tm.assert_produces_warning does not handle cases where we expect
-        # two warnings, in this case PerformanceWarning and FutureWarning.
-        # Until that is fixed, we don't catch either
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            result = dti + other
-        tm.assert_index_equal(result, expected)
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            result = other + dti
-        tm.assert_index_equal(result, expected)
+        msg = "Addition/subtraction of integers|cannot subtract DatetimeArray from"
+        assert_invalid_addsub_type(dti, other, msg)
 
     @pytest.mark.parametrize("int_holder", [np.array, pd.Index])
     def test_dti_add_intarray_no_freq(self, int_holder):
         # GH#19959
         dti = pd.DatetimeIndex(["2016-01-01", "NaT", "2017-04-05 06:07:08"])
         other = int_holder([9, 4, -1])
-        nfmsg = "Cannot shift with no freq"
-        tmsg = "cannot subtract DatetimeArray from"
-        with pytest.raises(NullFrequencyError, match=nfmsg):
-            dti + other
-        with pytest.raises(NullFrequencyError, match=nfmsg):
-            other + dti
-        with pytest.raises(NullFrequencyError, match=nfmsg):
-            dti - other
-        with pytest.raises(TypeError, match=tmsg):
-            other - dti
+        msg = "|".join(
+            ["cannot subtract DatetimeArray from", "Addition/subtraction of integers"]
+        )
+        assert_invalid_addsub_type(dti, other, msg)
 
     # -------------------------------------------------------------
     # Binary operations DatetimeIndex and TimedeltaIndex/array
@@ -2179,16 +2094,16 @@ def test_dti_isub_tdi(self, tz_naive_fixture):
         ids=lambda x: type(x).__name__,
     )
     @pytest.mark.parametrize("tz", [None, "US/Eastern"])
-    def test_add_datetimelike_and_dti(self, addend, tz):
+    def test_add_datetimelike_and_dtarr(self, box_with_array, addend, tz):
         # GH#9631
         dti = DatetimeIndex(["2011-01-01", "2011-01-02"]).tz_localize(tz)
-        msg = (
-            "cannot add DatetimeArray and {0}".format(type(addend).__name__)
-        ).replace("DatetimeIndex", "DatetimeArray")
+        dtarr = tm.box_expected(dti, box_with_array)
+        msg = "cannot add DatetimeArray and"
+
         with pytest.raises(TypeError, match=msg):
-            dti + addend
+            dtarr + addend
         with pytest.raises(TypeError, match=msg):
-            addend + dti
+            addend + dtarr
 
     # -------------------------------------------------------------
 
@@ -2268,13 +2183,6 @@ def test_timedelta64_equal_timedelta_supported_ops(self, op):
 
         intervals = ["D", "h", "m", "s", "us"]
 
-        # TODO: unused
-        # npy16_mappings = {'D': 24 * 60 * 60 * 1000000,
-        #                   'h': 60 * 60 * 1000000,
-        #                   'm': 60 * 1000000,
-        #                   's': 1000000,
-        #                   'us': 1}
-
         def timedelta64(*args):
             # see casting notes in NumPy gh-12927
             return np.sum(list(starmap(np.timedelta64, zip(args, intervals))))
@@ -2417,82 +2325,57 @@ def test_dti_add_series(self, tz, names):
         result4 = index + ser.values
         tm.assert_index_equal(result4, expected)
 
+    @pytest.mark.parametrize("op", [operator.add, roperator.radd, operator.sub])
     @pytest.mark.parametrize(
         "names", [(None, None, None), ("foo", "bar", None), ("foo", "foo", "foo")]
     )
-    def test_dti_add_offset_index(self, tz_naive_fixture, names):
+    def test_dti_addsub_offset_arraylike(
+        self, tz_naive_fixture, names, op, index_or_series
+    ):
         # GH#18849, GH#19744
+        box = pd.Index
+        other_box = index_or_series
+
         tz = tz_naive_fixture
         dti = pd.date_range("2017-01-01", periods=2, tz=tz, name=names[0])
-        other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)], name=names[1])
+        other = other_box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)], name=names[1])
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res = dti + other
-        expected = DatetimeIndex(
-            [dti[n] + other[n] for n in range(len(dti))], name=names[2], freq="infer"
-        )
-        tm.assert_index_equal(res, expected)
+        xbox = get_upcast_box(box, other)
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res2 = other + dti
-        tm.assert_index_equal(res2, expected)
-
-    @pytest.mark.parametrize(
-        "names", [(None, None, None), ("foo", "bar", None), ("foo", "foo", "foo")]
-    )
-    def test_dti_sub_offset_index(self, tz_naive_fixture, names):
-        # GH#18824, GH#19744
-        tz = tz_naive_fixture
-        dti = pd.date_range("2017-01-01", periods=2, tz=tz, name=names[0])
-        other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)], name=names[1])
+        with tm.assert_produces_warning(PerformanceWarning):
+            res = op(dti, other)
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res = dti - other
         expected = DatetimeIndex(
-            [dti[n] - other[n] for n in range(len(dti))], name=names[2], freq="infer"
+            [op(dti[n], other[n]) for n in range(len(dti))], name=names[2], freq="infer"
         )
-        tm.assert_index_equal(res, expected)
+        expected = tm.box_expected(expected, xbox)
+        tm.assert_equal(res, expected)
 
-    @pytest.mark.parametrize(
-        "names", [(None, None, None), ("foo", "bar", None), ("foo", "foo", "foo")]
-    )
-    def test_dti_with_offset_series(self, tz_naive_fixture, names):
-        # GH#18849
+    @pytest.mark.parametrize("other_box", [pd.Index, np.array])
+    def test_dti_addsub_object_arraylike(
+        self, tz_naive_fixture, box_with_array, other_box
+    ):
         tz = tz_naive_fixture
-        dti = pd.date_range("2017-01-01", periods=2, tz=tz, name=names[0])
-        other = Series([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)], name=names[1])
 
-        expected_add = Series(
-            [dti[n] + other[n] for n in range(len(dti))], name=names[2]
-        )
+        dti = pd.date_range("2017-01-01", periods=2, tz=tz)
+        dtarr = tm.box_expected(dti, box_with_array)
+        other = other_box([pd.offsets.MonthEnd(), pd.Timedelta(days=4)])
+        xbox = get_upcast_box(box_with_array, other)
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res = dti + other
-        tm.assert_series_equal(res, expected_add)
+        expected = pd.DatetimeIndex(["2017-01-31", "2017-01-06"], tz=tz_naive_fixture)
+        expected = tm.box_expected(expected, xbox)
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res2 = other + dti
-        tm.assert_series_equal(res2, expected_add)
+        warn = None if box_with_array is pd.DataFrame else PerformanceWarning
+        with tm.assert_produces_warning(warn):
+            result = dtarr + other
+        tm.assert_equal(result, expected)
 
-        expected_sub = Series(
-            [dti[n] - other[n] for n in range(len(dti))], name=names[2]
-        )
+        expected = pd.DatetimeIndex(["2016-12-31", "2016-12-29"], tz=tz_naive_fixture)
+        expected = tm.box_expected(expected, xbox)
 
-        with tm.assert_produces_warning(
-            PerformanceWarning, clear=[pd.core.arrays.datetimelike]
-        ):
-            res3 = dti - other
-        tm.assert_series_equal(res3, expected_sub)
+        with tm.assert_produces_warning(warn):
+            result = dtarr - other
+        tm.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("years", [-1, 0, 1])
diff --git a/pandas/tests/arithmetic/test_interval.py b/pandas/tests/arithmetic/test_interval.py
new file mode 100644
index 0000000000000..f9e1a515277d5
--- /dev/null
+++ b/pandas/tests/arithmetic/test_interval.py
@@ -0,0 +1,273 @@
+import operator
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_list_like
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Index,
+    Interval,
+    IntervalIndex,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray
+
+
+@pytest.fixture(
+    params=[
+        (Index([0, 2, 4, 4]), Index([1, 3, 5, 8])),
+        (Index([0.0, 1.0, 2.0, np.nan]), Index([1.0, 2.0, 3.0, np.nan])),
+        (
+            timedelta_range("0 days", periods=3).insert(4, pd.NaT),
+            timedelta_range("1 day", periods=3).insert(4, pd.NaT),
+        ),
+        (
+            date_range("20170101", periods=3).insert(4, pd.NaT),
+            date_range("20170102", periods=3).insert(4, pd.NaT),
+        ),
+        (
+            date_range("20170101", periods=3, tz="US/Eastern").insert(4, pd.NaT),
+            date_range("20170102", periods=3, tz="US/Eastern").insert(4, pd.NaT),
+        ),
+    ],
+    ids=lambda x: str(x[0].dtype),
+)
+def left_right_dtypes(request):
+    """
+    Fixture for building an IntervalArray from various dtypes
+    """
+    return request.param
+
+
+@pytest.fixture
+def array(left_right_dtypes):
+    """
+    Fixture to generate an IntervalArray of various dtypes containing NA if possible
+    """
+    left, right = left_right_dtypes
+    return IntervalArray.from_arrays(left, right)
+
+
+def create_categorical_intervals(left, right, closed="right"):
+    return Categorical(IntervalIndex.from_arrays(left, right, closed))
+
+
+def create_series_intervals(left, right, closed="right"):
+    return Series(IntervalArray.from_arrays(left, right, closed))
+
+
+def create_series_categorical_intervals(left, right, closed="right"):
+    return Series(Categorical(IntervalIndex.from_arrays(left, right, closed)))
+
+
+class TestComparison:
+    @pytest.fixture(params=[operator.eq, operator.ne])
+    def op(self, request):
+        return request.param
+
+    @pytest.fixture(
+        params=[
+            IntervalArray.from_arrays,
+            IntervalIndex.from_arrays,
+            create_categorical_intervals,
+            create_series_intervals,
+            create_series_categorical_intervals,
+        ],
+        ids=[
+            "IntervalArray",
+            "IntervalIndex",
+            "Categorical[Interval]",
+            "Series[Interval]",
+            "Series[Categorical[Interval]]",
+        ],
+    )
+    def interval_constructor(self, request):
+        """
+        Fixture for all pandas native interval constructors.
+        To be used as the LHS of IntervalArray comparisons.
+        """
+        return request.param
+
+    def elementwise_comparison(self, op, array, other):
+        """
+        Helper that performs elementwise comparisions between `array` and `other`
+        """
+        other = other if is_list_like(other) else [other] * len(array)
+        return np.array([op(x, y) for x, y in zip(array, other)])
+
+    def test_compare_scalar_interval(self, op, array):
+        # matches first interval
+        other = array[0]
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # matches on a single endpoint but not both
+        other = Interval(array.left[0], array.right[1])
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_scalar_interval_mixed_closed(self, op, closed, other_closed):
+        array = IntervalArray.from_arrays(range(2), range(1, 3), closed=closed)
+        other = Interval(0, 1, closed=other_closed)
+
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_scalar_na(self, op, array, nulls_fixture):
+        result = op(array, nulls_fixture)
+        expected = self.elementwise_comparison(op, array, nulls_fixture)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "other",
+        [
+            0,
+            1.0,
+            True,
+            "foo",
+            Timestamp("2017-01-01"),
+            Timestamp("2017-01-01", tz="US/Eastern"),
+            Timedelta("0 days"),
+            Period("2017-01-01", "D"),
+        ],
+    )
+    def test_compare_scalar_other(self, op, array, other):
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_list_like_interval(
+        self, op, array, interval_constructor,
+    ):
+        # same endpoints
+        other = interval_constructor(array.left, array.right)
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # different endpoints
+        other = interval_constructor(array.left[::-1], array.right[::-1])
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # all nan endpoints
+        other = interval_constructor([np.nan] * 4, [np.nan] * 4)
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_list_like_interval_mixed_closed(
+        self, op, interval_constructor, closed, other_closed
+    ):
+        array = IntervalArray.from_arrays(range(2), range(1, 3), closed=closed)
+        other = interval_constructor(range(2), range(1, 3), closed=other_closed)
+
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "other",
+        [
+            (
+                Interval(0, 1),
+                Interval(Timedelta("1 day"), Timedelta("2 days")),
+                Interval(4, 5, "both"),
+                Interval(10, 20, "neither"),
+            ),
+            (0, 1.5, Timestamp("20170103"), np.nan),
+            (
+                Timestamp("20170102", tz="US/Eastern"),
+                Timedelta("2 days"),
+                "baz",
+                pd.NaT,
+            ),
+        ],
+    )
+    def test_compare_list_like_object(self, op, array, other):
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_list_like_nan(self, op, array, nulls_fixture):
+        other = [nulls_fixture] * 4
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "other",
+        [
+            np.arange(4, dtype="int64"),
+            np.arange(4, dtype="float64"),
+            date_range("2017-01-01", periods=4),
+            date_range("2017-01-01", periods=4, tz="US/Eastern"),
+            timedelta_range("0 days", periods=4),
+            period_range("2017-01-01", periods=4, freq="D"),
+            Categorical(list("abab")),
+            Categorical(date_range("2017-01-01", periods=4)),
+            pd.array(list("abcd")),
+            pd.array(["foo", 3.14, None, object()]),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_compare_list_like_other(self, op, array, other):
+        result = op(array, other)
+        expected = self.elementwise_comparison(op, array, other)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("length", [1, 3, 5])
+    @pytest.mark.parametrize("other_constructor", [IntervalArray, list])
+    def test_compare_length_mismatch_errors(self, op, other_constructor, length):
+        array = IntervalArray.from_arrays(range(4), range(1, 5))
+        other = other_constructor([Interval(0, 1)] * length)
+        with pytest.raises(ValueError, match="Lengths must match to compare"):
+            op(array, other)
+
+    @pytest.mark.parametrize(
+        "constructor, expected_type, assert_func",
+        [
+            (IntervalIndex, np.array, tm.assert_numpy_array_equal),
+            (Series, Series, tm.assert_series_equal),
+        ],
+    )
+    def test_index_series_compat(self, op, constructor, expected_type, assert_func):
+        # IntervalIndex/Series that rely on IntervalArray for comparisons
+        breaks = range(4)
+        index = constructor(IntervalIndex.from_breaks(breaks))
+
+        # scalar comparisons
+        other = index[0]
+        result = op(index, other)
+        expected = expected_type(self.elementwise_comparison(op, index, other))
+        assert_func(result, expected)
+
+        other = breaks[0]
+        result = op(index, other)
+        expected = expected_type(self.elementwise_comparison(op, index, other))
+        assert_func(result, expected)
+
+        # list-like comparisons
+        other = IntervalArray.from_breaks(breaks)
+        result = op(index, other)
+        expected = expected_type(self.elementwise_comparison(op, index, other))
+        assert_func(result, expected)
+
+        other = [index[0], breaks[0], "foo"]
+        result = op(index, other)
+        expected = expected_type(self.elementwise_comparison(op, index, other))
+        assert_func(result, expected)
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index 584e22f8488f5..51d09a92773b1 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -5,14 +5,15 @@
 from decimal import Decimal
 from itertools import combinations
 import operator
+from typing import Any, List
 
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import Index, Series, Timedelta, TimedeltaIndex
+import pandas._testing as tm
 from pandas.core import ops
-import pandas.util.testing as tm
 
 
 def adjust_negative_zero(zero, expected):
@@ -30,6 +31,19 @@ def adjust_negative_zero(zero, expected):
     return expected
 
 
+# TODO: remove this kludge once mypy stops giving false positives here
+# List comprehension has incompatible type List[PandasObject]; expected List[RangeIndex]
+#  See GH#29725
+ser_or_index: List[Any] = [pd.Series, pd.Index]
+lefts: List[Any] = [pd.RangeIndex(10, 40, 10)]
+lefts.extend(
+    [
+        cls([10, 20, 30], dtype=dtype)
+        for dtype in ["i1", "i2", "i4", "i8", "u1", "u2", "u4", "u8", "f2", "f4", "f8"]
+        for cls in ser_or_index
+    ]
+)
+
 # ------------------------------------------------------------------
 # Comparisons
 
@@ -51,13 +65,16 @@ def test_df_numeric_cmp_dt64_raises(self):
         # GH#8932, GH#22163
         ts = pd.Timestamp.now()
         df = pd.DataFrame({"x": range(5)})
-        with pytest.raises(TypeError):
+
+        msg = "Invalid comparison between dtype=int64 and Timestamp"
+
+        with pytest.raises(TypeError, match=msg):
             df > ts
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             df < ts
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             ts < df
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             ts > df
 
         assert not (df == ts).any().any()
@@ -81,26 +98,7 @@ class TestNumericArraylikeArithmeticWithDatetimeLike:
     # TODO: also check name retentention
     @pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
     @pytest.mark.parametrize(
-        "left",
-        [pd.RangeIndex(10, 40, 10)]
-        + [
-            cls([10, 20, 30], dtype=dtype)
-            for dtype in [
-                "i1",
-                "i2",
-                "i4",
-                "i8",
-                "u1",
-                "u2",
-                "u4",
-                "u8",
-                "f2",
-                "f4",
-                "f8",
-            ]
-            for cls in [pd.Series, pd.Index]
-        ],
-        ids=lambda x: type(x).__name__ + str(x.dtype),
+        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
     )
     def test_mul_td64arr(self, left, box_cls):
         # GH#22390
@@ -120,26 +118,7 @@ def test_mul_td64arr(self, left, box_cls):
     # TODO: also check name retentention
     @pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
     @pytest.mark.parametrize(
-        "left",
-        [pd.RangeIndex(10, 40, 10)]
-        + [
-            cls([10, 20, 30], dtype=dtype)
-            for dtype in [
-                "i1",
-                "i2",
-                "i4",
-                "i8",
-                "u1",
-                "u2",
-                "u4",
-                "u8",
-                "f2",
-                "f4",
-                "f8",
-            ]
-            for cls in [pd.Series, pd.Index]
-        ],
-        ids=lambda x: type(x).__name__ + str(x.dtype),
+        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
     )
     def test_div_td64arr(self, left, box_cls):
         # GH#22390
@@ -156,10 +135,11 @@ def test_div_td64arr(self, left, box_cls):
         result = right // left
         tm.assert_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "Cannot divide"
+        with pytest.raises(TypeError, match=msg):
             left / right
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             left // right
 
     # TODO: de-duplicate with test_numeric_arr_mul_tdscalar
@@ -197,6 +177,28 @@ def test_numeric_arr_mul_tdscalar(self, scalar_td, numeric_idx, box):
         commute = scalar_td * index
         tm.assert_equal(commute, expected)
 
+    @pytest.mark.parametrize(
+        "scalar_td",
+        [
+            Timedelta(days=1),
+            Timedelta(days=1).to_timedelta64(),
+            Timedelta(days=1).to_pytimedelta(),
+        ],
+        ids=lambda x: type(x).__name__,
+    )
+    def test_numeric_arr_mul_tdscalar_numexpr_path(self, scalar_td, box):
+        arr = np.arange(2 * 10 ** 4).astype(np.int64)
+        obj = tm.box_expected(arr, box, transpose=False)
+
+        expected = arr.view("timedelta64[D]").astype("timedelta64[ns]")
+        expected = tm.box_expected(expected, box, transpose=False)
+
+        result = obj * scalar_td
+        tm.assert_equal(result, expected)
+
+        result = scalar_td * obj
+        tm.assert_equal(result, expected)
+
     def test_numeric_arr_rdiv_tdscalar(self, three_days, numeric_idx, box):
         index = numeric_idx[1:3]
 
@@ -208,7 +210,8 @@ def test_numeric_arr_rdiv_tdscalar(self, three_days, numeric_idx, box):
         result = three_days / index
         tm.assert_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "cannot use operands with types dtype"
+        with pytest.raises(TypeError, match=msg):
             index / three_days
 
     @pytest.mark.parametrize(
@@ -226,13 +229,19 @@ def test_numeric_arr_rdiv_tdscalar(self, three_days, numeric_idx, box):
     )
     def test_add_sub_timedeltalike_invalid(self, numeric_idx, other, box):
         left = tm.box_expected(numeric_idx, box)
-        with pytest.raises(TypeError):
+        msg = (
+            "unsupported operand type|"
+            "Addition/subtraction of integers and integer-arrays|"
+            "Instead of adding/subtracting|"
+            "cannot use operands with types dtype"
+        )
+        with pytest.raises(TypeError, match=msg):
             left + other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other + left
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             left - other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other - left
 
     @pytest.mark.parametrize(
@@ -250,13 +259,18 @@ def test_add_sub_datetimelike_invalid(self, numeric_idx, other, box):
         #  NullFrequencyError instead of TypeError so is excluded.
         left = tm.box_expected(numeric_idx, box)
 
-        with pytest.raises(TypeError):
+        msg = (
+            "unsupported operand type|"
+            "Cannot (add|subtract) NaT (to|from) ndarray|"
+            "Addition/subtraction of integers and integer-arrays"
+        )
+        with pytest.raises(TypeError, match=msg):
             left + other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other + left
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             left - other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other - left
 
 
@@ -628,14 +642,16 @@ def test_mul_index(self, numeric_idx):
 
     def test_mul_datelike_raises(self, numeric_idx):
         idx = numeric_idx
-        with pytest.raises(TypeError):
+        msg = "cannot perform __rmul__ with this index type"
+        with pytest.raises(TypeError, match=msg):
             idx * pd.date_range("20130101", periods=5)
 
     def test_mul_size_mismatch_raises(self, numeric_idx):
         idx = numeric_idx
-        with pytest.raises(ValueError):
+        msg = "operands could not be broadcast together"
+        with pytest.raises(ValueError, match=msg):
             idx * idx[0:3]
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=msg):
             idx * np.array([1, 2])
 
     @pytest.mark.parametrize("op", [operator.pow, ops.rpow])
@@ -813,10 +829,11 @@ def test_series_frame_radd_bug(self):
 
         # really raise this time
         now = pd.Timestamp.now().to_pydatetime()
-        with pytest.raises(TypeError):
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
             now + ts
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             ts + now
 
     # TODO: This came from series.test.test_operators, needs cleanup
@@ -837,7 +854,8 @@ def test_datetime64_with_index(self):
         result = ser - ser.index
         tm.assert_series_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "cannot subtract period"
+        with pytest.raises(TypeError, match=msg):
             # GH#18850
             result = ser - ser.index.to_period()
 
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
index f9c1de115b3a4..c0cb522b516ab 100644
--- a/pandas/tests/arithmetic/test_object.py
+++ b/pandas/tests/arithmetic/test_object.py
@@ -1,6 +1,7 @@
 # Arithmetic tests for DataFrame/Series/Index/Array classes that should
 # behave identically.
 # Specifically for object dtype
+import datetime
 from decimal import Decimal
 import operator
 
@@ -9,8 +10,8 @@
 
 import pandas as pd
 from pandas import Series, Timestamp
+import pandas._testing as tm
 from pandas.core import ops
-import pandas.util.testing as tm
 
 # ------------------------------------------------------------------
 # Comparisons
@@ -137,7 +138,13 @@ def test_objarr_radd_str_invalid(self, dtype, data, box_with_array):
         ser = Series(data, dtype=dtype)
 
         ser = tm.box_expected(ser, box_with_array)
-        with pytest.raises(TypeError):
+        msg = (
+            "can only concatenate str|"
+            "did not contain a loop with signature matching types|"
+            "unsupported operand type|"
+            "must be str"
+        )
+        with pytest.raises(TypeError, match=msg):
             "foo_" + ser
 
     @pytest.mark.parametrize("op", [operator.add, ops.radd, operator.sub, ops.rsub])
@@ -149,9 +156,10 @@ def test_objarr_add_invalid(self, op, box_with_array):
         obj_ser.name = "objects"
 
         obj_ser = tm.box_expected(obj_ser, box)
-        with pytest.raises(Exception):
+        msg = "can only concatenate str|unsupported operand type|must be str"
+        with pytest.raises(Exception, match=msg):
             op(obj_ser, 1)
-        with pytest.raises(Exception):
+        with pytest.raises(Exception, match=msg):
             op(obj_ser, np.array(1, dtype=np.int64))
 
     # TODO: Moved from tests.series.test_operators; needs cleanup
@@ -275,13 +283,15 @@ def test_add(self):
 
     def test_sub_fail(self):
         index = tm.makeStringIndex(100)
-        with pytest.raises(TypeError):
+
+        msg = "unsupported operand type|Cannot broadcast"
+        with pytest.raises(TypeError, match=msg):
             index - "a"
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index - index
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index - index.tolist()
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index.tolist() - index
 
     def test_sub_object(self):
@@ -295,10 +305,11 @@ def test_sub_object(self):
         result = index - pd.Index([Decimal(1), Decimal(1)])
         tm.assert_index_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
             index - "foo"
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index - np.array([2, "foo"])
 
     def test_rsub_object(self):
@@ -312,8 +323,54 @@ def test_rsub_object(self):
         result = np.array([Decimal(2), Decimal(2)]) - index
         tm.assert_index_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
             "foo" - index
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             np.array([True, pd.Timestamp.now()]) - index
+
+
+class MyIndex(pd.Index):
+    # Simple index subclass that tracks ops calls.
+
+    _calls: int
+
+    @classmethod
+    def _simple_new(cls, values, name=None, dtype=None):
+        result = object.__new__(cls)
+        result._data = values
+        result._index_data = values
+        result._name = name
+        result._calls = 0
+
+        return result._reset_identity()
+
+    def __add__(self, other):
+        self._calls += 1
+        return self._simple_new(self._index_data)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        [datetime.timedelta(1), datetime.timedelta(2)],
+        [datetime.datetime(2000, 1, 1), datetime.datetime(2000, 1, 2)],
+        [pd.Period("2000"), pd.Period("2001")],
+        ["a", "b"],
+    ],
+    ids=["timedelta", "datetime", "period", "object"],
+)
+def test_index_ops_defer_to_unknown_subclasses(other):
+    # https://github.com/pandas-dev/pandas/issues/31109
+    values = np.array(
+        [datetime.date(2000, 1, 1), datetime.date(2000, 1, 2)], dtype=object
+    )
+    a = MyIndex._simple_new(values)
+    other = pd.Index(other)
+    result = other + a
+    assert isinstance(result, MyIndex)
+    assert a._calls == 1
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
index ed693d873efb8..4cf1988a33de1 100644
--- a/pandas/tests/arithmetic/test_period.py
+++ b/pandas/tests/arithmetic/test_period.py
@@ -11,12 +11,14 @@
 
 import pandas as pd
 from pandas import Period, PeriodIndex, Series, period_range
+import pandas._testing as tm
 from pandas.core import ops
 from pandas.core.arrays import TimedeltaArray
-import pandas.util.testing as tm
 
 from pandas.tseries.frequencies import to_offset
 
+from .common import assert_invalid_comparison
+
 # ------------------------------------------------------------------
 # Comparisons
 
@@ -39,11 +41,93 @@ def test_compare_zerodim(self, box_with_array):
         expected = tm.box_expected(expected, xbox)
         tm.assert_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "scalar", ["foo", pd.Timestamp.now(), pd.Timedelta(days=4)]
+    )
+    def test_compare_invalid_scalar(self, box_with_array, scalar):
+        # comparison with scalar that cannot be interpreted as a Period
+        pi = pd.period_range("2000", periods=4)
+        parr = tm.box_expected(pi, box_with_array)
+        assert_invalid_comparison(parr, scalar, box_with_array)
+
+    @pytest.mark.parametrize(
+        "other",
+        [
+            pd.date_range("2000", periods=4).array,
+            pd.timedelta_range("1D", periods=4).array,
+            np.arange(4),
+            np.arange(4).astype(np.float64),
+            list(range(4)),
+        ],
+    )
+    def test_compare_invalid_listlike(self, box_with_array, other):
+        pi = pd.period_range("2000", periods=4)
+        parr = tm.box_expected(pi, box_with_array)
+        assert_invalid_comparison(parr, other, box_with_array)
+
+    @pytest.mark.parametrize("other_box", [list, np.array, lambda x: x.astype(object)])
+    def test_compare_object_dtype(self, box_with_array, other_box):
+        pi = pd.period_range("2000", periods=5)
+        parr = tm.box_expected(pi, box_with_array)
+
+        xbox = np.ndarray if box_with_array is pd.Index else box_with_array
+
+        other = other_box(pi)
+
+        expected = np.array([True, True, True, True, True])
+        expected = tm.box_expected(expected, xbox)
+
+        result = parr == other
+        tm.assert_equal(result, expected)
+        result = parr <= other
+        tm.assert_equal(result, expected)
+        result = parr >= other
+        tm.assert_equal(result, expected)
+
+        result = parr != other
+        tm.assert_equal(result, ~expected)
+        result = parr < other
+        tm.assert_equal(result, ~expected)
+        result = parr > other
+        tm.assert_equal(result, ~expected)
+
+        other = other_box(pi[::-1])
+
+        expected = np.array([False, False, True, False, False])
+        expected = tm.box_expected(expected, xbox)
+        result = parr == other
+        tm.assert_equal(result, expected)
+
+        expected = np.array([True, True, True, False, False])
+        expected = tm.box_expected(expected, xbox)
+        result = parr <= other
+        tm.assert_equal(result, expected)
+
+        expected = np.array([False, False, True, True, True])
+        expected = tm.box_expected(expected, xbox)
+        result = parr >= other
+        tm.assert_equal(result, expected)
+
+        expected = np.array([True, True, False, True, True])
+        expected = tm.box_expected(expected, xbox)
+        result = parr != other
+        tm.assert_equal(result, expected)
+
+        expected = np.array([True, True, False, False, False])
+        expected = tm.box_expected(expected, xbox)
+        result = parr < other
+        tm.assert_equal(result, expected)
+
+        expected = np.array([False, False, False, True, True])
+        expected = tm.box_expected(expected, xbox)
+        result = parr > other
+        tm.assert_equal(result, expected)
+
 
 class TestPeriodIndexComparisons:
     # TODO: parameterize over boxes
 
-    @pytest.mark.parametrize("other", ["2017", 2017])
+    @pytest.mark.parametrize("other", ["2017", pd.Period("2017", freq="D")])
     def test_eq(self, other):
         idx = PeriodIndex(["2017", "2017", "2018"], freq="D")
         expected = np.array([True, True, False])
@@ -51,6 +135,37 @@ def test_eq(self, other):
 
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "other",
+        [
+            2017,
+            [2017, 2017, 2017],
+            np.array([2017, 2017, 2017]),
+            np.array([2017, 2017, 2017], dtype=object),
+            pd.Index([2017, 2017, 2017]),
+        ],
+    )
+    def test_eq_integer_disallowed(self, other):
+        # match Period semantics by not treating integers as Periods
+
+        idx = PeriodIndex(["2017", "2017", "2018"], freq="D")
+        expected = np.array([False, False, False])
+        result = idx == other
+
+        tm.assert_numpy_array_equal(result, expected)
+        msg = (
+            r"(:?Invalid comparison between dtype=period\[D\] and .*)"
+            r"|(:?Cannot compare type Period with type .*)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            idx < other
+        with pytest.raises(TypeError, match=msg):
+            idx > other
+        with pytest.raises(TypeError, match=msg):
+            idx <= other
+        with pytest.raises(TypeError, match=msg):
+            idx >= other
+
     def test_pi_cmp_period(self):
         idx = period_range("2007-01", periods=20, freq="M")
 
@@ -168,9 +283,7 @@ def test_parr_cmp_pi_mismatched_freq_raises(self, freq, box_with_array):
 
         # TODO: Could parametrize over boxes for idx?
         idx = PeriodIndex(["2011", "2012", "2013", "2014"], freq="A")
-        rev_msg = (
-            r"Input has different freq=(M|2M|3M) from " r"PeriodArray\(freq=A-DEC\)"
-        )
+        rev_msg = r"Input has different freq=(M|2M|3M) from PeriodArray\(freq=A-DEC\)"
         idx_msg = rev_msg if box_with_array is tm.to_array else msg
         with pytest.raises(IncompatibleFrequency, match=idx_msg):
             base <= idx
@@ -184,7 +297,7 @@ def test_parr_cmp_pi_mismatched_freq_raises(self, freq, box_with_array):
             Period("2011", freq="4M") >= base
 
         idx = PeriodIndex(["2011", "2012", "2013", "2014"], freq="4M")
-        rev_msg = r"Input has different freq=(M|2M|3M) from " r"PeriodArray\(freq=4M\)"
+        rev_msg = r"Input has different freq=(M|2M|3M) from PeriodArray\(freq=4M\)"
         idx_msg = rev_msg if box_with_array is tm.to_array else msg
         with pytest.raises(IncompatibleFrequency, match=idx_msg):
             base <= idx
@@ -477,10 +590,11 @@ def test_parr_add_iadd_parr_raises(self, box_with_array):
         # a set operation (union).  This has since been changed to
         # raise a TypeError. See GH#14164 and GH#13077 for historical
         # reference.
-        with pytest.raises(TypeError):
+        msg = r"unsupported operand type\(s\) for \+: .* and .*"
+        with pytest.raises(TypeError, match=msg):
             rng + other
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             rng += other
 
     def test_pi_sub_isub_pi(self):
@@ -515,7 +629,8 @@ def test_parr_sub_pi_mismatched_freq(self, box_with_array):
         # TODO: parametrize over boxes for other?
 
         rng = tm.box_expected(rng, box_with_array)
-        with pytest.raises(IncompatibleFrequency):
+        msg = r"Input has different freq=[HD] from PeriodArray\(freq=[DH]\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
             rng - other
 
     @pytest.mark.parametrize("n", [1, 2, 3, 4])
@@ -567,7 +682,8 @@ def test_parr_add_sub_float_raises(self, op, other, box_with_array):
         dti = pd.DatetimeIndex(["2011-01-01", "2011-01-02"], freq="D")
         pi = dti.to_period("D")
         pi = tm.box_expected(pi, box_with_array)
-        with pytest.raises(TypeError):
+        msg = r"unsupported operand type\(s\) for [+-]: .* and .*"
+        with pytest.raises(TypeError, match=msg):
             op(pi, other)
 
     @pytest.mark.parametrize(
@@ -590,13 +706,18 @@ def test_parr_add_sub_invalid(self, other, box_with_array):
         rng = pd.period_range("1/1/2000", freq="D", periods=3)
         rng = tm.box_expected(rng, box_with_array)
 
-        with pytest.raises(TypeError):
+        msg = (
+            r"(:?cannot add PeriodArray and .*)"
+            r"|(:?cannot subtract .* from (:?a\s)?.*)"
+            r"|(:?unsupported operand type\(s\) for \+: .* and .*)"
+        )
+        with pytest.raises(TypeError, match=msg):
             rng + other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other + rng
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             rng - other
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             other - rng
 
     # -----------------------------------------------------------------
@@ -607,14 +728,16 @@ def test_pi_add_sub_td64_array_non_tick_raises(self):
         tdi = pd.TimedeltaIndex(["-1 Day", "-1 Day", "-1 Day"])
         tdarr = tdi.values
 
-        with pytest.raises(IncompatibleFrequency):
+        msg = r"Input has different freq=None from PeriodArray\(freq=Q-DEC\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
             rng + tdarr
-        with pytest.raises(IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             tdarr + rng
 
-        with pytest.raises(IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             rng - tdarr
-        with pytest.raises(TypeError):
+        msg = r"cannot subtract PeriodArray from timedelta64\[ns\]"
+        with pytest.raises(TypeError, match=msg):
             tdarr - rng
 
     def test_pi_add_sub_td64_array_tick(self):
@@ -641,10 +764,11 @@ def test_pi_add_sub_td64_array_tick(self):
         result = rng - tdarr
         tm.assert_index_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = r"cannot subtract .* from .*"
+        with pytest.raises(TypeError, match=msg):
             tdarr - rng
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             tdi - rng
 
     # -----------------------------------------------------------------
@@ -673,10 +797,11 @@ def test_pi_add_offset_array(self, box):
         unanchored = np.array([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)])
         # addition/subtraction ops with incompatible offsets should issue
         # a PerformanceWarning and _then_ raise a TypeError.
-        with pytest.raises(IncompatibleFrequency):
+        msg = r"Input cannot be converted to Period\(freq=Q-DEC\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 pi + unanchored
-        with pytest.raises(IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 unanchored + pi
 
@@ -701,10 +826,11 @@ def test_pi_sub_offset_array(self, box):
 
         # addition/subtraction ops with anchored offsets should issue
         # a PerformanceWarning and _then_ raise a TypeError.
-        with pytest.raises(IncompatibleFrequency):
+        msg = r"Input has different freq=-1M from Period\(freq=Q-DEC\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 pi - anchored
-        with pytest.raises(IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 anchored - pi
 
@@ -755,18 +881,18 @@ def test_pi_sub_isub_offset(self):
         rng -= pd.offsets.MonthEnd(5)
         tm.assert_index_equal(rng, expected)
 
-    def test_pi_add_offset_n_gt1(self, box_transpose_fail):
+    @pytest.mark.parametrize("transpose", [True, False])
+    def test_pi_add_offset_n_gt1(self, box_with_array, transpose):
         # GH#23215
         # add offset to PeriodIndex with freq.n > 1
-        box, transpose = box_transpose_fail
 
         per = pd.Period("2016-01", freq="2M")
         pi = pd.PeriodIndex([per])
 
         expected = pd.PeriodIndex(["2016-03"], freq="2M")
 
-        pi = tm.box_expected(pi, box, transpose=transpose)
-        expected = tm.box_expected(expected, box, transpose=transpose)
+        pi = tm.box_expected(pi, box_with_array, transpose=transpose)
+        expected = tm.box_expected(expected, box_with_array, transpose=transpose)
 
         result = pi + per.freq
         tm.assert_equal(result, expected)
@@ -814,7 +940,8 @@ def test_pi_sub_intarray(self, int_holder):
         expected = pd.PeriodIndex([pd.Period("2014Q1"), pd.Period("NaT")])
         tm.assert_index_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = r"bad operand type for unary -: 'PeriodArray'"
+        with pytest.raises(TypeError, match=msg):
             other - pi
 
     # ---------------------------------------------------------------
@@ -842,7 +969,11 @@ def test_pi_add_timedeltalike_minute_gt1(self, three_days):
         result = rng - other
         tm.assert_index_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = (
+            r"(:?bad operand type for unary -: 'PeriodArray')"
+            r"|(:?cannot subtract PeriodArray from timedelta64\[[hD]\])"
+        )
+        with pytest.raises(TypeError, match=msg):
             other - rng
 
     @pytest.mark.parametrize("freqstr", ["5ns", "5us", "5ms", "5s", "5T", "5h", "5d"])
@@ -864,8 +995,11 @@ def test_pi_add_timedeltalike_tick_gt1(self, three_days, freqstr):
         expected = pd.period_range(rng[0] - other, periods=6, freq=freqstr)
         result = rng - other
         tm.assert_index_equal(result, expected)
-
-        with pytest.raises(TypeError):
+        msg = (
+            r"(:?bad operand type for unary -: 'PeriodArray')"
+            r"|(:?cannot subtract PeriodArray from timedelta64\[[hD]\])"
+        )
+        with pytest.raises(TypeError, match=msg):
             other - rng
 
     def test_pi_add_iadd_timedeltalike_daily(self, three_days):
@@ -984,16 +1118,15 @@ def test_pi_add_sub_timedeltalike_freq_mismatch_monthly(self, mismatched_freq):
         with pytest.raises(IncompatibleFrequency, match=msg):
             rng -= other
 
-    def test_parr_add_sub_td64_nat(self, box_transpose_fail):
+    @pytest.mark.parametrize("transpose", [True, False])
+    def test_parr_add_sub_td64_nat(self, box_with_array, transpose):
         # GH#23320 special handling for timedelta64("NaT")
-        box, transpose = box_transpose_fail
-
         pi = pd.period_range("1994-04-01", periods=9, freq="19D")
         other = np.timedelta64("NaT")
         expected = pd.PeriodIndex(["NaT"] * 9, freq="19D")
 
-        obj = tm.box_expected(pi, box, transpose=transpose)
-        expected = tm.box_expected(expected, box, transpose=transpose)
+        obj = tm.box_expected(pi, box_with_array, transpose=transpose)
+        expected = tm.box_expected(expected, box_with_array, transpose=transpose)
 
         result = obj + other
         tm.assert_equal(result, expected)
@@ -1001,7 +1134,8 @@ def test_parr_add_sub_td64_nat(self, box_transpose_fail):
         tm.assert_equal(result, expected)
         result = obj - other
         tm.assert_equal(result, expected)
-        with pytest.raises(TypeError):
+        msg = r"cannot subtract .* from .*"
+        with pytest.raises(TypeError, match=msg):
             other - obj
 
     @pytest.mark.parametrize(
@@ -1011,16 +1145,12 @@ def test_parr_add_sub_td64_nat(self, box_transpose_fail):
             TimedeltaArray._from_sequence(["NaT"] * 9),
         ],
     )
-    def test_parr_add_sub_tdt64_nat_array(self, box_df_fail, other):
-        # FIXME: DataFrame fails because when when operating column-wise
-        #  timedelta64 entries become NaT and are treated like datetimes
-        box = box_df_fail
-
+    def test_parr_add_sub_tdt64_nat_array(self, box_with_array, other):
         pi = pd.period_range("1994-04-01", periods=9, freq="19D")
         expected = pd.PeriodIndex(["NaT"] * 9, freq="19D")
 
-        obj = tm.box_expected(pi, box)
-        expected = tm.box_expected(expected, box)
+        obj = tm.box_expected(pi, box_with_array)
+        expected = tm.box_expected(expected, box_with_array)
 
         result = obj + other
         tm.assert_equal(result, expected)
@@ -1028,7 +1158,8 @@ def test_parr_add_sub_tdt64_nat_array(self, box_df_fail, other):
         tm.assert_equal(result, expected)
         result = obj - other
         tm.assert_equal(result, expected)
-        with pytest.raises(TypeError):
+        msg = r"cannot subtract .* from .*"
+        with pytest.raises(TypeError, match=msg):
             other - obj
 
     # ---------------------------------------------------------------
@@ -1043,6 +1174,26 @@ def test_parr_add_sub_index(self):
         expected = pi - pi
         tm.assert_index_equal(result, expected)
 
+    def test_parr_add_sub_object_array(self):
+        pi = pd.period_range("2000-12-31", periods=3, freq="D")
+        parr = pi.array
+
+        other = np.array([pd.Timedelta(days=1), pd.offsets.Day(2), 3])
+
+        with tm.assert_produces_warning(PerformanceWarning):
+            result = parr + other
+
+        expected = pd.PeriodIndex(
+            ["2001-01-01", "2001-01-03", "2001-01-05"], freq="D"
+        ).array
+        tm.assert_equal(result, expected)
+
+        with tm.assert_produces_warning(PerformanceWarning):
+            result = parr - other
+
+        expected = pd.PeriodIndex(["2000-12-30"] * 3, freq="D").array
+        tm.assert_equal(result, expected)
+
 
 class TestPeriodSeriesArithmetic:
     def test_ops_series_timedelta(self):
diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py
index d480b26e30fff..abdeb1b30b626 100644
--- a/pandas/tests/arithmetic/test_timedelta64.py
+++ b/pandas/tests/arithmetic/test_timedelta64.py
@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from pandas.errors import NullFrequencyError, OutOfBoundsDatetime, PerformanceWarning
+from pandas.errors import OutOfBoundsDatetime, PerformanceWarning
 
 import pandas as pd
 from pandas import (
@@ -18,22 +18,12 @@
     Timestamp,
     timedelta_range,
 )
-from pandas.tests.arithmetic.test_datetime64 import assert_invalid_comparison
-import pandas.util.testing as tm
-
-
-def get_upcast_box(box, vector):
-    """
-    Given two box-types, find the one that takes priority
-    """
-    if box is DataFrame or isinstance(vector, DataFrame):
-        return DataFrame
-    if box is Series or isinstance(vector, Series):
-        return Series
-    if box is pd.Index or isinstance(vector, pd.Index):
-        return pd.Index
-    return box
-
+import pandas._testing as tm
+from pandas.tests.arithmetic.common import (
+    assert_invalid_addsub_type,
+    assert_invalid_comparison,
+    get_upcast_box,
+)
 
 # ------------------------------------------------------------------
 # Timedelta64[ns] dtype Comparisons
@@ -58,7 +48,8 @@ def test_compare_timedelta64_zerodim(self, box_with_array):
         expected = tm.box_expected(expected, xbox)
         tm.assert_equal(res, expected)
 
-        with pytest.raises(TypeError):
+        msg = "Invalid comparison between dtype"
+        with pytest.raises(TypeError, match=msg):
             # zero-dim of wrong dtype should still raise
             tdi >= np.array(4)
 
@@ -86,6 +77,49 @@ def test_td64_comparisons_invalid(self, box_with_array, invalid):
 
         assert_invalid_comparison(obj, invalid, box)
 
+    @pytest.mark.parametrize(
+        "other",
+        [
+            list(range(10)),
+            np.arange(10),
+            np.arange(10).astype(np.float32),
+            np.arange(10).astype(object),
+            pd.date_range("1970-01-01", periods=10, tz="UTC").array,
+            np.array(pd.date_range("1970-01-01", periods=10)),
+            list(pd.date_range("1970-01-01", periods=10)),
+            pd.date_range("1970-01-01", periods=10).astype(object),
+            pd.period_range("1971-01-01", freq="D", periods=10).array,
+            pd.period_range("1971-01-01", freq="D", periods=10).astype(object),
+        ],
+    )
+    def test_td64arr_cmp_arraylike_invalid(self, other):
+        # We don't parametrize this over box_with_array because listlike
+        #  other plays poorly with assert_invalid_comparison reversed checks
+
+        rng = timedelta_range("1 days", periods=10)._data
+        assert_invalid_comparison(rng, other, tm.to_array)
+
+    def test_td64arr_cmp_mixed_invalid(self):
+        rng = timedelta_range("1 days", periods=5)._data
+
+        other = np.array([0, 1, 2, rng[3], pd.Timestamp.now()])
+        result = rng == other
+        expected = np.array([False, False, False, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = rng != other
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        msg = "Invalid comparison between|Cannot compare type|not supported between"
+        with pytest.raises(TypeError, match=msg):
+            rng < other
+        with pytest.raises(TypeError, match=msg):
+            rng > other
+        with pytest.raises(TypeError, match=msg):
+            rng <= other
+        with pytest.raises(TypeError, match=msg):
+            rng >= other
+
 
 class TestTimedelta64ArrayComparisons:
     # TODO: All of these need to be parametrized over box
@@ -245,7 +279,7 @@ def test_subtraction_ops(self):
         with pytest.raises(TypeError, match=msg):
             td - dt
 
-        msg = "bad operand type for unary -: 'DatetimeArray'"
+        msg = "(bad|unsupported) operand type for unary"
         with pytest.raises(TypeError, match=msg):
             td - dti
 
@@ -409,7 +443,8 @@ def test_addition_ops(self):
             tdi[0:1] + dti
 
         # random indexes
-        with pytest.raises(NullFrequencyError):
+        msg = "Addition/subtraction of integers and integer-arrays"
+        with pytest.raises(TypeError, match=msg):
             tdi + pd.Int64Index([1, 2, 3])
 
         # this is a union!
@@ -484,6 +519,62 @@ def test_tda_add_sub_index(self):
         expected = tdi - tdi
         tm.assert_index_equal(result, expected)
 
+    # -------------------------------------------------------------
+    # Binary operations TimedeltaIndex and timedelta-like
+
+    def test_tdi_iadd_timedeltalike(self, two_hours):
+        # only test adding/sub offsets as + is now numeric
+        rng = timedelta_range("1 days", "10 days")
+        expected = timedelta_range("1 days 02:00:00", "10 days 02:00:00", freq="D")
+        rng += two_hours
+        tm.assert_index_equal(rng, expected)
+
+    def test_tdi_isub_timedeltalike(self, two_hours):
+        # only test adding/sub offsets as - is now numeric
+        rng = timedelta_range("1 days", "10 days")
+        expected = timedelta_range("0 days 22:00:00", "9 days 22:00:00")
+        rng -= two_hours
+        tm.assert_index_equal(rng, expected)
+
+    # -------------------------------------------------------------
+
+    def test_tdi_ops_attributes(self):
+        rng = timedelta_range("2 days", periods=5, freq="2D", name="x")
+
+        result = rng + 1 * rng.freq
+        exp = timedelta_range("4 days", periods=5, freq="2D", name="x")
+        tm.assert_index_equal(result, exp)
+        assert result.freq == "2D"
+
+        result = rng - 2 * rng.freq
+        exp = timedelta_range("-2 days", periods=5, freq="2D", name="x")
+        tm.assert_index_equal(result, exp)
+        assert result.freq == "2D"
+
+        result = rng * 2
+        exp = timedelta_range("4 days", periods=5, freq="4D", name="x")
+        tm.assert_index_equal(result, exp)
+        assert result.freq == "4D"
+
+        result = rng / 2
+        exp = timedelta_range("1 days", periods=5, freq="D", name="x")
+        tm.assert_index_equal(result, exp)
+        assert result.freq == "D"
+
+        result = -rng
+        exp = timedelta_range("-2 days", periods=5, freq="-2D", name="x")
+        tm.assert_index_equal(result, exp)
+        assert result.freq == "-2D"
+
+        rng = pd.timedelta_range("-2 days", periods=5, freq="D", name="x")
+
+        result = abs(rng)
+        exp = TimedeltaIndex(
+            ["2 days", "1 days", "0 days", "1 days", "2 days"], name="x"
+        )
+        tm.assert_index_equal(result, exp)
+        assert result.freq is None
+
 
 class TestAddSubNaTMasking:
     # TODO: parametrize over boxes
@@ -515,6 +606,7 @@ def test_tdi_add_timestamp_nat_masking(self):
     def test_tdi_add_overflow(self):
         # See GH#14068
         # preliminary test scalar analogue of vectorized tests below
+        # TODO: Make raised error message more informative and test
         with pytest.raises(OutOfBoundsDatetime):
             pd.to_timedelta(106580, "D") + Timestamp("2000")
         with pytest.raises(OutOfBoundsDatetime):
@@ -555,37 +647,29 @@ def test_tdi_add_overflow(self):
 class TestTimedeltaArraylikeAddSubOps:
     # Tests for timedelta64[ns] __add__, __sub__, __radd__, __rsub__
 
-    # TODO: moved from frame tests; needs parametrization/de-duplication
-    def test_td64_df_add_int_frame(self):
-        # GH#22696 Check that we don't dispatch to numpy implementation,
-        #  which treats int64 as m8[ns]
-        tdi = pd.timedelta_range("1", periods=3)
-        df = tdi.to_frame()
-        other = pd.DataFrame([1, 2, 3], index=tdi)  # indexed like `df`
-        with pytest.raises(TypeError):
-            df + other
-        with pytest.raises(TypeError):
-            other + df
-        with pytest.raises(TypeError):
-            df - other
-        with pytest.raises(TypeError):
-            other - df
-
     # TODO: moved from tests.indexes.timedeltas.test_arithmetic; needs
     #  parametrization+de-duplication
     def test_timedelta_ops_with_missing_values(self):
         # setup
         s1 = pd.to_timedelta(Series(["00:00:01"]))
         s2 = pd.to_timedelta(Series(["00:00:02"]))
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # Passing datetime64-dtype data to TimedeltaIndex is deprecated
-            sn = pd.to_timedelta(Series([pd.NaT]))
+
+        msg = r"dtype datetime64\[ns\] cannot be converted to timedelta64\[ns\]"
+        with pytest.raises(TypeError, match=msg):
+            # Passing datetime64-dtype data to TimedeltaIndex is no longer
+            #  supported GH#29794
+            pd.to_timedelta(Series([pd.NaT]))
+
+        sn = pd.to_timedelta(Series([pd.NaT], dtype="m8[ns]"))
 
         df1 = pd.DataFrame(["00:00:01"]).apply(pd.to_timedelta)
         df2 = pd.DataFrame(["00:00:02"]).apply(pd.to_timedelta)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # Passing datetime64-dtype data to TimedeltaIndex is deprecated
-            dfn = pd.DataFrame([pd.NaT]).apply(pd.to_timedelta)
+        with pytest.raises(TypeError, match=msg):
+            # Passing datetime64-dtype data to TimedeltaIndex is no longer
+            #  supported GH#29794
+            pd.DataFrame([pd.NaT]).apply(pd.to_timedelta)
+
+        dfn = pd.DataFrame([pd.NaT.value]).apply(pd.to_timedelta)
 
         scalar1 = pd.to_timedelta("00:00:01")
         scalar2 = pd.to_timedelta("00:00:02")
@@ -619,13 +703,14 @@ def test_timedelta_ops_with_missing_values(self):
         actual = -timedelta_NaT + s1
         tm.assert_series_equal(actual, sn)
 
-        with pytest.raises(TypeError):
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
             s1 + np.nan
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             np.nan + s1
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             s1 - np.nan
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             -np.nan + s1
 
         actual = s1 + pd.NaT
@@ -657,9 +742,10 @@ def test_timedelta_ops_with_missing_values(self):
         actual = df1 - timedelta_NaT
         tm.assert_frame_equal(actual, dfn)
 
-        with pytest.raises(TypeError):
+        msg = "cannot subtract a datelike from|unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
             df1 + np.nan
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             df1 - np.nan
 
         actual = df1 + pd.NaT  # NaT is datetime, not timedelta
@@ -817,51 +903,6 @@ def test_timedelta64_ops_nat(self):
         tm.assert_series_equal(timedelta_series / 2.0, Series([NaT, Timedelta("0.5s")]))
         tm.assert_series_equal(timedelta_series / np.nan, nat_series_dtype_timedelta)
 
-    # -------------------------------------------------------------
-    # Invalid Operations
-
-    @pytest.mark.parametrize("other", ["a", 3.14, np.array([2.0, 3.0])])
-    def test_td64arr_add_sub_invalid(self, box_with_array, other):
-        # GH#13624 for str
-        tdi = TimedeltaIndex(["1 day", "2 days"])
-        tdarr = tm.box_expected(tdi, box_with_array)
-
-        with pytest.raises(TypeError):
-            tdarr + other
-        with pytest.raises(TypeError):
-            other + tdarr
-        with pytest.raises(TypeError):
-            tdarr - other
-        with pytest.raises(TypeError):
-            other - tdarr
-
-    @pytest.mark.parametrize("freq", [None, "H"])
-    def test_td64arr_sub_period(self, box_with_array, freq):
-        # GH#13078
-        # not supported, check TypeError
-        p = pd.Period("2011-01-01", freq="D")
-        idx = TimedeltaIndex(["1 hours", "2 hours"], freq=freq)
-        idx = tm.box_expected(idx, box_with_array)
-
-        with pytest.raises(TypeError):
-            idx - p
-
-        with pytest.raises(TypeError):
-            p - idx
-
-    @pytest.mark.parametrize("pi_freq", ["D", "W", "Q", "H"])
-    @pytest.mark.parametrize("tdi_freq", [None, "H"])
-    def test_td64arr_sub_pi(self, box_with_array, tdi_freq, pi_freq):
-        # GH#20049 subtracting PeriodIndex should raise TypeError
-        tdi = TimedeltaIndex(["1 hours", "2 hours"], freq=tdi_freq)
-        dti = Timestamp("2018-03-07 17:16:40") + tdi
-        pi = dti.to_period(pi_freq)
-
-        # TODO: parametrize over box for pi?
-        tdi = tm.box_expected(tdi, box_with_array)
-        with pytest.raises(TypeError):
-            tdi - pi
-
     # -------------------------------------------------------------
     # Binary operations td64 arraylike and datetime-like
 
@@ -896,11 +937,16 @@ def test_td64arr_add_timestamp(self, box_with_array, tz_naive_fixture):
         result = other + idx
         tm.assert_equal(result, expected)
 
-    def test_td64arr_add_sub_timestamp(self, box_with_array):
-        # GH#11925
-        ts = Timestamp("2012-01-01")
-        # TODO: parametrize over types of datetime scalar?
-
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("2012-01-01"),
+            Timestamp("2012-01-01").to_pydatetime(),
+            Timestamp("2012-01-01").to_datetime64(),
+        ],
+    )
+    def test_td64arr_add_sub_datetimelike_scalar(self, ts, box_with_array):
+        # GH#11925, GH#29558
         tdi = timedelta_range("1 day", periods=3)
         expected = pd.date_range("2012-01-02", periods=3)
 
@@ -916,7 +962,8 @@ def test_td64arr_add_sub_timestamp(self, box_with_array):
         tm.assert_equal(ts - tdarr, expected2)
         tm.assert_equal(ts + (-tdarr), expected2)
 
-        with pytest.raises(TypeError):
+        msg = "cannot subtract a datelike"
+        with pytest.raises(TypeError, match=msg):
             tdarr - ts
 
     def test_tdi_sub_dt64_array(self, box_with_array):
@@ -928,7 +975,8 @@ def test_tdi_sub_dt64_array(self, box_with_array):
         tdi = tm.box_expected(tdi, box_with_array)
         expected = tm.box_expected(expected, box_with_array)
 
-        with pytest.raises(TypeError):
+        msg = "cannot subtract a datelike from"
+        with pytest.raises(TypeError, match=msg):
             tdi - dtarr
 
         # TimedeltaIndex.__rsub__
@@ -963,82 +1011,110 @@ def test_td64arr_add_datetime64_nat(self, box_with_array):
         tm.assert_equal(other + tdser, expected)
 
     # ------------------------------------------------------------------
-    # Operations with int-like others
+    # Invalid __add__/__sub__ operations
+
+    # TODO: moved from frame tests; needs parametrization/de-duplication
+    def test_td64_df_add_int_frame(self):
+        # GH#22696 Check that we don't dispatch to numpy implementation,
+        #  which treats int64 as m8[ns]
+        tdi = pd.timedelta_range("1", periods=3)
+        df = tdi.to_frame()
+        other = pd.DataFrame([1, 2, 3], index=tdi)  # indexed like `df`
+        assert_invalid_addsub_type(df, other)
+
+    @pytest.mark.parametrize("pi_freq", ["D", "W", "Q", "H"])
+    @pytest.mark.parametrize("tdi_freq", [None, "H"])
+    def test_td64arr_sub_periodlike(self, box_with_array, tdi_freq, pi_freq):
+        # GH#20049 subtracting PeriodIndex should raise TypeError
+        tdi = TimedeltaIndex(["1 hours", "2 hours"], freq=tdi_freq)
+        dti = Timestamp("2018-03-07 17:16:40") + tdi
+        pi = dti.to_period(pi_freq)
+
+        # TODO: parametrize over box for pi?
+        tdi = tm.box_expected(tdi, box_with_array)
+        msg = "cannot subtract|unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            tdi - pi
+
+        # FIXME: don't leave commented-out
+        # FIXME: this raises with period scalar but not with PeriodIndex?
+        # with pytest.raises(TypeError):
+        #    pi - tdi
+
+        # GH#13078 subtraction of Period scalar not supported
+        with pytest.raises(TypeError, match=msg):
+            tdi - pi[0]
+        with pytest.raises(TypeError, match=msg):
+            pi[0] - tdi
 
     @pytest.mark.parametrize(
         "other",
         [
+            # GH#12624 for str case
+            "a",
             # GH#19123
             1,
-            Series([20, 30, 40], dtype="uint8"),
-            np.array([20, 30, 40], dtype="uint8"),
-            pd.UInt64Index([20, 30, 40]),
-            pd.Int64Index([20, 30, 40]),
-            Series([2, 3, 4]),
             1.5,
             np.array(2),
         ],
     )
-    def test_td64arr_addsub_numeric_invalid(self, box_with_array, other):
-        box = box_with_array
+    def test_td64arr_addsub_numeric_scalar_invalid(self, box_with_array, other):
+        # vector-like others are tested in test_td64arr_add_sub_numeric_arr_invalid
         tdser = pd.Series(["59 Days", "59 Days", "NaT"], dtype="m8[ns]")
-        tdser = tm.box_expected(tdser, box)
-
-        err = TypeError
-        if box in [pd.Index, tm.to_array] and not isinstance(other, float):
-            err = NullFrequencyError
+        tdarr = tm.box_expected(tdser, box_with_array)
 
-        with pytest.raises(err):
-            tdser + other
-        with pytest.raises(err):
-            other + tdser
-        with pytest.raises(err):
-            tdser - other
-        with pytest.raises(err):
-            other - tdser
+        assert_invalid_addsub_type(tdarr, other)
 
-    @pytest.mark.parametrize(
-        "dtype",
-        [
-            "int64",
-            "int32",
-            "int16",
-            "uint64",
-            "uint32",
-            "uint16",
-            "uint8",
-            "float64",
-            "float32",
-            "float16",
-        ],
-    )
     @pytest.mark.parametrize(
         "vec",
         [
             np.array([1, 2, 3]),
             pd.Index([1, 2, 3]),
-            Series([1, 2, 3])
-            # TODO: Add DataFrame in here?
+            Series([1, 2, 3]),
+            DataFrame([[1, 2, 3]]),
         ],
         ids=lambda x: type(x).__name__,
     )
-    def test_td64arr_add_sub_numeric_arr_invalid(self, box_with_array, vec, dtype):
-        box = box_with_array
+    def test_td64arr_addsub_numeric_arr_invalid(
+        self, box_with_array, vec, any_real_dtype
+    ):
         tdser = pd.Series(["59 Days", "59 Days", "NaT"], dtype="m8[ns]")
-        tdser = tm.box_expected(tdser, box)
-        err = TypeError
-        if box in [pd.Index, tm.to_array] and not dtype.startswith("float"):
-            err = NullFrequencyError
-
-        vector = vec.astype(dtype)
-        with pytest.raises(err):
-            tdser + vector
-        with pytest.raises(err):
-            vector + tdser
-        with pytest.raises(err):
-            tdser - vector
-        with pytest.raises(err):
-            vector - tdser
+        tdarr = tm.box_expected(tdser, box_with_array)
+
+        vector = vec.astype(any_real_dtype)
+        assert_invalid_addsub_type(tdarr, vector)
+
+    def test_td64arr_add_sub_int(self, box_with_array, one):
+        # Variants of `one` for #19012, deprecated GH#22535
+        rng = timedelta_range("1 days 09:00:00", freq="H", periods=10)
+        tdarr = tm.box_expected(rng, box_with_array)
+
+        msg = "Addition/subtraction of integers"
+        assert_invalid_addsub_type(tdarr, one, msg)
+
+        # TOOD: get inplace ops into assert_invalid_addsub_type
+        with pytest.raises(TypeError, match=msg):
+            tdarr += one
+        with pytest.raises(TypeError, match=msg):
+            tdarr -= one
+
+    def test_td64arr_add_sub_integer_array(self, box_with_array):
+        # GH#19959, deprecated GH#22535
+        rng = timedelta_range("1 days 09:00:00", freq="H", periods=3)
+        tdarr = tm.box_expected(rng, box_with_array)
+        other = tm.box_expected([4, 3, 2], box_with_array)
+
+        msg = "Addition/subtraction of integers and integer-arrays"
+        assert_invalid_addsub_type(tdarr, other, msg)
+
+    def test_td64arr_addsub_integer_array_no_freq(self, box_with_array):
+        # GH#19959
+        tdi = TimedeltaIndex(["1 Day", "NaT", "3 Hours"])
+        tdarr = tm.box_expected(tdi, box_with_array)
+        other = tm.box_expected([14, -1, 16], box_with_array)
+
+        msg = "Addition/subtraction of integers"
+        assert_invalid_addsub_type(tdarr, other, msg)
 
     # ------------------------------------------------------------------
     # Operations with timedelta-like others
@@ -1431,19 +1507,55 @@ def test_td64arr_addsub_anchored_offset_arraylike(self, obox, box_with_array):
 
         # addition/subtraction ops with anchored offsets should issue
         # a PerformanceWarning and _then_ raise a TypeError.
-        with pytest.raises(TypeError):
+        msg = "has incorrect type|cannot add the type MonthEnd"
+        with pytest.raises(TypeError, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 tdi + anchored
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 anchored + tdi
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 tdi - anchored
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             with tm.assert_produces_warning(PerformanceWarning):
                 anchored - tdi
 
+    # ------------------------------------------------------------------
+    # Unsorted
+
+    def test_td64arr_add_sub_object_array(self, box_with_array):
+        tdi = pd.timedelta_range("1 day", periods=3, freq="D")
+        tdarr = tm.box_expected(tdi, box_with_array)
+
+        other = np.array(
+            [pd.Timedelta(days=1), pd.offsets.Day(2), pd.Timestamp("2000-01-04")]
+        )
+
+        warn = PerformanceWarning if box_with_array is not pd.DataFrame else None
+        with tm.assert_produces_warning(warn):
+            result = tdarr + other
+
+        expected = pd.Index(
+            [pd.Timedelta(days=2), pd.Timedelta(days=4), pd.Timestamp("2000-01-07")]
+        )
+        expected = tm.box_expected(expected, box_with_array)
+        tm.assert_equal(result, expected)
+
+        msg = "unsupported operand type|cannot subtract a datelike"
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(warn):
+                tdarr - other
+
+        with tm.assert_produces_warning(warn):
+            result = other - tdarr
+
+        expected = pd.Index(
+            [pd.Timedelta(0), pd.Timedelta(0), pd.Timestamp("2000-01-01")]
+        )
+        expected = tm.box_expected(expected, box_with_array)
+        tm.assert_equal(result, expected)
+
 
 class TestTimedeltaArraylikeMulDivOps:
     # Tests for timedelta64[ns]
@@ -1486,7 +1598,8 @@ def test_td64arr_mul_int(self, box_with_array):
     def test_td64arr_mul_tdlike_scalar_raises(self, two_hours, box_with_array):
         rng = timedelta_range("1 days", "10 days", name="foo")
         rng = tm.box_expected(rng, box_with_array)
-        with pytest.raises(TypeError):
+        msg = "argument must be an integer|cannot use operands with types dtype"
+        with pytest.raises(TypeError, match=msg):
             rng * two_hours
 
     def test_tdi_mul_int_array_zerodim(self, box_with_array):
@@ -1675,12 +1788,13 @@ def test_tdarr_div_length_mismatch(self, box_with_array):
         mismatched = [1, 2, 3, 4]
 
         rng = tm.box_expected(rng, box_with_array)
+        msg = "Cannot divide vectors|Unable to coerce to Series"
         for obj in [mismatched, mismatched[:2]]:
             # one shorter, one longer
             for other in [obj, np.array(obj), pd.Index(obj)]:
-                with pytest.raises(ValueError):
+                with pytest.raises(ValueError, match=msg):
                     rng / other
-                with pytest.raises(ValueError):
+                with pytest.raises(ValueError, match=msg):
                     other / rng
 
     # ------------------------------------------------------------------
@@ -1806,7 +1920,8 @@ def test_td64arr_mod_int(self, box_with_array):
         result = tdarr % 2
         tm.assert_equal(result, expected)
 
-        with pytest.raises(TypeError):
+        msg = "Cannot divide int by"
+        with pytest.raises(TypeError, match=msg):
             2 % tdarr
 
         if box_with_array is pd.DataFrame:
@@ -1855,21 +1970,26 @@ def test_td64arr_mul_tdscalar_invalid(self, box_with_array, scalar_td):
     def test_td64arr_mul_too_short_raises(self, box_with_array):
         idx = TimedeltaIndex(np.arange(5, dtype="int64"))
         idx = tm.box_expected(idx, box_with_array)
-        with pytest.raises(TypeError):
+        msg = (
+            "cannot use operands with types dtype|"
+            "Cannot multiply with unequal lengths|"
+            "Unable to coerce to Series"
+        )
+        with pytest.raises(TypeError, match=msg):
             idx * idx[:3]
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=msg):
             idx * np.array([1, 2])
 
     def test_td64arr_mul_td64arr_raises(self, box_with_array):
         idx = TimedeltaIndex(np.arange(5, dtype="int64"))
         idx = tm.box_expected(idx, box_with_array)
-        with pytest.raises(TypeError):
+        msg = "cannot use operands with types dtype"
+        with pytest.raises(TypeError, match=msg):
             idx * idx
 
     # ------------------------------------------------------------------
     # Operations with numeric others
 
-    @pytest.mark.parametrize("one", [1, np.array(1), 1.0, np.array(1.0)])
     def test_td64arr_mul_numeric_scalar(self, box_with_array, one):
         # GH#4521
         # divide/multiply by integers
@@ -1908,33 +2028,18 @@ def test_td64arr_div_numeric_scalar(self, box_with_array, two):
         with pytest.raises(TypeError, match="Cannot divide"):
             two / tdser
 
-    @pytest.mark.parametrize(
-        "dtype",
-        [
-            "int64",
-            "int32",
-            "int16",
-            "uint64",
-            "uint32",
-            "uint16",
-            "uint8",
-            "float64",
-            "float32",
-            "float16",
-        ],
-    )
     @pytest.mark.parametrize(
         "vector",
         [np.array([20, 30, 40]), pd.Index([20, 30, 40]), Series([20, 30, 40])],
         ids=lambda x: type(x).__name__,
     )
-    def test_td64arr_rmul_numeric_array(self, box_with_array, vector, dtype):
+    def test_td64arr_rmul_numeric_array(self, box_with_array, vector, any_real_dtype):
         # GH#4521
         # divide/multiply by integers
         xbox = get_upcast_box(box_with_array, vector)
 
         tdser = pd.Series(["59 Days", "59 Days", "NaT"], dtype="m8[ns]")
-        vector = vector.astype(dtype)
+        vector = vector.astype(any_real_dtype)
 
         expected = Series(["1180 Days", "1770 Days", "NaT"], dtype="timedelta64[ns]")
 
@@ -1947,32 +2052,19 @@ def test_td64arr_rmul_numeric_array(self, box_with_array, vector, dtype):
         result = vector * tdser
         tm.assert_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "dtype",
-        [
-            "int64",
-            "int32",
-            "int16",
-            "uint64",
-            "uint32",
-            "uint16",
-            "uint8",
-            "float64",
-            "float32",
-            "float16",
-        ],
-    )
     @pytest.mark.parametrize(
         "vector",
         [np.array([20, 30, 40]), pd.Index([20, 30, 40]), Series([20, 30, 40])],
         ids=lambda x: type(x).__name__,
     )
-    def test_td64arr_div_numeric_array(self, box_with_array, vector, dtype):
+    def test_td64arr_div_numeric_array(self, box_with_array, vector, any_real_dtype):
         # GH#4521
         # divide/multiply by integers
         xbox = get_upcast_box(box_with_array, vector)
+
         tdser = pd.Series(["59 Days", "59 Days", "NaT"], dtype="m8[ns]")
-        vector = vector.astype(dtype)
+        vector = vector.astype(any_real_dtype)
+
         expected = Series(["2.95D", "1D 23H 12m", "NaT"], dtype="timedelta64[ns]")
 
         tdser = tm.box_expected(tdser, box_with_array)
diff --git a/pandas/tests/arrays/categorical/test_algos.py b/pandas/tests/arrays/categorical/test_algos.py
index 1508fef86ae62..835aa87a7c21b 100644
--- a/pandas/tests/arrays/categorical/test_algos.py
+++ b/pandas/tests/arrays/categorical/test_algos.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("ordered", [True, False])
@@ -11,23 +11,23 @@ def test_factorize(categories, ordered):
     cat = pd.Categorical(
         ["b", "b", "a", "c", None], categories=categories, ordered=ordered
     )
-    labels, uniques = pd.factorize(cat)
-    expected_labels = np.array([0, 0, 1, 2, -1], dtype=np.intp)
+    codes, uniques = pd.factorize(cat)
+    expected_codes = np.array([0, 0, 1, 2, -1], dtype=np.intp)
     expected_uniques = pd.Categorical(
         ["b", "a", "c"], categories=categories, ordered=ordered
     )
 
-    tm.assert_numpy_array_equal(labels, expected_labels)
+    tm.assert_numpy_array_equal(codes, expected_codes)
     tm.assert_categorical_equal(uniques, expected_uniques)
 
 
 def test_factorized_sort():
     cat = pd.Categorical(["b", "b", None, "a"])
-    labels, uniques = pd.factorize(cat, sort=True)
-    expected_labels = np.array([1, 1, -1, 0], dtype=np.intp)
+    codes, uniques = pd.factorize(cat, sort=True)
+    expected_codes = np.array([1, 1, -1, 0], dtype=np.intp)
     expected_uniques = pd.Categorical(["a", "b"])
 
-    tm.assert_numpy_array_equal(labels, expected_labels)
+    tm.assert_numpy_array_equal(codes, expected_codes)
     tm.assert_categorical_equal(uniques, expected_uniques)
 
 
@@ -36,13 +36,13 @@ def test_factorized_sort_ordered():
         ["b", "b", None, "a"], categories=["c", "b", "a"], ordered=True
     )
 
-    labels, uniques = pd.factorize(cat, sort=True)
-    expected_labels = np.array([0, 0, -1, 1], dtype=np.intp)
+    codes, uniques = pd.factorize(cat, sort=True)
+    expected_codes = np.array([0, 0, -1, 1], dtype=np.intp)
     expected_uniques = pd.Categorical(
         ["b", "a"], categories=["c", "b", "a"], ordered=True
     )
 
-    tm.assert_numpy_array_equal(labels, expected_labels)
+    tm.assert_numpy_array_equal(codes, expected_codes)
     tm.assert_categorical_equal(uniques, expected_uniques)
 
 
@@ -59,7 +59,29 @@ def test_isin_cats():
     tm.assert_numpy_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("empty", [[], pd.Series(), np.array([])])
+@pytest.mark.parametrize(
+    "to_replace, value, result, expected_error_msg",
+    [
+        ("b", "c", ["a", "c"], "Categorical.categories are different"),
+        ("c", "d", ["a", "b"], None),
+        ("b", None, ["a", None], "Categorical.categories length are different"),
+    ],
+)
+def test_replace(to_replace, value, result, expected_error_msg):
+    # GH 26988
+    cat = pd.Categorical(["a", "b"])
+    expected = pd.Categorical(result)
+    result = cat.replace(to_replace, value)
+    tm.assert_categorical_equal(result, expected)
+    if to_replace == "b":  # the "c" test is supposed to be unchanged
+        with pytest.raises(AssertionError, match=expected_error_msg):
+            # ensure non-inplace call does not affect original
+            tm.assert_categorical_equal(cat, expected)
+    cat.replace(to_replace, value, inplace=True)
+    tm.assert_categorical_equal(cat, expected)
+
+
+@pytest.mark.parametrize("empty", [[], pd.Series(dtype=object), np.array([])])
 def test_isin_empty(empty):
     s = pd.Categorical(["a", "b"])
     expected = np.array([False, False], dtype=bool)
@@ -68,13 +90,30 @@ def test_isin_empty(empty):
     tm.assert_numpy_array_equal(expected, result)
 
 
+def test_diff():
+    s = pd.Series([1, 2, 3], dtype="category")
+    with tm.assert_produces_warning(FutureWarning):
+        result = s.diff()
+    expected = pd.Series([np.nan, 1, 1])
+    tm.assert_series_equal(result, expected)
+
+    expected = expected.to_frame(name="A")
+    df = s.to_frame(name="A")
+    with tm.assert_produces_warning(FutureWarning):
+        result = df.diff()
+
+    tm.assert_frame_equal(result, expected)
+
+
 class TestTake:
     # https://github.com/pandas-dev/pandas/issues/20664
 
-    def test_take_warns(self):
+    def test_take_default_allow_fill(self):
         cat = pd.Categorical(["a", "b"])
-        with tm.assert_produces_warning(FutureWarning):
-            cat.take([0, -1])
+        with tm.assert_produces_warning(None):
+            result = cat.take([0, -1])
+
+        assert result.equals(cat)
 
     def test_take_positive_no_warning(self):
         cat = pd.Categorical(["a", "b"])
@@ -84,13 +123,21 @@ def test_take_positive_no_warning(self):
     def test_take_bounds(self, allow_fill):
         # https://github.com/pandas-dev/pandas/issues/20664
         cat = pd.Categorical(["a", "b", "a"])
-        with pytest.raises(IndexError):
+        if allow_fill:
+            msg = "indices are out-of-bounds"
+        else:
+            msg = "index 4 is out of bounds for( axis 0 with)? size 3"
+        with pytest.raises(IndexError, match=msg):
             cat.take([4, 5], allow_fill=allow_fill)
 
     def test_take_empty(self, allow_fill):
         # https://github.com/pandas-dev/pandas/issues/20664
         cat = pd.Categorical([], categories=["a", "b"])
-        with pytest.raises(IndexError):
+        if allow_fill:
+            msg = "indices are out-of-bounds"
+        else:
+            msg = "cannot do a non-empty take from an empty axes"
+        with pytest.raises(IndexError, match=msg):
             cat.take([0], allow_fill=allow_fill)
 
     def test_positional_take(self, ordered_fixture):
@@ -140,3 +187,12 @@ def test_take_fill_value_new_raises(self):
         xpr = r"'fill_value' \('d'\) is not in this Categorical's categories."
         with pytest.raises(TypeError, match=xpr):
             cat.take([0, 1, -1], fill_value="d", allow_fill=True)
+
+    def test_take_nd_deprecated(self):
+        cat = pd.Categorical(["a", "b", "c"])
+        with tm.assert_produces_warning(FutureWarning):
+            cat.take_nd([0, 1])
+
+        ci = pd.Index(cat)
+        with tm.assert_produces_warning(FutureWarning):
+            ci.take_nd([0, 1])
diff --git a/pandas/tests/arrays/categorical/test_analytics.py b/pandas/tests/arrays/categorical/test_analytics.py
index d8831d7e6bf36..90fcf12093909 100644
--- a/pandas/tests/arrays/categorical/test_analytics.py
+++ b/pandas/tests/arrays/categorical/test_analytics.py
@@ -5,22 +5,23 @@
 
 from pandas.compat import PYPY
 
-from pandas import Categorical, Index, Series
+from pandas import Categorical, Index, NaT, Series, date_range
+import pandas._testing as tm
 from pandas.api.types import is_scalar
-import pandas.util.testing as tm
 
 
 class TestCategoricalAnalytics:
-    def test_min_max(self):
-
+    @pytest.mark.parametrize("aggregation", ["min", "max"])
+    def test_min_max_not_ordered_raises(self, aggregation):
         # unordered cats have no min/max
         cat = Categorical(["a", "b", "c", "d"], ordered=False)
         msg = "Categorical is not ordered for operation {}"
-        with pytest.raises(TypeError, match=msg.format("min")):
-            cat.min()
-        with pytest.raises(TypeError, match=msg.format("max")):
-            cat.max()
+        agg_func = getattr(cat, aggregation)
+
+        with pytest.raises(TypeError, match=msg.format(aggregation)):
+            agg_func()
 
+    def test_min_max_ordered(self):
         cat = Categorical(["a", "b", "c", "d"], ordered=True)
         _min = cat.min()
         _max = cat.max()
@@ -35,31 +36,66 @@ def test_min_max(self):
         assert _min == "d"
         assert _max == "a"
 
+    @pytest.mark.parametrize(
+        "categories,expected",
+        [
+            (list("ABC"), np.NaN),
+            ([1, 2, 3], np.NaN),
+            pytest.param(
+                Series(date_range("2020-01-01", periods=3), dtype="category"),
+                NaT,
+                marks=pytest.mark.xfail(
+                    reason="https://github.com/pandas-dev/pandas/issues/29962"
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("aggregation", ["min", "max"])
+    def test_min_max_ordered_empty(self, categories, expected, aggregation):
+        # GH 30227
+        cat = Categorical([], categories=list("ABC"), ordered=True)
+
+        agg_func = getattr(cat, aggregation)
+        result = agg_func()
+        assert result is expected
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_min_max_with_nan(self, skipna):
+        # GH 25303
         cat = Categorical(
             [np.nan, "b", "c", np.nan], categories=["d", "c", "b", "a"], ordered=True
         )
-        _min = cat.min()
-        _max = cat.max()
-        assert np.isnan(_min)
-        assert _max == "b"
+        _min = cat.min(skipna=skipna)
+        _max = cat.max(skipna=skipna)
 
-        _min = cat.min(numeric_only=True)
-        assert _min == "c"
-        _max = cat.max(numeric_only=True)
-        assert _max == "b"
+        if skipna is False:
+            assert np.isnan(_min)
+            assert np.isnan(_max)
+        else:
+            assert _min == "c"
+            assert _max == "b"
 
         cat = Categorical(
             [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
         )
-        _min = cat.min()
-        _max = cat.max()
-        assert np.isnan(_min)
-        assert _max == 1
-
-        _min = cat.min(numeric_only=True)
-        assert _min == 2
-        _max = cat.max(numeric_only=True)
-        assert _max == 1
+        _min = cat.min(skipna=skipna)
+        _max = cat.max(skipna=skipna)
+
+        if skipna is False:
+            assert np.isnan(_min)
+            assert np.isnan(_max)
+        else:
+            assert _min == 2
+            assert _max == 1
+
+    @pytest.mark.parametrize("method", ["min", "max"])
+    def test_deprecate_numeric_only_min_max(self, method):
+        # GH 25303
+        cat = Categorical(
+            [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
+        )
+        with tm.assert_produces_warning(expected_warning=FutureWarning):
+            getattr(cat, method)(numeric_only=True)
 
     @pytest.mark.parametrize(
         "values,categories,exp_mode",
@@ -78,65 +114,51 @@ def test_mode(self, values, categories, exp_mode):
         exp = Categorical(exp_mode, categories=categories, ordered=True)
         tm.assert_categorical_equal(res, exp)
 
-    def test_searchsorted(self):
+    def test_searchsorted(self, ordered_fixture):
         # https://github.com/pandas-dev/pandas/issues/8420
         # https://github.com/pandas-dev/pandas/issues/14522
 
-        c1 = Categorical(
-            ["cheese", "milk", "apple", "bread", "bread"],
-            categories=["cheese", "milk", "apple", "bread"],
-            ordered=True,
-        )
-        s1 = Series(c1)
-        c2 = Categorical(
+        cat = Categorical(
             ["cheese", "milk", "apple", "bread", "bread"],
             categories=["cheese", "milk", "apple", "bread"],
-            ordered=False,
+            ordered=ordered_fixture,
         )
-        s2 = Series(c2)
+        ser = Series(cat)
 
         # Searching for single item argument, side='left' (default)
-        res_cat = c1.searchsorted("apple")
+        res_cat = cat.searchsorted("apple")
         assert res_cat == 2
         assert is_scalar(res_cat)
 
-        res_ser = s1.searchsorted("apple")
+        res_ser = ser.searchsorted("apple")
         assert res_ser == 2
         assert is_scalar(res_ser)
 
         # Searching for single item array, side='left' (default)
-        res_cat = c1.searchsorted(["bread"])
-        res_ser = s1.searchsorted(["bread"])
+        res_cat = cat.searchsorted(["bread"])
+        res_ser = ser.searchsorted(["bread"])
         exp = np.array([3], dtype=np.intp)
         tm.assert_numpy_array_equal(res_cat, exp)
         tm.assert_numpy_array_equal(res_ser, exp)
 
         # Searching for several items array, side='right'
-        res_cat = c1.searchsorted(["apple", "bread"], side="right")
-        res_ser = s1.searchsorted(["apple", "bread"], side="right")
+        res_cat = cat.searchsorted(["apple", "bread"], side="right")
+        res_ser = ser.searchsorted(["apple", "bread"], side="right")
         exp = np.array([3, 5], dtype=np.intp)
         tm.assert_numpy_array_equal(res_cat, exp)
         tm.assert_numpy_array_equal(res_ser, exp)
 
         # Searching for a single value that is not from the Categorical
-        msg = r"Value\(s\) to be inserted must be in categories"
-        with pytest.raises(KeyError, match=msg):
-            c1.searchsorted("cucumber")
-        with pytest.raises(KeyError, match=msg):
-            s1.searchsorted("cucumber")
+        with pytest.raises(KeyError, match="cucumber"):
+            cat.searchsorted("cucumber")
+        with pytest.raises(KeyError, match="cucumber"):
+            ser.searchsorted("cucumber")
 
         # Searching for multiple values one of each is not from the Categorical
-        with pytest.raises(KeyError, match=msg):
-            c1.searchsorted(["bread", "cucumber"])
-        with pytest.raises(KeyError, match=msg):
-            s1.searchsorted(["bread", "cucumber"])
-
-        # searchsorted call for unordered Categorical
-        msg = "Categorical not ordered"
-        with pytest.raises(ValueError, match=msg):
-            c2.searchsorted("apple")
-        with pytest.raises(ValueError, match=msg):
-            s2.searchsorted("apple")
+        with pytest.raises(KeyError, match="cucumber"):
+            cat.searchsorted(["bread", "cucumber"])
+        with pytest.raises(KeyError, match="cucumber"):
+            ser.searchsorted(["bread", "cucumber"])
 
     def test_unique(self):
         # categories are reordered based on value when ordered=False
@@ -273,40 +295,42 @@ def test_map(self):
         # GH 12766: Return an index not an array
         tm.assert_index_equal(result, Index(np.array([1] * 5, dtype=np.int64)))
 
-    def test_validate_inplace(self):
+    @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+    def test_validate_inplace_raises(self, value):
         cat = Categorical(["A", "B", "B", "C", "A"])
-        invalid_values = [1, "True", [1, 2, 3], 5.0]
-
-        for value in invalid_values:
-            with pytest.raises(ValueError):
-                cat.set_ordered(value=True, inplace=value)
+        msg = (
+            'For argument "inplace" expected type bool, '
+            f"received type {type(value).__name__}"
+        )
+        with pytest.raises(ValueError, match=msg):
+            cat.set_ordered(value=True, inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.as_ordered(inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.as_ordered(inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.as_unordered(inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.as_unordered(inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.set_categories(["X", "Y", "Z"], rename=True, inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.set_categories(["X", "Y", "Z"], rename=True, inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.rename_categories(["X", "Y", "Z"], inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.rename_categories(["X", "Y", "Z"], inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.reorder_categories(["X", "Y", "Z"], ordered=True, inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.reorder_categories(["X", "Y", "Z"], ordered=True, inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.add_categories(new_categories=["D", "E", "F"], inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.add_categories(new_categories=["D", "E", "F"], inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.remove_categories(removals=["D", "E", "F"], inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.remove_categories(removals=["D", "E", "F"], inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.remove_unused_categories(inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.remove_unused_categories(inplace=value)
 
-            with pytest.raises(ValueError):
-                cat.sort_values(inplace=value)
+        with pytest.raises(ValueError, match=msg):
+            cat.sort_values(inplace=value)
 
     def test_isna(self):
         exp = np.array([False, False, True])
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index ab07b3c96a1db..f49f70f5acf77 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -1,10 +1,12 @@
+import re
+
 import numpy as np
 import pytest
 
 from pandas import Categorical, CategoricalIndex, DataFrame, Index, Series
+import pandas._testing as tm
 from pandas.core.arrays.categorical import _recode_for_categories
 from pandas.tests.arrays.categorical.common import TestCategorical
-import pandas.util.testing as tm
 
 
 class TestCategoricalAPI:
@@ -81,13 +83,15 @@ def test_rename_categories(self):
         )
         tm.assert_index_equal(cat.categories, Index([1, 2, 3]))
 
-        # Lengthen
-        with pytest.raises(ValueError):
-            cat.rename_categories([1, 2, 3, 4])
-
-        # Shorten
-        with pytest.raises(ValueError):
-            cat.rename_categories([1, 2])
+    @pytest.mark.parametrize("new_categories", [[1, 2, 3, 4], [1, 2]])
+    def test_rename_categories_wrong_length_raises(self, new_categories):
+        cat = Categorical(["a", "b", "c", "a"])
+        msg = (
+            "new categories need to have the same number of items as the "
+            "old categories!"
+        )
+        with pytest.raises(ValueError, match=msg):
+            cat.rename_categories(new_categories)
 
     def test_rename_categories_series(self):
         # https://github.com/pandas-dev/pandas/issues/17981
@@ -147,19 +151,19 @@ def test_reorder_categories(self):
         assert res is None
         tm.assert_categorical_equal(cat, new)
 
-        # not all "old" included in "new"
+    @pytest.mark.parametrize(
+        "new_categories",
+        [
+            ["a"],  # not all "old" included in "new"
+            ["a", "b", "d"],  # still not all "old" in "new"
+            ["a", "b", "c", "d"],  # all "old" included in "new", but too long
+        ],
+    )
+    def test_reorder_categories_raises(self, new_categories):
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
-
-        with pytest.raises(ValueError):
-            cat.reorder_categories(["a"])
-
-        # still not all "old" in "new"
-        with pytest.raises(ValueError):
-            cat.reorder_categories(["a", "b", "d"])
-
-        # all "old" included in "new", but too long
-        with pytest.raises(ValueError):
-            cat.reorder_categories(["a", "b", "c", "d"])
+        msg = "items in new_categories are not the same as in old categories"
+        with pytest.raises(ValueError, match=msg):
+            cat.reorder_categories(new_categories)
 
     def test_add_categories(self):
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
@@ -182,10 +186,6 @@ def test_add_categories(self):
         tm.assert_categorical_equal(cat, new)
         assert res is None
 
-        # new is in old categories
-        with pytest.raises(ValueError):
-            cat.add_categories(["d"])
-
         # GH 9927
         cat = Categorical(list("abc"), ordered=True)
         expected = Categorical(list("abc"), categories=list("abcde"), ordered=True)
@@ -199,6 +199,13 @@ def test_add_categories(self):
         res = cat.add_categories(["d", "e"])
         tm.assert_categorical_equal(res, expected)
 
+    def test_add_categories_existing_raises(self):
+        # new is in old categories
+        cat = Categorical(["a", "b", "c", "d"], ordered=True)
+        msg = re.escape("new categories must not include old categories: {'d'}")
+        with pytest.raises(ValueError, match=msg):
+            cat.add_categories(["d"])
+
     def test_set_categories(self):
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
         exp_categories = Index(["c", "b", "a"])
@@ -339,9 +346,13 @@ def test_remove_categories(self):
         tm.assert_categorical_equal(cat, new)
         assert res is None
 
-        # removal is not in categories
-        with pytest.raises(ValueError):
-            cat.remove_categories(["c"])
+    @pytest.mark.parametrize("removals", [["c"], ["c", np.nan], "c", ["c", "c"]])
+    def test_remove_categories_raises(self, removals):
+        cat = Categorical(["a", "b", "a"])
+        message = re.escape("removals must all be in old categories: {'c'}")
+
+        with pytest.raises(ValueError, match=message):
+            cat.remove_categories(removals)
 
     def test_remove_unused_categories(self):
         c = Categorical(["a", "b", "c", "d", "a"], categories=["a", "b", "c", "d", "e"])
@@ -447,13 +458,13 @@ def test_codes_immutable(self):
         tm.assert_numpy_array_equal(c.codes, exp)
 
         # Assignments to codes should raise
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="cannot set Categorical codes directly"):
             c.codes = np.array([0, 1, 2, 0, 1], dtype="int8")
 
         # changes in the codes array should raise
         codes = c.codes
 
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="assignment destination is read-only"):
             codes[4] = 1
 
         # But even after getting the codes, the original array should still be
@@ -498,9 +509,3 @@ def test_recode_to_categories_large(self):
         new = Index(expected)
         result = _recode_for_categories(codes, old, new)
         tm.assert_numpy_array_equal(result, expected)
-
-    def test_deprecated_get_values(self):
-        cat = Categorical(["a", "b", "c", "a"])
-        with tm.assert_produces_warning(FutureWarning):
-            res = cat.get_values()
-        tm.assert_numpy_array_equal(res, np.array(cat))
diff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py
index 704f9c94463e6..70e1421c8dcf4 100644
--- a/pandas/tests/arrays/categorical/test_constructors.py
+++ b/pandas/tests/arrays/categorical/test_constructors.py
@@ -3,6 +3,8 @@
 import numpy as np
 import pytest
 
+from pandas.compat.numpy import _np_version_under1p16
+
 from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
@@ -14,6 +16,7 @@
     Index,
     Interval,
     IntervalIndex,
+    MultiIndex,
     NaT,
     Series,
     Timestamp,
@@ -21,7 +24,7 @@
     period_range,
     timedelta_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCategoricalConstructors:
@@ -274,23 +277,19 @@ def test_constructor_with_index(self):
     def test_constructor_with_generator(self):
         # This was raising an Error in isna(single_val).any() because isna
         # returned a scalar for a generator
-        xrange = range
 
         exp = Categorical([0, 1, 2])
         cat = Categorical((x for x in [0, 1, 2]))
         tm.assert_categorical_equal(cat, exp)
-        cat = Categorical(xrange(3))
+        cat = Categorical(range(3))
         tm.assert_categorical_equal(cat, exp)
 
-        # This uses xrange internally
-        from pandas.core.index import MultiIndex
-
         MultiIndex.from_product([range(5), ["a", "b", "c"]])
 
         # check that categories accept generators and sequences
         cat = Categorical([0, 1, 2], categories=(x for x in [0, 1, 2]))
         tm.assert_categorical_equal(cat, exp)
-        cat = Categorical([0, 1, 2], categories=xrange(3))
+        cat = Categorical([0, 1, 2], categories=range(3))
         tm.assert_categorical_equal(cat, exp)
 
     @pytest.mark.parametrize(
@@ -309,7 +308,7 @@ def test_constructor_with_datetimelike(self, dtl):
         c = Categorical(s)
 
         expected = type(dtl)(s)
-        expected.freq = None
+        expected._data.freq = None
 
         tm.assert_index_equal(c.categories, expected)
         tm.assert_numpy_array_equal(c.codes, np.arange(5, dtype="int8"))
@@ -320,7 +319,7 @@ def test_constructor_with_datetimelike(self, dtl):
         c = Categorical(s2)
 
         expected = type(dtl)(s2.dropna())
-        expected.freq = None
+        expected._data.freq = None
 
         tm.assert_index_equal(c.categories, expected)
 
@@ -409,6 +408,11 @@ def test_constructor_str_unknown(self):
         with pytest.raises(ValueError, match="Unknown dtype"):
             Categorical([1, 2], dtype="foo")
 
+    def test_constructor_np_strs(self):
+        # GH#31499 Hastable.map_locations needs to work on np.str_ objects
+        cat = pd.Categorical(["1", "0", "1"], [np.str_("0"), np.str_("1")])
+        assert all(isinstance(x, np.str_) for x in cat.categories)
+
     def test_constructor_from_categorical_with_dtype(self):
         dtype = CategoricalDtype(["a", "b", "c"], ordered=True)
         values = Categorical(["a", "b", "d"])
@@ -524,13 +528,14 @@ def test_from_codes_with_float(self):
         codes = [1.0, 2.0, 0]  # integer, but in float dtype
         dtype = CategoricalDtype(categories=["a", "b", "c"])
 
-        with tm.assert_produces_warning(FutureWarning):
-            cat = Categorical.from_codes(codes, dtype.categories)
-        tm.assert_numpy_array_equal(cat.codes, np.array([1, 2, 0], dtype="i1"))
+        # empty codes should not raise for floats
+        Categorical.from_codes([], dtype.categories)
 
-        with tm.assert_produces_warning(FutureWarning):
-            cat = Categorical.from_codes(codes, dtype=dtype)
-        tm.assert_numpy_array_equal(cat.codes, np.array([1, 2, 0], dtype="i1"))
+        with pytest.raises(ValueError, match="codes need to be array-like integers"):
+            Categorical.from_codes(codes, dtype.categories)
+
+        with pytest.raises(ValueError, match="codes need to be array-like integers"):
+            Categorical.from_codes(codes, dtype=dtype)
 
         codes = [1.1, 2.0, 0]  # non-integer
         with pytest.raises(ValueError, match="codes need to be array-like integers"):
@@ -601,3 +606,10 @@ def test_constructor_imaginary(self):
         c1 = Categorical(values)
         tm.assert_index_equal(c1.categories, Index(values))
         tm.assert_numpy_array_equal(np.array(c1), np.array(values))
+
+    @pytest.mark.skipif(_np_version_under1p16, reason="Skipping for NumPy <1.16")
+    def test_constructor_string_and_tuples(self):
+        # GH 21416
+        c = pd.Categorical(np.array(["c", ("a", "b"), ("b", "a"), "c"], dtype=object))
+        expected_index = pd.Index([("a", "b"), ("b", "a"), "c"])
+        assert c.categories.equals(expected_index)
diff --git a/pandas/tests/arrays/categorical/test_dtypes.py b/pandas/tests/arrays/categorical/test_dtypes.py
index c08ad1da38671..19746d7d72162 100644
--- a/pandas/tests/arrays/categorical/test_dtypes.py
+++ b/pandas/tests/arrays/categorical/test_dtypes.py
@@ -4,7 +4,7 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
 from pandas import Categorical, CategoricalIndex, Index, Series, Timestamp
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCategoricalDtypes:
@@ -161,14 +161,6 @@ def test_astype_category(self, dtype_ordered, cat_ordered):
             expected = cat
             tm.assert_categorical_equal(result, expected)
 
-    def test_astype_category_ordered_none_deprecated(self):
-        # GH 26336
-        cdt1 = CategoricalDtype(categories=list("cdab"), ordered=True)
-        cdt2 = CategoricalDtype(categories=list("cedafb"))
-        cat = Categorical(list("abcdaba"), dtype=cdt1)
-        with tm.assert_produces_warning(FutureWarning):
-            cat.astype(cdt2)
-
     def test_iter_python_types(self):
         # GH-19909
         cat = Categorical([1, 2])
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 6edd7fd00b707..85d5a6a3dc3ac 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -3,9 +3,9 @@
 
 import pandas as pd
 from pandas import Categorical, CategoricalIndex, Index, PeriodIndex, Series
+import pandas._testing as tm
 import pandas.core.common as com
 from pandas.tests.arrays.categorical.common import TestCategorical
-import pandas.util.testing as tm
 
 
 class TestCategoricalIndexingWithFactor(TestCategorical):
@@ -63,7 +63,8 @@ def test_setitem_different_unordered_raises(self, other):
         # GH-24142
         target = pd.Categorical(["a", "b"], categories=["a", "b"])
         mask = np.array([True, False])
-        with pytest.raises(ValueError):
+        msg = "Cannot set a Categorical with another, without identical categories"
+        with pytest.raises(ValueError, match=msg):
             target[mask] = other[mask]
 
     @pytest.mark.parametrize(
@@ -78,8 +79,8 @@ def test_setitem_same_ordered_rasies(self, other):
         # Gh-24142
         target = pd.Categorical(["a", "b"], categories=["a", "b"], ordered=True)
         mask = np.array([True, False])
-
-        with pytest.raises(ValueError):
+        msg = "Cannot set a Categorical with another, without identical categories"
+        with pytest.raises(ValueError, match=msg):
             target[mask] = other[mask]
 
 
@@ -152,13 +153,15 @@ def test_categories_assigments(self):
         tm.assert_numpy_array_equal(s.__array__(), exp)
         tm.assert_index_equal(s.categories, Index([1, 2, 3]))
 
-        # lengthen
-        with pytest.raises(ValueError):
-            s.categories = [1, 2, 3, 4]
-
-        # shorten
-        with pytest.raises(ValueError):
-            s.categories = [1, 2]
+    @pytest.mark.parametrize("new_categories", [[1, 2, 3, 4], [1, 2]])
+    def test_categories_assigments_wrong_length_raises(self, new_categories):
+        cat = Categorical(["a", "b", "c", "a"])
+        msg = (
+            "new categories need to have the same number of items "
+            "as the old categories!"
+        )
+        with pytest.raises(ValueError, match=msg):
+            cat.categories = new_categories
 
     # Combinations of sorted/unique:
     @pytest.mark.parametrize(
@@ -206,13 +209,11 @@ def test_where_other_categorical(self):
         expected = pd.Series(Categorical(["a", "c", "c"], dtype=ser.dtype))
         tm.assert_series_equal(result, expected)
 
-    def test_where_warns(self):
+    def test_where_new_category_raises(self):
         ser = pd.Series(Categorical(["a", "b", "c"]))
-        with tm.assert_produces_warning(FutureWarning):
-            result = ser.where([True, False, True], "d")
-
-        expected = pd.Series(np.array(["a", "d", "c"], dtype="object"))
-        tm.assert_series_equal(result, expected)
+        msg = "Cannot setitem on a Categorical with a new category"
+        with pytest.raises(ValueError, match=msg):
+            ser.where([True, False, True], "d")
 
     def test_where_ordered_differs_rasies(self):
         ser = pd.Series(
@@ -221,11 +222,8 @@ def test_where_ordered_differs_rasies(self):
         other = Categorical(
             ["b", "c", "a"], categories=["a", "c", "b", "d"], ordered=True
         )
-        with tm.assert_produces_warning(FutureWarning):
-            result = ser.where([True, False, True], other)
-
-        expected = pd.Series(np.array(["a", "c", "c"], dtype=object))
-        tm.assert_series_equal(result, expected)
+        with pytest.raises(ValueError, match="without identical categories"):
+            ser.where([True, False, True], other)
 
 
 @pytest.mark.parametrize("index", [True, False])
diff --git a/pandas/tests/arrays/categorical/test_missing.py b/pandas/tests/arrays/categorical/test_missing.py
index 3037ac79cd592..8889f45a84237 100644
--- a/pandas/tests/arrays/categorical/test_missing.py
+++ b/pandas/tests/arrays/categorical/test_missing.py
@@ -6,7 +6,7 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
 from pandas import Categorical, Index, Series, isna
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCategoricalMissing:
@@ -77,7 +77,7 @@ def test_fillna_iterable_category(self, named):
             Point = collections.namedtuple("Point", "x y")
         else:
             Point = lambda *args: args  # tuple
-        cat = Categorical([Point(0, 0), Point(0, 1), None])
+        cat = Categorical(np.array([Point(0, 0), Point(0, 1), None], dtype=object))
         result = cat.fillna(Point(0, 0))
         expected = Categorical([Point(0, 0), Point(0, 1), Point(0, 0)])
 
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 22c1d5373372a..0c830c65e0f8b 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -6,8 +6,8 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Series, date_range
+import pandas._testing as tm
 from pandas.tests.arrays.categorical.common import TestCategorical
-import pandas.util.testing as tm
 
 
 class TestCategoricalOpsWithFactor(TestCategorical):
@@ -48,7 +48,7 @@ def test_comparisons(self):
         tm.assert_numpy_array_equal(result, expected)
 
         result = self.factor == "d"
-        expected = np.repeat(False, len(self.factor))
+        expected = np.zeros(len(self.factor), dtype=bool)
         tm.assert_numpy_array_equal(result, expected)
 
         # comparisons with categoricals
@@ -73,26 +73,32 @@ def test_comparisons(self):
         tm.assert_numpy_array_equal(res, exp)
 
         # Only categories with same categories can be compared
-        with pytest.raises(TypeError):
+        msg = "Categoricals can only be compared if 'categories' are the same"
+        with pytest.raises(TypeError, match=msg):
             cat > cat_rev
 
         cat_rev_base2 = Categorical(["b", "b", "b"], categories=["c", "b", "a", "d"])
 
-        with pytest.raises(TypeError):
+        msg = (
+            "Categoricals can only be compared if 'categories' are the same. "
+            "Categories are different lengths"
+        )
+        with pytest.raises(TypeError, match=msg):
             cat_rev > cat_rev_base2
 
         # Only categories with same ordering information can be compared
         cat_unorderd = cat.set_ordered(False)
         assert not (cat > cat).any()
 
-        with pytest.raises(TypeError):
+        msg = "Categoricals can only be compared if 'ordered' is the same"
+        with pytest.raises(TypeError, match=msg):
             cat > cat_unorderd
 
         # comparison (in both directions) with Series will raise
         s = Series(["b", "b", "b"])
         msg = (
-            "Cannot compare a Categorical for op __gt__ with type"
-            r" <class 'numpy\.ndarray'>"
+            "Cannot compare a Categorical for op __gt__ with type "
+            r"<class 'numpy\.ndarray'>"
         )
         with pytest.raises(TypeError, match=msg):
             cat > s
@@ -131,18 +137,6 @@ def test_compare_frame(self):
 
         df = DataFrame(cat)
 
-        for op in [
-            operator.eq,
-            operator.ne,
-            operator.ge,
-            operator.gt,
-            operator.le,
-            operator.lt,
-        ]:
-            with pytest.raises(ValueError):
-                # alignment raises unless we transpose
-                op(cat, df)
-
         result = cat == df.T
         expected = DataFrame([[True, True, True, True]])
         tm.assert_frame_equal(result, expected)
@@ -151,6 +145,15 @@ def test_compare_frame(self):
         expected = DataFrame([[False, True, True, False]])
         tm.assert_frame_equal(result, expected)
 
+    def test_compare_frame_raises(self, all_compare_operators):
+        # alignment raises unless we transpose
+        op = getattr(operator, all_compare_operators)
+        cat = Categorical(["a", "b", 2, "a"])
+        df = DataFrame(cat)
+        msg = "Unable to coerce to Series, length must be 1: given 4"
+        with pytest.raises(ValueError, match=msg):
+            op(cat, df)
+
     def test_datetime_categorical_comparison(self):
         dt_cat = Categorical(date_range("2014-01-01", periods=3), ordered=True)
         tm.assert_numpy_array_equal(dt_cat > dt_cat[0], np.array([False, True, True]))
@@ -169,8 +172,8 @@ def test_comparison_with_unknown_scalars(self):
         cat = Categorical([1, 2, 3], ordered=True)
 
         msg = (
-            "Cannot compare a Categorical for op __{}__ with a scalar,"
-            " which is not a category"
+            "Cannot compare a Categorical for op __{}__ with a scalar, "
+            "which is not a category"
         )
         with pytest.raises(TypeError, match=msg.format("lt")):
             cat < 4
@@ -255,14 +258,15 @@ def test_comparisons(self, data, reverse, base):
         tm.assert_numpy_array_equal(res_rev.values, exp_rev2)
 
         # Only categories with same categories can be compared
-        with pytest.raises(TypeError):
+        msg = "Categoricals can only be compared if 'categories' are the same"
+        with pytest.raises(TypeError, match=msg):
             cat > cat_rev
 
         # categorical cannot be compared to Series or numpy array, and also
         # not the other way around
         msg = (
-            "Cannot compare a Categorical for op __gt__ with type"
-            r" <class 'numpy\.ndarray'>"
+            "Cannot compare a Categorical for op __gt__ with type "
+            r"<class 'numpy\.ndarray'>"
         )
         with pytest.raises(TypeError, match=msg):
             cat > s
@@ -367,7 +371,9 @@ def test_numeric_like_ops(self):
 
         # numpy ops
         s = Series(Categorical([1, 2, 3, 4]))
-        with pytest.raises(TypeError):
+        with pytest.raises(
+            TypeError, match="Categorical cannot perform the operation sum"
+        ):
             np.sum(s)
 
         # numeric ops on a Series
@@ -384,7 +390,8 @@ def test_numeric_like_ops(self):
                 getattr(s, op)(2)
 
         # invalid ufunc
-        with pytest.raises(TypeError):
+        msg = "Object with dtype category cannot perform the numpy op log"
+        with pytest.raises(TypeError, match=msg):
             np.log(s)
 
     def test_contains(self):
@@ -394,7 +401,7 @@ def test_contains(self):
         assert "b" in c
         assert "z" not in c
         assert np.nan not in c
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match="unhashable type: 'list'"):
             assert [1] in c
 
         # assert codes NOT in index
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index 9321813b42b33..d08c4b47dd3cb 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -147,8 +147,6 @@ def test_categorical_repr_datetime(self):
         idx = date_range("2011-01-01 09:00", freq="H", periods=5)
         c = Categorical(idx)
 
-        # TODO(wesm): exceeding 80 characters in the console is not good
-        # behavior
         exp = (
             "[2011-01-01 09:00:00, 2011-01-01 10:00:00, 2011-01-01 11:00:00, "
             "2011-01-01 12:00:00, 2011-01-01 13:00:00]\n"
diff --git a/pandas/tests/arrays/categorical/test_sorting.py b/pandas/tests/arrays/categorical/test_sorting.py
index a0b09e19ece6e..2a0ef043bf9a9 100644
--- a/pandas/tests/arrays/categorical/test_sorting.py
+++ b/pandas/tests/arrays/categorical/test_sorting.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import Categorical, Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCategoricalSort:
diff --git a/pandas/tests/arrays/categorical/test_subclass.py b/pandas/tests/arrays/categorical/test_subclass.py
index cfc7b8541302f..b80d0ff41aba6 100644
--- a/pandas/tests/arrays/categorical/test_subclass.py
+++ b/pandas/tests/arrays/categorical/test_subclass.py
@@ -1,5 +1,5 @@
 from pandas import Categorical
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCategoricalSubclassing:
diff --git a/pandas/tests/arrays/categorical/test_warnings.py b/pandas/tests/arrays/categorical/test_warnings.py
index 53733770ed954..9e164a250cdb1 100644
--- a/pandas/tests/arrays/categorical/test_warnings.py
+++ b/pandas/tests/arrays/categorical/test_warnings.py
@@ -1,29 +1,29 @@
 import pytest
 
-import pandas as pd
-import pandas.util.testing as tm
+from pandas.util._test_decorators import async_mark
+
+import pandas._testing as tm
 
 
 class TestCategoricalWarnings:
-    def test_tab_complete_warning(self, ip):
+    @async_mark()
+    async def test_tab_complete_warning(self, ip):
         # https://github.com/pandas-dev/pandas/issues/16409
         pytest.importorskip("IPython", minversion="6.0.0")
         from IPython.core.completer import provisionalcompleter
 
         code = "import pandas as pd; c = Categorical([])"
-        ip.run_code(code)
-        with tm.assert_produces_warning(None):
-            with provisionalcompleter("ignore"):
-                list(ip.Completer.completions("c.", 1))
+        await ip.run_code(code)
 
-    def test_CategoricalAccessor_categorical_deprecation(self):
-        with tm.assert_produces_warning(FutureWarning):
-            pd.Series(["a", "b"], dtype="category").cat.categorical
+        # GH 31324 newer jedi version raises Deprecation warning
+        import jedi
 
-    def test_CategoricalAccessor_name_deprecation(self):
-        with tm.assert_produces_warning(FutureWarning):
-            pd.Series(["a", "b"], dtype="category").cat.name
-
-    def test_CategoricalAccessor_index_deprecation(self):
-        with tm.assert_produces_warning(FutureWarning):
-            pd.Series(["a", "b"], dtype="category").cat.index
+        if jedi.__version__ < "0.16.0":
+            warning = tm.assert_produces_warning(None)
+        else:
+            warning = tm.assert_produces_warning(
+                DeprecationWarning, check_stacklevel=False
+            )
+        with warning:
+            with provisionalcompleter("ignore"):
+                list(ip.Completer.completions("c.", 1))
diff --git a/pandas/tests/arrays/interval/test_interval.py b/pandas/tests/arrays/interval/test_interval.py
index 655a6e717119b..7e7762d8973a0 100644
--- a/pandas/tests/arrays/interval/test_interval.py
+++ b/pandas/tests/arrays/interval/test_interval.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 import pandas as pd
 from pandas import (
     Index,
@@ -11,8 +13,8 @@
     date_range,
     timedelta_range,
 )
+import pandas._testing as tm
 from pandas.core.arrays import IntervalArray
-import pandas.util.testing as tm
 
 
 @pytest.fixture(
@@ -79,6 +81,24 @@ def test_where_raises(self, other):
         with pytest.raises(ValueError, match=match):
             ser.where([True, False, True], other=other)
 
+    def test_shift(self):
+        # https://github.com/pandas-dev/pandas/issues/31495
+        a = IntervalArray.from_breaks([1, 2, 3])
+        result = a.shift()
+        # int -> float
+        expected = IntervalArray.from_tuples([(np.nan, np.nan), (1.0, 2.0)])
+        tm.assert_interval_array_equal(result, expected)
+
+    def test_shift_datetime(self):
+        a = IntervalArray.from_breaks(pd.date_range("2000", periods=4))
+        result = a.shift(2)
+        expected = a.take([-1, -1, 0], allow_fill=True)
+        tm.assert_interval_array_equal(result, expected)
+
+        result = a.shift(-1)
+        expected = a.take([1, 2, -1], allow_fill=True)
+        tm.assert_interval_array_equal(result, expected)
+
 
 class TestSetitem:
     def test_set_na(self, left_right_dtypes):
@@ -103,3 +123,110 @@ def test_repr():
         "Length: 2, closed: right, dtype: interval[int64]"
     )
     assert result == expected
+
+
+# ----------------------------------------------------------------------------
+# Arrow interaction
+
+
+pyarrow_skip = td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+
+
+@pyarrow_skip
+def test_arrow_extension_type():
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+
+    p1 = ArrowIntervalType(pa.int64(), "left")
+    p2 = ArrowIntervalType(pa.int64(), "left")
+    p3 = ArrowIntervalType(pa.int64(), "right")
+
+    assert p1.closed == "left"
+    assert p1 == p2
+    assert not p1 == p3
+    assert hash(p1) == hash(p2)
+    assert not hash(p1) == hash(p3)
+
+
+@pyarrow_skip
+def test_arrow_array():
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+
+    intervals = pd.interval_range(1, 5, freq=1).array
+
+    result = pa.array(intervals)
+    assert isinstance(result.type, ArrowIntervalType)
+    assert result.type.closed == intervals.closed
+    assert result.type.subtype == pa.int64()
+    assert result.storage.field("left").equals(pa.array([1, 2, 3, 4], type="int64"))
+    assert result.storage.field("right").equals(pa.array([2, 3, 4, 5], type="int64"))
+
+    expected = pa.array([{"left": i, "right": i + 1} for i in range(1, 5)])
+    assert result.storage.equals(expected)
+
+    # convert to its storage type
+    result = pa.array(intervals, type=expected.type)
+    assert result.equals(expected)
+
+    # unsupported conversions
+    with pytest.raises(TypeError, match="Not supported to convert IntervalArray"):
+        pa.array(intervals, type="float64")
+
+    with pytest.raises(TypeError, match="different 'subtype'"):
+        pa.array(intervals, type=ArrowIntervalType(pa.float64(), "left"))
+
+
+@pyarrow_skip
+def test_arrow_array_missing():
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+
+    arr = IntervalArray.from_breaks([0, 1, 2, 3])
+    arr[1] = None
+
+    result = pa.array(arr)
+    assert isinstance(result.type, ArrowIntervalType)
+    assert result.type.closed == arr.closed
+    assert result.type.subtype == pa.float64()
+
+    # fields have missing values (not NaN)
+    left = pa.array([0.0, None, 2.0], type="float64")
+    right = pa.array([1.0, None, 3.0], type="float64")
+    assert result.storage.field("left").equals(left)
+    assert result.storage.field("right").equals(right)
+
+    # structarray itself also has missing values on the array level
+    vals = [
+        {"left": 0.0, "right": 1.0},
+        {"left": None, "right": None},
+        {"left": 2.0, "right": 3.0},
+    ]
+    expected = pa.StructArray.from_pandas(vals, mask=np.array([False, True, False]))
+    assert result.storage.equals(expected)
+
+
+@pyarrow_skip
+@pytest.mark.parametrize(
+    "breaks",
+    [[0, 1, 2, 3], pd.date_range("2017", periods=4, freq="D")],
+    ids=["int", "datetime64[ns]"],
+)
+def test_arrow_table_roundtrip(breaks):
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowIntervalType
+
+    arr = IntervalArray.from_breaks(breaks)
+    arr[1] = None
+    df = pd.DataFrame({"a": arr})
+
+    table = pa.table(df)
+    assert isinstance(table.field("a").type, ArrowIntervalType)
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, pd.IntervalDtype)
+    tm.assert_frame_equal(result, df)
+
+    table2 = pa.concat_tables([table, table])
+    result = table2.to_pandas()
+    expected = pd.concat([df, df], ignore_index=True)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/arrays/interval/test_ops.py b/pandas/tests/arrays/interval/test_ops.py
index 43601ea301568..b4de80dc00a4e 100644
--- a/pandas/tests/arrays/interval/test_ops.py
+++ b/pandas/tests/arrays/interval/test_ops.py
@@ -3,8 +3,8 @@
 import pytest
 
 from pandas import Interval, IntervalIndex, Timedelta, Timestamp
+import pandas._testing as tm
 from pandas.core.arrays import IntervalArray
-import pandas.util.testing as tm
 
 
 @pytest.fixture(params=[IntervalArray, IntervalIndex])
@@ -83,8 +83,6 @@ def test_overlaps_na(self, constructor, start_shift):
     )
     def test_overlaps_invalid_type(self, constructor, other):
         interval_container = constructor.from_breaks(range(5))
-        msg = "`other` must be Interval-like, got {other}".format(
-            other=type(other).__name__
-        )
+        msg = f"`other` must be Interval-like, got {type(other).__name__}"
         with pytest.raises(TypeError, match=msg):
             interval_container.overlaps(other)
diff --git a/pandas/tests/arrays/sparse/test_accessor.py b/pandas/tests/arrays/sparse/test_accessor.py
index eab174862818c..d8a1831cd61ec 100644
--- a/pandas/tests/arrays/sparse/test_accessor.py
+++ b/pandas/tests/arrays/sparse/test_accessor.py
@@ -6,7 +6,8 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
 
 
 class TestSeriesAccessor:
@@ -31,7 +32,7 @@ def test_accessor_raises(self):
     def test_from_spmatrix(self, format, labels, dtype):
         import scipy.sparse
 
-        sp_dtype = pd.SparseDtype(dtype, np.array(0, dtype=dtype).item())
+        sp_dtype = SparseDtype(dtype, np.array(0, dtype=dtype).item())
 
         mat = scipy.sparse.eye(10, format=format, dtype=dtype)
         result = pd.DataFrame.sparse.from_spmatrix(mat, index=labels, columns=labels)
@@ -48,7 +49,7 @@ def test_from_spmatrix(self, format, labels, dtype):
     def test_from_spmatrix_columns(self, columns):
         import scipy.sparse
 
-        dtype = pd.SparseDtype("float64", 0.0)
+        dtype = SparseDtype("float64", 0.0)
 
         mat = scipy.sparse.random(10, 2, density=0.5)
         result = pd.DataFrame.sparse.from_spmatrix(mat, columns=columns)
@@ -67,9 +68,9 @@ def test_to_coo(self):
     def test_to_dense(self):
         df = pd.DataFrame(
             {
-                "A": pd.SparseArray([1, 0], dtype=pd.SparseDtype("int64", 0)),
-                "B": pd.SparseArray([1, 0], dtype=pd.SparseDtype("int64", 1)),
-                "C": pd.SparseArray([1.0, 0.0], dtype=pd.SparseDtype("float64", 0.0)),
+                "A": SparseArray([1, 0], dtype=SparseDtype("int64", 0)),
+                "B": SparseArray([1, 0], dtype=SparseDtype("int64", 1)),
+                "C": SparseArray([1.0, 0.0], dtype=SparseDtype("float64", 0.0)),
             },
             index=["b", "a"],
         )
@@ -82,8 +83,8 @@ def test_to_dense(self):
     def test_density(self):
         df = pd.DataFrame(
             {
-                "A": pd.SparseArray([1, 0, 2, 1], fill_value=0),
-                "B": pd.SparseArray([0, 1, 1, 1], fill_value=0),
+                "A": SparseArray([1, 0, 2, 1], fill_value=0),
+                "B": SparseArray([0, 1, 1, 1], fill_value=0),
             }
         )
         res = df.sparse.density
@@ -99,9 +100,7 @@ def test_series_from_coo(self, dtype, dense_index):
         A = scipy.sparse.eye(3, format="coo", dtype=dtype)
         result = pd.Series.sparse.from_coo(A, dense_index=dense_index)
         index = pd.MultiIndex.from_tuples([(0, 0), (1, 1), (2, 2)])
-        expected = pd.Series(
-            pd.SparseArray(np.array([1, 1, 1], dtype=dtype)), index=index
-        )
+        expected = pd.Series(SparseArray(np.array([1, 1, 1], dtype=dtype)), index=index)
         if dense_index:
             expected = expected.reindex(pd.MultiIndex.from_product(index.levels))
 
@@ -117,3 +116,8 @@ def test_series_from_coo_incorrect_format_raises(self):
             TypeError, match="Expected coo_matrix. Got csr_matrix instead."
         ):
             pd.Series.sparse.from_coo(m)
+
+    def test_with_column_named_sparse(self):
+        # https://github.com/pandas-dev/pandas/issues/30758
+        df = pd.DataFrame({"sparse": pd.arrays.SparseArray([1, 2])})
+        assert isinstance(df.sparse, pd.core.arrays.sparse.accessor.SparseFrameAccessor)
diff --git a/pandas/tests/arrays/sparse/test_arithmetics.py b/pandas/tests/arrays/sparse/test_arithmetics.py
index cb5b437c962f9..bf7d275e4ff7b 100644
--- a/pandas/tests/arrays/sparse/test_arithmetics.py
+++ b/pandas/tests/arrays/sparse/test_arithmetics.py
@@ -4,9 +4,9 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core import ops
-from pandas.core.sparse.api import SparseDtype
-import pandas.util.testing as tm
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
 
 
 @pytest.fixture(params=["integer", "block"])
@@ -21,12 +21,10 @@ def mix(request):
     return request.param
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
 class TestSparseArrayArithmetics:
 
     _base = np.array
-    _klass = pd.SparseArray
+    _klass = SparseArray
 
     def _assert(self, a, b):
         tm.assert_numpy_array_equal(a, b)
@@ -390,60 +388,26 @@ def test_mixed_array_comparison(self, kind):
         assert b.dtype == SparseDtype(rdtype, fill_value=2)
         self._check_comparison_ops(a, b, values, rvalues)
 
-
-class TestSparseSeriesArithmetic(TestSparseArrayArithmetics):
-
-    _base = pd.Series
-    _klass = pd.SparseSeries
-
-    def _assert(self, a, b):
-        tm.assert_series_equal(a, b)
-
-    def test_alignment(self, mix, all_arithmetic_functions):
-        op = all_arithmetic_functions
-
-        da = pd.Series(np.arange(4))
-        db = pd.Series(np.arange(4), index=[1, 2, 3, 4])
-
-        sa = pd.SparseSeries(np.arange(4), dtype=np.int64, fill_value=0)
-        sb = pd.SparseSeries(
-            np.arange(4), index=[1, 2, 3, 4], dtype=np.int64, fill_value=0
-        )
-        self._check_numeric_ops(sa, sb, da, db, mix, op)
-
-        sa = pd.SparseSeries(np.arange(4), dtype=np.int64, fill_value=np.nan)
-        sb = pd.SparseSeries(
-            np.arange(4), index=[1, 2, 3, 4], dtype=np.int64, fill_value=np.nan
-        )
-        self._check_numeric_ops(sa, sb, da, db, mix, op)
-
-        da = pd.Series(np.arange(4))
-        db = pd.Series(np.arange(4), index=[10, 11, 12, 13])
-
-        sa = pd.SparseSeries(np.arange(4), dtype=np.int64, fill_value=0)
-        sb = pd.SparseSeries(
-            np.arange(4), index=[10, 11, 12, 13], dtype=np.int64, fill_value=0
-        )
-        self._check_numeric_ops(sa, sb, da, db, mix, op)
-
-        sa = pd.SparseSeries(np.arange(4), dtype=np.int64, fill_value=np.nan)
-        sb = pd.SparseSeries(
-            np.arange(4), index=[10, 11, 12, 13], dtype=np.int64, fill_value=np.nan
-        )
-        self._check_numeric_ops(sa, sb, da, db, mix, op)
+    def test_xor(self):
+        s = SparseArray([True, True, False, False])
+        t = SparseArray([True, False, True, False])
+        result = s ^ t
+        sp_index = pd.core.arrays.sparse.IntIndex(4, np.array([0, 1, 2], dtype="int32"))
+        expected = SparseArray([False, True, True], sparse_index=sp_index)
+        tm.assert_sp_array_equal(result, expected)
 
 
 @pytest.mark.parametrize("op", [operator.eq, operator.add])
 def test_with_list(op):
-    arr = pd.SparseArray([0, 1], fill_value=0)
+    arr = SparseArray([0, 1], fill_value=0)
     result = op(arr, [0, 1])
-    expected = op(arr, pd.SparseArray([0, 1]))
+    expected = op(arr, SparseArray([0, 1]))
     tm.assert_sp_array_equal(result, expected)
 
 
 def test_with_dataframe():
     # GH#27910
-    arr = pd.SparseArray([0, 1], fill_value=0)
+    arr = SparseArray([0, 1], fill_value=0)
     df = pd.DataFrame([[1, 2], [3, 4]])
     result = arr.__add__(df)
     assert result is NotImplemented
@@ -451,7 +415,7 @@ def test_with_dataframe():
 
 def test_with_zerodim_ndarray():
     # GH#27910
-    arr = pd.SparseArray([0, 1], fill_value=0)
+    arr = SparseArray([0, 1], fill_value=0)
 
     result = arr * np.array(2)
     expected = arr * 2
@@ -460,23 +424,23 @@ def test_with_zerodim_ndarray():
 
 @pytest.mark.parametrize("ufunc", [np.abs, np.exp])
 @pytest.mark.parametrize(
-    "arr", [pd.SparseArray([0, 0, -1, 1]), pd.SparseArray([None, None, -1, 1])]
+    "arr", [SparseArray([0, 0, -1, 1]), SparseArray([None, None, -1, 1])]
 )
 def test_ufuncs(ufunc, arr):
     result = ufunc(arr)
     fill_value = ufunc(arr.fill_value)
-    expected = pd.SparseArray(ufunc(np.asarray(arr)), fill_value=fill_value)
+    expected = SparseArray(ufunc(np.asarray(arr)), fill_value=fill_value)
     tm.assert_sp_array_equal(result, expected)
 
 
 @pytest.mark.parametrize(
     "a, b",
     [
-        (pd.SparseArray([0, 0, 0]), np.array([0, 1, 2])),
-        (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
-        (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
-        (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
-        (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0]), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+        (SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
     ],
 )
 @pytest.mark.parametrize("ufunc", [np.add, np.greater])
@@ -484,12 +448,12 @@ def test_binary_ufuncs(ufunc, a, b):
     # can't say anything about fill value here.
     result = ufunc(a, b)
     expected = ufunc(np.asarray(a), np.asarray(b))
-    assert isinstance(result, pd.SparseArray)
+    assert isinstance(result, SparseArray)
     tm.assert_numpy_array_equal(np.asarray(result), expected)
 
 
 def test_ndarray_inplace():
-    sparray = pd.SparseArray([0, 2, 0, 0])
+    sparray = SparseArray([0, 2, 0, 0])
     ndarray = np.array([0, 1, 2, 3])
     ndarray += sparray
     expected = np.array([0, 3, 2, 3])
@@ -497,27 +461,35 @@ def test_ndarray_inplace():
 
 
 def test_sparray_inplace():
-    sparray = pd.SparseArray([0, 2, 0, 0])
+    sparray = SparseArray([0, 2, 0, 0])
     ndarray = np.array([0, 1, 2, 3])
     sparray += ndarray
-    expected = pd.SparseArray([0, 3, 2, 3], fill_value=0)
+    expected = SparseArray([0, 3, 2, 3], fill_value=0)
     tm.assert_sp_array_equal(sparray, expected)
 
 
 @pytest.mark.parametrize("fill_value", [True, False])
 def test_invert(fill_value):
     arr = np.array([True, False, False, True])
-    sparray = pd.SparseArray(arr, fill_value=fill_value)
+    sparray = SparseArray(arr, fill_value=fill_value)
     result = ~sparray
-    expected = pd.SparseArray(~arr, fill_value=not fill_value)
+    expected = SparseArray(~arr, fill_value=not fill_value)
     tm.assert_sp_array_equal(result, expected)
 
+    result = ~pd.Series(sparray)
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)
+
+    result = ~pd.DataFrame({"A": sparray})
+    expected = pd.DataFrame({"A": expected})
+    tm.assert_frame_equal(result, expected)
+
 
 @pytest.mark.parametrize("fill_value", [0, np.nan])
 @pytest.mark.parametrize("op", [operator.pos, operator.neg])
 def test_unary_op(op, fill_value):
     arr = np.array([0, 1, np.nan, 2])
-    sparray = pd.SparseArray(arr, fill_value=fill_value)
+    sparray = SparseArray(arr, fill_value=fill_value)
     result = op(sparray)
-    expected = pd.SparseArray(op(arr), fill_value=op(fill_value))
+    expected = SparseArray(op(arr), fill_value=op(fill_value))
     tm.assert_sp_array_equal(result, expected)
diff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py
index b94e2a16d217a..baca18239b929 100644
--- a/pandas/tests/arrays/sparse/test_array.py
+++ b/pandas/tests/arrays/sparse/test_array.py
@@ -10,9 +10,8 @@
 
 import pandas as pd
 from pandas import isna
-from pandas.core.sparse.api import SparseArray, SparseDtype, SparseSeries
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
 
 
 @pytest.fixture(params=["integer", "block"])
@@ -221,36 +220,6 @@ def test_scalar_with_index_infer_dtype(self, scalar, dtype):
         assert arr.dtype == dtype
         assert exp.dtype == dtype
 
-    @pytest.mark.parametrize("fill", [1, np.nan, 0])
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_sparse_series_round_trip(self, kind, fill):
-        # see gh-13999
-        arr = SparseArray([np.nan, 1, np.nan, 2, 3], kind=kind, fill_value=fill)
-        res = SparseArray(SparseSeries(arr))
-        tm.assert_sp_array_equal(arr, res)
-
-        arr = SparseArray(
-            [0, 0, 0, 1, 1, 2], dtype=np.int64, kind=kind, fill_value=fill
-        )
-        res = SparseArray(SparseSeries(arr), dtype=np.int64)
-        tm.assert_sp_array_equal(arr, res)
-
-        res = SparseArray(SparseSeries(arr))
-        tm.assert_sp_array_equal(arr, res)
-
-    @pytest.mark.parametrize("fill", [True, False, np.nan])
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_sparse_series_round_trip2(self, kind, fill):
-        # see gh-13999
-        arr = SparseArray(
-            [True, False, True, True], dtype=np.bool, kind=kind, fill_value=fill
-        )
-        res = SparseArray(SparseSeries(arr))
-        tm.assert_sp_array_equal(arr, res)
-
-        res = SparseArray(SparseSeries(arr))
-        tm.assert_sp_array_equal(arr, res)
-
     def test_get_item(self):
 
         assert np.isnan(self.arr[1])
@@ -338,11 +307,12 @@ def test_take_filling(self):
         with pytest.raises(ValueError, match=msg):
             sparse.take(np.array([1, 0, -5]), allow_fill=True)
 
-        with pytest.raises(IndexError):
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]), allow_fill=True)
 
     def test_take_filling_fill_value(self):
@@ -371,11 +341,12 @@ def test_take_filling_fill_value(self):
         with pytest.raises(ValueError, match=msg):
             sparse.take(np.array([1, 0, -5]), allow_fill=True)
 
-        with pytest.raises(IndexError):
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]), fill_value=True)
 
     def test_take_filling_all_nan(self):
@@ -389,11 +360,12 @@ def test_take_filling_all_nan(self):
         expected = SparseArray([np.nan, np.nan, np.nan], kind="block")
         tm.assert_sp_array_equal(result, expected)
 
-        with pytest.raises(IndexError):
+        msg = "out of bounds value in 'indices'"
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, -6]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]))
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             sparse.take(np.array([1, 5]), fill_value=True)
 
     def test_set_item(self):
@@ -416,7 +388,7 @@ def test_constructor_from_too_large_array(self):
     def test_constructor_from_sparse(self):
         res = SparseArray(self.zarr)
         assert res.fill_value == 0
-        assert_almost_equal(res.sp_values, self.zarr.sp_values)
+        tm.assert_almost_equal(res.sp_values, self.zarr.sp_values)
 
     def test_constructor_copy(self):
         cp = SparseArray(self.arr, copy=True)
@@ -498,7 +470,7 @@ def test_astype(self):
             arr.astype("Sparse[i8]")
 
     def test_astype_bool(self):
-        a = pd.SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
+        a = SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
         result = a.astype(bool)
         expected = SparseArray([True, 0, 0, True], dtype=SparseDtype(bool, 0))
         tm.assert_sp_array_equal(result, expected)
@@ -616,7 +588,7 @@ def test_copy(self):
         assert arr2.sp_index is self.arr.sp_index
 
     def test_values_asarray(self):
-        assert_almost_equal(self.arr.to_dense(), self.arr_data)
+        tm.assert_almost_equal(self.arr.to_dense(), self.arr_data)
 
     @pytest.mark.parametrize(
         "data,shape,dtype",
@@ -648,14 +620,13 @@ def test_dense_repr(self, vals, fill_value):
         res = arr.to_dense()
         tm.assert_numpy_array_equal(res, vals)
 
-        with tm.assert_produces_warning(FutureWarning):
-            res2 = arr.get_values()
+        res2 = arr._internal_get_values()
 
         tm.assert_numpy_array_equal(res2, vals)
 
     def test_getitem(self):
         def _checkit(i):
-            assert_almost_equal(self.arr[i], self.arr.to_dense()[i])
+            tm.assert_almost_equal(self.arr[i], self.arr.to_dense()[i])
 
         for i in range(len(self.arr)):
             _checkit(i)
@@ -689,24 +660,29 @@ def test_getslice_tuple(self):
         dense = np.array([np.nan, 0, 3, 4, 0, 5, np.nan, np.nan, 0])
 
         sparse = SparseArray(dense)
-        res = sparse[4:,]  # noqa: E231
+        res = sparse[
+            4:,
+        ]  # noqa: E231
         exp = SparseArray(dense[4:,])  # noqa: E231
         tm.assert_sp_array_equal(res, exp)
 
         sparse = SparseArray(dense, fill_value=0)
-        res = sparse[4:,]  # noqa: E231
+        res = sparse[
+            4:,
+        ]  # noqa: E231
         exp = SparseArray(dense[4:,], fill_value=0)  # noqa: E231
         tm.assert_sp_array_equal(res, exp)
 
-        with pytest.raises(IndexError):
+        msg = "too many indices for array"
+        with pytest.raises(IndexError, match=msg):
             sparse[4:, :]
 
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             # check numpy compat
             dense[4:, :]
 
     def test_boolean_slice_empty(self):
-        arr = pd.SparseArray([0, 1, 2])
+        arr = SparseArray([0, 1, 2])
         res = arr[[False, False, False]]
         assert res.dtype == arr.dtype
 
@@ -733,7 +709,7 @@ def _check_op(op, first, second):
                 op(first.to_dense(), second.to_dense()), fill_value=first.fill_value
             )
             assert isinstance(res, SparseArray)
-            assert_almost_equal(res.to_dense(), exp.to_dense())
+            tm.assert_almost_equal(res.to_dense(), exp.to_dense())
 
             res2 = op(first, second.to_dense())
             assert isinstance(res2, SparseArray)
@@ -753,8 +729,8 @@ def _check_op(op, first, second):
             except ValueError:
                 pass
             else:
-                assert_almost_equal(res4.fill_value, exp_fv)
-                assert_almost_equal(res4.to_dense(), exp)
+                tm.assert_almost_equal(res4.fill_value, exp_fv)
+                tm.assert_almost_equal(res4.to_dense(), exp)
 
         with np.errstate(all="ignore"):
             for first_arr, second_arr in [(arr1, arr2), (farr1, farr2)]:
@@ -852,13 +828,13 @@ def test_fillna_overlap(self):
 
     def test_nonzero(self):
         # Tests regression #21172.
-        sa = pd.SparseArray([float("nan"), float("nan"), 1, 0, 0, 2, 0, 0, 0, 3, 0, 0])
+        sa = SparseArray([float("nan"), float("nan"), 1, 0, 0, 2, 0, 0, 0, 3, 0, 0])
         expected = np.array([2, 5, 9], dtype=np.int32)
-        result, = sa.nonzero()
+        (result,) = sa.nonzero()
         tm.assert_numpy_array_equal(expected, result)
 
-        sa = pd.SparseArray([0, 0, 1, 0, 0, 2, 0, 0, 0, 3, 0, 0])
-        result, = sa.nonzero()
+        sa = SparseArray([0, 0, 1, 0, 0, 2, 0, 0, 0, 3, 0, 0])
+        (result,) = sa.nonzero()
         tm.assert_numpy_array_equal(expected, result)
 
 
@@ -1034,7 +1010,7 @@ def test_cumsum(self, data, expected, numpy):
                 np.cumsum(SparseArray(data), out=out)
         else:
             axis = 1  # SparseArray currently 1-D, so only axis = 0 is valid.
-            msg = "axis\\(={axis}\\) out of bounds".format(axis=axis)
+            msg = re.escape(f"axis(={axis}) out of bounds")
             with pytest.raises(ValueError, match=msg):
                 SparseArray(data).cumsum(axis=axis)
 
@@ -1110,11 +1086,11 @@ def test_ufunc_args(self):
     @pytest.mark.parametrize("fill_value", [0.0, np.nan])
     def test_modf(self, fill_value):
         # https://github.com/pandas-dev/pandas/issues/26946
-        sparse = pd.SparseArray([fill_value] * 10 + [1.1, 2.2], fill_value=fill_value)
+        sparse = SparseArray([fill_value] * 10 + [1.1, 2.2], fill_value=fill_value)
         r1, r2 = np.modf(sparse)
         e1, e2 = np.modf(np.asarray(sparse))
-        tm.assert_sp_array_equal(r1, pd.SparseArray(e1, fill_value=fill_value))
-        tm.assert_sp_array_equal(r2, pd.SparseArray(e2, fill_value=fill_value))
+        tm.assert_sp_array_equal(r1, SparseArray(e1, fill_value=fill_value))
+        tm.assert_sp_array_equal(r2, SparseArray(e2, fill_value=fill_value))
 
     def test_nbytes_integer(self):
         arr = SparseArray([1, 0, 0, 0, 2], kind="integer")
@@ -1130,7 +1106,7 @@ def test_nbytes_block(self):
         assert result == 24
 
     def test_asarray_datetime64(self):
-        s = pd.SparseArray(pd.to_datetime(["2012", None, None, "2013"]))
+        s = SparseArray(pd.to_datetime(["2012", None, None, "2013"]))
         np.asarray(s)
 
     def test_density(self):
@@ -1142,7 +1118,6 @@ def test_npoints(self):
         assert arr.npoints == 1
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 class TestAccessor:
     @pytest.mark.parametrize("attr", ["npoints", "density", "fill_value", "sp_values"])
     def test_get_attributes(self, attr):
@@ -1233,7 +1208,7 @@ def test_first_fill_value_loc(arr, loc):
 )
 @pytest.mark.parametrize("fill_value", [np.nan, 0, 1])
 def test_unique_na_fill(arr, fill_value):
-    a = pd.SparseArray(arr, fill_value=fill_value).unique()
+    a = SparseArray(arr, fill_value=fill_value).unique()
     b = pd.Series(arr).unique()
     assert isinstance(a, SparseArray)
     a = np.asarray(a)
@@ -1272,12 +1247,3 @@ def test_map_missing():
 
     result = arr.map({0: 10, 1: 11})
     tm.assert_sp_array_equal(result, expected)
-
-
-def test_deprecated_values():
-    arr = SparseArray([0, 1, 2])
-
-    with tm.assert_produces_warning(FutureWarning):
-        result = arr.values
-
-    tm.assert_numpy_array_equal(result, arr.to_dense())
diff --git a/pandas/tests/arrays/sparse/test_combine_concat.py b/pandas/tests/arrays/sparse/test_combine_concat.py
new file mode 100644
index 0000000000000..f1697dc9ff7ce
--- /dev/null
+++ b/pandas/tests/arrays/sparse/test_combine_concat.py
@@ -0,0 +1,31 @@
+import numpy as np
+import pytest
+
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+class TestSparseArrayConcat:
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_basic(self, kind):
+        a = SparseArray([1, 0, 0, 2], kind=kind)
+        b = SparseArray([1, 0, 2, 2], kind=kind)
+
+        result = SparseArray._concat_same_type([a, b])
+        # Can't make any assertions about the sparse index itself
+        # since we aren't don't merge sparse blocs across arrays
+        # in to_concat
+        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
+        tm.assert_numpy_array_equal(result.sp_values, expected)
+        assert result.kind == kind
+
+    @pytest.mark.parametrize("kind", ["integer", "block"])
+    def test_uses_first_kind(self, kind):
+        other = "integer" if kind == "block" else "block"
+        a = SparseArray([1, 0, 0, 2], kind=kind)
+        b = SparseArray([1, 0, 2, 2], kind=other)
+
+        result = SparseArray._concat_same_type([a, b])
+        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
+        tm.assert_numpy_array_equal(result.sp_values, expected)
+        assert result.kind == kind
diff --git a/pandas/tests/arrays/sparse/test_dtype.py b/pandas/tests/arrays/sparse/test_dtype.py
index db8f62962f0b0..5e9e2d854f577 100644
--- a/pandas/tests/arrays/sparse/test_dtype.py
+++ b/pandas/tests/arrays/sparse/test_dtype.py
@@ -1,8 +1,10 @@
+import re
+
 import numpy as np
 import pytest
 
 import pandas as pd
-from pandas.core.sparse.api import SparseDtype
+from pandas.core.arrays.sparse import SparseDtype
 
 
 @pytest.mark.parametrize(
@@ -80,7 +82,9 @@ def test_not_equal(a, b):
 
 
 def test_construct_from_string_raises():
-    with pytest.raises(TypeError):
+    with pytest.raises(
+        TypeError, match="Cannot construct a 'SparseDtype' from 'not a dtype'"
+    ):
         SparseDtype.construct_from_string("not a dtype")
 
 
@@ -175,9 +179,20 @@ def test_update_dtype(original, dtype, expected):
 
 
 @pytest.mark.parametrize(
-    "original, dtype",
-    [(SparseDtype(float, np.nan), int), (SparseDtype(str, "abc"), int)],
+    "original, dtype, expected_error_msg",
+    [
+        (
+            SparseDtype(float, np.nan),
+            int,
+            re.escape("Cannot convert non-finite values (NA or inf) to integer"),
+        ),
+        (
+            SparseDtype(str, "abc"),
+            int,
+            re.escape("invalid literal for int() with base 10: 'abc'"),
+        ),
+    ],
 )
-def test_update_dtype_raises(original, dtype):
-    with pytest.raises(ValueError):
+def test_update_dtype_raises(original, dtype, expected_error_msg):
+    with pytest.raises(ValueError, match=expected_error_msg):
         original.update_dtype(dtype)
diff --git a/pandas/tests/arrays/sparse/test_libsparse.py b/pandas/tests/arrays/sparse/test_libsparse.py
index a6836c58348b3..a2f861d378e67 100644
--- a/pandas/tests/arrays/sparse/test_libsparse.py
+++ b/pandas/tests/arrays/sparse/test_libsparse.py
@@ -7,8 +7,8 @@
 import pandas.util._test_decorators as td
 
 from pandas import Series
+import pandas._testing as tm
 from pandas.core.arrays.sparse import BlockIndex, IntIndex, _make_index
-import pandas.util.testing as tm
 
 TEST_LENGTH = 20
 
@@ -596,6 +596,6 @@ def _check_case(xloc, xlen, yloc, ylen, eloc, elen):
 
     @pytest.mark.parametrize("opname", ["add", "sub", "mul", "truediv", "floordiv"])
     def test_op(self, opname):
-        sparse_op = getattr(splib, "sparse_{opname}_float64".format(opname=opname))
+        sparse_op = getattr(splib, f"sparse_{opname}_float64")
         python_op = getattr(operator, opname)
         self._op_tests(sparse_op, python_op)
diff --git a/pandas/tests/sparse/__init__.py b/pandas/tests/arrays/string_/__init__.py
similarity index 100%
rename from pandas/tests/sparse/__init__.py
rename to pandas/tests/arrays/string_/__init__.py
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
new file mode 100644
index 0000000000000..5e2f14af341ab
--- /dev/null
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -0,0 +1,271 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_repr():
+    df = pd.DataFrame({"A": pd.array(["a", pd.NA, "b"], dtype="string")})
+    expected = "      A\n0     a\n1  <NA>\n2     b"
+    assert repr(df) == expected
+
+    expected = "0       a\n1    <NA>\n2       b\nName: A, dtype: string"
+    assert repr(df.A) == expected
+
+    expected = "<StringArray>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
+    assert repr(df.A.array) == expected
+
+
+def test_none_to_nan():
+    a = pd.arrays.StringArray._from_sequence(["a", None, "b"])
+    assert a[1] is not None
+    assert a[1] is pd.NA
+
+
+def test_setitem_validates():
+    a = pd.arrays.StringArray._from_sequence(["a", "b"])
+    with pytest.raises(ValueError, match="10"):
+        a[0] = 10
+
+    with pytest.raises(ValueError, match="strings"):
+        a[:] = np.array([1, 2])
+
+
+def test_setitem_with_scalar_string():
+    # is_float_dtype considers some strings, like 'd', to be floats
+    # which can cause issues.
+    arr = pd.array(["a", "c"], dtype="string")
+    arr[0] = "d"
+    expected = pd.array(["d", "c"], dtype="string")
+    tm.assert_extension_array_equal(arr, expected)
+
+
+@pytest.mark.parametrize(
+    "input, method",
+    [
+        (["a", "b", "c"], operator.methodcaller("capitalize")),
+        (["a", "b", "c"], operator.methodcaller("capitalize")),
+        (["a b", "a bc. de"], operator.methodcaller("capitalize")),
+    ],
+)
+def test_string_methods(input, method):
+    a = pd.Series(input, dtype="string")
+    b = pd.Series(input, dtype="object")
+    result = method(a.str)
+    expected = method(b.str)
+
+    assert result.dtype.name == "string"
+    tm.assert_series_equal(result.astype(object), expected)
+
+
+def test_astype_roundtrip():
+    s = pd.Series(pd.date_range("2000", periods=12))
+    s[0] = None
+
+    result = s.astype("string").astype("datetime64[ns]")
+    tm.assert_series_equal(result, s)
+
+
+def test_add():
+    a = pd.Series(["a", "b", "c", None, None], dtype="string")
+    b = pd.Series(["x", "y", None, "z", None], dtype="string")
+
+    result = a + b
+    expected = pd.Series(["ax", "by", None, None, None], dtype="string")
+    tm.assert_series_equal(result, expected)
+
+    result = a.add(b)
+    tm.assert_series_equal(result, expected)
+
+    result = a.radd(b)
+    expected = pd.Series(["xa", "yb", None, None, None], dtype="string")
+    tm.assert_series_equal(result, expected)
+
+    result = a.add(b, fill_value="-")
+    expected = pd.Series(["ax", "by", "c-", "-z", None], dtype="string")
+    tm.assert_series_equal(result, expected)
+
+
+def test_add_2d():
+    a = pd.array(["a", "b", "c"], dtype="string")
+    b = np.array([["a", "b", "c"]], dtype=object)
+    with pytest.raises(ValueError, match="3 != 1"):
+        a + b
+
+    s = pd.Series(a)
+    with pytest.raises(ValueError, match="3 != 1"):
+        s + b
+
+
+def test_add_sequence():
+    a = pd.array(["a", "b", None, None], dtype="string")
+    other = ["x", None, "y", None]
+
+    result = a + other
+    expected = pd.array(["ax", None, None, None], dtype="string")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = other + a
+    expected = pd.array(["xa", None, None, None], dtype="string")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_mul():
+    a = pd.array(["a", "b", None], dtype="string")
+    result = a * 2
+    expected = pd.array(["aa", "bb", None], dtype="string")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = 2 * a
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.xfail(reason="GH-28527")
+def test_add_strings():
+    array = pd.array(["a", "b", "c", "d"], dtype="string")
+    df = pd.DataFrame([["t", "u", "v", "w"]])
+    assert array.__add__(df) is NotImplemented
+
+    result = array + df
+    expected = pd.DataFrame([["at", "bu", "cv", "dw"]]).astype("string")
+    tm.assert_frame_equal(result, expected)
+
+    result = df + array
+    expected = pd.DataFrame([["ta", "ub", "vc", "wd"]]).astype("string")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.xfail(reason="GH-28527")
+def test_add_frame():
+    array = pd.array(["a", "b", np.nan, np.nan], dtype="string")
+    df = pd.DataFrame([["x", np.nan, "y", np.nan]])
+
+    assert array.__add__(df) is NotImplemented
+
+    result = array + df
+    expected = pd.DataFrame([["ax", np.nan, np.nan, np.nan]]).astype("string")
+    tm.assert_frame_equal(result, expected)
+
+    result = df + array
+    expected = pd.DataFrame([["xa", np.nan, np.nan, np.nan]]).astype("string")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_comparison_methods_scalar(all_compare_operators):
+    op_name = all_compare_operators
+
+    a = pd.array(["a", None, "c"], dtype="string")
+    other = "a"
+    result = getattr(a, op_name)(other)
+    expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
+    expected = pd.array(expected, dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = getattr(a, op_name)(pd.NA)
+    expected = pd.array([None, None, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_comparison_methods_array(all_compare_operators):
+    op_name = all_compare_operators
+
+    a = pd.array(["a", None, "c"], dtype="string")
+    other = [None, None, "c"]
+    result = getattr(a, op_name)(other)
+    expected = np.empty_like(a, dtype="object")
+    expected[-1] = getattr(other[-1], op_name)(a[-1])
+    expected = pd.array(expected, dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = getattr(a, op_name)(pd.NA)
+    expected = pd.array([None, None, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_constructor_raises():
+    with pytest.raises(ValueError, match="sequence of strings"):
+        pd.arrays.StringArray(np.array(["a", "b"], dtype="S1"))
+
+    with pytest.raises(ValueError, match="sequence of strings"):
+        pd.arrays.StringArray(np.array([]))
+
+    with pytest.raises(ValueError, match="strings or pandas.NA"):
+        pd.arrays.StringArray(np.array(["a", np.nan], dtype=object))
+
+    with pytest.raises(ValueError, match="strings or pandas.NA"):
+        pd.arrays.StringArray(np.array(["a", None], dtype=object))
+
+    with pytest.raises(ValueError, match="strings or pandas.NA"):
+        pd.arrays.StringArray(np.array(["a", pd.NaT], dtype=object))
+
+
+@pytest.mark.parametrize("copy", [True, False])
+def test_from_sequence_no_mutate(copy):
+    a = np.array(["a", np.nan], dtype=object)
+    original = a.copy()
+    result = pd.arrays.StringArray._from_sequence(a, copy=copy)
+    expected = pd.arrays.StringArray(np.array(["a", pd.NA], dtype=object))
+    tm.assert_extension_array_equal(result, expected)
+    tm.assert_numpy_array_equal(a, original)
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+@pytest.mark.xfail(reason="Not implemented StringArray.sum")
+def test_reduce(skipna):
+    arr = pd.Series(["a", "b", "c"], dtype="string")
+    result = arr.sum(skipna=skipna)
+    assert result == "abc"
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+@pytest.mark.xfail(reason="Not implemented StringArray.sum")
+def test_reduce_missing(skipna):
+    arr = pd.Series([None, "a", None, "b", "c", None], dtype="string")
+    result = arr.sum(skipna=skipna)
+    if skipna:
+        assert result == "abc"
+    else:
+        assert pd.isna(result)
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.0")
+def test_arrow_array():
+    # protocol added in 0.15.0
+    import pyarrow as pa
+
+    data = pd.array(["a", "b", "c"], dtype="string")
+    arr = pa.array(data)
+    expected = pa.array(list(data), type=pa.string(), from_pandas=True)
+    assert arr.equals(expected)
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+def test_arrow_roundtrip():
+    # roundtrip possible from arrow 1.0.0
+    import pyarrow as pa
+
+    data = pd.array(["a", "b", None], dtype="string")
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    assert table.field("a").type == "string"
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, pd.StringDtype)
+    tm.assert_frame_equal(result, df)
+    # ensure the missing value is represented by NA and not np.nan or None
+    assert result.loc[2, "a"] is pd.NA
+
+
+def test_value_counts_na():
+    arr = pd.array(["a", "b", "a", pd.NA], dtype="string")
+    result = arr.value_counts(dropna=False)
+    expected = pd.Series([2, 1, 1], index=["a", "b", pd.NA], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+    result = arr.value_counts(dropna=True)
+    expected = pd.Series([2, 1], index=["a", "b"], dtype="Int64")
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index e8d9ecfac61e4..b1b5a9482e34f 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -8,25 +8,34 @@
 from pandas.core.dtypes.dtypes import registry
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.api.extensions import register_extension_dtype
 from pandas.api.types import is_scalar
+from pandas.arrays import (
+    BooleanArray,
+    DatetimeArray,
+    IntegerArray,
+    IntervalArray,
+    SparseArray,
+    StringArray,
+    TimedeltaArray,
+)
 from pandas.core.arrays import PandasArray, integer_array, period_array
 from pandas.tests.extension.decimal import DecimalArray, DecimalDtype, to_decimal
-import pandas.util.testing as tm
 
 
 @pytest.mark.parametrize(
     "data, dtype, expected",
     [
         # Basic NumPy defaults.
-        ([1, 2], None, PandasArray(np.array([1, 2]))),
+        ([1, 2], None, IntegerArray._from_sequence([1, 2])),
         ([1, 2], object, PandasArray(np.array([1, 2], dtype=object))),
         (
             [1, 2],
             np.dtype("float32"),
             PandasArray(np.array([1.0, 2.0], dtype=np.dtype("float32"))),
         ),
-        (np.array([1, 2]), None, PandasArray(np.array([1, 2]))),
+        (np.array([1, 2], dtype="int64"), None, IntegerArray._from_sequence([1, 2]),),
         # String alias passes through to NumPy
         ([1, 2], "float32", PandasArray(np.array([1, 2], dtype="float32"))),
         # Period alias
@@ -45,37 +54,33 @@
         (
             [1, 2],
             np.dtype("datetime64[ns]"),
-            pd.arrays.DatetimeArray._from_sequence(
-                np.array([1, 2], dtype="datetime64[ns]")
-            ),
+            DatetimeArray._from_sequence(np.array([1, 2], dtype="datetime64[ns]")),
         ),
         (
             np.array([1, 2], dtype="datetime64[ns]"),
             None,
-            pd.arrays.DatetimeArray._from_sequence(
-                np.array([1, 2], dtype="datetime64[ns]")
-            ),
+            DatetimeArray._from_sequence(np.array([1, 2], dtype="datetime64[ns]")),
         ),
         (
             pd.DatetimeIndex(["2000", "2001"]),
             np.dtype("datetime64[ns]"),
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+            DatetimeArray._from_sequence(["2000", "2001"]),
         ),
         (
             pd.DatetimeIndex(["2000", "2001"]),
             None,
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+            DatetimeArray._from_sequence(["2000", "2001"]),
         ),
         (
             ["2000", "2001"],
             np.dtype("datetime64[ns]"),
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+            DatetimeArray._from_sequence(["2000", "2001"]),
         ),
         # Datetime (tz-aware)
         (
             ["2000", "2001"],
             pd.DatetimeTZDtype(tz="CET"),
-            pd.arrays.DatetimeArray._from_sequence(
+            DatetimeArray._from_sequence(
                 ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET")
             ),
         ),
@@ -83,17 +88,17 @@
         (
             ["1H", "2H"],
             np.dtype("timedelta64[ns]"),
-            pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+            TimedeltaArray._from_sequence(["1H", "2H"]),
         ),
         (
             pd.TimedeltaIndex(["1H", "2H"]),
             np.dtype("timedelta64[ns]"),
-            pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+            TimedeltaArray._from_sequence(["1H", "2H"]),
         ),
         (
             pd.TimedeltaIndex(["1H", "2H"]),
             None,
-            pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+            TimedeltaArray._from_sequence(["1H", "2H"]),
         ),
         # Category
         (["a", "b"], "category", pd.Categorical(["a", "b"])),
@@ -106,13 +111,19 @@
         (
             [pd.Interval(1, 2), pd.Interval(3, 4)],
             "interval",
-            pd.arrays.IntervalArray.from_tuples([(1, 2), (3, 4)]),
+            IntervalArray.from_tuples([(1, 2), (3, 4)]),
         ),
         # Sparse
-        ([0, 1], "Sparse[int64]", pd.SparseArray([0, 1], dtype="int64")),
+        ([0, 1], "Sparse[int64]", SparseArray([0, 1], dtype="int64")),
         # IntegerNA
         ([1, None], "Int16", integer_array([1, None], dtype="Int16")),
         (pd.Series([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
+        # String
+        (["a", None], "string", StringArray._from_sequence(["a", None])),
+        (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None]),),
+        # Boolean
+        ([True, None], "boolean", BooleanArray._from_sequence([True, None])),
+        ([True, None], pd.BooleanDtype(), BooleanArray._from_sequence([True, None]),),
         # Index
         (pd.Index([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
         # Series[EA] returns the EA
@@ -139,15 +150,15 @@ def test_array(data, dtype, expected):
 def test_array_copy():
     a = np.array([1, 2])
     # default is to copy
-    b = pd.array(a)
+    b = pd.array(a, dtype=a.dtype)
     assert np.shares_memory(a, b._ndarray) is False
 
     # copy=True
-    b = pd.array(a, copy=True)
+    b = pd.array(a, dtype=a.dtype, copy=True)
     assert np.shares_memory(a, b._ndarray) is False
 
     # copy=False
-    b = pd.array(a, copy=False)
+    b = pd.array(a, dtype=a.dtype, copy=False)
     assert np.shares_memory(a, b._ndarray) is True
 
 
@@ -163,31 +174,28 @@ def test_array_copy():
             period_array(["2000", "2001"], freq="D"),
         ),
         # interval
-        (
-            [pd.Interval(0, 1), pd.Interval(1, 2)],
-            pd.arrays.IntervalArray.from_breaks([0, 1, 2]),
-        ),
+        ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2]),),
         # datetime
         (
             [pd.Timestamp("2000"), pd.Timestamp("2001")],
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+            DatetimeArray._from_sequence(["2000", "2001"]),
         ),
         (
             [datetime.datetime(2000, 1, 1), datetime.datetime(2001, 1, 1)],
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+            DatetimeArray._from_sequence(["2000", "2001"]),
         ),
         (
             np.array([1, 2], dtype="M8[ns]"),
-            pd.arrays.DatetimeArray(np.array([1, 2], dtype="M8[ns]")),
+            DatetimeArray(np.array([1, 2], dtype="M8[ns]")),
         ),
         (
             np.array([1, 2], dtype="M8[us]"),
-            pd.arrays.DatetimeArray(np.array([1000, 2000], dtype="M8[ns]")),
+            DatetimeArray(np.array([1000, 2000], dtype="M8[ns]")),
         ),
         # datetimetz
         (
             [pd.Timestamp("2000", tz="CET"), pd.Timestamp("2001", tz="CET")],
-            pd.arrays.DatetimeArray._from_sequence(
+            DatetimeArray._from_sequence(
                 ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET")
             ),
         ),
@@ -196,21 +204,30 @@ def test_array_copy():
                 datetime.datetime(2000, 1, 1, tzinfo=cet),
                 datetime.datetime(2001, 1, 1, tzinfo=cet),
             ],
-            pd.arrays.DatetimeArray._from_sequence(["2000", "2001"], tz=cet),
+            DatetimeArray._from_sequence(["2000", "2001"], tz=cet),
         ),
         # timedelta
         (
             [pd.Timedelta("1H"), pd.Timedelta("2H")],
-            pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+            TimedeltaArray._from_sequence(["1H", "2H"]),
         ),
         (
             np.array([1, 2], dtype="m8[ns]"),
-            pd.arrays.TimedeltaArray(np.array([1, 2], dtype="m8[ns]")),
+            TimedeltaArray(np.array([1, 2], dtype="m8[ns]")),
         ),
         (
             np.array([1, 2], dtype="m8[us]"),
-            pd.arrays.TimedeltaArray(np.array([1000, 2000], dtype="m8[ns]")),
+            TimedeltaArray(np.array([1000, 2000], dtype="m8[ns]")),
         ),
+        # integer
+        ([1, 2], IntegerArray._from_sequence([1, 2])),
+        ([1, None], IntegerArray._from_sequence([1, None])),
+        # string
+        (["a", "b"], StringArray._from_sequence(["a", "b"])),
+        (["a", None], StringArray._from_sequence(["a", None])),
+        # Boolean
+        ([True, False], BooleanArray._from_sequence([True, False])),
+        ([True, None], BooleanArray._from_sequence([True, None])),
     ],
 )
 def test_array_inference(data, expected):
@@ -241,7 +258,7 @@ def test_array_inference_fails(data):
 @pytest.mark.parametrize("data", [np.array([[1, 2], [3, 4]]), [[1, 2], [3, 4]]])
 def test_nd_raises(data):
     with pytest.raises(ValueError, match="PandasArray must be 1-dimensional"):
-        pd.array(data)
+        pd.array(data, dtype="int64")
 
 
 def test_scalar_raises():
@@ -260,6 +277,13 @@ class DecimalDtype2(DecimalDtype):
 
     @classmethod
     def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
         return DecimalArray2
 
 
@@ -272,8 +296,9 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
         return super()._from_sequence(scalars, dtype=dtype, copy=copy)
 
 
-@pytest.mark.parametrize("box", [pd.Series, pd.Index])
-def test_array_unboxes(box):
+def test_array_unboxes(index_or_series):
+    box = index_or_series
+
     data = box([decimal.Decimal("1"), decimal.Decimal("2")])
     # make sure it works
     with pytest.raises(TypeError):
diff --git a/pandas/tests/arrays/test_boolean.py b/pandas/tests/arrays/test_boolean.py
new file mode 100644
index 0000000000000..cb9b07db4a0df
--- /dev/null
+++ b/pandas/tests/arrays/test_boolean.py
@@ -0,0 +1,931 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import BooleanArray
+from pandas.core.arrays.boolean import coerce_to_array
+from pandas.tests.extension.base import BaseOpsUtil
+
+
+def make_data():
+    return [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False]
+
+
+@pytest.fixture
+def dtype():
+    return pd.BooleanDtype()
+
+
+@pytest.fixture
+def data(dtype):
+    return pd.array(make_data(), dtype=dtype)
+
+
+def test_boolean_array_constructor():
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = BooleanArray(values, mask)
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    with pytest.raises(TypeError, match="values should be boolean numpy array"):
+        BooleanArray(values.tolist(), mask)
+
+    with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+        BooleanArray(values, mask.tolist())
+
+    with pytest.raises(TypeError, match="values should be boolean numpy array"):
+        BooleanArray(values.astype(int), mask)
+
+    with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+        BooleanArray(values, None)
+
+    with pytest.raises(ValueError, match="values must be a 1D array"):
+        BooleanArray(values.reshape(1, -1), mask)
+
+    with pytest.raises(ValueError, match="mask must be a 1D array"):
+        BooleanArray(values, mask.reshape(1, -1))
+
+
+def test_boolean_array_constructor_copy():
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = BooleanArray(values, mask)
+    assert result._data is values
+    assert result._mask is mask
+
+    result = BooleanArray(values, mask, copy=True)
+    assert result._data is not values
+    assert result._mask is not mask
+
+
+def test_to_boolean_array():
+    expected = BooleanArray(
+        np.array([True, False, True]), np.array([False, False, False])
+    )
+
+    result = pd.array([True, False, True], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, True]), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, True], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    expected = BooleanArray(
+        np.array([True, False, True]), np.array([False, False, True])
+    )
+
+    result = pd.array([True, False, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, None], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_all_none():
+    expected = BooleanArray(np.array([True, True, True]), np.array([True, True, True]))
+
+    result = pd.array([None, None, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([None, None, None], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "a, b",
+    [
+        ([True, False, None, np.nan, pd.NA], [True, False, None, None, None]),
+        ([True, np.nan], [True, None]),
+        ([True, pd.NA], [True, None]),
+        ([np.nan, np.nan], [None, None]),
+        (np.array([np.nan, np.nan], dtype=float), [None, None]),
+    ],
+)
+def test_to_boolean_array_missing_indicators(a, b):
+    result = pd.array(a, dtype="boolean")
+    expected = pd.array(b, dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        ["foo", "bar"],
+        ["1", "2"],
+        # "foo",
+        [1, 2],
+        [1.0, 2.0],
+        pd.date_range("20130101", periods=2),
+        np.array(["foo"]),
+        np.array([1, 2]),
+        np.array([1.0, 2.0]),
+        [np.nan, {"a": 1}],
+    ],
+)
+def test_to_boolean_array_error(values):
+    # error in converting existing arrays to BooleanArray
+    with pytest.raises(TypeError):
+        pd.array(values, dtype="boolean")
+
+
+def test_to_boolean_array_from_integer_array():
+    result = pd.array(np.array([1, 0, 1, 0]), dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array(np.array([1, 0, 1, None]), dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_float_array():
+    result = pd.array(np.array([1.0, 0.0, 1.0, 0.0]), dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array(np.array([1.0, 0.0, 1.0, np.nan]), dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_integer_like():
+    # integers of 0's and 1's
+    result = pd.array([1, 0, 1, 0], dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array([1, 0, 1, None], dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_coerce_to_array():
+    # TODO this is currently not public API
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+    result = BooleanArray(*coerce_to_array(values, mask=mask))
+    expected = BooleanArray(values, mask)
+    tm.assert_extension_array_equal(result, expected)
+    assert result._data is values
+    assert result._mask is mask
+    result = BooleanArray(*coerce_to_array(values, mask=mask, copy=True))
+    expected = BooleanArray(values, mask)
+    tm.assert_extension_array_equal(result, expected)
+    assert result._data is not values
+    assert result._mask is not mask
+
+    # mixed missing from values and mask
+    values = [True, False, None, False]
+    mask = np.array([False, False, False, True], dtype="bool")
+    result = BooleanArray(*coerce_to_array(values, mask=mask))
+    expected = BooleanArray(
+        np.array([True, False, True, True]), np.array([False, False, True, True])
+    )
+    tm.assert_extension_array_equal(result, expected)
+    result = BooleanArray(*coerce_to_array(np.array(values, dtype=object), mask=mask))
+    tm.assert_extension_array_equal(result, expected)
+    result = BooleanArray(*coerce_to_array(values, mask=mask.tolist()))
+    tm.assert_extension_array_equal(result, expected)
+
+    # raise errors for wrong dimension
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    with pytest.raises(ValueError, match="values must be a 1D list-like"):
+        coerce_to_array(values.reshape(1, -1))
+
+    with pytest.raises(ValueError, match="mask must be a 1D list-like"):
+        coerce_to_array(values, mask=mask.reshape(1, -1))
+
+
+def test_coerce_to_array_from_boolean_array():
+    # passing BooleanArray to coerce_to_array
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+    arr = BooleanArray(values, mask)
+    result = BooleanArray(*coerce_to_array(arr))
+    tm.assert_extension_array_equal(result, arr)
+    # no copy
+    assert result._data is arr._data
+    assert result._mask is arr._mask
+
+    result = BooleanArray(*coerce_to_array(arr), copy=True)
+    tm.assert_extension_array_equal(result, arr)
+    assert result._data is not arr._data
+    assert result._mask is not arr._mask
+
+    with pytest.raises(ValueError, match="cannot pass mask for BooleanArray input"):
+        coerce_to_array(arr, mask=mask)
+
+
+def test_coerce_to_numpy_array():
+    # with missing values -> object dtype
+    arr = pd.array([True, False, None], dtype="boolean")
+    result = np.array(arr)
+    expected = np.array([True, False, pd.NA], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # also with no missing values -> object dtype
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = np.array(arr)
+    expected = np.array([True, False, True], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # force bool dtype
+    result = np.array(arr, dtype="bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+    # with missing values will raise error
+    arr = pd.array([True, False, None], dtype="boolean")
+    with pytest.raises(ValueError):
+        np.array(arr, dtype="bool")
+
+
+def test_to_boolean_array_from_strings():
+    result = BooleanArray._from_sequence_of_strings(
+        np.array(["True", "False", np.nan], dtype=object)
+    )
+    expected = BooleanArray(
+        np.array([True, False, False]), np.array([False, False, True])
+    )
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_strings_invalid_string():
+    with pytest.raises(ValueError, match="cannot be cast"):
+        BooleanArray._from_sequence_of_strings(["donkey"])
+
+
+def test_repr():
+    df = pd.DataFrame({"A": pd.array([True, False, None], dtype="boolean")})
+    expected = "       A\n0   True\n1  False\n2   <NA>"
+    assert repr(df) == expected
+
+    expected = "0     True\n1    False\n2     <NA>\nName: A, dtype: boolean"
+    assert repr(df.A) == expected
+
+    expected = "<BooleanArray>\n[True, False, <NA>]\nLength: 3, dtype: boolean"
+    assert repr(df.A.array) == expected
+
+
+@pytest.mark.parametrize("box", [True, False], ids=["series", "array"])
+def test_to_numpy(box):
+    con = pd.Series if box else pd.array
+    # default (with or without missing values) -> object dtype
+    arr = con([True, False, True], dtype="boolean")
+    result = arr.to_numpy()
+    expected = np.array([True, False, True], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy()
+    expected = np.array([True, False, pd.NA], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy(dtype="str")
+    expected = np.array([True, False, pd.NA], dtype="<U5")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # no missing values -> can convert to bool, otherwise raises
+    arr = con([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype="bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    with pytest.raises(ValueError, match="cannot convert to 'bool'-dtype"):
+        result = arr.to_numpy(dtype="bool")
+
+    # specify dtype and na_value
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy(dtype=object, na_value=None)
+    expected = np.array([True, False, None], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype=bool, na_value=False)
+    expected = np.array([True, False, False], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype="int64", na_value=-99)
+    expected = np.array([1, 0, -99], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype="float64", na_value=np.nan)
+    expected = np.array([1, 0, np.nan], dtype="float64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # converting to int or float without specifying na_value raises
+    with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype"):
+        arr.to_numpy(dtype="int64")
+    with pytest.raises(ValueError, match="cannot convert to 'float64'-dtype"):
+        arr.to_numpy(dtype="float64")
+
+
+def test_to_numpy_copy():
+    # to_numpy can be zero-copy if no missing values
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype=bool)
+    result[0] = False
+    tm.assert_extension_array_equal(
+        arr, pd.array([False, False, True], dtype="boolean")
+    )
+
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype=bool, copy=True)
+    result[0] = False
+    tm.assert_extension_array_equal(arr, pd.array([True, False, True], dtype="boolean"))
+
+
+def test_astype():
+    # with missing values
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    with pytest.raises(ValueError, match="cannot convert NA to integer"):
+        arr.astype("int64")
+
+    with pytest.raises(ValueError, match="cannot convert float NaN to"):
+        arr.astype("bool")
+
+    result = arr.astype("float64")
+    expected = np.array([1, 0, np.nan], dtype="float64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.astype("str")
+    expected = np.array(["True", "False", "<NA>"], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # no missing values
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.astype("int64")
+    expected = np.array([1, 0, 1], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.astype("bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_astype_to_boolean_array():
+    # astype to BooleanArray
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    result = arr.astype("boolean")
+    tm.assert_extension_array_equal(result, arr)
+    result = arr.astype(pd.BooleanDtype())
+    tm.assert_extension_array_equal(result, arr)
+
+
+def test_astype_to_integer_array():
+    # astype to IntegerArray
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    result = arr.astype("Int64")
+    expected = pd.array([1, 0, None], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("na", [None, np.nan, pd.NA])
+def test_setitem_missing_values(na):
+    arr = pd.array([True, False, None], dtype="boolean")
+    expected = pd.array([True, None, None], dtype="boolean")
+    arr[1] = na
+    tm.assert_extension_array_equal(arr, expected)
+
+
+@pytest.mark.parametrize(
+    "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]
+)
+def test_ufuncs_binary(ufunc):
+    # two BooleanArrays
+    a = pd.array([True, False, None], dtype="boolean")
+    result = ufunc(a, a)
+    expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    result = ufunc(s, a)
+    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_series_equal(result, expected)
+
+    # Boolean with numpy array
+    arr = np.array([True, True, False])
+    result = ufunc(a, arr)
+    expected = pd.array(ufunc(a._data, arr), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(arr, a)
+    expected = pd.array(ufunc(arr, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    # BooleanArray with scalar
+    result = ufunc(a, True)
+    expected = pd.array(ufunc(a._data, True), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(True, a)
+    expected = pd.array(ufunc(True, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    # not handled types
+    with pytest.raises(TypeError):
+        ufunc(a, "test")
+
+
+@pytest.mark.parametrize("ufunc", [np.logical_not])
+def test_ufuncs_unary(ufunc):
+    a = pd.array([True, False, None], dtype="boolean")
+    result = ufunc(a)
+    expected = pd.array(ufunc(a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    result = ufunc(s)
+    expected = pd.Series(ufunc(a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("values", [[True, False], [True, None]])
+def test_ufunc_reduce_raises(values):
+    a = pd.array(values, dtype="boolean")
+    with pytest.raises(NotImplementedError):
+        np.add.reduce(a)
+
+
+class TestUnaryOps:
+    def test_invert(self):
+        a = pd.array([True, False, None], dtype="boolean")
+        expected = pd.array([False, True, None], dtype="boolean")
+        tm.assert_extension_array_equal(~a, expected)
+
+        expected = pd.Series(expected, index=["a", "b", "c"], name="name")
+        result = ~pd.Series(a, index=["a", "b", "c"], name="name")
+        tm.assert_series_equal(result, expected)
+
+        df = pd.DataFrame({"A": a, "B": [True, False, False]}, index=["a", "b", "c"])
+        result = ~df
+        expected = pd.DataFrame(
+            {"A": expected, "B": [False, True, True]}, index=["a", "b", "c"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+class TestLogicalOps(BaseOpsUtil):
+    def test_numpy_scalars_ok(self, all_logical_operators):
+        a = pd.array([True, False, None], dtype="boolean")
+        op = getattr(a, all_logical_operators)
+
+        tm.assert_extension_array_equal(op(True), op(np.bool(True)))
+        tm.assert_extension_array_equal(op(False), op(np.bool(False)))
+
+    def get_op_from_name(self, op_name):
+        short_opname = op_name.strip("_")
+        short_opname = short_opname if "xor" in short_opname else short_opname + "_"
+        try:
+            op = getattr(operator, short_opname)
+        except AttributeError:
+            # Assume it is the reverse operator
+            rop = getattr(operator, short_opname[1:])
+            op = lambda x, y: rop(y, x)
+
+        return op
+
+    def test_empty_ok(self, all_logical_operators):
+        a = pd.array([], dtype="boolean")
+        op_name = all_logical_operators
+        result = getattr(a, op_name)(True)
+        tm.assert_extension_array_equal(a, result)
+
+        result = getattr(a, op_name)(False)
+        tm.assert_extension_array_equal(a, result)
+
+        # TODO: pd.NA
+        # result = getattr(a, op_name)(pd.NA)
+        # tm.assert_extension_array_equal(a, result)
+
+    def test_logical_length_mismatch_raises(self, all_logical_operators):
+        op_name = all_logical_operators
+        a = pd.array([True, False, None], dtype="boolean")
+        msg = "Lengths must match to compare"
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)([True, False])
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)(np.array([True, False]))
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)(pd.array([True, False], dtype="boolean"))
+
+    def test_logical_nan_raises(self, all_logical_operators):
+        op_name = all_logical_operators
+        a = pd.array([True, False, None], dtype="boolean")
+        msg = "Got float instead"
+
+        with pytest.raises(TypeError, match=msg):
+            getattr(a, op_name)(np.nan)
+
+    @pytest.mark.parametrize("other", ["a", 1])
+    def test_non_bool_or_na_other_raises(self, other, all_logical_operators):
+        a = pd.array([True, False], dtype="boolean")
+        with pytest.raises(TypeError, match=str(type(other).__name__)):
+            getattr(a, all_logical_operators)(other)
+
+    def test_kleene_or(self):
+        # A clear test of behavior.
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a | b
+        expected = pd.array(
+            [True, True, True, True, False, None, True, None, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b | a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [True, None, None]),
+            (True, [True, True, True]),
+            (np.bool_(True), [True, True, True]),
+            (False, [True, False, None]),
+            (np.bool_(False), [True, False, None]),
+        ],
+    )
+    def test_kleene_or_scalar(self, other, expected):
+        # TODO: test True & False
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a | other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other | a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    def test_kleene_and(self):
+        # A clear test of behavior.
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a & b
+        expected = pd.array(
+            [True, False, None, False, False, False, None, False, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b & a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [None, False, None]),
+            (True, [True, False, None]),
+            (False, [False, False, False]),
+            (np.bool_(True), [True, False, None]),
+            (np.bool_(False), [False, False, False]),
+        ],
+    )
+    def test_kleene_and_scalar(self, other, expected):
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a & other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other & a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    def test_kleene_xor(self):
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a ^ b
+        expected = pd.array(
+            [False, True, None, True, False, None, None, None, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b ^ a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [None, None, None]),
+            (True, [False, True, None]),
+            (np.bool_(True), [False, True, None]),
+            (np.bool_(False), [True, False, None]),
+        ],
+    )
+    def test_kleene_xor_scalar(self, other, expected):
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a ^ other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other ^ a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other", [True, False, pd.NA, [True, False, None] * 3],
+    )
+    def test_no_masked_assumptions(self, other, all_logical_operators):
+        # The logical operations should not assume that masked values are False!
+        a = pd.arrays.BooleanArray(
+            np.array([True, True, True, False, False, False, True, False, True]),
+            np.array([False] * 6 + [True, True, True]),
+        )
+        b = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        if isinstance(other, list):
+            other = pd.array(other, dtype="boolean")
+
+        result = getattr(a, all_logical_operators)(other)
+        expected = getattr(b, all_logical_operators)(other)
+        tm.assert_extension_array_equal(result, expected)
+
+        if isinstance(other, BooleanArray):
+            other._data[other._mask] = True
+            a._data[a._mask] = False
+
+            result = getattr(a, all_logical_operators)(other)
+            expected = getattr(b, all_logical_operators)(other)
+            tm.assert_extension_array_equal(result, expected)
+
+
+class TestComparisonOps(BaseOpsUtil):
+    def _compare_other(self, data, op_name, other):
+        op = self.get_op_from_name(op_name)
+
+        # array
+        result = pd.Series(op(data, other))
+        expected = pd.Series(op(data._data, other), dtype="boolean")
+        # propagate NAs
+        expected[data._mask] = pd.NA
+
+        tm.assert_series_equal(result, expected)
+
+        # series
+        s = pd.Series(data)
+        result = op(s, other)
+
+        expected = pd.Series(data._data)
+        expected = op(expected, other)
+        expected = expected.astype("boolean")
+        # propagate NAs
+        expected[data._mask] = pd.NA
+
+        tm.assert_series_equal(result, expected)
+
+    def test_compare_scalar(self, data, all_compare_operators):
+        op_name = all_compare_operators
+        self._compare_other(data, op_name, True)
+
+    def test_compare_array(self, data, all_compare_operators):
+        op_name = all_compare_operators
+        other = pd.array([True] * len(data), dtype="boolean")
+        self._compare_other(data, op_name, other)
+        other = np.array([True] * len(data))
+        self._compare_other(data, op_name, other)
+        other = pd.Series([True] * len(data))
+        self._compare_other(data, op_name, other)
+
+    @pytest.mark.parametrize("other", [True, False, pd.NA])
+    def test_scalar(self, other, all_compare_operators):
+        op = self.get_op_from_name(all_compare_operators)
+        a = pd.array([True, False, None], dtype="boolean")
+
+        result = op(a, other)
+
+        if other is pd.NA:
+            expected = pd.array([None, None, None], dtype="boolean")
+        else:
+            values = op(a._data, other)
+            expected = BooleanArray(values, a._mask, copy=True)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = None
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    def test_array(self, all_compare_operators):
+        op = self.get_op_from_name(all_compare_operators)
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+
+        result = op(a, b)
+
+        values = op(a._data, b._data)
+        mask = a._mask | b._mask
+        expected = BooleanArray(values, mask)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = None
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+
+class TestArithmeticOps(BaseOpsUtil):
+    def test_error(self, data, all_arithmetic_operators):
+        # invalid ops
+
+        op = all_arithmetic_operators
+        s = pd.Series(data)
+        ops = getattr(s, op)
+        opa = getattr(data, op)
+
+        # invalid scalars
+        with pytest.raises(TypeError):
+            ops("foo")
+        with pytest.raises(TypeError):
+            ops(pd.Timestamp("20180101"))
+
+        # invalid array-likes
+        if op not in ("__mul__", "__rmul__"):
+            # TODO(extension) numpy's mul with object array sees booleans as numbers
+            with pytest.raises(TypeError):
+                ops(pd.Series("foo", index=s.index))
+
+        # 2d
+        result = opa(pd.DataFrame({"A": s}))
+        assert result is NotImplemented
+
+        with pytest.raises(NotImplementedError):
+            opa(np.arange(len(s)).reshape(-1, len(s)))
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_reductions_return_types(dropna, data, all_numeric_reductions):
+    op = all_numeric_reductions
+    s = pd.Series(data)
+    if dropna:
+        s = s.dropna()
+
+    if op in ("sum", "prod"):
+        assert isinstance(getattr(s, op)(), np.int64)
+    elif op in ("min", "max"):
+        assert isinstance(getattr(s, op)(), np.bool_)
+    else:
+        # "mean", "std", "var", "median", "kurt", "skew"
+        assert isinstance(getattr(s, op)(), np.float64)
+
+
+@pytest.mark.parametrize(
+    "values, exp_any, exp_all, exp_any_noskip, exp_all_noskip",
+    [
+        ([True, pd.NA], True, True, True, pd.NA),
+        ([False, pd.NA], False, False, pd.NA, False),
+        ([pd.NA], False, True, pd.NA, pd.NA),
+        ([], False, True, False, True),
+    ],
+)
+def test_any_all(values, exp_any, exp_all, exp_any_noskip, exp_all_noskip):
+    # the methods return numpy scalars
+    exp_any = pd.NA if exp_any is pd.NA else np.bool_(exp_any)
+    exp_all = pd.NA if exp_all is pd.NA else np.bool_(exp_all)
+    exp_any_noskip = pd.NA if exp_any_noskip is pd.NA else np.bool_(exp_any_noskip)
+    exp_all_noskip = pd.NA if exp_all_noskip is pd.NA else np.bool_(exp_all_noskip)
+
+    for con in [pd.array, pd.Series]:
+        a = con(values, dtype="boolean")
+        assert a.any() is exp_any
+        assert a.all() is exp_all
+        assert a.any(skipna=False) is exp_any_noskip
+        assert a.all(skipna=False) is exp_all_noskip
+
+        assert np.any(a.any()) is exp_any
+        assert np.all(a.all()) is exp_all
+
+
+# TODO when BooleanArray coerces to object dtype numpy array, need to do conversion
+# manually in the indexing code
+# def test_indexing_boolean_mask():
+#     arr = pd.array([1, 2, 3, 4], dtype="Int64")
+#     mask = pd.array([True, False, True, False], dtype="boolean")
+#     result = arr[mask]
+#     expected = pd.array([1, 3], dtype="Int64")
+#     tm.assert_extension_array_equal(result, expected)
+
+#     # missing values -> error
+#     mask = pd.array([True, False, True, None], dtype="boolean")
+#     with pytest.raises(IndexError):
+#         result = arr[mask]
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.0")
+def test_arrow_array(data):
+    # protocol added in 0.15.0
+    import pyarrow as pa
+
+    arr = pa.array(data)
+
+    # TODO use to_numpy(na_value=None) here
+    data_object = np.array(data, dtype=object)
+    data_object[data.isna()] = None
+    expected = pa.array(data_object, type=pa.bool_(), from_pandas=True)
+    assert arr.equals(expected)
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+def test_arrow_roundtrip():
+    # roundtrip possible from arrow 1.0.0
+    import pyarrow as pa
+
+    data = pd.array([True, False, None], dtype="boolean")
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    assert table.field("a").type == "bool"
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, pd.BooleanDtype)
+    tm.assert_frame_equal(result, df)
+
+
+def test_value_counts_na():
+    arr = pd.array([True, False, pd.NA], dtype="boolean")
+    result = arr.value_counts(dropna=False)
+    expected = pd.Series([1, 1, 1], index=[True, False, pd.NA], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+    result = arr.value_counts(dropna=True)
+    expected = pd.Series([1, 1], index=[True, False], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_diff():
+    a = pd.array(
+        [True, True, False, False, True, None, True, None, False], dtype="boolean"
+    )
+    result = pd.core.algorithms.diff(a, 1)
+    expected = pd.array(
+        [None, False, True, False, True, None, None, None, None], dtype="boolean"
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    result = s.diff()
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 7c482664bca48..17818b6ce689f 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -1,11 +1,17 @@
+from typing import Type, Union
+
 import numpy as np
 import pytest
 
 from pandas._libs import OutOfBoundsDatetime
+from pandas.compat.numpy import _np_version_under1p18
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
-import pandas.util.testing as tm
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.core.indexes.period import PeriodIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex
 
 
 # TODO: more freq variants
@@ -35,8 +41,8 @@ def datetime_index(request):
     """
     freqstr = request.param
     # TODO: non-monotone indexes; NaTs, different start dates, timezones
-    pi = pd.date_range(start=pd.Timestamp("2000-01-01"), periods=100, freq=freqstr)
-    return pi
+    dti = pd.date_range(start=pd.Timestamp("2000-01-01"), periods=100, freq=freqstr)
+    return dti
 
 
 @pytest.fixture
@@ -52,15 +58,15 @@ def timedelta_index(request):
 
 
 class SharedTests:
-    index_cls = None
+    index_cls: Type[Union[DatetimeIndex, PeriodIndex, TimedeltaIndex]]
 
     def test_compare_len1_raises(self):
         # make sure we raise when comparing with different lengths, specific
         #  to the case where one has length-1, which numpy would broadcast
         data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
 
-        idx = self.index_cls._simple_new(data, freq="D")
-        arr = self.array_cls(idx)
+        idx = self.array_cls._simple_new(data, freq="D")
+        arr = self.index_cls(idx)
 
         with pytest.raises(ValueError, match="Lengths must match"):
             arr == arr[:1]
@@ -73,8 +79,8 @@ def test_take(self):
         data = np.arange(100, dtype="i8") * 24 * 3600 * 10 ** 9
         np.random.shuffle(data)
 
-        idx = self.index_cls._simple_new(data, freq="D")
-        arr = self.array_cls(idx)
+        arr = self.array_cls._simple_new(data, freq="D")
+        idx = self.index_cls._simple_new(arr)
 
         takers = [1, 4, 94]
         result = arr.take(takers)
@@ -91,8 +97,7 @@ def test_take(self):
     def test_take_fill(self):
         data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
 
-        idx = self.index_cls._simple_new(data, freq="D")
-        arr = self.array_cls(idx)
+        arr = self.array_cls._simple_new(data, freq="D")
 
         result = arr.take([-1, 1], allow_fill=True, fill_value=None)
         assert result[0] is pd.NaT
@@ -115,7 +120,9 @@ def test_take_fill(self):
     def test_concat_same_type(self):
         data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
 
-        idx = self.index_cls._simple_new(data, freq="D").insert(0, pd.NaT)
+        arr = self.array_cls._simple_new(data, freq="D")
+        idx = self.index_cls(arr)
+        idx = idx.insert(0, pd.NaT)
         arr = self.array_cls(idx)
 
         result = arr._concat_same_type([arr[:-1], arr[1:], arr])
@@ -220,6 +227,19 @@ def test_setitem_raises(self):
         with pytest.raises(TypeError, match="'value' should be a.* 'object'"):
             arr[0] = object()
 
+    def test_inplace_arithmetic(self):
+        # GH#24115 check that iadd and isub are actually in-place
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        arr = self.array_cls(data, freq="D")
+
+        expected = arr + pd.Timedelta(days=1)
+        arr += pd.Timedelta(days=1)
+        tm.assert_equal(arr, expected)
+
+        expected = arr - pd.Timedelta(days=1)
+        arr -= pd.Timedelta(days=1)
+        tm.assert_equal(arr, expected)
+
 
 class TestDatetimeArray(SharedTests):
     index_cls = pd.DatetimeIndex
@@ -443,7 +463,7 @@ def test_concat_same_type_invalid(self, datetime_index):
         else:
             other = arr.tz_localize(None)
 
-        with pytest.raises(AssertionError):
+        with pytest.raises(ValueError, match="to_concat must have the same"):
             arr._concat_same_type([arr, other])
 
     def test_concat_same_type_different_freq(self):
@@ -468,7 +488,15 @@ def test_strftime(self, datetime_index):
         arr = DatetimeArray(datetime_index)
 
         result = arr.strftime("%Y %b")
-        expected = np.array(datetime_index.strftime("%Y %b"))
+        expected = np.array([ts.strftime("%Y %b") for ts in arr], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_strftime_nat(self):
+        # GH 29578
+        arr = DatetimeArray(DatetimeIndex(["2019-01-01", pd.NaT]))
+
+        result = arr.strftime("%Y-%m-%d")
+        expected = np.array(["2019-01-01", np.nan], dtype=object)
         tm.assert_numpy_array_equal(result, expected)
 
 
@@ -674,7 +702,15 @@ def test_strftime(self, period_index):
         arr = PeriodArray(period_index)
 
         result = arr.strftime("%Y")
-        expected = np.array(period_index.strftime("%Y"))
+        expected = np.array([per.strftime("%Y") for per in arr], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_strftime_nat(self):
+        # GH 29578
+        arr = PeriodArray(PeriodIndex(["2019-01-01", pd.NaT], dtype="period[D]"))
+
+        result = arr.strftime("%Y-%m-%d")
+        expected = np.array(["2019-01-01", np.nan], dtype=object)
         tm.assert_numpy_array_equal(result, expected)
 
 
@@ -724,3 +760,38 @@ def test_invalid_nat_setitem_array(array, non_casting_nats):
     for nat in non_casting_nats:
         with pytest.raises(TypeError):
             array[0] = nat
+
+
+@pytest.mark.parametrize(
+    "array",
+    [
+        pd.date_range("2000", periods=4).array,
+        pd.timedelta_range("2000", periods=4).array,
+    ],
+)
+def test_to_numpy_extra(array):
+    if _np_version_under1p18:
+        # np.isnan(NaT) raises, so use pandas'
+        isnan = pd.isna
+    else:
+        isnan = np.isnan
+
+    array[0] = pd.NaT
+    original = array.copy()
+
+    result = array.to_numpy()
+    assert isnan(result[0])
+
+    result = array.to_numpy(dtype="int64")
+    assert result[0] == -9223372036854775808
+
+    result = array.to_numpy(dtype="int64", na_value=0)
+    assert result[0] == 0
+
+    result = array.to_numpy(na_value=array[1].to_numpy())
+    assert result[0] == result[1]
+
+    result = array.to_numpy(na_value=array[1].to_numpy(copy=False))
+    assert result[0] == result[1]
+
+    tm.assert_equal(array, original)
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index d749d9bb47d25..a59ed429cc404 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -9,18 +9,23 @@
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray
 from pandas.core.arrays.datetimes import sequence_to_dt64ns
-import pandas.util.testing as tm
 
 
 class TestDatetimeArrayConstructor:
+    def test_from_sequence_invalid_type(self):
+        mi = pd.MultiIndex.from_product([np.arange(5), np.arange(5)])
+        with pytest.raises(TypeError, match="Cannot create a DatetimeArray"):
+            DatetimeArray._from_sequence(mi)
+
     def test_only_1dim_accepted(self):
         arr = np.array([0, 1, 2, 3], dtype="M8[h]").astype("M8[ns]")
 
         with pytest.raises(ValueError, match="Only 1-dimensional"):
-            # 2-dim
-            DatetimeArray(arr.reshape(2, 2))
+            # 3-dim, we allow 2D to sneak in for ops purposes GH#29853
+            DatetimeArray(arr.reshape(2, 2, 1))
 
         with pytest.raises(ValueError, match="Only 1-dimensional"):
             # 0-dim
@@ -168,7 +173,7 @@ def test_tz_setter_raises(self):
     def test_setitem_different_tz_raises(self):
         data = np.array([1, 2, 3], dtype="M8[ns]")
         arr = DatetimeArray(data, copy=False, dtype=DatetimeTZDtype(tz="US/Central"))
-        with pytest.raises(ValueError, match="None"):
+        with pytest.raises(TypeError, match="Cannot compare tz-naive and tz-aware"):
             arr[0] = pd.Timestamp("2000")
 
         with pytest.raises(ValueError, match="US/Central"):
@@ -277,6 +282,71 @@ def test_array_interface(self):
         )
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize("index", [True, False])
+    def test_searchsorted_different_tz(self, index):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        arr = DatetimeArray(data, freq="D").tz_localize("Asia/Tokyo")
+        if index:
+            arr = pd.Index(arr)
+
+        expected = arr.searchsorted(arr[2])
+        result = arr.searchsorted(arr[2].tz_convert("UTC"))
+        assert result == expected
+
+        expected = arr.searchsorted(arr[2:6])
+        result = arr.searchsorted(arr[2:6].tz_convert("UTC"))
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("index", [True, False])
+    def test_searchsorted_tzawareness_compat(self, index):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        arr = DatetimeArray(data, freq="D")
+        if index:
+            arr = pd.Index(arr)
+
+        mismatch = arr.tz_localize("Asia/Tokyo")
+
+        msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+        with pytest.raises(TypeError, match=msg):
+            arr.searchsorted(mismatch[0])
+        with pytest.raises(TypeError, match=msg):
+            arr.searchsorted(mismatch)
+
+        with pytest.raises(TypeError, match=msg):
+            mismatch.searchsorted(arr[0])
+        with pytest.raises(TypeError, match=msg):
+            mismatch.searchsorted(arr)
+
+    @pytest.mark.parametrize(
+        "other",
+        [
+            1,
+            np.int64(1),
+            1.0,
+            np.timedelta64("NaT"),
+            pd.Timedelta(days=2),
+            "invalid",
+            np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
+            np.arange(10).view("timedelta64[ns]") * 24 * 3600 * 10 ** 9,
+            pd.Timestamp.now().to_period("D"),
+        ],
+    )
+    @pytest.mark.parametrize("index", [True, False])
+    def test_searchsorted_invalid_types(self, other, index):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        arr = DatetimeArray(data, freq="D")
+        if index:
+            arr = pd.Index(arr)
+
+        msg = "|".join(
+            [
+                "searchsorted requires compatible dtype or scalar",
+                "Unexpected type for 'value'",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            arr.searchsorted(other)
+
 
 class TestSequenceToDT64NS:
     def test_tz_dtype_mismatch_raises(self):
diff --git a/pandas/tests/arrays/test_integer.py b/pandas/tests/arrays/test_integer.py
index 55e25caafc4ee..9f0e6407c25f0 100644
--- a/pandas/tests/arrays/test_integer.py
+++ b/pandas/tests/arrays/test_integer.py
@@ -6,6 +6,7 @@
 from pandas.core.dtypes.generic import ABCIndexClass
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.api.types import is_float, is_float_dtype, is_integer, is_scalar
 from pandas.core.arrays import IntegerArray, integer_array
 from pandas.core.arrays.integer import (
@@ -19,7 +20,6 @@
     UInt64Dtype,
 )
 from pandas.tests.extension.base import BaseOpsUtil
-import pandas.util.testing as tm
 
 
 def make_data():
@@ -90,7 +90,7 @@ def test_repr_dtype(dtype, expected):
 
 def test_repr_array():
     result = repr(integer_array([1, None, 3]))
-    expected = "<IntegerArray>\n[1, NaN, 3]\nLength: 3, dtype: Int64"
+    expected = "<IntegerArray>\n[1, <NA>, 3]\nLength: 3, dtype: Int64"
     assert result == expected
 
 
@@ -98,9 +98,9 @@ def test_repr_array_long():
     data = integer_array([1, 2, None] * 1000)
     expected = (
         "<IntegerArray>\n"
-        "[  1,   2, NaN,   1,   2, NaN,   1,   2, NaN,   1,\n"
+        "[   1,    2, <NA>,    1,    2, <NA>,    1,    2, <NA>,    1,\n"
         " ...\n"
-        " NaN,   1,   2, NaN,   1,   2, NaN,   1,   2, NaN]\n"
+        " <NA>,    1,    2, <NA>,    1,    2, <NA>,    1,    2, <NA>]\n"
         "Length: 3000, dtype: Int64"
     )
     result = repr(data)
@@ -108,13 +108,19 @@ def test_repr_array_long():
 
 
 class TestConstructors:
+    def test_uses_pandas_na(self):
+        a = pd.array([1, None], dtype=pd.Int64Dtype())
+        assert a[1] is pd.NA
+
     def test_from_dtype_from_float(self, data):
         # construct from our dtype & string dtype
         dtype = data.dtype
 
         # from float
         expected = pd.Series(data)
-        result = pd.Series(np.array(data).astype("float"), dtype=str(dtype))
+        result = pd.Series(
+            data.to_numpy(na_value=np.nan, dtype="float"), dtype=str(dtype)
+        )
         tm.assert_series_equal(result, expected)
 
         # from int / list
@@ -156,10 +162,13 @@ def _check_op(self, s, op_name, other, exc=None):
 
         # 1 ** na is na, so need to unmask those
         if op_name == "__pow__":
-            mask = np.where(s == 1, False, mask)
+            mask = np.where(~s.isna() & (s == 1), False, mask)
 
         elif op_name == "__rpow__":
-            mask = np.where(other == 1, False, mask)
+            other_is_one = other == 1
+            if isinstance(other_is_one, pd.Series):
+                other_is_one = other_is_one.fillna(False)
+            mask = np.where(other_is_one, False, mask)
 
         # float result type or float op
         if (
@@ -193,7 +202,7 @@ def _check_op_integer(self, result, expected, mask, s, op_name, other):
         # to compare properly, we convert the expected
         # to float, mask to nans and convert infs
         # if we have uints then we process as uints
-        # then conert to float
+        # then convert to float
         # and we ultimately want to create a IntArray
         # for comparisons
 
@@ -208,20 +217,27 @@ def _check_op_integer(self, result, expected, mask, s, op_name, other):
                 else:
                     expected = expected.fillna(0)
             else:
-                expected[(s.values == 0) & ((expected == 0) | expected.isna())] = 0
+                expected[
+                    (s.values == 0).fillna(False)
+                    & ((expected == 0).fillna(False) | expected.isna())
+                ] = 0
         try:
-            expected[(expected == np.inf) | (expected == -np.inf)] = fill_value
+            expected[
+                ((expected == np.inf) | (expected == -np.inf)).fillna(False)
+            ] = fill_value
             original = expected
             expected = expected.astype(s.dtype)
 
         except ValueError:
 
             expected = expected.astype(float)
-            expected[(expected == np.inf) | (expected == -np.inf)] = fill_value
+            expected[
+                ((expected == np.inf) | (expected == -np.inf)).fillna(False)
+            ] = fill_value
             original = expected
             expected = expected.astype(s.dtype)
 
-        expected[mask] = np.nan
+        expected[mask] = pd.NA
 
         # assert that the expected astype is ok
         # (skip for unsigned as they have wrap around)
@@ -255,21 +271,18 @@ def test_arith_integer_array(self, data, all_arithmetic_operators):
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
         # scalar
         op = all_arithmetic_operators
-
         s = pd.Series(data)
         self._check_op(s, op, 1, exc=TypeError)
 
     def test_arith_frame_with_scalar(self, data, all_arithmetic_operators):
         # frame & scalar
         op = all_arithmetic_operators
-
         df = pd.DataFrame({"A": data})
         self._check_op(df, op, 1, exc=TypeError)
 
     def test_arith_series_with_array(self, data, all_arithmetic_operators):
         # ndarray & other series
         op = all_arithmetic_operators
-
         s = pd.Series(data)
         other = np.ones(len(s), dtype=s.dtype.type)
         self._check_op(s, op, other, exc=TypeError)
@@ -317,38 +330,96 @@ def test_error(self, data, all_arithmetic_operators):
         opa = getattr(data, op)
 
         # invalid scalars
-        with pytest.raises(TypeError):
+        msg = (
+            r"(:?can only perform ops with numeric values)"
+            r"|(:?IntegerArray cannot perform the operation mod)"
+        )
+        with pytest.raises(TypeError, match=msg):
             ops("foo")
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             ops(pd.Timestamp("20180101"))
 
         # invalid array-likes
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             ops(pd.Series("foo", index=s.index))
 
         if op != "__rpow__":
             # TODO(extension)
             # rpow with a datetimelike coerces the integer array incorrectly
-            with pytest.raises(TypeError):
+            msg = (
+                r"(:?can only perform ops with numeric values)"
+                r"|(:?cannot perform .* with this index type: DatetimeArray)"
+                r"|(:?Addition/subtraction of integers and integer-arrays"
+                r" with DatetimeArray is no longer supported. *)"
+            )
+            with pytest.raises(TypeError, match=msg):
                 ops(pd.Series(pd.date_range("20180101", periods=len(s))))
 
         # 2d
         result = opa(pd.DataFrame({"A": s}))
         assert result is NotImplemented
 
-        with pytest.raises(NotImplementedError):
+        msg = r"can only perform ops with 1-d structures"
+        with pytest.raises(NotImplementedError, match=msg):
             opa(np.arange(len(s)).reshape(-1, len(s)))
 
-    def test_pow(self):
-        # https://github.com/pandas-dev/pandas/issues/22022
-        a = integer_array([1, np.nan, np.nan, 1])
-        b = integer_array([1, np.nan, 1, np.nan])
+    @pytest.mark.parametrize("zero, negative", [(0, False), (0.0, False), (-0.0, True)])
+    def test_divide_by_zero(self, zero, negative):
+        # https://github.com/pandas-dev/pandas/issues/27398
+        a = pd.array([0, 1, -1, None], dtype="Int64")
+        result = a / zero
+        expected = np.array([np.nan, np.inf, -np.inf, np.nan])
+        if negative:
+            expected *= -1
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_pow_scalar(self):
+        a = pd.array([-1, 0, 1, None, 2], dtype="Int64")
+        result = a ** 0
+        expected = pd.array([1, 1, 1, 1, 1], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = a ** 1
+        expected = pd.array([-1, 0, 1, None, 2], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = a ** pd.NA
+        expected = pd.array([None, None, 1, None, None], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = a ** np.nan
+        expected = np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64")
+        tm.assert_numpy_array_equal(result, expected)
+
+        # reversed
+        a = a[1:]  # Can't raise integers to negative powers.
+
+        result = 0 ** a
+        expected = pd.array([1, 0, None, 0], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = 1 ** a
+        expected = pd.array([1, 1, 1, 1], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = pd.NA ** a
+        expected = pd.array([1, None, None, None], dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = np.nan ** a
+        expected = np.array([1, np.nan, np.nan, np.nan], dtype="float64")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_pow_array(self):
+        a = integer_array([0, 0, 0, 1, 1, 1, None, None, None])
+        b = integer_array([0, 1, None, 0, 1, None, 0, 1, None])
         result = a ** b
-        expected = pd.core.arrays.integer_array([1, np.nan, np.nan, 1])
+        expected = integer_array([1, 0, None, 1, 1, 1, 1, None, None])
         tm.assert_extension_array_equal(result, expected)
 
     def test_rpow_one_to_na(self):
         # https://github.com/pandas-dev/pandas/issues/22022
+        # https://github.com/pandas-dev/pandas/issues/29997
         arr = integer_array([np.nan, np.nan])
         result = np.array([1.0, 2.0]) ** arr
         expected = np.array([1.0, np.nan])
@@ -361,10 +432,10 @@ def _compare_other(self, data, op_name, other):
 
         # array
         result = pd.Series(op(data, other))
-        expected = pd.Series(op(data._data, other))
+        expected = pd.Series(op(data._data, other), dtype="boolean")
 
         # fill the nan locations
-        expected[data._mask] = op_name == "__ne__"
+        expected[data._mask] = pd.NA
 
         tm.assert_series_equal(result, expected)
 
@@ -372,22 +443,87 @@ def _compare_other(self, data, op_name, other):
         s = pd.Series(data)
         result = op(s, other)
 
-        expected = pd.Series(data._data)
-        expected = op(expected, other)
+        expected = op(pd.Series(data._data), other)
 
         # fill the nan locations
-        expected[data._mask] = op_name == "__ne__"
+        expected[data._mask] = pd.NA
+        expected = expected.astype("boolean")
 
         tm.assert_series_equal(result, expected)
 
-    def test_compare_scalar(self, data, all_compare_operators):
-        op_name = all_compare_operators
-        self._compare_other(data, op_name, 0)
+    @pytest.mark.parametrize("other", [True, False, pd.NA, -1, 0, 1])
+    def test_scalar(self, other, all_compare_operators):
+        op = self.get_op_from_name(all_compare_operators)
+        a = pd.array([1, 0, None], dtype="Int64")
+
+        result = op(a, other)
+
+        if other is pd.NA:
+            expected = pd.array([None, None, None], dtype="boolean")
+        else:
+            values = op(a._data, other)
+            expected = pd.arrays.BooleanArray(values, a._mask, copy=True)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = pd.NA
+        tm.assert_extension_array_equal(a, pd.array([1, 0, None], dtype="Int64"))
+
+    def test_array(self, all_compare_operators):
+        op = self.get_op_from_name(all_compare_operators)
+        a = pd.array([0, 1, 2, None, None, None], dtype="Int64")
+        b = pd.array([0, 1, None, 0, 1, None], dtype="Int64")
+
+        result = op(a, b)
+        values = op(a._data, b._data)
+        mask = a._mask | b._mask
+
+        expected = pd.arrays.BooleanArray(values, mask)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = pd.NA
+        tm.assert_extension_array_equal(
+            a, pd.array([0, 1, 2, None, None, None], dtype="Int64")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([0, 1, None, 0, 1, None], dtype="Int64")
+        )
+
+    def test_compare_with_booleanarray(self, all_compare_operators):
+        op = self.get_op_from_name(all_compare_operators)
+        a = pd.array([True, False, None] * 3, dtype="boolean")
+        b = pd.array([0] * 3 + [1] * 3 + [None] * 3, dtype="Int64")
+        other = pd.array([False] * 3 + [True] * 3 + [None] * 3, dtype="boolean")
+        expected = op(a, other)
+        result = op(a, b)
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_no_shared_mask(self, data):
+        result = data + 1
+        assert np.shares_memory(result._mask, data._mask) is False
+
+    def test_compare_to_string(self, any_nullable_int_dtype):
+        # GH 28930
+        s = pd.Series([1, None], dtype=any_nullable_int_dtype)
+        result = s == "a"
+        expected = pd.Series([False, pd.NA], dtype="boolean")
+
+        self.assert_series_equal(result, expected)
+
+    def test_compare_to_int(self, any_nullable_int_dtype, all_compare_operators):
+        # GH 28930
+        s1 = pd.Series([1, None, 3], dtype=any_nullable_int_dtype)
+        s2 = pd.Series([1, None, 3], dtype="float")
 
-    def test_compare_array(self, data, all_compare_operators):
-        op_name = all_compare_operators
-        other = pd.Series([0] * len(data))
-        self._compare_other(data, op_name, other)
+        method = getattr(s1, all_compare_operators)
+        result = method(2)
+
+        method = getattr(s2, all_compare_operators)
+        expected = method(2).astype("boolean")
+        expected[s2.isna()] = pd.NA
+
+        self.assert_series_equal(result, expected)
 
 
 class TestCasting:
@@ -464,7 +600,8 @@ def test_astype(self, all_data):
 
         # coerce to same numpy_dtype - mixed
         s = pd.Series(mixed)
-        with pytest.raises(ValueError):
+        msg = r"cannot convert to .*-dtype NumPy array with missing values.*"
+        with pytest.raises(ValueError, match=msg):
             s.astype(all_data.dtype.numpy_dtype)
 
         # coerce to object
@@ -473,6 +610,17 @@ def test_astype(self, all_data):
         expected = pd.Series(np.asarray(mixed))
         tm.assert_series_equal(result, expected)
 
+    def test_astype_to_larger_numpy(self):
+        a = pd.array([1, 2], dtype="Int32")
+        result = a.astype("int64")
+        expected = np.array([1, 2], dtype="int64")
+        tm.assert_numpy_array_equal(result, expected)
+
+        a = pd.array([1, 2], dtype="UInt32")
+        result = a.astype("uint64")
+        expected = np.array([1, 2], dtype="uint64")
+        tm.assert_numpy_array_equal(result, expected)
+
     @pytest.mark.parametrize("dtype", [Int8Dtype(), "Int8", UInt32Dtype(), "UInt32"])
     def test_astype_specific_casting(self, dtype):
         s = pd.Series([1, 2, 3], dtype="Int64")
@@ -502,12 +650,61 @@ def test_construct_cast_invalid(self, dtype):
         with pytest.raises(TypeError, match=msg):
             pd.Series(arr).astype(dtype)
 
+    @pytest.mark.parametrize("in_series", [True, False])
+    def test_to_numpy_na_nan(self, in_series):
+        a = pd.array([0, 1, None], dtype="Int64")
+        if in_series:
+            a = pd.Series(a)
+
+        result = a.to_numpy(dtype="float64", na_value=np.nan)
+        expected = np.array([0.0, 1.0, np.nan], dtype="float64")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = a.to_numpy(dtype="int64", na_value=-1)
+        expected = np.array([0, 1, -1], dtype="int64")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = a.to_numpy(dtype="bool", na_value=False)
+        expected = np.array([False, True, False], dtype="bool")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("in_series", [True, False])
+    @pytest.mark.parametrize("dtype", ["int32", "int64", "bool"])
+    def test_to_numpy_dtype(self, dtype, in_series):
+        a = pd.array([0, 1], dtype="Int64")
+        if in_series:
+            a = pd.Series(a)
+
+        result = a.to_numpy(dtype=dtype)
+        expected = np.array([0, 1], dtype=dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["float64", "int64", "bool"])
+    def test_to_numpy_na_raises(self, dtype):
+        a = pd.array([0, 1, None], dtype="Int64")
+        with pytest.raises(ValueError, match=dtype):
+            a.to_numpy(dtype=dtype)
+
+    def test_astype_str(self):
+        a = pd.array([1, 2, None], dtype="Int64")
+        expected = np.array(["1", "2", "<NA>"], dtype=object)
+
+        tm.assert_numpy_array_equal(a.astype(str), expected)
+        tm.assert_numpy_array_equal(a.astype("str"), expected)
+
+    def test_astype_boolean(self):
+        # https://github.com/pandas-dev/pandas/issues/31102
+        a = pd.array([1, 0, -1, 2, None], dtype="Int64")
+        result = a.astype("boolean")
+        expected = pd.array([True, False, True, True, None], dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
 
 def test_frame_repr(data_missing):
 
     df = pd.DataFrame({"A": data_missing})
     result = repr(df)
-    expected = "     A\n0  NaN\n1    1"
+    expected = "      A\n0  <NA>\n1     1"
     assert result == expected
 
 
@@ -523,7 +720,7 @@ def test_conversions(data_missing):
     # we assert that we are exactly equal
     # including type conversions of scalars
     result = df["A"].astype("object").values
-    expected = np.array([np.nan, 1], dtype=object)
+    expected = np.array([pd.NA, 1], dtype=object)
     tm.assert_numpy_array_equal(result, expected)
 
     for r, e in zip(result, expected):
@@ -545,16 +742,17 @@ def test_integer_array_constructor():
     expected = integer_array([1, 2, 3, np.nan], dtype="int64")
     tm.assert_extension_array_equal(result, expected)
 
-    with pytest.raises(TypeError):
+    msg = r".* should be .* numpy array. Use the 'integer_array' function instead"
+    with pytest.raises(TypeError, match=msg):
         IntegerArray(values.tolist(), mask)
 
-    with pytest.raises(TypeError):
+    with pytest.raises(TypeError, match=msg):
         IntegerArray(values, mask.tolist())
 
-    with pytest.raises(TypeError):
+    with pytest.raises(TypeError, match=msg):
         IntegerArray(values.astype(float), mask)
-
-    with pytest.raises(TypeError):
+    msg = r"__init__\(\) missing 1 required positional argument: 'mask'"
+    with pytest.raises(TypeError, match=msg):
         IntegerArray(values)
 
 
@@ -602,7 +800,11 @@ def test_integer_array_constructor_copy():
 )
 def test_to_integer_array_error(values):
     # error in converting existing arrays to IntegerArrays
-    with pytest.raises(TypeError):
+    msg = (
+        r"(:?.* cannot be converted to an IntegerDtype)"
+        r"|(:?values must be a 1D list-like)"
+    )
+    with pytest.raises(TypeError, match=msg):
         integer_array(values)
 
 
@@ -686,7 +888,7 @@ def test_cross_type_arithmetic():
     tm.assert_series_equal(result, expected)
 
     result = (df.A + df.C) * 3 == 12
-    expected = pd.Series([False, True, False])
+    expected = pd.Series([False, True, None], dtype="boolean")
     tm.assert_series_equal(result, expected)
 
     result = df.A + df.B
@@ -750,13 +952,15 @@ def test_reduce_to_float(op):
 def test_astype_nansafe():
     # see gh-22343
     arr = integer_array([np.nan, 1, 2], dtype="Int8")
-    msg = "cannot convert float NaN to integer"
+    msg = "cannot convert to 'uint32'-dtype NumPy array with missing values."
 
     with pytest.raises(ValueError, match=msg):
         arr.astype("uint32")
 
 
 @pytest.mark.parametrize("ufunc", [np.abs, np.sign])
+# np.sign emits a warning with nans, <https://github.com/numpy/numpy/issues/15127>
+@pytest.mark.filterwarnings("ignore:invalid value encountered in sign")
 def test_ufuncs_single_int(ufunc):
     a = integer_array([1, 2, -3, np.nan])
     result = ufunc(a)
@@ -815,20 +1019,83 @@ def test_ufuncs_binary_int(ufunc):
 @pytest.mark.parametrize("values", [[0, 1], [0, None]])
 def test_ufunc_reduce_raises(values):
     a = integer_array(values)
-    with pytest.raises(NotImplementedError):
+    msg = r"The 'reduce' method is not supported."
+    with pytest.raises(NotImplementedError, match=msg):
         np.add.reduce(a)
 
 
-@td.skip_if_no("pyarrow", min_version="0.14.1.dev")
+@td.skip_if_no("pyarrow", min_version="0.15.0")
 def test_arrow_array(data):
     # protocol added in 0.15.0
     import pyarrow as pa
 
     arr = pa.array(data)
-    expected = pa.array(list(data), type=data.dtype.name.lower(), from_pandas=True)
+    expected = np.array(data, dtype=object)
+    expected[data.isna()] = None
+    expected = pa.array(expected, type=data.dtype.name.lower(), from_pandas=True)
     assert arr.equals(expected)
 
 
+@td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+def test_arrow_roundtrip(data):
+    # roundtrip possible from arrow 1.0.0
+    import pyarrow as pa
+
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    assert table.field("a").type == str(data.dtype.numpy_dtype)
+    result = table.to_pandas()
+    tm.assert_frame_equal(result, df)
+
+
+@pytest.mark.parametrize(
+    "pandasmethname, kwargs",
+    [
+        ("var", {"ddof": 0}),
+        ("var", {"ddof": 1}),
+        ("kurtosis", {}),
+        ("skew", {}),
+        ("sem", {}),
+    ],
+)
+def test_stat_method(pandasmethname, kwargs):
+    s = pd.Series(data=[1, 2, 3, 4, 5, 6, np.nan, np.nan], dtype="Int64")
+    pandasmeth = getattr(s, pandasmethname)
+    result = pandasmeth(**kwargs)
+    s2 = pd.Series(data=[1, 2, 3, 4, 5, 6], dtype="Int64")
+    pandasmeth = getattr(s2, pandasmethname)
+    expected = pandasmeth(**kwargs)
+    assert expected == result
+
+
+def test_value_counts_na():
+    arr = pd.array([1, 2, 1, pd.NA], dtype="Int64")
+    result = arr.value_counts(dropna=False)
+    expected = pd.Series([2, 1, 1], index=[1, 2, pd.NA], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+    result = arr.value_counts(dropna=True)
+    expected = pd.Series([2, 1], index=[1, 2], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_array_setitem_nullable_boolean_mask():
+    # GH 31446
+    ser = pd.Series([1, 2], dtype="Int64")
+    result = ser.where(ser > 1)
+    expected = pd.Series([pd.NA, 2], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_array_setitem():
+    # GH 31446
+    arr = pd.Series([1, 2], dtype="Int64").array
+    arr[arr > 1] = 1
+
+    expected = pd.array([1, 1], dtype="Int64")
+    tm.assert_extension_array_equal(arr, expected)
+
+
 # TODO(jreback) - these need testing / are broken
 
 # shift
diff --git a/pandas/tests/arrays/test_numpy.py b/pandas/tests/arrays/test_numpy.py
index c4c1696ede6e6..86793c4ec50dd 100644
--- a/pandas/tests/arrays/test_numpy.py
+++ b/pandas/tests/arrays/test_numpy.py
@@ -6,9 +6,9 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.arrays import PandasArray
 from pandas.core.arrays.numpy_ import PandasDtype
-import pandas.util.testing as tm
 
 
 @pytest.fixture(
@@ -211,3 +211,40 @@ def test_basic_binop():
     result = x + x
     expected = PandasArray(np.array([2, 4, 6]))
     tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [None, object])
+def test_setitem_object_typecode(dtype):
+    arr = PandasArray(np.array(["a", "b", "c"], dtype=dtype))
+    arr[0] = "t"
+    expected = PandasArray(np.array(["t", "b", "c"], dtype=dtype))
+    tm.assert_extension_array_equal(arr, expected)
+
+
+def test_setitem_no_coercion():
+    # https://github.com/pandas-dev/pandas/issues/28150
+    arr = PandasArray(np.array([1, 2, 3]))
+    with pytest.raises(ValueError, match="int"):
+        arr[0] = "a"
+
+    # With a value that we do coerce, check that we coerce the value
+    #  and not the underlying array.
+    arr[0] = 2.5
+    assert isinstance(arr[0], (int, np.integer)), type(arr[0])
+
+
+def test_setitem_preserves_views():
+    # GH#28150, see also extension test of the same name
+    arr = PandasArray(np.array([1, 2, 3]))
+    view1 = arr.view()
+    view2 = arr[:]
+    view3 = np.asarray(arr)
+
+    arr[0] = 9
+    assert view1[0] == 9
+    assert view2[0] == 9
+    assert view3[0] == 9
+
+    arr[-1] = 2.5
+    view1[-1] = 5
+    assert arr[-1] == 5
diff --git a/pandas/tests/arrays/test_period.py b/pandas/tests/arrays/test_period.py
index 252f278242fcc..0b95d3aa19366 100644
--- a/pandas/tests/arrays/test_period.py
+++ b/pandas/tests/arrays/test_period.py
@@ -3,12 +3,13 @@
 
 from pandas._libs.tslibs import iNaT
 from pandas._libs.tslibs.period import IncompatibleFrequency
+import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.dtypes import PeriodDtype, registry
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import PeriodArray, period_array
-import pandas.util.testing as tm
 
 # ----------------------------------------------------------------------------
 # Dtype
@@ -323,3 +324,92 @@ def test_min_max_empty(self, skipna):
 
         result = arr.max(skipna=skipna)
         assert result is pd.NaT
+
+
+# ----------------------------------------------------------------------------
+# Arrow interaction
+
+pyarrow_skip = pyarrow_skip = td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+
+
+@pyarrow_skip
+def test_arrow_extension_type():
+    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+
+    p1 = ArrowPeriodType("D")
+    p2 = ArrowPeriodType("D")
+    p3 = ArrowPeriodType("M")
+
+    assert p1.freq == "D"
+    assert p1 == p2
+    assert not p1 == p3
+    assert hash(p1) == hash(p2)
+    assert not hash(p1) == hash(p3)
+
+
+@pyarrow_skip
+@pytest.mark.parametrize(
+    "data, freq",
+    [
+        (pd.date_range("2017", periods=3), "D"),
+        (pd.date_range("2017", periods=3, freq="A"), "A-DEC"),
+    ],
+)
+def test_arrow_array(data, freq):
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+
+    periods = period_array(data, freq=freq)
+    result = pa.array(periods)
+    assert isinstance(result.type, ArrowPeriodType)
+    assert result.type.freq == freq
+    expected = pa.array(periods.asi8, type="int64")
+    assert result.storage.equals(expected)
+
+    # convert to its storage type
+    result = pa.array(periods, type=pa.int64())
+    assert result.equals(expected)
+
+    # unsupported conversions
+    msg = "Not supported to convert PeriodArray to 'double' type"
+    with pytest.raises(TypeError, match=msg):
+        pa.array(periods, type="float64")
+
+    with pytest.raises(TypeError, match="different 'freq'"):
+        pa.array(periods, type=ArrowPeriodType("T"))
+
+
+@pyarrow_skip
+def test_arrow_array_missing():
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+
+    arr = PeriodArray([1, 2, 3], freq="D")
+    arr[1] = pd.NaT
+
+    result = pa.array(arr)
+    assert isinstance(result.type, ArrowPeriodType)
+    assert result.type.freq == "D"
+    expected = pa.array([1, None, 3], type="int64")
+    assert result.storage.equals(expected)
+
+
+@pyarrow_skip
+def test_arrow_table_roundtrip():
+    import pyarrow as pa
+    from pandas.core.arrays._arrow_utils import ArrowPeriodType
+
+    arr = PeriodArray([1, 2, 3], freq="D")
+    arr[1] = pd.NaT
+    df = pd.DataFrame({"a": arr})
+
+    table = pa.table(df)
+    assert isinstance(table.field("a").type, ArrowPeriodType)
+    result = table.to_pandas()
+    assert isinstance(result["a"].dtype, PeriodDtype)
+    tm.assert_frame_equal(result, df)
+
+    table2 = pa.concat_tables([table, table])
+    result = table2.to_pandas()
+    expected = pd.concat([df, df], ignore_index=True)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index 540c3343b2a1b..c86b4f71ee592 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -2,8 +2,8 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import TimedeltaArray
-import pandas.util.testing as tm
 
 
 class TestTimedeltaArrayConstructor:
@@ -12,8 +12,8 @@ def test_only_1dim_accepted(self):
         arr = np.array([0, 1, 2, 3], dtype="m8[h]").astype("m8[ns]")
 
         with pytest.raises(ValueError, match="Only 1-dimensional"):
-            # 2-dim
-            TimedeltaArray(arr.reshape(2, 2))
+            # 3-dim, we allow 2D to sneak in for ops purposes GH#29853
+            TimedeltaArray(arr.reshape(2, 2, 1))
 
         with pytest.raises(ValueError, match="Only 1-dimensional"):
             # 0-dim
@@ -41,13 +41,12 @@ def test_other_type_raises(self):
     def test_incorrect_dtype_raises(self):
         # TODO: why TypeError for 'category' but ValueError for i8?
         with pytest.raises(
-            ValueError, match=r"category cannot be converted " r"to timedelta64\[ns\]"
+            ValueError, match=r"category cannot be converted to timedelta64\[ns\]"
         ):
             TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype="category")
 
         with pytest.raises(
-            ValueError,
-            match=r"dtype int64 cannot be converted " r"to timedelta64\[ns\]",
+            ValueError, match=r"dtype int64 cannot be converted to timedelta64\[ns\]",
         ):
             TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype=np.dtype("int64"))
 
@@ -141,8 +140,50 @@ def test_setitem_objects(self, obj):
         arr[0] = obj
         assert arr[0] == pd.Timedelta(seconds=1)
 
+    @pytest.mark.parametrize(
+        "other",
+        [
+            1,
+            np.int64(1),
+            1.0,
+            np.datetime64("NaT"),
+            pd.Timestamp.now(),
+            "invalid",
+            np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
+            (np.arange(10) * 24 * 3600 * 10 ** 9).view("datetime64[ns]"),
+            pd.Timestamp.now().to_period("D"),
+        ],
+    )
+    @pytest.mark.parametrize("index", [True, False])
+    def test_searchsorted_invalid_types(self, other, index):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+        arr = TimedeltaArray(data, freq="D")
+        if index:
+            arr = pd.Index(arr)
+
+        msg = "|".join(
+            [
+                "searchsorted requires compatible dtype or scalar",
+                "Unexpected type for 'value'",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            arr.searchsorted(other)
+
 
 class TestReductions:
+    @pytest.mark.parametrize("name", ["sum", "std", "min", "max", "median"])
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_reductions_empty(self, name, skipna):
+        tdi = pd.TimedeltaIndex([])
+        arr = tdi.array
+
+        result = getattr(tdi, name)(skipna=skipna)
+        assert result is pd.NaT
+
+        result = getattr(arr, name)(skipna=skipna)
+        assert result is pd.NaT
+
     def test_min_max(self):
         arr = TimedeltaArray._from_sequence(["3H", "3H", "NaT", "2H", "5H", "4H"])
 
@@ -160,11 +201,87 @@ def test_min_max(self):
         result = arr.max(skipna=False)
         assert result is pd.NaT
 
-    @pytest.mark.parametrize("skipna", [True, False])
-    def test_min_max_empty(self, skipna):
-        arr = TimedeltaArray._from_sequence([])
-        result = arr.min(skipna=skipna)
+    def test_sum(self):
+        tdi = pd.TimedeltaIndex(["3H", "3H", "NaT", "2H", "5H", "4H"])
+        arr = tdi.array
+
+        result = arr.sum(skipna=True)
+        expected = pd.Timedelta(hours=17)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = tdi.sum(skipna=True)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = arr.sum(skipna=False)
+        assert result is pd.NaT
+
+        result = tdi.sum(skipna=False)
+        assert result is pd.NaT
+
+        result = arr.sum(min_count=9)
+        assert result is pd.NaT
+
+        result = tdi.sum(min_count=9)
+        assert result is pd.NaT
+
+        result = arr.sum(min_count=1)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = tdi.sum(min_count=1)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+    def test_npsum(self):
+        # GH#25335 np.sum should return a Timedelta, not timedelta64
+        tdi = pd.TimedeltaIndex(["3H", "3H", "2H", "5H", "4H"])
+        arr = tdi.array
+
+        result = np.sum(tdi)
+        expected = pd.Timedelta(hours=17)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = np.sum(arr)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+    def test_std(self):
+        tdi = pd.TimedeltaIndex(["0H", "4H", "NaT", "4H", "0H", "2H"])
+        arr = tdi.array
+
+        result = arr.std(skipna=True)
+        expected = pd.Timedelta(hours=2)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = tdi.std(skipna=True)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = arr.std(skipna=False)
+        assert result is pd.NaT
+
+        result = tdi.std(skipna=False)
+        assert result is pd.NaT
+
+    def test_median(self):
+        tdi = pd.TimedeltaIndex(["0H", "3H", "NaT", "5H06m", "0H", "2H"])
+        arr = tdi.array
+
+        result = arr.median(skipna=True)
+        expected = pd.Timedelta(hours=2)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = tdi.median(skipna=True)
+        assert isinstance(result, pd.Timedelta)
+        assert result == expected
+
+        result = arr.std(skipna=False)
         assert result is pd.NaT
 
-        result = arr.max(skipna=skipna)
+        result = tdi.std(skipna=False)
         assert result is pd.NaT
diff --git a/pandas/tests/sparse/frame/__init__.py b/pandas/tests/base/__init__.py
similarity index 100%
rename from pandas/tests/sparse/frame/__init__.py
rename to pandas/tests/base/__init__.py
diff --git a/pandas/tests/base/test_constructors.py b/pandas/tests/base/test_constructors.py
new file mode 100644
index 0000000000000..e27b5c307cd99
--- /dev/null
+++ b/pandas/tests/base/test_constructors.py
@@ -0,0 +1,147 @@
+from datetime import datetime
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.compat import PYPY
+
+import pandas as pd
+from pandas import DataFrame, Index, Series
+import pandas._testing as tm
+from pandas.core.accessor import PandasDelegate
+from pandas.core.base import NoNewAttributesMixin, PandasObject
+
+
+class TestPandasDelegate:
+    class Delegator:
+        _properties = ["foo"]
+        _methods = ["bar"]
+
+        def _set_foo(self, value):
+            self.foo = value
+
+        def _get_foo(self):
+            return self.foo
+
+        foo = property(_get_foo, _set_foo, doc="foo property")
+
+        def bar(self, *args, **kwargs):
+            """ a test bar method """
+            pass
+
+    class Delegate(PandasDelegate, PandasObject):
+        def __init__(self, obj):
+            self.obj = obj
+
+    def setup_method(self, method):
+        pass
+
+    def test_invalid_delegation(self):
+        # these show that in order for the delegation to work
+        # the _delegate_* methods need to be overridden to not raise
+        # a TypeError
+
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator,
+            accessors=self.Delegator._properties,
+            typ="property",
+        )
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator, accessors=self.Delegator._methods, typ="method"
+        )
+
+        delegate = self.Delegate(self.Delegator())
+
+        msg = "You cannot access the property foo"
+        with pytest.raises(TypeError, match=msg):
+            delegate.foo
+
+        msg = "The property foo cannot be set"
+        with pytest.raises(TypeError, match=msg):
+            delegate.foo = 5
+
+        msg = "You cannot access the property foo"
+        with pytest.raises(TypeError, match=msg):
+            delegate.foo()
+
+    @pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
+    def test_memory_usage(self):
+        # Delegate does not implement memory_usage.
+        # Check that we fall back to in-built `__sizeof__`
+        # GH 12924
+        delegate = self.Delegate(self.Delegator())
+        sys.getsizeof(delegate)
+
+
+class TestNoNewAttributesMixin:
+    def test_mixin(self):
+        class T(NoNewAttributesMixin):
+            pass
+
+        t = T()
+        assert not hasattr(t, "__frozen")
+
+        t.a = "test"
+        assert t.a == "test"
+
+        t._freeze()
+        assert "__frozen" in dir(t)
+        assert getattr(t, "__frozen")
+        msg = "You cannot add any new attribute"
+        with pytest.raises(AttributeError, match=msg):
+            t.b = "test"
+
+        assert not hasattr(t, "b")
+
+
+class TestConstruction:
+    # test certain constructor behaviours on dtype inference across Series,
+    # Index and DataFrame
+
+    @pytest.mark.parametrize(
+        "klass",
+        [
+            Series,
+            lambda x, **kwargs: DataFrame({"a": x}, **kwargs)["a"],
+            pytest.param(
+                lambda x, **kwargs: DataFrame(x, **kwargs)[0], marks=pytest.mark.xfail
+            ),
+            Index,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "a",
+        [
+            np.array(["2263-01-01"], dtype="datetime64[D]"),
+            np.array([datetime(2263, 1, 1)], dtype=object),
+            np.array([np.datetime64("2263-01-01", "D")], dtype=object),
+            np.array(["2263-01-01"], dtype=object),
+        ],
+        ids=[
+            "datetime64[D]",
+            "object-datetime.datetime",
+            "object-numpy-scalar",
+            "object-string",
+        ],
+    )
+    def test_constructor_datetime_outofbound(self, a, klass):
+        # GH-26853 (+ bug GH-26206 out of bound non-ns unit)
+
+        # No dtype specified (dtype inference)
+        # datetime64[non-ns] raise error, other cases result in object dtype
+        # and preserve original data
+        if a.dtype.kind == "M":
+            msg = "Out of bounds"
+            with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
+                klass(a)
+        else:
+            result = klass(a)
+            assert result.dtype == "object"
+            tm.assert_numpy_array_equal(result.to_numpy(), a)
+
+        # Explicit dtype specified
+        # Forced conversion fails for all -> all cases raise error
+        msg = "Out of bounds"
+        with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
+            klass(a, dtype="datetime64[ns]")
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
new file mode 100644
index 0000000000000..46fd1551e6170
--- /dev/null
+++ b/pandas/tests/base/test_conversion.py
@@ -0,0 +1,440 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_datetime64_dtype, is_timedelta64_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+from pandas import CategoricalIndex, Series, Timedelta, Timestamp
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    IntervalArray,
+    PandasArray,
+    PeriodArray,
+    SparseArray,
+    TimedeltaArray,
+)
+
+
+class TestToIterable:
+    # test that we convert an iterable to python types
+
+    dtypes = [
+        ("int8", int),
+        ("int16", int),
+        ("int32", int),
+        ("int64", int),
+        ("uint8", int),
+        ("uint16", int),
+        ("uint32", int),
+        ("uint64", int),
+        ("float16", float),
+        ("float32", float),
+        ("float64", float),
+        ("datetime64[ns]", Timestamp),
+        ("datetime64[ns, US/Eastern]", Timestamp),
+        ("timedelta64[ns]", Timedelta),
+    ]
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    @pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning")
+    # TODO(GH-24559): Remove the filterwarnings
+    def test_iterable(self, index_or_series, method, dtype, rdtype):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        s = typ([1], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype, obj",
+        [
+            ("object", object, "a"),
+            ("object", int, 1),
+            ("category", object, "a"),
+            ("category", int, 1),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_iterable_object_and_category(
+        self, index_or_series, method, dtype, rdtype, obj
+    ):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        s = typ([obj], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    def test_iterable_items(self, dtype, rdtype):
+        # gh-13258
+        # test if items yields the correct boxed scalars
+        # this only applies to series
+        s = Series([1], dtype=dtype)
+        _, result = list(s.items())[0]
+        assert isinstance(result, rdtype)
+
+        _, result = list(s.items())[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype", dtypes + [("object", int), ("category", int)]
+    )
+    @pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning")
+    # TODO(GH-24559): Remove the filterwarnings
+    def test_iterable_map(self, index_or_series, dtype, rdtype):
+        # gh-13236
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        s = typ([1], dtype=dtype)
+        result = s.map(type)[0]
+        if not isinstance(rdtype, tuple):
+            rdtype = tuple([rdtype])
+        assert result in rdtype
+
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_categorial_datetimelike(self, method):
+        i = CategoricalIndex([Timestamp("1999-12-31"), Timestamp("2000-12-31")])
+
+        result = method(i)[0]
+        assert isinstance(result, Timestamp)
+
+    def test_iter_box(self):
+        vals = [Timestamp("2011-01-01"), Timestamp("2011-01-02")]
+        s = Series(vals)
+        assert s.dtype == "datetime64[ns]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz is None
+            assert res == exp
+
+        vals = [
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            Timestamp("2011-01-02", tz="US/Eastern"),
+        ]
+        s = Series(vals)
+
+        assert s.dtype == "datetime64[ns, US/Eastern]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz == exp.tz
+            assert res == exp
+
+        # timedelta
+        vals = [Timedelta("1 days"), Timedelta("2 days")]
+        s = Series(vals)
+        assert s.dtype == "timedelta64[ns]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timedelta)
+            assert res == exp
+
+        # period
+        vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
+        s = Series(vals)
+        assert s.dtype == "Period[M]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, pd.Period)
+            assert res.freq == "M"
+            assert res == exp
+
+
+@pytest.mark.parametrize(
+    "array, expected_type, dtype",
+    [
+        (np.array([0, 1], dtype=np.int64), np.ndarray, "int64"),
+        (np.array(["a", "b"]), np.ndarray, "object"),
+        (pd.Categorical(["a", "b"]), pd.Categorical, "category"),
+        (
+            pd.DatetimeIndex(["2017", "2018"], tz="US/Central"),
+            DatetimeArray,
+            "datetime64[ns, US/Central]",
+        ),
+        (
+            pd.PeriodIndex([2018, 2019], freq="A"),
+            PeriodArray,
+            pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
+        ),
+        (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval",),
+        # This test is currently failing for datetime64[ns] and timedelta64[ns].
+        # The NumPy type system is sufficient for representing these types, so
+        # we just use NumPy for Series / DataFrame columns of these types (so
+        # we get consolidation and so on).
+        # However, DatetimeIndex and TimedeltaIndex use the DateLikeArray
+        # abstraction to for code reuse.
+        # At the moment, we've judged that allowing this test to fail is more
+        # practical that overriding Series._values to special case
+        # Series[M8[ns]] and Series[m8[ns]] to return a DateLikeArray.
+        pytest.param(
+            pd.DatetimeIndex(["2017", "2018"]),
+            np.ndarray,
+            "datetime64[ns]",
+            marks=[pytest.mark.xfail(reason="datetime _values", strict=True)],
+        ),
+        pytest.param(
+            pd.TimedeltaIndex([10 ** 10]),
+            np.ndarray,
+            "m8[ns]",
+            marks=[pytest.mark.xfail(reason="timedelta _values", strict=True)],
+        ),
+    ],
+)
+def test_values_consistent(array, expected_type, dtype):
+    l_values = pd.Series(array)._values
+    r_values = pd.Index(array)._values
+    assert type(l_values) is expected_type
+    assert type(l_values) is type(r_values)
+
+    tm.assert_equal(l_values, r_values)
+
+
+@pytest.mark.parametrize(
+    "array, expected",
+    [
+        (np.array([0, 1], dtype=np.int64), np.array([0, 1], dtype=np.int64)),
+        (np.array(["0", "1"]), np.array(["0", "1"], dtype=object)),
+        (pd.Categorical(["a", "a"]), np.array([0, 0], dtype="int8")),
+        (
+            pd.DatetimeIndex(["2017-01-01T00:00:00"]),
+            np.array(["2017-01-01T00:00:00"], dtype="M8[ns]"),
+        ),
+        (
+            pd.DatetimeIndex(["2017-01-01T00:00:00"], tz="US/Eastern"),
+            np.array(["2017-01-01T05:00:00"], dtype="M8[ns]"),
+        ),
+        (pd.TimedeltaIndex([10 ** 10]), np.array([10 ** 10], dtype="m8[ns]")),
+        (
+            pd.PeriodIndex(["2017", "2018"], freq="D"),
+            np.array([17167, 17532], dtype=np.int64),
+        ),
+    ],
+)
+def test_ndarray_values(array, expected):
+    l_values = pd.Series(array)._ndarray_values
+    r_values = pd.Index(array)._ndarray_values
+    tm.assert_numpy_array_equal(l_values, r_values)
+    tm.assert_numpy_array_equal(l_values, expected)
+
+
+@pytest.mark.parametrize("arr", [np.array([1, 2, 3])])
+def test_numpy_array(arr):
+    ser = pd.Series(arr)
+    result = ser.array
+    expected = PandasArray(arr)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_numpy_array_all_dtypes(any_numpy_dtype):
+    ser = pd.Series(dtype=any_numpy_dtype)
+    result = ser.array
+    if is_datetime64_dtype(any_numpy_dtype):
+        assert isinstance(result, DatetimeArray)
+    elif is_timedelta64_dtype(any_numpy_dtype):
+        assert isinstance(result, TimedeltaArray)
+    else:
+        assert isinstance(result, PandasArray)
+
+
+@pytest.mark.parametrize(
+    "array, attr",
+    [
+        (pd.Categorical(["a", "b"]), "_codes"),
+        (pd.core.arrays.period_array(["2000", "2001"], freq="D"), "_data"),
+        (pd.core.arrays.integer_array([0, np.nan]), "_data"),
+        (IntervalArray.from_breaks([0, 1]), "_left"),
+        (SparseArray([0, 1]), "_sparse_values"),
+        (DatetimeArray(np.array([1, 2], dtype="datetime64[ns]")), "_data"),
+        # tz-aware Datetime
+        (
+            DatetimeArray(
+                np.array(
+                    ["2000-01-01T12:00:00", "2000-01-02T12:00:00"], dtype="M8[ns]"
+                ),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            ),
+            "_data",
+        ),
+    ],
+)
+def test_array(array, attr, index_or_series):
+    box = index_or_series
+    if array.dtype.name in ("Int64", "Sparse[int64, 0]") and box is pd.Index:
+        pytest.skip(f"No index type for {array.dtype}")
+    result = box(array, copy=False).array
+
+    if attr:
+        array = getattr(array, attr)
+        result = getattr(result, attr)
+
+    assert result is array
+
+
+def test_array_multiindex_raises():
+    idx = pd.MultiIndex.from_product([["A"], ["a", "b"]])
+    msg = "MultiIndex has no single backing array"
+    with pytest.raises(ValueError, match=msg):
+        idx.array
+
+
+@pytest.mark.parametrize(
+    "array, expected",
+    [
+        (np.array([1, 2], dtype=np.int64), np.array([1, 2], dtype=np.int64)),
+        (pd.Categorical(["a", "b"]), np.array(["a", "b"], dtype=object)),
+        (
+            pd.core.arrays.period_array(["2000", "2001"], freq="D"),
+            np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
+        ),
+        (
+            pd.core.arrays.integer_array([0, np.nan]),
+            np.array([0, pd.NA], dtype=object),
+        ),
+        (
+            IntervalArray.from_breaks([0, 1, 2]),
+            np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
+        ),
+        (SparseArray([0, 1]), np.array([0, 1], dtype=np.int64)),
+        # tz-naive datetime
+        (
+            DatetimeArray(np.array(["2000", "2001"], dtype="M8[ns]")),
+            np.array(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        # tz-aware stays tz`-aware
+        (
+            DatetimeArray(
+                np.array(
+                    ["2000-01-01T06:00:00", "2000-01-02T06:00:00"], dtype="M8[ns]"
+                ),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            ),
+            np.array(
+                [
+                    pd.Timestamp("2000-01-01", tz="US/Central"),
+                    pd.Timestamp("2000-01-02", tz="US/Central"),
+                ]
+            ),
+        ),
+        # Timedelta
+        (
+            TimedeltaArray(np.array([0, 3600000000000], dtype="i8"), freq="H"),
+            np.array([0, 3600000000000], dtype="m8[ns]"),
+        ),
+    ],
+)
+def test_to_numpy(array, expected, index_or_series):
+    box = index_or_series
+    thing = box(array)
+
+    if array.dtype.name in ("Int64", "Sparse[int64, 0]") and box is pd.Index:
+        pytest.skip(f"No index type for {array.dtype}")
+
+    result = thing.to_numpy()
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+@pytest.mark.parametrize(
+    "arr", [np.array([1, 2, 3], dtype="int64"), np.array(["a", "b", "c"], dtype=object)]
+)
+def test_to_numpy_copy(arr, as_series):
+    obj = pd.Index(arr, copy=False)
+    if as_series:
+        obj = pd.Series(obj.values, copy=False)
+
+    # no copy by default
+    result = obj.to_numpy()
+    assert np.shares_memory(arr, result) is True
+
+    result = obj.to_numpy(copy=False)
+    assert np.shares_memory(arr, result) is True
+
+    # copy=True
+    result = obj.to_numpy(copy=True)
+    assert np.shares_memory(arr, result) is False
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+def test_to_numpy_dtype(as_series):
+    tz = "US/Eastern"
+    obj = pd.DatetimeIndex(["2000", "2001"], tz=tz)
+    if as_series:
+        obj = pd.Series(obj)
+
+    # preserve tz by default
+    result = obj.to_numpy()
+    expected = np.array(
+        [pd.Timestamp("2000", tz=tz), pd.Timestamp("2001", tz=tz)], dtype=object
+    )
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="M8[ns]")
+    expected = np.array(["2000-01-01T05", "2001-01-01T05"], dtype="M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values, dtype, na_value, expected",
+    [
+        ([1, 2, None], "float64", 0, [1.0, 2.0, 0.0]),
+        (
+            [pd.Timestamp("2000"), pd.Timestamp("2000"), pd.NaT],
+            None,
+            pd.Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+@pytest.mark.parametrize("container", [pd.Series, pd.Index])  # type: ignore
+def test_to_numpy_na_value_numpy_dtype(container, values, dtype, na_value, expected):
+    s = container(values)
+    result = s.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_kwargs_raises():
+    # numpy
+    s = pd.Series([1, 2, 3])
+    msg = r"to_numpy\(\) got an unexpected keyword argument 'foo'"
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
+
+    # extension
+    s = pd.Series([1, 2, 3], dtype="Int64")
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
diff --git a/pandas/tests/test_base.py b/pandas/tests/base/test_ops.py
similarity index 53%
rename from pandas/tests/test_base.py
rename to pandas/tests/base/test_ops.py
index c760c75e44f6b..e522c7f743a05 100644
--- a/pandas/tests/test_base.py
+++ b/pandas/tests/base/test_ops.py
@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta
 from io import StringIO
-import re
 import sys
+from typing import Any
 
 import numpy as np
 import pytest
@@ -14,14 +14,11 @@
     is_datetime64_dtype,
     is_datetime64tz_dtype,
     is_object_dtype,
-    is_timedelta64_dtype,
     needs_i8_conversion,
 )
-from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
 from pandas import (
-    CategoricalIndex,
     DataFrame,
     DatetimeIndex,
     Index,
@@ -33,137 +30,16 @@
     TimedeltaIndex,
     Timestamp,
 )
-from pandas.core.accessor import PandasDelegate
-from pandas.core.arrays import DatetimeArray, PandasArray, TimedeltaArray
-from pandas.core.base import NoNewAttributesMixin, PandasObject
-from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
-class CheckStringMixin:
-    def test_string_methods_dont_fail(self):
-        repr(self.container)
-        str(self.container)
-        bytes(self.container)
-
-    def test_tricky_container(self):
-        if not hasattr(self, "unicode_container"):
-            pytest.skip("Need unicode_container to test with this")
-        repr(self.unicode_container)
-        str(self.unicode_container)
-
-
-class CheckImmutable:
-    mutable_regex = re.compile("does not support mutable operations")
-
-    def check_mutable_error(self, *args, **kwargs):
-        # Pass whatever function you normally would to pytest.raises
-        # (after the Exception kind).
-        with pytest.raises(TypeError):
-            self.mutable_regex(*args, **kwargs)
-
-    def test_no_mutable_funcs(self):
-        def setitem():
-            self.container[0] = 5
-
-        self.check_mutable_error(setitem)
-
-        def setslice():
-            self.container[1:2] = 3
-
-        self.check_mutable_error(setslice)
-
-        def delitem():
-            del self.container[0]
-
-        self.check_mutable_error(delitem)
-
-        def delslice():
-            del self.container[0:3]
-
-        self.check_mutable_error(delslice)
-        mutable_methods = getattr(self, "mutable_methods", [])
-
-        for meth in mutable_methods:
-            self.check_mutable_error(getattr(self.container, meth))
-
-    def test_slicing_maintains_type(self):
-        result = self.container[1:2]
-        expected = self.lst[1:2]
-        self.check_result(result, expected)
-
-    def check_result(self, result, expected, klass=None):
-        klass = klass or self.klass
-        assert isinstance(result, klass)
-        assert result == expected
-
-
-class TestPandasDelegate:
-    class Delegator:
-        _properties = ["foo"]
-        _methods = ["bar"]
-
-        def _set_foo(self, value):
-            self.foo = value
-
-        def _get_foo(self):
-            return self.foo
-
-        foo = property(_get_foo, _set_foo, doc="foo property")
-
-        def bar(self, *args, **kwargs):
-            """ a test bar method """
-            pass
-
-    class Delegate(PandasDelegate, PandasObject):
-        def __init__(self, obj):
-            self.obj = obj
-
-    def setup_method(self, method):
-        pass
-
-    def test_invalid_delegation(self):
-        # these show that in order for the delegation to work
-        # the _delegate_* methods need to be overridden to not raise
-        # a TypeError
-
-        self.Delegate._add_delegate_accessors(
-            delegate=self.Delegator,
-            accessors=self.Delegator._properties,
-            typ="property",
-        )
-        self.Delegate._add_delegate_accessors(
-            delegate=self.Delegator, accessors=self.Delegator._methods, typ="method"
-        )
-
-        delegate = self.Delegate(self.Delegator())
-
-        with pytest.raises(TypeError):
-            delegate.foo
-
-        with pytest.raises(TypeError):
-            delegate.foo = 5
-
-        with pytest.raises(TypeError):
-            delegate.foo()
-
-    @pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
-    def test_memory_usage(self):
-        # Delegate does not implement memory_usage.
-        # Check that we fall back to in-built `__sizeof__`
-        # GH 12924
-        delegate = self.Delegate(self.Delegator())
-        sys.getsizeof(delegate)
+def allow_na_ops(obj: Any) -> bool:
+    """Whether to skip test cases including NaN"""
+    is_bool_index = isinstance(obj, Index) and obj.is_boolean()
+    return not is_bool_index and obj._can_hold_na
 
 
 class Ops:
-    def _allow_na_ops(self, obj):
-        """Whether to skip test cases including NaN"""
-        if isinstance(obj, Index) and (obj.is_boolean() or not obj._can_hold_na):
-            # don't test boolean / int64 index
-            return False
-        return True
-
     def setup_method(self, method):
         self.bool_index = tm.makeBoolIndex(10, name="a")
         self.int_index = tm.makeIntIndex(10, name="a")
@@ -179,84 +55,80 @@ def setup_method(self, method):
         self.int_series = Series(arr, index=self.int_index, name="a")
         self.float_series = Series(arr, index=self.float_index, name="a")
         self.dt_series = Series(arr, index=self.dt_index, name="a")
-        self.dt_tz_series = self.dt_tz_index.to_series(keep_tz=True)
+        self.dt_tz_series = self.dt_tz_index.to_series()
         self.period_series = Series(arr, index=self.period_index, name="a")
         self.string_series = Series(arr, index=self.string_index, name="a")
         self.unicode_series = Series(arr, index=self.unicode_index, name="a")
 
         types = ["bool", "int", "float", "dt", "dt_tz", "period", "string", "unicode"]
-        self.indexes = [getattr(self, "{}_index".format(t)) for t in types]
-        self.series = [getattr(self, "{}_series".format(t)) for t in types]
-        self.objs = self.indexes + self.series
-
-    def check_ops_properties(self, props, filter=None, ignore_failures=False):
-        for op in props:
-            for o in self.is_valid_objs:
-
-                # if a filter, skip if it doesn't match
-                if filter is not None:
-                    filt = o.index if isinstance(o, Series) else o
-                    if not filter(filt):
-                        continue
-
-                try:
-                    if isinstance(o, Series):
-                        expected = Series(getattr(o.index, op), index=o.index, name="a")
-                    else:
-                        expected = getattr(o, op)
-                except (AttributeError):
-                    if ignore_failures:
-                        continue
-
-                result = getattr(o, op)
-
-                # these could be series, arrays or scalars
-                if isinstance(result, Series) and isinstance(expected, Series):
-                    tm.assert_series_equal(result, expected)
-                elif isinstance(result, Index) and isinstance(expected, Index):
-                    tm.assert_index_equal(result, expected)
-                elif isinstance(result, np.ndarray) and isinstance(
-                    expected, np.ndarray
-                ):
-                    tm.assert_numpy_array_equal(result, expected)
-                else:
-                    assert result == expected
-
-            # freq raises AttributeError on an Int64Index because its not
-            # defined we mostly care about Series here anyhow
-            if not ignore_failures:
-                for o in self.not_valid_objs:
-
-                    # an object that is datetimelike will raise a TypeError,
-                    # otherwise an AttributeError
-                    err = AttributeError
-                    if issubclass(type(o), DatetimeIndexOpsMixin):
-                        err = TypeError
-
-                    with pytest.raises(err):
-                        getattr(o, op)
-
-    @pytest.mark.parametrize("klass", [Series, DataFrame])
-    def test_binary_ops_docs(self, klass):
-        op_map = {
-            "add": "+",
-            "sub": "-",
-            "mul": "*",
-            "mod": "%",
-            "pow": "**",
-            "truediv": "/",
-            "floordiv": "//",
-        }
-        for op_name in op_map:
-            operand1 = klass.__name__.lower()
-            operand2 = "other"
-            op = op_map[op_name]
-            expected_str = " ".join([operand1, op, operand2])
-            assert expected_str in getattr(klass, op_name).__doc__
-
-            # reverse version of the binary ops
-            expected_str = " ".join([operand2, op, operand1])
-            assert expected_str in getattr(klass, "r" + op_name).__doc__
+        self.indexes = [getattr(self, f"{t}_index") for t in types]
+        self.series = [getattr(self, f"{t}_series") for t in types]
+
+        # To test narrow dtypes, we use narrower *data* elements, not *index* elements
+        index = self.int_index
+        self.float32_series = Series(arr.astype(np.float32), index=index, name="a")
+
+        arr_int = np.random.choice(10, size=10, replace=False)
+        self.int8_series = Series(arr_int.astype(np.int8), index=index, name="a")
+        self.int16_series = Series(arr_int.astype(np.int16), index=index, name="a")
+        self.int32_series = Series(arr_int.astype(np.int32), index=index, name="a")
+
+        self.uint8_series = Series(arr_int.astype(np.uint8), index=index, name="a")
+        self.uint16_series = Series(arr_int.astype(np.uint16), index=index, name="a")
+        self.uint32_series = Series(arr_int.astype(np.uint32), index=index, name="a")
+
+        nrw_types = ["float32", "int8", "int16", "int32", "uint8", "uint16", "uint32"]
+        self.narrow_series = [getattr(self, f"{t}_series") for t in nrw_types]
+
+        self.objs = self.indexes + self.series + self.narrow_series
+
+
+@pytest.mark.parametrize(
+    "op_name, op",
+    [
+        ("add", "+"),
+        ("sub", "-"),
+        ("mul", "*"),
+        ("mod", "%"),
+        ("pow", "**"),
+        ("truediv", "/"),
+        ("floordiv", "//"),
+    ],
+)
+@pytest.mark.parametrize("klass", [Series, DataFrame])
+def test_binary_ops(klass, op_name, op):
+    # not using the all_arithmetic_functions fixture with _get_opstr
+    # as _get_opstr is used internally in the dynamic implementation of the docstring
+    operand1 = klass.__name__.lower()
+    operand2 = "other"
+    expected_str = " ".join([operand1, op, operand2])
+    assert expected_str in getattr(klass, op_name).__doc__
+
+    # reverse version of the binary ops
+    expected_str = " ".join([operand2, op, operand1])
+    assert expected_str in getattr(klass, "r" + op_name).__doc__
+
+
+class TestTranspose(Ops):
+    errmsg = "the 'axes' parameter is not supported"
+
+    def test_transpose(self):
+        for obj in self.objs:
+            tm.assert_equal(obj.transpose(), obj)
+
+    def test_transpose_non_default_axes(self):
+        for obj in self.objs:
+            with pytest.raises(ValueError, match=self.errmsg):
+                obj.transpose(1)
+            with pytest.raises(ValueError, match=self.errmsg):
+                obj.transpose(axes=1)
+
+    def test_numpy_transpose(self):
+        for obj in self.objs:
+            tm.assert_equal(np.transpose(obj), obj)
+
+            with pytest.raises(ValueError, match=self.errmsg):
+                np.transpose(obj, axes=1)
 
 
 class TestIndexOps(Ops):
@@ -295,9 +167,10 @@ def test_none_comparison(self):
                 if is_datetime64_dtype(o) or is_datetime64tz_dtype(o):
                     # Following DatetimeIndex (and Timestamp) convention,
                     # inequality comparisons with Series[datetime64] raise
-                    with pytest.raises(TypeError):
+                    msg = "Invalid comparison"
+                    with pytest.raises(TypeError, match=msg):
                         None > o
-                    with pytest.raises(TypeError):
+                    with pytest.raises(TypeError, match=msg):
                         o > None
                 else:
                     result = None > o
@@ -316,31 +189,18 @@ def test_ndarray_compat_properties(self):
                 assert getattr(o, p, None) is not None
 
             # deprecated properties
-            for p in ["flags", "strides", "itemsize"]:
-                with tm.assert_produces_warning(FutureWarning):
-                    assert getattr(o, p, None) is not None
-
-            with tm.assert_produces_warning(FutureWarning):
-                assert hasattr(o, "base")
-
-            # If we have a datetime-like dtype then needs a view to work
-            # but the user is responsible for that
-            try:
-                with tm.assert_produces_warning(FutureWarning):
-                    assert o.data is not None
-            except ValueError:
-                pass
+            for p in ["flags", "strides", "itemsize", "base", "data"]:
+                assert not hasattr(o, p)
 
-            with pytest.raises(ValueError):
-                with tm.assert_produces_warning(FutureWarning):
-                    o.item()  # len > 1
+            msg = "can only convert an array of size 1 to a Python scalar"
+            with pytest.raises(ValueError, match=msg):
+                o.item()  # len > 1
 
             assert o.ndim == 1
             assert o.size == len(o)
 
-        with tm.assert_produces_warning(FutureWarning):
-            assert Index([1]).item() == 1
-            assert Series([1]).item() == 1
+        assert Index([1]).item() == 1
+        assert Series([1]).item() == 1
 
     def test_value_counts_unique_nunique(self):
         for orig in self.objs:
@@ -383,8 +243,9 @@ def test_value_counts_unique_nunique(self):
 
             result = o.unique()
             if isinstance(o, Index):
-                assert isinstance(result, o.__class__)
+                assert isinstance(result, type(o))
                 tm.assert_index_equal(result, orig)
+                assert result.dtype == orig.dtype
             elif is_datetime64tz_dtype(o):
                 # datetimetz Series returns array of Timestamp
                 assert result[0] == orig[0]
@@ -396,6 +257,7 @@ def test_value_counts_unique_nunique(self):
                 )
             else:
                 tm.assert_numpy_array_equal(result, orig.values)
+                assert result.dtype == orig.dtype
 
             assert o.nunique() == len(np.unique(o.values))
 
@@ -407,7 +269,7 @@ def test_value_counts_unique_nunique_null(self, null_obj):
             klass = type(o)
             values = o._ndarray_values
 
-            if not self._allow_na_ops(o):
+            if not allow_na_ops(o):
                 continue
 
             # special assign to the numpy array
@@ -497,8 +359,8 @@ def test_value_counts_unique_nunique_null(self, null_obj):
             assert o.nunique() == 8
             assert o.nunique(dropna=False) == 9
 
-    @pytest.mark.parametrize("klass", [Index, Series])
-    def test_value_counts_inferred(self, klass):
+    def test_value_counts_inferred(self, index_or_series):
+        klass = index_or_series
         s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
         s = klass(s_values)
         expected = Series([4, 3, 2, 1], index=["b", "a", "d", "c"])
@@ -528,13 +390,14 @@ def test_value_counts_inferred(self, klass):
         expected = Series([0.4, 0.3, 0.2, 0.1], index=["b", "a", "d", "c"])
         tm.assert_series_equal(hist, expected)
 
-    @pytest.mark.parametrize("klass", [Index, Series])
-    def test_value_counts_bins(self, klass):
+    def test_value_counts_bins(self, index_or_series):
+        klass = index_or_series
         s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
         s = klass(s_values)
 
         # bins
-        with pytest.raises(TypeError):
+        msg = "bins argument only works with numeric data"
+        with pytest.raises(TypeError, match=msg):
             s.value_counts(bins=1)
 
         s1 = Series([1, 1, 2, 3])
@@ -582,7 +445,7 @@ def test_value_counts_bins(self, klass):
             tm.assert_numpy_array_equal(s.unique(), exp)
         assert s.nunique() == 3
 
-        s = klass({})
+        s = klass({}) if klass is dict else klass({}, dtype=object)
         expected = Series([], dtype=np.int64)
         tm.assert_series_equal(s.value_counts(), expected, check_index_type=False)
         # returned dtype differs depending on original
@@ -593,8 +456,8 @@ def test_value_counts_bins(self, klass):
 
         assert s.nunique() == 0
 
-    @pytest.mark.parametrize("klass", [Index, Series])
-    def test_value_counts_datetime64(self, klass):
+    def test_value_counts_datetime64(self, index_or_series):
+        klass = index_or_series
 
         # GH 3002, datetime64[ns]
         # don't test names though
@@ -634,7 +497,7 @@ def test_value_counts_datetime64(self, klass):
 
         # with NaT
         s = df["dt"].copy()
-        s = klass([v for v in s.values] + [pd.NaT])
+        s = klass(list(s.values) + [pd.NaT])
 
         result = s.value_counts()
         assert result.index.dtype == "datetime64[ns]"
@@ -688,9 +551,9 @@ def test_factorize(self):
             else:
                 exp_arr = np.array(range(len(o)), dtype=np.intp)
                 exp_uniques = o
-            labels, uniques = o.factorize()
+            codes, uniques = o.factorize()
 
-            tm.assert_numpy_array_equal(labels, exp_arr)
+            tm.assert_numpy_array_equal(codes, exp_arr)
             if isinstance(o, Series):
                 tm.assert_index_equal(uniques, Index(orig), check_names=False)
             else:
@@ -717,9 +580,9 @@ def test_factorize_repeated(self):
             exp_arr = np.array(
                 [5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.intp
             )
-            labels, uniques = n.factorize(sort=True)
+            codes, uniques = n.factorize(sort=True)
 
-            tm.assert_numpy_array_equal(labels, exp_arr)
+            tm.assert_numpy_array_equal(codes, exp_arr)
             if isinstance(o, Series):
                 tm.assert_index_equal(
                     uniques, Index(orig).sort_values(), check_names=False
@@ -728,8 +591,8 @@ def test_factorize_repeated(self):
                 tm.assert_index_equal(uniques, o, check_names=False)
 
             exp_arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4], np.intp)
-            labels, uniques = n.factorize(sort=False)
-            tm.assert_numpy_array_equal(labels, exp_arr)
+            codes, uniques = n.factorize(sort=False)
+            tm.assert_numpy_array_equal(codes, exp_arr)
 
             if isinstance(o, Series):
                 expected = Index(o.iloc[5:10].append(o.iloc[:5]))
@@ -794,9 +657,7 @@ def test_duplicated_drop_duplicates_index(self):
 
                 with pytest.raises(
                     TypeError,
-                    match=(
-                        r"drop_duplicates\(\) got an " r"unexpected keyword argument"
-                    ),
+                    match=r"drop_duplicates\(\) got an unexpected keyword argument",
                 ):
                     idx.drop_duplicates(inplace=True)
 
@@ -889,7 +750,7 @@ def test_fillna(self):
                 o = orig.copy()
                 klass = type(o)
 
-                if not self._allow_na_ops(o):
+                if not allow_na_ops(o):
                     continue
 
                 if needs_i8_conversion(o):
@@ -904,7 +765,7 @@ def test_fillna(self):
 
                 expected = [fill_value] * 2 + list(values[2:])
 
-                expected = klass(expected)
+                expected = klass(expected, dtype=orig.dtype)
                 o = klass(values)
 
                 # check values has the same dtype as the original
@@ -955,7 +816,8 @@ def test_validate_bool_args(self):
         invalid_values = [1, "True", [1, 2, 3], 5.0]
 
         for value in invalid_values:
-            with pytest.raises(ValueError):
+            msg = "expected type bool"
+            with pytest.raises(ValueError, match=msg):
                 self.int_series.drop_duplicates(inplace=value)
 
     def test_getitem(self):
@@ -968,9 +830,11 @@ def test_getitem(self):
 
             assert i[-1] == i[9]
 
-            with pytest.raises(IndexError):
+            msg = "index 20 is out of bounds for axis 0 with size 10"
+            with pytest.raises(IndexError, match=msg):
                 i[20]
-            with pytest.raises(IndexError):
+            msg = "single positional indexer is out-of-bounds"
+            with pytest.raises(IndexError, match=msg):
                 s.iloc[20]
 
     @pytest.mark.parametrize("indexer_klass", [list, pd.Index])
@@ -990,486 +854,8 @@ def test_bool_indexing(self, indexer_klass, indexer):
             s = pd.Series(idx)
             tm.assert_series_equal(s[indexer_klass(indexer)], s.iloc[exp_idx])
 
-
-class TestTranspose(Ops):
-    errmsg = "the 'axes' parameter is not supported"
-
-    def test_transpose(self):
-        for obj in self.objs:
-            tm.assert_equal(obj.transpose(), obj)
-
-    def test_transpose_non_default_axes(self):
-        for obj in self.objs:
-            with pytest.raises(ValueError, match=self.errmsg):
-                obj.transpose(1)
-            with pytest.raises(ValueError, match=self.errmsg):
-                obj.transpose(axes=1)
-
-    def test_numpy_transpose(self):
-        for obj in self.objs:
-            tm.assert_equal(np.transpose(obj), obj)
-
-            with pytest.raises(ValueError, match=self.errmsg):
-                np.transpose(obj, axes=1)
-
-
-class TestNoNewAttributesMixin:
-    def test_mixin(self):
-        class T(NoNewAttributesMixin):
-            pass
-
-        t = T()
-        assert not hasattr(t, "__frozen")
-
-        t.a = "test"
-        assert t.a == "test"
-
-        t._freeze()
-        assert "__frozen" in dir(t)
-        assert getattr(t, "__frozen")
-
-        with pytest.raises(AttributeError):
-            t.b = "test"
-
-        assert not hasattr(t, "b")
-
-
-class TestToIterable:
-    # test that we convert an iterable to python types
-
-    dtypes = [
-        ("int8", int),
-        ("int16", int),
-        ("int32", int),
-        ("int64", int),
-        ("uint8", int),
-        ("uint16", int),
-        ("uint32", int),
-        ("uint64", int),
-        ("float16", float),
-        ("float32", float),
-        ("float64", float),
-        ("datetime64[ns]", Timestamp),
-        ("datetime64[ns, US/Eastern]", Timestamp),
-        ("timedelta64[ns]", Timedelta),
-    ]
-
-    @pytest.mark.parametrize("dtype, rdtype", dtypes)
-    @pytest.mark.parametrize(
-        "method",
-        [
-            lambda x: x.tolist(),
-            lambda x: x.to_list(),
-            lambda x: list(x),
-            lambda x: list(x.__iter__()),
-        ],
-        ids=["tolist", "to_list", "list", "iter"],
-    )
-    @pytest.mark.parametrize("typ", [Series, Index])
-    @pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning")
-    # TODO(GH-24559): Remove the filterwarnings
-    def test_iterable(self, typ, method, dtype, rdtype):
-        # gh-10904
-        # gh-13258
-        # coerce iteration to underlying python / pandas types
-        s = typ([1], dtype=dtype)
-        result = method(s)[0]
-        assert isinstance(result, rdtype)
-
-    @pytest.mark.parametrize(
-        "dtype, rdtype, obj",
-        [
-            ("object", object, "a"),
-            ("object", int, 1),
-            ("category", object, "a"),
-            ("category", int, 1),
-        ],
-    )
-    @pytest.mark.parametrize(
-        "method",
-        [
-            lambda x: x.tolist(),
-            lambda x: x.to_list(),
-            lambda x: list(x),
-            lambda x: list(x.__iter__()),
-        ],
-        ids=["tolist", "to_list", "list", "iter"],
-    )
-    @pytest.mark.parametrize("typ", [Series, Index])
-    def test_iterable_object_and_category(self, typ, method, dtype, rdtype, obj):
-        # gh-10904
-        # gh-13258
-        # coerce iteration to underlying python / pandas types
-        s = typ([obj], dtype=dtype)
-        result = method(s)[0]
-        assert isinstance(result, rdtype)
-
-    @pytest.mark.parametrize("dtype, rdtype", dtypes)
-    def test_iterable_items(self, dtype, rdtype):
-        # gh-13258
-        # test if items yields the correct boxed scalars
-        # this only applies to series
-        s = Series([1], dtype=dtype)
-        _, result = list(s.items())[0]
-        assert isinstance(result, rdtype)
-
-        _, result = list(s.items())[0]
-        assert isinstance(result, rdtype)
-
-    @pytest.mark.parametrize(
-        "dtype, rdtype", dtypes + [("object", int), ("category", int)]
-    )
-    @pytest.mark.parametrize("typ", [Series, Index])
-    @pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning")
-    # TODO(GH-24559): Remove the filterwarnings
-    def test_iterable_map(self, typ, dtype, rdtype):
-        # gh-13236
-        # coerce iteration to underlying python / pandas types
-        s = typ([1], dtype=dtype)
-        result = s.map(type)[0]
-        if not isinstance(rdtype, tuple):
-            rdtype = tuple([rdtype])
-        assert result in rdtype
-
-    @pytest.mark.parametrize(
-        "method",
-        [
-            lambda x: x.tolist(),
-            lambda x: x.to_list(),
-            lambda x: list(x),
-            lambda x: list(x.__iter__()),
-        ],
-        ids=["tolist", "to_list", "list", "iter"],
-    )
-    def test_categorial_datetimelike(self, method):
-        i = CategoricalIndex([Timestamp("1999-12-31"), Timestamp("2000-12-31")])
-
-        result = method(i)[0]
-        assert isinstance(result, Timestamp)
-
-    def test_iter_box(self):
-        vals = [Timestamp("2011-01-01"), Timestamp("2011-01-02")]
-        s = Series(vals)
-        assert s.dtype == "datetime64[ns]"
-        for res, exp in zip(s, vals):
-            assert isinstance(res, Timestamp)
-            assert res.tz is None
-            assert res == exp
-
-        vals = [
-            Timestamp("2011-01-01", tz="US/Eastern"),
-            Timestamp("2011-01-02", tz="US/Eastern"),
-        ]
-        s = Series(vals)
-
-        assert s.dtype == "datetime64[ns, US/Eastern]"
-        for res, exp in zip(s, vals):
-            assert isinstance(res, Timestamp)
-            assert res.tz == exp.tz
-            assert res == exp
-
-        # timedelta
-        vals = [Timedelta("1 days"), Timedelta("2 days")]
-        s = Series(vals)
-        assert s.dtype == "timedelta64[ns]"
-        for res, exp in zip(s, vals):
-            assert isinstance(res, Timedelta)
-            assert res == exp
-
-        # period
-        vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
-        s = Series(vals)
-        assert s.dtype == "Period[M]"
-        for res, exp in zip(s, vals):
-            assert isinstance(res, pd.Period)
-            assert res.freq == "M"
-            assert res == exp
-
-
-@pytest.mark.parametrize(
-    "array, expected_type, dtype",
-    [
-        (np.array([0, 1], dtype=np.int64), np.ndarray, "int64"),
-        (np.array(["a", "b"]), np.ndarray, "object"),
-        (pd.Categorical(["a", "b"]), pd.Categorical, "category"),
-        (
-            pd.DatetimeIndex(["2017", "2018"], tz="US/Central"),
-            DatetimeArray,
-            "datetime64[ns, US/Central]",
-        ),
-        (
-            pd.PeriodIndex([2018, 2019], freq="A"),
-            pd.core.arrays.PeriodArray,
-            pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
-        ),
-        (
-            pd.IntervalIndex.from_breaks([0, 1, 2]),
-            pd.core.arrays.IntervalArray,
-            "interval",
-        ),
-        # This test is currently failing for datetime64[ns] and timedelta64[ns].
-        # The NumPy type system is sufficient for representing these types, so
-        # we just use NumPy for Series / DataFrame columns of these types (so
-        # we get consolidation and so on).
-        # However, DatetimeIndex and TimedeltaIndex use the DateLikeArray
-        # abstraction to for code reuse.
-        # At the moment, we've judged that allowing this test to fail is more
-        # practical that overriding Series._values to special case
-        # Series[M8[ns]] and Series[m8[ns]] to return a DateLikeArray.
-        pytest.param(
-            pd.DatetimeIndex(["2017", "2018"]),
-            np.ndarray,
-            "datetime64[ns]",
-            marks=[pytest.mark.xfail(reason="datetime _values", strict=True)],
-        ),
-        pytest.param(
-            pd.TimedeltaIndex([10 ** 10]),
-            np.ndarray,
-            "m8[ns]",
-            marks=[pytest.mark.xfail(reason="timedelta _values", strict=True)],
-        ),
-    ],
-)
-def test_values_consistent(array, expected_type, dtype):
-    l_values = pd.Series(array)._values
-    r_values = pd.Index(array)._values
-    assert type(l_values) is expected_type
-    assert type(l_values) is type(r_values)
-
-    tm.assert_equal(l_values, r_values)
-
-
-@pytest.mark.parametrize(
-    "array, expected",
-    [
-        (np.array([0, 1], dtype=np.int64), np.array([0, 1], dtype=np.int64)),
-        (np.array(["0", "1"]), np.array(["0", "1"], dtype=object)),
-        (pd.Categorical(["a", "a"]), np.array([0, 0], dtype="int8")),
-        (
-            pd.DatetimeIndex(["2017-01-01T00:00:00"]),
-            np.array(["2017-01-01T00:00:00"], dtype="M8[ns]"),
-        ),
-        (
-            pd.DatetimeIndex(["2017-01-01T00:00:00"], tz="US/Eastern"),
-            np.array(["2017-01-01T05:00:00"], dtype="M8[ns]"),
-        ),
-        (pd.TimedeltaIndex([10 ** 10]), np.array([10 ** 10], dtype="m8[ns]")),
-        (
-            pd.PeriodIndex(["2017", "2018"], freq="D"),
-            np.array([17167, 17532], dtype=np.int64),
-        ),
-    ],
-)
-def test_ndarray_values(array, expected):
-    l_values = pd.Series(array)._ndarray_values
-    r_values = pd.Index(array)._ndarray_values
-    tm.assert_numpy_array_equal(l_values, r_values)
-    tm.assert_numpy_array_equal(l_values, expected)
-
-
-@pytest.mark.parametrize("arr", [np.array([1, 2, 3])])
-def test_numpy_array(arr):
-    ser = pd.Series(arr)
-    result = ser.array
-    expected = PandasArray(arr)
-    tm.assert_extension_array_equal(result, expected)
-
-
-def test_numpy_array_all_dtypes(any_numpy_dtype):
-    ser = pd.Series(dtype=any_numpy_dtype)
-    result = ser.array
-    if is_datetime64_dtype(any_numpy_dtype):
-        assert isinstance(result, DatetimeArray)
-    elif is_timedelta64_dtype(any_numpy_dtype):
-        assert isinstance(result, TimedeltaArray)
-    else:
-        assert isinstance(result, PandasArray)
-
-
-@pytest.mark.parametrize(
-    "array, attr",
-    [
-        (pd.Categorical(["a", "b"]), "_codes"),
-        (pd.core.arrays.period_array(["2000", "2001"], freq="D"), "_data"),
-        (pd.core.arrays.integer_array([0, np.nan]), "_data"),
-        (pd.core.arrays.IntervalArray.from_breaks([0, 1]), "_left"),
-        (pd.SparseArray([0, 1]), "_sparse_values"),
-        (DatetimeArray(np.array([1, 2], dtype="datetime64[ns]")), "_data"),
-        # tz-aware Datetime
-        (
-            DatetimeArray(
-                np.array(
-                    ["2000-01-01T12:00:00", "2000-01-02T12:00:00"], dtype="M8[ns]"
-                ),
-                dtype=DatetimeTZDtype(tz="US/Central"),
-            ),
-            "_data",
-        ),
-    ],
-)
-@pytest.mark.parametrize("box", [pd.Series, pd.Index])
-def test_array(array, attr, box):
-    if array.dtype.name in ("Int64", "Sparse[int64, 0]") and box is pd.Index:
-        pytest.skip("No index type for {}".format(array.dtype))
-    result = box(array, copy=False).array
-
-    if attr:
-        array = getattr(array, attr)
-        result = getattr(result, attr)
-
-    assert result is array
-
-
-def test_array_multiindex_raises():
-    idx = pd.MultiIndex.from_product([["A"], ["a", "b"]])
-    with pytest.raises(ValueError, match="MultiIndex"):
-        idx.array
-
-
-@pytest.mark.parametrize(
-    "array, expected",
-    [
-        (np.array([1, 2], dtype=np.int64), np.array([1, 2], dtype=np.int64)),
-        (pd.Categorical(["a", "b"]), np.array(["a", "b"], dtype=object)),
-        (
-            pd.core.arrays.period_array(["2000", "2001"], freq="D"),
-            np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
-        ),
-        (
-            pd.core.arrays.integer_array([0, np.nan]),
-            np.array([0, np.nan], dtype=object),
-        ),
-        (
-            pd.core.arrays.IntervalArray.from_breaks([0, 1, 2]),
-            np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
-        ),
-        (pd.SparseArray([0, 1]), np.array([0, 1], dtype=np.int64)),
-        # tz-naive datetime
-        (
-            DatetimeArray(np.array(["2000", "2001"], dtype="M8[ns]")),
-            np.array(["2000", "2001"], dtype="M8[ns]"),
-        ),
-        # tz-aware stays tz`-aware
-        (
-            DatetimeArray(
-                np.array(
-                    ["2000-01-01T06:00:00", "2000-01-02T06:00:00"], dtype="M8[ns]"
-                ),
-                dtype=DatetimeTZDtype(tz="US/Central"),
-            ),
-            np.array(
-                [
-                    pd.Timestamp("2000-01-01", tz="US/Central"),
-                    pd.Timestamp("2000-01-02", tz="US/Central"),
-                ]
-            ),
-        ),
-        # Timedelta
-        (
-            TimedeltaArray(np.array([0, 3600000000000], dtype="i8"), freq="H"),
-            np.array([0, 3600000000000], dtype="m8[ns]"),
-        ),
-    ],
-)
-@pytest.mark.parametrize("box", [pd.Series, pd.Index])
-def test_to_numpy(array, expected, box):
-    thing = box(array)
-
-    if array.dtype.name in ("Int64", "Sparse[int64, 0]") and box is pd.Index:
-        pytest.skip("No index type for {}".format(array.dtype))
-
-    result = thing.to_numpy()
-    tm.assert_numpy_array_equal(result, expected)
-
-
-@pytest.mark.parametrize("as_series", [True, False])
-@pytest.mark.parametrize(
-    "arr", [np.array([1, 2, 3], dtype="int64"), np.array(["a", "b", "c"], dtype=object)]
-)
-def test_to_numpy_copy(arr, as_series):
-    obj = pd.Index(arr, copy=False)
-    if as_series:
-        obj = pd.Series(obj.values, copy=False)
-
-    # no copy by default
-    result = obj.to_numpy()
-    assert np.shares_memory(arr, result) is True
-
-    result = obj.to_numpy(copy=False)
-    assert np.shares_memory(arr, result) is True
-
-    # copy=True
-    result = obj.to_numpy(copy=True)
-    assert np.shares_memory(arr, result) is False
-
-
-@pytest.mark.parametrize("as_series", [True, False])
-def test_to_numpy_dtype(as_series):
-    tz = "US/Eastern"
-    obj = pd.DatetimeIndex(["2000", "2001"], tz=tz)
-    if as_series:
-        obj = pd.Series(obj)
-
-    # preserve tz by default
-    result = obj.to_numpy()
-    expected = np.array(
-        [pd.Timestamp("2000", tz=tz), pd.Timestamp("2001", tz=tz)], dtype=object
-    )
-    tm.assert_numpy_array_equal(result, expected)
-
-    result = obj.to_numpy(dtype="object")
-    tm.assert_numpy_array_equal(result, expected)
-
-    result = obj.to_numpy(dtype="M8[ns]")
-    expected = np.array(["2000-01-01T05", "2001-01-01T05"], dtype="M8[ns]")
-    tm.assert_numpy_array_equal(result, expected)
-
-
-class TestConstruction:
-    # test certain constructor behaviours on dtype inference across Series,
-    # Index and DataFrame
-
-    @pytest.mark.parametrize(
-        "klass",
-        [
-            Series,
-            lambda x, **kwargs: DataFrame({"a": x}, **kwargs)["a"],
-            pytest.param(
-                lambda x, **kwargs: DataFrame(x, **kwargs)[0], marks=pytest.mark.xfail
-            ),
-            Index,
-        ],
-    )
-    @pytest.mark.parametrize(
-        "a",
-        [
-            np.array(["2263-01-01"], dtype="datetime64[D]"),
-            np.array([datetime(2263, 1, 1)], dtype=object),
-            np.array([np.datetime64("2263-01-01", "D")], dtype=object),
-            np.array(["2263-01-01"], dtype=object),
-        ],
-        ids=[
-            "datetime64[D]",
-            "object-datetime.datetime",
-            "object-numpy-scalar",
-            "object-string",
-        ],
-    )
-    def test_constructor_datetime_outofbound(self, a, klass):
-        # GH-26853 (+ bug GH-26206 out of bound non-ns unit)
-
-        # No dtype specified (dtype inference)
-        # datetime64[non-ns] raise error, other cases result in object dtype
-        # and preserve original data
-        if a.dtype.kind == "M":
-            with pytest.raises(pd.errors.OutOfBoundsDatetime):
-                klass(a)
-        else:
-            result = klass(a)
-            assert result.dtype == "object"
-            tm.assert_numpy_array_equal(result.to_numpy(), a)
-
-        # Explicit dtype specified
-        # Forced conversion fails for all -> all cases raise error
-        with pytest.raises(pd.errors.OutOfBoundsDatetime):
-            klass(a, dtype="datetime64[ns]")
+    def test_get_indexer_non_unique_dtype_mismatch(self):
+        # GH 25459
+        indexes, missing = pd.Index(["A", "B"]).get_indexer_non_unique(pd.Index([0]))
+        tm.assert_numpy_array_equal(np.array([-1], dtype=np.intp), indexes)
+        tm.assert_numpy_array_equal(np.array([0], dtype=np.int64), missing)
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index b6ffd8a83e409..a240e6cef5930 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -2,6 +2,7 @@
 from functools import reduce
 from itertools import product
 import operator
+from typing import Dict, Type
 import warnings
 
 import numpy as np
@@ -15,11 +16,16 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, compat, date_range
+import pandas._testing as tm
 from pandas.core.computation import pytables
 from pandas.core.computation.check import _NUMEXPR_VERSION
 from pandas.core.computation.engines import NumExprClobberingError, _engines
 import pandas.core.computation.expr as expr
-from pandas.core.computation.expr import PandasExprVisitor, PythonExprVisitor
+from pandas.core.computation.expr import (
+    BaseExprVisitor,
+    PandasExprVisitor,
+    PythonExprVisitor,
+)
 from pandas.core.computation.expressions import _NUMEXPR_INSTALLED, _USE_NUMEXPR
 from pandas.core.computation.ops import (
     _arith_ops_syms,
@@ -28,15 +34,6 @@
     _special_case_arith_ops_syms,
     _unary_math_ops,
 )
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_frame_equal,
-    assert_numpy_array_equal,
-    assert_produces_warning,
-    assert_series_equal,
-    makeCustomDataframe as mkdf,
-    randbool,
-)
 
 
 @pytest.fixture(
@@ -45,10 +42,8 @@
             engine,
             marks=pytest.mark.skipif(
                 engine == "numexpr" and not _USE_NUMEXPR,
-                reason="numexpr enabled->{enabled}, "
-                "installed->{installed}".format(
-                    enabled=_USE_NUMEXPR, installed=_NUMEXPR_INSTALLED
-                ),
+                reason=f"numexpr enabled->{_USE_NUMEXPR}, "
+                f"installed->{_NUMEXPR_INSTALLED}",
             ),
         )
         for engine in _engines
@@ -192,22 +187,20 @@ def test_complex_cmp_ops(self, cmp1, cmp2):
             rhs_new = _eval_single_bin(lhs, cmp2, rhs, self.engine)
             expected = _eval_single_bin(lhs_new, binop, rhs_new, self.engine)
 
-            ex = "(lhs {cmp1} rhs) {binop} (lhs {cmp2} rhs)".format(
-                cmp1=cmp1, binop=binop, cmp2=cmp2
-            )
+            ex = f"(lhs {cmp1} rhs) {binop} (lhs {cmp2} rhs)"
             result = pd.eval(ex, engine=self.engine, parser=self.parser)
             self.check_equal(result, expected)
 
     def test_simple_cmp_ops(self):
         bool_lhses = (
-            DataFrame(randbool(size=(10, 5))),
-            Series(randbool((5,))),
-            randbool(),
+            DataFrame(tm.randbool(size=(10, 5))),
+            Series(tm.randbool((5,))),
+            tm.randbool(),
         )
         bool_rhses = (
-            DataFrame(randbool(size=(10, 5))),
-            Series(randbool((5,))),
-            randbool(),
+            DataFrame(tm.randbool(size=(10, 5))),
+            Series(tm.randbool((5,))),
+            tm.randbool(),
         )
         for lhs, rhs, cmp_op in product(bool_lhses, bool_rhses, self.cmp_ops):
             self.check_simple_cmp_op(lhs, cmp_op, rhs)
@@ -268,9 +261,9 @@ def check_operands(left, right, cmp_op):
         rhs_new = check_operands(mid, rhs, cmp2)
 
         if lhs_new is not None and rhs_new is not None:
-            ex1 = "lhs {0} mid {1} rhs".format(cmp1, cmp2)
-            ex2 = "lhs {0} mid and mid {1} rhs".format(cmp1, cmp2)
-            ex3 = "(lhs {0} mid) & (mid {1} rhs)".format(cmp1, cmp2)
+            ex1 = f"lhs {cmp1} mid {cmp2} rhs"
+            ex2 = f"lhs {cmp1} mid and mid {cmp2} rhs"
+            ex3 = f"(lhs {cmp1} mid) & (mid {cmp2} rhs)"
             expected = _eval_single_bin(lhs_new, "&", rhs_new, self.engine)
 
             for ex in (ex1, ex2, ex3):
@@ -279,11 +272,11 @@ def check_operands(left, right, cmp_op):
                 tm.assert_almost_equal(result, expected)
 
     def check_simple_cmp_op(self, lhs, cmp1, rhs):
-        ex = "lhs {0} rhs".format(cmp1)
+        ex = f"lhs {cmp1} rhs"
         msg = (
-            r"only list-like( or dict-like)? objects are allowed to be"
-            r" passed to (DataFrame\.)?isin\(\), you passed a"
-            r" (\[|')bool(\]|')|"
+            r"only list-like( or dict-like)? objects are allowed to be "
+            r"passed to (DataFrame\.)?isin\(\), you passed a "
+            r"(\[|')bool(\]|')|"
             "argument of type 'bool' is not iterable"
         )
         if cmp1 in ("in", "not in") and not is_list_like(rhs):
@@ -300,12 +293,12 @@ def check_simple_cmp_op(self, lhs, cmp1, rhs):
             self.check_equal(result, expected)
 
     def check_binary_arith_op(self, lhs, arith1, rhs):
-        ex = "lhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs"
         result = pd.eval(ex, engine=self.engine, parser=self.parser)
         expected = _eval_single_bin(lhs, arith1, rhs, self.engine)
 
         tm.assert_almost_equal(result, expected)
-        ex = "lhs {0} rhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs {arith1} rhs"
         result = pd.eval(ex, engine=self.engine, parser=self.parser)
         nlhs = _eval_single_bin(lhs, arith1, rhs, self.engine)
         self.check_alignment(result, nlhs, rhs, arith1)
@@ -320,25 +313,25 @@ def check_alignment(self, result, nlhs, ghs, op):
         else:
 
             # direct numpy comparison
-            expected = self.ne.evaluate("nlhs {0} ghs".format(op))
+            expected = self.ne.evaluate(f"nlhs {op} ghs")
             tm.assert_numpy_array_equal(result.values, expected)
 
     # modulus, pow, and floor division require special casing
 
     def check_modulus(self, lhs, arith1, rhs):
-        ex = "lhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs"
         result = pd.eval(ex, engine=self.engine, parser=self.parser)
         expected = lhs % rhs
 
         tm.assert_almost_equal(result, expected)
-        expected = self.ne.evaluate("expected {0} rhs".format(arith1))
+        expected = self.ne.evaluate(f"expected {arith1} rhs")
         if isinstance(result, (DataFrame, Series)):
             tm.assert_almost_equal(result.values, expected)
         else:
             tm.assert_almost_equal(result, expected.item())
 
     def check_floor_division(self, lhs, arith1, rhs):
-        ex = "lhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs"
 
         if self.engine == "python":
             res = pd.eval(ex, engine=self.engine, parser=self.parser)
@@ -346,8 +339,8 @@ def check_floor_division(self, lhs, arith1, rhs):
             self.check_equal(res, expected)
         else:
             msg = (
-                r"unsupported operand type\(s\) for //: 'VariableNode' and"
-                " 'VariableNode'"
+                r"unsupported operand type\(s\) for //: 'VariableNode' and "
+                "'VariableNode'"
             )
             with pytest.raises(TypeError, match=msg):
                 pd.eval(
@@ -373,7 +366,7 @@ def get_expected_pow_result(self, lhs, rhs):
         return expected
 
     def check_pow(self, lhs, arith1, rhs):
-        ex = "lhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs"
         expected = self.get_expected_pow_result(lhs, rhs)
         result = pd.eval(ex, engine=self.engine, parser=self.parser)
 
@@ -387,7 +380,7 @@ def check_pow(self, lhs, arith1, rhs):
         else:
             tm.assert_almost_equal(result, expected)
 
-            ex = "(lhs {0} rhs) {0} rhs".format(arith1)
+            ex = f"(lhs {arith1} rhs) {arith1} rhs"
             result = pd.eval(ex, engine=self.engine, parser=self.parser)
             expected = self.get_expected_pow_result(
                 self.get_expected_pow_result(lhs, rhs), rhs
@@ -412,12 +405,12 @@ def check_single_invert_op(self, lhs, cmp1, rhs):
 
     def check_compound_invert_op(self, lhs, cmp1, rhs):
         skip_these = ["in", "not in"]
-        ex = "~(lhs {0} rhs)".format(cmp1)
+        ex = f"~(lhs {cmp1} rhs)"
 
         msg = (
-            r"only list-like( or dict-like)? objects are allowed to be"
-            r" passed to (DataFrame\.)?isin\(\), you passed a"
-            r" (\[|')float(\]|')|"
+            r"only list-like( or dict-like)? objects are allowed to be "
+            r"passed to (DataFrame\.)?isin\(\), you passed a "
+            r"(\[|')float(\]|')|"
             "argument of type 'float' is not iterable"
         )
         if is_scalar(rhs) and cmp1 in skip_these:
@@ -446,7 +439,7 @@ def check_compound_invert_op(self, lhs, cmp1, rhs):
                 tm.assert_almost_equal(ev, result)
 
     def ex(self, op, var_name="lhs"):
-        return "{0}{1}".format(op, var_name)
+        return f"{op}{var_name}"
 
     def test_frame_invert(self):
         expr = self.ex("~")
@@ -470,13 +463,13 @@ def test_frame_invert(self):
         else:
             expect = ~lhs
             result = pd.eval(expr, engine=self.engine, parser=self.parser)
-            assert_frame_equal(expect, result)
+            tm.assert_frame_equal(expect, result)
 
         # bool always works
         lhs = DataFrame(rand(5, 2) > 0.5)
         expect = ~lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
+        tm.assert_frame_equal(expect, result)
 
         # object raises
         lhs = DataFrame({"b": ["a", 1, 2.0], "c": rand(3) > 0.5})
@@ -509,13 +502,13 @@ def test_series_invert(self):
         else:
             expect = ~lhs
             result = pd.eval(expr, engine=self.engine, parser=self.parser)
-            assert_series_equal(expect, result)
+            tm.assert_series_equal(expect, result)
 
         # bool
         lhs = Series(rand(5) > 0.5)
         expect = ~lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
+        tm.assert_series_equal(expect, result)
 
         # float
         # int
@@ -537,13 +530,13 @@ def test_frame_negate(self):
         lhs = DataFrame(randn(5, 2))
         expect = -lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
+        tm.assert_frame_equal(expect, result)
 
         # int
         lhs = DataFrame(randint(5, size=(5, 2)))
         expect = -lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
+        tm.assert_frame_equal(expect, result)
 
         # bool doesn't work with numexpr but works elsewhere
         lhs = DataFrame(rand(5, 2) > 0.5)
@@ -553,7 +546,7 @@ def test_frame_negate(self):
         else:
             expect = -lhs
             result = pd.eval(expr, engine=self.engine, parser=self.parser)
-            assert_frame_equal(expect, result)
+            tm.assert_frame_equal(expect, result)
 
     def test_series_negate(self):
         expr = self.ex("-")
@@ -562,13 +555,13 @@ def test_series_negate(self):
         lhs = Series(randn(5))
         expect = -lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
+        tm.assert_series_equal(expect, result)
 
         # int
         lhs = Series(randint(5, size=5))
         expect = -lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
+        tm.assert_series_equal(expect, result)
 
         # bool doesn't work with numexpr but works elsewhere
         lhs = Series(rand(5) > 0.5)
@@ -578,49 +571,43 @@ def test_series_negate(self):
         else:
             expect = -lhs
             result = pd.eval(expr, engine=self.engine, parser=self.parser)
-            assert_series_equal(expect, result)
+            tm.assert_series_equal(expect, result)
 
-    def test_frame_pos(self):
+    @pytest.mark.parametrize(
+        "lhs",
+        [
+            # Float
+            DataFrame(randn(5, 2)),
+            # Int
+            DataFrame(randint(5, size=(5, 2))),
+            # bool doesn't work with numexpr but works elsewhere
+            DataFrame(rand(5, 2) > 0.5),
+        ],
+    )
+    def test_frame_pos(self, lhs):
         expr = self.ex("+")
-
-        # float
-        lhs = DataFrame(randn(5, 2))
         expect = lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
 
-        # int
-        lhs = DataFrame(randint(5, size=(5, 2)))
-        expect = lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
+        tm.assert_frame_equal(expect, result)
 
-        # bool doesn't work with numexpr but works elsewhere
-        lhs = DataFrame(rand(5, 2) > 0.5)
-        expect = lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_frame_equal(expect, result)
-
-    def test_series_pos(self):
+    @pytest.mark.parametrize(
+        "lhs",
+        [
+            # Float
+            Series(randn(5)),
+            # Int
+            Series(randint(5, size=5)),
+            # bool doesn't work with numexpr but works elsewhere
+            Series(rand(5) > 0.5),
+        ],
+    )
+    def test_series_pos(self, lhs):
         expr = self.ex("+")
-
-        # float
-        lhs = Series(randn(5))
-        expect = lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
-
-        # int
-        lhs = Series(randint(5, size=5))
         expect = lhs
-        result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
 
-        # bool doesn't work with numexpr but works elsewhere
-        lhs = Series(rand(5) > 0.5)
-        expect = lhs
         result = pd.eval(expr, engine=self.engine, parser=self.parser)
-        assert_series_equal(expect, result)
+        tm.assert_series_equal(expect, result)
 
     def test_scalar_unary(self):
         with pytest.raises(TypeError):
@@ -640,7 +627,7 @@ def test_scalar_unary(self):
 
     def test_unary_in_array(self):
         # GH 11235
-        assert_numpy_array_equal(
+        tm.assert_numpy_array_equal(
             pd.eval(
                 "[-True, True, ~True, +True,"
                 "-False, False, ~False, +False,"
@@ -736,16 +723,16 @@ def test_float_truncation(self):
 
         df = pd.DataFrame({"A": [1000000000.0009, 1000000000.0011, 1000000000.0015]})
         cutoff = 1000000000.0006
-        result = df.query("A < {cutoff:.4f}".format(cutoff=cutoff))
+        result = df.query(f"A < {cutoff:.4f}")
         assert result.empty
 
         cutoff = 1000000000.0010
-        result = df.query("A > {cutoff:.4f}".format(cutoff=cutoff))
+        result = df.query(f"A > {cutoff:.4f}")
         expected = df.loc[[1, 2], :]
         tm.assert_frame_equal(expected, result)
 
         exact = 1000000000.0011
-        result = df.query("A == {exact:.4f}".format(exact=exact))
+        result = df.query(f"A == {exact:.4f}")
         expected = df.loc[[1], :]
         tm.assert_frame_equal(expected, result)
 
@@ -784,7 +771,7 @@ def setup_ops(self):
         self.unary_ops = "+", "-", "~"
 
     def check_chained_cmp_op(self, lhs, cmp1, mid, cmp2, rhs):
-        ex1 = "lhs {0} mid {1} rhs".format(cmp1, cmp2)
+        ex1 = f"lhs {cmp1} mid {cmp2} rhs"
         with pytest.raises(NotImplementedError):
             pd.eval(ex1, engine=self.engine, parser=self.parser)
 
@@ -797,7 +784,7 @@ def setup_class(cls):
         cls.parser = "python"
 
     def check_modulus(self, lhs, arith1, rhs):
-        ex = "lhs {0} rhs".format(arith1)
+        ex = f"lhs {arith1} rhs"
         result = pd.eval(ex, engine=self.engine, parser=self.parser)
 
         expected = lhs % rhs
@@ -814,7 +801,7 @@ def check_alignment(self, result, nlhs, ghs, op):
             # TypeError, AttributeError: series or frame with scalar align
             pass
         else:
-            expected = eval("nlhs {0} ghs".format(op))
+            expected = eval(f"nlhs {op} ghs")
             tm.assert_almost_equal(result, expected)
 
 
@@ -842,18 +829,18 @@ class TestTypeCasting:
     # chain(*(np.sctypes[x] for x in ['uint', 'int', 'float']))
     @pytest.mark.parametrize("dt", [np.float32, np.float64])
     def test_binop_typecasting(self, engine, parser, op, dt):
-        df = mkdf(5, 3, data_gen_f=f, dtype=dt)
-        s = "df {} 3".format(op)
+        df = tm.makeCustomDataframe(5, 3, data_gen_f=f, dtype=dt)
+        s = f"df {op} 3"
         res = pd.eval(s, engine=engine, parser=parser)
         assert df.values.dtype == dt
         assert res.values.dtype == dt
-        assert_frame_equal(res, eval(s))
+        tm.assert_frame_equal(res, eval(s))
 
-        s = "3 {} df".format(op)
+        s = f"3 {op} df"
         res = pd.eval(s, engine=engine, parser=parser)
         assert df.values.dtype == dt
         assert res.values.dtype == dt
-        assert_frame_equal(res, eval(s))
+        tm.assert_frame_equal(res, eval(s))
 
 
 # -------------------------------------
@@ -877,19 +864,19 @@ class TestAlignment:
 
     def test_align_nested_unary_op(self, engine, parser):
         s = "df * ~2"
-        df = mkdf(5, 3, data_gen_f=f)
+        df = tm.makeCustomDataframe(5, 3, data_gen_f=f)
         res = pd.eval(s, engine=engine, parser=parser)
-        assert_frame_equal(res, df * ~2)
+        tm.assert_frame_equal(res, df * ~2)
 
     def test_basic_frame_alignment(self, engine, parser):
         args = product(self.lhs_index_types, self.index_types, self.index_types)
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("always", RuntimeWarning)
             for lr_idx_type, rr_idx_type, c_idx_type in args:
-                df = mkdf(
+                df = tm.makeCustomDataframe(
                     10, 10, data_gen_f=f, r_idx_type=lr_idx_type, c_idx_type=c_idx_type
                 )
-                df2 = mkdf(
+                df2 = tm.makeCustomDataframe(
                     20, 10, data_gen_f=f, r_idx_type=rr_idx_type, c_idx_type=c_idx_type
                 )
                 # only warns if not monotonic and not sortable
@@ -898,20 +885,20 @@ def test_basic_frame_alignment(self, engine, parser):
                         res = pd.eval("df + df2", engine=engine, parser=parser)
                 else:
                     res = pd.eval("df + df2", engine=engine, parser=parser)
-                assert_frame_equal(res, df + df2)
+                tm.assert_frame_equal(res, df + df2)
 
     def test_frame_comparison(self, engine, parser):
         args = product(self.lhs_index_types, repeat=2)
         for r_idx_type, c_idx_type in args:
-            df = mkdf(
+            df = tm.makeCustomDataframe(
                 10, 10, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type
             )
             res = pd.eval("df < 2", engine=engine, parser=parser)
-            assert_frame_equal(res, df < 2)
+            tm.assert_frame_equal(res, df < 2)
 
             df3 = DataFrame(randn(*df.shape), index=df.index, columns=df.columns)
             res = pd.eval("df < df3", engine=engine, parser=parser)
-            assert_frame_equal(res, df < df3)
+            tm.assert_frame_equal(res, df < df3)
 
     @pytest.mark.slow
     def test_medium_complex_frame_alignment(self, engine, parser):
@@ -923,19 +910,25 @@ def test_medium_complex_frame_alignment(self, engine, parser):
             warnings.simplefilter("always", RuntimeWarning)
 
             for r1, c1, r2, c2 in args:
-                df = mkdf(3, 2, data_gen_f=f, r_idx_type=r1, c_idx_type=c1)
-                df2 = mkdf(4, 2, data_gen_f=f, r_idx_type=r2, c_idx_type=c2)
-                df3 = mkdf(5, 2, data_gen_f=f, r_idx_type=r2, c_idx_type=c2)
+                df = tm.makeCustomDataframe(
+                    3, 2, data_gen_f=f, r_idx_type=r1, c_idx_type=c1
+                )
+                df2 = tm.makeCustomDataframe(
+                    4, 2, data_gen_f=f, r_idx_type=r2, c_idx_type=c2
+                )
+                df3 = tm.makeCustomDataframe(
+                    5, 2, data_gen_f=f, r_idx_type=r2, c_idx_type=c2
+                )
                 if should_warn(df.index, df2.index, df3.index):
                     with tm.assert_produces_warning(RuntimeWarning):
                         res = pd.eval("df + df2 + df3", engine=engine, parser=parser)
                 else:
                     res = pd.eval("df + df2 + df3", engine=engine, parser=parser)
-                assert_frame_equal(res, df + df2 + df3)
+                tm.assert_frame_equal(res, df + df2 + df3)
 
     def test_basic_frame_series_alignment(self, engine, parser):
         def testit(r_idx_type, c_idx_type, index_name):
-            df = mkdf(
+            df = tm.makeCustomDataframe(
                 10, 10, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type
             )
             index = getattr(df, index_name)
@@ -951,7 +944,7 @@ def testit(r_idx_type, c_idx_type, index_name):
                 expected = df.add(s) if engine == "numexpr" else df + s
             else:
                 expected = df + s
-            assert_frame_equal(res, expected)
+            tm.assert_frame_equal(res, expected)
 
         args = product(self.lhs_index_types, self.index_types, ("index", "columns"))
         with warnings.catch_warnings(record=True):
@@ -961,7 +954,9 @@ def testit(r_idx_type, c_idx_type, index_name):
 
     def test_basic_series_frame_alignment(self, engine, parser):
         def testit(r_idx_type, c_idx_type, index_name):
-            df = mkdf(10, 7, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type)
+            df = tm.makeCustomDataframe(
+                10, 7, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type
+            )
             index = getattr(df, index_name)
             s = Series(np.random.randn(5), index[:5])
             if should_warn(s.index, df.index):
@@ -974,7 +969,7 @@ def testit(r_idx_type, c_idx_type, index_name):
                 expected = df.add(s) if engine == "numexpr" else s + df
             else:
                 expected = s + df
-            assert_frame_equal(res, expected)
+            tm.assert_frame_equal(res, expected)
 
         # only test dt with dt, otherwise weird joins result
         args = product(["i", "u", "s"], ["i", "u", "s"], ("index", "columns"))
@@ -1002,14 +997,14 @@ def test_series_frame_commutativity(self, engine, parser):
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("always", RuntimeWarning)
             for r_idx_type, c_idx_type, op, index_name in args:
-                df = mkdf(
+                df = tm.makeCustomDataframe(
                     10, 10, data_gen_f=f, r_idx_type=r_idx_type, c_idx_type=c_idx_type
                 )
                 index = getattr(df, index_name)
                 s = Series(np.random.randn(5), index[:5])
 
-                lhs = "s {0} df".format(op)
-                rhs = "df {0} s".format(op)
+                lhs = f"s {op} df"
+                rhs = f"df {op} s"
                 if should_warn(df.index, s.index):
                     with tm.assert_produces_warning(RuntimeWarning):
                         a = pd.eval(lhs, engine=engine, parser=parser)
@@ -1021,7 +1016,7 @@ def test_series_frame_commutativity(self, engine, parser):
 
                 if r_idx_type != "dt" and c_idx_type != "dt":
                     if engine == "numexpr":
-                        assert_frame_equal(a, b)
+                        tm.assert_frame_equal(a, b)
 
     @pytest.mark.slow
     def test_complex_series_frame_alignment(self, engine, parser):
@@ -1040,8 +1035,12 @@ def test_complex_series_frame_alignment(self, engine, parser):
                 index_name = random.choice(["index", "columns"])
                 obj_name = random.choice(["df", "df2"])
 
-                df = mkdf(m1, n, data_gen_f=f, r_idx_type=r1, c_idx_type=c1)
-                df2 = mkdf(m2, n, data_gen_f=f, r_idx_type=r2, c_idx_type=c2)
+                df = tm.makeCustomDataframe(
+                    m1, n, data_gen_f=f, r_idx_type=r1, c_idx_type=c1
+                )
+                df2 = tm.makeCustomDataframe(
+                    m2, n, data_gen_f=f, r_idx_type=r2, c_idx_type=c2
+                )
                 index = getattr(locals().get(obj_name), index_name)
                 s = Series(np.random.randn(n), index[:n])
 
@@ -1067,7 +1066,7 @@ def test_complex_series_frame_alignment(self, engine, parser):
                 else:
                     res = pd.eval("df2 + s + df", engine=engine, parser=parser)
                 assert res.shape == expected.shape
-                assert_frame_equal(res, expected)
+                tm.assert_frame_equal(res, expected)
 
     def test_performance_warning_for_poor_alignment(self, engine, parser):
         df = DataFrame(randn(1000, 10))
@@ -1077,16 +1076,16 @@ def test_performance_warning_for_poor_alignment(self, engine, parser):
         else:
             seen = False
 
-        with assert_produces_warning(seen):
+        with tm.assert_produces_warning(seen):
             pd.eval("df + s", engine=engine, parser=parser)
 
         s = Series(randn(1000))
-        with assert_produces_warning(False):
+        with tm.assert_produces_warning(False):
             pd.eval("df + s", engine=engine, parser=parser)
 
         df = DataFrame(randn(10, 10000))
         s = Series(randn(10000))
-        with assert_produces_warning(False):
+        with tm.assert_produces_warning(False):
             pd.eval("df + s", engine=engine, parser=parser)
 
         df = DataFrame(randn(10, 10))
@@ -1099,17 +1098,17 @@ def test_performance_warning_for_poor_alignment(self, engine, parser):
         else:
             wrn = False
 
-        with assert_produces_warning(wrn) as w:
+        with tm.assert_produces_warning(wrn) as w:
             pd.eval("df + s", engine=engine, parser=parser)
 
             if not is_python_engine:
                 assert len(w) == 1
                 msg = str(w[0].message)
+                loged = np.log10(s.size - df.shape[1])
                 expected = (
-                    "Alignment difference on axis {0} is larger"
-                    " than an order of magnitude on term {1!r}, "
-                    "by more than {2:.4g}; performance may suffer"
-                    "".format(1, "df", np.log10(s.size - df.shape[1]))
+                    f"Alignment difference on axis 1 is larger "
+                    f"than an order of magnitude on term 'df', "
+                    f"by more than {loged:.4g}; performance may suffer"
                 )
                 assert msg == expected
 
@@ -1140,9 +1139,9 @@ def test_simple_arith_ops(self):
         ops = self.arith_ops
 
         for op in filter(lambda x: x != "//", ops):
-            ex = "1 {0} 1".format(op)
-            ex2 = "x {0} 1".format(op)
-            ex3 = "1 {0} (x + 1)".format(op)
+            ex = f"1 {op} 1"
+            ex2 = f"x {op} 1"
+            ex3 = f"1 {op} (x + 1)"
 
             if op in ("in", "not in"):
                 msg = "argument of type 'int' is not iterable"
@@ -1167,7 +1166,7 @@ def test_simple_arith_ops(self):
 
     def test_simple_bool_ops(self):
         for op, lhs, rhs in product(expr._bool_ops_syms, (True, False), (True, False)):
-            ex = "{0} {1} {2}".format(lhs, op, rhs)
+            ex = f"{lhs} {op} {rhs}"
             res = self.eval(ex)
             exp = eval(ex)
             assert res == exp
@@ -1176,7 +1175,7 @@ def test_bool_ops_with_constants(self):
         for op, lhs, rhs in product(
             expr._bool_ops_syms, ("True", "False"), ("True", "False")
         ):
-            ex = "{0} {1} {2}".format(lhs, op, rhs)
+            ex = f"{lhs} {op} {rhs}"
             res = self.eval(ex)
             exp = eval(ex)
             assert res == exp
@@ -1194,32 +1193,40 @@ def test_constant(self):
     def test_single_variable(self):
         df = DataFrame(randn(10, 2))
         df2 = self.eval("df", local_dict={"df": df})
-        assert_frame_equal(df, df2)
+        tm.assert_frame_equal(df, df2)
 
     def test_truediv(self):
         s = np.array([1])
         ex = "s / 1"
         d = {"s": s}  # noqa
 
-        res = self.eval(ex, truediv=False)
+        # FutureWarning: The `truediv` parameter in pd.eval is deprecated and will be
+        # removed in a future version.
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval(ex, truediv=False)
         tm.assert_numpy_array_equal(res, np.array([1.0]))
 
-        res = self.eval(ex, truediv=True)
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval(ex, truediv=True)
         tm.assert_numpy_array_equal(res, np.array([1.0]))
 
-        res = self.eval("1 / 2", truediv=True)
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval("1 / 2", truediv=True)
         expec = 0.5
         assert res == expec
 
-        res = self.eval("1 / 2", truediv=False)
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval("1 / 2", truediv=False)
         expec = 0.5
         assert res == expec
 
-        res = self.eval("s / 2", truediv=False)
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval("s / 2", truediv=False)
         expec = 0.5
         assert res == expec
 
-        res = self.eval("s / 2", truediv=True)
+        with tm.assert_produces_warning(FutureWarning):
+            res = self.eval("s / 2", truediv=True)
         expec = 0.5
         assert res == expec
 
@@ -1232,7 +1239,7 @@ def test_lhs_expression_subscript(self):
         df = DataFrame(np.random.randn(5, 3))
         result = self.eval("(df + 1)[df > 2]", local_dict={"df": df})
         expected = (df + 1)[df > 2]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_attr_expression(self):
         df = DataFrame(np.random.randn(5, 3), columns=list("abc"))
@@ -1245,7 +1252,7 @@ def test_attr_expression(self):
         exprs = expr1, expr2, expr3
         expecs = expec1, expec2, expec3
         for e, expec in zip(exprs, expecs):
-            assert_series_equal(expec, self.eval(e, local_dict={"df": df}))
+            tm.assert_series_equal(expec, self.eval(e, local_dict={"df": df}))
 
     def test_assignment_fails(self):
         df = DataFrame(np.random.randn(5, 3), columns=list("abc"))
@@ -1279,14 +1286,14 @@ def test_assignment_column(self):
         expected["a"] = expected["a"] + expected["b"]
         df = orig_df.copy()
         df.eval("a = a + b", inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # single assignment - new variable
         expected = orig_df.copy()
         expected["c"] = expected["a"] + expected["b"]
         df = orig_df.copy()
         df.eval("c = a + b", inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # with a local name overlap
         def f():
@@ -1298,7 +1305,7 @@ def f():
         df = f()
         expected = orig_df.copy()
         expected["a"] = 1 + expected["b"]
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         df = orig_df.copy()
 
@@ -1307,7 +1314,7 @@ def f():
             old_a = df.a.copy()
             df.eval("a = a + b", inplace=True)
             result = old_a + df.b
-            assert_series_equal(result, df.a, check_names=False)
+            tm.assert_series_equal(result, df.a, check_names=False)
             assert result.name is None
 
         f()
@@ -1324,14 +1331,14 @@ def f():
         self.eval("c = df.a + df.b", local_dict={"df": df}, target=df, inplace=True)
         expected = orig_df.copy()
         expected["c"] = expected["a"] + expected["b"]
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_column_in(self):
         # GH 11235
         df = DataFrame({"a": [11], "b": [-32]})
         result = df.eval("a in [11, -32]")
         expected = Series([True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def assignment_not_inplace(self):
         # see gh-9297
@@ -1357,7 +1364,7 @@ def test_multi_line_expression(self):
         d = c + b""",
             inplace=True,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
         assert ans is None
 
         expected["a"] = expected["a"] - 1
@@ -1368,7 +1375,7 @@ def test_multi_line_expression(self):
         e = a + 2""",
             inplace=True,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
         assert ans is None
 
         # multi-line not valid if not all assignments
@@ -1393,7 +1400,7 @@ def test_multi_line_expression_not_inplace(self):
         d = c + b""",
             inplace=False,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
 
         expected["a"] = expected["a"] - 1
         expected["e"] = expected["a"] + 2
@@ -1403,7 +1410,7 @@ def test_multi_line_expression_not_inplace(self):
         e = a + 2""",
             inplace=False,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
 
     def test_multi_line_expression_local_variable(self):
         # GH 15342
@@ -1420,7 +1427,7 @@ def test_multi_line_expression_local_variable(self):
         """,
             inplace=True,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
         assert ans is None
 
     def test_multi_line_expression_callable_local_variable(self):
@@ -1440,7 +1447,7 @@ def local_func(a, b):
         """,
             inplace=True,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
         assert ans is None
 
     def test_multi_line_expression_callable_local_variable_with_kwargs(self):
@@ -1460,7 +1467,7 @@ def local_func(a, b):
         """,
             inplace=True,
         )
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
         assert ans is None
 
     def test_assignment_in_query(self):
@@ -1469,7 +1476,7 @@ def test_assignment_in_query(self):
         df_orig = df.copy()
         with pytest.raises(ValueError):
             df.query("a = 1")
-        assert_frame_equal(df, df_orig)
+        tm.assert_frame_equal(df, df_orig)
 
     def test_query_inplace(self):
         # see gh-11149
@@ -1477,7 +1484,7 @@ def test_query_inplace(self):
         expected = df.copy()
         expected = expected[expected["a"] == 2]
         df.query("a == 2", inplace=True)
-        assert_frame_equal(expected, df)
+        tm.assert_frame_equal(expected, df)
 
         df = {}
         expected = {"a": 3}
@@ -1517,26 +1524,26 @@ def test_inplace_no_assignment(self, target):
             self.eval(expression, target=target, inplace=True)
 
     def test_basic_period_index_boolean_expression(self):
-        df = mkdf(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
+        df = tm.makeCustomDataframe(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
 
         e = df < 2
         r = self.eval("df < 2", local_dict={"df": df})
         x = df < 2
 
-        assert_frame_equal(r, e)
-        assert_frame_equal(x, e)
+        tm.assert_frame_equal(r, e)
+        tm.assert_frame_equal(x, e)
 
     def test_basic_period_index_subscript_expression(self):
-        df = mkdf(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
+        df = tm.makeCustomDataframe(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
         r = self.eval("df[df < 2 + 3]", local_dict={"df": df})
         e = df[df < 2 + 3]
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
     def test_nested_period_index_subscript_expression(self):
-        df = mkdf(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
+        df = tm.makeCustomDataframe(2, 2, data_gen_f=f, c_idx_type="p", r_idx_type="i")
         r = self.eval("df[df[df < 2] < 2] + df * 2", local_dict={"df": df})
         e = df[df[df < 2] < 2] + df * 2
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
     def test_date_boolean(self):
         df = DataFrame(randn(5, 3))
@@ -1548,7 +1555,7 @@ def test_date_boolean(self):
             parser=self.parser,
         )
         expec = df.dates1 < "20130101"
-        assert_series_equal(res, expec, check_names=False)
+        tm.assert_series_equal(res, expec, check_names=False)
 
     def test_simple_in_ops(self):
         if self.parser != "python":
@@ -1670,7 +1677,7 @@ def test_bool_ops_with_constants(self):
         for op, lhs, rhs in product(
             expr._bool_ops_syms, ("True", "False"), ("True", "False")
         ):
-            ex = "{0} {1} {2}".format(lhs, op, rhs)
+            ex = f"{lhs} {op} {rhs}"
             if op in ("and", "or"):
                 with pytest.raises(NotImplementedError):
                     self.eval(ex)
@@ -1681,7 +1688,7 @@ def test_bool_ops_with_constants(self):
 
     def test_simple_bool_ops(self):
         for op, lhs, rhs in product(expr._bool_ops_syms, (True, False), (True, False)):
-            ex = "lhs {0} rhs".format(op)
+            ex = f"lhs {op} rhs"
             if op in ("and", "or"):
                 with pytest.raises(NotImplementedError):
                     pd.eval(ex, engine=self.engine, parser=self.parser)
@@ -1733,7 +1740,7 @@ def test_unary_functions(self, unary_fns_for_ne):
         a = df.a
 
         for fn in unary_fns_for_ne:
-            expr = "{0}(a)".format(fn)
+            expr = f"{fn}(a)"
             got = self.eval(expr)
             with np.errstate(all="ignore"):
                 expect = getattr(np, fn)(a)
@@ -1741,9 +1748,9 @@ def test_unary_functions(self, unary_fns_for_ne):
 
     def test_floor_and_ceil_functions_raise_error(self, ne_lt_2_6_9, unary_fns_for_ne):
         for fn in ("floor", "ceil"):
-            msg = '"{0}" is not a supported function'.format(fn)
+            msg = f'"{fn}" is not a supported function'
             with pytest.raises(ValueError, match=msg):
-                expr = "{0}(100)".format(fn)
+                expr = f"{fn}(100)"
                 self.eval(expr)
 
     def test_binary_functions(self):
@@ -1751,7 +1758,7 @@ def test_binary_functions(self):
         a = df.a
         b = df.b
         for fn in self.binary_fns:
-            expr = "{0}(a, b)".format(fn)
+            expr = f"{fn}(a, b)"
             got = self.eval(expr)
             with np.errstate(all="ignore"):
                 expect = getattr(np, fn)(a, b)
@@ -1880,9 +1887,9 @@ def test_invalid_parser():
         pd.eval("x + y", local_dict={"x": 1, "y": 2}, parser="asdf")
 
 
-_parsers = {
+_parsers: Dict[str, Type[BaseExprVisitor]] = {
     "python": PythonExprVisitor,
-    "pytables": pytables.ExprVisitor,
+    "pytables": pytables.PyTablesExprVisitor,
     "pandas": PandasExprVisitor,
 }
 
@@ -1962,9 +1969,9 @@ def test_bool_ops_fails_on_scalars(lhs, cmp, rhs, engine, parser):
     lhs = gen[lhs]()  # noqa
     rhs = gen[rhs]()  # noqa
 
-    ex1 = "lhs {0} mid {1} rhs".format(cmp, cmp)
-    ex2 = "lhs {0} mid and mid {1} rhs".format(cmp, cmp)
-    ex3 = "(lhs {0} mid) & (mid {1} rhs)".format(cmp, cmp)
+    ex1 = f"lhs {cmp} mid {cmp} rhs"
+    ex2 = f"lhs {cmp} mid and mid {cmp} rhs"
+    ex3 = f"(lhs {cmp} mid) & (mid {cmp} rhs)"
     for ex in (ex1, ex2, ex3):
         with pytest.raises(NotImplementedError):
             pd.eval(ex, engine=engine, parser=parser)
@@ -1981,7 +1988,7 @@ def test_bool_ops_fails_on_scalars(lhs, cmp, rhs, engine, parser):
 )
 def test_equals_various(other):
     df = DataFrame({"A": ["a", "b", "c"]})
-    result = df.eval("A == {}".format(other))
+    result = df.eval(f"A == {other}")
     expected = Series([False, False, False], name="A")
     if _USE_NUMEXPR:
         # https://github.com/pandas-dev/pandas/issues/10239
@@ -1997,6 +2004,23 @@ def test_inf(engine, parser):
     assert result == expected
 
 
+def test_truediv_deprecated(engine, parser):
+    # GH#29182
+    match = "The `truediv` parameter in pd.eval is deprecated"
+
+    with tm.assert_produces_warning(FutureWarning) as m:
+        pd.eval("1+1", engine=engine, parser=parser, truediv=True)
+
+    assert len(m) == 1
+    assert match in str(m[0].message)
+
+    with tm.assert_produces_warning(FutureWarning) as m:
+        pd.eval("1+1", engine=engine, parser=parser, truediv=False)
+
+    assert len(m) == 1
+    assert match in str(m[0].message)
+
+
 def test_negate_lt_eq_le(engine, parser):
     df = pd.DataFrame([[0, 10], [1, 20]], columns=["cat", "count"])
     expected = df[~(df.cat > 0)]
diff --git a/pandas/tests/config/test_config.py b/pandas/tests/config/test_config.py
index efaeb7b1471ec..51640641c78e6 100644
--- a/pandas/tests/config/test_config.py
+++ b/pandas/tests/config/test_config.py
@@ -218,6 +218,7 @@ def test_validation(self):
         self.cf.set_option("a", 2)  # int is_int
         self.cf.set_option("b.c", "wurld")  # str is_str
         self.cf.set_option("d", 2)
+        self.cf.set_option("d", None)  # non-negative int can be None
 
         # None not is_int
         with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/config/test_localization.py b/pandas/tests/config/test_localization.py
index 20a5be0c8a289..e815a90207a08 100644
--- a/pandas/tests/config/test_localization.py
+++ b/pandas/tests/config/test_localization.py
@@ -8,6 +8,8 @@
 
 from pandas.compat import is_platform_windows
 
+import pandas as pd
+
 _all_locales = get_locales() or []
 _current_locale = locale.getlocale()
 
@@ -56,21 +58,21 @@ def test_get_locales_prefix():
 
 
 @_skip_if_only_one_locale
-def test_set_locale():
+@pytest.mark.parametrize(
+    "lang,enc",
+    [
+        ("it_CH", "UTF-8"),
+        ("en_US", "ascii"),
+        ("zh_CN", "GB2312"),
+        ("it_IT", "ISO-8859-1"),
+    ],
+)
+def test_set_locale(lang, enc):
     if all(x is None for x in _current_locale):
         # Not sure why, but on some Travis runs with pytest,
         #  getlocale() returned (None, None).
         pytest.skip("Current locale is not set.")
 
-    locale_override = os.environ.get("LOCALE_OVERRIDE", None)
-
-    if locale_override is None:
-        lang, enc = "it_CH", "UTF-8"
-    elif locale_override == "C":
-        lang, enc = "en_US", "ascii"
-    else:
-        lang, enc = locale_override.split(".")
-
     enc = codecs.lookup(enc).name
     new_locale = lang, enc
 
@@ -91,3 +93,13 @@ def test_set_locale():
     # Once we exit the "with" statement, locale should be back to what it was.
     current_locale = locale.getlocale()
     assert current_locale == _current_locale
+
+
+def test_encoding_detected():
+    system_locale = os.environ.get("LC_ALL")
+    system_encoding = system_locale.split(".")[-1] if system_locale else "utf-8"
+
+    assert (
+        codecs.lookup(pd.options.display.encoding).name
+        == codecs.lookup(system_encoding).name
+    )
diff --git a/pandas/tests/dtypes/cast/test_construct_from_scalar.py b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
index 4ff3be5dfaa72..cc823a3d6e02c 100644
--- a/pandas/tests/dtypes/cast/test_construct_from_scalar.py
+++ b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
@@ -2,7 +2,7 @@
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
 from pandas import Categorical
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 def test_cast_1d_array_like_from_scalar_categorical():
diff --git a/pandas/tests/dtypes/cast/test_construct_ndarray.py b/pandas/tests/dtypes/cast/test_construct_ndarray.py
index da3789a87aa07..fe271392122a2 100644
--- a/pandas/tests/dtypes/cast/test_construct_ndarray.py
+++ b/pandas/tests/dtypes/cast/test_construct_ndarray.py
@@ -3,7 +3,7 @@
 
 from pandas.core.dtypes.cast import construct_1d_ndarray_preserving_na
 
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/dtypes/cast/test_downcast.py b/pandas/tests/dtypes/cast/test_downcast.py
index d574b03a8c724..d6e6ed3022b75 100644
--- a/pandas/tests/dtypes/cast/test_downcast.py
+++ b/pandas/tests/dtypes/cast/test_downcast.py
@@ -1,10 +1,12 @@
+import decimal
+
 import numpy as np
 import pytest
 
 from pandas.core.dtypes.cast import maybe_downcast_to_dtype
 
 from pandas import DatetimeIndex, Series, Timestamp
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -25,6 +27,13 @@
             "infer",
             np.array([8, 8, 8, 8, 9], dtype=np.int64),
         ),
+        (
+            # This is a judgement call, but we do _not_ downcast Decimal
+            #  objects
+            np.array([decimal.Decimal(0.0)]),
+            "int64",
+            np.array([decimal.Decimal(0.0)]),
+        ),
     ],
 )
 def test_downcast(arr, expected, dtype):
diff --git a/pandas/tests/dtypes/cast/test_infer_dtype.py b/pandas/tests/dtypes/cast/test_infer_dtype.py
index 602b2f26eaa4a..2744cfa8ddc62 100644
--- a/pandas/tests/dtypes/cast/test_infer_dtype.py
+++ b/pandas/tests/dtypes/cast/test_infer_dtype.py
@@ -10,8 +10,16 @@
 )
 from pandas.core.dtypes.common import is_dtype_equal
 
-from pandas import Categorical, Period, Series, Timedelta, Timestamp, date_range
-from pandas.util import testing as tm
+from pandas import (
+    Categorical,
+    Interval,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
 
 
 @pytest.fixture(params=[True, False])
@@ -73,7 +81,7 @@ def test_infer_dtype_from_period(freq, pandas_dtype):
     dtype, val = infer_dtype_from_scalar(p, pandas_dtype=pandas_dtype)
 
     if pandas_dtype:
-        exp_dtype = "period[{0}]".format(freq)
+        exp_dtype = f"period[{freq}]"
         exp_val = p.ordinal
     else:
         exp_dtype = np.object_
@@ -97,7 +105,7 @@ def test_infer_from_scalar_tz(tz, pandas_dtype):
     dtype, val = infer_dtype_from_scalar(dt, pandas_dtype=pandas_dtype)
 
     if pandas_dtype:
-        exp_dtype = "datetime64[ns, {0}]".format(tz)
+        exp_dtype = f"datetime64[ns, {tz}]"
         exp_val = dt.value
     else:
         exp_dtype = np.object_
@@ -107,6 +115,25 @@ def test_infer_from_scalar_tz(tz, pandas_dtype):
     assert val == exp_val
 
 
+@pytest.mark.parametrize(
+    "left, right, subtype",
+    [
+        (0, 1, "int64"),
+        (0.0, 1.0, "float64"),
+        (Timestamp(0), Timestamp(1), "datetime64[ns]"),
+        (Timestamp(0, tz="UTC"), Timestamp(1, tz="UTC"), "datetime64[ns, UTC]"),
+        (Timedelta(0), Timedelta(1), "timedelta64[ns]"),
+    ],
+)
+def test_infer_from_interval(left, right, subtype, closed, pandas_dtype):
+    # GH 30337
+    interval = Interval(left, right, closed)
+    result_dtype, result_value = infer_dtype_from_scalar(interval, pandas_dtype)
+    expected_dtype = f"interval[{subtype}]" if pandas_dtype else np.object_
+    assert result_dtype == expected_dtype
+    assert result_value == interval
+
+
 def test_infer_dtype_from_scalar_errors():
     msg = "invalid ndarray passed to infer_dtype_from_scalar"
 
diff --git a/pandas/tests/dtypes/cast/test_promote.py b/pandas/tests/dtypes/cast/test_promote.py
index 44aebd4d277f2..69f8f46356a4d 100644
--- a/pandas/tests/dtypes/cast/test_promote.py
+++ b/pandas/tests/dtypes/cast/test_promote.py
@@ -7,8 +7,7 @@
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs import NaT, iNaT
-from pandas.compat import is_platform_windows
+from pandas._libs.tslibs import NaT
 
 from pandas.core.dtypes.cast import maybe_promote
 from pandas.core.dtypes.common import (
@@ -19,10 +18,10 @@
     is_integer_dtype,
     is_object_dtype,
     is_scalar,
-    is_string_dtype,
     is_timedelta64_dtype,
 )
-from pandas.core.dtypes.dtypes import DatetimeTZDtype, PandasExtensionDtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import isna
 
 import pandas as pd
 
@@ -64,55 +63,7 @@ def any_numpy_dtype_reduced(request):
     return request.param
 
 
-@pytest.fixture(
-    params=[(True, None), (True, object), (False, None)],
-    ids=["True-None", "True-object", "False-None"],
-)
-def box(request):
-    """
-    Parametrized fixture determining whether/how to transform fill_value.
-
-    Since fill_value is defined on a per-test basis, the actual transformation
-    (based on this fixture) is executed in _check_promote.
-
-    Returns
-    -------
-    boxed : Boolean
-        Whether fill_value should be wrapped in an np.array.
-    box_dtype : dtype
-        The dtype to pass to np.array([fill_value], dtype=box_dtype). If None,
-        then this is passed on unmodified, and corresponds to the numpy default
-        dtype for the given fill_value.
-
-    * (True, None)    # fill_value wrapped in array with default dtype
-    * (True, object)  # fill_value wrapped in array with object dtype
-    * (False, None)   # fill_value passed on as scalar
-    """
-    return request.param
-
-
-def _safe_dtype_assert(left_dtype, right_dtype):
-    """
-    Compare two dtypes without raising TypeError.
-    """
-    if isinstance(right_dtype, PandasExtensionDtype):
-        # switch order of equality check because numpy dtypes (e.g. if
-        # left_dtype is np.object_) do not know some expected dtypes (e.g.
-        # DatetimeTZDtype) and would raise a TypeError in their __eq__-method.
-        assert right_dtype == left_dtype
-    else:
-        assert left_dtype == right_dtype
-
-
-def _check_promote(
-    dtype,
-    fill_value,
-    boxed,
-    box_dtype,
-    expected_dtype,
-    exp_val_for_scalar=None,
-    exp_val_for_array=None,
-):
+def _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar=None):
     """
     Auxiliary function to unify testing of scalar/array promotion.
 
@@ -121,13 +72,8 @@ def _check_promote(
     dtype : dtype
         The value to pass on as the first argument to maybe_promote.
     fill_value : scalar
-        The value to pass on as the second argument to maybe_promote, either as
-        a scalar, or boxed into an array (depending on the parameter `boxed`).
-    boxed : Boolean
-        Parameter whether fill_value should be passed to maybe_promote
-        directly, or wrapped in an array (of dtype box_dtype).
-    box_dtype : dtype
-        The dtype to enforce when wrapping fill_value into an np.array.
+        The value to pass on as the second argument to maybe_promote as
+        a scalar.
     expected_dtype : dtype
         The expected dtype returned by maybe_promote (by design this is the
         same regardless of whether fill_value was passed as a scalar or in an
@@ -135,60 +81,165 @@ def _check_promote(
     exp_val_for_scalar : scalar
         The expected value for the (potentially upcast) fill_value returned by
         maybe_promote.
-    exp_val_for_array : scalar
-        The expected missing value marker for the expected_dtype (which is
-        returned by maybe_promote when it receives an array).
     """
     assert is_scalar(fill_value)
 
-    if boxed:
-        # in this case, we pass on fill_value wrapped in an array of specified
-        # box_dtype; the expected value returned from maybe_promote is the
-        # missing value marker for the returned dtype.
-        fill_array = np.array([fill_value], dtype=box_dtype)
-        result_dtype, result_fill_value = maybe_promote(dtype, fill_array)
-        expected_fill_value = exp_val_for_array
+    # here, we pass on fill_value as a scalar directly; the expected value
+    # returned from maybe_promote is fill_value, potentially upcast to the
+    # returned dtype.
+    result_dtype, result_fill_value = maybe_promote(dtype, fill_value)
+    expected_fill_value = exp_val_for_scalar
+
+    assert result_dtype == expected_dtype
+    _assert_match(result_fill_value, expected_fill_value)
+
+
+def _assert_match(result_fill_value, expected_fill_value):
+    # GH#23982/25425 require the same type in addition to equality/NA-ness
+    res_type = type(result_fill_value)
+    ex_type = type(expected_fill_value)
+    if res_type.__name__ == "uint64":
+        # No idea why, but these (sometimes) do not compare as equal
+        assert ex_type.__name__ == "uint64"
+    elif res_type.__name__ == "ulonglong":
+        # On some builds we get this instead of np.uint64
+        # Note: cant check res_type.dtype.itemsize directly on numpy 1.18
+        assert res_type(0).itemsize == 8
+        assert ex_type == res_type or ex_type == np.uint64
     else:
-        # here, we pass on fill_value as a scalar directly; the expected value
-        # returned from maybe_promote is fill_value, potentially upcast to the
-        # returned dtype.
-        result_dtype, result_fill_value = maybe_promote(dtype, fill_value)
-        expected_fill_value = exp_val_for_scalar
-
-    _safe_dtype_assert(result_dtype, expected_dtype)
-
-    # for equal values, also check type (relevant e.g. for int vs float, resp.
-    # for different datetimes and timedeltas)
-    match_value = (
-        result_fill_value
-        == expected_fill_value
-        # disabled type check due to too many xfails; GH 23982/25425
-        # and type(result_fill_value) == type(expected_fill_value)
-    )
-
-    # for missing values, None == None and iNaT == iNaT (which is checked
+        # On some builds, type comparison fails, e.g. np.int32 != np.int32
+        assert res_type == ex_type or res_type.__name__ == ex_type.__name__
+
+    match_value = result_fill_value == expected_fill_value
+
+    # Note: type check above ensures that we have the _same_ NA value
+    # for missing values, None == None (which is checked
     # through match_value above), but np.nan != np.nan and pd.NaT != pd.NaT
-    match_missing = (result_fill_value is np.nan and expected_fill_value is np.nan) or (
-        result_fill_value is NaT and expected_fill_value is NaT
-    )
+    match_missing = isna(result_fill_value) and isna(expected_fill_value)
 
     assert match_value or match_missing
 
 
-def test_maybe_promote_int_with_int():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # size 8
+        ("int8", 1, "int8"),
+        ("int8", np.iinfo("int8").max + 1, "int16"),
+        ("int8", np.iinfo("int16").max + 1, "int32"),
+        ("int8", np.iinfo("int32").max + 1, "int64"),
+        ("int8", np.iinfo("int64").max + 1, "object"),
+        ("int8", -1, "int8"),
+        ("int8", np.iinfo("int8").min - 1, "int16"),
+        ("int8", np.iinfo("int16").min - 1, "int32"),
+        ("int8", np.iinfo("int32").min - 1, "int64"),
+        ("int8", np.iinfo("int64").min - 1, "object"),
+        # keep signed-ness as long as possible
+        ("uint8", 1, "uint8"),
+        ("uint8", np.iinfo("int8").max + 1, "uint8"),
+        ("uint8", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint8", np.iinfo("int16").max + 1, "uint16"),
+        ("uint8", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint8", np.iinfo("int32").max + 1, "uint32"),
+        ("uint8", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint8", np.iinfo("int64").max + 1, "uint64"),
+        ("uint8", np.iinfo("uint64").max + 1, "object"),
+        # max of uint8 cannot be contained in int8
+        ("uint8", -1, "int16"),
+        ("uint8", np.iinfo("int8").min - 1, "int16"),
+        ("uint8", np.iinfo("int16").min - 1, "int32"),
+        ("uint8", np.iinfo("int32").min - 1, "int64"),
+        ("uint8", np.iinfo("int64").min - 1, "object"),
+        # size 16
+        ("int16", 1, "int16"),
+        ("int16", np.iinfo("int8").max + 1, "int16"),
+        ("int16", np.iinfo("int16").max + 1, "int32"),
+        ("int16", np.iinfo("int32").max + 1, "int64"),
+        ("int16", np.iinfo("int64").max + 1, "object"),
+        ("int16", -1, "int16"),
+        ("int16", np.iinfo("int8").min - 1, "int16"),
+        ("int16", np.iinfo("int16").min - 1, "int32"),
+        ("int16", np.iinfo("int32").min - 1, "int64"),
+        ("int16", np.iinfo("int64").min - 1, "object"),
+        ("uint16", 1, "uint16"),
+        ("uint16", np.iinfo("int8").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint16", np.iinfo("int16").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint16", np.iinfo("int32").max + 1, "uint32"),
+        ("uint16", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint16", np.iinfo("int64").max + 1, "uint64"),
+        ("uint16", np.iinfo("uint64").max + 1, "object"),
+        ("uint16", -1, "int32"),
+        ("uint16", np.iinfo("int8").min - 1, "int32"),
+        ("uint16", np.iinfo("int16").min - 1, "int32"),
+        ("uint16", np.iinfo("int32").min - 1, "int64"),
+        ("uint16", np.iinfo("int64").min - 1, "object"),
+        # size 32
+        ("int32", 1, "int32"),
+        ("int32", np.iinfo("int8").max + 1, "int32"),
+        ("int32", np.iinfo("int16").max + 1, "int32"),
+        ("int32", np.iinfo("int32").max + 1, "int64"),
+        ("int32", np.iinfo("int64").max + 1, "object"),
+        ("int32", -1, "int32"),
+        ("int32", np.iinfo("int8").min - 1, "int32"),
+        ("int32", np.iinfo("int16").min - 1, "int32"),
+        ("int32", np.iinfo("int32").min - 1, "int64"),
+        ("int32", np.iinfo("int64").min - 1, "object"),
+        ("uint32", 1, "uint32"),
+        ("uint32", np.iinfo("int8").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint8").max + 1, "uint32"),
+        ("uint32", np.iinfo("int16").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint32", np.iinfo("int32").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint32", np.iinfo("int64").max + 1, "uint64"),
+        ("uint32", np.iinfo("uint64").max + 1, "object"),
+        ("uint32", -1, "int64"),
+        ("uint32", np.iinfo("int8").min - 1, "int64"),
+        ("uint32", np.iinfo("int16").min - 1, "int64"),
+        ("uint32", np.iinfo("int32").min - 1, "int64"),
+        ("uint32", np.iinfo("int64").min - 1, "object"),
+        # size 64
+        ("int64", 1, "int64"),
+        ("int64", np.iinfo("int8").max + 1, "int64"),
+        ("int64", np.iinfo("int16").max + 1, "int64"),
+        ("int64", np.iinfo("int32").max + 1, "int64"),
+        ("int64", np.iinfo("int64").max + 1, "object"),
+        ("int64", -1, "int64"),
+        ("int64", np.iinfo("int8").min - 1, "int64"),
+        ("int64", np.iinfo("int16").min - 1, "int64"),
+        ("int64", np.iinfo("int32").min - 1, "int64"),
+        ("int64", np.iinfo("int64").min - 1, "object"),
+        ("uint64", 1, "uint64"),
+        ("uint64", np.iinfo("int8").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint8").max + 1, "uint64"),
+        ("uint64", np.iinfo("int16").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint16").max + 1, "uint64"),
+        ("uint64", np.iinfo("int32").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint64", np.iinfo("int64").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint64").max + 1, "object"),
+        ("uint64", -1, "object"),
+        ("uint64", np.iinfo("int8").min - 1, "object"),
+        ("uint64", np.iinfo("int16").min - 1, "object"),
+        ("uint64", np.iinfo("int32").min - 1, "object"),
+        ("uint64", np.iinfo("int64").min - 1, "object"),
+    ],
+)
+def test_maybe_promote_int_with_int(dtype, fill_value, expected_dtype):
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
+
+    # output is not a generic int, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(True, None), (False, None)])
-def test_maybe_promote_int_with_float(any_int_dtype, float_dtype, box):
+def test_maybe_promote_int_with_float(any_int_dtype, float_dtype):
     dtype = np.dtype(any_int_dtype)
     fill_dtype = np.dtype(float_dtype)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if float_dtype == "float32" and not boxed:
-        pytest.xfail("falsely upcasts to float64")
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -197,26 +248,14 @@ def test_maybe_promote_int_with_float(any_int_dtype, float_dtype, box):
     expected_dtype = np.float64
     # fill_value can be different float type
     exp_val_for_scalar = np.float64(fill_value)
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(True, None), (False, None)])
-def test_maybe_promote_float_with_int(float_dtype, any_int_dtype, box):
+def test_maybe_promote_float_with_int(float_dtype, any_int_dtype):
 
     dtype = np.dtype(float_dtype)
     fill_dtype = np.dtype(any_int_dtype)
-    boxed, box_dtype = box  # read from parametrized fixture
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -226,33 +265,49 @@ def test_maybe_promote_float_with_int(float_dtype, any_int_dtype, box):
     expected_dtype = dtype
     # output is not a generic float, but corresponds to expected_dtype
     exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # float filled with float
+        ("float32", 1, "float32"),
+        ("float32", np.finfo("float32").max * 1.1, "float64"),
+        ("float64", 1, "float64"),
+        ("float64", np.finfo("float32").max * 1.1, "float64"),
+        # complex filled with float
+        ("complex64", 1, "complex64"),
+        ("complex64", np.finfo("float32").max * 1.1, "complex128"),
+        ("complex128", 1, "complex128"),
+        ("complex128", np.finfo("float32").max * 1.1, "complex128"),
+        # float filled with complex
+        ("float32", 1 + 1j, "complex64"),
+        ("float32", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        ("float64", 1 + 1j, "complex128"),
+        ("float64", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        # complex filled with complex
+        ("complex64", 1 + 1j, "complex64"),
+        ("complex64", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        ("complex128", 1 + 1j, "complex128"),
+        ("complex128", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+    ],
+)
+def test_maybe_promote_float_with_float(dtype, fill_value, expected_dtype):
+
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
 
+    # output is not a generic float, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
 
-def test_maybe_promote_float_with_float():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_bool_with_any(any_numpy_dtype_reduced, box):
+def test_maybe_promote_bool_with_any(any_numpy_dtype_reduced):
     dtype = np.dtype(bool)
     fill_dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if boxed and fill_dtype == bool:
-        pytest.xfail("falsely upcasts to object")
-    if boxed and box_dtype is None and is_datetime_or_timedelta_dtype(fill_dtype):
-        pytest.xfail("wrongly casts fill_value")
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -260,74 +315,69 @@ def test_maybe_promote_bool_with_any(any_numpy_dtype_reduced, box):
     # filling bool with anything but bool casts to object
     expected_dtype = np.dtype(object) if fill_dtype != bool else fill_dtype
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan if fill_dtype != bool else None
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_any_with_bool(any_numpy_dtype_reduced, box):
+def test_maybe_promote_any_with_bool(any_numpy_dtype_reduced):
     dtype = np.dtype(any_numpy_dtype_reduced)
     fill_value = True
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if boxed and dtype == bool:
-        pytest.xfail("falsely upcasts to object")
-    if boxed and dtype not in (str, object) and box_dtype is None:
-        pytest.xfail("falsely upcasts to object")
-    if not boxed and is_datetime_or_timedelta_dtype(dtype):
-        pytest.xfail("raises error")
 
     # filling anything but bool with bool casts to object
     expected_dtype = np.dtype(object) if dtype != bool else dtype
     # output is not a generic bool, but corresponds to expected_dtype
     exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
-    exp_val_for_array = np.nan if dtype != bool else None
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_bytes_with_any():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+def test_maybe_promote_bytes_with_any(bytes_dtype, any_numpy_dtype_reduced):
+    dtype = np.dtype(bytes_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype_reduced)
 
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
 
-def test_maybe_promote_any_with_bytes():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    exp_val_for_scalar = fill_value
 
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
-def test_maybe_promote_datetime64_with_any():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+
+def test_maybe_promote_any_with_bytes(any_numpy_dtype_reduced, bytes_dtype):
+    dtype = np.dtype(any_numpy_dtype_reduced)
+
+    # create array of given dtype
+    fill_value = b"abc"
+
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    # output is not a generic bytes, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_datetime64_with_any(datetime64_dtype, any_numpy_dtype_reduced):
+    dtype = np.dtype(datetime64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype_reduced)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling datetime with anything but datetime casts to object
+    if is_datetime64_dtype(fill_dtype):
+        expected_dtype = dtype
+        # for datetime dtypes, scalar values get cast to to_datetime64
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-# override parametrization of box to add special case for dt_dtype
-@pytest.mark.parametrize(
-    "box",
-    [
-        (True, None),  # fill_value wrapped in array with default dtype
-        # disabled due to too many xfails; see GH 23982 / 25425
-        # (True, 'dt_dtype'),  # fill_value in array with explicit datetime dtype
-        # (True, object),      # fill_value wrapped in array with object dtype
-        (False, None),  # fill_value passed on as scalar
-    ],
-)
 @pytest.mark.parametrize(
     "fill_value",
     [
@@ -339,62 +389,27 @@ def test_maybe_promote_datetime64_with_any():
     ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
 )
 def test_maybe_promote_any_with_datetime64(
-    any_numpy_dtype_reduced, datetime64_dtype, fill_value, box
+    any_numpy_dtype_reduced, datetime64_dtype, fill_value
 ):
     dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if is_datetime64_dtype(dtype):
-        if boxed and (
-            box_dtype == object
-            or (box_dtype is None and not is_datetime64_dtype(type(fill_value)))
-        ):
-            pytest.xfail("falsely upcasts to object")
-    else:
-        if boxed and (
-            box_dtype == "dt_dtype"
-            or (box_dtype is None and is_datetime64_dtype(type(fill_value)))
-        ):
-            pytest.xfail("mix of lack of upcasting, resp. wrong missing value")
-        if not boxed and is_timedelta64_dtype(dtype):
-            pytest.xfail("raises error")
-
-    # special case for box_dtype
-    box_dtype = np.dtype(datetime64_dtype) if box_dtype == "dt_dtype" else box_dtype
 
     # filling datetime with anything but datetime casts to object
     if is_datetime64_dtype(dtype):
         expected_dtype = dtype
         # for datetime dtypes, scalar values get cast to pd.Timestamp.value
-        exp_val_for_scalar = pd.Timestamp(fill_value).value
-        exp_val_for_array = iNaT
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
     else:
         expected_dtype = np.dtype(object)
         exp_val_for_scalar = fill_value
-        exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(True, object)])
 def test_maybe_promote_datetimetz_with_any_numpy_dtype(
-    tz_aware_fixture, any_numpy_dtype_reduced, box
+    tz_aware_fixture, any_numpy_dtype_reduced
 ):
     dtype = DatetimeTZDtype(tz=tz_aware_fixture)
     fill_dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if box_dtype != object:
-        pytest.xfail("does not upcast correctly")
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -402,36 +417,13 @@ def test_maybe_promote_datetimetz_with_any_numpy_dtype(
     # filling datetimetz with any numpy dtype casts to object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
-
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
-
-
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(True, None), (True, object)])
-def test_maybe_promote_datetimetz_with_datetimetz(
-    tz_aware_fixture, tz_aware_fixture2, box
-):
-    dtype = DatetimeTZDtype(tz=tz_aware_fixture)
-    fill_dtype = DatetimeTZDtype(tz=tz_aware_fixture2)
-    boxed, box_dtype = box  # read from parametrized fixture
 
-    from dateutil.tz import tzlocal
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
-    if is_platform_windows() and tz_aware_fixture2 == tzlocal():
-        pytest.xfail("Cannot process fill_value with this dtype, see GH 24310")
-    if dtype.tz == fill_dtype.tz and boxed:
-        pytest.xfail("falsely upcasts")
-    if dtype.tz != fill_dtype.tz and not boxed:
-        pytest.xfail("falsely upcasts")
+
+def test_maybe_promote_datetimetz_with_datetimetz(tz_aware_fixture, tz_aware_fixture2):
+    dtype = DatetimeTZDtype(tz=tz_aware_fixture)
+    fill_dtype = DatetimeTZDtype(tz=tz_aware_fixture2)
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = pd.Series([10 ** 9], dtype=fill_dtype)[0]
@@ -440,56 +432,21 @@ def test_maybe_promote_datetimetz_with_datetimetz(
     exp_val_for_scalar = fill_value
     if dtype.tz == fill_dtype.tz:
         expected_dtype = dtype
-        exp_val_for_array = NaT
     else:
         expected_dtype = np.dtype(object)
-        exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-@pytest.mark.parametrize(
-    "fill_value", [None, np.nan, NaT, iNaT], ids=["None", "np.nan", "pd.NaT", "iNaT"]
-)
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(False, None)])
-def test_maybe_promote_datetimetz_with_na(tz_aware_fixture, fill_value, box):
+@pytest.mark.parametrize("fill_value", [None, np.nan, NaT])
+def test_maybe_promote_datetimetz_with_na(tz_aware_fixture, fill_value):
 
     dtype = DatetimeTZDtype(tz=tz_aware_fixture)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if boxed and (
-        box_dtype == object
-        or (box_dtype is None and (fill_value is None or fill_value is NaT))
-    ):
-        pytest.xfail("false upcasts to object")
-    # takes the opinion that DatetimeTZ should have single na-marker
-    # using iNaT would lead to errors elsewhere -> NaT
-    if not boxed and fill_value == iNaT:
-        pytest.xfail("wrong missing value marker")
 
     expected_dtype = dtype
-    # DatetimeTZDtype does not use iNaT as missing value marker
     exp_val_for_scalar = NaT
-    exp_val_for_array = NaT
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
 @pytest.mark.parametrize(
@@ -503,36 +460,37 @@ def test_maybe_promote_datetimetz_with_na(tz_aware_fixture, fill_value, box):
     ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
 )
 def test_maybe_promote_any_numpy_dtype_with_datetimetz(
-    any_numpy_dtype_reduced, tz_aware_fixture, fill_value, box
+    any_numpy_dtype_reduced, tz_aware_fixture, fill_value
 ):
     dtype = np.dtype(any_numpy_dtype_reduced)
     fill_dtype = DatetimeTZDtype(tz=tz_aware_fixture)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if is_datetime_or_timedelta_dtype(dtype) and not boxed:
-        pytest.xfail("raises error")
 
     fill_value = pd.Series([fill_value], dtype=fill_dtype)[0]
 
     # filling any numpy dtype with datetimetz casts to object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
 
+def test_maybe_promote_timedelta64_with_any(timedelta64_dtype, any_numpy_dtype_reduced):
+    dtype = np.dtype(timedelta64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype_reduced)
 
-def test_maybe_promote_timedelta64_with_any():
-    # placeholder due to too many xfails; see GH 23982 / 25425
-    pass
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling timedelta with anything but timedelta casts to object
+    if is_timedelta64_dtype(fill_dtype):
+        expected_dtype = dtype
+        # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
 @pytest.mark.parametrize(
@@ -540,80 +498,26 @@ def test_maybe_promote_timedelta64_with_any():
     [pd.Timedelta(days=1), np.timedelta64(24, "h"), datetime.timedelta(1)],
     ids=["pd.Timedelta", "np.timedelta64", "datetime.timedelta"],
 )
-# override parametrization of box to add special case for td_dtype
-@pytest.mark.parametrize(
-    "box",
-    [
-        (True, None),  # fill_value wrapped in array with default dtype
-        # disabled due to too many xfails; see GH 23982 / 25425
-        # (True, 'td_dtype'),  # fill_value in array with explicit timedelta dtype
-        (True, object),  # fill_value wrapped in array with object dtype
-        (False, None),  # fill_value passed on as scalar
-    ],
-)
 def test_maybe_promote_any_with_timedelta64(
-    any_numpy_dtype_reduced, timedelta64_dtype, fill_value, box
+    any_numpy_dtype_reduced, timedelta64_dtype, fill_value
 ):
     dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if is_timedelta64_dtype(dtype):
-        if boxed and (
-            box_dtype == object
-            or (box_dtype is None and not is_timedelta64_dtype(type(fill_value)))
-        ):
-            pytest.xfail("falsely upcasts to object")
-    else:
-        if boxed and box_dtype is None and is_timedelta64_dtype(type(fill_value)):
-            pytest.xfail("does not upcast correctly")
-        if (
-            not boxed
-            and is_timedelta64_dtype(type(fill_value))
-            and (
-                is_integer_dtype(dtype)
-                or is_float_dtype(dtype)
-                or is_complex_dtype(dtype)
-                or issubclass(dtype.type, np.bytes_)
-            )
-        ):
-            pytest.xfail("does not upcast correctly")
-        if box_dtype == "td_dtype":
-            pytest.xfail("falsely upcasts")
-        if not boxed and is_datetime64_dtype(dtype):
-            pytest.xfail("raises error")
-
-    # special case for box_dtype
-    box_dtype = np.dtype(timedelta64_dtype) if box_dtype == "td_dtype" else box_dtype
 
     # filling anything but timedelta with timedelta casts to object
     if is_timedelta64_dtype(dtype):
         expected_dtype = dtype
         # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
-        exp_val_for_scalar = pd.Timedelta(fill_value).value
-        exp_val_for_array = iNaT
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
     else:
         expected_dtype = np.dtype(object)
         exp_val_for_scalar = fill_value
-        exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype_reduced, box):
+def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype_reduced):
     dtype = np.dtype(string_dtype)
     fill_dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if boxed and box_dtype is None and is_datetime_or_timedelta_dtype(fill_dtype):
-        pytest.xfail("wrong missing value marker")
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -621,78 +525,26 @@ def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype_reduced, bo
     # filling string with anything casts to object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-# override parametrization of box to add special case for str
-@pytest.mark.parametrize(
-    "box",
-    [
-        # disabled due to too many xfails; see GH 23982 / 25425
-        # (True, None),    # fill_value wrapped in array with default dtype
-        # (True, 'str'),   # fill_value wrapped in array with generic string-dtype
-        (True, object),  # fill_value wrapped in array with object dtype
-        (False, None),  # fill_value passed on as scalar
-    ],
-)
-def test_maybe_promote_any_with_string(any_numpy_dtype_reduced, string_dtype, box):
+def test_maybe_promote_any_with_string(any_numpy_dtype_reduced, string_dtype):
     dtype = np.dtype(any_numpy_dtype_reduced)
-    fill_dtype = np.dtype(string_dtype)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if is_datetime_or_timedelta_dtype(dtype) and box_dtype != object:
-        pytest.xfail("does not upcast or raises")
-    if (
-        boxed
-        and box_dtype in (None, "str")
-        and (
-            is_integer_dtype(dtype)
-            or is_float_dtype(dtype)
-            or is_complex_dtype(dtype)
-            or issubclass(dtype.type, np.bytes_)
-        )
-    ):
-        pytest.xfail("does not upcast correctly")
 
     # create array of given dtype
     fill_value = "abc"
 
-    # special case for box_dtype (cannot use fixture in parametrization)
-    box_dtype = fill_dtype if box_dtype == "str" else box_dtype
-
     # filling anything with a string casts to object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype_reduced, box):
+def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype_reduced):
     dtype = np.dtype(object_dtype)
     fill_dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if boxed and box_dtype is None and is_datetime_or_timedelta_dtype(fill_dtype):
-        pytest.xfail("wrong missing value marker")
 
     # create array of given dtype; casts "1" to correct dtype
     fill_value = np.array([1], dtype=fill_dtype)[0]
@@ -700,25 +552,12 @@ def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype_reduced, bo
     # filling object with anything stays object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-def test_maybe_promote_any_with_object(any_numpy_dtype_reduced, object_dtype, box):
+def test_maybe_promote_any_with_object(any_numpy_dtype_reduced, object_dtype):
     dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if not boxed and is_datetime_or_timedelta_dtype(dtype):
-        pytest.xfail("raises error")
 
     # create array of object dtype from a scalar value (i.e. passing
     # dtypes.common.is_scalar), which can however not be cast to int/float etc.
@@ -727,83 +566,27 @@ def test_maybe_promote_any_with_object(any_numpy_dtype_reduced, object_dtype, bo
     # filling object with anything stays object
     expected_dtype = np.dtype(object)
     exp_val_for_scalar = fill_value
-    exp_val_for_array = np.nan
 
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
-@pytest.mark.parametrize(
-    "fill_value", [None, np.nan, NaT, iNaT], ids=["None", "np.nan", "pd.NaT", "iNaT"]
-)
-# override parametrization due to to many xfails; see GH 23982 / 25425
-@pytest.mark.parametrize("box", [(False, None)])
-def test_maybe_promote_any_numpy_dtype_with_na(
-    any_numpy_dtype_reduced, fill_value, box
-):
+@pytest.mark.parametrize("fill_value", [None, np.nan, NaT])
+def test_maybe_promote_any_numpy_dtype_with_na(any_numpy_dtype_reduced, fill_value):
     dtype = np.dtype(any_numpy_dtype_reduced)
-    boxed, box_dtype = box  # read from parametrized fixture
-
-    if (
-        dtype == bytes
-        and not boxed
-        and fill_value is not None
-        and fill_value is not NaT
-    ):
-        pytest.xfail("does not upcast to object")
-    elif dtype == "uint64" and not boxed and fill_value == iNaT:
-        pytest.xfail("does not upcast correctly")
-    elif is_datetime_or_timedelta_dtype(dtype) and boxed:
-        pytest.xfail("falsely upcasts to object")
-    elif (
-        boxed
-        and (
-            is_integer_dtype(dtype) or is_float_dtype(dtype) or is_complex_dtype(dtype)
-        )
-        and fill_value is not NaT
-        and dtype != "uint64"
-    ):
-        pytest.xfail("falsely upcasts to object")
-    elif boxed and dtype == "uint64" and (fill_value is np.nan or fill_value is None):
-        pytest.xfail("falsely upcasts to object")
-    # below: opinionated that iNaT should be interpreted as missing value
-    elif (
-        not boxed
-        and (is_float_dtype(dtype) or is_complex_dtype(dtype))
-        and fill_value == iNaT
-    ):
-        pytest.xfail("does not cast to missing value marker correctly")
-    elif (is_string_dtype(dtype) or dtype == bool) and not boxed and fill_value == iNaT:
-        pytest.xfail("does not cast to missing value marker correctly")
-
-    if is_integer_dtype(dtype) and dtype == "uint64" and fill_value == iNaT:
-        # uint64 + negative int casts to object; iNaT is considered as missing
-        expected_dtype = np.dtype(object)
-        exp_val_for_scalar = np.nan
-    elif is_integer_dtype(dtype) and fill_value == iNaT:
-        # other integer + iNaT casts to int64
-        expected_dtype = np.int64
-        exp_val_for_scalar = iNaT
-    elif is_integer_dtype(dtype) and fill_value is not NaT:
+
+    if is_integer_dtype(dtype) and fill_value is not NaT:
         # integer + other missing value (np.nan / None) casts to float
         expected_dtype = np.float64
         exp_val_for_scalar = np.nan
-    elif is_object_dtype(dtype) and (fill_value == iNaT or fill_value is NaT):
+    elif is_object_dtype(dtype) and fill_value is NaT:
         # inserting into object does not cast the value
         # but *does* cast None to np.nan
         expected_dtype = np.dtype(object)
         exp_val_for_scalar = fill_value
     elif is_datetime_or_timedelta_dtype(dtype):
-        # datetime / timedelta cast all missing values to iNaT
+        # datetime / timedelta cast all missing values to dtyped-NaT
         expected_dtype = dtype
-        exp_val_for_scalar = iNaT
+        exp_val_for_scalar = dtype.type("NaT", "ns")
     elif fill_value is NaT:
         # NaT upcasts everything that's not datetime/timedelta to object
         expected_dtype = np.dtype(object)
@@ -817,24 +600,7 @@ def test_maybe_promote_any_numpy_dtype_with_na(
         expected_dtype = np.dtype(object)
         exp_val_for_scalar = np.nan
 
-    # array case has same expected_dtype; but returns corresponding na-marker
-    if is_integer_dtype(expected_dtype):
-        # integers cannot hold NaNs; maybe_promote_with_array returns None
-        exp_val_for_array = None
-    elif is_datetime_or_timedelta_dtype(expected_dtype):
-        exp_val_for_array = iNaT
-    else:  # expected_dtype = float / complex / object
-        exp_val_for_array = np.nan
-
-    _check_promote(
-        dtype,
-        fill_value,
-        boxed,
-        box_dtype,
-        expected_dtype,
-        exp_val_for_scalar,
-        exp_val_for_array,
-    )
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
 
 
 @pytest.mark.parametrize("dim", [0, 2, 3])
@@ -848,15 +614,18 @@ def test_maybe_promote_dimensions(any_numpy_dtype_reduced, dim):
     for _ in range(dim):
         fill_array = np.expand_dims(fill_array, 0)
 
-    # test against 1-dimensional case
-    expected_dtype, expected_missing_value = maybe_promote(
-        dtype, np.array([1], dtype=dtype)
-    )
+    if dtype != object:
+        # test against 1-dimensional case
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            maybe_promote(dtype, np.array([1], dtype=dtype))
 
-    result_dtype, result_missing_value = maybe_promote(dtype, fill_array)
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            maybe_promote(dtype, fill_array)
 
-    assert result_dtype == expected_dtype
-    # None == None, iNaT == iNaT, but np.nan != np.nan
-    assert (result_missing_value == expected_missing_value) or (
-        result_missing_value is np.nan and expected_missing_value is np.nan
-    )
+    else:
+        expected_dtype, expected_missing_value = maybe_promote(
+            dtype, np.array([1], dtype=dtype)
+        )
+        result_dtype, result_missing_value = maybe_promote(dtype, fill_array)
+        assert result_dtype == expected_dtype
+        _assert_match(result_missing_value, expected_missing_value)
diff --git a/pandas/tests/dtypes/cast/test_upcast.py b/pandas/tests/dtypes/cast/test_upcast.py
index f076bcd578001..bb7a7d059c7ee 100644
--- a/pandas/tests/dtypes/cast/test_upcast.py
+++ b/pandas/tests/dtypes/cast/test_upcast.py
@@ -4,12 +4,12 @@
 from pandas.core.dtypes.cast import maybe_upcast_putmask
 
 from pandas import Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("result", [Series([10, 11, 12]), [10, 11, 12], (10, 11, 12)])
 def test_upcast_error(result):
-    # GH23823
+    # GH23823 require result arg to be ndarray
     mask = np.array([False, True, False])
     other = np.array([61, 62, 63])
     with pytest.raises(ValueError):
@@ -17,76 +17,55 @@ def test_upcast_error(result):
 
 
 @pytest.mark.parametrize(
-    "arr, other, exp_changed, expected",
+    "arr, other",
     [
-        (np.arange(1, 6), np.array([61, 62, 63]), False, np.array([1, 61, 3, 62, 63])),
+        (np.arange(1, 6), np.array([61, 62, 63])),
+        (np.arange(1, 6), np.array([61.1, 62.2, 63.3])),
+        (np.arange(10, 15), np.array([61, 62])),
+        (np.arange(10, 15), np.array([61, np.nan])),
         (
-            np.arange(1, 6),
-            np.array([61.1, 62.2, 63.3]),
-            True,
-            np.array([1, 61.1, 3, 62.2, 63.3]),
+            np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]"),
+            np.arange("2018-01-01", "2018-01-04", dtype="datetime64[D]"),
         ),
-        (np.arange(1, 6), np.nan, True, np.array([1, np.nan, 3, np.nan, np.nan])),
-        (np.arange(10, 15), np.array([61, 62]), False, np.array([10, 61, 12, 62, 61])),
         (
-            np.arange(10, 15),
-            np.array([61, np.nan]),
-            True,
-            np.array([10, 61, 12, np.nan, 61]),
+            np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]"),
+            np.arange("2018-01-01", "2018-01-03", dtype="datetime64[D]"),
         ),
     ],
 )
-def test_upcast(arr, other, exp_changed, expected):
+def test_upcast_scalar_other(arr, other):
+    # for now we do not support non-scalar `other`
+    mask = np.array([False, True, False, True, True])
+    with pytest.raises(ValueError, match="other must be a scalar"):
+        maybe_upcast_putmask(arr, mask, other)
+
+
+def test_upcast():
     # GH23823
+    arr = np.arange(1, 6)
     mask = np.array([False, True, False, True, True])
-    result, changed = maybe_upcast_putmask(arr, mask, other)
+    result, changed = maybe_upcast_putmask(arr, mask, other=np.nan)
 
-    assert changed == exp_changed
+    expected = np.array([1, np.nan, 3, np.nan, np.nan])
+    assert changed
     tm.assert_numpy_array_equal(result, expected)
 
 
-@pytest.mark.parametrize(
-    "arr, other, exp_changed, expected",
-    [
-        (
-            np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]"),
-            np.arange("2018-01-01", "2018-01-04", dtype="datetime64[D]"),
-            False,
-            np.array(
-                ["2019-01-01", "2018-01-01", "2019-01-03", "2018-01-02", "2018-01-03"],
-                dtype="datetime64[D]",
-            ),
-        ),
-        (
-            np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]"),
-            np.nan,
-            False,
-            np.array(
-                [
-                    "2019-01-01",
-                    np.datetime64("NaT"),
-                    "2019-01-03",
-                    np.datetime64("NaT"),
-                    np.datetime64("NaT"),
-                ],
-                dtype="datetime64[D]",
-            ),
-        ),
-        (
-            np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]"),
-            np.arange("2018-01-01", "2018-01-03", dtype="datetime64[D]"),
-            False,
-            np.array(
-                ["2019-01-01", "2018-01-01", "2019-01-03", "2018-01-02", "2018-01-01"],
-                dtype="datetime64[D]",
-            ),
-        ),
-    ],
-)
-def test_upcast_datetime(arr, other, exp_changed, expected):
+def test_upcast_datetime():
     # GH23823
+    arr = np.arange("2019-01-01", "2019-01-06", dtype="datetime64[D]")
     mask = np.array([False, True, False, True, True])
-    result, changed = maybe_upcast_putmask(arr, mask, other)
+    result, changed = maybe_upcast_putmask(arr, mask, other=np.nan)
 
-    assert changed == exp_changed
+    expected = np.array(
+        [
+            "2019-01-01",
+            np.datetime64("NaT"),
+            "2019-01-03",
+            np.datetime64("NaT"),
+            np.datetime64("NaT"),
+        ],
+        dtype="datetime64[D]",
+    )
+    assert not changed
     tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index db9f647e0f0c7..4c917b9bb42d2 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -1,8 +1,12 @@
+from datetime import datetime
+from typing import List
+
 import numpy as np
 import pytest
 
 import pandas.util._test_decorators as td
 
+from pandas.core.dtypes.cast import astype_nansafe
 import pandas.core.dtypes.common as com
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
@@ -11,8 +15,11 @@
     IntervalDtype,
     PeriodDtype,
 )
+from pandas.core.dtypes.missing import isna
 
 import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import SparseArray
 from pandas.conftest import (
     ALL_EA_INT_DTYPES,
     ALL_INT_DTYPES,
@@ -21,10 +28,6 @@
     UNSIGNED_EA_INT_DTYPES,
     UNSIGNED_INT_DTYPES,
 )
-from pandas.core.sparse.api import SparseDtype
-import pandas.util.testing as tm
-
-ignore_sparse_warning = pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 
 
 # EA & Actual Dtypes
@@ -179,10 +182,8 @@ def test_is_object():
 @pytest.mark.parametrize(
     "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
 )
-@ignore_sparse_warning
 def test_is_sparse(check_scipy):
-    assert com.is_sparse(pd.SparseArray([1, 2, 3]))
-    assert com.is_sparse(pd.SparseSeries([1, 2, 3]))
+    assert com.is_sparse(SparseArray([1, 2, 3]))
 
     assert not com.is_sparse(np.array([1, 2, 3]))
 
@@ -193,14 +194,12 @@ def test_is_sparse(check_scipy):
 
 
 @td.skip_if_no_scipy
-@ignore_sparse_warning
 def test_is_scipy_sparse():
     from scipy.sparse import bsr_matrix
 
     assert com.is_scipy_sparse(bsr_matrix([1, 2, 3]))
 
-    assert not com.is_scipy_sparse(pd.SparseArray([1, 2, 3]))
-    assert not com.is_scipy_sparse(pd.SparseSeries([1, 2, 3]))
+    assert not com.is_scipy_sparse(SparseArray([1, 2, 3]))
 
 
 def test_is_categorical():
@@ -212,25 +211,6 @@ def test_is_categorical():
     assert not com.is_categorical([1, 2, 3])
 
 
-def test_is_datetimetz():
-    with tm.assert_produces_warning(FutureWarning):
-        assert not com.is_datetimetz([1, 2, 3])
-        assert not com.is_datetimetz(pd.DatetimeIndex([1, 2, 3]))
-
-        assert com.is_datetimetz(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern"))
-
-        dtype = DatetimeTZDtype("ns", tz="US/Eastern")
-        s = pd.Series([], dtype=dtype)
-        assert com.is_datetimetz(s)
-
-
-def test_is_period_deprecated():
-    with tm.assert_produces_warning(FutureWarning):
-        assert not com.is_period([1, 2, 3])
-        assert not com.is_period(pd.Index([1, 2, 3]))
-        assert com.is_period(pd.PeriodIndex(["2017-01-01"], freq="D"))
-
-
 def test_is_datetime64_dtype():
     assert not com.is_datetime64_dtype(object)
     assert not com.is_datetime64_dtype([1, 2, 3])
@@ -298,6 +278,8 @@ def test_is_string_dtype():
     assert com.is_string_dtype(str)
     assert com.is_string_dtype(object)
     assert com.is_string_dtype(np.array(["a", "b"]))
+    assert com.is_string_dtype(pd.StringDtype())
+    assert com.is_string_dtype(pd.array(["a", "b"], dtype="string"))
 
 
 def test_is_period_arraylike():
@@ -312,24 +294,13 @@ def test_is_datetime_arraylike():
     assert com.is_datetime_arraylike(pd.DatetimeIndex([1, 2, 3]))
 
 
-def test_is_datetimelike():
-    assert not com.is_datetimelike([1, 2, 3])
-    assert not com.is_datetimelike(pd.Index([1, 2, 3]))
-
-    assert com.is_datetimelike(pd.DatetimeIndex([1, 2, 3]))
-    assert com.is_datetimelike(pd.PeriodIndex([], freq="A"))
-    assert com.is_datetimelike(np.array([], dtype=np.datetime64))
-    assert com.is_datetimelike(pd.Series([], dtype="timedelta64[ns]"))
-    assert com.is_datetimelike(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
-
-    dtype = DatetimeTZDtype("ns", tz="US/Eastern")
-    s = pd.Series([], dtype=dtype)
-    assert com.is_datetimelike(s)
+integer_dtypes: List = []
 
 
 @pytest.mark.parametrize(
     "dtype",
-    [pd.Series([1, 2])]
+    integer_dtypes
+    + [pd.Series([1, 2])]
     + ALL_INT_DTYPES
     + to_numpy_dtypes(ALL_INT_DTYPES)
     + ALL_EA_INT_DTYPES
@@ -355,9 +326,13 @@ def test_is_not_integer_dtype(dtype):
     assert not com.is_integer_dtype(dtype)
 
 
+signed_integer_dtypes: List = []
+
+
 @pytest.mark.parametrize(
     "dtype",
-    [pd.Series([1, 2])]
+    signed_integer_dtypes
+    + [pd.Series([1, 2])]
     + SIGNED_INT_DTYPES
     + to_numpy_dtypes(SIGNED_INT_DTYPES)
     + SIGNED_EA_INT_DTYPES
@@ -387,9 +362,13 @@ def test_is_not_signed_integer_dtype(dtype):
     assert not com.is_signed_integer_dtype(dtype)
 
 
+unsigned_integer_dtypes: List = []
+
+
 @pytest.mark.parametrize(
     "dtype",
-    [pd.Series([1, 2], dtype=np.uint32)]
+    unsigned_integer_dtypes
+    + [pd.Series([1, 2], dtype=np.uint32)]
     + UNSIGNED_INT_DTYPES
     + to_numpy_dtypes(UNSIGNED_INT_DTYPES)
     + UNSIGNED_EA_INT_DTYPES
@@ -513,7 +492,7 @@ def test_is_numeric_v_string_like():
 
 
 def test_is_datetimelike_v_numeric():
-    dt = np.datetime64(pd.datetime(2017, 1, 1))
+    dt = np.datetime64(datetime(2017, 1, 1))
 
     assert not com.is_datetimelike_v_numeric(1, 1)
     assert not com.is_datetimelike_v_numeric(dt, dt)
@@ -582,11 +561,14 @@ def test_is_bool_dtype():
     assert com.is_bool_dtype(np.array([True, False]))
     assert com.is_bool_dtype(pd.Index([True, False]))
 
+    assert com.is_bool_dtype(pd.BooleanDtype())
+    assert com.is_bool_dtype(pd.array([True, False, None], dtype="boolean"))
 
+
+@pytest.mark.filterwarnings("ignore:'is_extension_type' is deprecated:FutureWarning")
 @pytest.mark.parametrize(
     "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
 )
-@ignore_sparse_warning
 def test_is_extension_type(check_scipy):
     assert not com.is_extension_type([1, 2, 3])
     assert not com.is_extension_type(np.array([1, 2, 3]))
@@ -595,8 +577,7 @@ def test_is_extension_type(check_scipy):
     cat = pd.Categorical([1, 2, 3])
     assert com.is_extension_type(cat)
     assert com.is_extension_type(pd.Series(cat))
-    assert com.is_extension_type(pd.SparseArray([1, 2, 3]))
-    assert com.is_extension_type(pd.SparseSeries([1, 2, 3]))
+    assert com.is_extension_type(SparseArray([1, 2, 3]))
     assert com.is_extension_type(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
 
     dtype = DatetimeTZDtype("ns", tz="US/Eastern")
@@ -609,6 +590,35 @@ def test_is_extension_type(check_scipy):
         assert not com.is_extension_type(scipy.sparse.bsr_matrix([1, 2, 3]))
 
 
+def test_is_extension_type_deprecation():
+    with tm.assert_produces_warning(FutureWarning):
+        com.is_extension_type([1, 2, 3])
+
+
+@pytest.mark.parametrize(
+    "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
+)
+def test_is_extension_array_dtype(check_scipy):
+    assert not com.is_extension_array_dtype([1, 2, 3])
+    assert not com.is_extension_array_dtype(np.array([1, 2, 3]))
+    assert not com.is_extension_array_dtype(pd.DatetimeIndex([1, 2, 3]))
+
+    cat = pd.Categorical([1, 2, 3])
+    assert com.is_extension_array_dtype(cat)
+    assert com.is_extension_array_dtype(pd.Series(cat))
+    assert com.is_extension_array_dtype(SparseArray([1, 2, 3]))
+    assert com.is_extension_array_dtype(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
+
+    dtype = DatetimeTZDtype("ns", tz="US/Eastern")
+    s = pd.Series([], dtype=dtype)
+    assert com.is_extension_array_dtype(s)
+
+    if check_scipy:
+        import scipy.sparse
+
+        assert not com.is_extension_array_dtype(scipy.sparse.bsr_matrix([1, 2, 3]))
+
+
 def test_is_complex_dtype():
     assert not com.is_complex_dtype(int)
     assert not com.is_complex_dtype(str)
@@ -619,18 +629,6 @@ def test_is_complex_dtype():
     assert com.is_complex_dtype(np.array([1 + 1j, 5]))
 
 
-def test_is_offsetlike():
-    assert com.is_offsetlike(np.array([pd.DateOffset(month=3), pd.offsets.Nano()]))
-    assert com.is_offsetlike(pd.offsets.MonthEnd())
-    assert com.is_offsetlike(pd.Index([pd.DateOffset(second=1)]))
-
-    assert not com.is_offsetlike(pd.Timedelta(1))
-    assert not com.is_offsetlike(np.array([1 + 1j, 5]))
-
-    # mixed case
-    assert not com.is_offsetlike(np.array([pd.DateOffset(), pd.Timestamp(0)]))
-
-
 @pytest.mark.parametrize(
     "input_param,result",
     [
@@ -664,26 +662,21 @@ def test__get_dtype(input_param, result):
     assert com._get_dtype(input_param) == result
 
 
-@ignore_sparse_warning
-def test__get_dtype_sparse():
-    ser = pd.SparseSeries([1, 2], dtype="int32")
-    expected = SparseDtype("int32")
-    assert com._get_dtype(ser) == expected
-    assert com._get_dtype(ser.dtype) == expected
-
-
 @pytest.mark.parametrize(
     "input_param,expected_error_message",
     [
         (None, "Cannot deduce dtype from null object"),
         (1, "data type not understood"),
         (1.2, "data type not understood"),
-        ("random string", 'data type "random string" not understood'),
+        # numpy dev changed from double-quotes to single quotes
+        ("random string", "data type [\"']random string[\"'] not understood"),
         (pd.DataFrame([1, 2]), "data type not understood"),
     ],
 )
 def test__get_dtype_fails(input_param, expected_error_message):
     # python objects
+    # 2020-02-02 npdev changed error message
+    expected_error_message += f"|Cannot interpret '{input_param}' as a data type"
     with pytest.raises(TypeError, match=expected_error_message):
         com._get_dtype(input_param)
 
@@ -725,9 +718,40 @@ def test__is_dtype_type(input_param, result):
     assert com._is_dtype_type(input_param, lambda tipo: tipo == result)
 
 
-@ignore_sparse_warning
-def test__is_dtype_type_sparse():
-    ser = pd.SparseSeries([1, 2], dtype="int32")
-    result = np.dtype("int32")
-    assert com._is_dtype_type(ser, lambda tipo: tipo == result)
-    assert com._is_dtype_type(ser.dtype, lambda tipo: tipo == result)
+@pytest.mark.parametrize("val", [np.datetime64("NaT"), np.timedelta64("NaT")])
+@pytest.mark.parametrize("typ", [np.int64])
+def test_astype_nansafe(val, typ):
+    arr = np.array([val])
+
+    msg = "Cannot convert NaT values to integer"
+    with pytest.raises(ValueError, match=msg):
+        astype_nansafe(arr, dtype=typ)
+
+
+@pytest.mark.parametrize("from_type", [np.datetime64, np.timedelta64])
+@pytest.mark.parametrize(
+    "to_type",
+    [
+        np.uint8,
+        np.uint16,
+        np.uint32,
+        np.int8,
+        np.int16,
+        np.int32,
+        np.float16,
+        np.float32,
+    ],
+)
+def test_astype_datetime64_bad_dtype_raises(from_type, to_type):
+    arr = np.array([from_type("2018")])
+
+    with pytest.raises(TypeError, match="cannot astype"):
+        astype_nansafe(arr, dtype=to_type)
+
+
+@pytest.mark.parametrize("from_type", [np.datetime64, np.timedelta64])
+def test_astype_object_preserves_datetime_na(from_type):
+    arr = np.array([from_type("NaT")])
+    result = astype_nansafe(arr, dtype="object")
+
+    assert isna(result)[0]
diff --git a/pandas/tests/dtypes/test_concat.py b/pandas/tests/dtypes/test_concat.py
index 0ca2f7c976535..02daa185b1cdb 100644
--- a/pandas/tests/dtypes/test_concat.py
+++ b/pandas/tests/dtypes/test_concat.py
@@ -2,7 +2,7 @@
 
 import pandas.core.dtypes.concat as _concat
 
-from pandas import DatetimeIndex, Index, Period, PeriodIndex, Series, TimedeltaIndex
+from pandas import DatetimeIndex, Period, PeriodIndex, Series, TimedeltaIndex
 
 
 @pytest.mark.parametrize(
@@ -40,9 +40,8 @@
         ),
     ],
 )
-@pytest.mark.parametrize("klass", [Index, Series])
-def test_get_dtype_kinds(klass, to_concat, expected):
-    to_concat_klass = [klass(c) for c in to_concat]
+def test_get_dtype_kinds(index_or_series, to_concat, expected):
+    to_concat_klass = [index_or_series(c) for c in to_concat]
     result = _concat.get_dtype_kinds(to_concat_klass)
     assert result == set(expected)
 
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index d3f0d7c43ee6b..dd99b81fb6764 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -12,10 +12,8 @@
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
-    is_datetimetz,
     is_dtype_equal,
     is_interval_dtype,
-    is_period,
     is_period_dtype,
     is_string_dtype,
 )
@@ -24,78 +22,70 @@
     DatetimeTZDtype,
     IntervalDtype,
     PeriodDtype,
-    ordered_sentinel,
     registry,
 )
 
 import pandas as pd
 from pandas import Categorical, CategoricalIndex, IntervalIndex, Series, date_range
-from pandas.core.sparse.api import SparseDtype
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
 
 
 class Base:
-    def setup_method(self, method):
-        self.dtype = self.create()
-
-    def test_hash(self):
-        hash(self.dtype)
-
-    def test_equality_invalid(self):
-        assert not self.dtype == "foo"
-        assert not is_dtype_equal(self.dtype, np.int64)
-
-    def test_numpy_informed(self):
-        with pytest.raises(TypeError, match="data type not understood"):
-            np.dtype(self.dtype)
+    def test_hash(self, dtype):
+        hash(dtype)
+
+    def test_equality_invalid(self, dtype):
+        assert not dtype == "foo"
+        assert not is_dtype_equal(dtype, np.int64)
+
+    def test_numpy_informed(self, dtype):
+        # npdev 2020-02-02 changed from "data type not understood" to
+        #  "Cannot interpret 'foo' as a data type"
+        msg = "|".join(
+            ["data type not understood", "Cannot interpret '.*' as a data type"]
+        )
+        with pytest.raises(TypeError, match=msg):
+            np.dtype(dtype)
 
-        assert not self.dtype == np.str_
-        assert not np.str_ == self.dtype
+        assert not dtype == np.str_
+        assert not np.str_ == dtype
 
-    def test_pickle(self):
+    def test_pickle(self, dtype):
         # make sure our cache is NOT pickled
 
         # clear the cache
-        type(self.dtype).reset_cache()
-        assert not len(self.dtype._cache)
+        type(dtype).reset_cache()
+        assert not len(dtype._cache)
 
         # force back to the cache
-        result = tm.round_trip_pickle(self.dtype)
-        assert not len(self.dtype._cache)
-        assert result == self.dtype
+        result = tm.round_trip_pickle(dtype)
+        assert not len(dtype._cache)
+        assert result == dtype
 
 
 class TestCategoricalDtype(Base):
-    def create(self):
-        # TODO(GH 26403): Remove when default ordered becomes False
-        return CategoricalDtype(ordered=None)
-
-    def test_pickle(self):
-        # make sure our cache is NOT pickled
-
-        # clear the cache
-        type(self.dtype).reset_cache()
-        assert not len(self.dtype._cache)
-
-        # force back to the cache
-        result = tm.round_trip_pickle(self.dtype)
-        assert result == self.dtype
-
-    def test_hash_vs_equality(self):
-        dtype = self.dtype
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestCategoricalDtype
+        """
+        return CategoricalDtype()
+
+    def test_hash_vs_equality(self, dtype):
         dtype2 = CategoricalDtype()
         assert dtype == dtype2
         assert dtype2 == dtype
         assert hash(dtype) == hash(dtype2)
 
-    def test_equality(self):
-        assert is_dtype_equal(self.dtype, "category")
-        assert is_dtype_equal(self.dtype, CategoricalDtype())
-        assert not is_dtype_equal(self.dtype, "foo")
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "category")
+        assert is_dtype_equal(dtype, CategoricalDtype())
+        assert not is_dtype_equal(dtype, "foo")
 
-    def test_construction_from_string(self):
+    def test_construction_from_string(self, dtype):
         result = CategoricalDtype.construct_from_string("category")
-        assert is_dtype_equal(self.dtype, result)
+        assert is_dtype_equal(dtype, result)
         msg = "Cannot construct a 'CategoricalDtype' from 'foo'"
         with pytest.raises(TypeError, match=msg):
             CategoricalDtype.construct_from_string("foo")
@@ -137,16 +127,16 @@ def test_from_values_or_dtype_raises(self, values, categories, ordered, dtype):
         with pytest.raises(ValueError, match=msg):
             CategoricalDtype._from_values_or_dtype(values, categories, ordered, dtype)
 
-    def test_is_dtype(self):
-        assert CategoricalDtype.is_dtype(self.dtype)
+    def test_is_dtype(self, dtype):
+        assert CategoricalDtype.is_dtype(dtype)
         assert CategoricalDtype.is_dtype("category")
         assert CategoricalDtype.is_dtype(CategoricalDtype())
         assert not CategoricalDtype.is_dtype("foo")
         assert not CategoricalDtype.is_dtype(np.float64)
 
-    def test_basic(self):
+    def test_basic(self, dtype):
 
-        assert is_categorical_dtype(self.dtype)
+        assert is_categorical_dtype(dtype)
 
         factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"])
 
@@ -184,12 +174,16 @@ def test_is_boolean(self, categories, expected):
 
 
 class TestDatetimeTZDtype(Base):
-    def create(self):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestDatetimeTZDtype
+        """
         return DatetimeTZDtype("ns", "US/Eastern")
 
     def test_alias_to_unit_raises(self):
         # 23990
-        with tm.assert_produces_warning(FutureWarning):
+        with pytest.raises(ValueError, match="Passing a dtype alias"):
             DatetimeTZDtype("datetime64[ns, US/Central]")
 
     def test_alias_to_unit_bad_alias_raises(self):
@@ -200,9 +194,8 @@ def test_alias_to_unit_bad_alias_raises(self):
         with pytest.raises(TypeError, match=""):
             DatetimeTZDtype("datetime64[ns, US/NotATZ]")
 
-    def test_hash_vs_equality(self):
+    def test_hash_vs_equality(self, dtype):
         # make sure that we satisfy is semantics
-        dtype = self.dtype
         dtype2 = DatetimeTZDtype("ns", "US/Eastern")
         dtype3 = DatetimeTZDtype(dtype2)
         assert dtype == dtype2
@@ -227,43 +220,54 @@ def test_subclass(self):
         assert issubclass(type(a), type(a))
         assert issubclass(type(a), type(b))
 
-    def test_compat(self):
-        assert is_datetime64tz_dtype(self.dtype)
+    def test_compat(self, dtype):
+        assert is_datetime64tz_dtype(dtype)
         assert is_datetime64tz_dtype("datetime64[ns, US/Eastern]")
-        assert is_datetime64_any_dtype(self.dtype)
+        assert is_datetime64_any_dtype(dtype)
         assert is_datetime64_any_dtype("datetime64[ns, US/Eastern]")
-        assert is_datetime64_ns_dtype(self.dtype)
+        assert is_datetime64_ns_dtype(dtype)
         assert is_datetime64_ns_dtype("datetime64[ns, US/Eastern]")
-        assert not is_datetime64_dtype(self.dtype)
+        assert not is_datetime64_dtype(dtype)
         assert not is_datetime64_dtype("datetime64[ns, US/Eastern]")
 
-    def test_construction_from_string(self):
+    def test_construction_from_string(self, dtype):
         result = DatetimeTZDtype.construct_from_string("datetime64[ns, US/Eastern]")
-        assert is_dtype_equal(self.dtype, result)
-        msg = "Could not construct DatetimeTZDtype from 'foo'"
-        with pytest.raises(TypeError, match=msg):
-            DatetimeTZDtype.construct_from_string("foo")
+        assert is_dtype_equal(dtype, result)
 
-    def test_construct_from_string_raises(self):
-        with pytest.raises(TypeError, match="notatz"):
-            DatetimeTZDtype.construct_from_string("datetime64[ns, notatz]")
+    @pytest.mark.parametrize(
+        "string",
+        [
+            "foo",
+            "datetime64[ns, notatz]",
+            # non-nano unit
+            "datetime64[ps, UTC]",
+            # dateutil str that returns None from gettz
+            "datetime64[ns, dateutil/invalid]",
+        ],
+    )
+    def test_construct_from_string_invalid_raises(self, string):
+        msg = f"Cannot construct a 'DatetimeTZDtype' from '{string}'"
+        with pytest.raises(TypeError, match=re.escape(msg)):
+            DatetimeTZDtype.construct_from_string(string)
 
-        with pytest.raises(TypeError, match="^Could not construct DatetimeTZDtype$"):
+    def test_construct_from_string_wrong_type_raises(self):
+        msg = "'construct_from_string' expects a string, got <class 'list'>"
+        with pytest.raises(TypeError, match=msg):
             DatetimeTZDtype.construct_from_string(["datetime64[ns, notatz]"])
 
-    def test_is_dtype(self):
+    def test_is_dtype(self, dtype):
         assert not DatetimeTZDtype.is_dtype(None)
-        assert DatetimeTZDtype.is_dtype(self.dtype)
+        assert DatetimeTZDtype.is_dtype(dtype)
         assert DatetimeTZDtype.is_dtype("datetime64[ns, US/Eastern]")
         assert not DatetimeTZDtype.is_dtype("foo")
         assert DatetimeTZDtype.is_dtype(DatetimeTZDtype("ns", "US/Pacific"))
         assert not DatetimeTZDtype.is_dtype(np.float64)
 
-    def test_equality(self):
-        assert is_dtype_equal(self.dtype, "datetime64[ns, US/Eastern]")
-        assert is_dtype_equal(self.dtype, DatetimeTZDtype("ns", "US/Eastern"))
-        assert not is_dtype_equal(self.dtype, "foo")
-        assert not is_dtype_equal(self.dtype, DatetimeTZDtype("ns", "CET"))
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "datetime64[ns, US/Eastern]")
+        assert is_dtype_equal(dtype, DatetimeTZDtype("ns", "US/Eastern"))
+        assert not is_dtype_equal(dtype, "foo")
+        assert not is_dtype_equal(dtype, DatetimeTZDtype("ns", "CET"))
         assert not is_dtype_equal(
             DatetimeTZDtype("ns", "US/Eastern"), DatetimeTZDtype("ns", "US/Pacific")
         )
@@ -271,9 +275,9 @@ def test_equality(self):
         # numpy compat
         assert is_dtype_equal(np.dtype("M8[ns]"), "datetime64[ns]")
 
-    def test_basic(self):
+    def test_basic(self, dtype):
 
-        assert is_datetime64tz_dtype(self.dtype)
+        assert is_datetime64tz_dtype(dtype)
 
         dr = date_range("20130101", periods=3, tz="US/Eastern")
         s = Series(dr, name="A")
@@ -284,32 +288,22 @@ def test_basic(self):
         assert not is_datetime64tz_dtype(np.dtype("float64"))
         assert not is_datetime64tz_dtype(1.0)
 
-        with tm.assert_produces_warning(FutureWarning):
-            assert is_datetimetz(s)
-            assert is_datetimetz(s.dtype)
-            assert not is_datetimetz(np.dtype("float64"))
-            assert not is_datetimetz(1.0)
-
     def test_dst(self):
 
         dr1 = date_range("2013-01-01", periods=3, tz="US/Eastern")
         s1 = Series(dr1, name="A")
         assert is_datetime64tz_dtype(s1)
-        with tm.assert_produces_warning(FutureWarning):
-            assert is_datetimetz(s1)
 
         dr2 = date_range("2013-08-01", periods=3, tz="US/Eastern")
         s2 = Series(dr2, name="A")
         assert is_datetime64tz_dtype(s2)
-        with tm.assert_produces_warning(FutureWarning):
-            assert is_datetimetz(s2)
         assert s1.dtype == s2.dtype
 
     @pytest.mark.parametrize("tz", ["UTC", "US/Eastern"])
     @pytest.mark.parametrize("constructor", ["M8", "datetime64"])
     def test_parser(self, tz, constructor):
         # pr #11245
-        dtz_str = "{con}[ns, {tz}]".format(con=constructor, tz=tz)
+        dtz_str = f"{constructor}[ns, {tz}]"
         result = DatetimeTZDtype.construct_from_string(dtz_str)
         expected = DatetimeTZDtype("ns", tz)
         assert result == expected
@@ -329,12 +323,15 @@ def test_tz_standardize(self):
 
 
 class TestPeriodDtype(Base):
-    def create(self):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestPeriodDtype
+        """
         return PeriodDtype("D")
 
-    def test_hash_vs_equality(self):
+    def test_hash_vs_equality(self, dtype):
         # make sure that we satisfy is semantics
-        dtype = self.dtype
         dtype2 = PeriodDtype("D")
         dtype3 = PeriodDtype(dtype2)
         assert dtype == dtype2
@@ -389,17 +386,17 @@ def test_identity(self):
         assert PeriodDtype("period[1S1U]") == PeriodDtype("period[1000001U]")
         assert PeriodDtype("period[1S1U]") is PeriodDtype("period[1000001U]")
 
-    def test_compat(self):
-        assert not is_datetime64_ns_dtype(self.dtype)
+    def test_compat(self, dtype):
+        assert not is_datetime64_ns_dtype(dtype)
         assert not is_datetime64_ns_dtype("period[D]")
-        assert not is_datetime64_dtype(self.dtype)
+        assert not is_datetime64_dtype(dtype)
         assert not is_datetime64_dtype("period[D]")
 
-    def test_construction_from_string(self):
+    def test_construction_from_string(self, dtype):
         result = PeriodDtype("period[D]")
-        assert is_dtype_equal(self.dtype, result)
+        assert is_dtype_equal(dtype, result)
         result = PeriodDtype.construct_from_string("period[D]")
-        assert is_dtype_equal(self.dtype, result)
+        assert is_dtype_equal(dtype, result)
         with pytest.raises(TypeError):
             PeriodDtype.construct_from_string("foo")
         with pytest.raises(TypeError):
@@ -412,8 +409,11 @@ def test_construction_from_string(self):
         with pytest.raises(TypeError):
             PeriodDtype.construct_from_string("datetime64[ns, US/Eastern]")
 
-    def test_is_dtype(self):
-        assert PeriodDtype.is_dtype(self.dtype)
+        with pytest.raises(TypeError, match="list"):
+            PeriodDtype.construct_from_string([1, 2, 3])
+
+    def test_is_dtype(self, dtype):
+        assert PeriodDtype.is_dtype(dtype)
         assert PeriodDtype.is_dtype("period[D]")
         assert PeriodDtype.is_dtype("period[3D]")
         assert PeriodDtype.is_dtype(PeriodDtype("3D"))
@@ -431,38 +431,30 @@ def test_is_dtype(self):
         assert not PeriodDtype.is_dtype(np.int64)
         assert not PeriodDtype.is_dtype(np.float64)
 
-    def test_equality(self):
-        assert is_dtype_equal(self.dtype, "period[D]")
-        assert is_dtype_equal(self.dtype, PeriodDtype("D"))
-        assert is_dtype_equal(self.dtype, PeriodDtype("D"))
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "period[D]")
+        assert is_dtype_equal(dtype, PeriodDtype("D"))
+        assert is_dtype_equal(dtype, PeriodDtype("D"))
         assert is_dtype_equal(PeriodDtype("D"), PeriodDtype("D"))
 
-        assert not is_dtype_equal(self.dtype, "D")
+        assert not is_dtype_equal(dtype, "D")
         assert not is_dtype_equal(PeriodDtype("D"), PeriodDtype("2D"))
 
-    def test_basic(self):
-        assert is_period_dtype(self.dtype)
+    def test_basic(self, dtype):
+        assert is_period_dtype(dtype)
 
         pidx = pd.period_range("2013-01-01 09:00", periods=5, freq="H")
 
         assert is_period_dtype(pidx.dtype)
         assert is_period_dtype(pidx)
-        with tm.assert_produces_warning(FutureWarning):
-            assert is_period(pidx)
 
         s = Series(pidx, name="A")
 
         assert is_period_dtype(s.dtype)
         assert is_period_dtype(s)
-        with tm.assert_produces_warning(FutureWarning):
-            assert is_period(s)
 
         assert not is_period_dtype(np.dtype("float64"))
         assert not is_period_dtype(1.0)
-        with tm.assert_produces_warning(FutureWarning):
-            assert not is_period(np.dtype("float64"))
-        with tm.assert_produces_warning(FutureWarning):
-            assert not is_period(1.0)
 
     def test_empty(self):
         dt = PeriodDtype()
@@ -475,12 +467,15 @@ def test_not_string(self):
 
 
 class TestIntervalDtype(Base):
-    def create(self):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestIntervalDtype
+        """
         return IntervalDtype("int64")
 
-    def test_hash_vs_equality(self):
+    def test_hash_vs_equality(self, dtype):
         # make sure that we satisfy is semantics
-        dtype = self.dtype
         dtype2 = IntervalDtype("int64")
         dtype3 = IntervalDtype(dtype2)
         assert dtype == dtype2
@@ -547,18 +542,18 @@ def test_construction_errors(self, subtype):
         with pytest.raises(TypeError, match=msg):
             IntervalDtype(subtype)
 
-    def test_construction_from_string(self):
+    def test_construction_from_string(self, dtype):
         result = IntervalDtype("interval[int64]")
-        assert is_dtype_equal(self.dtype, result)
+        assert is_dtype_equal(dtype, result)
         result = IntervalDtype.construct_from_string("interval[int64]")
-        assert is_dtype_equal(self.dtype, result)
+        assert is_dtype_equal(dtype, result)
 
     @pytest.mark.parametrize("string", [0, 3.14, ("a", "b"), None])
     def test_construction_from_string_errors(self, string):
         # these are invalid entirely
-        msg = "a string needs to be passed, got type"
+        msg = f"'construct_from_string' expects a string, got {type(string)}"
 
-        with pytest.raises(TypeError, match=msg):
+        with pytest.raises(TypeError, match=re.escape(msg)):
             IntervalDtype.construct_from_string(string)
 
     @pytest.mark.parametrize("string", ["foo", "foo[int64]", "IntervalA"])
@@ -580,8 +575,8 @@ def test_subclass(self):
         assert issubclass(type(a), type(a))
         assert issubclass(type(a), type(b))
 
-    def test_is_dtype(self):
-        assert IntervalDtype.is_dtype(self.dtype)
+    def test_is_dtype(self, dtype):
+        assert IntervalDtype.is_dtype(dtype)
         assert IntervalDtype.is_dtype("interval")
         assert IntervalDtype.is_dtype(IntervalDtype("float64"))
         assert IntervalDtype.is_dtype(IntervalDtype("int64"))
@@ -597,12 +592,12 @@ def test_is_dtype(self):
         assert not IntervalDtype.is_dtype(np.int64)
         assert not IntervalDtype.is_dtype(np.float64)
 
-    def test_equality(self):
-        assert is_dtype_equal(self.dtype, "interval[int64]")
-        assert is_dtype_equal(self.dtype, IntervalDtype("int64"))
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "interval[int64]")
+        assert is_dtype_equal(dtype, IntervalDtype("int64"))
         assert is_dtype_equal(IntervalDtype("int64"), IntervalDtype("int64"))
 
-        assert not is_dtype_equal(self.dtype, "int64")
+        assert not is_dtype_equal(dtype, "int64")
         assert not is_dtype_equal(IntervalDtype("int64"), IntervalDtype("float64"))
 
         # invalid subtype comparisons do not raise when directly compared
@@ -647,7 +642,7 @@ def test_equality_generic(self, subtype):
     def test_name_repr(self, subtype):
         # GH 18980
         dtype = IntervalDtype(subtype)
-        expected = "interval[{subtype}]".format(subtype=subtype)
+        expected = f"interval[{subtype}]"
         assert str(dtype) == expected
         assert dtype.name == "interval"
 
@@ -658,8 +653,8 @@ def test_name_repr_generic(self, subtype):
         assert str(dtype) == "interval"
         assert dtype.name == "interval"
 
-    def test_basic(self):
-        assert is_interval_dtype(self.dtype)
+    def test_basic(self, dtype):
+        assert is_interval_dtype(dtype)
 
         ii = IntervalIndex.from_breaks(range(3))
 
@@ -697,6 +692,10 @@ def test_caching(self):
         tm.round_trip_pickle(dtype)
         assert len(IntervalDtype._cache) == 0
 
+    def test_not_string(self):
+        # GH30568: though IntervalDtype has object kind, it cannot be string
+        assert not is_string_dtype(IntervalDtype())
+
 
 class TestCategoricalDtypeParametrized:
     @pytest.mark.parametrize(
@@ -731,8 +730,7 @@ def test_unordered_same(self, ordered):
     def test_categories(self):
         result = CategoricalDtype(["a", "b", "c"])
         tm.assert_index_equal(result.categories, pd.Index(["a", "b", "c"]))
-        with tm.assert_produces_warning(FutureWarning):
-            assert result.ordered is None
+        assert result.ordered is False
 
     def test_equal_but_different(self, ordered_fixture):
         c1 = CategoricalDtype([1, 2, 3])
@@ -857,25 +855,15 @@ def test_categorical_categories(self):
     @pytest.mark.parametrize(
         "new_categories", [list("abc"), list("cba"), list("wxyz"), None]
     )
-    @pytest.mark.parametrize("new_ordered", [True, False, None, ordered_sentinel])
+    @pytest.mark.parametrize("new_ordered", [True, False, None])
     def test_update_dtype(self, ordered_fixture, new_categories, new_ordered):
-        dtype = CategoricalDtype(list("abc"), ordered_fixture)
+        original_categories = list("abc")
+        dtype = CategoricalDtype(original_categories, ordered_fixture)
         new_dtype = CategoricalDtype(new_categories, new_ordered)
 
-        expected_categories = new_dtype.categories
-        if expected_categories is None:
-            expected_categories = dtype.categories
-
-        expected_ordered = new_ordered
-        if new_ordered is ordered_sentinel or new_ordered is None:
-            expected_ordered = dtype.ordered
-
-        # GH 26336
-        if new_ordered is ordered_sentinel and ordered_fixture is True:
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                result = dtype.update_dtype(new_dtype)
-        else:
-            result = dtype.update_dtype(new_dtype)
+        result = dtype.update_dtype(new_dtype)
+        expected_categories = pd.Index(new_categories or original_categories)
+        expected_ordered = new_ordered if new_ordered is not None else dtype.ordered
 
         tm.assert_index_equal(result.categories, expected_categories)
         assert result.ordered is expected_ordered
@@ -895,27 +883,6 @@ def test_update_dtype_errors(self, bad_dtype):
         with pytest.raises(ValueError, match=msg):
             dtype.update_dtype(bad_dtype)
 
-    @pytest.mark.parametrize("ordered", [ordered_sentinel, None, True, False])
-    def test_ordered_none_default_deprecated(self, ordered):
-        # GH 26403: CDT.ordered only warns if ordered is not explicitly passed
-        dtype = CategoricalDtype(list("abc"), ordered=ordered)
-        warning = FutureWarning if ordered is ordered_sentinel else None
-        with tm.assert_produces_warning(warning):
-            dtype.ordered
-
-    @pytest.mark.parametrize("ordered", [True, False, None, ordered_sentinel])
-    def test_pickle_ordered_from_sentinel(self, ordered):
-        # GH 27295: can remove test when _ordered_from_sentinel is removed (GH 26403)
-        dtype = CategoricalDtype(categories=list("abc"), ordered=ordered)
-
-        warning = FutureWarning if ordered is ordered_sentinel else None
-        with tm.assert_produces_warning(warning, check_stacklevel=False):
-            dtype_from_pickle = tm.round_trip_pickle(dtype)
-
-        result = dtype_from_pickle._ordered_from_sentinel
-        expected = ordered is ordered_sentinel
-        assert result is expected
-
 
 @pytest.mark.parametrize(
     "dtype", [CategoricalDtype, IntervalDtype, DatetimeTZDtype, PeriodDtype]
@@ -951,7 +918,7 @@ def test_registry_find(dtype, expected):
         (pd.Series([1, 2]), False),
         (np.array([True, False]), True),
         (pd.Series([True, False]), True),
-        (pd.SparseArray([True, False]), True),
+        (SparseArray([True, False]), True),
         (SparseDtype(bool), True),
     ],
 )
@@ -960,9 +927,8 @@ def test_is_bool_dtype(dtype, expected):
     assert result is expected
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 def test_is_bool_dtype_sparse():
-    result = is_bool_dtype(pd.SparseSeries([True, False]))
+    result = is_bool_dtype(pd.Series(SparseArray([True, False])))
     assert result is True
 
 
diff --git a/pandas/tests/dtypes/test_generic.py b/pandas/tests/dtypes/test_generic.py
index b42822a03ebcd..2c8631ac2d71d 100644
--- a/pandas/tests/dtypes/test_generic.py
+++ b/pandas/tests/dtypes/test_generic.py
@@ -1,11 +1,11 @@
-from warnings import catch_warnings, simplefilter
+from warnings import catch_warnings
 
 import numpy as np
 
 from pandas.core.dtypes import generic as gt
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestABCClasses:
@@ -17,12 +17,7 @@ class TestABCClasses:
     categorical = pd.Categorical([1, 2, 3], categories=[2, 3, 1])
     categorical_df = pd.DataFrame({"values": [1, 2, 3]}, index=categorical)
     df = pd.DataFrame({"names": ["a", "b", "c"]}, index=multi_index)
-    with catch_warnings():
-        simplefilter("ignore", FutureWarning)
-        sparse_series = pd.Series([1, 2, 3]).to_sparse()
-        sparse_frame = pd.SparseDataFrame({"a": [1, -1, None]})
-
-    sparse_array = pd.SparseArray(np.random.randn(10))
+    sparse_array = pd.arrays.SparseArray(np.random.randn(10))
     datetime_array = pd.core.arrays.DatetimeArray(datetime_index)
     timedelta_array = pd.core.arrays.TimedeltaArray(timedelta_index)
 
@@ -40,9 +35,7 @@ def test_abc_types(self):
         assert isinstance(pd.Int64Index([1, 2, 3]), gt.ABCIndexClass)
         assert isinstance(pd.Series([1, 2, 3]), gt.ABCSeries)
         assert isinstance(self.df, gt.ABCDataFrame)
-        assert isinstance(self.sparse_series, gt.ABCSparseSeries)
         assert isinstance(self.sparse_array, gt.ABCSparseArray)
-        assert isinstance(self.sparse_frame, gt.ABCSparseDataFrame)
         assert isinstance(self.categorical, gt.ABCCategorical)
         assert isinstance(pd.Period("2012", freq="A-DEC"), gt.ABCPeriod)
 
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 0a8707bdac3a0..48f9262ad3486 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -4,6 +4,7 @@
 
 """
 import collections
+from collections import namedtuple
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from fractions import Fraction
@@ -51,7 +52,8 @@
     Timestamp,
     isna,
 )
-from pandas.util import testing as tm
+import pandas._testing as tm
+from pandas.core.arrays import IntegerArray
 
 
 @pytest.fixture(params=[True, False], ids=str)
@@ -62,46 +64,46 @@ def coerce(request):
 # collect all objects to be tested for list-like-ness; use tuples of objects,
 # whether they are list-like or not (special casing for sets), and their ID
 ll_params = [
-    ([1], True, "list"),  # noqa: E241
-    ([], True, "list-empty"),  # noqa: E241
-    ((1,), True, "tuple"),  # noqa: E241
-    (tuple(), True, "tuple-empty"),  # noqa: E241
-    ({"a": 1}, True, "dict"),  # noqa: E241
-    (dict(), True, "dict-empty"),  # noqa: E241
-    ({"a", 1}, "set", "set"),  # noqa: E241
-    (set(), "set", "set-empty"),  # noqa: E241
-    (frozenset({"a", 1}), "set", "frozenset"),  # noqa: E241
-    (frozenset(), "set", "frozenset-empty"),  # noqa: E241
-    (iter([1, 2]), True, "iterator"),  # noqa: E241
-    (iter([]), True, "iterator-empty"),  # noqa: E241
-    ((x for x in [1, 2]), True, "generator"),  # noqa: E241
-    ((x for x in []), True, "generator-empty"),  # noqa: E241
-    (Series([1]), True, "Series"),  # noqa: E241
-    (Series([]), True, "Series-empty"),  # noqa: E241
-    (Series(["a"]).str, True, "StringMethods"),  # noqa: E241
-    (Series([], dtype="O").str, True, "StringMethods-empty"),  # noqa: E241
-    (Index([1]), True, "Index"),  # noqa: E241
-    (Index([]), True, "Index-empty"),  # noqa: E241
-    (DataFrame([[1]]), True, "DataFrame"),  # noqa: E241
-    (DataFrame(), True, "DataFrame-empty"),  # noqa: E241
-    (np.ndarray((2,) * 1), True, "ndarray-1d"),  # noqa: E241
-    (np.array([]), True, "ndarray-1d-empty"),  # noqa: E241
-    (np.ndarray((2,) * 2), True, "ndarray-2d"),  # noqa: E241
-    (np.array([[]]), True, "ndarray-2d-empty"),  # noqa: E241
-    (np.ndarray((2,) * 3), True, "ndarray-3d"),  # noqa: E241
-    (np.array([[[]]]), True, "ndarray-3d-empty"),  # noqa: E241
-    (np.ndarray((2,) * 4), True, "ndarray-4d"),  # noqa: E241
-    (np.array([[[[]]]]), True, "ndarray-4d-empty"),  # noqa: E241
-    (np.array(2), False, "ndarray-0d"),  # noqa: E241
-    (1, False, "int"),  # noqa: E241
-    (b"123", False, "bytes"),  # noqa: E241
-    (b"", False, "bytes-empty"),  # noqa: E241
-    ("123", False, "string"),  # noqa: E241
-    ("", False, "string-empty"),  # noqa: E241
-    (str, False, "string-type"),  # noqa: E241
-    (object(), False, "object"),  # noqa: E241
-    (np.nan, False, "NaN"),  # noqa: E241
-    (None, False, "None"),  # noqa: E241
+    ([1], True, "list"),
+    ([], True, "list-empty"),
+    ((1,), True, "tuple"),
+    (tuple(), True, "tuple-empty"),
+    ({"a": 1}, True, "dict"),
+    (dict(), True, "dict-empty"),
+    ({"a", 1}, "set", "set"),
+    (set(), "set", "set-empty"),
+    (frozenset({"a", 1}), "set", "frozenset"),
+    (frozenset(), "set", "frozenset-empty"),
+    (iter([1, 2]), True, "iterator"),
+    (iter([]), True, "iterator-empty"),
+    ((x for x in [1, 2]), True, "generator"),
+    ((_ for _ in []), True, "generator-empty"),
+    (Series([1]), True, "Series"),
+    (Series([], dtype=object), True, "Series-empty"),
+    (Series(["a"]).str, True, "StringMethods"),
+    (Series([], dtype="O").str, True, "StringMethods-empty"),
+    (Index([1]), True, "Index"),
+    (Index([]), True, "Index-empty"),
+    (DataFrame([[1]]), True, "DataFrame"),
+    (DataFrame(), True, "DataFrame-empty"),
+    (np.ndarray((2,) * 1), True, "ndarray-1d"),
+    (np.array([]), True, "ndarray-1d-empty"),
+    (np.ndarray((2,) * 2), True, "ndarray-2d"),
+    (np.array([[]]), True, "ndarray-2d-empty"),
+    (np.ndarray((2,) * 3), True, "ndarray-3d"),
+    (np.array([[[]]]), True, "ndarray-3d-empty"),
+    (np.ndarray((2,) * 4), True, "ndarray-4d"),
+    (np.array([[[[]]]]), True, "ndarray-4d-empty"),
+    (np.array(2), False, "ndarray-0d"),
+    (1, False, "int"),
+    (b"123", False, "bytes"),
+    (b"", False, "bytes-empty"),
+    ("123", False, "string"),
+    ("", False, "string-empty"),
+    (str, False, "string-type"),
+    (object(), False, "object"),
+    (np.nan, False, "NaN"),
+    (None, False, "None"),
 ]
 objs, expected, ids = zip(*ll_params)
 
@@ -138,7 +140,7 @@ def __getitem__(self):
 
 
 def test_is_array_like():
-    assert inference.is_array_like(Series([]))
+    assert inference.is_array_like(Series([], dtype=object))
     assert inference.is_array_like(Series([1, 2]))
     assert inference.is_array_like(np.array(["a", "b"]))
     assert inference.is_array_like(Index(["2016-01-01"]))
@@ -164,7 +166,7 @@ class DtypeList(list):
         {"a": 1},
         {1, "a"},
         Series([1]),
-        Series([]),
+        Series([], dtype=object),
         Series(["a"]).str,
         (x for x in range(5)),
     ],
@@ -238,7 +240,7 @@ def __getitem__(self, key):
 
         if has_contains:
 
-            def __contains__(self, key):
+            def __contains__(self, key) -> bool:
                 return self.d.__contains__(key)
 
     d = DictLike({1: 2})
@@ -288,7 +290,10 @@ class MockFile:
     assert not is_file(data)
 
 
-@pytest.mark.parametrize("ll", [collections.namedtuple("Test", list("abc"))(1, 2, 3)])
+test_tuple = collections.namedtuple("Test", ["a", "b", "c"])
+
+
+@pytest.mark.parametrize("ll", [test_tuple(1, 2, 3)])
 def test_is_names_tuple_passes(ll):
     assert inference.is_named_tuple(ll)
 
@@ -379,9 +384,12 @@ def test_isinf_scalar(self):
         assert not libmissing.isneginf_scalar(1)
         assert not libmissing.isneginf_scalar("a")
 
-    def test_maybe_convert_numeric_infinities(self):
+    @pytest.mark.parametrize("maybe_int", [True, False])
+    @pytest.mark.parametrize(
+        "infinity", ["inf", "inF", "iNf", "Inf", "iNF", "InF", "INf", "INF"]
+    )
+    def test_maybe_convert_numeric_infinities(self, infinity, maybe_int):
         # see gh-13274
-        infinities = ["inf", "inF", "iNf", "Inf", "iNF", "InF", "INf", "INF"]
         na_values = {"", "NULL", "nan"}
 
         pos = np.array(["inf"], dtype=np.float64)
@@ -389,35 +397,31 @@ def test_maybe_convert_numeric_infinities(self):
 
         msg = "Unable to parse string"
 
-        for infinity in infinities:
-            for maybe_int in (True, False):
-                out = lib.maybe_convert_numeric(
-                    np.array([infinity], dtype=object), na_values, maybe_int
-                )
-                tm.assert_numpy_array_equal(out, pos)
-
-                out = lib.maybe_convert_numeric(
-                    np.array(["-" + infinity], dtype=object), na_values, maybe_int
-                )
-                tm.assert_numpy_array_equal(out, neg)
-
-                out = lib.maybe_convert_numeric(
-                    np.array([infinity], dtype=object), na_values, maybe_int
-                )
-                tm.assert_numpy_array_equal(out, pos)
-
-                out = lib.maybe_convert_numeric(
-                    np.array(["+" + infinity], dtype=object), na_values, maybe_int
-                )
-                tm.assert_numpy_array_equal(out, pos)
-
-                # too many characters
-                with pytest.raises(ValueError, match=msg):
-                    lib.maybe_convert_numeric(
-                        np.array(["foo_" + infinity], dtype=object),
-                        na_values,
-                        maybe_int,
-                    )
+        out = lib.maybe_convert_numeric(
+            np.array([infinity], dtype=object), na_values, maybe_int
+        )
+        tm.assert_numpy_array_equal(out, pos)
+
+        out = lib.maybe_convert_numeric(
+            np.array(["-" + infinity], dtype=object), na_values, maybe_int
+        )
+        tm.assert_numpy_array_equal(out, neg)
+
+        out = lib.maybe_convert_numeric(
+            np.array([infinity], dtype=object), na_values, maybe_int
+        )
+        tm.assert_numpy_array_equal(out, pos)
+
+        out = lib.maybe_convert_numeric(
+            np.array(["+" + infinity], dtype=object), na_values, maybe_int
+        )
+        tm.assert_numpy_array_equal(out, pos)
+
+        # too many characters
+        with pytest.raises(ValueError, match=msg):
+            lib.maybe_convert_numeric(
+                np.array(["foo_" + infinity], dtype=object), na_values, maybe_int
+            )
 
     def test_maybe_convert_numeric_post_floatify_nan(self, coerce):
         # see gh-13314
@@ -446,7 +450,7 @@ def test_scientific_no_exponent(self):
     def test_convert_non_hashable(self):
         # GH13324
         # make sure that we are handing non-hashables
-        arr = np.array([[10.0, 2], 1.0, "apple"])
+        arr = np.array([[10.0, 2], 1.0, "apple"], dtype=object)
         result = lib.maybe_convert_numeric(arr, set(), False, True)
         tm.assert_numpy_array_equal(result, np.array([np.nan, 1.0, np.nan]))
 
@@ -503,7 +507,7 @@ def test_convert_numeric_int64_uint64(self, case, coerce):
         result = lib.maybe_convert_numeric(case, set(), coerce_numeric=coerce)
         tm.assert_almost_equal(result, expected)
 
-    @pytest.mark.parametrize("value", [-2 ** 63 - 1, 2 ** 64])
+    @pytest.mark.parametrize("value", [-(2 ** 63) - 1, 2 ** 64])
     def test_convert_int_overflow(self, value):
         # see gh-18584
         arr = np.array([value], dtype=object)
@@ -550,6 +554,20 @@ def test_maybe_convert_objects_datetime(self):
         out = lib.maybe_convert_objects(arr, convert_datetime=1, convert_timedelta=1)
         tm.assert_numpy_array_equal(out, exp)
 
+    @pytest.mark.parametrize(
+        "exp",
+        [
+            IntegerArray(np.array([2, 0], dtype="i8"), np.array([False, True])),
+            IntegerArray(np.array([2, 0], dtype="int64"), np.array([False, True])),
+        ],
+    )
+    def test_maybe_convert_objects_nullable_integer(self, exp):
+        # GH27335
+        arr = np.array([2, np.NaN], dtype=object)
+        result = lib.maybe_convert_objects(arr, convert_to_nullable_integer=1)
+
+        tm.assert_extension_array_equal(result, exp)
+
     def test_mixed_dtypes_remain_object_array(self):
         # GH14956
         array = np.array([datetime(2015, 1, 1, tzinfo=pytz.utc), 1], dtype=object)
@@ -611,13 +629,13 @@ def test_integer_na(self, arr, skipna):
         expected = "integer" if skipna else "integer-na"
         assert result == expected
 
-    def test_deprecation(self):
-        # GH 24050
-        arr = np.array([1, 2, 3], dtype=object)
+    def test_infer_dtype_skipna_default(self):
+        # infer_dtype `skipna` default deprecated in GH#24050,
+        #  changed to True in GH#29876
+        arr = np.array([1, 2, 3, np.nan], dtype=object)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = lib.infer_dtype(arr)  # default: skipna=None -> warn
-            assert result == "integer"
+        result = lib.infer_dtype(arr)
+        assert result == "integer"
 
     def test_bools(self):
         arr = np.array([True, False, True, True, True], dtype="O")
@@ -715,12 +733,17 @@ def test_string(self):
     def test_unicode(self):
         arr = ["a", np.nan, "c"]
         result = lib.infer_dtype(arr, skipna=False)
+        # This currently returns "mixed", but it's not clear that's optimal.
+        # This could also return "string" or "mixed-string"
         assert result == "mixed"
 
         arr = ["a", np.nan, "c"]
         result = lib.infer_dtype(arr, skipna=True)
-        expected = "string"
-        assert result == expected
+        assert result == "string"
+
+        arr = ["a", "c"]
+        result = lib.infer_dtype(arr, skipna=False)
+        assert result == "string"
 
     @pytest.mark.parametrize(
         "dtype, missing, skipna, expected",
@@ -1091,28 +1114,28 @@ def test_is_string_array(self):
 
         assert lib.is_string_array(np.array(["foo", "bar"]))
         assert not lib.is_string_array(
-            np.array(["foo", "bar", np.nan], dtype=object), skipna=False
+            np.array(["foo", "bar", pd.NA], dtype=object), skipna=False
         )
         assert lib.is_string_array(
+            np.array(["foo", "bar", pd.NA], dtype=object), skipna=True
+        )
+        # NaN is not valid for string array, just NA
+        assert not lib.is_string_array(
             np.array(["foo", "bar", np.nan], dtype=object), skipna=True
         )
+
         assert not lib.is_string_array(np.array([1, 2]))
 
     def test_to_object_array_tuples(self):
         r = (5, 6)
         values = [r]
-        result = lib.to_object_array_tuples(values)
-
-        try:
-            # make sure record array works
-            from collections import namedtuple
+        lib.to_object_array_tuples(values)
 
-            record = namedtuple("record", "x y")
-            r = record(5, 6)
-            values = [r]
-            result = lib.to_object_array_tuples(values)  # noqa
-        except ImportError:
-            pass
+        # make sure record array works
+        record = namedtuple("record", "x y")
+        r = record(5, 6)
+        values = [r]
+        lib.to_object_array_tuples(values)
 
     def test_object(self):
 
@@ -1152,8 +1175,6 @@ def test_is_period(self):
     def test_categorical(self):
 
         # GH 8974
-        from pandas import Categorical, Series
-
         arr = Categorical(list("abc"))
         result = lib.infer_dtype(arr, skipna=True)
         assert result == "categorical"
@@ -1298,7 +1319,7 @@ def test_is_datetime_dtypes(self):
         assert is_datetime64tz_dtype(tsa)
 
         for tz in ["US/Eastern", "UTC"]:
-            dtype = "datetime64[ns, {}]".format(tz)
+            dtype = f"datetime64[ns, {tz}]"
             assert not is_datetime64_dtype(dtype)
             assert is_datetime64tz_dtype(dtype)
             assert is_datetime64_ns_dtype(dtype)
@@ -1325,9 +1346,11 @@ def test_is_scalar_builtin_scalars(self):
         assert is_scalar(None)
         assert is_scalar(True)
         assert is_scalar(False)
-        assert is_scalar(Number())
         assert is_scalar(Fraction())
         assert is_scalar(0.0)
+        assert is_scalar(1)
+        assert is_scalar(complex(2))
+        assert is_scalar(float("NaN"))
         assert is_scalar(np.nan)
         assert is_scalar("foobar")
         assert is_scalar(b"foobar")
@@ -1336,6 +1359,7 @@ def test_is_scalar_builtin_scalars(self):
         assert is_scalar(time(12, 0))
         assert is_scalar(timedelta(hours=1))
         assert is_scalar(pd.NaT)
+        assert is_scalar(pd.NA)
 
     def test_is_scalar_builtin_nonscalars(self):
         assert not is_scalar({})
@@ -1350,6 +1374,7 @@ def test_is_scalar_numpy_array_scalars(self):
         assert is_scalar(np.int64(1))
         assert is_scalar(np.float64(1.0))
         assert is_scalar(np.int32(1))
+        assert is_scalar(np.complex64(2))
         assert is_scalar(np.object_("foobar"))
         assert is_scalar(np.str_("foobar"))
         assert is_scalar(np.unicode_("foobar"))
@@ -1382,17 +1407,32 @@ def test_is_scalar_pandas_scalars(self):
         assert is_scalar(DateOffset(days=1))
 
     def test_is_scalar_pandas_containers(self):
-        assert not is_scalar(Series())
+        assert not is_scalar(Series(dtype=object))
         assert not is_scalar(Series([1]))
         assert not is_scalar(DataFrame())
         assert not is_scalar(DataFrame([[1]]))
         assert not is_scalar(Index([]))
         assert not is_scalar(Index([1]))
 
+    def test_is_scalar_number(self):
+        # Number() is not recognied by PyNumber_Check, so by extension
+        #  is not recognized by is_scalar, but instances of non-abstract
+        #  subclasses are.
+
+        class Numeric(Number):
+            def __init__(self, value):
+                self.value = value
+
+            def __int__(self):
+                return self.value
+
+        num = Numeric(1)
+        assert is_scalar(num)
+
 
 def test_datetimeindex_from_empty_datetime64_array():
     for unit in ["ms", "us", "ns"]:
-        idx = DatetimeIndex(np.array([], dtype="datetime64[{unit}]".format(unit=unit)))
+        idx = DatetimeIndex(np.array([], dtype=f"datetime64[{unit}]"))
         assert len(idx) == 0
 
 
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index bbc485ecf94f2..7ba59786bb0fa 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -1,6 +1,5 @@
 from datetime import datetime
 from decimal import Decimal
-from warnings import catch_warnings, filterwarnings
 
 import numpy as np
 import pytest
@@ -23,7 +22,10 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Float64Index, NaT, Series, TimedeltaIndex, date_range
-from pandas.util import testing as tm
+import pandas._testing as tm
+
+now = pd.Timestamp.now()
+utcnow = pd.Timestamp.now("UTC")
 
 
 @pytest.mark.parametrize("notna_f", [notna, notnull])
@@ -87,7 +89,8 @@ def test_isna_isnull(self, isna_f):
         assert not isna_f(-np.inf)
 
         # type
-        assert not isna_f(type(pd.Series()))
+        assert not isna_f(type(pd.Series(dtype=object)))
+        assert not isna_f(type(pd.Series(dtype=np.float64)))
         assert not isna_f(type(pd.DataFrame()))
 
         # series
@@ -291,6 +294,11 @@ def test_array_equivalent():
         np.array([np.nan, None], dtype="object"),
         np.array([np.nan, None], dtype="object"),
     )
+    # Check the handling of nested arrays in array_equivalent_object
+    assert array_equivalent(
+        np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+        np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+    )
     assert array_equivalent(
         np.array([np.nan, 1 + 1j], dtype="complex"),
         np.array([np.nan, 1 + 1j], dtype="complex"),
@@ -311,27 +319,48 @@ def test_array_equivalent():
     assert not array_equivalent(
         TimedeltaIndex([0, np.nan]), TimedeltaIndex([1, np.nan])
     )
-    with catch_warnings():
-        filterwarnings("ignore", "Converting timezone", FutureWarning)
-        assert array_equivalent(
-            DatetimeIndex([0, np.nan], tz="US/Eastern"),
-            DatetimeIndex([0, np.nan], tz="US/Eastern"),
-        )
-        assert not array_equivalent(
-            DatetimeIndex([0, np.nan], tz="US/Eastern"),
-            DatetimeIndex([1, np.nan], tz="US/Eastern"),
-        )
-        assert not array_equivalent(
-            DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan], tz="US/Eastern")
-        )
-        assert not array_equivalent(
-            DatetimeIndex([0, np.nan], tz="CET"),
-            DatetimeIndex([0, np.nan], tz="US/Eastern"),
-        )
+    assert array_equivalent(
+        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+    )
+    assert not array_equivalent(
+        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+        DatetimeIndex([1, np.nan], tz="US/Eastern"),
+    )
+    assert not array_equivalent(
+        DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan], tz="US/Eastern")
+    )
+    assert not array_equivalent(
+        DatetimeIndex([0, np.nan], tz="CET"),
+        DatetimeIndex([0, np.nan], tz="US/Eastern"),
+    )
 
     assert not array_equivalent(DatetimeIndex([0, np.nan]), TimedeltaIndex([0, np.nan]))
 
 
+@pytest.mark.parametrize(
+    "lvalue, rvalue",
+    [
+        # There are 3 variants for each of lvalue and rvalue. We include all
+        #  three for the tz-naive `now` and exclude the datetim64 variant
+        #  for utcnow because it drops tzinfo.
+        (now, utcnow),
+        (now.to_datetime64(), utcnow),
+        (now.to_pydatetime(), utcnow),
+        (now, utcnow),
+        (now.to_datetime64(), utcnow.to_pydatetime()),
+        (now.to_pydatetime(), utcnow.to_pydatetime()),
+    ],
+)
+def test_array_equivalent_tzawareness(lvalue, rvalue):
+    # we shouldn't raise if comparing tzaware and tznaive datetimes
+    left = np.array([lvalue], dtype=object)
+    right = np.array([rvalue], dtype=object)
+
+    assert not array_equivalent(left, right, strict_nan=True)
+    assert not array_equivalent(left, right, strict_nan=False)
+
+
 def test_array_equivalent_compat():
     # see gh-13388
     m = np.array([(1, 2), (3, 4)], dtype=[("a", int), ("b", float)])
@@ -360,6 +389,20 @@ def test_array_equivalent_str():
         )
 
 
+def test_array_equivalent_nested():
+    # reached in groupby aggregations, make sure we use np.any when checking
+    #  if the comparison is truthy
+    left = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
+    right = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=True)
+    assert not array_equivalent(left, right[::-1], strict_nan=True)
+
+    left = np.array([np.array([50, 50, 50]), np.array([40, 40, 40])], dtype=object)
+    right = np.array([50, 40])
+    assert not array_equivalent(left, right, strict_nan=True)
+
+
 @pytest.mark.parametrize(
     "dtype, na_value",
     [
diff --git a/pandas/tests/extension/arrow/arrays.py b/pandas/tests/extension/arrow/arrays.py
index 6a28f76e474cc..b67ca4cfab83d 100644
--- a/pandas/tests/extension/arrow/arrays.py
+++ b/pandas/tests/extension/arrow/arrays.py
@@ -7,6 +7,7 @@
 """
 import copy
 import itertools
+from typing import Type
 
 import numpy as np
 import pyarrow as pa
@@ -29,17 +30,18 @@ class ArrowBoolDtype(ExtensionDtype):
     na_value = pa.NULL
 
     @classmethod
-    def construct_from_string(cls, string):
-        if string == cls.name:
-            return cls()
-        else:
-            raise TypeError("Cannot construct a '{}' from '{}'".format(cls, string))
-
-    @classmethod
-    def construct_array_type(cls):
+    def construct_array_type(cls) -> Type["ArrowBoolArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
         return ArrowBoolArray
 
-    def _is_boolean(self):
+    @property
+    def _is_boolean(self) -> bool:
         return True
 
 
@@ -52,14 +54,14 @@ class ArrowStringDtype(ExtensionDtype):
     na_value = pa.NULL
 
     @classmethod
-    def construct_from_string(cls, string):
-        if string == cls.name:
-            return cls()
-        else:
-            raise TypeError("Cannot construct a '{}' from '{}'".format(cls, string))
-
-    @classmethod
-    def construct_array_type(cls):
+    def construct_array_type(cls) -> Type["ArrowStringArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
         return ArrowStringArray
 
 
@@ -79,7 +81,7 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
         return cls.from_scalars(scalars)
 
     def __repr__(self):
-        return "{cls}({data})".format(cls=type(self).__name__, data=repr(self._data))
+        return f"{type(self).__name__}({repr(self._data)})"
 
     def __getitem__(self, item):
         if pd.api.types.is_scalar(item):
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index 9c53210b75d6b..94dd09d3eb053 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -2,10 +2,10 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.tests.extension import base
-import pandas.util.testing as tm
 
-pytest.importorskip("pyarrow", minversion="0.10.0")
+pytest.importorskip("pyarrow", minversion="0.13.0")
 
 from .arrays import ArrowBoolArray, ArrowBoolDtype  # isort:skip
 
diff --git a/pandas/tests/extension/arrow/test_string.py b/pandas/tests/extension/arrow/test_string.py
index 06f149aa4b75f..abd5c1f386dc5 100644
--- a/pandas/tests/extension/arrow/test_string.py
+++ b/pandas/tests/extension/arrow/test_string.py
@@ -2,7 +2,7 @@
 
 import pandas as pd
 
-pytest.importorskip("pyarrow", minversion="0.10.0")
+pytest.importorskip("pyarrow", minversion="0.13.0")
 
 from .arrays import ArrowStringDtype  # isort:skip
 
diff --git a/pandas/tests/extension/base/__init__.py b/pandas/tests/extension/base/__init__.py
index 090df35bd94c9..e2b6ea0304f6a 100644
--- a/pandas/tests/extension/base/__init__.py
+++ b/pandas/tests/extension/base/__init__.py
@@ -49,7 +49,12 @@ class TestMyDtype(BaseDtypeTests):
 from .io import BaseParsingTests  # noqa
 from .methods import BaseMethodsTests  # noqa
 from .missing import BaseMissingTests  # noqa
-from .ops import BaseArithmeticOpsTests, BaseComparisonOpsTests, BaseOpsUtil  # noqa
+from .ops import (  # noqa
+    BaseArithmeticOpsTests,
+    BaseComparisonOpsTests,
+    BaseOpsUtil,
+    BaseUnaryOpsTests,
+)
 from .printing import BasePrintingTests  # noqa
 from .reduce import (  # noqa
     BaseBooleanReduceTests,
diff --git a/pandas/tests/extension/base/base.py b/pandas/tests/extension/base/base.py
index 2f808d20acd31..97d8e7c66dbdb 100644
--- a/pandas/tests/extension/base/base.py
+++ b/pandas/tests/extension/base/base.py
@@ -1,9 +1,21 @@
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class BaseExtensionTests:
+    # classmethod and different signature is needed
+    # to make inheritance compliant with mypy
+    @classmethod
+    def assert_equal(cls, left, right, **kwargs):
+        return tm.assert_equal(left, right, **kwargs)
 
-    assert_equal = staticmethod(tm.assert_equal)
-    assert_series_equal = staticmethod(tm.assert_series_equal)
-    assert_frame_equal = staticmethod(tm.assert_frame_equal)
-    assert_extension_array_equal = staticmethod(tm.assert_extension_array_equal)
+    @classmethod
+    def assert_series_equal(cls, left, right, *args, **kwargs):
+        return tm.assert_series_equal(left, right, *args, **kwargs)
+
+    @classmethod
+    def assert_frame_equal(cls, left, right, *args, **kwargs):
+        return tm.assert_frame_equal(left, right, *args, **kwargs)
+
+    @classmethod
+    def assert_extension_array_equal(cls, left, right, *args, **kwargs):
+        return tm.assert_extension_array_equal(left, right, *args, **kwargs)
diff --git a/pandas/tests/extension/base/casting.py b/pandas/tests/extension/base/casting.py
index 7146443bf8de5..58859fc6ac54c 100644
--- a/pandas/tests/extension/base/casting.py
+++ b/pandas/tests/extension/base/casting.py
@@ -1,3 +1,5 @@
+import numpy as np
+
 import pandas as pd
 from pandas.core.internals import ObjectBlock
 
@@ -21,3 +23,12 @@ def test_astype_str(self, data):
         result = pd.Series(data[:5]).astype(str)
         expected = pd.Series(data[:5].astype(str))
         self.assert_series_equal(result, expected)
+
+    def test_to_numpy(self, data):
+        expected = np.asarray(data)
+
+        result = data.to_numpy()
+        self.assert_equal(result, expected)
+
+        result = pd.Series(data).to_numpy()
+        self.assert_equal(result, expected)
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index 7262a85b1fe00..c40646ca2415e 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -64,6 +64,15 @@ def test_from_dtype(self, data):
         result = pd.Series(list(data), dtype=str(dtype))
         self.assert_series_equal(result, expected)
 
+        # gh-30280
+
+        expected = pd.DataFrame(data).astype(dtype)
+        result = pd.DataFrame(list(data), dtype=dtype)
+        self.assert_frame_equal(result, expected)
+
+        result = pd.DataFrame(list(data), dtype=str(dtype))
+        self.assert_frame_equal(result, expected)
+
     def test_pandas_array(self, data):
         # pd.array(extension_array) should be idempotent...
         result = pd.array(data)
diff --git a/pandas/tests/extension/base/dtype.py b/pandas/tests/extension/base/dtype.py
index a5040c8cfc2fc..b01867624cb16 100644
--- a/pandas/tests/extension/base/dtype.py
+++ b/pandas/tests/extension/base/dtype.py
@@ -16,8 +16,7 @@ def test_name(self, dtype):
 
     def test_kind(self, dtype):
         valid = set("biufcmMOSUV")
-        if dtype.kind is not None:
-            assert dtype.kind in valid
+        assert dtype.kind in valid
 
     def test_construct_from_string_own_name(self, dtype):
         result = dtype.construct_from_string(dtype.name)
@@ -38,6 +37,9 @@ def test_is_dtype_from_self(self, dtype):
         result = type(dtype).is_dtype(dtype)
         assert result is True
 
+    def test_is_dtype_other_input(self, dtype):
+        assert dtype.is_dtype([1, 2, 3]) is False
+
     def test_is_not_string_type(self, dtype):
         return not pd.api.types.is_string_dtype(dtype)
 
@@ -96,7 +98,17 @@ def test_eq(self, dtype):
         assert dtype != "anonther_type"
 
     def test_construct_from_string(self, dtype):
-        dtype_instance = dtype.__class__.construct_from_string(dtype.name)
-        assert isinstance(dtype_instance, dtype.__class__)
-        with pytest.raises(TypeError):
-            dtype.__class__.construct_from_string("another_type")
+        dtype_instance = type(dtype).construct_from_string(dtype.name)
+        assert isinstance(dtype_instance, type(dtype))
+
+    def test_construct_from_string_another_type_raises(self, dtype):
+        msg = f"Cannot construct a '{type(dtype).__name__}' from 'another_type'"
+        with pytest.raises(TypeError, match=msg):
+            type(dtype).construct_from_string("another_type")
+
+    def test_construct_from_string_wrong_type_raises(self, dtype):
+        with pytest.raises(
+            TypeError,
+            match="'construct_from_string' expects a string, got <class 'int'>",
+        ):
+            type(dtype).construct_from_string(0)
diff --git a/pandas/tests/extension/base/getitem.py b/pandas/tests/extension/base/getitem.py
index d56cc50f4739c..8615a8df22dcc 100644
--- a/pandas/tests/extension/base/getitem.py
+++ b/pandas/tests/extension/base/getitem.py
@@ -97,6 +97,15 @@ def test_getitem_scalar_na(self, data_missing, na_cmp, na_value):
         result = data_missing[0]
         assert na_cmp(result, na_value)
 
+    def test_getitem_empty(self, data):
+        # Indexing with empty list
+        result = data[[]]
+        assert len(result) == 0
+        assert isinstance(result, type(data))
+
+        expected = data[np.array([], dtype="int64")]
+        self.assert_extension_array_equal(result, expected)
+
     def test_getitem_mask(self, data):
         # Empty mask, raw array
         mask = np.zeros(len(data), dtype=bool)
@@ -121,6 +130,82 @@ def test_getitem_mask(self, data):
         assert len(result) == 1
         assert result.dtype == data.dtype
 
+    def test_getitem_mask_raises(self, data):
+        mask = np.array([True, False])
+        with pytest.raises(IndexError):
+            data[mask]
+
+        mask = pd.array(mask, dtype="boolean")
+        with pytest.raises(IndexError):
+            data[mask]
+
+    def test_getitem_boolean_array_mask(self, data):
+        mask = pd.array(np.zeros(data.shape, dtype="bool"), dtype="boolean")
+        result = data[mask]
+        assert len(result) == 0
+        assert isinstance(result, type(data))
+
+        result = pd.Series(data)[mask]
+        assert len(result) == 0
+        assert result.dtype == data.dtype
+
+        mask[:5] = True
+        expected = data.take([0, 1, 2, 3, 4])
+        result = data[mask]
+        self.assert_extension_array_equal(result, expected)
+
+        expected = pd.Series(expected)
+        result = pd.Series(data)[mask]
+        self.assert_series_equal(result, expected)
+
+    def test_getitem_boolean_array_mask_raises(self, data):
+        mask = pd.array(np.zeros(data.shape, dtype="bool"), dtype="boolean")
+        mask[:2] = pd.NA
+
+        msg = (
+            "Cannot mask with a boolean indexer containing NA values|"
+            "cannot mask with array containing NA / NaN values"
+        )
+        with pytest.raises(ValueError, match=msg):
+            data[mask]
+
+        s = pd.Series(data)
+
+        with pytest.raises(ValueError):
+            s[mask]
+
+    @pytest.mark.parametrize(
+        "idx",
+        [[0, 1, 2], pd.array([0, 1, 2], dtype="Int64"), np.array([0, 1, 2])],
+        ids=["list", "integer-array", "numpy-array"],
+    )
+    def test_getitem_integer_array(self, data, idx):
+        result = data[idx]
+        assert len(result) == 3
+        assert isinstance(result, type(data))
+        expected = data.take([0, 1, 2])
+        self.assert_extension_array_equal(result, expected)
+
+        expected = pd.Series(expected)
+        result = pd.Series(data)[idx]
+        self.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [[0, 1, 2, pd.NA], pd.array([0, 1, 2, pd.NA], dtype="Int64")],
+        ids=["list", "integer-array"],
+    )
+    def test_getitem_integer_with_missing_raises(self, data, idx):
+        msg = "Cannot index with an integer indexer containing NA values"
+        with pytest.raises(ValueError, match=msg):
+            data[idx]
+
+        # TODO this raises KeyError about labels not found (it tries label-based)
+        # import pandas._testing as tm
+        # s = pd.Series(data, index=[tm.rands(4) for _ in range(len(data))])
+        # with pytest.raises(ValueError, match=msg):
+        #    s[idx]
+
     def test_getitem_slice(self, data):
         # getitem[slice] should return an array
         result = data[slice(0)]  # empty
@@ -206,7 +291,9 @@ def test_take_non_na_fill_value(self, data_missing):
         fill_value = data_missing[1]  # valid
         na = data_missing[0]
 
-        array = data_missing._from_sequence([na, fill_value, na])
+        array = data_missing._from_sequence(
+            [na, fill_value, na], dtype=data_missing.dtype
+        )
         result = array.take([-1, 1], fill_value=fill_value, allow_fill=True)
         expected = array.take([1, 1])
         self.assert_extension_array_equal(result, expected)
@@ -254,10 +341,12 @@ def test_reindex_non_na_fill_value(self, data_missing):
         valid = data_missing[1]
         na = data_missing[0]
 
-        array = data_missing._from_sequence([na, valid])
+        array = data_missing._from_sequence([na, valid], dtype=data_missing.dtype)
         ser = pd.Series(array)
         result = ser.reindex([0, 1, 2], fill_value=valid)
-        expected = pd.Series(data_missing._from_sequence([na, valid, valid]))
+        expected = pd.Series(
+            data_missing._from_sequence([na, valid, valid], dtype=data_missing.dtype)
+        )
 
         self.assert_series_equal(result, expected)
 
@@ -266,3 +355,16 @@ def test_loc_len1(self, data):
         df = pd.DataFrame({"A": data})
         res = df.loc[[0], "A"]
         assert res._data._block.ndim == 1
+
+    def test_item(self, data):
+        # https://github.com/pandas-dev/pandas/pull/30175
+        s = pd.Series(data)
+        result = s[:1].item()
+        assert result == data[0]
+
+        msg = "can only convert an array of size 1 to a Python scalar"
+        with pytest.raises(ValueError, match=msg):
+            s[:0].item()
+
+        with pytest.raises(ValueError, match=msg):
+            s.item()
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index dc926d2ff6ab4..94d0ef7bbea84 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -1,7 +1,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from .base import BaseExtensionTests
 
diff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py
index a29f6deeffae6..cdea96334be2a 100644
--- a/pandas/tests/extension/base/interface.py
+++ b/pandas/tests/extension/base/interface.py
@@ -4,7 +4,7 @@
 from pandas.core.dtypes.dtypes import ExtensionDtype
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from .base import BaseExtensionTests
 
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index 6d47b0c1d1f77..22e53dbc89f01 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -1,9 +1,13 @@
+import operator
+
 import numpy as np
 import pytest
 
+from pandas.core.dtypes.common import is_bool_dtype
+
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.sorting import nargsort
-import pandas.util.testing as tm
 
 from .base import BaseExtensionTests
 
@@ -113,29 +117,29 @@ def test_unique(self, data, box, method):
 
     @pytest.mark.parametrize("na_sentinel", [-1, -2])
     def test_factorize(self, data_for_grouping, na_sentinel):
-        labels, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
-        expected_labels = np.array(
+        codes, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
+        expected_codes = np.array(
             [0, 0, na_sentinel, na_sentinel, 1, 1, 0, 2], dtype=np.intp
         )
         expected_uniques = data_for_grouping.take([0, 4, 7])
 
-        tm.assert_numpy_array_equal(labels, expected_labels)
+        tm.assert_numpy_array_equal(codes, expected_codes)
         self.assert_extension_array_equal(uniques, expected_uniques)
 
     @pytest.mark.parametrize("na_sentinel", [-1, -2])
     def test_factorize_equivalence(self, data_for_grouping, na_sentinel):
-        l1, u1 = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
-        l2, u2 = data_for_grouping.factorize(na_sentinel=na_sentinel)
+        codes_1, uniques_1 = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
+        codes_2, uniques_2 = data_for_grouping.factorize(na_sentinel=na_sentinel)
 
-        tm.assert_numpy_array_equal(l1, l2)
-        self.assert_extension_array_equal(u1, u2)
+        tm.assert_numpy_array_equal(codes_1, codes_2)
+        self.assert_extension_array_equal(uniques_1, uniques_2)
 
     def test_factorize_empty(self, data):
-        labels, uniques = pd.factorize(data[:0])
-        expected_labels = np.array([], dtype=np.intp)
+        codes, uniques = pd.factorize(data[:0])
+        expected_codes = np.array([], dtype=np.intp)
         expected_uniques = type(data)._from_sequence([], dtype=data[:0].dtype)
 
-        tm.assert_numpy_array_equal(labels, expected_labels)
+        tm.assert_numpy_array_equal(codes, expected_codes)
         self.assert_extension_array_equal(uniques, expected_uniques)
 
     def test_fillna_copy_frame(self, data_missing):
@@ -231,6 +235,32 @@ def test_container_shift(self, data, frame, periods, indices):
 
         compare(result, expected)
 
+    @pytest.mark.parametrize("periods", [1, -2])
+    def test_diff(self, data, periods):
+        data = data[:5]
+        if is_bool_dtype(data.dtype):
+            op = operator.xor
+        else:
+            op = operator.sub
+        try:
+            # does this array implement ops?
+            op(data, data)
+        except Exception:
+            pytest.skip(f"{type(data)} does not support diff")
+        s = pd.Series(data)
+        result = s.diff(periods)
+        expected = pd.Series(op(data, data.shift(periods)))
+        self.assert_series_equal(result, expected)
+
+        df = pd.DataFrame({"A": data, "B": [1.0] * 5})
+        result = df.diff(periods)
+        if periods == 1:
+            b = [np.nan, 0, 0, 0, 0]
+        else:
+            b = [0, 0, 0, np.nan, np.nan]
+        expected = pd.DataFrame({"A": expected, "B": b})
+        self.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize(
         "periods, indices",
         [[-4, [-1, -1]], [-1, [1, -1]], [0, [0, 1]], [1, [-1, 0]], [4, [-1, -1]]],
@@ -250,6 +280,13 @@ def test_shift_empty_array(self, data, periods):
         expected = empty
         self.assert_extension_array_equal(result, expected)
 
+    def test_shift_zero_copies(self, data):
+        result = data.shift(0)
+        assert result is not data
+
+        result = data[:0].shift(2)
+        assert result is not data
+
     def test_shift_fill_value(self, data):
         arr = data[:4]
         fill_value = data[0]
@@ -261,6 +298,11 @@ def test_shift_fill_value(self, data):
         expected = data.take([2, 3, 0, 0])
         self.assert_extension_array_equal(result, expected)
 
+    def test_not_hashable(self, data):
+        # We are in general mutable, so not hashable
+        with pytest.raises(TypeError, match="unhashable type"):
+            hash(data)
+
     def test_hash_pandas_object_works(self, data, as_frame):
         # https://github.com/pandas-dev/pandas/issues/23066
         data = pd.Series(data)
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index 21bbb365ab0f3..2393d2edcd2c6 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from .base import BaseExtensionTests
 
diff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py
index e35464964f432..0609f19c8e0c3 100644
--- a/pandas/tests/extension/base/ops.py
+++ b/pandas/tests/extension/base/ops.py
@@ -1,4 +1,5 @@
 import operator
+from typing import Optional, Type
 
 import pytest
 
@@ -61,10 +62,10 @@ class BaseArithmeticOpsTests(BaseOpsUtil):
     * divmod_exc = TypeError
     """
 
-    series_scalar_exc = TypeError
-    frame_scalar_exc = TypeError
-    series_array_exc = TypeError
-    divmod_exc = TypeError
+    series_scalar_exc: Optional[Type[TypeError]] = TypeError
+    frame_scalar_exc: Optional[Type[TypeError]] = TypeError
+    series_array_exc: Optional[Type[TypeError]] = TypeError
+    divmod_exc: Optional[Type[TypeError]] = TypeError
 
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
         # series & scalar
@@ -122,9 +123,7 @@ def test_direct_arith_with_series_returns_not_implemented(self, data):
             result = data.__add__(other)
             assert result is NotImplemented
         else:
-            raise pytest.skip(
-                "{} does not implement add".format(data.__class__.__name__)
-            )
+            raise pytest.skip(f"{type(data).__name__} does not implement add")
 
 
 class BaseComparisonOpsTests(BaseOpsUtil):
@@ -168,6 +167,12 @@ def test_direct_arith_with_series_returns_not_implemented(self, data):
             result = data.__eq__(other)
             assert result is NotImplemented
         else:
-            raise pytest.skip(
-                "{} does not implement __eq__".format(data.__class__.__name__)
-            )
+            raise pytest.skip(f"{type(data).__name__} does not implement __eq__")
+
+
+class BaseUnaryOpsTests(BaseOpsUtil):
+    def test_invert(self, data):
+        s = pd.Series(data, name="name")
+        result = ~s
+        expected = pd.Series(~data, name="name")
+        self.assert_series_equal(result, expected)
diff --git a/pandas/tests/extension/base/printing.py b/pandas/tests/extension/base/printing.py
index 0f10efbf32a49..ad34a83c7cf71 100644
--- a/pandas/tests/extension/base/printing.py
+++ b/pandas/tests/extension/base/printing.py
@@ -18,8 +18,8 @@ def test_array_repr(self, data, size):
             data = type(data)._concat_same_type([data] * 5)
 
         result = repr(data)
-        assert data.__class__.__name__ in result
-        assert "Length: {}".format(len(data)) in result
+        assert type(data).__name__ in result
+        assert f"Length: {len(data)}" in result
         assert str(data.dtype) in result
         if size == "big":
             assert "..." in result
diff --git a/pandas/tests/extension/base/reduce.py b/pandas/tests/extension/base/reduce.py
index 8766bb771f8a2..6f433d659575a 100644
--- a/pandas/tests/extension/base/reduce.py
+++ b/pandas/tests/extension/base/reduce.py
@@ -3,7 +3,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from .base import BaseExtensionTests
 
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index 90e607343297d..ec21898852888 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -94,6 +94,19 @@ def test_concat_columns(self, data, na_value):
         result = pd.concat([df1["A"], df2["B"]], axis=1)
         self.assert_frame_equal(result, expected)
 
+    def test_concat_extension_arrays_copy_false(self, data, na_value):
+        # GH 20756
+        df1 = pd.DataFrame({"A": data[:3]})
+        df2 = pd.DataFrame({"B": data[3:7]})
+        expected = pd.DataFrame(
+            {
+                "A": data._from_sequence(list(data[:3]) + [na_value], dtype=data.dtype),
+                "B": data[3:7],
+            }
+        )
+        result = pd.concat([df1, df2], axis=1, copy=False)
+        self.assert_frame_equal(result, expected)
+
     def test_align(self, data, na_value):
         a = data[:3]
         b = data[2:5]
@@ -295,3 +308,19 @@ def test_ravel(self, data):
         # Check that we have a view, not a copy
         result[0] = result[1]
         assert data[0] == data[1]
+
+    def test_transpose(self, data):
+        df = pd.DataFrame({"A": data[:4], "B": data[:4]}, index=["a", "b", "c", "d"])
+        result = df.T
+        expected = pd.DataFrame(
+            {
+                "a": type(data)._from_sequence([data[0]] * 2, dtype=data.dtype),
+                "b": type(data)._from_sequence([data[1]] * 2, dtype=data.dtype),
+                "c": type(data)._from_sequence([data[2]] * 2, dtype=data.dtype),
+                "d": type(data)._from_sequence([data[3]] * 2, dtype=data.dtype),
+            },
+            index=["A", "B"],
+        )
+        self.assert_frame_equal(result, expected)
+        self.assert_frame_equal(np.transpose(np.transpose(df)), df)
+        self.assert_frame_equal(np.transpose(np.transpose(df[["A"]])), df[["A"]])
diff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py
index bb6bb02b462e2..e0ca603aaa0ed 100644
--- a/pandas/tests/extension/base/setitem.py
+++ b/pandas/tests/extension/base/setitem.py
@@ -4,6 +4,7 @@
 import pytest
 
 import pandas as pd
+from pandas.core.arrays.numpy_ import PandasDtype
 
 from .base import BaseExtensionTests
 
@@ -186,3 +187,23 @@ def test_setitem_scalar_key_sequence_raise(self, data):
         arr = data[:5].copy()
         with pytest.raises(ValueError):
             arr[0] = arr[[0, 1]]
+
+    def test_setitem_preserves_views(self, data):
+        # GH#28150 setitem shouldn't swap the underlying data
+        view1 = data.view()
+        view2 = data[:]
+
+        data[0] = data[1]
+        assert view1[0] == data[1]
+        assert view2[0] == data[1]
+
+    def test_setitem_nullable_mask(self, data):
+        # GH 31446
+        # TODO: there is some issue with PandasArray, therefore,
+        # TODO: skip the setitem test for now, and fix it later
+        if data.dtype != PandasDtype("object"):
+            arr = data[:5]
+            expected = data.take([0, 0, 0, 3, 4])
+            mask = pd.array([True, True, True, False, False])
+            arr[mask] = data[0]
+            self.assert_extension_array_equal(expected, arr)
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index a1988744d76a1..2614d8c72c342 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -2,14 +2,16 @@
 import numbers
 import random
 import sys
+from typing import Type
 
 import numpy as np
 
 from pandas.core.dtypes.base import ExtensionDtype
 
 import pandas as pd
-from pandas.api.extensions import register_extension_dtype
+from pandas.api.extensions import no_default, register_extension_dtype
 from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin
+from pandas.core.indexers import check_array_indexer
 
 
 @register_extension_dtype
@@ -22,12 +24,13 @@ class DecimalDtype(ExtensionDtype):
     def __init__(self, context=None):
         self.context = context or decimal.getcontext()
 
-    def __repr__(self):
-        return "DecimalDtype(context={})".format(self.context)
+    def __repr__(self) -> str:
+        return f"DecimalDtype(context={self.context})"
 
     @classmethod
-    def construct_array_type(cls):
-        """Return the array type associated with this dtype
+    def construct_array_type(cls) -> Type["DecimalArray"]:
+        """
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -35,15 +38,8 @@ def construct_array_type(cls):
         """
         return DecimalArray
 
-    @classmethod
-    def construct_from_string(cls, string):
-        if string == cls.name:
-            return cls()
-        else:
-            raise TypeError("Cannot construct a '{}' from '{}'".format(cls, string))
-
     @property
-    def _is_numeric(self):
+    def _is_numeric(self) -> bool:
         return True
 
 
@@ -83,6 +79,12 @@ def _from_factorized(cls, values, original):
 
     _HANDLED_TYPES = (decimal.Decimal, numbers.Number, np.ndarray)
 
+    def to_numpy(self, dtype=None, copy=False, na_value=no_default, decimals=None):
+        result = np.asarray(self, dtype=dtype)
+        if decimals is not None:
+            result = np.asarray([round(x, decimals) for x in result])
+        return result
+
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         #
         if not all(
@@ -108,6 +110,8 @@ def __getitem__(self, item):
         if isinstance(item, numbers.Integral):
             return self._data[item]
         else:
+            # array, slice.
+            item = pd.api.indexers.check_array_indexer(self, item)
             return type(self)(self._data[item])
 
     def take(self, indexer, allow_fill=False, fill_value=None):
@@ -135,6 +139,8 @@ def __setitem__(self, key, value):
             value = [decimal.Decimal(v) for v in value]
         else:
             value = decimal.Decimal(value)
+
+        key = check_array_indexer(self, key)
         self._data[key] = value
 
     def __len__(self) -> int:
@@ -166,14 +172,19 @@ def _concat_same_type(cls, to_concat):
     def _reduce(self, name, skipna=True, **kwargs):
 
         if skipna:
-            raise NotImplementedError("decimal does not support skipna=True")
+            # If we don't have any NAs, we can ignore skipna
+            if self.isna().any():
+                other = self[~self.isna()]
+                return other._reduce(name, **kwargs)
+
+        if name == "sum" and len(self) == 0:
+            # GH#29630 avoid returning int 0 or np.bool_(False) on old numpy
+            return decimal.Decimal(0)
 
         try:
             op = getattr(self.data, name)
         except AttributeError:
-            raise NotImplementedError(
-                "decimal does not support the {} operation".format(name)
-            )
+            raise NotImplementedError(f"decimal does not support the {name} operation")
         return op(axis=0)
 
 
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index 3ac9d37ccf4f3..bd9b77a2bc419 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -6,8 +6,8 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.tests.extension import base
-import pandas.util.testing as tm
 
 from .array import DecimalArray, DecimalDtype, make_data, to_decimal
 
@@ -66,7 +66,8 @@ def data_for_grouping():
 
 
 class BaseDecimal:
-    def assert_series_equal(self, left, right, *args, **kwargs):
+    @classmethod
+    def assert_series_equal(cls, left, right, *args, **kwargs):
         def convert(x):
             # need to convert array([Decimal(NaN)], dtype='object') to np.NaN
             # because Series[object].isnan doesn't recognize decimal(NaN) as
@@ -88,7 +89,8 @@ def convert(x):
         tm.assert_series_equal(left_na, right_na)
         return tm.assert_series_equal(left[~left_na], right[~right_na], *args, **kwargs)
 
-    def assert_frame_equal(self, left, right, *args, **kwargs):
+    @classmethod
+    def assert_frame_equal(cls, left, right, *args, **kwargs):
         # TODO(EA): select_dtypes
         tm.assert_index_equal(
             left.columns,
@@ -103,7 +105,7 @@ def assert_frame_equal(self, left, right, *args, **kwargs):
         decimals = (left.dtypes == "decimal").index
 
         for col in decimals:
-            self.assert_series_equal(left[col], right[col], *args, **kwargs)
+            cls.assert_series_equal(left[col], right[col], *args, **kwargs)
 
         left = left.drop(columns=decimals)
         right = right.drop(columns=decimals)
@@ -145,7 +147,7 @@ class TestMissing(BaseDecimal, base.BaseMissingTests):
 class Reduce:
     def check_reduce(self, s, op_name, skipna):
 
-        if skipna or op_name in ["median", "skew", "kurt"]:
+        if op_name in ["median", "skew", "kurt"]:
             with pytest.raises(NotImplementedError):
                 getattr(s, op_name)(skipna=skipna)
 
@@ -426,3 +428,90 @@ def test_array_ufunc_series_defer():
 
     tm.assert_series_equal(r1, expected)
     tm.assert_series_equal(r2, expected)
+
+
+def test_groupby_agg():
+    # Ensure that the result of agg is inferred to be decimal dtype
+    # https://github.com/pandas-dev/pandas/issues/29141
+
+    data = make_data()[:5]
+    df = pd.DataFrame(
+        {"id1": [0, 0, 0, 1, 1], "id2": [0, 1, 0, 1, 1], "decimals": DecimalArray(data)}
+    )
+
+    # single key, selected column
+    expected = pd.Series(to_decimal([data[0], data[3]]))
+    result = df.groupby("id1")["decimals"].agg(lambda x: x.iloc[0])
+    tm.assert_series_equal(result, expected, check_names=False)
+    result = df["decimals"].groupby(df["id1"]).agg(lambda x: x.iloc[0])
+    tm.assert_series_equal(result, expected, check_names=False)
+
+    # multiple keys, selected column
+    expected = pd.Series(
+        to_decimal([data[0], data[1], data[3]]),
+        index=pd.MultiIndex.from_tuples([(0, 0), (0, 1), (1, 1)]),
+    )
+    result = df.groupby(["id1", "id2"])["decimals"].agg(lambda x: x.iloc[0])
+    tm.assert_series_equal(result, expected, check_names=False)
+    result = df["decimals"].groupby([df["id1"], df["id2"]]).agg(lambda x: x.iloc[0])
+    tm.assert_series_equal(result, expected, check_names=False)
+
+    # multiple columns
+    expected = pd.DataFrame({"id2": [0, 1], "decimals": to_decimal([data[0], data[3]])})
+    result = df.groupby("id1").agg(lambda x: x.iloc[0])
+    tm.assert_frame_equal(result, expected, check_names=False)
+
+
+def test_groupby_agg_ea_method(monkeypatch):
+    # Ensure that the result of agg is inferred to be decimal dtype
+    # https://github.com/pandas-dev/pandas/issues/29141
+
+    def DecimalArray__my_sum(self):
+        return np.sum(np.array(self))
+
+    monkeypatch.setattr(DecimalArray, "my_sum", DecimalArray__my_sum, raising=False)
+
+    data = make_data()[:5]
+    df = pd.DataFrame({"id": [0, 0, 0, 1, 1], "decimals": DecimalArray(data)})
+    expected = pd.Series(to_decimal([data[0] + data[1] + data[2], data[3] + data[4]]))
+
+    result = df.groupby("id")["decimals"].agg(lambda x: x.values.my_sum())
+    tm.assert_series_equal(result, expected, check_names=False)
+    s = pd.Series(DecimalArray(data))
+    result = s.groupby(np.array([0, 0, 0, 1, 1])).agg(lambda x: x.values.my_sum())
+    tm.assert_series_equal(result, expected, check_names=False)
+
+
+def test_indexing_no_materialize(monkeypatch):
+    # See https://github.com/pandas-dev/pandas/issues/29708
+    # Ensure that indexing operations do not materialize (convert to a numpy
+    # array) the ExtensionArray unnecessary
+
+    def DecimalArray__array__(self, dtype=None):
+        raise Exception("tried to convert a DecimalArray to a numpy array")
+
+    monkeypatch.setattr(DecimalArray, "__array__", DecimalArray__array__, raising=False)
+
+    data = make_data()
+    s = pd.Series(DecimalArray(data))
+    df = pd.DataFrame({"a": s, "b": range(len(s))})
+
+    # ensure the following operations do not raise an error
+    s[s > 0.5]
+    df[s > 0.5]
+    s.at[0]
+    df.at[0, "a"]
+
+
+def test_to_numpy_keyword():
+    # test the extra keyword
+    values = [decimal.Decimal("1.1111"), decimal.Decimal("2.2222")]
+    expected = np.array(
+        [decimal.Decimal("1.11"), decimal.Decimal("2.22")], dtype="object"
+    )
+    a = pd.array(values, dtype="decimal")
+    result = a.to_numpy(decimals=2)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = pd.Series(a).to_numpy(decimals=2)
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py
index b64ddbd6ac84d..1ba1b872fa5e2 100644
--- a/pandas/tests/extension/json/array.py
+++ b/pandas/tests/extension/json/array.py
@@ -16,22 +16,23 @@
 import random
 import string
 import sys
+from typing import Any, Mapping, Type
 
 import numpy as np
 
-from pandas.core.dtypes.base import ExtensionDtype
-
-from pandas.core.arrays import ExtensionArray
+import pandas as pd
+from pandas.api.extensions import ExtensionArray, ExtensionDtype
 
 
 class JSONDtype(ExtensionDtype):
     type = abc.Mapping
     name = "json"
-    na_value = UserDict()
+    na_value: Mapping[str, Any] = UserDict()
 
     @classmethod
-    def construct_array_type(cls):
-        """Return the array type associated with this dtype
+    def construct_array_type(cls) -> Type["JSONArray"]:
+        """
+        Return the array type associated with this dtype.
 
         Returns
         -------
@@ -39,13 +40,6 @@ def construct_array_type(cls):
         """
         return JSONArray
 
-    @classmethod
-    def construct_from_string(cls, string):
-        if string == cls.name:
-            return cls()
-        else:
-            raise TypeError("Cannot construct a '{}' from '{}'".format(cls, string))
-
 
 class JSONArray(ExtensionArray):
     dtype = JSONDtype()
@@ -75,17 +69,18 @@ def _from_factorized(cls, values, original):
     def __getitem__(self, item):
         if isinstance(item, numbers.Integral):
             return self.data[item]
-        elif isinstance(item, np.ndarray) and item.dtype == "bool":
-            return self._from_sequence([x for x, m in zip(self, item) if m])
-        elif isinstance(item, abc.Iterable):
-            # fancy indexing
-            return type(self)([self.data[i] for i in item])
         elif isinstance(item, slice) and item == slice(None):
             # Make sure we get a view
             return type(self)(self.data)
-        else:
+        elif isinstance(item, slice):
             # slice
             return type(self)(self.data[item])
+        else:
+            item = pd.api.indexers.check_array_indexer(self, item)
+            if pd.api.types.is_bool_dtype(item.dtype):
+                return self._from_sequence([x for x, m in zip(self, item) if m])
+            # integer
+            return type(self)([self.data[i] for i in item])
 
     def __setitem__(self, key, value):
         if isinstance(key, numbers.Integral):
@@ -109,6 +104,11 @@ def __setitem__(self, key, value):
     def __len__(self) -> int:
         return len(self.data)
 
+    def __array__(self, dtype=None):
+        if dtype is None:
+            dtype = object
+        return np.asarray(self.data, dtype=dtype)
+
     @property
     def nbytes(self) -> int:
         return sys.getsizeof(self.data)
@@ -182,7 +182,7 @@ def _values_for_factorize(self):
 
     def _values_for_argsort(self):
         # Disable NumPy's shape inference by including an empty tuple...
-        # If all the elemnts of self are the same size P, NumPy will
+        # If all the elements of self are the same size P, NumPy will
         # cast them to an (N, P) array, instead of an (N,) array of tuples.
         frozen = [()] + [tuple(x.items()) for x in self]
         return np.array(frozen, dtype=object)[1:]
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index bc75ec6aeb2df..f7ca99be2adea 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -3,11 +3,9 @@
 
 import pytest
 
-from pandas.compat import PY36
-
 import pandas as pd
+import pandas._testing as tm
 from pandas.tests.extension import base
-import pandas.util.testing as tm
 
 from .array import JSONArray, JSONDtype, make_data
 
@@ -81,7 +79,8 @@ class BaseJSON:
     # The default assert_series_equal eventually does a
     # Series.values, which raises. We work around it by
     # converting the UserDicts to dicts.
-    def assert_series_equal(self, left, right, **kwargs):
+    @classmethod
+    def assert_series_equal(cls, left, right, *args, **kwargs):
         if left.dtype.name == "json":
             assert left.dtype == right.dtype
             left = pd.Series(
@@ -92,9 +91,11 @@ def assert_series_equal(self, left, right, **kwargs):
                 index=right.index,
                 name=right.name,
             )
-        tm.assert_series_equal(left, right, **kwargs)
+        tm.assert_series_equal(left, right, *args, **kwargs)
 
-    def assert_frame_equal(self, left, right, *args, **kwargs):
+    @classmethod
+    def assert_frame_equal(cls, left, right, *args, **kwargs):
+        obj_type = kwargs.get("obj", "DataFrame")
         tm.assert_index_equal(
             left.columns,
             right.columns,
@@ -102,13 +103,13 @@ def assert_frame_equal(self, left, right, *args, **kwargs):
             check_names=kwargs.get("check_names", True),
             check_exact=kwargs.get("check_exact", False),
             check_categorical=kwargs.get("check_categorical", True),
-            obj="{obj}.columns".format(obj=kwargs.get("obj", "DataFrame")),
+            obj=f"{obj_type}.columns",
         )
 
         jsons = (left.dtypes == "json").index
 
         for col in jsons:
-            self.assert_series_equal(left[col], right[col], *args, **kwargs)
+            cls.assert_series_equal(left[col], right[col], *args, **kwargs)
 
         left = left.drop(columns=jsons)
         right = right.drop(columns=jsons)
@@ -180,9 +181,6 @@ def test_fillna_frame(self):
 
 
 unhashable = pytest.mark.skip(reason="Unhashable")
-unstable = pytest.mark.skipif(
-    not PY36, reason="Dictionary order unstable"  # 3.6 or higher
-)
 
 
 class TestReduce(base.BaseNoReduceTests):
@@ -199,20 +197,16 @@ def test_sort_values_frame(self):
         # TODO (EA.factorize): see if _values_for_factorize allows this.
         pass
 
-    @unstable
     def test_argsort(self, data_for_sorting):
         super().test_argsort(data_for_sorting)
 
-    @unstable
     def test_argsort_missing(self, data_missing_for_sorting):
         super().test_argsort_missing(data_missing_for_sorting)
 
-    @unstable
     @pytest.mark.parametrize("ascending", [True, False])
     def test_sort_values(self, data_for_sorting, ascending):
         super().test_sort_values(data_for_sorting, ascending)
 
-    @unstable
     @pytest.mark.parametrize("ascending", [True, False])
     def test_sort_values_missing(self, data_missing_for_sorting, ascending):
         super().test_sort_values_missing(data_missing_for_sorting, ascending)
@@ -280,7 +274,6 @@ def test_groupby_extension_apply(self):
         we'll be able to dispatch unique.
         """
 
-    @unstable
     @pytest.mark.parametrize("as_index", [True, False])
     def test_groupby_extension_agg(self, as_index, data_for_grouping):
         super().test_groupby_extension_agg(as_index, data_for_grouping)
diff --git a/pandas/tests/extension/list/__init__.py b/pandas/tests/extension/list/__init__.py
new file mode 100644
index 0000000000000..108f1937d07d3
--- /dev/null
+++ b/pandas/tests/extension/list/__init__.py
@@ -0,0 +1,3 @@
+from .array import ListArray, ListDtype, make_data
+
+__all__ = ["ListArray", "ListDtype", "make_data"]
diff --git a/pandas/tests/extension/list/array.py b/pandas/tests/extension/list/array.py
new file mode 100644
index 0000000000000..7c1da5e8102e2
--- /dev/null
+++ b/pandas/tests/extension/list/array.py
@@ -0,0 +1,127 @@
+"""
+Test extension array for storing nested data in a pandas container.
+
+The ListArray stores an ndarray of lists.
+"""
+import numbers
+import random
+import string
+from typing import Type
+
+import numpy as np
+
+from pandas.core.dtypes.base import ExtensionDtype
+
+import pandas as pd
+from pandas.core.arrays import ExtensionArray
+
+
+class ListDtype(ExtensionDtype):
+    type = list
+    name = "list"
+    na_value = np.nan
+
+    @classmethod
+    def construct_array_type(cls) -> Type["ListArray"]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return ListArray
+
+
+class ListArray(ExtensionArray):
+    dtype = ListDtype()
+    __array_priority__ = 1000
+
+    def __init__(self, values, dtype=None, copy=False):
+        if not isinstance(values, np.ndarray):
+            raise TypeError("Need to pass a numpy array as values")
+        for val in values:
+            if not isinstance(val, self.dtype.type) and not pd.isna(val):
+                raise TypeError("All values must be of type " + str(self.dtype.type))
+        self.data = values
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        data = np.empty(len(scalars), dtype=object)
+        data[:] = scalars
+        return cls(data)
+
+    def __getitem__(self, item):
+        if isinstance(item, numbers.Integral):
+            return self.data[item]
+        else:
+            # slice, list-like, mask
+            return type(self)(self.data[item])
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def isna(self):
+        return np.array(
+            [not isinstance(x, list) and np.isnan(x) for x in self.data], dtype=bool
+        )
+
+    def take(self, indexer, allow_fill=False, fill_value=None):
+        # re-implement here, since NumPy has trouble setting
+        # sized objects like UserDicts into scalar slots of
+        # an ndarary.
+        indexer = np.asarray(indexer)
+        msg = (
+            "Index is out of bounds or cannot do a "
+            "non-empty take from an empty array."
+        )
+
+        if allow_fill:
+            if fill_value is None:
+                fill_value = self.dtype.na_value
+            # bounds check
+            if (indexer < -1).any():
+                raise ValueError
+            try:
+                output = [
+                    self.data[loc] if loc != -1 else fill_value for loc in indexer
+                ]
+            except IndexError:
+                raise IndexError(msg)
+        else:
+            try:
+                output = [self.data[loc] for loc in indexer]
+            except IndexError:
+                raise IndexError(msg)
+
+        return self._from_sequence(output)
+
+    def copy(self):
+        return type(self)(self.data[:])
+
+    def astype(self, dtype, copy=True):
+        if isinstance(dtype, type(self.dtype)) and dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        elif pd.api.types.is_string_dtype(dtype) and not pd.api.types.is_object_dtype(
+            dtype
+        ):
+            # numpy has problems with astype(str) for nested elements
+            return np.array([str(x) for x in self.data], dtype=dtype)
+        return np.array(self.data, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat):
+        data = np.concatenate([x.data for x in to_concat])
+        return cls(data)
+
+
+def make_data():
+    # TODO: Use a regular dict. See _NDFrameIndexer._setitem_with_indexer
+    data = np.empty(100, dtype=object)
+    data[:] = [
+        [random.choice(string.ascii_letters) for _ in range(random.randint(0, 10))]
+        for _ in range(100)
+    ]
+    return data
diff --git a/pandas/tests/extension/list/test_list.py b/pandas/tests/extension/list/test_list.py
new file mode 100644
index 0000000000000..c5c4417155562
--- /dev/null
+++ b/pandas/tests/extension/list/test_list.py
@@ -0,0 +1,30 @@
+import pytest
+
+import pandas as pd
+
+from .array import ListArray, ListDtype, make_data
+
+
+@pytest.fixture
+def dtype():
+    return ListDtype()
+
+
+@pytest.fixture
+def data():
+    """Length-100 ListArray for semantics test."""
+    data = make_data()
+
+    while len(data[0]) == len(data[1]):
+        data = make_data()
+
+    return ListArray(data)
+
+
+def test_to_csv(data):
+    # https://github.com/pandas-dev/pandas/issues/28840
+    # array with list-likes fail when doing astype(str) on the numpy array
+    # which was done in to_native_types
+    df = pd.DataFrame({"a": data})
+    res = df.to_csv()
+    assert str(data[0]) in res
diff --git a/pandas/tests/extension/test_boolean.py b/pandas/tests/extension/test_boolean.py
new file mode 100644
index 0000000000000..0c6b187eac1fc
--- /dev/null
+++ b/pandas/tests/extension/test_boolean.py
@@ -0,0 +1,351 @@
+"""
+This file contains a minimal set of tests for compliance with the extension
+array interface test suite, and should contain no other tests.
+The test suite for the full functionality of the array is located in
+`pandas/tests/arrays/`.
+
+The tests in this file are inherited from the BaseExtensionTests, and only
+minimal tweaks should be applied to get the tests passing (by overwriting a
+parent method).
+
+Additional tests should either be added to one of the BaseExtensionTests
+classes (if they are relevant for the extension interface for all dtypes), or
+be added to the array-specific tests in `pandas/tests/arrays/`.
+
+"""
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import _np_version_under1p14
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays.boolean import BooleanDtype
+from pandas.tests.extension import base
+
+
+def make_data():
+    return [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False]
+
+
+@pytest.fixture
+def dtype():
+    return BooleanDtype()
+
+
+@pytest.fixture
+def data(dtype):
+    return pd.array(make_data(), dtype=dtype)
+
+
+@pytest.fixture
+def data_for_twos(dtype):
+    return pd.array(np.ones(100), dtype=dtype)
+
+
+@pytest.fixture
+def data_missing(dtype):
+    return pd.array([np.nan, True], dtype=dtype)
+
+
+@pytest.fixture
+def data_for_sorting(dtype):
+    return pd.array([True, True, False], dtype=dtype)
+
+
+@pytest.fixture
+def data_missing_for_sorting(dtype):
+    return pd.array([True, np.nan, False], dtype=dtype)
+
+
+@pytest.fixture
+def na_cmp():
+    # we are pd.NA
+    return lambda x, y: x is pd.NA and y is pd.NA
+
+
+@pytest.fixture
+def na_value():
+    return pd.NA
+
+
+@pytest.fixture
+def data_for_grouping(dtype):
+    b = True
+    a = False
+    na = np.nan
+    return pd.array([b, b, na, na, a, a, b], dtype=dtype)
+
+
+class TestDtype(base.BaseDtypeTests):
+    pass
+
+
+class TestInterface(base.BaseInterfaceTests):
+    pass
+
+
+class TestConstructors(base.BaseConstructorsTests):
+    pass
+
+
+class TestGetitem(base.BaseGetitemTests):
+    pass
+
+
+class TestSetitem(base.BaseSetitemTests):
+    pass
+
+
+class TestMissing(base.BaseMissingTests):
+    pass
+
+
+class TestArithmeticOps(base.BaseArithmeticOpsTests):
+    def check_opname(self, s, op_name, other, exc=None):
+        # overwriting to indicate ops don't raise an error
+        super().check_opname(s, op_name, other, exc=None)
+
+    def _check_op(self, s, op, other, op_name, exc=NotImplementedError):
+        if exc is None:
+            if op_name in ("__sub__", "__rsub__"):
+                # subtraction for bools raises TypeError (but not yet in 1.13)
+                if _np_version_under1p14:
+                    pytest.skip("__sub__ does not yet raise in numpy 1.13")
+                with pytest.raises(TypeError):
+                    op(s, other)
+
+                return
+
+            result = op(s, other)
+            expected = s.combine(other, op)
+
+            if op_name in (
+                "__floordiv__",
+                "__rfloordiv__",
+                "__pow__",
+                "__rpow__",
+                "__mod__",
+                "__rmod__",
+            ):
+                # combine keeps boolean type
+                expected = expected.astype("Int8")
+            elif op_name in ("__truediv__", "__rtruediv__"):
+                # combine with bools does not generate the correct result
+                #  (numpy behaviour for div is to regard the bools as numeric)
+                expected = s.astype(float).combine(other, op)
+            if op_name == "__rpow__":
+                # for rpow, combine does not propagate NaN
+                expected[result.isna()] = np.nan
+            self.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(exc):
+                op(s, other)
+
+    def _check_divmod_op(self, s, op, other, exc=None):
+        # override to not raise an error
+        super()._check_divmod_op(s, op, other, None)
+
+    @pytest.mark.skip(reason="BooleanArray does not error on ops")
+    def test_error(self, data, all_arithmetic_operators):
+        # other specific errors tested in the boolean array specific tests
+        pass
+
+
+class TestComparisonOps(base.BaseComparisonOpsTests):
+    def check_opname(self, s, op_name, other, exc=None):
+        # overwriting to indicate ops don't raise an error
+        super().check_opname(s, op_name, other, exc=None)
+
+    def _compare_other(self, s, data, op_name, other):
+        self.check_opname(s, op_name, other)
+
+    @pytest.mark.skip(reason="Tested in tests/arrays/test_boolean.py")
+    def test_compare_scalar(self, data, all_compare_operators):
+        pass
+
+    @pytest.mark.skip(reason="Tested in tests/arrays/test_boolean.py")
+    def test_compare_array(self, data, all_compare_operators):
+        pass
+
+
+class TestReshaping(base.BaseReshapingTests):
+    pass
+
+
+class TestMethods(base.BaseMethodsTests):
+    @pytest.mark.parametrize("na_sentinel", [-1, -2])
+    def test_factorize(self, data_for_grouping, na_sentinel):
+        # override because we only have 2 unique values
+        labels, uniques = pd.factorize(data_for_grouping, na_sentinel=na_sentinel)
+        expected_labels = np.array(
+            [0, 0, na_sentinel, na_sentinel, 1, 1, 0], dtype=np.intp
+        )
+        expected_uniques = data_for_grouping.take([0, 4])
+
+        tm.assert_numpy_array_equal(labels, expected_labels)
+        self.assert_extension_array_equal(uniques, expected_uniques)
+
+    def test_combine_le(self, data_repeated):
+        # override because expected needs to be boolean instead of bool dtype
+        orig_data1, orig_data2 = data_repeated(2)
+        s1 = pd.Series(orig_data1)
+        s2 = pd.Series(orig_data2)
+        result = s1.combine(s2, lambda x1, x2: x1 <= x2)
+        expected = pd.Series(
+            [a <= b for (a, b) in zip(list(orig_data1), list(orig_data2))],
+            dtype="boolean",
+        )
+        self.assert_series_equal(result, expected)
+
+        val = s1.iloc[0]
+        result = s1.combine(val, lambda x1, x2: x1 <= x2)
+        expected = pd.Series([a <= val for a in list(orig_data1)], dtype="boolean")
+        self.assert_series_equal(result, expected)
+
+    def test_searchsorted(self, data_for_sorting, as_series):
+        # override because we only have 2 unique values
+        data_for_sorting = pd.array([True, False], dtype="boolean")
+        b, a = data_for_sorting
+        arr = type(data_for_sorting)._from_sequence([a, b])
+
+        if as_series:
+            arr = pd.Series(arr)
+        assert arr.searchsorted(a) == 0
+        assert arr.searchsorted(a, side="right") == 1
+
+        assert arr.searchsorted(b) == 1
+        assert arr.searchsorted(b, side="right") == 2
+
+        result = arr.searchsorted(arr.take([0, 1]))
+        expected = np.array([0, 1], dtype=np.intp)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+        # sorter
+        sorter = np.array([1, 0])
+        assert data_for_sorting.searchsorted(a, sorter=sorter) == 0
+
+    @pytest.mark.skip(reason="uses nullable integer")
+    def test_value_counts(self, all_data, dropna):
+        return super().test_value_counts(all_data, dropna)
+
+
+class TestCasting(base.BaseCastingTests):
+    pass
+
+
+class TestGroupby(base.BaseGroupbyTests):
+    """
+    Groupby-specific tests are overridden because boolean only has 2
+    unique values, base tests uses 3 groups.
+    """
+
+    def test_grouping_grouper(self, data_for_grouping):
+        df = pd.DataFrame(
+            {"A": ["B", "B", None, None, "A", "A", "B"], "B": data_for_grouping}
+        )
+        gr1 = df.groupby("A").grouper.groupings[0]
+        gr2 = df.groupby("B").grouper.groupings[0]
+
+        tm.assert_numpy_array_equal(gr1.grouper, df.A.values)
+        tm.assert_extension_array_equal(gr2.grouper, data_for_grouping)
+
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_groupby_extension_agg(self, as_index, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
+        result = df.groupby("B", as_index=as_index).A.mean()
+        _, index = pd.factorize(data_for_grouping, sort=True)
+
+        index = pd.Index(index, name="B")
+        expected = pd.Series([3, 1], index=index, name="A")
+        if as_index:
+            self.assert_series_equal(result, expected)
+        else:
+            expected = expected.reset_index()
+            self.assert_frame_equal(result, expected)
+
+    def test_groupby_extension_no_sort(self, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
+        result = df.groupby("B", sort=False).A.mean()
+        _, index = pd.factorize(data_for_grouping, sort=False)
+
+        index = pd.Index(index, name="B")
+        expected = pd.Series([1, 3], index=index, name="A")
+        self.assert_series_equal(result, expected)
+
+    def test_groupby_extension_transform(self, data_for_grouping):
+        valid = data_for_grouping[~data_for_grouping.isna()]
+        df = pd.DataFrame({"A": [1, 1, 3, 3, 1], "B": valid})
+
+        result = df.groupby("B").A.transform(len)
+        expected = pd.Series([3, 3, 2, 2, 3], name="A")
+
+        self.assert_series_equal(result, expected)
+
+    def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
+        df.groupby("B").apply(groupby_apply_op)
+        df.groupby("B").A.apply(groupby_apply_op)
+        df.groupby("A").apply(groupby_apply_op)
+        df.groupby("A").B.apply(groupby_apply_op)
+
+    def test_groupby_apply_identity(self, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1], "B": data_for_grouping})
+        result = df.groupby("A").B.apply(lambda x: x.array)
+        expected = pd.Series(
+            [
+                df.B.iloc[[0, 1, 6]].array,
+                df.B.iloc[[2, 3]].array,
+                df.B.iloc[[4, 5]].array,
+            ],
+            index=pd.Index([1, 2, 3], name="A"),
+            name="B",
+        )
+        self.assert_series_equal(result, expected)
+
+    def test_in_numeric_groupby(self, data_for_grouping):
+        df = pd.DataFrame(
+            {
+                "A": [1, 1, 2, 2, 3, 3, 1],
+                "B": data_for_grouping,
+                "C": [1, 1, 1, 1, 1, 1, 1],
+            }
+        )
+        result = df.groupby("A").sum().columns
+
+        if data_for_grouping.dtype._is_numeric:
+            expected = pd.Index(["B", "C"])
+        else:
+            expected = pd.Index(["C"])
+
+        tm.assert_index_equal(result, expected)
+
+
+class TestNumericReduce(base.BaseNumericReduceTests):
+    def check_reduce(self, s, op_name, skipna):
+        result = getattr(s, op_name)(skipna=skipna)
+        expected = getattr(s.astype("float64"), op_name)(skipna=skipna)
+        # override parent function to cast to bool for min/max
+        if np.isnan(expected):
+            expected = pd.NA
+        elif op_name in ("min", "max"):
+            expected = bool(expected)
+        tm.assert_almost_equal(result, expected)
+
+
+class TestBooleanReduce(base.BaseBooleanReduceTests):
+    pass
+
+
+class TestPrinting(base.BasePrintingTests):
+    pass
+
+
+class TestUnaryOps(base.BaseUnaryOpsTests):
+    pass
+
+
+# TODO parsing not yet supported
+# class TestParsing(base.BaseParsingTests):
+#     pass
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index 0c0e8b0123c03..336b23e54d74c 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -19,10 +19,10 @@
 import pytest
 
 import pandas as pd
-from pandas import Categorical
+from pandas import Categorical, CategoricalIndex, Timestamp
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype
 from pandas.tests.extension import base
-import pandas.util.testing as tm
 
 
 def make_data():
@@ -93,10 +93,7 @@ class TestConstructors(base.BaseConstructorsTests):
 
 
 class TestReshaping(base.BaseReshapingTests):
-    def test_ravel(self, data):
-        # GH#27199 Categorical.ravel returns self until after deprecation cycle
-        with tm.assert_produces_warning(FutureWarning):
-            data.ravel()
+    pass
 
 
 class TestGetitem(base.BaseGetitemTests):
@@ -197,7 +194,51 @@ def test_searchsorted(self, data_for_sorting):
 
 
 class TestCasting(base.BaseCastingTests):
-    pass
+    @pytest.mark.parametrize("cls", [Categorical, CategoricalIndex])
+    @pytest.mark.parametrize("values", [[1, np.nan], [Timestamp("2000"), pd.NaT]])
+    def test_cast_nan_to_int(self, cls, values):
+        # GH 28406
+        s = cls(values)
+
+        msg = "Cannot (cast|convert)"
+        with pytest.raises((ValueError, TypeError), match=msg):
+            s.astype(int)
+
+    @pytest.mark.parametrize(
+        "expected",
+        [
+            pd.Series(["2019", "2020"], dtype="datetime64[ns, UTC]"),
+            pd.Series([0, 0], dtype="timedelta64[ns]"),
+            pd.Series([pd.Period("2019"), pd.Period("2020")], dtype="period[A-DEC]"),
+            pd.Series([pd.Interval(0, 1), pd.Interval(1, 2)], dtype="interval"),
+            pd.Series([1, np.nan], dtype="Int64"),
+        ],
+    )
+    def test_cast_category_to_extension_dtype(self, expected):
+        # GH 28668
+        result = expected.astype("category").astype(expected.dtype)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype, expected",
+        [
+            (
+                "datetime64[ns]",
+                np.array(["2015-01-01T00:00:00.000000000"], dtype="datetime64[ns]"),
+            ),
+            (
+                "datetime64[ns, MET]",
+                pd.DatetimeIndex(
+                    [pd.Timestamp("2015-01-01 00:00:00+0100", tz="MET")]
+                ).array,
+            ),
+        ],
+    )
+    def test_consistent_casting(self, dtype, expected):
+        # GH 28448
+        result = pd.Categorical("2015-01-01").astype(dtype)
+        assert result == expected
 
 
 class TestArithmeticOps(base.BaseArithmeticOpsTests):
diff --git a/pandas/tests/extension/test_common.py b/pandas/tests/extension/test_common.py
index 9b5f9d64f6b67..e43650c291200 100644
--- a/pandas/tests/extension/test_common.py
+++ b/pandas/tests/extension/test_common.py
@@ -5,8 +5,8 @@
 from pandas.core.dtypes.common import is_extension_array_dtype
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import ExtensionArray
-import pandas.util.testing as tm
 
 
 class DummyDtype(dtypes.ExtensionDtype):
diff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py
index a60607d586ada..3aa188098620d 100644
--- a/pandas/tests/extension/test_datetime.py
+++ b/pandas/tests/extension/test_datetime.py
@@ -44,9 +44,9 @@ def data_missing_for_sorting(dtype):
 @pytest.fixture
 def data_for_grouping(dtype):
     """
-        Expected to be like [B, B, NA, NA, A, A, B, C]
+    Expected to be like [B, B, NA, NA, A, A, B, C]
 
-        Where A < B < C and NA is missing
+    Where A < B < C and NA is missing
     """
     a = pd.Timestamp("2000-01-01")
     b = pd.Timestamp("2000-01-02")
diff --git a/pandas/tests/extension/test_integer.py b/pandas/tests/extension/test_integer.py
index d051345fdd12d..f55ec75b47dfa 100644
--- a/pandas/tests/extension/test_integer.py
+++ b/pandas/tests/extension/test_integer.py
@@ -19,6 +19,7 @@
 from pandas.core.dtypes.common import is_extension_array_dtype
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays import integer_array
 from pandas.core.arrays.integer import (
     Int8Dtype,
@@ -34,7 +35,7 @@
 
 
 def make_data():
-    return list(range(1, 9)) + [np.nan] + list(range(10, 98)) + [np.nan] + [99, 100]
+    return list(range(1, 9)) + [pd.NA] + list(range(10, 98)) + [pd.NA] + [99, 100]
 
 
 @pytest.fixture(
@@ -65,7 +66,7 @@ def data_for_twos(dtype):
 
 @pytest.fixture
 def data_missing(dtype):
-    return integer_array([np.nan, 1], dtype=dtype)
+    return integer_array([pd.NA, 1], dtype=dtype)
 
 
 @pytest.fixture
@@ -75,18 +76,18 @@ def data_for_sorting(dtype):
 
 @pytest.fixture
 def data_missing_for_sorting(dtype):
-    return integer_array([1, np.nan, 0], dtype=dtype)
+    return integer_array([1, pd.NA, 0], dtype=dtype)
 
 
 @pytest.fixture
 def na_cmp():
-    # we are np.nan
-    return lambda x, y: np.isnan(x) and np.isnan(y)
+    # we are pd.NA
+    return lambda x, y: x is pd.NA and y is pd.NA
 
 
 @pytest.fixture
 def na_value():
-    return np.nan
+    return pd.NA
 
 
 @pytest.fixture
@@ -94,7 +95,7 @@ def data_for_grouping(dtype):
     b = 1
     a = 0
     c = 2
-    na = np.nan
+    na = pd.NA
     return integer_array([b, b, na, na, a, a, b, c], dtype=dtype)
 
 
@@ -129,7 +130,7 @@ def _check_op(self, s, op, other, op_name, exc=NotImplementedError):
             expected = s.combine(other, op)
 
             if op_name in ("__rtruediv__", "__truediv__", "__div__"):
-                expected = expected.astype(float)
+                expected = expected.fillna(np.nan).astype(float)
                 if op_name == "__rtruediv__":
                     # TODO reverse operators result in object dtype
                     result = result.astype(float)
@@ -142,6 +143,7 @@ def _check_op(self, s, op, other, op_name, exc=NotImplementedError):
                 # combine method result in 'biggest' (int64) dtype
                 expected = expected.astype(s.dtype)
                 pass
+
             if (op_name == "__rpow__") and isinstance(other, pd.Series):
                 # TODO pow on Int arrays gives different result with NA
                 # see https://github.com/pandas-dev/pandas/issues/22022
@@ -162,6 +164,16 @@ def test_error(self, data, all_arithmetic_operators):
 
 
 class TestComparisonOps(base.BaseComparisonOpsTests):
+    def _check_op(self, s, op, other, op_name, exc=NotImplementedError):
+        if exc is None:
+            result = op(s, other)
+            # Override to do the astype to boolean
+            expected = s.combine(other, op).astype("boolean")
+            self.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(exc):
+                op(s, other)
+
     def check_opname(self, s, op_name, other, exc=None):
         super().check_opname(s, op_name, other, exc=None)
 
@@ -198,7 +210,7 @@ class TestMissing(base.BaseMissingTests):
 
 
 class TestMethods(base.BaseMethodsTests):
-    @pytest.mark.parametrize("dropna", [True, False])
+    @pytest.mark.skip(reason="uses nullable integer")
     def test_value_counts(self, all_data, dropna):
         all_data = all_data[:10]
         if dropna:
@@ -222,7 +234,14 @@ class TestGroupby(base.BaseGroupbyTests):
 
 
 class TestNumericReduce(base.BaseNumericReduceTests):
-    pass
+    def check_reduce(self, s, op_name, skipna):
+        # overwrite to ensure pd.NA is tested instead of np.nan
+        # https://github.com/pandas-dev/pandas/issues/30958
+        result = getattr(s, op_name)(skipna=skipna)
+        expected = getattr(s.astype("float64"), op_name)(skipna=skipna)
+        if np.isnan(expected):
+            expected = pd.NA
+        tm.assert_almost_equal(result, expected)
 
 
 class TestBooleanReduce(base.BaseBooleanReduceTests):
diff --git a/pandas/tests/extension/test_interval.py b/pandas/tests/extension/test_interval.py
index 4fdcf930d224f..2411f6cfbd936 100644
--- a/pandas/tests/extension/test_interval.py
+++ b/pandas/tests/extension/test_interval.py
@@ -147,7 +147,9 @@ class TestReshaping(BaseInterval, base.BaseReshapingTests):
 
 
 class TestSetitem(BaseInterval, base.BaseSetitemTests):
-    pass
+    @pytest.mark.xfail(reason="GH#27147 setitem changes underlying index")
+    def test_setitem_preserves_views(self, data):
+        super().test_setitem_preserves_views(data)
 
 
 class TestPrinting(BaseInterval, base.BasePrintingTests):
diff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py
index 221cf0787d839..8a820c8746857 100644
--- a/pandas/tests/extension/test_numpy.py
+++ b/pandas/tests/extension/test_numpy.py
@@ -4,8 +4,8 @@
 from pandas.compat.numpy import _np_version_under1p16
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.arrays.numpy_ import PandasArray, PandasDtype
-import pandas.util.testing as tm
 
 from . import base
 
@@ -51,7 +51,7 @@ def data_missing(allow_in_pandas, dtype):
     if dtype.numpy_dtype == "object":
         if _np_version_under1p16:
             raise pytest.skip("Skipping for NumPy <1.16")
-        return PandasArray(np.array([np.nan, (1,)]))
+        return PandasArray(np.array([np.nan, (1,)], dtype=object))
     return PandasArray(np.array([np.nan, 1.0]))
 
 
@@ -78,7 +78,7 @@ def data_for_sorting(allow_in_pandas, dtype):
     if dtype.numpy_dtype == "object":
         # Use an empty tuple for first element, then remove,
         # to disable np.array's shape inference.
-        return PandasArray(np.array([(), (2,), (3,), (1,)])[1:])
+        return PandasArray(np.array([(), (2,), (3,), (1,)], dtype=object)[1:])
     return PandasArray(np.array([1, 2, 0]))
 
 
@@ -90,7 +90,7 @@ def data_missing_for_sorting(allow_in_pandas, dtype):
     A < B and NA missing.
     """
     if dtype.numpy_dtype == "object":
-        return PandasArray(np.array([(1,), np.nan, (0,)]))
+        return PandasArray(np.array([(1,), np.nan, (0,)], dtype=object))
     return PandasArray(np.array([1, np.nan, 0]))
 
 
@@ -106,7 +106,9 @@ def data_for_grouping(allow_in_pandas, dtype):
         a, b, c = (1,), (2,), (3,)
     else:
         a, b, c = np.arange(3)
-    return PandasArray(np.array([b, b, np.nan, np.nan, a, a, b, c]))
+    return PandasArray(
+        np.array([b, b, np.nan, np.nan, a, a, b, c], dtype=dtype.numpy_dtype)
+    )
 
 
 @pytest.fixture
@@ -246,6 +248,10 @@ def test_repeat(self, data, repeats, as_series, use_numpy):
         # Fails creating expected
         super().test_repeat(data, repeats, as_series, use_numpy)
 
+    @pytest.mark.xfail(reason="PandasArray.diff may fail on dtype")
+    def test_diff(self, data, periods):
+        return super().test_diff(data, periods)
+
 
 @skip_nested
 class TestArithmetics(BaseNumPyTests, base.BaseArithmeticOpsTests):
@@ -330,6 +336,10 @@ def test_merge_on_extension_array_duplicates(self, data):
         # Fails creating expected
         super().test_merge_on_extension_array_duplicates(data)
 
+    @skip_nested
+    def test_transpose(self, data):
+        super().test_transpose(data)
+
 
 class TestSetitem(BaseNumPyTests, base.BaseSetitemTests):
     @skip_nested
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index 6ebe71e173ec2..198a228b621b4 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -4,9 +4,10 @@
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
-from pandas import SparseArray, SparseDtype
+from pandas import SparseDtype
+import pandas._testing as tm
+from pandas.arrays import SparseArray
 from pandas.tests.extension import base
-import pandas.util.testing as tm
 
 
 def make_data(fill_value):
@@ -132,6 +133,10 @@ def test_concat_columns(self, data, na_value):
         self._check_unsupported(data)
         super().test_concat_columns(data, na_value)
 
+    def test_concat_extension_arrays_copy_false(self, data, na_value):
+        self._check_unsupported(data)
+        super().test_concat_extension_arrays_copy_false(data, na_value)
+
     def test_align(self, data, na_value):
         self._check_unsupported(data)
         super().test_align(data, na_value)
@@ -231,7 +236,7 @@ def test_combine_le(self, data_repeated):
         s2 = pd.Series(orig_data2)
         result = s1.combine(s2, lambda x1, x2: x1 <= x2)
         expected = pd.Series(
-            pd.SparseArray(
+            SparseArray(
                 [a <= b for (a, b) in zip(list(orig_data1), list(orig_data2))],
                 fill_value=False,
             )
@@ -241,7 +246,7 @@ def test_combine_le(self, data_repeated):
         val = s1.iloc[0]
         result = s1.combine(val, lambda x1, x2: x1 <= x2)
         expected = pd.Series(
-            pd.SparseArray([a <= val for a in list(orig_data1)], fill_value=False)
+            SparseArray([a <= val for a in list(orig_data1)], fill_value=False)
         )
         self.assert_series_equal(result, expected)
 
@@ -346,7 +351,7 @@ def _compare_other(self, s, data, op_name, other):
 
         with np.errstate(all="ignore"):
             expected = pd.Series(
-                pd.SparseArray(
+                SparseArray(
                     op(np.asarray(data), np.asarray(other)),
                     fill_value=result.values.fill_value,
                 )
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
new file mode 100644
index 0000000000000..86aed671f1b88
--- /dev/null
+++ b/pandas/tests/extension/test_string.py
@@ -0,0 +1,114 @@
+import string
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas.core.arrays.string_ import StringArray, StringDtype
+from pandas.tests.extension import base
+
+
+@pytest.fixture
+def dtype():
+    return StringDtype()
+
+
+@pytest.fixture
+def data():
+    strings = np.random.choice(list(string.ascii_letters), size=100)
+    while strings[0] == strings[1]:
+        strings = np.random.choice(list(string.ascii_letters), size=100)
+
+    return StringArray._from_sequence(strings)
+
+
+@pytest.fixture
+def data_missing():
+    """Length 2 array with [NA, Valid]"""
+    return StringArray._from_sequence([pd.NA, "A"])
+
+
+@pytest.fixture
+def data_for_sorting():
+    return StringArray._from_sequence(["B", "C", "A"])
+
+
+@pytest.fixture
+def data_missing_for_sorting():
+    return StringArray._from_sequence(["B", pd.NA, "A"])
+
+
+@pytest.fixture
+def na_value():
+    return pd.NA
+
+
+@pytest.fixture
+def data_for_grouping():
+    return StringArray._from_sequence(["B", "B", pd.NA, pd.NA, "A", "A", "B", "C"])
+
+
+class TestDtype(base.BaseDtypeTests):
+    pass
+
+
+class TestInterface(base.BaseInterfaceTests):
+    pass
+
+
+class TestConstructors(base.BaseConstructorsTests):
+    pass
+
+
+class TestReshaping(base.BaseReshapingTests):
+    pass
+
+
+class TestGetitem(base.BaseGetitemTests):
+    pass
+
+
+class TestSetitem(base.BaseSetitemTests):
+    pass
+
+
+class TestMissing(base.BaseMissingTests):
+    pass
+
+
+class TestNoReduce(base.BaseNoReduceTests):
+    pass
+
+
+class TestMethods(base.BaseMethodsTests):
+    @pytest.mark.skip(reason="returns nullable")
+    def test_value_counts(self, all_data, dropna):
+        return super().test_value_counts(all_data, dropna)
+
+
+class TestCasting(base.BaseCastingTests):
+    pass
+
+
+class TestComparisonOps(base.BaseComparisonOpsTests):
+    def _compare_other(self, s, data, op_name, other):
+        result = getattr(s, op_name)(other)
+        expected = getattr(s.astype(object), op_name)(other).astype("boolean")
+        self.assert_series_equal(result, expected)
+
+    def test_compare_scalar(self, data, all_compare_operators):
+        op_name = all_compare_operators
+        s = pd.Series(data)
+        self._compare_other(s, data, op_name, "abc")
+
+
+class TestParsing(base.BaseParsingTests):
+    pass
+
+
+class TestPrinting(base.BasePrintingTests):
+    pass
+
+
+class TestGroupBy(base.BaseGroupbyTests):
+    pass
diff --git a/pandas/tests/frame/common.py b/pandas/tests/frame/common.py
index 281028b971d1e..463a140972ab5 100644
--- a/pandas/tests/frame/common.py
+++ b/pandas/tests/frame/common.py
@@ -1,127 +1,3 @@
-import numpy as np
-
-from pandas.util._decorators import cache_readonly
-
-import pandas as pd
-import pandas.util.testing as tm
-
-_seriesd = tm.getSeriesData()
-_tsd = tm.getTimeSeriesData()
-
-_frame = pd.DataFrame(_seriesd)
-_frame2 = pd.DataFrame(_seriesd, columns=["D", "C", "B", "A"])
-_intframe = pd.DataFrame({k: v.astype(int) for k, v in _seriesd.items()})
-
-_tsframe = pd.DataFrame(_tsd)
-
-_mixed_frame = _frame.copy()
-_mixed_frame["foo"] = "bar"
-
-
-class TestData:
-    @cache_readonly
-    def frame(self):
-        return _frame.copy()
-
-    @cache_readonly
-    def frame2(self):
-        return _frame2.copy()
-
-    @cache_readonly
-    def intframe(self):
-        # force these all to int64 to avoid platform testing issues
-        return pd.DataFrame({c: s for c, s in _intframe.items()}, dtype=np.int64)
-
-    @cache_readonly
-    def tsframe(self):
-        return _tsframe.copy()
-
-    @cache_readonly
-    def mixed_frame(self):
-        return _mixed_frame.copy()
-
-    @cache_readonly
-    def mixed_float(self):
-        return pd.DataFrame(
-            {
-                "A": _frame["A"].copy().astype("float32"),
-                "B": _frame["B"].copy().astype("float32"),
-                "C": _frame["C"].copy().astype("float16"),
-                "D": _frame["D"].copy().astype("float64"),
-            }
-        )
-
-    @cache_readonly
-    def mixed_float2(self):
-        return pd.DataFrame(
-            {
-                "A": _frame2["A"].copy().astype("float32"),
-                "B": _frame2["B"].copy().astype("float32"),
-                "C": _frame2["C"].copy().astype("float16"),
-                "D": _frame2["D"].copy().astype("float64"),
-            }
-        )
-
-    @cache_readonly
-    def mixed_int(self):
-        return pd.DataFrame(
-            {
-                "A": _intframe["A"].copy().astype("int32"),
-                "B": np.ones(len(_intframe["B"]), dtype="uint64"),
-                "C": _intframe["C"].copy().astype("uint8"),
-                "D": _intframe["D"].copy().astype("int64"),
-            }
-        )
-
-    @cache_readonly
-    def all_mixed(self):
-        return pd.DataFrame(
-            {
-                "a": 1.0,
-                "b": 2,
-                "c": "foo",
-                "float32": np.array([1.0] * 10, dtype="float32"),
-                "int32": np.array([1] * 10, dtype="int32"),
-            },
-            index=np.arange(10),
-        )
-
-    @cache_readonly
-    def tzframe(self):
-        result = pd.DataFrame(
-            {
-                "A": pd.date_range("20130101", periods=3),
-                "B": pd.date_range("20130101", periods=3, tz="US/Eastern"),
-                "C": pd.date_range("20130101", periods=3, tz="CET"),
-            }
-        )
-        result.iloc[1, 1] = pd.NaT
-        result.iloc[1, 2] = pd.NaT
-        return result
-
-    @cache_readonly
-    def empty(self):
-        return pd.DataFrame()
-
-    @cache_readonly
-    def ts1(self):
-        return tm.makeTimeSeries(nper=30)
-
-    @cache_readonly
-    def ts2(self):
-        return tm.makeTimeSeries(nper=30)[5:]
-
-    @cache_readonly
-    def simple(self):
-        arr = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
-
-        return pd.DataFrame(arr, columns=["one", "two", "three"], index=["a", "b", "c"])
-
-
-# self.ts3 = tm.makeTimeSeries()[-5:]
-# self.ts4 = tm.makeTimeSeries()[1:-1]
-
-
 def _check_mixed_float(df, dtype=None):
     # float16 are most likely to be upcasted to float32
     dtypes = dict(A="float32", B="float32", C="float16", D="float64")
diff --git a/pandas/tests/frame/conftest.py b/pandas/tests/frame/conftest.py
index 915d6edcd8367..774eb443c45fe 100644
--- a/pandas/tests/frame/conftest.py
+++ b/pandas/tests/frame/conftest.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, NaT, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture
diff --git a/pandas/tests/frame/indexing/test_categorical.py b/pandas/tests/frame/indexing/test_categorical.py
new file mode 100644
index 0000000000000..a29c193676db2
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_categorical.py
@@ -0,0 +1,398 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import Categorical, DataFrame, Index, Series
+import pandas._testing as tm
+
+
+class TestDataFrameIndexingCategorical:
+    def test_assignment(self):
+        # assignment
+        df = DataFrame(
+            {"value": np.array(np.random.randint(0, 10000, 100), dtype="int32")}
+        )
+        labels = Categorical(
+            ["{0} - {1}".format(i, i + 499) for i in range(0, 10000, 500)]
+        )
+
+        df = df.sort_values(by=["value"], ascending=True)
+        s = pd.cut(df.value, range(0, 10500, 500), right=False, labels=labels)
+        d = s.values
+        df["D"] = d
+        str(df)
+
+        result = df.dtypes
+        expected = Series(
+            [np.dtype("int32"), CategoricalDtype(categories=labels, ordered=False)],
+            index=["value", "D"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        df["E"] = s
+        str(df)
+
+        result = df.dtypes
+        expected = Series(
+            [
+                np.dtype("int32"),
+                CategoricalDtype(categories=labels, ordered=False),
+                CategoricalDtype(categories=labels, ordered=False),
+            ],
+            index=["value", "D", "E"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        result1 = df["D"]
+        result2 = df["E"]
+        tm.assert_categorical_equal(result1._data._block.values, d)
+
+        # sorting
+        s.name = "E"
+        tm.assert_series_equal(result2.sort_index(), s.sort_index())
+
+        cat = Categorical([1, 2, 3, 10], categories=[1, 2, 3, 4, 10])
+        df = DataFrame(Series(cat))
+
+    def test_assigning_ops(self):
+        # systematically test the assigning operations:
+        # for all slicing ops:
+        #  for value in categories and value not in categories:
+
+        #   - assign a single value -> exp_single_cats_value
+
+        #   - assign a complete row (mixed values) -> exp_single_row
+
+        # assign multiple rows (mixed values) (-> array) -> exp_multi_row
+
+        # assign a part of a column with dtype == categorical ->
+        # exp_parts_cats_col
+
+        # assign a part of a column with dtype != categorical ->
+        # exp_parts_cats_col
+
+        cats = Categorical(["a", "a", "a", "a", "a", "a", "a"], categories=["a", "b"])
+        idx = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values = [1, 1, 1, 1, 1, 1, 1]
+        orig = DataFrame({"cats": cats, "values": values}, index=idx)
+
+        # the expected values
+        # changed single row
+        cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
+        idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values1 = [1, 1, 2, 1, 1, 1, 1]
+        exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
+
+        # changed multiple rows
+        cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
+        idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values2 = [1, 1, 2, 2, 1, 1, 1]
+        exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
+
+        # changed part of the cats column
+        cats3 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
+        idx3 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values3 = [1, 1, 1, 1, 1, 1, 1]
+        exp_parts_cats_col = DataFrame({"cats": cats3, "values": values3}, index=idx3)
+
+        # changed single value in cats col
+        cats4 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
+        idx4 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values4 = [1, 1, 1, 1, 1, 1, 1]
+        exp_single_cats_value = DataFrame(
+            {"cats": cats4, "values": values4}, index=idx4
+        )
+
+        #  iloc
+        # ###############
+        #   - assign a single value -> exp_single_cats_value
+        df = orig.copy()
+        df.iloc[2, 0] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        df = orig.copy()
+        df.iloc[df.index == "j", 0] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        #   - assign a single value not in the current categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.iloc[2, 0] = "c"
+
+        #   - assign a complete row (mixed values) -> exp_single_row
+        df = orig.copy()
+        df.iloc[2, :] = ["b", 2]
+        tm.assert_frame_equal(df, exp_single_row)
+
+        #   - assign a complete row (mixed values) not in categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.iloc[2, :] = ["c", 2]
+
+        #   - assign multiple rows (mixed values) -> exp_multi_row
+        df = orig.copy()
+        df.iloc[2:4, :] = [["b", 2], ["b", 2]]
+        tm.assert_frame_equal(df, exp_multi_row)
+
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.iloc[2:4, :] = [["c", 2], ["c", 2]]
+
+        # assign a part of a column with dtype == categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.iloc[2:4, 0] = Categorical(["b", "b"], categories=["a", "b"])
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            # different categories -> not sure if this should fail or pass
+            df = orig.copy()
+            df.iloc[2:4, 0] = Categorical(list("bb"), categories=list("abc"))
+
+        with pytest.raises(ValueError):
+            # different values
+            df = orig.copy()
+            df.iloc[2:4, 0] = Categorical(list("cc"), categories=list("abc"))
+
+        # assign a part of a column with dtype != categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.iloc[2:4, 0] = ["b", "b"]
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            df.iloc[2:4, 0] = ["c", "c"]
+
+        #  loc
+        # ##############
+        #   - assign a single value -> exp_single_cats_value
+        df = orig.copy()
+        df.loc["j", "cats"] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        df = orig.copy()
+        df.loc[df.index == "j", "cats"] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        #   - assign a single value not in the current categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j", "cats"] = "c"
+
+        #   - assign a complete row (mixed values) -> exp_single_row
+        df = orig.copy()
+        df.loc["j", :] = ["b", 2]
+        tm.assert_frame_equal(df, exp_single_row)
+
+        #   - assign a complete row (mixed values) not in categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j", :] = ["c", 2]
+
+        #   - assign multiple rows (mixed values) -> exp_multi_row
+        df = orig.copy()
+        df.loc["j":"k", :] = [["b", 2], ["b", 2]]
+        tm.assert_frame_equal(df, exp_multi_row)
+
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j":"k", :] = [["c", 2], ["c", 2]]
+
+        # assign a part of a column with dtype == categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.loc["j":"k", "cats"] = Categorical(["b", "b"], categories=["a", "b"])
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            # different categories -> not sure if this should fail or pass
+            df = orig.copy()
+            df.loc["j":"k", "cats"] = Categorical(
+                ["b", "b"], categories=["a", "b", "c"]
+            )
+
+        with pytest.raises(ValueError):
+            # different values
+            df = orig.copy()
+            df.loc["j":"k", "cats"] = Categorical(
+                ["c", "c"], categories=["a", "b", "c"]
+            )
+
+        # assign a part of a column with dtype != categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.loc["j":"k", "cats"] = ["b", "b"]
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            df.loc["j":"k", "cats"] = ["c", "c"]
+
+        #  loc
+        # ##############
+        #   - assign a single value -> exp_single_cats_value
+        df = orig.copy()
+        df.loc["j", df.columns[0]] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        df = orig.copy()
+        df.loc[df.index == "j", df.columns[0]] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        #   - assign a single value not in the current categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j", df.columns[0]] = "c"
+
+        #   - assign a complete row (mixed values) -> exp_single_row
+        df = orig.copy()
+        df.loc["j", :] = ["b", 2]
+        tm.assert_frame_equal(df, exp_single_row)
+
+        #   - assign a complete row (mixed values) not in categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j", :] = ["c", 2]
+
+        #   - assign multiple rows (mixed values) -> exp_multi_row
+        df = orig.copy()
+        df.loc["j":"k", :] = [["b", 2], ["b", 2]]
+        tm.assert_frame_equal(df, exp_multi_row)
+
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.loc["j":"k", :] = [["c", 2], ["c", 2]]
+
+        # assign a part of a column with dtype == categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.loc["j":"k", df.columns[0]] = Categorical(["b", "b"], categories=["a", "b"])
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            # different categories -> not sure if this should fail or pass
+            df = orig.copy()
+            df.loc["j":"k", df.columns[0]] = Categorical(
+                ["b", "b"], categories=["a", "b", "c"]
+            )
+
+        with pytest.raises(ValueError):
+            # different values
+            df = orig.copy()
+            df.loc["j":"k", df.columns[0]] = Categorical(
+                ["c", "c"], categories=["a", "b", "c"]
+            )
+
+        # assign a part of a column with dtype != categorical ->
+        # exp_parts_cats_col
+        df = orig.copy()
+        df.loc["j":"k", df.columns[0]] = ["b", "b"]
+        tm.assert_frame_equal(df, exp_parts_cats_col)
+
+        with pytest.raises(ValueError):
+            df.loc["j":"k", df.columns[0]] = ["c", "c"]
+
+        # iat
+        df = orig.copy()
+        df.iat[2, 0] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        #   - assign a single value not in the current categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.iat[2, 0] = "c"
+
+        # at
+        #   - assign a single value -> exp_single_cats_value
+        df = orig.copy()
+        df.at["j", "cats"] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        #   - assign a single value not in the current categories set
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.at["j", "cats"] = "c"
+
+        # fancy indexing
+        catsf = Categorical(
+            ["a", "a", "c", "c", "a", "a", "a"], categories=["a", "b", "c"]
+        )
+        idxf = Index(["h", "i", "j", "k", "l", "m", "n"])
+        valuesf = [1, 1, 3, 3, 1, 1, 1]
+        df = DataFrame({"cats": catsf, "values": valuesf}, index=idxf)
+
+        exp_fancy = exp_multi_row.copy()
+        exp_fancy["cats"].cat.set_categories(["a", "b", "c"], inplace=True)
+
+        df[df["cats"] == "c"] = ["b", 2]
+        # category c is kept in .categories
+        tm.assert_frame_equal(df, exp_fancy)
+
+        # set_value
+        df = orig.copy()
+        df.at["j", "cats"] = "b"
+        tm.assert_frame_equal(df, exp_single_cats_value)
+
+        with pytest.raises(ValueError):
+            df = orig.copy()
+            df.at["j", "cats"] = "c"
+
+        # Assigning a Category to parts of a int/... column uses the values of
+        # the Categorical
+        df = DataFrame({"a": [1, 1, 1, 1, 1], "b": list("aaaaa")})
+        exp = DataFrame({"a": [1, "b", "b", 1, 1], "b": list("aabba")})
+        df.loc[1:2, "a"] = Categorical(["b", "b"], categories=["a", "b"])
+        df.loc[2:3, "b"] = Categorical(["b", "b"], categories=["a", "b"])
+        tm.assert_frame_equal(df, exp)
+
+    def test_functions_no_warnings(self):
+        df = DataFrame({"value": np.random.randint(0, 100, 20)})
+        labels = ["{0} - {1}".format(i, i + 9) for i in range(0, 100, 10)]
+        with tm.assert_produces_warning(False):
+            df["group"] = pd.cut(
+                df.value, range(0, 105, 10), right=False, labels=labels
+            )
+
+    def test_setitem_single_row_categorical(self):
+        # GH 25495
+        df = DataFrame({"Alpha": ["a"], "Numeric": [0]})
+        categories = pd.Categorical(df["Alpha"], categories=["a", "b", "c"])
+        df.loc[:, "Alpha"] = categories
+
+        result = df["Alpha"]
+        expected = Series(categories, index=df.index, name="Alpha")
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_indexing_preserves_index_category_dtype(self):
+        # GH 15166
+        df = DataFrame(
+            data=np.arange(2, 22, 2),
+            index=pd.MultiIndex(
+                levels=[pd.CategoricalIndex(["a", "b"]), range(10)],
+                codes=[[0] * 5 + [1] * 5, range(10)],
+                names=["Index1", "Index2"],
+            ),
+        )
+
+        expected = pd.CategoricalIndex(
+            ["a", "b"],
+            categories=["a", "b"],
+            ordered=False,
+            name="Index1",
+            dtype="category",
+        )
+
+        result = df.index.levels[0]
+        tm.assert_index_equal(result, expected)
+
+        result = df.loc[["a"]].index.levels[0]
+        tm.assert_index_equal(result, expected)
+
+    def test_wrong_length_cat_dtype_raises(self):
+        # GH29523
+        cat = pd.Categorical.from_codes([0, 1, 1, 0, 1, 2], ["a", "b", "c"])
+        df = pd.DataFrame({"bar": range(10)})
+        err = "Length of values does not match length of index"
+        with pytest.raises(ValueError, match=err):
+            df["foo"] = cat
diff --git a/pandas/tests/frame/indexing/test_datetime.py b/pandas/tests/frame/indexing/test_datetime.py
new file mode 100644
index 0000000000000..6bfcac3793584
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_datetime.py
@@ -0,0 +1,55 @@
+import pandas as pd
+from pandas import DataFrame, Index, Series, date_range, notna
+import pandas._testing as tm
+
+
+class TestDataFrameIndexingDatetimeWithTZ:
+    def test_setitem(self, timezone_frame):
+
+        df = timezone_frame
+        idx = df["B"].rename("foo")
+
+        # setitem
+        df["C"] = idx
+        tm.assert_series_equal(df["C"], Series(idx, name="C"))
+
+        df["D"] = "foo"
+        df["D"] = idx
+        tm.assert_series_equal(df["D"], Series(idx, name="D"))
+        del df["D"]
+
+        # assert that A & C are not sharing the same base (e.g. they
+        # are copies)
+        b1 = df._data.blocks[1]
+        b2 = df._data.blocks[2]
+        tm.assert_extension_array_equal(b1.values, b2.values)
+        assert id(b1.values._data.base) != id(b2.values._data.base)
+
+        # with nan
+        df2 = df.copy()
+        df2.iloc[1, 1] = pd.NaT
+        df2.iloc[1, 2] = pd.NaT
+        result = df2["B"]
+        tm.assert_series_equal(notna(result), Series([True, False, True], name="B"))
+        tm.assert_series_equal(df2.dtypes, df.dtypes)
+
+    def test_set_reset(self):
+
+        idx = Index(date_range("20130101", periods=3, tz="US/Eastern"), name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype, "M8[ns, US/Eastern"
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+    def test_scalar_assignment(self):
+        # issue #19843
+        df = pd.DataFrame(index=(0, 1, 2))
+        df["now"] = pd.Timestamp("20130101", tz="UTC")
+        expected = pd.DataFrame(
+            {"now": pd.Timestamp("20130101", tz="UTC")}, index=[0, 1, 2]
+        )
+        tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/frame/indexing/test_iat.py b/pandas/tests/frame/indexing/test_iat.py
new file mode 100644
index 0000000000000..23e3392251a3a
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_iat.py
@@ -0,0 +1,7 @@
+def test_iat(float_frame):
+
+    for i, row in enumerate(float_frame.index):
+        for j, col in enumerate(float_frame.columns):
+            result = float_frame.iat[i, j]
+            expected = float_frame.at[row, col]
+            assert result == expected
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
new file mode 100644
index 0000000000000..d892e3d637772
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -0,0 +1,2212 @@
+from datetime import date, datetime, time, timedelta
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslib import iNaT
+
+from pandas.core.dtypes.common import is_float_dtype, is_integer
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+from pandas.arrays import SparseArray
+import pandas.core.common as com
+from pandas.core.indexing import IndexingError
+
+from pandas.tseries.offsets import BDay
+
+
+class TestGet:
+    def test_get(self, float_frame):
+        b = float_frame.get("B")
+        tm.assert_series_equal(b, float_frame["B"])
+
+        assert float_frame.get("foo") is None
+        tm.assert_series_equal(
+            float_frame.get("foo", float_frame["B"]), float_frame["B"]
+        )
+
+    @pytest.mark.parametrize(
+        "df",
+        [
+            DataFrame(),
+            DataFrame(columns=list("AB")),
+            DataFrame(columns=list("AB"), index=range(3)),
+        ],
+    )
+    def test_get_none(self, df):
+        # see gh-5652
+        assert df.get(None) is None
+
+
+class TestDataFrameIndexing:
+    def test_getitem(self, float_frame):
+        # Slicing
+        sl = float_frame[:20]
+        assert len(sl.index) == 20
+
+        # Column access
+        for _, series in sl.items():
+            assert len(series.index) == 20
+            assert tm.equalContents(series.index, sl.index)
+
+        for key, _ in float_frame._series.items():
+            assert float_frame[key] is not None
+
+        assert "random" not in float_frame
+        with pytest.raises(KeyError, match="random"):
+            float_frame["random"]
+
+        df = float_frame.copy()
+        df["$10"] = np.random.randn(len(df))
+
+        ad = np.random.randn(len(df))
+        df["@awesome_domain"] = ad
+
+        with pytest.raises(KeyError, match=re.escape("'df[\"$10\"]'")):
+            df.__getitem__('df["$10"]')
+
+        res = df["@awesome_domain"]
+        tm.assert_numpy_array_equal(ad, res.values)
+
+    def test_getitem_dupe_cols(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+        msg = "\"None of [Index(['baf'], dtype='object')] are in the [columns]\""
+        with pytest.raises(KeyError, match=re.escape(msg)):
+            df[["baf"]]
+
+    @pytest.mark.parametrize("key_type", [iter, np.array, Series, Index])
+    def test_loc_iterable(self, float_frame, key_type):
+        idx = key_type(["A", "B", "C"])
+        result = float_frame.loc[:, idx]
+        expected = float_frame.loc[:, ["A", "B", "C"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_timedelta_0seconds(self):
+        # GH#10583
+        df = pd.DataFrame(np.random.normal(size=(10, 4)))
+        df.index = pd.timedelta_range(start="0s", periods=10, freq="s")
+        expected = df.loc[pd.Timedelta("0s") :, :]
+        result = df.loc["0s":, :]
+        tm.assert_frame_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "idx_type",
+        [
+            list,
+            iter,
+            Index,
+            set,
+            lambda l: dict(zip(l, range(len(l)))),
+            lambda l: dict(zip(l, range(len(l)))).keys(),
+        ],
+        ids=["list", "iter", "Index", "set", "dict", "dict_keys"],
+    )
+    @pytest.mark.parametrize("levels", [1, 2])
+    def test_getitem_listlike(self, idx_type, levels, float_frame):
+        # GH 21294
+
+        if levels == 1:
+            frame, missing = float_frame, "food"
+        else:
+            # MultiIndex columns
+            frame = DataFrame(
+                np.random.randn(8, 3),
+                columns=Index(
+                    [("foo", "bar"), ("baz", "qux"), ("peek", "aboo")],
+                    name=("sth", "sth2"),
+                ),
+            )
+            missing = ("good", "food")
+
+        keys = [frame.columns[1], frame.columns[0]]
+        idx = idx_type(keys)
+        idx_check = list(idx_type(keys))
+
+        result = frame[idx]
+
+        expected = frame.loc[:, idx_check]
+        expected.columns.names = frame.columns.names
+
+        tm.assert_frame_equal(result, expected)
+
+        idx = idx_type(keys + [missing])
+        with pytest.raises(KeyError, match="not in index"):
+            frame[idx]
+
+    @pytest.mark.parametrize(
+        "val,expected", [(2 ** 63 - 1, Series([1])), (2 ** 63, Series([2]))]
+    )
+    def test_loc_uint64(self, val, expected):
+        # see gh-19399
+        df = DataFrame([1, 2], index=[2 ** 63 - 1, 2 ** 63])
+        result = df.loc[val]
+
+        expected.name = val
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_callable(self, float_frame):
+        # GH 12533
+        result = float_frame[lambda x: "A"]
+        tm.assert_series_equal(result, float_frame.loc[:, "A"])
+
+        result = float_frame[lambda x: ["A", "B"]]
+        tm.assert_frame_equal(result, float_frame.loc[:, ["A", "B"]])
+
+        df = float_frame[:3]
+        result = df[lambda x: [True, False, True]]
+        tm.assert_frame_equal(result, float_frame.iloc[[0, 2], :])
+
+    def test_setitem_list(self, float_frame):
+
+        float_frame["E"] = "foo"
+        data = float_frame[["A", "B"]]
+        float_frame[["B", "A"]] = data
+
+        tm.assert_series_equal(float_frame["B"], data["A"], check_names=False)
+        tm.assert_series_equal(float_frame["A"], data["B"], check_names=False)
+
+        msg = "Columns must be same length as key"
+        with pytest.raises(ValueError, match=msg):
+            data[["A"]] = float_frame[["A", "B"]]
+
+        msg = "Length of values does not match length of index"
+        with pytest.raises(ValueError, match=msg):
+            data["A"] = range(len(data.index) - 1)
+
+        df = DataFrame(0, index=range(3), columns=["tt1", "tt2"], dtype=np.int_)
+        df.loc[1, ["tt1", "tt2"]] = [1, 2]
+
+        result = df.loc[df.index[1], ["tt1", "tt2"]]
+        expected = Series([1, 2], df.columns, dtype=np.int_, name=1)
+        tm.assert_series_equal(result, expected)
+
+        df["tt1"] = df["tt2"] = "0"
+        df.loc[df.index[1], ["tt1", "tt2"]] = ["1", "2"]
+        result = df.loc[df.index[1], ["tt1", "tt2"]]
+        expected = Series(["1", "2"], df.columns, name=1)
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_list_not_dataframe(self, float_frame):
+        data = np.random.randn(len(float_frame), 2)
+        float_frame[["A", "B"]] = data
+        tm.assert_almost_equal(float_frame[["A", "B"]].values, data)
+
+    def test_setitem_list_of_tuples(self, float_frame):
+        tuples = list(zip(float_frame["A"], float_frame["B"]))
+        float_frame["tuples"] = tuples
+
+        result = float_frame["tuples"]
+        expected = Series(tuples, index=float_frame.index, name="tuples")
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_multi_index(self):
+        # GH7655, test that assigning to a sub-frame of a frame
+        # with multi-index columns aligns both rows and columns
+        it = ["jim", "joe", "jolie"], ["first", "last"], ["left", "center", "right"]
+
+        cols = MultiIndex.from_product(it)
+        index = pd.date_range("20141006", periods=20)
+        vals = np.random.randint(1, 1000, (len(index), len(cols)))
+        df = pd.DataFrame(vals, columns=cols, index=index)
+
+        i, j = df.index.values.copy(), it[-1][:]
+
+        np.random.shuffle(i)
+        df["jim"] = df["jolie"].loc[i, ::-1]
+        tm.assert_frame_equal(df["jim"], df["jolie"])
+
+        np.random.shuffle(j)
+        df[("joe", "first")] = df[("jolie", "last")].loc[i, j]
+        tm.assert_frame_equal(df[("joe", "first")], df[("jolie", "last")])
+
+        np.random.shuffle(j)
+        df[("joe", "last")] = df[("jolie", "first")].loc[i, j]
+        tm.assert_frame_equal(df[("joe", "last")], df[("jolie", "first")])
+
+    def test_setitem_callable(self):
+        # GH 12533
+        df = pd.DataFrame({"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]})
+        df[lambda x: "A"] = [11, 12, 13, 14]
+
+        exp = pd.DataFrame({"A": [11, 12, 13, 14], "B": [5, 6, 7, 8]})
+        tm.assert_frame_equal(df, exp)
+
+    def test_setitem_other_callable(self):
+        # GH 13299
+        def inc(x):
+            return x + 1
+
+        df = pd.DataFrame([[-1, 1], [1, -1]])
+        df[df > 0] = inc
+
+        expected = pd.DataFrame([[-1, inc], [inc, -1]])
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_boolean(
+        self, float_string_frame, mixed_float_frame, mixed_int_frame, datetime_frame
+    ):
+        # boolean indexing
+        d = datetime_frame.index[10]
+        indexer = datetime_frame.index > d
+        indexer_obj = indexer.astype(object)
+
+        subindex = datetime_frame.index[indexer]
+        subframe = datetime_frame[indexer]
+
+        tm.assert_index_equal(subindex, subframe.index)
+        with pytest.raises(ValueError, match="Item wrong length"):
+            datetime_frame[indexer[:-1]]
+
+        subframe_obj = datetime_frame[indexer_obj]
+        tm.assert_frame_equal(subframe_obj, subframe)
+
+        with pytest.raises(ValueError, match="Boolean array expected"):
+            datetime_frame[datetime_frame]
+
+        # test that Series work
+        indexer_obj = Series(indexer_obj, datetime_frame.index)
+
+        subframe_obj = datetime_frame[indexer_obj]
+        tm.assert_frame_equal(subframe_obj, subframe)
+
+        # test that Series indexers reindex
+        # we are producing a warning that since the passed boolean
+        # key is not the same as the given index, we will reindex
+        # not sure this is really necessary
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            indexer_obj = indexer_obj.reindex(datetime_frame.index[::-1])
+            subframe_obj = datetime_frame[indexer_obj]
+            tm.assert_frame_equal(subframe_obj, subframe)
+
+        # test df[df > 0]
+        for df in [
+            datetime_frame,
+            float_string_frame,
+            mixed_float_frame,
+            mixed_int_frame,
+        ]:
+            if df is float_string_frame:
+                continue
+
+            data = df._get_numeric_data()
+            bif = df[df > 0]
+            bifw = DataFrame(
+                {c: np.where(data[c] > 0, data[c], np.nan) for c in data.columns},
+                index=data.index,
+                columns=data.columns,
+            )
+
+            # add back other columns to compare
+            for c in df.columns:
+                if c not in bifw:
+                    bifw[c] = df[c]
+            bifw = bifw.reindex(columns=df.columns)
+
+            tm.assert_frame_equal(bif, bifw, check_dtype=False)
+            for c in df.columns:
+                if bif[c].dtype != bifw[c].dtype:
+                    assert bif[c].dtype == df[c].dtype
+
+    def test_getitem_boolean_casting(self, datetime_frame):
+
+        # don't upcast if we don't need to
+        df = datetime_frame.copy()
+        df["E"] = 1
+        df["E"] = df["E"].astype("int32")
+        df["E1"] = df["E"].copy()
+        df["F"] = 1
+        df["F"] = df["F"].astype("int64")
+        df["F1"] = df["F"].copy()
+
+        casted = df[df > 0]
+        result = casted.dtypes
+        expected = Series(
+            [np.dtype("float64")] * 4
+            + [np.dtype("int32")] * 2
+            + [np.dtype("int64")] * 2,
+            index=["A", "B", "C", "D", "E", "E1", "F", "F1"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        # int block splitting
+        df.loc[df.index[1:3], ["E1", "F1"]] = 0
+        casted = df[df > 0]
+        result = casted.dtypes
+        expected = Series(
+            [np.dtype("float64")] * 4
+            + [np.dtype("int32")]
+            + [np.dtype("float64")]
+            + [np.dtype("int64")]
+            + [np.dtype("float64")],
+            index=["A", "B", "C", "D", "E", "E1", "F", "F1"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        # where dtype conversions
+        # GH 3733
+        df = DataFrame(data=np.random.randn(100, 50))
+        df = df.where(df > 0)  # create nans
+        bools = df > 0
+        mask = isna(df)
+        expected = bools.astype(float).mask(mask)
+        result = bools.mask(mask)
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_boolean_list(self):
+        df = DataFrame(np.arange(12).reshape(3, 4))
+
+        def _checkit(lst):
+            result = df[lst]
+            expected = df.loc[df.index[lst]]
+            tm.assert_frame_equal(result, expected)
+
+        _checkit([True, False, True])
+        _checkit([True, True, True])
+        _checkit([False, False, False])
+
+    def test_getitem_boolean_iadd(self):
+        arr = np.random.randn(5, 5)
+
+        df = DataFrame(arr.copy(), columns=["A", "B", "C", "D", "E"])
+
+        df[df < 0] += 1
+        arr[arr < 0] += 1
+
+        tm.assert_almost_equal(df.values, arr)
+
+    def test_boolean_index_empty_corner(self):
+        # #2096
+        blah = DataFrame(np.empty([0, 1]), columns=["A"], index=DatetimeIndex([]))
+
+        # both of these should succeed trivially
+        k = np.array([], bool)
+
+        blah[k]
+        blah[k] = 0
+
+    def test_getitem_ix_mixed_integer(self):
+        df = DataFrame(
+            np.random.randn(4, 3), index=[1, 10, "C", "E"], columns=[1, 2, 3]
+        )
+
+        result = df.iloc[:-1]
+        expected = df.loc[df.index[:-1]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[[1, 10]]
+        expected = df.loc[Index([1, 10])]
+        tm.assert_frame_equal(result, expected)
+
+        # 11320
+        df = pd.DataFrame(
+            {
+                "rna": (1.5, 2.2, 3.2, 4.5),
+                -1000: [11, 21, 36, 40],
+                0: [10, 22, 43, 34],
+                1000: [0, 10, 20, 30],
+            },
+            columns=["rna", -1000, 0, 1000],
+        )
+        result = df[[1000]]
+        expected = df.iloc[:, [3]]
+        tm.assert_frame_equal(result, expected)
+        result = df[[-1000]]
+        expected = df.iloc[:, [1]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getattr(self, float_frame):
+        tm.assert_series_equal(float_frame.A, float_frame["A"])
+        msg = "'DataFrame' object has no attribute 'NONEXISTENT_NAME'"
+        with pytest.raises(AttributeError, match=msg):
+            float_frame.NONEXISTENT_NAME
+
+    def test_setattr_column(self):
+        df = DataFrame({"foobar": 1}, index=range(10))
+
+        df.foobar = 5
+        assert (df.foobar == 5).all()
+
+    def test_setitem(self, float_frame):
+        # not sure what else to do here
+        series = float_frame["A"][::2]
+        float_frame["col5"] = series
+        assert "col5" in float_frame
+
+        assert len(series) == 15
+        assert len(float_frame) == 30
+
+        exp = np.ravel(np.column_stack((series.values, [np.nan] * 15)))
+        exp = Series(exp, index=float_frame.index, name="col5")
+        tm.assert_series_equal(float_frame["col5"], exp)
+
+        series = float_frame["A"]
+        float_frame["col6"] = series
+        tm.assert_series_equal(series, float_frame["col6"], check_names=False)
+
+        msg = (
+            r"\"None of \[Float64Index\(\[.*dtype='float64'\)\] are in the "
+            r"\[columns\]\""
+        )
+        with pytest.raises(KeyError, match=msg):
+            float_frame[np.random.randn(len(float_frame) + 1)] = 1
+
+        # set ndarray
+        arr = np.random.randn(len(float_frame))
+        float_frame["col9"] = arr
+        assert (float_frame["col9"] == arr).all()
+
+        float_frame["col7"] = 5
+        assert (float_frame["col7"] == 5).all()
+
+        float_frame["col0"] = 3.14
+        assert (float_frame["col0"] == 3.14).all()
+
+        float_frame["col8"] = "foo"
+        assert (float_frame["col8"] == "foo").all()
+
+        # this is partially a view (e.g. some blocks are view)
+        # so raise/warn
+        smaller = float_frame[:2]
+
+        with pytest.raises(com.SettingWithCopyError):
+            smaller["col10"] = ["1", "2"]
+
+        assert smaller["col10"].dtype == np.object_
+        assert (smaller["col10"] == ["1", "2"]).all()
+
+        # dtype changing GH4204
+        df = DataFrame([[0, 0]])
+        df.iloc[0] = np.nan
+        expected = DataFrame([[np.nan, np.nan]])
+        tm.assert_frame_equal(df, expected)
+
+        df = DataFrame([[0, 0]])
+        df.loc[0] = np.nan
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"])
+    def test_setitem_dtype(self, dtype, float_frame):
+        arr = np.random.randn(len(float_frame))
+
+        float_frame[dtype] = np.array(arr, dtype=dtype)
+        assert float_frame[dtype].dtype.name == dtype
+
+    def test_setitem_tuple(self, float_frame):
+        float_frame["A", "B"] = float_frame["A"]
+        tm.assert_series_equal(
+            float_frame["A", "B"], float_frame["A"], check_names=False
+        )
+
+    def test_setitem_always_copy(self, float_frame):
+        s = float_frame["A"].copy()
+        float_frame["E"] = s
+
+        float_frame["E"][5:10] = np.nan
+        assert notna(s[5:10]).all()
+
+    def test_setitem_boolean(self, float_frame):
+        df = float_frame.copy()
+        values = float_frame.values
+
+        df[df["A"] > 0] = 4
+        values[values[:, 0] > 0] = 4
+        tm.assert_almost_equal(df.values, values)
+
+        # test that column reindexing works
+        series = df["A"] == 4
+        series = series.reindex(df.index[::-1])
+        df[series] = 1
+        values[values[:, 0] == 4] = 1
+        tm.assert_almost_equal(df.values, values)
+
+        df[df > 0] = 5
+        values[values > 0] = 5
+        tm.assert_almost_equal(df.values, values)
+
+        df[df == 5] = 0
+        values[values == 5] = 0
+        tm.assert_almost_equal(df.values, values)
+
+        # a df that needs alignment first
+        df[df[:-1] < 0] = 2
+        np.putmask(values[:-1], values[:-1] < 0, 2)
+        tm.assert_almost_equal(df.values, values)
+
+        # indexed with same shape but rows-reversed df
+        df[df[::-1] == 2] = 3
+        values[values == 2] = 3
+        tm.assert_almost_equal(df.values, values)
+
+        msg = "Must pass DataFrame or 2-d ndarray with boolean values only"
+        with pytest.raises(TypeError, match=msg):
+            df[df * 0] = 2
+
+        # index with DataFrame
+        mask = df > np.abs(df)
+        expected = df.copy()
+        df[df > np.abs(df)] = np.nan
+        expected.values[mask.values] = np.nan
+        tm.assert_frame_equal(df, expected)
+
+        # set from DataFrame
+        expected = df.copy()
+        df[df > np.abs(df)] = df * 2
+        np.putmask(expected.values, mask.values, df.values * 2)
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "mask_type",
+        [lambda df: df > np.abs(df) / 2, lambda df: (df > np.abs(df) / 2).values],
+        ids=["dataframe", "array"],
+    )
+    def test_setitem_boolean_mask(self, mask_type, float_frame):
+
+        # Test for issue #18582
+        df = float_frame.copy()
+        mask = mask_type(df)
+
+        # index with boolean mask
+        result = df.copy()
+        result[mask] = np.nan
+
+        expected = df.copy()
+        expected.values[np.array(mask)] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    def test_setitem_cast(self, float_frame):
+        float_frame["D"] = float_frame["D"].astype("i8")
+        assert float_frame["D"].dtype == np.int64
+
+        # #669, should not cast?
+        # this is now set to int64, which means a replacement of the column to
+        # the value dtype (and nothing to do with the existing dtype)
+        float_frame["B"] = 0
+        assert float_frame["B"].dtype == np.int64
+
+        # cast if pass array of course
+        float_frame["B"] = np.arange(len(float_frame))
+        assert issubclass(float_frame["B"].dtype.type, np.integer)
+
+        float_frame["foo"] = "bar"
+        float_frame["foo"] = 0
+        assert float_frame["foo"].dtype == np.int64
+
+        float_frame["foo"] = "bar"
+        float_frame["foo"] = 2.5
+        assert float_frame["foo"].dtype == np.float64
+
+        float_frame["something"] = 0
+        assert float_frame["something"].dtype == np.int64
+        float_frame["something"] = 2
+        assert float_frame["something"].dtype == np.int64
+        float_frame["something"] = 2.5
+        assert float_frame["something"].dtype == np.float64
+
+        # GH 7704
+        # dtype conversion on setting
+        df = DataFrame(np.random.rand(30, 3), columns=tuple("ABC"))
+        df["event"] = np.nan
+        df.loc[10, "event"] = "foo"
+        result = df.dtypes
+        expected = Series(
+            [np.dtype("float64")] * 3 + [np.dtype("object")],
+            index=["A", "B", "C", "event"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        # Test that data type is preserved . #5782
+        df = DataFrame({"one": np.arange(6, dtype=np.int8)})
+        df.loc[1, "one"] = 6
+        assert df.dtypes.one == np.dtype(np.int8)
+        df.one = np.int8(7)
+        assert df.dtypes.one == np.dtype(np.int8)
+
+    def test_setitem_boolean_column(self, float_frame):
+        expected = float_frame.copy()
+        mask = float_frame["A"] > 0
+
+        float_frame.loc[mask, "B"] = 0
+        expected.values[mask.values, 1] = 0
+
+        tm.assert_frame_equal(float_frame, expected)
+
+    def test_frame_setitem_timestamp(self):
+        # GH#2155
+        columns = date_range(start="1/1/2012", end="2/1/2012", freq=BDay())
+        data = DataFrame(columns=columns, index=range(10))
+        t = datetime(2012, 11, 1)
+        ts = Timestamp(t)
+        data[ts] = np.nan  # works, mostly a smoke-test
+        assert np.isnan(data[ts]).all()
+
+    def test_setitem_corner(self, float_frame):
+        # corner case
+        df = DataFrame({"B": [1.0, 2.0, 3.0], "C": ["a", "b", "c"]}, index=np.arange(3))
+        del df["B"]
+        df["B"] = [1.0, 2.0, 3.0]
+        assert "B" in df
+        assert len(df.columns) == 2
+
+        df["A"] = "beginning"
+        df["E"] = "foo"
+        df["D"] = "bar"
+        df[datetime.now()] = "date"
+        df[datetime.now()] = 5.0
+
+        # what to do when empty frame with index
+        dm = DataFrame(index=float_frame.index)
+        dm["A"] = "foo"
+        dm["B"] = "bar"
+        assert len(dm.columns) == 2
+        assert dm.values.dtype == np.object_
+
+        # upcast
+        dm["C"] = 1
+        assert dm["C"].dtype == np.int64
+
+        dm["E"] = 1.0
+        assert dm["E"].dtype == np.float64
+
+        # set existing column
+        dm["A"] = "bar"
+        assert "bar" == dm["A"][0]
+
+        dm = DataFrame(index=np.arange(3))
+        dm["A"] = 1
+        dm["foo"] = "bar"
+        del dm["foo"]
+        dm["foo"] = "bar"
+        assert dm["foo"].dtype == np.object_
+
+        dm["coercable"] = ["1", "2", "3"]
+        assert dm["coercable"].dtype == np.object_
+
+    def test_setitem_corner2(self):
+        data = {
+            "title": ["foobar", "bar", "foobar"] + ["foobar"] * 17,
+            "cruft": np.random.random(20),
+        }
+
+        df = DataFrame(data)
+        ix = df[df["title"] == "bar"].index
+
+        df.loc[ix, ["title"]] = "foobar"
+        df.loc[ix, ["cruft"]] = 0
+
+        assert df.loc[1, "title"] == "foobar"
+        assert df.loc[1, "cruft"] == 0
+
+    def test_setitem_ambig(self):
+        # Difficulties with mixed-type data
+        from decimal import Decimal
+
+        # Created as float type
+        dm = DataFrame(index=range(3), columns=range(3))
+
+        coercable_series = Series([Decimal(1) for _ in range(3)], index=range(3))
+        uncoercable_series = Series(["foo", "bzr", "baz"], index=range(3))
+
+        dm[0] = np.ones(3)
+        assert len(dm.columns) == 3
+
+        dm[1] = coercable_series
+        assert len(dm.columns) == 3
+
+        dm[2] = uncoercable_series
+        assert len(dm.columns) == 3
+        assert dm[2].dtype == np.object_
+
+    def test_setitem_clear_caches(self):
+        # see gh-304
+        df = DataFrame(
+            {"x": [1.1, 2.1, 3.1, 4.1], "y": [5.1, 6.1, 7.1, 8.1]}, index=[0, 1, 2, 3]
+        )
+        df.insert(2, "z", np.nan)
+
+        # cache it
+        foo = df["z"]
+        df.loc[df.index[2:], "z"] = 42
+
+        expected = Series([np.nan, np.nan, 42, 42], index=df.index, name="z")
+
+        assert df["z"] is not foo
+        tm.assert_series_equal(df["z"], expected)
+
+    def test_setitem_None(self, float_frame):
+        # GH #766
+        float_frame[None] = float_frame["A"]
+        tm.assert_series_equal(
+            float_frame.iloc[:, -1], float_frame["A"], check_names=False
+        )
+        tm.assert_series_equal(
+            float_frame.loc[:, None], float_frame["A"], check_names=False
+        )
+        tm.assert_series_equal(float_frame[None], float_frame["A"], check_names=False)
+        repr(float_frame)
+
+    def test_setitem_empty(self):
+        # GH 9596
+        df = pd.DataFrame(
+            {"a": ["1", "2", "3"], "b": ["11", "22", "33"], "c": ["111", "222", "333"]}
+        )
+
+        result = df.copy()
+        result.loc[result.b.isna(), "a"] = result.a
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("dtype", ["float", "int64"])
+    @pytest.mark.parametrize("kwargs", [dict(), dict(index=[1]), dict(columns=["A"])])
+    def test_setitem_empty_frame_with_boolean(self, dtype, kwargs):
+        # see gh-10126
+        kwargs["dtype"] = dtype
+        df = DataFrame(**kwargs)
+
+        df2 = df.copy()
+        df[df > df2] = 47
+        tm.assert_frame_equal(df, df2)
+
+    def test_setitem_with_empty_listlike(self):
+        # GH #17101
+        index = pd.Index([], name="idx")
+        result = pd.DataFrame(columns=["A"], index=index)
+        result["A"] = []
+        expected = pd.DataFrame(columns=["A"], index=index)
+        tm.assert_index_equal(result.index, expected.index)
+
+    def test_setitem_scalars_no_index(self):
+        # GH16823 / 17894
+        df = DataFrame()
+        df["foo"] = 1
+        expected = DataFrame(columns=["foo"]).astype(np.int64)
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_empty_frame_with_boolean(self):
+        # Test for issue #11859
+
+        df = pd.DataFrame()
+        df2 = df[df > 0]
+        tm.assert_frame_equal(df, df2)
+
+    def test_delitem_corner(self, float_frame):
+        f = float_frame.copy()
+        del f["D"]
+        assert len(f.columns) == 3
+        with pytest.raises(KeyError, match=r"^'D'$"):
+            del f["D"]
+        del f["B"]
+        assert len(f.columns) == 2
+
+    def test_slice_floats(self):
+        index = [52195.504153, 52196.303147, 52198.369883]
+        df = DataFrame(np.random.rand(3, 2), index=index)
+
+        s1 = df.loc[52195.1:52196.5]
+        assert len(s1) == 2
+
+        s1 = df.loc[52195.1:52196.6]
+        assert len(s1) == 2
+
+        s1 = df.loc[52195.1:52198.9]
+        assert len(s1) == 3
+
+    def test_getitem_fancy_slice_integers_step(self):
+        df = DataFrame(np.random.randn(10, 5))
+
+        # this is OK
+        result = df.iloc[:8:2]  # noqa
+        df.iloc[:8:2] = np.nan
+        assert isna(df.iloc[:8:2]).values.all()
+
+    def test_getitem_setitem_integer_slice_keyerrors(self):
+        df = DataFrame(np.random.randn(10, 5), index=range(0, 20, 2))
+
+        # this is OK
+        cp = df.copy()
+        cp.iloc[4:10] = 0
+        assert (cp.iloc[4:10] == 0).values.all()
+
+        # so is this
+        cp = df.copy()
+        cp.iloc[3:11] = 0
+        assert (cp.iloc[3:11] == 0).values.all()
+
+        result = df.iloc[2:6]
+        result2 = df.loc[3:11]
+        expected = df.reindex([4, 6, 8, 10])
+
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        # non-monotonic, raise KeyError
+        df2 = df.iloc[list(range(5)) + list(range(5, 10))[::-1]]
+        with pytest.raises(KeyError, match=r"^3$"):
+            df2.loc[3:11]
+        with pytest.raises(KeyError, match=r"^3$"):
+            df2.loc[3:11] = 0
+
+    def test_fancy_getitem_slice_mixed(self, float_frame, float_string_frame):
+        sliced = float_string_frame.iloc[:, -3:]
+        assert sliced["D"].dtype == np.float64
+
+        # get view with single block
+        # setting it triggers setting with copy
+        sliced = float_frame.iloc[:, -3:]
+
+        with pytest.raises(com.SettingWithCopyError):
+            sliced["C"] = 4.0
+
+        assert (float_frame["C"] == 4).all()
+
+    def test_setitem_slice_position(self):
+        # GH#31469
+        df = pd.DataFrame(np.zeros((100, 1)))
+        df[-4:] = 1
+        arr = np.zeros((100, 1))
+        arr[-4:] = 1
+        expected = pd.DataFrame(arr)
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_setitem_non_ix_labels(self):
+        df = tm.makeTimeDataFrame()
+
+        start, end = df.index[[5, 10]]
+
+        result = df.loc[start:end]
+        result2 = df[start:end]
+        expected = df[5:11]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        result = df.copy()
+        result.loc[start:end] = 0
+        result2 = df.copy()
+        result2[start:end] = 0
+        expected = df.copy()
+        expected[5:11] = 0
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+    def test_ix_multi_take(self):
+        df = DataFrame(np.random.randn(3, 2))
+        rs = df.loc[df.index == 0, :]
+        xp = df.reindex([0])
+        tm.assert_frame_equal(rs, xp)
+
+        # FIXME: dont leave commented-out
+        """ #1321
+        df = DataFrame(np.random.randn(3, 2))
+        rs = df.loc[df.index==0, df.columns==1]
+        xp = df.reindex([0], [1])
+        tm.assert_frame_equal(rs, xp)
+        """
+
+    def test_getitem_fancy_scalar(self, float_frame):
+        f = float_frame
+        ix = f.loc
+
+        # individual value
+        for col in f.columns:
+            ts = f[col]
+            for idx in f.index[::5]:
+                assert ix[idx, col] == ts[idx]
+
+    def test_setitem_fancy_scalar(self, float_frame):
+        f = float_frame
+        expected = float_frame.copy()
+        ix = f.loc
+
+        # individual value
+        for j, col in enumerate(f.columns):
+            ts = f[col]  # noqa
+            for idx in f.index[::5]:
+                i = f.index.get_loc(idx)
+                val = np.random.randn()
+                expected.values[i, j] = val
+
+                ix[idx, col] = val
+                tm.assert_frame_equal(f, expected)
+
+    def test_getitem_fancy_boolean(self, float_frame):
+        f = float_frame
+        ix = f.loc
+
+        expected = f.reindex(columns=["B", "D"])
+        result = ix[:, [False, True, False, True]]
+        tm.assert_frame_equal(result, expected)
+
+        expected = f.reindex(index=f.index[5:10], columns=["B", "D"])
+        result = ix[f.index[5:10], [False, True, False, True]]
+        tm.assert_frame_equal(result, expected)
+
+        boolvec = f.index > f.index[7]
+        expected = f.reindex(index=f.index[boolvec])
+        result = ix[boolvec]
+        tm.assert_frame_equal(result, expected)
+        result = ix[boolvec, :]
+        tm.assert_frame_equal(result, expected)
+
+        result = ix[boolvec, f.columns[2:]]
+        expected = f.reindex(index=f.index[boolvec], columns=["C", "D"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_setitem_fancy_boolean(self, float_frame):
+        # from 2d, set with booleans
+        frame = float_frame.copy()
+        expected = float_frame.copy()
+
+        mask = frame["A"] > 0
+        frame.loc[mask] = 0.0
+        expected.values[mask.values] = 0.0
+        tm.assert_frame_equal(frame, expected)
+
+        frame = float_frame.copy()
+        expected = float_frame.copy()
+        frame.loc[mask, ["A", "B"]] = 0.0
+        expected.values[mask.values, :2] = 0.0
+        tm.assert_frame_equal(frame, expected)
+
+    def test_getitem_fancy_ints(self, float_frame):
+        result = float_frame.iloc[[1, 4, 7]]
+        expected = float_frame.loc[float_frame.index[[1, 4, 7]]]
+        tm.assert_frame_equal(result, expected)
+
+        result = float_frame.iloc[:, [2, 0, 1]]
+        expected = float_frame.loc[:, float_frame.columns[[2, 0, 1]]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_setitem_fancy_exceptions(self, float_frame):
+        ix = float_frame.iloc
+        with pytest.raises(IndexingError, match="Too many indexers"):
+            ix[:, :, :]
+
+        with pytest.raises(IndexingError):
+            ix[:, :, :] = 1
+
+    def test_getitem_setitem_boolean_misaligned(self, float_frame):
+        # boolean index misaligned labels
+        mask = float_frame["A"][::-1] > 1
+
+        result = float_frame.loc[mask]
+        expected = float_frame.loc[mask[::-1]]
+        tm.assert_frame_equal(result, expected)
+
+        cp = float_frame.copy()
+        expected = float_frame.copy()
+        cp.loc[mask] = 0
+        expected.loc[mask] = 0
+        tm.assert_frame_equal(cp, expected)
+
+    def test_getitem_setitem_boolean_multi(self):
+        df = DataFrame(np.random.randn(3, 2))
+
+        # get
+        k1 = np.array([True, False, True])
+        k2 = np.array([False, True])
+        result = df.loc[k1, k2]
+        expected = df.loc[[0, 2], [1]]
+        tm.assert_frame_equal(result, expected)
+
+        expected = df.copy()
+        df.loc[np.array([True, False, True]), np.array([False, True])] = 5
+        expected.loc[[0, 2], [1]] = 5
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_setitem_float_labels(self):
+        index = Index([1.5, 2, 3, 4, 5])
+        df = DataFrame(np.random.randn(5, 5), index=index)
+
+        result = df.loc[1.5:4]
+        expected = df.reindex([1.5, 2, 3, 4])
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 4
+
+        result = df.loc[4:5]
+        expected = df.reindex([4, 5])  # reindex with int
+        tm.assert_frame_equal(result, expected, check_index_type=False)
+        assert len(result) == 2
+
+        result = df.loc[4:5]
+        expected = df.reindex([4.0, 5.0])  # reindex with float
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 2
+
+        # loc_float changes this to work properly
+        result = df.loc[1:2]
+        expected = df.iloc[0:2]
+        tm.assert_frame_equal(result, expected)
+
+        df.loc[1:2] = 0
+        result = df[1:2]
+        assert (result == 0).all().all()
+
+        # #2727
+        index = Index([1.0, 2.5, 3.5, 4.5, 5.0])
+        df = DataFrame(np.random.randn(5, 5), index=index)
+
+        # positional slicing only via iloc!
+        msg = (
+            "cannot do positional indexing on Float64Index with "
+            r"these indexers \[1.0\] of type float"
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.iloc[1.0:5]
+
+        result = df.iloc[4:5]
+        expected = df.reindex([5.0])
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 1
+
+        cp = df.copy()
+
+        with pytest.raises(TypeError):
+            cp.iloc[1.0:5] = 0
+
+        with pytest.raises(TypeError):
+            result = cp.iloc[1.0:5] == 0  # noqa
+
+        assert result.values.all()
+        assert (cp.iloc[0:1] == df.iloc[0:1]).values.all()
+
+        cp = df.copy()
+        cp.iloc[4:5] = 0
+        assert (cp.iloc[4:5] == 0).values.all()
+        assert (cp.iloc[0:4] == df.iloc[0:4]).values.all()
+
+        # float slicing
+        result = df.loc[1.0:5]
+        expected = df
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 5
+
+        result = df.loc[1.1:5]
+        expected = df.reindex([2.5, 3.5, 4.5, 5.0])
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 4
+
+        result = df.loc[4.51:5]
+        expected = df.reindex([5.0])
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 1
+
+        result = df.loc[1.0:5.0]
+        expected = df.reindex([1.0, 2.5, 3.5, 4.5, 5.0])
+        tm.assert_frame_equal(result, expected)
+        assert len(result) == 5
+
+        cp = df.copy()
+        cp.loc[1.0:5.0] = 0
+        result = cp.loc[1.0:5.0]
+        assert (result == 0).values.all()
+
+    def test_setitem_single_column_mixed(self):
+        df = DataFrame(
+            np.random.randn(5, 3),
+            index=["a", "b", "c", "d", "e"],
+            columns=["foo", "bar", "baz"],
+        )
+        df["str"] = "qux"
+        df.loc[df.index[::2], "str"] = np.nan
+        expected = np.array([np.nan, "qux", np.nan, "qux", np.nan], dtype=object)
+        tm.assert_almost_equal(df["str"].values, expected)
+
+    def test_setitem_single_column_mixed_datetime(self):
+        df = DataFrame(
+            np.random.randn(5, 3),
+            index=["a", "b", "c", "d", "e"],
+            columns=["foo", "bar", "baz"],
+        )
+
+        df["timestamp"] = Timestamp("20010102")
+
+        # check our dtypes
+        result = df.dtypes
+        expected = Series(
+            [np.dtype("float64")] * 3 + [np.dtype("datetime64[ns]")],
+            index=["foo", "bar", "baz", "timestamp"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        # GH#16674 iNaT is treated as an integer when given by the user
+        df.loc["b", "timestamp"] = iNaT
+        assert not isna(df.loc["b", "timestamp"])
+        assert df["timestamp"].dtype == np.object_
+        assert df.loc["b", "timestamp"] == iNaT
+
+        # allow this syntax
+        df.loc["c", "timestamp"] = np.nan
+        assert isna(df.loc["c", "timestamp"])
+
+        # allow this syntax
+        df.loc["d", :] = np.nan
+        assert not isna(df.loc["c", :]).all()
+
+        # FIXME: don't leave commented-out
+        # as of GH 3216 this will now work!
+        # try to set with a list like item
+        # pytest.raises(
+        #    Exception, df.loc.__setitem__, ('d', 'timestamp'), [np.nan])
+
+    def test_setitem_mixed_datetime(self):
+        # GH 9336
+        expected = DataFrame(
+            {
+                "a": [0, 0, 0, 0, 13, 14],
+                "b": [
+                    datetime(2012, 1, 1),
+                    1,
+                    "x",
+                    "y",
+                    datetime(2013, 1, 1),
+                    datetime(2014, 1, 1),
+                ],
+            }
+        )
+        df = pd.DataFrame(0, columns=list("ab"), index=range(6))
+        df["b"] = pd.NaT
+        df.loc[0, "b"] = datetime(2012, 1, 1)
+        df.loc[1, "b"] = 1
+        df.loc[[2, 3], "b"] = "x", "y"
+        A = np.array(
+            [
+                [13, np.datetime64("2013-01-01T00:00:00")],
+                [14, np.datetime64("2014-01-01T00:00:00")],
+            ]
+        )
+        df.loc[[4, 5], ["a", "b"]] = A
+        tm.assert_frame_equal(df, expected)
+
+    def test_setitem_frame_float(self, float_frame):
+        piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
+        float_frame.loc[float_frame.index[-2] :, ["A", "B"]] = piece.values
+        result = float_frame.loc[float_frame.index[-2:], ["A", "B"]].values
+        expected = piece.values
+        tm.assert_almost_equal(result, expected)
+
+    def test_setitem_frame_mixed(self, float_string_frame):
+        # GH 3216
+
+        # already aligned
+        f = float_string_frame.copy()
+        piece = DataFrame(
+            [[1.0, 2.0], [3.0, 4.0]], index=f.index[0:2], columns=["A", "B"]
+        )
+        key = (slice(None, 2), ["A", "B"])
+        f.loc[key] = piece
+        tm.assert_almost_equal(f.loc[f.index[0:2], ["A", "B"]].values, piece.values)
+
+        # rows unaligned
+        f = float_string_frame.copy()
+        piece = DataFrame(
+            [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]],
+            index=list(f.index[0:2]) + ["foo", "bar"],
+            columns=["A", "B"],
+        )
+        key = (slice(None, 2), ["A", "B"])
+        f.loc[key] = piece
+        tm.assert_almost_equal(
+            f.loc[f.index[0:2:], ["A", "B"]].values, piece.values[0:2]
+        )
+
+        # key is unaligned with values
+        f = float_string_frame.copy()
+        piece = f.loc[f.index[:2], ["A"]]
+        piece.index = f.index[-2:]
+        key = (slice(-2, None), ["A", "B"])
+        f.loc[key] = piece
+        piece["B"] = np.nan
+        tm.assert_almost_equal(f.loc[f.index[-2:], ["A", "B"]].values, piece.values)
+
+        # ndarray
+        f = float_string_frame.copy()
+        piece = float_string_frame.loc[f.index[:2], ["A", "B"]]
+        key = (slice(-2, None), ["A", "B"])
+        f.loc[key] = piece.values
+        tm.assert_almost_equal(f.loc[f.index[-2:], ["A", "B"]].values, piece.values)
+
+    def test_setitem_frame_upcast(self):
+        # needs upcasting
+        df = DataFrame([[1, 2, "foo"], [3, 4, "bar"]], columns=["A", "B", "C"])
+        df2 = df.copy()
+        df2.loc[:, ["A", "B"]] = df.loc[:, ["A", "B"]] + 0.5
+        expected = df.reindex(columns=["A", "B"])
+        expected += 0.5
+        expected["C"] = df["C"]
+        tm.assert_frame_equal(df2, expected)
+
+    def test_setitem_frame_align(self, float_frame):
+        piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
+        piece.index = float_frame.index[-2:]
+        piece.columns = ["A", "B"]
+        float_frame.loc[float_frame.index[-2:], ["A", "B"]] = piece
+        result = float_frame.loc[float_frame.index[-2:], ["A", "B"]].values
+        expected = piece.values
+        tm.assert_almost_equal(result, expected)
+
+    def test_getitem_setitem_ix_duplicates(self):
+        # #1201
+        df = DataFrame(np.random.randn(5, 3), index=["foo", "foo", "bar", "baz", "bar"])
+
+        result = df.loc["foo"]
+        expected = df[:2]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc["bar"]
+        expected = df.iloc[[2, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc["baz"]
+        expected = df.iloc[3]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_ix_boolean_duplicates_multiple(self):
+        # #1201
+        df = DataFrame(np.random.randn(5, 3), index=["foo", "foo", "bar", "baz", "bar"])
+
+        result = df.loc[["bar"]]
+        exp = df.iloc[[2, 4]]
+        tm.assert_frame_equal(result, exp)
+
+        result = df.loc[df[1] > 0]
+        exp = df[df[1] > 0]
+        tm.assert_frame_equal(result, exp)
+
+        result = df.loc[df[0] > 0]
+        exp = df[df[0] > 0]
+        tm.assert_frame_equal(result, exp)
+
+    def test_getitem_setitem_ix_bool_keyerror(self):
+        # #2199
+        df = DataFrame({"a": [1, 2, 3]})
+
+        with pytest.raises(KeyError, match=r"^False$"):
+            df.loc[False]
+        with pytest.raises(KeyError, match=r"^True$"):
+            df.loc[True]
+
+        msg = "cannot use a single bool to index into setitem"
+        with pytest.raises(KeyError, match=msg):
+            df.loc[False] = 0
+        with pytest.raises(KeyError, match=msg):
+            df.loc[True] = 0
+
+    def test_getitem_list_duplicates(self):
+        # #1943
+        df = DataFrame(np.random.randn(4, 4), columns=list("AABC"))
+        df.columns.name = "foo"
+
+        result = df[["B", "C"]]
+        assert result.columns.name == "foo"
+
+        expected = df.iloc[:, 2:]
+        tm.assert_frame_equal(result, expected)
+
+    def test_get_value(self, float_frame):
+        for idx in float_frame.index:
+            for col in float_frame.columns:
+                result = float_frame._get_value(idx, col)
+                expected = float_frame[col][idx]
+                assert result == expected
+
+    def test_lookup_float(self, float_frame):
+        df = float_frame
+        rows = list(df.index) * len(df.columns)
+        cols = list(df.columns) * len(df.index)
+        result = df.lookup(rows, cols)
+
+        expected = np.array([df.loc[r, c] for r, c in zip(rows, cols)])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_lookup_mixed(self, float_string_frame):
+        df = float_string_frame
+        rows = list(df.index) * len(df.columns)
+        cols = list(df.columns) * len(df.index)
+        result = df.lookup(rows, cols)
+
+        expected = np.array(
+            [df.loc[r, c] for r, c in zip(rows, cols)], dtype=np.object_
+        )
+        tm.assert_almost_equal(result, expected)
+
+    def test_lookup_bool(self):
+        df = DataFrame(
+            {
+                "label": ["a", "b", "a", "c"],
+                "mask_a": [True, True, False, True],
+                "mask_b": [True, False, False, False],
+                "mask_c": [False, True, False, True],
+            }
+        )
+        df["mask"] = df.lookup(df.index, "mask_" + df["label"])
+
+        exp_mask = np.array(
+            [df.loc[r, c] for r, c in zip(df.index, "mask_" + df["label"])]
+        )
+
+        tm.assert_series_equal(df["mask"], pd.Series(exp_mask, name="mask"))
+        assert df["mask"].dtype == np.bool_
+
+    def test_lookup_raises(self, float_frame):
+        with pytest.raises(KeyError, match="'One or more row labels was not found'"):
+            float_frame.lookup(["xyz"], ["A"])
+
+        with pytest.raises(KeyError, match="'One or more column labels was not found'"):
+            float_frame.lookup([float_frame.index[0]], ["xyz"])
+
+        with pytest.raises(ValueError, match="same size"):
+            float_frame.lookup(["a", "b", "c"], ["a"])
+
+    def test_set_value(self, float_frame):
+        for idx in float_frame.index:
+            for col in float_frame.columns:
+                float_frame._set_value(idx, col, 1)
+                assert float_frame[col][idx] == 1
+
+    def test_set_value_resize(self, float_frame):
+
+        res = float_frame._set_value("foobar", "B", 0)
+        assert res is None
+        assert float_frame.index[-1] == "foobar"
+        assert float_frame._get_value("foobar", "B") == 0
+
+        float_frame.loc["foobar", "qux"] = 0
+        assert float_frame._get_value("foobar", "qux") == 0
+
+        res = float_frame.copy()
+        res._set_value("foobar", "baz", "sam")
+        assert res["baz"].dtype == np.object_
+
+        res = float_frame.copy()
+        res._set_value("foobar", "baz", True)
+        assert res["baz"].dtype == np.object_
+
+        res = float_frame.copy()
+        res._set_value("foobar", "baz", 5)
+        assert is_float_dtype(res["baz"])
+        assert isna(res["baz"].drop(["foobar"])).all()
+        msg = "could not convert string to float: 'sam'"
+        with pytest.raises(ValueError, match=msg):
+            res._set_value("foobar", "baz", "sam")
+
+    def test_set_value_with_index_dtype_change(self):
+        df_orig = DataFrame(np.random.randn(3, 3), index=range(3), columns=list("ABC"))
+
+        # this is actually ambiguous as the 2 is interpreted as a positional
+        # so column is not created
+        df = df_orig.copy()
+        df._set_value("C", 2, 1.0)
+        assert list(df.index) == list(df_orig.index) + ["C"]
+        # assert list(df.columns) == list(df_orig.columns) + [2]
+
+        df = df_orig.copy()
+        df.loc["C", 2] = 1.0
+        assert list(df.index) == list(df_orig.index) + ["C"]
+        # assert list(df.columns) == list(df_orig.columns) + [2]
+
+        # create both new
+        df = df_orig.copy()
+        df._set_value("C", "D", 1.0)
+        assert list(df.index) == list(df_orig.index) + ["C"]
+        assert list(df.columns) == list(df_orig.columns) + ["D"]
+
+        df = df_orig.copy()
+        df.loc["C", "D"] = 1.0
+        assert list(df.index) == list(df_orig.index) + ["C"]
+        assert list(df.columns) == list(df_orig.columns) + ["D"]
+
+    def test_get_set_value_no_partial_indexing(self):
+        # partial w/ MultiIndex raise exception
+        index = MultiIndex.from_tuples([(0, 1), (0, 2), (1, 1), (1, 2)])
+        df = DataFrame(index=index, columns=range(4))
+        with pytest.raises(KeyError, match=r"^0$"):
+            df._get_value(0, 1)
+
+    # TODO: rename?  remove?
+    def test_single_element_ix_dont_upcast(self, float_frame):
+        float_frame["E"] = 1
+        assert issubclass(float_frame["E"].dtype.type, (int, np.integer))
+
+        result = float_frame.loc[float_frame.index[5], "E"]
+        assert is_integer(result)
+
+        # GH 11617
+        df = pd.DataFrame(dict(a=[1.23]))
+        df["b"] = 666
+
+        result = df.loc[0, "b"]
+        assert is_integer(result)
+
+        expected = Series([666], [0], name="b")
+        result = df.loc[[0], "b"]
+        tm.assert_series_equal(result, expected)
+
+    def test_iloc_row(self):
+        df = DataFrame(np.random.randn(10, 4), index=range(0, 20, 2))
+
+        result = df.iloc[1]
+        exp = df.loc[2]
+        tm.assert_series_equal(result, exp)
+
+        result = df.iloc[2]
+        exp = df.loc[4]
+        tm.assert_series_equal(result, exp)
+
+        # slice
+        result = df.iloc[slice(4, 8)]
+        expected = df.loc[8:14]
+        tm.assert_frame_equal(result, expected)
+
+        # verify slice is view
+        # setting it makes it raise/warn
+        with pytest.raises(com.SettingWithCopyError):
+            result[2] = 0.0
+
+        exp_col = df[2].copy()
+        exp_col[4:8] = 0.0
+        tm.assert_series_equal(df[2], exp_col)
+
+        # list of integers
+        result = df.iloc[[1, 2, 4, 6]]
+        expected = df.reindex(df.index[[1, 2, 4, 6]])
+        tm.assert_frame_equal(result, expected)
+
+    def test_iloc_col(self):
+
+        df = DataFrame(np.random.randn(4, 10), columns=range(0, 20, 2))
+
+        result = df.iloc[:, 1]
+        exp = df.loc[:, 2]
+        tm.assert_series_equal(result, exp)
+
+        result = df.iloc[:, 2]
+        exp = df.loc[:, 4]
+        tm.assert_series_equal(result, exp)
+
+        # slice
+        result = df.iloc[:, slice(4, 8)]
+        expected = df.loc[:, 8:14]
+        tm.assert_frame_equal(result, expected)
+
+        # verify slice is view
+        # and that we are setting a copy
+        with pytest.raises(com.SettingWithCopyError):
+            result[8] = 0.0
+
+        assert (df[8] == 0).all()
+
+        # list of integers
+        result = df.iloc[:, [1, 2, 4, 6]]
+        expected = df.reindex(columns=df.columns[[1, 2, 4, 6]])
+        tm.assert_frame_equal(result, expected)
+
+    def test_iloc_duplicates(self):
+
+        df = DataFrame(np.random.rand(3, 3), columns=list("ABC"), index=list("aab"))
+
+        result = df.iloc[0]
+        assert isinstance(result, Series)
+        tm.assert_almost_equal(result.values, df.values[0])
+
+        result = df.T.iloc[:, 0]
+        assert isinstance(result, Series)
+        tm.assert_almost_equal(result.values, df.values[0])
+
+        # #2259
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[1, 1, 2])
+        result = df.iloc[:, [0]]
+        expected = df.take([0], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_duplicates(self):
+        # gh-17105
+
+        # insert a duplicate element to the index
+        trange = pd.date_range(
+            start=pd.Timestamp(year=2017, month=1, day=1),
+            end=pd.Timestamp(year=2017, month=1, day=5),
+        )
+
+        trange = trange.insert(loc=5, item=pd.Timestamp(year=2017, month=1, day=5))
+
+        df = pd.DataFrame(0, index=trange, columns=["A", "B"])
+        bool_idx = np.array([False, False, False, False, False, True])
+
+        # assignment
+        df.loc[trange[bool_idx], "A"] = 6
+
+        expected = pd.DataFrame(
+            {"A": [0, 0, 0, 0, 6, 6], "B": [0, 0, 0, 0, 0, 0]}, index=trange
+        )
+        tm.assert_frame_equal(df, expected)
+
+        # in-place
+        df = pd.DataFrame(0, index=trange, columns=["A", "B"])
+        df.loc[trange[bool_idx], "A"] += 6
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "method,expected_values",
+        [
+            ("nearest", [0, 1, 1, 2]),
+            ("pad", [np.nan, 0, 1, 1]),
+            ("backfill", [0, 1, 2, 2]),
+        ],
+    )
+    def test_reindex_methods(self, method, expected_values):
+        df = pd.DataFrame({"x": list(range(5))})
+        target = np.array([-0.1, 0.9, 1.1, 1.5])
+
+        expected = pd.DataFrame({"x": expected_values}, index=target)
+        actual = df.reindex(target, method=method)
+        tm.assert_frame_equal(expected, actual)
+
+        actual = df.reindex_like(df, method=method, tolerance=0)
+        tm.assert_frame_equal(df, actual)
+        actual = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
+        tm.assert_frame_equal(df, actual)
+
+        actual = df.reindex(target, method=method, tolerance=1)
+        tm.assert_frame_equal(expected, actual)
+        actual = df.reindex(target, method=method, tolerance=[1, 1, 1, 1])
+        tm.assert_frame_equal(expected, actual)
+
+        e2 = expected[::-1]
+        actual = df.reindex(target[::-1], method=method)
+        tm.assert_frame_equal(e2, actual)
+
+        new_order = [3, 0, 2, 1]
+        e2 = expected.iloc[new_order]
+        actual = df.reindex(target[new_order], method=method)
+        tm.assert_frame_equal(e2, actual)
+
+        switched_method = (
+            "pad" if method == "backfill" else "backfill" if method == "pad" else method
+        )
+        actual = df[::-1].reindex(target, method=switched_method)
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_methods_nearest_special(self):
+        df = pd.DataFrame({"x": list(range(5))})
+        target = np.array([-0.1, 0.9, 1.1, 1.5])
+
+        expected = pd.DataFrame({"x": [0, 1, 1, np.nan]}, index=target)
+        actual = df.reindex(target, method="nearest", tolerance=0.2)
+        tm.assert_frame_equal(expected, actual)
+
+        expected = pd.DataFrame({"x": [0, np.nan, 1, np.nan]}, index=target)
+        actual = df.reindex(target, method="nearest", tolerance=[0.5, 0.01, 0.4, 0.1])
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_nearest_tz(self, tz_aware_fixture):
+        # GH26683
+        tz = tz_aware_fixture
+        idx = pd.date_range("2019-01-01", periods=5, tz=tz)
+        df = pd.DataFrame({"x": list(range(5))}, index=idx)
+
+        expected = df.head(3)
+        actual = df.reindex(idx[:3], method="nearest")
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_frame_add_nat(self):
+        rng = date_range("1/1/2000 00:00:00", periods=10, freq="10s")
+        df = DataFrame({"A": np.random.randn(len(rng)), "B": rng})
+
+        result = df.reindex(range(15))
+        assert np.issubdtype(result["B"].dtype, np.dtype("M8[ns]"))
+
+        mask = com.isna(result)["B"]
+        assert mask[-5:].all()
+        assert not mask[:-5].any()
+
+    def test_reindex_limit(self):
+        # GH 28631
+        data = [["A", "A", "A"], ["B", "B", "B"], ["C", "C", "C"], ["D", "D", "D"]]
+        exp_data = [
+            ["A", "A", "A"],
+            ["B", "B", "B"],
+            ["C", "C", "C"],
+            ["D", "D", "D"],
+            ["D", "D", "D"],
+            [np.nan, np.nan, np.nan],
+        ]
+        df = DataFrame(data)
+        result = df.reindex([0, 1, 2, 3, 4, 5], method="ffill", limit=1)
+        expected = DataFrame(exp_data)
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_dataframe_column_ns_dtype(self):
+        x = DataFrame([datetime.now(), datetime.now()])
+        assert x[0].dtype == np.dtype("M8[ns]")
+
+    def test_non_monotonic_reindex_methods(self):
+        dr = pd.date_range("2013-08-01", periods=6, freq="B")
+        data = np.random.randn(6, 1)
+        df = pd.DataFrame(data, index=dr, columns=list("A"))
+        df_rev = pd.DataFrame(data, index=dr[[3, 4, 5] + [0, 1, 2]], columns=list("A"))
+        # index is not monotonic increasing or decreasing
+        msg = "index must be monotonic increasing or decreasing"
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="pad")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="ffill")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="bfill")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="nearest")
+
+    def test_reindex_level(self):
+        from itertools import permutations
+
+        icol = ["jim", "joe", "jolie"]
+
+        def verify_first_level(df, level, idx, check_index_type=True):
+            def f(val):
+                return np.nonzero((df[level] == val).to_numpy())[0]
+
+            i = np.concatenate(list(map(f, idx)))
+            left = df.set_index(icol).reindex(idx, level=level)
+            right = df.iloc[i].set_index(icol)
+            tm.assert_frame_equal(left, right, check_index_type=check_index_type)
+
+        def verify(df, level, idx, indexer, check_index_type=True):
+            left = df.set_index(icol).reindex(idx, level=level)
+            right = df.iloc[indexer].set_index(icol)
+            tm.assert_frame_equal(left, right, check_index_type=check_index_type)
+
+        df = pd.DataFrame(
+            {
+                "jim": list("B" * 4 + "A" * 2 + "C" * 3),
+                "joe": list("abcdeabcd")[::-1],
+                "jolie": [10, 20, 30] * 3,
+                "joline": np.random.randint(0, 1000, 9),
+            }
+        )
+
+        target = [
+            ["C", "B", "A"],
+            ["F", "C", "A", "D"],
+            ["A"],
+            ["A", "B", "C"],
+            ["C", "A", "B"],
+            ["C", "B"],
+            ["C", "A"],
+            ["A", "B"],
+            ["B", "A", "C"],
+        ]
+
+        for idx in target:
+            verify_first_level(df, "jim", idx)
+
+        # reindex by these causes different MultiIndex levels
+        for idx in [["D", "F"], ["A", "C", "B"]]:
+            verify_first_level(df, "jim", idx, check_index_type=False)
+
+        verify(df, "joe", list("abcde"), [3, 2, 1, 0, 5, 4, 8, 7, 6])
+        verify(df, "joe", list("abcd"), [3, 2, 1, 0, 5, 8, 7, 6])
+        verify(df, "joe", list("abc"), [3, 2, 1, 8, 7, 6])
+        verify(df, "joe", list("eca"), [1, 3, 4, 6, 8])
+        verify(df, "joe", list("edc"), [0, 1, 4, 5, 6])
+        verify(df, "joe", list("eadbc"), [3, 0, 2, 1, 4, 5, 8, 7, 6])
+        verify(df, "joe", list("edwq"), [0, 4, 5])
+        verify(df, "joe", list("wq"), [], check_index_type=False)
+
+        df = DataFrame(
+            {
+                "jim": ["mid"] * 5 + ["btm"] * 8 + ["top"] * 7,
+                "joe": ["3rd"] * 2
+                + ["1st"] * 3
+                + ["2nd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["2nd"] * 2,
+                # this needs to be jointly unique with jim and joe or
+                # reindexing will fail ~1.5% of the time, this works
+                # out to needing unique groups of same size as joe
+                "jolie": np.concatenate(
+                    [
+                        np.random.choice(1000, x, replace=False)
+                        for x in [2, 3, 3, 2, 3, 2, 3, 2]
+                    ]
+                ),
+                "joline": np.random.randn(20).round(3) * 10,
+            }
+        )
+
+        for idx in permutations(df["jim"].unique()):
+            for i in range(3):
+                verify_first_level(df, "jim", idx[: i + 1])
+
+        i = [2, 3, 4, 0, 1, 8, 9, 5, 6, 7, 10, 11, 12, 13, 14, 18, 19, 15, 16, 17]
+        verify(df, "joe", ["1st", "2nd", "3rd"], i)
+
+        i = [0, 1, 2, 3, 4, 10, 11, 12, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 13, 14]
+        verify(df, "joe", ["3rd", "2nd", "1st"], i)
+
+        i = [0, 1, 5, 6, 7, 10, 11, 12, 18, 19, 15, 16, 17]
+        verify(df, "joe", ["2nd", "3rd"], i)
+
+        i = [0, 1, 2, 3, 4, 10, 11, 12, 8, 9, 15, 16, 17, 13, 14]
+        verify(df, "joe", ["3rd", "1st"], i)
+
+    def test_getitem_ix_float_duplicates(self):
+        df = pd.DataFrame(
+            np.random.randn(3, 3), index=[0.1, 0.2, 0.2], columns=list("abc")
+        )
+        expect = df.iloc[1:]
+        tm.assert_frame_equal(df.loc[0.2], expect)
+
+        expect = df.iloc[1:, 0]
+        tm.assert_series_equal(df.loc[0.2, "a"], expect)
+
+        df.index = [1, 0.2, 0.2]
+        expect = df.iloc[1:]
+        tm.assert_frame_equal(df.loc[0.2], expect)
+
+        expect = df.iloc[1:, 0]
+        tm.assert_series_equal(df.loc[0.2, "a"], expect)
+
+        df = pd.DataFrame(
+            np.random.randn(4, 3), index=[1, 0.2, 0.2, 1], columns=list("abc")
+        )
+        expect = df.iloc[1:-1]
+        tm.assert_frame_equal(df.loc[0.2], expect)
+
+        expect = df.iloc[1:-1, 0]
+        tm.assert_series_equal(df.loc[0.2, "a"], expect)
+
+        df.index = [0.1, 0.2, 2, 0.2]
+        expect = df.iloc[[1, -1]]
+        tm.assert_frame_equal(df.loc[0.2], expect)
+
+        expect = df.iloc[[1, -1], 0]
+        tm.assert_series_equal(df.loc[0.2, "a"], expect)
+
+    def test_getitem_sparse_column(self):
+        # https://github.com/pandas-dev/pandas/issues/23559
+        data = SparseArray([0, 1])
+        df = pd.DataFrame({"A": data})
+        expected = pd.Series(data, name="A")
+        result = df["A"]
+        tm.assert_series_equal(result, expected)
+
+        result = df.iloc[:, 0]
+        tm.assert_series_equal(result, expected)
+
+        result = df.loc[:, "A"]
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_with_sparse_value(self):
+        # GH8131
+        df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
+        sp_array = SparseArray([0, 0, 1])
+        df["new_column"] = sp_array
+        tm.assert_series_equal(
+            df["new_column"], pd.Series(sp_array, name="new_column"), check_names=False
+        )
+
+    def test_setitem_with_unaligned_sparse_value(self):
+        df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
+        sp_series = pd.Series(SparseArray([0, 0, 1]), index=[2, 1, 0])
+        df["new_column"] = sp_series
+        exp = pd.Series(SparseArray([1, 0, 0]), name="new_column")
+        tm.assert_series_equal(df["new_column"], exp)
+
+    def test_setitem_with_unaligned_tz_aware_datetime_column(self):
+        # GH 12981
+        # Assignment of unaligned offset-aware datetime series.
+        # Make sure timezone isn't lost
+        column = pd.Series(
+            pd.date_range("2015-01-01", periods=3, tz="utc"), name="dates"
+        )
+        df = pd.DataFrame({"dates": column})
+        df["dates"] = column[[1, 0, 2]]
+        tm.assert_series_equal(df["dates"], column)
+
+        df = pd.DataFrame({"dates": column})
+        df.loc[[0, 1, 2], "dates"] = column[[1, 0, 2]]
+        tm.assert_series_equal(df["dates"], column)
+
+    def test_setitem_datetime_coercion(self):
+        # gh-1048
+        df = pd.DataFrame({"c": [pd.Timestamp("2010-10-01")] * 3})
+        df.loc[0:1, "c"] = np.datetime64("2008-08-08")
+        assert pd.Timestamp("2008-08-08") == df.loc[0, "c"]
+        assert pd.Timestamp("2008-08-08") == df.loc[1, "c"]
+        df.loc[2, "c"] = date(2005, 5, 5)
+        assert pd.Timestamp("2005-05-05") == df.loc[2, "c"]
+
+    def test_setitem_datetimelike_with_inference(self):
+        # GH 7592
+        # assignment of timedeltas with NaT
+
+        one_hour = timedelta(hours=1)
+        df = DataFrame(index=date_range("20130101", periods=4))
+        df["A"] = np.array([1 * one_hour] * 4, dtype="m8[ns]")
+        df.loc[:, "B"] = np.array([2 * one_hour] * 4, dtype="m8[ns]")
+        df.loc[:3, "C"] = np.array([3 * one_hour] * 3, dtype="m8[ns]")
+        df.loc[:, "D"] = np.array([4 * one_hour] * 4, dtype="m8[ns]")
+        df.loc[df.index[:3], "E"] = np.array([5 * one_hour] * 3, dtype="m8[ns]")
+        df["F"] = np.timedelta64("NaT")
+        df.loc[df.index[:-1], "F"] = np.array([6 * one_hour] * 3, dtype="m8[ns]")
+        df.loc[df.index[-3] :, "G"] = date_range("20130101", periods=3)
+        df["H"] = np.datetime64("NaT")
+        result = df.dtypes
+        expected = Series(
+            [np.dtype("timedelta64[ns]")] * 6 + [np.dtype("datetime64[ns]")] * 2,
+            index=list("ABCDEFGH"),
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("idxer", ["var", ["var"]])
+    def test_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
+        # GH 11365
+        tz = tz_naive_fixture
+        idx = date_range(start="2015-07-12", periods=3, freq="H", tz=tz)
+        expected = DataFrame(1.2, index=idx, columns=["var"])
+        result = DataFrame(index=idx, columns=["var"])
+        result.loc[:, idxer] = expected
+        tm.assert_frame_equal(result, expected)
+
+    def test_at_time_between_time_datetimeindex(self):
+        index = date_range("2012-01-01", "2012-01-05", freq="30min")
+        df = DataFrame(np.random.randn(len(index), 5), index=index)
+        akey = time(12, 0, 0)
+        bkey = slice(time(13, 0, 0), time(14, 0, 0))
+        ainds = [24, 72, 120, 168]
+        binds = [26, 27, 28, 74, 75, 76, 122, 123, 124, 170, 171, 172]
+
+        result = df.at_time(akey)
+        expected = df.loc[akey]
+        expected2 = df.iloc[ainds]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected2)
+        assert len(result) == 4
+
+        result = df.between_time(bkey.start, bkey.stop)
+        expected = df.loc[bkey]
+        expected2 = df.iloc[binds]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected2)
+        assert len(result) == 12
+
+        result = df.copy()
+        result.loc[akey] = 0
+        result = result.loc[akey]
+        expected = df.loc[akey].copy()
+        expected.loc[:] = 0
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.loc[akey] = 0
+        result.loc[akey] = df.iloc[ainds]
+        tm.assert_frame_equal(result, df)
+
+        result = df.copy()
+        result.loc[bkey] = 0
+        result = result.loc[bkey]
+        expected = df.loc[bkey].copy()
+        expected.loc[:] = 0
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.loc[bkey] = 0
+        result.loc[bkey] = df.iloc[binds]
+        tm.assert_frame_equal(result, df)
+
+    def test_index_namedtuple(self):
+        from collections import namedtuple
+
+        IndexType = namedtuple("IndexType", ["a", "b"])
+        idx1 = IndexType("foo", "bar")
+        idx2 = IndexType("baz", "bof")
+        index = Index([idx1, idx2], name="composite_index", tupleize_cols=False)
+        df = DataFrame([(1, 2), (3, 4)], index=index, columns=["A", "B"])
+
+        result = df.loc[IndexType("foo", "bar")]["A"]
+        assert result == 1
+
+    @pytest.mark.parametrize("tpl", [tuple([1]), tuple([1, 2])])
+    def test_index_single_double_tuples(self, tpl):
+        # GH 20991
+        idx = pd.Index([tuple([1]), tuple([1, 2])], name="A", tupleize_cols=False)
+        df = DataFrame(index=idx)
+
+        result = df.loc[[tpl]]
+        idx = pd.Index([tpl], name="A", tupleize_cols=False)
+        expected = DataFrame(index=idx)
+        tm.assert_frame_equal(result, expected)
+
+    def test_boolean_indexing(self):
+        idx = list(range(3))
+        cols = ["A", "B", "C"]
+        df1 = DataFrame(
+            index=idx,
+            columns=cols,
+            data=np.array(
+                [[0.0, 0.5, 1.0], [1.5, 2.0, 2.5], [3.0, 3.5, 4.0]], dtype=float
+            ),
+        )
+        df2 = DataFrame(index=idx, columns=cols, data=np.ones((len(idx), len(cols))))
+
+        expected = DataFrame(
+            index=idx,
+            columns=cols,
+            data=np.array([[0.0, 0.5, 1.0], [1.5, 2.0, -1], [-1, -1, -1]], dtype=float),
+        )
+
+        df1[df1 > 2.0 * df2] = -1
+        tm.assert_frame_equal(df1, expected)
+        with pytest.raises(ValueError, match="Item wrong length"):
+            df1[df1.index[:-1] > 2] = -1
+
+    def test_boolean_indexing_mixed(self):
+        df = DataFrame(
+            {
+                0: {35: np.nan, 40: np.nan, 43: np.nan, 49: np.nan, 50: np.nan},
+                1: {
+                    35: np.nan,
+                    40: 0.32632316859446198,
+                    43: np.nan,
+                    49: 0.32632316859446198,
+                    50: 0.39114724480578139,
+                },
+                2: {
+                    35: np.nan,
+                    40: np.nan,
+                    43: 0.29012581014105987,
+                    49: np.nan,
+                    50: np.nan,
+                },
+                3: {35: np.nan, 40: np.nan, 43: np.nan, 49: np.nan, 50: np.nan},
+                4: {
+                    35: 0.34215328467153283,
+                    40: np.nan,
+                    43: np.nan,
+                    49: np.nan,
+                    50: np.nan,
+                },
+                "y": {35: 0, 40: 0, 43: 0, 49: 0, 50: 1},
+            }
+        )
+
+        # mixed int/float ok
+        df2 = df.copy()
+        df2[df2 > 0.3] = 1
+        expected = df.copy()
+        expected.loc[40, 1] = 1
+        expected.loc[49, 1] = 1
+        expected.loc[50, 1] = 1
+        expected.loc[35, 4] = 1
+        tm.assert_frame_equal(df2, expected)
+
+        df["foo"] = "test"
+        msg = "not supported between instances|unorderable types"
+
+        with pytest.raises(TypeError, match=msg):
+            df[df > 0.3] = 1
+
+    def test_mask(self):
+        df = DataFrame(np.random.randn(5, 3))
+        cond = df > 0
+
+        rs = df.where(cond, np.nan)
+        tm.assert_frame_equal(rs, df.mask(df <= 0))
+        tm.assert_frame_equal(rs, df.mask(~cond))
+
+        other = DataFrame(np.random.randn(5, 3))
+        rs = df.where(cond, other)
+        tm.assert_frame_equal(rs, df.mask(df <= 0, other))
+        tm.assert_frame_equal(rs, df.mask(~cond, other))
+
+        # see gh-21891
+        df = DataFrame([1, 2])
+        res = df.mask([[True], [False]])
+
+        exp = DataFrame([np.nan, 2])
+        tm.assert_frame_equal(res, exp)
+
+    def test_mask_inplace(self):
+        # GH8801
+        df = DataFrame(np.random.randn(5, 3))
+        cond = df > 0
+
+        rdf = df.copy()
+
+        rdf.where(cond, inplace=True)
+        tm.assert_frame_equal(rdf, df.where(cond))
+        tm.assert_frame_equal(rdf, df.mask(~cond))
+
+        rdf = df.copy()
+        rdf.where(cond, -df, inplace=True)
+        tm.assert_frame_equal(rdf, df.where(cond, -df))
+        tm.assert_frame_equal(rdf, df.mask(~cond, -df))
+
+    def test_mask_edge_case_1xN_frame(self):
+        # GH4071
+        df = DataFrame([[1, 2]])
+        res = df.mask(DataFrame([[True, False]]))
+        expec = DataFrame([[np.nan, 2]])
+        tm.assert_frame_equal(res, expec)
+
+    def test_mask_callable(self):
+        # GH 12533
+        df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        result = df.mask(lambda x: x > 4, lambda x: x + 1)
+        exp = DataFrame([[1, 2, 3], [4, 6, 7], [8, 9, 10]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, df.mask(df > 4, df + 1))
+
+        # return ndarray and scalar
+        result = df.mask(lambda x: (x % 2 == 0).values, lambda x: 99)
+        exp = DataFrame([[1, 99, 3], [99, 5, 99], [7, 99, 9]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, df.mask(df % 2 == 0, 99))
+
+        # chain
+        result = (df + 2).mask(lambda x: x > 8, lambda x: x + 10)
+        exp = DataFrame([[3, 4, 5], [6, 7, 8], [19, 20, 21]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, (df + 2).mask((df + 2) > 8, (df + 2) + 10))
+
+    def test_type_error_multiindex(self):
+        # See gh-12218
+        df = DataFrame(
+            columns=["i", "c", "x", "y"],
+            data=[[0, 0, 1, 2], [1, 0, 3, 4], [0, 1, 1, 2], [1, 1, 3, 4]],
+        )
+        dg = df.pivot_table(index="i", columns="c", values=["x", "y"])
+
+        with pytest.raises(TypeError, match="is an invalid key"):
+            dg[:, 0]
+
+        index = Index(range(2), name="i")
+        columns = MultiIndex(
+            levels=[["x", "y"], [0, 1]], codes=[[0, 1], [0, 0]], names=[None, "c"]
+        )
+        expected = DataFrame([[1, 2], [3, 4]], columns=columns, index=index)
+
+        result = dg.loc[:, (slice(None), 0)]
+        tm.assert_frame_equal(result, expected)
+
+        name = ("x", 0)
+        index = Index(range(2), name="i")
+        expected = Series([1, 3], index=index, name=name)
+
+        result = dg["x", 0]
+        tm.assert_series_equal(result, expected)
+
+    def test_interval_index(self):
+        # GH 19977
+        index = pd.interval_range(start=0, periods=3)
+        df = pd.DataFrame(
+            [[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=index, columns=["A", "B", "C"]
+        )
+
+        expected = 1
+        result = df.loc[0.5, "A"]
+        tm.assert_almost_equal(result, expected)
+
+        index = pd.interval_range(start=0, periods=3, closed="both")
+        df = pd.DataFrame(
+            [[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=index, columns=["A", "B", "C"]
+        )
+
+        index_exp = pd.interval_range(start=0, periods=2, freq=1, closed="both")
+        expected = pd.Series([1, 4], index=index_exp, name="A")
+        result = df.loc[1, "A"]
+        tm.assert_series_equal(result, expected)
+
+
+class TestDataFrameIndexingUInt64:
+    def test_setitem(self, uint64_frame):
+
+        df = uint64_frame
+        idx = df["A"].rename("foo")
+
+        # setitem
+        df["C"] = idx
+        tm.assert_series_equal(df["C"], Series(idx, name="C"))
+
+        df["D"] = "foo"
+        df["D"] = idx
+        tm.assert_series_equal(df["D"], Series(idx, name="D"))
+        del df["D"]
+
+        # With NaN: because uint64 has no NaN element,
+        # the column should be cast to object.
+        df2 = df.copy()
+        df2.iloc[1, 1] = pd.NaT
+        df2.iloc[1, 2] = pd.NaT
+        result = df2["B"]
+        tm.assert_series_equal(notna(result), Series([True, False, True], name="B"))
+        tm.assert_series_equal(
+            df2.dtypes,
+            Series(
+                [np.dtype("uint64"), np.dtype("O"), np.dtype("O")],
+                index=["A", "B", "C"],
+            ),
+        )
+
+    def test_set_reset(self):
+
+        idx = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10], name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype == np.dtype("uint64")
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+
+def test_object_casting_indexing_wraps_datetimelike():
+    # GH#31649, check the indexing methods all the way down the stack
+    df = pd.DataFrame(
+        {
+            "A": [1, 2],
+            "B": pd.date_range("2000", periods=2),
+            "C": pd.timedelta_range("1 Day", periods=2),
+        }
+    )
+
+    ser = df.loc[0]
+    assert isinstance(ser.values[1], pd.Timestamp)
+    assert isinstance(ser.values[2], pd.Timedelta)
+
+    ser = df.iloc[0]
+    assert isinstance(ser.values[1], pd.Timestamp)
+    assert isinstance(ser.values[2], pd.Timedelta)
+
+    ser = df.xs(0, axis=0)
+    assert isinstance(ser.values[1], pd.Timestamp)
+    assert isinstance(ser.values[2], pd.Timedelta)
+
+    mgr = df._data
+    arr = mgr.fast_xs(0)
+    assert isinstance(arr[1], pd.Timestamp)
+    assert isinstance(arr[2], pd.Timedelta)
+
+    blk = mgr.blocks[mgr._blknos[1]]
+    assert blk.dtype == "M8[ns]"  # we got the right block
+    val = blk.iget((0, 0))
+    assert isinstance(val, pd.Timestamp)
+
+    blk = mgr.blocks[mgr._blknos[2]]
+    assert blk.dtype == "m8[ns]"  # we got the right block
+    val = blk.iget((0, 0))
+    assert isinstance(val, pd.Timedelta)
diff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py
new file mode 100644
index 0000000000000..507b2e9cd237b
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_where.py
@@ -0,0 +1,588 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+from pandas import DataFrame, DatetimeIndex, Series, Timestamp, date_range, isna
+import pandas._testing as tm
+
+
+@pytest.fixture(params=["default", "float_string", "mixed_float", "mixed_int"])
+def where_frame(request, float_string_frame, mixed_float_frame, mixed_int_frame):
+    if request.param == "default":
+        return DataFrame(np.random.randn(5, 3), columns=["A", "B", "C"])
+    if request.param == "float_string":
+        return float_string_frame
+    if request.param == "mixed_float":
+        return mixed_float_frame
+    if request.param == "mixed_int":
+        return mixed_int_frame
+
+
+def _safe_add(df):
+    # only add to the numeric items
+    def is_ok(s):
+        return (
+            issubclass(s.dtype.type, (np.integer, np.floating)) and s.dtype != "uint8"
+        )
+
+    return DataFrame(dict((c, s + 1) if is_ok(s) else (c, s) for c, s in df.items()))
+
+
+class TestDataFrameIndexingWhere:
+    def test_where_get(self, where_frame, float_string_frame):
+        def _check_get(df, cond, check_dtypes=True):
+            other1 = _safe_add(df)
+            rs = df.where(cond, other1)
+            rs2 = df.where(cond.values, other1)
+            for k, v in rs.items():
+                exp = Series(np.where(cond[k], df[k], other1[k]), index=v.index)
+                tm.assert_series_equal(v, exp, check_names=False)
+            tm.assert_frame_equal(rs, rs2)
+
+            # dtypes
+            if check_dtypes:
+                assert (rs.dtypes == df.dtypes).all()
+
+        # check getting
+        df = where_frame
+        if df is float_string_frame:
+            with pytest.raises(TypeError):
+                df > 0
+            return
+        cond = df > 0
+        _check_get(df, cond)
+
+    def test_where_upcasting(self):
+        # upcasting case (GH # 2794)
+        df = DataFrame(
+            {
+                c: Series([1] * 3, dtype=c)
+                for c in ["float32", "float64", "int32", "int64"]
+            }
+        )
+        df.iloc[1, :] = 0
+        result = df.dtypes
+        expected = Series(
+            [
+                np.dtype("float32"),
+                np.dtype("float64"),
+                np.dtype("int32"),
+                np.dtype("int64"),
+            ],
+            index=["float32", "float64", "int32", "int64"],
+        )
+
+        # when we don't preserve boolean casts
+        #
+        # expected = Series({ 'float32' : 1, 'float64' : 3 })
+
+        tm.assert_series_equal(result, expected)
+
+    def test_where_alignment(self, where_frame, float_string_frame):
+        # aligning
+        def _check_align(df, cond, other, check_dtypes=True):
+            rs = df.where(cond, other)
+            for i, k in enumerate(rs.columns):
+                result = rs[k]
+                d = df[k].values
+                c = cond[k].reindex(df[k].index).fillna(False).values
+
+                if is_scalar(other):
+                    o = other
+                else:
+                    if isinstance(other, np.ndarray):
+                        o = Series(other[:, i], index=result.index).values
+                    else:
+                        o = other[k].values
+
+                new_values = d if c.all() else np.where(c, d, o)
+                expected = Series(new_values, index=result.index, name=k)
+
+                # since we can't always have the correct numpy dtype
+                # as numpy doesn't know how to downcast, don't check
+                tm.assert_series_equal(result, expected, check_dtype=False)
+
+            # dtypes
+            # can't check dtype when other is an ndarray
+
+            if check_dtypes and not isinstance(other, np.ndarray):
+                assert (rs.dtypes == df.dtypes).all()
+
+        df = where_frame
+        if df is float_string_frame:
+            with pytest.raises(TypeError):
+                df > 0
+            return
+
+        # other is a frame
+        cond = (df > 0)[1:]
+        _check_align(df, cond, _safe_add(df))
+
+        # check other is ndarray
+        cond = df > 0
+        _check_align(df, cond, (_safe_add(df).values))
+
+        # integers are upcast, so don't check the dtypes
+        cond = df > 0
+        check_dtypes = all(not issubclass(s.type, np.integer) for s in df.dtypes)
+        _check_align(df, cond, np.nan, check_dtypes=check_dtypes)
+
+    def test_where_invalid(self):
+        # invalid conditions
+        df = DataFrame(np.random.randn(5, 3), columns=["A", "B", "C"])
+        cond = df > 0
+
+        err1 = (df + 1).values[0:2, :]
+        msg = "other must be the same shape as self when an ndarray"
+        with pytest.raises(ValueError, match=msg):
+            df.where(cond, err1)
+
+        err2 = cond.iloc[:2, :].values
+        other1 = _safe_add(df)
+        msg = "Array conditional must be same shape as self"
+        with pytest.raises(ValueError, match=msg):
+            df.where(err2, other1)
+
+        with pytest.raises(ValueError, match=msg):
+            df.mask(True)
+        with pytest.raises(ValueError, match=msg):
+            df.mask(0)
+
+    def test_where_set(self, where_frame, float_string_frame):
+        # where inplace
+
+        def _check_set(df, cond, check_dtypes=True):
+            dfi = df.copy()
+            econd = cond.reindex_like(df).fillna(True)
+            expected = dfi.mask(~econd)
+
+            dfi.where(cond, np.nan, inplace=True)
+            tm.assert_frame_equal(dfi, expected)
+
+            # dtypes (and confirm upcasts)x
+            if check_dtypes:
+                for k, v in df.dtypes.items():
+                    if issubclass(v.type, np.integer) and not cond[k].all():
+                        v = np.dtype("float64")
+                    assert dfi[k].dtype == v
+
+        df = where_frame
+        if df is float_string_frame:
+            with pytest.raises(TypeError):
+                df > 0
+            return
+
+        cond = df > 0
+        _check_set(df, cond)
+
+        cond = df >= 0
+        _check_set(df, cond)
+
+        # aligning
+        cond = (df >= 0)[1:]
+        _check_set(df, cond)
+
+    def test_where_series_slicing(self):
+        # GH 10218
+        # test DataFrame.where with Series slicing
+        df = DataFrame({"a": range(3), "b": range(4, 7)})
+        result = df.where(df["a"] == 1)
+        expected = df[df["a"] == 1].reindex(df.index)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [list, tuple, np.array])
+    def test_where_array_like(self, klass):
+        # see gh-15414
+        df = DataFrame({"a": [1, 2, 3]})
+        cond = [[False], [True], [True]]
+        expected = DataFrame({"a": [np.nan, 2, 3]})
+
+        result = df.where(klass(cond))
+        tm.assert_frame_equal(result, expected)
+
+        df["b"] = 2
+        expected["b"] = [2, np.nan, 2]
+        cond = [[False, True], [True, False], [True, True]]
+
+        result = df.where(klass(cond))
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "cond",
+        [
+            [[1], [0], [1]],
+            Series([[2], [5], [7]]),
+            DataFrame({"a": [2, 5, 7]}),
+            [["True"], ["False"], ["True"]],
+            [[Timestamp("2017-01-01")], [pd.NaT], [Timestamp("2017-01-02")]],
+        ],
+    )
+    def test_where_invalid_input_single(self, cond):
+        # see gh-15414: only boolean arrays accepted
+        df = DataFrame({"a": [1, 2, 3]})
+        msg = "Boolean array expected for the condition"
+
+        with pytest.raises(ValueError, match=msg):
+            df.where(cond)
+
+    @pytest.mark.parametrize(
+        "cond",
+        [
+            [[0, 1], [1, 0], [1, 1]],
+            Series([[0, 2], [5, 0], [4, 7]]),
+            [["False", "True"], ["True", "False"], ["True", "True"]],
+            DataFrame({"a": [2, 5, 7], "b": [4, 8, 9]}),
+            [
+                [pd.NaT, Timestamp("2017-01-01")],
+                [Timestamp("2017-01-02"), pd.NaT],
+                [Timestamp("2017-01-03"), Timestamp("2017-01-03")],
+            ],
+        ],
+    )
+    def test_where_invalid_input_multiple(self, cond):
+        # see gh-15414: only boolean arrays accepted
+        df = DataFrame({"a": [1, 2, 3], "b": [2, 2, 2]})
+        msg = "Boolean array expected for the condition"
+
+        with pytest.raises(ValueError, match=msg):
+            df.where(cond)
+
+    def test_where_dataframe_col_match(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+        cond = DataFrame([[True, False, True], [False, False, True]])
+
+        result = df.where(cond)
+        expected = DataFrame([[1.0, np.nan, 3], [np.nan, np.nan, 6]])
+        tm.assert_frame_equal(result, expected)
+
+        # this *does* align, though has no matching columns
+        cond.columns = ["a", "b", "c"]
+        result = df.where(cond)
+        expected = DataFrame(np.nan, index=df.index, columns=df.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_ndframe_align(self):
+        msg = "Array conditional must be same shape as self"
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+
+        cond = [True]
+        with pytest.raises(ValueError, match=msg):
+            df.where(cond)
+
+        expected = DataFrame([[1, 2, 3], [np.nan, np.nan, np.nan]])
+
+        out = df.where(Series(cond))
+        tm.assert_frame_equal(out, expected)
+
+        cond = np.array([False, True, False, True])
+        with pytest.raises(ValueError, match=msg):
+            df.where(cond)
+
+        expected = DataFrame([[np.nan, np.nan, np.nan], [4, 5, 6]])
+
+        out = df.where(Series(cond))
+        tm.assert_frame_equal(out, expected)
+
+    def test_where_bug(self):
+        # see gh-2793
+        df = DataFrame(
+            {"a": [1.0, 2.0, 3.0, 4.0], "b": [4.0, 3.0, 2.0, 1.0]}, dtype="float64"
+        )
+        expected = DataFrame(
+            {"a": [np.nan, np.nan, 3.0, 4.0], "b": [4.0, 3.0, np.nan, np.nan]},
+            dtype="float64",
+        )
+        result = df.where(df > 2, np.nan)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(result > 2, np.nan, inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_bug_mixed(self, sint_dtype):
+        # see gh-2793
+        df = DataFrame(
+            {
+                "a": np.array([1, 2, 3, 4], dtype=sint_dtype),
+                "b": np.array([4.0, 3.0, 2.0, 1.0], dtype="float64"),
+            }
+        )
+
+        expected = DataFrame(
+            {"a": [np.nan, np.nan, 3.0, 4.0], "b": [4.0, 3.0, np.nan, np.nan]},
+            dtype="float64",
+        )
+
+        result = df.where(df > 2, np.nan)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(result > 2, np.nan, inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_bug_transposition(self):
+        # see gh-7506
+        a = DataFrame({0: [1, 2], 1: [3, 4], 2: [5, 6]})
+        b = DataFrame({0: [np.nan, 8], 1: [9, np.nan], 2: [np.nan, np.nan]})
+        do_not_replace = b.isna() | (a > b)
+
+        expected = a.copy()
+        expected[~do_not_replace] = b
+
+        result = a.where(do_not_replace, b)
+        tm.assert_frame_equal(result, expected)
+
+        a = DataFrame({0: [4, 6], 1: [1, 0]})
+        b = DataFrame({0: [np.nan, 3], 1: [3, np.nan]})
+        do_not_replace = b.isna() | (a > b)
+
+        expected = a.copy()
+        expected[~do_not_replace] = b
+
+        result = a.where(do_not_replace, b)
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_datetime(self):
+
+        # GH 3311
+        df = DataFrame(
+            dict(
+                A=date_range("20130102", periods=5),
+                B=date_range("20130104", periods=5),
+                C=np.random.randn(5),
+            )
+        )
+
+        stamp = datetime(2013, 1, 3)
+        with pytest.raises(TypeError):
+            df > stamp
+
+        result = df[df.iloc[:, :-1] > stamp]
+
+        expected = df.copy()
+        expected.loc[[0, 1], "A"] = np.nan
+        expected.loc[:, "C"] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_none(self):
+        # GH 4667
+        # setting with None changes dtype
+        df = DataFrame({"series": Series(range(10))}).astype(float)
+        df[df > 7] = None
+        expected = DataFrame(
+            {"series": Series([0, 1, 2, 3, 4, 5, 6, 7, np.nan, np.nan])}
+        )
+        tm.assert_frame_equal(df, expected)
+
+        # GH 7656
+        df = DataFrame(
+            [
+                {"A": 1, "B": np.nan, "C": "Test"},
+                {"A": np.nan, "B": "Test", "C": np.nan},
+            ]
+        )
+        msg = "boolean setting on mixed-type"
+
+        with pytest.raises(TypeError, match=msg):
+            df.where(~isna(df), None, inplace=True)
+
+    def test_where_empty_df_and_empty_cond_having_non_bool_dtypes(self):
+        # see gh-21947
+        df = pd.DataFrame(columns=["a"])
+        cond = df.applymap(lambda x: x > 0)
+
+        result = df.where(cond)
+        tm.assert_frame_equal(result, df)
+
+    def test_where_align(self):
+        def create():
+            df = DataFrame(np.random.randn(10, 3))
+            df.iloc[3:5, 0] = np.nan
+            df.iloc[4:6, 1] = np.nan
+            df.iloc[5:8, 2] = np.nan
+            return df
+
+        # series
+        df = create()
+        expected = df.fillna(df.mean())
+        result = df.where(pd.notna(df), df.mean(), axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+        df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
+        tm.assert_frame_equal(df, expected)
+
+        df = create().fillna(0)
+        expected = df.apply(lambda x, y: x.where(x > 0, y), y=df[0])
+        result = df.where(df > 0, df[0], axis="index")
+        tm.assert_frame_equal(result, expected)
+        result = df.where(df > 0, df[0], axis="rows")
+        tm.assert_frame_equal(result, expected)
+
+        # frame
+        df = create()
+        expected = df.fillna(1)
+        result = df.where(
+            pd.notna(df), DataFrame(1, index=df.index, columns=df.columns)
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_complex(self):
+        # GH 6345
+        expected = DataFrame([[1 + 1j, 2], [np.nan, 4 + 1j]], columns=["a", "b"])
+        df = DataFrame([[1 + 1j, 2], [5 + 1j, 4 + 1j]], columns=["a", "b"])
+        df[df.abs() >= 5] = np.nan
+        tm.assert_frame_equal(df, expected)
+
+    def test_where_axis(self):
+        # GH 9736
+        df = DataFrame(np.random.randn(2, 2))
+        mask = DataFrame([[False, False], [False, False]])
+        s = Series([0, 1])
+
+        expected = DataFrame([[0, 0], [1, 1]], dtype="float64")
+        result = df.where(mask, s, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(mask, s, axis="index", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([[0, 1], [0, 1]], dtype="float64")
+        result = df.where(mask, s, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(mask, s, axis="columns", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        # Upcast needed
+        df = DataFrame([[1, 2], [3, 4]], dtype="int64")
+        mask = DataFrame([[False, False], [False, False]])
+        s = Series([0, np.nan])
+
+        expected = DataFrame([[0, 0], [np.nan, np.nan]], dtype="float64")
+        result = df.where(mask, s, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(mask, s, axis="index", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([[0, np.nan], [0, np.nan]])
+        result = df.where(mask, s, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(
+            {
+                0: np.array([0, 0], dtype="int64"),
+                1: np.array([np.nan, np.nan], dtype="float64"),
+            }
+        )
+        result = df.copy()
+        result.where(mask, s, axis="columns", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        # Multiple dtypes (=> multiple Blocks)
+        df = pd.concat(
+            [
+                DataFrame(np.random.randn(10, 2)),
+                DataFrame(np.random.randint(0, 10, size=(10, 2)), dtype="int64"),
+            ],
+            ignore_index=True,
+            axis=1,
+        )
+        mask = DataFrame(False, columns=df.columns, index=df.index)
+        s1 = Series(1, index=df.columns)
+        s2 = Series(2, index=df.index)
+
+        result = df.where(mask, s1, axis="columns")
+        expected = DataFrame(1.0, columns=df.columns, index=df.index)
+        expected[2] = expected[2].astype("int64")
+        expected[3] = expected[3].astype("int64")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(mask, s1, axis="columns", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.where(mask, s2, axis="index")
+        expected = DataFrame(2.0, columns=df.columns, index=df.index)
+        expected[2] = expected[2].astype("int64")
+        expected[3] = expected[3].astype("int64")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.where(mask, s2, axis="index", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+        # DataFrame vs DataFrame
+        d1 = df.copy().drop(1, axis=0)
+        expected = df.copy()
+        expected.loc[1, :] = np.nan
+
+        result = df.where(mask, d1)
+        tm.assert_frame_equal(result, expected)
+        result = df.where(mask, d1, axis="index")
+        tm.assert_frame_equal(result, expected)
+        result = df.copy()
+        result.where(mask, d1, inplace=True)
+        tm.assert_frame_equal(result, expected)
+        result = df.copy()
+        result.where(mask, d1, inplace=True, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        d2 = df.copy().drop(1, axis=1)
+        expected = df.copy()
+        expected.loc[:, 1] = np.nan
+
+        result = df.where(mask, d2)
+        tm.assert_frame_equal(result, expected)
+        result = df.where(mask, d2, axis="columns")
+        tm.assert_frame_equal(result, expected)
+        result = df.copy()
+        result.where(mask, d2, inplace=True)
+        tm.assert_frame_equal(result, expected)
+        result = df.copy()
+        result.where(mask, d2, inplace=True, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+    def test_where_callable(self):
+        # GH 12533
+        df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        result = df.where(lambda x: x > 4, lambda x: x + 1)
+        exp = DataFrame([[2, 3, 4], [5, 5, 6], [7, 8, 9]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, df.where(df > 4, df + 1))
+
+        # return ndarray and scalar
+        result = df.where(lambda x: (x % 2 == 0).values, lambda x: 99)
+        exp = DataFrame([[99, 2, 99], [4, 99, 6], [99, 8, 99]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, df.where(df % 2 == 0, 99))
+
+        # chain
+        result = (df + 2).where(lambda x: x > 8, lambda x: x + 10)
+        exp = DataFrame([[13, 14, 15], [16, 17, 18], [9, 10, 11]])
+        tm.assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, (df + 2).where((df + 2) > 8, (df + 2) + 10))
+
+    def test_where_tz_values(self, tz_naive_fixture):
+        df1 = DataFrame(
+            DatetimeIndex(["20150101", "20150102", "20150103"], tz=tz_naive_fixture),
+            columns=["date"],
+        )
+        df2 = DataFrame(
+            DatetimeIndex(["20150103", "20150104", "20150105"], tz=tz_naive_fixture),
+            columns=["date"],
+        )
+        mask = DataFrame([True, True, False], columns=["date"])
+        exp = DataFrame(
+            DatetimeIndex(["20150101", "20150102", "20150105"], tz=tz_naive_fixture),
+            columns=["date"],
+        )
+        result = df1.where(mask, df2)
+        tm.assert_frame_equal(exp, result)
diff --git a/pandas/tests/frame/indexing/test_xs.py b/pandas/tests/frame/indexing/test_xs.py
new file mode 100644
index 0000000000000..71b40585f0c2f
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_xs.py
@@ -0,0 +1,95 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay
+
+
+class TestXS:
+    def test_xs(self, float_frame, datetime_frame):
+        idx = float_frame.index[5]
+        xs = float_frame.xs(idx)
+        for item, value in xs.items():
+            if np.isnan(value):
+                assert np.isnan(float_frame[item][idx])
+            else:
+                assert value == float_frame[item][idx]
+
+        # mixed-type xs
+        test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
+        frame = DataFrame(test_data)
+        xs = frame.xs("1")
+        assert xs.dtype == np.object_
+        assert xs["A"] == 1
+        assert xs["B"] == "1"
+
+        with pytest.raises(
+            KeyError, match=re.escape("Timestamp('1999-12-31 00:00:00', freq='B')")
+        ):
+            datetime_frame.xs(datetime_frame.index[0] - BDay())
+
+        # xs get column
+        series = float_frame.xs("A", axis=1)
+        expected = float_frame["A"]
+        tm.assert_series_equal(series, expected)
+
+        # view is returned if possible
+        series = float_frame.xs("A", axis=1)
+        series[:] = 5
+        assert (expected == 5).all()
+
+    def test_xs_corner(self):
+        # pathological mixed-type reordering case
+        df = DataFrame(index=[0])
+        df["A"] = 1.0
+        df["B"] = "foo"
+        df["C"] = 2.0
+        df["D"] = "bar"
+        df["E"] = 3.0
+
+        xs = df.xs(0)
+        exp = pd.Series([1.0, "foo", 2.0, "bar", 3.0], index=list("ABCDE"), name=0)
+        tm.assert_series_equal(xs, exp)
+
+        # no columns but Index(dtype=object)
+        df = DataFrame(index=["a", "b", "c"])
+        result = df.xs("a")
+        expected = Series([], name="a", index=pd.Index([]), dtype=np.float64)
+        tm.assert_series_equal(result, expected)
+
+    def test_xs_duplicates(self):
+        df = DataFrame(np.random.randn(5, 2), index=["b", "b", "c", "b", "a"])
+
+        cross = df.xs("c")
+        exp = df.iloc[2]
+        tm.assert_series_equal(cross, exp)
+
+    def test_xs_keep_level(self):
+        df = DataFrame(
+            {
+                "day": {0: "sat", 1: "sun"},
+                "flavour": {0: "strawberry", 1: "strawberry"},
+                "sales": {0: 10, 1: 12},
+                "year": {0: 2008, 1: 2008},
+            }
+        ).set_index(["year", "flavour", "day"])
+        result = df.xs("sat", level="day", drop_level=False)
+        expected = df[:1]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.xs([2008, "sat"], level=["year", "day"], drop_level=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_xs_view(self):
+        # in 0.14 this will return a view if possible a copy otherwise, but
+        # this is numpy dependent
+
+        dm = DataFrame(np.arange(20.0).reshape(4, 5), index=range(4), columns=range(5))
+
+        dm.xs(2)[:] = 10
+        assert (dm.xs(2) == 10).all()
diff --git a/pandas/tests/frame/methods/__init__.py b/pandas/tests/frame/methods/__init__.py
new file mode 100644
index 0000000000000..245594bfdc9e7
--- /dev/null
+++ b/pandas/tests/frame/methods/__init__.py
@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) DataFrame methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.series.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""
diff --git a/pandas/tests/frame/methods/test_append.py b/pandas/tests/frame/methods/test_append.py
new file mode 100644
index 0000000000000..9fc3629e794e2
--- /dev/null
+++ b/pandas/tests/frame/methods/test_append.py
@@ -0,0 +1,199 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, Timestamp
+import pandas._testing as tm
+
+
+class TestDataFrameAppend:
+    def test_append_empty_list(self):
+        # GH 28769
+        df = DataFrame()
+        result = df.append([])
+        expected = df
+        tm.assert_frame_equal(result, expected)
+        assert result is not df
+
+        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
+        result = df.append([])
+        expected = df
+        tm.assert_frame_equal(result, expected)
+        assert result is not df  # .append() should return a new object
+
+    def test_append_series_dict(self):
+        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
+
+        series = df.loc[4]
+        msg = "Indexes have overlapping values"
+        with pytest.raises(ValueError, match=msg):
+            df.append(series, verify_integrity=True)
+
+        series.name = None
+        msg = "Can only append a Series if ignore_index=True"
+        with pytest.raises(TypeError, match=msg):
+            df.append(series, verify_integrity=True)
+
+        result = df.append(series[::-1], ignore_index=True)
+        expected = df.append(
+            DataFrame({0: series[::-1]}, index=df.columns).T, ignore_index=True
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # dict
+        result = df.append(series.to_dict(), ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.append(series[::-1][:3], ignore_index=True)
+        expected = df.append(
+            DataFrame({0: series[::-1][:3]}).T, ignore_index=True, sort=True
+        )
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
+
+        msg = "Can only append a dict if ignore_index=True"
+        with pytest.raises(TypeError, match=msg):
+            df.append(series.to_dict())
+
+        # can append when name set
+        row = df.loc[4]
+        row.name = 5
+        result = df.append(row)
+        expected = df.append(df[-1:], ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_list_of_series_dicts(self):
+        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
+
+        dicts = [x.to_dict() for idx, x in df.iterrows()]
+
+        result = df.append(dicts, ignore_index=True)
+        expected = df.append(df, ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+        # different columns
+        dicts = [
+            {"foo": 1, "bar": 2, "baz": 3, "peekaboo": 4},
+            {"foo": 5, "bar": 6, "baz": 7, "peekaboo": 8},
+        ]
+        result = df.append(dicts, ignore_index=True, sort=True)
+        expected = df.append(DataFrame(dicts), ignore_index=True, sort=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_missing_cols(self):
+        # GH22252
+        # exercise the conditional branch in append method where the data
+        # to be appended is a list and does not contain all columns that are in
+        # the target DataFrame
+        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
+
+        dicts = [{"foo": 9}, {"bar": 10}]
+        with tm.assert_produces_warning(None):
+            result = df.append(dicts, ignore_index=True, sort=True)
+
+        expected = df.append(DataFrame(dicts), ignore_index=True, sort=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_empty_dataframe(self):
+
+        # Empty df append empty df
+        df1 = DataFrame()
+        df2 = DataFrame()
+        result = df1.append(df2)
+        expected = df1.copy()
+        tm.assert_frame_equal(result, expected)
+
+        # Non-empty df append empty df
+        df1 = DataFrame(np.random.randn(5, 2))
+        df2 = DataFrame()
+        result = df1.append(df2)
+        expected = df1.copy()
+        tm.assert_frame_equal(result, expected)
+
+        # Empty df with columns append empty df
+        df1 = DataFrame(columns=["bar", "foo"])
+        df2 = DataFrame()
+        result = df1.append(df2)
+        expected = df1.copy()
+        tm.assert_frame_equal(result, expected)
+
+        # Non-Empty df with columns append empty df
+        df1 = DataFrame(np.random.randn(5, 2), columns=["bar", "foo"])
+        df2 = DataFrame()
+        result = df1.append(df2)
+        expected = df1.copy()
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_dtypes(self):
+
+        # GH 5754
+        # row appends of different dtypes (so need to do by-item)
+        # can sometimes infer the correct type
+
+        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(5))
+        df2 = DataFrame()
+        result = df1.append(df2)
+        expected = df1.copy()
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
+        df2 = DataFrame({"bar": "foo"}, index=range(1, 2))
+        result = df1.append(df2)
+        expected = DataFrame({"bar": [Timestamp("20130101"), "foo"]})
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
+        df2 = DataFrame({"bar": np.nan}, index=range(1, 2))
+        result = df1.append(df2)
+        expected = DataFrame(
+            {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
+        df2 = DataFrame({"bar": np.nan}, index=range(1, 2), dtype=object)
+        result = df1.append(df2)
+        expected = DataFrame(
+            {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"bar": np.nan}, index=range(1))
+        df2 = DataFrame({"bar": Timestamp("20130101")}, index=range(1, 2))
+        result = df1.append(df2)
+        expected = DataFrame(
+            {"bar": Series([np.nan, Timestamp("20130101")], dtype="M8[ns]")}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
+        df2 = DataFrame({"bar": 1}, index=range(1, 2), dtype=object)
+        result = df1.append(df2)
+        expected = DataFrame({"bar": Series([Timestamp("20130101"), 1])})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "timestamp", ["2019-07-19 07:04:57+0100", "2019-07-19 07:04:57"]
+    )
+    def test_append_timestamps_aware_or_naive(self, tz_naive_fixture, timestamp):
+        # GH 30238
+        tz = tz_naive_fixture
+        df = pd.DataFrame([pd.Timestamp(timestamp, tz=tz)])
+        result = df.append(df.iloc[0]).iloc[-1]
+        expected = pd.Series(pd.Timestamp(timestamp, tz=tz), name=0)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            ([1], pd.Int64Dtype()),
+            ([1], pd.CategoricalDtype()),
+            ([pd.Interval(left=0, right=5)], pd.IntervalDtype()),
+            ([pd.Period("2000-03", freq="M")], pd.PeriodDtype("M")),
+            ([1], pd.SparseDtype()),
+        ],
+    )
+    def test_other_dtypes(self, data, dtype):
+        df = pd.DataFrame(data, dtype=dtype)
+        result = df.append(df.iloc[0]).iloc[-1]
+        expected = pd.Series(data, name=0, dtype=dtype)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_asof.py b/pandas/tests/frame/methods/test_asof.py
similarity index 82%
rename from pandas/tests/frame/test_asof.py
rename to pandas/tests/frame/methods/test_asof.py
index 9a7d806c79dc3..e2b417972638e 100644
--- a/pandas/tests/frame/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -1,8 +1,8 @@
 import numpy as np
 import pytest
 
-from pandas import DataFrame, Series, Timestamp, date_range, to_datetime
-import pandas.util.testing as tm
+from pandas import DataFrame, Period, Series, Timestamp, date_range, to_datetime
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -30,6 +30,7 @@ def test_basic(self, date_range_frame):
         ub = df.index[30]
 
         dates = list(dates)
+
         result = df.asof(dates)
         assert result.notna().all(1).all()
 
@@ -65,9 +66,12 @@ def test_missing(self, date_range_frame):
         # no match found - `where` value before earliest date in index
         N = 10
         df = date_range_frame.iloc[:N].copy()
+
         result = df.asof("1989-12-31")
 
-        expected = Series(index=["A", "B"], name=Timestamp("1989-12-31"))
+        expected = Series(
+            index=["A", "B"], name=Timestamp("1989-12-31"), dtype=np.float64
+        )
         tm.assert_series_equal(result, expected)
 
         result = df.asof(to_datetime(["1989-12-31"]))
@@ -76,6 +80,12 @@ def test_missing(self, date_range_frame):
         )
         tm.assert_frame_equal(result, expected)
 
+        # Check that we handle PeriodIndex correctly, dont end up with
+        #  period.ordinal for series name
+        df = df.to_period("D")
+        result = df.asof("1989-12-31")
+        assert isinstance(result.name, Period)
+
     def test_all_nans(self, date_range_frame):
         # GH 15713
         # DataFrame is all nans
@@ -130,5 +140,19 @@ def test_time_zone_aware_index(self, stamp, expected):
                 Timestamp("2018-01-01 22:35:10.550+00:00"),
             ],
         )
+
         result = df.asof(stamp)
         tm.assert_series_equal(result, expected)
+
+    def test_is_copy(self, date_range_frame):
+        # GH-27357, GH-30784: ensure the result of asof is an actual copy and
+        # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+        df = date_range_frame
+        N = 50
+        df.loc[15:30, "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = df.asof(dates)
+
+        with tm.assert_produces_warning(None):
+            result["C"] = 1
diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py
new file mode 100644
index 0000000000000..34727da3b95ae
--- /dev/null
+++ b/pandas/tests/frame/methods/test_clip.py
@@ -0,0 +1,157 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class TestDataFrameClip:
+    def test_clip(self, float_frame):
+        median = float_frame.median().median()
+        original = float_frame.copy()
+
+        double = float_frame.clip(upper=median, lower=median)
+        assert not (double.values != median).any()
+
+        # Verify that float_frame was not changed inplace
+        assert (float_frame.values == original.values).all()
+
+    def test_inplace_clip(self, float_frame):
+        # GH#15388
+        median = float_frame.median().median()
+        frame_copy = float_frame.copy()
+
+        frame_copy.clip(upper=median, lower=median, inplace=True)
+        assert not (frame_copy.values != median).any()
+
+    def test_dataframe_clip(self):
+        # GH#2747
+        df = DataFrame(np.random.randn(1000, 2))
+
+        for lb, ub in [(-1, 1), (1, -1)]:
+            clipped_df = df.clip(lb, ub)
+
+            lb, ub = min(lb, ub), max(ub, lb)
+            lb_mask = df.values <= lb
+            ub_mask = df.values >= ub
+            mask = ~lb_mask & ~ub_mask
+            assert (clipped_df.values[lb_mask] == lb).all()
+            assert (clipped_df.values[ub_mask] == ub).all()
+            assert (clipped_df.values[mask] == df.values[mask]).all()
+
+    def test_clip_mixed_numeric(self):
+        # TODO(jreback)
+        # clip on mixed integer or floats
+        # with integer clippers coerces to float
+        df = DataFrame({"A": [1, 2, 3], "B": [1.0, np.nan, 3.0]})
+        result = df.clip(1, 2)
+        expected = DataFrame({"A": [1, 2, 2], "B": [1.0, np.nan, 2.0]})
+        tm.assert_frame_equal(result, expected, check_like=True)
+
+        # GH#24162, clipping now preserves numeric types per column
+        df = DataFrame([[1, 2, 3.4], [3, 4, 5.6]], columns=["foo", "bar", "baz"])
+        expected = df.dtypes
+        result = df.clip(upper=3).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_clip_against_series(self, inplace):
+        # GH#6966
+
+        df = DataFrame(np.random.randn(1000, 2))
+        lb = Series(np.random.randn(1000))
+        ub = lb + 1
+
+        original = df.copy()
+        clipped_df = df.clip(lb, ub, axis=0, inplace=inplace)
+
+        if inplace:
+            clipped_df = df
+
+        for i in range(2):
+            lb_mask = original.iloc[:, i] <= lb
+            ub_mask = original.iloc[:, i] >= ub
+            mask = ~lb_mask & ~ub_mask
+
+            result = clipped_df.loc[lb_mask, i]
+            tm.assert_series_equal(result, lb[lb_mask], check_names=False)
+            assert result.name == i
+
+            result = clipped_df.loc[ub_mask, i]
+            tm.assert_series_equal(result, ub[ub_mask], check_names=False)
+            assert result.name == i
+
+            tm.assert_series_equal(clipped_df.loc[mask, i], df.loc[mask, i])
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("lower", [[2, 3, 4], np.asarray([2, 3, 4])])
+    @pytest.mark.parametrize(
+        "axis,res",
+        [
+            (0, [[2.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 7.0, 7.0]]),
+            (1, [[2.0, 3.0, 4.0], [4.0, 5.0, 6.0], [5.0, 6.0, 7.0]]),
+        ],
+    )
+    def test_clip_against_list_like(self, simple_frame, inplace, lower, axis, res):
+        # GH#15390
+        original = simple_frame.copy(deep=True)
+
+        result = original.clip(lower=lower, upper=[5, 6, 7], axis=axis, inplace=inplace)
+
+        expected = pd.DataFrame(res, columns=original.columns, index=original.index)
+        if inplace:
+            result = original
+        tm.assert_frame_equal(result, expected, check_exact=True)
+
+    @pytest.mark.parametrize("axis", [0, 1, None])
+    def test_clip_against_frame(self, axis):
+        df = DataFrame(np.random.randn(1000, 2))
+        lb = DataFrame(np.random.randn(1000, 2))
+        ub = lb + 1
+
+        clipped_df = df.clip(lb, ub, axis=axis)
+
+        lb_mask = df <= lb
+        ub_mask = df >= ub
+        mask = ~lb_mask & ~ub_mask
+
+        tm.assert_frame_equal(clipped_df[lb_mask], lb[lb_mask])
+        tm.assert_frame_equal(clipped_df[ub_mask], ub[ub_mask])
+        tm.assert_frame_equal(clipped_df[mask], df[mask])
+
+    def test_clip_against_unordered_columns(self):
+        # GH#20911
+        df1 = DataFrame(np.random.randn(1000, 4), columns=["A", "B", "C", "D"])
+        df2 = DataFrame(np.random.randn(1000, 4), columns=["D", "A", "B", "C"])
+        df3 = DataFrame(df2.values - 1, columns=["B", "D", "C", "A"])
+        result_upper = df1.clip(lower=0, upper=df2)
+        expected_upper = df1.clip(lower=0, upper=df2[df1.columns])
+        result_lower = df1.clip(lower=df3, upper=3)
+        expected_lower = df1.clip(lower=df3[df1.columns], upper=3)
+        result_lower_upper = df1.clip(lower=df3, upper=df2)
+        expected_lower_upper = df1.clip(lower=df3[df1.columns], upper=df2[df1.columns])
+        tm.assert_frame_equal(result_upper, expected_upper)
+        tm.assert_frame_equal(result_lower, expected_lower)
+        tm.assert_frame_equal(result_lower_upper, expected_lower_upper)
+
+    def test_clip_with_na_args(self, float_frame):
+        """Should process np.nan argument as None """
+        # GH#17276
+        tm.assert_frame_equal(float_frame.clip(np.nan), float_frame)
+        tm.assert_frame_equal(float_frame.clip(upper=np.nan, lower=np.nan), float_frame)
+
+        # GH#19992
+        df = DataFrame({"col_0": [1, 2, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]})
+
+        result = df.clip(lower=[4, 5, np.nan], axis=0)
+        expected = DataFrame(
+            {"col_0": [4, 5, np.nan], "col_1": [4, 5, np.nan], "col_2": [7, 8, np.nan]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.clip(lower=[4, 5, np.nan], axis=1)
+        expected = DataFrame(
+            {"col_0": [4, 4, 4], "col_1": [5, 5, 6], "col_2": [np.nan, np.nan, np.nan]}
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_combine_first.py b/pandas/tests/frame/methods/test_combine_first.py
new file mode 100644
index 0000000000000..7715cb1cb6eec
--- /dev/null
+++ b/pandas/tests/frame/methods/test_combine_first.py
@@ -0,0 +1,349 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Index, Series
+import pandas._testing as tm
+
+
+class TestDataFrameCombineFirst:
+    def test_combine_first_mixed(self):
+        a = Series(["a", "b"], index=range(2))
+        b = Series(range(2), index=range(2))
+        f = DataFrame({"A": a, "B": b})
+
+        a = Series(["a", "b"], index=range(5, 7))
+        b = Series(range(2), index=range(5, 7))
+        g = DataFrame({"A": a, "B": b})
+
+        exp = pd.DataFrame(
+            {"A": list("abab"), "B": [0.0, 1.0, 0.0, 1.0]}, index=[0, 1, 5, 6]
+        )
+        combined = f.combine_first(g)
+        tm.assert_frame_equal(combined, exp)
+
+    def test_combine_first(self, float_frame):
+        # disjoint
+        head, tail = float_frame[:5], float_frame[5:]
+
+        combined = head.combine_first(tail)
+        reordered_frame = float_frame.reindex(combined.index)
+        tm.assert_frame_equal(combined, reordered_frame)
+        assert tm.equalContents(combined.columns, float_frame.columns)
+        tm.assert_series_equal(combined["A"], reordered_frame["A"])
+
+        # same index
+        fcopy = float_frame.copy()
+        fcopy["A"] = 1
+        del fcopy["C"]
+
+        fcopy2 = float_frame.copy()
+        fcopy2["B"] = 0
+        del fcopy2["D"]
+
+        combined = fcopy.combine_first(fcopy2)
+
+        assert (combined["A"] == 1).all()
+        tm.assert_series_equal(combined["B"], fcopy["B"])
+        tm.assert_series_equal(combined["C"], fcopy2["C"])
+        tm.assert_series_equal(combined["D"], fcopy["D"])
+
+        # overlap
+        head, tail = reordered_frame[:10].copy(), reordered_frame
+        head["A"] = 1
+
+        combined = head.combine_first(tail)
+        assert (combined["A"][:10] == 1).all()
+
+        # reverse overlap
+        tail["A"][:10] = 0
+        combined = tail.combine_first(head)
+        assert (combined["A"][:10] == 0).all()
+
+        # no overlap
+        f = float_frame[:10]
+        g = float_frame[10:]
+        combined = f.combine_first(g)
+        tm.assert_series_equal(combined["A"].reindex(f.index), f["A"])
+        tm.assert_series_equal(combined["A"].reindex(g.index), g["A"])
+
+        # corner cases
+        comb = float_frame.combine_first(DataFrame())
+        tm.assert_frame_equal(comb, float_frame)
+
+        comb = DataFrame().combine_first(float_frame)
+        tm.assert_frame_equal(comb, float_frame)
+
+        comb = float_frame.combine_first(DataFrame(index=["faz", "boo"]))
+        assert "faz" in comb.index
+
+        # #2525
+        df = DataFrame({"a": [1]}, index=[datetime(2012, 1, 1)])
+        df2 = DataFrame(columns=["b"])
+        result = df.combine_first(df2)
+        assert "b" in result
+
+    def test_combine_first_mixed_bug(self):
+        idx = Index(["a", "b", "c", "e"])
+        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
+        ser2 = Series(["a", "b", "c", "e"], index=idx)
+        ser3 = Series([12, 4, 5, 97], index=idx)
+
+        frame1 = DataFrame({"col0": ser1, "col2": ser2, "col3": ser3})
+
+        idx = Index(["a", "b", "c", "f"])
+        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
+        ser2 = Series(["a", "b", "c", "f"], index=idx)
+        ser3 = Series([12, 4, 5, 97], index=idx)
+
+        frame2 = DataFrame({"col1": ser1, "col2": ser2, "col5": ser3})
+
+        combined = frame1.combine_first(frame2)
+        assert len(combined.columns) == 5
+
+        # gh 3016 (same as in update)
+        df = DataFrame(
+            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+
+        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
+        result = df.combine_first(other)
+        tm.assert_frame_equal(result, df)
+
+        df.loc[0, "A"] = np.nan
+        result = df.combine_first(other)
+        df.loc[0, "A"] = 45
+        tm.assert_frame_equal(result, df)
+
+        # doc example
+        df1 = DataFrame(
+            {"A": [1.0, np.nan, 3.0, 5.0, np.nan], "B": [np.nan, 2.0, 3.0, np.nan, 6.0]}
+        )
+
+        df2 = DataFrame(
+            {
+                "A": [5.0, 2.0, 4.0, np.nan, 3.0, 7.0],
+                "B": [np.nan, np.nan, 3.0, 4.0, 6.0, 8.0],
+            }
+        )
+
+        result = df1.combine_first(df2)
+        expected = DataFrame({"A": [1, 2, 3, 5, 3, 7.0], "B": [np.nan, 2, 3, 4, 6, 8]})
+        tm.assert_frame_equal(result, expected)
+
+        # GH3552, return object dtype with bools
+        df1 = DataFrame(
+            [[np.nan, 3.0, True], [-4.6, np.nan, True], [np.nan, 7.0, False]]
+        )
+        df2 = DataFrame([[-42.6, np.nan, True], [-5.0, 1.6, False]], index=[1, 2])
+
+        result = df1.combine_first(df2)[2]
+        expected = Series([True, True, False], name=2)
+        tm.assert_series_equal(result, expected)
+
+        # GH 3593, converting datetime64[ns] incorrectly
+        df0 = DataFrame(
+            {"a": [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]}
+        )
+        df1 = DataFrame({"a": [None, None, None]})
+        df2 = df1.combine_first(df0)
+        tm.assert_frame_equal(df2, df0)
+
+        df2 = df0.combine_first(df1)
+        tm.assert_frame_equal(df2, df0)
+
+        df0 = DataFrame(
+            {"a": [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]}
+        )
+        df1 = DataFrame({"a": [datetime(2000, 1, 2), None, None]})
+        df2 = df1.combine_first(df0)
+        result = df0.copy()
+        result.iloc[0, :] = df1.iloc[0, :]
+        tm.assert_frame_equal(df2, result)
+
+        df2 = df0.combine_first(df1)
+        tm.assert_frame_equal(df2, df0)
+
+    def test_combine_first_align_nan(self):
+        # GH 7509 (not fixed)
+        dfa = pd.DataFrame([[pd.Timestamp("2011-01-01"), 2]], columns=["a", "b"])
+        dfb = pd.DataFrame([[4], [5]], columns=["b"])
+        assert dfa["a"].dtype == "datetime64[ns]"
+        assert dfa["b"].dtype == "int64"
+
+        res = dfa.combine_first(dfb)
+        exp = pd.DataFrame(
+            {"a": [pd.Timestamp("2011-01-01"), pd.NaT], "b": [2.0, 5.0]},
+            columns=["a", "b"],
+        )
+        tm.assert_frame_equal(res, exp)
+        assert res["a"].dtype == "datetime64[ns]"
+        # ToDo: this must be int64
+        assert res["b"].dtype == "float64"
+
+        res = dfa.iloc[:0].combine_first(dfb)
+        exp = pd.DataFrame({"a": [np.nan, np.nan], "b": [4, 5]}, columns=["a", "b"])
+        tm.assert_frame_equal(res, exp)
+        # ToDo: this must be datetime64
+        assert res["a"].dtype == "float64"
+        # ToDo: this must be int64
+        assert res["b"].dtype == "int64"
+
+    def test_combine_first_timezone(self):
+        # see gh-7630
+        data1 = pd.to_datetime("20100101 01:01").tz_localize("UTC")
+        df1 = pd.DataFrame(
+            columns=["UTCdatetime", "abc"],
+            data=data1,
+            index=pd.date_range("20140627", periods=1),
+        )
+        data2 = pd.to_datetime("20121212 12:12").tz_localize("UTC")
+        df2 = pd.DataFrame(
+            columns=["UTCdatetime", "xyz"],
+            data=data2,
+            index=pd.date_range("20140628", periods=1),
+        )
+        res = df2[["UTCdatetime"]].combine_first(df1)
+        exp = pd.DataFrame(
+            {
+                "UTCdatetime": [
+                    pd.Timestamp("2010-01-01 01:01", tz="UTC"),
+                    pd.Timestamp("2012-12-12 12:12", tz="UTC"),
+                ],
+                "abc": [pd.Timestamp("2010-01-01 01:01:00", tz="UTC"), pd.NaT],
+            },
+            columns=["UTCdatetime", "abc"],
+            index=pd.date_range("20140627", periods=2, freq="D"),
+        )
+        tm.assert_frame_equal(res, exp)
+        assert res["UTCdatetime"].dtype == "datetime64[ns, UTC]"
+        assert res["abc"].dtype == "datetime64[ns, UTC]"
+
+        # see gh-10567
+        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="UTC")
+        df1 = pd.DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-03", "2015-01-05", tz="UTC")
+        df2 = pd.DataFrame({"DATE": dts2})
+
+        res = df1.combine_first(df2)
+        tm.assert_frame_equal(res, df1)
+        assert res["DATE"].dtype == "datetime64[ns, UTC]"
+
+        dts1 = pd.DatetimeIndex(
+            ["2011-01-01", "NaT", "2011-01-03", "2011-01-04"], tz="US/Eastern"
+        )
+        df1 = pd.DataFrame({"DATE": dts1}, index=[1, 3, 5, 7])
+        dts2 = pd.DatetimeIndex(
+            ["2012-01-01", "2012-01-02", "2012-01-03"], tz="US/Eastern"
+        )
+        df2 = pd.DataFrame({"DATE": dts2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.DatetimeIndex(
+            [
+                "2011-01-01",
+                "2012-01-01",
+                "NaT",
+                "2012-01-02",
+                "2011-01-03",
+                "2011-01-04",
+            ],
+            tz="US/Eastern",
+        )
+        exp = pd.DataFrame({"DATE": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+
+        # different tz
+        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="US/Eastern")
+        df1 = pd.DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-03", "2015-01-05")
+        df2 = pd.DataFrame({"DATE": dts2})
+
+        # if df1 doesn't have NaN, keep its dtype
+        res = df1.combine_first(df2)
+        tm.assert_frame_equal(res, df1)
+        assert res["DATE"].dtype == "datetime64[ns, US/Eastern]"
+
+        dts1 = pd.date_range("2015-01-01", "2015-01-02", tz="US/Eastern")
+        df1 = pd.DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-01", "2015-01-03")
+        df2 = pd.DataFrame({"DATE": dts2})
+
+        res = df1.combine_first(df2)
+        exp_dts = [
+            pd.Timestamp("2015-01-01", tz="US/Eastern"),
+            pd.Timestamp("2015-01-02", tz="US/Eastern"),
+            pd.Timestamp("2015-01-03"),
+        ]
+        exp = pd.DataFrame({"DATE": exp_dts})
+        tm.assert_frame_equal(res, exp)
+        assert res["DATE"].dtype == "object"
+
+    def test_combine_first_timedelta(self):
+        data1 = pd.TimedeltaIndex(["1 day", "NaT", "3 day", "4day"])
+        df1 = pd.DataFrame({"TD": data1}, index=[1, 3, 5, 7])
+        data2 = pd.TimedeltaIndex(["10 day", "11 day", "12 day"])
+        df2 = pd.DataFrame({"TD": data2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.TimedeltaIndex(
+            ["1 day", "10 day", "NaT", "11 day", "3 day", "4 day"]
+        )
+        exp = pd.DataFrame({"TD": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["TD"].dtype == "timedelta64[ns]"
+
+    def test_combine_first_period(self):
+        data1 = pd.PeriodIndex(["2011-01", "NaT", "2011-03", "2011-04"], freq="M")
+        df1 = pd.DataFrame({"P": data1}, index=[1, 3, 5, 7])
+        data2 = pd.PeriodIndex(["2012-01-01", "2012-02", "2012-03"], freq="M")
+        df2 = pd.DataFrame({"P": data2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.PeriodIndex(
+            ["2011-01", "2012-01", "NaT", "2012-02", "2011-03", "2011-04"], freq="M"
+        )
+        exp = pd.DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["P"].dtype == data1.dtype
+
+        # different freq
+        dts2 = pd.PeriodIndex(["2012-01-01", "2012-01-02", "2012-01-03"], freq="D")
+        df2 = pd.DataFrame({"P": dts2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = [
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2012-01-01", freq="D"),
+            pd.NaT,
+            pd.Period("2012-01-02", freq="D"),
+            pd.Period("2011-03", freq="M"),
+            pd.Period("2011-04", freq="M"),
+        ]
+        exp = pd.DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["P"].dtype == "object"
+
+    def test_combine_first_int(self):
+        # GH14687 - integer series that do no align exactly
+
+        df1 = pd.DataFrame({"a": [0, 1, 3, 5]}, dtype="int64")
+        df2 = pd.DataFrame({"a": [1, 4]}, dtype="int64")
+
+        res = df1.combine_first(df2)
+        tm.assert_frame_equal(res, df1)
+        assert res["a"].dtype == "int64"
+
+    @pytest.mark.parametrize("val", [1, 1.0])
+    def test_combine_first_with_asymmetric_other(self, val):
+        # see gh-20699
+        df1 = pd.DataFrame({"isNum": [val]})
+        df2 = pd.DataFrame({"isBool": [True]})
+
+        res = df1.combine_first(df2)
+        exp = pd.DataFrame({"isBool": [True], "isNum": [val]})
+
+        tm.assert_frame_equal(res, exp)
diff --git a/pandas/tests/frame/methods/test_count.py b/pandas/tests/frame/methods/test_count.py
new file mode 100644
index 0000000000000..13a93e3efc48c
--- /dev/null
+++ b/pandas/tests/frame/methods/test_count.py
@@ -0,0 +1,36 @@
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class TestDataFrameCount:
+    def test_count(self):
+        # corner case
+        frame = DataFrame()
+        ct1 = frame.count(1)
+        assert isinstance(ct1, Series)
+
+        ct2 = frame.count(0)
+        assert isinstance(ct2, Series)
+
+        # GH#423
+        df = DataFrame(index=range(10))
+        result = df.count(1)
+        expected = Series(0, index=df.index)
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame(columns=range(10))
+        result = df.count(0)
+        expected = Series(0, index=df.columns)
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame()
+        result = df.count()
+        expected = Series(0, index=[])
+        tm.assert_series_equal(result, expected)
+
+    def test_count_objects(self, float_string_frame):
+        dm = DataFrame(float_string_frame._series)
+        df = DataFrame(float_string_frame._series)
+
+        tm.assert_series_equal(dm.count(), df.count())
+        tm.assert_series_equal(dm.count(1), df.count(1))
diff --git a/pandas/tests/frame/methods/test_cov_corr.py b/pandas/tests/frame/methods/test_cov_corr.py
new file mode 100644
index 0000000000000..5c13b60aae0d0
--- /dev/null
+++ b/pandas/tests/frame/methods/test_cov_corr.py
@@ -0,0 +1,272 @@
+import warnings
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame, Series, isna
+import pandas._testing as tm
+
+
+class TestDataFrameCov:
+    def test_cov(self, float_frame, float_string_frame):
+        # min_periods no NAs (corner case)
+        expected = float_frame.cov()
+        result = float_frame.cov(min_periods=len(float_frame))
+
+        tm.assert_frame_equal(expected, result)
+
+        result = float_frame.cov(min_periods=len(float_frame) + 1)
+        assert isna(result.values).all()
+
+        # with NAs
+        frame = float_frame.copy()
+        frame["A"][:5] = np.nan
+        frame["B"][5:10] = np.nan
+        result = float_frame.cov(min_periods=len(float_frame) - 8)
+        expected = float_frame.cov()
+        expected.loc["A", "B"] = np.nan
+        expected.loc["B", "A"] = np.nan
+
+        # regular
+        float_frame["A"][:5] = np.nan
+        float_frame["B"][:10] = np.nan
+        cov = float_frame.cov()
+
+        tm.assert_almost_equal(cov["A"]["C"], float_frame["A"].cov(float_frame["C"]))
+
+        # exclude non-numeric types
+        result = float_string_frame.cov()
+        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].cov()
+        tm.assert_frame_equal(result, expected)
+
+        # Single column frame
+        df = DataFrame(np.linspace(0.0, 1.0, 10))
+        result = df.cov()
+        expected = DataFrame(
+            np.cov(df.values.T).reshape((1, 1)), index=df.columns, columns=df.columns
+        )
+        tm.assert_frame_equal(result, expected)
+        df.loc[0] = np.nan
+        result = df.cov()
+        expected = DataFrame(
+            np.cov(df.values[1:].T).reshape((1, 1)),
+            index=df.columns,
+            columns=df.columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+class TestDataFrameCorr:
+    # DataFrame.corr(), as opposed to DataFrame.corrwith
+
+    @pytest.mark.parametrize("method", ["pearson", "kendall", "spearman"])
+    @td.skip_if_no_scipy
+    def test_corr_scipy_method(self, float_frame, method):
+        float_frame["A"][:5] = np.nan
+        float_frame["B"][5:10] = np.nan
+
+        correls = float_frame.corr(method=method)
+        expected = float_frame["A"].corr(float_frame["C"], method=method)
+        tm.assert_almost_equal(correls["A"]["C"], expected)
+
+    # ---------------------------------------------------------------------
+
+    @td.skip_if_no_scipy
+    def test_corr_non_numeric(self, float_frame, float_string_frame):
+        float_frame["A"][:5] = np.nan
+        float_frame["B"][5:10] = np.nan
+
+        # exclude non-numeric types
+        result = float_string_frame.corr()
+        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].corr()
+        tm.assert_frame_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
+    def test_corr_nooverlap(self, meth):
+        # nothing in common
+        df = DataFrame(
+            {
+                "A": [1, 1.5, 1, np.nan, np.nan, np.nan],
+                "B": [np.nan, np.nan, np.nan, 1, 1.5, 1],
+                "C": [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+            }
+        )
+        rs = df.corr(meth)
+        assert isna(rs.loc["A", "B"])
+        assert isna(rs.loc["B", "A"])
+        assert rs.loc["A", "A"] == 1
+        assert rs.loc["B", "B"] == 1
+        assert isna(rs.loc["C", "C"])
+
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize("meth", ["pearson", "spearman"])
+    def test_corr_constant(self, meth):
+        # constant --> all NA
+
+        df = DataFrame(
+            {
+                "A": [1, 1, 1, np.nan, np.nan, np.nan],
+                "B": [np.nan, np.nan, np.nan, 1, 1, 1],
+            }
+        )
+        rs = df.corr(meth)
+        assert isna(rs.values).all()
+
+    @td.skip_if_no_scipy
+    def test_corr_int_and_boolean(self):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        df = DataFrame({"a": [True, False], "b": [1, 0]})
+
+        expected = DataFrame(np.ones((2, 2)), index=["a", "b"], columns=["a", "b"])
+        for meth in ["pearson", "kendall", "spearman"]:
+
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("ignore", RuntimeWarning)
+                result = df.corr(meth)
+            tm.assert_frame_equal(result, expected)
+
+    def test_corr_cov_independent_index_column(self):
+        # GH#14617
+        df = pd.DataFrame(np.random.randn(4 * 10).reshape(10, 4), columns=list("abcd"))
+        for method in ["cov", "corr"]:
+            result = getattr(df, method)()
+            assert result.index is not result.columns
+            assert result.index.equals(result.columns)
+
+    def test_corr_invalid_method(self):
+        # GH#22298
+        df = pd.DataFrame(np.random.normal(size=(10, 2)))
+        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
+        with pytest.raises(ValueError, match=msg):
+            df.corr(method="____")
+
+    def test_corr_int(self):
+        # dtypes other than float64 GH#1761
+        df3 = DataFrame({"a": [1, 2, 3, 4], "b": [1, 2, 3, 4]})
+
+        df3.cov()
+        df3.corr()
+
+
+class TestDataFrameCorrWith:
+    def test_corrwith(self, datetime_frame):
+        a = datetime_frame
+        noise = Series(np.random.randn(len(a)), index=a.index)
+
+        b = datetime_frame.add(noise, axis=0)
+
+        # make sure order does not matter
+        b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:])
+        del b["B"]
+
+        colcorr = a.corrwith(b, axis=0)
+        tm.assert_almost_equal(colcorr["A"], a["A"].corr(b["A"]))
+
+        rowcorr = a.corrwith(b, axis=1)
+        tm.assert_series_equal(rowcorr, a.T.corrwith(b.T, axis=0))
+
+        dropped = a.corrwith(b, axis=0, drop=True)
+        tm.assert_almost_equal(dropped["A"], a["A"].corr(b["A"]))
+        assert "B" not in dropped
+
+        dropped = a.corrwith(b, axis=1, drop=True)
+        assert a.index[-1] not in dropped.index
+
+        # non time-series data
+        index = ["a", "b", "c", "d", "e"]
+        columns = ["one", "two", "three", "four"]
+        df1 = DataFrame(np.random.randn(5, 4), index=index, columns=columns)
+        df2 = DataFrame(np.random.randn(4, 4), index=index[:4], columns=columns)
+        correls = df1.corrwith(df2, axis=1)
+        for row in index[:4]:
+            tm.assert_almost_equal(correls[row], df1.loc[row].corr(df2.loc[row]))
+
+    def test_corrwith_with_objects(self):
+        df1 = tm.makeTimeDataFrame()
+        df2 = tm.makeTimeDataFrame()
+        cols = ["A", "B", "C", "D"]
+
+        df1["obj"] = "foo"
+        df2["obj"] = "bar"
+
+        result = df1.corrwith(df2)
+        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols])
+        tm.assert_series_equal(result, expected)
+
+        result = df1.corrwith(df2, axis=1)
+        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols], axis=1)
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_series(self, datetime_frame):
+        result = datetime_frame.corrwith(datetime_frame["A"])
+        expected = datetime_frame.apply(datetime_frame["A"].corr)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_matches_corrcoef(self):
+        df1 = DataFrame(np.arange(10000), columns=["a"])
+        df2 = DataFrame(np.arange(10000) ** 2, columns=["a"])
+        c1 = df1.corrwith(df2)["a"]
+        c2 = np.corrcoef(df1["a"], df2["a"])[0][1]
+
+        tm.assert_almost_equal(c1, c2)
+        assert c1 < 1
+
+    def test_corrwith_mixed_dtypes(self):
+        # GH#18570
+        df = pd.DataFrame(
+            {"a": [1, 4, 3, 2], "b": [4, 6, 7, 3], "c": ["a", "b", "c", "d"]}
+        )
+        s = pd.Series([0, 6, 7, 3])
+        result = df.corrwith(s)
+        corrs = [df["a"].corr(s), df["b"].corr(s)]
+        expected = pd.Series(data=corrs, index=["a", "b"])
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_index_intersection(self):
+        df1 = pd.DataFrame(np.random.random(size=(10, 2)), columns=["a", "b"])
+        df2 = pd.DataFrame(np.random.random(size=(10, 3)), columns=["a", "b", "c"])
+
+        result = df1.corrwith(df2, drop=True).index.sort_values()
+        expected = df1.columns.intersection(df2.columns).sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_corrwith_index_union(self):
+        df1 = pd.DataFrame(np.random.random(size=(10, 2)), columns=["a", "b"])
+        df2 = pd.DataFrame(np.random.random(size=(10, 3)), columns=["a", "b", "c"])
+
+        result = df1.corrwith(df2, drop=False).index.sort_values()
+        expected = df1.columns.union(df2.columns).sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_corrwith_dup_cols(self):
+        # GH#21925
+        df1 = pd.DataFrame(np.vstack([np.arange(10)] * 3).T)
+        df2 = df1.copy()
+        df2 = pd.concat((df2, df2[0]), axis=1)
+
+        result = df1.corrwith(df2)
+        expected = pd.Series(np.ones(4), index=[0, 0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    def test_corrwith_spearman(self):
+        # GH#21925
+        df = pd.DataFrame(np.random.random(size=(100, 3)))
+        result = df.corrwith(df ** 2, method="spearman")
+        expected = Series(np.ones(len(result)))
+        tm.assert_series_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    def test_corrwith_kendall(self):
+        # GH#21925
+        df = pd.DataFrame(np.random.random(size=(100, 3)))
+        result = df.corrwith(df ** 2, method="kendall")
+        expected = Series(np.ones(len(result)))
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_describe.py b/pandas/tests/frame/methods/test_describe.py
new file mode 100644
index 0000000000000..127233ed2713e
--- /dev/null
+++ b/pandas/tests/frame/methods/test_describe.py
@@ -0,0 +1,300 @@
+import numpy as np
+
+import pandas as pd
+from pandas import Categorical, DataFrame, Series, Timestamp, date_range
+import pandas._testing as tm
+
+
+class TestDataFrameDescribe:
+    def test_describe_bool_in_mixed_frame(self):
+        df = DataFrame(
+            {
+                "string_data": ["a", "b", "c", "d", "e"],
+                "bool_data": [True, True, False, False, False],
+                "int_data": [10, 20, 30, 40, 50],
+            }
+        )
+
+        # Integer data are included in .describe() output,
+        # Boolean and string data are not.
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 30, df.int_data.std(), 10, 20, 30, 40, 50]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # Top value is a boolean value that is False
+        result = df.describe(include=["bool"])
+
+        expected = DataFrame(
+            {"bool_data": [5, 2, False, 3]}, index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # GH#27183
+        df = pd.DataFrame({"A": [None, None]}, dtype=object)
+        result = df.describe()
+        expected = pd.DataFrame(
+            {"A": [0, 0, np.nan, np.nan]},
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.iloc[:0].describe()
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_bool_frame(self):
+        # GH#13891
+        df = pd.DataFrame(
+            {
+                "bool_data_1": [False, False, True, True],
+                "bool_data_2": [False, True, True, True],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data_1": [4, 2, True, 2], "bool_data_2": [4, 2, True, 3]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = pd.DataFrame(
+            {
+                "bool_data": [False, False, True, True, False],
+                "int_data": [0, 1, 2, 3, 4],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 2, df.int_data.std(), 0, 1, 2, 3, 4]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = pd.DataFrame(
+            {"bool_data": [False, False, True, True], "str_data": ["a", "b", "c", "a"]}
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data": [4, 2, True, 2], "str_data": [4, 3, "a", 2]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_categorical(self):
+        df = DataFrame({"value": np.random.randint(0, 10000, 100)})
+        labels = ["{0} - {1}".format(i, i + 499) for i in range(0, 10000, 500)]
+        cat_labels = Categorical(labels, labels)
+
+        df = df.sort_values(by=["value"], ascending=True)
+        df["value_group"] = pd.cut(
+            df.value, range(0, 10500, 500), right=False, labels=cat_labels
+        )
+        cat = df
+
+        # Categoricals should not show up together with numerical columns
+        result = cat.describe()
+        assert len(result.columns) == 1
+
+        # In a frame, describe() for the cat should be the same as for string
+        # arrays (count, unique, top, freq)
+
+        cat = Categorical(
+            ["a", "b", "b", "b"], categories=["a", "b", "c"], ordered=True
+        )
+        s = Series(cat)
+        result = s.describe()
+        expected = Series([4, 2, "b", 3], index=["count", "unique", "top", "freq"])
+        tm.assert_series_equal(result, expected)
+
+        cat = Series(Categorical(["a", "b", "c", "c"]))
+        df3 = DataFrame({"cat": cat, "s": ["a", "b", "c", "c"]})
+        result = df3.describe()
+        tm.assert_numpy_array_equal(result["cat"].values, result["s"].values)
+
+    def test_describe_empty_categorical_column(self):
+        # GH#26397
+        # Ensure the index of an an empty categorical DataFrame column
+        # also contains (count, unique, top, freq)
+        df = pd.DataFrame({"empty_col": Categorical([])})
+        result = df.describe()
+        expected = DataFrame(
+            {"empty_col": [0, 0, np.nan, np.nan]},
+            index=["count", "unique", "top", "freq"],
+            dtype="object",
+        )
+        tm.assert_frame_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2, 0])
+        assert np.isnan(result.iloc[3, 0])
+
+    def test_describe_categorical_columns(self):
+        # GH#11558
+        columns = pd.CategoricalIndex(["int1", "int2", "obj"], ordered=True, name="XXX")
+        df = DataFrame(
+            {
+                "int1": [10, 20, 30, 40, 50],
+                "int2": [10, 20, 30, 40, 50],
+                "obj": ["A", 0, None, "X", 1],
+            },
+            columns=columns,
+        )
+        result = df.describe()
+
+        exp_columns = pd.CategoricalIndex(
+            ["int1", "int2"],
+            categories=["int1", "int2", "obj"],
+            ordered=True,
+            name="XXX",
+        )
+        expected = DataFrame(
+            {
+                "int1": [5, 30, df.int1.std(), 10, 20, 30, 40, 50],
+                "int2": [5, 30, df.int2.std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            columns=exp_columns,
+        )
+
+        tm.assert_frame_equal(result, expected)
+        tm.assert_categorical_equal(result.columns.values, expected.columns.values)
+
+    def test_describe_datetime_columns(self):
+        columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01", "2011-03-01"],
+            freq="MS",
+            tz="US/Eastern",
+            name="XXX",
+        )
+        df = DataFrame(
+            {
+                0: [10, 20, 30, 40, 50],
+                1: [10, 20, 30, 40, 50],
+                2: ["A", 0, None, "X", 1],
+            }
+        )
+        df.columns = columns
+        result = df.describe()
+
+        exp_columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01"], freq="MS", tz="US/Eastern", name="XXX"
+        )
+        expected = DataFrame(
+            {
+                0: [5, 30, df.iloc[:, 0].std(), 10, 20, 30, 40, 50],
+                1: [5, 30, df.iloc[:, 1].std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        expected.columns = exp_columns
+        tm.assert_frame_equal(result, expected)
+        assert result.columns.freq == "MS"
+        assert result.columns.tz == expected.columns.tz
+
+    def test_describe_timedelta_values(self):
+        # GH#6145
+        t1 = pd.timedelta_range("1 days", freq="D", periods=5)
+        t2 = pd.timedelta_range("1 hours", freq="H", periods=5)
+        df = pd.DataFrame({"t1": t1, "t2": t2})
+
+        expected = DataFrame(
+            {
+                "t1": [
+                    5,
+                    pd.Timedelta("3 days"),
+                    df.iloc[:, 0].std(),
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                    pd.Timedelta("4 days"),
+                    pd.Timedelta("5 days"),
+                ],
+                "t2": [
+                    5,
+                    pd.Timedelta("3 hours"),
+                    df.iloc[:, 1].std(),
+                    pd.Timedelta("1 hours"),
+                    pd.Timedelta("2 hours"),
+                    pd.Timedelta("3 hours"),
+                    pd.Timedelta("4 hours"),
+                    pd.Timedelta("5 hours"),
+                ],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+
+        result = df.describe()
+        tm.assert_frame_equal(result, expected)
+
+        exp_repr = (
+            "                           t1                      t2\n"
+            "count                       5                       5\n"
+            "mean          3 days 00:00:00         0 days 03:00:00\n"
+            "std    1 days 13:56:50.394919  0 days 01:34:52.099788\n"
+            "min           1 days 00:00:00         0 days 01:00:00\n"
+            "25%           2 days 00:00:00         0 days 02:00:00\n"
+            "50%           3 days 00:00:00         0 days 03:00:00\n"
+            "75%           4 days 00:00:00         0 days 04:00:00\n"
+            "max           5 days 00:00:00         0 days 05:00:00"
+        )
+        assert repr(result) == exp_repr
+
+    def test_describe_tz_values(self, tz_naive_fixture):
+        # GH#21332
+        tz = tz_naive_fixture
+        s1 = Series(range(5))
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s2 = Series(date_range(start, end, tz=tz))
+        df = pd.DataFrame({"s1": s1, "s2": s2})
+
+        expected = DataFrame(
+            {
+                "s1": [5, 2, 0, 1, 2, 3, 4, 1.581139],
+                "s2": [
+                    5,
+                    Timestamp(2018, 1, 3).tz_localize(tz),
+                    start.tz_localize(tz),
+                    s2[1],
+                    s2[2],
+                    s2[3],
+                    end.tz_localize(tz),
+                    np.nan,
+                ],
+            },
+            index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
+        )
+        result = df.describe(include="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_percentiles_integer_idx(self):
+        # GH#26660
+        df = pd.DataFrame({"x": [1]})
+        pct = np.linspace(0, 1, 10 + 1)
+        result = df.describe(percentiles=pct)
+
+        expected = DataFrame(
+            {"x": [1.0, 1.0, np.NaN, 1.0, *[1.0 for _ in pct], 1.0]},
+            index=[
+                "count",
+                "mean",
+                "std",
+                "min",
+                "0%",
+                "10%",
+                "20%",
+                "30%",
+                "40%",
+                "50%",
+                "60%",
+                "70%",
+                "80%",
+                "90%",
+                "100%",
+                "max",
+            ],
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_diff.py b/pandas/tests/frame/methods/test_diff.py
new file mode 100644
index 0000000000000..ffdb6d41ebda5
--- /dev/null
+++ b/pandas/tests/frame/methods/test_diff.py
@@ -0,0 +1,120 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, Timestamp, date_range
+import pandas._testing as tm
+
+
+class TestDataFrameDiff:
+    def test_diff(self, datetime_frame):
+        the_diff = datetime_frame.diff(1)
+
+        tm.assert_series_equal(
+            the_diff["A"], datetime_frame["A"] - datetime_frame["A"].shift(1)
+        )
+
+        # int dtype
+        a = 10_000_000_000_000_000
+        b = a + 1
+        s = Series([a, b])
+
+        rs = DataFrame({"s": s}).diff()
+        assert rs.s[1] == 1
+
+        # mixed numeric
+        tf = datetime_frame.astype("float32")
+        the_diff = tf.diff(1)
+        tm.assert_series_equal(the_diff["A"], tf["A"] - tf["A"].shift(1))
+
+        # GH#10907
+        df = pd.DataFrame({"y": pd.Series([2]), "z": pd.Series([3])})
+        df.insert(0, "x", 1)
+        result = df.diff(axis=1)
+        expected = pd.DataFrame(
+            {"x": np.nan, "y": pd.Series(1), "z": pd.Series(1)}
+        ).astype("float64")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis0(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+
+        result = df.diff(axis=0)
+        expected = DataFrame(
+            {
+                0: pd.TimedeltaIndex(["NaT", "1 days"]),
+                1: pd.TimedeltaIndex(["NaT", "1 days"]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis1(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+        if tz is None:
+            result = df.diff(axis=1)
+            expected = DataFrame(
+                {
+                    0: pd.TimedeltaIndex(["NaT", "NaT"]),
+                    1: pd.TimedeltaIndex(["0 days", "0 days"]),
+                }
+            )
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(NotImplementedError):
+                result = df.diff(axis=1)
+
+    def test_diff_timedelta(self):
+        # GH#4533
+        df = DataFrame(
+            dict(
+                time=[Timestamp("20130101 9:01"), Timestamp("20130101 9:02")],
+                value=[1.0, 2.0],
+            )
+        )
+
+        res = df.diff()
+        exp = DataFrame(
+            [[pd.NaT, np.nan], [pd.Timedelta("00:01:00"), 1]], columns=["time", "value"]
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_diff_mixed_dtype(self):
+        df = DataFrame(np.random.randn(5, 3))
+        df["A"] = np.array([1, 2, 3, 4, 5], dtype=object)
+
+        result = df.diff()
+        assert result[0].dtype == np.float64
+
+    def test_diff_neg_n(self, datetime_frame):
+        rs = datetime_frame.diff(-1)
+        xp = datetime_frame - datetime_frame.shift(-1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_float_n(self, datetime_frame):
+        rs = datetime_frame.diff(1.0)
+        xp = datetime_frame.diff(1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_axis(self):
+        # GH#9727
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0]])
+        tm.assert_frame_equal(
+            df.diff(axis=1), DataFrame([[np.nan, 1.0], [np.nan, 1.0]])
+        )
+        tm.assert_frame_equal(
+            df.diff(axis=0), DataFrame([[np.nan, np.nan], [2.0, 2.0]])
+        )
diff --git a/pandas/tests/frame/test_duplicates.py b/pandas/tests/frame/methods/test_drop_duplicates.py
similarity index 81%
rename from pandas/tests/frame/test_duplicates.py
rename to pandas/tests/frame/methods/test_drop_duplicates.py
index d2a1fc43d2046..fd4bae26ade57 100644
--- a/pandas/tests/frame/test_duplicates.py
+++ b/pandas/tests/frame/methods/test_drop_duplicates.py
@@ -3,95 +3,20 @@
 import numpy as np
 import pytest
 
-from pandas import DataFrame, Series
-import pandas.util.testing as tm
+from pandas import DataFrame
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("subset", ["a", ["a"], ["a", "B"]])
-def test_duplicated_with_misspelled_column_name(subset):
+def test_drop_duplicates_with_misspelled_column_name(subset):
     # GH 19730
     df = DataFrame({"A": [0, 0, 1], "B": [0, 0, 1], "C": [0, 0, 1]})
     msg = re.escape("Index(['a'], dtype='object')")
 
-    with pytest.raises(KeyError, match=msg):
-        df.duplicated(subset)
-
     with pytest.raises(KeyError, match=msg):
         df.drop_duplicates(subset)
 
 
-@pytest.mark.slow
-def test_duplicated_do_not_fail_on_wide_dataframes():
-    # gh-21524
-    # Given the wide dataframe with a lot of columns
-    # with different (important!) values
-    data = {
-        "col_{0:02d}".format(i): np.random.randint(0, 1000, 30000) for i in range(100)
-    }
-    df = DataFrame(data).T
-    result = df.duplicated()
-
-    # Then duplicates produce the bool Series as a result and don't fail during
-    # calculation. Actual values doesn't matter here, though usually it's all
-    # False in this case
-    assert isinstance(result, Series)
-    assert result.dtype == np.bool
-
-
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, True, False, True])),
-        ("last", Series([True, True, False, False, False])),
-        (False, Series([True, True, True, False, True])),
-    ],
-)
-def test_duplicated_keep(keep, expected):
-    df = DataFrame({"A": [0, 1, 1, 2, 0], "B": ["a", "b", "b", "c", "a"]})
-
-    result = df.duplicated(keep=keep)
-    tm.assert_series_equal(result, expected)
-
-
-@pytest.mark.xfail(reason="GH#21720; nan/None falsely considered equal")
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, True, False, True])),
-        ("last", Series([True, True, False, False, False])),
-        (False, Series([True, True, True, False, True])),
-    ],
-)
-def test_duplicated_nan_none(keep, expected):
-    df = DataFrame({"C": [np.nan, 3, 3, None, np.nan]}, dtype=object)
-
-    result = df.duplicated(keep=keep)
-    tm.assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize("keep", ["first", "last", False])
-@pytest.mark.parametrize("subset", [None, ["A", "B"], "A"])
-def test_duplicated_subset(subset, keep):
-    df = DataFrame(
-        {
-            "A": [0, 1, 1, 2, 0],
-            "B": ["a", "b", "b", "c", "a"],
-            "C": [np.nan, 3, 3, None, np.nan],
-        }
-    )
-
-    if subset is None:
-        subset = list(df.columns)
-    elif isinstance(subset, str):
-        # need to have a DataFrame, not a Series
-        # -> select columns with singleton list, not string
-        subset = [subset]
-
-    expected = df[subset].duplicated(keep=keep)
-    result = df.duplicated(keep=keep, subset=subset)
-    tm.assert_series_equal(result, expected)
-
-
 def test_drop_duplicates():
     df = DataFrame(
         {
@@ -188,17 +113,6 @@ def test_drop_duplicates():
         assert df.duplicated(keep=keep).sum() == 0
 
 
-def test_duplicated_on_empty_frame():
-    # GH 25184
-
-    df = DataFrame(columns=["a", "b"])
-    dupes = df.duplicated("a")
-
-    result = df[dupes]
-    expected = df.copy()
-    tm.assert_frame_equal(result, expected)
-
-
 def test_drop_duplicates_with_duplicate_column_names():
     # GH17836
     df = DataFrame([[1, 2, 5], [3, 4, 6], [3, 4, 7]], columns=["a", "a", "b"])
@@ -477,3 +391,30 @@ def test_drop_duplicates_inplace():
     expected = orig2.drop_duplicates(["A", "B"], keep=False)
     result = df2
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("inplace", [True, False])
+@pytest.mark.parametrize(
+    "origin_dict, output_dict, ignore_index, output_index",
+    [
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, True, [0, 1]),
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, False, [0, 2]),
+        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, True, [0, 1]),
+        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, False, [0, 2]),
+    ],
+)
+def test_drop_duplicates_ignore_index(
+    inplace, origin_dict, output_dict, ignore_index, output_index
+):
+    # GH 30114
+    df = DataFrame(origin_dict)
+    expected = DataFrame(output_dict, index=output_index)
+
+    if inplace:
+        result_df = df.copy()
+        result_df.drop_duplicates(ignore_index=ignore_index, inplace=inplace)
+    else:
+        result_df = df.drop_duplicates(ignore_index=ignore_index, inplace=inplace)
+
+    tm.assert_frame_equal(result_df, expected)
+    tm.assert_frame_equal(df, DataFrame(origin_dict))
diff --git a/pandas/tests/frame/methods/test_duplicated.py b/pandas/tests/frame/methods/test_duplicated.py
new file mode 100644
index 0000000000000..72eec8753315c
--- /dev/null
+++ b/pandas/tests/frame/methods/test_duplicated.py
@@ -0,0 +1,100 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("subset", ["a", ["a"], ["a", "B"]])
+def test_duplicated_with_misspelled_column_name(subset):
+    # GH 19730
+    df = DataFrame({"A": [0, 0, 1], "B": [0, 0, 1], "C": [0, 0, 1]})
+    msg = re.escape("Index(['a'], dtype='object')")
+
+    with pytest.raises(KeyError, match=msg):
+        df.duplicated(subset)
+
+
+@pytest.mark.slow
+def test_duplicated_do_not_fail_on_wide_dataframes():
+    # gh-21524
+    # Given the wide dataframe with a lot of columns
+    # with different (important!) values
+    data = {
+        "col_{0:02d}".format(i): np.random.randint(0, 1000, 30000) for i in range(100)
+    }
+    df = DataFrame(data).T
+    result = df.duplicated()
+
+    # Then duplicates produce the bool Series as a result and don't fail during
+    # calculation. Actual values doesn't matter here, though usually it's all
+    # False in this case
+    assert isinstance(result, Series)
+    assert result.dtype == np.bool
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_keep(keep, expected):
+    df = DataFrame({"A": [0, 1, 1, 2, 0], "B": ["a", "b", "b", "c", "a"]})
+
+    result = df.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.xfail(reason="GH#21720; nan/None falsely considered equal")
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_nan_none(keep, expected):
+    df = DataFrame({"C": [np.nan, 3, 3, None, np.nan]}, dtype=object)
+
+    result = df.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("keep", ["first", "last", False])
+@pytest.mark.parametrize("subset", [None, ["A", "B"], "A"])
+def test_duplicated_subset(subset, keep):
+    df = DataFrame(
+        {
+            "A": [0, 1, 1, 2, 0],
+            "B": ["a", "b", "b", "c", "a"],
+            "C": [np.nan, 3, 3, None, np.nan],
+        }
+    )
+
+    if subset is None:
+        subset = list(df.columns)
+    elif isinstance(subset, str):
+        # need to have a DataFrame, not a Series
+        # -> select columns with singleton list, not string
+        subset = [subset]
+
+    expected = df[subset].duplicated(keep=keep)
+    result = df.duplicated(keep=keep, subset=subset)
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicated_on_empty_frame():
+    # GH 25184
+
+    df = DataFrame(columns=["a", "b"])
+    dupes = df.duplicated("a")
+
+    result = df[dupes]
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_explode.py b/pandas/tests/frame/methods/test_explode.py
similarity index 64%
rename from pandas/tests/frame/test_explode.py
rename to pandas/tests/frame/methods/test_explode.py
index b4330aadbfba3..76c87ed355492 100644
--- a/pandas/tests/frame/test_explode.py
+++ b/pandas/tests/frame/methods/test_explode.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 def test_error():
@@ -118,3 +118,47 @@ def test_usecase():
         index=[0, 0, 1, 1],
     )
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "input_dict, input_index, expected_dict, expected_index",
+    [
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            [0, 0],
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            [0, 0, 0, 0],
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.Index([0, 0], name="my_index"),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.Index([0, 0, 0, 0], name="my_index"),
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0], [1, 1]], names=["my_first_index", "my_second_index"]
+            ),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0, 0, 0], [1, 1, 1, 1]],
+                names=["my_first_index", "my_second_index"],
+            ),
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.MultiIndex.from_arrays([[0, 0], [1, 1]], names=["my_index", None]),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0, 0, 0], [1, 1, 1, 1]], names=["my_index", None]
+            ),
+        ),
+    ],
+)
+def test_duplicate_index(input_dict, input_index, expected_dict, expected_index):
+    # GH 28005
+    df = pd.DataFrame(input_dict, index=input_index)
+    result = df.explode("col1")
+    expected = pd.DataFrame(expected_dict, index=expected_index, dtype=object)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_head_tail.py b/pandas/tests/frame/methods/test_head_tail.py
new file mode 100644
index 0000000000000..93763bc12ce0d
--- /dev/null
+++ b/pandas/tests/frame/methods/test_head_tail.py
@@ -0,0 +1,30 @@
+import numpy as np
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+def test_head_tail(float_frame):
+    tm.assert_frame_equal(float_frame.head(), float_frame[:5])
+    tm.assert_frame_equal(float_frame.tail(), float_frame[-5:])
+
+    tm.assert_frame_equal(float_frame.head(0), float_frame[0:0])
+    tm.assert_frame_equal(float_frame.tail(0), float_frame[0:0])
+
+    tm.assert_frame_equal(float_frame.head(-1), float_frame[:-1])
+    tm.assert_frame_equal(float_frame.tail(-1), float_frame[1:])
+    tm.assert_frame_equal(float_frame.head(1), float_frame[:1])
+    tm.assert_frame_equal(float_frame.tail(1), float_frame[-1:])
+    # with a float index
+    df = float_frame.copy()
+    df.index = np.arange(len(float_frame)) + 0.1
+    tm.assert_frame_equal(df.head(), df.iloc[:5])
+    tm.assert_frame_equal(df.tail(), df.iloc[-5:])
+    tm.assert_frame_equal(df.head(0), df[0:0])
+    tm.assert_frame_equal(df.tail(0), df[0:0])
+    tm.assert_frame_equal(df.head(-1), df.iloc[:-1])
+    tm.assert_frame_equal(df.tail(-1), df.iloc[1:])
+    # test empty dataframe
+    empty_df = DataFrame()
+    tm.assert_frame_equal(empty_df.tail(), empty_df)
+    tm.assert_frame_equal(empty_df.head(), empty_df)
diff --git a/pandas/tests/frame/methods/test_isin.py b/pandas/tests/frame/methods/test_isin.py
new file mode 100644
index 0000000000000..0eb94afc99d94
--- /dev/null
+++ b/pandas/tests/frame/methods/test_isin.py
@@ -0,0 +1,186 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, MultiIndex, Series
+import pandas._testing as tm
+
+
+class TestDataFrameIsIn:
+    def test_isin(self):
+        # GH#4211
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        other = ["a", "b", "c"]
+
+        result = df.isin(other)
+        expected = DataFrame([df.loc[s].isin(other) for s in df.index])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_isin_empty(self, empty):
+        # GH#16991
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        expected = DataFrame(False, df.index, df.columns)
+
+        result = df.isin(empty)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_dict(self):
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        d = {"A": ["a"]}
+
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+        # non unique columns
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        df.columns = ["A", "A"]
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_with_string_scalar(self):
+        # GH#4763
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        with pytest.raises(TypeError):
+            df.isin("a")
+
+        with pytest.raises(TypeError):
+            df.isin("aaa")
+
+    def test_isin_df(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        df2 = DataFrame({"A": [0, 2, 12, 4], "B": [2, np.nan, 4, 5]})
+        expected = DataFrame(False, df1.index, df1.columns)
+        result = df1.isin(df2)
+        expected["A"].loc[[1, 3]] = True
+        expected["B"].loc[[0, 2]] = True
+        tm.assert_frame_equal(result, expected)
+
+        # partial overlapping columns
+        df2.columns = ["A", "C"]
+        result = df1.isin(df2)
+        expected["B"] = False
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_tuples(self):
+        # GH#16394
+        df = pd.DataFrame({"A": [1, 2, 3], "B": ["a", "b", "f"]})
+        df["C"] = list(zip(df["A"], df["B"]))
+        result = df["C"].isin([(1, "a")])
+        tm.assert_series_equal(result, Series([True, False, False], name="C"))
+
+    def test_isin_df_dupe_values(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        # just cols duped
+        df2 = DataFrame([[0, 2], [12, 4], [2, np.nan], [4, 5]], columns=["B", "B"])
+        with pytest.raises(ValueError):
+            df1.isin(df2)
+
+        # just index duped
+        df2 = DataFrame(
+            [[0, 2], [12, 4], [2, np.nan], [4, 5]],
+            columns=["A", "B"],
+            index=[0, 0, 1, 1],
+        )
+        with pytest.raises(ValueError):
+            df1.isin(df2)
+
+        # cols and index:
+        df2.columns = ["B", "B"]
+        with pytest.raises(ValueError):
+            df1.isin(df2)
+
+    def test_isin_dupe_self(self):
+        other = DataFrame({"A": [1, 0, 1, 0], "B": [1, 1, 0, 0]})
+        df = DataFrame([[1, 1], [1, 0], [0, 0]], columns=["A", "A"])
+        result = df.isin(other)
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected.loc[0] = True
+        expected.iloc[1, 1] = True
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_against_series(self):
+        df = pd.DataFrame(
+            {"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]}, index=["a", "b", "c", "d"]
+        )
+        s = pd.Series([1, 3, 11, 4], index=["a", "b", "c", "d"])
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected["A"].loc["a"] = True
+        expected.loc["d"] = True
+        result = df.isin(s)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_multiIndex(self):
+        idx = MultiIndex.from_tuples(
+            [
+                (0, "a", "foo"),
+                (0, "a", "bar"),
+                (0, "b", "bar"),
+                (0, "b", "baz"),
+                (2, "a", "foo"),
+                (2, "a", "bar"),
+                (2, "c", "bar"),
+                (2, "c", "baz"),
+                (1, "b", "foo"),
+                (1, "b", "bar"),
+                (1, "c", "bar"),
+                (1, "c", "baz"),
+            ]
+        )
+        df1 = DataFrame({"A": np.ones(12), "B": np.zeros(12)}, index=idx)
+        df2 = DataFrame(
+            {
+                "A": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+                "B": [1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1],
+            }
+        )
+        # against regular index
+        expected = DataFrame(False, index=df1.index, columns=df1.columns)
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+        df2.index = idx
+        expected = df2.values.astype(np.bool)
+        expected[:, 1] = ~expected[:, 1]
+        expected = DataFrame(expected, columns=["A", "B"], index=idx)
+
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_empty_datetimelike(self):
+        # GH#15473
+        df1_ts = DataFrame({"date": pd.to_datetime(["2014-01-01", "2014-01-02"])})
+        df1_td = DataFrame({"date": [pd.Timedelta(1, "s"), pd.Timedelta(2, "s")]})
+        df2 = DataFrame({"date": []})
+        df3 = DataFrame()
+
+        expected = DataFrame({"date": [False, False]})
+
+        result = df1_ts.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_ts.isin(df3)
+        tm.assert_frame_equal(result, expected)
+
+        result = df1_td.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_td.isin(df3)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_nlargest.py b/pandas/tests/frame/methods/test_nlargest.py
new file mode 100644
index 0000000000000..4ce474230b686
--- /dev/null
+++ b/pandas/tests/frame/methods/test_nlargest.py
@@ -0,0 +1,211 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from string import ascii_lowercase
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.fixture
+def df_duplicates():
+    return pd.DataFrame(
+        {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
+        index=[0, 0, 1, 1, 1],
+    )
+
+
+@pytest.fixture
+def df_strings():
+    return pd.DataFrame(
+        {
+            "a": np.random.permutation(10),
+            "b": list(ascii_lowercase[:10]),
+            "c": np.random.permutation(10).astype("float64"),
+        }
+    )
+
+
+@pytest.fixture
+def df_main_dtypes():
+    return pd.DataFrame(
+        {
+            "group": [1, 1, 2],
+            "int": [1, 2, 3],
+            "float": [4.0, 5.0, 6.0],
+            "string": list("abc"),
+            "category_string": pd.Series(list("abc")).astype("category"),
+            "category_int": [7, 8, 9],
+            "datetime": pd.date_range("20130101", periods=3),
+            "datetimetz": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+            "timedelta": pd.timedelta_range("1 s", periods=3, freq="s"),
+        },
+        columns=[
+            "group",
+            "int",
+            "float",
+            "string",
+            "category_string",
+            "category_int",
+            "datetime",
+            "datetimetz",
+            "timedelta",
+        ],
+    )
+
+
+class TestNLargestNSmallest:
+
+    # ----------------------------------------------------------------------
+    # Top / bottom
+    @pytest.mark.parametrize(
+        "order",
+        [
+            ["a"],
+            ["c"],
+            ["a", "b"],
+            ["a", "c"],
+            ["b", "a"],
+            ["b", "c"],
+            ["a", "b", "c"],
+            ["c", "a", "b"],
+            ["c", "b", "a"],
+            ["b", "c", "a"],
+            ["b", "a", "c"],
+            # dups!
+            ["b", "c", "c"],
+        ],
+    )
+    @pytest.mark.parametrize("n", range(1, 11))
+    def test_nlargest_n(self, df_strings, nselect_method, n, order):
+        # GH#10393
+        df = df_strings
+        if "b" in order:
+
+            error_msg = (
+                f"Column 'b' has dtype object, "
+                f"cannot use method '{nselect_method}' with this dtype"
+            )
+            with pytest.raises(TypeError, match=error_msg):
+                getattr(df, nselect_method)(n, order)
+        else:
+            ascending = nselect_method == "nsmallest"
+            result = getattr(df, nselect_method)(n, order)
+            expected = df.sort_values(order, ascending=ascending).head(n)
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "columns", [["group", "category_string"], ["group", "string"]]
+    )
+    def test_nlargest_error(self, df_main_dtypes, nselect_method, columns):
+        df = df_main_dtypes
+        col = columns[1]
+        error_msg = (
+            f"Column '{col}' has dtype {df[col].dtype}, "
+            f"cannot use method '{nselect_method}' with this dtype"
+        )
+        # escape some characters that may be in the repr
+        error_msg = (
+            error_msg.replace("(", "\\(")
+            .replace(")", "\\)")
+            .replace("[", "\\[")
+            .replace("]", "\\]")
+        )
+        with pytest.raises(TypeError, match=error_msg):
+            getattr(df, nselect_method)(2, columns)
+
+    def test_nlargest_all_dtypes(self, df_main_dtypes):
+        df = df_main_dtypes
+        df.nsmallest(2, list(set(df) - {"category_string", "string"}))
+        df.nlargest(2, list(set(df) - {"category_string", "string"}))
+
+    def test_nlargest_duplicates_on_starter_columns(self):
+        # regression test for GH#22752
+
+        df = pd.DataFrame({"a": [2, 2, 2, 1, 1, 1], "b": [1, 2, 3, 3, 2, 1]})
+
+        result = df.nlargest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [2, 2, 2, 1], "b": [3, 2, 1, 3]}, index=[2, 1, 0, 3]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [1, 1, 1, 2], "b": [1, 2, 3, 1]}, index=[5, 4, 3, 0]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_n_identical_values(self):
+        # GH#15297
+        df = pd.DataFrame({"a": [1] * 5, "b": [1, 2, 3, 4, 5]})
+
+        result = df.nlargest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]}, index=[0, 1, 2])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "order",
+        [["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
+    )
+    @pytest.mark.parametrize("n", range(1, 6))
+    def test_nlargest_n_duplicate_index(self, df_duplicates, n, order):
+        # GH#13412
+
+        df = df_duplicates
+        result = df.nsmallest(n, order)
+        expected = df.sort_values(order).head(n)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nlargest(n, order)
+        expected = df.sort_values(order, ascending=False).head(n)
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # GH#16818
+        df = pd.DataFrame(
+            {"a": [5, 4, 4, 2, 3, 3, 3, 3], "b": [10, 9, 8, 7, 5, 50, 10, 20]}
+        )
+        result = df.nlargest(4, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {0: 5, 1: 4, 2: 4, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {0: 10, 1: 9, 2: 8, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(2, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {3: 2, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {3: 7, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_multiindex_column_lookup(self):
+        # Check whether tuples are correctly treated as multi-level lookups.
+        # GH#23033
+        df = pd.DataFrame(
+            columns=pd.MultiIndex.from_product([["x"], ["a", "b"]]),
+            data=[[0.33, 0.13], [0.86, 0.25], [0.25, 0.70], [0.85, 0.91]],
+        )
+
+        # nsmallest
+        result = df.nsmallest(3, ("x", "a"))
+        expected = df.iloc[[2, 0, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        # nlargest
+        result = df.nlargest(3, ("x", "b"))
+        expected = df.iloc[[3, 2, 1]]
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_pct_change.py b/pandas/tests/frame/methods/test_pct_change.py
new file mode 100644
index 0000000000000..8f3f37fb9fff7
--- /dev/null
+++ b/pandas/tests/frame/methods/test_pct_change.py
@@ -0,0 +1,96 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class TestDataFramePctChange:
+    def test_pct_change_numeric(self):
+        # GH#11150
+        pnl = DataFrame(
+            [np.arange(0, 40, 10), np.arange(0, 40, 10), np.arange(0, 40, 10)]
+        ).astype(np.float64)
+        pnl.iat[1, 0] = np.nan
+        pnl.iat[1, 1] = np.nan
+        pnl.iat[2, 3] = 60
+
+        for axis in range(2):
+            expected = pnl.ffill(axis=axis) / pnl.ffill(axis=axis).shift(axis=axis) - 1
+            result = pnl.pct_change(axis=axis, fill_method="pad")
+
+            tm.assert_frame_equal(result, expected)
+
+    def test_pct_change(self, datetime_frame):
+        rs = datetime_frame.pct_change(fill_method=None)
+        tm.assert_frame_equal(rs, datetime_frame / datetime_frame.shift(1) - 1)
+
+        rs = datetime_frame.pct_change(2)
+        filled = datetime_frame.fillna(method="pad")
+        tm.assert_frame_equal(rs, filled / filled.shift(2) - 1)
+
+        rs = datetime_frame.pct_change(fill_method="bfill", limit=1)
+        filled = datetime_frame.fillna(method="bfill", limit=1)
+        tm.assert_frame_equal(rs, filled / filled.shift(1) - 1)
+
+        rs = datetime_frame.pct_change(freq="5D")
+        filled = datetime_frame.fillna(method="pad")
+        tm.assert_frame_equal(
+            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
+        )
+
+    def test_pct_change_shift_over_nas(self):
+        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
+
+        df = DataFrame({"a": s, "b": s})
+
+        chg = df.pct_change()
+        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
+        edf = DataFrame({"a": expected, "b": expected})
+        tm.assert_frame_equal(chg, edf)
+
+    @pytest.mark.parametrize(
+        "freq, periods, fill_method, limit",
+        [
+            ("5B", 5, None, None),
+            ("3B", 3, None, None),
+            ("3B", 3, "bfill", None),
+            ("7B", 7, "pad", 1),
+            ("7B", 7, "bfill", 3),
+            ("14B", 14, None, None),
+        ],
+    )
+    def test_pct_change_periods_freq(
+        self, datetime_frame, freq, periods, fill_method, limit
+    ):
+        # GH#7292
+        rs_freq = datetime_frame.pct_change(
+            freq=freq, fill_method=fill_method, limit=limit
+        )
+        rs_periods = datetime_frame.pct_change(
+            periods, fill_method=fill_method, limit=limit
+        )
+        tm.assert_frame_equal(rs_freq, rs_periods)
+
+        empty_ts = DataFrame(index=datetime_frame.index, columns=datetime_frame.columns)
+        rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
+        rs_periods = empty_ts.pct_change(periods, fill_method=fill_method, limit=limit)
+        tm.assert_frame_equal(rs_freq, rs_periods)
+
+
+@pytest.mark.parametrize("fill_method", ["pad", "ffill", None])
+def test_pct_change_with_duplicated_indices(fill_method):
+    # GH30463
+    data = DataFrame(
+        {0: [np.nan, 1, 2, 3, 9, 18], 1: [0, 1, np.nan, 3, 9, 18]}, index=["a", "b"] * 3
+    )
+    result = data.pct_change(fill_method=fill_method)
+    if fill_method is None:
+        second_column = [np.nan, np.inf, np.nan, np.nan, 2.0, 1.0]
+    else:
+        second_column = [np.nan, np.inf, 0.0, 2.0, 2.0, 1.0]
+    expected = DataFrame(
+        {0: [np.nan, np.nan, 1.0, 0.5, 2.0, 1.0], 1: second_column},
+        index=["a", "b"] * 3,
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py
similarity index 91%
rename from pandas/tests/frame/test_quantile.py
rename to pandas/tests/frame/methods/test_quantile.py
index e5e881dece34a..64461c08d34f4 100644
--- a/pandas/tests/frame/test_quantile.py
+++ b/pandas/tests/frame/methods/test_quantile.py
@@ -3,11 +3,20 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 class TestDataFrameQuantile:
+    def test_quantile_sparse(self):
+        # GH#17198
+        s = pd.Series(pd.arrays.SparseArray([1, 2]))
+        s1 = pd.Series(pd.arrays.SparseArray([3, 4]))
+        df = pd.DataFrame({0: s, 1: s1})
+        result = df.quantile()
+
+        expected = pd.Series([1.5, 3.5], name=0.5)
+        tm.assert_series_equal(result, expected)
+
     def test_quantile(self, datetime_frame):
         from numpy import percentile
 
@@ -28,19 +37,19 @@ def test_quantile(self, datetime_frame):
         df = DataFrame({"col1": ["A", "A", "B", "B"], "col2": [1, 2, 3, 4]})
         rs = df.quantile(0.5)
         xp = df.median().rename(0.5)
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         # axis
         df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
         result = df.quantile(0.5, axis=1)
         expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.quantile([0.5, 0.75], axis=1)
         expected = DataFrame(
             {1: [1.5, 1.75], 2: [2.5, 2.75], 3: [3.5, 3.75]}, index=[0.5, 0.75]
         )
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # We may want to break API in the future to change this
         # so that we exclude non-numeric along the same axis
@@ -48,7 +57,7 @@ def test_quantile(self, datetime_frame):
         df = DataFrame([[1, 2, 3], ["a", "b", 4]])
         result = df.quantile(0.5, axis=1)
         expected = Series([3.0, 4.0], index=[0, 1], name=0.5)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_quantile_axis_mixed(self):
 
@@ -63,7 +72,7 @@ def test_quantile_axis_mixed(self):
         )
         result = df.quantile(0.5, axis=1)
         expected = Series([1.5, 2.5, 3.5], name=0.5)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # must raise
         with pytest.raises(TypeError):
@@ -77,25 +86,25 @@ def test_quantile_axis_parameter(self):
         result = df.quantile(0.5, axis=0)
 
         expected = Series([2.0, 3.0], index=["A", "B"], name=0.5)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = df.quantile(0.5, axis="index")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.quantile(0.5, axis=1)
 
         expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.quantile(0.5, axis="columns")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         msg = "No axis named -1 for object type <class 'pandas.core.frame.DataFrame'>"
         with pytest.raises(ValueError, match=msg):
             df.quantile(0.1, axis=-1)
         msg = (
-            "No axis named column for object type"
-            " <class 'pandas.core.frame.DataFrame'>"
+            "No axis named column for object type "
+            "<class 'pandas.core.frame.DataFrame'>"
         )
         with pytest.raises(ValueError, match=msg):
             df.quantile(0.1, axis="column")
@@ -128,14 +137,14 @@ def test_quantile_interpolation(self):
             interpolation="nearest",
         )
         expected = Series(exp, index=[1, 2, 3], name=0.5, dtype="float64")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # axis
         result = df.quantile([0.5, 0.75], axis=1, interpolation="lower")
         expected = DataFrame(
             {1: [1.0, 1.0], 2: [2.0, 2.0], 3: [3.0, 3.0]}, index=[0.5, 0.75]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # test degenerate case
         df = DataFrame({"x": [], "y": []})
@@ -152,7 +161,7 @@ def test_quantile_interpolation(self):
             index=[0.25, 0.5],
             columns=["a", "b", "c"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_quantile_interpolation_datetime(self, datetime_frame):
         # see gh-10174
@@ -183,7 +192,7 @@ def test_quantile_multi(self):
             index=[0.25, 0.5],
             columns=["a", "b", "c"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # axis = 1
         result = df.quantile([0.25, 0.5], axis=1)
@@ -196,7 +205,7 @@ def test_quantile_multi(self):
         expected = DataFrame(
             {"x": [np.nan, np.nan], "y": [np.nan, np.nan]}, index=[0.1, 0.9]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_quantile_datetime(self):
         df = DataFrame({"a": pd.to_datetime(["2010", "2011"]), "b": [0, 5]})
@@ -210,14 +219,14 @@ def test_quantile_datetime(self):
         expected = Series(
             [Timestamp("2010-07-02 12:00:00"), 2.5], index=["a", "b"], name=0.5
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # datetime w/ multi
         result = df.quantile([0.5], numeric_only=False)
         expected = DataFrame(
             [[Timestamp("2010-07-02 12:00:00"), 2.5]], index=[0.5], columns=["a", "b"]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # axis = 1
         df["c"] = pd.to_datetime(["2011", "2012"])
@@ -227,7 +236,7 @@ def test_quantile_datetime(self):
             index=[0, 1],
             name=0.5,
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df[["a", "c"]].quantile([0.5], axis=1, numeric_only=False)
         expected = DataFrame(
@@ -235,7 +244,7 @@ def test_quantile_datetime(self):
             index=[0.5],
             columns=[0, 1],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # empty when numeric_only=True
         # FIXME (gives empty frame in 0.18.1, broken in 0.19.0)
@@ -473,7 +482,7 @@ def test_quantile_empty_no_columns(self):
         df = pd.DataFrame(pd.date_range("1/1/18", periods=5))
         df.columns.name = "captain tightpants"
         result = df.quantile(0.5)
-        expected = pd.Series([], index=[], name=0.5)
+        expected = pd.Series([], index=[], name=0.5, dtype=np.float64)
         expected.index.name = "captain tightpants"
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/frame/test_rank.py b/pandas/tests/frame/methods/test_rank.py
similarity index 92%
rename from pandas/tests/frame/test_rank.py
rename to pandas/tests/frame/methods/test_rank.py
index fd9c53c7d9f5b..bab2db3192b4a 100644
--- a/pandas/tests/frame/test_rank.py
+++ b/pandas/tests/frame/methods/test_rank.py
@@ -3,9 +3,10 @@
 import numpy as np
 import pytest
 
+import pandas.util._test_decorators as td
+
 from pandas import DataFrame, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 class TestRank:
@@ -27,8 +28,10 @@ def method(self, request):
         """
         return request.param
 
+    @td.skip_if_no_scipy
     def test_rank(self, float_frame):
-        rankdata = pytest.importorskip("scipy.stats.rankdata")
+        import scipy.stats  # noqa:F401
+        from scipy.stats import rankdata
 
         float_frame["A"][::2] = np.nan
         float_frame["B"][::3] = np.nan
@@ -110,6 +113,15 @@ def test_rank2(self):
         exp = DataFrame({"a": [3.5, 1.0, 3.5, 5.0, 6.0, 7.0, 2.0]})
         tm.assert_frame_equal(df.rank(), exp)
 
+    def test_rank_does_not_mutate(self):
+        # GH#18521
+        # Check rank does not mutate DataFrame
+        df = DataFrame(np.random.randn(10, 3), dtype="float64")
+        expected = df.copy()
+        df.rank()
+        result = df
+        tm.assert_frame_equal(result, expected)
+
     def test_rank_mixed_frame(self, float_string_frame):
         float_string_frame["datetime"] = datetime.now()
         float_string_frame["timedelta"] = timedelta(days=1, seconds=1)
@@ -118,8 +130,10 @@ def test_rank_mixed_frame(self, float_string_frame):
         expected = float_string_frame.rank(1, numeric_only=True)
         tm.assert_frame_equal(result, expected)
 
+    @td.skip_if_no_scipy
     def test_rank_na_option(self, float_frame):
-        rankdata = pytest.importorskip("scipy.stats.rankdata")
+        import scipy.stats  # noqa:F401
+        from scipy.stats import rankdata
 
         float_frame["A"][::2] = np.nan
         float_frame["B"][::3] = np.nan
@@ -200,9 +214,10 @@ def test_rank_axis(self):
         tm.assert_frame_equal(df.rank(axis=0), df.rank(axis="index"))
         tm.assert_frame_equal(df.rank(axis=1), df.rank(axis="columns"))
 
+    @td.skip_if_no_scipy
     def test_rank_methods_frame(self):
-        pytest.importorskip("scipy.stats.special")
-        rankdata = pytest.importorskip("scipy.stats.rankdata")
+        import scipy.stats  # noqa:F401
+        from scipy.stats import rankdata
 
         xs = np.random.randint(0, 21, (100, 26))
         xs = (xs - 10.0) / 10.0
@@ -231,7 +246,7 @@ def test_rank_descending(self, method, dtype):
 
         res = df.rank(ascending=False)
         expected = (df.max() - df).rank()
-        assert_frame_equal(res, expected)
+        tm.assert_frame_equal(res, expected)
 
         if method == "first" and dtype == "O":
             return
@@ -240,10 +255,10 @@ def test_rank_descending(self, method, dtype):
 
         if dtype != "O":
             res2 = df.rank(method=method, ascending=False, numeric_only=True)
-            assert_frame_equal(res2, expected)
+            tm.assert_frame_equal(res2, expected)
 
         res3 = df.rank(method=method, ascending=False, numeric_only=False)
-        assert_frame_equal(res3, expected)
+        tm.assert_frame_equal(res3, expected)
 
     @pytest.mark.parametrize("axis", [0, 1])
     @pytest.mark.parametrize("dtype", [None, object])
@@ -258,7 +273,7 @@ def _check2d(df, expected, method="average", axis=0):
                 exp_df = exp_df.T
 
             result = df.rank(method=method, axis=axis)
-            assert_frame_equal(result, exp_df)
+            tm.assert_frame_equal(result, exp_df)
 
         disabled = {(object, "first")}
         if (dtype, method) in disabled:
diff --git a/pandas/tests/frame/test_replace.py b/pandas/tests/frame/methods/test_replace.py
similarity index 77%
rename from pandas/tests/frame/test_replace.py
rename to pandas/tests/frame/methods/test_replace.py
index b341ed6a52ca5..92b74c4409d7d 100644
--- a/pandas/tests/frame/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1,48 +1,47 @@
 from datetime import datetime
 from io import StringIO
 import re
-from typing import Dict
+from typing import Dict, List, Union
 
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, date_range
-from pandas.tests.frame.common import TestData
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 @pytest.fixture
-def mix_ab() -> Dict[str, list]:
+def mix_ab() -> Dict[str, List[Union[int, str]]]:
     return {"a": list(range(4)), "b": list("ab..")}
 
 
 @pytest.fixture
-def mix_abc() -> Dict[str, list]:
+def mix_abc() -> Dict[str, List[Union[float, str]]]:
     return {"a": list(range(4)), "b": list("ab.."), "c": ["a", "b", np.nan, "d"]}
 
 
-class TestDataFrameReplace(TestData):
-    def test_replace_inplace(self):
-        self.tsframe["A"][:5] = np.nan
-        self.tsframe["A"][-5:] = np.nan
+class TestDataFrameReplace:
+    def test_replace_inplace(self, datetime_frame, float_string_frame):
+        datetime_frame["A"][:5] = np.nan
+        datetime_frame["A"][-5:] = np.nan
 
-        tsframe = self.tsframe.copy()
+        tsframe = datetime_frame.copy()
         tsframe.replace(np.nan, 0, inplace=True)
-        assert_frame_equal(tsframe, self.tsframe.fillna(0))
+        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
 
         # mixed type
-        mf = self.mixed_frame
+        mf = float_string_frame
         mf.iloc[5:20, mf.columns.get_loc("foo")] = np.nan
         mf.iloc[-10:, mf.columns.get_loc("A")] = np.nan
 
-        result = self.mixed_frame.replace(np.nan, 0)
-        expected = self.mixed_frame.fillna(value=0)
-        assert_frame_equal(result, expected)
+        result = float_string_frame.replace(np.nan, 0)
+        expected = float_string_frame.fillna(value=0)
+        tm.assert_frame_equal(result, expected)
 
-        tsframe = self.tsframe.copy()
+        tsframe = datetime_frame.copy()
         tsframe.replace([np.nan], [0], inplace=True)
-        assert_frame_equal(tsframe, self.tsframe.fillna(0))
+        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
 
     def test_regex_replace_scalar(self, mix_ab):
         obj = {"a": list("ab.."), "b": list("efgh")}
@@ -53,11 +52,11 @@ def test_regex_replace_scalar(self, mix_ab):
         # regex -> value
         # obj frame
         res = dfobj.replace(r"\s*\.\s*", np.nan, regex=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.replace(r"\s*\.\s*", np.nan, regex=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -65,22 +64,22 @@ def test_regex_replace_scalar(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.replace(r"\s*(\.)\s*", r"\1\1\1", regex=True)
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # everything with compiled regexs as well
         res = dfobj.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -88,26 +87,26 @@ def test_regex_replace_scalar(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.replace(re.compile(r"\s*(\.)\s*"), r"\1\1\1")
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         res = dfmix.replace(regex=re.compile(r"\s*(\.)\s*"), value=r"\1\1\1")
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         res = dfmix.replace(regex=r"\s*(\.)\s*", value=r"\1\1\1")
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_scalar_inplace(self, mix_ab):
         obj = {"a": list("ab.."), "b": list("efgh")}
@@ -119,12 +118,12 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         # obj frame
         res = dfobj.copy()
         res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
         res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -133,7 +132,7 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.copy()
@@ -141,17 +140,17 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # everything with compiled regexs as well
         res = dfobj.copy()
         res.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
         res.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -160,7 +159,7 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.copy()
@@ -168,16 +167,16 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         res = dfobj.copy()
         res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
         res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -186,7 +185,7 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.copy()
@@ -194,17 +193,17 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # everything with compiled regexs as well
         res = dfobj.copy()
         res.replace(regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True)
-        assert_frame_equal(dfobj, res.fillna("."))
+        tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
         res.replace(regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True)
-        assert_frame_equal(dfmix, res.fillna("."))
+        tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
@@ -213,7 +212,7 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # with mixed
         res = dfmix.copy()
@@ -221,7 +220,7 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_list_obj(self):
         obj = {"a": list("ab.."), "b": list("efgh"), "c": list("helo")}
@@ -239,7 +238,7 @@ def test_regex_replace_list_obj(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r"\s*(\.)\s*", r"(e|f|g)"]
@@ -252,7 +251,7 @@ def test_regex_replace_list_obj(self):
                 "c": ["h", "e_crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
         # or vN)]
@@ -266,7 +265,7 @@ def test_regex_replace_list_obj(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         to_replace_res = [r"\s*(\.)\s*", r"e"]
         values = [r"\1\1", r"crap"]
@@ -278,7 +277,7 @@ def test_regex_replace_list_obj(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_list_obj_inplace(self):
         # same as above with inplace=True
@@ -299,7 +298,7 @@ def test_regex_replace_list_obj_inplace(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r"\s*(\.)\s*", r"(e|f|g)"]
@@ -313,7 +312,7 @@ def test_regex_replace_list_obj_inplace(self):
                 "c": ["h", "e_crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
         # or vN)]
@@ -328,7 +327,7 @@ def test_regex_replace_list_obj_inplace(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         to_replace_res = [r"\s*(\.)\s*", r"e"]
         values = [r"\1\1", r"crap"]
@@ -341,7 +340,7 @@ def test_regex_replace_list_obj_inplace(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_list_mixed(self, mix_ab):
         # mixed frame to make sure this doesn't break things
@@ -361,14 +360,14 @@ def test_regex_replace_list_mixed(self, mix_ab):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r"\s*(\.)\s*", r"(a|b)"]
         values = [r"\1\1", r"\1_crap"]
         res = dfmix.replace(to_replace_res, values, regex=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["a_crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
         # or vN)]
@@ -376,13 +375,13 @@ def test_regex_replace_list_mixed(self, mix_ab):
         values = [r"\1\1", r"crap", r"\1_crap"]
         res = dfmix.replace(to_replace_res, values, regex=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
         values = [r"\1\1", r"crap", r"\1_crap"]
         res = dfmix.replace(regex=to_replace_res, value=values)
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_list_mixed_inplace(self, mix_ab):
         dfmix = DataFrame(mix_ab)
@@ -394,7 +393,7 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b", np.nan, np.nan]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r"\s*(\.)\s*", r"(a|b)"]
@@ -402,7 +401,7 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["a_crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
         # or vN)]
@@ -411,14 +410,14 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
         values = [r"\1\1", r"crap", r"\1_crap"]
         res = dfmix.copy()
         res.replace(regex=to_replace_res, value=values, inplace=True)
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_regex_replace_dict_mixed(self, mix_abc):
         dfmix = DataFrame(mix_abc)
@@ -435,8 +434,8 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
 
         # list of dicts {re1: re11, re2: re12, ..., reN: re1N}, search the
         # whole frame
@@ -446,8 +445,8 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
 
         res = dfmix.replace(regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"})
         res2 = dfmix.copy()
@@ -455,8 +454,8 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
 
         # scalar -> dict
         # to_replace regex, {value: value}
@@ -466,8 +465,8 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         res = dfmix.replace("a", {"b": np.nan}, regex=True)
         res2 = dfmix.copy()
         res2.replace("a", {"b": np.nan}, regex=True, inplace=True)
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
 
         res = dfmix.replace("a", {"b": np.nan}, regex=True)
         res2 = dfmix.copy()
@@ -475,8 +474,8 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": [np.nan, "b", ".", "."], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
 
     def test_regex_replace_dict_nested(self, mix_abc):
         # nested dicts will not work until this is implemented for Series
@@ -490,23 +489,23 @@ def test_regex_replace_dict_nested(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
-        assert_frame_equal(res3, expec)
-        assert_frame_equal(res4, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res4, expec)
 
     def test_regex_replace_dict_nested_non_first_character(self):
         # GH 25259
         df = pd.DataFrame({"first": ["abc", "bca", "cab"]})
         expected = pd.DataFrame({"first": [".bc", "bc.", "c.b"]})
         result = df.replace({"a": "."}, regex=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_regex_replace_dict_nested_gh4115(self):
         df = pd.DataFrame({"Type": ["Q", "T", "Q", "Q", "T"], "tmp": 2})
         expected = DataFrame({"Type": [0, 1, 0, 0, 1], "tmp": 2})
         result = df.replace({"Type": {"Q": 0, "T": 1}})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_regex_replace_list_to_scalar(self, mix_abc):
         df = DataFrame(mix_abc)
@@ -522,9 +521,9 @@ def test_regex_replace_list_to_scalar(self, mix_abc):
         res3 = df.copy()
         res2.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True)
         res3.replace(regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True)
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
-        assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
 
     def test_regex_replace_str_to_numeric(self, mix_abc):
         # what happens when you try to replace a numeric value with a regex?
@@ -535,9 +534,9 @@ def test_regex_replace_str_to_numeric(self, mix_abc):
         res3 = df.copy()
         res3.replace(regex=r"\s*\.\s*", value=0, inplace=True)
         expec = DataFrame({"a": mix_abc["a"], "b": ["a", "b", 0, 0], "c": mix_abc["c"]})
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
-        assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
 
     def test_regex_replace_regex_list_to_numeric(self, mix_abc):
         df = DataFrame(mix_abc)
@@ -549,9 +548,9 @@ def test_regex_replace_regex_list_to_numeric(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", 0, 0, 0], "c": ["a", 0, np.nan, "d"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
-        assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
 
     def test_regex_replace_series_of_regexes(self, mix_abc):
         df = DataFrame(mix_abc)
@@ -565,15 +564,15 @@ def test_regex_replace_series_of_regexes(self, mix_abc):
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
-        assert_frame_equal(res, expec)
-        assert_frame_equal(res2, expec)
-        assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
 
     def test_regex_replace_numeric_to_object_conversion(self, mix_abc):
         df = DataFrame(mix_abc)
         expec = DataFrame({"a": ["a", 1, 2, 3], "b": mix_abc["b"], "c": mix_abc["c"]})
         res = df.replace(0, "a")
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
         assert res.a.dtype == np.object_
 
     @pytest.mark.parametrize("metachar", ["[]", "()", r"\d", r"\w", r"\s"])
@@ -581,23 +580,23 @@ def test_replace_regex_metachar(self, metachar):
         df = DataFrame({"a": [metachar, "else"]})
         result = df.replace({"a": {metachar: "paren"}})
         expected = DataFrame({"a": ["paren", "else"]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
-    def test_replace(self):
-        self.tsframe["A"][:5] = np.nan
-        self.tsframe["A"][-5:] = np.nan
+    def test_replace(self, datetime_frame):
+        datetime_frame["A"][:5] = np.nan
+        datetime_frame["A"][-5:] = np.nan
 
-        zero_filled = self.tsframe.replace(np.nan, -1e8)
-        assert_frame_equal(zero_filled, self.tsframe.fillna(-1e8))
-        assert_frame_equal(zero_filled.replace(-1e8, np.nan), self.tsframe)
+        zero_filled = datetime_frame.replace(np.nan, -1e8)
+        tm.assert_frame_equal(zero_filled, datetime_frame.fillna(-1e8))
+        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), datetime_frame)
 
-        self.tsframe["A"][:5] = np.nan
-        self.tsframe["A"][-5:] = np.nan
-        self.tsframe["B"][:5] = -1e8
+        datetime_frame["A"][:5] = np.nan
+        datetime_frame["A"][-5:] = np.nan
+        datetime_frame["B"][:5] = -1e8
 
         # empty
         df = DataFrame(index=["a", "b"])
-        assert_frame_equal(df, df.replace(5, 7))
+        tm.assert_frame_equal(df, df.replace(5, 7))
 
         # GH 11698
         # test for mixed data types.
@@ -608,7 +607,7 @@ def test_replace(self):
         expected_df = pd.DataFrame(
             [(np.nan, pd.to_datetime("20150101")), ("a", pd.to_datetime("20150102"))]
         )
-        assert_frame_equal(df1, expected_df)
+        tm.assert_frame_equal(df1, expected_df)
 
     def test_replace_list(self):
         obj = {"a": list("ab.."), "b": list("efgh"), "c": list("helo")}
@@ -626,7 +625,7 @@ def test_replace_list(self):
                 "c": ["h", "crap", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # list of [v1, v2, ..., vN] -> [v1, v2, .., vN]
         to_replace_res = [r".", r"f"]
@@ -639,7 +638,7 @@ def test_replace_list(self):
                 "c": ["h", "e", "l", "o"],
             }
         )
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_replace_with_empty_list(self):
         # GH 21977
@@ -647,7 +646,7 @@ def test_replace_with_empty_list(self):
         df = pd.DataFrame({"col": s})
         expected = df
         result = df.replace([], np.nan)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # GH 19266
         with pytest.raises(ValueError, match="cannot assign mismatch"):
@@ -660,20 +659,20 @@ def test_replace_series_dict(self):
         df = DataFrame({"zero": {"a": 0.0, "b": 1}, "one": {"a": 2.0, "b": 0}})
         result = df.replace(0, {"zero": 0.5, "one": 1.0})
         expected = DataFrame({"zero": {"a": 0.5, "b": 1}, "one": {"a": 2.0, "b": 1.0}})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.replace(0, df.mean())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # series to series/dict
         df = DataFrame({"zero": {"a": 0.0, "b": 1}, "one": {"a": 2.0, "b": 0}})
         s = Series({"zero": 0.0, "one": 2.0})
         result = df.replace(s, {"zero": 0.5, "one": 1.0})
         expected = DataFrame({"zero": {"a": 0.5, "b": 1}, "one": {"a": 1.0, "b": 0.0}})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.replace(s, df.mean())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_convert(self):
         # gh 3907
@@ -682,22 +681,22 @@ def test_replace_convert(self):
         rep = df.replace(m)
         expec = Series([np.int64] * 3)
         res = rep.dtypes
-        assert_series_equal(expec, res)
+        tm.assert_series_equal(expec, res)
 
-    def test_replace_mixed(self):
-        mf = self.mixed_frame
+    def test_replace_mixed(self, float_string_frame):
+        mf = float_string_frame
         mf.iloc[5:20, mf.columns.get_loc("foo")] = np.nan
         mf.iloc[-10:, mf.columns.get_loc("A")] = np.nan
 
-        result = self.mixed_frame.replace(np.nan, -18)
-        expected = self.mixed_frame.fillna(value=-18)
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result.replace(-18, np.nan), self.mixed_frame)
+        result = float_string_frame.replace(np.nan, -18)
+        expected = float_string_frame.fillna(value=-18)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result.replace(-18, np.nan), float_string_frame)
 
-        result = self.mixed_frame.replace(np.nan, -1e8)
-        expected = self.mixed_frame.fillna(value=-1e8)
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result.replace(-1e8, np.nan), self.mixed_frame)
+        result = float_string_frame.replace(np.nan, -1e8)
+        expected = float_string_frame.fillna(value=-1e8)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result.replace(-1e8, np.nan), float_string_frame)
 
         # int block upcasting
         df = DataFrame(
@@ -713,10 +712,10 @@ def test_replace_mixed(self):
             }
         )
         result = df.replace(0, 0.5)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df.replace(0, 0.5, inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # int block splitting
         df = DataFrame(
@@ -734,7 +733,7 @@ def test_replace_mixed(self):
             }
         )
         result = df.replace(0, 0.5)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # to object block upcasting
         df = DataFrame(
@@ -750,7 +749,7 @@ def test_replace_mixed(self):
             }
         )
         result = df.replace(2, "foo")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
             {
@@ -759,7 +758,7 @@ def test_replace_mixed(self):
             }
         )
         result = df.replace([1, 2], ["foo", "bar"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # test case from
         df = DataFrame(
@@ -770,59 +769,59 @@ def test_replace_mixed(self):
         m = df.mean()
         expected.iloc[0, 0] = m[0]
         expected.iloc[1, 1] = m[1]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_simple_nested_dict(self):
         df = DataFrame({"col": range(1, 5)})
         expected = DataFrame({"col": ["a", 2, 3, "b"]})
 
         result = df.replace({"col": {1: "a", 4: "b"}})
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
         # in this case, should be the same as the not nested version
         result = df.replace({1: "a", 4: "b"})
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
     def test_replace_simple_nested_dict_with_nonexistent_value(self):
         df = DataFrame({"col": range(1, 5)})
         expected = DataFrame({"col": ["a", 2, 3, "b"]})
 
         result = df.replace({-1: "-", 1: "a", 4: "b"})
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
         result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
-    def test_replace_value_is_none(self):
-        orig_value = self.tsframe.iloc[0, 0]
-        orig2 = self.tsframe.iloc[1, 0]
+    def test_replace_value_is_none(self, datetime_frame):
+        orig_value = datetime_frame.iloc[0, 0]
+        orig2 = datetime_frame.iloc[1, 0]
 
-        self.tsframe.iloc[0, 0] = np.nan
-        self.tsframe.iloc[1, 0] = 1
+        datetime_frame.iloc[0, 0] = np.nan
+        datetime_frame.iloc[1, 0] = 1
 
-        result = self.tsframe.replace(to_replace={np.nan: 0})
-        expected = self.tsframe.T.replace(to_replace={np.nan: 0}).T
-        assert_frame_equal(result, expected)
+        result = datetime_frame.replace(to_replace={np.nan: 0})
+        expected = datetime_frame.T.replace(to_replace={np.nan: 0}).T
+        tm.assert_frame_equal(result, expected)
 
-        result = self.tsframe.replace(to_replace={np.nan: 0, 1: -1e8})
-        tsframe = self.tsframe.copy()
+        result = datetime_frame.replace(to_replace={np.nan: 0, 1: -1e8})
+        tsframe = datetime_frame.copy()
         tsframe.iloc[0, 0] = 0
         tsframe.iloc[1, 0] = -1e8
         expected = tsframe
-        assert_frame_equal(expected, result)
-        self.tsframe.iloc[0, 0] = orig_value
-        self.tsframe.iloc[1, 0] = orig2
+        tm.assert_frame_equal(expected, result)
+        datetime_frame.iloc[0, 0] = orig_value
+        datetime_frame.iloc[1, 0] = orig2
 
-    def test_replace_for_new_dtypes(self):
+    def test_replace_for_new_dtypes(self, datetime_frame):
 
         # dtypes
-        tsframe = self.tsframe.copy().astype(np.float32)
+        tsframe = datetime_frame.copy().astype(np.float32)
         tsframe["A"][:5] = np.nan
         tsframe["A"][-5:] = np.nan
 
         zero_filled = tsframe.replace(np.nan, -1e8)
-        assert_frame_equal(zero_filled, tsframe.fillna(-1e8))
-        assert_frame_equal(zero_filled.replace(-1e8, np.nan), tsframe)
+        tm.assert_frame_equal(zero_filled, tsframe.fillna(-1e8))
+        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), tsframe)
 
         tsframe["A"][:5] = np.nan
         tsframe["A"][-5:] = np.nan
@@ -832,7 +831,7 @@ def test_replace_for_new_dtypes(self):
         b[b == -1e8] = np.nan
         tsframe["B"] = b
         result = tsframe.fillna(method="bfill")
-        assert_frame_equal(result, tsframe.fillna(method="bfill"))
+        tm.assert_frame_equal(result, tsframe.fillna(method="bfill"))
 
     @pytest.mark.parametrize(
         "frame, to_replace, value, expected",
@@ -909,7 +908,7 @@ def test_replace_for_new_dtypes(self):
     )
     def test_replace_dtypes(self, frame, to_replace, value, expected):
         result = getattr(frame, "replace")(to_replace, value)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_input_formats_listlike(self):
         # both dicts
@@ -920,13 +919,13 @@ def test_replace_input_formats_listlike(self):
         )
         filled = df.replace(to_rep, values)
         expected = {k: v.replace(to_rep[k], values[k]) for k, v in df.items()}
-        assert_frame_equal(filled, DataFrame(expected))
+        tm.assert_frame_equal(filled, DataFrame(expected))
 
         result = df.replace([0, 2, 5], [5, 2, 0])
         expected = DataFrame(
             {"A": [np.nan, 5, np.inf], "B": [5, 2, 0], "C": ["", "asdf", "fd"]}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # scalar to dict
         values = {"A": 0, "B": -1, "C": "missing"}
@@ -935,7 +934,7 @@ def test_replace_input_formats_listlike(self):
         )
         filled = df.replace(np.nan, values)
         expected = {k: v.replace(np.nan, values[k]) for k, v in df.items()}
-        assert_frame_equal(filled, DataFrame(expected))
+        tm.assert_frame_equal(filled, DataFrame(expected))
 
         # list to list
         to_rep = [np.nan, 0, ""]
@@ -944,7 +943,7 @@ def test_replace_input_formats_listlike(self):
         expected = df.copy()
         for i in range(len(to_rep)):
             expected.replace(to_rep[i], values[i], inplace=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         msg = r"Replacement lists must match in length\. Expecting 3 got 2"
         with pytest.raises(ValueError, match=msg):
@@ -959,7 +958,7 @@ def test_replace_input_formats_scalar(self):
         to_rep = {"A": np.nan, "B": 0, "C": ""}
         filled = df.replace(to_rep, 0)
         expected = {k: v.replace(to_rep[k], 0) for k, v in df.items()}
-        assert_frame_equal(filled, DataFrame(expected))
+        tm.assert_frame_equal(filled, DataFrame(expected))
 
         msg = "value argument must be scalar, dict, or Series"
         with pytest.raises(TypeError, match=msg):
@@ -971,7 +970,7 @@ def test_replace_input_formats_scalar(self):
         expected = df.copy()
         for i in range(len(to_rep)):
             expected.replace(to_rep[i], -1, inplace=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_limit(self):
         pass
@@ -995,7 +994,7 @@ def test_replace_dict_no_regex(self):
         }
         expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
         result = answer.replace(weights)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_replace_series_no_regex(self):
         answer = Series(
@@ -1018,7 +1017,7 @@ def test_replace_series_no_regex(self):
         )
         expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
         result = answer.replace(weights)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_replace_dict_tuple_list_ordering_remains_the_same(self):
         df = DataFrame(dict(A=[np.nan, 1]))
@@ -1027,9 +1026,9 @@ def test_replace_dict_tuple_list_ordering_remains_the_same(self):
         res3 = df.replace(to_replace=[1, np.nan], value=[-1e8, 0])
 
         expected = DataFrame({"A": [0, -1e8]})
-        assert_frame_equal(res1, res2)
-        assert_frame_equal(res2, res3)
-        assert_frame_equal(res3, expected)
+        tm.assert_frame_equal(res1, res2)
+        tm.assert_frame_equal(res2, res3)
+        tm.assert_frame_equal(res3, expected)
 
     def test_replace_doesnt_replace_without_regex(self):
         raw = """fol T_opp T_Dir T_Enh
@@ -1039,24 +1038,24 @@ def test_replace_doesnt_replace_without_regex(self):
         3    3     0    bt     0"""
         df = pd.read_csv(StringIO(raw), sep=r"\s+")
         res = df.replace({r"\D": 1})
-        assert_frame_equal(df, res)
+        tm.assert_frame_equal(df, res)
 
     def test_replace_bool_with_string(self):
         df = DataFrame({"a": [True, False], "b": list("ab")})
         result = df.replace(True, "a")
         expected = DataFrame({"a": ["a", False], "b": df.b})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_pure_bool_with_string_no_op(self):
         df = DataFrame(np.random.rand(2, 2) > 0.5)
         result = df.replace("asdf", "fdsa")
-        assert_frame_equal(df, result)
+        tm.assert_frame_equal(df, result)
 
     def test_replace_bool_with_bool(self):
         df = DataFrame(np.random.rand(2, 2) > 0.5)
         result = df.replace(False, True)
         expected = DataFrame(np.ones((2, 2), dtype=bool))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_with_dict_with_bool_keys(self):
         df = DataFrame({0: [True, False], 1: [False, True]})
@@ -1067,7 +1066,7 @@ def test_replace_truthy(self):
         df = DataFrame({"a": [True, True]})
         r = df.replace([np.inf, -np.inf], np.nan)
         e = df
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
     def test_nested_dict_overlapping_keys_replace_int(self):
         # GH 27660 keep behaviour consistent for simple dictionary and
@@ -1076,7 +1075,7 @@ def test_nested_dict_overlapping_keys_replace_int(self):
 
         result = df.replace({"a": dict(zip(range(1, 5), range(2, 6)))})
         expected = df.replace(dict(zip(range(1, 5), range(2, 6))))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_nested_dict_overlapping_keys_replace_str(self):
         # GH 27660
@@ -1086,18 +1085,18 @@ def test_nested_dict_overlapping_keys_replace_str(self):
         df = DataFrame({"a": astr})
         result = df.replace(dict(zip(astr, bstr)))
         expected = df.replace({"a": dict(zip(astr, bstr))})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_swapping_bug(self):
         df = pd.DataFrame({"a": [True, False, True]})
         res = df.replace({"a": {True: "Y", False: "N"}})
         expect = pd.DataFrame({"a": ["Y", "N", "Y"]})
-        assert_frame_equal(res, expect)
+        tm.assert_frame_equal(res, expect)
 
         df = pd.DataFrame({"a": [0, 1, 0]})
         res = df.replace({"a": {0: "Y", 1: "N"}})
         expect = pd.DataFrame({"a": ["Y", "N", "Y"]})
-        assert_frame_equal(res, expect)
+        tm.assert_frame_equal(res, expect)
 
     def test_replace_period(self):
         d = {
@@ -1133,7 +1132,7 @@ def test_replace_period(self):
             {"fname": [d["fname"][k] for k in df.fname.values]}, dtype=object
         )
         result = df.replace(d)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_datetime(self):
         d = {
@@ -1163,7 +1162,7 @@ def test_replace_datetime(self):
         assert set(df.fname.values) == set(d["fname"].keys())
         expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]})
         result = df.replace(d)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_datetimetz(self):
 
@@ -1182,10 +1181,10 @@ def test_replace_datetimetz(self):
                 "B": Series([0, 1, 2], dtype="float64"),
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.fillna(1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.replace(0, np.nan)
         expected = DataFrame(
@@ -1194,7 +1193,7 @@ def test_replace_datetimetz(self):
                 "B": [np.nan, np.nan, 2],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.replace(
             Timestamp("20130102", tz="US/Eastern"),
@@ -1210,12 +1209,12 @@ def test_replace_datetimetz(self):
                 "B": [0, np.nan, 2],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.copy()
         result.iloc[1, 0] = np.nan
         result = result.replace({"A": pd.NaT}, Timestamp("20130104", tz="US/Eastern"))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # coerce to object
         result = df.copy()
@@ -1231,7 +1230,7 @@ def test_replace_datetimetz(self):
                 "B": [0, np.nan, 2],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.copy()
         result.iloc[1, 0] = np.nan
@@ -1246,16 +1245,16 @@ def test_replace_datetimetz(self):
                 "B": [0, np.nan, 2],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_replace_with_empty_dictlike(self, mix_abc):
         # GH 15289
         df = DataFrame(mix_abc)
-        assert_frame_equal(df, df.replace({}))
-        assert_frame_equal(df, df.replace(Series([])))
+        tm.assert_frame_equal(df, df.replace({}))
+        tm.assert_frame_equal(df, df.replace(Series([], dtype=object)))
 
-        assert_frame_equal(df, df.replace({"b": {}}))
-        assert_frame_equal(df, df.replace(Series({"b": {}})))
+        tm.assert_frame_equal(df, df.replace({"b": {}}))
+        tm.assert_frame_equal(df, df.replace(Series({"b": {}})))
 
     @pytest.mark.parametrize(
         "to_replace, method, expected",
@@ -1295,4 +1294,72 @@ def test_replace_method(self, to_replace, method, expected):
 
         result = df.replace(to_replace=to_replace, value=None, method=method)
         expected = DataFrame(expected)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "replace_dict, final_data",
+        [({"a": 1, "b": 1}, [[3, 3], [2, 2]]), ({"a": 1, "b": 2}, [[3, 1], [2, 3]])],
+    )
+    def test_categorical_replace_with_dict(self, replace_dict, final_data):
+        # GH 26988
+        df = DataFrame([[1, 1], [2, 2]], columns=["a", "b"], dtype="category")
+        expected = DataFrame(final_data, columns=["a", "b"], dtype="category")
+        expected["a"] = expected["a"].cat.set_categories([1, 2, 3])
+        expected["b"] = expected["b"].cat.set_categories([1, 2, 3])
+        result = df.replace(replace_dict, 3)
+        tm.assert_frame_equal(result, expected)
+        with pytest.raises(AssertionError):
+            # ensure non-inplace call does not affect original
+            tm.assert_frame_equal(df, expected)
+        df.replace(replace_dict, 3, inplace=True)
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "df, to_replace, exp",
+        [
+            (
+                {"col1": [1, 2, 3], "col2": [4, 5, 6]},
+                {4: 5, 5: 6, 6: 7},
+                {"col1": [1, 2, 3], "col2": [5, 6, 7]},
+            ),
+            (
+                {"col1": [1, 2, 3], "col2": ["4", "5", "6"]},
+                {"4": "5", "5": "6", "6": "7"},
+                {"col1": [1, 2, 3], "col2": ["5", "6", "7"]},
+            ),
+        ],
+    )
+    def test_replace_commutative(self, df, to_replace, exp):
+        # GH 16051
+        # DataFrame.replace() overwrites when values are non-numeric
+        # also added to data frame whilst issue was for series
+
+        df = pd.DataFrame(df)
+
+        expected = pd.DataFrame(exp)
+        result = df.replace(to_replace)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "replacer",
+        [
+            pd.Timestamp("20170827"),
+            np.int8(1),
+            np.int16(1),
+            np.float32(1),
+            np.float64(1),
+        ],
+    )
+    def test_replace_replacer_dtype(self, replacer):
+        # GH26632
+        df = pd.DataFrame(["a"])
+        result = df.replace({"a": replacer, "b": replacer})
+        expected = pd.DataFrame([replacer])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_after_convert_dtypes(self):
+        # GH31517
+        df = pd.DataFrame({"grp": [1, 2, 3, 4, 5]}, dtype="Int64")
+        result = df.replace(1, 10)
+        expected = pd.DataFrame({"grp": [10, 2, 3, 4, 5]}, dtype="Int64")
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_round.py b/pandas/tests/frame/methods/test_round.py
new file mode 100644
index 0000000000000..0865e03cedc50
--- /dev/null
+++ b/pandas/tests/frame/methods/test_round.py
@@ -0,0 +1,217 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, date_range
+import pandas._testing as tm
+
+
+class TestDataFrameRound:
+    def test_round(self):
+        # GH#2665
+
+        # Test that rounding an empty DataFrame does nothing
+        df = DataFrame()
+        tm.assert_frame_equal(df, df.round())
+
+        # Here's the test frame we'll be working with
+        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
+
+        # Default round to integer (i.e. decimals=0)
+        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
+        tm.assert_frame_equal(df.round(), expected_rounded)
+
+        # Round with an integer
+        decimals = 2
+        expected_rounded = DataFrame(
+            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
+        )
+        tm.assert_frame_equal(df.round(decimals), expected_rounded)
+
+        # This should also work with np.round (since np.round dispatches to
+        # df.round)
+        tm.assert_frame_equal(np.round(df, decimals), expected_rounded)
+
+        # Round with a list
+        round_list = [1, 2]
+        with pytest.raises(TypeError):
+            df.round(round_list)
+
+        # Round with a dictionary
+        expected_rounded = DataFrame(
+            {"col1": [1.1, 2.1, 3.1], "col2": [1.23, 2.23, 3.23]}
+        )
+        round_dict = {"col1": 1, "col2": 2}
+        tm.assert_frame_equal(df.round(round_dict), expected_rounded)
+
+        # Incomplete dict
+        expected_partially_rounded = DataFrame(
+            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
+        )
+        partial_round_dict = {"col2": 1}
+        tm.assert_frame_equal(df.round(partial_round_dict), expected_partially_rounded)
+
+        # Dict with unknown elements
+        wrong_round_dict = {"col3": 2, "col2": 1}
+        tm.assert_frame_equal(df.round(wrong_round_dict), expected_partially_rounded)
+
+        # float input to `decimals`
+        non_int_round_dict = {"col1": 1, "col2": 0.5}
+        with pytest.raises(TypeError):
+            df.round(non_int_round_dict)
+
+        # String input
+        non_int_round_dict = {"col1": 1, "col2": "foo"}
+        with pytest.raises(TypeError):
+            df.round(non_int_round_dict)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError):
+            df.round(non_int_round_Series)
+
+        # List input
+        non_int_round_dict = {"col1": 1, "col2": [1, 2]}
+        with pytest.raises(TypeError):
+            df.round(non_int_round_dict)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError):
+            df.round(non_int_round_Series)
+
+        # Non integer Series inputs
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError):
+            df.round(non_int_round_Series)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError):
+            df.round(non_int_round_Series)
+
+        # Negative numbers
+        negative_round_dict = {"col1": -1, "col2": -2}
+        big_df = df * 100
+        expected_neg_rounded = DataFrame(
+            {"col1": [110.0, 210, 310], "col2": [100.0, 200, 300]}
+        )
+        tm.assert_frame_equal(big_df.round(negative_round_dict), expected_neg_rounded)
+
+        # nan in Series round
+        nan_round_Series = Series({"col1": np.nan, "col2": 1})
+
+        # TODO(wesm): unused?
+        expected_nan_round = DataFrame(  # noqa
+            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
+        )
+
+        with pytest.raises(TypeError):
+            df.round(nan_round_Series)
+
+        # Make sure this doesn't break existing Series.round
+        tm.assert_series_equal(df["col1"].round(1), expected_rounded["col1"])
+
+        # named columns
+        # GH#11986
+        decimals = 2
+        expected_rounded = DataFrame(
+            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
+        )
+        df.columns.name = "cols"
+        expected_rounded.columns.name = "cols"
+        tm.assert_frame_equal(df.round(decimals), expected_rounded)
+
+        # interaction of named columns & series
+        tm.assert_series_equal(df["col1"].round(decimals), expected_rounded["col1"])
+        tm.assert_series_equal(df.round(decimals)["col1"], expected_rounded["col1"])
+
+    def test_round_numpy(self):
+        # GH#12600
+        df = DataFrame([[1.53, 1.36], [0.06, 7.01]])
+        out = np.round(df, decimals=0)
+        expected = DataFrame([[2.0, 1.0], [0.0, 7.0]])
+        tm.assert_frame_equal(out, expected)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.round(df, decimals=0, out=df)
+
+    def test_round_numpy_with_nan(self):
+        # See GH#14197
+        df = Series([1.53, np.nan, 0.06]).to_frame()
+        with tm.assert_produces_warning(None):
+            result = df.round()
+        expected = Series([2.0, np.nan, 0.0]).to_frame()
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_mixed_type(self):
+        # GH#11885
+        df = DataFrame(
+            {
+                "col1": [1.1, 2.2, 3.3, 4.4],
+                "col2": ["1", "a", "c", "f"],
+                "col3": date_range("20111111", periods=4),
+            }
+        )
+        round_0 = DataFrame(
+            {
+                "col1": [1.0, 2.0, 3.0, 4.0],
+                "col2": ["1", "a", "c", "f"],
+                "col3": date_range("20111111", periods=4),
+            }
+        )
+        tm.assert_frame_equal(df.round(), round_0)
+        tm.assert_frame_equal(df.round(1), df)
+        tm.assert_frame_equal(df.round({"col1": 1}), df)
+        tm.assert_frame_equal(df.round({"col1": 0}), round_0)
+        tm.assert_frame_equal(df.round({"col1": 0, "col2": 1}), round_0)
+        tm.assert_frame_equal(df.round({"col3": 1}), df)
+
+    def test_round_with_duplicate_columns(self):
+        # GH#11611
+
+        df = pd.DataFrame(
+            np.random.random([3, 3]),
+            columns=["A", "B", "C"],
+            index=["first", "second", "third"],
+        )
+
+        dfs = pd.concat((df, df), axis=1)
+        rounded = dfs.round()
+        tm.assert_index_equal(rounded.index, dfs.index)
+
+        decimals = pd.Series([1, 0, 2], index=["A", "B", "A"])
+        msg = "Index of decimals must be unique"
+        with pytest.raises(ValueError, match=msg):
+            df.round(decimals)
+
+    def test_round_builtin(self):
+        # GH#11763
+        # Here's the test frame we'll be working with
+        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
+
+        # Default round to integer (i.e. decimals=0)
+        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
+        tm.assert_frame_equal(round(df), expected_rounded)
+
+    def test_round_nonunique_categorical(self):
+        # See GH#21809
+        idx = pd.CategoricalIndex(["low"] * 3 + ["hi"] * 3)
+        df = pd.DataFrame(np.random.rand(6, 3), columns=list("abc"))
+
+        expected = df.round(3)
+        expected.index = idx
+
+        df_categorical = df.copy().set_index(idx)
+        assert df_categorical.shape == (6, 3)
+        result = df_categorical.round(3)
+        assert result.shape == (6, 3)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_interval_category_columns(self):
+        # GH#30063
+        columns = pd.CategoricalIndex(pd.interval_range(0, 2))
+        df = DataFrame([[0.66, 1.1], [0.3, 0.25]], columns=columns)
+
+        result = df.round()
+        expected = DataFrame([[1.0, 1.0], [0.0, 0.0]], columns=columns)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
new file mode 100644
index 0000000000000..cfb17de892b1c
--- /dev/null
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -0,0 +1,187 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Index, Series, date_range, offsets
+import pandas._testing as tm
+
+
+class TestDataFrameShift:
+    def test_shift(self, datetime_frame, int_frame):
+        # naive shift
+        shiftedFrame = datetime_frame.shift(5)
+        tm.assert_index_equal(shiftedFrame.index, datetime_frame.index)
+
+        shiftedSeries = datetime_frame["A"].shift(5)
+        tm.assert_series_equal(shiftedFrame["A"], shiftedSeries)
+
+        shiftedFrame = datetime_frame.shift(-5)
+        tm.assert_index_equal(shiftedFrame.index, datetime_frame.index)
+
+        shiftedSeries = datetime_frame["A"].shift(-5)
+        tm.assert_series_equal(shiftedFrame["A"], shiftedSeries)
+
+        # shift by 0
+        unshifted = datetime_frame.shift(0)
+        tm.assert_frame_equal(unshifted, datetime_frame)
+
+        # shift by DateOffset
+        shiftedFrame = datetime_frame.shift(5, freq=offsets.BDay())
+        assert len(shiftedFrame) == len(datetime_frame)
+
+        shiftedFrame2 = datetime_frame.shift(5, freq="B")
+        tm.assert_frame_equal(shiftedFrame, shiftedFrame2)
+
+        d = datetime_frame.index[0]
+        shifted_d = d + offsets.BDay(5)
+        tm.assert_series_equal(
+            datetime_frame.xs(d), shiftedFrame.xs(shifted_d), check_names=False
+        )
+
+        # shift int frame
+        int_shifted = int_frame.shift(1)  # noqa
+
+        # Shifting with PeriodIndex
+        ps = tm.makePeriodFrame()
+        shifted = ps.shift(1)
+        unshifted = shifted.shift(-1)
+        tm.assert_index_equal(shifted.index, ps.index)
+        tm.assert_index_equal(unshifted.index, ps.index)
+        tm.assert_numpy_array_equal(
+            unshifted.iloc[:, 0].dropna().values, ps.iloc[:-1, 0].values
+        )
+
+        shifted2 = ps.shift(1, "B")
+        shifted3 = ps.shift(1, offsets.BDay())
+        tm.assert_frame_equal(shifted2, shifted3)
+        tm.assert_frame_equal(ps, shifted2.shift(-1, "B"))
+
+        msg = "does not match PeriodIndex freq"
+        with pytest.raises(ValueError, match=msg):
+            ps.shift(freq="D")
+
+        # shift other axis
+        # GH#6371
+        df = DataFrame(np.random.rand(10, 5))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # shift named axis
+        df = DataFrame(np.random.rand(10, 5))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_bool(self):
+        df = DataFrame({"high": [True, False], "low": [False, False]})
+        rs = df.shift(1)
+        xp = DataFrame(
+            np.array([[np.nan, np.nan], [True, False]], dtype=object),
+            columns=["high", "low"],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_categorical(self):
+        # GH#9416
+        s1 = pd.Series(["a", "b", "c"], dtype="category")
+        s2 = pd.Series(["A", "B", "C"], dtype="category")
+        df = DataFrame({"one": s1, "two": s2})
+        rs = df.shift(1)
+        xp = DataFrame({"one": s1.shift(1), "two": s2.shift(1)})
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_fill_value(self):
+        # GH#24128
+        df = DataFrame(
+            [1, 2, 3, 4, 5], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        exp = DataFrame(
+            [0, 1, 2, 3, 4], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        result = df.shift(1, fill_value=0)
+        tm.assert_frame_equal(result, exp)
+
+        exp = DataFrame(
+            [0, 0, 1, 2, 3], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        result = df.shift(2, fill_value=0)
+        tm.assert_frame_equal(result, exp)
+
+    def test_shift_empty(self):
+        # Regression test for GH#8019
+        df = DataFrame({"foo": []})
+        rs = df.shift(-1)
+
+        tm.assert_frame_equal(df, rs)
+
+    def test_shift_duplicate_columns(self):
+        # GH#9092; verify that position-based shifting works
+        # in the presence of duplicate columns
+        column_lists = [list(range(5)), [1] * 5, [1, 1, 2, 2, 1]]
+        data = np.random.randn(20, 5)
+
+        shifted = []
+        for columns in column_lists:
+            df = pd.DataFrame(data.copy(), columns=columns)
+            for s in range(5):
+                df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
+            df.columns = range(5)
+            shifted.append(df)
+
+        # sanity check the base case
+        nulls = shifted[0].isna().sum()
+        tm.assert_series_equal(nulls, Series(range(1, 6), dtype="int64"))
+
+        # check all answers are the same
+        tm.assert_frame_equal(shifted[0], shifted[1])
+        tm.assert_frame_equal(shifted[0], shifted[2])
+
+    def test_tshift(self, datetime_frame):
+        # PeriodIndex
+        ps = tm.makePeriodFrame()
+        shifted = ps.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_frame_equal(unshifted, ps)
+
+        shifted2 = ps.tshift(freq="B")
+        tm.assert_frame_equal(shifted, shifted2)
+
+        shifted3 = ps.tshift(freq=offsets.BDay())
+        tm.assert_frame_equal(shifted, shifted3)
+
+        with pytest.raises(ValueError, match="does not match"):
+            ps.tshift(freq="M")
+
+        # DatetimeIndex
+        shifted = datetime_frame.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_frame_equal(datetime_frame, unshifted)
+
+        shifted2 = datetime_frame.tshift(freq=datetime_frame.index.freq)
+        tm.assert_frame_equal(shifted, shifted2)
+
+        inferred_ts = DataFrame(
+            datetime_frame.values,
+            Index(np.asarray(datetime_frame.index)),
+            columns=datetime_frame.columns,
+        )
+        shifted = inferred_ts.tshift(1)
+        unshifted = shifted.tshift(-1)
+        tm.assert_frame_equal(shifted, datetime_frame.tshift(1))
+        tm.assert_frame_equal(unshifted, inferred_ts)
+
+        no_freq = datetime_frame.iloc[[0, 5, 7], :]
+        msg = "Freq was not given and was not set in the index"
+        with pytest.raises(ValueError, match=msg):
+            no_freq.tshift()
diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
new file mode 100644
index 0000000000000..2c25e1f3740a3
--- /dev/null
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -0,0 +1,320 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import CategoricalDtype, DataFrame, IntervalIndex, MultiIndex, Series
+import pandas._testing as tm
+
+
+class TestDataFrameSortIndex:
+    def test_sort_index_nan(self):
+        # GH#3917
+
+        # Test DataFrame with nan label
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]},
+            index=[1, 2, 3, 4, 5, 6, np.nan],
+        )
+
+        # NaN label, ascending=True, na_position='last'
+        sorted_df = df.sort_index(kind="quicksort", ascending=True, na_position="last")
+        expected = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]},
+            index=[1, 2, 3, 4, 5, 6, np.nan],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=True, na_position='first'
+        sorted_df = df.sort_index(na_position="first")
+        expected = DataFrame(
+            {"A": [4, 1, 2, np.nan, 1, 6, 8], "B": [5, 9, np.nan, 5, 2, 5, 4]},
+            index=[np.nan, 1, 2, 3, 4, 5, 6],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=False, na_position='last'
+        sorted_df = df.sort_index(kind="quicksort", ascending=False)
+        expected = DataFrame(
+            {"A": [8, 6, 1, np.nan, 2, 1, 4], "B": [4, 5, 2, 5, np.nan, 9, 5]},
+            index=[6, 5, 4, 3, 2, 1, np.nan],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=False, na_position='first'
+        sorted_df = df.sort_index(
+            kind="quicksort", ascending=False, na_position="first"
+        )
+        expected = DataFrame(
+            {"A": [4, 8, 6, 1, np.nan, 2, 1], "B": [5, 4, 5, 2, 5, np.nan, 9]},
+            index=[np.nan, 6, 5, 4, 3, 2, 1],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_index_multi_index(self):
+        # GH#25775, testing that sorting by index works with a multi-index.
+        df = DataFrame(
+            {"a": [3, 1, 2], "b": [0, 0, 0], "c": [0, 1, 2], "d": list("abc")}
+        )
+        result = df.set_index(list("abc")).sort_index(level=list("ba"))
+
+        expected = DataFrame(
+            {"a": [1, 2, 3], "b": [0, 0, 0], "c": [1, 2, 0], "d": list("bca")}
+        )
+        expected = expected.set_index(list("abc"))
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_inplace(self):
+        frame = DataFrame(
+            np.random.randn(4, 4), index=[1, 2, 3, 4], columns=["A", "B", "C", "D"]
+        )
+
+        # axis=0
+        unordered = frame.loc[[3, 2, 4, 1]]
+        a_id = id(unordered["A"])
+        df = unordered.copy()
+        df.sort_index(inplace=True)
+        expected = frame
+        tm.assert_frame_equal(df, expected)
+        assert a_id != id(df["A"])
+
+        df = unordered.copy()
+        df.sort_index(ascending=False, inplace=True)
+        expected = frame[::-1]
+        tm.assert_frame_equal(df, expected)
+
+        # axis=1
+        unordered = frame.loc[:, ["D", "B", "C", "A"]]
+        df = unordered.copy()
+        df.sort_index(axis=1, inplace=True)
+        expected = frame
+        tm.assert_frame_equal(df, expected)
+
+        df = unordered.copy()
+        df.sort_index(axis=1, ascending=False, inplace=True)
+        expected = frame.iloc[:, ::-1]
+        tm.assert_frame_equal(df, expected)
+
+    def test_sort_index_different_sortorder(self):
+        A = np.arange(20).repeat(5)
+        B = np.tile(np.arange(5), 20)
+
+        indexer = np.random.permutation(100)
+        A = A.take(indexer)
+        B = B.take(indexer)
+
+        df = DataFrame({"A": A, "B": B, "C": np.random.randn(100)})
+
+        ex_indexer = np.lexsort((df.B.max() - df.B, df.A))
+        expected = df.take(ex_indexer)
+
+        # test with multiindex, too
+        idf = df.set_index(["A", "B"])
+
+        result = idf.sort_index(ascending=[1, 0])
+        expected = idf.take(ex_indexer)
+        tm.assert_frame_equal(result, expected)
+
+        # also, Series!
+        result = idf["C"].sort_index(ascending=[1, 0])
+        tm.assert_series_equal(result, expected["C"])
+
+    def test_sort_index_level(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        df = DataFrame([[1, 2], [3, 4]], mi)
+
+        result = df.sort_index(level="A", sort_remaining=False)
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["A", "B"], sort_remaining=False)
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+        # Error thrown by sort_index when
+        # first index is sorted last (GH#26053)
+        result = df.sort_index(level=["C", "B", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["B", "C", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["C", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_categorical_index(self):
+
+        df = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+                "B": Series(list("aabbca")).astype(CategoricalDtype(list("cab"))),
+            }
+        ).set_index("B")
+
+        result = df.sort_index()
+        expected = df.iloc[[4, 0, 1, 5, 2, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(ascending=False)
+        expected = df.iloc[[2, 3, 0, 1, 5, 4]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index(self):
+        # GH#13496
+
+        frame = DataFrame(
+            np.arange(16).reshape(4, 4),
+            index=[1, 2, 3, 4],
+            columns=["A", "B", "C", "D"],
+        )
+
+        # axis=0 : sort rows by index labels
+        unordered = frame.loc[[3, 2, 4, 1]]
+        result = unordered.sort_index(axis=0)
+        expected = frame
+        tm.assert_frame_equal(result, expected)
+
+        result = unordered.sort_index(ascending=False)
+        expected = frame[::-1]
+        tm.assert_frame_equal(result, expected)
+
+        # axis=1 : sort columns by column names
+        unordered = frame.iloc[:, [2, 1, 3, 0]]
+        result = unordered.sort_index(axis=1)
+        tm.assert_frame_equal(result, frame)
+
+        result = unordered.sort_index(axis=1, ascending=False)
+        expected = frame.iloc[:, ::-1]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("level", ["A", 0])  # GH#21052
+    def test_sort_index_multiindex(self, level):
+        # GH#13496
+
+        # sort rows by specified level of multi-index
+        mi = MultiIndex.from_tuples(
+            [[2, 1, 3], [2, 1, 2], [1, 1, 1]], names=list("ABC")
+        )
+        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=mi)
+
+        expected_mi = MultiIndex.from_tuples(
+            [[1, 1, 1], [2, 1, 2], [2, 1, 3]], names=list("ABC")
+        )
+        expected = pd.DataFrame([[5, 6], [3, 4], [1, 2]], index=expected_mi)
+        result = df.sort_index(level=level)
+        tm.assert_frame_equal(result, expected)
+
+        # sort_remaining=False
+        expected_mi = MultiIndex.from_tuples(
+            [[1, 1, 1], [2, 1, 3], [2, 1, 2]], names=list("ABC")
+        )
+        expected = pd.DataFrame([[5, 6], [1, 2], [3, 4]], index=expected_mi)
+        result = df.sort_index(level=level, sort_remaining=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_intervalindex(self):
+        # this is a de-facto sort via unstack
+        # confirming that we sort in the order of the bins
+        y = Series(np.random.randn(100))
+        x1 = Series(np.sign(np.random.randn(100)))
+        x2 = pd.cut(Series(np.random.randn(100)), bins=[-3, -0.5, 0, 0.5, 3])
+        model = pd.concat([y, x1, x2], axis=1, keys=["Y", "X1", "X2"])
+
+        result = model.groupby(["X1", "X2"], observed=True).mean().unstack()
+        expected = IntervalIndex.from_tuples(
+            [(-3.0, -0.5), (-0.5, 0.0), (0.0, 0.5), (0.5, 3.0)], closed="right"
+        )
+        result = result.columns.levels[1].categories
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ascending, ignore_index, output_index",
+        [
+            ({"A": [1, 2, 3]}, {"A": [2, 3, 1]}, False, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [1, 3, 2]}, True, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [2, 3, 1]}, False, False, [5, 3, 2]),
+            ({"A": [1, 2, 3]}, {"A": [1, 3, 2]}, True, False, [2, 3, 5]),
+        ],
+    )
+    def test_sort_index_ignore_index(
+        self, inplace, original_dict, sorted_dict, ascending, ignore_index, output_index
+    ):
+        # GH 30114
+        original_index = [2, 5, 3]
+        df = DataFrame(original_dict, index=original_index)
+        expected_df = DataFrame(sorted_dict, index=output_index)
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_index(**kwargs)
+        else:
+            result_df = df.sort_index(**kwargs)
+
+        tm.assert_frame_equal(result_df, expected_df)
+        tm.assert_frame_equal(df, DataFrame(original_dict, index=original_index))
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ascending, ignore_index, output_index",
+        [
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [1, 2], "M2": [3, 4]},
+                True,
+                True,
+                [0, 1],
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [2, 1], "M2": [4, 3]},
+                False,
+                True,
+                [0, 1],
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [1, 2], "M2": [3, 4]},
+                True,
+                False,
+                MultiIndex.from_tuples([[2, 1], [3, 4]], names=list("AB")),
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [2, 1], "M2": [4, 3]},
+                False,
+                False,
+                MultiIndex.from_tuples([[3, 4], [2, 1]], names=list("AB")),
+            ),
+        ],
+    )
+    def test_sort_index_ignore_index_multi_index(
+        self, inplace, original_dict, sorted_dict, ascending, ignore_index, output_index
+    ):
+        # GH 30114, this is to test ignore_index on MulitIndex of index
+        mi = MultiIndex.from_tuples([[2, 1], [3, 4]], names=list("AB"))
+        df = DataFrame(original_dict, index=mi)
+        expected_df = DataFrame(sorted_dict, index=output_index)
+
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_index(**kwargs)
+        else:
+            result_df = df.sort_index(**kwargs)
+
+        tm.assert_frame_equal(result_df, expected_df)
+        tm.assert_frame_equal(df, DataFrame(original_dict, index=mi))
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
new file mode 100644
index 0000000000000..96f4d6ed90d6b
--- /dev/null
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -0,0 +1,518 @@
+import random
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Categorical, DataFrame, NaT, Timestamp, date_range
+import pandas._testing as tm
+
+
+class TestDataFrameSortValues:
+    def test_sort_values(self):
+        frame = DataFrame(
+            [[1, 1, 2], [3, 1, 0], [4, 5, 6]], index=[1, 2, 3], columns=list("ABC")
+        )
+
+        # by column (axis=0)
+        sorted_df = frame.sort_values(by="A")
+        indexer = frame["A"].argsort().values
+        expected = frame.loc[frame.index[indexer]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by="A", ascending=False)
+        indexer = indexer[::-1]
+        expected = frame.loc[frame.index[indexer]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by="A", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # GH4839
+        sorted_df = frame.sort_values(by=["A"], ascending=[False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # multiple bys
+        sorted_df = frame.sort_values(by=["B", "C"])
+        expected = frame.loc[[2, 1, 3]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=["B", "C"], ascending=False)
+        tm.assert_frame_equal(sorted_df, expected[::-1])
+
+        sorted_df = frame.sort_values(by=["B", "A"], ascending=[True, False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        msg = "No axis named 2 for object type <class 'pandas.core.frame.DataFrame'>"
+        with pytest.raises(ValueError, match=msg):
+            frame.sort_values(by=["A", "B"], axis=2, inplace=True)
+
+        # by row (axis=1): GH#10806
+        sorted_df = frame.sort_values(by=3, axis=1)
+        expected = frame
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=3, axis=1, ascending=False)
+        expected = frame.reindex(columns=["C", "B", "A"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 2], axis="columns")
+        expected = frame.reindex(columns=["B", "A", "C"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=[True, False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=False)
+        expected = frame.reindex(columns=["C", "B", "A"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        msg = r"Length of ascending \(5\) != length of by \(2\)"
+        with pytest.raises(ValueError, match=msg):
+            frame.sort_values(by=["A", "B"], axis=0, ascending=[True] * 5)
+
+    def test_sort_values_inplace(self):
+        frame = DataFrame(
+            np.random.randn(4, 4), index=[1, 2, 3, 4], columns=["A", "B", "C", "D"]
+        )
+
+        sorted_df = frame.copy()
+        sorted_df.sort_values(by="A", inplace=True)
+        expected = frame.sort_values(by="A")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort_values(by=1, axis=1, inplace=True)
+        expected = frame.sort_values(by=1, axis=1)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort_values(by="A", ascending=False, inplace=True)
+        expected = frame.sort_values(by="A", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort_values(by=["A", "B"], ascending=False, inplace=True)
+        expected = frame.sort_values(by=["A", "B"], ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_multicolumn(self):
+        A = np.arange(5).repeat(20)
+        B = np.tile(np.arange(5), 20)
+        random.shuffle(A)
+        random.shuffle(B)
+        frame = DataFrame({"A": A, "B": B, "C": np.random.randn(100)})
+
+        result = frame.sort_values(by=["A", "B"])
+        indexer = np.lexsort((frame["B"], frame["A"]))
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.sort_values(by=["A", "B"], ascending=False)
+        indexer = np.lexsort(
+            (frame["B"].rank(ascending=False), frame["A"].rank(ascending=False))
+        )
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.sort_values(by=["B", "A"])
+        indexer = np.lexsort((frame["A"], frame["B"]))
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_multicolumn_uint64(self):
+        # GH#9918
+        # uint64 multicolumn sort
+
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([18446637057563306014, 1162265347240853609]),
+                "b": pd.Series([1, 2]),
+            }
+        )
+        df["a"] = df["a"].astype(np.uint64)
+        result = df.sort_values(["a", "b"])
+
+        expected = pd.DataFrame(
+            {
+                "a": pd.Series([18446637057563306014, 1162265347240853609]),
+                "b": pd.Series([1, 2]),
+            },
+            index=pd.Index([1, 0]),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_nan(self):
+        # GH#3917
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]}
+        )
+
+        # sort one column only
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, np.nan, 5, 5, 4]},
+            index=[2, 0, 3, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A"], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        expected = DataFrame(
+            {"A": [np.nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, np.nan, 9, 2]},
+            index=[2, 5, 4, 6, 1, 0, 3],
+        )
+        sorted_df = df.sort_values(["A"], na_position="first", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        expected = df.reindex(columns=["B", "A"])
+        sorted_df = df.sort_values(by=1, axis=1, na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='last', order
+        expected = DataFrame(
+            {"A": [1, 1, 2, 4, 6, 8, np.nan], "B": [2, 9, np.nan, 5, 5, 4, 5]},
+            index=[3, 0, 1, 6, 4, 5, 2],
+        )
+        sorted_df = df.sort_values(["A", "B"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='first', order
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 2, 9, np.nan, 5, 5, 4]},
+            index=[2, 3, 0, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A", "B"], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='first', not order
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, np.nan, 5, 5, 4]},
+            index=[2, 0, 3, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A", "B"], ascending=[1, 0], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='last', not order
+        expected = DataFrame(
+            {"A": [8, 6, 4, 2, 1, 1, np.nan], "B": [4, 5, 5, np.nan, 2, 9, 5]},
+            index=[5, 4, 6, 1, 3, 0, 2],
+        )
+        sorted_df = df.sort_values(["A", "B"], ascending=[0, 1], na_position="last")
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_stable_descending_sort(self):
+        # GH#6399
+        df = DataFrame(
+            [[2, "first"], [2, "second"], [1, "a"], [1, "b"]],
+            columns=["sort_col", "order"],
+        )
+        sorted_df = df.sort_values(by="sort_col", kind="mergesort", ascending=False)
+        tm.assert_frame_equal(df, sorted_df)
+
+    def test_sort_values_stable_descending_multicolumn_sort(self):
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]}
+        )
+        # test stable mergesort
+        expected = DataFrame(
+            {"A": [np.nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, np.nan, 2, 9]},
+            index=[2, 5, 4, 6, 1, 3, 0],
+        )
+        sorted_df = df.sort_values(
+            ["A", "B"], ascending=[0, 1], na_position="first", kind="mergesort"
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        expected = DataFrame(
+            {"A": [np.nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, np.nan, 9, 2]},
+            index=[2, 5, 4, 6, 1, 0, 3],
+        )
+        sorted_df = df.sort_values(
+            ["A", "B"], ascending=[0, 0], na_position="first", kind="mergesort"
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_stable_categorial(self):
+        # GH#16793
+        df = DataFrame({"x": pd.Categorical(np.repeat([1, 2, 3, 4], 5), ordered=True)})
+        expected = df.copy()
+        sorted_df = df.sort_values("x", kind="mergesort")
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_datetimes(self):
+
+        # GH#3461, argsort / lexsort differences for a datetime column
+        df = DataFrame(
+            ["a", "a", "a", "b", "c", "d", "e", "f", "g"],
+            columns=["A"],
+            index=date_range("20130101", periods=9),
+        )
+        dts = [
+            Timestamp(x)
+            for x in [
+                "2004-02-11",
+                "2004-01-21",
+                "2004-01-26",
+                "2005-09-20",
+                "2010-10-04",
+                "2009-05-12",
+                "2008-11-12",
+                "2010-09-28",
+                "2010-09-28",
+            ]
+        ]
+        df["B"] = dts[::2] + dts[1::2]
+        df["C"] = 2.0
+        df["A1"] = 3.0
+
+        df1 = df.sort_values(by="A")
+        df2 = df.sort_values(by=["A"])
+        tm.assert_frame_equal(df1, df2)
+
+        df1 = df.sort_values(by="B")
+        df2 = df.sort_values(by=["B"])
+        tm.assert_frame_equal(df1, df2)
+
+        df1 = df.sort_values(by="B")
+
+        df2 = df.sort_values(by=["C", "B"])
+        tm.assert_frame_equal(df1, df2)
+
+    def test_sort_values_frame_column_inplace_sort_exception(self, float_frame):
+        s = float_frame["A"]
+        with pytest.raises(ValueError, match="This Series is a view"):
+            s.sort_values(inplace=True)
+
+        cp = s.copy()
+        cp.sort_values()  # it works!
+
+    def test_sort_values_nat_values_in_int_column(self):
+
+        # GH#14922: "sorting with large float and multiple columns incorrect"
+
+        # cause was that the int64 value NaT was considered as "na". Which is
+        # only correct for datetime64 columns.
+
+        int_values = (2, int(NaT))
+        float_values = (2.0, -1.797693e308)
+
+        df = DataFrame(
+            dict(int=int_values, float=float_values), columns=["int", "float"]
+        )
+
+        df_reversed = DataFrame(
+            dict(int=int_values[::-1], float=float_values[::-1]),
+            columns=["int", "float"],
+            index=[1, 0],
+        )
+
+        # NaT is not a "na" for int64 columns, so na_position must not
+        # influence the result:
+        df_sorted = df.sort_values(["int", "float"], na_position="last")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        df_sorted = df.sort_values(["int", "float"], na_position="first")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        # reverse sorting order
+        df_sorted = df.sort_values(["int", "float"], ascending=False)
+        tm.assert_frame_equal(df_sorted, df)
+
+        # and now check if NaT is still considered as "na" for datetime64
+        # columns:
+        df = DataFrame(
+            dict(datetime=[Timestamp("2016-01-01"), NaT], float=float_values),
+            columns=["datetime", "float"],
+        )
+
+        df_reversed = DataFrame(
+            dict(datetime=[NaT, Timestamp("2016-01-01")], float=float_values[::-1]),
+            columns=["datetime", "float"],
+            index=[1, 0],
+        )
+
+        df_sorted = df.sort_values(["datetime", "float"], na_position="first")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        df_sorted = df.sort_values(["datetime", "float"], na_position="last")
+        tm.assert_frame_equal(df_sorted, df)
+
+        # Ascending should not affect the results.
+        df_sorted = df.sort_values(["datetime", "float"], ascending=False)
+        tm.assert_frame_equal(df_sorted, df)
+
+    def test_sort_values_na_position_with_categories(self):
+        # GH#22556
+        # Positioning missing value properly when column is Categorical.
+        categories = ["A", "B", "C"]
+        category_indices = [0, 2, 4]
+        list_of_nans = [np.nan, np.nan]
+        na_indices = [1, 3]
+        na_position_first = "first"
+        na_position_last = "last"
+        column_name = "c"
+
+        reversed_categories = sorted(categories, reverse=True)
+        reversed_category_indices = sorted(category_indices, reverse=True)
+        reversed_na_indices = sorted(na_indices)
+
+        df = pd.DataFrame(
+            {
+                column_name: pd.Categorical(
+                    ["A", np.nan, "B", np.nan, "C"], categories=categories, ordered=True
+                )
+            }
+        )
+        # sort ascending with na first
+        result = df.sort_values(
+            by=column_name, ascending=True, na_position=na_position_first
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    list_of_nans + categories, categories=categories, ordered=True
+                )
+            },
+            index=na_indices + category_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort ascending with na last
+        result = df.sort_values(
+            by=column_name, ascending=True, na_position=na_position_last
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    categories + list_of_nans, categories=categories, ordered=True
+                )
+            },
+            index=category_indices + na_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort descending with na first
+        result = df.sort_values(
+            by=column_name, ascending=False, na_position=na_position_first
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    list_of_nans + reversed_categories,
+                    categories=categories,
+                    ordered=True,
+                )
+            },
+            index=reversed_na_indices + reversed_category_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort descending with na last
+        result = df.sort_values(
+            by=column_name, ascending=False, na_position=na_position_last
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    reversed_categories + list_of_nans,
+                    categories=categories,
+                    ordered=True,
+                )
+            },
+            index=reversed_category_indices + reversed_na_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_nat(self):
+
+        # GH#16836
+
+        d1 = [Timestamp(x) for x in ["2016-01-01", "2015-01-01", np.nan, "2016-01-01"]]
+        d2 = [
+            Timestamp(x)
+            for x in ["2017-01-01", "2014-01-01", "2016-01-01", "2015-01-01"]
+        ]
+        df = pd.DataFrame({"a": d1, "b": d2}, index=[0, 1, 2, 3])
+
+        d3 = [Timestamp(x) for x in ["2015-01-01", "2016-01-01", "2016-01-01", np.nan]]
+        d4 = [
+            Timestamp(x)
+            for x in ["2014-01-01", "2015-01-01", "2017-01-01", "2016-01-01"]
+        ]
+        expected = pd.DataFrame({"a": d3, "b": d4}, index=[1, 3, 0, 2])
+        sorted_df = df.sort_values(by=["a", "b"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_na_position_with_categories_raises(self):
+        df = pd.DataFrame(
+            {
+                "c": pd.Categorical(
+                    ["A", np.nan, "B", np.nan, "C"],
+                    categories=["A", "B", "C"],
+                    ordered=True,
+                )
+            }
+        )
+
+        with pytest.raises(ValueError):
+            df.sort_values(by="c", ascending=False, na_position="bad_position")
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ignore_index, output_index",
+        [
+            ({"A": [1, 2, 3]}, {"A": [3, 2, 1]}, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [3, 2, 1]}, False, [2, 1, 0]),
+            (
+                {"A": [1, 2, 3], "B": [2, 3, 4]},
+                {"A": [3, 2, 1], "B": [4, 3, 2]},
+                True,
+                [0, 1, 2],
+            ),
+            (
+                {"A": [1, 2, 3], "B": [2, 3, 4]},
+                {"A": [3, 2, 1], "B": [4, 3, 2]},
+                False,
+                [2, 1, 0],
+            ),
+        ],
+    )
+    def test_sort_values_ignore_index(
+        self, inplace, original_dict, sorted_dict, ignore_index, output_index
+    ):
+        # GH 30114
+        df = DataFrame(original_dict)
+        expected = DataFrame(sorted_dict, index=output_index)
+        kwargs = {"ignore_index": ignore_index, "inplace": inplace}
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_values("A", ascending=False, **kwargs)
+        else:
+            result_df = df.sort_values("A", ascending=False, **kwargs)
+
+        tm.assert_frame_equal(result_df, expected)
+        tm.assert_frame_equal(df, DataFrame(original_dict))
+
+    def test_sort_values_nat_na_position_default(self):
+        # GH 13230
+        expected = pd.DataFrame(
+            {
+                "A": [1, 2, 3, 4, 4],
+                "date": pd.DatetimeIndex(
+                    [
+                        "2010-01-01 09:00:00",
+                        "2010-01-01 09:00:01",
+                        "2010-01-01 09:00:02",
+                        "2010-01-01 09:00:03",
+                        "NaT",
+                    ]
+                ),
+            }
+        )
+        result = expected.sort_values(["A", "date"])
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
new file mode 100644
index 0000000000000..7b0adceb57668
--- /dev/null
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -0,0 +1,258 @@
+from collections import OrderedDict, defaultdict
+from datetime import datetime
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas import DataFrame, Series, Timestamp
+import pandas._testing as tm
+
+
+class TestDataFrameToDict:
+    def test_to_dict_timestamp(self):
+
+        # GH#11247
+        # split/records producing np.datetime64 rather than Timestamps
+        # on datetime64[ns] dtypes only
+
+        tsmp = Timestamp("20130101")
+        test_data = DataFrame({"A": [tsmp, tsmp], "B": [tsmp, tsmp]})
+        test_data_mixed = DataFrame({"A": [tsmp, tsmp], "B": [1, 2]})
+
+        expected_records = [{"A": tsmp, "B": tsmp}, {"A": tsmp, "B": tsmp}]
+        expected_records_mixed = [{"A": tsmp, "B": 1}, {"A": tsmp, "B": 2}]
+
+        assert test_data.to_dict(orient="records") == expected_records
+        assert test_data_mixed.to_dict(orient="records") == expected_records_mixed
+
+        expected_series = {
+            "A": Series([tsmp, tsmp], name="A"),
+            "B": Series([tsmp, tsmp], name="B"),
+        }
+        expected_series_mixed = {
+            "A": Series([tsmp, tsmp], name="A"),
+            "B": Series([1, 2], name="B"),
+        }
+
+        tm.assert_dict_equal(test_data.to_dict(orient="series"), expected_series)
+        tm.assert_dict_equal(
+            test_data_mixed.to_dict(orient="series"), expected_series_mixed
+        )
+
+        expected_split = {
+            "index": [0, 1],
+            "data": [[tsmp, tsmp], [tsmp, tsmp]],
+            "columns": ["A", "B"],
+        }
+        expected_split_mixed = {
+            "index": [0, 1],
+            "data": [[tsmp, 1], [tsmp, 2]],
+            "columns": ["A", "B"],
+        }
+
+        tm.assert_dict_equal(test_data.to_dict(orient="split"), expected_split)
+        tm.assert_dict_equal(
+            test_data_mixed.to_dict(orient="split"), expected_split_mixed
+        )
+
+    def test_to_dict_index_not_unique_with_index_orient(self):
+        # GH#22801
+        # Data loss when indexes are not unique. Raise ValueError.
+        df = DataFrame({"a": [1, 2], "b": [0.5, 0.75]}, index=["A", "A"])
+        msg = "DataFrame index must be unique for orient='index'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient="index")
+
+    def test_to_dict_invalid_orient(self):
+        df = DataFrame({"A": [0, 1]})
+        msg = "orient 'xinvalid' not understood"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient="xinvalid")
+
+    @pytest.mark.parametrize("mapping", [dict, defaultdict(list), OrderedDict])
+    def test_to_dict(self, mapping):
+        test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
+
+        # GH#16122
+        recons_data = DataFrame(test_data).to_dict(into=mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][k2]
+
+        recons_data = DataFrame(test_data).to_dict("l", mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][int(k2) - 1]
+
+        recons_data = DataFrame(test_data).to_dict("s", mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][k2]
+
+        recons_data = DataFrame(test_data).to_dict("sp", mapping)
+        expected_split = {
+            "columns": ["A", "B"],
+            "index": ["1", "2", "3"],
+            "data": [[1.0, "1"], [2.0, "2"], [np.nan, "3"]],
+        }
+        tm.assert_dict_equal(recons_data, expected_split)
+
+        recons_data = DataFrame(test_data).to_dict("r", mapping)
+        expected_records = [
+            {"A": 1.0, "B": "1"},
+            {"A": 2.0, "B": "2"},
+            {"A": np.nan, "B": "3"},
+        ]
+        assert isinstance(recons_data, list)
+        assert len(recons_data) == 3
+        for l, r in zip(recons_data, expected_records):
+            tm.assert_dict_equal(l, r)
+
+        # GH#10844
+        recons_data = DataFrame(test_data).to_dict("i")
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k2][k]
+
+        df = DataFrame(test_data)
+        df["duped"] = df[df.columns[0]]
+        recons_data = df.to_dict("i")
+        comp_data = test_data.copy()
+        comp_data["duped"] = comp_data[df.columns[0]]
+        for k, v in comp_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k2][k]
+
+    @pytest.mark.parametrize("mapping", [list, defaultdict, []])
+    def test_to_dict_errors(self, mapping):
+        # GH#16122
+        df = DataFrame(np.random.randn(3, 3))
+        with pytest.raises(TypeError):
+            df.to_dict(into=mapping)
+
+    def test_to_dict_not_unique_warning(self):
+        # GH#16927: When converting to a dict, if a column has a non-unique name
+        # it will be dropped, throwing a warning.
+        df = DataFrame([[1, 2, 3]], columns=["a", "a", "b"])
+        with tm.assert_produces_warning(UserWarning):
+            df.to_dict()
+
+    # orient - orient argument to to_dict function
+    # item_getter - function for extracting value from
+    # the resulting dict using column name and index
+    @pytest.mark.parametrize(
+        "orient,item_getter",
+        [
+            ("dict", lambda d, col, idx: d[col][idx]),
+            ("records", lambda d, col, idx: d[idx][col]),
+            ("list", lambda d, col, idx: d[col][idx]),
+            ("split", lambda d, col, idx: d["data"][idx][d["columns"].index(col)]),
+            ("index", lambda d, col, idx: d[idx][col]),
+        ],
+    )
+    def test_to_dict_box_scalars(self, orient, item_getter):
+        # GH#14216, GH#23753
+        # make sure that we are boxing properly
+        df = DataFrame({"a": [1, 2], "b": [0.1, 0.2]})
+        result = df.to_dict(orient=orient)
+        assert isinstance(item_getter(result, "a", 0), int)
+        assert isinstance(item_getter(result, "b", 0), float)
+
+    def test_to_dict_tz(self):
+        # GH#18372 When converting to dict with orient='records' columns of
+        # datetime that are tz-aware were not converted to required arrays
+        data = [
+            (datetime(2017, 11, 18, 21, 53, 0, 219225, tzinfo=pytz.utc),),
+            (datetime(2017, 11, 18, 22, 6, 30, 61810, tzinfo=pytz.utc),),
+        ]
+        df = DataFrame(list(data), columns=["d"])
+
+        result = df.to_dict(orient="records")
+        expected = [
+            {"d": Timestamp("2017-11-18 21:53:00.219225+0000", tz=pytz.utc)},
+            {"d": Timestamp("2017-11-18 22:06:30.061810+0000", tz=pytz.utc)},
+        ]
+        tm.assert_dict_equal(result[0], expected[0])
+        tm.assert_dict_equal(result[1], expected[1])
+
+    @pytest.mark.parametrize(
+        "into, expected",
+        [
+            (
+                dict,
+                {
+                    0: {"int_col": 1, "float_col": 1.0},
+                    1: {"int_col": 2, "float_col": 2.0},
+                    2: {"int_col": 3, "float_col": 3.0},
+                },
+            ),
+            (
+                OrderedDict,
+                OrderedDict(
+                    [
+                        (0, {"int_col": 1, "float_col": 1.0}),
+                        (1, {"int_col": 2, "float_col": 2.0}),
+                        (2, {"int_col": 3, "float_col": 3.0}),
+                    ]
+                ),
+            ),
+            (
+                defaultdict(dict),
+                defaultdict(
+                    dict,
+                    {
+                        0: {"int_col": 1, "float_col": 1.0},
+                        1: {"int_col": 2, "float_col": 2.0},
+                        2: {"int_col": 3, "float_col": 3.0},
+                    },
+                ),
+            ),
+        ],
+    )
+    def test_to_dict_index_dtypes(self, into, expected):
+        # GH#18580
+        # When using to_dict(orient='index') on a dataframe with int
+        # and float columns only the int columns were cast to float
+
+        df = DataFrame({"int_col": [1, 2, 3], "float_col": [1.0, 2.0, 3.0]})
+
+        result = df.to_dict(orient="index", into=into)
+        cols = ["int_col", "float_col"]
+        result = DataFrame.from_dict(result, orient="index")[cols]
+        expected = DataFrame.from_dict(expected, orient="index")[cols]
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_dict_numeric_names(self):
+        # GH#24940
+        df = DataFrame({str(i): [i] for i in range(5)})
+        result = set(df.to_dict("records")[0].keys())
+        expected = set(df.columns)
+        assert result == expected
+
+    def test_to_dict_wide(self):
+        # GH#24939
+        df = DataFrame({("A_{:d}".format(i)): [i] for i in range(256)})
+        result = df.to_dict("records")[0]
+        expected = {"A_{:d}".format(i): i for i in range(256)}
+        assert result == expected
+
+    def test_to_dict_orient_dtype(self):
+        # GH#22620
+        # Input Data
+        input_data = {"a": [1, 2, 3], "b": [1.0, 2.0, 3.0], "c": ["X", "Y", "Z"]}
+        df = DataFrame(input_data)
+        # Expected Dtypes
+        expected = {"a": int, "b": float, "c": str}
+        # Extracting dtypes out of to_dict operation
+        for df_dict in df.to_dict("records"):
+            result = {
+                "a": type(df_dict["a"]),
+                "b": type(df_dict["b"]),
+                "c": type(df_dict["c"]),
+            }
+            assert result == expected
diff --git a/pandas/tests/frame/test_convert_to.py b/pandas/tests/frame/methods/test_to_records.py
similarity index 56%
rename from pandas/tests/frame/test_convert_to.py
rename to pandas/tests/frame/methods/test_to_records.py
index 3f0768ad5bdac..d0181f0309af1 100644
--- a/pandas/tests/frame/test_convert_to.py
+++ b/pandas/tests/frame/methods/test_to_records.py
@@ -1,108 +1,25 @@
-from collections import OrderedDict, abc, defaultdict
-from datetime import datetime
+from collections import abc
 
 import numpy as np
 import pytest
-import pytz
-
-from pandas import (
-    CategoricalDtype,
-    DataFrame,
-    MultiIndex,
-    Series,
-    Timestamp,
-    date_range,
-)
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-
-
-class TestDataFrameConvertTo(TestData):
-    def test_to_dict_timestamp(self):
-
-        # GH11247
-        # split/records producing np.datetime64 rather than Timestamps
-        # on datetime64[ns] dtypes only
-
-        tsmp = Timestamp("20130101")
-        test_data = DataFrame({"A": [tsmp, tsmp], "B": [tsmp, tsmp]})
-        test_data_mixed = DataFrame({"A": [tsmp, tsmp], "B": [1, 2]})
-
-        expected_records = [{"A": tsmp, "B": tsmp}, {"A": tsmp, "B": tsmp}]
-        expected_records_mixed = [{"A": tsmp, "B": 1}, {"A": tsmp, "B": 2}]
-
-        assert test_data.to_dict(orient="records") == expected_records
-        assert test_data_mixed.to_dict(orient="records") == expected_records_mixed
-
-        expected_series = {
-            "A": Series([tsmp, tsmp], name="A"),
-            "B": Series([tsmp, tsmp], name="B"),
-        }
-        expected_series_mixed = {
-            "A": Series([tsmp, tsmp], name="A"),
-            "B": Series([1, 2], name="B"),
-        }
-
-        tm.assert_dict_equal(test_data.to_dict(orient="series"), expected_series)
-        tm.assert_dict_equal(
-            test_data_mixed.to_dict(orient="series"), expected_series_mixed
-        )
-
-        expected_split = {
-            "index": [0, 1],
-            "data": [[tsmp, tsmp], [tsmp, tsmp]],
-            "columns": ["A", "B"],
-        }
-        expected_split_mixed = {
-            "index": [0, 1],
-            "data": [[tsmp, 1], [tsmp, 2]],
-            "columns": ["A", "B"],
-        }
-
-        tm.assert_dict_equal(test_data.to_dict(orient="split"), expected_split)
-        tm.assert_dict_equal(
-            test_data_mixed.to_dict(orient="split"), expected_split_mixed
-        )
 
-    def test_to_dict_index_not_unique_with_index_orient(self):
-        # GH22801
-        # Data loss when indexes are not unique. Raise ValueError.
-        df = DataFrame({"a": [1, 2], "b": [0.5, 0.75]}, index=["A", "A"])
-        msg = "DataFrame index must be unique for orient='index'"
-        with pytest.raises(ValueError, match=msg):
-            df.to_dict(orient="index")
+from pandas import CategoricalDtype, DataFrame, MultiIndex, Series, date_range
+import pandas._testing as tm
 
-    def test_to_dict_invalid_orient(self):
-        df = DataFrame({"A": [0, 1]})
-        msg = "orient 'xinvalid' not understood"
-        with pytest.raises(ValueError, match=msg):
-            df.to_dict(orient="xinvalid")
 
+class TestDataFrameToRecords:
     def test_to_records_dt64(self):
         df = DataFrame(
             [["one", "two", "three"], ["four", "five", "six"]],
             index=date_range("2012-01-01", "2012-01-02"),
         )
 
-        # convert_datetime64 defaults to None
         expected = df.index.values[0]
         result = df.to_records()["index"][0]
         assert expected == result
 
-        # check for FutureWarning if convert_datetime64=False is passed
-        with tm.assert_produces_warning(FutureWarning):
-            expected = df.index.values[0]
-            result = df.to_records(convert_datetime64=False)["index"][0]
-            assert expected == result
-
-        # check for FutureWarning if convert_datetime64=True is passed
-        with tm.assert_produces_warning(FutureWarning):
-            expected = df.index[0]
-            result = df.to_records(convert_datetime64=True)["index"][0]
-            assert expected == result
-
     def test_to_records_with_multindex(self):
-        # GH3189
+        # GH#3189
         index = [
             ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
             ["one", "two", "one", "two", "one", "two", "one", "two"],
@@ -150,7 +67,7 @@ def test_to_records_index_name(self):
         assert "level_0" in rs.dtype.fields
 
     def test_to_records_with_unicode_index(self):
-        # GH13172
+        # GH#13172
         # unicode_literals conflict with to_records
         result = DataFrame([{"a": "x", "b": "y"}]).set_index("a").to_records()
         expected = np.rec.array([("x", "y")], dtype=[("a", "O"), ("b", "O")])
@@ -158,7 +75,7 @@ def test_to_records_with_unicode_index(self):
 
     def test_to_records_with_unicode_column_names(self):
         # xref issue: https://github.com/numpy/numpy/issues/2407
-        # Issue #11879. to_records used to raise an exception when used
+        # Issue GH#11879. to_records used to raise an exception when used
         # with column names containing non-ascii characters in Python 2
         result = DataFrame(data={"accented_name_é": [1.0]}).to_records()
 
@@ -171,8 +88,7 @@ def test_to_records_with_unicode_column_names(self):
         tm.assert_almost_equal(result, expected)
 
     def test_to_records_with_categorical(self):
-
-        # GH8626
+        # GH#8626
 
         # dict creation
         df = DataFrame({"A": list("abc")}, dtype="category")
@@ -319,12 +235,12 @@ def test_to_records_with_categorical(self):
             # Check that bad types raise
             (
                 dict(index=False, column_dtypes={"A": "int32", "B": "foo"}),
-                (TypeError, 'data type "foo" not understood'),
+                (TypeError, "data type [\"']foo[\"'] not understood"),
             ),
         ],
     )
     def test_to_records_dtype(self, kwargs, expected):
-        # see gh-18146
+        # see GH#18146
         df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
 
         if not isinstance(expected, np.recarray):
@@ -397,12 +313,12 @@ def test_to_records_dtype(self, kwargs, expected):
         ],
     )
     def test_to_records_dtype_mi(self, df, kwargs, expected):
-        # see gh-18146
+        # see GH#18146
         result = df.to_records(**kwargs)
         tm.assert_almost_equal(result, expected)
 
     def test_to_records_dict_like(self):
-        # see gh-18146
+        # see GH#18146
         class DictLike:
             def __init__(self, **kwargs):
                 self.d = kwargs.copy()
@@ -410,7 +326,7 @@ def __init__(self, **kwargs):
             def __getitem__(self, key):
                 return self.d.__getitem__(key)
 
-            def __contains__(self, key):
+            def __contains__(self, key) -> bool:
                 return key in self.d
 
             def keys(self):
@@ -430,81 +346,9 @@ def keys(self):
         )
         tm.assert_almost_equal(result, expected)
 
-    @pytest.mark.parametrize("mapping", [dict, defaultdict(list), OrderedDict])
-    def test_to_dict(self, mapping):
-        test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
-
-        # GH16122
-        recons_data = DataFrame(test_data).to_dict(into=mapping)
-
-        for k, v in test_data.items():
-            for k2, v2 in v.items():
-                assert v2 == recons_data[k][k2]
-
-        recons_data = DataFrame(test_data).to_dict("l", mapping)
-
-        for k, v in test_data.items():
-            for k2, v2 in v.items():
-                assert v2 == recons_data[k][int(k2) - 1]
-
-        recons_data = DataFrame(test_data).to_dict("s", mapping)
-
-        for k, v in test_data.items():
-            for k2, v2 in v.items():
-                assert v2 == recons_data[k][k2]
-
-        recons_data = DataFrame(test_data).to_dict("sp", mapping)
-        expected_split = {
-            "columns": ["A", "B"],
-            "index": ["1", "2", "3"],
-            "data": [[1.0, "1"], [2.0, "2"], [np.nan, "3"]],
-        }
-        tm.assert_dict_equal(recons_data, expected_split)
-
-        recons_data = DataFrame(test_data).to_dict("r", mapping)
-        expected_records = [
-            {"A": 1.0, "B": "1"},
-            {"A": 2.0, "B": "2"},
-            {"A": np.nan, "B": "3"},
-        ]
-        assert isinstance(recons_data, list)
-        assert len(recons_data) == 3
-        for l, r in zip(recons_data, expected_records):
-            tm.assert_dict_equal(l, r)
-
-        # GH10844
-        recons_data = DataFrame(test_data).to_dict("i")
-
-        for k, v in test_data.items():
-            for k2, v2 in v.items():
-                assert v2 == recons_data[k2][k]
-
-        df = DataFrame(test_data)
-        df["duped"] = df[df.columns[0]]
-        recons_data = df.to_dict("i")
-        comp_data = test_data.copy()
-        comp_data["duped"] = comp_data[df.columns[0]]
-        for k, v in comp_data.items():
-            for k2, v2 in v.items():
-                assert v2 == recons_data[k2][k]
-
-    @pytest.mark.parametrize("mapping", [list, defaultdict, []])
-    def test_to_dict_errors(self, mapping):
-        # GH16122
-        df = DataFrame(np.random.randn(3, 3))
-        with pytest.raises(TypeError):
-            df.to_dict(into=mapping)
-
-    def test_to_dict_not_unique_warning(self):
-        # GH16927: When converting to a dict, if a column has a non-unique name
-        # it will be dropped, throwing a warning.
-        df = DataFrame([[1, 2, 3]], columns=["a", "a", "b"])
-        with tm.assert_produces_warning(UserWarning):
-            df.to_dict()
-
     @pytest.mark.parametrize("tz", ["UTC", "GMT", "US/Eastern"])
     def test_to_records_datetimeindex_with_tz(self, tz):
-        # GH13937
+        # GH#13937
         dr = date_range("2016-01-01", periods=10, freq="S", tz=tz)
 
         df = DataFrame({"datetime": dr}, index=dr)
@@ -514,102 +358,3 @@ def test_to_records_datetimeindex_with_tz(self, tz):
 
         # both converted to UTC, so they are equal
         tm.assert_numpy_array_equal(result, expected)
-
-    # orient - orient argument to to_dict function
-    # item_getter - function for extracting value from
-    # the resulting dict using column name and index
-    @pytest.mark.parametrize(
-        "orient,item_getter",
-        [
-            ("dict", lambda d, col, idx: d[col][idx]),
-            ("records", lambda d, col, idx: d[idx][col]),
-            ("list", lambda d, col, idx: d[col][idx]),
-            ("split", lambda d, col, idx: d["data"][idx][d["columns"].index(col)]),
-            ("index", lambda d, col, idx: d[idx][col]),
-        ],
-    )
-    def test_to_dict_box_scalars(self, orient, item_getter):
-        # 14216, 23753
-        # make sure that we are boxing properly
-        df = DataFrame({"a": [1, 2], "b": [0.1, 0.2]})
-        result = df.to_dict(orient=orient)
-        assert isinstance(item_getter(result, "a", 0), int)
-        assert isinstance(item_getter(result, "b", 0), float)
-
-    def test_frame_to_dict_tz(self):
-        # GH18372 When converting to dict with orient='records' columns of
-        # datetime that are tz-aware were not converted to required arrays
-        data = [
-            (datetime(2017, 11, 18, 21, 53, 0, 219225, tzinfo=pytz.utc),),
-            (datetime(2017, 11, 18, 22, 6, 30, 61810, tzinfo=pytz.utc),),
-        ]
-        df = DataFrame(list(data), columns=["d"])
-
-        result = df.to_dict(orient="records")
-        expected = [
-            {"d": Timestamp("2017-11-18 21:53:00.219225+0000", tz=pytz.utc)},
-            {"d": Timestamp("2017-11-18 22:06:30.061810+0000", tz=pytz.utc)},
-        ]
-        tm.assert_dict_equal(result[0], expected[0])
-        tm.assert_dict_equal(result[1], expected[1])
-
-    @pytest.mark.parametrize(
-        "into, expected",
-        [
-            (
-                dict,
-                {
-                    0: {"int_col": 1, "float_col": 1.0},
-                    1: {"int_col": 2, "float_col": 2.0},
-                    2: {"int_col": 3, "float_col": 3.0},
-                },
-            ),
-            (
-                OrderedDict,
-                OrderedDict(
-                    [
-                        (0, {"int_col": 1, "float_col": 1.0}),
-                        (1, {"int_col": 2, "float_col": 2.0}),
-                        (2, {"int_col": 3, "float_col": 3.0}),
-                    ]
-                ),
-            ),
-            (
-                defaultdict(list),
-                defaultdict(
-                    list,
-                    {
-                        0: {"int_col": 1, "float_col": 1.0},
-                        1: {"int_col": 2, "float_col": 2.0},
-                        2: {"int_col": 3, "float_col": 3.0},
-                    },
-                ),
-            ),
-        ],
-    )
-    def test_to_dict_index_dtypes(self, into, expected):
-        # GH 18580
-        # When using to_dict(orient='index') on a dataframe with int
-        # and float columns only the int columns were cast to float
-
-        df = DataFrame({"int_col": [1, 2, 3], "float_col": [1.0, 2.0, 3.0]})
-
-        result = df.to_dict(orient="index", into=into)
-        cols = ["int_col", "float_col"]
-        result = DataFrame.from_dict(result, orient="index")[cols]
-        expected = DataFrame.from_dict(expected, orient="index")[cols]
-        tm.assert_frame_equal(result, expected)
-
-    def test_to_dict_numeric_names(self):
-        # https://github.com/pandas-dev/pandas/issues/24940
-        df = DataFrame({str(i): [i] for i in range(5)})
-        result = set(df.to_dict("records")[0].keys())
-        expected = set(df.columns)
-        assert result == expected
-
-    def test_to_dict_wide(self):
-        # https://github.com/pandas-dev/pandas/issues/24939
-        df = DataFrame({("A_{:d}".format(i)): [i] for i in range(256)})
-        result = df.to_dict("records")[0]
-        expected = {"A_{:d}".format(i): i for i in range(256)}
-        assert result == expected
diff --git a/pandas/tests/frame/methods/test_transpose.py b/pandas/tests/frame/methods/test_transpose.py
new file mode 100644
index 0000000000000..a5fe5f3a6d5e4
--- /dev/null
+++ b/pandas/tests/frame/methods/test_transpose.py
@@ -0,0 +1,76 @@
+import numpy as np
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestTranspose:
+    def test_transpose_tzaware_1col_single_tz(self):
+        # GH#26825
+        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
+
+        df = pd.DataFrame(dti)
+        assert (df.dtypes == dti.dtype).all()
+        res = df.T
+        assert (res.dtypes == dti.dtype).all()
+
+    def test_transpose_tzaware_2col_single_tz(self):
+        # GH#26825
+        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
+
+        df3 = pd.DataFrame({"A": dti, "B": dti})
+        assert (df3.dtypes == dti.dtype).all()
+        res3 = df3.T
+        assert (res3.dtypes == dti.dtype).all()
+
+    def test_transpose_tzaware_2col_mixed_tz(self):
+        # GH#26825
+        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
+        dti2 = dti.tz_convert("US/Pacific")
+
+        df4 = pd.DataFrame({"A": dti, "B": dti2})
+        assert (df4.dtypes == [dti.dtype, dti2.dtype]).all()
+        assert (df4.T.dtypes == object).all()
+        tm.assert_frame_equal(df4.T.T, df4)
+
+    def test_transpose_object_to_tzaware_mixed_tz(self):
+        # GH#26825
+        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
+        dti2 = dti.tz_convert("US/Pacific")
+
+        # mixed all-tzaware dtypes
+        df2 = pd.DataFrame([dti, dti2])
+        assert (df2.dtypes == object).all()
+        res2 = df2.T
+        assert (res2.dtypes == [dti.dtype, dti2.dtype]).all()
+
+    def test_transpose_uint64(self, uint64_frame):
+
+        result = uint64_frame.T
+        expected = pd.DataFrame(uint64_frame.values.T)
+        expected.index = ["A", "B"]
+        tm.assert_frame_equal(result, expected)
+
+    def test_transpose_float(self, float_frame):
+        frame = float_frame
+        dft = frame.T
+        for idx, series in dft.items():
+            for col, value in series.items():
+                if np.isnan(value):
+                    assert np.isnan(frame[col][idx])
+                else:
+                    assert value == frame[col][idx]
+
+        # mixed type
+        index, data = tm.getMixedTypeDict()
+        mixed = pd.DataFrame(data, index=index)
+
+        mixed_T = mixed.T
+        for col, s in mixed_T.items():
+            assert s.dtype == np.object_
+
+    def test_transpose_get_view(self, float_frame):
+        dft = float_frame.T
+        dft.values[:, 5:10] = 5
+
+        assert (float_frame.values[5:10] == 5).all()
diff --git a/pandas/tests/frame/methods/test_truncate.py b/pandas/tests/frame/methods/test_truncate.py
new file mode 100644
index 0000000000000..ad86ee1266874
--- /dev/null
+++ b/pandas/tests/frame/methods/test_truncate.py
@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestDataFrameTruncate:
+    def test_truncate(self, datetime_frame):
+        ts = datetime_frame[::3]
+
+        start, end = datetime_frame.index[3], datetime_frame.index[6]
+
+        start_missing = datetime_frame.index[2]
+        end_missing = datetime_frame.index[7]
+
+        # neither specified
+        truncated = ts.truncate()
+        tm.assert_frame_equal(truncated, ts)
+
+        # both specified
+        expected = ts[1:3]
+
+        truncated = ts.truncate(start, end)
+        tm.assert_frame_equal(truncated, expected)
+
+        truncated = ts.truncate(start_missing, end_missing)
+        tm.assert_frame_equal(truncated, expected)
+
+        # start specified
+        expected = ts[1:]
+
+        truncated = ts.truncate(before=start)
+        tm.assert_frame_equal(truncated, expected)
+
+        truncated = ts.truncate(before=start_missing)
+        tm.assert_frame_equal(truncated, expected)
+
+        # end specified
+        expected = ts[:3]
+
+        truncated = ts.truncate(after=end)
+        tm.assert_frame_equal(truncated, expected)
+
+        truncated = ts.truncate(after=end_missing)
+        tm.assert_frame_equal(truncated, expected)
+
+        msg = "Truncate: 2000-01-06 00:00:00 must be after 2000-02-04 00:00:00"
+        with pytest.raises(ValueError, match=msg):
+            ts.truncate(
+                before=ts.index[-1] - ts.index.freq, after=ts.index[0] + ts.index.freq
+            )
+
+    def test_truncate_copy(self, datetime_frame):
+        index = datetime_frame.index
+        truncated = datetime_frame.truncate(index[5], index[10])
+        truncated.values[:] = 5.0
+        assert not (datetime_frame.values[5:11] == 5).any()
+
+    def test_truncate_nonsortedindex(self):
+        # GH#17935
+
+        df = pd.DataFrame({"A": ["a", "b", "c", "d", "e"]}, index=[5, 3, 2, 9, 0])
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            df.truncate(before=3, after=9)
+
+        rng = pd.date_range("2011-01-01", "2012-01-01", freq="W")
+        ts = pd.DataFrame(
+            {"A": np.random.randn(len(rng)), "B": np.random.randn(len(rng))}, index=rng
+        )
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values("A", ascending=False).truncate(
+                before="2011-11", after="2011-12"
+            )
+
+        df = pd.DataFrame(
+            {
+                3: np.random.randn(5),
+                20: np.random.randn(5),
+                2: np.random.randn(5),
+                0: np.random.randn(5),
+            },
+            columns=[3, 20, 2, 0],
+        )
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            df.truncate(before=2, after=20, axis=1)
diff --git a/pandas/tests/frame/methods/test_update.py b/pandas/tests/frame/methods/test_update.py
new file mode 100644
index 0000000000000..d9de026dbf4e9
--- /dev/null
+++ b/pandas/tests/frame/methods/test_update.py
@@ -0,0 +1,135 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, date_range
+import pandas._testing as tm
+
+
+class TestDataFrameUpdate:
+    def test_update_nan(self):
+        # #15593 #15617
+        # test 1
+        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
+        df2 = DataFrame({"A": [None, 2, 3]})
+        expected = df1.copy()
+        df1.update(df2, overwrite=False)
+
+        tm.assert_frame_equal(df1, expected)
+
+        # test 2
+        df1 = DataFrame({"A": [1.0, None, 3], "B": date_range("2000", periods=3)})
+        df2 = DataFrame({"A": [None, 2, 3]})
+        expected = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
+        df1.update(df2, overwrite=False)
+
+        tm.assert_frame_equal(df1, expected)
+
+    def test_update(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [3.6, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_dtypes(self):
+
+        # gh 3016
+        df = DataFrame(
+            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+
+        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
+        df.update(other)
+
+        expected = DataFrame(
+            [[45.0, 45.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_nooverwrite(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other, overwrite=False)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [1.5, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 3.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_filtered(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other, filter_func=lambda x: x > 2)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "bad_kwarg, exception, msg",
+        [
+            # errors must be 'ignore' or 'raise'
+            ({"errors": "something"}, ValueError, "The parameter errors must.*"),
+            ({"join": "inner"}, NotImplementedError, "Only left join is supported"),
+        ],
+    )
+    def test_update_raise_bad_parameter(self, bad_kwarg, exception, msg):
+        df = DataFrame([[1.5, 1, 3.0]])
+        with pytest.raises(exception, match=msg):
+            df.update(df, **bad_kwarg)
+
+    def test_update_raise_on_overlap(self):
+        df = DataFrame(
+            [[1.5, 1, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[2.0, np.nan], [np.nan, 7]], index=[1, 3], columns=[1, 2])
+        with pytest.raises(ValueError, match="Data overlaps"):
+            df.update(other, errors="raise")
+
+    def test_update_from_non_df(self):
+        d = {"a": Series([1, 2, 3, 4]), "b": Series([5, 6, 7, 8])}
+        df = DataFrame(d)
+
+        d["a"] = Series([5, 6, 7, 8])
+        df.update(d)
+
+        expected = DataFrame(d)
+
+        tm.assert_frame_equal(df, expected)
+
+        d = {"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]}
+        df = DataFrame(d)
+
+        d["a"] = [5, 6, 7, 8]
+        df.update(d)
+
+        expected = DataFrame(d)
+
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_datetime_tz(self):
+        # GH 25807
+        result = DataFrame([pd.Timestamp("2019", tz="UTC")])
+        result.update(result)
+        expected = DataFrame([pd.Timestamp("2019", tz="UTC")])
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index 00b59fd4dc087..602ea9ca0471a 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -1,3 +1,4 @@
+from collections import ChainMap
 from datetime import datetime, timedelta
 import inspect
 
@@ -24,10 +25,9 @@
     date_range,
     to_datetime,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 class TestDataFrameAlterAxes:
     def test_set_index_directly(self, float_string_frame):
         df = float_string_frame
@@ -341,8 +341,8 @@ def __init__(self, name, color):
                 self.name = name
                 self.color = color
 
-            def __str__(self):
-                return "<Thing {self.name!r}>".format(self=self)
+            def __str__(self) -> str:
+                return f"<Thing {repr(self.name)}>"
 
             # necessary for pretty KeyError
             __repr__ = __str__
@@ -380,8 +380,8 @@ def test_set_index_custom_label_hashable_iterable(self):
 
         class Thing(frozenset):
             # need to stabilize repr for KeyError (due to random order in sets)
-            def __repr__(self):
-                tmp = sorted(list(self))
+            def __repr__(self) -> str:
+                tmp = sorted(self)
                 # double curly brace prints one brace in format string
                 return "frozenset({{{}}})".format(", ".join(map(repr, tmp)))
 
@@ -418,8 +418,8 @@ def __init__(self, name, color):
                 self.name = name
                 self.color = color
 
-            def __str__(self):
-                return "<Thing {self.name!r}>".format(self=self)
+            def __str__(self) -> str:
+                return f"<Thing {repr(self.name)}>"
 
         thing1 = Thing("One", "red")
         thing2 = Thing("Two", "blue")
@@ -493,29 +493,29 @@ def test_convert_dti_to_series(self):
         tm.assert_series_equal(result, expected)
 
         # convert to series while keeping the timezone
-        result = idx.to_series(keep_tz=True, index=[0, 1])
+        msg = "stop passing 'keep_tz'"
+        with tm.assert_produces_warning(FutureWarning) as m:
+            result = idx.to_series(keep_tz=True, index=[0, 1])
         tm.assert_series_equal(result, expected)
+        assert msg in str(m[0].message)
 
         # convert to utc
-        with tm.assert_produces_warning(FutureWarning):
+        with tm.assert_produces_warning(FutureWarning) as m:
             df["B"] = idx.to_series(keep_tz=False, index=[0, 1])
         result = df["B"]
         comp = Series(DatetimeIndex(expected.values).tz_localize(None), name="B")
         tm.assert_series_equal(result, comp)
-
-        with tm.assert_produces_warning(FutureWarning) as m:
-            result = idx.to_series(index=[0, 1])
-        tm.assert_series_equal(result, expected.dt.tz_convert(None))
-        msg = (
-            "The default of the 'keep_tz' keyword in "
-            "DatetimeIndex.to_series will change to True in a future "
-            "release."
-        )
+        msg = "do 'idx.tz_convert(None)' before calling"
         assert msg in str(m[0].message)
 
-        with tm.assert_produces_warning(FutureWarning):
+        result = idx.to_series(index=[0, 1])
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning) as m:
             result = idx.to_series(keep_tz=False, index=[0, 1])
         tm.assert_series_equal(result, expected.dt.tz_convert(None))
+        msg = "do 'idx.tz_convert(None)' before calling"
+        assert msg in str(m[0].message)
 
         # list of datetimes with a tz
         df["B"] = idx.to_pydatetime()
@@ -692,6 +692,24 @@ def test_rename(self, float_frame):
         tm.assert_index_equal(renamed.index, Index(["bar", "foo"], name="name"))
         assert renamed.index.name == renamer.index.name
 
+    @pytest.mark.parametrize(
+        "args,kwargs",
+        [
+            ((ChainMap({"A": "a"}, {"B": "b"}),), dict(axis="columns")),
+            ((), dict(columns=ChainMap({"A": "a"}, {"B": "b"}))),
+        ],
+    )
+    def test_rename_chainmap(self, args, kwargs):
+        # see gh-23859
+        colAData = range(1, 11)
+        colBdata = np.random.randn(10)
+
+        df = DataFrame({"A": colAData, "B": colBdata})
+        result = df.rename(*args, **kwargs)
+
+        expected = DataFrame({"a": colAData, "b": colBdata})
+        tm.assert_frame_equal(result, expected)
+
     def test_rename_axis_inplace(self, float_frame):
         # GH 15704
         expected = float_frame.rename_axis("foo")
@@ -727,8 +745,7 @@ def test_rename_axis_mapper(self):
         # GH 19978
         mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
         df = DataFrame(
-            {"x": [i for i in range(len(mi))], "y": [i * 10 for i in range(len(mi))]},
-            index=mi,
+            {"x": list(range(len(mi))), "y": [i * 10 for i in range(len(mi))]}, index=mi
         )
 
         # Test for rename of the Index object of columns
@@ -1295,7 +1312,7 @@ def test_rename_mapper_multi(self):
     def test_rename_positional_named(self):
         # https://github.com/pandas-dev/pandas/issues/12392
         df = DataFrame({"a": [1, 2], "b": [1, 2]}, index=["X", "Y"])
-        result = df.rename(str.lower, columns=str.upper)
+        result = df.rename(index=str.lower, columns=str.upper)
         expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["x", "y"])
         tm.assert_frame_equal(result, expected)
 
@@ -1319,12 +1336,12 @@ def test_rename_axis_style_raises(self):
 
         # Multiple targets and axis
         with pytest.raises(TypeError, match=over_spec_msg):
-            df.rename(str.lower, str.lower, axis="columns")
+            df.rename(str.lower, index=str.lower, axis="columns")
 
         # Too many targets
-        over_spec_msg = "Cannot specify all of 'mapper', 'index', 'columns'."
+        over_spec_msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
         with pytest.raises(TypeError, match=over_spec_msg):
-            df.rename(str.lower, str.lower, str.lower)
+            df.rename(str.lower, index=str.lower, columns=str.lower)
 
         # Duplicates
         with pytest.raises(TypeError, match="multiple values"):
@@ -1358,16 +1375,42 @@ def test_reindex_api_equivalence(self):
         for res in [res2, res3]:
             tm.assert_frame_equal(res1, res)
 
-    def test_rename_positional(self):
+    def test_rename_positional_raises(self):
+        # GH 29136
         df = DataFrame(columns=["A", "B"])
-        with tm.assert_produces_warning(FutureWarning) as rec:
-            result = df.rename(None, str.lower)
-        expected = DataFrame(columns=["a", "b"])
-        tm.assert_frame_equal(result, expected)
-        assert len(rec) == 1
-        message = str(rec[0].message)
-        assert "rename" in message
-        assert "Use named arguments" in message
+        msg = r"rename\(\) takes from 1 to 2 positional arguments"
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, str.lower)
+
+    def test_rename_no_mappings_raises(self):
+        # GH 29136
+        df = DataFrame([[1]])
+        msg = "must pass an index to rename"
+        with pytest.raises(TypeError, match=msg):
+            df.rename()
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, index=None)
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, columns=None)
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, columns=None, index=None)
+
+    def test_rename_mapper_and_positional_arguments_raises(self):
+        # GH 29136
+        df = DataFrame([[1]])
+        msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, index={})
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, columns={})
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, columns={}, index={})
 
     def test_assign_columns(self, float_frame):
         float_frame["hi"] = "there"
@@ -1392,14 +1435,6 @@ def test_set_index_preserve_categorical_dtype(self):
             result = result.reindex(columns=df.columns)
             tm.assert_frame_equal(result, df)
 
-    def test_ambiguous_warns(self):
-        df = DataFrame({"A": [1, 2]})
-        with tm.assert_produces_warning(FutureWarning):
-            df.rename(id, id)
-
-        with tm.assert_produces_warning(FutureWarning):
-            df.rename({0: 10}, {"A": "B"})
-
     def test_rename_signature(self):
         sig = inspect.signature(DataFrame.rename)
         parameters = set(sig.parameters)
@@ -1452,7 +1487,6 @@ def test_droplevel(self):
         tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 class TestIntervalIndex:
     def test_setitem(self):
 
@@ -1532,21 +1566,3 @@ def test_set_axis_inplace(self):
         for axis in 3, "foo":
             with pytest.raises(ValueError, match="No axis named"):
                 df.set_axis(list("abc"), axis=axis)
-
-    def test_set_axis_prior_to_deprecation_signature(self):
-        df = DataFrame(
-            {"A": [1.1, 2.2, 3.3], "B": [5.0, 6.1, 7.2], "C": [4.4, 5.5, 6.6]},
-            index=[2010, 2011, 2012],
-        )
-
-        expected = {0: df.copy(), 1: df.copy()}
-        expected[0].index = list("abc")
-        expected[1].columns = list("abc")
-        expected["index"] = expected[0]
-        expected["columns"] = expected[1]
-
-        # old signature
-        for axis in expected:
-            with tm.assert_produces_warning(FutureWarning):
-                result = df.set_axis(axis, list("abc"), inplace=False)
-            tm.assert_frame_equal(result, expected[axis])
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index e99208ac78e15..25b2997eb088f 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -1,7 +1,6 @@
 from datetime import timedelta
+from decimal import Decimal
 import operator
-from string import ascii_lowercase
-import warnings
 
 import numpy as np
 import pytest
@@ -21,9 +20,9 @@
     to_datetime,
     to_timedelta,
 )
+import pandas._testing as tm
 import pandas.core.algorithms as algorithms
 import pandas.core.nanops as nanops
-import pandas.util.testing as tm
 
 
 def assert_stat_op_calc(
@@ -259,606 +258,6 @@ def assert_bool_op_api(
 
 class TestDataFrameAnalytics:
 
-    # ---------------------------------------------------------------------
-    # Correlation and covariance
-
-    @td.skip_if_no_scipy
-    def test_corr_pearson(self, float_frame):
-        float_frame["A"][:5] = np.nan
-        float_frame["B"][5:10] = np.nan
-
-        self._check_method(float_frame, "pearson")
-
-    @td.skip_if_no_scipy
-    def test_corr_kendall(self, float_frame):
-        float_frame["A"][:5] = np.nan
-        float_frame["B"][5:10] = np.nan
-
-        self._check_method(float_frame, "kendall")
-
-    @td.skip_if_no_scipy
-    def test_corr_spearman(self, float_frame):
-        float_frame["A"][:5] = np.nan
-        float_frame["B"][5:10] = np.nan
-
-        self._check_method(float_frame, "spearman")
-
-    def _check_method(self, frame, method="pearson"):
-        correls = frame.corr(method=method)
-        expected = frame["A"].corr(frame["C"], method=method)
-        tm.assert_almost_equal(correls["A"]["C"], expected)
-
-    @td.skip_if_no_scipy
-    def test_corr_non_numeric(self, float_frame, float_string_frame):
-        float_frame["A"][:5] = np.nan
-        float_frame["B"][5:10] = np.nan
-
-        # exclude non-numeric types
-        result = float_string_frame.corr()
-        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].corr()
-        tm.assert_frame_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
-    def test_corr_nooverlap(self, meth):
-        # nothing in common
-        df = DataFrame(
-            {
-                "A": [1, 1.5, 1, np.nan, np.nan, np.nan],
-                "B": [np.nan, np.nan, np.nan, 1, 1.5, 1],
-                "C": [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
-            }
-        )
-        rs = df.corr(meth)
-        assert isna(rs.loc["A", "B"])
-        assert isna(rs.loc["B", "A"])
-        assert rs.loc["A", "A"] == 1
-        assert rs.loc["B", "B"] == 1
-        assert isna(rs.loc["C", "C"])
-
-    @td.skip_if_no_scipy
-    @pytest.mark.parametrize("meth", ["pearson", "spearman"])
-    def test_corr_constant(self, meth):
-        # constant --> all NA
-
-        df = DataFrame(
-            {
-                "A": [1, 1, 1, np.nan, np.nan, np.nan],
-                "B": [np.nan, np.nan, np.nan, 1, 1, 1],
-            }
-        )
-        rs = df.corr(meth)
-        assert isna(rs.values).all()
-
-    def test_corr_int(self):
-        # dtypes other than float64 #1761
-        df3 = DataFrame({"a": [1, 2, 3, 4], "b": [1, 2, 3, 4]})
-
-        df3.cov()
-        df3.corr()
-
-    @td.skip_if_no_scipy
-    def test_corr_int_and_boolean(self):
-        # when dtypes of pandas series are different
-        # then ndarray will have dtype=object,
-        # so it need to be properly handled
-        df = DataFrame({"a": [True, False], "b": [1, 0]})
-
-        expected = DataFrame(np.ones((2, 2)), index=["a", "b"], columns=["a", "b"])
-        for meth in ["pearson", "kendall", "spearman"]:
-
-            with warnings.catch_warnings(record=True):
-                warnings.simplefilter("ignore", RuntimeWarning)
-                result = df.corr(meth)
-            tm.assert_frame_equal(result, expected)
-
-    def test_corr_cov_independent_index_column(self):
-        # GH 14617
-        df = pd.DataFrame(np.random.randn(4 * 10).reshape(10, 4), columns=list("abcd"))
-        for method in ["cov", "corr"]:
-            result = getattr(df, method)()
-            assert result.index is not result.columns
-            assert result.index.equals(result.columns)
-
-    def test_corr_invalid_method(self):
-        # GH 22298
-        df = pd.DataFrame(np.random.normal(size=(10, 2)))
-        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
-        with pytest.raises(ValueError, match=msg):
-            df.corr(method="____")
-
-    def test_cov(self, float_frame, float_string_frame):
-        # min_periods no NAs (corner case)
-        expected = float_frame.cov()
-        result = float_frame.cov(min_periods=len(float_frame))
-
-        tm.assert_frame_equal(expected, result)
-
-        result = float_frame.cov(min_periods=len(float_frame) + 1)
-        assert isna(result.values).all()
-
-        # with NAs
-        frame = float_frame.copy()
-        frame["A"][:5] = np.nan
-        frame["B"][5:10] = np.nan
-        result = float_frame.cov(min_periods=len(float_frame) - 8)
-        expected = float_frame.cov()
-        expected.loc["A", "B"] = np.nan
-        expected.loc["B", "A"] = np.nan
-
-        # regular
-        float_frame["A"][:5] = np.nan
-        float_frame["B"][:10] = np.nan
-        cov = float_frame.cov()
-
-        tm.assert_almost_equal(cov["A"]["C"], float_frame["A"].cov(float_frame["C"]))
-
-        # exclude non-numeric types
-        result = float_string_frame.cov()
-        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].cov()
-        tm.assert_frame_equal(result, expected)
-
-        # Single column frame
-        df = DataFrame(np.linspace(0.0, 1.0, 10))
-        result = df.cov()
-        expected = DataFrame(
-            np.cov(df.values.T).reshape((1, 1)), index=df.columns, columns=df.columns
-        )
-        tm.assert_frame_equal(result, expected)
-        df.loc[0] = np.nan
-        result = df.cov()
-        expected = DataFrame(
-            np.cov(df.values[1:].T).reshape((1, 1)),
-            index=df.columns,
-            columns=df.columns,
-        )
-        tm.assert_frame_equal(result, expected)
-
-    def test_corrwith(self, datetime_frame):
-        a = datetime_frame
-        noise = Series(np.random.randn(len(a)), index=a.index)
-
-        b = datetime_frame.add(noise, axis=0)
-
-        # make sure order does not matter
-        b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:])
-        del b["B"]
-
-        colcorr = a.corrwith(b, axis=0)
-        tm.assert_almost_equal(colcorr["A"], a["A"].corr(b["A"]))
-
-        rowcorr = a.corrwith(b, axis=1)
-        tm.assert_series_equal(rowcorr, a.T.corrwith(b.T, axis=0))
-
-        dropped = a.corrwith(b, axis=0, drop=True)
-        tm.assert_almost_equal(dropped["A"], a["A"].corr(b["A"]))
-        assert "B" not in dropped
-
-        dropped = a.corrwith(b, axis=1, drop=True)
-        assert a.index[-1] not in dropped.index
-
-        # non time-series data
-        index = ["a", "b", "c", "d", "e"]
-        columns = ["one", "two", "three", "four"]
-        df1 = DataFrame(np.random.randn(5, 4), index=index, columns=columns)
-        df2 = DataFrame(np.random.randn(4, 4), index=index[:4], columns=columns)
-        correls = df1.corrwith(df2, axis=1)
-        for row in index[:4]:
-            tm.assert_almost_equal(correls[row], df1.loc[row].corr(df2.loc[row]))
-
-    def test_corrwith_with_objects(self):
-        df1 = tm.makeTimeDataFrame()
-        df2 = tm.makeTimeDataFrame()
-        cols = ["A", "B", "C", "D"]
-
-        df1["obj"] = "foo"
-        df2["obj"] = "bar"
-
-        result = df1.corrwith(df2)
-        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols])
-        tm.assert_series_equal(result, expected)
-
-        result = df1.corrwith(df2, axis=1)
-        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols], axis=1)
-        tm.assert_series_equal(result, expected)
-
-    def test_corrwith_series(self, datetime_frame):
-        result = datetime_frame.corrwith(datetime_frame["A"])
-        expected = datetime_frame.apply(datetime_frame["A"].corr)
-
-        tm.assert_series_equal(result, expected)
-
-    def test_corrwith_matches_corrcoef(self):
-        df1 = DataFrame(np.arange(10000), columns=["a"])
-        df2 = DataFrame(np.arange(10000) ** 2, columns=["a"])
-        c1 = df1.corrwith(df2)["a"]
-        c2 = np.corrcoef(df1["a"], df2["a"])[0][1]
-
-        tm.assert_almost_equal(c1, c2)
-        assert c1 < 1
-
-    def test_corrwith_mixed_dtypes(self):
-        # GH 18570
-        df = pd.DataFrame(
-            {"a": [1, 4, 3, 2], "b": [4, 6, 7, 3], "c": ["a", "b", "c", "d"]}
-        )
-        s = pd.Series([0, 6, 7, 3])
-        result = df.corrwith(s)
-        corrs = [df["a"].corr(s), df["b"].corr(s)]
-        expected = pd.Series(data=corrs, index=["a", "b"])
-        tm.assert_series_equal(result, expected)
-
-    def test_corrwith_index_intersection(self):
-        df1 = pd.DataFrame(np.random.random(size=(10, 2)), columns=["a", "b"])
-        df2 = pd.DataFrame(np.random.random(size=(10, 3)), columns=["a", "b", "c"])
-
-        result = df1.corrwith(df2, drop=True).index.sort_values()
-        expected = df1.columns.intersection(df2.columns).sort_values()
-        tm.assert_index_equal(result, expected)
-
-    def test_corrwith_index_union(self):
-        df1 = pd.DataFrame(np.random.random(size=(10, 2)), columns=["a", "b"])
-        df2 = pd.DataFrame(np.random.random(size=(10, 3)), columns=["a", "b", "c"])
-
-        result = df1.corrwith(df2, drop=False).index.sort_values()
-        expected = df1.columns.union(df2.columns).sort_values()
-        tm.assert_index_equal(result, expected)
-
-    def test_corrwith_dup_cols(self):
-        # GH 21925
-        df1 = pd.DataFrame(np.vstack([np.arange(10)] * 3).T)
-        df2 = df1.copy()
-        df2 = pd.concat((df2, df2[0]), axis=1)
-
-        result = df1.corrwith(df2)
-        expected = pd.Series(np.ones(4), index=[0, 0, 1, 2])
-        tm.assert_series_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    def test_corrwith_spearman(self):
-        # GH 21925
-        df = pd.DataFrame(np.random.random(size=(100, 3)))
-        result = df.corrwith(df ** 2, method="spearman")
-        expected = Series(np.ones(len(result)))
-        tm.assert_series_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    def test_corrwith_kendall(self):
-        # GH 21925
-        df = pd.DataFrame(np.random.random(size=(100, 3)))
-        result = df.corrwith(df ** 2, method="kendall")
-        expected = Series(np.ones(len(result)))
-        tm.assert_series_equal(result, expected)
-
-    # ---------------------------------------------------------------------
-    # Describe
-
-    def test_bool_describe_in_mixed_frame(self):
-        df = DataFrame(
-            {
-                "string_data": ["a", "b", "c", "d", "e"],
-                "bool_data": [True, True, False, False, False],
-                "int_data": [10, 20, 30, 40, 50],
-            }
-        )
-
-        # Integer data are included in .describe() output,
-        # Boolean and string data are not.
-        result = df.describe()
-        expected = DataFrame(
-            {"int_data": [5, 30, df.int_data.std(), 10, 20, 30, 40, 50]},
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-        )
-        tm.assert_frame_equal(result, expected)
-
-        # Top value is a boolean value that is False
-        result = df.describe(include=["bool"])
-
-        expected = DataFrame(
-            {"bool_data": [5, 2, False, 3]}, index=["count", "unique", "top", "freq"]
-        )
-        tm.assert_frame_equal(result, expected)
-
-    def test_describe_empty_object(self):
-        # https://github.com/pandas-dev/pandas/issues/27183
-        df = pd.DataFrame({"A": [None, None]}, dtype=object)
-        result = df.describe()
-        expected = pd.DataFrame(
-            {"A": [0, 0, np.nan, np.nan]},
-            dtype=object,
-            index=["count", "unique", "top", "freq"],
-        )
-        tm.assert_frame_equal(result, expected)
-
-        result = df.iloc[:0].describe()
-        tm.assert_frame_equal(result, expected)
-
-    def test_describe_bool_frame(self):
-        # GH 13891
-        df = pd.DataFrame(
-            {
-                "bool_data_1": [False, False, True, True],
-                "bool_data_2": [False, True, True, True],
-            }
-        )
-        result = df.describe()
-        expected = DataFrame(
-            {"bool_data_1": [4, 2, True, 2], "bool_data_2": [4, 2, True, 3]},
-            index=["count", "unique", "top", "freq"],
-        )
-        tm.assert_frame_equal(result, expected)
-
-        df = pd.DataFrame(
-            {
-                "bool_data": [False, False, True, True, False],
-                "int_data": [0, 1, 2, 3, 4],
-            }
-        )
-        result = df.describe()
-        expected = DataFrame(
-            {"int_data": [5, 2, df.int_data.std(), 0, 1, 2, 3, 4]},
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-        )
-        tm.assert_frame_equal(result, expected)
-
-        df = pd.DataFrame(
-            {"bool_data": [False, False, True, True], "str_data": ["a", "b", "c", "a"]}
-        )
-        result = df.describe()
-        expected = DataFrame(
-            {"bool_data": [4, 2, True, 2], "str_data": [4, 3, "a", 2]},
-            index=["count", "unique", "top", "freq"],
-        )
-        tm.assert_frame_equal(result, expected)
-
-    def test_describe_categorical(self):
-        df = DataFrame({"value": np.random.randint(0, 10000, 100)})
-        labels = ["{0} - {1}".format(i, i + 499) for i in range(0, 10000, 500)]
-        cat_labels = Categorical(labels, labels)
-
-        df = df.sort_values(by=["value"], ascending=True)
-        df["value_group"] = pd.cut(
-            df.value, range(0, 10500, 500), right=False, labels=cat_labels
-        )
-        cat = df
-
-        # Categoricals should not show up together with numerical columns
-        result = cat.describe()
-        assert len(result.columns) == 1
-
-        # In a frame, describe() for the cat should be the same as for string
-        # arrays (count, unique, top, freq)
-
-        cat = Categorical(
-            ["a", "b", "b", "b"], categories=["a", "b", "c"], ordered=True
-        )
-        s = Series(cat)
-        result = s.describe()
-        expected = Series([4, 2, "b", 3], index=["count", "unique", "top", "freq"])
-        tm.assert_series_equal(result, expected)
-
-        cat = Series(Categorical(["a", "b", "c", "c"]))
-        df3 = DataFrame({"cat": cat, "s": ["a", "b", "c", "c"]})
-        result = df3.describe()
-        tm.assert_numpy_array_equal(result["cat"].values, result["s"].values)
-
-    def test_describe_empty_categorical_column(self):
-        # GH 26397
-        # Ensure the index of an an empty categorical DataFrame column
-        # also contains (count, unique, top, freq)
-        df = pd.DataFrame({"empty_col": Categorical([])})
-        result = df.describe()
-        expected = DataFrame(
-            {"empty_col": [0, 0, np.nan, np.nan]},
-            index=["count", "unique", "top", "freq"],
-            dtype="object",
-        )
-        tm.assert_frame_equal(result, expected)
-        # ensure NaN, not None
-        assert np.isnan(result.iloc[2, 0])
-        assert np.isnan(result.iloc[3, 0])
-
-    def test_describe_categorical_columns(self):
-        # GH 11558
-        columns = pd.CategoricalIndex(["int1", "int2", "obj"], ordered=True, name="XXX")
-        df = DataFrame(
-            {
-                "int1": [10, 20, 30, 40, 50],
-                "int2": [10, 20, 30, 40, 50],
-                "obj": ["A", 0, None, "X", 1],
-            },
-            columns=columns,
-        )
-        result = df.describe()
-
-        exp_columns = pd.CategoricalIndex(
-            ["int1", "int2"],
-            categories=["int1", "int2", "obj"],
-            ordered=True,
-            name="XXX",
-        )
-        expected = DataFrame(
-            {
-                "int1": [5, 30, df.int1.std(), 10, 20, 30, 40, 50],
-                "int2": [5, 30, df.int2.std(), 10, 20, 30, 40, 50],
-            },
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-            columns=exp_columns,
-        )
-
-        tm.assert_frame_equal(result, expected)
-        tm.assert_categorical_equal(result.columns.values, expected.columns.values)
-
-    def test_describe_datetime_columns(self):
-        columns = pd.DatetimeIndex(
-            ["2011-01-01", "2011-02-01", "2011-03-01"],
-            freq="MS",
-            tz="US/Eastern",
-            name="XXX",
-        )
-        df = DataFrame(
-            {
-                0: [10, 20, 30, 40, 50],
-                1: [10, 20, 30, 40, 50],
-                2: ["A", 0, None, "X", 1],
-            }
-        )
-        df.columns = columns
-        result = df.describe()
-
-        exp_columns = pd.DatetimeIndex(
-            ["2011-01-01", "2011-02-01"], freq="MS", tz="US/Eastern", name="XXX"
-        )
-        expected = DataFrame(
-            {
-                0: [5, 30, df.iloc[:, 0].std(), 10, 20, 30, 40, 50],
-                1: [5, 30, df.iloc[:, 1].std(), 10, 20, 30, 40, 50],
-            },
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-        )
-        expected.columns = exp_columns
-        tm.assert_frame_equal(result, expected)
-        assert result.columns.freq == "MS"
-        assert result.columns.tz == expected.columns.tz
-
-    def test_describe_timedelta_values(self):
-        # GH 6145
-        t1 = pd.timedelta_range("1 days", freq="D", periods=5)
-        t2 = pd.timedelta_range("1 hours", freq="H", periods=5)
-        df = pd.DataFrame({"t1": t1, "t2": t2})
-
-        expected = DataFrame(
-            {
-                "t1": [
-                    5,
-                    pd.Timedelta("3 days"),
-                    df.iloc[:, 0].std(),
-                    pd.Timedelta("1 days"),
-                    pd.Timedelta("2 days"),
-                    pd.Timedelta("3 days"),
-                    pd.Timedelta("4 days"),
-                    pd.Timedelta("5 days"),
-                ],
-                "t2": [
-                    5,
-                    pd.Timedelta("3 hours"),
-                    df.iloc[:, 1].std(),
-                    pd.Timedelta("1 hours"),
-                    pd.Timedelta("2 hours"),
-                    pd.Timedelta("3 hours"),
-                    pd.Timedelta("4 hours"),
-                    pd.Timedelta("5 hours"),
-                ],
-            },
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-        )
-
-        result = df.describe()
-        tm.assert_frame_equal(result, expected)
-
-        exp_repr = (
-            "                           t1                      t2\n"
-            "count                       5                       5\n"
-            "mean          3 days 00:00:00         0 days 03:00:00\n"
-            "std    1 days 13:56:50.394919  0 days 01:34:52.099788\n"
-            "min           1 days 00:00:00         0 days 01:00:00\n"
-            "25%           2 days 00:00:00         0 days 02:00:00\n"
-            "50%           3 days 00:00:00         0 days 03:00:00\n"
-            "75%           4 days 00:00:00         0 days 04:00:00\n"
-            "max           5 days 00:00:00         0 days 05:00:00"
-        )
-        assert repr(result) == exp_repr
-
-    def test_describe_tz_values(self, tz_naive_fixture):
-        # GH 21332
-        tz = tz_naive_fixture
-        s1 = Series(range(5))
-        start = Timestamp(2018, 1, 1)
-        end = Timestamp(2018, 1, 5)
-        s2 = Series(date_range(start, end, tz=tz))
-        df = pd.DataFrame({"s1": s1, "s2": s2})
-
-        expected = DataFrame(
-            {
-                "s1": [
-                    5,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    2,
-                    1.581139,
-                    0,
-                    1,
-                    2,
-                    3,
-                    4,
-                ],
-                "s2": [
-                    5,
-                    5,
-                    s2.value_counts().index[0],
-                    1,
-                    start.tz_localize(tz),
-                    end.tz_localize(tz),
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                ],
-            },
-            index=[
-                "count",
-                "unique",
-                "top",
-                "freq",
-                "first",
-                "last",
-                "mean",
-                "std",
-                "min",
-                "25%",
-                "50%",
-                "75%",
-                "max",
-            ],
-        )
-        result = df.describe(include="all")
-        tm.assert_frame_equal(result, expected)
-
-    def test_describe_percentiles_integer_idx(self):
-        # Issue 26660
-        df = pd.DataFrame({"x": [1]})
-        pct = np.linspace(0, 1, 10 + 1)
-        result = df.describe(percentiles=pct)
-
-        expected = DataFrame(
-            {"x": [1.0, 1.0, np.NaN, 1.0, *[1.0 for _ in pct], 1.0]},
-            index=[
-                "count",
-                "mean",
-                "std",
-                "min",
-                "0%",
-                "10%",
-                "20%",
-                "30%",
-                "40%",
-                "50%",
-                "60%",
-                "70%",
-                "80%",
-                "90%",
-                "100%",
-                "max",
-            ],
-        )
-        tm.assert_frame_equal(result, expected)
-
     # ---------------------------------------------------------------------
     # Reductions
 
@@ -1066,13 +465,36 @@ def test_mean_mixed_datetime_numeric(self, tz):
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("tz", [None, "UTC"])
-    def test_mean_excludeds_datetimes(self, tz):
+    def test_mean_excludes_datetimes(self, tz):
         # https://github.com/pandas-dev/pandas/issues/24752
         # Our long-term desired behavior is unclear, but the behavior in
         # 0.24.0rc1 was buggy.
         df = pd.DataFrame({"A": [pd.Timestamp("2000", tz=tz)] * 2})
         result = df.mean()
-        expected = pd.Series()
+        expected = pd.Series(dtype=np.float64)
+        tm.assert_series_equal(result, expected)
+
+    def test_mean_mixed_string_decimal(self):
+        # GH 11670
+        # possible bug when calculating mean of DataFrame?
+
+        d = [
+            {"A": 2, "B": None, "C": Decimal("628.00")},
+            {"A": 1, "B": None, "C": Decimal("383.00")},
+            {"A": 3, "B": None, "C": Decimal("651.00")},
+            {"A": 2, "B": None, "C": Decimal("575.00")},
+            {"A": 4, "B": None, "C": Decimal("1114.00")},
+            {"A": 1, "B": "TEST", "C": Decimal("241.00")},
+            {"A": 2, "B": None, "C": Decimal("572.00")},
+            {"A": 4, "B": None, "C": Decimal("609.00")},
+            {"A": 3, "B": None, "C": Decimal("820.00")},
+            {"A": 5, "B": None, "C": Decimal("1223.00")},
+        ]
+
+        df = pd.DataFrame(d)
+
+        result = df.mean()
+        expected = pd.Series([2.7, 681.6], index=["A", "C"])
         tm.assert_series_equal(result, expected)
 
     def test_var_std(self, datetime_frame):
@@ -1220,7 +642,7 @@ def test_mode_dropna(self, dropna, expected):
             }
         )
 
-        result = df[sorted(list(expected.keys()))].mode(dropna=dropna)
+        result = df[sorted(expected.keys())].mode(dropna=dropna)
         expected = DataFrame(expected)
         tm.assert_frame_equal(result, expected)
 
@@ -1401,6 +823,16 @@ def test_sum_bool(self, float_frame):
         bools.sum(1)
         bools.sum(0)
 
+    def test_sum_mixed_datetime(self):
+        # GH#30886
+        df = pd.DataFrame(
+            {"A": pd.date_range("2000", periods=4), "B": [1, 2, 3, 4]}
+        ).reindex([2, 3, 4])
+        result = df.sum()
+
+        expected = pd.Series({"B": 7.0})
+        tm.assert_series_equal(result, expected)
+
     def test_mean_corner(self, float_frame, float_string_frame):
         # unit test when have object data
         the_mean = float_string_frame.mean(axis=0)
@@ -1471,162 +903,6 @@ def test_sum_bools(self):
         bools = isna(df)
         assert bools.sum(axis=1)[0] == 10
 
-    # ---------------------------------------------------------------------
-    # Cumulative Reductions - cumsum, cummax, ...
-
-    def test_cumsum_corner(self):
-        dm = DataFrame(np.arange(20).reshape(4, 5), index=range(4), columns=range(5))
-        # ?(wesm)
-        result = dm.cumsum()  # noqa
-
-    def test_cumsum(self, datetime_frame):
-        datetime_frame.loc[5:10, 0] = np.nan
-        datetime_frame.loc[10:15, 1] = np.nan
-        datetime_frame.loc[15:, 2] = np.nan
-
-        # axis = 0
-        cumsum = datetime_frame.cumsum()
-        expected = datetime_frame.apply(Series.cumsum)
-        tm.assert_frame_equal(cumsum, expected)
-
-        # axis = 1
-        cumsum = datetime_frame.cumsum(axis=1)
-        expected = datetime_frame.apply(Series.cumsum, axis=1)
-        tm.assert_frame_equal(cumsum, expected)
-
-        # works
-        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
-        result = df.cumsum()  # noqa
-
-        # fix issue
-        cumsum_xs = datetime_frame.cumsum(axis=1)
-        assert np.shape(cumsum_xs) == np.shape(datetime_frame)
-
-    def test_cumprod(self, datetime_frame):
-        datetime_frame.loc[5:10, 0] = np.nan
-        datetime_frame.loc[10:15, 1] = np.nan
-        datetime_frame.loc[15:, 2] = np.nan
-
-        # axis = 0
-        cumprod = datetime_frame.cumprod()
-        expected = datetime_frame.apply(Series.cumprod)
-        tm.assert_frame_equal(cumprod, expected)
-
-        # axis = 1
-        cumprod = datetime_frame.cumprod(axis=1)
-        expected = datetime_frame.apply(Series.cumprod, axis=1)
-        tm.assert_frame_equal(cumprod, expected)
-
-        # fix issue
-        cumprod_xs = datetime_frame.cumprod(axis=1)
-        assert np.shape(cumprod_xs) == np.shape(datetime_frame)
-
-        # ints
-        df = datetime_frame.fillna(0).astype(int)
-        df.cumprod(0)
-        df.cumprod(1)
-
-        # ints32
-        df = datetime_frame.fillna(0).astype(np.int32)
-        df.cumprod(0)
-        df.cumprod(1)
-
-    def test_cummin(self, datetime_frame):
-        datetime_frame.loc[5:10, 0] = np.nan
-        datetime_frame.loc[10:15, 1] = np.nan
-        datetime_frame.loc[15:, 2] = np.nan
-
-        # axis = 0
-        cummin = datetime_frame.cummin()
-        expected = datetime_frame.apply(Series.cummin)
-        tm.assert_frame_equal(cummin, expected)
-
-        # axis = 1
-        cummin = datetime_frame.cummin(axis=1)
-        expected = datetime_frame.apply(Series.cummin, axis=1)
-        tm.assert_frame_equal(cummin, expected)
-
-        # it works
-        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
-        result = df.cummin()  # noqa
-
-        # fix issue
-        cummin_xs = datetime_frame.cummin(axis=1)
-        assert np.shape(cummin_xs) == np.shape(datetime_frame)
-
-    def test_cummax(self, datetime_frame):
-        datetime_frame.loc[5:10, 0] = np.nan
-        datetime_frame.loc[10:15, 1] = np.nan
-        datetime_frame.loc[15:, 2] = np.nan
-
-        # axis = 0
-        cummax = datetime_frame.cummax()
-        expected = datetime_frame.apply(Series.cummax)
-        tm.assert_frame_equal(cummax, expected)
-
-        # axis = 1
-        cummax = datetime_frame.cummax(axis=1)
-        expected = datetime_frame.apply(Series.cummax, axis=1)
-        tm.assert_frame_equal(cummax, expected)
-
-        # it works
-        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
-        result = df.cummax()  # noqa
-
-        # fix issue
-        cummax_xs = datetime_frame.cummax(axis=1)
-        assert np.shape(cummax_xs) == np.shape(datetime_frame)
-
-    # ---------------------------------------------------------------------
-    # Miscellanea
-
-    def test_count(self):
-        # corner case
-        frame = DataFrame()
-        ct1 = frame.count(1)
-        assert isinstance(ct1, Series)
-
-        ct2 = frame.count(0)
-        assert isinstance(ct2, Series)
-
-        # GH#423
-        df = DataFrame(index=range(10))
-        result = df.count(1)
-        expected = Series(0, index=df.index)
-        tm.assert_series_equal(result, expected)
-
-        df = DataFrame(columns=range(10))
-        result = df.count(0)
-        expected = Series(0, index=df.columns)
-        tm.assert_series_equal(result, expected)
-
-        df = DataFrame()
-        result = df.count()
-        expected = Series(0, index=[])
-        tm.assert_series_equal(result, expected)
-
-    def test_count_objects(self, float_string_frame):
-        dm = DataFrame(float_string_frame._series)
-        df = DataFrame(float_string_frame._series)
-
-        tm.assert_series_equal(dm.count(), df.count())
-        tm.assert_series_equal(dm.count(1), df.count(1))
-
-    def test_pct_change(self):
-        # GH#11150
-        pnl = DataFrame(
-            [np.arange(0, 40, 10), np.arange(0, 40, 10), np.arange(0, 40, 10)]
-        ).astype(np.float64)
-        pnl.iat[1, 0] = np.nan
-        pnl.iat[1, 1] = np.nan
-        pnl.iat[2, 3] = 60
-
-        for axis in range(2):
-            expected = pnl.ffill(axis=axis) / pnl.ffill(axis=axis).shift(axis=axis) - 1
-            result = pnl.pct_change(axis=axis, fill_method="pad")
-
-            tm.assert_frame_equal(result, expected)
-
     # ----------------------------------------------------------------------
     # Index of max / min
 
@@ -1864,560 +1140,6 @@ def test_any_all_level_axis_none_raises(self, method):
         with pytest.raises(ValueError, match=xpr):
             getattr(df, method)(axis=None, level="out")
 
-    # ----------------------------------------------------------------------
-    # Isin
-
-    def test_isin(self):
-        # GH 4211
-        df = DataFrame(
-            {
-                "vals": [1, 2, 3, 4],
-                "ids": ["a", "b", "f", "n"],
-                "ids2": ["a", "n", "c", "n"],
-            },
-            index=["foo", "bar", "baz", "qux"],
-        )
-        other = ["a", "b", "c"]
-
-        result = df.isin(other)
-        expected = DataFrame([df.loc[s].isin(other) for s in df.index])
-        tm.assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize("empty", [[], Series(), np.array([])])
-    def test_isin_empty(self, empty):
-        # GH 16991
-        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
-        expected = DataFrame(False, df.index, df.columns)
-
-        result = df.isin(empty)
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_dict(self):
-        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
-        d = {"A": ["a"]}
-
-        expected = DataFrame(False, df.index, df.columns)
-        expected.loc[0, "A"] = True
-
-        result = df.isin(d)
-        tm.assert_frame_equal(result, expected)
-
-        # non unique columns
-        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
-        df.columns = ["A", "A"]
-        expected = DataFrame(False, df.index, df.columns)
-        expected.loc[0, "A"] = True
-        result = df.isin(d)
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_with_string_scalar(self):
-        # GH 4763
-        df = DataFrame(
-            {
-                "vals": [1, 2, 3, 4],
-                "ids": ["a", "b", "f", "n"],
-                "ids2": ["a", "n", "c", "n"],
-            },
-            index=["foo", "bar", "baz", "qux"],
-        )
-        with pytest.raises(TypeError):
-            df.isin("a")
-
-        with pytest.raises(TypeError):
-            df.isin("aaa")
-
-    def test_isin_df(self):
-        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
-        df2 = DataFrame({"A": [0, 2, 12, 4], "B": [2, np.nan, 4, 5]})
-        expected = DataFrame(False, df1.index, df1.columns)
-        result = df1.isin(df2)
-        expected["A"].loc[[1, 3]] = True
-        expected["B"].loc[[0, 2]] = True
-        tm.assert_frame_equal(result, expected)
-
-        # partial overlapping columns
-        df2.columns = ["A", "C"]
-        result = df1.isin(df2)
-        expected["B"] = False
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_tuples(self):
-        # GH 16394
-        df = pd.DataFrame({"A": [1, 2, 3], "B": ["a", "b", "f"]})
-        df["C"] = list(zip(df["A"], df["B"]))
-        result = df["C"].isin([(1, "a")])
-        tm.assert_series_equal(result, Series([True, False, False], name="C"))
-
-    def test_isin_df_dupe_values(self):
-        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
-        # just cols duped
-        df2 = DataFrame([[0, 2], [12, 4], [2, np.nan], [4, 5]], columns=["B", "B"])
-        with pytest.raises(ValueError):
-            df1.isin(df2)
-
-        # just index duped
-        df2 = DataFrame(
-            [[0, 2], [12, 4], [2, np.nan], [4, 5]],
-            columns=["A", "B"],
-            index=[0, 0, 1, 1],
-        )
-        with pytest.raises(ValueError):
-            df1.isin(df2)
-
-        # cols and index:
-        df2.columns = ["B", "B"]
-        with pytest.raises(ValueError):
-            df1.isin(df2)
-
-    def test_isin_dupe_self(self):
-        other = DataFrame({"A": [1, 0, 1, 0], "B": [1, 1, 0, 0]})
-        df = DataFrame([[1, 1], [1, 0], [0, 0]], columns=["A", "A"])
-        result = df.isin(other)
-        expected = DataFrame(False, index=df.index, columns=df.columns)
-        expected.loc[0] = True
-        expected.iloc[1, 1] = True
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_against_series(self):
-        df = pd.DataFrame(
-            {"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]}, index=["a", "b", "c", "d"]
-        )
-        s = pd.Series([1, 3, 11, 4], index=["a", "b", "c", "d"])
-        expected = DataFrame(False, index=df.index, columns=df.columns)
-        expected["A"].loc["a"] = True
-        expected.loc["d"] = True
-        result = df.isin(s)
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_multiIndex(self):
-        idx = MultiIndex.from_tuples(
-            [
-                (0, "a", "foo"),
-                (0, "a", "bar"),
-                (0, "b", "bar"),
-                (0, "b", "baz"),
-                (2, "a", "foo"),
-                (2, "a", "bar"),
-                (2, "c", "bar"),
-                (2, "c", "baz"),
-                (1, "b", "foo"),
-                (1, "b", "bar"),
-                (1, "c", "bar"),
-                (1, "c", "baz"),
-            ]
-        )
-        df1 = DataFrame({"A": np.ones(12), "B": np.zeros(12)}, index=idx)
-        df2 = DataFrame(
-            {
-                "A": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
-                "B": [1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1],
-            }
-        )
-        # against regular index
-        expected = DataFrame(False, index=df1.index, columns=df1.columns)
-        result = df1.isin(df2)
-        tm.assert_frame_equal(result, expected)
-
-        df2.index = idx
-        expected = df2.values.astype(np.bool)
-        expected[:, 1] = ~expected[:, 1]
-        expected = DataFrame(expected, columns=["A", "B"], index=idx)
-
-        result = df1.isin(df2)
-        tm.assert_frame_equal(result, expected)
-
-    def test_isin_empty_datetimelike(self):
-        # GH 15473
-        df1_ts = DataFrame({"date": pd.to_datetime(["2014-01-01", "2014-01-02"])})
-        df1_td = DataFrame({"date": [pd.Timedelta(1, "s"), pd.Timedelta(2, "s")]})
-        df2 = DataFrame({"date": []})
-        df3 = DataFrame()
-
-        expected = DataFrame({"date": [False, False]})
-
-        result = df1_ts.isin(df2)
-        tm.assert_frame_equal(result, expected)
-        result = df1_ts.isin(df3)
-        tm.assert_frame_equal(result, expected)
-
-        result = df1_td.isin(df2)
-        tm.assert_frame_equal(result, expected)
-        result = df1_td.isin(df3)
-        tm.assert_frame_equal(result, expected)
-
-    # ---------------------------------------------------------------------
-    # Rounding
-
-    def test_round(self):
-        # GH 2665
-
-        # Test that rounding an empty DataFrame does nothing
-        df = DataFrame()
-        tm.assert_frame_equal(df, df.round())
-
-        # Here's the test frame we'll be working with
-        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
-
-        # Default round to integer (i.e. decimals=0)
-        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
-        tm.assert_frame_equal(df.round(), expected_rounded)
-
-        # Round with an integer
-        decimals = 2
-        expected_rounded = DataFrame(
-            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
-        )
-        tm.assert_frame_equal(df.round(decimals), expected_rounded)
-
-        # This should also work with np.round (since np.round dispatches to
-        # df.round)
-        tm.assert_frame_equal(np.round(df, decimals), expected_rounded)
-
-        # Round with a list
-        round_list = [1, 2]
-        with pytest.raises(TypeError):
-            df.round(round_list)
-
-        # Round with a dictionary
-        expected_rounded = DataFrame(
-            {"col1": [1.1, 2.1, 3.1], "col2": [1.23, 2.23, 3.23]}
-        )
-        round_dict = {"col1": 1, "col2": 2}
-        tm.assert_frame_equal(df.round(round_dict), expected_rounded)
-
-        # Incomplete dict
-        expected_partially_rounded = DataFrame(
-            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
-        )
-        partial_round_dict = {"col2": 1}
-        tm.assert_frame_equal(df.round(partial_round_dict), expected_partially_rounded)
-
-        # Dict with unknown elements
-        wrong_round_dict = {"col3": 2, "col2": 1}
-        tm.assert_frame_equal(df.round(wrong_round_dict), expected_partially_rounded)
-
-        # float input to `decimals`
-        non_int_round_dict = {"col1": 1, "col2": 0.5}
-        with pytest.raises(TypeError):
-            df.round(non_int_round_dict)
-
-        # String input
-        non_int_round_dict = {"col1": 1, "col2": "foo"}
-        with pytest.raises(TypeError):
-            df.round(non_int_round_dict)
-
-        non_int_round_Series = Series(non_int_round_dict)
-        with pytest.raises(TypeError):
-            df.round(non_int_round_Series)
-
-        # List input
-        non_int_round_dict = {"col1": 1, "col2": [1, 2]}
-        with pytest.raises(TypeError):
-            df.round(non_int_round_dict)
-
-        non_int_round_Series = Series(non_int_round_dict)
-        with pytest.raises(TypeError):
-            df.round(non_int_round_Series)
-
-        # Non integer Series inputs
-        non_int_round_Series = Series(non_int_round_dict)
-        with pytest.raises(TypeError):
-            df.round(non_int_round_Series)
-
-        non_int_round_Series = Series(non_int_round_dict)
-        with pytest.raises(TypeError):
-            df.round(non_int_round_Series)
-
-        # Negative numbers
-        negative_round_dict = {"col1": -1, "col2": -2}
-        big_df = df * 100
-        expected_neg_rounded = DataFrame(
-            {"col1": [110.0, 210, 310], "col2": [100.0, 200, 300]}
-        )
-        tm.assert_frame_equal(big_df.round(negative_round_dict), expected_neg_rounded)
-
-        # nan in Series round
-        nan_round_Series = Series({"col1": np.nan, "col2": 1})
-
-        # TODO(wesm): unused?
-        expected_nan_round = DataFrame(  # noqa
-            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
-        )
-
-        with pytest.raises(TypeError):
-            df.round(nan_round_Series)
-
-        # Make sure this doesn't break existing Series.round
-        tm.assert_series_equal(df["col1"].round(1), expected_rounded["col1"])
-
-        # named columns
-        # GH 11986
-        decimals = 2
-        expected_rounded = DataFrame(
-            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
-        )
-        df.columns.name = "cols"
-        expected_rounded.columns.name = "cols"
-        tm.assert_frame_equal(df.round(decimals), expected_rounded)
-
-        # interaction of named columns & series
-        tm.assert_series_equal(df["col1"].round(decimals), expected_rounded["col1"])
-        tm.assert_series_equal(df.round(decimals)["col1"], expected_rounded["col1"])
-
-    def test_numpy_round(self):
-        # GH 12600
-        df = DataFrame([[1.53, 1.36], [0.06, 7.01]])
-        out = np.round(df, decimals=0)
-        expected = DataFrame([[2.0, 1.0], [0.0, 7.0]])
-        tm.assert_frame_equal(out, expected)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.round(df, decimals=0, out=df)
-
-    def test_numpy_round_nan(self):
-        # See gh-14197
-        df = Series([1.53, np.nan, 0.06]).to_frame()
-        with tm.assert_produces_warning(None):
-            result = df.round()
-        expected = Series([2.0, np.nan, 0.0]).to_frame()
-        tm.assert_frame_equal(result, expected)
-
-    def test_round_mixed_type(self):
-        # GH 11885
-        df = DataFrame(
-            {
-                "col1": [1.1, 2.2, 3.3, 4.4],
-                "col2": ["1", "a", "c", "f"],
-                "col3": date_range("20111111", periods=4),
-            }
-        )
-        round_0 = DataFrame(
-            {
-                "col1": [1.0, 2.0, 3.0, 4.0],
-                "col2": ["1", "a", "c", "f"],
-                "col3": date_range("20111111", periods=4),
-            }
-        )
-        tm.assert_frame_equal(df.round(), round_0)
-        tm.assert_frame_equal(df.round(1), df)
-        tm.assert_frame_equal(df.round({"col1": 1}), df)
-        tm.assert_frame_equal(df.round({"col1": 0}), round_0)
-        tm.assert_frame_equal(df.round({"col1": 0, "col2": 1}), round_0)
-        tm.assert_frame_equal(df.round({"col3": 1}), df)
-
-    def test_round_issue(self):
-        # GH 11611
-
-        df = pd.DataFrame(
-            np.random.random([3, 3]),
-            columns=["A", "B", "C"],
-            index=["first", "second", "third"],
-        )
-
-        dfs = pd.concat((df, df), axis=1)
-        rounded = dfs.round()
-        tm.assert_index_equal(rounded.index, dfs.index)
-
-        decimals = pd.Series([1, 0, 2], index=["A", "B", "A"])
-        msg = "Index of decimals must be unique"
-        with pytest.raises(ValueError, match=msg):
-            df.round(decimals)
-
-    def test_built_in_round(self):
-        # GH 11763
-        # Here's the test frame we'll be working with
-        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
-
-        # Default round to integer (i.e. decimals=0)
-        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
-        tm.assert_frame_equal(round(df), expected_rounded)
-
-    def test_round_nonunique_categorical(self):
-        # See GH21809
-        idx = pd.CategoricalIndex(["low"] * 3 + ["hi"] * 3)
-        df = pd.DataFrame(np.random.rand(6, 3), columns=list("abc"))
-
-        expected = df.round(3)
-        expected.index = idx
-
-        df_categorical = df.copy().set_index(idx)
-        assert df_categorical.shape == (6, 3)
-        result = df_categorical.round(3)
-        assert result.shape == (6, 3)
-
-        tm.assert_frame_equal(result, expected)
-
-    # ---------------------------------------------------------------------
-    # Clip
-
-    def test_clip(self, float_frame):
-        median = float_frame.median().median()
-        original = float_frame.copy()
-
-        with tm.assert_produces_warning(FutureWarning):
-            capped = float_frame.clip_upper(median)
-        assert not (capped.values > median).any()
-
-        with tm.assert_produces_warning(FutureWarning):
-            floored = float_frame.clip_lower(median)
-        assert not (floored.values < median).any()
-
-        double = float_frame.clip(upper=median, lower=median)
-        assert not (double.values != median).any()
-
-        # Verify that float_frame was not changed inplace
-        assert (float_frame.values == original.values).all()
-
-    def test_inplace_clip(self, float_frame):
-        # GH 15388
-        median = float_frame.median().median()
-        frame_copy = float_frame.copy()
-
-        with tm.assert_produces_warning(FutureWarning):
-            frame_copy.clip_upper(median, inplace=True)
-        assert not (frame_copy.values > median).any()
-        frame_copy = float_frame.copy()
-
-        with tm.assert_produces_warning(FutureWarning):
-            frame_copy.clip_lower(median, inplace=True)
-        assert not (frame_copy.values < median).any()
-        frame_copy = float_frame.copy()
-
-        frame_copy.clip(upper=median, lower=median, inplace=True)
-        assert not (frame_copy.values != median).any()
-
-    def test_dataframe_clip(self):
-        # GH 2747
-        df = DataFrame(np.random.randn(1000, 2))
-
-        for lb, ub in [(-1, 1), (1, -1)]:
-            clipped_df = df.clip(lb, ub)
-
-            lb, ub = min(lb, ub), max(ub, lb)
-            lb_mask = df.values <= lb
-            ub_mask = df.values >= ub
-            mask = ~lb_mask & ~ub_mask
-            assert (clipped_df.values[lb_mask] == lb).all()
-            assert (clipped_df.values[ub_mask] == ub).all()
-            assert (clipped_df.values[mask] == df.values[mask]).all()
-
-    def test_clip_mixed_numeric(self):
-        # TODO(jreback)
-        # clip on mixed integer or floats
-        # with integer clippers coerces to float
-        df = DataFrame({"A": [1, 2, 3], "B": [1.0, np.nan, 3.0]})
-        result = df.clip(1, 2)
-        expected = DataFrame({"A": [1, 2, 2], "B": [1.0, np.nan, 2.0]})
-        tm.assert_frame_equal(result, expected, check_like=True)
-
-        # GH 24162, clipping now preserves numeric types per column
-        df = DataFrame([[1, 2, 3.4], [3, 4, 5.6]], columns=["foo", "bar", "baz"])
-        expected = df.dtypes
-        result = df.clip(upper=3).dtypes
-        tm.assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("inplace", [True, False])
-    def test_clip_against_series(self, inplace):
-        # GH 6966
-
-        df = DataFrame(np.random.randn(1000, 2))
-        lb = Series(np.random.randn(1000))
-        ub = lb + 1
-
-        original = df.copy()
-        clipped_df = df.clip(lb, ub, axis=0, inplace=inplace)
-
-        if inplace:
-            clipped_df = df
-
-        for i in range(2):
-            lb_mask = original.iloc[:, i] <= lb
-            ub_mask = original.iloc[:, i] >= ub
-            mask = ~lb_mask & ~ub_mask
-
-            result = clipped_df.loc[lb_mask, i]
-            tm.assert_series_equal(result, lb[lb_mask], check_names=False)
-            assert result.name == i
-
-            result = clipped_df.loc[ub_mask, i]
-            tm.assert_series_equal(result, ub[ub_mask], check_names=False)
-            assert result.name == i
-
-            tm.assert_series_equal(clipped_df.loc[mask, i], df.loc[mask, i])
-
-    @pytest.mark.parametrize("inplace", [True, False])
-    @pytest.mark.parametrize("lower", [[2, 3, 4], np.asarray([2, 3, 4])])
-    @pytest.mark.parametrize(
-        "axis,res",
-        [
-            (0, [[2.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 7.0, 7.0]]),
-            (1, [[2.0, 3.0, 4.0], [4.0, 5.0, 6.0], [5.0, 6.0, 7.0]]),
-        ],
-    )
-    def test_clip_against_list_like(self, simple_frame, inplace, lower, axis, res):
-        # GH 15390
-        original = simple_frame.copy(deep=True)
-
-        result = original.clip(lower=lower, upper=[5, 6, 7], axis=axis, inplace=inplace)
-
-        expected = pd.DataFrame(res, columns=original.columns, index=original.index)
-        if inplace:
-            result = original
-        tm.assert_frame_equal(result, expected, check_exact=True)
-
-    @pytest.mark.parametrize("axis", [0, 1, None])
-    def test_clip_against_frame(self, axis):
-        df = DataFrame(np.random.randn(1000, 2))
-        lb = DataFrame(np.random.randn(1000, 2))
-        ub = lb + 1
-
-        clipped_df = df.clip(lb, ub, axis=axis)
-
-        lb_mask = df <= lb
-        ub_mask = df >= ub
-        mask = ~lb_mask & ~ub_mask
-
-        tm.assert_frame_equal(clipped_df[lb_mask], lb[lb_mask])
-        tm.assert_frame_equal(clipped_df[ub_mask], ub[ub_mask])
-        tm.assert_frame_equal(clipped_df[mask], df[mask])
-
-    def test_clip_against_unordered_columns(self):
-        # GH 20911
-        df1 = DataFrame(np.random.randn(1000, 4), columns=["A", "B", "C", "D"])
-        df2 = DataFrame(np.random.randn(1000, 4), columns=["D", "A", "B", "C"])
-        df3 = DataFrame(df2.values - 1, columns=["B", "D", "C", "A"])
-        result_upper = df1.clip(lower=0, upper=df2)
-        expected_upper = df1.clip(lower=0, upper=df2[df1.columns])
-        result_lower = df1.clip(lower=df3, upper=3)
-        expected_lower = df1.clip(lower=df3[df1.columns], upper=3)
-        result_lower_upper = df1.clip(lower=df3, upper=df2)
-        expected_lower_upper = df1.clip(lower=df3[df1.columns], upper=df2[df1.columns])
-        tm.assert_frame_equal(result_upper, expected_upper)
-        tm.assert_frame_equal(result_lower, expected_lower)
-        tm.assert_frame_equal(result_lower_upper, expected_lower_upper)
-
-    def test_clip_with_na_args(self, float_frame):
-        """Should process np.nan argument as None """
-        # GH 17276
-        tm.assert_frame_equal(float_frame.clip(np.nan), float_frame)
-        tm.assert_frame_equal(float_frame.clip(upper=np.nan, lower=np.nan), float_frame)
-
-        # GH 19992
-        df = DataFrame({"col_0": [1, 2, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]})
-
-        result = df.clip(lower=[4, 5, np.nan], axis=0)
-        expected = DataFrame(
-            {"col_0": [4, 5, np.nan], "col_1": [4, 5, np.nan], "col_2": [7, 8, np.nan]}
-        )
-        tm.assert_frame_equal(result, expected)
-
-        result = df.clip(lower=[4, 5, np.nan], axis=1)
-        expected = DataFrame(
-            {"col_0": [4, 4, 4], "col_1": [5, 5, 6], "col_2": [np.nan, np.nan, np.nan]}
-        )
-        tm.assert_frame_equal(result, expected)
-
     # ---------------------------------------------------------------------
     # Matrix-like
 
@@ -2533,198 +1255,8 @@ def test_matmul(self):
         with pytest.raises(ValueError, match="aligned"):
             operator.matmul(df, df2)
 
-
-@pytest.fixture
-def df_duplicates():
-    return pd.DataFrame(
-        {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
-        index=[0, 0, 1, 1, 1],
-    )
-
-
-@pytest.fixture
-def df_strings():
-    return pd.DataFrame(
-        {
-            "a": np.random.permutation(10),
-            "b": list(ascii_lowercase[:10]),
-            "c": np.random.permutation(10).astype("float64"),
-        }
-    )
-
-
-@pytest.fixture
-def df_main_dtypes():
-    return pd.DataFrame(
-        {
-            "group": [1, 1, 2],
-            "int": [1, 2, 3],
-            "float": [4.0, 5.0, 6.0],
-            "string": list("abc"),
-            "category_string": pd.Series(list("abc")).astype("category"),
-            "category_int": [7, 8, 9],
-            "datetime": pd.date_range("20130101", periods=3),
-            "datetimetz": pd.date_range("20130101", periods=3, tz="US/Eastern"),
-            "timedelta": pd.timedelta_range("1 s", periods=3, freq="s"),
-        },
-        columns=[
-            "group",
-            "int",
-            "float",
-            "string",
-            "category_string",
-            "category_int",
-            "datetime",
-            "datetimetz",
-            "timedelta",
-        ],
-    )
-
-
-class TestNLargestNSmallest:
-
-    dtype_error_msg_template = (
-        "Column {column!r} has dtype {dtype}, cannot "
-        "use method {method!r} with this dtype"
-    )
-
-    # ----------------------------------------------------------------------
-    # Top / bottom
-    @pytest.mark.parametrize(
-        "order",
-        [
-            ["a"],
-            ["c"],
-            ["a", "b"],
-            ["a", "c"],
-            ["b", "a"],
-            ["b", "c"],
-            ["a", "b", "c"],
-            ["c", "a", "b"],
-            ["c", "b", "a"],
-            ["b", "c", "a"],
-            ["b", "a", "c"],
-            # dups!
-            ["b", "c", "c"],
-        ],
-    )
-    @pytest.mark.parametrize("n", range(1, 11))
-    def test_n(self, df_strings, nselect_method, n, order):
-        # GH 10393
-        df = df_strings
-        if "b" in order:
-
-            error_msg = self.dtype_error_msg_template.format(
-                column="b", method=nselect_method, dtype="object"
-            )
-            with pytest.raises(TypeError, match=error_msg):
-                getattr(df, nselect_method)(n, order)
-        else:
-            ascending = nselect_method == "nsmallest"
-            result = getattr(df, nselect_method)(n, order)
-            expected = df.sort_values(order, ascending=ascending).head(n)
-            tm.assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "columns", [["group", "category_string"], ["group", "string"]]
-    )
-    def test_n_error(self, df_main_dtypes, nselect_method, columns):
-        df = df_main_dtypes
-        col = columns[1]
-        error_msg = self.dtype_error_msg_template.format(
-            column=col, method=nselect_method, dtype=df[col].dtype
-        )
-        # escape some characters that may be in the repr
-        error_msg = (
-            error_msg.replace("(", "\\(")
-            .replace(")", "\\)")
-            .replace("[", "\\[")
-            .replace("]", "\\]")
-        )
-        with pytest.raises(TypeError, match=error_msg):
-            getattr(df, nselect_method)(2, columns)
-
-    def test_n_all_dtypes(self, df_main_dtypes):
-        df = df_main_dtypes
-        df.nsmallest(2, list(set(df) - {"category_string", "string"}))
-        df.nlargest(2, list(set(df) - {"category_string", "string"}))
-
-    @pytest.mark.parametrize(
-        "method,expected",
-        [
-            (
-                "nlargest",
-                pd.DataFrame(
-                    {"a": [2, 2, 2, 1], "b": [3, 2, 1, 3]}, index=[2, 1, 0, 3]
-                ),
-            ),
-            (
-                "nsmallest",
-                pd.DataFrame(
-                    {"a": [1, 1, 1, 2], "b": [1, 2, 3, 1]}, index=[5, 4, 3, 0]
-                ),
-            ),
-        ],
-    )
-    def test_duplicates_on_starter_columns(self, method, expected):
-        # regression test for #22752
-
-        df = pd.DataFrame({"a": [2, 2, 2, 1, 1, 1], "b": [1, 2, 3, 3, 2, 1]})
-
-        result = getattr(df, method)(4, columns=["a", "b"])
-        tm.assert_frame_equal(result, expected)
-
-    def test_n_identical_values(self):
-        # GH 15297
-        df = pd.DataFrame({"a": [1] * 5, "b": [1, 2, 3, 4, 5]})
-
-        result = df.nlargest(3, "a")
-        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]}, index=[0, 1, 2])
-        tm.assert_frame_equal(result, expected)
-
-        result = df.nsmallest(3, "a")
-        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]})
-        tm.assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "order",
-        [["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
-    )
-    @pytest.mark.parametrize("n", range(1, 6))
-    def test_n_duplicate_index(self, df_duplicates, n, order):
-        # GH 13412
-
-        df = df_duplicates
-        result = df.nsmallest(n, order)
-        expected = df.sort_values(order).head(n)
-        tm.assert_frame_equal(result, expected)
-
-        result = df.nlargest(n, order)
-        expected = df.sort_values(order, ascending=False).head(n)
-        tm.assert_frame_equal(result, expected)
-
-    def test_duplicate_keep_all_ties(self):
-        # GH 16818
-        df = pd.DataFrame(
-            {"a": [5, 4, 4, 2, 3, 3, 3, 3], "b": [10, 9, 8, 7, 5, 50, 10, 20]}
-        )
-        result = df.nlargest(4, "a", keep="all")
-        expected = pd.DataFrame(
-            {
-                "a": {0: 5, 1: 4, 2: 4, 4: 3, 5: 3, 6: 3, 7: 3},
-                "b": {0: 10, 1: 9, 2: 8, 4: 5, 5: 50, 6: 10, 7: 20},
-            }
-        )
-        tm.assert_frame_equal(result, expected)
-
-        result = df.nsmallest(2, "a", keep="all")
-        expected = pd.DataFrame(
-            {
-                "a": {3: 2, 4: 3, 5: 3, 6: 3, 7: 3},
-                "b": {3: 7, 4: 5, 5: 50, 6: 10, 7: 20},
-            }
-        )
-        tm.assert_frame_equal(result, expected)
+    # ---------------------------------------------------------------------
+    # Unsorted
 
     def test_series_broadcasting(self):
         # smoke test for numpy warnings
@@ -2735,34 +1267,6 @@ def test_series_broadcasting(self):
         s_nan = Series([np.nan, np.nan, 1])
 
         with tm.assert_produces_warning(None):
-            with tm.assert_produces_warning(FutureWarning):
-                df_nan.clip_lower(s, axis=0)
+            df_nan.clip(lower=s, axis=0)
             for op in ["lt", "le", "gt", "ge", "eq", "ne"]:
                 getattr(df, op)(s_nan, axis=0)
-
-    def test_series_nat_conversion(self):
-        # GH 18521
-        # Check rank does not mutate DataFrame
-        df = DataFrame(np.random.randn(10, 3), dtype="float64")
-        expected = df.copy()
-        df.rank()
-        result = df
-        tm.assert_frame_equal(result, expected)
-
-    def test_multiindex_column_lookup(self):
-        # Check whether tuples are correctly treated as multi-level lookups.
-        # GH 23033
-        df = pd.DataFrame(
-            columns=pd.MultiIndex.from_product([["x"], ["a", "b"]]),
-            data=[[0.33, 0.13], [0.86, 0.25], [0.25, 0.70], [0.85, 0.91]],
-        )
-
-        # nsmallest
-        result = df.nsmallest(3, ("x", "a"))
-        expected = df.iloc[[2, 0, 3]]
-        tm.assert_frame_equal(result, expected)
-
-        # nlargest
-        result = df.nlargest(3, ("x", "b"))
-        expected = df.iloc[[3, 2, 1]]
-        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index c6852576f660b..17cc50661e3cb 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -5,51 +5,24 @@
 import numpy as np
 import pytest
 
+from pandas.compat import PY37
+from pandas.util._test_decorators import async_mark
+
 import pandas as pd
-from pandas import (
-    Categorical,
-    DataFrame,
-    Series,
-    SparseDataFrame,
-    SparseDtype,
-    compat,
-    date_range,
-    timedelta_range,
-)
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
-
-
-class SharedWithSparse:
-    """
-    A collection of tests DataFrame and SparseDataFrame can share.
-
-    In generic tests on this class, use ``self._assert_frame_equal()`` and
-    ``self._assert_series_equal()`` which are implemented in sub-classes
-    and dispatch correctly.
-    """
-
-    def _assert_frame_equal(self, left, right):
-        """Dispatch to frame class dependent assertion"""
-        raise NotImplementedError
-
-    def _assert_series_equal(self, left, right):
-        """Dispatch to series class dependent assertion"""
-        raise NotImplementedError
-
-    def test_copy_index_name_checking(self, float_frame):
+from pandas import Categorical, DataFrame, Series, compat, date_range, timedelta_range
+import pandas._testing as tm
+
+
+class TestDataFrameMisc:
+    @pytest.mark.parametrize("attr", ["index", "columns"])
+    def test_copy_index_name_checking(self, float_frame, attr):
         # don't want to be able to modify the index stored elsewhere after
         # making a copy
-        for attr in ("index", "columns"):
-            ind = getattr(float_frame, attr)
-            ind.name = None
-            cp = float_frame.copy()
-            getattr(cp, attr).name = "foo"
-            assert getattr(float_frame, attr).name is None
+        ind = getattr(float_frame, attr)
+        ind.name = None
+        cp = float_frame.copy()
+        getattr(cp, attr).name = "foo"
+        assert getattr(float_frame, attr).name is None
 
     def test_getitem_pop_assign_name(self, float_frame):
         s = float_frame["A"]
@@ -147,16 +120,16 @@ def test_tab_completion(self):
     def test_not_hashable(self):
         empty_frame = DataFrame()
 
-        df = self.klass([1])
-        msg = "'(Sparse)?DataFrame' objects are mutable, thus they cannot be hashed"
+        df = DataFrame([1])
+        msg = "'DataFrame' objects are mutable, thus they cannot be hashed"
         with pytest.raises(TypeError, match=msg):
             hash(df)
         with pytest.raises(TypeError, match=msg):
             hash(empty_frame)
 
     def test_new_empty_index(self):
-        df1 = self.klass(np.random.randn(0, 3))
-        df2 = self.klass(np.random.randn(0, 3))
+        df1 = DataFrame(np.random.randn(0, 3))
+        df2 = DataFrame(np.random.randn(0, 3))
         df1.index.name = "foo"
         assert df2.index.name is None
 
@@ -167,7 +140,7 @@ def test_array_interface(self, float_frame):
         assert result.index is float_frame.index
         assert result.columns is float_frame.columns
 
-        self._assert_frame_equal(result, float_frame.apply(np.sqrt))
+        tm.assert_frame_equal(result, float_frame.apply(np.sqrt))
 
     def test_get_agg_axis(self, float_frame):
         cols = float_frame._get_agg_axis(0)
@@ -193,9 +166,9 @@ def test_nonzero(self, float_frame, float_string_frame):
         assert not df.empty
 
     def test_iteritems(self):
-        df = self.klass([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
         for k, v in df.items():
-            assert isinstance(v, self.klass._constructor_sliced)
+            assert isinstance(v, DataFrame._constructor_sliced)
 
     def test_items(self):
         # GH 17213, GH 13918
@@ -212,18 +185,15 @@ def test_iter(self, float_frame):
     def test_iterrows(self, float_frame, float_string_frame):
         for k, v in float_frame.iterrows():
             exp = float_frame.loc[k]
-            self._assert_series_equal(v, exp)
+            tm.assert_series_equal(v, exp)
 
         for k, v in float_string_frame.iterrows():
             exp = float_string_frame.loc[k]
-            self._assert_series_equal(v, exp)
+            tm.assert_series_equal(v, exp)
 
     def test_iterrows_iso8601(self):
         # GH 19671
-        if self.klass == SparseDataFrame:
-            pytest.xfail(reason="SparseBlock datetime type not implemented.")
-
-        s = self.klass(
+        s = DataFrame(
             {
                 "non_iso8601": ["M1701", "M1802", "M1903", "M2004"],
                 "iso8601": date_range("2000-01-01", periods=4, freq="M"),
@@ -231,7 +201,7 @@ def test_iterrows_iso8601(self):
         )
         for k, v in s.iterrows():
             exp = s.loc[k]
-            self._assert_series_equal(v, exp)
+            tm.assert_series_equal(v, exp)
 
     def test_iterrows_corner(self):
         # gh-12222
@@ -257,19 +227,19 @@ def test_iterrows_corner(self):
 
     def test_itertuples(self, float_frame):
         for i, tup in enumerate(float_frame.itertuples()):
-            s = self.klass._constructor_sliced(tup[1:])
+            s = DataFrame._constructor_sliced(tup[1:])
             s.name = tup[0]
             expected = float_frame.iloc[i, :].reset_index(drop=True)
-            self._assert_series_equal(s, expected)
+            tm.assert_series_equal(s, expected)
 
-        df = self.klass(
+        df = DataFrame(
             {"floats": np.random.randn(5), "ints": range(5)}, columns=["floats", "ints"]
         )
 
         for tup in df.itertuples(index=False):
             assert isinstance(tup[1], int)
 
-        df = self.klass(data={"a": [1, 2, 3], "b": [4, 5, 6]})
+        df = DataFrame(data={"a": [1, 2, 3], "b": [4, 5, 6]})
         dfaa = df[["a", "a"]]
 
         assert list(dfaa.itertuples()) == [(0, 1, 1), (1, 2, 2), (2, 3, 3)]
@@ -294,8 +264,27 @@ def test_itertuples(self, float_frame):
         df3 = DataFrame({"f" + str(i): [i] for i in range(1024)})
         # will raise SyntaxError if trying to create namedtuple
         tup3 = next(df3.itertuples())
-        assert not hasattr(tup3, "_fields")
         assert isinstance(tup3, tuple)
+        if PY37:
+            assert hasattr(tup3, "_fields")
+        else:
+            assert not hasattr(tup3, "_fields")
+
+        # GH 28282
+        df_254_columns = DataFrame([{f"foo_{i}": f"bar_{i}" for i in range(254)}])
+        result_254_columns = next(df_254_columns.itertuples(index=False))
+        assert isinstance(result_254_columns, tuple)
+        assert hasattr(result_254_columns, "_fields")
+
+        df_255_columns = DataFrame([{f"foo_{i}": f"bar_{i}" for i in range(255)}])
+        result_255_columns = next(df_255_columns.itertuples(index=False))
+        assert isinstance(result_255_columns, tuple)
+
+        # Dataframes with >=255 columns will fallback to regular tuples on python < 3.7
+        if PY37:
+            assert hasattr(result_255_columns, "_fields")
+        else:
+            assert not hasattr(result_255_columns, "_fields")
 
     def test_sequence_like_with_categorical(self):
 
@@ -324,7 +313,7 @@ def test_sequence_like_with_categorical(self):
     def test_len(self, float_frame):
         assert len(float_frame) == len(float_frame.index)
 
-    def test_values(self, float_frame, float_string_frame):
+    def test_values_mixed_dtypes(self, float_frame, float_string_frame):
         frame = float_frame
         arr = frame.values
 
@@ -341,14 +330,14 @@ def test_values(self, float_frame, float_string_frame):
         arr = float_string_frame[["foo", "A"]].values
         assert arr[0, 0] == "bar"
 
-        df = self.klass({"complex": [1j, 2j, 3j], "real": [1, 2, 3]})
+        df = DataFrame({"complex": [1j, 2j, 3j], "real": [1, 2, 3]})
         arr = df.values
         assert arr[0, 0] == 1j
 
         # single block corner case
         arr = float_frame[["A", "B"]].values
         expected = float_frame.reindex(columns=["A", "B"]).values
-        assert_almost_equal(arr, expected)
+        tm.assert_almost_equal(arr, expected)
 
     def test_to_numpy(self):
         df = pd.DataFrame({"A": [1, 2], "B": [3, 4.5]})
@@ -369,32 +358,14 @@ def test_to_numpy_copy(self):
         assert df.to_numpy(copy=False).base is arr
         assert df.to_numpy(copy=True).base is None
 
-    def test_transpose(self, float_frame):
-        frame = float_frame
-        dft = frame.T
-        for idx, series in dft.items():
-            for col, value in series.items():
-                if np.isnan(value):
-                    assert np.isnan(frame[col][idx])
-                else:
-                    assert value == frame[col][idx]
-
-        # mixed type
-        index, data = tm.getMixedTypeDict()
-        mixed = self.klass(data, index=index)
-
-        mixed_T = mixed.T
-        for col, s in mixed_T.items():
-            assert s.dtype == np.object_
-
     def test_swapaxes(self):
-        df = self.klass(np.random.randn(10, 5))
-        self._assert_frame_equal(df.T, df.swapaxes(0, 1))
-        self._assert_frame_equal(df.T, df.swapaxes(1, 0))
-        self._assert_frame_equal(df, df.swapaxes(0, 0))
+        df = DataFrame(np.random.randn(10, 5))
+        tm.assert_frame_equal(df.T, df.swapaxes(0, 1))
+        tm.assert_frame_equal(df.T, df.swapaxes(1, 0))
+        tm.assert_frame_equal(df, df.swapaxes(0, 0))
         msg = (
-            "No axis named 2 for object type"
-            r" <class 'pandas.core(.sparse)?.frame.(Sparse)?DataFrame'>"
+            "No axis named 2 for object type "
+            r"<class 'pandas.core(.sparse)?.frame.(Sparse)?DataFrame'>"
         )
         with pytest.raises(ValueError, match=msg):
             df.swapaxes(2, 5)
@@ -405,11 +376,11 @@ def test_axis_aliases(self, float_frame):
         # reg name
         expected = f.sum(axis=0)
         result = f.sum(axis="index")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = f.sum(axis=1)
         result = f.sum(axis="columns")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_class_axis(self):
         # GH 18147
@@ -422,7 +393,7 @@ def test_more_values(self, float_string_frame):
         assert values.shape[1] == len(float_string_frame.columns)
 
     def test_repr_with_mi_nat(self, float_string_frame):
-        df = self.klass(
+        df = DataFrame(
             {"X": [1, 2]}, index=[[pd.NaT, pd.Timestamp("20130101")], ["a", "b"]]
         )
         result = repr(df)
@@ -439,18 +410,18 @@ def test_series_put_names(self, float_string_frame):
             assert v.name == k
 
     def test_empty_nonzero(self):
-        df = self.klass([1, 2, 3])
+        df = DataFrame([1, 2, 3])
         assert not df.empty
-        df = self.klass(index=[1], columns=[1])
+        df = DataFrame(index=[1], columns=[1])
         assert not df.empty
-        df = self.klass(index=["a", "b"], columns=["c", "d"]).dropna()
+        df = DataFrame(index=["a", "b"], columns=["c", "d"]).dropna()
         assert df.empty
         assert df.T.empty
         empty_frames = [
-            self.klass(),
-            self.klass(index=[1]),
-            self.klass(columns=[1]),
-            self.klass({1: []}),
+            DataFrame(),
+            DataFrame(index=[1]),
+            DataFrame(columns=[1]),
+            DataFrame({1: []}),
         ]
         for df in empty_frames:
             assert df.empty
@@ -458,7 +429,7 @@ def test_empty_nonzero(self):
 
     def test_with_datetimelikes(self):
 
-        df = self.klass(
+        df = DataFrame(
             {
                 "A": date_range("20130101", periods=10),
                 "B": timedelta_range("1 day", periods=10),
@@ -467,32 +438,13 @@ def test_with_datetimelikes(self):
         t = df.T
 
         result = t.dtypes.value_counts()
-        if self.klass is DataFrame:
-            expected = Series({np.dtype("object"): 10})
-        else:
-            expected = Series({SparseDtype(dtype=object): 10})
+        expected = Series({np.dtype("object"): 10})
         tm.assert_series_equal(result, expected)
 
-
-class TestDataFrameMisc(SharedWithSparse):
-
-    klass = DataFrame
-    # SharedWithSparse tests use generic, klass-agnostic assertion
-    _assert_frame_equal = staticmethod(assert_frame_equal)
-    _assert_series_equal = staticmethod(assert_series_equal)
-
     def test_values(self, float_frame):
         float_frame.values[:, 0] = 5.0
         assert (float_frame.values[:, 0] == 5).all()
 
-    def test_as_matrix_deprecated(self, float_frame):
-        # GH 18458
-        with tm.assert_produces_warning(FutureWarning):
-            cols = float_frame.columns.tolist()
-            result = float_frame.as_matrix(columns=cols)
-        expected = float_frame.values
-        tm.assert_numpy_array_equal(result, expected)
-
     def test_deepcopy(self, float_frame):
         cp = deepcopy(float_frame)
         series = cp["A"]
@@ -500,12 +452,6 @@ def test_deepcopy(self, float_frame):
         for idx, value in series.items():
             assert float_frame["A"][idx] != value
 
-    def test_transpose_get_view(self, float_frame):
-        dft = float_frame.T
-        dft.values[:, 5:10] = 5
-
-        assert (float_frame.values[5:10] == 5).all()
-
     def test_inplace_return_self(self):
         # GH 1893
 
@@ -570,19 +516,22 @@ def _check_f(base, f):
         f = lambda x: x.rename({1: "foo"}, inplace=True)
         _check_f(d.copy(), f)
 
-    def test_tab_complete_warning(self, ip):
+    @async_mark()
+    async def test_tab_complete_warning(self, ip):
         # GH 16409
         pytest.importorskip("IPython", minversion="6.0.0")
         from IPython.core.completer import provisionalcompleter
 
         code = "import pandas as pd; df = pd.DataFrame()"
-        ip.run_code(code)
+        await ip.run_code(code)
         with tm.assert_produces_warning(None):
             with provisionalcompleter("ignore"):
                 list(ip.Completer.completions("df.", 1))
 
-    def test_get_values_deprecated(self):
-        df = DataFrame({"a": [1, 2], "b": [0.1, 0.2]})
-        with tm.assert_produces_warning(FutureWarning):
-            res = df.get_values()
-        tm.assert_numpy_array_equal(res, df.values)
+    def test_attrs(self):
+        df = pd.DataFrame({"A": [2, 3]})
+        assert df.attrs == {}
+        df.attrs["version"] = 1
+
+        result = df.rename(columns=str)
+        assert result.attrs == {"version": 1}
diff --git a/pandas/tests/frame/test_apply.py b/pandas/tests/frame/test_apply.py
index 92912ff9ec093..fe6abef97acc4 100644
--- a/pandas/tests/frame/test_apply.py
+++ b/pandas/tests/frame/test_apply.py
@@ -11,10 +11,10 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range, notna
+import pandas._testing as tm
 from pandas.conftest import _get_cython_table_params
 from pandas.core.apply import frame_apply
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+from pandas.core.base import SpecificationError
 
 
 @pytest.fixture
@@ -70,7 +70,7 @@ def test_apply_mixed_datetimelike(self):
             }
         )
         result = df.apply(lambda x: x, axis=1)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_apply_empty(self, float_frame):
         # empty
@@ -85,17 +85,17 @@ def test_apply_empty(self, float_frame):
         no_rows = float_frame[:0]
         result = no_rows.apply(lambda x: x.mean())
         expected = Series(np.nan, index=float_frame.columns)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         no_cols = float_frame.loc[:, []]
         result = no_cols.apply(lambda x: x.mean(), axis=1)
         expected = Series(np.nan, index=float_frame.index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 2476
         expected = DataFrame(index=["a"])
         result = expected.apply(lambda x: x["a"], axis=1)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
     def test_apply_with_reduce_empty(self):
         # reduce with an empty DataFrame
@@ -103,35 +103,51 @@ def test_apply_with_reduce_empty(self):
 
         x = []
         result = empty_frame.apply(x.append, axis=1, result_type="expand")
-        assert_frame_equal(result, empty_frame)
+        tm.assert_frame_equal(result, empty_frame)
         result = empty_frame.apply(x.append, axis=1, result_type="reduce")
-        assert_series_equal(result, Series([], index=pd.Index([], dtype=object)))
+        expected = Series([], index=pd.Index([], dtype=object), dtype=np.float64)
+        tm.assert_series_equal(result, expected)
 
         empty_with_cols = DataFrame(columns=["a", "b", "c"])
         result = empty_with_cols.apply(x.append, axis=1, result_type="expand")
-        assert_frame_equal(result, empty_with_cols)
+        tm.assert_frame_equal(result, empty_with_cols)
         result = empty_with_cols.apply(x.append, axis=1, result_type="reduce")
-        assert_series_equal(result, Series([], index=pd.Index([], dtype=object)))
+        expected = Series([], index=pd.Index([], dtype=object), dtype=np.float64)
+        tm.assert_series_equal(result, expected)
 
         # Ensure that x.append hasn't been called
         assert x == []
 
-    def test_apply_deprecate_reduce(self):
-        empty_frame = DataFrame()
+    @pytest.mark.parametrize("func", ["sum", "prod", "any", "all"])
+    def test_apply_funcs_over_empty(self, func):
+        # GH 28213
+        df = DataFrame(columns=["a", "b", "c"])
 
-        x = []
-        with tm.assert_produces_warning(FutureWarning):
-            empty_frame.apply(x.append, axis=1, reduce=True)
+        result = df.apply(getattr(np, func))
+        expected = getattr(df, func)()
+        tm.assert_series_equal(result, expected)
+
+    def test_nunique_empty(self):
+        # GH 28213
+        df = DataFrame(columns=["a", "b", "c"])
+
+        result = df.nunique()
+        expected = Series(0, index=df.columns)
+        tm.assert_series_equal(result, expected)
+
+        result = df.T.nunique()
+        expected = Series([], index=pd.Index([]), dtype=np.float64)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_standard_nonunique(self):
         df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=["a", "a", "c"])
 
         result = df.apply(lambda s: s[0], axis=1)
         expected = Series([1, 4, 7], ["a", "a", "c"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.T.apply(lambda s: s[0], axis=0)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("func", ["sum", "mean", "min", "max", "std"])
     @pytest.mark.parametrize(
@@ -149,10 +165,6 @@ def test_apply_with_string_funcs(self, float_frame, func, args, kwds):
         expected = getattr(float_frame, func)(*args, **kwds)
         tm.assert_series_equal(result, expected)
 
-    def test_apply_broadcast_deprecated(self, float_frame):
-        with tm.assert_produces_warning(FutureWarning):
-            float_frame.apply(np.mean, broadcast=True)
-
     def test_apply_broadcast(self, float_frame, int_frame_const_col):
 
         # scalars
@@ -230,13 +242,13 @@ def test_apply_raw(self, float_frame):
         expected0 = float_frame.apply(lambda x: x.values.mean())
         expected1 = float_frame.apply(lambda x: x.values.mean(), axis=1)
 
-        assert_series_equal(result0, expected0)
-        assert_series_equal(result1, expected1)
+        tm.assert_series_equal(result0, expected0)
+        tm.assert_series_equal(result1, expected1)
 
         # no reduction
         result = float_frame.apply(lambda x: x * 2, raw=True)
         expected = float_frame * 2
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_apply_axis1(self, float_frame):
         d = float_frame.index[0]
@@ -248,7 +260,7 @@ def test_apply_ignore_failures(self, float_string_frame):
             float_string_frame, np.mean, 0, ignore_failures=True
         ).apply_standard()
         expected = float_string_frame._get_numeric_data().apply(np.mean)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_mixed_dtype_corner(self):
         df = DataFrame({"A": ["foo"], "B": [1.0]})
@@ -256,16 +268,16 @@ def test_apply_mixed_dtype_corner(self):
         # the result here is actually kind of ambiguous, should it be a Series
         # or a DataFrame?
         expected = Series(np.nan, index=pd.Index([], dtype="int64"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": ["foo"], "B": [1.0]})
         result = df.apply(lambda x: x["A"], axis=1)
         expected = Series(["foo"], index=[0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.apply(lambda x: x["B"], axis=1)
         expected = Series([1.0], index=[0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_empty_infer_type(self):
         no_cols = DataFrame(index=["a", "b", "c"])
@@ -312,32 +324,32 @@ def subtract_and_divide(x, sub, divide=1):
 
         result = float_frame.apply(add_some, howmuch=2)
         expected = float_frame.apply(lambda x: x + 2)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = float_frame.apply(agg_and_add, howmuch=2)
         expected = float_frame.apply(lambda x: x.mean() + 2)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = float_frame.apply(subtract_and_divide, args=(2,), divide=2)
         expected = float_frame.apply(lambda x: (x - 2.0) / 2.0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_apply_yield_list(self, float_frame):
         result = float_frame.apply(list)
-        assert_frame_equal(result, float_frame)
+        tm.assert_frame_equal(result, float_frame)
 
     def test_apply_reduce_Series(self, float_frame):
         float_frame.loc[::2, "A"] = np.nan
         expected = float_frame.mean(1)
         result = float_frame.apply(np.mean, axis=1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_reduce_rows_to_dict(self):
         # GH 25196
         data = pd.DataFrame([[1, 2], [3, 4]])
         expected = pd.Series([{0: 1, 1: 3}, {0: 2, 1: 4}])
         result = data.apply(dict)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_differently_indexed(self):
         df = DataFrame(np.random.randn(20, 10))
@@ -346,13 +358,13 @@ def test_apply_differently_indexed(self):
         expected0 = DataFrame(
             {i: v.describe() for i, v in df.items()}, columns=df.columns
         )
-        assert_frame_equal(result0, expected0)
+        tm.assert_frame_equal(result0, expected0)
 
         result1 = df.apply(Series.describe, axis=1)
         expected1 = DataFrame(
             {i: v.describe() for i, v in df.T.items()}, columns=df.index
         ).T
-        assert_frame_equal(result1, expected1)
+        tm.assert_frame_equal(result1, expected1)
 
     def test_apply_modify_traceback(self):
         data = DataFrame(
@@ -414,12 +426,9 @@ def transform2(row):
                 row["D"] = 7
             return row
 
-        try:
+        msg = "'float' object has no attribute 'startswith'"
+        with pytest.raises(AttributeError, match=msg):
             data.apply(transform, axis=1)
-        except AttributeError as e:
-            assert len(e.args) == 2
-            assert e.args[1] == "occurred at index 4"
-            assert e.args[0] == "'float' object has no attribute 'startswith'"
 
     def test_apply_bug(self):
 
@@ -453,7 +462,7 @@ def f(r):
             columns=["a", "market", "position"],
         )
         result = positions.apply(f, axis=1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_convert_objects(self):
         data = DataFrame(
@@ -504,16 +513,16 @@ def test_apply_convert_objects(self):
         )
 
         result = data.apply(lambda x: x, axis=1)
-        assert_frame_equal(result._convert(datetime=True), data)
+        tm.assert_frame_equal(result._convert(datetime=True), data)
 
     def test_apply_attach_name(self, float_frame):
         result = float_frame.apply(lambda x: x.name)
         expected = Series(float_frame.columns, index=float_frame.columns)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = float_frame.apply(lambda x: x.name, axis=1)
         expected = Series(float_frame.index, index=float_frame.index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # non-reductions
         result = float_frame.apply(lambda x: np.repeat(x.name, len(x)))
@@ -522,14 +531,14 @@ def test_apply_attach_name(self, float_frame):
             index=float_frame.index,
             columns=float_frame.columns,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = float_frame.apply(lambda x: np.repeat(x.name, len(x)), axis=1)
         expected = Series(
             np.repeat(t[0], len(float_frame.columns)) for t in float_frame.itertuples()
         )
         expected.index = float_frame.index
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_multi_index(self, float_frame):
         index = MultiIndex.from_arrays([["a", "a", "b"], ["c", "d", "d"]])
@@ -538,7 +547,7 @@ def test_apply_multi_index(self, float_frame):
         expected = DataFrame(
             [[1, 2], [3, 4], [5, 6]], index=index, columns=["min", "max"]
         )
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     def test_apply_dict(self):
 
@@ -556,9 +565,9 @@ def test_apply_dict(self):
             reduce_false = df.apply(fn, result_type="expand")
             reduce_none = df.apply(fn)
 
-            assert_series_equal(reduce_true, dicts)
-            assert_frame_equal(reduce_false, df)
-            assert_series_equal(reduce_none, dicts)
+            tm.assert_series_equal(reduce_true, dicts)
+            tm.assert_frame_equal(reduce_false, df)
+            tm.assert_series_equal(reduce_none, dicts)
 
     def test_applymap(self, float_frame):
         applied = float_frame.applymap(lambda x: x * 2)
@@ -635,7 +644,7 @@ def test_applymap_box(self):
             }
         )
 
-        result = df.applymap(lambda x: "{0}".format(x.__class__.__name__))
+        result = df.applymap(lambda x: type(x).__name__)
         expected = pd.DataFrame(
             {
                 "a": ["Timestamp", "Timestamp"],
@@ -662,17 +671,17 @@ def test_apply_non_numpy_dtype(self):
             {"dt": pd.date_range("2015-01-01", periods=3, tz="Europe/Brussels")}
         )
         result = df.apply(lambda x: x)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         result = df.apply(lambda x: x + pd.Timedelta("1day"))
         expected = DataFrame(
             {"dt": pd.date_range("2015-01-02", periods=3, tz="Europe/Brussels")}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame({"dt": ["a", "b", "c", "a"]}, dtype="category")
         result = df.apply(lambda x: x)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_apply_dup_names_multi_agg(self):
         # GH 21063
@@ -682,6 +691,26 @@ def test_apply_dup_names_multi_agg(self):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_apply_nested_result_axis_1(self):
+        # GH 13820
+        def apply_list(row):
+            return [2 * row["A"], 2 * row["C"], 2 * row["B"]]
+
+        df = pd.DataFrame(np.zeros((4, 4)), columns=list("ABCD"))
+        result = df.apply(apply_list, axis=1)
+        expected = Series(
+            [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_apply_noreduction_tzaware_object(self):
+        # https://github.com/pandas-dev/pandas/issues/31505
+        df = pd.DataFrame({"foo": [pd.Timestamp("2020", tz="UTC")]}, dtype="object")
+        result = df.apply(lambda x: x)
+        tm.assert_frame_equal(result, df)
+        result = df.apply(lambda x: x.copy())
+        tm.assert_frame_equal(result, df)
+
 
 class TestInferOutputShape:
     # the user has supplied an opaque UDF where
@@ -703,19 +732,19 @@ def test_with_dictlike_columns(self):
         df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
         result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1)
         expected = Series([{"s": 3} for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df["tm"] = [
             pd.Timestamp("2017-05-01 00:00:00"),
             pd.Timestamp("2017-05-02 00:00:00"),
         ]
         result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # compose a series
         result = (df["a"] + df["b"]).apply(lambda x: {"s": x})
         expected = Series([{"s": 3}, {"s": 3}])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 18775
         df = DataFrame()
@@ -726,7 +755,7 @@ def test_with_dictlike_columns(self):
         )
         result = df.apply(lambda x: {}, axis=1)
         expected = Series([{}, {}, {}])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_with_dictlike_columns_with_infer(self):
         # GH 17602
@@ -735,7 +764,7 @@ def test_with_dictlike_columns_with_infer(self):
             lambda x: {"s": x["a"] + x["b"]}, axis=1, result_type="expand"
         )
         expected = DataFrame({"s": [3, 3]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df["tm"] = [
             pd.Timestamp("2017-05-01 00:00:00"),
@@ -744,7 +773,7 @@ def test_with_dictlike_columns_with_infer(self):
         result = df.apply(
             lambda x: {"s": x["a"] + x["b"]}, axis=1, result_type="expand"
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_with_listlike_columns(self):
         # GH 17348
@@ -758,11 +787,11 @@ def test_with_listlike_columns(self):
 
         result = df[["a", "b"]].apply(tuple, axis=1)
         expected = Series([t[1:] for t in df[["a", "b"]].itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df[["a", "ts"]].apply(tuple, axis=1)
         expected = Series([t[1:] for t in df[["a", "ts"]].itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 18919
         df = DataFrame(
@@ -772,7 +801,7 @@ def test_with_listlike_columns(self):
 
         result = df.apply(lambda row: [el for el in row["x"] if el in row["y"]], axis=1)
         expected = Series([[], ["q"]], index=df.index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_infer_output_shape_columns(self):
         # GH 18573
@@ -789,7 +818,7 @@ def test_infer_output_shape_columns(self):
         )
         result = df.apply(lambda row: (row.number, row.string), axis=1)
         expected = Series([(t.number, t.string) for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_infer_output_shape_listlike_columns(self):
         # GH 16353
@@ -798,22 +827,22 @@ def test_infer_output_shape_listlike_columns(self):
 
         result = df.apply(lambda x: [1, 2, 3], axis=1)
         expected = Series([[1, 2, 3] for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.apply(lambda x: [1, 2], axis=1)
         expected = Series([[1, 2] for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 17970
         df = DataFrame({"a": [1, 2, 3]}, index=list("abc"))
 
         result = df.apply(lambda row: np.ones(1), axis=1)
         expected = Series([np.ones(1) for t in df.itertuples()], index=df.index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.apply(lambda row: np.ones(2), axis=1)
         expected = Series([np.ones(2) for t in df.itertuples()], index=df.index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 17892
         df = pd.DataFrame(
@@ -835,7 +864,7 @@ def fun(x):
 
         result = df.apply(fun, axis=1)
         expected = Series([(1, 2) for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_consistent_coerce_for_shapes(self):
         # we want column names to NOT be propagated
@@ -844,11 +873,11 @@ def test_consistent_coerce_for_shapes(self):
 
         result = df.apply(lambda x: [1, 2, 3], axis=1)
         expected = Series([[1, 2, 3] for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.apply(lambda x: [1, 2], axis=1)
         expected = Series([[1, 2] for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_consistent_names(self, int_frame_const_col):
         # if a Series is returned, we should use the resulting index names
@@ -860,11 +889,11 @@ def test_consistent_names(self, int_frame_const_col):
         expected = int_frame_const_col.rename(
             columns={"A": "test", "B": "other", "C": "cols"}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.apply(lambda x: Series([1, 2], index=["test", "other"]), axis=1)
         expected = expected[["test", "other"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_result_type(self, int_frame_const_col):
         # result_type should be consistent no matter which
@@ -874,36 +903,36 @@ def test_result_type(self, int_frame_const_col):
         result = df.apply(lambda x: [1, 2, 3], axis=1, result_type="expand")
         expected = df.copy()
         expected.columns = [0, 1, 2]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.apply(lambda x: [1, 2], axis=1, result_type="expand")
         expected = df[["A", "B"]].copy()
         expected.columns = [0, 1]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # broadcast result
         result = df.apply(lambda x: [1, 2, 3], axis=1, result_type="broadcast")
         expected = df.copy()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         columns = ["other", "col", "names"]
         result = df.apply(
             lambda x: Series([1, 2, 3], index=columns), axis=1, result_type="broadcast"
         )
         expected = df.copy()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # series result
         result = df.apply(lambda x: Series([1, 2, 3], index=x.index), axis=1)
         expected = df.copy()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # series result with other index
         columns = ["other", "col", "names"]
         result = df.apply(lambda x: Series([1, 2, 3], index=columns), axis=1)
         expected = df.copy()
         expected.columns = columns
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("result_type", ["foo", 1])
     def test_result_type_error(self, result_type, int_frame_const_col):
@@ -924,11 +953,11 @@ def test_consistency_for_boxed(self, box, int_frame_const_col):
 
         result = df.apply(lambda x: box([1, 2]), axis=1)
         expected = Series([box([1, 2]) for t in df.itertuples()])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.apply(lambda x: box([1, 2]), axis=1, result_type="expand")
         expected = int_frame_const_col[["A", "B"]].rename(columns={"A": 0, "B": 1})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
 
 def zip_frames(frames, axis=1):
@@ -962,13 +991,13 @@ def test_agg_transform(self, axis, float_frame):
             # ufunc
             result = float_frame.transform(np.sqrt, axis=axis)
             expected = f_sqrt.copy()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = float_frame.apply(np.sqrt, axis=axis)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = float_frame.transform(np.sqrt, axis=axis)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # list-like
             result = float_frame.apply([np.sqrt], axis=axis)
@@ -981,10 +1010,10 @@ def test_agg_transform(self, axis, float_frame):
                 expected.index = pd.MultiIndex.from_product(
                     [float_frame.index, ["sqrt"]]
                 )
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = float_frame.transform([np.sqrt], axis=axis)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # multiple items in list
             # these are in the order as if we are applying both
@@ -999,10 +1028,10 @@ def test_agg_transform(self, axis, float_frame):
                 expected.index = pd.MultiIndex.from_product(
                     [float_frame.index, ["absolute", "sqrt"]]
                 )
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = float_frame.transform([np.abs, "sqrt"], axis=axis)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_transform_and_agg_err(self, axis, float_frame):
         # cannot both transform and agg
@@ -1088,7 +1117,8 @@ def test_agg_dict_nested_renaming_depr(self):
         df = pd.DataFrame({"A": range(5), "B": 5})
 
         # nested renaming
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        msg = r"nested renamer is not supported"
+        with pytest.raises(SpecificationError, match=msg):
             df.agg({"A": {"foo": "min"}, "B": {"bar": "max"}})
 
     def test_agg_reduce(self, axis, float_frame):
@@ -1108,7 +1138,7 @@ def test_agg_reduce(self, axis, float_frame):
         expected = expected.T if axis in {0, "index"} else expected
 
         result = float_frame.agg(["mean", "max", "sum"], axis=axis)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # dict input with scalars
         func = OrderedDict([(name1, "mean"), (name2, "sum")])
@@ -1120,7 +1150,7 @@ def test_agg_reduce(self, axis, float_frame):
             ],
             index=[name1, name2],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # dict input with lists
         func = OrderedDict([(name1, ["mean"]), (name2, ["sum"])])
@@ -1136,7 +1166,7 @@ def test_agg_reduce(self, axis, float_frame):
             }
         )
         expected = expected.T if axis in {1, "columns"} else expected
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # dict input with lists with multiple
         func = OrderedDict([(name1, ["mean", "sum"]), (name2, ["sum", "max"])])
@@ -1168,7 +1198,7 @@ def test_agg_reduce(self, axis, float_frame):
             )
         )
         expected = expected.T if axis in {1, "columns"} else expected
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_nuiscance_columns(self):
 
@@ -1184,7 +1214,7 @@ def test_nuiscance_columns(self):
 
         result = df.agg("min")
         expected = Series([1, 1.0, "bar", pd.Timestamp("20130101")], index=df.columns)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.agg(["min"])
         expected = DataFrame(
@@ -1192,17 +1222,17 @@ def test_nuiscance_columns(self):
             index=["min"],
             columns=df.columns,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.agg("sum")
         expected = Series([6, 6.0, "foobarbaz"], index=["A", "B", "C"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.agg(["sum"])
         expected = DataFrame(
             [[6, 6.0, "foobarbaz"]], index=["sum"], columns=["A", "B", "C"]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_non_callable_aggregates(self):
 
@@ -1217,13 +1247,13 @@ def test_non_callable_aggregates(self):
         result = df.agg({"A": "count"})
         expected = Series({"A": 2})
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Non-function aggregate
         result = df.agg({"A": "size"})
         expected = Series({"A": 3})
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Mix function and non-function aggs
         result1 = df.agg(["count", "size"])
@@ -1238,14 +1268,14 @@ def test_non_callable_aggregates(self):
             }
         )
 
-        assert_frame_equal(result1, result2, check_like=True)
-        assert_frame_equal(result2, expected, check_like=True)
+        tm.assert_frame_equal(result1, result2, check_like=True)
+        tm.assert_frame_equal(result2, expected, check_like=True)
 
         # Just functional string arg is same as calling df.arg()
         result = df.agg("count")
         expected = df.count()
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Just a string attribute arg same as calling df.arg
         result = df.agg("size")
@@ -1253,22 +1283,39 @@ def test_non_callable_aggregates(self):
 
         assert result == expected
 
+    def test_agg_listlike_result(self):
+        # GH-29587 user defined function returning list-likes
+        df = DataFrame(
+            {"A": [2, 2, 3], "B": [1.5, np.nan, 1.5], "C": ["foo", None, "bar"]}
+        )
+
+        def func(group_col):
+            return list(group_col.dropna().unique())
+
+        result = df.agg(func)
+        expected = pd.Series([[2, 3], [1.5], ["foo", "bar"]], index=["A", "B", "C"])
+        tm.assert_series_equal(result, expected)
+
+        result = df.agg([func])
+        expected = expected.to_frame("func").T
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize(
         "df, func, expected",
         chain(
             _get_cython_table_params(
                 DataFrame(),
                 [
-                    ("sum", Series()),
-                    ("max", Series()),
-                    ("min", Series()),
+                    ("sum", Series(dtype="float64")),
+                    ("max", Series(dtype="float64")),
+                    ("min", Series(dtype="float64")),
                     ("all", Series(dtype=bool)),
                     ("any", Series(dtype=bool)),
-                    ("mean", Series()),
-                    ("prod", Series()),
-                    ("std", Series()),
-                    ("var", Series()),
-                    ("median", Series()),
+                    ("mean", Series(dtype="float64")),
+                    ("prod", Series(dtype="float64")),
+                    ("std", Series(dtype="float64")),
+                    ("var", Series(dtype="float64")),
+                    ("median", Series(dtype="float64")),
                 ],
             ),
             _get_cython_table_params(
@@ -1304,8 +1351,8 @@ def test_agg_cython_table(self, df, func, expected, axis):
             _get_cython_table_params(
                 DataFrame([[np.nan, 1], [1, 2]]),
                 [
-                    ("cumprod", DataFrame([[np.nan, 1], [1.0, 2.0]])),
-                    ("cumsum", DataFrame([[np.nan, 1], [1.0, 3.0]])),
+                    ("cumprod", DataFrame([[np.nan, 1], [1, 2]])),
+                    ("cumsum", DataFrame([[np.nan, 1], [1, 3]])),
                 ],
             ),
         ),
@@ -1314,6 +1361,10 @@ def test_agg_cython_table_transform(self, df, func, expected, axis):
         # GH 21224
         # test transforming functions in
         # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)
+        if axis == "columns" or axis == 1:
+            # operating blockwise doesn't let us preserve dtypes
+            expected = expected.astype("float64")
+
         result = df.agg(func, axis=axis)
         tm.assert_frame_equal(result, expected)
 
@@ -1336,3 +1387,28 @@ def test_frequency_is_original(self, num_cols):
         df = DataFrame(1, index=index, columns=range(num_cols))
         df.apply(lambda x: x)
         assert index.freq == original.freq
+
+    def test_apply_datetime_tz_issue(self):
+        # GH 29052
+
+        timestamps = [
+            pd.Timestamp("2019-03-15 12:34:31.909000+0000", tz="UTC"),
+            pd.Timestamp("2019-03-15 12:34:34.359000+0000", tz="UTC"),
+            pd.Timestamp("2019-03-15 12:34:34.660000+0000", tz="UTC"),
+        ]
+        df = DataFrame(data=[0, 1, 2], index=timestamps)
+        result = df.apply(lambda x: x.name, axis=1)
+        expected = pd.Series(index=timestamps, data=timestamps)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("df", [pd.DataFrame({"A": ["a", None], "B": ["c", "d"]})])
+    @pytest.mark.parametrize("method", ["min", "max", "sum"])
+    def test_consistency_of_aggregates_of_columns_with_missing_values(self, df, method):
+        # GH 16832
+        none_in_first_column_result = getattr(df[["A", "B"]], method)()
+        none_in_second_column_result = getattr(df[["B", "A"]], method)()
+
+        tm.assert_series_equal(
+            none_in_first_column_result, none_in_second_column_result
+        )
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 706bc122c6d9e..c6eacf2bbcd84 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -6,8 +6,8 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int
-import pandas.util.testing as tm
 
 # -------------------------------------------------------------------
 # Comparisons
@@ -16,6 +16,13 @@
 class TestFrameComparisons:
     # Specifically _not_ flex-comparisons
 
+    def test_frame_in_list(self):
+        # GH#12689 this should raise at the DataFrame level, not blocks
+        df = pd.DataFrame(np.random.randn(6, 4), columns=list("ABCD"))
+        msg = "The truth value of a DataFrame is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            df in [None]
+
     def test_comparison_invalid(self):
         def check(df, df2):
 
@@ -235,21 +242,46 @@ def _test_seq(df, idx_ser, col_ser):
         rs = df.le(df)
         assert not rs.loc[0, 0]
 
+    def test_bool_flex_frame_complex_dtype(self):
         # complex
         arr = np.array([np.nan, 1, 6, np.nan])
         arr2 = np.array([2j, np.nan, 7, None])
         df = pd.DataFrame({"a": arr})
         df2 = pd.DataFrame({"a": arr2})
-        rs = df.gt(df2)
-        assert not rs.values.any()
+
+        msg = "|".join(
+            [
+                "'>' not supported between instances of '.*' and 'complex'",
+                r"unorderable types: .*complex\(\)",  # PY35
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            # inequalities are not well-defined for complex numbers
+            df.gt(df2)
+        with pytest.raises(TypeError, match=msg):
+            # regression test that we get the same behavior for Series
+            df["a"].gt(df2["a"])
+        with pytest.raises(TypeError, match=msg):
+            # Check that we match numpy behavior here
+            df.values > df2.values
+
         rs = df.ne(df2)
         assert rs.values.all()
 
         arr3 = np.array([2j, np.nan, None])
         df3 = pd.DataFrame({"a": arr3})
-        rs = df3.gt(2j)
-        assert not rs.values.any()
 
+        with pytest.raises(TypeError, match=msg):
+            # inequalities are not well-defined for complex numbers
+            df3.gt(2j)
+        with pytest.raises(TypeError, match=msg):
+            # regression test that we get the same behavior for Series
+            df3["a"].gt(2j)
+        with pytest.raises(TypeError, match=msg):
+            # Check that we match numpy behavior here
+            df3.values > 2j
+
+    def test_bool_flex_frame_object_dtype(self):
         # corner, dtype=object
         df1 = pd.DataFrame({"col": ["foo", np.nan, "bar"]})
         df2 = pd.DataFrame({"col": ["foo", datetime.now(), "bar"]})
@@ -300,6 +332,21 @@ def test_df_flex_cmp_constant_return_types_empty(self, opname):
 
 
 class TestFrameFlexArithmetic:
+    def test_floordiv_axis0(self):
+        # make sure we df.floordiv(ser, axis=0) matches column-wise result
+        arr = np.arange(3)
+        ser = pd.Series(arr)
+        df = pd.DataFrame({"A": ser, "B": ser})
+
+        result = df.floordiv(ser, axis=0)
+
+        expected = pd.DataFrame({col: df[col] // ser for col in df.columns})
+
+        tm.assert_frame_equal(result, expected)
+
+        result2 = df.floordiv(ser.values, axis=0)
+        tm.assert_frame_equal(result2, expected)
+
     def test_df_add_td64_columnwise(self):
         # GH 22534 Check that column-wise addition broadcasts correctly
         dti = pd.date_range("2016-01-01", periods=10)
@@ -445,7 +492,7 @@ def test_arith_flex_series(self, simple_frame):
     def test_arith_flex_zero_len_raises(self):
         # GH 19522 passing fill_value to frame flex arith methods should
         # raise even in the zero-length special cases
-        ser_len0 = pd.Series([])
+        ser_len0 = pd.Series([], dtype=object)
         df_len0 = pd.DataFrame(columns=["A", "B"])
         df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
 
@@ -457,6 +504,16 @@ def test_arith_flex_zero_len_raises(self):
 
 
 class TestFrameArithmetic:
+    def test_td64_op_nat_casting(self):
+        # Make sure we don't accidentally treat timedelta64(NaT) as datetime64
+        #  when calling dispatch_to_series in DataFrame arithmetic
+        ser = pd.Series(["NaT", "NaT"], dtype="timedelta64[ns]")
+        df = pd.DataFrame([[1, 2], [3, 4]])
+
+        result = df * ser
+        expected = pd.DataFrame({0: ser, 1: ser})
+        tm.assert_frame_equal(result, expected)
+
     def test_df_add_2d_array_rowlike_broadcasts(self):
         # GH#23000
         arr = np.arange(6).reshape(3, 2)
@@ -653,3 +710,45 @@ def test_operations_with_interval_categories_index(self, all_arithmetic_operator
         result = getattr(df, op)(num)
         expected = pd.DataFrame([[getattr(n, op)(num) for n in data]], columns=ind)
         tm.assert_frame_equal(result, expected)
+
+
+def test_frame_with_zero_len_series_corner_cases():
+    # GH#28600
+    # easy all-float case
+    df = pd.DataFrame(np.random.randn(6).reshape(3, 2), columns=["A", "B"])
+    ser = pd.Series(dtype=np.float64)
+
+    result = df + ser
+    expected = pd.DataFrame(df.values * np.nan, columns=df.columns)
+    tm.assert_frame_equal(result, expected)
+
+    result = df == ser
+    expected = pd.DataFrame(False, index=df.index, columns=df.columns)
+    tm.assert_frame_equal(result, expected)
+
+    # non-float case should not raise on comparison
+    df2 = pd.DataFrame(df.values.view("M8[ns]"), columns=df.columns)
+    result = df2 == ser
+    expected = pd.DataFrame(False, index=df.index, columns=df.columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_zero_len_frame_with_series_corner_cases():
+    # GH#28600
+    df = pd.DataFrame(columns=["A", "B"], dtype=np.float64)
+    ser = pd.Series([1, 2], index=["A", "B"])
+
+    result = df + ser
+    expected = df
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_single_columns_object_sum_axis_1():
+    # GH 13758
+    data = {
+        "One": pd.Series(["A", 1.2, np.nan]),
+    }
+    df = pd.DataFrame(data)
+    result = df.sum(axis=1)
+    expected = pd.Series(["A", 1.2, 0])
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index 1ef10ea5857d0..7effa98fd8213 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -8,8 +8,7 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Index, MultiIndex, Series, date_range, isna
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 class TestDataFrameSelectReindex:
@@ -73,10 +72,10 @@ def test_drop_col_still_multiindex(self):
 
     def test_drop(self):
         simple = DataFrame({"A": [1, 2, 3, 4], "B": [0, 1, 2, 3]})
-        assert_frame_equal(simple.drop("A", axis=1), simple[["B"]])
-        assert_frame_equal(simple.drop(["A", "B"], axis="columns"), simple[[]])
-        assert_frame_equal(simple.drop([0, 1, 3], axis=0), simple.loc[[2], :])
-        assert_frame_equal(simple.drop([0, 3], axis="index"), simple.loc[[1, 2], :])
+        tm.assert_frame_equal(simple.drop("A", axis=1), simple[["B"]])
+        tm.assert_frame_equal(simple.drop(["A", "B"], axis="columns"), simple[[]])
+        tm.assert_frame_equal(simple.drop([0, 1, 3], axis=0), simple.loc[[2], :])
+        tm.assert_frame_equal(simple.drop([0, 3], axis="index"), simple.loc[[1, 2], :])
 
         with pytest.raises(KeyError, match=r"\[5\] not found in axis"):
             simple.drop(5)
@@ -88,12 +87,12 @@ def test_drop(self):
             simple.drop(["A", "C"], 1)
 
         # errors = 'ignore'
-        assert_frame_equal(simple.drop(5, errors="ignore"), simple)
-        assert_frame_equal(
+        tm.assert_frame_equal(simple.drop(5, errors="ignore"), simple)
+        tm.assert_frame_equal(
             simple.drop([0, 5], errors="ignore"), simple.loc[[1, 2, 3], :]
         )
-        assert_frame_equal(simple.drop("C", axis=1, errors="ignore"), simple)
-        assert_frame_equal(
+        tm.assert_frame_equal(simple.drop("C", axis=1, errors="ignore"), simple)
+        tm.assert_frame_equal(
             simple.drop(["A", "C"], axis=1, errors="ignore"), simple[["B"]]
         )
 
@@ -101,21 +100,21 @@ def test_drop(self):
         nu_df = DataFrame(
             list(zip(range(3), range(-3, 1), list("abc"))), columns=["a", "a", "b"]
         )
-        assert_frame_equal(nu_df.drop("a", axis=1), nu_df[["b"]])
-        assert_frame_equal(nu_df.drop("b", axis="columns"), nu_df["a"])
-        assert_frame_equal(nu_df.drop([]), nu_df)  # GH 16398
+        tm.assert_frame_equal(nu_df.drop("a", axis=1), nu_df[["b"]])
+        tm.assert_frame_equal(nu_df.drop("b", axis="columns"), nu_df["a"])
+        tm.assert_frame_equal(nu_df.drop([]), nu_df)  # GH 16398
 
         nu_df = nu_df.set_index(pd.Index(["X", "Y", "X"]))
         nu_df.columns = list("abc")
-        assert_frame_equal(nu_df.drop("X", axis="rows"), nu_df.loc[["Y"], :])
-        assert_frame_equal(nu_df.drop(["X", "Y"], axis=0), nu_df.loc[[], :])
+        tm.assert_frame_equal(nu_df.drop("X", axis="rows"), nu_df.loc[["Y"], :])
+        tm.assert_frame_equal(nu_df.drop(["X", "Y"], axis=0), nu_df.loc[[], :])
 
         # inplace cache issue
         # GH 5628
         df = pd.DataFrame(np.random.randn(10, 3), columns=list("abc"))
         expected = df[~(df.b > 0)]
         df.drop(labels=df[df.b > 0].index, inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_drop_multiindex_not_lexsorted(self):
         # GH 11640
@@ -266,7 +265,7 @@ def test_reindex(self, float_frame):
 
         # copy with no axes
         result = float_frame.reindex()
-        assert_frame_equal(result, float_frame)
+        tm.assert_frame_equal(result, float_frame)
         assert result is not float_frame
 
     def test_reindex_nan(self):
@@ -277,10 +276,10 @@ def test_reindex_nan(self):
         )
 
         i, j = [np.nan, 5, 5, np.nan, 1, 2, np.nan], [1, 3, 3, 1, 2, 0, 1]
-        assert_frame_equal(df.reindex(i), df.iloc[j])
+        tm.assert_frame_equal(df.reindex(i), df.iloc[j])
 
         df.index = df.index.astype("object")
-        assert_frame_equal(df.reindex(i), df.iloc[j], check_index_type=False)
+        tm.assert_frame_equal(df.reindex(i), df.iloc[j], check_index_type=False)
 
         # GH10388
         df = pd.DataFrame(
@@ -296,7 +295,7 @@ def test_reindex_nan(self):
 
         left = df.set_index(["delta", "other", "date"]).reset_index()
         right = df.reindex(columns=["delta", "other", "date", "amount"])
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
     def test_reindex_name_remains(self):
         s = Series(np.random.rand(10))
@@ -329,7 +328,7 @@ def test_reindex_int(self, int_frame):
     def test_reindex_like(self, float_frame):
         other = float_frame.reindex(index=float_frame.index[:10], columns=["C", "B"])
 
-        assert_frame_equal(other, float_frame.reindex_like(other))
+        tm.assert_frame_equal(other, float_frame.reindex_like(other))
 
     def test_reindex_columns(self, float_frame):
         new_frame = float_frame.reindex(columns=["A", "B", "E"])
@@ -364,7 +363,7 @@ def test_reindex_columns_method(self):
             columns=range(6),
             dtype=float,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # method='ffill'
         result = df.reindex(columns=range(6), method="ffill")
@@ -378,7 +377,7 @@ def test_reindex_columns_method(self):
             columns=range(6),
             dtype=float,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # method='bfill'
         result = df.reindex(columns=range(6), method="bfill")
@@ -392,7 +391,7 @@ def test_reindex_columns_method(self):
             columns=range(6),
             dtype=float,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_axes(self):
         # GH 3317, reindexing by both axes loses freq of the index
@@ -419,29 +418,29 @@ def test_reindex_fill_value(self):
 
         result = df.reindex(range(15), fill_value=0)
         expected = df.reindex(range(15)).fillna(0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # axis=1
         result = df.reindex(columns=range(5), fill_value=0.0)
         expected = df.copy()
         expected[4] = 0.0
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex(columns=range(5), fill_value=0)
         expected = df.copy()
         expected[4] = 0
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex(columns=range(5), fill_value="foo")
         expected = df.copy()
         expected[4] = "foo"
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # other dtypes
         df["foo"] = "foo"
         result = df.reindex(range(15), fill_value=0)
         expected = df.reindex(range(15)).fillna(0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_dups(self):
 
@@ -453,7 +452,7 @@ def test_reindex_dups(self):
         result = df.copy()
         result.index = list(range(len(df)))
         expected = DataFrame(arr, index=list(range(len(df))))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # reindex fails
         msg = "cannot reindex from a duplicate axis"
@@ -467,13 +466,13 @@ def test_reindex_axis_style(self):
             {"A": [1, 2, np.nan], "B": [4, 5, np.nan]}, index=[0, 1, 3]
         )
         result = df.reindex([0, 1, 3])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex([0, 1, 3], axis=0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex([0, 1, 3], axis="index")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_positional_warns(self):
         # https://github.com/pandas-dev/pandas/issues/12392
@@ -482,7 +481,7 @@ def test_reindex_positional_warns(self):
         with tm.assert_produces_warning(FutureWarning):
             result = df.reindex([0, 1], ["A", "B", "C"])
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_axis_style_raises(self):
         # https://github.com/pandas-dev/pandas/issues/12392
@@ -524,7 +523,7 @@ def test_reindex_single_named_indexer(self):
         df = pd.DataFrame({"A": [1, 2, 3], "B": [1, 2, 3]})
         result = df.reindex([0, 1], columns=["A"])
         expected = pd.DataFrame({"A": [1, 2]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_api_equivalence(self):
         # https://github.com/pandas-dev/pandas/issues/12392
@@ -699,8 +698,8 @@ def _check_align(self, a, b, axis, fill_axis, how, method, limit=None):
         ea = ea.fillna(axis=fill_axis, method=method, limit=limit)
         eb = eb.fillna(axis=fill_axis, method=method, limit=limit)
 
-        assert_frame_equal(aa, ea)
-        assert_frame_equal(ab, eb)
+        tm.assert_frame_equal(aa, ea)
+        tm.assert_frame_equal(ab, eb)
 
     @pytest.mark.parametrize("meth", ["pad", "bfill"])
     @pytest.mark.parametrize("ax", [0, 1, None])
@@ -750,7 +749,7 @@ def test_align_int_fill_bug(self):
 
         result = df1 - df1.mean()
         expected = df2 - df2.mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_align_multiindex(self):
         # GH 10665
@@ -768,11 +767,11 @@ def test_align_multiindex(self):
         res2l, res2r = df2.align(df1, join="right")
 
         expl = df1
-        assert_frame_equal(expl, res1l)
-        assert_frame_equal(expl, res2r)
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
         expr = pd.DataFrame([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
-        assert_frame_equal(expr, res1r)
-        assert_frame_equal(expr, res2l)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
 
         res1l, res1r = df1.align(df2, join="right")
         res2l, res2r = df2.align(df1, join="left")
@@ -781,11 +780,11 @@ def test_align_multiindex(self):
             [range(2), range(2), range(2)], names=("a", "b", "c")
         )
         expl = pd.DataFrame([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
-        assert_frame_equal(expl, res1l)
-        assert_frame_equal(expl, res2r)
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
         expr = pd.DataFrame([0, 0, 1, 1] * 2, index=exp_idx)
-        assert_frame_equal(expr, res1r)
-        assert_frame_equal(expr, res2l)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
 
     def test_align_series_combinations(self):
         df = pd.DataFrame({"a": [1, 3, 5], "b": [1, 3, 5]}, index=list("ACE"))
@@ -895,7 +894,7 @@ def test_filter_regex_search(self, float_frame):
 
         result = df.filter(regex="BB")
         exp = df[[x for x in df.columns if "BB" in x]]
-        assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, exp)
 
     @pytest.mark.parametrize(
         "name,expected",
@@ -909,8 +908,8 @@ def test_filter_unicode(self, name, expected):
         # GH13101
         df = DataFrame({"a": [1, 2], "あ": [3, 4]})
 
-        assert_frame_equal(df.filter(like=name), expected)
-        assert_frame_equal(df.filter(regex=name), expected)
+        tm.assert_frame_equal(df.filter(like=name), expected)
+        tm.assert_frame_equal(df.filter(regex=name), expected)
 
     @pytest.mark.parametrize("name", ["a", "a"])
     def test_filter_bytestring(self, name):
@@ -918,17 +917,25 @@ def test_filter_bytestring(self, name):
         df = DataFrame({b"a": [1, 2], b"b": [3, 4]})
         expected = DataFrame({b"a": [1, 2]})
 
-        assert_frame_equal(df.filter(like=name), expected)
-        assert_frame_equal(df.filter(regex=name), expected)
+        tm.assert_frame_equal(df.filter(like=name), expected)
+        tm.assert_frame_equal(df.filter(regex=name), expected)
 
     def test_filter_corner(self):
         empty = DataFrame()
 
         result = empty.filter([])
-        assert_frame_equal(result, empty)
+        tm.assert_frame_equal(result, empty)
 
         result = empty.filter(like="foo")
-        assert_frame_equal(result, empty)
+        tm.assert_frame_equal(result, empty)
+
+    def test_filter_regex_non_string(self):
+        # GH#5798 trying to filter on non-string columns should drop,
+        #  not raise
+        df = pd.DataFrame(np.random.random((3, 2)), columns=["STRING", 123])
+        result = df.filter(regex="STRING")
+        expected = df[["STRING"]]
+        tm.assert_frame_equal(result, expected)
 
     def test_take(self, float_frame):
         # homogeneous
@@ -937,12 +944,12 @@ def test_take(self, float_frame):
 
             result = df.take(order, axis=0)
             expected = df.reindex(df.index.take(order))
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # axis = 1
             result = df.take(order, axis=1)
             expected = df.loc[:, ["D", "B", "C", "A"]]
-            assert_frame_equal(result, expected, check_names=False)
+            tm.assert_frame_equal(result, expected, check_names=False)
 
         # negative indices
         order = [2, 1, -1]
@@ -950,15 +957,15 @@ def test_take(self, float_frame):
 
             result = df.take(order, axis=0)
             expected = df.reindex(df.index.take(order))
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = df.take(order, axis=0)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # axis = 1
             result = df.take(order, axis=1)
             expected = df.loc[:, ["C", "B", "D"]]
-            assert_frame_equal(result, expected, check_names=False)
+            tm.assert_frame_equal(result, expected, check_names=False)
 
         # illegal indices
         msg = "indices are out-of-bounds"
@@ -979,12 +986,12 @@ def test_take_mixed_type(self, float_string_frame):
 
             result = df.take(order, axis=0)
             expected = df.reindex(df.index.take(order))
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # axis = 1
             result = df.take(order, axis=1)
             expected = df.loc[:, ["foo", "B", "C", "A", "D"]]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         # negative indices
         order = [4, 1, -2]
@@ -992,12 +999,12 @@ def test_take_mixed_type(self, float_string_frame):
 
             result = df.take(order, axis=0)
             expected = df.reindex(df.index.take(order))
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # axis = 1
             result = df.take(order, axis=1)
             expected = df.loc[:, ["foo", "B", "D"]]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_take_mixed_numeric(self, mixed_float_frame, mixed_int_frame):
         # by dtype
@@ -1006,12 +1013,12 @@ def test_take_mixed_numeric(self, mixed_float_frame, mixed_int_frame):
 
             result = df.take(order, axis=0)
             expected = df.reindex(df.index.take(order))
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # axis = 1
             result = df.take(order, axis=1)
             expected = df.loc[:, ["B", "C", "A", "D"]]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_reindex_boolean(self):
         frame = DataFrame(
@@ -1052,15 +1059,15 @@ def test_reindex_with_nans(self):
 
         result = df.reindex(index=[101.0, 102.0, 103.0])
         expected = df.iloc[[1, 3, 4]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex(index=[103.0])
         expected = df.iloc[[4]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.reindex(index=[101.0])
         expected = df.iloc[[1]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_multi(self):
         df = DataFrame(np.random.randn(3, 3))
@@ -1068,28 +1075,28 @@ def test_reindex_multi(self):
         result = df.reindex(index=range(4), columns=range(4))
         expected = df.reindex(list(range(4))).reindex(columns=range(4))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame(np.random.randint(0, 10, (3, 3)))
 
         result = df.reindex(index=range(4), columns=range(4))
         expected = df.reindex(list(range(4))).reindex(columns=range(4))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame(np.random.randint(0, 10, (3, 3)))
 
         result = df.reindex(index=range(2), columns=range(2))
         expected = df.reindex(range(2)).reindex(columns=range(2))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame(np.random.randn(5, 3) + 1j, columns=["a", "b", "c"])
 
         result = df.reindex(index=[0, 1], columns=["a", "b"])
         expected = df.reindex([0, 1]).reindex(columns=["a", "b"])
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_reindex_multi_categorical_time(self):
         # https://github.com/pandas-dev/pandas/issues/21390
@@ -1104,7 +1111,7 @@ def test_reindex_multi_categorical_time(self):
 
         result = df2.reindex(midx)
         expected = pd.DataFrame({"a": [0, 1, 2, 3, 4, 5, 6, np.nan, 8]}, index=midx)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     data = [[1, 2, 3], [1, 2, 3]]
 
@@ -1127,9 +1134,9 @@ def test_raise_on_drop_duplicate_index(self, actual):
         with pytest.raises(KeyError, match=msg):
             actual.T.drop("c", level=level, axis=1)
         expected_no_err = actual.drop("c", axis=0, level=level, errors="ignore")
-        assert_frame_equal(expected_no_err, actual)
+        tm.assert_frame_equal(expected_no_err, actual)
         expected_no_err = actual.T.drop("c", axis=1, level=level, errors="ignore")
-        assert_frame_equal(expected_no_err.T, actual)
+        tm.assert_frame_equal(expected_no_err.T, actual)
 
     @pytest.mark.parametrize("index", [[1, 2, 3], [1, 1, 2]])
     @pytest.mark.parametrize("drop_labels", [[], [1], [2]])
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 1b6ee91317996..a5f5e6f36cd58 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -15,15 +15,10 @@
     date_range,
     option_context,
 )
+import pandas._testing as tm
 from pandas.core.arrays import IntervalArray, integer_array
 from pandas.core.internals import ObjectBlock
 from pandas.core.internals.blocks import IntBlock
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
 
 # Segregated collection of methods that require the BlockManager internal data
 # structure
@@ -50,11 +45,11 @@ def test_setitem_invalidates_datetime_index_freq(self):
     def test_cast_internals(self, float_frame):
         casted = DataFrame(float_frame._data, dtype=int)
         expected = DataFrame(float_frame._series, dtype=int)
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
         casted = DataFrame(float_frame._data, dtype=np.int32)
         expected = DataFrame(float_frame._series, dtype=np.int32)
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
     def test_consolidate(self, float_frame):
         float_frame["E"] = 7.0
@@ -101,7 +96,7 @@ def test_boolean_set_uncons(self, float_frame):
         expected[expected > 1] = 2
 
         float_frame[float_frame > 1] = 2
-        assert_almost_equal(expected, float_frame.values)
+        tm.assert_almost_equal(expected, float_frame.values)
 
     def test_values_numeric_cols(self, float_frame):
         float_frame["foo"] = "bar"
@@ -155,66 +150,66 @@ def test_constructor_with_convert(self):
         df = DataFrame({"A": [2 ** 63 - 1]})
         result = df["A"]
         expected = Series(np.asarray([2 ** 63 - 1], np.int64), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [2 ** 63]})
         result = df["A"]
         expected = Series(np.asarray([2 ** 63], np.uint64), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [datetime(2005, 1, 1), True]})
         result = df["A"]
         expected = Series(
             np.asarray([datetime(2005, 1, 1), True], np.object_), name="A"
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [None, 1]})
         result = df["A"]
         expected = Series(np.asarray([np.nan, 1], np.float_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0, 2]})
         result = df["A"]
         expected = Series(np.asarray([1.0, 2], np.float_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0 + 2.0j, 3]})
         result = df["A"]
         expected = Series(np.asarray([1.0 + 2.0j, 3], np.complex_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0 + 2.0j, 3.0]})
         result = df["A"]
         expected = Series(np.asarray([1.0 + 2.0j, 3.0], np.complex_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0 + 2.0j, True]})
         result = df["A"]
         expected = Series(np.asarray([1.0 + 2.0j, True], np.object_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0, None]})
         result = df["A"]
         expected = Series(np.asarray([1.0, np.nan], np.float_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [1.0 + 2.0j, None]})
         result = df["A"]
         expected = Series(np.asarray([1.0 + 2.0j, np.nan], np.complex_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [2.0, 1, True, None]})
         result = df["A"]
         expected = Series(np.asarray([2.0, 1, True, None], np.object_), name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame({"A": [2.0, 1, datetime(2006, 1, 1), None]})
         result = df["A"]
         expected = Series(
             np.asarray([2.0, 1, datetime(2006, 1, 1), None], np.object_), name="A"
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_construction_with_mixed(self, float_string_frame):
         # test construction edge cases with mixed types
@@ -245,7 +240,7 @@ def test_construction_with_mixed(self, float_string_frame):
             ],
             index=list("ABCD") + ["foo", "datetime", "timedelta"],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_construction_with_conversions(self):
 
@@ -256,7 +251,7 @@ def test_construction_with_conversions(self):
         expected = DataFrame(
             {"A": pd.timedelta_range("00:00:01", periods=3, freq="s")}, index=range(3)
         )
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         expected = DataFrame(
             {
@@ -276,7 +271,7 @@ def test_construction_with_conversions(self):
         # df['dt3'] = np.array(['2013-01-01 00:00:01','2013-01-01
         # 00:00:02','2013-01-01 00:00:03'],dtype='datetime64[s]')
 
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_constructor_compound_dtypes(self):
         # GH 5191
@@ -308,7 +303,7 @@ def test_equals_different_blocks(self):
         assert df0._data.blocks[0].dtype != df1._data.blocks[0].dtype
 
         # do the real tests
-        assert_frame_equal(df0, df1)
+        tm.assert_frame_equal(df0, df1)
         assert df0.equals(df1)
         assert df1.equals(df0)
 
@@ -318,10 +313,7 @@ def test_copy_blocks(self, float_frame):
         column = df.columns[0]
 
         # use the default copy=True, change a column
-
-        # deprecated 0.21.0
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            blocks = df.as_blocks()
+        blocks = df._to_dict_of_blocks(copy=True)
         for dtype, _df in blocks.items():
             if column in _df:
                 _df.loc[:, column] = _df[column] + 1
@@ -335,10 +327,7 @@ def test_no_copy_blocks(self, float_frame):
         column = df.columns[0]
 
         # use the copy=False, change a column
-
-        # deprecated 0.21.0
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            blocks = df.as_blocks(copy=False)
+        blocks = df._to_dict_of_blocks(copy=False)
         for dtype, _df in blocks.items():
             if column in _df:
                 _df.loc[:, column] = _df[column] + 1
@@ -359,7 +348,7 @@ def test_pickle(self, float_string_frame, timezone_frame):
         empty_frame = DataFrame()
 
         unpickled = tm.round_trip_pickle(float_string_frame)
-        assert_frame_equal(float_string_frame, unpickled)
+        tm.assert_frame_equal(float_string_frame, unpickled)
 
         # buglet
         float_string_frame._data.ndim
@@ -370,19 +359,19 @@ def test_pickle(self, float_string_frame, timezone_frame):
 
         # tz frame
         unpickled = tm.round_trip_pickle(timezone_frame)
-        assert_frame_equal(timezone_frame, unpickled)
+        tm.assert_frame_equal(timezone_frame, unpickled)
 
     def test_consolidate_datetime64(self):
         # numpy vstack bug
 
-        data = """\
-starting,ending,measure
-2012-06-21 00:00,2012-06-23 07:00,77
-2012-06-23 07:00,2012-06-23 16:30,65
-2012-06-23 16:30,2012-06-25 08:00,77
-2012-06-25 08:00,2012-06-26 12:00,0
-2012-06-26 12:00,2012-06-27 08:00,77
-"""
+        data = (
+            "starting,ending,measure\n"
+            "2012-06-21 00:00,2012-06-23 07:00,77\n"
+            "2012-06-23 07:00,2012-06-23 16:30,65\n"
+            "2012-06-23 16:30,2012-06-25 08:00,77\n"
+            "2012-06-25 08:00,2012-06-26 12:00,0\n"
+            "2012-06-26 12:00,2012-06-27 08:00,77\n"
+        )
         df = pd.read_csv(StringIO(data), parse_dates=[0, 1])
 
         ser_starting = df.starting
@@ -408,9 +397,6 @@ def test_is_mixed_type(self, float_frame, float_string_frame):
         assert float_string_frame._is_mixed_type
 
     def test_get_numeric_data(self):
-        # TODO(wesm): unused?
-        intname = np.dtype(np.int_).name  # noqa
-        floatname = np.dtype(np.float_).name  # noqa
 
         datetime64name = np.dtype("M8[ns]").name
         objectname = np.dtype(np.object_).name
@@ -429,7 +415,7 @@ def test_get_numeric_data(self):
             ],
             index=["a", "b", "c", "f"],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame(
             {
@@ -446,22 +432,22 @@ def test_get_numeric_data(self):
 
         result = df._get_numeric_data()
         expected = df.loc[:, ["a", "b", "d", "e", "f"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         only_obj = df.loc[:, ["c", "g"]]
         result = only_obj._get_numeric_data()
         expected = df.loc[:, []]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame.from_dict({"a": [1, 2], "b": ["foo", "bar"], "c": [np.pi, np.e]})
         result = df._get_numeric_data()
         expected = DataFrame.from_dict({"a": [1, 2], "c": [np.pi, np.e]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = result.copy()
         result = df._get_numeric_data()
         expected = df
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_get_numeric_data_extension_dtype(self):
         # GH 22290
@@ -475,13 +461,13 @@ def test_get_numeric_data_extension_dtype(self):
         )
         result = df._get_numeric_data()
         expected = df.loc[:, ["A", "C"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_convert_objects(self, float_string_frame):
 
         oops = float_string_frame.T.T
         converted = oops._convert(datetime=True)
-        assert_frame_equal(converted, float_string_frame)
+        tm.assert_frame_equal(converted, float_string_frame)
         assert converted["A"].dtype == np.float64
 
         # force numeric conversion
@@ -517,12 +503,12 @@ def test_convert_objects(self, float_string_frame):
         df = DataFrame(dict(s=Series([1, "na", 3, 4])))
         result = df._convert(datetime=True, numeric=True)
         expected = DataFrame(dict(s=Series([1, np.nan, 3, 4])))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_convert_objects_no_conversion(self):
         mixed1 = DataFrame({"a": [1, 2, 3], "b": [4.0, 5, 6], "c": ["x", "y", "z"]})
         mixed2 = mixed1._convert(datetime=True)
-        assert_frame_equal(mixed1, mixed2)
+        tm.assert_frame_equal(mixed1, mixed2)
 
     def test_infer_objects(self):
         # GH 11221
@@ -592,14 +578,11 @@ def test_get_X_columns(self):
         tm.assert_index_equal(df._get_numeric_data().columns, pd.Index(["a", "b", "e"]))
 
     def test_strange_column_corruption_issue(self):
+        # FIXME: dont leave commented-out
         # (wesm) Unclear how exactly this is related to internal matters
         df = DataFrame(index=[0, 1])
         df[0] = np.nan
         wasCol = {}
-        # uncommenting these makes the results match
-        # for col in xrange(100, 200):
-        #    wasCol[col] = 1
-        #    df[col] = np.nan
 
         for i, dt in enumerate(df.index):
             for col in range(100, 200):
@@ -626,14 +609,14 @@ def test_constructor_no_pandas_array(self):
     def test_add_column_with_pandas_array(self):
         # GH 26390
         df = pd.DataFrame({"a": [1, 2, 3, 4], "b": ["a", "b", "c", "d"]})
-        df["c"] = pd.array([1, 2, None, 3])
+        df["c"] = pd.arrays.PandasArray(np.array([1, 2, None, 3], dtype=object))
         df2 = pd.DataFrame(
             {
                 "a": [1, 2, 3, 4],
                 "b": ["a", "b", "c", "d"],
-                "c": pd.array([1, 2, None, 3]),
+                "c": pd.arrays.PandasArray(np.array([1, 2, None, 3], dtype=object)),
             }
         )
         assert type(df["c"]._data.blocks[0]) == ObjectBlock
         assert type(df2["c"]._data.blocks[0]) == ObjectBlock
-        assert_frame_equal(df, df2)
+        tm.assert_frame_equal(df, df2)
diff --git a/pandas/tests/frame/test_combine_concat.py b/pandas/tests/frame/test_combine_concat.py
index e38d214eadeb6..36a476d195fe5 100644
--- a/pandas/tests/frame/test_combine_concat.py
+++ b/pandas/tests/frame/test_combine_concat.py
@@ -5,8 +5,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 class TestDataFrameConcatCommon:
@@ -20,7 +19,7 @@ def test_concat_multiple_frames_dtypes(self):
             [np.dtype("float64")] * 2 + [np.dtype("float32")] * 2,
             index=["foo", "bar", 0, 1],
         )
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
     @pytest.mark.parametrize(
         "data",
@@ -56,15 +55,15 @@ def test_concat_multiple_tzs(self):
 
         results = pd.concat([df1, df2]).reset_index(drop=True)
         expected = DataFrame(dict(time=[ts1, ts2]), dtype=object)
-        assert_frame_equal(results, expected)
+        tm.assert_frame_equal(results, expected)
 
         results = pd.concat([df1, df3]).reset_index(drop=True)
         expected = DataFrame(dict(time=[ts1, ts3]), dtype=object)
-        assert_frame_equal(results, expected)
+        tm.assert_frame_equal(results, expected)
 
         results = pd.concat([df2, df3]).reset_index(drop=True)
         expected = DataFrame(dict(time=[ts2, ts3]))
-        assert_frame_equal(results, expected)
+        tm.assert_frame_equal(results, expected)
 
     @pytest.mark.parametrize(
         "t1",
@@ -91,7 +90,7 @@ def test_concat_tz_NaT(self, t1):
         result = pd.concat([df1, df2])
         expected = DataFrame([[ts1, ts2], [ts3, pd.NaT]], index=[0, 0])
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_tz_not_aligned(self):
         # GH 22796
@@ -102,7 +101,7 @@ def test_concat_tz_not_aligned(self):
         expected = pd.DataFrame(
             {"A": list(ts) + list(ts), "B": [pd.NaT, pd.NaT] + list(ts)}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_tuple_keys(self):
         # GH 14438
@@ -127,269 +126,7 @@ def test_concat_tuple_keys(self):
                 },
             }
         )
-        assert_frame_equal(results, expected)
-
-    def test_append_series_dict(self):
-        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
-
-        series = df.loc[4]
-        msg = "Indexes have overlapping values"
-        with pytest.raises(ValueError, match=msg):
-            df.append(series, verify_integrity=True)
-
-        series.name = None
-        msg = "Can only append a Series if ignore_index=True"
-        with pytest.raises(TypeError, match=msg):
-            df.append(series, verify_integrity=True)
-
-        result = df.append(series[::-1], ignore_index=True)
-        expected = df.append(
-            DataFrame({0: series[::-1]}, index=df.columns).T, ignore_index=True
-        )
-        assert_frame_equal(result, expected)
-
-        # dict
-        result = df.append(series.to_dict(), ignore_index=True)
-        assert_frame_equal(result, expected)
-
-        result = df.append(series[::-1][:3], ignore_index=True)
-        expected = df.append(
-            DataFrame({0: series[::-1][:3]}).T, ignore_index=True, sort=True
-        )
-        assert_frame_equal(result, expected.loc[:, result.columns])
-
-        # can append when name set
-        row = df.loc[4]
-        row.name = 5
-        result = df.append(row)
-        expected = df.append(df[-1:], ignore_index=True)
-        assert_frame_equal(result, expected)
-
-    def test_append_list_of_series_dicts(self):
-        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
-
-        dicts = [x.to_dict() for idx, x in df.iterrows()]
-
-        result = df.append(dicts, ignore_index=True)
-        expected = df.append(df, ignore_index=True)
-        assert_frame_equal(result, expected)
-
-        # different columns
-        dicts = [
-            {"foo": 1, "bar": 2, "baz": 3, "peekaboo": 4},
-            {"foo": 5, "bar": 6, "baz": 7, "peekaboo": 8},
-        ]
-        result = df.append(dicts, ignore_index=True, sort=True)
-        expected = df.append(DataFrame(dicts), ignore_index=True, sort=True)
-        assert_frame_equal(result, expected)
-
-    def test_append_missing_cols(self):
-        # GH22252
-        # exercise the conditional branch in append method where the data
-        # to be appended is a list and does not contain all columns that are in
-        # the target DataFrame
-        df = DataFrame(np.random.randn(5, 4), columns=["foo", "bar", "baz", "qux"])
-
-        dicts = [{"foo": 9}, {"bar": 10}]
-        with tm.assert_produces_warning(None):
-            result = df.append(dicts, ignore_index=True, sort=True)
-
-        expected = df.append(DataFrame(dicts), ignore_index=True, sort=True)
-        assert_frame_equal(result, expected)
-
-    def test_append_empty_dataframe(self):
-
-        # Empty df append empty df
-        df1 = DataFrame()
-        df2 = DataFrame()
-        result = df1.append(df2)
-        expected = df1.copy()
-        assert_frame_equal(result, expected)
-
-        # Non-empty df append empty df
-        df1 = DataFrame(np.random.randn(5, 2))
-        df2 = DataFrame()
-        result = df1.append(df2)
-        expected = df1.copy()
-        assert_frame_equal(result, expected)
-
-        # Empty df with columns append empty df
-        df1 = DataFrame(columns=["bar", "foo"])
-        df2 = DataFrame()
-        result = df1.append(df2)
-        expected = df1.copy()
-        assert_frame_equal(result, expected)
-
-        # Non-Empty df with columns append empty df
-        df1 = DataFrame(np.random.randn(5, 2), columns=["bar", "foo"])
-        df2 = DataFrame()
-        result = df1.append(df2)
-        expected = df1.copy()
-        assert_frame_equal(result, expected)
-
-    def test_append_dtypes(self):
-
-        # GH 5754
-        # row appends of different dtypes (so need to do by-item)
-        # can sometimes infer the correct type
-
-        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(5))
-        df2 = DataFrame()
-        result = df1.append(df2)
-        expected = df1.copy()
-        assert_frame_equal(result, expected)
-
-        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
-        df2 = DataFrame({"bar": "foo"}, index=range(1, 2))
-        result = df1.append(df2)
-        expected = DataFrame({"bar": [Timestamp("20130101"), "foo"]})
-        assert_frame_equal(result, expected)
-
-        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
-        df2 = DataFrame({"bar": np.nan}, index=range(1, 2))
-        result = df1.append(df2)
-        expected = DataFrame(
-            {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
-        )
-        assert_frame_equal(result, expected)
-
-        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
-        df2 = DataFrame({"bar": np.nan}, index=range(1, 2), dtype=object)
-        result = df1.append(df2)
-        expected = DataFrame(
-            {"bar": Series([Timestamp("20130101"), np.nan], dtype="M8[ns]")}
-        )
-        assert_frame_equal(result, expected)
-
-        df1 = DataFrame({"bar": np.nan}, index=range(1))
-        df2 = DataFrame({"bar": Timestamp("20130101")}, index=range(1, 2))
-        result = df1.append(df2)
-        expected = DataFrame(
-            {"bar": Series([np.nan, Timestamp("20130101")], dtype="M8[ns]")}
-        )
-        assert_frame_equal(result, expected)
-
-        df1 = DataFrame({"bar": Timestamp("20130101")}, index=range(1))
-        df2 = DataFrame({"bar": 1}, index=range(1, 2), dtype=object)
-        result = df1.append(df2)
-        expected = DataFrame({"bar": Series([Timestamp("20130101"), 1])})
-        assert_frame_equal(result, expected)
-
-    def test_update(self):
-        df = DataFrame(
-            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
-        )
-
-        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
-
-        df.update(other)
-
-        expected = DataFrame(
-            [[1.5, np.nan, 3], [3.6, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
-        )
-        assert_frame_equal(df, expected)
-
-    def test_update_dtypes(self):
-
-        # gh 3016
-        df = DataFrame(
-            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
-            columns=["A", "B", "bool1", "bool2"],
-        )
-
-        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
-        df.update(other)
-
-        expected = DataFrame(
-            [[45.0, 45.0, False, True], [4.0, 5.0, True, False]],
-            columns=["A", "B", "bool1", "bool2"],
-        )
-        assert_frame_equal(df, expected)
-
-    def test_update_nooverwrite(self):
-        df = DataFrame(
-            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
-        )
-
-        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
-
-        df.update(other, overwrite=False)
-
-        expected = DataFrame(
-            [[1.5, np.nan, 3], [1.5, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 3.0]]
-        )
-        assert_frame_equal(df, expected)
-
-    def test_update_filtered(self):
-        df = DataFrame(
-            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
-        )
-
-        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
-
-        df.update(other, filter_func=lambda x: x > 2)
-
-        expected = DataFrame(
-            [[1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
-        )
-        assert_frame_equal(df, expected)
-
-    @pytest.mark.parametrize(
-        "bad_kwarg, exception, msg",
-        [
-            # errors must be 'ignore' or 'raise'
-            ({"errors": "something"}, ValueError, "The parameter errors must.*"),
-            ({"join": "inner"}, NotImplementedError, "Only left join is supported"),
-        ],
-    )
-    def test_update_raise_bad_parameter(self, bad_kwarg, exception, msg):
-        df = DataFrame([[1.5, 1, 3.0]])
-        with pytest.raises(exception, match=msg):
-            df.update(df, **bad_kwarg)
-
-    def test_update_raise_on_overlap(self):
-        df = DataFrame(
-            [[1.5, 1, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
-        )
-
-        other = DataFrame([[2.0, np.nan], [np.nan, 7]], index=[1, 3], columns=[1, 2])
-        with pytest.raises(ValueError, match="Data overlaps"):
-            df.update(other, errors="raise")
-
-    @pytest.mark.parametrize("raise_conflict", [True, False])
-    def test_update_deprecation(self, raise_conflict):
-        df = DataFrame([[1.5, 1, 3.0]])
-        other = DataFrame()
-        with tm.assert_produces_warning(FutureWarning):
-            df.update(other, raise_conflict=raise_conflict)
-
-    def test_update_from_non_df(self):
-        d = {"a": Series([1, 2, 3, 4]), "b": Series([5, 6, 7, 8])}
-        df = DataFrame(d)
-
-        d["a"] = Series([5, 6, 7, 8])
-        df.update(d)
-
-        expected = DataFrame(d)
-
-        assert_frame_equal(df, expected)
-
-        d = {"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]}
-        df = DataFrame(d)
-
-        d["a"] = [5, 6, 7, 8]
-        df.update(d)
-
-        expected = DataFrame(d)
-
-        assert_frame_equal(df, expected)
-
-    def test_update_datetime_tz(self):
-        # GH 25807
-        result = DataFrame([pd.Timestamp("2019", tz="UTC")])
-        result.update(result)
-        expected = DataFrame([pd.Timestamp("2019", tz="UTC")])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(results, expected)
 
     def test_join_str_datetime(self):
         str_dates = ["20120209", "20120222"]
@@ -440,8 +177,8 @@ def test_join_multiindex_leftright(self):
         )
 
         # these must be the same results (but columns are flipped)
-        assert_frame_equal(df1.join(df2, how="left"), exp)
-        assert_frame_equal(df2.join(df1, how="right"), exp[["value2", "value1"]])
+        tm.assert_frame_equal(df1.join(df2, how="left"), exp)
+        tm.assert_frame_equal(df2.join(df1, how="right"), exp[["value2", "value1"]])
 
         exp_idx = pd.MultiIndex.from_product(
             [["a", "b"], ["x", "y", "z"]], names=["first", "second"]
@@ -459,8 +196,8 @@ def test_join_multiindex_leftright(self):
             columns=["value1", "value2"],
         )
 
-        assert_frame_equal(df1.join(df2, how="right"), exp)
-        assert_frame_equal(df2.join(df1, how="left"), exp[["value2", "value1"]])
+        tm.assert_frame_equal(df1.join(df2, how="right"), exp)
+        tm.assert_frame_equal(df2.join(df1, how="left"), exp[["value2", "value1"]])
 
     def test_concat_named_keys(self):
         # GH 14252
@@ -471,20 +208,20 @@ def test_concat_named_keys(self):
             {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
             index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=["baz", None]),
         )
-        assert_frame_equal(concatted_named_from_keys, expected_named)
+        tm.assert_frame_equal(concatted_named_from_keys, expected_named)
 
         index_no_name = Index(["a", "b"], name=None)
         concatted_named_from_names = pd.concat(
             [df, df], keys=index_no_name, names=["baz"]
         )
-        assert_frame_equal(concatted_named_from_names, expected_named)
+        tm.assert_frame_equal(concatted_named_from_names, expected_named)
 
         concatted_unnamed = pd.concat([df, df], keys=index_no_name)
         expected_unnamed = pd.DataFrame(
             {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
             index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=[None, None]),
         )
-        assert_frame_equal(concatted_unnamed, expected_unnamed)
+        tm.assert_frame_equal(concatted_unnamed, expected_unnamed)
 
     def test_concat_axis_parameter(self):
         # GH 14369
@@ -495,13 +232,13 @@ def test_concat_axis_parameter(self):
         expected_index = pd.DataFrame({"A": [0.1, 0.2, 0.3, 0.4]}, index=[0, 1, 0, 1])
 
         concatted_index = pd.concat([df1, df2], axis="index")
-        assert_frame_equal(concatted_index, expected_index)
+        tm.assert_frame_equal(concatted_index, expected_index)
 
         concatted_row = pd.concat([df1, df2], axis="rows")
-        assert_frame_equal(concatted_row, expected_index)
+        tm.assert_frame_equal(concatted_row, expected_index)
 
         concatted_0 = pd.concat([df1, df2], axis=0)
-        assert_frame_equal(concatted_0, expected_index)
+        tm.assert_frame_equal(concatted_0, expected_index)
 
         # Columns/1 DataFrame
         expected_columns = pd.DataFrame(
@@ -509,10 +246,10 @@ def test_concat_axis_parameter(self):
         )
 
         concatted_columns = pd.concat([df1, df2], axis="columns")
-        assert_frame_equal(concatted_columns, expected_columns)
+        tm.assert_frame_equal(concatted_columns, expected_columns)
 
         concatted_1 = pd.concat([df1, df2], axis=1)
-        assert_frame_equal(concatted_1, expected_columns)
+        tm.assert_frame_equal(concatted_1, expected_columns)
 
         series1 = pd.Series([0.1, 0.2])
         series2 = pd.Series([0.3, 0.4])
@@ -521,13 +258,13 @@ def test_concat_axis_parameter(self):
         expected_index_series = pd.Series([0.1, 0.2, 0.3, 0.4], index=[0, 1, 0, 1])
 
         concatted_index_series = pd.concat([series1, series2], axis="index")
-        assert_series_equal(concatted_index_series, expected_index_series)
+        tm.assert_series_equal(concatted_index_series, expected_index_series)
 
         concatted_row_series = pd.concat([series1, series2], axis="rows")
-        assert_series_equal(concatted_row_series, expected_index_series)
+        tm.assert_series_equal(concatted_row_series, expected_index_series)
 
         concatted_0_series = pd.concat([series1, series2], axis=0)
-        assert_series_equal(concatted_0_series, expected_index_series)
+        tm.assert_series_equal(concatted_0_series, expected_index_series)
 
         # Columns/1 Series
         expected_columns_series = pd.DataFrame(
@@ -535,10 +272,10 @@ def test_concat_axis_parameter(self):
         )
 
         concatted_columns_series = pd.concat([series1, series2], axis="columns")
-        assert_frame_equal(concatted_columns_series, expected_columns_series)
+        tm.assert_frame_equal(concatted_columns_series, expected_columns_series)
 
         concatted_1_series = pd.concat([series1, series2], axis=1)
-        assert_frame_equal(concatted_1_series, expected_columns_series)
+        tm.assert_frame_equal(concatted_1_series, expected_columns_series)
 
         # Testing ValueError
         with pytest.raises(ValueError, match="No axis named"):
@@ -576,347 +313,6 @@ def test_concat_astype_dup_col(self):
         ).astype("category")
         tm.assert_frame_equal(result, expected)
 
-
-class TestDataFrameCombineFirst:
-    def test_combine_first_mixed(self):
-        a = Series(["a", "b"], index=range(2))
-        b = Series(range(2), index=range(2))
-        f = DataFrame({"A": a, "B": b})
-
-        a = Series(["a", "b"], index=range(5, 7))
-        b = Series(range(2), index=range(5, 7))
-        g = DataFrame({"A": a, "B": b})
-
-        exp = pd.DataFrame(
-            {"A": list("abab"), "B": [0.0, 1.0, 0.0, 1.0]}, index=[0, 1, 5, 6]
-        )
-        combined = f.combine_first(g)
-        tm.assert_frame_equal(combined, exp)
-
-    def test_combine_first(self, float_frame):
-        # disjoint
-        head, tail = float_frame[:5], float_frame[5:]
-
-        combined = head.combine_first(tail)
-        reordered_frame = float_frame.reindex(combined.index)
-        assert_frame_equal(combined, reordered_frame)
-        assert tm.equalContents(combined.columns, float_frame.columns)
-        assert_series_equal(combined["A"], reordered_frame["A"])
-
-        # same index
-        fcopy = float_frame.copy()
-        fcopy["A"] = 1
-        del fcopy["C"]
-
-        fcopy2 = float_frame.copy()
-        fcopy2["B"] = 0
-        del fcopy2["D"]
-
-        combined = fcopy.combine_first(fcopy2)
-
-        assert (combined["A"] == 1).all()
-        assert_series_equal(combined["B"], fcopy["B"])
-        assert_series_equal(combined["C"], fcopy2["C"])
-        assert_series_equal(combined["D"], fcopy["D"])
-
-        # overlap
-        head, tail = reordered_frame[:10].copy(), reordered_frame
-        head["A"] = 1
-
-        combined = head.combine_first(tail)
-        assert (combined["A"][:10] == 1).all()
-
-        # reverse overlap
-        tail["A"][:10] = 0
-        combined = tail.combine_first(head)
-        assert (combined["A"][:10] == 0).all()
-
-        # no overlap
-        f = float_frame[:10]
-        g = float_frame[10:]
-        combined = f.combine_first(g)
-        assert_series_equal(combined["A"].reindex(f.index), f["A"])
-        assert_series_equal(combined["A"].reindex(g.index), g["A"])
-
-        # corner cases
-        comb = float_frame.combine_first(DataFrame())
-        assert_frame_equal(comb, float_frame)
-
-        comb = DataFrame().combine_first(float_frame)
-        assert_frame_equal(comb, float_frame)
-
-        comb = float_frame.combine_first(DataFrame(index=["faz", "boo"]))
-        assert "faz" in comb.index
-
-        # #2525
-        df = DataFrame({"a": [1]}, index=[datetime(2012, 1, 1)])
-        df2 = DataFrame(columns=["b"])
-        result = df.combine_first(df2)
-        assert "b" in result
-
-    def test_combine_first_mixed_bug(self):
-        idx = Index(["a", "b", "c", "e"])
-        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
-        ser2 = Series(["a", "b", "c", "e"], index=idx)
-        ser3 = Series([12, 4, 5, 97], index=idx)
-
-        frame1 = DataFrame({"col0": ser1, "col2": ser2, "col3": ser3})
-
-        idx = Index(["a", "b", "c", "f"])
-        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
-        ser2 = Series(["a", "b", "c", "f"], index=idx)
-        ser3 = Series([12, 4, 5, 97], index=idx)
-
-        frame2 = DataFrame({"col1": ser1, "col2": ser2, "col5": ser3})
-
-        combined = frame1.combine_first(frame2)
-        assert len(combined.columns) == 5
-
-        # gh 3016 (same as in update)
-        df = DataFrame(
-            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
-            columns=["A", "B", "bool1", "bool2"],
-        )
-
-        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
-        result = df.combine_first(other)
-        assert_frame_equal(result, df)
-
-        df.loc[0, "A"] = np.nan
-        result = df.combine_first(other)
-        df.loc[0, "A"] = 45
-        assert_frame_equal(result, df)
-
-        # doc example
-        df1 = DataFrame(
-            {"A": [1.0, np.nan, 3.0, 5.0, np.nan], "B": [np.nan, 2.0, 3.0, np.nan, 6.0]}
-        )
-
-        df2 = DataFrame(
-            {
-                "A": [5.0, 2.0, 4.0, np.nan, 3.0, 7.0],
-                "B": [np.nan, np.nan, 3.0, 4.0, 6.0, 8.0],
-            }
-        )
-
-        result = df1.combine_first(df2)
-        expected = DataFrame({"A": [1, 2, 3, 5, 3, 7.0], "B": [np.nan, 2, 3, 4, 6, 8]})
-        assert_frame_equal(result, expected)
-
-        # GH3552, return object dtype with bools
-        df1 = DataFrame(
-            [[np.nan, 3.0, True], [-4.6, np.nan, True], [np.nan, 7.0, False]]
-        )
-        df2 = DataFrame([[-42.6, np.nan, True], [-5.0, 1.6, False]], index=[1, 2])
-
-        result = df1.combine_first(df2)[2]
-        expected = Series([True, True, False], name=2)
-        assert_series_equal(result, expected)
-
-        # GH 3593, converting datetime64[ns] incorrectly
-        df0 = DataFrame(
-            {"a": [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]}
-        )
-        df1 = DataFrame({"a": [None, None, None]})
-        df2 = df1.combine_first(df0)
-        assert_frame_equal(df2, df0)
-
-        df2 = df0.combine_first(df1)
-        assert_frame_equal(df2, df0)
-
-        df0 = DataFrame(
-            {"a": [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]}
-        )
-        df1 = DataFrame({"a": [datetime(2000, 1, 2), None, None]})
-        df2 = df1.combine_first(df0)
-        result = df0.copy()
-        result.iloc[0, :] = df1.iloc[0, :]
-        assert_frame_equal(df2, result)
-
-        df2 = df0.combine_first(df1)
-        assert_frame_equal(df2, df0)
-
-    def test_combine_first_align_nan(self):
-        # GH 7509 (not fixed)
-        dfa = pd.DataFrame([[pd.Timestamp("2011-01-01"), 2]], columns=["a", "b"])
-        dfb = pd.DataFrame([[4], [5]], columns=["b"])
-        assert dfa["a"].dtype == "datetime64[ns]"
-        assert dfa["b"].dtype == "int64"
-
-        res = dfa.combine_first(dfb)
-        exp = pd.DataFrame(
-            {"a": [pd.Timestamp("2011-01-01"), pd.NaT], "b": [2.0, 5.0]},
-            columns=["a", "b"],
-        )
-        tm.assert_frame_equal(res, exp)
-        assert res["a"].dtype == "datetime64[ns]"
-        # ToDo: this must be int64
-        assert res["b"].dtype == "float64"
-
-        res = dfa.iloc[:0].combine_first(dfb)
-        exp = pd.DataFrame({"a": [np.nan, np.nan], "b": [4, 5]}, columns=["a", "b"])
-        tm.assert_frame_equal(res, exp)
-        # ToDo: this must be datetime64
-        assert res["a"].dtype == "float64"
-        # ToDo: this must be int64
-        assert res["b"].dtype == "int64"
-
-    def test_combine_first_timezone(self):
-        # see gh-7630
-        data1 = pd.to_datetime("20100101 01:01").tz_localize("UTC")
-        df1 = pd.DataFrame(
-            columns=["UTCdatetime", "abc"],
-            data=data1,
-            index=pd.date_range("20140627", periods=1),
-        )
-        data2 = pd.to_datetime("20121212 12:12").tz_localize("UTC")
-        df2 = pd.DataFrame(
-            columns=["UTCdatetime", "xyz"],
-            data=data2,
-            index=pd.date_range("20140628", periods=1),
-        )
-        res = df2[["UTCdatetime"]].combine_first(df1)
-        exp = pd.DataFrame(
-            {
-                "UTCdatetime": [
-                    pd.Timestamp("2010-01-01 01:01", tz="UTC"),
-                    pd.Timestamp("2012-12-12 12:12", tz="UTC"),
-                ],
-                "abc": [pd.Timestamp("2010-01-01 01:01:00", tz="UTC"), pd.NaT],
-            },
-            columns=["UTCdatetime", "abc"],
-            index=pd.date_range("20140627", periods=2, freq="D"),
-        )
-        tm.assert_frame_equal(res, exp)
-        assert res["UTCdatetime"].dtype == "datetime64[ns, UTC]"
-        assert res["abc"].dtype == "datetime64[ns, UTC]"
-
-        # see gh-10567
-        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="UTC")
-        df1 = pd.DataFrame({"DATE": dts1})
-        dts2 = pd.date_range("2015-01-03", "2015-01-05", tz="UTC")
-        df2 = pd.DataFrame({"DATE": dts2})
-
-        res = df1.combine_first(df2)
-        tm.assert_frame_equal(res, df1)
-        assert res["DATE"].dtype == "datetime64[ns, UTC]"
-
-        dts1 = pd.DatetimeIndex(
-            ["2011-01-01", "NaT", "2011-01-03", "2011-01-04"], tz="US/Eastern"
-        )
-        df1 = pd.DataFrame({"DATE": dts1}, index=[1, 3, 5, 7])
-        dts2 = pd.DatetimeIndex(
-            ["2012-01-01", "2012-01-02", "2012-01-03"], tz="US/Eastern"
-        )
-        df2 = pd.DataFrame({"DATE": dts2}, index=[2, 4, 5])
-
-        res = df1.combine_first(df2)
-        exp_dts = pd.DatetimeIndex(
-            [
-                "2011-01-01",
-                "2012-01-01",
-                "NaT",
-                "2012-01-02",
-                "2011-01-03",
-                "2011-01-04",
-            ],
-            tz="US/Eastern",
-        )
-        exp = pd.DataFrame({"DATE": exp_dts}, index=[1, 2, 3, 4, 5, 7])
-        tm.assert_frame_equal(res, exp)
-
-        # different tz
-        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="US/Eastern")
-        df1 = pd.DataFrame({"DATE": dts1})
-        dts2 = pd.date_range("2015-01-03", "2015-01-05")
-        df2 = pd.DataFrame({"DATE": dts2})
-
-        # if df1 doesn't have NaN, keep its dtype
-        res = df1.combine_first(df2)
-        tm.assert_frame_equal(res, df1)
-        assert res["DATE"].dtype == "datetime64[ns, US/Eastern]"
-
-        dts1 = pd.date_range("2015-01-01", "2015-01-02", tz="US/Eastern")
-        df1 = pd.DataFrame({"DATE": dts1})
-        dts2 = pd.date_range("2015-01-01", "2015-01-03")
-        df2 = pd.DataFrame({"DATE": dts2})
-
-        res = df1.combine_first(df2)
-        exp_dts = [
-            pd.Timestamp("2015-01-01", tz="US/Eastern"),
-            pd.Timestamp("2015-01-02", tz="US/Eastern"),
-            pd.Timestamp("2015-01-03"),
-        ]
-        exp = pd.DataFrame({"DATE": exp_dts})
-        tm.assert_frame_equal(res, exp)
-        assert res["DATE"].dtype == "object"
-
-    def test_combine_first_timedelta(self):
-        data1 = pd.TimedeltaIndex(["1 day", "NaT", "3 day", "4day"])
-        df1 = pd.DataFrame({"TD": data1}, index=[1, 3, 5, 7])
-        data2 = pd.TimedeltaIndex(["10 day", "11 day", "12 day"])
-        df2 = pd.DataFrame({"TD": data2}, index=[2, 4, 5])
-
-        res = df1.combine_first(df2)
-        exp_dts = pd.TimedeltaIndex(
-            ["1 day", "10 day", "NaT", "11 day", "3 day", "4 day"]
-        )
-        exp = pd.DataFrame({"TD": exp_dts}, index=[1, 2, 3, 4, 5, 7])
-        tm.assert_frame_equal(res, exp)
-        assert res["TD"].dtype == "timedelta64[ns]"
-
-    def test_combine_first_period(self):
-        data1 = pd.PeriodIndex(["2011-01", "NaT", "2011-03", "2011-04"], freq="M")
-        df1 = pd.DataFrame({"P": data1}, index=[1, 3, 5, 7])
-        data2 = pd.PeriodIndex(["2012-01-01", "2012-02", "2012-03"], freq="M")
-        df2 = pd.DataFrame({"P": data2}, index=[2, 4, 5])
-
-        res = df1.combine_first(df2)
-        exp_dts = pd.PeriodIndex(
-            ["2011-01", "2012-01", "NaT", "2012-02", "2011-03", "2011-04"], freq="M"
-        )
-        exp = pd.DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
-        tm.assert_frame_equal(res, exp)
-        assert res["P"].dtype == data1.dtype
-
-        # different freq
-        dts2 = pd.PeriodIndex(["2012-01-01", "2012-01-02", "2012-01-03"], freq="D")
-        df2 = pd.DataFrame({"P": dts2}, index=[2, 4, 5])
-
-        res = df1.combine_first(df2)
-        exp_dts = [
-            pd.Period("2011-01", freq="M"),
-            pd.Period("2012-01-01", freq="D"),
-            pd.NaT,
-            pd.Period("2012-01-02", freq="D"),
-            pd.Period("2011-03", freq="M"),
-            pd.Period("2011-04", freq="M"),
-        ]
-        exp = pd.DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
-        tm.assert_frame_equal(res, exp)
-        assert res["P"].dtype == "object"
-
-    def test_combine_first_int(self):
-        # GH14687 - integer series that do no align exactly
-
-        df1 = pd.DataFrame({"a": [0, 1, 3, 5]}, dtype="int64")
-        df2 = pd.DataFrame({"a": [1, 4]}, dtype="int64")
-
-        res = df1.combine_first(df2)
-        tm.assert_frame_equal(res, df1)
-        assert res["a"].dtype == "int64"
-
-    @pytest.mark.parametrize("val", [1, 1.0])
-    def test_combine_first_with_asymmetric_other(self, val):
-        # see gh-20699
-        df1 = pd.DataFrame({"isNum": [val]})
-        df2 = pd.DataFrame({"isBool": [True]})
-
-        res = df1.combine_first(df2)
-        exp = pd.DataFrame({"isBool": [True], "isNum": [val]})
-
-        tm.assert_frame_equal(res, exp)
-
     def test_concat_datetime_datetime64_frame(self):
         # #2624
         rows = []
@@ -930,23 +326,3 @@ def test_concat_datetime_datetime64_frame(self):
 
         # it works!
         pd.concat([df1, df2_obj])
-
-
-class TestDataFrameUpdate:
-    def test_update_nan(self):
-        # #15593 #15617
-        # test 1
-        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
-        df2 = DataFrame({"A": [None, 2, 3]})
-        expected = df1.copy()
-        df1.update(df2, overwrite=False)
-
-        tm.assert_frame_equal(df1, expected)
-
-        # test 2
-        df1 = DataFrame({"A": [1.0, None, 3], "B": date_range("2000", periods=3)})
-        df2 = DataFrame({"A": [None, 2, 3]})
-        expected = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
-        df1.update(df2, overwrite=False)
-
-        tm.assert_frame_equal(df1, expected)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index ebffeeaa3063e..5f4c78449f71d 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -1,5 +1,5 @@
 from collections import OrderedDict, abc
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
 import functools
 import itertools
 
@@ -8,9 +8,8 @@
 import numpy.ma.mrecords as mrecords
 import pytest
 
-from pandas.compat import PY36, is_platform_little_endian
+from pandas.compat import is_platform_little_endian
 
-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
 from pandas.core.dtypes.common import is_integer_dtype
 
 import pandas as pd
@@ -26,7 +25,9 @@
     date_range,
     isna,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.arrays import IntervalArray, PeriodArray, SparseArray
+from pandas.core.construction import create_series_with_explicit_dtype
 
 MIXED_FLOAT_DTYPES = ["float16", "float32", "float64"]
 MIXED_INT_DTYPES = [
@@ -42,6 +43,19 @@
 
 
 class TestDataFrameConstructors:
+    def test_series_with_name_not_matching_column(self):
+        # GH#9232
+        x = pd.Series(range(5), name=1)
+        y = pd.Series(range(5), name=0)
+
+        result = pd.DataFrame(x, columns=[0])
+        expected = pd.DataFrame([], columns=[0])
+        tm.assert_frame_equal(result, expected)
+
+        result = pd.DataFrame(y, columns=[1])
+        expected = pd.DataFrame([], columns=[1])
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize(
         "constructor",
         [
@@ -50,13 +64,13 @@ class TestDataFrameConstructors:
             lambda: DataFrame({}),
             lambda: DataFrame(()),
             lambda: DataFrame([]),
-            lambda: DataFrame((x for x in [])),
+            lambda: DataFrame((_ for _ in [])),
             lambda: DataFrame(range(0)),
             lambda: DataFrame(data=None),
             lambda: DataFrame(data={}),
             lambda: DataFrame(data=()),
             lambda: DataFrame(data=[]),
-            lambda: DataFrame(data=(x for x in [])),
+            lambda: DataFrame(data=(_ for _ in [])),
             lambda: DataFrame(data=range(0)),
         ],
     )
@@ -72,7 +86,7 @@ def test_empty_constructor(self, constructor):
         [
             ([[]], RangeIndex(1), RangeIndex(0)),
             ([[], []], RangeIndex(2), RangeIndex(0)),
-            ([(x for x in [])], RangeIndex(1), RangeIndex(0)),
+            ([(_ for _ in [])], RangeIndex(1), RangeIndex(0)),
         ],
     )
     def test_emptylike_constructor(self, emptylike, expected_index, expected_columns):
@@ -245,9 +259,9 @@ def test_constructor_overflow_int64(self):
             np.array([2 ** 64], dtype=object),
             np.array([2 ** 65]),
             [2 ** 64 + 1],
-            np.array([-2 ** 63 - 4], dtype=object),
-            np.array([-2 ** 64 - 1]),
-            [-2 ** 65 - 2],
+            np.array([-(2 ** 63) - 4], dtype=object),
+            np.array([-(2 ** 64) - 1]),
+            [-(2 ** 65) - 2],
         ],
     )
     def test_constructor_int_overflow(self, values):
@@ -387,7 +401,6 @@ def test_constructor_dict_nan_tuple_key(self, value):
         result = DataFrame(data, index=idx, columns=cols)
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.skipif(not PY36, reason="Insertion order for Python>=3.6")
     def test_constructor_dict_order_insertion(self):
         datetime_series = tm.makeTimeSeries(nper=30)
         datetime_series_short = tm.makeTimeSeries(nper=25)
@@ -399,17 +412,11 @@ def test_constructor_dict_order_insertion(self):
         expected = DataFrame(data=d, columns=list("ba"))
         tm.assert_frame_equal(frame, expected)
 
-    @pytest.mark.skipif(PY36, reason="order by value for Python<3.6")
-    def test_constructor_dict_order_by_values(self):
-        datetime_series = tm.makeTimeSeries(nper=30)
-        datetime_series_short = tm.makeTimeSeries(nper=25)
-
-        # GH19018
-        # initialization ordering: by value if python<3.6
-        d = {"b": datetime_series_short, "a": datetime_series}
-        frame = DataFrame(data=d)
-        expected = DataFrame(data=d, columns=list("ab"))
-        tm.assert_frame_equal(frame, expected)
+    def test_constructor_dict_nan_key_and_columns(self):
+        # GH 16894
+        result = pd.DataFrame({np.nan: [1, 2], 2: [2, 3]}, columns=[np.nan, 2])
+        expected = pd.DataFrame([[1, 2], [2, 3]], columns=[np.nan, 2])
+        tm.assert_frame_equal(result, expected)
 
     def test_constructor_multi_index(self):
         # GH 4078
@@ -424,6 +431,25 @@ def test_constructor_multi_index(self):
         df = DataFrame(index=mi, columns=mi)
         assert pd.isna(df).values.ravel().all()
 
+    def test_constructor_2d_index(self):
+        # GH 25416
+        # handling of 2d index in construction
+        df = pd.DataFrame([[1]], columns=[[1]], index=[1, 2])
+        expected = pd.DataFrame(
+            [1, 1],
+            index=pd.Int64Index([1, 2], dtype="int64"),
+            columns=pd.MultiIndex(levels=[[1]], codes=[[0]]),
+        )
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame([[1]], columns=[[1]], index=[[1, 2]])
+        expected = pd.DataFrame(
+            [1, 1],
+            index=pd.MultiIndex(levels=[[1, 2]], codes=[[0, 1]]),
+            columns=pd.MultiIndex(levels=[[1]], codes=[[0]]),
+        )
+        tm.assert_frame_equal(df, expected)
+
     def test_constructor_error_msgs(self):
         msg = "Empty data passed with indices specified."
         # passing an empty array with columns specified.
@@ -459,11 +485,11 @@ def test_constructor_error_msgs(self):
             DataFrame(np.zeros((3, 3, 3)), columns=["A", "B", "C"], index=[1])
 
         # wrong size axis labels
-        msg = "Shape of passed values " r"is \(2, 3\), indices " r"imply \(1, 3\)"
+        msg = r"Shape of passed values is \(2, 3\), indices imply \(1, 3\)"
         with pytest.raises(ValueError, match=msg):
             DataFrame(np.random.rand(2, 3), columns=["A", "B", "C"], index=[1])
 
-        msg = "Shape of passed values " r"is \(2, 3\), indices " r"imply \(2, 2\)"
+        msg = r"Shape of passed values is \(2, 3\), indices imply \(2, 2\)"
         with pytest.raises(ValueError, match=msg):
             DataFrame(np.random.rand(2, 3), columns=["A", "B"], index=[1, 2])
 
@@ -491,17 +517,17 @@ def test_constructor_with_embedded_frames(self):
         result = df2.loc[1, 0]
         tm.assert_frame_equal(result, df1 + 10)
 
-    def test_constructor_subclass_dict(self, float_frame):
+    def test_constructor_subclass_dict(self, float_frame, dict_subclass):
         # Test for passing dict subclass to constructor
         data = {
-            "col1": tm.TestSubDict((x, 10.0 * x) for x in range(10)),
-            "col2": tm.TestSubDict((x, 20.0 * x) for x in range(10)),
+            "col1": dict_subclass((x, 10.0 * x) for x in range(10)),
+            "col2": dict_subclass((x, 20.0 * x) for x in range(10)),
         }
         df = DataFrame(data)
         refdf = DataFrame({col: dict(val.items()) for col, val in data.items()})
         tm.assert_frame_equal(refdf, df)
 
-        data = tm.TestSubDict(data.items())
+        data = dict_subclass(data.items())
         df = DataFrame(data)
         tm.assert_frame_equal(refdf, df)
 
@@ -1211,7 +1237,9 @@ def test_constructor_list_of_series(self):
             OrderedDict([["a", 1.5], ["b", 3], ["c", 4]]),
             OrderedDict([["b", 3], ["c", 4], ["d", 6]]),
         ]
-        data = [Series(d) for d in data]
+        data = [
+            create_series_with_explicit_dtype(d, dtype_if_empty=object) for d in data
+        ]
 
         result = DataFrame(data)
         sdict = OrderedDict(zip(range(len(data)), data))
@@ -1221,7 +1249,7 @@ def test_constructor_list_of_series(self):
         result2 = DataFrame(data, index=np.arange(6))
         tm.assert_frame_equal(result, result2)
 
-        result = DataFrame([Series()])
+        result = DataFrame([Series(dtype=object)])
         expected = DataFrame(index=[0])
         tm.assert_frame_equal(result, expected)
 
@@ -1354,7 +1382,7 @@ def test_constructor_list_of_dict_order(self):
             }
         )
         result = DataFrame(data)
-        tm.assert_frame_equal(result, expected, check_like=not PY36)
+        tm.assert_frame_equal(result, expected)
 
     def test_constructor_orient(self, float_string_frame):
         data_dict = float_string_frame.T._series
@@ -1405,6 +1433,23 @@ def test_from_dict_columns_parameter(self):
                 dict([("A", [1, 2]), ("B", [4, 5])]), columns=["one", "two"]
             )
 
+    @pytest.mark.parametrize(
+        "data_dict, keys",
+        [
+            ([{("a",): 1}, {("a",): 2}], [("a",)]),
+            ([OrderedDict([(("a",), 1), (("b",), 2)])], [("a",), ("b",)]),
+            ([{("a", "b"): 1}], [("a", "b")]),
+        ],
+    )
+    def test_constructor_from_dict_tuples(self, data_dict, keys):
+        # GH 16769
+        df = DataFrame.from_dict(data_dict)
+
+        result = df.columns
+        expected = Index(keys, dtype="object", tupleize_cols=False)
+
+        tm.assert_index_equal(result, expected)
+
     def test_constructor_Series_named(self):
         a = Series([1, 2, 3], index=["a", "b", "c"], name="x")
         df = DataFrame(a)
@@ -1428,7 +1473,7 @@ def test_constructor_Series_named(self):
             DataFrame(s, columns=[1, 2])
 
         # #2234
-        a = Series([], name="x")
+        a = Series([], name="x", dtype=object)
         df = DataFrame(a)
         assert df.columns[0] == "x"
 
@@ -1485,92 +1530,6 @@ def test_constructor_manager_resize(self, float_frame):
         tm.assert_index_equal(result.index, Index(index))
         tm.assert_index_equal(result.columns, Index(columns))
 
-    def test_constructor_from_items(self, float_frame, float_string_frame):
-        items = [(c, float_frame[c]) for c in float_frame.columns]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            recons = DataFrame.from_items(items)
-        tm.assert_frame_equal(recons, float_frame)
-
-        # pass some columns
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            recons = DataFrame.from_items(items, columns=["C", "B", "A"])
-        tm.assert_frame_equal(recons, float_frame.loc[:, ["C", "B", "A"]])
-
-        # orient='index'
-
-        row_items = [
-            (idx, float_string_frame.xs(idx)) for idx in float_string_frame.index
-        ]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            recons = DataFrame.from_items(
-                row_items, columns=float_string_frame.columns, orient="index"
-            )
-        tm.assert_frame_equal(recons, float_string_frame)
-        assert recons["A"].dtype == np.float64
-
-        msg = "Must pass columns with orient='index'"
-        with pytest.raises(TypeError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                DataFrame.from_items(row_items, orient="index")
-
-        # orient='index', but thar be tuples
-        arr = construct_1d_object_array_from_listlike(
-            [("bar", "baz")] * len(float_string_frame)
-        )
-        float_string_frame["foo"] = arr
-        row_items = [
-            (idx, list(float_string_frame.xs(idx))) for idx in float_string_frame.index
-        ]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            recons = DataFrame.from_items(
-                row_items, columns=float_string_frame.columns, orient="index"
-            )
-        tm.assert_frame_equal(recons, float_string_frame)
-        assert isinstance(recons["foo"][0], tuple)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            rs = DataFrame.from_items(
-                [("A", [1, 2, 3]), ("B", [4, 5, 6])],
-                orient="index",
-                columns=["one", "two", "three"],
-            )
-        xp = DataFrame(
-            [[1, 2, 3], [4, 5, 6]], index=["A", "B"], columns=["one", "two", "three"]
-        )
-        tm.assert_frame_equal(rs, xp)
-
-    def test_constructor_from_items_scalars(self):
-        # GH 17312
-        msg = (
-            r"The value in each \(key, value\) "
-            "pair must be an array, Series, or dict"
-        )
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                DataFrame.from_items([("A", 1), ("B", 4)])
-
-        msg = (
-            r"The value in each \(key, value\) "
-            "pair must be an array, Series, or dict"
-        )
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                DataFrame.from_items(
-                    [("A", 1), ("B", 2)], columns=["col1"], orient="index"
-                )
-
-    def test_from_items_deprecation(self):
-        # GH 17320
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            DataFrame.from_items([("A", [1, 2, 3]), ("B", [4, 5, 6])])
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            DataFrame.from_items(
-                [("A", [1, 2, 3]), ("B", [4, 5, 6])],
-                columns=["col1", "col2", "col3"],
-                orient="index",
-            )
-
     def test_constructor_mix_series_nonseries(self, float_frame):
         df = DataFrame(
             {"A": float_frame["A"], "B": list(float_frame["B"])}, columns=["A", "B"]
@@ -1772,7 +1731,7 @@ def test_constructor_with_datetimes(self):
         # preserver an index with a tz on dict construction
         i = date_range("1/1/2011", periods=5, freq="10s", tz="US/Eastern")
 
-        expected = DataFrame({"a": i.to_series(keep_tz=True).reset_index(drop=True)})
+        expected = DataFrame({"a": i.to_series().reset_index(drop=True)})
         df = DataFrame()
         df["a"] = i
         tm.assert_frame_equal(df, expected)
@@ -1783,20 +1742,27 @@ def test_constructor_with_datetimes(self):
         # multiples
         i_no_tz = date_range("1/1/2011", periods=5, freq="10s")
         df = DataFrame({"a": i, "b": i_no_tz})
-        expected = DataFrame(
-            {"a": i.to_series(keep_tz=True).reset_index(drop=True), "b": i_no_tz}
-        )
+        expected = DataFrame({"a": i.to_series().reset_index(drop=True), "b": i_no_tz})
         tm.assert_frame_equal(df, expected)
 
-    def test_constructor_datetimes_with_nulls(self):
-        # gh-15869
-        for arr in [
+    @pytest.mark.parametrize(
+        "arr",
+        [
             np.array([None, None, None, None, datetime.now(), None]),
             np.array([None, None, datetime.now(), None]),
-        ]:
-            result = DataFrame(arr).dtypes
-            expected = Series([np.dtype("datetime64[ns]")])
-            tm.assert_series_equal(result, expected)
+            [[np.datetime64("NaT")], [None]],
+            [[np.datetime64("NaT")], [pd.NaT]],
+            [[None], [np.datetime64("NaT")]],
+            [[None], [pd.NaT]],
+            [[pd.NaT], [np.datetime64("NaT")]],
+            [[pd.NaT], [None]],
+        ],
+    )
+    def test_constructor_datetimes_with_nulls(self, arr):
+        # gh-15869, GH#11220
+        result = DataFrame(arr).dtypes
+        expected = Series([np.dtype("datetime64[ns]")])
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_for_list_with_dtypes(self):
         # test list of lists/ndarrays
@@ -1894,9 +1860,8 @@ def check(df):
             # No NaN found -> error
             if len(indexer) == 0:
                 msg = (
-                    "cannot do label indexing on"
-                    r" <class 'pandas\.core\.indexes\.range\.RangeIndex'>"
-                    r" with these indexers \[nan\] of <class 'float'>"
+                    "cannot do label indexing on RangeIndex "
+                    r"with these indexers \[nan\] of type float"
                 )
                 with pytest.raises(TypeError, match=msg):
                     df.loc[:, np.nan]
@@ -2422,11 +2387,11 @@ def test_from_records_series_list_dict(self):
 
     def test_to_frame_with_falsey_names(self):
         # GH 16114
-        result = Series(name=0).to_frame().dtypes
-        expected = Series({0: np.float64})
+        result = Series(name=0, dtype=object).to_frame().dtypes
+        expected = Series({0: object})
         tm.assert_series_equal(result, expected)
 
-        result = DataFrame(Series(name=0)).dtypes
+        result = DataFrame(Series(name=0, dtype=object)).dtypes
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("dtype", [None, "uint8", "category"])
@@ -2450,6 +2415,47 @@ class List(list):
         result = DataFrame(List([List([1, 2, 3]), List([4, 5, 6])]))
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "extension_arr",
+        [
+            Categorical(list("aabbc")),
+            SparseArray([1, np.nan, np.nan, np.nan]),
+            IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+            PeriodArray(pd.period_range(start="1/1/2017", end="1/1/2018", freq="M")),
+        ],
+    )
+    def test_constructor_with_extension_array(self, extension_arr):
+        # GH11363
+        expected = DataFrame(Series(extension_arr))
+        result = DataFrame(extension_arr)
+        tm.assert_frame_equal(result, expected)
+
+    def test_datetime_date_tuple_columns_from_dict(self):
+        # GH 10863
+        v = date.today()
+        tup = v, v
+        result = DataFrame({tup: Series(range(3), index=range(3))}, columns=[tup])
+        expected = DataFrame([0, 1, 2], columns=pd.Index(pd.Series([tup])))
+        tm.assert_frame_equal(result, expected)
+
+    def test_construct_with_two_categoricalindex_series(self):
+        # GH 14600
+        s1 = pd.Series(
+            [39, 6, 4], index=pd.CategoricalIndex(["female", "male", "unknown"])
+        )
+        s2 = pd.Series(
+            [2, 152, 2, 242, 150],
+            index=pd.CategoricalIndex(["f", "female", "m", "male", "unknown"]),
+        )
+        result = pd.DataFrame([s1, s2])
+        expected = pd.DataFrame(
+            np.array(
+                [[np.nan, 39.0, np.nan, 6.0, 4.0], [2.0, 152.0, 2.0, 242.0, 150.0]]
+            ),
+            columns=["f", "female", "m", "male", "unknown"],
+        )
+        tm.assert_frame_equal(result, expected)
+
 
 class TestDataFrameConstructorWithDatetimeTZ:
     def test_from_dict(self):
@@ -2576,3 +2582,11 @@ def test_from_tzaware_mixed_object_array(self):
             "datetime64[ns, CET]",
         ]
         assert (res.dtypes == expected_dtypes).all()
+
+    def test_from_2d_ndarray_with_dtype(self):
+        # GH#12513
+        array_dim2 = np.arange(10).reshape((5, 2))
+        df = pd.DataFrame(array_dim2, dtype="datetime64[ns, UTC]")
+
+        expected = pd.DataFrame(array_dim2).astype("datetime64[ns, UTC]")
+        tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/frame/test_cumulative.py b/pandas/tests/frame/test_cumulative.py
new file mode 100644
index 0000000000000..b545d6aa8afd3
--- /dev/null
+++ b/pandas/tests/frame/test_cumulative.py
@@ -0,0 +1,135 @@
+"""
+Tests for DataFrame cumulative operations
+
+See also
+--------
+tests.series.test_cumulative
+"""
+
+import numpy as np
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class TestDataFrameCumulativeOps:
+    # ---------------------------------------------------------------------
+    # Cumulative Operations - cumsum, cummax, ...
+
+    def test_cumsum_corner(self):
+        dm = DataFrame(np.arange(20).reshape(4, 5), index=range(4), columns=range(5))
+        # TODO(wesm): do something with this?
+        result = dm.cumsum()  # noqa
+
+    def test_cumsum(self, datetime_frame):
+        datetime_frame.loc[5:10, 0] = np.nan
+        datetime_frame.loc[10:15, 1] = np.nan
+        datetime_frame.loc[15:, 2] = np.nan
+
+        # axis = 0
+        cumsum = datetime_frame.cumsum()
+        expected = datetime_frame.apply(Series.cumsum)
+        tm.assert_frame_equal(cumsum, expected)
+
+        # axis = 1
+        cumsum = datetime_frame.cumsum(axis=1)
+        expected = datetime_frame.apply(Series.cumsum, axis=1)
+        tm.assert_frame_equal(cumsum, expected)
+
+        # works
+        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
+        df.cumsum()
+
+        # fix issue
+        cumsum_xs = datetime_frame.cumsum(axis=1)
+        assert np.shape(cumsum_xs) == np.shape(datetime_frame)
+
+    def test_cumprod(self, datetime_frame):
+        datetime_frame.loc[5:10, 0] = np.nan
+        datetime_frame.loc[10:15, 1] = np.nan
+        datetime_frame.loc[15:, 2] = np.nan
+
+        # axis = 0
+        cumprod = datetime_frame.cumprod()
+        expected = datetime_frame.apply(Series.cumprod)
+        tm.assert_frame_equal(cumprod, expected)
+
+        # axis = 1
+        cumprod = datetime_frame.cumprod(axis=1)
+        expected = datetime_frame.apply(Series.cumprod, axis=1)
+        tm.assert_frame_equal(cumprod, expected)
+
+        # fix issue
+        cumprod_xs = datetime_frame.cumprod(axis=1)
+        assert np.shape(cumprod_xs) == np.shape(datetime_frame)
+
+        # ints
+        df = datetime_frame.fillna(0).astype(int)
+        df.cumprod(0)
+        df.cumprod(1)
+
+        # ints32
+        df = datetime_frame.fillna(0).astype(np.int32)
+        df.cumprod(0)
+        df.cumprod(1)
+
+    def test_cummin(self, datetime_frame):
+        datetime_frame.loc[5:10, 0] = np.nan
+        datetime_frame.loc[10:15, 1] = np.nan
+        datetime_frame.loc[15:, 2] = np.nan
+
+        # axis = 0
+        cummin = datetime_frame.cummin()
+        expected = datetime_frame.apply(Series.cummin)
+        tm.assert_frame_equal(cummin, expected)
+
+        # axis = 1
+        cummin = datetime_frame.cummin(axis=1)
+        expected = datetime_frame.apply(Series.cummin, axis=1)
+        tm.assert_frame_equal(cummin, expected)
+
+        # it works
+        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
+        df.cummin()
+
+        # fix issue
+        cummin_xs = datetime_frame.cummin(axis=1)
+        assert np.shape(cummin_xs) == np.shape(datetime_frame)
+
+    def test_cummax(self, datetime_frame):
+        datetime_frame.loc[5:10, 0] = np.nan
+        datetime_frame.loc[10:15, 1] = np.nan
+        datetime_frame.loc[15:, 2] = np.nan
+
+        # axis = 0
+        cummax = datetime_frame.cummax()
+        expected = datetime_frame.apply(Series.cummax)
+        tm.assert_frame_equal(cummax, expected)
+
+        # axis = 1
+        cummax = datetime_frame.cummax(axis=1)
+        expected = datetime_frame.apply(Series.cummax, axis=1)
+        tm.assert_frame_equal(cummax, expected)
+
+        # it works
+        df = DataFrame({"A": np.arange(20)}, index=np.arange(20))
+        df.cummax()
+
+        # fix issue
+        cummax_xs = datetime_frame.cummax(axis=1)
+        assert np.shape(cummax_xs) == np.shape(datetime_frame)
+
+    def test_cumulative_ops_preserve_dtypes(self):
+        # GH#19296 dont incorrectly upcast to object
+        df = DataFrame({"A": [1, 2, 3], "B": [1, 2, 3.0], "C": [True, False, False]})
+
+        result = df.cumsum()
+
+        expected = DataFrame(
+            {
+                "A": Series([1, 3, 6], dtype=np.int64),
+                "B": Series([1, 3, 6], dtype=np.float64),
+                "C": df["C"].cumsum(),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py
index 00be13b1c0e72..966f0d416676c 100644
--- a/pandas/tests/frame/test_dtypes.py
+++ b/pandas/tests/frame/test_dtypes.py
@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, IntervalDtype
 
 import pandas as pd
 from pandas import (
@@ -18,13 +18,8 @@
     date_range,
     option_context,
 )
+import pandas._testing as tm
 from pandas.core.arrays import integer_array
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_frame_equal,
-    assert_series_equal,
-    makeCustomDataframe as mkdf,
-)
 
 
 def _check_cast(df, v):
@@ -51,60 +46,32 @@ def test_concat_empty_dataframe_dtypes(self):
         assert result["b"].dtype == np.float64
         assert result["c"].dtype == np.float64
 
-    def test_empty_frame_dtypes_ftypes(self):
+    def test_empty_frame_dtypes(self):
         empty_df = pd.DataFrame()
-        assert_series_equal(empty_df.dtypes, pd.Series(dtype=np.object))
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(empty_df.ftypes, pd.Series(dtype=np.object))
+        tm.assert_series_equal(empty_df.dtypes, pd.Series(dtype=np.object))
 
         nocols_df = pd.DataFrame(index=[1, 2, 3])
-        assert_series_equal(nocols_df.dtypes, pd.Series(dtype=np.object))
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(nocols_df.ftypes, pd.Series(dtype=np.object))
+        tm.assert_series_equal(nocols_df.dtypes, pd.Series(dtype=np.object))
 
         norows_df = pd.DataFrame(columns=list("abc"))
-        assert_series_equal(norows_df.dtypes, pd.Series(np.object, index=list("abc")))
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(
-                norows_df.ftypes, pd.Series("object:dense", index=list("abc"))
-            )
+        tm.assert_series_equal(
+            norows_df.dtypes, pd.Series(np.object, index=list("abc"))
+        )
 
         norows_int_df = pd.DataFrame(columns=list("abc")).astype(np.int32)
-        assert_series_equal(
+        tm.assert_series_equal(
             norows_int_df.dtypes, pd.Series(np.dtype("int32"), index=list("abc"))
         )
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(
-                norows_int_df.ftypes, pd.Series("int32:dense", index=list("abc"))
-            )
 
         odict = OrderedDict
         df = pd.DataFrame(odict([("a", 1), ("b", True), ("c", 1.0)]), index=[1, 2, 3])
         ex_dtypes = pd.Series(
             odict([("a", np.int64), ("b", np.bool), ("c", np.float64)])
         )
-        ex_ftypes = pd.Series(
-            odict([("a", "int64:dense"), ("b", "bool:dense"), ("c", "float64:dense")])
-        )
-        assert_series_equal(df.dtypes, ex_dtypes)
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(df.ftypes, ex_ftypes)
+        tm.assert_series_equal(df.dtypes, ex_dtypes)
 
         # same but for empty slice of df
-        assert_series_equal(df[:0].dtypes, ex_dtypes)
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(df[:0].ftypes, ex_ftypes)
+        tm.assert_series_equal(df[:0].dtypes, ex_dtypes)
 
     def test_datetime_with_tz_dtypes(self):
         tzframe = DataFrame(
@@ -126,18 +93,20 @@ def test_datetime_with_tz_dtypes(self):
             ["A", "B", "C"],
         )
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_dtypes_are_correct_after_column_slice(self):
         # GH6525
         df = pd.DataFrame(index=range(5), columns=list("abc"), dtype=np.float_)
         odict = OrderedDict
-        assert_series_equal(
+        tm.assert_series_equal(
             df.dtypes,
             pd.Series(odict([("a", np.float_), ("b", np.float_), ("c", np.float_)])),
         )
-        assert_series_equal(df.iloc[:, 2:].dtypes, pd.Series(odict([("c", np.float_)])))
-        assert_series_equal(
+        tm.assert_series_equal(
+            df.iloc[:, 2:].dtypes, pd.Series(odict([("c", np.float_)]))
+        )
+        tm.assert_series_equal(
             df.dtypes,
             pd.Series(odict([("a", np.float_), ("b", np.float_), ("c", np.float_)])),
         )
@@ -161,27 +130,27 @@ def test_select_dtypes_include_using_list_like(self):
 
         ri = df.select_dtypes(include=[np.number])
         ei = df[["b", "c", "d", "k"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=[np.number], exclude=["timedelta"])
         ei = df[["b", "c", "d"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=[np.number, "category"], exclude=["timedelta"])
         ei = df[["b", "c", "d", "f"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=["datetime"])
         ei = df[["g"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=["datetime64"])
         ei = df[["g"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=["datetimetz"])
         ei = df[["h", "i"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         with pytest.raises(NotImplementedError, match=r"^$"):
             df.select_dtypes(include=["period"])
@@ -198,7 +167,7 @@ def test_select_dtypes_exclude_using_list_like(self):
         )
         re = df.select_dtypes(exclude=[np.number])
         ee = df[["a", "e"]]
-        assert_frame_equal(re, ee)
+        tm.assert_frame_equal(re, ee)
 
     def test_select_dtypes_exclude_include_using_list_like(self):
         df = DataFrame(
@@ -215,13 +184,13 @@ def test_select_dtypes_exclude_include_using_list_like(self):
         include = np.bool_, "integer"
         r = df.select_dtypes(include=include, exclude=exclude)
         e = df[["b", "c", "e"]]
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
         exclude = ("datetime",)
         include = "bool", "int64", "int32"
         r = df.select_dtypes(include=include, exclude=exclude)
         e = df[["b", "e"]]
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
     def test_select_dtypes_include_using_scalars(self):
         df = DataFrame(
@@ -242,19 +211,19 @@ def test_select_dtypes_include_using_scalars(self):
 
         ri = df.select_dtypes(include=np.number)
         ei = df[["b", "c", "d", "k"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include="datetime")
         ei = df[["g"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include="datetime64")
         ei = df[["g"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include="category")
         ei = df[["f"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         with pytest.raises(NotImplementedError, match=r"^$"):
             df.select_dtypes(include="period")
@@ -278,11 +247,11 @@ def test_select_dtypes_exclude_using_scalars(self):
 
         ri = df.select_dtypes(exclude=np.number)
         ei = df[["a", "e", "f", "g", "h", "i", "j"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(exclude="category")
         ei = df[["a", "b", "c", "d", "e", "g", "h", "i", "j", "k"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         with pytest.raises(NotImplementedError, match=r"^$"):
             df.select_dtypes(exclude="period")
@@ -306,7 +275,7 @@ def test_select_dtypes_include_exclude_using_scalars(self):
 
         ri = df.select_dtypes(include=np.number, exclude="floating")
         ei = df[["b", "c", "k"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
     def test_select_dtypes_include_exclude_mixed_scalars_lists(self):
         df = DataFrame(
@@ -327,11 +296,11 @@ def test_select_dtypes_include_exclude_mixed_scalars_lists(self):
 
         ri = df.select_dtypes(include=np.number, exclude=["floating", "timedelta"])
         ei = df[["b", "c"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
         ri = df.select_dtypes(include=[np.number, "category"], exclude="floating")
         ei = df[["b", "c", "f", "k"]]
-        assert_frame_equal(ri, ei)
+        tm.assert_frame_equal(ri, ei)
 
     def test_select_dtypes_duplicate_columns(self):
         # GH20839
@@ -355,7 +324,7 @@ def test_select_dtypes_duplicate_columns(self):
         )
 
         result = df.select_dtypes(include=[np.number], exclude=["floating"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_select_dtypes_not_an_attr_but_still_valid_dtype(self):
         df = DataFrame(
@@ -372,11 +341,11 @@ def test_select_dtypes_not_an_attr_but_still_valid_dtype(self):
         assert not hasattr(np, "u8")
         r = df.select_dtypes(include=["i8", "O"], exclude=["timedelta"])
         e = df[["a", "b"]]
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
         r = df.select_dtypes(include=["i8", "O", "timedelta64[ns]"])
         e = df[["a", "b", "g"]]
-        assert_frame_equal(r, e)
+        tm.assert_frame_equal(r, e)
 
     def test_select_dtypes_empty(self):
         df = DataFrame({"a": list("abc"), "b": list(range(1, 4))})
@@ -413,7 +382,7 @@ def test_select_dtypes_datetime_with_tz(self):
         df3 = pd.concat([df2.A.to_frame(), df2.B.to_frame()], axis=1)
         result = df3.select_dtypes(include=["datetime64[ns]"])
         expected = df3.reindex(columns=[])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "dtype", [str, "str", np.string_, "S1", "unicode", np.unicode_, "U1"]
@@ -456,10 +425,10 @@ def test_select_dtypes_bad_arg_raises(self):
 
     def test_select_dtypes_typecodes(self):
         # GH 11990
-        df = mkdf(30, 3, data_gen_f=lambda x, y: np.random.random())
+        df = tm.makeCustomDataframe(30, 3, data_gen_f=lambda x, y: np.random.random())
         expected = df
         FLOAT_TYPES = list(np.typecodes["AllFloat"])
-        assert_frame_equal(df.select_dtypes(FLOAT_TYPES), expected)
+        tm.assert_frame_equal(df.select_dtypes(FLOAT_TYPES), expected)
 
     def test_dtypes_gh8722(self, float_string_frame):
         float_string_frame["bool"] = float_string_frame["A"] > 0
@@ -467,29 +436,13 @@ def test_dtypes_gh8722(self, float_string_frame):
         expected = Series(
             {k: v.dtype for k, v in float_string_frame.items()}, index=result.index
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # compat, GH 8722
         with option_context("use_inf_as_na", True):
             df = DataFrame([[1]])
             result = df.dtypes
-            assert_series_equal(result, Series({0: np.dtype("int64")}))
-
-    def test_ftypes(self, mixed_float_frame):
-        frame = mixed_float_frame
-        expected = Series(
-            dict(
-                A="float32:dense",
-                B="float32:dense",
-                C="float16:dense",
-                D="float64:dense",
-            )
-        ).sort_values()
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            result = frame.ftypes.sort_values()
-        assert_series_equal(result, expected)
+            tm.assert_series_equal(result, Series({0: np.dtype("int64")}))
 
     def test_astype_float(self, float_frame):
         casted = float_frame.astype(int)
@@ -498,7 +451,7 @@ def test_astype_float(self, float_frame):
             index=float_frame.index,
             columns=float_frame.columns,
         )
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
         casted = float_frame.astype(np.int32)
         expected = DataFrame(
@@ -506,7 +459,7 @@ def test_astype_float(self, float_frame):
             index=float_frame.index,
             columns=float_frame.columns,
         )
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
         float_frame["foo"] = "5"
         casted = float_frame.astype(int)
@@ -515,7 +468,7 @@ def test_astype_float(self, float_frame):
             index=float_frame.index,
             columns=float_frame.columns,
         )
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
     def test_astype_mixed_float(self, mixed_float_frame):
         # mixed casting
@@ -557,7 +510,7 @@ def test_astype_with_exclude_string(self, float_frame):
         casted = df.astype(int, errors="ignore")
 
         expected["string"] = "foo"
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
         df = float_frame.copy()
         expected = float_frame.astype(np.int32)
@@ -565,7 +518,7 @@ def test_astype_with_exclude_string(self, float_frame):
         casted = df.astype(np.int32, errors="ignore")
 
         expected["string"] = "foo"
-        assert_frame_equal(casted, expected)
+        tm.assert_frame_equal(casted, expected)
 
     def test_astype_with_view_float(self, float_frame):
 
@@ -624,21 +577,21 @@ def test_astype_str(self):
             }
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_astype_str_float(self):
         # see gh-11302
         result = DataFrame([np.NaN]).astype(str)
         expected = DataFrame(["nan"])
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         result = DataFrame([1.12345678901234567890]).astype(str)
 
         # < 1.14 truncates
         # >= 1.14 preserves the full repr
         val = "1.12345678901" if _np_version_under1p14 else "1.1234567890123457"
         expected = DataFrame([val])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("dtype_class", [dict, Series])
     def test_astype_dict_like(self, dtype_class):
@@ -661,8 +614,8 @@ def test_astype_dict_like(self, dtype_class):
                 "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float32"),
             }
         )
-        assert_frame_equal(result, expected)
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
 
         dt2 = dtype_class({"b": np.float32, "c": "float32", "d": np.float64})
         result = df.astype(dt2)
@@ -674,13 +627,13 @@ def test_astype_dict_like(self, dtype_class):
                 "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float64"),
             }
         )
-        assert_frame_equal(result, expected)
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
 
         # change all columns
         dt3 = dtype_class({"a": str, "b": str, "c": str, "d": str})
-        assert_frame_equal(df.astype(dt3), df.astype(str))
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(df.astype(dt3), df.astype(str))
+        tm.assert_frame_equal(df, original)
 
         # error should be raised when using something other than column labels
         # in the keys of the dtype dict
@@ -691,22 +644,22 @@ def test_astype_dict_like(self, dtype_class):
             df.astype(dt4)
         with pytest.raises(KeyError, match=msg):
             df.astype(dt5)
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(df, original)
 
         # if the dtypes provided are the same as the original dtypes, the
         # resulting DataFrame should be the same as the original DataFrame
         dt6 = dtype_class({col: df[col].dtype for col in df.columns})
         equiv = df.astype(dt6)
-        assert_frame_equal(df, equiv)
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
 
         # GH 16717
         # if dtypes provided is empty, the resulting DataFrame
         # should be the same as the original DataFrame
-        dt7 = dtype_class({})
-        result = df.astype(dt7)
-        assert_frame_equal(df, equiv)
-        assert_frame_equal(df, original)
+        dt7 = dtype_class({}) if dtype_class is dict else dtype_class({}, dtype=object)
+        equiv = df.astype(dt7)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
 
     def test_astype_duplicate_col(self):
         a1 = Series([1, 2, 3, 4, 5], name="a")
@@ -719,11 +672,11 @@ def test_astype_duplicate_col(self):
         b_str = Series(["0.1", "0.2", "0.4", "0.6", "0.8"], dtype=str, name="b")
         a2_str = Series(["0", "1", "2", "3", "4"], dtype="str", name="a")
         expected = concat([a1_str, b_str, a2_str], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.astype({"a": "str"})
         expected = concat([a1_str, b, a2_str], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "dtype",
@@ -746,14 +699,7 @@ def test_astype_categorical(self, dtype):
         expected = DataFrame({k: Categorical(d[k], dtype=dtype) for k in d})
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "cls",
-        [
-            pd.api.types.CategoricalDtype,
-            pd.api.types.DatetimeTZDtype,
-            pd.api.types.IntervalDtype,
-        ],
-    )
+    @pytest.mark.parametrize("cls", [CategoricalDtype, DatetimeTZDtype, IntervalDtype])
     def test_astype_categoricaldtype_class_raises(self, cls):
         df = DataFrame({"A": ["a", "a", "b", "c"]})
         xpr = "Expected an instance of {}".format(cls.__name__)
@@ -763,6 +709,15 @@ def test_astype_categoricaldtype_class_raises(self, cls):
         with pytest.raises(TypeError, match=xpr):
             df["A"].astype(cls)
 
+    def test_singlerow_slice_categoricaldtype_gives_series(self):
+        # GH29521
+        df = pd.DataFrame({"x": pd.Categorical("a b c d e".split())})
+        result = df.iloc[0]
+        raw_cat = pd.Categorical(["a"], categories=["a", "b", "c", "d", "e"])
+        expected = pd.Series(raw_cat, index=["x"], name=0, dtype="category")
+
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize("dtype", ["Int64", "Int32", "Int16"])
     def test_astype_extension_dtypes(self, dtype):
         # GH 22578
@@ -814,7 +769,23 @@ def test_astype_extension_dtypes_duplicate_col(self, dtype):
 
         result = df.astype(dtype)
         expected = concat([a1.astype(dtype), a2.astype(dtype)], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("kwargs", [dict(), dict(other=None)])
+    def test_df_where_with_category(self, kwargs):
+        # GH 16979
+        df = DataFrame(np.arange(2 * 3).reshape(2, 3), columns=list("ABC"))
+        mask = np.array([[True, False, True], [False, True, True]])
+
+        # change type to category
+        df.A = df.A.astype("category")
+        df.B = df.B.astype("category")
+        df.C = df.C.astype("category")
+
+        result = df.A.where(mask[:, 0], **kwargs)
+        expected = Series(pd.Categorical([0, np.nan], categories=[0, 3]), name="A")
+
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "dtype", [{100: "float64", 200: "uint64"}, "category", "float64"]
@@ -826,6 +797,31 @@ def test_astype_column_metadata(self, dtype):
         df = df.astype(dtype)
         tm.assert_index_equal(df.columns, columns)
 
+    def test_df_where_change_dtype(self):
+        # GH 16979
+        df = DataFrame(np.arange(2 * 3).reshape(2, 3), columns=list("ABC"))
+        mask = np.array([[True, False, False], [False, False, True]])
+
+        result = df.where(mask)
+        expected = DataFrame(
+            [[0, np.nan, np.nan], [np.nan, np.nan, 5]], columns=list("ABC")
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # change type to category
+        df.A = df.A.astype("category")
+        df.B = df.B.astype("category")
+        df.C = df.C.astype("category")
+
+        result = df.where(mask)
+        A = pd.Categorical([0, np.nan], categories=[0, 3])
+        B = pd.Categorical([np.nan, np.nan], categories=[1, 4])
+        C = pd.Categorical([np.nan, 5], categories=[2, 5])
+        expected = DataFrame({"A": A, "B": B, "C": C})
+
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize("dtype", ["M8", "m8"])
     @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
     def test_astype_from_datetimelike_to_objectt(self, dtype, unit):
@@ -901,15 +897,15 @@ def test_astype_to_incorrect_datetimelike(self, unit):
 
         df = DataFrame(np.array([[1, 2, 3]], dtype=dtype))
         msg = (
-            r"cannot astype a datetimelike from \[datetime64\[ns\]\] to"
-            r" \[timedelta64\[{}\]\]"
+            r"cannot astype a datetimelike from \[datetime64\[ns\]\] to "
+            r"\[timedelta64\[{}\]\]"
         ).format(unit)
         with pytest.raises(TypeError, match=msg):
             df.astype(other)
 
         msg = (
-            r"cannot astype a timedelta from \[timedelta64\[ns\]\] to"
-            r" \[datetime64\[{}\]\]"
+            r"cannot astype a timedelta from \[timedelta64\[ns\]\] to "
+            r"\[datetime64\[{}\]\]"
         ).format(unit)
         df = DataFrame(np.array([[1, 2, 3]], dtype=other))
         with pytest.raises(TypeError, match=msg):
@@ -926,7 +922,7 @@ def test_timedeltas(self):
         expected = Series(
             [np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")], index=list("AB")
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df["C"] = df["A"] + df["B"]
         result = df.dtypes
@@ -938,7 +934,7 @@ def test_timedeltas(self):
             ],
             index=list("ABC"),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # mixed int types
         df["D"] = 1
@@ -952,7 +948,7 @@ def test_timedeltas(self):
             ],
             index=list("ABCD"),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_arg_for_errors_in_astype(self):
         # issue #14878
@@ -1001,13 +997,13 @@ def test_constructor_list_str(self, input_vals, string_dtype):
 
         result = DataFrame({"A": input_vals}, dtype=string_dtype)
         expected = DataFrame({"A": input_vals}).astype({"A": string_dtype})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_constructor_list_str_na(self, string_dtype):
 
         result = DataFrame({"A": [1.0, 2.0, None]}, dtype=string_dtype)
         expected = DataFrame({"A": ["1.0", "2.0", None]}, dtype=object)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "data, expected",
@@ -1064,6 +1060,39 @@ def test_asarray_homogenous(self):
         expected = np.array([[1, 1], [2, 2]], dtype="object")
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_str_to_small_float_conversion_type(self):
+        # GH 20388
+        np.random.seed(13)
+        col_data = [str(np.random.random() * 1e-12) for _ in range(5)]
+        result = pd.DataFrame(col_data, columns=["A"])
+        expected = pd.DataFrame(col_data, columns=["A"], dtype=object)
+        tm.assert_frame_equal(result, expected)
+        # change the dtype of the elements from object to float one by one
+        result.loc[result.index, "A"] = [float(x) for x in col_data]
+        expected = pd.DataFrame(col_data, columns=["A"], dtype=float)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "convert_integer, expected", [(False, np.dtype("int32")), (True, "Int32")]
+    )
+    def test_convert_dtypes(self, convert_integer, expected):
+        # Specific types are tested in tests/series/test_dtypes.py
+        # Just check that it works for DataFrame here
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
+                "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
+            }
+        )
+        result = df.convert_dtypes(True, True, convert_integer, False)
+        expected = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype=expected),
+                "b": pd.Series(["x", "y", "z"], dtype="string"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
 
 class TestDataFrameDatetimeWithTZ:
     def test_interleave(self, timezone_frame):
@@ -1146,7 +1175,7 @@ def test_astype(self, timezone_frame):
             dtype=object,
         )
         result = timezone_frame.astype(object)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = timezone_frame.astype("datetime64[ns]")
         expected = DataFrame(
@@ -1166,7 +1195,7 @@ def test_astype(self, timezone_frame):
         )
         expected.iloc[1, 1] = pd.NaT
         expected.iloc[1, 2] = pd.NaT
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_astype_str(self, timezone_frame):
         # str formatting
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
deleted file mode 100644
index a78b2ab7d1c4c..0000000000000
--- a/pandas/tests/frame/test_indexing.py
+++ /dev/null
@@ -1,3866 +0,0 @@
-from datetime import date, datetime, time, timedelta
-import re
-from warnings import catch_warnings, simplefilter
-
-import numpy as np
-import pytest
-
-from pandas._libs.tslib import iNaT
-
-from pandas.core.dtypes.common import is_float_dtype, is_integer, is_scalar
-from pandas.core.dtypes.dtypes import CategoricalDtype
-
-import pandas as pd
-from pandas import (
-    Categorical,
-    DataFrame,
-    DatetimeIndex,
-    Index,
-    MultiIndex,
-    Series,
-    Timestamp,
-    date_range,
-    isna,
-    notna,
-)
-import pandas.core.common as com
-from pandas.core.indexing import IndexingError
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
-
-from pandas.tseries.offsets import BDay
-
-
-class TestDataFrameIndexing(TestData):
-    def test_getitem(self, float_frame):
-        # Slicing
-        sl = float_frame[:20]
-        assert len(sl.index) == 20
-
-        # Column access
-        for _, series in sl.items():
-            assert len(series.index) == 20
-            assert tm.equalContents(series.index, sl.index)
-
-        for key, _ in float_frame._series.items():
-            assert float_frame[key] is not None
-
-        assert "random" not in float_frame
-        with pytest.raises(KeyError, match="random"):
-            float_frame["random"]
-
-        df = float_frame.copy()
-        df["$10"] = np.random.randn(len(df))
-
-        ad = np.random.randn(len(df))
-        df["@awesome_domain"] = ad
-
-        with pytest.raises(KeyError, match=re.escape("'df[\"$10\"]'")):
-            df.__getitem__('df["$10"]')
-
-        res = df["@awesome_domain"]
-        tm.assert_numpy_array_equal(ad, res.values)
-
-    def test_getitem_dupe_cols(self):
-        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
-        msg = "\"None of [Index(['baf'], dtype='object')] are in the [columns]\""
-        with pytest.raises(KeyError, match=re.escape(msg)):
-            df[["baf"]]
-
-    def test_get(self, float_frame):
-        b = float_frame.get("B")
-        assert_series_equal(b, float_frame["B"])
-
-        assert float_frame.get("foo") is None
-        assert_series_equal(float_frame.get("foo", float_frame["B"]), float_frame["B"])
-
-    @pytest.mark.parametrize(
-        "df",
-        [
-            DataFrame(),
-            DataFrame(columns=list("AB")),
-            DataFrame(columns=list("AB"), index=range(3)),
-        ],
-    )
-    def test_get_none(self, df):
-        # see gh-5652
-        assert df.get(None) is None
-
-    @pytest.mark.parametrize("key_type", [iter, np.array, Series, Index])
-    def test_loc_iterable(self, float_frame, key_type):
-        idx = key_type(["A", "B", "C"])
-        result = float_frame.loc[:, idx]
-        expected = float_frame.loc[:, ["A", "B", "C"]]
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "idx_type",
-        [
-            list,
-            iter,
-            Index,
-            set,
-            lambda l: dict(zip(l, range(len(l)))),
-            lambda l: dict(zip(l, range(len(l)))).keys(),
-        ],
-        ids=["list", "iter", "Index", "set", "dict", "dict_keys"],
-    )
-    @pytest.mark.parametrize("levels", [1, 2])
-    def test_getitem_listlike(self, idx_type, levels, float_frame):
-        # GH 21294
-
-        if levels == 1:
-            frame, missing = float_frame, "food"
-        else:
-            # MultiIndex columns
-            frame = DataFrame(
-                np.random.randn(8, 3),
-                columns=Index(
-                    [("foo", "bar"), ("baz", "qux"), ("peek", "aboo")],
-                    name=("sth", "sth2"),
-                ),
-            )
-            missing = ("good", "food")
-
-        keys = [frame.columns[1], frame.columns[0]]
-        idx = idx_type(keys)
-        idx_check = list(idx_type(keys))
-
-        result = frame[idx]
-
-        expected = frame.loc[:, idx_check]
-        expected.columns.names = frame.columns.names
-
-        assert_frame_equal(result, expected)
-
-        idx = idx_type(keys + [missing])
-        with pytest.raises(KeyError, match="not in index"):
-            frame[idx]
-
-    @pytest.mark.parametrize(
-        "val,expected", [(2 ** 63 - 1, Series([1])), (2 ** 63, Series([2]))]
-    )
-    def test_loc_uint64(self, val, expected):
-        # see gh-19399
-        df = DataFrame([1, 2], index=[2 ** 63 - 1, 2 ** 63])
-        result = df.loc[val]
-
-        expected.name = val
-        tm.assert_series_equal(result, expected)
-
-    def test_getitem_callable(self, float_frame):
-        # GH 12533
-        result = float_frame[lambda x: "A"]
-        tm.assert_series_equal(result, float_frame.loc[:, "A"])
-
-        result = float_frame[lambda x: ["A", "B"]]
-        tm.assert_frame_equal(result, float_frame.loc[:, ["A", "B"]])
-
-        df = float_frame[:3]
-        result = df[lambda x: [True, False, True]]
-        tm.assert_frame_equal(result, float_frame.iloc[[0, 2], :])
-
-    def test_setitem_list(self, float_frame):
-
-        float_frame["E"] = "foo"
-        data = float_frame[["A", "B"]]
-        float_frame[["B", "A"]] = data
-
-        assert_series_equal(float_frame["B"], data["A"], check_names=False)
-        assert_series_equal(float_frame["A"], data["B"], check_names=False)
-
-        msg = "Columns must be same length as key"
-        with pytest.raises(ValueError, match=msg):
-            data[["A"]] = float_frame[["A", "B"]]
-
-        msg = "Length of values does not match length of index"
-        with pytest.raises(ValueError, match=msg):
-            data["A"] = range(len(data.index) - 1)
-
-        df = DataFrame(0, index=range(3), columns=["tt1", "tt2"], dtype=np.int_)
-        df.loc[1, ["tt1", "tt2"]] = [1, 2]
-
-        result = df.loc[df.index[1], ["tt1", "tt2"]]
-        expected = Series([1, 2], df.columns, dtype=np.int_, name=1)
-        assert_series_equal(result, expected)
-
-        df["tt1"] = df["tt2"] = "0"
-        df.loc[df.index[1], ["tt1", "tt2"]] = ["1", "2"]
-        result = df.loc[df.index[1], ["tt1", "tt2"]]
-        expected = Series(["1", "2"], df.columns, name=1)
-        assert_series_equal(result, expected)
-
-    def test_setitem_list_not_dataframe(self, float_frame):
-        data = np.random.randn(len(float_frame), 2)
-        float_frame[["A", "B"]] = data
-        assert_almost_equal(float_frame[["A", "B"]].values, data)
-
-    def test_setitem_list_of_tuples(self, float_frame):
-        tuples = list(zip(float_frame["A"], float_frame["B"]))
-        float_frame["tuples"] = tuples
-
-        result = float_frame["tuples"]
-        expected = Series(tuples, index=float_frame.index, name="tuples")
-        assert_series_equal(result, expected)
-
-    def test_setitem_mulit_index(self):
-        # GH7655, test that assigning to a sub-frame of a frame
-        # with multi-index columns aligns both rows and columns
-        it = ["jim", "joe", "jolie"], ["first", "last"], ["left", "center", "right"]
-
-        cols = MultiIndex.from_product(it)
-        index = pd.date_range("20141006", periods=20)
-        vals = np.random.randint(1, 1000, (len(index), len(cols)))
-        df = pd.DataFrame(vals, columns=cols, index=index)
-
-        i, j = df.index.values.copy(), it[-1][:]
-
-        np.random.shuffle(i)
-        df["jim"] = df["jolie"].loc[i, ::-1]
-        assert_frame_equal(df["jim"], df["jolie"])
-
-        np.random.shuffle(j)
-        df[("joe", "first")] = df[("jolie", "last")].loc[i, j]
-        assert_frame_equal(df[("joe", "first")], df[("jolie", "last")])
-
-        np.random.shuffle(j)
-        df[("joe", "last")] = df[("jolie", "first")].loc[i, j]
-        assert_frame_equal(df[("joe", "last")], df[("jolie", "first")])
-
-    def test_setitem_callable(self):
-        # GH 12533
-        df = pd.DataFrame({"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]})
-        df[lambda x: "A"] = [11, 12, 13, 14]
-
-        exp = pd.DataFrame({"A": [11, 12, 13, 14], "B": [5, 6, 7, 8]})
-        tm.assert_frame_equal(df, exp)
-
-    def test_setitem_other_callable(self):
-        # GH 13299
-        def inc(x):
-            return x + 1
-
-        df = pd.DataFrame([[-1, 1], [1, -1]])
-        df[df > 0] = inc
-
-        expected = pd.DataFrame([[-1, inc], [inc, -1]])
-        tm.assert_frame_equal(df, expected)
-
-    def test_getitem_boolean(
-        self, float_string_frame, mixed_float_frame, mixed_int_frame, datetime_frame
-    ):
-        # boolean indexing
-        d = datetime_frame.index[10]
-        indexer = datetime_frame.index > d
-        indexer_obj = indexer.astype(object)
-
-        subindex = datetime_frame.index[indexer]
-        subframe = datetime_frame[indexer]
-
-        tm.assert_index_equal(subindex, subframe.index)
-        with pytest.raises(ValueError, match="Item wrong length"):
-            datetime_frame[indexer[:-1]]
-
-        subframe_obj = datetime_frame[indexer_obj]
-        assert_frame_equal(subframe_obj, subframe)
-
-        with pytest.raises(ValueError, match="Boolean array expected"):
-            datetime_frame[datetime_frame]
-
-        # test that Series work
-        indexer_obj = Series(indexer_obj, datetime_frame.index)
-
-        subframe_obj = datetime_frame[indexer_obj]
-        assert_frame_equal(subframe_obj, subframe)
-
-        # test that Series indexers reindex
-        # we are producing a warning that since the passed boolean
-        # key is not the same as the given index, we will reindex
-        # not sure this is really necessary
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            indexer_obj = indexer_obj.reindex(datetime_frame.index[::-1])
-            subframe_obj = datetime_frame[indexer_obj]
-            assert_frame_equal(subframe_obj, subframe)
-
-        # test df[df > 0]
-        for df in [
-            datetime_frame,
-            float_string_frame,
-            mixed_float_frame,
-            mixed_int_frame,
-        ]:
-            if df is float_string_frame:
-                continue
-
-            data = df._get_numeric_data()
-            bif = df[df > 0]
-            bifw = DataFrame(
-                {c: np.where(data[c] > 0, data[c], np.nan) for c in data.columns},
-                index=data.index,
-                columns=data.columns,
-            )
-
-            # add back other columns to compare
-            for c in df.columns:
-                if c not in bifw:
-                    bifw[c] = df[c]
-            bifw = bifw.reindex(columns=df.columns)
-
-            assert_frame_equal(bif, bifw, check_dtype=False)
-            for c in df.columns:
-                if bif[c].dtype != bifw[c].dtype:
-                    assert bif[c].dtype == df[c].dtype
-
-    def test_getitem_boolean_casting(self, datetime_frame):
-
-        # don't upcast if we don't need to
-        df = datetime_frame.copy()
-        df["E"] = 1
-        df["E"] = df["E"].astype("int32")
-        df["E1"] = df["E"].copy()
-        df["F"] = 1
-        df["F"] = df["F"].astype("int64")
-        df["F1"] = df["F"].copy()
-
-        casted = df[df > 0]
-        result = casted.dtypes
-        expected = Series(
-            [np.dtype("float64")] * 4
-            + [np.dtype("int32")] * 2
-            + [np.dtype("int64")] * 2,
-            index=["A", "B", "C", "D", "E", "E1", "F", "F1"],
-        )
-        assert_series_equal(result, expected)
-
-        # int block splitting
-        df.loc[df.index[1:3], ["E1", "F1"]] = 0
-        casted = df[df > 0]
-        result = casted.dtypes
-        expected = Series(
-            [np.dtype("float64")] * 4
-            + [np.dtype("int32")]
-            + [np.dtype("float64")]
-            + [np.dtype("int64")]
-            + [np.dtype("float64")],
-            index=["A", "B", "C", "D", "E", "E1", "F", "F1"],
-        )
-        assert_series_equal(result, expected)
-
-        # where dtype conversions
-        # GH 3733
-        df = DataFrame(data=np.random.randn(100, 50))
-        df = df.where(df > 0)  # create nans
-        bools = df > 0
-        mask = isna(df)
-        expected = bools.astype(float).mask(mask)
-        result = bools.mask(mask)
-        assert_frame_equal(result, expected)
-
-    def test_getitem_boolean_list(self):
-        df = DataFrame(np.arange(12).reshape(3, 4))
-
-        def _checkit(lst):
-            result = df[lst]
-            expected = df.loc[df.index[lst]]
-            assert_frame_equal(result, expected)
-
-        _checkit([True, False, True])
-        _checkit([True, True, True])
-        _checkit([False, False, False])
-
-    def test_getitem_boolean_iadd(self):
-        arr = np.random.randn(5, 5)
-
-        df = DataFrame(arr.copy(), columns=["A", "B", "C", "D", "E"])
-
-        df[df < 0] += 1
-        arr[arr < 0] += 1
-
-        assert_almost_equal(df.values, arr)
-
-    def test_boolean_index_empty_corner(self):
-        # #2096
-        blah = DataFrame(np.empty([0, 1]), columns=["A"], index=DatetimeIndex([]))
-
-        # both of these should succeed trivially
-        k = np.array([], bool)
-
-        blah[k]
-        blah[k] = 0
-
-    def test_getitem_ix_mixed_integer(self):
-        df = DataFrame(
-            np.random.randn(4, 3), index=[1, 10, "C", "E"], columns=[1, 2, 3]
-        )
-
-        result = df.iloc[:-1]
-        expected = df.loc[df.index[:-1]]
-        assert_frame_equal(result, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[[1, 10]]
-            expected = df.ix[Index([1, 10], dtype=object)]
-        assert_frame_equal(result, expected)
-
-        # 11320
-        df = pd.DataFrame(
-            {
-                "rna": (1.5, 2.2, 3.2, 4.5),
-                -1000: [11, 21, 36, 40],
-                0: [10, 22, 43, 34],
-                1000: [0, 10, 20, 30],
-            },
-            columns=["rna", -1000, 0, 1000],
-        )
-        result = df[[1000]]
-        expected = df.iloc[:, [3]]
-        assert_frame_equal(result, expected)
-        result = df[[-1000]]
-        expected = df.iloc[:, [1]]
-        assert_frame_equal(result, expected)
-
-    def test_getitem_setitem_ix_negative_integers(self, float_frame):
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = float_frame.ix[:, -1]
-        assert_series_equal(result, float_frame["D"])
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = float_frame.ix[:, [-1]]
-        assert_frame_equal(result, float_frame[["D"]])
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = float_frame.ix[:, [-1, -2]]
-        assert_frame_equal(result, float_frame[["D", "C"]])
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            float_frame.ix[:, [-1]] = 0
-        assert (float_frame["D"] == 0).all()
-
-        df = DataFrame(np.random.randn(8, 4))
-        # ix does label-based indexing when having an integer index
-        msg = "\"None of [Int64Index([-1], dtype='int64')] are in the [index]\""
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            with pytest.raises(KeyError, match=re.escape(msg)):
-                df.ix[[-1]]
-
-        msg = "\"None of [Int64Index([-1], dtype='int64')] are in the [columns]\""
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            with pytest.raises(KeyError, match=re.escape(msg)):
-                df.ix[:, [-1]]
-
-        # #1942
-        a = DataFrame(np.random.randn(20, 2), index=[chr(x + 65) for x in range(20)])
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            a.ix[-1] = a.ix[-2]
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_series_equal(a.ix[-1], a.ix[-2], check_names=False)
-            assert a.ix[-1].name == "T"
-            assert a.ix[-2].name == "S"
-
-    def test_getattr(self, float_frame):
-        assert_series_equal(float_frame.A, float_frame["A"])
-        msg = "'DataFrame' object has no attribute 'NONEXISTENT_NAME'"
-        with pytest.raises(AttributeError, match=msg):
-            float_frame.NONEXISTENT_NAME
-
-    def test_setattr_column(self):
-        df = DataFrame({"foobar": 1}, index=range(10))
-
-        df.foobar = 5
-        assert (df.foobar == 5).all()
-
-    def test_setitem(self, float_frame):
-        # not sure what else to do here
-        series = float_frame["A"][::2]
-        float_frame["col5"] = series
-        assert "col5" in float_frame
-
-        assert len(series) == 15
-        assert len(float_frame) == 30
-
-        exp = np.ravel(np.column_stack((series.values, [np.nan] * 15)))
-        exp = Series(exp, index=float_frame.index, name="col5")
-        tm.assert_series_equal(float_frame["col5"], exp)
-
-        series = float_frame["A"]
-        float_frame["col6"] = series
-        tm.assert_series_equal(series, float_frame["col6"], check_names=False)
-
-        msg = (
-            r"\"None of \[Float64Index\(\[.*dtype='float64'\)\] are in the"
-            r" \[columns\]\""
-        )
-        with pytest.raises(KeyError, match=msg):
-            float_frame[np.random.randn(len(float_frame) + 1)] = 1
-
-        # set ndarray
-        arr = np.random.randn(len(float_frame))
-        float_frame["col9"] = arr
-        assert (float_frame["col9"] == arr).all()
-
-        float_frame["col7"] = 5
-        assert (float_frame["col7"] == 5).all()
-
-        float_frame["col0"] = 3.14
-        assert (float_frame["col0"] == 3.14).all()
-
-        float_frame["col8"] = "foo"
-        assert (float_frame["col8"] == "foo").all()
-
-        # this is partially a view (e.g. some blocks are view)
-        # so raise/warn
-        smaller = float_frame[:2]
-
-        with pytest.raises(com.SettingWithCopyError):
-            smaller["col10"] = ["1", "2"]
-
-        assert smaller["col10"].dtype == np.object_
-        assert (smaller["col10"] == ["1", "2"]).all()
-
-        # dtype changing GH4204
-        df = DataFrame([[0, 0]])
-        df.iloc[0] = np.nan
-        expected = DataFrame([[np.nan, np.nan]])
-        assert_frame_equal(df, expected)
-
-        df = DataFrame([[0, 0]])
-        df.loc[0] = np.nan
-        assert_frame_equal(df, expected)
-
-    @pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"])
-    def test_setitem_dtype(self, dtype, float_frame):
-        arr = np.random.randn(len(float_frame))
-
-        float_frame[dtype] = np.array(arr, dtype=dtype)
-        assert float_frame[dtype].dtype.name == dtype
-
-    def test_setitem_tuple(self, float_frame):
-        float_frame["A", "B"] = float_frame["A"]
-        assert_series_equal(float_frame["A", "B"], float_frame["A"], check_names=False)
-
-    def test_setitem_always_copy(self, float_frame):
-        s = float_frame["A"].copy()
-        float_frame["E"] = s
-
-        float_frame["E"][5:10] = np.nan
-        assert notna(s[5:10]).all()
-
-    def test_setitem_boolean(self, float_frame):
-        df = float_frame.copy()
-        values = float_frame.values
-
-        df[df["A"] > 0] = 4
-        values[values[:, 0] > 0] = 4
-        assert_almost_equal(df.values, values)
-
-        # test that column reindexing works
-        series = df["A"] == 4
-        series = series.reindex(df.index[::-1])
-        df[series] = 1
-        values[values[:, 0] == 4] = 1
-        assert_almost_equal(df.values, values)
-
-        df[df > 0] = 5
-        values[values > 0] = 5
-        assert_almost_equal(df.values, values)
-
-        df[df == 5] = 0
-        values[values == 5] = 0
-        assert_almost_equal(df.values, values)
-
-        # a df that needs alignment first
-        df[df[:-1] < 0] = 2
-        np.putmask(values[:-1], values[:-1] < 0, 2)
-        assert_almost_equal(df.values, values)
-
-        # indexed with same shape but rows-reversed df
-        df[df[::-1] == 2] = 3
-        values[values == 2] = 3
-        assert_almost_equal(df.values, values)
-
-        msg = "Must pass DataFrame or 2-d ndarray with boolean values only"
-        with pytest.raises(TypeError, match=msg):
-            df[df * 0] = 2
-
-        # index with DataFrame
-        mask = df > np.abs(df)
-        expected = df.copy()
-        df[df > np.abs(df)] = np.nan
-        expected.values[mask.values] = np.nan
-        assert_frame_equal(df, expected)
-
-        # set from DataFrame
-        expected = df.copy()
-        df[df > np.abs(df)] = df * 2
-        np.putmask(expected.values, mask.values, df.values * 2)
-        assert_frame_equal(df, expected)
-
-    @pytest.mark.parametrize(
-        "mask_type",
-        [lambda df: df > np.abs(df) / 2, lambda df: (df > np.abs(df) / 2).values],
-        ids=["dataframe", "array"],
-    )
-    def test_setitem_boolean_mask(self, mask_type, float_frame):
-
-        # Test for issue #18582
-        df = float_frame.copy()
-        mask = mask_type(df)
-
-        # index with boolean mask
-        result = df.copy()
-        result[mask] = np.nan
-
-        expected = df.copy()
-        expected.values[np.array(mask)] = np.nan
-        assert_frame_equal(result, expected)
-
-    def test_setitem_cast(self, float_frame):
-        float_frame["D"] = float_frame["D"].astype("i8")
-        assert float_frame["D"].dtype == np.int64
-
-        # #669, should not cast?
-        # this is now set to int64, which means a replacement of the column to
-        # the value dtype (and nothing to do with the existing dtype)
-        float_frame["B"] = 0
-        assert float_frame["B"].dtype == np.int64
-
-        # cast if pass array of course
-        float_frame["B"] = np.arange(len(float_frame))
-        assert issubclass(float_frame["B"].dtype.type, np.integer)
-
-        float_frame["foo"] = "bar"
-        float_frame["foo"] = 0
-        assert float_frame["foo"].dtype == np.int64
-
-        float_frame["foo"] = "bar"
-        float_frame["foo"] = 2.5
-        assert float_frame["foo"].dtype == np.float64
-
-        float_frame["something"] = 0
-        assert float_frame["something"].dtype == np.int64
-        float_frame["something"] = 2
-        assert float_frame["something"].dtype == np.int64
-        float_frame["something"] = 2.5
-        assert float_frame["something"].dtype == np.float64
-
-        # GH 7704
-        # dtype conversion on setting
-        df = DataFrame(np.random.rand(30, 3), columns=tuple("ABC"))
-        df["event"] = np.nan
-        df.loc[10, "event"] = "foo"
-        result = df.dtypes
-        expected = Series(
-            [np.dtype("float64")] * 3 + [np.dtype("object")],
-            index=["A", "B", "C", "event"],
-        )
-        assert_series_equal(result, expected)
-
-        # Test that data type is preserved . #5782
-        df = DataFrame({"one": np.arange(6, dtype=np.int8)})
-        df.loc[1, "one"] = 6
-        assert df.dtypes.one == np.dtype(np.int8)
-        df.one = np.int8(7)
-        assert df.dtypes.one == np.dtype(np.int8)
-
-    def test_setitem_boolean_column(self, float_frame):
-        expected = float_frame.copy()
-        mask = float_frame["A"] > 0
-
-        float_frame.loc[mask, "B"] = 0
-        expected.values[mask.values, 1] = 0
-
-        assert_frame_equal(float_frame, expected)
-
-    def test_frame_setitem_timestamp(self):
-        # GH#2155
-        columns = date_range(start="1/1/2012", end="2/1/2012", freq=BDay())
-        data = DataFrame(columns=columns, index=range(10))
-        t = datetime(2012, 11, 1)
-        ts = Timestamp(t)
-        data[ts] = np.nan  # works, mostly a smoke-test
-        assert np.isnan(data[ts]).all()
-
-    def test_setitem_corner(self, float_frame):
-        # corner case
-        df = DataFrame({"B": [1.0, 2.0, 3.0], "C": ["a", "b", "c"]}, index=np.arange(3))
-        del df["B"]
-        df["B"] = [1.0, 2.0, 3.0]
-        assert "B" in df
-        assert len(df.columns) == 2
-
-        df["A"] = "beginning"
-        df["E"] = "foo"
-        df["D"] = "bar"
-        df[datetime.now()] = "date"
-        df[datetime.now()] = 5.0
-
-        # what to do when empty frame with index
-        dm = DataFrame(index=float_frame.index)
-        dm["A"] = "foo"
-        dm["B"] = "bar"
-        assert len(dm.columns) == 2
-        assert dm.values.dtype == np.object_
-
-        # upcast
-        dm["C"] = 1
-        assert dm["C"].dtype == np.int64
-
-        dm["E"] = 1.0
-        assert dm["E"].dtype == np.float64
-
-        # set existing column
-        dm["A"] = "bar"
-        assert "bar" == dm["A"][0]
-
-        dm = DataFrame(index=np.arange(3))
-        dm["A"] = 1
-        dm["foo"] = "bar"
-        del dm["foo"]
-        dm["foo"] = "bar"
-        assert dm["foo"].dtype == np.object_
-
-        dm["coercable"] = ["1", "2", "3"]
-        assert dm["coercable"].dtype == np.object_
-
-    def test_setitem_corner2(self):
-        data = {
-            "title": ["foobar", "bar", "foobar"] + ["foobar"] * 17,
-            "cruft": np.random.random(20),
-        }
-
-        df = DataFrame(data)
-        ix = df[df["title"] == "bar"].index
-
-        df.loc[ix, ["title"]] = "foobar"
-        df.loc[ix, ["cruft"]] = 0
-
-        assert df.loc[1, "title"] == "foobar"
-        assert df.loc[1, "cruft"] == 0
-
-    def test_setitem_ambig(self):
-        # Difficulties with mixed-type data
-        from decimal import Decimal
-
-        # Created as float type
-        dm = DataFrame(index=range(3), columns=range(3))
-
-        coercable_series = Series([Decimal(1) for _ in range(3)], index=range(3))
-        uncoercable_series = Series(["foo", "bzr", "baz"], index=range(3))
-
-        dm[0] = np.ones(3)
-        assert len(dm.columns) == 3
-
-        dm[1] = coercable_series
-        assert len(dm.columns) == 3
-
-        dm[2] = uncoercable_series
-        assert len(dm.columns) == 3
-        assert dm[2].dtype == np.object_
-
-    def test_setitem_clear_caches(self):
-        # see gh-304
-        df = DataFrame(
-            {"x": [1.1, 2.1, 3.1, 4.1], "y": [5.1, 6.1, 7.1, 8.1]}, index=[0, 1, 2, 3]
-        )
-        df.insert(2, "z", np.nan)
-
-        # cache it
-        foo = df["z"]
-        df.loc[df.index[2:], "z"] = 42
-
-        expected = Series([np.nan, np.nan, 42, 42], index=df.index, name="z")
-
-        assert df["z"] is not foo
-        tm.assert_series_equal(df["z"], expected)
-
-    def test_setitem_None(self, float_frame):
-        # GH #766
-        float_frame[None] = float_frame["A"]
-        assert_series_equal(
-            float_frame.iloc[:, -1], float_frame["A"], check_names=False
-        )
-        assert_series_equal(
-            float_frame.loc[:, None], float_frame["A"], check_names=False
-        )
-        assert_series_equal(float_frame[None], float_frame["A"], check_names=False)
-        repr(float_frame)
-
-    def test_setitem_empty(self):
-        # GH 9596
-        df = pd.DataFrame(
-            {"a": ["1", "2", "3"], "b": ["11", "22", "33"], "c": ["111", "222", "333"]}
-        )
-
-        result = df.copy()
-        result.loc[result.b.isna(), "a"] = result.a
-        assert_frame_equal(result, df)
-
-    @pytest.mark.parametrize("dtype", ["float", "int64"])
-    @pytest.mark.parametrize("kwargs", [dict(), dict(index=[1]), dict(columns=["A"])])
-    def test_setitem_empty_frame_with_boolean(self, dtype, kwargs):
-        # see gh-10126
-        kwargs["dtype"] = dtype
-        df = DataFrame(**kwargs)
-
-        df2 = df.copy()
-        df[df > df2] = 47
-        assert_frame_equal(df, df2)
-
-    def test_setitem_with_empty_listlike(self):
-        # GH #17101
-        index = pd.Index([], name="idx")
-        result = pd.DataFrame(columns=["A"], index=index)
-        result["A"] = []
-        expected = pd.DataFrame(columns=["A"], index=index)
-        tm.assert_index_equal(result.index, expected.index)
-
-    def test_setitem_scalars_no_index(self):
-        # GH16823 / 17894
-        df = DataFrame()
-        df["foo"] = 1
-        expected = DataFrame(columns=["foo"]).astype(np.int64)
-        assert_frame_equal(df, expected)
-
-    def test_getitem_empty_frame_with_boolean(self):
-        # Test for issue #11859
-
-        df = pd.DataFrame()
-        df2 = df[df > 0]
-        assert_frame_equal(df, df2)
-
-    def test_delitem_corner(self, float_frame):
-        f = float_frame.copy()
-        del f["D"]
-        assert len(f.columns) == 3
-        with pytest.raises(KeyError, match=r"^'D'$"):
-            del f["D"]
-        del f["B"]
-        assert len(f.columns) == 2
-
-    def test_getitem_fancy_2d(self, float_frame):
-        f = float_frame
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(f.ix[:, ["B", "A"]], f.reindex(columns=["B", "A"]))
-
-        subidx = float_frame.index[[5, 4, 1]]
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(
-                f.ix[subidx, ["B", "A"]], f.reindex(index=subidx, columns=["B", "A"])
-            )
-
-        # slicing rows, etc.
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(f.ix[5:10], f[5:10])
-            assert_frame_equal(f.ix[5:10, :], f[5:10])
-            assert_frame_equal(
-                f.ix[:5, ["A", "B"]], f.reindex(index=f.index[:5], columns=["A", "B"])
-            )
-
-        # slice rows with labels, inclusive!
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            expected = f.ix[5:11]
-            result = f.ix[f.index[5] : f.index[10]]
-        assert_frame_equal(expected, result)
-
-        # slice columns
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(f.ix[:, :2], f.reindex(columns=["A", "B"]))
-
-        # get view
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            exp = f.copy()
-            f.ix[5:10].values[:] = 5
-            exp.values[5:10] = 5
-            assert_frame_equal(f, exp)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            msg = "Cannot index with multidimensional key"
-            with pytest.raises(ValueError, match=msg):
-                f.ix[f > 0.5]
-
-    def test_slice_floats(self):
-        index = [52195.504153, 52196.303147, 52198.369883]
-        df = DataFrame(np.random.rand(3, 2), index=index)
-
-        s1 = df.loc[52195.1:52196.5]
-        assert len(s1) == 2
-
-        s1 = df.loc[52195.1:52196.6]
-        assert len(s1) == 2
-
-        s1 = df.loc[52195.1:52198.9]
-        assert len(s1) == 3
-
-    def test_getitem_fancy_slice_integers_step(self):
-        df = DataFrame(np.random.randn(10, 5))
-
-        # this is OK
-        result = df.iloc[:8:2]  # noqa
-        df.iloc[:8:2] = np.nan
-        assert isna(df.iloc[:8:2]).values.all()
-
-    def test_getitem_setitem_integer_slice_keyerrors(self):
-        df = DataFrame(np.random.randn(10, 5), index=range(0, 20, 2))
-
-        # this is OK
-        cp = df.copy()
-        cp.iloc[4:10] = 0
-        assert (cp.iloc[4:10] == 0).values.all()
-
-        # so is this
-        cp = df.copy()
-        cp.iloc[3:11] = 0
-        assert (cp.iloc[3:11] == 0).values.all()
-
-        result = df.iloc[2:6]
-        result2 = df.loc[3:11]
-        expected = df.reindex([4, 6, 8, 10])
-
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-
-        # non-monotonic, raise KeyError
-        df2 = df.iloc[list(range(5)) + list(range(5, 10))[::-1]]
-        with pytest.raises(KeyError, match=r"^3$"):
-            df2.loc[3:11]
-        with pytest.raises(KeyError, match=r"^3$"):
-            df2.loc[3:11] = 0
-
-    def test_setitem_fancy_2d(self, float_frame):
-
-        # case 1
-        frame = float_frame.copy()
-        expected = frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[:, ["B", "A"]] = 1
-        expected["B"] = 1.0
-        expected["A"] = 1.0
-        assert_frame_equal(frame, expected)
-
-        # case 2
-        frame = float_frame.copy()
-        frame2 = float_frame.copy()
-
-        expected = frame.copy()
-
-        subidx = float_frame.index[[5, 4, 1]]
-        values = np.random.randn(3, 2)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[subidx, ["B", "A"]] = values
-            frame2.ix[[5, 4, 1], ["B", "A"]] = values
-
-            expected["B"].ix[subidx] = values[:, 0]
-            expected["A"].ix[subidx] = values[:, 1]
-
-        assert_frame_equal(frame, expected)
-        assert_frame_equal(frame2, expected)
-
-        # case 3: slicing rows, etc.
-        frame = float_frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            expected1 = float_frame.copy()
-            frame.ix[5:10] = 1.0
-            expected1.values[5:10] = 1.0
-        assert_frame_equal(frame, expected1)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            expected2 = float_frame.copy()
-            arr = np.random.randn(5, len(frame.columns))
-            frame.ix[5:10] = arr
-            expected2.values[5:10] = arr
-        assert_frame_equal(frame, expected2)
-
-        # case 4
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame = float_frame.copy()
-            frame.ix[5:10, :] = 1.0
-            assert_frame_equal(frame, expected1)
-            frame.ix[5:10, :] = arr
-        assert_frame_equal(frame, expected2)
-
-        # case 5
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame = float_frame.copy()
-            frame2 = float_frame.copy()
-
-            expected = float_frame.copy()
-            values = np.random.randn(5, 2)
-
-            frame.ix[:5, ["A", "B"]] = values
-            expected["A"][:5] = values[:, 0]
-            expected["B"][:5] = values[:, 1]
-        assert_frame_equal(frame, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame2.ix[:5, [0, 1]] = values
-        assert_frame_equal(frame2, expected)
-
-        # case 6: slice rows with labels, inclusive!
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame = float_frame.copy()
-            expected = float_frame.copy()
-
-            frame.ix[frame.index[5] : frame.index[10]] = 5.0
-            expected.values[5:11] = 5
-        assert_frame_equal(frame, expected)
-
-        # case 7: slice columns
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame = float_frame.copy()
-            frame2 = float_frame.copy()
-            expected = float_frame.copy()
-
-            # slice indices
-            frame.ix[:, 1:3] = 4.0
-            expected.values[:, 1:3] = 4.0
-            assert_frame_equal(frame, expected)
-
-            # slice with labels
-            frame.ix[:, "B":"C"] = 4.0
-            assert_frame_equal(frame, expected)
-
-        # new corner case of boolean slicing / setting
-        frame = DataFrame(zip([2, 3, 9, 6, 7], [np.nan] * 5), columns=["a", "b"])
-        lst = [100]
-        lst.extend([np.nan] * 4)
-        expected = DataFrame(zip([100, 3, 9, 6, 7], lst), columns=["a", "b"])
-        frame[frame["a"] == 2] = 100
-        assert_frame_equal(frame, expected)
-
-    def test_fancy_getitem_slice_mixed(self, float_frame, float_string_frame):
-        sliced = float_string_frame.iloc[:, -3:]
-        assert sliced["D"].dtype == np.float64
-
-        # get view with single block
-        # setting it triggers setting with copy
-        sliced = float_frame.iloc[:, -3:]
-
-        with pytest.raises(com.SettingWithCopyError):
-            sliced["C"] = 4.0
-
-        assert (float_frame["C"] == 4).all()
-
-    def test_fancy_setitem_int_labels(self):
-        # integer index defers to label-based indexing
-
-        df = DataFrame(np.random.randn(10, 5), index=np.arange(0, 20, 2))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            tmp = df.copy()
-            exp = df.copy()
-            tmp.ix[[0, 2, 4]] = 5
-            exp.values[:3] = 5
-        assert_frame_equal(tmp, exp)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            tmp = df.copy()
-            exp = df.copy()
-            tmp.ix[6] = 5
-            exp.values[3] = 5
-        assert_frame_equal(tmp, exp)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            tmp = df.copy()
-            exp = df.copy()
-            tmp.ix[:, 2] = 5
-
-        # tmp correctly sets the dtype
-        # so match the exp way
-        exp[2] = 5
-        assert_frame_equal(tmp, exp)
-
-    def test_fancy_getitem_int_labels(self):
-        df = DataFrame(np.random.randn(10, 5), index=np.arange(0, 20, 2))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[[4, 2, 0], [2, 0]]
-            expected = df.reindex(index=[4, 2, 0], columns=[2, 0])
-        assert_frame_equal(result, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[[4, 2, 0]]
-            expected = df.reindex(index=[4, 2, 0])
-        assert_frame_equal(result, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[4]
-            expected = df.xs(4)
-        assert_series_equal(result, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[:, 3]
-            expected = df[3]
-        assert_series_equal(result, expected)
-
-    def test_fancy_index_int_labels_exceptions(self, float_frame):
-        df = DataFrame(np.random.randn(10, 5), index=np.arange(0, 20, 2))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-
-            # labels that aren't contained
-            with pytest.raises(KeyError, match=r"\[1\] not in index"):
-                df.ix[[0, 1, 2], [2, 3, 4]] = 5
-
-            # try to set indices not contained in frame
-            msg = (
-                r"None of \[Index\(\['foo', 'bar', 'baz'\],"
-                r" dtype='object'\)\] are in the \[index\]"
-            )
-            with pytest.raises(KeyError, match=msg):
-                float_frame.ix[["foo", "bar", "baz"]] = 1
-            msg = (
-                r"None of \[Index\(\['E'\], dtype='object'\)\] are in the"
-                r" \[columns\]"
-            )
-            with pytest.raises(KeyError, match=msg):
-                float_frame.ix[:, ["E"]] = 1
-
-            # FIXME: don't leave commented-out
-            # partial setting now allows this GH2578
-            # pytest.raises(KeyError, float_frame.ix.__setitem__,
-            #               (slice(None, None), 'E'), 1)
-
-    def test_setitem_fancy_mixed_2d(self, float_string_frame):
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            self.mixed_frame.ix[:5, ["C", "B", "A"]] = 5
-            result = self.mixed_frame.ix[:5, ["C", "B", "A"]]
-            assert (result.values == 5).all()
-
-            float_string_frame.ix[5] = np.nan
-            assert isna(float_string_frame.ix[5]).all()
-
-            float_string_frame.ix[5] = float_string_frame.ix[6]
-            assert_series_equal(
-                float_string_frame.ix[5], float_string_frame.ix[6], check_names=False
-            )
-
-        # #1432
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df = DataFrame({1: [1.0, 2.0, 3.0], 2: [3, 4, 5]})
-            assert df._is_mixed_type
-
-            df.ix[1] = [5, 10]
-
-            expected = DataFrame({1: [1.0, 5.0, 3.0], 2: [3, 10, 5]})
-
-            assert_frame_equal(df, expected)
-
-    def test_ix_align(self):
-        b = Series(np.random.randn(10), name=0).sort_values()
-        df_orig = DataFrame(np.random.randn(10, 4))
-        df = df_orig.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df.ix[:, 0] = b
-            assert_series_equal(df.ix[:, 0].reindex(b.index), b)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            dft = df_orig.T
-            dft.ix[0, :] = b
-            assert_series_equal(dft.ix[0, :].reindex(b.index), b)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df = df_orig.copy()
-            df.ix[:5, 0] = b
-            s = df.ix[:5, 0]
-            assert_series_equal(s, b.reindex(s.index))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            dft = df_orig.T
-            dft.ix[0, :5] = b
-            s = dft.ix[0, :5]
-            assert_series_equal(s, b.reindex(s.index))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df = df_orig.copy()
-            idx = [0, 1, 3, 5]
-            df.ix[idx, 0] = b
-            s = df.ix[idx, 0]
-            assert_series_equal(s, b.reindex(s.index))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            dft = df_orig.T
-            dft.ix[0, idx] = b
-            s = dft.ix[0, idx]
-            assert_series_equal(s, b.reindex(s.index))
-
-    def test_ix_frame_align(self):
-        b = DataFrame(np.random.randn(3, 4))
-        df_orig = DataFrame(np.random.randn(10, 4))
-        df = df_orig.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df.ix[:3] = b
-            out = b.ix[:3]
-            assert_frame_equal(out, b)
-
-        b.sort_index(inplace=True)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df = df_orig.copy()
-            df.ix[[0, 1, 2]] = b
-            out = df.ix[[0, 1, 2]].reindex(b.index)
-            assert_frame_equal(out, b)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            df = df_orig.copy()
-            df.ix[:3] = b
-            out = df.ix[:3]
-            assert_frame_equal(out, b.reindex(out.index))
-
-    def test_getitem_setitem_non_ix_labels(self):
-        df = tm.makeTimeDataFrame()
-
-        start, end = df.index[[5, 10]]
-
-        result = df.loc[start:end]
-        result2 = df[start:end]
-        expected = df[5:11]
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-
-        result = df.copy()
-        result.loc[start:end] = 0
-        result2 = df.copy()
-        result2[start:end] = 0
-        expected = df.copy()
-        expected[5:11] = 0
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-
-    def test_ix_multi_take(self):
-        df = DataFrame(np.random.randn(3, 2))
-        rs = df.loc[df.index == 0, :]
-        xp = df.reindex([0])
-        assert_frame_equal(rs, xp)
-
-        """ #1321
-        df = DataFrame(np.random.randn(3, 2))
-        rs = df.loc[df.index==0, df.columns==1]
-        xp = df.reindex([0], [1])
-        assert_frame_equal(rs, xp)
-        """
-
-    def test_ix_multi_take_nonint_index(self):
-        df = DataFrame(np.random.randn(3, 2), index=["x", "y", "z"], columns=["a", "b"])
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            rs = df.ix[[0], [0]]
-        xp = df.reindex(["x"], columns=["a"])
-        assert_frame_equal(rs, xp)
-
-    def test_ix_multi_take_multiindex(self):
-        df = DataFrame(
-            np.random.randn(3, 2),
-            index=["x", "y", "z"],
-            columns=[["a", "b"], ["1", "2"]],
-        )
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            rs = df.ix[[0], [0]]
-        xp = df.reindex(["x"], columns=[("a", "1")])
-        assert_frame_equal(rs, xp)
-
-    def test_ix_dup(self):
-        idx = Index(["a", "a", "b", "c", "d", "d"])
-        df = DataFrame(np.random.randn(len(idx), 3), idx)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            sub = df.ix[:"d"]
-            assert_frame_equal(sub, df)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            sub = df.ix["a":"c"]
-            assert_frame_equal(sub, df.ix[0:4])
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            sub = df.ix["b":"d"]
-            assert_frame_equal(sub, df.ix[2:])
-
-    def test_getitem_fancy_1d(self, float_frame, float_string_frame):
-        f = float_frame
-
-        # return self if no slicing...for now
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert f.ix[:, :] is f
-
-        # low dimensional slice
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            xs1 = f.ix[2, ["C", "B", "A"]]
-        xs2 = f.xs(f.index[2]).reindex(["C", "B", "A"])
-        tm.assert_series_equal(xs1, xs2)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            ts1 = f.ix[5:10, 2]
-        ts2 = f[f.columns[2]][5:10]
-        tm.assert_series_equal(ts1, ts2)
-
-        # positional xs
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            xs1 = f.ix[0]
-        xs2 = f.xs(f.index[0])
-        tm.assert_series_equal(xs1, xs2)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            xs1 = f.ix[f.index[5]]
-        xs2 = f.xs(f.index[5])
-        tm.assert_series_equal(xs1, xs2)
-
-        # single column
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_series_equal(f.ix[:, "A"], f["A"])
-
-        # return view
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            exp = f.copy()
-            exp.values[5] = 4
-            f.ix[5][:] = 4
-        tm.assert_frame_equal(exp, f)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            exp.values[:, 1] = 6
-            f.ix[:, 1][:] = 6
-        tm.assert_frame_equal(exp, f)
-
-        # slice of mixed-frame
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            xs = float_string_frame.ix[5]
-        exp = float_string_frame.xs(float_string_frame.index[5])
-        tm.assert_series_equal(xs, exp)
-
-    def test_setitem_fancy_1d(self, float_frame):
-
-        # case 1: set cross-section for indices
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[2, ["C", "B", "A"]] = [1.0, 2.0, 3.0]
-        expected["C"][2] = 1.0
-        expected["B"][2] = 2.0
-        expected["A"][2] = 3.0
-        assert_frame_equal(frame, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame2 = float_frame.copy()
-            frame2.ix[2, [3, 2, 1]] = [1.0, 2.0, 3.0]
-        assert_frame_equal(frame, expected)
-
-        # case 2, set a section of a column
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            vals = np.random.randn(5)
-            expected.values[5:10, 2] = vals
-            frame.ix[5:10, 2] = vals
-        assert_frame_equal(frame, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame2 = float_frame.copy()
-            frame2.ix[5:10, "B"] = vals
-        assert_frame_equal(frame, expected)
-
-        # case 3: full xs
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[4] = 5.0
-            expected.values[4] = 5.0
-        assert_frame_equal(frame, expected)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[frame.index[4]] = 6.0
-            expected.values[4] = 6.0
-        assert_frame_equal(frame, expected)
-
-        # single column
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            frame.ix[:, "A"] = 7.0
-            expected["A"] = 7.0
-        assert_frame_equal(frame, expected)
-
-    def test_getitem_fancy_scalar(self, float_frame):
-        f = float_frame
-        ix = f.loc
-
-        # individual value
-        for col in f.columns:
-            ts = f[col]
-            for idx in f.index[::5]:
-                assert ix[idx, col] == ts[idx]
-
-    def test_setitem_fancy_scalar(self, float_frame):
-        f = float_frame
-        expected = float_frame.copy()
-        ix = f.loc
-
-        # individual value
-        for j, col in enumerate(f.columns):
-            ts = f[col]  # noqa
-            for idx in f.index[::5]:
-                i = f.index.get_loc(idx)
-                val = np.random.randn()
-                expected.values[i, j] = val
-
-                ix[idx, col] = val
-                assert_frame_equal(f, expected)
-
-    def test_getitem_fancy_boolean(self, float_frame):
-        f = float_frame
-        ix = f.loc
-
-        expected = f.reindex(columns=["B", "D"])
-        result = ix[:, [False, True, False, True]]
-        assert_frame_equal(result, expected)
-
-        expected = f.reindex(index=f.index[5:10], columns=["B", "D"])
-        result = ix[f.index[5:10], [False, True, False, True]]
-        assert_frame_equal(result, expected)
-
-        boolvec = f.index > f.index[7]
-        expected = f.reindex(index=f.index[boolvec])
-        result = ix[boolvec]
-        assert_frame_equal(result, expected)
-        result = ix[boolvec, :]
-        assert_frame_equal(result, expected)
-
-        result = ix[boolvec, f.columns[2:]]
-        expected = f.reindex(index=f.index[boolvec], columns=["C", "D"])
-        assert_frame_equal(result, expected)
-
-    def test_setitem_fancy_boolean(self, float_frame):
-        # from 2d, set with booleans
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-
-        mask = frame["A"] > 0
-        frame.loc[mask] = 0.0
-        expected.values[mask.values] = 0.0
-        assert_frame_equal(frame, expected)
-
-        frame = float_frame.copy()
-        expected = float_frame.copy()
-        frame.loc[mask, ["A", "B"]] = 0.0
-        expected.values[mask.values, :2] = 0.0
-        assert_frame_equal(frame, expected)
-
-    def test_getitem_fancy_ints(self, float_frame):
-        result = float_frame.iloc[[1, 4, 7]]
-        expected = float_frame.loc[float_frame.index[[1, 4, 7]]]
-        assert_frame_equal(result, expected)
-
-        result = float_frame.iloc[:, [2, 0, 1]]
-        expected = float_frame.loc[:, float_frame.columns[[2, 0, 1]]]
-        assert_frame_equal(result, expected)
-
-    def test_getitem_setitem_fancy_exceptions(self, float_frame):
-        ix = float_frame.iloc
-        with pytest.raises(IndexingError, match="Too many indexers"):
-            ix[:, :, :]
-
-        with pytest.raises(IndexingError):
-            ix[:, :, :] = 1
-
-    def test_getitem_setitem_boolean_misaligned(self, float_frame):
-        # boolean index misaligned labels
-        mask = float_frame["A"][::-1] > 1
-
-        result = float_frame.loc[mask]
-        expected = float_frame.loc[mask[::-1]]
-        assert_frame_equal(result, expected)
-
-        cp = float_frame.copy()
-        expected = float_frame.copy()
-        cp.loc[mask] = 0
-        expected.loc[mask] = 0
-        assert_frame_equal(cp, expected)
-
-    def test_getitem_setitem_boolean_multi(self):
-        df = DataFrame(np.random.randn(3, 2))
-
-        # get
-        k1 = np.array([True, False, True])
-        k2 = np.array([False, True])
-        result = df.loc[k1, k2]
-        expected = df.loc[[0, 2], [1]]
-        assert_frame_equal(result, expected)
-
-        expected = df.copy()
-        df.loc[np.array([True, False, True]), np.array([False, True])] = 5
-        expected.loc[[0, 2], [1]] = 5
-        assert_frame_equal(df, expected)
-
-    def test_getitem_setitem_float_labels(self):
-        index = Index([1.5, 2, 3, 4, 5])
-        df = DataFrame(np.random.randn(5, 5), index=index)
-
-        result = df.loc[1.5:4]
-        expected = df.reindex([1.5, 2, 3, 4])
-        assert_frame_equal(result, expected)
-        assert len(result) == 4
-
-        result = df.loc[4:5]
-        expected = df.reindex([4, 5])  # reindex with int
-        assert_frame_equal(result, expected, check_index_type=False)
-        assert len(result) == 2
-
-        result = df.loc[4:5]
-        expected = df.reindex([4.0, 5.0])  # reindex with float
-        assert_frame_equal(result, expected)
-        assert len(result) == 2
-
-        # loc_float changes this to work properly
-        result = df.loc[1:2]
-        expected = df.iloc[0:2]
-        assert_frame_equal(result, expected)
-
-        df.loc[1:2] = 0
-        result = df[1:2]
-        assert (result == 0).all().all()
-
-        # #2727
-        index = Index([1.0, 2.5, 3.5, 4.5, 5.0])
-        df = DataFrame(np.random.randn(5, 5), index=index)
-
-        # positional slicing only via iloc!
-        msg = (
-            "cannot do slice indexing on"
-            r" <class 'pandas\.core\.indexes\.numeric\.Float64Index'> with"
-            r" these indexers \[1.0\] of <class 'float'>"
-        )
-        with pytest.raises(TypeError, match=msg):
-            df.iloc[1.0:5]
-
-        result = df.iloc[4:5]
-        expected = df.reindex([5.0])
-        assert_frame_equal(result, expected)
-        assert len(result) == 1
-
-        cp = df.copy()
-
-        with pytest.raises(TypeError):
-            cp.iloc[1.0:5] = 0
-
-        with pytest.raises(TypeError):
-            result = cp.iloc[1.0:5] == 0  # noqa
-
-        assert result.values.all()
-        assert (cp.iloc[0:1] == df.iloc[0:1]).values.all()
-
-        cp = df.copy()
-        cp.iloc[4:5] = 0
-        assert (cp.iloc[4:5] == 0).values.all()
-        assert (cp.iloc[0:4] == df.iloc[0:4]).values.all()
-
-        # float slicing
-        result = df.loc[1.0:5]
-        expected = df
-        assert_frame_equal(result, expected)
-        assert len(result) == 5
-
-        result = df.loc[1.1:5]
-        expected = df.reindex([2.5, 3.5, 4.5, 5.0])
-        assert_frame_equal(result, expected)
-        assert len(result) == 4
-
-        result = df.loc[4.51:5]
-        expected = df.reindex([5.0])
-        assert_frame_equal(result, expected)
-        assert len(result) == 1
-
-        result = df.loc[1.0:5.0]
-        expected = df.reindex([1.0, 2.5, 3.5, 4.5, 5.0])
-        assert_frame_equal(result, expected)
-        assert len(result) == 5
-
-        cp = df.copy()
-        cp.loc[1.0:5.0] = 0
-        result = cp.loc[1.0:5.0]
-        assert (result == 0).values.all()
-
-    def test_setitem_single_column_mixed(self):
-        df = DataFrame(
-            np.random.randn(5, 3),
-            index=["a", "b", "c", "d", "e"],
-            columns=["foo", "bar", "baz"],
-        )
-        df["str"] = "qux"
-        df.loc[df.index[::2], "str"] = np.nan
-        expected = np.array([np.nan, "qux", np.nan, "qux", np.nan], dtype=object)
-        assert_almost_equal(df["str"].values, expected)
-
-    def test_setitem_single_column_mixed_datetime(self):
-        df = DataFrame(
-            np.random.randn(5, 3),
-            index=["a", "b", "c", "d", "e"],
-            columns=["foo", "bar", "baz"],
-        )
-
-        df["timestamp"] = Timestamp("20010102")
-
-        # check our dtypes
-        result = df.dtypes
-        expected = Series(
-            [np.dtype("float64")] * 3 + [np.dtype("datetime64[ns]")],
-            index=["foo", "bar", "baz", "timestamp"],
-        )
-        assert_series_equal(result, expected)
-
-        # GH#16674 iNaT is treated as an integer when given by the user
-        df.loc["b", "timestamp"] = iNaT
-        assert not isna(df.loc["b", "timestamp"])
-        assert df["timestamp"].dtype == np.object_
-        assert df.loc["b", "timestamp"] == iNaT
-
-        # allow this syntax
-        df.loc["c", "timestamp"] = np.nan
-        assert isna(df.loc["c", "timestamp"])
-
-        # allow this syntax
-        df.loc["d", :] = np.nan
-        assert not isna(df.loc["c", :]).all()
-
-        # FIXME: don't leave commented-out
-        # as of GH 3216 this will now work!
-        # try to set with a list like item
-        # pytest.raises(
-        #    Exception, df.loc.__setitem__, ('d', 'timestamp'), [np.nan])
-
-    def test_setitem_mixed_datetime(self):
-        # GH 9336
-        expected = DataFrame(
-            {
-                "a": [0, 0, 0, 0, 13, 14],
-                "b": [
-                    pd.datetime(2012, 1, 1),
-                    1,
-                    "x",
-                    "y",
-                    pd.datetime(2013, 1, 1),
-                    pd.datetime(2014, 1, 1),
-                ],
-            }
-        )
-        df = pd.DataFrame(0, columns=list("ab"), index=range(6))
-        df["b"] = pd.NaT
-        df.loc[0, "b"] = pd.datetime(2012, 1, 1)
-        df.loc[1, "b"] = 1
-        df.loc[[2, 3], "b"] = "x", "y"
-        A = np.array(
-            [
-                [13, np.datetime64("2013-01-01T00:00:00")],
-                [14, np.datetime64("2014-01-01T00:00:00")],
-            ]
-        )
-        df.loc[[4, 5], ["a", "b"]] = A
-        assert_frame_equal(df, expected)
-
-    def test_setitem_frame_float(self, float_frame):
-        piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
-        float_frame.loc[float_frame.index[-2] :, ["A", "B"]] = piece.values
-        result = float_frame.loc[float_frame.index[-2:], ["A", "B"]].values
-        expected = piece.values
-        assert_almost_equal(result, expected)
-
-    def test_setitem_frame_mixed(self, float_string_frame):
-        # GH 3216
-
-        # already aligned
-        f = float_string_frame.copy()
-        piece = DataFrame(
-            [[1.0, 2.0], [3.0, 4.0]], index=f.index[0:2], columns=["A", "B"]
-        )
-        key = (slice(None, 2), ["A", "B"])
-        f.loc[key] = piece
-        assert_almost_equal(f.loc[f.index[0:2], ["A", "B"]].values, piece.values)
-
-        # rows unaligned
-        f = float_string_frame.copy()
-        piece = DataFrame(
-            [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]],
-            index=list(f.index[0:2]) + ["foo", "bar"],
-            columns=["A", "B"],
-        )
-        key = (slice(None, 2), ["A", "B"])
-        f.loc[key] = piece
-        assert_almost_equal(f.loc[f.index[0:2:], ["A", "B"]].values, piece.values[0:2])
-
-        # key is unaligned with values
-        f = float_string_frame.copy()
-        piece = f.loc[f.index[:2], ["A"]]
-        piece.index = f.index[-2:]
-        key = (slice(-2, None), ["A", "B"])
-        f.loc[key] = piece
-        piece["B"] = np.nan
-        assert_almost_equal(f.loc[f.index[-2:], ["A", "B"]].values, piece.values)
-
-        # ndarray
-        f = float_string_frame.copy()
-        piece = float_string_frame.loc[f.index[:2], ["A", "B"]]
-        key = (slice(-2, None), ["A", "B"])
-        f.loc[key] = piece.values
-        assert_almost_equal(f.loc[f.index[-2:], ["A", "B"]].values, piece.values)
-
-    def test_setitem_frame_upcast(self):
-        # needs upcasting
-        df = DataFrame([[1, 2, "foo"], [3, 4, "bar"]], columns=["A", "B", "C"])
-        df2 = df.copy()
-        df2.loc[:, ["A", "B"]] = df.loc[:, ["A", "B"]] + 0.5
-        expected = df.reindex(columns=["A", "B"])
-        expected += 0.5
-        expected["C"] = df["C"]
-        assert_frame_equal(df2, expected)
-
-    def test_setitem_frame_align(self, float_frame):
-        piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
-        piece.index = float_frame.index[-2:]
-        piece.columns = ["A", "B"]
-        float_frame.loc[float_frame.index[-2:], ["A", "B"]] = piece
-        result = float_frame.loc[float_frame.index[-2:], ["A", "B"]].values
-        expected = piece.values
-        assert_almost_equal(result, expected)
-
-    def test_getitem_setitem_ix_duplicates(self):
-        # #1201
-        df = DataFrame(np.random.randn(5, 3), index=["foo", "foo", "bar", "baz", "bar"])
-
-        result = df.loc["foo"]
-        expected = df[:2]
-        assert_frame_equal(result, expected)
-
-        result = df.loc["bar"]
-        expected = df.iloc[[2, 4]]
-        assert_frame_equal(result, expected)
-
-        result = df.loc["baz"]
-        expected = df.iloc[3]
-        assert_series_equal(result, expected)
-
-    def test_getitem_ix_boolean_duplicates_multiple(self):
-        # #1201
-        df = DataFrame(np.random.randn(5, 3), index=["foo", "foo", "bar", "baz", "bar"])
-
-        result = df.loc[["bar"]]
-        exp = df.iloc[[2, 4]]
-        assert_frame_equal(result, exp)
-
-        result = df.loc[df[1] > 0]
-        exp = df[df[1] > 0]
-        assert_frame_equal(result, exp)
-
-        result = df.loc[df[0] > 0]
-        exp = df[df[0] > 0]
-        assert_frame_equal(result, exp)
-
-    def test_getitem_setitem_ix_bool_keyerror(self):
-        # #2199
-        df = DataFrame({"a": [1, 2, 3]})
-
-        with pytest.raises(KeyError, match=r"^False$"):
-            df.loc[False]
-        with pytest.raises(KeyError, match=r"^True$"):
-            df.loc[True]
-
-        msg = "cannot use a single bool to index into setitem"
-        with pytest.raises(KeyError, match=msg):
-            df.loc[False] = 0
-        with pytest.raises(KeyError, match=msg):
-            df.loc[True] = 0
-
-    def test_getitem_list_duplicates(self):
-        # #1943
-        df = DataFrame(np.random.randn(4, 4), columns=list("AABC"))
-        df.columns.name = "foo"
-
-        result = df[["B", "C"]]
-        assert result.columns.name == "foo"
-
-        expected = df.iloc[:, 2:]
-        assert_frame_equal(result, expected)
-
-    def test_get_value(self, float_frame):
-        for idx in float_frame.index:
-            for col in float_frame.columns:
-                result = float_frame._get_value(idx, col)
-                expected = float_frame[col][idx]
-                assert result == expected
-
-    def test_lookup_float(self, float_frame):
-        df = float_frame
-        rows = list(df.index) * len(df.columns)
-        cols = list(df.columns) * len(df.index)
-        result = df.lookup(rows, cols)
-
-        expected = np.array([df.loc[r, c] for r, c in zip(rows, cols)])
-        tm.assert_numpy_array_equal(result, expected)
-
-    def test_lookup_mixed(self, float_string_frame):
-        df = float_string_frame
-        rows = list(df.index) * len(df.columns)
-        cols = list(df.columns) * len(df.index)
-        result = df.lookup(rows, cols)
-
-        expected = np.array(
-            [df.loc[r, c] for r, c in zip(rows, cols)], dtype=np.object_
-        )
-        tm.assert_almost_equal(result, expected)
-
-    def test_lookup_bool(self):
-        df = DataFrame(
-            {
-                "label": ["a", "b", "a", "c"],
-                "mask_a": [True, True, False, True],
-                "mask_b": [True, False, False, False],
-                "mask_c": [False, True, False, True],
-            }
-        )
-        df["mask"] = df.lookup(df.index, "mask_" + df["label"])
-
-        exp_mask = np.array(
-            [df.loc[r, c] for r, c in zip(df.index, "mask_" + df["label"])]
-        )
-
-        tm.assert_series_equal(df["mask"], pd.Series(exp_mask, name="mask"))
-        assert df["mask"].dtype == np.bool_
-
-    def test_lookup_raises(self, float_frame):
-        with pytest.raises(KeyError, match="'One or more row labels was not found'"):
-            float_frame.lookup(["xyz"], ["A"])
-
-        with pytest.raises(KeyError, match="'One or more column labels was not found'"):
-            float_frame.lookup([float_frame.index[0]], ["xyz"])
-
-        with pytest.raises(ValueError, match="same size"):
-            float_frame.lookup(["a", "b", "c"], ["a"])
-
-    def test_set_value(self, float_frame):
-        for idx in float_frame.index:
-            for col in float_frame.columns:
-                float_frame._set_value(idx, col, 1)
-                assert float_frame[col][idx] == 1
-
-    def test_set_value_resize(self, float_frame):
-
-        res = float_frame._set_value("foobar", "B", 0)
-        assert res is float_frame
-        assert res.index[-1] == "foobar"
-        assert res._get_value("foobar", "B") == 0
-
-        float_frame.loc["foobar", "qux"] = 0
-        assert float_frame._get_value("foobar", "qux") == 0
-
-        res = float_frame.copy()
-        res3 = res._set_value("foobar", "baz", "sam")
-        assert res3["baz"].dtype == np.object_
-
-        res = float_frame.copy()
-        res3 = res._set_value("foobar", "baz", True)
-        assert res3["baz"].dtype == np.object_
-
-        res = float_frame.copy()
-        res3 = res._set_value("foobar", "baz", 5)
-        assert is_float_dtype(res3["baz"])
-        assert isna(res3["baz"].drop(["foobar"])).all()
-        msg = "could not convert string to float: 'sam'"
-        with pytest.raises(ValueError, match=msg):
-            res3._set_value("foobar", "baz", "sam")
-
-    def test_set_value_with_index_dtype_change(self):
-        df_orig = DataFrame(np.random.randn(3, 3), index=range(3), columns=list("ABC"))
-
-        # this is actually ambiguous as the 2 is interpreted as a positional
-        # so column is not created
-        df = df_orig.copy()
-        df._set_value("C", 2, 1.0)
-        assert list(df.index) == list(df_orig.index) + ["C"]
-        # assert list(df.columns) == list(df_orig.columns) + [2]
-
-        df = df_orig.copy()
-        df.loc["C", 2] = 1.0
-        assert list(df.index) == list(df_orig.index) + ["C"]
-        # assert list(df.columns) == list(df_orig.columns) + [2]
-
-        # create both new
-        df = df_orig.copy()
-        df._set_value("C", "D", 1.0)
-        assert list(df.index) == list(df_orig.index) + ["C"]
-        assert list(df.columns) == list(df_orig.columns) + ["D"]
-
-        df = df_orig.copy()
-        df.loc["C", "D"] = 1.0
-        assert list(df.index) == list(df_orig.index) + ["C"]
-        assert list(df.columns) == list(df_orig.columns) + ["D"]
-
-    def test_get_set_value_no_partial_indexing(self):
-        # partial w/ MultiIndex raise exception
-        index = MultiIndex.from_tuples([(0, 1), (0, 2), (1, 1), (1, 2)])
-        df = DataFrame(index=index, columns=range(4))
-        with pytest.raises(KeyError, match=r"^0$"):
-            df._get_value(0, 1)
-
-    def test_single_element_ix_dont_upcast(self, float_frame):
-        float_frame["E"] = 1
-        assert issubclass(float_frame["E"].dtype.type, (int, np.integer))
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = float_frame.ix[float_frame.index[5], "E"]
-            assert is_integer(result)
-
-        result = float_frame.loc[float_frame.index[5], "E"]
-        assert is_integer(result)
-
-        # GH 11617
-        df = pd.DataFrame(dict(a=[1.23]))
-        df["b"] = 666
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[0, "b"]
-        assert is_integer(result)
-        result = df.loc[0, "b"]
-        assert is_integer(result)
-
-        expected = Series([666], [0], name="b")
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[[0], "b"]
-        assert_series_equal(result, expected)
-        result = df.loc[[0], "b"]
-        assert_series_equal(result, expected)
-
-    def test_iloc_row(self):
-        df = DataFrame(np.random.randn(10, 4), index=range(0, 20, 2))
-
-        result = df.iloc[1]
-        exp = df.loc[2]
-        assert_series_equal(result, exp)
-
-        result = df.iloc[2]
-        exp = df.loc[4]
-        assert_series_equal(result, exp)
-
-        # slice
-        result = df.iloc[slice(4, 8)]
-        expected = df.loc[8:14]
-        assert_frame_equal(result, expected)
-
-        # verify slice is view
-        # setting it makes it raise/warn
-        with pytest.raises(com.SettingWithCopyError):
-            result[2] = 0.0
-
-        exp_col = df[2].copy()
-        exp_col[4:8] = 0.0
-        assert_series_equal(df[2], exp_col)
-
-        # list of integers
-        result = df.iloc[[1, 2, 4, 6]]
-        expected = df.reindex(df.index[[1, 2, 4, 6]])
-        assert_frame_equal(result, expected)
-
-    def test_iloc_col(self):
-
-        df = DataFrame(np.random.randn(4, 10), columns=range(0, 20, 2))
-
-        result = df.iloc[:, 1]
-        exp = df.loc[:, 2]
-        assert_series_equal(result, exp)
-
-        result = df.iloc[:, 2]
-        exp = df.loc[:, 4]
-        assert_series_equal(result, exp)
-
-        # slice
-        result = df.iloc[:, slice(4, 8)]
-        expected = df.loc[:, 8:14]
-        assert_frame_equal(result, expected)
-
-        # verify slice is view
-        # and that we are setting a copy
-        with pytest.raises(com.SettingWithCopyError):
-            result[8] = 0.0
-
-        assert (df[8] == 0).all()
-
-        # list of integers
-        result = df.iloc[:, [1, 2, 4, 6]]
-        expected = df.reindex(columns=df.columns[[1, 2, 4, 6]])
-        assert_frame_equal(result, expected)
-
-    def test_iloc_duplicates(self):
-
-        df = DataFrame(np.random.rand(3, 3), columns=list("ABC"), index=list("aab"))
-
-        result = df.iloc[0]
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result2 = df.ix[0]
-        assert isinstance(result, Series)
-        assert_almost_equal(result.values, df.values[0])
-        assert_series_equal(result, result2)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.T.iloc[:, 0]
-            result2 = df.T.ix[:, 0]
-        assert isinstance(result, Series)
-        assert_almost_equal(result.values, df.values[0])
-        assert_series_equal(result, result2)
-
-        # multiindex
-        df = DataFrame(
-            np.random.randn(3, 3),
-            columns=[["i", "i", "j"], ["A", "A", "B"]],
-            index=[["i", "i", "j"], ["X", "X", "Y"]],
-        )
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            rs = df.iloc[0]
-            xp = df.ix[0]
-        assert_series_equal(rs, xp)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            rs = df.iloc[:, 0]
-            xp = df.T.ix[0]
-        assert_series_equal(rs, xp)
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            rs = df.iloc[:, [0]]
-            xp = df.ix[:, [0]]
-        assert_frame_equal(rs, xp)
-
-        # #2259
-        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[1, 1, 2])
-        result = df.iloc[:, [0]]
-        expected = df.take([0], axis=1)
-        assert_frame_equal(result, expected)
-
-    def test_loc_duplicates(self):
-        # gh-17105
-
-        # insert a duplicate element to the index
-        trange = pd.date_range(
-            start=pd.Timestamp(year=2017, month=1, day=1),
-            end=pd.Timestamp(year=2017, month=1, day=5),
-        )
-
-        trange = trange.insert(loc=5, item=pd.Timestamp(year=2017, month=1, day=5))
-
-        df = pd.DataFrame(0, index=trange, columns=["A", "B"])
-        bool_idx = np.array([False, False, False, False, False, True])
-
-        # assignment
-        df.loc[trange[bool_idx], "A"] = 6
-
-        expected = pd.DataFrame(
-            {"A": [0, 0, 0, 0, 6, 6], "B": [0, 0, 0, 0, 0, 0]}, index=trange
-        )
-        tm.assert_frame_equal(df, expected)
-
-        # in-place
-        df = pd.DataFrame(0, index=trange, columns=["A", "B"])
-        df.loc[trange[bool_idx], "A"] += 6
-        tm.assert_frame_equal(df, expected)
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_iloc_sparse_propegate_fill_value(self):
-        from pandas.core.sparse.api import SparseDataFrame
-
-        df = SparseDataFrame({"A": [999, 1]}, default_fill_value=999)
-        assert len(df["A"].sp_values) == len(df.iloc[:, 0].sp_values)
-
-    def test_iat(self, float_frame):
-
-        for i, row in enumerate(float_frame.index):
-            for j, col in enumerate(float_frame.columns):
-                result = float_frame.iat[i, j]
-                expected = float_frame.at[row, col]
-                assert result == expected
-
-    def test_nested_exception(self):
-        # Ignore the strange way of triggering the problem
-        # (which may get fixed), it's just a way to trigger
-        # the issue or reraising an outer exception without
-        # a named argument
-        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}).set_index(
-            ["a", "b"]
-        )
-        index = list(df.index)
-        index[0] = ["a", "b"]
-        df.index = index
-
-        try:
-            repr(df)
-        except Exception as e:
-            assert type(e) != UnboundLocalError
-
-    @pytest.mark.parametrize(
-        "method,expected_values",
-        [
-            ("nearest", [0, 1, 1, 2]),
-            ("pad", [np.nan, 0, 1, 1]),
-            ("backfill", [0, 1, 2, 2]),
-        ],
-    )
-    def test_reindex_methods(self, method, expected_values):
-        df = pd.DataFrame({"x": list(range(5))})
-        target = np.array([-0.1, 0.9, 1.1, 1.5])
-
-        expected = pd.DataFrame({"x": expected_values}, index=target)
-        actual = df.reindex(target, method=method)
-        assert_frame_equal(expected, actual)
-
-        actual = df.reindex_like(df, method=method, tolerance=0)
-        assert_frame_equal(df, actual)
-        actual = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
-        assert_frame_equal(df, actual)
-
-        actual = df.reindex(target, method=method, tolerance=1)
-        assert_frame_equal(expected, actual)
-        actual = df.reindex(target, method=method, tolerance=[1, 1, 1, 1])
-        assert_frame_equal(expected, actual)
-
-        e2 = expected[::-1]
-        actual = df.reindex(target[::-1], method=method)
-        assert_frame_equal(e2, actual)
-
-        new_order = [3, 0, 2, 1]
-        e2 = expected.iloc[new_order]
-        actual = df.reindex(target[new_order], method=method)
-        assert_frame_equal(e2, actual)
-
-        switched_method = (
-            "pad" if method == "backfill" else "backfill" if method == "pad" else method
-        )
-        actual = df[::-1].reindex(target, method=switched_method)
-        assert_frame_equal(expected, actual)
-
-    def test_reindex_methods_nearest_special(self):
-        df = pd.DataFrame({"x": list(range(5))})
-        target = np.array([-0.1, 0.9, 1.1, 1.5])
-
-        expected = pd.DataFrame({"x": [0, 1, 1, np.nan]}, index=target)
-        actual = df.reindex(target, method="nearest", tolerance=0.2)
-        assert_frame_equal(expected, actual)
-
-        expected = pd.DataFrame({"x": [0, np.nan, 1, np.nan]}, index=target)
-        actual = df.reindex(target, method="nearest", tolerance=[0.5, 0.01, 0.4, 0.1])
-        assert_frame_equal(expected, actual)
-
-    def test_reindex_frame_add_nat(self):
-        rng = date_range("1/1/2000 00:00:00", periods=10, freq="10s")
-        df = DataFrame({"A": np.random.randn(len(rng)), "B": rng})
-
-        result = df.reindex(range(15))
-        assert np.issubdtype(result["B"].dtype, np.dtype("M8[ns]"))
-
-        mask = com.isna(result)["B"]
-        assert mask[-5:].all()
-        assert not mask[:-5].any()
-
-    def test_set_dataframe_column_ns_dtype(self):
-        x = DataFrame([datetime.now(), datetime.now()])
-        assert x[0].dtype == np.dtype("M8[ns]")
-
-    def test_non_monotonic_reindex_methods(self):
-        dr = pd.date_range("2013-08-01", periods=6, freq="B")
-        data = np.random.randn(6, 1)
-        df = pd.DataFrame(data, index=dr, columns=list("A"))
-        df_rev = pd.DataFrame(data, index=dr[[3, 4, 5] + [0, 1, 2]], columns=list("A"))
-        # index is not monotonic increasing or decreasing
-        msg = "index must be monotonic increasing or decreasing"
-        with pytest.raises(ValueError, match=msg):
-            df_rev.reindex(df.index, method="pad")
-        with pytest.raises(ValueError, match=msg):
-            df_rev.reindex(df.index, method="ffill")
-        with pytest.raises(ValueError, match=msg):
-            df_rev.reindex(df.index, method="bfill")
-        with pytest.raises(ValueError, match=msg):
-            df_rev.reindex(df.index, method="nearest")
-
-    def test_reindex_level(self):
-        from itertools import permutations
-
-        icol = ["jim", "joe", "jolie"]
-
-        def verify_first_level(df, level, idx, check_index_type=True):
-            def f(val):
-                return np.nonzero((df[level] == val).to_numpy())[0]
-
-            i = np.concatenate(list(map(f, idx)))
-            left = df.set_index(icol).reindex(idx, level=level)
-            right = df.iloc[i].set_index(icol)
-            assert_frame_equal(left, right, check_index_type=check_index_type)
-
-        def verify(df, level, idx, indexer, check_index_type=True):
-            left = df.set_index(icol).reindex(idx, level=level)
-            right = df.iloc[indexer].set_index(icol)
-            assert_frame_equal(left, right, check_index_type=check_index_type)
-
-        df = pd.DataFrame(
-            {
-                "jim": list("B" * 4 + "A" * 2 + "C" * 3),
-                "joe": list("abcdeabcd")[::-1],
-                "jolie": [10, 20, 30] * 3,
-                "joline": np.random.randint(0, 1000, 9),
-            }
-        )
-
-        target = [
-            ["C", "B", "A"],
-            ["F", "C", "A", "D"],
-            ["A"],
-            ["A", "B", "C"],
-            ["C", "A", "B"],
-            ["C", "B"],
-            ["C", "A"],
-            ["A", "B"],
-            ["B", "A", "C"],
-        ]
-
-        for idx in target:
-            verify_first_level(df, "jim", idx)
-
-        # reindex by these causes different MultiIndex levels
-        for idx in [["D", "F"], ["A", "C", "B"]]:
-            verify_first_level(df, "jim", idx, check_index_type=False)
-
-        verify(df, "joe", list("abcde"), [3, 2, 1, 0, 5, 4, 8, 7, 6])
-        verify(df, "joe", list("abcd"), [3, 2, 1, 0, 5, 8, 7, 6])
-        verify(df, "joe", list("abc"), [3, 2, 1, 8, 7, 6])
-        verify(df, "joe", list("eca"), [1, 3, 4, 6, 8])
-        verify(df, "joe", list("edc"), [0, 1, 4, 5, 6])
-        verify(df, "joe", list("eadbc"), [3, 0, 2, 1, 4, 5, 8, 7, 6])
-        verify(df, "joe", list("edwq"), [0, 4, 5])
-        verify(df, "joe", list("wq"), [], check_index_type=False)
-
-        df = DataFrame(
-            {
-                "jim": ["mid"] * 5 + ["btm"] * 8 + ["top"] * 7,
-                "joe": ["3rd"] * 2
-                + ["1st"] * 3
-                + ["2nd"] * 3
-                + ["1st"] * 2
-                + ["3rd"] * 3
-                + ["1st"] * 2
-                + ["3rd"] * 3
-                + ["2nd"] * 2,
-                # this needs to be jointly unique with jim and joe or
-                # reindexing will fail ~1.5% of the time, this works
-                # out to needing unique groups of same size as joe
-                "jolie": np.concatenate(
-                    [
-                        np.random.choice(1000, x, replace=False)
-                        for x in [2, 3, 3, 2, 3, 2, 3, 2]
-                    ]
-                ),
-                "joline": np.random.randn(20).round(3) * 10,
-            }
-        )
-
-        for idx in permutations(df["jim"].unique()):
-            for i in range(3):
-                verify_first_level(df, "jim", idx[: i + 1])
-
-        i = [2, 3, 4, 0, 1, 8, 9, 5, 6, 7, 10, 11, 12, 13, 14, 18, 19, 15, 16, 17]
-        verify(df, "joe", ["1st", "2nd", "3rd"], i)
-
-        i = [0, 1, 2, 3, 4, 10, 11, 12, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 13, 14]
-        verify(df, "joe", ["3rd", "2nd", "1st"], i)
-
-        i = [0, 1, 5, 6, 7, 10, 11, 12, 18, 19, 15, 16, 17]
-        verify(df, "joe", ["2nd", "3rd"], i)
-
-        i = [0, 1, 2, 3, 4, 10, 11, 12, 8, 9, 15, 16, 17, 13, 14]
-        verify(df, "joe", ["3rd", "1st"], i)
-
-    def test_getitem_ix_float_duplicates(self):
-        df = pd.DataFrame(
-            np.random.randn(3, 3), index=[0.1, 0.2, 0.2], columns=list("abc")
-        )
-        expect = df.iloc[1:]
-        assert_frame_equal(df.loc[0.2], expect)
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(df.ix[0.2], expect)
-
-        expect = df.iloc[1:, 0]
-        assert_series_equal(df.loc[0.2, "a"], expect)
-
-        df.index = [1, 0.2, 0.2]
-        expect = df.iloc[1:]
-        assert_frame_equal(df.loc[0.2], expect)
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(df.ix[0.2], expect)
-
-        expect = df.iloc[1:, 0]
-        assert_series_equal(df.loc[0.2, "a"], expect)
-
-        df = pd.DataFrame(
-            np.random.randn(4, 3), index=[1, 0.2, 0.2, 1], columns=list("abc")
-        )
-        expect = df.iloc[1:-1]
-        assert_frame_equal(df.loc[0.2], expect)
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(df.ix[0.2], expect)
-
-        expect = df.iloc[1:-1, 0]
-        assert_series_equal(df.loc[0.2, "a"], expect)
-
-        df.index = [0.1, 0.2, 2, 0.2]
-        expect = df.iloc[[1, -1]]
-        assert_frame_equal(df.loc[0.2], expect)
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            assert_frame_equal(df.ix[0.2], expect)
-
-        expect = df.iloc[[1, -1], 0]
-        assert_series_equal(df.loc[0.2, "a"], expect)
-
-    def test_getitem_sparse_column(self):
-        # https://github.com/pandas-dev/pandas/issues/23559
-        data = pd.SparseArray([0, 1])
-        df = pd.DataFrame({"A": data})
-        expected = pd.Series(data, name="A")
-        result = df["A"]
-        tm.assert_series_equal(result, expected)
-
-        result = df.iloc[:, 0]
-        tm.assert_series_equal(result, expected)
-
-        result = df.loc[:, "A"]
-        tm.assert_series_equal(result, expected)
-
-    def test_setitem_with_sparse_value(self):
-        # GH8131
-        df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
-        sp_array = pd.SparseArray([0, 0, 1])
-        df["new_column"] = sp_array
-        assert_series_equal(
-            df["new_column"], pd.Series(sp_array, name="new_column"), check_names=False
-        )
-
-    def test_setitem_with_unaligned_sparse_value(self):
-        df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
-        sp_series = pd.Series(pd.SparseArray([0, 0, 1]), index=[2, 1, 0])
-        df["new_column"] = sp_series
-        exp = pd.Series(pd.SparseArray([1, 0, 0]), name="new_column")
-        assert_series_equal(df["new_column"], exp)
-
-    def test_setitem_with_unaligned_tz_aware_datetime_column(self):
-        # GH 12981
-        # Assignment of unaligned offset-aware datetime series.
-        # Make sure timezone isn't lost
-        column = pd.Series(
-            pd.date_range("2015-01-01", periods=3, tz="utc"), name="dates"
-        )
-        df = pd.DataFrame({"dates": column})
-        df["dates"] = column[[1, 0, 2]]
-        assert_series_equal(df["dates"], column)
-
-        df = pd.DataFrame({"dates": column})
-        df.loc[[0, 1, 2], "dates"] = column[[1, 0, 2]]
-        assert_series_equal(df["dates"], column)
-
-    def test_setitem_datetime_coercion(self):
-        # gh-1048
-        df = pd.DataFrame({"c": [pd.Timestamp("2010-10-01")] * 3})
-        df.loc[0:1, "c"] = np.datetime64("2008-08-08")
-        assert pd.Timestamp("2008-08-08") == df.loc[0, "c"]
-        assert pd.Timestamp("2008-08-08") == df.loc[1, "c"]
-        df.loc[2, "c"] = date(2005, 5, 5)
-        assert pd.Timestamp("2005-05-05") == df.loc[2, "c"]
-
-    def test_setitem_datetimelike_with_inference(self):
-        # GH 7592
-        # assignment of timedeltas with NaT
-
-        one_hour = timedelta(hours=1)
-        df = DataFrame(index=date_range("20130101", periods=4))
-        df["A"] = np.array([1 * one_hour] * 4, dtype="m8[ns]")
-        df.loc[:, "B"] = np.array([2 * one_hour] * 4, dtype="m8[ns]")
-        df.loc[:3, "C"] = np.array([3 * one_hour] * 3, dtype="m8[ns]")
-        df.loc[:, "D"] = np.array([4 * one_hour] * 4, dtype="m8[ns]")
-        df.loc[df.index[:3], "E"] = np.array([5 * one_hour] * 3, dtype="m8[ns]")
-        df["F"] = np.timedelta64("NaT")
-        df.loc[df.index[:-1], "F"] = np.array([6 * one_hour] * 3, dtype="m8[ns]")
-        df.loc[df.index[-3] :, "G"] = date_range("20130101", periods=3)
-        df["H"] = np.datetime64("NaT")
-        result = df.dtypes
-        expected = Series(
-            [np.dtype("timedelta64[ns]")] * 6 + [np.dtype("datetime64[ns]")] * 2,
-            index=list("ABCDEFGH"),
-        )
-        assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("idxer", ["var", ["var"]])
-    def test_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
-        # GH 11365
-        tz = tz_naive_fixture
-        idx = date_range(start="2015-07-12", periods=3, freq="H", tz=tz)
-        expected = DataFrame(1.2, index=idx, columns=["var"])
-        result = DataFrame(index=idx, columns=["var"])
-        result.loc[:, idxer] = expected
-        tm.assert_frame_equal(result, expected)
-
-    def test_at_time_between_time_datetimeindex(self):
-        index = date_range("2012-01-01", "2012-01-05", freq="30min")
-        df = DataFrame(np.random.randn(len(index), 5), index=index)
-        akey = time(12, 0, 0)
-        bkey = slice(time(13, 0, 0), time(14, 0, 0))
-        ainds = [24, 72, 120, 168]
-        binds = [26, 27, 28, 74, 75, 76, 122, 123, 124, 170, 171, 172]
-
-        result = df.at_time(akey)
-        expected = df.loc[akey]
-        expected2 = df.iloc[ainds]
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result, expected2)
-        assert len(result) == 4
-
-        result = df.between_time(bkey.start, bkey.stop)
-        expected = df.loc[bkey]
-        expected2 = df.iloc[binds]
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result, expected2)
-        assert len(result) == 12
-
-        result = df.copy()
-        result.loc[akey] = 0
-        result = result.loc[akey]
-        expected = df.loc[akey].copy()
-        expected.loc[:] = 0
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.loc[akey] = 0
-        result.loc[akey] = df.iloc[ainds]
-        assert_frame_equal(result, df)
-
-        result = df.copy()
-        result.loc[bkey] = 0
-        result = result.loc[bkey]
-        expected = df.loc[bkey].copy()
-        expected.loc[:] = 0
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.loc[bkey] = 0
-        result.loc[bkey] = df.iloc[binds]
-        assert_frame_equal(result, df)
-
-    def test_xs(self, float_frame, datetime_frame):
-        idx = float_frame.index[5]
-        xs = float_frame.xs(idx)
-        for item, value in xs.items():
-            if np.isnan(value):
-                assert np.isnan(float_frame[item][idx])
-            else:
-                assert value == float_frame[item][idx]
-
-        # mixed-type xs
-        test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
-        frame = DataFrame(test_data)
-        xs = frame.xs("1")
-        assert xs.dtype == np.object_
-        assert xs["A"] == 1
-        assert xs["B"] == "1"
-
-        with pytest.raises(
-            KeyError, match=re.escape("Timestamp('1999-12-31 00:00:00', freq='B')")
-        ):
-            datetime_frame.xs(datetime_frame.index[0] - BDay())
-
-        # xs get column
-        series = float_frame.xs("A", axis=1)
-        expected = float_frame["A"]
-        assert_series_equal(series, expected)
-
-        # view is returned if possible
-        series = float_frame.xs("A", axis=1)
-        series[:] = 5
-        assert (expected == 5).all()
-
-    def test_xs_corner(self):
-        # pathological mixed-type reordering case
-        df = DataFrame(index=[0])
-        df["A"] = 1.0
-        df["B"] = "foo"
-        df["C"] = 2.0
-        df["D"] = "bar"
-        df["E"] = 3.0
-
-        xs = df.xs(0)
-        exp = pd.Series([1.0, "foo", 2.0, "bar", 3.0], index=list("ABCDE"), name=0)
-        tm.assert_series_equal(xs, exp)
-
-        # no columns but Index(dtype=object)
-        df = DataFrame(index=["a", "b", "c"])
-        result = df.xs("a")
-        expected = Series([], name="a", index=pd.Index([], dtype=object))
-        assert_series_equal(result, expected)
-
-    def test_xs_duplicates(self):
-        df = DataFrame(np.random.randn(5, 2), index=["b", "b", "c", "b", "a"])
-
-        cross = df.xs("c")
-        exp = df.iloc[2]
-        assert_series_equal(cross, exp)
-
-    def test_xs_keep_level(self):
-        df = DataFrame(
-            {
-                "day": {0: "sat", 1: "sun"},
-                "flavour": {0: "strawberry", 1: "strawberry"},
-                "sales": {0: 10, 1: 12},
-                "year": {0: 2008, 1: 2008},
-            }
-        ).set_index(["year", "flavour", "day"])
-        result = df.xs("sat", level="day", drop_level=False)
-        expected = df[:1]
-        assert_frame_equal(result, expected)
-
-        result = df.xs([2008, "sat"], level=["year", "day"], drop_level=False)
-        assert_frame_equal(result, expected)
-
-    def test_xs_view(self):
-        # in 0.14 this will return a view if possible a copy otherwise, but
-        # this is numpy dependent
-
-        dm = DataFrame(np.arange(20.0).reshape(4, 5), index=range(4), columns=range(5))
-
-        dm.xs(2)[:] = 10
-        assert (dm.xs(2) == 10).all()
-
-    def test_index_namedtuple(self):
-        from collections import namedtuple
-
-        IndexType = namedtuple("IndexType", ["a", "b"])
-        idx1 = IndexType("foo", "bar")
-        idx2 = IndexType("baz", "bof")
-        index = Index([idx1, idx2], name="composite_index", tupleize_cols=False)
-        df = DataFrame([(1, 2), (3, 4)], index=index, columns=["A", "B"])
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            result = df.ix[IndexType("foo", "bar")]["A"]
-        assert result == 1
-
-        result = df.loc[IndexType("foo", "bar")]["A"]
-        assert result == 1
-
-    def test_boolean_indexing(self):
-        idx = list(range(3))
-        cols = ["A", "B", "C"]
-        df1 = DataFrame(
-            index=idx,
-            columns=cols,
-            data=np.array(
-                [[0.0, 0.5, 1.0], [1.5, 2.0, 2.5], [3.0, 3.5, 4.0]], dtype=float
-            ),
-        )
-        df2 = DataFrame(index=idx, columns=cols, data=np.ones((len(idx), len(cols))))
-
-        expected = DataFrame(
-            index=idx,
-            columns=cols,
-            data=np.array([[0.0, 0.5, 1.0], [1.5, 2.0, -1], [-1, -1, -1]], dtype=float),
-        )
-
-        df1[df1 > 2.0 * df2] = -1
-        assert_frame_equal(df1, expected)
-        with pytest.raises(ValueError, match="Item wrong length"):
-            df1[df1.index[:-1] > 2] = -1
-
-    def test_boolean_indexing_mixed(self):
-        df = DataFrame(
-            {
-                0: {35: np.nan, 40: np.nan, 43: np.nan, 49: np.nan, 50: np.nan},
-                1: {
-                    35: np.nan,
-                    40: 0.32632316859446198,
-                    43: np.nan,
-                    49: 0.32632316859446198,
-                    50: 0.39114724480578139,
-                },
-                2: {
-                    35: np.nan,
-                    40: np.nan,
-                    43: 0.29012581014105987,
-                    49: np.nan,
-                    50: np.nan,
-                },
-                3: {35: np.nan, 40: np.nan, 43: np.nan, 49: np.nan, 50: np.nan},
-                4: {
-                    35: 0.34215328467153283,
-                    40: np.nan,
-                    43: np.nan,
-                    49: np.nan,
-                    50: np.nan,
-                },
-                "y": {35: 0, 40: 0, 43: 0, 49: 0, 50: 1},
-            }
-        )
-
-        # mixed int/float ok
-        df2 = df.copy()
-        df2[df2 > 0.3] = 1
-        expected = df.copy()
-        expected.loc[40, 1] = 1
-        expected.loc[49, 1] = 1
-        expected.loc[50, 1] = 1
-        expected.loc[35, 4] = 1
-        assert_frame_equal(df2, expected)
-
-        df["foo"] = "test"
-        msg = "not supported between instances|unorderable types"
-
-        with pytest.raises(TypeError, match=msg):
-            df[df > 0.3] = 1
-
-    def test_where(self, float_string_frame, mixed_float_frame, mixed_int_frame):
-        default_frame = DataFrame(np.random.randn(5, 3), columns=["A", "B", "C"])
-
-        def _safe_add(df):
-            # only add to the numeric items
-            def is_ok(s):
-                return (
-                    issubclass(s.dtype.type, (np.integer, np.floating))
-                    and s.dtype != "uint8"
-                )
-
-            return DataFrame(
-                dict((c, s + 1) if is_ok(s) else (c, s) for c, s in df.items())
-            )
-
-        def _check_get(df, cond, check_dtypes=True):
-            other1 = _safe_add(df)
-            rs = df.where(cond, other1)
-            rs2 = df.where(cond.values, other1)
-            for k, v in rs.items():
-                exp = Series(np.where(cond[k], df[k], other1[k]), index=v.index)
-                assert_series_equal(v, exp, check_names=False)
-            assert_frame_equal(rs, rs2)
-
-            # dtypes
-            if check_dtypes:
-                assert (rs.dtypes == df.dtypes).all()
-
-        # check getting
-        for df in [
-            default_frame,
-            float_string_frame,
-            mixed_float_frame,
-            mixed_int_frame,
-        ]:
-            if df is float_string_frame:
-                with pytest.raises(TypeError):
-                    df > 0
-                continue
-            cond = df > 0
-            _check_get(df, cond)
-
-        # upcasting case (GH # 2794)
-        df = DataFrame(
-            {
-                c: Series([1] * 3, dtype=c)
-                for c in ["float32", "float64", "int32", "int64"]
-            }
-        )
-        df.iloc[1, :] = 0
-        result = df.dtypes
-        expected = Series(
-            [
-                np.dtype("float32"),
-                np.dtype("float64"),
-                np.dtype("int32"),
-                np.dtype("int64"),
-            ],
-            index=["float32", "float64", "int32", "int64"],
-        )
-
-        # when we don't preserve boolean casts
-        #
-        # expected = Series({ 'float32' : 1, 'float64' : 3 })
-
-        assert_series_equal(result, expected)
-
-        # aligning
-        def _check_align(df, cond, other, check_dtypes=True):
-            rs = df.where(cond, other)
-            for i, k in enumerate(rs.columns):
-                result = rs[k]
-                d = df[k].values
-                c = cond[k].reindex(df[k].index).fillna(False).values
-
-                if is_scalar(other):
-                    o = other
-                else:
-                    if isinstance(other, np.ndarray):
-                        o = Series(other[:, i], index=result.index).values
-                    else:
-                        o = other[k].values
-
-                new_values = d if c.all() else np.where(c, d, o)
-                expected = Series(new_values, index=result.index, name=k)
-
-                # since we can't always have the correct numpy dtype
-                # as numpy doesn't know how to downcast, don't check
-                assert_series_equal(result, expected, check_dtype=False)
-
-            # dtypes
-            # can't check dtype when other is an ndarray
-
-            if check_dtypes and not isinstance(other, np.ndarray):
-                assert (rs.dtypes == df.dtypes).all()
-
-        for df in [float_string_frame, mixed_float_frame, mixed_int_frame]:
-            if df is float_string_frame:
-                with pytest.raises(TypeError):
-                    df > 0
-                continue
-
-            # other is a frame
-            cond = (df > 0)[1:]
-            _check_align(df, cond, _safe_add(df))
-
-            # check other is ndarray
-            cond = df > 0
-            _check_align(df, cond, (_safe_add(df).values))
-
-            # integers are upcast, so don't check the dtypes
-            cond = df > 0
-            check_dtypes = all(not issubclass(s.type, np.integer) for s in df.dtypes)
-            _check_align(df, cond, np.nan, check_dtypes=check_dtypes)
-
-        # invalid conditions
-        df = default_frame
-        err1 = (df + 1).values[0:2, :]
-        msg = "other must be the same shape as self when an ndarray"
-        with pytest.raises(ValueError, match=msg):
-            df.where(cond, err1)
-
-        err2 = cond.iloc[:2, :].values
-        other1 = _safe_add(df)
-        msg = "Array conditional must be same shape as self"
-        with pytest.raises(ValueError, match=msg):
-            df.where(err2, other1)
-
-        with pytest.raises(ValueError, match=msg):
-            df.mask(True)
-        with pytest.raises(ValueError, match=msg):
-            df.mask(0)
-
-        # where inplace
-        def _check_set(df, cond, check_dtypes=True):
-            dfi = df.copy()
-            econd = cond.reindex_like(df).fillna(True)
-            expected = dfi.mask(~econd)
-
-            dfi.where(cond, np.nan, inplace=True)
-            assert_frame_equal(dfi, expected)
-
-            # dtypes (and confirm upcasts)x
-            if check_dtypes:
-                for k, v in df.dtypes.items():
-                    if issubclass(v.type, np.integer) and not cond[k].all():
-                        v = np.dtype("float64")
-                    assert dfi[k].dtype == v
-
-        for df in [
-            default_frame,
-            float_string_frame,
-            mixed_float_frame,
-            mixed_int_frame,
-        ]:
-            if df is float_string_frame:
-                with pytest.raises(TypeError):
-                    df > 0
-                continue
-
-            cond = df > 0
-            _check_set(df, cond)
-
-            cond = df >= 0
-            _check_set(df, cond)
-
-            # aligning
-            cond = (df >= 0)[1:]
-            _check_set(df, cond)
-
-        # GH 10218
-        # test DataFrame.where with Series slicing
-        df = DataFrame({"a": range(3), "b": range(4, 7)})
-        result = df.where(df["a"] == 1)
-        expected = df[df["a"] == 1].reindex(df.index)
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize("klass", [list, tuple, np.array])
-    def test_where_array_like(self, klass):
-        # see gh-15414
-        df = DataFrame({"a": [1, 2, 3]})
-        cond = [[False], [True], [True]]
-        expected = DataFrame({"a": [np.nan, 2, 3]})
-
-        result = df.where(klass(cond))
-        assert_frame_equal(result, expected)
-
-        df["b"] = 2
-        expected["b"] = [2, np.nan, 2]
-        cond = [[False, True], [True, False], [True, True]]
-
-        result = df.where(klass(cond))
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "cond",
-        [
-            [[1], [0], [1]],
-            Series([[2], [5], [7]]),
-            DataFrame({"a": [2, 5, 7]}),
-            [["True"], ["False"], ["True"]],
-            [[Timestamp("2017-01-01")], [pd.NaT], [Timestamp("2017-01-02")]],
-        ],
-    )
-    def test_where_invalid_input_single(self, cond):
-        # see gh-15414: only boolean arrays accepted
-        df = DataFrame({"a": [1, 2, 3]})
-        msg = "Boolean array expected for the condition"
-
-        with pytest.raises(ValueError, match=msg):
-            df.where(cond)
-
-    @pytest.mark.parametrize(
-        "cond",
-        [
-            [[0, 1], [1, 0], [1, 1]],
-            Series([[0, 2], [5, 0], [4, 7]]),
-            [["False", "True"], ["True", "False"], ["True", "True"]],
-            DataFrame({"a": [2, 5, 7], "b": [4, 8, 9]}),
-            [
-                [pd.NaT, Timestamp("2017-01-01")],
-                [Timestamp("2017-01-02"), pd.NaT],
-                [Timestamp("2017-01-03"), Timestamp("2017-01-03")],
-            ],
-        ],
-    )
-    def test_where_invalid_input_multiple(self, cond):
-        # see gh-15414: only boolean arrays accepted
-        df = DataFrame({"a": [1, 2, 3], "b": [2, 2, 2]})
-        msg = "Boolean array expected for the condition"
-
-        with pytest.raises(ValueError, match=msg):
-            df.where(cond)
-
-    def test_where_dataframe_col_match(self):
-        df = DataFrame([[1, 2, 3], [4, 5, 6]])
-        cond = DataFrame([[True, False, True], [False, False, True]])
-
-        result = df.where(cond)
-        expected = DataFrame([[1.0, np.nan, 3], [np.nan, np.nan, 6]])
-        tm.assert_frame_equal(result, expected)
-
-        # this *does* align, though has no matching columns
-        cond.columns = ["a", "b", "c"]
-        result = df.where(cond)
-        expected = DataFrame(np.nan, index=df.index, columns=df.columns)
-        tm.assert_frame_equal(result, expected)
-
-    def test_where_ndframe_align(self):
-        msg = "Array conditional must be same shape as self"
-        df = DataFrame([[1, 2, 3], [4, 5, 6]])
-
-        cond = [True]
-        with pytest.raises(ValueError, match=msg):
-            df.where(cond)
-
-        expected = DataFrame([[1, 2, 3], [np.nan, np.nan, np.nan]])
-
-        out = df.where(Series(cond))
-        tm.assert_frame_equal(out, expected)
-
-        cond = np.array([False, True, False, True])
-        with pytest.raises(ValueError, match=msg):
-            df.where(cond)
-
-        expected = DataFrame([[np.nan, np.nan, np.nan], [4, 5, 6]])
-
-        out = df.where(Series(cond))
-        tm.assert_frame_equal(out, expected)
-
-    def test_where_bug(self):
-        # see gh-2793
-        df = DataFrame(
-            {"a": [1.0, 2.0, 3.0, 4.0], "b": [4.0, 3.0, 2.0, 1.0]}, dtype="float64"
-        )
-        expected = DataFrame(
-            {"a": [np.nan, np.nan, 3.0, 4.0], "b": [4.0, 3.0, np.nan, np.nan]},
-            dtype="float64",
-        )
-        result = df.where(df > 2, np.nan)
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(result > 2, np.nan, inplace=True)
-        assert_frame_equal(result, expected)
-
-    def test_where_bug_mixed(self, sint_dtype):
-        # see gh-2793
-        df = DataFrame(
-            {
-                "a": np.array([1, 2, 3, 4], dtype=sint_dtype),
-                "b": np.array([4.0, 3.0, 2.0, 1.0], dtype="float64"),
-            }
-        )
-
-        expected = DataFrame(
-            {"a": [np.nan, np.nan, 3.0, 4.0], "b": [4.0, 3.0, np.nan, np.nan]},
-            dtype="float64",
-        )
-
-        result = df.where(df > 2, np.nan)
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(result > 2, np.nan, inplace=True)
-        assert_frame_equal(result, expected)
-
-    def test_where_bug_transposition(self):
-        # see gh-7506
-        a = DataFrame({0: [1, 2], 1: [3, 4], 2: [5, 6]})
-        b = DataFrame({0: [np.nan, 8], 1: [9, np.nan], 2: [np.nan, np.nan]})
-        do_not_replace = b.isna() | (a > b)
-
-        expected = a.copy()
-        expected[~do_not_replace] = b
-
-        result = a.where(do_not_replace, b)
-        assert_frame_equal(result, expected)
-
-        a = DataFrame({0: [4, 6], 1: [1, 0]})
-        b = DataFrame({0: [np.nan, 3], 1: [3, np.nan]})
-        do_not_replace = b.isna() | (a > b)
-
-        expected = a.copy()
-        expected[~do_not_replace] = b
-
-        result = a.where(do_not_replace, b)
-        assert_frame_equal(result, expected)
-
-    def test_where_datetime(self):
-
-        # GH 3311
-        df = DataFrame(
-            dict(
-                A=date_range("20130102", periods=5),
-                B=date_range("20130104", periods=5),
-                C=np.random.randn(5),
-            )
-        )
-
-        stamp = datetime(2013, 1, 3)
-        with pytest.raises(TypeError):
-            df > stamp
-
-        result = df[df.iloc[:, :-1] > stamp]
-
-        expected = df.copy()
-        expected.loc[[0, 1], "A"] = np.nan
-        expected.loc[:, "C"] = np.nan
-        assert_frame_equal(result, expected)
-
-    def test_where_none(self):
-        # GH 4667
-        # setting with None changes dtype
-        df = DataFrame({"series": Series(range(10))}).astype(float)
-        df[df > 7] = None
-        expected = DataFrame(
-            {"series": Series([0, 1, 2, 3, 4, 5, 6, 7, np.nan, np.nan])}
-        )
-        assert_frame_equal(df, expected)
-
-        # GH 7656
-        df = DataFrame(
-            [
-                {"A": 1, "B": np.nan, "C": "Test"},
-                {"A": np.nan, "B": "Test", "C": np.nan},
-            ]
-        )
-        msg = "boolean setting on mixed-type"
-
-        with pytest.raises(TypeError, match=msg):
-            df.where(~isna(df), None, inplace=True)
-
-    def test_where_empty_df_and_empty_cond_having_non_bool_dtypes(self):
-        # see gh-21947
-        df = pd.DataFrame(columns=["a"])
-        cond = df.applymap(lambda x: x > 0)
-
-        result = df.where(cond)
-        tm.assert_frame_equal(result, df)
-
-    def test_where_align(self):
-        def create():
-            df = DataFrame(np.random.randn(10, 3))
-            df.iloc[3:5, 0] = np.nan
-            df.iloc[4:6, 1] = np.nan
-            df.iloc[5:8, 2] = np.nan
-            return df
-
-        # series
-        df = create()
-        expected = df.fillna(df.mean())
-        result = df.where(pd.notna(df), df.mean(), axis="columns")
-        assert_frame_equal(result, expected)
-
-        df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
-        assert_frame_equal(df, expected)
-
-        df = create().fillna(0)
-        expected = df.apply(lambda x, y: x.where(x > 0, y), y=df[0])
-        result = df.where(df > 0, df[0], axis="index")
-        assert_frame_equal(result, expected)
-        result = df.where(df > 0, df[0], axis="rows")
-        assert_frame_equal(result, expected)
-
-        # frame
-        df = create()
-        expected = df.fillna(1)
-        result = df.where(
-            pd.notna(df), DataFrame(1, index=df.index, columns=df.columns)
-        )
-        assert_frame_equal(result, expected)
-
-    def test_where_complex(self):
-        # GH 6345
-        expected = DataFrame([[1 + 1j, 2], [np.nan, 4 + 1j]], columns=["a", "b"])
-        df = DataFrame([[1 + 1j, 2], [5 + 1j, 4 + 1j]], columns=["a", "b"])
-        df[df.abs() >= 5] = np.nan
-        assert_frame_equal(df, expected)
-
-    def test_where_axis(self):
-        # GH 9736
-        df = DataFrame(np.random.randn(2, 2))
-        mask = DataFrame([[False, False], [False, False]])
-        s = Series([0, 1])
-
-        expected = DataFrame([[0, 0], [1, 1]], dtype="float64")
-        result = df.where(mask, s, axis="index")
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(mask, s, axis="index", inplace=True)
-        assert_frame_equal(result, expected)
-
-        expected = DataFrame([[0, 1], [0, 1]], dtype="float64")
-        result = df.where(mask, s, axis="columns")
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(mask, s, axis="columns", inplace=True)
-        assert_frame_equal(result, expected)
-
-        # Upcast needed
-        df = DataFrame([[1, 2], [3, 4]], dtype="int64")
-        mask = DataFrame([[False, False], [False, False]])
-        s = Series([0, np.nan])
-
-        expected = DataFrame([[0, 0], [np.nan, np.nan]], dtype="float64")
-        result = df.where(mask, s, axis="index")
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(mask, s, axis="index", inplace=True)
-        assert_frame_equal(result, expected)
-
-        expected = DataFrame([[0, np.nan], [0, np.nan]])
-        result = df.where(mask, s, axis="columns")
-        assert_frame_equal(result, expected)
-
-        expected = DataFrame(
-            {
-                0: np.array([0, 0], dtype="int64"),
-                1: np.array([np.nan, np.nan], dtype="float64"),
-            }
-        )
-        result = df.copy()
-        result.where(mask, s, axis="columns", inplace=True)
-        assert_frame_equal(result, expected)
-
-        # Multiple dtypes (=> multiple Blocks)
-        df = pd.concat(
-            [
-                DataFrame(np.random.randn(10, 2)),
-                DataFrame(np.random.randint(0, 10, size=(10, 2)), dtype="int64"),
-            ],
-            ignore_index=True,
-            axis=1,
-        )
-        mask = DataFrame(False, columns=df.columns, index=df.index)
-        s1 = Series(1, index=df.columns)
-        s2 = Series(2, index=df.index)
-
-        result = df.where(mask, s1, axis="columns")
-        expected = DataFrame(1.0, columns=df.columns, index=df.index)
-        expected[2] = expected[2].astype("int64")
-        expected[3] = expected[3].astype("int64")
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(mask, s1, axis="columns", inplace=True)
-        assert_frame_equal(result, expected)
-
-        result = df.where(mask, s2, axis="index")
-        expected = DataFrame(2.0, columns=df.columns, index=df.index)
-        expected[2] = expected[2].astype("int64")
-        expected[3] = expected[3].astype("int64")
-        assert_frame_equal(result, expected)
-
-        result = df.copy()
-        result.where(mask, s2, axis="index", inplace=True)
-        assert_frame_equal(result, expected)
-
-        # DataFrame vs DataFrame
-        d1 = df.copy().drop(1, axis=0)
-        expected = df.copy()
-        expected.loc[1, :] = np.nan
-
-        result = df.where(mask, d1)
-        assert_frame_equal(result, expected)
-        result = df.where(mask, d1, axis="index")
-        assert_frame_equal(result, expected)
-        result = df.copy()
-        result.where(mask, d1, inplace=True)
-        assert_frame_equal(result, expected)
-        result = df.copy()
-        result.where(mask, d1, inplace=True, axis="index")
-        assert_frame_equal(result, expected)
-
-        d2 = df.copy().drop(1, axis=1)
-        expected = df.copy()
-        expected.loc[:, 1] = np.nan
-
-        result = df.where(mask, d2)
-        assert_frame_equal(result, expected)
-        result = df.where(mask, d2, axis="columns")
-        assert_frame_equal(result, expected)
-        result = df.copy()
-        result.where(mask, d2, inplace=True)
-        assert_frame_equal(result, expected)
-        result = df.copy()
-        result.where(mask, d2, inplace=True, axis="columns")
-        assert_frame_equal(result, expected)
-
-    def test_where_callable(self):
-        # GH 12533
-        df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-        result = df.where(lambda x: x > 4, lambda x: x + 1)
-        exp = DataFrame([[2, 3, 4], [5, 5, 6], [7, 8, 9]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, df.where(df > 4, df + 1))
-
-        # return ndarray and scalar
-        result = df.where(lambda x: (x % 2 == 0).values, lambda x: 99)
-        exp = DataFrame([[99, 2, 99], [4, 99, 6], [99, 8, 99]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, df.where(df % 2 == 0, 99))
-
-        # chain
-        result = (df + 2).where(lambda x: x > 8, lambda x: x + 10)
-        exp = DataFrame([[13, 14, 15], [16, 17, 18], [9, 10, 11]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, (df + 2).where((df + 2) > 8, (df + 2) + 10))
-
-    def test_where_tz_values(self, tz_naive_fixture):
-        df1 = DataFrame(
-            DatetimeIndex(["20150101", "20150102", "20150103"], tz=tz_naive_fixture),
-            columns=["date"],
-        )
-        df2 = DataFrame(
-            DatetimeIndex(["20150103", "20150104", "20150105"], tz=tz_naive_fixture),
-            columns=["date"],
-        )
-        mask = DataFrame([True, True, False], columns=["date"])
-        exp = DataFrame(
-            DatetimeIndex(["20150101", "20150102", "20150105"], tz=tz_naive_fixture),
-            columns=["date"],
-        )
-        result = df1.where(mask, df2)
-        assert_frame_equal(exp, result)
-
-    def test_mask(self):
-        df = DataFrame(np.random.randn(5, 3))
-        cond = df > 0
-
-        rs = df.where(cond, np.nan)
-        assert_frame_equal(rs, df.mask(df <= 0))
-        assert_frame_equal(rs, df.mask(~cond))
-
-        other = DataFrame(np.random.randn(5, 3))
-        rs = df.where(cond, other)
-        assert_frame_equal(rs, df.mask(df <= 0, other))
-        assert_frame_equal(rs, df.mask(~cond, other))
-
-        # see gh-21891
-        df = DataFrame([1, 2])
-        res = df.mask([[True], [False]])
-
-        exp = DataFrame([np.nan, 2])
-        tm.assert_frame_equal(res, exp)
-
-    def test_mask_inplace(self):
-        # GH8801
-        df = DataFrame(np.random.randn(5, 3))
-        cond = df > 0
-
-        rdf = df.copy()
-
-        rdf.where(cond, inplace=True)
-        assert_frame_equal(rdf, df.where(cond))
-        assert_frame_equal(rdf, df.mask(~cond))
-
-        rdf = df.copy()
-        rdf.where(cond, -df, inplace=True)
-        assert_frame_equal(rdf, df.where(cond, -df))
-        assert_frame_equal(rdf, df.mask(~cond, -df))
-
-    def test_mask_edge_case_1xN_frame(self):
-        # GH4071
-        df = DataFrame([[1, 2]])
-        res = df.mask(DataFrame([[True, False]]))
-        expec = DataFrame([[np.nan, 2]])
-        assert_frame_equal(res, expec)
-
-    def test_mask_callable(self):
-        # GH 12533
-        df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-        result = df.mask(lambda x: x > 4, lambda x: x + 1)
-        exp = DataFrame([[1, 2, 3], [4, 6, 7], [8, 9, 10]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, df.mask(df > 4, df + 1))
-
-        # return ndarray and scalar
-        result = df.mask(lambda x: (x % 2 == 0).values, lambda x: 99)
-        exp = DataFrame([[1, 99, 3], [99, 5, 99], [7, 99, 9]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, df.mask(df % 2 == 0, 99))
-
-        # chain
-        result = (df + 2).mask(lambda x: x > 8, lambda x: x + 10)
-        exp = DataFrame([[3, 4, 5], [6, 7, 8], [19, 20, 21]])
-        tm.assert_frame_equal(result, exp)
-        tm.assert_frame_equal(result, (df + 2).mask((df + 2) > 8, (df + 2) + 10))
-
-    def test_head_tail(self, float_frame):
-        assert_frame_equal(float_frame.head(), float_frame[:5])
-        assert_frame_equal(float_frame.tail(), float_frame[-5:])
-
-        assert_frame_equal(float_frame.head(0), float_frame[0:0])
-        assert_frame_equal(float_frame.tail(0), float_frame[0:0])
-
-        assert_frame_equal(float_frame.head(-1), float_frame[:-1])
-        assert_frame_equal(float_frame.tail(-1), float_frame[1:])
-        assert_frame_equal(float_frame.head(1), float_frame[:1])
-        assert_frame_equal(float_frame.tail(1), float_frame[-1:])
-        # with a float index
-        df = float_frame.copy()
-        df.index = np.arange(len(float_frame)) + 0.1
-        assert_frame_equal(df.head(), df.iloc[:5])
-        assert_frame_equal(df.tail(), df.iloc[-5:])
-        assert_frame_equal(df.head(0), df[0:0])
-        assert_frame_equal(df.tail(0), df[0:0])
-        assert_frame_equal(df.head(-1), df.iloc[:-1])
-        assert_frame_equal(df.tail(-1), df.iloc[1:])
-        # test empty dataframe
-        empty_df = DataFrame()
-        assert_frame_equal(empty_df.tail(), empty_df)
-        assert_frame_equal(empty_df.head(), empty_df)
-
-    def test_type_error_multiindex(self):
-        # See gh-12218
-        df = DataFrame(
-            columns=["i", "c", "x", "y"],
-            data=[[0, 0, 1, 2], [1, 0, 3, 4], [0, 1, 1, 2], [1, 1, 3, 4]],
-        )
-        dg = df.pivot_table(index="i", columns="c", values=["x", "y"])
-
-        with pytest.raises(TypeError, match="is an invalid key"):
-            str(dg[:, 0])
-
-        index = Index(range(2), name="i")
-        columns = MultiIndex(
-            levels=[["x", "y"], [0, 1]], codes=[[0, 1], [0, 0]], names=[None, "c"]
-        )
-        expected = DataFrame([[1, 2], [3, 4]], columns=columns, index=index)
-
-        result = dg.loc[:, (slice(None), 0)]
-        assert_frame_equal(result, expected)
-
-        name = ("x", 0)
-        index = Index(range(2), name="i")
-        expected = Series([1, 3], index=index, name=name)
-
-        result = dg["x", 0]
-        assert_series_equal(result, expected)
-
-    def test_interval_index(self):
-        # GH 19977
-        index = pd.interval_range(start=0, periods=3)
-        df = pd.DataFrame(
-            [[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=index, columns=["A", "B", "C"]
-        )
-
-        expected = 1
-        result = df.loc[0.5, "A"]
-        assert_almost_equal(result, expected)
-
-        index = pd.interval_range(start=0, periods=3, closed="both")
-        df = pd.DataFrame(
-            [[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=index, columns=["A", "B", "C"]
-        )
-
-        index_exp = pd.interval_range(start=0, periods=2, freq=1, closed="both")
-        expected = pd.Series([1, 4], index=index_exp, name="A")
-        result = df.loc[1, "A"]
-        assert_series_equal(result, expected)
-
-
-class TestDataFrameIndexingDatetimeWithTZ(TestData):
-    def test_setitem(self, timezone_frame):
-
-        df = timezone_frame
-        idx = df["B"].rename("foo")
-
-        # setitem
-        df["C"] = idx
-        assert_series_equal(df["C"], Series(idx, name="C"))
-
-        df["D"] = "foo"
-        df["D"] = idx
-        assert_series_equal(df["D"], Series(idx, name="D"))
-        del df["D"]
-
-        # assert that A & C are not sharing the same base (e.g. they
-        # are copies)
-        b1 = df._data.blocks[1]
-        b2 = df._data.blocks[2]
-        tm.assert_extension_array_equal(b1.values, b2.values)
-        assert id(b1.values._data.base) != id(b2.values._data.base)
-
-        # with nan
-        df2 = df.copy()
-        df2.iloc[1, 1] = pd.NaT
-        df2.iloc[1, 2] = pd.NaT
-        result = df2["B"]
-        assert_series_equal(notna(result), Series([True, False, True], name="B"))
-        assert_series_equal(df2.dtypes, df.dtypes)
-
-    def test_set_reset(self):
-
-        idx = Index(date_range("20130101", periods=3, tz="US/Eastern"), name="foo")
-
-        # set/reset
-        df = DataFrame({"A": [0, 1, 2]}, index=idx)
-        result = df.reset_index()
-        assert result["foo"].dtype, "M8[ns, US/Eastern"
-
-        df = result.set_index("foo")
-        tm.assert_index_equal(df.index, idx)
-
-    def test_transpose(self, timezone_frame):
-
-        result = timezone_frame.T
-        expected = DataFrame(timezone_frame.values.T)
-        expected.index = ["A", "B", "C"]
-        assert_frame_equal(result, expected)
-
-    def test_scalar_assignment(self):
-        # issue #19843
-        df = pd.DataFrame(index=(0, 1, 2))
-        df["now"] = pd.Timestamp("20130101", tz="UTC")
-        expected = pd.DataFrame(
-            {"now": pd.Timestamp("20130101", tz="UTC")}, index=[0, 1, 2]
-        )
-        tm.assert_frame_equal(df, expected)
-
-
-class TestDataFrameIndexingUInt64(TestData):
-    def test_setitem(self, uint64_frame):
-
-        df = uint64_frame
-        idx = df["A"].rename("foo")
-
-        # setitem
-        df["C"] = idx
-        assert_series_equal(df["C"], Series(idx, name="C"))
-
-        df["D"] = "foo"
-        df["D"] = idx
-        assert_series_equal(df["D"], Series(idx, name="D"))
-        del df["D"]
-
-        # With NaN: because uint64 has no NaN element,
-        # the column should be cast to object.
-        df2 = df.copy()
-        df2.iloc[1, 1] = pd.NaT
-        df2.iloc[1, 2] = pd.NaT
-        result = df2["B"]
-        assert_series_equal(notna(result), Series([True, False, True], name="B"))
-        assert_series_equal(
-            df2.dtypes,
-            Series(
-                [np.dtype("uint64"), np.dtype("O"), np.dtype("O")],
-                index=["A", "B", "C"],
-            ),
-        )
-
-    def test_set_reset(self):
-
-        idx = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10], name="foo")
-
-        # set/reset
-        df = DataFrame({"A": [0, 1, 2]}, index=idx)
-        result = df.reset_index()
-        assert result["foo"].dtype == np.dtype("uint64")
-
-        df = result.set_index("foo")
-        tm.assert_index_equal(df.index, idx)
-
-    def test_transpose(self, uint64_frame):
-
-        result = uint64_frame.T
-        expected = DataFrame(uint64_frame.values.T)
-        expected.index = ["A", "B"]
-        assert_frame_equal(result, expected)
-
-
-class TestDataFrameIndexingCategorical:
-    def test_assignment(self):
-        # assignment
-        df = DataFrame(
-            {"value": np.array(np.random.randint(0, 10000, 100), dtype="int32")}
-        )
-        labels = Categorical(
-            ["{0} - {1}".format(i, i + 499) for i in range(0, 10000, 500)]
-        )
-
-        df = df.sort_values(by=["value"], ascending=True)
-        s = pd.cut(df.value, range(0, 10500, 500), right=False, labels=labels)
-        d = s.values
-        df["D"] = d
-        str(df)
-
-        result = df.dtypes
-        expected = Series(
-            [np.dtype("int32"), CategoricalDtype(categories=labels, ordered=False)],
-            index=["value", "D"],
-        )
-        tm.assert_series_equal(result, expected)
-
-        df["E"] = s
-        str(df)
-
-        result = df.dtypes
-        expected = Series(
-            [
-                np.dtype("int32"),
-                CategoricalDtype(categories=labels, ordered=False),
-                CategoricalDtype(categories=labels, ordered=False),
-            ],
-            index=["value", "D", "E"],
-        )
-        tm.assert_series_equal(result, expected)
-
-        result1 = df["D"]
-        result2 = df["E"]
-        tm.assert_categorical_equal(result1._data._block.values, d)
-
-        # sorting
-        s.name = "E"
-        tm.assert_series_equal(result2.sort_index(), s.sort_index())
-
-        cat = Categorical([1, 2, 3, 10], categories=[1, 2, 3, 4, 10])
-        df = DataFrame(Series(cat))
-
-    def test_assigning_ops(self):
-        # systematically test the assigning operations:
-        # for all slicing ops:
-        #  for value in categories and value not in categories:
-
-        #   - assign a single value -> exp_single_cats_value
-
-        #   - assign a complete row (mixed values) -> exp_single_row
-
-        # assign multiple rows (mixed values) (-> array) -> exp_multi_row
-
-        # assign a part of a column with dtype == categorical ->
-        # exp_parts_cats_col
-
-        # assign a part of a column with dtype != categorical ->
-        # exp_parts_cats_col
-
-        cats = Categorical(["a", "a", "a", "a", "a", "a", "a"], categories=["a", "b"])
-        idx = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values = [1, 1, 1, 1, 1, 1, 1]
-        orig = DataFrame({"cats": cats, "values": values}, index=idx)
-
-        # the expected values
-        # changed single row
-        cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
-        idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values1 = [1, 1, 2, 1, 1, 1, 1]
-        exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
-
-        # changed multiple rows
-        cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
-        idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values2 = [1, 1, 2, 2, 1, 1, 1]
-        exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
-
-        # changed part of the cats column
-        cats3 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
-        idx3 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values3 = [1, 1, 1, 1, 1, 1, 1]
-        exp_parts_cats_col = DataFrame({"cats": cats3, "values": values3}, index=idx3)
-
-        # changed single value in cats col
-        cats4 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
-        idx4 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values4 = [1, 1, 1, 1, 1, 1, 1]
-        exp_single_cats_value = DataFrame(
-            {"cats": cats4, "values": values4}, index=idx4
-        )
-
-        #  iloc
-        # ###############
-        #   - assign a single value -> exp_single_cats_value
-        df = orig.copy()
-        df.iloc[2, 0] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        df = orig.copy()
-        df.iloc[df.index == "j", 0] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        #   - assign a single value not in the current categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.iloc[2, 0] = "c"
-
-        #   - assign a complete row (mixed values) -> exp_single_row
-        df = orig.copy()
-        df.iloc[2, :] = ["b", 2]
-        tm.assert_frame_equal(df, exp_single_row)
-
-        #   - assign a complete row (mixed values) not in categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.iloc[2, :] = ["c", 2]
-
-        #   - assign multiple rows (mixed values) -> exp_multi_row
-        df = orig.copy()
-        df.iloc[2:4, :] = [["b", 2], ["b", 2]]
-        tm.assert_frame_equal(df, exp_multi_row)
-
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.iloc[2:4, :] = [["c", 2], ["c", 2]]
-
-        # assign a part of a column with dtype == categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.iloc[2:4, 0] = Categorical(["b", "b"], categories=["a", "b"])
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            # different categories -> not sure if this should fail or pass
-            df = orig.copy()
-            df.iloc[2:4, 0] = Categorical(list("bb"), categories=list("abc"))
-
-        with pytest.raises(ValueError):
-            # different values
-            df = orig.copy()
-            df.iloc[2:4, 0] = Categorical(list("cc"), categories=list("abc"))
-
-        # assign a part of a column with dtype != categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.iloc[2:4, 0] = ["b", "b"]
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            df.iloc[2:4, 0] = ["c", "c"]
-
-        #  loc
-        # ##############
-        #   - assign a single value -> exp_single_cats_value
-        df = orig.copy()
-        df.loc["j", "cats"] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        df = orig.copy()
-        df.loc[df.index == "j", "cats"] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        #   - assign a single value not in the current categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j", "cats"] = "c"
-
-        #   - assign a complete row (mixed values) -> exp_single_row
-        df = orig.copy()
-        df.loc["j", :] = ["b", 2]
-        tm.assert_frame_equal(df, exp_single_row)
-
-        #   - assign a complete row (mixed values) not in categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j", :] = ["c", 2]
-
-        #   - assign multiple rows (mixed values) -> exp_multi_row
-        df = orig.copy()
-        df.loc["j":"k", :] = [["b", 2], ["b", 2]]
-        tm.assert_frame_equal(df, exp_multi_row)
-
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j":"k", :] = [["c", 2], ["c", 2]]
-
-        # assign a part of a column with dtype == categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.loc["j":"k", "cats"] = Categorical(["b", "b"], categories=["a", "b"])
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            # different categories -> not sure if this should fail or pass
-            df = orig.copy()
-            df.loc["j":"k", "cats"] = Categorical(
-                ["b", "b"], categories=["a", "b", "c"]
-            )
-
-        with pytest.raises(ValueError):
-            # different values
-            df = orig.copy()
-            df.loc["j":"k", "cats"] = Categorical(
-                ["c", "c"], categories=["a", "b", "c"]
-            )
-
-        # assign a part of a column with dtype != categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.loc["j":"k", "cats"] = ["b", "b"]
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            df.loc["j":"k", "cats"] = ["c", "c"]
-
-        #  loc
-        # ##############
-        #   - assign a single value -> exp_single_cats_value
-        df = orig.copy()
-        df.loc["j", df.columns[0]] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        df = orig.copy()
-        df.loc[df.index == "j", df.columns[0]] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        #   - assign a single value not in the current categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j", df.columns[0]] = "c"
-
-        #   - assign a complete row (mixed values) -> exp_single_row
-        df = orig.copy()
-        df.loc["j", :] = ["b", 2]
-        tm.assert_frame_equal(df, exp_single_row)
-
-        #   - assign a complete row (mixed values) not in categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j", :] = ["c", 2]
-
-        #   - assign multiple rows (mixed values) -> exp_multi_row
-        df = orig.copy()
-        df.loc["j":"k", :] = [["b", 2], ["b", 2]]
-        tm.assert_frame_equal(df, exp_multi_row)
-
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.loc["j":"k", :] = [["c", 2], ["c", 2]]
-
-        # assign a part of a column with dtype == categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.loc["j":"k", df.columns[0]] = Categorical(["b", "b"], categories=["a", "b"])
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            # different categories -> not sure if this should fail or pass
-            df = orig.copy()
-            df.loc["j":"k", df.columns[0]] = Categorical(
-                ["b", "b"], categories=["a", "b", "c"]
-            )
-
-        with pytest.raises(ValueError):
-            # different values
-            df = orig.copy()
-            df.loc["j":"k", df.columns[0]] = Categorical(
-                ["c", "c"], categories=["a", "b", "c"]
-            )
-
-        # assign a part of a column with dtype != categorical ->
-        # exp_parts_cats_col
-        df = orig.copy()
-        df.loc["j":"k", df.columns[0]] = ["b", "b"]
-        tm.assert_frame_equal(df, exp_parts_cats_col)
-
-        with pytest.raises(ValueError):
-            df.loc["j":"k", df.columns[0]] = ["c", "c"]
-
-        # iat
-        df = orig.copy()
-        df.iat[2, 0] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        #   - assign a single value not in the current categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.iat[2, 0] = "c"
-
-        # at
-        #   - assign a single value -> exp_single_cats_value
-        df = orig.copy()
-        df.at["j", "cats"] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        #   - assign a single value not in the current categories set
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.at["j", "cats"] = "c"
-
-        # fancy indexing
-        catsf = Categorical(
-            ["a", "a", "c", "c", "a", "a", "a"], categories=["a", "b", "c"]
-        )
-        idxf = Index(["h", "i", "j", "k", "l", "m", "n"])
-        valuesf = [1, 1, 3, 3, 1, 1, 1]
-        df = DataFrame({"cats": catsf, "values": valuesf}, index=idxf)
-
-        exp_fancy = exp_multi_row.copy()
-        exp_fancy["cats"].cat.set_categories(["a", "b", "c"], inplace=True)
-
-        df[df["cats"] == "c"] = ["b", 2]
-        # category c is kept in .categories
-        tm.assert_frame_equal(df, exp_fancy)
-
-        # set_value
-        df = orig.copy()
-        df.at["j", "cats"] = "b"
-        tm.assert_frame_equal(df, exp_single_cats_value)
-
-        with pytest.raises(ValueError):
-            df = orig.copy()
-            df.at["j", "cats"] = "c"
-
-        # Assigning a Category to parts of a int/... column uses the values of
-        # the Categorical
-        df = DataFrame({"a": [1, 1, 1, 1, 1], "b": list("aaaaa")})
-        exp = DataFrame({"a": [1, "b", "b", 1, 1], "b": list("aabba")})
-        df.loc[1:2, "a"] = Categorical(["b", "b"], categories=["a", "b"])
-        df.loc[2:3, "b"] = Categorical(["b", "b"], categories=["a", "b"])
-        tm.assert_frame_equal(df, exp)
-
-    def test_functions_no_warnings(self):
-        df = DataFrame({"value": np.random.randint(0, 100, 20)})
-        labels = ["{0} - {1}".format(i, i + 9) for i in range(0, 100, 10)]
-        with tm.assert_produces_warning(False):
-            df["group"] = pd.cut(
-                df.value, range(0, 105, 10), right=False, labels=labels
-            )
diff --git a/pandas/tests/frame/test_join.py b/pandas/tests/frame/test_join.py
index 220968d4b3d29..c6e28f3c64f12 100644
--- a/pandas/tests/frame/test_join.py
+++ b/pandas/tests/frame/test_join.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, Index, period_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -195,7 +195,7 @@ def test_join_left_sequence_non_unique_index():
     tm.assert_frame_equal(joined, expected)
 
 
-@pytest.mark.parametrize("sort_kw", [True, False, None])
+@pytest.mark.parametrize("sort_kw", [True, False])
 def test_suppress_future_warning_with_sort_kw(sort_kw):
     a = DataFrame({"col1": [1, 2]}, index=["c", "a"])
 
@@ -213,12 +213,6 @@ def test_suppress_future_warning_with_sort_kw(sort_kw):
     if sort_kw is False:
         expected = expected.reindex(index=["c", "a", "b"])
 
-    if sort_kw is None:
-        # only warn if not explicitly specified
-        ctx = tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
-    else:
-        ctx = tm.assert_produces_warning(None, check_stacklevel=False)
-
-    with ctx:
+    with tm.assert_produces_warning(None, check_stacklevel=False):
         result = a.join([b, c], how="outer", sort=sort_kw)
     tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_missing.py b/pandas/tests/frame/test_missing.py
index 94667ecfa837d..ae0516dd29a1f 100644
--- a/pandas/tests/frame/test_missing.py
+++ b/pandas/tests/frame/test_missing.py
@@ -8,18 +8,8 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Series, Timestamp, date_range
+import pandas._testing as tm
 from pandas.tests.frame.common import _check_mixed_float
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
-
-
-def _skip_if_no_pchip():
-    try:
-        from scipy.interpolate import pchip_interpolate  # noqa
-    except ImportError:
-        import pytest
-
-        pytest.skip("scipy.interpolate.pchip missing")
 
 
 class TestDataFrameMissingData:
@@ -35,15 +25,15 @@ def test_dropEmptyRows(self, float_frame):
 
         smaller_frame = frame.dropna(how="all")
         # check that original was preserved
-        assert_series_equal(frame["foo"], original)
+        tm.assert_series_equal(frame["foo"], original)
         inplace_frame1.dropna(how="all", inplace=True)
-        assert_series_equal(smaller_frame["foo"], expected)
-        assert_series_equal(inplace_frame1["foo"], expected)
+        tm.assert_series_equal(smaller_frame["foo"], expected)
+        tm.assert_series_equal(inplace_frame1["foo"], expected)
 
         smaller_frame = frame.dropna(how="all", subset=["foo"])
         inplace_frame2.dropna(how="all", subset=["foo"], inplace=True)
-        assert_series_equal(smaller_frame["foo"], expected)
-        assert_series_equal(inplace_frame2["foo"], expected)
+        tm.assert_series_equal(smaller_frame["foo"], expected)
+        tm.assert_series_equal(inplace_frame2["foo"], expected)
 
     def test_dropIncompleteRows(self, float_frame):
         N = len(float_frame.index)
@@ -56,7 +46,7 @@ def test_dropIncompleteRows(self, float_frame):
         inp_frame1, inp_frame2 = frame.copy(), frame.copy()
 
         smaller_frame = frame.dropna()
-        assert_series_equal(frame["foo"], original)
+        tm.assert_series_equal(frame["foo"], original)
         inp_frame1.dropna(inplace=True)
 
         exp = Series(mat[5:], index=float_frame.index[5:], name="foo")
@@ -64,7 +54,7 @@ def test_dropIncompleteRows(self, float_frame):
         tm.assert_series_equal(inp_frame1["foo"], exp)
 
         samesize_frame = frame.dropna(subset=["bar"])
-        assert_series_equal(frame["foo"], original)
+        tm.assert_series_equal(frame["foo"], original)
         assert (frame["bar"] == 5).all()
         inp_frame2.dropna(subset=["bar"], inplace=True)
         tm.assert_index_equal(samesize_frame.index, float_frame.index)
@@ -78,52 +68,52 @@ def test_dropna(self):
         expected = df.loc[:, [0, 1, 3]]
         inp = df.copy()
         inp.dropna(axis=1, inplace=True)
-        assert_frame_equal(dropped, expected)
-        assert_frame_equal(inp, expected)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
 
         dropped = df.dropna(axis=0)
         expected = df.loc[list(range(2, 6))]
         inp = df.copy()
         inp.dropna(axis=0, inplace=True)
-        assert_frame_equal(dropped, expected)
-        assert_frame_equal(inp, expected)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
 
         # threshold
         dropped = df.dropna(axis=1, thresh=5)
         expected = df.loc[:, [0, 1, 3]]
         inp = df.copy()
         inp.dropna(axis=1, thresh=5, inplace=True)
-        assert_frame_equal(dropped, expected)
-        assert_frame_equal(inp, expected)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
 
         dropped = df.dropna(axis=0, thresh=4)
         expected = df.loc[range(2, 6)]
         inp = df.copy()
         inp.dropna(axis=0, thresh=4, inplace=True)
-        assert_frame_equal(dropped, expected)
-        assert_frame_equal(inp, expected)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
 
         dropped = df.dropna(axis=1, thresh=4)
-        assert_frame_equal(dropped, df)
+        tm.assert_frame_equal(dropped, df)
 
         dropped = df.dropna(axis=1, thresh=3)
-        assert_frame_equal(dropped, df)
+        tm.assert_frame_equal(dropped, df)
 
         # subset
         dropped = df.dropna(axis=0, subset=[0, 1, 3])
         inp = df.copy()
         inp.dropna(axis=0, subset=[0, 1, 3], inplace=True)
-        assert_frame_equal(dropped, df)
-        assert_frame_equal(inp, df)
+        tm.assert_frame_equal(dropped, df)
+        tm.assert_frame_equal(inp, df)
 
         # all
         dropped = df.dropna(axis=1, how="all")
-        assert_frame_equal(dropped, df)
+        tm.assert_frame_equal(dropped, df)
 
         df[2] = np.nan
         dropped = df.dropna(axis=1, how="all")
         expected = df.loc[:, [0, 1, 3]]
-        assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(dropped, expected)
 
         # bad input
         msg = "No axis named 3 for object type <class 'pandas.core.frame.DataFrame'>"
@@ -137,13 +127,13 @@ def test_drop_and_dropna_caching(self):
         df = pd.DataFrame({"A": original.values.copy()})
         df2 = df.copy()
         df["A"].dropna()
-        assert_series_equal(df["A"], original)
+        tm.assert_series_equal(df["A"], original)
         df["A"].dropna(inplace=True)
-        assert_series_equal(df["A"], expected)
+        tm.assert_series_equal(df["A"], expected)
         df2["A"].drop([1])
-        assert_series_equal(df2["A"], original)
+        tm.assert_series_equal(df2["A"], original)
         df2["A"].drop([1], inplace=True)
-        assert_series_equal(df2["A"], original.drop([1]))
+        tm.assert_series_equal(df2["A"], original.drop([1]))
 
     def test_dropna_corner(self, float_frame):
         # bad input
@@ -166,23 +156,16 @@ def test_dropna_multiple_axes(self):
                 [7, np.nan, 8, 9],
             ]
         )
-        cp = df.copy()
 
         # GH20987
-        with tm.assert_produces_warning(FutureWarning):
-            result = df.dropna(how="all", axis=[0, 1])
-        with tm.assert_produces_warning(FutureWarning):
-            result2 = df.dropna(how="all", axis=(0, 1))
-        expected = df.dropna(how="all").dropna(how="all", axis=1)
-
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-        assert_frame_equal(df, cp)
+        with pytest.raises(TypeError, match="supplying multiple axes"):
+            df.dropna(how="all", axis=[0, 1])
+        with pytest.raises(TypeError, match="supplying multiple axes"):
+            df.dropna(how="all", axis=(0, 1))
 
         inp = df.copy()
-        with tm.assert_produces_warning(FutureWarning):
+        with pytest.raises(TypeError, match="supplying multiple axes"):
             inp.dropna(how="all", axis=(0, 1), inplace=True)
-        assert_frame_equal(inp, expected)
 
     def test_dropna_tz_aware_datetime(self):
         # GH13407
@@ -192,13 +175,13 @@ def test_dropna_tz_aware_datetime(self):
         df["Time"] = [dt1]
         result = df.dropna(axis=0)
         expected = DataFrame({"Time": [dt1]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Ex2
         df = DataFrame({"Time": [dt1, None, np.nan, dt2]})
         result = df.dropna(axis=0)
         expected = DataFrame([dt1, dt2], columns=["Time"], index=[0, 3])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dropna_categorical_interval_index(self):
         # GH 25087
@@ -268,10 +251,10 @@ def test_fillna_different_dtype(self):
         expected = DataFrame(
             [["a", "a", "foo", "a"], ["b", "b", "foo", "b"], ["c", "c", "foo", "c"]]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df.fillna({2: "foo"}, inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_fillna_limit_and_value(self):
         # limit and value
@@ -283,7 +266,7 @@ def test_fillna_limit_and_value(self):
         expected.iloc[2, 0] = 999
         expected.iloc[3, 2] = 999
         result = df.fillna(999, limit=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_fillna_datelike(self):
         # with datelike
@@ -298,7 +281,7 @@ def test_fillna_datelike(self):
         expected = df.copy()
         expected["Date"] = expected["Date"].fillna(df.loc[df.index[0], "Date2"])
         result = df.fillna(value={"Date": df["Date2"]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_fillna_tzaware(self):
         # with timezone
@@ -312,7 +295,7 @@ def test_fillna_tzaware(self):
                 ]
             }
         )
-        assert_frame_equal(df.fillna(method="pad"), exp)
+        tm.assert_frame_equal(df.fillna(method="pad"), exp)
 
         df = pd.DataFrame({"A": [pd.NaT, pd.Timestamp("2012-11-11 00:00:00+01:00")]})
         exp = pd.DataFrame(
@@ -323,7 +306,7 @@ def test_fillna_tzaware(self):
                 ]
             }
         )
-        assert_frame_equal(df.fillna(method="bfill"), exp)
+        tm.assert_frame_equal(df.fillna(method="bfill"), exp)
 
     def test_fillna_tzaware_different_column(self):
         # with timezone in another column
@@ -341,7 +324,7 @@ def test_fillna_tzaware_different_column(self):
                 "B": [1.0, 2.0, 2.0, 2.0],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_na_actions_categorical(self):
 
@@ -391,13 +374,15 @@ def test_fillna_categorical_nan(self):
         cat = Categorical([np.nan, 2, np.nan])
         val = Categorical([np.nan, np.nan, np.nan])
         df = DataFrame({"cats": cat, "vals": val})
-        res = df.fillna(df.median())
+        with tm.assert_produces_warning(RuntimeWarning):
+            res = df.fillna(df.median())
         v_exp = [np.nan, np.nan, np.nan]
         df_exp = DataFrame({"cats": [2, 2, 2], "vals": v_exp}, dtype="category")
         tm.assert_frame_equal(res, df_exp)
 
         result = df.cats.fillna(np.nan)
         tm.assert_series_equal(result, df.cats)
+
         result = df.vals.fillna(np.nan)
         tm.assert_series_equal(result, df.vals)
 
@@ -423,37 +408,37 @@ def test_fillna_downcast(self):
         df = pd.DataFrame({"a": [1.0, np.nan]})
         result = df.fillna(0, downcast="infer")
         expected = pd.DataFrame({"a": [1, 0]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # infer int64 from float64 when fillna value is a dict
         df = pd.DataFrame({"a": [1.0, np.nan]})
         result = df.fillna({"a": 0}, downcast="infer")
         expected = pd.DataFrame({"a": [1, 0]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_fillna_dtype_conversion(self):
         # make sure that fillna on an empty frame works
         df = DataFrame(index=["A", "B", "C"], columns=[1, 2, 3, 4, 5])
         result = df.dtypes
         expected = Series([np.dtype("object")] * 5, index=[1, 2, 3, 4, 5])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df.fillna(1)
         expected = DataFrame(1, index=["A", "B", "C"], columns=[1, 2, 3, 4, 5])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # empty block
         df = DataFrame(index=range(3), columns=["A", "B"], dtype="float64")
         result = df.fillna("nan")
         expected = DataFrame("nan", index=range(3), columns=["A", "B"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # equiv of replace
         df = DataFrame(dict(A=[1, np.nan], B=[1.0, 2.0]))
         for v in ["", 1, np.nan, 1.0]:
             expected = df.replace(np.nan, v)
             result = df.fillna(v)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_fillna_datetime_columns(self):
         # GH 7095
@@ -503,7 +488,7 @@ def test_ffill(self, datetime_frame):
         datetime_frame["A"][:5] = np.nan
         datetime_frame["A"][-5:] = np.nan
 
-        assert_frame_equal(
+        tm.assert_frame_equal(
             datetime_frame.ffill(), datetime_frame.fillna(method="ffill")
         )
 
@@ -511,7 +496,7 @@ def test_bfill(self, datetime_frame):
         datetime_frame["A"][:5] = np.nan
         datetime_frame["A"][-5:] = np.nan
 
-        assert_frame_equal(
+        tm.assert_frame_equal(
             datetime_frame.bfill(), datetime_frame.fillna(method="bfill")
         )
 
@@ -609,7 +594,7 @@ def test_fillna_dict_series(self):
         expected = df.copy()
         expected["a"] = expected["a"].fillna(0)
         expected["b"] = expected["b"].fillna(5)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # it works
         result = df.fillna({"a": 0, "b": 5, "d": 7})
@@ -617,7 +602,7 @@ def test_fillna_dict_series(self):
         # Series treated same as dict
         result = df.fillna(df.max())
         expected = df.fillna(df.max().to_dict())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # disable this for now
         with pytest.raises(NotImplementedError, match="column by column"):
@@ -656,7 +641,7 @@ def test_fillna_dataframe(self):
             index=list("VWXYZ"),
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_fillna_columns(self):
         df = DataFrame(np.random.randn(10, 10))
@@ -664,12 +649,12 @@ def test_fillna_columns(self):
 
         result = df.fillna(method="ffill", axis=1)
         expected = df.T.fillna(method="pad").T
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df.insert(6, "foo", 5)
         result = df.fillna(method="ffill", axis=1)
         expected = df.astype(float).fillna(method="ffill", axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_fillna_invalid_method(self, float_frame):
         with pytest.raises(ValueError, match="ffil"):
@@ -677,7 +662,7 @@ def test_fillna_invalid_method(self, float_frame):
 
     def test_fillna_invalid_value(self, float_frame):
         # list
-        msg = '"value" parameter must be a scalar or dict, but you passed' ' a "{}"'
+        msg = '"value" parameter must be a scalar or dict, but you passed a "{}"'
         with pytest.raises(TypeError, match=msg.format("list")):
             float_frame.fillna([1, 2])
         # tuple
@@ -685,8 +670,8 @@ def test_fillna_invalid_value(self, float_frame):
             float_frame.fillna((1, 2))
         # frame with series
         msg = (
-            '"value" parameter must be a scalar, dict or Series, but you'
-            ' passed a "DataFrame"'
+            '"value" parameter must be a scalar, dict or Series, but you '
+            'passed a "DataFrame"'
         )
         with pytest.raises(TypeError, match=msg):
             float_frame.iloc[:, 0].fillna(float_frame)
@@ -719,7 +704,7 @@ def test_fill_value_when_combine_const(self):
 
         exp = df.fillna(0).add(2)
         res = df.add(2, fill_value=0)
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
 
 class TestDataFrameInterpolate:
@@ -741,13 +726,13 @@ def test_interp_basic(self):
             }
         )
         result = df.interpolate()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.set_index("C").interpolate()
         expected = df.set_index("C")
         expected.loc[3, "A"] = 3
         expected.loc[5, "B"] = 9
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_interp_bad_method(self):
         df = DataFrame(
@@ -773,11 +758,11 @@ def test_interp_combo(self):
 
         result = df["A"].interpolate()
         expected = Series([1.0, 2.0, 3.0, 4.0], name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = df["A"].interpolate(downcast="infer")
         expected = Series([1, 2, 3, 4], name="A")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_nan_idx(self):
         df = DataFrame({"A": [1, 2, np.nan, 4], "B": [np.nan, 2, 3, 4]})
@@ -796,33 +781,33 @@ def test_interp_various(self):
 
         expected.A.loc[3] = 2.66666667
         expected.A.loc[13] = 5.76923076
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(method="cubic")
         # GH #15662.
         expected.A.loc[3] = 2.81547781
         expected.A.loc[13] = 5.52964175
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(method="nearest")
         expected.A.loc[3] = 2
         expected.A.loc[13] = 5
-        assert_frame_equal(result, expected, check_dtype=False)
+        tm.assert_frame_equal(result, expected, check_dtype=False)
 
         result = df.interpolate(method="quadratic")
         expected.A.loc[3] = 2.82150771
         expected.A.loc[13] = 6.12648668
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(method="slinear")
         expected.A.loc[3] = 2.66666667
         expected.A.loc[13] = 5.76923077
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(method="zero")
         expected.A.loc[3] = 2.0
         expected.A.loc[13] = 5
-        assert_frame_equal(result, expected, check_dtype=False)
+        tm.assert_frame_equal(result, expected, check_dtype=False)
 
     @td.skip_if_no_scipy
     def test_interp_alt_scipy(self):
@@ -833,23 +818,21 @@ def test_interp_alt_scipy(self):
         expected = df.copy()
         expected.loc[2, "A"] = 3
         expected.loc[5, "A"] = 6
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(method="barycentric", downcast="infer")
-        assert_frame_equal(result, expected.astype(np.int64))
+        tm.assert_frame_equal(result, expected.astype(np.int64))
 
         result = df.interpolate(method="krogh")
         expectedk = df.copy()
         expectedk["A"] = expected["A"]
-        assert_frame_equal(result, expectedk)
-
-        _skip_if_no_pchip()
+        tm.assert_frame_equal(result, expectedk)
 
         result = df.interpolate(method="pchip")
         expected.loc[2, "A"] = 3
         expected.loc[5, "A"] = 6.0
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_interp_rowwise(self):
         df = DataFrame(
@@ -867,14 +850,31 @@ def test_interp_rowwise(self):
         expected.loc[0, 2] = 3
         expected.loc[1, 3] = 3
         expected[4] = expected[4].astype(np.float64)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(axis=1, method="values")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.interpolate(axis=0)
         expected = df.interpolate()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "axis_name, axis_number",
+        [
+            pytest.param("rows", 0, id="rows_0"),
+            pytest.param("index", 0, id="index_0"),
+            pytest.param("columns", 1, id="columns_1"),
+        ],
+    )
+    def test_interp_axis_names(self, axis_name, axis_number):
+        # GH 29132: test axis names
+        data = {0: [0, np.nan, 6], 1: [1, np.nan, 7], 2: [2, 5, 8]}
+
+        df = DataFrame(data, dtype=np.float64)
+        result = df.interpolate(axis=axis_name, method="linear")
+        expected = df.interpolate(axis=axis_number, method="linear")
+        tm.assert_frame_equal(result, expected)
 
     def test_rowwise_alt(self):
         df = DataFrame(
@@ -895,11 +895,11 @@ def test_interp_leading_nans(self, check_scipy):
         result = df.interpolate()
         expected = df.copy()
         expected["B"].loc[3] = -3.75
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         if check_scipy:
             result = df.interpolate(method="polynomial", order=1)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_interp_raise_on_only_mixed(self):
         df = DataFrame(
@@ -930,11 +930,11 @@ def test_interp_inplace(self):
         expected = DataFrame({"a": [1.0, 2.0, 3.0, 4.0]})
         result = df.copy()
         result["a"].interpolate(inplace=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.copy()
         result["a"].interpolate(inplace=True, downcast="infer")
-        assert_frame_equal(result, expected.astype("int64"))
+        tm.assert_frame_equal(result, expected.astype("int64"))
 
     def test_interp_inplace_row(self):
         # GH 10395
@@ -943,7 +943,7 @@ def test_interp_inplace_row(self):
         )
         expected = result.interpolate(method="linear", axis=1, inplace=False)
         result.interpolate(method="linear", axis=1, inplace=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_interp_ignore_all_good(self):
         # GH
@@ -965,8 +965,21 @@ def test_interp_ignore_all_good(self):
         )
 
         result = df.interpolate(downcast=None)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # all good
         result = df[["B", "D"]].interpolate(downcast=None)
-        assert_frame_equal(result, df[["B", "D"]])
+        tm.assert_frame_equal(result, df[["B", "D"]])
+
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_interp_time_inplace_axis(self, axis):
+        # GH 9687
+        periods = 5
+        idx = pd.date_range(start="2014-01-01", periods=periods)
+        data = np.random.rand(periods, periods)
+        data[data < 0.5] = np.nan
+        expected = pd.DataFrame(index=idx, columns=idx, data=data)
+
+        result = expected.interpolate(axis=0, method="time")
+        expected.interpolate(axis=0, method="time", inplace=True)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py
index 7ad5abca82b29..8bc2aa214e035 100644
--- a/pandas/tests/frame/test_mutate_columns.py
+++ b/pandas/tests/frame/test_mutate_columns.py
@@ -3,11 +3,8 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PY36
-
 from pandas import DataFrame, Index, MultiIndex, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 # Column add, remove, delete.
 
@@ -19,34 +16,34 @@ def test_assign(self):
         result = df.assign(C=df.B / df.A)
         expected = df.copy()
         expected["C"] = [4, 2.5, 2]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # lambda syntax
         result = df.assign(C=lambda x: x.B / x.A)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # original is unmodified
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(df, original)
 
         # Non-Series array-like
         result = df.assign(C=[4, 2.5, 2])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         # original is unmodified
-        assert_frame_equal(df, original)
+        tm.assert_frame_equal(df, original)
 
         result = df.assign(B=df.B / df.A)
         expected = expected.drop("B", axis=1).rename(columns={"C": "B"})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # overwrite
         result = df.assign(A=df.A + df.B)
         expected = df.copy()
         expected["A"] = [5, 7, 9]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # lambda
         result = df.assign(A=lambda x: x.A + x.B)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_assign_multiple(self):
         df = DataFrame([[1, 4], [2, 5], [3, 6]], columns=["A", "B"])
@@ -54,23 +51,20 @@ def test_assign_multiple(self):
         expected = DataFrame(
             [[1, 4, 7, 1, 4], [2, 5, 8, 2, 5], [3, 6, 9, 3, 6]], columns=list("ABCDE")
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_assign_order(self):
         # GH 9818
         df = DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
         result = df.assign(D=df.A + df.B, C=df.A - df.B)
 
-        if PY36:
-            expected = DataFrame([[1, 2, 3, -1], [3, 4, 7, -1]], columns=list("ABDC"))
-        else:
-            expected = DataFrame([[1, 2, -1, 3], [3, 4, -1, 7]], columns=list("ABCD"))
-        assert_frame_equal(result, expected)
+        expected = DataFrame([[1, 2, 3, -1], [3, 4, 7, -1]], columns=list("ABDC"))
+        tm.assert_frame_equal(result, expected)
         result = df.assign(C=df.A - df.B, D=df.A + df.B)
 
         expected = DataFrame([[1, 2, -1, 3], [3, 4, -1, 7]], columns=list("ABCD"))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_assign_bad(self):
         df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
@@ -81,35 +75,16 @@ def test_assign_bad(self):
         with pytest.raises(AttributeError):
             df.assign(C=df.A, D=df.A + df.C)
 
-    @pytest.mark.skipif(
-        PY36,
-        reason="""Issue #14207: valid for python
-                        3.6 and above""",
-    )
-    def test_assign_dependent_old_python(self):
-        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-
-        # Key C does not exist at definition time of df
-        with pytest.raises(KeyError, match="^'C'$"):
-            df.assign(C=lambda df: df.A, D=lambda df: df["A"] + df["C"])
-        with pytest.raises(KeyError, match="^'C'$"):
-            df.assign(C=df.A, D=lambda x: x["A"] + x["C"])
-
-    @pytest.mark.skipif(
-        not PY36,
-        reason="""Issue #14207: not valid for
-                        python 3.5 and below""",
-    )
     def test_assign_dependent(self):
         df = DataFrame({"A": [1, 2], "B": [3, 4]})
 
         result = df.assign(C=df.A, D=lambda x: x["A"] + x["C"])
         expected = DataFrame([[1, 3, 1, 2], [2, 4, 2, 4]], columns=list("ABCD"))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.assign(C=lambda df: df.A, D=lambda df: df["A"] + df["C"])
         expected = DataFrame([[1, 3, 1, 2], [2, 4, 2, 4]], columns=list("ABCD"))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_insert_error_msmgs(self):
 
@@ -140,7 +115,7 @@ def test_insert_benchmark(self):
         for i in range(K):
             df[i] = new_col
         expected = DataFrame(np.repeat(new_col, K).reshape(N, K), index=range(N))
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_insert(self):
         df = DataFrame(
@@ -199,7 +174,7 @@ def test_insert(self):
         df["X"] = df.index
         df["X"] = ["x", "y", "z"]
         exp = DataFrame(data={"X": ["x", "y", "z"]}, index=["A", "B", "C"])
-        assert_frame_equal(df, exp)
+        tm.assert_frame_equal(df, exp)
 
     def test_delitem(self, float_frame):
         del float_frame["A"]
@@ -277,11 +252,11 @@ def test_insert_column_bug_4032(self):
         result = df.rename(columns={})
         str(result)
         expected = DataFrame([[1, 1.1], [2, 2.2]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         df.insert(0, "c", [1.3, 2.3])
 
         result = df.rename(columns={})
         str(result)
 
         expected = DataFrame([[1.3, 1, 1.1], [2.3, 2, 2.2]], columns=["c", "a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_nonunique_indexes.py b/pandas/tests/frame/test_nonunique_indexes.py
index 4faa0d0e3f941..32ead406a3e86 100644
--- a/pandas/tests/frame/test_nonunique_indexes.py
+++ b/pandas/tests/frame/test_nonunique_indexes.py
@@ -3,16 +3,14 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, date_range
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
-class TestDataFrameNonuniqueIndexes(TestData):
+class TestDataFrameNonuniqueIndexes:
     def test_column_dups_operations(self):
         def check(result, expected=None):
             if expected is not None:
-                assert_frame_equal(result, expected)
+                tm.assert_frame_equal(result, expected)
             result.dtypes
             str(result)
 
@@ -117,7 +115,7 @@ def check(result, expected=None):
             [[4.0, 5.0, "bah", 3], [4.0, 5.0, "bah", 3], [4.0, 5.0, "bah", 3]],
             columns=["new_col", "new_col", "string", "foo2"],
         )
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # dup across dtypes
         df = DataFrame(
@@ -199,7 +197,7 @@ def check(result, expected=None):
                 "QT_Close",
             ],
         ).set_index(["STK_ID", "RPT_Date"], drop=False)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # reindex is invalid!
         df = DataFrame(
@@ -287,7 +285,7 @@ def test_column_dups2(self):
         expected = df.take([0, 1, 1], axis=1)
         df2 = df.take([2, 0, 1, 2, 1], axis=1)
         result = df2.drop("C", axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # dropna
         df = DataFrame(
@@ -308,12 +306,12 @@ def test_column_dups2(self):
         df.columns = ["A", "A", "B", "C"]
 
         result = df.dropna(subset=["A", "C"], how="all")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_column_dups_indexing(self):
         def check(result, expected=None):
             if expected is not None:
-                assert_frame_equal(result, expected)
+                tm.assert_frame_equal(result, expected)
             result.dtypes
             str(result)
 
@@ -351,7 +349,7 @@ def check(result, expected=None):
         df2 = DataFrame([1, 2, 3], index=[1, 2, 3])
         expected = DataFrame([0, 2, 0, 2, 2], index=[1, 1, 2, 2, 3])
         result = df1.sub(df2)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # equality
         df1 = DataFrame([[1, 2], [2, np.nan], [3, 4], [4, 4]], columns=["A", "B"])
@@ -368,7 +366,7 @@ def check(result, expected=None):
             [[False, True], [True, False], [False, False], [True, False]],
             columns=["A", "A"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # mixed column selection
         # GH 5639
@@ -412,7 +410,7 @@ def test_column_dups_indexing2(self):
         )
         result = df.B - df.A
         expected = Series(1, index=[2, 2, 3, 3, 4])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame(
             {
@@ -423,7 +421,7 @@ def test_column_dups_indexing2(self):
         )
         result = df.B - df.A
         expected = Series(pd.Timedelta("9 hours"), index=[2, 2, 3, 3, 4])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_columns_with_dups(self):
         # GH 3468 related
@@ -433,20 +431,20 @@ def test_columns_with_dups(self):
         df.columns = ["a", "a.1"]
         str(df)
         expected = DataFrame([[1, 2]], columns=["a", "a.1"])
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         df = DataFrame([[1, 2, 3]], columns=["b", "a", "a"])
         df.columns = ["b", "a", "a.1"]
         str(df)
         expected = DataFrame([[1, 2, 3]], columns=["b", "a", "a.1"])
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # with a dup index
         df = DataFrame([[1, 2]], columns=["a", "a"])
         df.columns = ["b", "b"]
         str(df)
         expected = DataFrame([[1, 2]], columns=["b", "b"])
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # multi-dtype
         df = DataFrame(
@@ -458,13 +456,13 @@ def test_columns_with_dups(self):
         expected = DataFrame(
             [[1, 2, 1.0, 2.0, 3.0, "foo", "bar"]], columns=list("ABCDEFG")
         )
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         df = DataFrame([[1, 2, "foo", "bar"]], columns=["a", "a", "a", "a"])
         df.columns = ["a", "a.1", "a.2", "a.3"]
         str(df)
         expected = DataFrame([[1, 2, "foo", "bar"]], columns=["a", "a.1", "a.2", "a.3"])
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # dups across blocks
         df_float = DataFrame(np.random.randn(10, 3), dtype="float64")
@@ -488,7 +486,7 @@ def test_columns_with_dups(self):
         rs = DataFrame(vals, columns=["A", "A", "B"])
         xp = DataFrame(vals)
         xp.columns = ["A", "A", "B"]
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
     def test_values_duplicates(self):
         df = DataFrame(
@@ -507,14 +505,14 @@ def test_set_value_by_index(self):
         expected = df.iloc[:, 2]
 
         df.iloc[:, 0] = 3
-        assert_series_equal(df.iloc[:, 2], expected)
+        tm.assert_series_equal(df.iloc[:, 2], expected)
 
         df = DataFrame(np.arange(9).reshape(3, 3).T)
         df.columns = [2, float(2), str(2)]
         expected = df.iloc[:, 1]
 
         df.iloc[:, 0] = 3
-        assert_series_equal(df.iloc[:, 1], expected)
+        tm.assert_series_equal(df.iloc[:, 1], expected)
 
     def test_insert_with_columns_dups(self):
         # GH 14291
@@ -525,4 +523,4 @@ def test_insert_with_columns_dups(self):
         exp = pd.DataFrame(
             [["a", "d", "g"], ["b", "e", "h"], ["c", "f", "i"]], columns=["A", "A", "A"]
         )
-        assert_frame_equal(df, exp)
+        tm.assert_frame_equal(df, exp)
diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py
index bffdf17a49750..162f3c114fa5d 100644
--- a/pandas/tests/frame/test_operators.py
+++ b/pandas/tests/frame/test_operators.py
@@ -6,14 +6,9 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series
+import pandas._testing as tm
 import pandas.core.common as com
 from pandas.tests.frame.common import _check_mixed_float
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_frame_equal,
-    assert_numpy_array_equal,
-    assert_series_equal,
-)
 
 
 class TestDataFrameUnaryOperators:
@@ -31,8 +26,8 @@ class TestDataFrameUnaryOperators:
         ],
     )
     def test_neg_numeric(self, df, expected):
-        assert_frame_equal(-df, expected)
-        assert_series_equal(-df["a"], expected["a"])
+        tm.assert_frame_equal(-df, expected)
+        tm.assert_series_equal(-df["a"], expected["a"])
 
     @pytest.mark.parametrize(
         "df, expected",
@@ -45,8 +40,8 @@ def test_neg_object(self, df, expected):
         # GH#21380
         df = pd.DataFrame({"a": df})
         expected = pd.DataFrame({"a": expected})
-        assert_frame_equal(-df, expected)
-        assert_series_equal(-df["a"], expected["a"])
+        tm.assert_frame_equal(-df, expected)
+        tm.assert_series_equal(-df["a"], expected["a"])
 
     @pytest.mark.parametrize(
         "df",
@@ -64,7 +59,28 @@ def test_neg_raises(self, df):
     def test_invert(self, float_frame):
         df = float_frame
 
-        assert_frame_equal(-(df < 0), ~(df < 0))
+        tm.assert_frame_equal(-(df < 0), ~(df < 0))
+
+    def test_invert_mixed(self):
+        shape = (10, 5)
+        df = pd.concat(
+            [
+                pd.DataFrame(np.zeros(shape, dtype="bool")),
+                pd.DataFrame(np.zeros(shape, dtype=int)),
+            ],
+            axis=1,
+            ignore_index=True,
+        )
+        result = ~df
+        expected = pd.concat(
+            [
+                pd.DataFrame(np.ones(shape, dtype="bool")),
+                pd.DataFrame(-np.ones(shape, dtype=int)),
+            ],
+            axis=1,
+            ignore_index=True,
+        )
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "df",
@@ -76,8 +92,8 @@ def test_invert(self, float_frame):
     )
     def test_pos_numeric(self, df):
         # GH#16073
-        assert_frame_equal(+df, df)
-        assert_series_equal(+df["a"], df["a"])
+        tm.assert_frame_equal(+df, df)
+        tm.assert_series_equal(+df["a"], df["a"])
 
     @pytest.mark.parametrize(
         "df",
@@ -93,8 +109,8 @@ def test_pos_numeric(self, df):
     )
     def test_pos_object(self, df):
         # GH#21380
-        assert_frame_equal(+df, df)
-        assert_series_equal(+df["a"], df["a"])
+        tm.assert_frame_equal(+df, df)
+        tm.assert_series_equal(+df["a"], df["a"])
 
     @pytest.mark.parametrize(
         "df", [pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])})]
@@ -115,29 +131,30 @@ def test_logical_ops_empty_frame(self):
         df = DataFrame(index=[1])
 
         result = df & df
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         result = df | df
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         df2 = DataFrame(index=[1, 2])
         result = df & df2
-        assert_frame_equal(result, df2)
+        tm.assert_frame_equal(result, df2)
 
         dfa = DataFrame(index=[1], columns=["A"])
 
         result = dfa & dfa
-        assert_frame_equal(result, dfa)
+        expected = DataFrame(False, index=[1], columns=["A"])
+        tm.assert_frame_equal(result, expected)
 
     def test_logical_ops_bool_frame(self):
         # GH#5808
         df1a_bool = DataFrame(True, index=[1], columns=["A"])
 
         result = df1a_bool & df1a_bool
-        assert_frame_equal(result, df1a_bool)
+        tm.assert_frame_equal(result, df1a_bool)
 
         result = df1a_bool | df1a_bool
-        assert_frame_equal(result, df1a_bool)
+        tm.assert_frame_equal(result, df1a_bool)
 
     def test_logical_ops_int_frame(self):
         # GH#5808
@@ -145,7 +162,11 @@ def test_logical_ops_int_frame(self):
         df1a_bool = DataFrame(True, index=[1], columns=["A"])
 
         result = df1a_int | df1a_bool
-        assert_frame_equal(result, df1a_int)
+        tm.assert_frame_equal(result, df1a_bool)
+
+        # Check that this matches Series behavior
+        res_ser = df1a_int["A"] | df1a_bool["A"]
+        tm.assert_series_equal(res_ser, df1a_bool["A"])
 
     def test_logical_ops_invalid(self):
         # GH#5808
@@ -167,13 +188,13 @@ def _check_bin_op(op):
                 op(df1.values, df2.values), index=df1.index, columns=df1.columns
             )
             assert result.values.dtype == np.bool_
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         def _check_unary_op(op):
             result = op(df1)
             expected = DataFrame(op(df1.values), index=df1.index, columns=df1.columns)
             assert result.values.dtype == np.bool_
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         df1 = {
             "a": {"a": True, "b": False, "c": False, "d": True, "e": True},
@@ -207,16 +228,52 @@ def test_logical_with_nas(self):
         # bool comparisons should return bool
         result = d["a"] | d["b"]
         expected = Series([False, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH4604, automatic casting here
         result = d["a"].fillna(False) | d["b"]
         expected = Series([True, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = d["a"].fillna(False, downcast=False) | d["b"]
         expected = Series([True, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "left, right, op, expected",
+        [
+            (
+                [True, False, np.nan],
+                [True, False, True],
+                operator.and_,
+                [True, False, False],
+            ),
+            (
+                [True, False, True],
+                [True, False, np.nan],
+                operator.and_,
+                [True, False, False],
+            ),
+            (
+                [True, False, np.nan],
+                [True, False, True],
+                operator.or_,
+                [True, False, False],
+            ),
+            (
+                [True, False, True],
+                [True, False, np.nan],
+                operator.or_,
+                [True, False, True],
+            ),
+        ],
+    )
+    def test_logical_operators_nans(self, left, right, op, expected):
+        # GH 13896
+        result = op(DataFrame(left), DataFrame(right))
+        expected = DataFrame(expected)
+
+        tm.assert_frame_equal(result, expected)
 
 
 class TestDataFrameOperators:
@@ -234,18 +291,18 @@ def test_operators_none_as_na(self, op):
         result = op(df, 3)
         expected = op(filled, 3).astype(object)
         expected[com.isna(expected)] = None
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = op(df, df)
         expected = op(filled, filled).astype(object)
         expected[com.isna(expected)] = None
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = op(df, df.fillna(7))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = op(df.fillna(7), df)
-        assert_frame_equal(result, expected, check_dtype=False)
+        tm.assert_frame_equal(result, expected, check_dtype=False)
 
     @pytest.mark.parametrize("op,res", [("__eq__", False), ("__ne__", True)])
     # TODO: not sure what's correct here.
@@ -283,7 +340,7 @@ def test_binary_ops_align(self):
             expected = pd.concat(
                 [opa(df.loc[idx[:, :, i], :], v) for i, v in x.items()]
             ).sort_index()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             x = Series([1.0, 10.0], ["two", "three"])
             result = getattr(df, op)(x, level="second", axis=0)
@@ -293,7 +350,7 @@ def test_binary_ops_align(self):
                 .reindex_like(df)
                 .sort_index()
             )
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         # GH9463 (alignment level of dataframe with series)
 
@@ -319,11 +376,11 @@ def test_binary_ops_align(self):
         )
 
         for res in [res1, res2]:
-            assert_frame_equal(res, exp)
+            tm.assert_frame_equal(res, exp)
 
         exp.columns.names = ["lvl0", "lvl1"]
         for res in [res3, res4, res5, res6]:
-            assert_frame_equal(res, exp)
+            tm.assert_frame_equal(res, exp)
 
     def test_dti_tz_convert_to_utc(self):
         base = pd.DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03"], tz="UTC")
@@ -333,7 +390,7 @@ def test_dti_tz_convert_to_utc(self):
         df1 = DataFrame({"A": [1, 2]}, index=idx1)
         df2 = DataFrame({"A": [1, 1]}, index=idx2)
         exp = DataFrame({"A": [np.nan, 3, np.nan]}, index=base)
-        assert_frame_equal(df1 + df2, exp)
+        tm.assert_frame_equal(df1 + df2, exp)
 
     def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
         frame_copy = float_frame.reindex(float_frame.index[::2])
@@ -379,7 +436,7 @@ def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
         # out of order
         reverse = float_frame.reindex(columns=float_frame.columns[::-1])
 
-        assert_frame_equal(reverse + float_frame, float_frame * 2)
+        tm.assert_frame_equal(reverse + float_frame, float_frame * 2)
 
         # mix vs float64, upcast
         added = float_frame + mixed_float_frame
@@ -395,7 +452,7 @@ def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
         added = float_frame + mixed_int_frame
         _check_mixed_float(added, dtype="float64")
 
-    def test_combineSeries(
+    def test_combine_series(
         self, float_frame, mixed_float_frame, mixed_int_frame, datetime_frame
     ):
 
@@ -405,7 +462,7 @@ def test_combineSeries(
         added = float_frame + series
 
         for key, s in added.items():
-            assert_series_equal(s, float_frame[key] + series[key])
+            tm.assert_series_equal(s, float_frame[key] + series[key])
 
         larger_series = series.to_dict()
         larger_series["E"] = 1
@@ -413,7 +470,7 @@ def test_combineSeries(
         larger_added = float_frame + larger_series
 
         for key, s in float_frame.items():
-            assert_series_equal(larger_added[key], s + series[key])
+            tm.assert_series_equal(larger_added[key], s + series[key])
         assert "E" in larger_added
         assert np.isnan(larger_added["E"]).all()
 
@@ -427,6 +484,7 @@ def test_combineSeries(
         added = mixed_float_frame + series.astype("float16")
         _check_mixed_float(added, dtype=dict(C=None))
 
+        # FIXME: don't leave commented-out
         # these raise with numexpr.....as we are adding an int64 to an
         # uint64....weird vs int
 
@@ -447,7 +505,7 @@ def test_combineSeries(
 
         for key, col in datetime_frame.items():
             result = col + ts
-            assert_series_equal(added[key], result, check_names=False)
+            tm.assert_series_equal(added[key], result, check_names=False)
             assert added[key].name == key
             if col.name == ts.name:
                 assert result.name == "A"
@@ -461,21 +519,21 @@ def test_combineSeries(
 
         smaller_ts = ts[:-5]
         smaller_added2 = datetime_frame.add(smaller_ts, axis="index")
-        assert_frame_equal(smaller_added, smaller_added2)
+        tm.assert_frame_equal(smaller_added, smaller_added2)
 
         # length 0, result is all-nan
         result = datetime_frame.add(ts[:0], axis="index")
         expected = DataFrame(
             np.nan, index=datetime_frame.index, columns=datetime_frame.columns
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Frame is all-nan
         result = datetime_frame[:0].add(ts, axis="index")
         expected = DataFrame(
             np.nan, index=datetime_frame.index, columns=datetime_frame.columns
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # empty but with non-empty index
         frame = datetime_frame[:1].reindex(columns=[])
@@ -529,6 +587,16 @@ def test_comp(func):
         test_comp(operator.ge)
         test_comp(operator.le)
 
+    def test_strings_to_numbers_comparisons_raises(self, compare_operators_no_eq_ne):
+        # GH 11565
+        df = DataFrame(
+            {x: {"x": "foo", "y": "bar", "z": "baz"} for x in ["a", "b", "c"]}
+        )
+
+        f = getattr(operator, compare_operators_no_eq_ne)
+        with pytest.raises(TypeError):
+            f(df, 0)
+
     def test_comparison_protected_from_errstate(self):
         missing_df = tm.makeDataFrame()
         missing_df.iloc[0]["A"] = np.nan
@@ -552,10 +620,10 @@ def test_boolean_comparison(self):
         # gt
         expected = DataFrame([[False, False], [False, True], [True, True]])
         result = df > b
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.values > b
-        assert_numpy_array_equal(result, expected.values)
+        tm.assert_numpy_array_equal(result, expected.values)
 
         msg1d = "Unable to coerce to Series, length must be 2: given 3"
         msg2d = "Unable to coerce to DataFrame, shape must be"
@@ -570,10 +638,10 @@ def test_boolean_comparison(self):
 
         # broadcasts like ndarray (GH#23000)
         result = df > b_r
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.values > b_r
-        assert_numpy_array_equal(result, expected.values)
+        tm.assert_numpy_array_equal(result, expected.values)
 
         with pytest.raises(ValueError, match=msg2d):
             df > b_c
@@ -584,7 +652,7 @@ def test_boolean_comparison(self):
         # ==
         expected = DataFrame([[False, False], [True, False], [False, False]])
         result = df == b
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         with pytest.raises(ValueError, match=msg1d):
             result = df == lst
@@ -594,10 +662,10 @@ def test_boolean_comparison(self):
 
         # broadcasts like ndarray (GH#23000)
         result = df == b_r
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.values == b_r
-        assert_numpy_array_equal(result, expected.values)
+        tm.assert_numpy_array_equal(result, expected.values)
 
         with pytest.raises(ValueError, match=msg2d):
             df == b_c
@@ -633,8 +701,8 @@ def test_combine_generic(self, float_frame):
             float_frame.loc[float_frame.index[:-5], ["A", "B", "C"]].reindex_like(chunk)
             * 2
         )
-        assert_frame_equal(chunk, exp)
-        assert_frame_equal(chunk2, exp)
+        tm.assert_frame_equal(chunk, exp)
+        tm.assert_frame_equal(chunk2, exp)
 
     def test_inplace_ops_alignment(self):
 
@@ -664,9 +732,9 @@ def test_inplace_ops_alignment(self):
         X[block1] += Z[block1]
         result4 = X.reindex(columns=subs)
 
-        assert_frame_equal(result1, result2)
-        assert_frame_equal(result1, result3)
-        assert_frame_equal(result1, result4)
+        tm.assert_frame_equal(result1, result2)
+        tm.assert_frame_equal(result1, result3)
+        tm.assert_frame_equal(result1, result4)
 
         # sub
         X = X_orig.copy()
@@ -681,9 +749,9 @@ def test_inplace_ops_alignment(self):
         X[block1] -= Z[block1]
         result4 = X.reindex(columns=subs)
 
-        assert_frame_equal(result1, result2)
-        assert_frame_equal(result1, result3)
-        assert_frame_equal(result1, result4)
+        tm.assert_frame_equal(result1, result2)
+        tm.assert_frame_equal(result1, result3)
+        tm.assert_frame_equal(result1, result4)
 
     def test_inplace_ops_identity(self):
 
@@ -696,16 +764,16 @@ def test_inplace_ops_identity(self):
         s = s_orig.copy()
         s2 = s
         s += 1
-        assert_series_equal(s, s2)
-        assert_series_equal(s_orig + 1, s)
+        tm.assert_series_equal(s, s2)
+        tm.assert_series_equal(s_orig + 1, s)
         assert s is s2
         assert s._data is s2._data
 
         df = df_orig.copy()
         df2 = df
         df += 1
-        assert_frame_equal(df, df2)
-        assert_frame_equal(df_orig + 1, df)
+        tm.assert_frame_equal(df, df2)
+        tm.assert_frame_equal(df_orig + 1, df)
         assert df is df2
         assert df._data is df2._data
 
@@ -713,14 +781,14 @@ def test_inplace_ops_identity(self):
         s = s_orig.copy()
         s2 = s
         s += 1.5
-        assert_series_equal(s, s2)
-        assert_series_equal(s_orig + 1.5, s)
+        tm.assert_series_equal(s, s2)
+        tm.assert_series_equal(s_orig + 1.5, s)
 
         df = df_orig.copy()
         df2 = df
         df += 1.5
-        assert_frame_equal(df, df2)
-        assert_frame_equal(df_orig + 1.5, df)
+        tm.assert_frame_equal(df, df2)
+        tm.assert_frame_equal(df_orig + 1.5, df)
         assert df is df2
         assert df._data is df2._data
 
@@ -731,16 +799,16 @@ def test_inplace_ops_identity(self):
         df2 = df
         df["A"] += 1
         expected = DataFrame({"A": arr.copy() + 1, "B": "foo"})
-        assert_frame_equal(df, expected)
-        assert_frame_equal(df2, expected)
+        tm.assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df2, expected)
         assert df._data is df2._data
 
         df = df_orig.copy()
         df2 = df
         df["A"] += 1.5
         expected = DataFrame({"A": arr.copy() + 1.5, "B": "foo"})
-        assert_frame_equal(df, expected)
-        assert_frame_equal(df2, expected)
+        tm.assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df2, expected)
         assert df._data is df2._data
 
     @pytest.mark.parametrize(
@@ -778,7 +846,7 @@ def test_inplace_ops_identity2(self, op):
         # no id change and value is correct
         getattr(df, iop)(operand)
         expected = getattr(df_copy, op)(operand)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
         expected = id(df)
         assert id(df) == expected
 
@@ -796,10 +864,10 @@ def test_alignment_non_pandas(self):
         ]:
 
             tm.assert_series_equal(
-                align(df, val, "index"), Series([1, 2, 3], index=df.index)
+                align(df, val, "index")[1], Series([1, 2, 3], index=df.index)
             )
             tm.assert_series_equal(
-                align(df, val, "columns"), Series([1, 2, 3], index=df.columns)
+                align(df, val, "columns")[1], Series([1, 2, 3], index=df.columns)
             )
 
         # length mismatch
@@ -814,10 +882,11 @@ def test_alignment_non_pandas(self):
 
         val = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
         tm.assert_frame_equal(
-            align(df, val, "index"), DataFrame(val, index=df.index, columns=df.columns)
+            align(df, val, "index")[1],
+            DataFrame(val, index=df.index, columns=df.columns),
         )
         tm.assert_frame_equal(
-            align(df, val, "columns"),
+            align(df, val, "columns")[1],
             DataFrame(val, index=df.index, columns=df.columns),
         )
 
@@ -841,44 +910,3 @@ def test_no_warning(self, all_arithmetic_operators):
         b = df["B"]
         with tm.assert_produces_warning(None):
             getattr(df, all_arithmetic_operators)(b, 0)
-
-
-class TestTranspose:
-    def test_transpose_tzaware_1col_single_tz(self):
-        # GH#26825
-        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
-
-        df = pd.DataFrame(dti)
-        assert (df.dtypes == dti.dtype).all()
-        res = df.T
-        assert (res.dtypes == dti.dtype).all()
-
-    def test_transpose_tzaware_2col_single_tz(self):
-        # GH#26825
-        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
-
-        df3 = pd.DataFrame({"A": dti, "B": dti})
-        assert (df3.dtypes == dti.dtype).all()
-        res3 = df3.T
-        assert (res3.dtypes == dti.dtype).all()
-
-    def test_transpose_tzaware_2col_mixed_tz(self):
-        # GH#26825
-        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
-        dti2 = dti.tz_convert("US/Pacific")
-
-        df4 = pd.DataFrame({"A": dti, "B": dti2})
-        assert (df4.dtypes == [dti.dtype, dti2.dtype]).all()
-        assert (df4.T.dtypes == object).all()
-        tm.assert_frame_equal(df4.T.T, df4)
-
-    def test_transpose_object_to_tzaware_mixed_tz(self):
-        # GH#26825
-        dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
-        dti2 = dti.tz_convert("US/Pacific")
-
-        # mixed all-tzaware dtypes
-        df2 = pd.DataFrame([dti, dti2])
-        assert (df2.dtypes == object).all()
-        res2 = df2.T
-        assert (res2.dtypes == [dti.dtype, dti2.dtype]).all()
diff --git a/pandas/tests/frame/test_period.py b/pandas/tests/frame/test_period.py
index a545db3365e36..a6b2b334d3ec8 100644
--- a/pandas/tests/frame/test_period.py
+++ b/pandas/tests/frame/test_period.py
@@ -14,7 +14,7 @@
     period_range,
     to_datetime,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _permute(obj):
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index 82c197ac054f0..bf9eeb532b43b 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -8,13 +8,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, date_range
+import pandas._testing as tm
 from pandas.core.computation.check import _NUMEXPR_INSTALLED
-from pandas.tests.frame.common import TestData
-from pandas.util.testing import (
-    assert_frame_equal,
-    assert_series_equal,
-    makeCustomDataframe as mkdf,
-)
 
 PARSERS = "python", "pandas"
 ENGINES = "python", pytest.param("numexpr", marks=td.skip_if_no_ne)
@@ -32,7 +27,7 @@ def engine(request):
 
 def skip_if_no_pandas_parser(parser):
     if parser != "pandas":
-        pytest.skip("cannot evaluate with parser {0!r}".format(parser))
+        pytest.skip(f"cannot evaluate with parser {repr(parser)}")
 
 
 class TestCompat:
@@ -47,34 +42,34 @@ def test_query_default(self):
         # this should always work, whether _NUMEXPR_INSTALLED or not
         df = self.df
         result = df.query("A>0")
-        assert_frame_equal(result, self.expected1)
+        tm.assert_frame_equal(result, self.expected1)
         result = df.eval("A+1")
-        assert_series_equal(result, self.expected2, check_names=False)
+        tm.assert_series_equal(result, self.expected2, check_names=False)
 
     def test_query_None(self):
 
         df = self.df
         result = df.query("A>0", engine=None)
-        assert_frame_equal(result, self.expected1)
+        tm.assert_frame_equal(result, self.expected1)
         result = df.eval("A+1", engine=None)
-        assert_series_equal(result, self.expected2, check_names=False)
+        tm.assert_series_equal(result, self.expected2, check_names=False)
 
     def test_query_python(self):
 
         df = self.df
         result = df.query("A>0", engine="python")
-        assert_frame_equal(result, self.expected1)
+        tm.assert_frame_equal(result, self.expected1)
         result = df.eval("A+1", engine="python")
-        assert_series_equal(result, self.expected2, check_names=False)
+        tm.assert_series_equal(result, self.expected2, check_names=False)
 
     def test_query_numexpr(self):
 
         df = self.df
         if _NUMEXPR_INSTALLED:
             result = df.query("A>0", engine="numexpr")
-            assert_frame_equal(result, self.expected1)
+            tm.assert_frame_equal(result, self.expected1)
             result = df.eval("A+1", engine="numexpr")
-            assert_series_equal(result, self.expected2, check_names=False)
+            tm.assert_series_equal(result, self.expected2, check_names=False)
         else:
             with pytest.raises(ImportError):
                 df.query("A>0", engine="numexpr")
@@ -82,52 +77,56 @@ def test_query_numexpr(self):
                 df.eval("A+1", engine="numexpr")
 
 
-class TestDataFrameEval(TestData):
-    def test_ops(self):
+class TestDataFrameEval:
+
+    # smaller hits python, larger hits numexpr
+    @pytest.mark.parametrize("n", [4, 4000])
+    @pytest.mark.parametrize(
+        "op_str,op,rop",
+        [
+            ("+", "__add__", "__radd__"),
+            ("-", "__sub__", "__rsub__"),
+            ("*", "__mul__", "__rmul__"),
+            ("/", "__truediv__", "__rtruediv__"),
+        ],
+    )
+    def test_ops(self, op_str, op, rop, n):
 
         # tst ops and reversed ops in evaluation
         # GH7198
 
-        # smaller hits python, larger hits numexpr
-        for n in [4, 4000]:
-
-            df = DataFrame(1, index=range(n), columns=list("abcd"))
-            df.iloc[0] = 2
-            m = df.mean()
+        df = DataFrame(1, index=range(n), columns=list("abcd"))
+        df.iloc[0] = 2
+        m = df.mean()
 
-            for op_str, op, rop in [
-                ("+", "__add__", "__radd__"),
-                ("-", "__sub__", "__rsub__"),
-                ("*", "__mul__", "__rmul__"),
-                ("/", "__truediv__", "__rtruediv__"),
-            ]:
-
-                base = DataFrame(  # noqa
-                    np.tile(m.values, n).reshape(n, -1), columns=list("abcd")
-                )
+        base = DataFrame(  # noqa
+            np.tile(m.values, n).reshape(n, -1), columns=list("abcd")
+        )
 
-                expected = eval("base{op}df".format(op=op_str))
+        expected = eval(f"base {op_str} df")
 
-                # ops as strings
-                result = eval("m{op}df".format(op=op_str))
-                assert_frame_equal(result, expected)
+        # ops as strings
+        result = eval(f"m {op_str} df")
+        tm.assert_frame_equal(result, expected)
 
-                # these are commutative
-                if op in ["+", "*"]:
-                    result = getattr(df, op)(m)
-                    assert_frame_equal(result, expected)
+        # these are commutative
+        if op in ["+", "*"]:
+            result = getattr(df, op)(m)
+            tm.assert_frame_equal(result, expected)
 
-                # these are not
-                elif op in ["-", "/"]:
-                    result = getattr(df, rop)(m)
-                    assert_frame_equal(result, expected)
+        # these are not
+        elif op in ["-", "/"]:
+            result = getattr(df, rop)(m)
+            tm.assert_frame_equal(result, expected)
 
-        # GH7192
+    def test_dataframe_sub_numexpr_path(self):
+        # GH7192: Note we need a large number of rows to ensure this
+        #  goes through the numexpr path
         df = DataFrame(dict(A=np.random.randn(25000)))
         df.iloc[0:5] = np.nan
         expected = 1 - np.isnan(df.iloc[0:25])
         result = (1 - np.isnan(df)).iloc[0:25]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_query_non_str(self):
         # GH 11485
@@ -172,41 +171,41 @@ def test_query_with_named_multiindex(self, parser, engine):
         res1 = df.query('color == "red"', parser=parser, engine=engine)
         res2 = df.query('"red" == color', parser=parser, engine=engine)
         exp = df[ind == "red"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # inequality
         res1 = df.query('color != "red"', parser=parser, engine=engine)
         res2 = df.query('"red" != color', parser=parser, engine=engine)
         exp = df[ind != "red"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # list equality (really just set membership)
         res1 = df.query('color == ["red"]', parser=parser, engine=engine)
         res2 = df.query('["red"] == color', parser=parser, engine=engine)
         exp = df[ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('color != ["red"]', parser=parser, engine=engine)
         res2 = df.query('["red"] != color', parser=parser, engine=engine)
         exp = df[~ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # in/not in ops
         res1 = df.query('["red"] in color', parser=parser, engine=engine)
         res2 = df.query('"red" in color', parser=parser, engine=engine)
         exp = df[ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('["red"] not in color', parser=parser, engine=engine)
         res2 = df.query('"red" not in color', parser=parser, engine=engine)
         exp = df[~ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
     def test_query_with_unnamed_multiindex(self, parser, engine):
         skip_if_no_pandas_parser(parser)
@@ -219,82 +218,82 @@ def test_query_with_unnamed_multiindex(self, parser, engine):
         res1 = df.query('ilevel_0 == "red"', parser=parser, engine=engine)
         res2 = df.query('"red" == ilevel_0', parser=parser, engine=engine)
         exp = df[ind == "red"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # inequality
         res1 = df.query('ilevel_0 != "red"', parser=parser, engine=engine)
         res2 = df.query('"red" != ilevel_0', parser=parser, engine=engine)
         exp = df[ind != "red"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # list equality (really just set membership)
         res1 = df.query('ilevel_0 == ["red"]', parser=parser, engine=engine)
         res2 = df.query('["red"] == ilevel_0', parser=parser, engine=engine)
         exp = df[ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('ilevel_0 != ["red"]', parser=parser, engine=engine)
         res2 = df.query('["red"] != ilevel_0', parser=parser, engine=engine)
         exp = df[~ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # in/not in ops
         res1 = df.query('["red"] in ilevel_0', parser=parser, engine=engine)
         res2 = df.query('"red" in ilevel_0', parser=parser, engine=engine)
         exp = df[ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('["red"] not in ilevel_0', parser=parser, engine=engine)
         res2 = df.query('"red" not in ilevel_0', parser=parser, engine=engine)
         exp = df[~ind.isin(["red"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # ## LEVEL 1
         ind = Series(df.index.get_level_values(1).values, index=index)
         res1 = df.query('ilevel_1 == "eggs"', parser=parser, engine=engine)
         res2 = df.query('"eggs" == ilevel_1', parser=parser, engine=engine)
         exp = df[ind == "eggs"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # inequality
         res1 = df.query('ilevel_1 != "eggs"', parser=parser, engine=engine)
         res2 = df.query('"eggs" != ilevel_1', parser=parser, engine=engine)
         exp = df[ind != "eggs"]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # list equality (really just set membership)
         res1 = df.query('ilevel_1 == ["eggs"]', parser=parser, engine=engine)
         res2 = df.query('["eggs"] == ilevel_1', parser=parser, engine=engine)
         exp = df[ind.isin(["eggs"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('ilevel_1 != ["eggs"]', parser=parser, engine=engine)
         res2 = df.query('["eggs"] != ilevel_1', parser=parser, engine=engine)
         exp = df[~ind.isin(["eggs"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         # in/not in ops
         res1 = df.query('["eggs"] in ilevel_1', parser=parser, engine=engine)
         res2 = df.query('"eggs" in ilevel_1', parser=parser, engine=engine)
         exp = df[ind.isin(["eggs"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
         res1 = df.query('["eggs"] not in ilevel_1', parser=parser, engine=engine)
         res2 = df.query('"eggs" not in ilevel_1', parser=parser, engine=engine)
         exp = df[~ind.isin(["eggs"])]
-        assert_frame_equal(res1, exp)
-        assert_frame_equal(res2, exp)
+        tm.assert_frame_equal(res1, exp)
+        tm.assert_frame_equal(res2, exp)
 
     def test_query_with_partially_named_multiindex(self, parser, engine):
         skip_if_no_pandas_parser(parser)
@@ -308,27 +307,29 @@ def test_query_with_partially_named_multiindex(self, parser, engine):
             df.index.get_level_values("rating").values, index=index, name="rating"
         )
         exp = df[ind == 1]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
         res = df.query("rating != 1", parser=parser, engine=engine)
         ind = Series(
             df.index.get_level_values("rating").values, index=index, name="rating"
         )
         exp = df[ind != 1]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
         res = df.query('ilevel_0 == "red"', parser=parser, engine=engine)
         ind = Series(df.index.get_level_values(0).values, index=index)
         exp = df[ind == "red"]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
         res = df.query('ilevel_0 != "red"', parser=parser, engine=engine)
         ind = Series(df.index.get_level_values(0).values, index=index)
         exp = df[ind != "red"]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
     def test_query_multiindex_get_index_resolvers(self):
-        df = mkdf(10, 3, r_idx_nlevels=2, r_idx_names=["spam", "eggs"])
+        df = tm.makeCustomDataframe(
+            10, 3, r_idx_nlevels=2, r_idx_names=["spam", "eggs"]
+        )
         resolvers = df._get_index_resolvers()
 
         def to_series(mi, level):
@@ -349,7 +350,7 @@ def to_series(mi, level):
             if isinstance(v, Index):
                 assert v.is_(expected[k])
             elif isinstance(v, Series):
-                assert_series_equal(v, expected[k])
+                tm.assert_series_equal(v, expected[k])
             else:
                 raise AssertionError("object must be a Series or Index")
 
@@ -376,7 +377,7 @@ def test_date_query_with_attribute_access(self):
             "@df.dates1 < 20130101 < @df.dates3", engine=engine, parser=parser
         )
         expec = df[(df.dates1 < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_query_no_attribute_access(self):
         engine, parser = self.engine, self.parser
@@ -386,7 +387,7 @@ def test_date_query_no_attribute_access(self):
         df["dates3"] = date_range("1/1/2014", periods=5)
         res = df.query("dates1 < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.dates1 < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_query_with_NaT(self):
         engine, parser = self.engine, self.parser
@@ -399,7 +400,7 @@ def test_date_query_with_NaT(self):
         df.loc[np.random.rand(n) > 0.5, "dates3"] = pd.NaT
         res = df.query("dates1 < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.dates1 < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query(self):
         engine, parser = self.engine, self.parser
@@ -410,7 +411,7 @@ def test_date_index_query(self):
         df.set_index("dates1", inplace=True, drop=True)
         res = df.query("index < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query_with_NaT(self):
         engine, parser = self.engine, self.parser
@@ -422,7 +423,7 @@ def test_date_index_query_with_NaT(self):
         df.set_index("dates1", inplace=True, drop=True)
         res = df.query("index < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query_with_NaT_duplicates(self):
         engine, parser = self.engine, self.parser
@@ -435,7 +436,7 @@ def test_date_index_query_with_NaT_duplicates(self):
         df.set_index("dates1", inplace=True, drop=True)
         res = df.query("dates1 < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index.to_series() < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_query_with_non_date(self):
         engine, parser = self.engine, self.parser
@@ -449,13 +450,11 @@ def test_date_query_with_non_date(self):
         assert len(result) == 0
 
         result = df.query("dates != nondate", parser=parser, engine=engine)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         for op in ["<", ">", "<=", ">="]:
             with pytest.raises(TypeError):
-                df.query(
-                    "dates {op} nondate".format(op=op), parser=parser, engine=engine
-                )
+                df.query(f"dates {op} nondate", parser=parser, engine=engine)
 
     def test_query_syntax_error(self):
         engine, parser = self.engine, self.parser
@@ -474,18 +473,20 @@ def test_query_scope(self):
         a, b = 1, 2  # noqa
         res = df.query("a > b", engine=engine, parser=parser)
         expected = df[df.a > df.b]
-        assert_frame_equal(res, expected)
+        tm.assert_frame_equal(res, expected)
 
         res = df.query("@a > b", engine=engine, parser=parser)
         expected = df[a > df.b]
-        assert_frame_equal(res, expected)
+        tm.assert_frame_equal(res, expected)
 
         # no local variable c
-        with pytest.raises(UndefinedVariableError):
+        with pytest.raises(
+            UndefinedVariableError, match="local variable 'c' is not defined"
+        ):
             df.query("@a > b > @c", engine=engine, parser=parser)
 
         # no column named 'c'
-        with pytest.raises(UndefinedVariableError):
+        with pytest.raises(UndefinedVariableError, match="name 'c' is not defined"):
             df.query("@a > b > c", engine=engine, parser=parser)
 
     def test_query_doesnt_pickup_local(self):
@@ -496,7 +497,7 @@ def test_query_doesnt_pickup_local(self):
         df = DataFrame(np.random.randint(m, size=(n, 3)), columns=list("abc"))
 
         # we don't pick up the local 'sin'
-        with pytest.raises(UndefinedVariableError):
+        with pytest.raises(UndefinedVariableError, match="name 'sin' is not defined"):
             df.query("sin > 5", engine=engine, parser=parser)
 
     def test_query_builtin(self):
@@ -516,10 +517,10 @@ def test_query(self):
         engine, parser = self.engine, self.parser
         df = DataFrame(np.random.randn(10, 3), columns=["a", "b", "c"])
 
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df.query("a < b", engine=engine, parser=parser), df[df.a < df.b]
         )
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df.query("a + b > b * c", engine=engine, parser=parser),
             df[df.a + df.b > df.b * df.c],
         )
@@ -533,12 +534,12 @@ def test_query_index_with_name(self):
         )
         res = df.query("(blob < 5) & (a < b)", engine=engine, parser=parser)
         expec = df[(df.index < 5) & (df.a < df.b)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         res = df.query("blob < b", engine=engine, parser=parser)
         expec = df[df.index < df.b]
 
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_query_index_without_name(self):
         engine, parser = self.engine, self.parser
@@ -551,12 +552,12 @@ def test_query_index_without_name(self):
         # "index" should refer to the index
         res = df.query("index < b", engine=engine, parser=parser)
         expec = df[df.index < df.b]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
         # test against a scalar
         res = df.query("index < 5", engine=engine, parser=parser)
         expec = df[df.index < 5]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_nested_scope(self):
         engine = self.engine
@@ -569,20 +570,20 @@ def test_nested_scope(self):
         expected = df[(df > 0) & (df2 > 0)]
 
         result = df.query("(@df > 0) & (@df2 > 0)", engine=engine, parser=parser)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = pd.eval("df[df > 0 and df2 > 0]", engine=engine, parser=parser)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = pd.eval(
             "df[df > 0 and df2 > 0 and df[df > 0] > 0]", engine=engine, parser=parser
         )
         expected = df[(df > 0) & (df2 > 0) & (df[df > 0] > 0)]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = pd.eval("df[(df>0) & (df2>0)]", engine=engine, parser=parser)
         expected = df.query("(@df>0) & (@df2>0)", engine=engine, parser=parser)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_nested_raises_on_local_self_reference(self):
         from pandas.core.computation.ops import UndefinedVariableError
@@ -590,7 +591,7 @@ def test_nested_raises_on_local_self_reference(self):
         df = DataFrame(np.random.randn(5, 3))
 
         # can't reference ourself b/c we're a local so @ is necessary
-        with pytest.raises(UndefinedVariableError):
+        with pytest.raises(UndefinedVariableError, match="name 'df' is not defined"):
             df.query("df > 0", engine=self.engine, parser=self.parser)
 
     def test_local_syntax(self):
@@ -601,11 +602,11 @@ def test_local_syntax(self):
         b = 1
         expect = df[df.a < b]
         result = df.query("a < @b", engine=engine, parser=parser)
-        assert_frame_equal(result, expect)
+        tm.assert_frame_equal(result, expect)
 
         expect = df[df.a < df.b]
         result = df.query("a < b", engine=engine, parser=parser)
-        assert_frame_equal(result, expect)
+        tm.assert_frame_equal(result, expect)
 
     def test_chained_cmp_and_in(self):
         skip_if_no_pandas_parser(self.parser)
@@ -619,7 +620,7 @@ def test_chained_cmp_and_in(self):
             (df.a < df.b) & (df.b < df.c) & ~df.b.isin(df.a) & ~df.c.isin(df.b)
         )  # noqa
         expec = df[ind]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_local_variable_with_in(self):
         engine, parser = self.engine, self.parser
@@ -630,12 +631,12 @@ def test_local_variable_with_in(self):
 
         expected = df.loc[(df.b - 1).isin(a)]
         result = df.query("b - 1 in a", engine=engine, parser=parser)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
         b = Series(np.random.randint(10, size=15), name="b")
         expected = df.loc[(b - 1).isin(a)]
         result = df.query("@b - 1 in a", engine=engine, parser=parser)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
     def test_at_inside_string(self):
         engine, parser = self.engine, self.parser
@@ -644,7 +645,7 @@ def test_at_inside_string(self):
         df = DataFrame({"a": ["a", "a", "b", "b", "@c", "@c"]})
         result = df.query('a == "@c"', engine=engine, parser=parser)
         expected = df[df.a == "@c"]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_query_undefined_local(self):
         from pandas.core.computation.ops import UndefinedVariableError
@@ -653,9 +654,9 @@ def test_query_undefined_local(self):
         skip_if_no_pandas_parser(parser)
 
         df = DataFrame(np.random.rand(10, 2), columns=list("ab"))
-        msg = "local variable 'c' is not defined"
-
-        with pytest.raises(UndefinedVariableError, match=msg):
+        with pytest.raises(
+            UndefinedVariableError, match="local variable 'c' is not defined"
+        ):
             df.query("a == @c", engine=engine, parser=parser)
 
     def test_index_resolvers_come_after_columns_with_the_same_name(self):
@@ -666,34 +667,33 @@ def test_index_resolvers_come_after_columns_with_the_same_name(self):
         df.index.name = "index"
         result = df.query("index > 5", engine=self.engine, parser=self.parser)
         expected = df[df["index"] > 5]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame({"index": a, "b": np.random.randn(a.size)})
         result = df.query("ilevel_0 > 5", engine=self.engine, parser=self.parser)
         expected = df.loc[df.index[df.index > 5]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame({"a": a, "b": np.random.randn(a.size)})
         df.index.name = "a"
         result = df.query("a > 5", engine=self.engine, parser=self.parser)
         expected = df[df.a > 5]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.query("index > 5", engine=self.engine, parser=self.parser)
         expected = df.loc[df.index[df.index > 5]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_inf(self):
         n = 10
         df = DataFrame({"a": np.random.rand(n), "b": np.random.rand(n)})
         df.loc[::2, 0] = np.inf
-        ops = "==", "!="
-        d = dict(zip(ops, (operator.eq, operator.ne)))
+        d = {"==": operator.eq, "!=": operator.ne}
         for op, f in d.items():
-            q = "a {op} inf".format(op=op)
+            q = f"a {op} inf"
             expected = df[f(df.a, np.inf)]
             result = df.query(q, engine=self.engine, parser=self.parser)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
 
 @td.skip_if_no_ne
@@ -703,7 +703,6 @@ def setup_class(cls):
         super().setup_class()
         cls.engine = "numexpr"
         cls.parser = "python"
-        cls.frame = TestData().frame
 
     def test_date_query_no_attribute_access(self):
         engine, parser = self.engine, self.parser
@@ -715,7 +714,7 @@ def test_date_query_no_attribute_access(self):
             "(dates1 < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
         expec = df[(df.dates1 < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_query_with_NaT(self):
         engine, parser = self.engine, self.parser
@@ -730,7 +729,7 @@ def test_date_query_with_NaT(self):
             "(dates1 < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
         expec = df[(df.dates1 < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query(self):
         engine, parser = self.engine, self.parser
@@ -743,7 +742,7 @@ def test_date_index_query(self):
             "(index < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query_with_NaT(self):
         engine, parser = self.engine, self.parser
@@ -757,7 +756,7 @@ def test_date_index_query_with_NaT(self):
             "(index < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_date_index_query_with_NaT_duplicates(self):
         engine, parser = self.engine, self.parser
@@ -787,18 +786,18 @@ def test_nested_scope(self):
         with pytest.raises(SyntaxError):
             df.query("(@df>0) & (@df2>0)", engine=engine, parser=parser)
 
-        with pytest.raises(UndefinedVariableError):
+        with pytest.raises(UndefinedVariableError, match="name 'df' is not defined"):
             df.query("(df>0) & (df2>0)", engine=engine, parser=parser)
 
         expected = df[(df > 0) & (df2 > 0)]
         result = pd.eval("df[(df > 0) & (df2 > 0)]", engine=engine, parser=parser)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
         expected = df[(df > 0) & (df2 > 0) & (df[df > 0] > 0)]
         result = pd.eval(
             "df[(df > 0) & (df2 > 0) & (df[df > 0] > 0)]", engine=engine, parser=parser
         )
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
 
 class TestDataFrameQueryPythonPandas(TestDataFrameQueryNumExprPandas):
@@ -807,7 +806,6 @@ def setup_class(cls):
         super().setup_class()
         cls.engine = "python"
         cls.parser = "pandas"
-        cls.frame = TestData().frame
 
     def test_query_builtin(self):
         engine, parser = self.engine, self.parser
@@ -818,7 +816,7 @@ def test_query_builtin(self):
         df.index.name = "sin"
         expected = df[df.index > 5]
         result = df.query("sin > 5", engine=engine, parser=parser)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
 
 class TestDataFrameQueryPythonPython(TestDataFrameQueryNumExprPython):
@@ -826,7 +824,6 @@ class TestDataFrameQueryPythonPython(TestDataFrameQueryNumExprPython):
     def setup_class(cls):
         super().setup_class()
         cls.engine = cls.parser = "python"
-        cls.frame = TestData().frame
 
     def test_query_builtin(self):
         engine, parser = self.engine, self.parser
@@ -837,7 +834,7 @@ def test_query_builtin(self):
         df.index.name = "sin"
         expected = df[df.index > 5]
         result = df.query("sin > 5", engine=engine, parser=parser)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
 
 class TestDataFrameQueryStrings:
@@ -857,7 +854,7 @@ def test_str_query_method(self, parser, engine):
             ops = 2 * ([eq] + [ne])
 
             for lhs, op, rhs in zip(lhs, ops, rhs):
-                ex = "{lhs} {op} {rhs}".format(lhs=lhs, op=op, rhs=rhs)
+                ex = f"{lhs} {op} {rhs}"
                 msg = r"'(Not)?In' nodes are not implemented"
                 with pytest.raises(NotImplementedError, match=msg):
                     df.query(
@@ -868,19 +865,19 @@ def test_str_query_method(self, parser, engine):
                     )
         else:
             res = df.query('"a" == strings', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
             res = df.query('strings == "a"', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
-            assert_frame_equal(res, df[df.strings.isin(["a"])])
+            tm.assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, df[df.strings.isin(["a"])])
 
             expect = df[df.strings != "a"]
             res = df.query('strings != "a"', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
             res = df.query('"a" != strings', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
-            assert_frame_equal(res, df[~df.strings.isin(["a"])])
+            tm.assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, df[~df.strings.isin(["a"])])
 
     def test_str_list_query_method(self, parser, engine):
         df = DataFrame(np.random.randn(10, 1), columns=["b"])
@@ -898,23 +895,23 @@ def test_str_list_query_method(self, parser, engine):
             ops = 2 * ([eq] + [ne])
 
             for lhs, op, rhs in zip(lhs, ops, rhs):
-                ex = "{lhs} {op} {rhs}".format(lhs=lhs, op=op, rhs=rhs)
+                ex = f"{lhs} {op} {rhs}"
                 with pytest.raises(NotImplementedError):
                     df.query(ex, engine=engine, parser=parser)
         else:
             res = df.query('strings == ["a", "b"]', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
             res = df.query('["a", "b"] == strings', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
             expect = df[~df.strings.isin(["a", "b"])]
 
             res = df.query('strings != ["a", "b"]', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
             res = df.query('["a", "b"] != strings', engine=engine, parser=parser)
-            assert_frame_equal(res, expect)
+            tm.assert_frame_equal(res, expect)
 
     def test_query_with_string_columns(self, parser, engine):
         df = DataFrame(
@@ -928,11 +925,11 @@ def test_query_with_string_columns(self, parser, engine):
         if parser == "pandas":
             res = df.query("a in b", parser=parser, engine=engine)
             expec = df[df.a.isin(df.b)]
-            assert_frame_equal(res, expec)
+            tm.assert_frame_equal(res, expec)
 
             res = df.query("a in b and c < d", parser=parser, engine=engine)
             expec = df[df.a.isin(df.b) & (df.c < df.d)]
-            assert_frame_equal(res, expec)
+            tm.assert_frame_equal(res, expec)
         else:
             with pytest.raises(NotImplementedError):
                 df.query("a in b", parser=parser, engine=engine)
@@ -951,11 +948,11 @@ def test_object_array_eq_ne(self, parser, engine):
         )
         res = df.query("a == b", parser=parser, engine=engine)
         exp = df[df.a == df.b]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
         res = df.query("a != b", parser=parser, engine=engine)
         exp = df[df.a != df.b]
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
     def test_query_with_nested_strings(self, parser, engine):
         skip_if_no_pandas_parser(parser)
@@ -978,28 +975,27 @@ def test_query_with_nested_strings(self, parser, engine):
         )
         expected = df[df.event == '"page 1 load"']
         res = df.query("""'"page 1 load"' in event""", parser=parser, engine=engine)
-        assert_frame_equal(expected, res)
+        tm.assert_frame_equal(expected, res)
 
     def test_query_with_nested_special_character(self, parser, engine):
         skip_if_no_pandas_parser(parser)
         df = DataFrame({"a": ["a", "b", "test & test"], "b": [1, 2, 3]})
         res = df.query('a == "test & test"', parser=parser, engine=engine)
         expec = df[df.a == "test & test"]
-        assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res, expec)
 
     def test_query_lex_compare_strings(self, parser, engine):
-        import operator as opr
 
         a = Series(np.random.choice(list("abcde"), 20))
         b = Series(np.arange(a.size))
         df = DataFrame({"X": a, "Y": b})
 
-        ops = {"<": opr.lt, ">": opr.gt, "<=": opr.le, ">=": opr.ge}
+        ops = {"<": operator.lt, ">": operator.gt, "<=": operator.le, ">=": operator.ge}
 
         for op, func in ops.items():
-            res = df.query('X %s "d"' % op, engine=engine, parser=parser)
+            res = df.query(f'X {op} "d"', engine=engine, parser=parser)
             expected = df[func(df.X, "d")]
-            assert_frame_equal(res, expected)
+            tm.assert_frame_equal(res, expected)
 
     def test_query_single_element_booleans(self, parser, engine):
         columns = "bid", "bidsize", "ask", "asksize"
@@ -1007,7 +1003,7 @@ def test_query_single_element_booleans(self, parser, engine):
         df = DataFrame(data, columns=columns)
         res = df.query("bid & ask", engine=engine, parser=parser)
         expected = df[df.bid & df.ask]
-        assert_frame_equal(res, expected)
+        tm.assert_frame_equal(res, expected)
 
     def test_query_string_scalar_variable(self, parser, engine):
         skip_if_no_pandas_parser(parser)
@@ -1020,7 +1016,7 @@ def test_query_string_scalar_variable(self, parser, engine):
         e = df[df.Symbol == "BUD US"]
         symb = "BUD US"  # noqa
         r = df.query("Symbol == @symb", parser=parser, engine=engine)
-        assert_frame_equal(e, r)
+        tm.assert_frame_equal(e, r)
 
 
 class TestDataFrameEvalWithFrame:
@@ -1033,12 +1029,12 @@ def teardown_method(self, method):
     def test_simple_expr(self, parser, engine):
         res = self.frame.eval("a + b", engine=engine, parser=parser)
         expect = self.frame.a + self.frame.b
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     def test_bool_arith_expr(self, parser, engine):
         res = self.frame.eval("a[a < 1] + b", engine=engine, parser=parser)
         expect = self.frame.a[self.frame.a < 1] + self.frame.b
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     @pytest.mark.parametrize("op", ["+", "-", "*", "/"])
     def test_invalid_type_for_operator_raises(self, parser, engine, op):
@@ -1046,58 +1042,137 @@ def test_invalid_type_for_operator_raises(self, parser, engine, op):
         msg = r"unsupported operand type\(s\) for .+: '.+' and '.+'"
 
         with pytest.raises(TypeError, match=msg):
-            df.eval("a {0} b".format(op), engine=engine, parser=parser)
+            df.eval(f"a {op} b", engine=engine, parser=parser)
 
 
 class TestDataFrameQueryBacktickQuoting:
     @pytest.fixture(scope="class")
     def df(self):
+        """
+        Yields a dataframe with strings that may or may not need escaping
+        by backticks. The last two columns cannot be escaped by backticks
+        and should raise a ValueError.
+        """
         yield DataFrame(
             {
                 "A": [1, 2, 3],
                 "B B": [3, 2, 1],
                 "C C": [4, 5, 6],
+                "C  C": [7, 4, 3],
                 "C_C": [8, 9, 10],
                 "D_D D": [11, 1, 101],
+                "E.E": [6, 3, 5],
+                "F-F": [8, 1, 10],
+                "1e1": [2, 4, 8],
+                "def": [10, 11, 2],
+                "A (x)": [4, 1, 3],
+                "B(x)": [1, 1, 5],
+                "B (x)": [2, 7, 4],
+                "  &^ :!€$?(} >    <++*''  ": [2, 5, 6],
+                "": [10, 11, 1],
+                " A": [4, 7, 9],
+                "  ": [1, 2, 1],
+                "it's": [6, 3, 1],
+                "that's": [9, 1, 8],
+                "☺": [8, 7, 6],
+                "foo#bar": [2, 4, 5],
+                1: [5, 7, 9],
             }
         )
 
     def test_single_backtick_variable_query(self, df):
         res = df.query("1 < `B B`")
         expect = df[1 < df["B B"]]
-        assert_frame_equal(res, expect)
+        tm.assert_frame_equal(res, expect)
 
     def test_two_backtick_variables_query(self, df):
         res = df.query("1 < `B B` and 4 < `C C`")
         expect = df[(1 < df["B B"]) & (4 < df["C C"])]
-        assert_frame_equal(res, expect)
+        tm.assert_frame_equal(res, expect)
 
     def test_single_backtick_variable_expr(self, df):
         res = df.eval("A + `B B`")
         expect = df["A"] + df["B B"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     def test_two_backtick_variables_expr(self, df):
         res = df.eval("`B B` + `C C`")
         expect = df["B B"] + df["C C"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     def test_already_underscore_variable(self, df):
         res = df.eval("`C_C` + A")
         expect = df["C_C"] + df["A"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     def test_same_name_but_underscores(self, df):
         res = df.eval("C_C + `C C`")
         expect = df["C_C"] + df["C C"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
     def test_mixed_underscores_and_spaces(self, df):
         res = df.eval("A + `D_D D`")
         expect = df["A"] + df["D_D D"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
 
-    def backtick_quote_name_with_no_spaces(self, df):
+    def test_backtick_quote_name_with_no_spaces(self, df):
         res = df.eval("A + `C_C`")
         expect = df["A"] + df["C_C"]
-        assert_series_equal(res, expect)
+        tm.assert_series_equal(res, expect)
+
+    def test_special_characters(self, df):
+        res = df.eval("`E.E` + `F-F` - A")
+        expect = df["E.E"] + df["F-F"] - df["A"]
+        tm.assert_series_equal(res, expect)
+
+    def test_start_with_digit(self, df):
+        res = df.eval("A + `1e1`")
+        expect = df["A"] + df["1e1"]
+        tm.assert_series_equal(res, expect)
+
+    def test_keyword(self, df):
+        res = df.eval("A + `def`")
+        expect = df["A"] + df["def"]
+        tm.assert_series_equal(res, expect)
+
+    def test_unneeded_quoting(self, df):
+        res = df.query("`A` > 2")
+        expect = df[df["A"] > 2]
+        tm.assert_frame_equal(res, expect)
+
+    def test_parenthesis(self, df):
+        res = df.query("`A (x)` > 2")
+        expect = df[df["A (x)"] > 2]
+        tm.assert_frame_equal(res, expect)
+
+    def test_empty_string(self, df):
+        res = df.query("`` > 5")
+        expect = df[df[""] > 5]
+        tm.assert_frame_equal(res, expect)
+
+    def test_multiple_spaces(self, df):
+        res = df.query("`C  C` > 5")
+        expect = df[df["C  C"] > 5]
+        tm.assert_frame_equal(res, expect)
+
+    def test_start_with_spaces(self, df):
+        res = df.eval("` A` + `  `")
+        expect = df[" A"] + df["  "]
+        tm.assert_series_equal(res, expect)
+
+    def test_lots_of_operators_string(self, df):
+        res = df.query("`  &^ :!€$?(} >    <++*''  ` > 4")
+        expect = df[df["  &^ :!€$?(} >    <++*''  "] > 4]
+        tm.assert_frame_equal(res, expect)
+
+    def test_failing_quote(self, df):
+        with pytest.raises(SyntaxError):
+            df.query("`it's` > `that's`")
+
+    def test_failing_character_outside_range(self, df):
+        with pytest.raises(SyntaxError):
+            df.query("`☺` > 4")
+
+    def test_failing_hashtag(self, df):
+        with pytest.raises(SyntaxError):
+            df.query("`foo#bar` > 4")
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index 48f42b5f101ce..4ac009ef508c4 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -3,6 +3,7 @@
 import re
 import sys
 import textwrap
+import warnings
 
 import numpy as np
 import pytest
@@ -18,8 +19,7 @@
     option_context,
     period_range,
 )
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.formats.format as fmt
 
@@ -27,21 +27,21 @@
 # structure
 
 
-class TestDataFrameReprInfoEtc(TestData):
+class TestDataFrameReprInfoEtc:
     def test_repr_empty(self):
         # empty
-        foo = repr(self.empty)  # noqa
+        repr(DataFrame())
 
         # empty with index
         frame = DataFrame(index=np.arange(1000))
-        foo = repr(frame)  # noqa
+        repr(frame)
 
-    def test_repr_mixed(self):
+    def test_repr_mixed(self, float_string_frame):
         buf = StringIO()
 
         # mixed
-        foo = repr(self.mixed_frame)  # noqa
-        self.mixed_frame.info(verbose=False, buf=buf)
+        repr(float_string_frame)
+        float_string_frame.info(verbose=False, buf=buf)
 
     @pytest.mark.slow
     def test_repr_mixed_big(self):
@@ -52,27 +52,27 @@ def test_repr_mixed_big(self):
         biggie.loc[:20, "A"] = np.nan
         biggie.loc[:20, "B"] = np.nan
 
-        foo = repr(biggie)  # noqa
+        repr(biggie)
 
-    def test_repr(self):
+    def test_repr(self, float_frame):
         buf = StringIO()
 
         # small one
-        foo = repr(self.frame)
-        self.frame.info(verbose=False, buf=buf)
+        repr(float_frame)
+        float_frame.info(verbose=False, buf=buf)
 
         # even smaller
-        self.frame.reindex(columns=["A"]).info(verbose=False, buf=buf)
-        self.frame.reindex(columns=["A", "B"]).info(verbose=False, buf=buf)
+        float_frame.reindex(columns=["A"]).info(verbose=False, buf=buf)
+        float_frame.reindex(columns=["A", "B"]).info(verbose=False, buf=buf)
 
         # exhausting cases in DataFrame.info
 
         # columns but no index
         no_index = DataFrame(columns=[0, 1, 3])
-        foo = repr(no_index)  # noqa
+        repr(no_index)
 
         # no columns or index
-        self.empty.info(buf=buf)
+        DataFrame().info(buf=buf)
 
         df = DataFrame(["a\n\r\tb"], columns=["a\n\r\td"], index=["a\n\r\tf"])
         assert "\t" not in repr(df)
@@ -96,9 +96,8 @@ def test_repr_big(self):
         biggie = DataFrame(np.zeros((200, 4)), columns=range(4), index=range(200))
         repr(biggie)
 
-    def test_repr_unsortable(self):
+    def test_repr_unsortable(self, float_frame):
         # columns are not sortable
-        import warnings
 
         warn_filters = warnings.filters
         warnings.filterwarnings("ignore", category=FutureWarning, module=".*format")
@@ -115,13 +114,13 @@ def test_repr_unsortable(self):
         repr(unsortable)
 
         fmt.set_option("display.precision", 3, "display.column_space", 10)
-        repr(self.frame)
+        repr(float_frame)
 
         fmt.set_option("display.max_rows", 10, "display.max_columns", 2)
-        repr(self.frame)
+        repr(float_frame)
 
         fmt.set_option("display.max_rows", 1000, "display.max_columns", 1000)
-        repr(self.frame)
+        repr(float_frame)
 
         tm.reset_display_options()
 
@@ -130,9 +129,6 @@ def test_repr_unsortable(self):
     def test_repr_unicode(self):
         uval = "\u03c3\u03c3\u03c3\u03c3"
 
-        # TODO(wesm): is this supposed to be used?
-        bval = uval.encode("utf-8")  # noqa
-
         df = DataFrame({"A": [uval, uval]})
 
         result = repr(df)
@@ -165,13 +161,13 @@ def test_repr_column_name_unicode_truncation_bug(self):
                 "Id": [7117434],
                 "StringCol": (
                     "Is it possible to modify drop plot code"
-                    " so that the output graph is displayed "
+                    "so that the output graph is displayed "
                     "in iphone simulator, Is it possible to "
                     "modify drop plot code so that the "
                     "output graph is \xe2\x80\xa8displayed "
                     "in iphone simulator.Now we are adding "
-                    "the CSV file externally. I want to Call"
-                    " the File through the code.."
+                    "the CSV file externally. I want to Call "
+                    "the File through the code.."
                 ),
             }
         )
@@ -196,16 +192,37 @@ def test_latex_repr(self):
         # GH 12182
         assert df._repr_latex_() is None
 
-    def test_info(self):
+    def test_info(self, float_frame, datetime_frame):
         io = StringIO()
-        self.frame.info(buf=io)
-        self.tsframe.info(buf=io)
+        float_frame.info(buf=io)
+        datetime_frame.info(buf=io)
 
         frame = DataFrame(np.random.randn(5, 3))
 
         frame.info()
         frame.info(verbose=False)
 
+    def test_info_verbose(self):
+        buf = StringIO()
+        size = 1001
+        start = 5
+        frame = DataFrame(np.random.randn(3, size))
+        frame.info(verbose=True, buf=buf)
+
+        res = buf.getvalue()
+        header = " #    Column  Dtype  \n---   ------  -----  "
+        assert header in res
+
+        frame.info(verbose=True, buf=buf)
+        buf.seek(0)
+        lines = buf.readlines()
+        assert len(lines) > 0
+
+        for i, line in enumerate(lines):
+            if i >= start and i < start + size:
+                line_nr = f" {i - start} "
+                assert line.startswith(line_nr)
+
     def test_info_memory(self):
         # https://github.com/pandas-dev/pandas/issues/21056
         df = pd.DataFrame({"a": pd.Series([1, 2], dtype="i8")})
@@ -215,16 +232,16 @@ def test_info_memory(self):
         bytes = float(df.memory_usage().sum())
 
         expected = textwrap.dedent(
-            """\
+            f"""\
         <class 'pandas.core.frame.DataFrame'>
         RangeIndex: 2 entries, 0 to 1
         Data columns (total 1 columns):
-        a    2 non-null int64
+         #   Column  Non-Null Count  Dtype
+        ---  ------  --------------  -----
+         0   a       2 non-null      int64
         dtypes: int64(1)
-        memory usage: {} bytes
-        """.format(
-                bytes
-            )
+        memory usage: {bytes} bytes
+        """
         )
 
         assert result == expected
@@ -263,8 +280,8 @@ def test_info_duplicate_columns_shows_correct_dtypes(self):
         frame.info(buf=io)
         io.seek(0)
         lines = io.readlines()
-        assert "a    1 non-null int64\n" == lines[3]
-        assert "a    1 non-null float64\n" == lines[4]
+        assert " 0   a       1 non-null      int64  \n" == lines[5]
+        assert " 1   a       1 non-null      float64\n" == lines[6]
 
     def test_info_shows_column_dtypes(self):
         dtypes = [
@@ -284,13 +301,18 @@ def test_info_shows_column_dtypes(self):
         buf = StringIO()
         df.info(buf=buf)
         res = buf.getvalue()
+        header = (
+            " #   Column  Non-Null Count  Dtype          \n"
+            "---  ------  --------------  -----          "
+        )
+        assert header in res
         for i, dtype in enumerate(dtypes):
-            name = "{i:d}    {n:d} non-null {dtype}".format(i=i, n=n, dtype=dtype)
+            name = f" {i:d}   {i:d}       {n:d} non-null     {dtype}"
             assert name in res
 
     def test_info_max_cols(self):
         df = DataFrame(np.random.randn(10, 5))
-        for len_, verbose in [(5, None), (5, False), (10, True)]:
+        for len_, verbose in [(5, None), (5, False), (12, True)]:
             # For verbose always      ^ setting  ^ summarize ^ full output
             with option_context("max_info_columns", 4):
                 buf = StringIO()
@@ -298,16 +320,16 @@ def test_info_max_cols(self):
                 res = buf.getvalue()
                 assert len(res.strip().split("\n")) == len_
 
-        for len_, verbose in [(10, None), (5, False), (10, True)]:
+        for len_, verbose in [(12, None), (5, False), (12, True)]:
 
-            # max_cols no exceeded
+            # max_cols not exceeded
             with option_context("max_info_columns", 5):
                 buf = StringIO()
                 df.info(buf=buf, verbose=verbose)
                 res = buf.getvalue()
                 assert len(res.strip().split("\n")) == len_
 
-        for len_, max_cols in [(10, 5), (5, 4)]:
+        for len_, max_cols in [(12, 5), (5, 4)]:
             # setting truncates
             with option_context("max_info_columns", 4):
                 buf = StringIO()
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index eb654be3f12e6..b3af5a7b7317e 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -6,12 +6,10 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Period, Series, Timedelta, date_range
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
-class TestDataFrameReshape(TestData):
+class TestDataFrameReshape:
     def test_pivot(self):
         data = {
             "index": ["A", "B", "C", "C", "B", "A"],
@@ -83,7 +81,7 @@ def test_pivot_index_none(self):
         )
 
         expected.index.name, expected.columns.name = "index", "columns"
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # omit values
         result = frame.pivot(columns="columns")
@@ -101,8 +99,8 @@ def test_pivot_index_none(self):
         expected.columns.name = "columns"
         tm.assert_frame_equal(result, expected)
 
-    def test_stack_unstack(self):
-        df = self.frame.copy()
+    def test_stack_unstack(self, float_frame):
+        df = float_frame.copy()
         df[:] = np.arange(np.prod(df.shape)).reshape(df.shape)
 
         stacked = df.stack()
@@ -111,13 +109,13 @@ def test_stack_unstack(self):
         unstacked = stacked.unstack()
         unstacked_df = stacked_df.unstack()
 
-        assert_frame_equal(unstacked, df)
-        assert_frame_equal(unstacked_df["bar"], df)
+        tm.assert_frame_equal(unstacked, df)
+        tm.assert_frame_equal(unstacked_df["bar"], df)
 
         unstacked_cols = stacked.unstack(0)
         unstacked_cols_df = stacked_df.unstack(0)
-        assert_frame_equal(unstacked_cols.T, df)
-        assert_frame_equal(unstacked_cols_df["bar"].T, df)
+        tm.assert_frame_equal(unstacked_cols.T, df)
+        tm.assert_frame_equal(unstacked_cols_df["bar"].T, df)
 
     def test_stack_mixed_level(self):
         # GH 18310
@@ -127,7 +125,7 @@ def test_stack_mixed_level(self):
         df = DataFrame(1, index=levels[0], columns=levels[1])
         result = df.stack()
         expected = Series(1, index=MultiIndex.from_product(levels[:2]))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # MultiIndex columns:
         df = DataFrame(1, index=levels[0], columns=MultiIndex.from_product(levels[1:]))
@@ -135,12 +133,12 @@ def test_stack_mixed_level(self):
         expected = DataFrame(
             1, index=MultiIndex.from_product([levels[0], levels[2]]), columns=levels[1]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # as above, but used labels in level are actually of homogeneous type
         result = df[["a", "b"]].stack(1)
         expected = expected[["a", "b"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill(self):
 
@@ -157,14 +155,14 @@ def test_unstack_fill(self):
         expected = DataFrame(
             {"a": [1, -1, 5], "b": [2, 4, -1]}, index=["x", "y", "z"], dtype=np.int16
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # From a series with incorrect data type for fill_value
         result = data.unstack(fill_value=0.5)
         expected = DataFrame(
             {"a": [1, 0.5, 5], "b": [2, 4, 0.5]}, index=["x", "y", "z"], dtype=np.float
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # GH #13971: fill_value when unstacking multiple levels:
         df = DataFrame(
@@ -174,20 +172,20 @@ def test_unstack_fill(self):
         key = ("w", "b", "j")
         expected = unstacked[key]
         result = pd.Series([0, 0, 2], index=unstacked.index, name=key)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         stacked = unstacked.stack(["x", "y"])
         stacked.index = stacked.index.reorder_levels(df.index.names)
         # Workaround for GH #17886 (unnecessarily casts to float):
         stacked = stacked.astype(np.int64)
         result = stacked.loc[df.index]
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         # From a series
         s = df["w"]
         result = s.unstack(["x", "y"], fill_value=0)
         expected = unstacked["w"]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill_frame(self):
 
@@ -205,7 +203,7 @@ def test_unstack_fill_frame(self):
         expected.columns = MultiIndex.from_tuples(
             [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # From a mixed type dataframe
         df["A"] = df["A"].astype(np.int16)
@@ -214,7 +212,7 @@ def test_unstack_fill_frame(self):
         result = df.unstack(fill_value=-1)
         expected["A"] = expected["A"].astype(np.int16)
         expected["B"] = expected["B"].astype(np.float64)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # From a dataframe with incorrect data type for fill_value
         result = df.unstack(fill_value=0.5)
@@ -224,7 +222,7 @@ def test_unstack_fill_frame(self):
         expected.columns = MultiIndex.from_tuples(
             [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill_frame_datetime(self):
 
@@ -240,14 +238,14 @@ def test_unstack_fill_frame_datetime(self):
             {"a": [dv[0], pd.NaT, dv[3]], "b": [dv[1], dv[2], pd.NaT]},
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = data.unstack(fill_value=dv[0])
         expected = DataFrame(
             {"a": [dv[0], dv[0], dv[3]], "b": [dv[1], dv[2], dv[0]]},
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill_frame_timedelta(self):
 
@@ -263,14 +261,14 @@ def test_unstack_fill_frame_timedelta(self):
             {"a": [td[0], pd.NaT, td[3]], "b": [td[1], td[2], pd.NaT]},
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = data.unstack(fill_value=td[1])
         expected = DataFrame(
             {"a": [td[0], td[1], td[3]], "b": [td[1], td[2], td[1]]},
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill_frame_period(self):
 
@@ -291,7 +289,7 @@ def test_unstack_fill_frame_period(self):
             {"a": [periods[0], None, periods[3]], "b": [periods[1], periods[2], None]},
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = data.unstack(fill_value=periods[1])
         expected = DataFrame(
@@ -301,7 +299,7 @@ def test_unstack_fill_frame_period(self):
             },
             index=["x", "y", "z"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_fill_frame_categorical(self):
 
@@ -320,7 +318,7 @@ def test_unstack_fill_frame_categorical(self):
             },
             index=list("xyz"),
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Fill with non-category results in a TypeError
         msg = r"'fill_value' \('d'\) is not in"
@@ -336,7 +334,81 @@ def test_unstack_fill_frame_categorical(self):
             },
             index=list("xyz"),
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    def test_unstack_tuplename_in_multiindex(self):
+        # GH 19966
+        idx = pd.MultiIndex.from_product(
+            [["a", "b", "c"], [1, 2, 3]], names=[("A", "a"), ("B", "b")]
+        )
+        df = pd.DataFrame({"d": [1] * 9, "e": [2] * 9}, index=idx)
+        result = df.unstack(("A", "a"))
+
+        expected = pd.DataFrame(
+            [[1, 1, 1, 2, 2, 2], [1, 1, 1, 2, 2, 2], [1, 1, 1, 2, 2, 2]],
+            columns=pd.MultiIndex.from_tuples(
+                [
+                    ("d", "a"),
+                    ("d", "b"),
+                    ("d", "c"),
+                    ("e", "a"),
+                    ("e", "b"),
+                    ("e", "c"),
+                ],
+                names=[None, ("A", "a")],
+            ),
+            index=pd.Index([1, 2, 3], name=("B", "b")),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "unstack_idx, expected_values, expected_index, expected_columns",
+        [
+            (
+                ("A", "a"),
+                [[1, 1, 2, 2], [1, 1, 2, 2], [1, 1, 2, 2], [1, 1, 2, 2]],
+                pd.MultiIndex.from_tuples(
+                    [(1, 3), (1, 4), (2, 3), (2, 4)], names=["B", "C"]
+                ),
+                pd.MultiIndex.from_tuples(
+                    [("d", "a"), ("d", "b"), ("e", "a"), ("e", "b")],
+                    names=[None, ("A", "a")],
+                ),
+            ),
+            (
+                (("A", "a"), "B"),
+                [[1, 1, 1, 1, 2, 2, 2, 2], [1, 1, 1, 1, 2, 2, 2, 2]],
+                pd.Index([3, 4], name="C"),
+                pd.MultiIndex.from_tuples(
+                    [
+                        ("d", "a", 1),
+                        ("d", "a", 2),
+                        ("d", "b", 1),
+                        ("d", "b", 2),
+                        ("e", "a", 1),
+                        ("e", "a", 2),
+                        ("e", "b", 1),
+                        ("e", "b", 2),
+                    ],
+                    names=[None, ("A", "a"), "B"],
+                ),
+            ),
+        ],
+    )
+    def test_unstack_mixed_type_name_in_multiindex(
+        self, unstack_idx, expected_values, expected_index, expected_columns
+    ):
+        # GH 19966
+        idx = pd.MultiIndex.from_product(
+            [["a", "b"], [1, 2], [3, 4]], names=[("A", "a"), "B", "C"]
+        )
+        df = pd.DataFrame({"d": [1] * 8, "e": [2] * 8}, index=idx)
+        result = df.unstack(unstack_idx)
+
+        expected = pd.DataFrame(
+            expected_values, columns=expected_columns, index=expected_index,
+        )
+        tm.assert_frame_equal(result, expected)
 
     def test_unstack_preserve_dtypes(self):
         # Checks fix for #11847
@@ -359,7 +431,7 @@ def test_unstack_preserve_dtypes(self):
         def unstack_and_compare(df, column_name):
             unstacked1 = df.unstack([column_name])
             unstacked2 = df.unstack(column_name)
-            assert_frame_equal(unstacked1, unstacked2)
+            tm.assert_frame_equal(unstacked1, unstacked2)
 
         df1 = df.set_index(["state", "index"])
         unstack_and_compare(df1, "index")
@@ -384,13 +456,15 @@ def test_stack_ints(self):
         columns = MultiIndex.from_tuples(list(itertools.product(range(3), repeat=3)))
         df = DataFrame(np.random.randn(30, 27), columns=columns)
 
-        assert_frame_equal(df.stack(level=[1, 2]), df.stack(level=1).stack(level=1))
-        assert_frame_equal(df.stack(level=[-2, -1]), df.stack(level=1).stack(level=1))
+        tm.assert_frame_equal(df.stack(level=[1, 2]), df.stack(level=1).stack(level=1))
+        tm.assert_frame_equal(
+            df.stack(level=[-2, -1]), df.stack(level=1).stack(level=1)
+        )
 
         df_named = df.copy()
         df_named.columns.set_names(range(3), inplace=True)
 
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df_named.stack(level=[1, 2]), df_named.stack(level=1).stack(level=1)
         )
 
@@ -414,18 +488,18 @@ def test_stack_mixed_levels(self):
         # the level numbers
         df2 = df.copy()
         df2.columns.names = ["exp", "animal", 1]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df2.stack(level=["animal", 1]), animal_hair_stacked, check_names=False
         )
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df2.stack(level=["exp", 1]), exp_hair_stacked, check_names=False
         )
 
         # When mixed types are passed and the ints are not level
         # names, raise
         msg = (
-            "level should contain all level names or all level numbers, not"
-            " a mixture of the two"
+            "level should contain all level names or all level numbers, not "
+            "a mixture of the two"
         )
         with pytest.raises(ValueError, match=msg):
             df2.stack(level=["animal", 0])
@@ -434,7 +508,7 @@ def test_stack_mixed_levels(self):
         # strange error about lexsort depth
         df3 = df.copy()
         df3.columns.names = ["exp", "animal", 0]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df3.stack(level=["animal", 0]), animal_hair_stacked, check_names=False
         )
 
@@ -456,24 +530,28 @@ def test_stack_int_level_names(self):
 
         df2 = df.copy()
         df2.columns.names = [0, 1, 2]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df2.stack(level=[1, 2]), animal_hair_stacked, check_names=False
         )
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df2.stack(level=[0, 1]), exp_animal_stacked, check_names=False
         )
-        assert_frame_equal(df2.stack(level=[0, 2]), exp_hair_stacked, check_names=False)
+        tm.assert_frame_equal(
+            df2.stack(level=[0, 2]), exp_hair_stacked, check_names=False
+        )
 
         # Out-of-order int column names
         df3 = df.copy()
         df3.columns.names = [2, 0, 1]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df3.stack(level=[0, 1]), animal_hair_stacked, check_names=False
         )
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df3.stack(level=[2, 0]), exp_animal_stacked, check_names=False
         )
-        assert_frame_equal(df3.stack(level=[2, 1]), exp_hair_stacked, check_names=False)
+        tm.assert_frame_equal(
+            df3.stack(level=[2, 1]), exp_hair_stacked, check_names=False
+        )
 
     def test_unstack_bool(self):
         df = DataFrame(
@@ -487,7 +565,7 @@ def test_unstack_bool(self):
             index=["a", "b"],
             columns=MultiIndex.from_arrays([["col", "col"], ["c", "l"]]),
         )
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
     def test_unstack_level_binding(self):
         # GH9856
@@ -513,15 +591,15 @@ def test_unstack_level_binding(self):
             columns=pd.Index(["a", "b"], name="third"),
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
-    def test_unstack_to_series(self):
+    def test_unstack_to_series(self, float_frame):
         # check reversibility
-        data = self.frame.unstack()
+        data = float_frame.unstack()
 
         assert isinstance(data, Series)
         undo = data.unstack().T
-        assert_frame_equal(undo, self.frame)
+        tm.assert_frame_equal(undo, float_frame)
 
         # check NA handling
         data = DataFrame({"x": [1, 2, np.NaN], "y": [3.0, 4, np.NaN]})
@@ -534,13 +612,13 @@ def test_unstack_to_series(self):
         )
         expected = Series([1, 2, np.NaN, 3, 4, np.NaN], index=midx)
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # check composability of unstack
         old_data = data.copy()
         for _ in range(4):
             data = data.unstack()
-        assert_frame_equal(old_data, data)
+        tm.assert_frame_equal(old_data, data)
 
     def test_unstack_dtypes(self):
 
@@ -550,7 +628,7 @@ def test_unstack_dtypes(self):
         df = DataFrame(rows, columns=list("ABCD"))
         result = df.dtypes
         expected = Series([np.dtype("int64")] * 4, index=list("ABCD"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # single dtype
         df2 = df.set_index(["A", "B"])
@@ -562,7 +640,7 @@ def test_unstack_dtypes(self):
                 [["C", "C", "D", "D"], [1, 2, 1, 2]], names=(None, "B")
             ),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # mixed
         df2 = df.set_index(["A", "B"])
@@ -575,7 +653,7 @@ def test_unstack_dtypes(self):
                 [["C", "C", "D", "D"], [1, 2, 1, 2]], names=(None, "B")
             ),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         df2["D"] = "foo"
         df3 = df2.unstack("B")
         result = df3.dtypes
@@ -585,7 +663,7 @@ def test_unstack_dtypes(self):
                 [["C", "C", "D", "D"], [1, 2, 1, 2]], names=(None, "B")
             ),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH7405
         for c, d in (
@@ -695,7 +773,7 @@ def verify(df):
             for i, j in zip(rows, cols):
                 left = sorted(df.iloc[i, j].split("."))
                 right = mk_list(df.index[i]) + mk_list(df.columns[j])
-                right = sorted(list(map(cast, right)))
+                right = sorted(map(cast, right))
                 assert left == right
 
         df = DataFrame(
@@ -708,7 +786,7 @@ def verify(df):
 
         left = df.set_index(["jim", "joe"]).unstack()["jolie"]
         right = df.set_index(["joe", "jim"]).unstack()["jolie"].T
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         for idx in itertools.permutations(df.columns[:2]):
             mi = df.set_index(list(idx))
@@ -786,7 +864,7 @@ def verify(df):
         )
 
         right = DataFrame(vals, columns=cols, index=idx)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         df = DataFrame({"A": list("aaaabbbb"), "B": list(range(4)) * 2, "C": range(8)})
         df.iloc[2, 1] = np.NaN
@@ -798,7 +876,7 @@ def verify(df):
         )
         idx = Index([np.nan, 0, 1, 2, 3], name="B")
         right = DataFrame(vals, columns=cols, index=idx)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         df = pd.DataFrame(
             {"A": list("aaaabbbb"), "B": list(range(4)) * 2, "C": range(8)}
@@ -812,7 +890,7 @@ def verify(df):
         )
         idx = Index([np.nan, 0, 1, 2, 3], name="B")
         right = DataFrame(vals, columns=cols, index=idx)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         # GH7401
         df = pd.DataFrame(
@@ -835,7 +913,7 @@ def verify(df):
         )
 
         right = DataFrame(vals, columns=cols, index=idx)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         # GH4862
         vals = [
@@ -872,10 +950,10 @@ def verify(df):
         )
 
         right = DataFrame(vals, columns=cols, index=idx)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         left = df.loc[17264:].copy().set_index(["s_id", "dosage", "agent"])
-        assert_frame_equal(left.unstack(), right)
+        tm.assert_frame_equal(left.unstack(), right)
 
         # GH9497 - multiple unstack with nulls
         df = DataFrame(
@@ -908,7 +986,7 @@ def test_stack_datetime_column_multiIndex(self):
         eidx = MultiIndex.from_product([(0, 1, 2, 3), ("B",)])
         ecols = MultiIndex.from_tuples([(t, "A")])
         expected = DataFrame([1, 2, 3, 4], index=eidx, columns=ecols)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_stack_partial_multiIndex(self):
         # GH 8844
@@ -926,18 +1004,18 @@ def _test_stack_with_multiindex(multiindex):
                     # as df.stack(level=level, dropna=True).
                     expected = df.stack(level=level, dropna=True)
                     if isinstance(expected, Series):
-                        assert_series_equal(result, expected)
+                        tm.assert_series_equal(result, expected)
                     else:
-                        assert_frame_equal(result, expected)
+                        tm.assert_frame_equal(result, expected)
 
                 df.columns = MultiIndex.from_tuples(
                     df.columns.to_numpy(), names=df.columns.names
                 )
                 expected = df.stack(level=level, dropna=False)
                 if isinstance(expected, Series):
-                    assert_series_equal(result, expected)
+                    tm.assert_series_equal(result, expected)
                 else:
-                    assert_frame_equal(result, expected)
+                    tm.assert_frame_equal(result, expected)
 
         full_multiindex = MultiIndex.from_tuples(
             [("B", "x"), ("B", "z"), ("A", "y"), ("C", "x"), ("C", "u")],
@@ -974,7 +1052,7 @@ def _test_stack_with_multiindex(multiindex):
             columns=Index(["B", "C"], name="Upper"),
             dtype=df.dtypes[0],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("ordered", [False, True])
     @pytest.mark.parametrize("labels", [list("yxz"), list("yxy")])
@@ -1076,14 +1154,14 @@ def test_unstack_fill_frame_object():
     expected = pd.DataFrame(
         {"a": ["a", np.nan, "a"], "b": ["b", "c", np.nan]}, index=list("xyz")
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # Fill with any value replaces missing values as expected
     result = data.unstack(fill_value="d")
     expected = pd.DataFrame(
         {"a": ["a", "d", "a"], "b": ["b", "c", "d"]}, index=list("xyz")
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_unstack_timezone_aware_values():
@@ -1107,7 +1185,7 @@ def test_unstack_timezone_aware_values():
             names=[None, "b"],
         ),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_stack_timezone_aware_values():
@@ -1123,4 +1201,35 @@ def test_stack_timezone_aware_values():
             levels=[["a", "b", "c"], ["A"]], codes=[[0, 1, 2], [0, 0, 0]]
         ),
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
+
+
+def test_unstacking_multi_index_df():
+    # see gh-30740
+    df = DataFrame(
+        {
+            "name": ["Alice", "Bob"],
+            "score": [9.5, 8],
+            "employed": [False, True],
+            "kids": [0, 0],
+            "gender": ["female", "male"],
+        }
+    )
+    df = df.set_index(["name", "employed", "kids", "gender"])
+    df = df.unstack(["gender"], fill_value=0)
+    expected = df.unstack("employed", fill_value=0).unstack("kids", fill_value=0)
+    result = df.unstack(["employed", "kids"], fill_value=0)
+    expected = DataFrame(
+        [[9.5, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 8.0]],
+        index=Index(["Alice", "Bob"], name="name"),
+        columns=MultiIndex.from_tuples(
+            [
+                ("score", "female", False, 0),
+                ("score", "female", True, 0),
+                ("score", "male", False, 0),
+                ("score", "male", True, 0),
+            ],
+            names=[None, "gender", "employed", "kids"],
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_sort_values_level_as_str.py b/pandas/tests/frame/test_sort_values_level_as_str.py
index 2bcc115bcd09c..40526ab27ac9a 100644
--- a/pandas/tests/frame/test_sort_values_level_as_str.py
+++ b/pandas/tests/frame/test_sort_values_level_as_str.py
@@ -4,8 +4,7 @@
 from pandas.errors import PerformanceWarning
 
 from pandas import DataFrame
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -62,7 +61,7 @@ def test_sort_index_level_and_column_label(df_none, df_idx, sort_names, ascendin
     # Compute result sorting on mix on columns and index levels
     result = df_idx.sort_values(by=sort_names, ascending=ascending, axis=0)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_sort_column_level_and_index_label(df_none, df_idx, sort_names, ascending):
@@ -88,6 +87,6 @@ def test_sort_column_level_and_index_label(df_none, df_idx, sort_names, ascendin
         # Accessing multi-level columns that are not lexsorted raises a
         # performance warning
         with tm.assert_produces_warning(PerformanceWarning, check_stacklevel=False):
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
     else:
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_sorting.py b/pandas/tests/frame/test_sorting.py
deleted file mode 100644
index 24833f8c02df0..0000000000000
--- a/pandas/tests/frame/test_sorting.py
+++ /dev/null
@@ -1,739 +0,0 @@
-import random
-
-import numpy as np
-import pytest
-
-import pandas as pd
-from pandas import (
-    Categorical,
-    DataFrame,
-    IntervalIndex,
-    MultiIndex,
-    NaT,
-    Series,
-    Timestamp,
-    date_range,
-)
-from pandas.api.types import CategoricalDtype
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
-
-
-class TestDataFrameSorting(TestData):
-    def test_sort_values(self):
-        frame = DataFrame(
-            [[1, 1, 2], [3, 1, 0], [4, 5, 6]], index=[1, 2, 3], columns=list("ABC")
-        )
-
-        # by column (axis=0)
-        sorted_df = frame.sort_values(by="A")
-        indexer = frame["A"].argsort().values
-        expected = frame.loc[frame.index[indexer]]
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by="A", ascending=False)
-        indexer = indexer[::-1]
-        expected = frame.loc[frame.index[indexer]]
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by="A", ascending=False)
-        assert_frame_equal(sorted_df, expected)
-
-        # GH4839
-        sorted_df = frame.sort_values(by=["A"], ascending=[False])
-        assert_frame_equal(sorted_df, expected)
-
-        # multiple bys
-        sorted_df = frame.sort_values(by=["B", "C"])
-        expected = frame.loc[[2, 1, 3]]
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by=["B", "C"], ascending=False)
-        assert_frame_equal(sorted_df, expected[::-1])
-
-        sorted_df = frame.sort_values(by=["B", "A"], ascending=[True, False])
-        assert_frame_equal(sorted_df, expected)
-
-        msg = "No axis named 2 for object type <class 'pandas.core.frame.DataFrame'>"
-        with pytest.raises(ValueError, match=msg):
-            frame.sort_values(by=["A", "B"], axis=2, inplace=True)
-
-        # by row (axis=1): GH 10806
-        sorted_df = frame.sort_values(by=3, axis=1)
-        expected = frame
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by=3, axis=1, ascending=False)
-        expected = frame.reindex(columns=["C", "B", "A"])
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by=[1, 2], axis="columns")
-        expected = frame.reindex(columns=["B", "A", "C"])
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=[True, False])
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=False)
-        expected = frame.reindex(columns=["C", "B", "A"])
-        assert_frame_equal(sorted_df, expected)
-
-        msg = r"Length of ascending \(5\) != length of by \(2\)"
-        with pytest.raises(ValueError, match=msg):
-            frame.sort_values(by=["A", "B"], axis=0, ascending=[True] * 5)
-
-    def test_sort_values_inplace(self):
-        frame = DataFrame(
-            np.random.randn(4, 4), index=[1, 2, 3, 4], columns=["A", "B", "C", "D"]
-        )
-
-        sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", inplace=True)
-        expected = frame.sort_values(by="A")
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.copy()
-        sorted_df.sort_values(by=1, axis=1, inplace=True)
-        expected = frame.sort_values(by=1, axis=1)
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", ascending=False, inplace=True)
-        expected = frame.sort_values(by="A", ascending=False)
-        assert_frame_equal(sorted_df, expected)
-
-        sorted_df = frame.copy()
-        sorted_df.sort_values(by=["A", "B"], ascending=False, inplace=True)
-        expected = frame.sort_values(by=["A", "B"], ascending=False)
-        assert_frame_equal(sorted_df, expected)
-
-    def test_sort_nan(self):
-        # GH3917
-        nan = np.nan
-        df = DataFrame({"A": [1, 2, nan, 1, 6, 8, 4], "B": [9, nan, 5, 2, 5, 4, 5]})
-
-        # sort one column only
-        expected = DataFrame(
-            {"A": [nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, nan, 5, 5, 4]},
-            index=[2, 0, 3, 1, 6, 4, 5],
-        )
-        sorted_df = df.sort_values(["A"], na_position="first")
-        assert_frame_equal(sorted_df, expected)
-
-        expected = DataFrame(
-            {"A": [nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, nan, 9, 2]},
-            index=[2, 5, 4, 6, 1, 0, 3],
-        )
-        sorted_df = df.sort_values(["A"], na_position="first", ascending=False)
-        assert_frame_equal(sorted_df, expected)
-
-        expected = df.reindex(columns=["B", "A"])
-        sorted_df = df.sort_values(by=1, axis=1, na_position="first")
-        assert_frame_equal(sorted_df, expected)
-
-        # na_position='last', order
-        expected = DataFrame(
-            {"A": [1, 1, 2, 4, 6, 8, nan], "B": [2, 9, nan, 5, 5, 4, 5]},
-            index=[3, 0, 1, 6, 4, 5, 2],
-        )
-        sorted_df = df.sort_values(["A", "B"])
-        assert_frame_equal(sorted_df, expected)
-
-        # na_position='first', order
-        expected = DataFrame(
-            {"A": [nan, 1, 1, 2, 4, 6, 8], "B": [5, 2, 9, nan, 5, 5, 4]},
-            index=[2, 3, 0, 1, 6, 4, 5],
-        )
-        sorted_df = df.sort_values(["A", "B"], na_position="first")
-        assert_frame_equal(sorted_df, expected)
-
-        # na_position='first', not order
-        expected = DataFrame(
-            {"A": [nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, nan, 5, 5, 4]},
-            index=[2, 0, 3, 1, 6, 4, 5],
-        )
-        sorted_df = df.sort_values(["A", "B"], ascending=[1, 0], na_position="first")
-        assert_frame_equal(sorted_df, expected)
-
-        # na_position='last', not order
-        expected = DataFrame(
-            {"A": [8, 6, 4, 2, 1, 1, nan], "B": [4, 5, 5, nan, 2, 9, 5]},
-            index=[5, 4, 6, 1, 3, 0, 2],
-        )
-        sorted_df = df.sort_values(["A", "B"], ascending=[0, 1], na_position="last")
-        assert_frame_equal(sorted_df, expected)
-
-        # Test DataFrame with nan label
-        df = DataFrame(
-            {"A": [1, 2, nan, 1, 6, 8, 4], "B": [9, nan, 5, 2, 5, 4, 5]},
-            index=[1, 2, 3, 4, 5, 6, nan],
-        )
-
-        # NaN label, ascending=True, na_position='last'
-        sorted_df = df.sort_index(kind="quicksort", ascending=True, na_position="last")
-        expected = DataFrame(
-            {"A": [1, 2, nan, 1, 6, 8, 4], "B": [9, nan, 5, 2, 5, 4, 5]},
-            index=[1, 2, 3, 4, 5, 6, nan],
-        )
-        assert_frame_equal(sorted_df, expected)
-
-        # NaN label, ascending=True, na_position='first'
-        sorted_df = df.sort_index(na_position="first")
-        expected = DataFrame(
-            {"A": [4, 1, 2, nan, 1, 6, 8], "B": [5, 9, nan, 5, 2, 5, 4]},
-            index=[nan, 1, 2, 3, 4, 5, 6],
-        )
-        assert_frame_equal(sorted_df, expected)
-
-        # NaN label, ascending=False, na_position='last'
-        sorted_df = df.sort_index(kind="quicksort", ascending=False)
-        expected = DataFrame(
-            {"A": [8, 6, 1, nan, 2, 1, 4], "B": [4, 5, 2, 5, nan, 9, 5]},
-            index=[6, 5, 4, 3, 2, 1, nan],
-        )
-        assert_frame_equal(sorted_df, expected)
-
-        # NaN label, ascending=False, na_position='first'
-        sorted_df = df.sort_index(
-            kind="quicksort", ascending=False, na_position="first"
-        )
-        expected = DataFrame(
-            {"A": [4, 8, 6, 1, nan, 2, 1], "B": [5, 4, 5, 2, 5, nan, 9]},
-            index=[nan, 6, 5, 4, 3, 2, 1],
-        )
-        assert_frame_equal(sorted_df, expected)
-
-    def test_stable_descending_sort(self):
-        # GH #6399
-        df = DataFrame(
-            [[2, "first"], [2, "second"], [1, "a"], [1, "b"]],
-            columns=["sort_col", "order"],
-        )
-        sorted_df = df.sort_values(by="sort_col", kind="mergesort", ascending=False)
-        assert_frame_equal(df, sorted_df)
-
-    def test_stable_descending_multicolumn_sort(self):
-        nan = np.nan
-        df = DataFrame({"A": [1, 2, nan, 1, 6, 8, 4], "B": [9, nan, 5, 2, 5, 4, 5]})
-        # test stable mergesort
-        expected = DataFrame(
-            {"A": [nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, nan, 2, 9]},
-            index=[2, 5, 4, 6, 1, 3, 0],
-        )
-        sorted_df = df.sort_values(
-            ["A", "B"], ascending=[0, 1], na_position="first", kind="mergesort"
-        )
-        assert_frame_equal(sorted_df, expected)
-
-        expected = DataFrame(
-            {"A": [nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, nan, 9, 2]},
-            index=[2, 5, 4, 6, 1, 0, 3],
-        )
-        sorted_df = df.sort_values(
-            ["A", "B"], ascending=[0, 0], na_position="first", kind="mergesort"
-        )
-        assert_frame_equal(sorted_df, expected)
-
-    def test_sort_multi_index(self):
-        # GH 25775, testing that sorting by index works with a multi-index.
-        df = DataFrame(
-            {"a": [3, 1, 2], "b": [0, 0, 0], "c": [0, 1, 2], "d": list("abc")}
-        )
-        result = df.set_index(list("abc")).sort_index(level=list("ba"))
-
-        expected = DataFrame(
-            {"a": [1, 2, 3], "b": [0, 0, 0], "c": [1, 2, 0], "d": list("bca")}
-        )
-        expected = expected.set_index(list("abc"))
-
-        tm.assert_frame_equal(result, expected)
-
-    def test_stable_categorial(self):
-        # GH 16793
-        df = DataFrame({"x": pd.Categorical(np.repeat([1, 2, 3, 4], 5), ordered=True)})
-        expected = df.copy()
-        sorted_df = df.sort_values("x", kind="mergesort")
-        assert_frame_equal(sorted_df, expected)
-
-    def test_sort_datetimes(self):
-
-        # GH 3461, argsort / lexsort differences for a datetime column
-        df = DataFrame(
-            ["a", "a", "a", "b", "c", "d", "e", "f", "g"],
-            columns=["A"],
-            index=date_range("20130101", periods=9),
-        )
-        dts = [
-            Timestamp(x)
-            for x in [
-                "2004-02-11",
-                "2004-01-21",
-                "2004-01-26",
-                "2005-09-20",
-                "2010-10-04",
-                "2009-05-12",
-                "2008-11-12",
-                "2010-09-28",
-                "2010-09-28",
-            ]
-        ]
-        df["B"] = dts[::2] + dts[1::2]
-        df["C"] = 2.0
-        df["A1"] = 3.0
-
-        df1 = df.sort_values(by="A")
-        df2 = df.sort_values(by=["A"])
-        assert_frame_equal(df1, df2)
-
-        df1 = df.sort_values(by="B")
-        df2 = df.sort_values(by=["B"])
-        assert_frame_equal(df1, df2)
-
-        df1 = df.sort_values(by="B")
-
-        df2 = df.sort_values(by=["C", "B"])
-        assert_frame_equal(df1, df2)
-
-    def test_frame_column_inplace_sort_exception(self):
-        s = self.frame["A"]
-        with pytest.raises(ValueError, match="This Series is a view"):
-            s.sort_values(inplace=True)
-
-        cp = s.copy()
-        cp.sort_values()  # it works!
-
-    def test_sort_nat_values_in_int_column(self):
-
-        # GH 14922: "sorting with large float and multiple columns incorrect"
-
-        # cause was that the int64 value NaT was considered as "na". Which is
-        # only correct for datetime64 columns.
-
-        int_values = (2, int(NaT))
-        float_values = (2.0, -1.797693e308)
-
-        df = DataFrame(
-            dict(int=int_values, float=float_values), columns=["int", "float"]
-        )
-
-        df_reversed = DataFrame(
-            dict(int=int_values[::-1], float=float_values[::-1]),
-            columns=["int", "float"],
-            index=[1, 0],
-        )
-
-        # NaT is not a "na" for int64 columns, so na_position must not
-        # influence the result:
-        df_sorted = df.sort_values(["int", "float"], na_position="last")
-        assert_frame_equal(df_sorted, df_reversed)
-
-        df_sorted = df.sort_values(["int", "float"], na_position="first")
-        assert_frame_equal(df_sorted, df_reversed)
-
-        # reverse sorting order
-        df_sorted = df.sort_values(["int", "float"], ascending=False)
-        assert_frame_equal(df_sorted, df)
-
-        # and now check if NaT is still considered as "na" for datetime64
-        # columns:
-        df = DataFrame(
-            dict(datetime=[Timestamp("2016-01-01"), NaT], float=float_values),
-            columns=["datetime", "float"],
-        )
-
-        df_reversed = DataFrame(
-            dict(datetime=[NaT, Timestamp("2016-01-01")], float=float_values[::-1]),
-            columns=["datetime", "float"],
-            index=[1, 0],
-        )
-
-        df_sorted = df.sort_values(["datetime", "float"], na_position="first")
-        assert_frame_equal(df_sorted, df_reversed)
-
-        df_sorted = df.sort_values(["datetime", "float"], na_position="last")
-        assert_frame_equal(df_sorted, df)
-
-        # Ascending should not affect the results.
-        df_sorted = df.sort_values(["datetime", "float"], ascending=False)
-        assert_frame_equal(df_sorted, df)
-
-    def test_sort_nat(self):
-
-        # GH 16836
-
-        d1 = [Timestamp(x) for x in ["2016-01-01", "2015-01-01", np.nan, "2016-01-01"]]
-        d2 = [
-            Timestamp(x)
-            for x in ["2017-01-01", "2014-01-01", "2016-01-01", "2015-01-01"]
-        ]
-        df = pd.DataFrame({"a": d1, "b": d2}, index=[0, 1, 2, 3])
-
-        d3 = [Timestamp(x) for x in ["2015-01-01", "2016-01-01", "2016-01-01", np.nan]]
-        d4 = [
-            Timestamp(x)
-            for x in ["2014-01-01", "2015-01-01", "2017-01-01", "2016-01-01"]
-        ]
-        expected = pd.DataFrame({"a": d3, "b": d4}, index=[1, 3, 0, 2])
-        sorted_df = df.sort_values(by=["a", "b"])
-        tm.assert_frame_equal(sorted_df, expected)
-
-
-class TestDataFrameSortIndexKinds(TestData):
-    def test_sort_index_multicolumn(self):
-        A = np.arange(5).repeat(20)
-        B = np.tile(np.arange(5), 20)
-        random.shuffle(A)
-        random.shuffle(B)
-        frame = DataFrame({"A": A, "B": B, "C": np.random.randn(100)})
-
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            frame.sort_index(by=["A", "B"])
-        result = frame.sort_values(by=["A", "B"])
-        indexer = np.lexsort((frame["B"], frame["A"]))
-        expected = frame.take(indexer)
-        assert_frame_equal(result, expected)
-
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            frame.sort_index(by=["A", "B"], ascending=False)
-        result = frame.sort_values(by=["A", "B"], ascending=False)
-        indexer = np.lexsort(
-            (frame["B"].rank(ascending=False), frame["A"].rank(ascending=False))
-        )
-        expected = frame.take(indexer)
-        assert_frame_equal(result, expected)
-
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            frame.sort_index(by=["B", "A"])
-        result = frame.sort_values(by=["B", "A"])
-        indexer = np.lexsort((frame["A"], frame["B"]))
-        expected = frame.take(indexer)
-        assert_frame_equal(result, expected)
-
-    def test_sort_index_inplace(self):
-        frame = DataFrame(
-            np.random.randn(4, 4), index=[1, 2, 3, 4], columns=["A", "B", "C", "D"]
-        )
-
-        # axis=0
-        unordered = frame.loc[[3, 2, 4, 1]]
-        a_id = id(unordered["A"])
-        df = unordered.copy()
-        df.sort_index(inplace=True)
-        expected = frame
-        assert_frame_equal(df, expected)
-        assert a_id != id(df["A"])
-
-        df = unordered.copy()
-        df.sort_index(ascending=False, inplace=True)
-        expected = frame[::-1]
-        assert_frame_equal(df, expected)
-
-        # axis=1
-        unordered = frame.loc[:, ["D", "B", "C", "A"]]
-        df = unordered.copy()
-        df.sort_index(axis=1, inplace=True)
-        expected = frame
-        assert_frame_equal(df, expected)
-
-        df = unordered.copy()
-        df.sort_index(axis=1, ascending=False, inplace=True)
-        expected = frame.iloc[:, ::-1]
-        assert_frame_equal(df, expected)
-
-    def test_sort_index_different_sortorder(self):
-        A = np.arange(20).repeat(5)
-        B = np.tile(np.arange(5), 20)
-
-        indexer = np.random.permutation(100)
-        A = A.take(indexer)
-        B = B.take(indexer)
-
-        df = DataFrame({"A": A, "B": B, "C": np.random.randn(100)})
-
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            df.sort_index(by=["A", "B"], ascending=[1, 0])
-        result = df.sort_values(by=["A", "B"], ascending=[1, 0])
-
-        ex_indexer = np.lexsort((df.B.max() - df.B, df.A))
-        expected = df.take(ex_indexer)
-        assert_frame_equal(result, expected)
-
-        # test with multiindex, too
-        idf = df.set_index(["A", "B"])
-
-        result = idf.sort_index(ascending=[1, 0])
-        expected = idf.take(ex_indexer)
-        assert_frame_equal(result, expected)
-
-        # also, Series!
-        result = idf["C"].sort_index(ascending=[1, 0])
-        assert_series_equal(result, expected["C"])
-
-    def test_sort_index_duplicates(self):
-
-        # with 9816, these are all translated to .sort_values
-
-        df = DataFrame([range(5, 9), range(4)], columns=["a", "a", "b", "b"])
-
-        with pytest.raises(ValueError, match="not unique"):
-            # use .sort_values #9816
-            with tm.assert_produces_warning(FutureWarning):
-                df.sort_index(by="a")
-        with pytest.raises(ValueError, match="not unique"):
-            df.sort_values(by="a")
-
-        with pytest.raises(ValueError, match="not unique"):
-            # use .sort_values #9816
-            with tm.assert_produces_warning(FutureWarning):
-                df.sort_index(by=["a"])
-        with pytest.raises(ValueError, match="not unique"):
-            df.sort_values(by=["a"])
-
-        with pytest.raises(ValueError, match="not unique"):
-            # use .sort_values #9816
-            with tm.assert_produces_warning(FutureWarning):
-                # multi-column 'by' is separate codepath
-                df.sort_index(by=["a", "b"])
-        with pytest.raises(ValueError, match="not unique"):
-            # multi-column 'by' is separate codepath
-            df.sort_values(by=["a", "b"])
-
-        # with multi-index
-        # GH4370
-        df = DataFrame(
-            np.random.randn(4, 2), columns=MultiIndex.from_tuples([("a", 0), ("a", 1)])
-        )
-        with pytest.raises(ValueError, match="level"):
-            # use .sort_values #9816
-            with tm.assert_produces_warning(FutureWarning):
-                df.sort_index(by="a")
-        with pytest.raises(ValueError, match="level"):
-            df.sort_values(by="a")
-
-        # convert tuples to a list of tuples
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            df.sort_index(by=[("a", 1)])
-        expected = df.sort_values(by=[("a", 1)])
-
-        # use .sort_values #9816
-        with tm.assert_produces_warning(FutureWarning):
-            df.sort_index(by=("a", 1))
-        result = df.sort_values(by=("a", 1))
-        assert_frame_equal(result, expected)
-
-    def test_sort_index_level(self):
-        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
-        df = DataFrame([[1, 2], [3, 4]], mi)
-
-        result = df.sort_index(level="A", sort_remaining=False)
-        expected = df
-        assert_frame_equal(result, expected)
-
-        result = df.sort_index(level=["A", "B"], sort_remaining=False)
-        expected = df
-        assert_frame_equal(result, expected)
-
-        # Error thrown by sort_index when
-        # first index is sorted last (#26053)
-        result = df.sort_index(level=["C", "B", "A"])
-        expected = df.iloc[[1, 0]]
-        assert_frame_equal(result, expected)
-
-        result = df.sort_index(level=["B", "C", "A"])
-        expected = df.iloc[[1, 0]]
-        assert_frame_equal(result, expected)
-
-        result = df.sort_index(level=["C", "A"])
-        expected = df.iloc[[1, 0]]
-        assert_frame_equal(result, expected)
-
-    def test_sort_index_categorical_index(self):
-
-        df = DataFrame(
-            {
-                "A": np.arange(6, dtype="int64"),
-                "B": Series(list("aabbca")).astype(CategoricalDtype(list("cab"))),
-            }
-        ).set_index("B")
-
-        result = df.sort_index()
-        expected = df.iloc[[4, 0, 1, 5, 2, 3]]
-        assert_frame_equal(result, expected)
-
-        result = df.sort_index(ascending=False)
-        expected = df.iloc[[2, 3, 0, 1, 5, 4]]
-        assert_frame_equal(result, expected)
-
-    def test_sort_index(self):
-        # GH13496
-
-        frame = DataFrame(
-            np.arange(16).reshape(4, 4),
-            index=[1, 2, 3, 4],
-            columns=["A", "B", "C", "D"],
-        )
-
-        # axis=0 : sort rows by index labels
-        unordered = frame.loc[[3, 2, 4, 1]]
-        result = unordered.sort_index(axis=0)
-        expected = frame
-        assert_frame_equal(result, expected)
-
-        result = unordered.sort_index(ascending=False)
-        expected = frame[::-1]
-        assert_frame_equal(result, expected)
-
-        # axis=1 : sort columns by column names
-        unordered = frame.iloc[:, [2, 1, 3, 0]]
-        result = unordered.sort_index(axis=1)
-        assert_frame_equal(result, frame)
-
-        result = unordered.sort_index(axis=1, ascending=False)
-        expected = frame.iloc[:, ::-1]
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize("level", ["A", 0])  # GH 21052
-    def test_sort_index_multiindex(self, level):
-        # GH13496
-
-        # sort rows by specified level of multi-index
-        mi = MultiIndex.from_tuples(
-            [[2, 1, 3], [2, 1, 2], [1, 1, 1]], names=list("ABC")
-        )
-        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=mi)
-
-        expected_mi = MultiIndex.from_tuples(
-            [[1, 1, 1], [2, 1, 2], [2, 1, 3]], names=list("ABC")
-        )
-        expected = pd.DataFrame([[5, 6], [3, 4], [1, 2]], index=expected_mi)
-        result = df.sort_index(level=level)
-        assert_frame_equal(result, expected)
-
-        # sort_remaining=False
-        expected_mi = MultiIndex.from_tuples(
-            [[1, 1, 1], [2, 1, 3], [2, 1, 2]], names=list("ABC")
-        )
-        expected = pd.DataFrame([[5, 6], [1, 2], [3, 4]], index=expected_mi)
-        result = df.sort_index(level=level, sort_remaining=False)
-        assert_frame_equal(result, expected)
-
-    def test_sort_index_intervalindex(self):
-        # this is a de-facto sort via unstack
-        # confirming that we sort in the order of the bins
-        y = Series(np.random.randn(100))
-        x1 = Series(np.sign(np.random.randn(100)))
-        x2 = pd.cut(Series(np.random.randn(100)), bins=[-3, -0.5, 0, 0.5, 3])
-        model = pd.concat([y, x1, x2], axis=1, keys=["Y", "X1", "X2"])
-
-        result = model.groupby(["X1", "X2"], observed=True).mean().unstack()
-        expected = IntervalIndex.from_tuples(
-            [(-3.0, -0.5), (-0.5, 0.0), (0.0, 0.5), (0.5, 3.0)], closed="right"
-        )
-        result = result.columns.levels[1].categories
-        tm.assert_index_equal(result, expected)
-
-    def test_sort_index_na_position_with_categories(self):
-        # GH 22556
-        # Positioning missing value properly when column is Categorical.
-        categories = ["A", "B", "C"]
-        category_indices = [0, 2, 4]
-        list_of_nans = [np.nan, np.nan]
-        na_indices = [1, 3]
-        na_position_first = "first"
-        na_position_last = "last"
-        column_name = "c"
-
-        reversed_categories = sorted(categories, reverse=True)
-        reversed_category_indices = sorted(category_indices, reverse=True)
-        reversed_na_indices = sorted(na_indices)
-
-        df = pd.DataFrame(
-            {
-                column_name: pd.Categorical(
-                    ["A", np.nan, "B", np.nan, "C"], categories=categories, ordered=True
-                )
-            }
-        )
-        # sort ascending with na first
-        result = df.sort_values(
-            by=column_name, ascending=True, na_position=na_position_first
-        )
-        expected = DataFrame(
-            {
-                column_name: Categorical(
-                    list_of_nans + categories, categories=categories, ordered=True
-                )
-            },
-            index=na_indices + category_indices,
-        )
-
-        assert_frame_equal(result, expected)
-
-        # sort ascending with na last
-        result = df.sort_values(
-            by=column_name, ascending=True, na_position=na_position_last
-        )
-        expected = DataFrame(
-            {
-                column_name: Categorical(
-                    categories + list_of_nans, categories=categories, ordered=True
-                )
-            },
-            index=category_indices + na_indices,
-        )
-
-        assert_frame_equal(result, expected)
-
-        # sort descending with na first
-        result = df.sort_values(
-            by=column_name, ascending=False, na_position=na_position_first
-        )
-        expected = DataFrame(
-            {
-                column_name: Categorical(
-                    list_of_nans + reversed_categories,
-                    categories=categories,
-                    ordered=True,
-                )
-            },
-            index=reversed_na_indices + reversed_category_indices,
-        )
-
-        assert_frame_equal(result, expected)
-
-        # sort descending with na last
-        result = df.sort_values(
-            by=column_name, ascending=False, na_position=na_position_last
-        )
-        expected = DataFrame(
-            {
-                column_name: Categorical(
-                    reversed_categories + list_of_nans,
-                    categories=categories,
-                    ordered=True,
-                )
-            },
-            index=reversed_category_indices + reversed_na_indices,
-        )
-
-        assert_frame_equal(result, expected)
-
-    def test_sort_index_na_position_with_categories_raises(self):
-        df = pd.DataFrame(
-            {
-                "c": pd.Categorical(
-                    ["A", np.nan, "B", np.nan, "C"],
-                    categories=["A", "B", "C"],
-                    ordered=True,
-                )
-            }
-        )
-
-        with pytest.raises(ValueError):
-            df.sort_values(by="c", ascending=False, na_position="bad_position")
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index c66a97c2b294b..a2e7dc527c4b8 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -3,11 +3,10 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
-class TestDataFrameSubclassing(TestData):
+class TestDataFrameSubclassing:
     def test_frame_subclassing_and_slicing(self):
         # Subclass frame and ensure it returns the right class on slicing it
         # In reference to PR 9632
@@ -190,38 +189,6 @@ def test_subclass_iterrows(self):
             assert isinstance(row, tm.SubclassedSeries)
             tm.assert_series_equal(row, df.loc[i])
 
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_subclass_sparse_slice(self):
-        rows = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]
-        ssdf = tm.SubclassedSparseDataFrame(rows)
-        ssdf.testattr = "testattr"
-
-        tm.assert_sp_frame_equal(ssdf.loc[:2], tm.SubclassedSparseDataFrame(rows[:3]))
-        tm.assert_sp_frame_equal(ssdf.iloc[:2], tm.SubclassedSparseDataFrame(rows[:2]))
-        tm.assert_sp_frame_equal(ssdf[:2], tm.SubclassedSparseDataFrame(rows[:2]))
-        assert ssdf.loc[:2].testattr == "testattr"
-        assert ssdf.iloc[:2].testattr == "testattr"
-        assert ssdf[:2].testattr == "testattr"
-
-        tm.assert_sp_series_equal(
-            ssdf.loc[1],
-            tm.SubclassedSparseSeries(rows[1]),
-            check_names=False,
-            check_kind=False,
-        )
-        tm.assert_sp_series_equal(
-            ssdf.iloc[1],
-            tm.SubclassedSparseSeries(rows[1]),
-            check_names=False,
-            check_kind=False,
-        )
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_subclass_sparse_transpose(self):
-        ossdf = tm.SubclassedSparseDataFrame([[1, 2, 3], [4, 5, 6]])
-        essdf = tm.SubclassedSparseDataFrame([[1, 4], [2, 5], [3, 6]])
-        tm.assert_sp_frame_equal(ossdf.T, essdf)
-
     def test_subclass_stack(self):
         # GH 15564
         df = tm.SubclassedDataFrame(
@@ -590,3 +557,17 @@ def strech(row):
         result = df.apply(lambda x: [1, 2, 3], axis=1)
         assert not isinstance(result, tm.SubclassedDataFrame)
         tm.assert_series_equal(result, expected)
+
+    def test_subclassed_numeric_reductions(self, all_numeric_reductions):
+        # GH 25596
+
+        df = tm.SubclassedDataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
+        result = getattr(df, all_numeric_reductions)()
+        assert isinstance(result, tm.SubclassedSeries)
+
+    def test_subclassed_boolean_reductions(self, all_boolean_reductions):
+        # GH 25596
+
+        df = tm.SubclassedDataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
+        result = getattr(df, all_boolean_reductions)()
+        assert isinstance(result, tm.SubclassedSeries)
diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py
index b8708e6ca1871..e89f4ee07ea00 100644
--- a/pandas/tests/frame/test_timeseries.py
+++ b/pandas/tests/frame/test_timeseries.py
@@ -12,18 +12,11 @@
     Index,
     MultiIndex,
     Series,
-    Timestamp,
     date_range,
     period_range,
     to_datetime,
 )
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-)
+import pandas._testing as tm
 
 import pandas.tseries.offsets as offsets
 
@@ -33,169 +26,7 @@ def close_open_fixture(request):
     return request.param
 
 
-class TestDataFrameTimeSeriesMethods(TestData):
-    def test_diff(self):
-        the_diff = self.tsframe.diff(1)
-
-        assert_series_equal(
-            the_diff["A"], self.tsframe["A"] - self.tsframe["A"].shift(1)
-        )
-
-        # int dtype
-        a = 10000000000000000
-        b = a + 1
-        s = Series([a, b])
-
-        rs = DataFrame({"s": s}).diff()
-        assert rs.s[1] == 1
-
-        # mixed numeric
-        tf = self.tsframe.astype("float32")
-        the_diff = tf.diff(1)
-        assert_series_equal(the_diff["A"], tf["A"] - tf["A"].shift(1))
-
-        # issue 10907
-        df = pd.DataFrame({"y": pd.Series([2]), "z": pd.Series([3])})
-        df.insert(0, "x", 1)
-        result = df.diff(axis=1)
-        expected = pd.DataFrame(
-            {"x": np.nan, "y": pd.Series(1), "z": pd.Series(1)}
-        ).astype("float64")
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize("tz", [None, "UTC"])
-    def test_diff_datetime_axis0(self, tz):
-        # GH 18578
-        df = DataFrame(
-            {
-                0: date_range("2010", freq="D", periods=2, tz=tz),
-                1: date_range("2010", freq="D", periods=2, tz=tz),
-            }
-        )
-
-        result = df.diff(axis=0)
-        expected = DataFrame(
-            {
-                0: pd.TimedeltaIndex(["NaT", "1 days"]),
-                1: pd.TimedeltaIndex(["NaT", "1 days"]),
-            }
-        )
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize("tz", [None, "UTC"])
-    def test_diff_datetime_axis1(self, tz):
-        # GH 18578
-        df = DataFrame(
-            {
-                0: date_range("2010", freq="D", periods=2, tz=tz),
-                1: date_range("2010", freq="D", periods=2, tz=tz),
-            }
-        )
-        if tz is None:
-            result = df.diff(axis=1)
-            expected = DataFrame(
-                {
-                    0: pd.TimedeltaIndex(["NaT", "NaT"]),
-                    1: pd.TimedeltaIndex(["0 days", "0 days"]),
-                }
-            )
-            assert_frame_equal(result, expected)
-        else:
-            with pytest.raises(NotImplementedError):
-                result = df.diff(axis=1)
-
-    def test_diff_timedelta(self):
-        # GH 4533
-        df = DataFrame(
-            dict(
-                time=[Timestamp("20130101 9:01"), Timestamp("20130101 9:02")],
-                value=[1.0, 2.0],
-            )
-        )
-
-        res = df.diff()
-        exp = DataFrame(
-            [[pd.NaT, np.nan], [pd.Timedelta("00:01:00"), 1]], columns=["time", "value"]
-        )
-        assert_frame_equal(res, exp)
-
-    def test_diff_mixed_dtype(self):
-        df = DataFrame(np.random.randn(5, 3))
-        df["A"] = np.array([1, 2, 3, 4, 5], dtype=object)
-
-        result = df.diff()
-        assert result[0].dtype == np.float64
-
-    def test_diff_neg_n(self):
-        rs = self.tsframe.diff(-1)
-        xp = self.tsframe - self.tsframe.shift(-1)
-        assert_frame_equal(rs, xp)
-
-    def test_diff_float_n(self):
-        rs = self.tsframe.diff(1.0)
-        xp = self.tsframe.diff(1)
-        assert_frame_equal(rs, xp)
-
-    def test_diff_axis(self):
-        # GH 9727
-        df = DataFrame([[1.0, 2.0], [3.0, 4.0]])
-        assert_frame_equal(df.diff(axis=1), DataFrame([[np.nan, 1.0], [np.nan, 1.0]]))
-        assert_frame_equal(df.diff(axis=0), DataFrame([[np.nan, np.nan], [2.0, 2.0]]))
-
-    def test_pct_change(self):
-        rs = self.tsframe.pct_change(fill_method=None)
-        assert_frame_equal(rs, self.tsframe / self.tsframe.shift(1) - 1)
-
-        rs = self.tsframe.pct_change(2)
-        filled = self.tsframe.fillna(method="pad")
-        assert_frame_equal(rs, filled / filled.shift(2) - 1)
-
-        rs = self.tsframe.pct_change(fill_method="bfill", limit=1)
-        filled = self.tsframe.fillna(method="bfill", limit=1)
-        assert_frame_equal(rs, filled / filled.shift(1) - 1)
-
-        rs = self.tsframe.pct_change(freq="5D")
-        filled = self.tsframe.fillna(method="pad")
-        assert_frame_equal(
-            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
-        )
-
-    def test_pct_change_shift_over_nas(self):
-        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
-
-        df = DataFrame({"a": s, "b": s})
-
-        chg = df.pct_change()
-        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
-        edf = DataFrame({"a": expected, "b": expected})
-        assert_frame_equal(chg, edf)
-
-    @pytest.mark.parametrize(
-        "freq, periods, fill_method, limit",
-        [
-            ("5B", 5, None, None),
-            ("3B", 3, None, None),
-            ("3B", 3, "bfill", None),
-            ("7B", 7, "pad", 1),
-            ("7B", 7, "bfill", 3),
-            ("14B", 14, None, None),
-        ],
-    )
-    def test_pct_change_periods_freq(self, freq, periods, fill_method, limit):
-        # GH 7292
-        rs_freq = self.tsframe.pct_change(
-            freq=freq, fill_method=fill_method, limit=limit
-        )
-        rs_periods = self.tsframe.pct_change(
-            periods, fill_method=fill_method, limit=limit
-        )
-        assert_frame_equal(rs_freq, rs_periods)
-
-        empty_ts = DataFrame(index=self.tsframe.index, columns=self.tsframe.columns)
-        rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
-        rs_periods = empty_ts.pct_change(periods, fill_method=fill_method, limit=limit)
-        assert_frame_equal(rs_freq, rs_periods)
-
+class TestDataFrameTimeSeriesMethods:
     def test_frame_ctor_datetime64_column(self):
         rng = date_range("1/1/2000 00:00:00", "1/1/2000 1:59:50", freq="10s")
         dates = np.asarray(rng)
@@ -249,270 +80,9 @@ def test_frame_append_datetime64_col_other_units(self):
 
             assert (tmp["dates"].values == ex_vals).all()
 
-    def test_shift(self):
-        # naive shift
-        shiftedFrame = self.tsframe.shift(5)
-        tm.assert_index_equal(shiftedFrame.index, self.tsframe.index)
-
-        shiftedSeries = self.tsframe["A"].shift(5)
-        assert_series_equal(shiftedFrame["A"], shiftedSeries)
-
-        shiftedFrame = self.tsframe.shift(-5)
-        tm.assert_index_equal(shiftedFrame.index, self.tsframe.index)
-
-        shiftedSeries = self.tsframe["A"].shift(-5)
-        assert_series_equal(shiftedFrame["A"], shiftedSeries)
-
-        # shift by 0
-        unshifted = self.tsframe.shift(0)
-        assert_frame_equal(unshifted, self.tsframe)
-
-        # shift by DateOffset
-        shiftedFrame = self.tsframe.shift(5, freq=offsets.BDay())
-        assert len(shiftedFrame) == len(self.tsframe)
-
-        shiftedFrame2 = self.tsframe.shift(5, freq="B")
-        assert_frame_equal(shiftedFrame, shiftedFrame2)
-
-        d = self.tsframe.index[0]
-        shifted_d = d + offsets.BDay(5)
-        assert_series_equal(
-            self.tsframe.xs(d), shiftedFrame.xs(shifted_d), check_names=False
-        )
-
-        # shift int frame
-        int_shifted = self.intframe.shift(1)  # noqa
-
-        # Shifting with PeriodIndex
-        ps = tm.makePeriodFrame()
-        shifted = ps.shift(1)
-        unshifted = shifted.shift(-1)
-        tm.assert_index_equal(shifted.index, ps.index)
-        tm.assert_index_equal(unshifted.index, ps.index)
-        tm.assert_numpy_array_equal(
-            unshifted.iloc[:, 0].dropna().values, ps.iloc[:-1, 0].values
-        )
-
-        shifted2 = ps.shift(1, "B")
-        shifted3 = ps.shift(1, offsets.BDay())
-        assert_frame_equal(shifted2, shifted3)
-        assert_frame_equal(ps, shifted2.shift(-1, "B"))
-
-        msg = "does not match PeriodIndex freq"
-        with pytest.raises(ValueError, match=msg):
-            ps.shift(freq="D")
-
-        # shift other axis
-        # GH 6371
-        df = DataFrame(np.random.rand(10, 5))
-        expected = pd.concat(
-            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
-            ignore_index=True,
-            axis=1,
-        )
-        result = df.shift(1, axis=1)
-        assert_frame_equal(result, expected)
-
-        # shift named axis
-        df = DataFrame(np.random.rand(10, 5))
-        expected = pd.concat(
-            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
-            ignore_index=True,
-            axis=1,
-        )
-        result = df.shift(1, axis="columns")
-        assert_frame_equal(result, expected)
-
-    def test_shift_bool(self):
-        df = DataFrame({"high": [True, False], "low": [False, False]})
-        rs = df.shift(1)
-        xp = DataFrame(
-            np.array([[np.nan, np.nan], [True, False]], dtype=object),
-            columns=["high", "low"],
-        )
-        assert_frame_equal(rs, xp)
-
-    def test_shift_categorical(self):
-        # GH 9416
-        s1 = pd.Series(["a", "b", "c"], dtype="category")
-        s2 = pd.Series(["A", "B", "C"], dtype="category")
-        df = DataFrame({"one": s1, "two": s2})
-        rs = df.shift(1)
-        xp = DataFrame({"one": s1.shift(1), "two": s2.shift(1)})
-        assert_frame_equal(rs, xp)
-
-    def test_shift_fill_value(self):
-        # GH #24128
-        df = DataFrame(
-            [1, 2, 3, 4, 5], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-        exp = DataFrame(
-            [0, 1, 2, 3, 4], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-        result = df.shift(1, fill_value=0)
-        assert_frame_equal(result, exp)
-
-        exp = DataFrame(
-            [0, 0, 1, 2, 3], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-        result = df.shift(2, fill_value=0)
-        assert_frame_equal(result, exp)
-
-    def test_shift_empty(self):
-        # Regression test for #8019
-        df = DataFrame({"foo": []})
-        rs = df.shift(-1)
-
-        assert_frame_equal(df, rs)
-
-    def test_shift_duplicate_columns(self):
-        # GH 9092; verify that position-based shifting works
-        # in the presence of duplicate columns
-        column_lists = [list(range(5)), [1] * 5, [1, 1, 2, 2, 1]]
-        data = np.random.randn(20, 5)
-
-        shifted = []
-        for columns in column_lists:
-            df = pd.DataFrame(data.copy(), columns=columns)
-            for s in range(5):
-                df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
-            df.columns = range(5)
-            shifted.append(df)
-
-        # sanity check the base case
-        nulls = shifted[0].isna().sum()
-        assert_series_equal(nulls, Series(range(1, 6), dtype="int64"))
-
-        # check all answers are the same
-        assert_frame_equal(shifted[0], shifted[1])
-        assert_frame_equal(shifted[0], shifted[2])
-
-    def test_tshift(self):
-        # PeriodIndex
-        ps = tm.makePeriodFrame()
-        shifted = ps.tshift(1)
-        unshifted = shifted.tshift(-1)
-
-        assert_frame_equal(unshifted, ps)
-
-        shifted2 = ps.tshift(freq="B")
-        assert_frame_equal(shifted, shifted2)
-
-        shifted3 = ps.tshift(freq=offsets.BDay())
-        assert_frame_equal(shifted, shifted3)
-
-        with pytest.raises(ValueError, match="does not match"):
-            ps.tshift(freq="M")
-
-        # DatetimeIndex
-        shifted = self.tsframe.tshift(1)
-        unshifted = shifted.tshift(-1)
-
-        assert_frame_equal(self.tsframe, unshifted)
-
-        shifted2 = self.tsframe.tshift(freq=self.tsframe.index.freq)
-        assert_frame_equal(shifted, shifted2)
-
-        inferred_ts = DataFrame(
-            self.tsframe.values,
-            Index(np.asarray(self.tsframe.index)),
-            columns=self.tsframe.columns,
-        )
-        shifted = inferred_ts.tshift(1)
-        unshifted = shifted.tshift(-1)
-        assert_frame_equal(shifted, self.tsframe.tshift(1))
-        assert_frame_equal(unshifted, inferred_ts)
-
-        no_freq = self.tsframe.iloc[[0, 5, 7], :]
-        msg = "Freq was not given and was not set in the index"
-        with pytest.raises(ValueError, match=msg):
-            no_freq.tshift()
-
-    def test_truncate(self):
-        ts = self.tsframe[::3]
-
-        start, end = self.tsframe.index[3], self.tsframe.index[6]
-
-        start_missing = self.tsframe.index[2]
-        end_missing = self.tsframe.index[7]
-
-        # neither specified
-        truncated = ts.truncate()
-        assert_frame_equal(truncated, ts)
-
-        # both specified
-        expected = ts[1:3]
-
-        truncated = ts.truncate(start, end)
-        assert_frame_equal(truncated, expected)
-
-        truncated = ts.truncate(start_missing, end_missing)
-        assert_frame_equal(truncated, expected)
-
-        # start specified
-        expected = ts[1:]
-
-        truncated = ts.truncate(before=start)
-        assert_frame_equal(truncated, expected)
-
-        truncated = ts.truncate(before=start_missing)
-        assert_frame_equal(truncated, expected)
-
-        # end specified
-        expected = ts[:3]
-
-        truncated = ts.truncate(after=end)
-        assert_frame_equal(truncated, expected)
-
-        truncated = ts.truncate(after=end_missing)
-        assert_frame_equal(truncated, expected)
-
-        msg = "Truncate: 2000-01-06 00:00:00 must be after 2000-02-04 00:00:00"
-        with pytest.raises(ValueError, match=msg):
-            ts.truncate(
-                before=ts.index[-1] - ts.index.freq, after=ts.index[0] + ts.index.freq
-            )
-
-    def test_truncate_copy(self):
-        index = self.tsframe.index
-        truncated = self.tsframe.truncate(index[5], index[10])
-        truncated.values[:] = 5.0
-        assert not (self.tsframe.values[5:11] == 5).any()
-
-    def test_truncate_nonsortedindex(self):
-        # GH 17935
-
-        df = pd.DataFrame({"A": ["a", "b", "c", "d", "e"]}, index=[5, 3, 2, 9, 0])
-        msg = "truncate requires a sorted index"
-        with pytest.raises(ValueError, match=msg):
-            df.truncate(before=3, after=9)
-
-        rng = pd.date_range("2011-01-01", "2012-01-01", freq="W")
-        ts = pd.DataFrame(
-            {"A": np.random.randn(len(rng)), "B": np.random.randn(len(rng))}, index=rng
-        )
-        msg = "truncate requires a sorted index"
-        with pytest.raises(ValueError, match=msg):
-            ts.sort_values("A", ascending=False).truncate(
-                before="2011-11", after="2011-12"
-            )
-
-        df = pd.DataFrame(
-            {
-                3: np.random.randn(5),
-                20: np.random.randn(5),
-                2: np.random.randn(5),
-                0: np.random.randn(5),
-            },
-            columns=[3, 20, 2, 0],
-        )
-        msg = "truncate requires a sorted index"
-        with pytest.raises(ValueError, match=msg):
-            df.truncate(before=2, after=20, axis=1)
-
-    def test_asfreq(self):
-        offset_monthly = self.tsframe.asfreq(offsets.BMonthEnd())
-        rule_monthly = self.tsframe.asfreq("BM")
+    def test_asfreq(self, datetime_frame):
+        offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd())
+        rule_monthly = datetime_frame.asfreq("BM")
 
         tm.assert_almost_equal(offset_monthly["A"], rule_monthly["A"])
 
@@ -523,7 +93,7 @@ def test_asfreq(self):
         filled_dep = rule_monthly.asfreq("B", method="pad")  # noqa
 
         # test does not blow up on length-0 DataFrame
-        zero_length = self.tsframe.reindex([])
+        zero_length = datetime_frame.reindex([])
         result = zero_length.asfreq("BM")
         assert result is not zero_length
 
@@ -552,11 +122,11 @@ def test_asfreq_fillvalue(self):
         actual_df = df.asfreq(freq="1S", fill_value=9.0)
         expected_df = df.asfreq(freq="1S").fillna(9.0)
         expected_df.loc["2016-01-01 00:00:08", "one"] = None
-        assert_frame_equal(expected_df, actual_df)
+        tm.assert_frame_equal(expected_df, actual_df)
 
         expected_series = ts.asfreq(freq="1S").fillna(9.0)
         actual_series = ts.asfreq(freq="1S", fill_value=9.0)
-        assert_series_equal(expected_series, actual_series)
+        tm.assert_series_equal(expected_series, actual_series)
 
     @pytest.mark.parametrize(
         "data,idx,expected_first,expected_last",
@@ -569,13 +139,15 @@ def test_asfreq_fillvalue(self):
             ({"A": [1, np.nan, 3]}, [1, 2, 2], 1, 2),
         ],
     )
-    def test_first_last_valid(self, data, idx, expected_first, expected_last):
-        N = len(self.frame.index)
+    def test_first_last_valid(
+        self, float_frame, data, idx, expected_first, expected_last
+    ):
+        N = len(float_frame.index)
         mat = np.random.randn(N)
         mat[:5] = np.nan
         mat[-5:] = np.nan
 
-        frame = DataFrame({"foo": mat}, index=self.frame.index)
+        frame = DataFrame({"foo": mat}, index=float_frame.index)
         index = frame.first_valid_index()
 
         assert index == frame.index[5]
@@ -607,6 +179,14 @@ def test_first_last_valid(self, data, idx, expected_first, expected_last):
         assert expected_first == df.first_valid_index()
         assert expected_last == df.last_valid_index()
 
+    @pytest.mark.parametrize("klass", [Series, DataFrame])
+    def test_first_valid_index_all_nan(self, klass):
+        # GH#9752 Series/DataFrame should both return None, not raise
+        obj = klass([np.nan])
+
+        assert obj.first_valid_index() is None
+        assert obj.iloc[:0].first_valid_index() is None
+
     def test_first_subset(self):
         ts = tm.makeTimeDataFrame(freq="12h")
         result = ts.first("10d")
@@ -618,14 +198,14 @@ def test_first_subset(self):
 
         result = ts.first("3M")
         expected = ts[:"3/31/2000"]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = ts.first("21D")
         expected = ts[:21]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = ts[:0].first("3M")
-        assert_frame_equal(result, ts[:0])
+        tm.assert_frame_equal(result, ts[:0])
 
     def test_first_raises(self):
         # GH20725
@@ -644,14 +224,14 @@ def test_last_subset(self):
 
         result = ts.last("21D")
         expected = ts["2000-01-10":]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = ts.last("21D")
         expected = ts[-21:]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = ts[:0].last("3M")
-        assert_frame_equal(result, ts[:0])
+        tm.assert_frame_equal(result, ts[:0])
 
     def test_last_raises(self):
         # GH20725
@@ -669,19 +249,19 @@ def test_at_time(self):
 
         result = ts.at_time("9:30")
         expected = ts.at_time(time(9, 30))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = ts.loc[time(9, 30)]
         expected = ts.loc[(rng.hour == 9) & (rng.minute == 30)]
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # midnight, everything
         rng = date_range("1/1/2000", "1/31/2000")
         ts = DataFrame(np.random.randn(len(rng), 3), index=rng)
 
         result = ts.at_time(time(0, 0))
-        assert_frame_equal(result, ts)
+        tm.assert_frame_equal(result, ts)
 
         # time doesn't exist
         rng = date_range("1/1/2012", freq="23Min", periods=384)
@@ -733,7 +313,7 @@ def test_at_time_axis(self, axis):
             expected = ts.loc[:, indices]
 
         result = ts.at_time("9:30", axis=axis)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_between_time(self, close_open_fixture):
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
@@ -764,7 +344,7 @@ def test_between_time(self, close_open_fixture):
 
         result = ts.between_time("00:00", "01:00")
         expected = ts.between_time(stime, etime)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # across midnight
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
@@ -887,7 +467,7 @@ def test_frame_to_period(self):
         pts = df.to_period()
         exp = df.copy()
         exp.index = pr
-        assert_frame_equal(pts, exp)
+        tm.assert_frame_equal(pts, exp)
 
         pts = df.to_period("M")
         tm.assert_index_equal(pts.index, exp.index.asfreq("M"))
@@ -896,7 +476,7 @@ def test_frame_to_period(self):
         pts = df.to_period(axis=1)
         exp = df.copy()
         exp.columns = pr
-        assert_frame_equal(pts, exp)
+        tm.assert_frame_equal(pts, exp)
 
         pts = df.to_period("M", axis=1)
         tm.assert_index_equal(pts.columns, exp.columns.asfreq("M"))
@@ -923,7 +503,7 @@ def test_tz_convert_and_localize(self, fn):
 
             df1 = DataFrame(np.ones(5), index=l0)
             df1 = getattr(df1, fn)("US/Pacific")
-            assert_index_equal(df1.index, l0_expected)
+            tm.assert_index_equal(df1.index, l0_expected)
 
             # MultiIndex
             # GH7846
@@ -931,14 +511,14 @@ def test_tz_convert_and_localize(self, fn):
 
             df3 = getattr(df2, fn)("US/Pacific", level=0)
             assert not df3.index.levels[0].equals(l0)
-            assert_index_equal(df3.index.levels[0], l0_expected)
-            assert_index_equal(df3.index.levels[1], l1)
+            tm.assert_index_equal(df3.index.levels[0], l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1)
             assert not df3.index.levels[1].equals(l1_expected)
 
             df3 = getattr(df2, fn)("US/Pacific", level=1)
-            assert_index_equal(df3.index.levels[0], l0)
+            tm.assert_index_equal(df3.index.levels[0], l0)
             assert not df3.index.levels[0].equals(l0_expected)
-            assert_index_equal(df3.index.levels[1], l1_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
             assert not df3.index.levels[1].equals(l1)
 
             df4 = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
@@ -946,9 +526,9 @@ def test_tz_convert_and_localize(self, fn):
             # TODO: untested
             df5 = getattr(df4, fn)("US/Pacific", level=1)  # noqa
 
-            assert_index_equal(df3.index.levels[0], l0)
+            tm.assert_index_equal(df3.index.levels[0], l0)
             assert not df3.index.levels[0].equals(l0_expected)
-            assert_index_equal(df3.index.levels[1], l1_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
             assert not df3.index.levels[1].equals(l1)
 
         # Bad Inputs
diff --git a/pandas/tests/frame/test_timezones.py b/pandas/tests/frame/test_timezones.py
index 3e110a4b040da..b60f2052a988f 100644
--- a/pandas/tests/frame/test_timezones.py
+++ b/pandas/tests/frame/test_timezones.py
@@ -11,8 +11,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
 
 
 class TestDataFrameTimezones:
@@ -37,7 +37,7 @@ def test_frame_values_with_tz(self):
         expected = np.concatenate([expected, expected], axis=1)
         tm.assert_numpy_array_equal(result, expected)
 
-        # three columns, heterogenous
+        # three columns, heterogeneous
         est = "US/Eastern"
         df = df.assign(C=df.A.dt.tz_convert(est))
 
diff --git a/pandas/tests/frame/test_to_csv.py b/pandas/tests/frame/test_to_csv.py
index 8fb028a0f0326..aeff92971b42a 100644
--- a/pandas/tests/frame/test_to_csv.py
+++ b/pandas/tests/frame/test_to_csv.py
@@ -18,18 +18,10 @@
     read_csv,
     to_datetime,
 )
+import pandas._testing as tm
 import pandas.core.common as com
-from pandas.tests.frame.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-    ensure_clean,
-    makeCustomDataframe as mkdf,
-)
 
-from pandas.io.common import _get_handle
+from pandas.io.common import get_handle
 
 MIXED_FLOAT_DTYPES = ["float16", "float32", "float64"]
 MIXED_INT_DTYPES = [
@@ -44,37 +36,37 @@
 ]
 
 
-class TestDataFrameToCSV(TestData):
+class TestDataFrameToCSV:
     def read_csv(self, path, **kwargs):
         params = dict(index_col=0, parse_dates=True)
         params.update(**kwargs)
 
         return pd.read_csv(path, **params)
 
-    def test_to_csv_from_csv1(self):
+    def test_to_csv_from_csv1(self, float_frame, datetime_frame):
 
-        with ensure_clean("__tmp_to_csv_from_csv1__") as path:
-            self.frame["A"][:5] = np.nan
+        with tm.ensure_clean("__tmp_to_csv_from_csv1__") as path:
+            float_frame["A"][:5] = np.nan
 
-            self.frame.to_csv(path)
-            self.frame.to_csv(path, columns=["A", "B"])
-            self.frame.to_csv(path, header=False)
-            self.frame.to_csv(path, index=False)
+            float_frame.to_csv(path)
+            float_frame.to_csv(path, columns=["A", "B"])
+            float_frame.to_csv(path, header=False)
+            float_frame.to_csv(path, index=False)
 
             # test roundtrip
-            self.tsframe.to_csv(path)
+            datetime_frame.to_csv(path)
             recons = self.read_csv(path)
-            assert_frame_equal(self.tsframe, recons)
+            tm.assert_frame_equal(datetime_frame, recons)
 
-            self.tsframe.to_csv(path, index_label="index")
+            datetime_frame.to_csv(path, index_label="index")
             recons = self.read_csv(path, index_col=None)
 
-            assert len(recons.columns) == len(self.tsframe.columns) + 1
+            assert len(recons.columns) == len(datetime_frame.columns) + 1
 
             # no index
-            self.tsframe.to_csv(path, index=False)
+            datetime_frame.to_csv(path, index=False)
             recons = self.read_csv(path, index_col=None)
-            assert_almost_equal(self.tsframe.values, recons.values)
+            tm.assert_almost_equal(datetime_frame.values, recons.values)
 
             # corner case
             dm = DataFrame(
@@ -86,11 +78,11 @@ def test_to_csv_from_csv1(self):
             dm.to_csv(path)
 
             recons = self.read_csv(path)
-            assert_frame_equal(dm, recons)
+            tm.assert_frame_equal(dm, recons)
 
-    def test_to_csv_from_csv2(self):
+    def test_to_csv_from_csv2(self, float_frame):
 
-        with ensure_clean("__tmp_to_csv_from_csv2__") as path:
+        with tm.ensure_clean("__tmp_to_csv_from_csv2__") as path:
 
             # duplicate index
             df = DataFrame(
@@ -98,31 +90,31 @@ def test_to_csv_from_csv2(self):
             )
             df.to_csv(path)
             result = self.read_csv(path)
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
             midx = MultiIndex.from_tuples([("A", 1, 2), ("A", 1, 2), ("B", 1, 2)])
             df = DataFrame(np.random.randn(3, 3), index=midx, columns=["x", "y", "z"])
 
             df.to_csv(path)
             result = self.read_csv(path, index_col=[0, 1, 2], parse_dates=False)
-            assert_frame_equal(result, df, check_names=False)
+            tm.assert_frame_equal(result, df, check_names=False)
 
             # column aliases
             col_aliases = Index(["AA", "X", "Y", "Z"])
-            self.frame2.to_csv(path, header=col_aliases)
+            float_frame.to_csv(path, header=col_aliases)
 
             rs = self.read_csv(path)
-            xp = self.frame2.copy()
+            xp = float_frame.copy()
             xp.columns = col_aliases
-            assert_frame_equal(xp, rs)
+            tm.assert_frame_equal(xp, rs)
 
             msg = "Writing 4 cols but got 2 aliases"
             with pytest.raises(ValueError, match=msg):
-                self.frame2.to_csv(path, header=["AA", "X"])
+                float_frame.to_csv(path, header=["AA", "X"])
 
     def test_to_csv_from_csv3(self):
 
-        with ensure_clean("__tmp_to_csv_from_csv3__") as path:
+        with tm.ensure_clean("__tmp_to_csv_from_csv3__") as path:
             df1 = DataFrame(np.random.randn(3, 1))
             df2 = DataFrame(np.random.randn(3, 1))
 
@@ -132,11 +124,11 @@ def test_to_csv_from_csv3(self):
             rs = pd.read_csv(path, index_col=0)
             rs.columns = [int(label) for label in rs.columns]
             xp.columns = [int(label) for label in xp.columns]
-            assert_frame_equal(xp, rs)
+            tm.assert_frame_equal(xp, rs)
 
     def test_to_csv_from_csv4(self):
 
-        with ensure_clean("__tmp_to_csv_from_csv4__") as path:
+        with tm.ensure_clean("__tmp_to_csv_from_csv4__") as path:
             # GH 10833 (TimedeltaIndex formatting)
             dt = pd.Timedelta(seconds=1)
             df = pd.DataFrame(
@@ -151,24 +143,24 @@ def test_to_csv_from_csv4(self):
             result.index = result.index.rename("dt_index")
             result["dt_data"] = pd.to_timedelta(result["dt_data"])
 
-            assert_frame_equal(df, result, check_index_type=True)
+            tm.assert_frame_equal(df, result, check_index_type=True)
 
-    def test_to_csv_from_csv5(self):
+    def test_to_csv_from_csv5(self, timezone_frame):
 
         # tz, 8260
-        with ensure_clean("__tmp_to_csv_from_csv5__") as path:
+        with tm.ensure_clean("__tmp_to_csv_from_csv5__") as path:
 
-            self.tzframe.to_csv(path)
+            timezone_frame.to_csv(path)
             result = pd.read_csv(path, index_col=0, parse_dates=["A"])
 
             converter = (
                 lambda c: to_datetime(result[c])
                 .dt.tz_convert("UTC")
-                .dt.tz_convert(self.tzframe[c].dt.tz)
+                .dt.tz_convert(timezone_frame[c].dt.tz)
             )
             result["B"] = converter("B")
             result["C"] = converter("C")
-            assert_frame_equal(result, self.tzframe)
+            tm.assert_frame_equal(result, timezone_frame)
 
     def test_to_csv_cols_reordering(self):
         # GH3454
@@ -177,21 +169,21 @@ def test_to_csv_cols_reordering(self):
         chunksize = 5
         N = int(chunksize * 2.5)
 
-        df = mkdf(N, 3)
+        df = tm.makeCustomDataframe(N, 3)
         cs = df.columns
         cols = [cs[2], cs[0]]
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             df.to_csv(path, columns=cols, chunksize=chunksize)
             rs_c = pd.read_csv(path, index_col=0)
 
-        assert_frame_equal(df[cols], rs_c, check_names=False)
+        tm.assert_frame_equal(df[cols], rs_c, check_names=False)
 
     def test_to_csv_new_dupe_cols(self):
         import pandas as pd
 
         def _check_df(df, cols=None):
-            with ensure_clean() as path:
+            with tm.ensure_clean() as path:
                 df.to_csv(path, columns=cols, chunksize=chunksize)
                 rs_c = pd.read_csv(path, index_col=0)
 
@@ -209,20 +201,20 @@ def _check_df(df, cols=None):
                         obj_df = df[c]
                         obj_rs = rs_c[c]
                         if isinstance(obj_df, Series):
-                            assert_series_equal(obj_df, obj_rs)
+                            tm.assert_series_equal(obj_df, obj_rs)
                         else:
-                            assert_frame_equal(obj_df, obj_rs, check_names=False)
+                            tm.assert_frame_equal(obj_df, obj_rs, check_names=False)
 
                 # wrote in the same order
                 else:
                     rs_c.columns = df.columns
-                    assert_frame_equal(df, rs_c, check_names=False)
+                    tm.assert_frame_equal(df, rs_c, check_names=False)
 
         chunksize = 5
         N = int(chunksize * 2.5)
 
         # dupe cols
-        df = mkdf(N, 3)
+        df = tm.makeCustomDataframe(N, 3)
         df.columns = ["a", "a", "b"]
         _check_df(df, None)
 
@@ -253,12 +245,14 @@ def make_dtnat_arr(n, nnat=None):
         s2 = make_dtnat_arr(chunksize + 5, 0)
 
         # s3=make_dtnjat_arr(chunksize+5,0)
-        with ensure_clean("1.csv") as pth:
+        with tm.ensure_clean("1.csv") as pth:
             df = DataFrame(dict(a=s1, b=s2))
             df.to_csv(pth, chunksize=chunksize)
 
             recons = self.read_csv(pth)._convert(datetime=True, coerce=True)
-            assert_frame_equal(df, recons, check_names=False, check_less_precise=True)
+            tm.assert_frame_equal(
+                df, recons, check_names=False, check_less_precise=True
+            )
 
     @pytest.mark.slow
     def test_to_csv_moar(self):
@@ -272,13 +266,13 @@ def _do_test(
                     kwargs["index_col"] = list(range(rnlvl))
                 kwargs["header"] = list(range(cnlvl))
 
-                with ensure_clean("__tmp_to_csv_moar__") as path:
+                with tm.ensure_clean("__tmp_to_csv_moar__") as path:
                     df.to_csv(path, encoding="utf8", chunksize=chunksize)
                     recons = self.read_csv(path, **kwargs)
             else:
                 kwargs["header"] = 0
 
-                with ensure_clean("__tmp_to_csv_moar__") as path:
+                with tm.ensure_clean("__tmp_to_csv_moar__") as path:
                     df.to_csv(path, encoding="utf8", chunksize=chunksize)
                     recons = self.read_csv(path, **kwargs)
 
@@ -360,7 +354,9 @@ def _to_uni(x):
                     recons.columns = np.array(recons.columns, dtype=c_dtype)
                     df.columns = np.array(df.columns, dtype=c_dtype)
 
-            assert_frame_equal(df, recons, check_names=False, check_less_precise=True)
+            tm.assert_frame_equal(
+                df, recons, check_names=False, check_less_precise=True
+            )
 
         N = 100
         chunksize = 1000
@@ -383,7 +379,13 @@ def _to_uni(x):
                 base,
                 base + 1,
             ]:
-                _do_test(mkdf(nrows, ncols, r_idx_type="dt", c_idx_type="s"), "dt", "s")
+                _do_test(
+                    tm.makeCustomDataframe(
+                        nrows, ncols, r_idx_type="dt", c_idx_type="s"
+                    ),
+                    "dt",
+                    "s",
+                )
 
         for ncols in [4]:
             base = int((chunksize // ncols or 1) or 1)
@@ -403,7 +405,13 @@ def _to_uni(x):
                 base,
                 base + 1,
             ]:
-                _do_test(mkdf(nrows, ncols, r_idx_type="dt", c_idx_type="s"), "dt", "s")
+                _do_test(
+                    tm.makeCustomDataframe(
+                        nrows, ncols, r_idx_type="dt", c_idx_type="s"
+                    ),
+                    "dt",
+                    "s",
+                )
                 pass
 
         for r_idx_type, c_idx_type in [("i", "i"), ("s", "s"), ("u", "dt"), ("p", "p")]:
@@ -426,7 +434,7 @@ def _to_uni(x):
                     base + 1,
                 ]:
                     _do_test(
-                        mkdf(
+                        tm.makeCustomDataframe(
                             nrows, ncols, r_idx_type=r_idx_type, c_idx_type=c_idx_type
                         ),
                         r_idx_type,
@@ -451,10 +459,10 @@ def _to_uni(x):
                 base,
                 base + 1,
             ]:
-                _do_test(mkdf(nrows, ncols))
+                _do_test(tm.makeCustomDataframe(nrows, ncols))
 
         for nrows in [10, N - 2, N - 1, N, N + 1, N + 2]:
-            df = mkdf(nrows, 3)
+            df = tm.makeCustomDataframe(nrows, 3)
             cols = list(df.columns)
             cols[:2] = ["dupe", "dupe"]
             cols[-2:] = ["dupe", "dupe"]
@@ -466,7 +474,9 @@ def _to_uni(x):
             _do_test(df, dupe_col=True)
 
         _do_test(DataFrame(index=np.arange(10)))
-        _do_test(mkdf(chunksize // 2 + 1, 2, r_idx_nlevels=2), rnlvl=2)
+        _do_test(
+            tm.makeCustomDataframe(chunksize // 2 + 1, 2, r_idx_nlevels=2), rnlvl=2
+        )
         for ncols in [2, 3, 4]:
             base = int(chunksize // ncols)
             for nrows in [
@@ -485,58 +495,60 @@ def _to_uni(x):
                 base,
                 base + 1,
             ]:
-                _do_test(mkdf(nrows, ncols, r_idx_nlevels=2), rnlvl=2)
-                _do_test(mkdf(nrows, ncols, c_idx_nlevels=2), cnlvl=2)
+                _do_test(tm.makeCustomDataframe(nrows, ncols, r_idx_nlevels=2), rnlvl=2)
+                _do_test(tm.makeCustomDataframe(nrows, ncols, c_idx_nlevels=2), cnlvl=2)
                 _do_test(
-                    mkdf(nrows, ncols, r_idx_nlevels=2, c_idx_nlevels=2),
+                    tm.makeCustomDataframe(
+                        nrows, ncols, r_idx_nlevels=2, c_idx_nlevels=2
+                    ),
                     rnlvl=2,
                     cnlvl=2,
                 )
 
-    def test_to_csv_from_csv_w_some_infs(self):
+    def test_to_csv_from_csv_w_some_infs(self, float_frame):
 
         # test roundtrip with inf, -inf, nan, as full columns and mix
-        self.frame["G"] = np.nan
+        float_frame["G"] = np.nan
         f = lambda x: [np.inf, np.nan][np.random.rand() < 0.5]
-        self.frame["H"] = self.frame.index.map(f)
+        float_frame["H"] = float_frame.index.map(f)
 
-        with ensure_clean() as path:
-            self.frame.to_csv(path)
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
             recons = self.read_csv(path)
 
             # TODO to_csv drops column name
-            assert_frame_equal(self.frame, recons, check_names=False)
-            assert_frame_equal(
-                np.isinf(self.frame), np.isinf(recons), check_names=False
+            tm.assert_frame_equal(float_frame, recons, check_names=False)
+            tm.assert_frame_equal(
+                np.isinf(float_frame), np.isinf(recons), check_names=False
             )
 
-    def test_to_csv_from_csv_w_all_infs(self):
+    def test_to_csv_from_csv_w_all_infs(self, float_frame):
 
         # test roundtrip with inf, -inf, nan, as full columns and mix
-        self.frame["E"] = np.inf
-        self.frame["F"] = -np.inf
+        float_frame["E"] = np.inf
+        float_frame["F"] = -np.inf
 
-        with ensure_clean() as path:
-            self.frame.to_csv(path)
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
             recons = self.read_csv(path)
 
             # TODO to_csv drops column name
-            assert_frame_equal(self.frame, recons, check_names=False)
-            assert_frame_equal(
-                np.isinf(self.frame), np.isinf(recons), check_names=False
+            tm.assert_frame_equal(float_frame, recons, check_names=False)
+            tm.assert_frame_equal(
+                np.isinf(float_frame), np.isinf(recons), check_names=False
             )
 
     def test_to_csv_no_index(self):
         # GH 3624, after appending columns, to_csv fails
-        with ensure_clean("__tmp_to_csv_no_index__") as path:
+        with tm.ensure_clean("__tmp_to_csv_no_index__") as path:
             df = DataFrame({"c1": [1, 2, 3], "c2": [4, 5, 6]})
             df.to_csv(path, index=False)
             result = read_csv(path)
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
             df["c3"] = Series([7, 8, 9], dtype="int64")
             df.to_csv(path, index=False)
             result = read_csv(path)
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
     def test_to_csv_with_mix_columns(self):
         # gh-11637: incorrect output when a mix of integer and string column
@@ -551,27 +563,27 @@ def test_to_csv_headers(self):
         # causes to_csv to have different header semantics.
         from_df = DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
         to_df = DataFrame([[1, 2], [3, 4]], columns=["X", "Y"])
-        with ensure_clean("__tmp_to_csv_headers__") as path:
+        with tm.ensure_clean("__tmp_to_csv_headers__") as path:
             from_df.to_csv(path, header=["X", "Y"])
             recons = self.read_csv(path)
 
-            assert_frame_equal(to_df, recons)
+            tm.assert_frame_equal(to_df, recons)
 
             from_df.to_csv(path, index=False, header=["X", "Y"])
             recons = self.read_csv(path)
 
             recons.reset_index(inplace=True)
-            assert_frame_equal(to_df, recons)
+            tm.assert_frame_equal(to_df, recons)
 
-    def test_to_csv_multiindex(self):
+    def test_to_csv_multiindex(self, float_frame, datetime_frame):
 
-        frame = self.frame
+        frame = float_frame
         old_index = frame.index
         arrays = np.arange(len(old_index) * 2).reshape(2, -1)
         new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
         frame.index = new_index
 
-        with ensure_clean("__tmp_to_csv_multiindex__") as path:
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
 
             frame.to_csv(path, header=False)
             frame.to_csv(path, columns=["A", "B"])
@@ -582,14 +594,14 @@ def test_to_csv_multiindex(self):
             df = self.read_csv(path, index_col=[0, 1], parse_dates=False)
 
             # TODO to_csv drops column name
-            assert_frame_equal(frame, df, check_names=False)
+            tm.assert_frame_equal(frame, df, check_names=False)
             assert frame.index.names == df.index.names
 
             # needed if setUp becomes a class method
-            self.frame.index = old_index
+            float_frame.index = old_index
 
             # try multiindex with dates
-            tsframe = self.tsframe
+            tsframe = datetime_frame
             old_index = tsframe.index
             new_index = [old_index, np.arange(len(old_index))]
             tsframe.index = MultiIndex.from_arrays(new_index)
@@ -598,7 +610,7 @@ def test_to_csv_multiindex(self):
             recons = self.read_csv(path, index_col=[0, 1])
 
             # TODO to_csv drops column name
-            assert_frame_equal(tsframe, recons, check_names=False)
+            tm.assert_frame_equal(tsframe, recons, check_names=False)
 
             # do not load index
             tsframe.to_csv(path)
@@ -608,12 +620,12 @@ def test_to_csv_multiindex(self):
             # no index
             tsframe.to_csv(path, index=False)
             recons = self.read_csv(path, index_col=None)
-            assert_almost_equal(recons.values, self.tsframe.values)
+            tm.assert_almost_equal(recons.values, datetime_frame.values)
 
             # needed if setUp becomes class method
-            self.tsframe.index = old_index
+            datetime_frame.index = old_index
 
-        with ensure_clean("__tmp_to_csv_multiindex__") as path:
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
             # GH3571, GH1651, GH3141
 
             def _make_frame(names=None):
@@ -628,28 +640,28 @@ def _make_frame(names=None):
                 )
 
             # column & index are multi-index
-            df = mkdf(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
             df.to_csv(path)
             result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1])
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # column is mi
-            df = mkdf(5, 3, r_idx_nlevels=1, c_idx_nlevels=4)
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=1, c_idx_nlevels=4)
             df.to_csv(path)
             result = read_csv(path, header=[0, 1, 2, 3], index_col=0)
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # dup column names?
-            df = mkdf(5, 3, r_idx_nlevels=3, c_idx_nlevels=4)
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=3, c_idx_nlevels=4)
             df.to_csv(path)
             result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1, 2])
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # writing with no index
             df = _make_frame()
             df.to_csv(path, index=False)
             result = read_csv(path, header=[0, 1])
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # we lose the names here
             df = _make_frame(True)
@@ -657,18 +669,18 @@ def _make_frame(names=None):
             result = read_csv(path, header=[0, 1])
             assert com.all_none(*result.columns.names)
             result.columns.names = df.columns.names
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # whatsnew example
             df = _make_frame()
             df.to_csv(path)
             result = read_csv(path, header=[0, 1], index_col=[0])
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             df = _make_frame(True)
             df.to_csv(path)
             result = read_csv(path, header=[0, 1], index_col=[0])
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # invalid options
             df = _make_frame(True)
@@ -684,7 +696,7 @@ def _make_frame(names=None):
             with pytest.raises(TypeError, match=msg):
                 df.to_csv(path, columns=["foo", "bar"])
 
-        with ensure_clean("__tmp_to_csv_multiindex__") as path:
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
             # empty
             tsframe[:0].to_csv(path)
             recons = self.read_csv(path)
@@ -699,7 +711,7 @@ def test_to_csv_interval_index(self):
         # GH 28210
         df = DataFrame({"A": list("abc"), "B": range(3)}, index=pd.interval_range(0, 3))
 
-        with ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
+        with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
             df.to_csv(path)
             result = self.read_csv(path, index_col=0)
 
@@ -707,13 +719,13 @@ def test_to_csv_interval_index(self):
             expected = df.copy()
             expected.index = expected.index.astype(str)
 
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_to_csv_float32_nanrep(self):
         df = DataFrame(np.random.randn(1, 4).astype(np.float32))
         df[1] = np.nan
 
-        with ensure_clean("__tmp_to_csv_float32_nanrep__.csv") as path:
+        with tm.ensure_clean("__tmp_to_csv_float32_nanrep__.csv") as path:
             df.to_csv(path, na_rep=999)
 
             with open(path) as f:
@@ -725,10 +737,10 @@ def test_to_csv_withcommas(self):
         # Commas inside fields should be correctly escaped when saving as CSV.
         df = DataFrame({"A": [1, 2, 3], "B": ["5,6", "7,8", "9,0"]})
 
-        with ensure_clean("__tmp_to_csv_withcommas__.csv") as path:
+        with tm.ensure_clean("__tmp_to_csv_withcommas__.csv") as path:
             df.to_csv(path)
             df2 = self.read_csv(path)
-            assert_frame_equal(df2, df)
+            tm.assert_frame_equal(df2, df)
 
     def test_to_csv_mixed(self):
         def create_cols(name):
@@ -767,12 +779,12 @@ def create_cols(name):
             for c in create_cols(n):
                 dtypes[c] = dtype
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             df.to_csv(filename)
             rs = read_csv(
                 filename, index_col=0, dtype=dtypes, parse_dates=create_cols("date")
             )
-            assert_frame_equal(rs, df)
+            tm.assert_frame_equal(rs, df)
 
     def test_to_csv_dups_cols(self):
 
@@ -782,11 +794,11 @@ def test_to_csv_dups_cols(self):
             dtype="float64",
         )
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             df.to_csv(filename)  # single dtype, fine
             result = read_csv(filename, index_col=0)
             result.columns = df.columns
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
         df_float = DataFrame(np.random.randn(1000, 3), dtype="float64")
         df_int = DataFrame(np.random.randn(1000, 3), dtype="int64")
@@ -802,7 +814,7 @@ def test_to_csv_dups_cols(self):
             cols.extend([0, 1, 2])
         df.columns = cols
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             df.to_csv(filename)
             result = read_csv(filename, index_col=0)
 
@@ -811,22 +823,21 @@ def test_to_csv_dups_cols(self):
                 result[i] = to_datetime(result[i])
 
             result.columns = df.columns
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
         # GH3457
-        from pandas.util.testing import makeCustomDataframe as mkdf
 
         N = 10
-        df = mkdf(N, 3)
+        df = tm.makeCustomDataframe(N, 3)
         df.columns = ["a", "a", "b"]
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             df.to_csv(filename)
 
             # read_csv will rename the dups columns
             result = read_csv(filename, index_col=0)
             result = result.rename(columns={"a.1": "a"})
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
     def test_to_csv_chunking(self):
 
@@ -836,44 +847,44 @@ def test_to_csv_chunking(self):
         aa["D"] = aa.A + 3.0
 
         for chunksize in [10000, 50000, 100000]:
-            with ensure_clean() as filename:
+            with tm.ensure_clean() as filename:
                 aa.to_csv(filename, chunksize=chunksize)
                 rs = read_csv(filename, index_col=0)
-                assert_frame_equal(rs, aa)
+                tm.assert_frame_equal(rs, aa)
 
     @pytest.mark.slow
     def test_to_csv_wide_frame_formatting(self):
         # Issue #8621
         df = DataFrame(np.random.randn(1, 100010), columns=None, index=None)
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             df.to_csv(filename, header=False, index=False)
             rs = read_csv(filename, header=None)
-            assert_frame_equal(rs, df)
+            tm.assert_frame_equal(rs, df)
 
     def test_to_csv_bug(self):
         f1 = StringIO("a,1.0\nb,2.0")
         df = self.read_csv(f1, header=None)
         newdf = DataFrame({"t": df[df.columns[0]]})
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             newdf.to_csv(path)
 
             recons = read_csv(path, index_col=0)
             # don't check_names as t != 1
-            assert_frame_equal(recons, newdf, check_names=False)
+            tm.assert_frame_equal(recons, newdf, check_names=False)
 
     def test_to_csv_unicode(self):
 
         df = DataFrame({"c/\u03c3": [1, 2, 3]})
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
 
             df.to_csv(path, encoding="UTF-8")
             df2 = read_csv(path, index_col=0, encoding="UTF-8")
-            assert_frame_equal(df, df2)
+            tm.assert_frame_equal(df, df2)
 
             df.to_csv(path, encoding="UTF-8", index=False)
             df2 = read_csv(path, index_col=None, encoding="UTF-8")
-            assert_frame_equal(df, df2)
+            tm.assert_frame_equal(df, df2)
 
     def test_to_csv_unicode_index_col(self):
         buf = StringIO("")
@@ -887,15 +898,15 @@ def test_to_csv_unicode_index_col(self):
         buf.seek(0)
 
         df2 = read_csv(buf, index_col=0, encoding="UTF-8")
-        assert_frame_equal(df, df2)
+        tm.assert_frame_equal(df, df2)
 
-    def test_to_csv_stringio(self):
+    def test_to_csv_stringio(self, float_frame):
         buf = StringIO()
-        self.frame.to_csv(buf)
+        float_frame.to_csv(buf)
         buf.seek(0)
         recons = read_csv(buf, index_col=0)
         # TODO to_csv drops column name
-        assert_frame_equal(recons, self.frame, check_names=False)
+        tm.assert_frame_equal(recons, float_frame, check_names=False)
 
     def test_to_csv_float_format(self):
 
@@ -905,7 +916,7 @@ def test_to_csv_float_format(self):
             columns=["X", "Y", "Z"],
         )
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
 
             df.to_csv(filename, float_format="%.2f")
 
@@ -915,7 +926,7 @@ def test_to_csv_float_format(self):
                 index=["A", "B"],
                 columns=["X", "Y", "Z"],
             )
-            assert_frame_equal(rs, xp)
+            tm.assert_frame_equal(rs, xp)
 
     def test_to_csv_unicodewriter_quoting(self):
         df = DataFrame({"A": [1, 2, 3], "B": ["foo", "bar", "baz"]})
@@ -954,7 +965,7 @@ def test_to_csv_line_terminators(self):
         # see gh-20353
         df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             # case 1: CRLF as line terminator
             df.to_csv(path, line_terminator="\r\n")
             expected = b",A,B\r\none,1,4\r\ntwo,2,5\r\nthree,3,6\r\n"
@@ -962,7 +973,7 @@ def test_to_csv_line_terminators(self):
             with open(path, mode="rb") as f:
                 assert f.read() == expected
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             # case 2: LF as line terminator
             df.to_csv(path, line_terminator="\n")
             expected = b",A,B\none,1,4\ntwo,2,5\nthree,3,6\n"
@@ -970,7 +981,7 @@ def test_to_csv_line_terminators(self):
             with open(path, mode="rb") as f:
                 assert f.read() == expected
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             # case 3: The default line terminator(=os.linesep)(gh-21406)
             df.to_csv(path)
             os_linesep = os.linesep.encode("utf-8")
@@ -1013,14 +1024,14 @@ def test_to_csv_from_csv_categorical(self):
 
         assert res.getvalue() == exp.getvalue()
 
-    def test_to_csv_path_is_none(self):
+    def test_to_csv_path_is_none(self, float_frame):
         # GH 8215
         # Make sure we return string for consistency with
         # Series.to_csv()
-        csv_str = self.frame.to_csv(path_or_buf=None)
+        csv_str = float_frame.to_csv(path_or_buf=None)
         assert isinstance(csv_str, str)
         recons = pd.read_csv(StringIO(csv_str), index_col=0)
-        assert_frame_equal(self.frame, recons)
+        tm.assert_frame_equal(float_frame, recons)
 
     @pytest.mark.parametrize(
         "df,encoding",
@@ -1044,17 +1055,17 @@ def test_to_csv_path_is_none(self):
     )
     def test_to_csv_compression(self, df, encoding, compression):
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
 
             df.to_csv(filename, compression=compression, encoding=encoding)
             # test the round trip - to_csv -> read_csv
             result = read_csv(
                 filename, compression=compression, index_col=0, encoding=encoding
             )
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # test the round trip using file handle - to_csv -> read_csv
-            f, _handles = _get_handle(
+            f, _handles = get_handle(
                 filename, "w", compression=compression, encoding=encoding
             )
             with f:
@@ -1066,7 +1077,7 @@ def test_to_csv_compression(self, df, encoding, compression):
                 index_col=0,
                 squeeze=True,
             )
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
             # explicitly make sure file is compressed
             with tm.decompress_file(filename, compression) as fh:
@@ -1075,11 +1086,11 @@ def test_to_csv_compression(self, df, encoding, compression):
                     assert col in text
 
             with tm.decompress_file(filename, compression) as fh:
-                assert_frame_equal(df, read_csv(fh, index_col=0, encoding=encoding))
+                tm.assert_frame_equal(df, read_csv(fh, index_col=0, encoding=encoding))
 
-    def test_to_csv_date_format(self):
-        with ensure_clean("__tmp_to_csv_date_format__") as path:
-            dt_index = self.tsframe.index
+    def test_to_csv_date_format(self, datetime_frame):
+        with tm.ensure_clean("__tmp_to_csv_date_format__") as path:
+            dt_index = datetime_frame.index
             datetime_frame = DataFrame(
                 {"A": dt_index, "B": dt_index.shift(1)}, index=dt_index
             )
@@ -1095,7 +1106,7 @@ def test_to_csv_date_format(self):
                 lambda x: int(x.strftime("%Y%m%d"))
             )
 
-            assert_frame_equal(test, datetime_frame_int)
+            tm.assert_frame_equal(test, datetime_frame_int)
 
             datetime_frame.to_csv(path, date_format="%Y-%m-%d")
 
@@ -1108,7 +1119,7 @@ def test_to_csv_date_format(self):
                 lambda x: x.strftime("%Y-%m-%d")
             )
 
-            assert_frame_equal(test, datetime_frame_str)
+            tm.assert_frame_equal(test, datetime_frame_str)
 
             # Check that columns get converted
             datetime_frame_columns = datetime_frame.T
@@ -1124,7 +1135,7 @@ def test_to_csv_date_format(self):
                 lambda x: x.strftime("%Y%m%d")
             )
 
-            assert_frame_equal(test, datetime_frame_columns)
+            tm.assert_frame_equal(test, datetime_frame_columns)
 
             # test NaTs
             nat_index = to_datetime(
@@ -1135,11 +1146,11 @@ def test_to_csv_date_format(self):
 
             test = read_csv(path, parse_dates=[0, 1], index_col=0)
 
-            assert_frame_equal(test, nat_frame)
+            tm.assert_frame_equal(test, nat_frame)
 
     def test_to_csv_with_dst_transitions(self):
 
-        with ensure_clean("csv_date_format_with_dst") as path:
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
             # make sure we are not failing on transitions
             times = pd.date_range(
                 "2013-10-26 23:00",
@@ -1159,12 +1170,12 @@ def test_to_csv_with_dst_transitions(self):
                 result.index = to_datetime(result.index, utc=True).tz_convert(
                     "Europe/London"
                 )
-                assert_frame_equal(result, df)
+                tm.assert_frame_equal(result, df)
 
         # GH11619
         idx = pd.date_range("2015-01-01", "2015-12-31", freq="H", tz="Europe/Paris")
         df = DataFrame({"values": 1, "idx": idx}, index=idx)
-        with ensure_clean("csv_date_format_with_dst") as path:
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
             df.to_csv(path, index=True)
             result = read_csv(path, index_col=0)
             result.index = to_datetime(result.index, utc=True).tz_convert(
@@ -1173,15 +1184,15 @@ def test_to_csv_with_dst_transitions(self):
             result["idx"] = to_datetime(result["idx"], utc=True).astype(
                 "datetime64[ns, Europe/Paris]"
             )
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
         # assert working
         df.astype(str)
 
-        with ensure_clean("csv_date_format_with_dst") as path:
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
             df.to_pickle(path)
             result = pd.read_pickle(path)
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
     def test_to_csv_quoting(self):
         df = DataFrame(
@@ -1332,14 +1343,14 @@ def test_to_csv_single_level_multi_index(self):
         df = df.reindex(columns=[(1,), (3,)])
         expected = ",1,3\n0,1,3\n"
         result = df.to_csv(line_terminator="\n")
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
     def test_gz_lineend(self):
         # GH 25311
         df = pd.DataFrame({"a": [1, 2]})
         expected_rows = ["a", "1", "2"]
         expected = tm.convert_rows_list_to_csv_str(expected_rows)
-        with ensure_clean("__test_gz_lineend.csv.gz") as path:
+        with tm.ensure_clean("__test_gz_lineend.csv.gz") as path:
             df.to_csv(path, index=False)
             with tm.decompress_file(path, compression="gzip") as f:
                 result = f.read().decode("utf-8")
diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index ff9895cf14318..d8f4257566f84 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -9,12 +9,7 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
+import pandas._testing as tm
 
 from .test_generic import Generic
 
@@ -28,7 +23,7 @@
 
 class TestDataFrame(Generic):
     _typ = DataFrame
-    _comparator = lambda self, x, y: assert_frame_equal(x, y)
+    _comparator = lambda self, x, y: tm.assert_frame_equal(x, y)
 
     def test_rename_mi(self):
         df = DataFrame(
@@ -165,7 +160,7 @@ def finalize(self, other, method=None, **kwargs):
 
         # reset
         DataFrame._metadata = _metadata
-        DataFrame.__finalize__ = _finalize
+        DataFrame.__finalize__ = _finalize  # FIXME: use monkeypatch
 
     def test_set_attribute(self):
         # Test for consistent setattr behavior when an attribute and a column
@@ -177,8 +172,71 @@ def test_set_attribute(self):
         df.y = 5
 
         assert df.y == 5
-        assert_series_equal(df["y"], Series([2, 4, 6], name="y"))
+        tm.assert_series_equal(df["y"], Series([2, 4, 6], name="y"))
 
+    def test_deepcopy_empty(self):
+        # This test covers empty frame copying with non-empty column sets
+        # as reported in issue GH15370
+        empty_frame = DataFrame(data=[], index=[], columns=["A"])
+        empty_frame_copy = deepcopy(empty_frame)
+
+        self._compare(empty_frame_copy, empty_frame)
+
+
+# formerly in Generic but only test DataFrame
+class TestDataFrame2:
+    def test_validate_bool_args(self):
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        invalid_values = [1, "True", [1, 2, 3], 5.0]
+
+        for value in invalid_values:
+            with pytest.raises(ValueError):
+                super(DataFrame, df).rename_axis(
+                    mapper={"a": "x", "b": "y"}, axis=1, inplace=value
+                )
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df).drop("a", axis=1, inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df)._consolidate(inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df).fillna(value=0, inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df).replace(to_replace=1, value=7, inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df).interpolate(inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df)._where(cond=df.a > 2, inplace=value)
+
+            with pytest.raises(ValueError):
+                super(DataFrame, df).mask(cond=df.a > 2, inplace=value)
+
+    def test_unexpected_keyword(self):
+        # GH8597
+        df = DataFrame(np.random.randn(5, 2), columns=["jim", "joe"])
+        ca = pd.Categorical([0, 0, 2, 2, 3, np.nan])
+        ts = df["joe"].copy()
+        ts[2] = np.nan
+
+        with pytest.raises(TypeError, match="unexpected keyword"):
+            df.drop("joe", axis=1, in_place=True)
+
+        with pytest.raises(TypeError, match="unexpected keyword"):
+            df.reindex([1, 0], inplace=True)
+
+        with pytest.raises(TypeError, match="unexpected keyword"):
+            ca.fillna(0, inplace=True)
+
+        with pytest.raises(TypeError, match="unexpected keyword"):
+            ts.fillna(0, in_place=True)
+
+
+class TestToXArray:
     @pytest.mark.skipif(
         not _XARRAY_INSTALLED
         or _XARRAY_INSTALLED
@@ -201,7 +259,7 @@ def test_set_attribute(self):
     def test_to_xarray_index_types(self, index):
         from xarray import Dataset
 
-        index = getattr(tm, "make{}".format(index))
+        index = getattr(tm, f"make{index}")
         df = DataFrame(
             {
                 "a": list("abc"),
@@ -222,18 +280,17 @@ def test_to_xarray_index_types(self, index):
         assert result.dims["foo"] == 3
         assert len(result.coords) == 1
         assert len(result.data_vars) == 8
-        assert_almost_equal(list(result.coords.keys()), ["foo"])
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
         assert isinstance(result, Dataset)
 
         # idempotency
         # categoricals are not preserved
-        # datetimes w/tz are not preserved
+        # datetimes w/tz are preserved
         # column names are lost
         expected = df.copy()
         expected["f"] = expected["f"].astype(object)
-        expected["h"] = expected["h"].astype("datetime64[ns]")
         expected.columns.name = None
-        assert_frame_equal(
+        tm.assert_frame_equal(
             result.to_dataframe(),
             expected,
             check_index_type=False,
@@ -270,20 +327,11 @@ def test_to_xarray(self):
         assert result.dims["two"] == 3
         assert len(result.coords) == 2
         assert len(result.data_vars) == 8
-        assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
         assert isinstance(result, Dataset)
 
         result = result.to_dataframe()
         expected = df.copy()
         expected["f"] = expected["f"].astype(object)
-        expected["h"] = expected["h"].astype("datetime64[ns]")
         expected.columns.name = None
-        assert_frame_equal(result, expected, check_index_type=False)
-
-    def test_deepcopy_empty(self):
-        # This test covers empty frame copying with non-empty column sets
-        # as reported in issue GH15370
-        empty_frame = DataFrame(data=[], index=[], columns=["A"])
-        empty_frame_copy = deepcopy(empty_frame)
-
-        self._compare(empty_frame_copy, empty_frame)
+        tm.assert_frame_equal(result, expected, check_index_type=False)
diff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py
index 7b9e50ebbf342..1f4fd90d9b059 100644
--- a/pandas/tests/generic/test_generic.py
+++ b/pandas/tests/generic/test_generic.py
@@ -7,8 +7,7 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 # ----------------------------------------------------------------------
 # Generic types test cases
@@ -24,9 +23,11 @@ def _axes(self):
         return self._typ._AXIS_ORDERS
 
     def _construct(self, shape, value=None, dtype=None, **kwargs):
-        """ construct an object for the given shape
-            if value is specified use that if its a scalar
-            if value is an array, repeat it as needed """
+        """
+        construct an object for the given shape
+        if value is specified use that if its a scalar
+        if value is an array, repeat it as needed
+        """
 
         if isinstance(shape, int):
             shape = tuple([shape] * self._ndim)
@@ -34,6 +35,7 @@ def _construct(self, shape, value=None, dtype=None, **kwargs):
             if is_scalar(value):
                 if value == "empty":
                     arr = None
+                    dtype = np.float64
 
                     # remove the info axis
                     kwargs.pop(self._typ._info_axis_name, None)
@@ -103,29 +105,12 @@ def test_get_numeric_data(self):
         # _get_numeric_data is includes _get_bool_data, so can't test for
         # non-inclusion
 
-    def test_get_default(self):
-
-        # GH 7725
-        d0 = "a", "b", "c", "d"
-        d1 = np.arange(4, dtype="int64")
-        others = "e", 10
-
-        for data, index in ((d0, d1), (d1, d0)):
-            s = Series(data, index=index)
-            for i, d in zip(index, data):
-                assert s.get(i) == d
-                assert s.get(i, d) == d
-                assert s.get(i, "z") == d
-                for other in others:
-                    assert s.get(other, "z") == "z"
-                    assert s.get(other, other) == other
-
     def test_nonzero(self):
 
         # GH 4633
         # look at the boolean/nonzero behavior for objects
         obj = self._construct(shape=4)
-        msg = "The truth value of a {} is ambiguous".format(self._typ.__name__)
+        msg = f"The truth value of a {self._typ.__name__} is ambiguous"
         with pytest.raises(ValueError, match=msg):
             bool(obj == 0)
         with pytest.raises(ValueError, match=msg):
@@ -203,9 +188,9 @@ def test_constructor_compound_dtypes(self):
         def f(dtype):
             return self._construct(shape=3, value=1, dtype=dtype)
 
-        msg = "compound dtypes are not implemented in the {} constructor".format(
-            self._typ.__name__
-        )
+        msg = "compound dtypes are not implemented"
+        f"in the {self._typ.__name__} constructor"
+
         with pytest.raises(NotImplementedError, match=msg):
             f([("A", "datetime64[h]"), ("B", "str"), ("C", "int32")])
 
@@ -323,6 +308,7 @@ def test_sample(self):
             self._compare(
                 o.sample(n=4, random_state=seed), o.sample(n=4, random_state=seed)
             )
+
             self._compare(
                 o.sample(frac=0.7, random_state=seed),
                 o.sample(frac=0.7, random_state=seed),
@@ -338,6 +324,15 @@ def test_sample(self):
                 o.sample(frac=0.7, random_state=np.random.RandomState(test)),
             )
 
+            self._compare(
+                o.sample(
+                    frac=2, replace=True, random_state=np.random.RandomState(test)
+                ),
+                o.sample(
+                    frac=2, replace=True, random_state=np.random.RandomState(test)
+                ),
+            )
+
             os1, os2 = [], []
             for _ in range(2):
                 np.random.seed(test)
@@ -425,6 +420,26 @@ def test_sample(self):
         weights_with_None[5] = 0.5
         self._compare(o.sample(n=1, axis=0, weights=weights_with_None), o.iloc[5:6])
 
+    def test_sample_upsampling_without_replacement(self):
+        # GH27451
+
+        df = pd.DataFrame({"A": list("abc")})
+        msg = (
+            "Replace has to be set to `True` when "
+            "upsampling the population `frac` > 1."
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.sample(frac=2, replace=False)
+
+    def test_sample_is_copy(self):
+        # GH-27357, GH-30784: ensure the result of sample is an actual copy and
+        # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+        df = pd.DataFrame(np.random.randn(10, 3), columns=["a", "b", "c"])
+        df2 = df.sample(3)
+
+        with tm.assert_produces_warning(None):
+            df2["d"] = 1
+
     def test_size_compat(self):
         # GH8846
         # size property should be defined
@@ -439,24 +454,6 @@ def test_split_compat(self):
         assert len(np.array_split(o, 5)) == 5
         assert len(np.array_split(o, 2)) == 2
 
-    def test_unexpected_keyword(self):  # GH8597
-        df = DataFrame(np.random.randn(5, 2), columns=["jim", "joe"])
-        ca = pd.Categorical([0, 0, 2, 2, 3, np.nan])
-        ts = df["joe"].copy()
-        ts[2] = np.nan
-
-        with pytest.raises(TypeError, match="unexpected keyword"):
-            df.drop("joe", axis=1, in_place=True)
-
-        with pytest.raises(TypeError, match="unexpected keyword"):
-            df.reindex([1, 0], inplace=True)
-
-        with pytest.raises(TypeError, match="unexpected keyword"):
-            ca.fillna(0, inplace=True)
-
-        with pytest.raises(TypeError, match="unexpected keyword"):
-            ts.fillna(0, in_place=True)
-
     # See gh-12301
     def test_stat_unexpected_keyword(self):
         obj = self._construct(5)
@@ -514,40 +511,6 @@ def test_truncate_out_of_bounds(self):
         self._compare(big.truncate(before=0, after=3e6), big)
         self._compare(big.truncate(before=-1, after=2e6), big)
 
-    def test_validate_bool_args(self):
-        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
-        invalid_values = [1, "True", [1, 2, 3], 5.0]
-
-        for value in invalid_values:
-            with pytest.raises(ValueError):
-                super(DataFrame, df).rename_axis(
-                    mapper={"a": "x", "b": "y"}, axis=1, inplace=value
-                )
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).drop("a", axis=1, inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).sort_index(inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df)._consolidate(inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).fillna(value=0, inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).replace(to_replace=1, value=7, inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).interpolate(inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df)._where(cond=df.a > 2, inplace=value)
-
-            with pytest.raises(ValueError):
-                super(DataFrame, df).mask(cond=df.a > 2, inplace=value)
-
     def test_copy_and_deepcopy(self):
         # GH 15444
         for shape in [0, 1, 2]:
@@ -606,7 +569,7 @@ def test_sample(sel):
             }
         )
         sample1 = df.sample(n=1, weights="easyweights")
-        assert_frame_equal(sample1, df.iloc[5:6])
+        tm.assert_frame_equal(sample1, df.iloc[5:6])
 
         # Ensure proper error if string given as weight for Series or
         # DataFrame with axis = 1.
@@ -635,19 +598,21 @@ def test_sample(sel):
         # Test axis argument
         df = pd.DataFrame({"col1": range(10), "col2": ["a"] * 10})
         second_column_weight = [0, 1]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df.sample(n=1, axis=1, weights=second_column_weight), df[["col2"]]
         )
 
         # Different axis arg types
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df.sample(n=1, axis="columns", weights=second_column_weight), df[["col2"]]
         )
 
         weight = [0] * 10
         weight[5] = 0.5
-        assert_frame_equal(df.sample(n=1, axis="rows", weights=weight), df.iloc[5:6])
-        assert_frame_equal(df.sample(n=1, axis="index", weights=weight), df.iloc[5:6])
+        tm.assert_frame_equal(df.sample(n=1, axis="rows", weights=weight), df.iloc[5:6])
+        tm.assert_frame_equal(
+            df.sample(n=1, axis="index", weights=weight), df.iloc[5:6]
+        )
 
         # Check out of range axis values
         with pytest.raises(ValueError):
@@ -672,26 +637,26 @@ def test_sample(sel):
             {"col1": range(10, 20), "col2": range(20, 30), "colString": ["a"] * 10}
         )
         sample1 = df.sample(n=1, axis=1, weights=easy_weight_list)
-        assert_frame_equal(sample1, df[["colString"]])
+        tm.assert_frame_equal(sample1, df[["colString"]])
 
         # Test default axes
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df.sample(n=3, random_state=42), df.sample(n=3, axis=0, random_state=42)
         )
 
         # Test that function aligns weights with frame
         df = DataFrame({"col1": [5, 6, 7], "col2": ["a", "b", "c"]}, index=[9, 5, 3])
         s = Series([1, 0, 0], index=[3, 5, 9])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s))
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=s))
 
         # Weights have index values to be dropped because not in
         # sampled DataFrame
         s2 = Series([0.001, 0, 10000], index=[3, 5, 10])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s2))
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=s2))
 
         # Weights have empty values to be filed with zeros
         s3 = Series([0.01, 0], index=[3, 5])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s3))
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=s3))
 
         # No overlap in weight and sampled DataFrame indices
         s4 = Series([1, 0], index=[1, 2])
@@ -710,13 +675,10 @@ def test_squeeze(self):
         tm.assert_series_equal(df.squeeze(), df["A"])
 
         # don't fail with 0 length dimensions GH11229 & GH8999
-        empty_series = Series([], name="five")
+        empty_series = Series([], name="five", dtype=np.float64)
         empty_frame = DataFrame([empty_series])
-
-        [
-            tm.assert_series_equal(empty_series, higher_dim.squeeze())
-            for higher_dim in [empty_series, empty_frame]
-        ]
+        tm.assert_series_equal(empty_series, empty_series.squeeze())
+        tm.assert_series_equal(empty_series, empty_frame.squeeze())
 
         # axis argument
         df = tm.makeTimeDataFrame(nper=1).iloc[:, :1]
@@ -800,6 +762,23 @@ def test_take_invalid_kwargs(self):
             with pytest.raises(ValueError, match=msg):
                 obj.take(indices, mode="clip")
 
+    @pytest.mark.parametrize("is_copy", [True, False])
+    def test_depr_take_kwarg_is_copy(self, is_copy):
+        # GH 27357
+        df = DataFrame({"A": [1, 2, 3]})
+        msg = (
+            "is_copy is deprecated and will be removed in a future version. "
+            "'take' always returns a copy, so there is no need to specify this."
+        )
+        with tm.assert_produces_warning(FutureWarning) as w:
+            df.take([0, 1], is_copy=is_copy)
+
+        assert w[0].message.args[0] == msg
+
+        s = Series([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            s.take([0, 1], is_copy=is_copy)
+
     def test_equals(self):
         s1 = pd.Series([1, 2, 3], index=[0, 2, 1])
         s2 = s1.copy()
@@ -876,10 +855,10 @@ def test_equals(self):
         # GH 8437
         a = pd.Series([False, np.nan])
         b = pd.Series([False, np.nan])
-        c = pd.Series(index=range(2))
-        d = pd.Series(index=range(2))
-        e = pd.Series(index=range(2))
-        f = pd.Series(index=range(2))
+        c = pd.Series(index=range(2), dtype=object)
+        d = c.copy()
+        e = c.copy()
+        f = c.copy()
         c[:-1] = d[:-1] = e[0] = f[0] = False
         assert a.equals(a)
         assert a.equals(b)
@@ -893,19 +872,19 @@ def test_pipe(self):
         f = lambda x, y: x ** y
         result = df.pipe(f, 2)
         expected = DataFrame({"A": [1, 4, 9]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.A.pipe(f, 2)
-        assert_series_equal(result, expected.A)
+        tm.assert_series_equal(result, expected.A)
 
     def test_pipe_tuple(self):
         df = DataFrame({"A": [1, 2, 3]})
         f = lambda x, y: y
         result = df.pipe((f, "y"), 0)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         result = df.A.pipe((f, "y"), 0)
-        assert_series_equal(result, df.A)
+        tm.assert_series_equal(result, df.A)
 
     def test_pipe_tuple_error(self):
         df = DataFrame({"A": [1, 2, 3]})
@@ -918,7 +897,7 @@ def test_pipe_tuple_error(self):
 
     @pytest.mark.parametrize("box", [pd.Series, pd.DataFrame])
     def test_axis_classmethods(self, box):
-        obj = box()
+        obj = box(dtype=object)
         values = (
             list(box._AXIS_NAMES.keys())
             + list(box._AXIS_NUMBERS.keys())
@@ -928,23 +907,3 @@ def test_axis_classmethods(self, box):
             assert obj._get_axis_number(v) == box._get_axis_number(v)
             assert obj._get_axis_name(v) == box._get_axis_name(v)
             assert obj._get_block_manager_axis(v) == box._get_block_manager_axis(v)
-
-    def test_deprecated_to_dense(self):
-        # GH 26557: DEPR
-        # Deprecated 0.25.0
-
-        df = pd.DataFrame({"A": [1, 2, 3]})
-        with tm.assert_produces_warning(FutureWarning):
-            result = df.to_dense()
-        tm.assert_frame_equal(result, df)
-
-        ser = pd.Series([1, 2, 3])
-        with tm.assert_produces_warning(FutureWarning):
-            result = ser.to_dense()
-        tm.assert_series_equal(result, ser)
-
-    def test_deprecated_get_dtype_counts(self):
-        # GH 18262
-        df = DataFrame([1])
-        with tm.assert_produces_warning(FutureWarning):
-            df.get_dtype_counts()
diff --git a/pandas/tests/generic/test_series.py b/pandas/tests/generic/test_series.py
index 5c3c35832356e..ce0daf8522687 100644
--- a/pandas/tests/generic/test_series.py
+++ b/pandas/tests/generic/test_series.py
@@ -8,8 +8,7 @@
 
 import pandas as pd
 from pandas import MultiIndex, Series, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal, assert_series_equal
+import pandas._testing as tm
 
 from .test_generic import Generic
 
@@ -23,7 +22,7 @@
 
 class TestSeries(Generic):
     _typ = Series
-    _comparator = lambda self, x, y: assert_series_equal(x, y)
+    _comparator = lambda self, x, y: tm.assert_series_equal(x, y)
 
     def setup_method(self):
         self.ts = tm.makeTimeSeries()  # Was at top level in test_series
@@ -182,8 +181,49 @@ def finalize(self, other, method=None, **kwargs):
 
         # reset
         Series._metadata = _metadata
-        Series.__finalize__ = _finalize
+        Series.__finalize__ = _finalize  # FIXME: use monkeypatch
 
+    @pytest.mark.parametrize(
+        "s",
+        [
+            Series([np.arange(5)]),
+            pd.date_range("1/1/2011", periods=24, freq="H"),
+            pd.Series(range(5), index=pd.date_range("2017", periods=5)),
+        ],
+    )
+    @pytest.mark.parametrize("shift_size", [0, 1, 2])
+    def test_shift_always_copy(self, s, shift_size):
+        # GH22397
+        assert s.shift(shift_size) is not s
+
+    @pytest.mark.parametrize("move_by_freq", [pd.Timedelta("1D"), pd.Timedelta("1M")])
+    def test_datetime_shift_always_copy(self, move_by_freq):
+        # GH22397
+        s = pd.Series(range(5), index=pd.date_range("2017", periods=5))
+        assert s.shift(freq=move_by_freq) is not s
+
+
+class TestSeries2:
+    # moved from Generic
+    def test_get_default(self):
+
+        # GH#7725
+        d0 = ["a", "b", "c", "d"]
+        d1 = np.arange(4, dtype="int64")
+        others = ["e", 10]
+
+        for data, index in ((d0, d1), (d1, d0)):
+            s = Series(data, index=index)
+            for i, d in zip(index, data):
+                assert s.get(i) == d
+                assert s.get(i, d) == d
+                assert s.get(i, "z") == d
+                for other in others:
+                    assert s.get(other, "z") == "z"
+                    assert s.get(other, other) == other
+
+
+class TestToXArray:
     @pytest.mark.skipif(
         not _XARRAY_INSTALLED
         or _XARRAY_INSTALLED
@@ -206,18 +246,18 @@ def finalize(self, other, method=None, **kwargs):
     def test_to_xarray_index_types(self, index):
         from xarray import DataArray
 
-        index = getattr(tm, "make{}".format(index))
+        index = getattr(tm, f"make{index}")
         s = Series(range(6), index=index(6))
         s.index.name = "foo"
         result = s.to_xarray()
         repr(result)
         assert len(result) == 6
         assert len(result.coords) == 1
-        assert_almost_equal(list(result.coords.keys()), ["foo"])
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
         assert isinstance(result, DataArray)
 
         # idempotency
-        assert_series_equal(
+        tm.assert_series_equal(
             result.to_series(), s, check_index_type=False, check_categorical=True
         )
 
@@ -225,12 +265,12 @@ def test_to_xarray_index_types(self, index):
     def test_to_xarray(self):
         from xarray import DataArray
 
-        s = Series([])
+        s = Series([], dtype=object)
         s.index.name = "foo"
         result = s.to_xarray()
         assert len(result) == 0
         assert len(result.coords) == 1
-        assert_almost_equal(list(result.coords.keys()), ["foo"])
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
         assert isinstance(result, DataArray)
 
         s = Series(range(6))
@@ -240,30 +280,6 @@ def test_to_xarray(self):
         )
         result = s.to_xarray()
         assert len(result) == 2
-        assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
         assert isinstance(result, DataArray)
-        assert_series_equal(result.to_series(), s)
-
-    def test_valid_deprecated(self):
-        # GH18800
-        with tm.assert_produces_warning(FutureWarning):
-            pd.Series([]).valid()
-
-    @pytest.mark.parametrize(
-        "s",
-        [
-            Series([np.arange(5)]),
-            pd.date_range("1/1/2011", periods=24, freq="H"),
-            pd.Series(range(5), index=pd.date_range("2017", periods=5)),
-        ],
-    )
-    @pytest.mark.parametrize("shift_size", [0, 1, 2])
-    def test_shift_always_copy(self, s, shift_size):
-        # GH22397
-        assert s.shift(shift_size) is not s
-
-    @pytest.mark.parametrize("move_by_freq", [pd.Timedelta("1D"), pd.Timedelta("1M")])
-    def test_datetime_shift_always_copy(self, move_by_freq):
-        # GH22397
-        s = pd.Series(range(5), index=pd.date_range("2017", periods=5))
-        assert s.shift(freq=move_by_freq) is not s
+        tm.assert_series_equal(result.to_series(), s)
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index aa80c461a00e7..ff99081521ffb 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -1,18 +1,16 @@
 """
 test .agg behavior / note that .apply is tested generally in test_groupby.py
 """
-from collections import OrderedDict
 import functools
 
 import numpy as np
 import pytest
 
 import pandas as pd
-from pandas import DataFrame, Index, MultiIndex, Series, compat, concat
+from pandas import DataFrame, Index, MultiIndex, Series, concat
+import pandas._testing as tm
 from pandas.core.base import SpecificationError
-from pandas.core.groupby.generic import _make_unique, _maybe_mangle_lambdas
 from pandas.core.groupby.grouper import Grouping
-import pandas.util.testing as tm
 
 
 def test_agg_regression1(tsframe):
@@ -92,6 +90,25 @@ def test_groupby_aggregation_mixed_dtype():
     tm.assert_frame_equal(result, expected)
 
 
+def test_groupby_aggregation_multi_level_column():
+    # GH 29772
+    lst = [
+        [True, True, True, False],
+        [True, False, np.nan, False],
+        [True, True, np.nan, False],
+        [True, True, np.nan, False],
+    ]
+    df = pd.DataFrame(
+        data=lst,
+        columns=pd.MultiIndex.from_tuples([("A", 0), ("A", 1), ("B", 0), ("B", 1)]),
+    )
+
+    result = df.groupby(level=1, axis=1).sum()
+    expected = pd.DataFrame({0: [2.0, 1, 1, 1], 1: [1, 0, 1, 1]})
+
+    tm.assert_frame_equal(result, expected)
+
+
 def test_agg_apply_corner(ts, tsframe):
     # nothing to group, all NA
     grouped = ts.groupby(ts * np.nan)
@@ -156,18 +173,14 @@ def test_aggregate_str_func(tsframe, groupbyfunc):
     tm.assert_frame_equal(result, expected)
 
     # group frame by function dict
-    result = grouped.agg(
-        OrderedDict([["A", "var"], ["B", "std"], ["C", "mean"], ["D", "sem"]])
-    )
+    result = grouped.agg({"A": "var", "B": "std", "C": "mean", "D": "sem"})
     expected = DataFrame(
-        OrderedDict(
-            [
-                ["A", grouped["A"].var()],
-                ["B", grouped["B"].std()],
-                ["C", grouped["C"].mean()],
-                ["D", grouped["D"].sem()],
-            ]
-        )
+        {
+            "A": grouped["A"].var(),
+            "B": grouped["B"].std(),
+            "C": grouped["C"].mean(),
+            "D": grouped["D"].sem(),
+        }
     )
     tm.assert_frame_equal(result, expected)
 
@@ -242,22 +255,20 @@ def test_multiple_functions_tuples_and_non_tuples(df):
 def test_more_flexible_frame_multi_function(df):
     grouped = df.groupby("A")
 
-    exmean = grouped.agg(OrderedDict([["C", np.mean], ["D", np.mean]]))
-    exstd = grouped.agg(OrderedDict([["C", np.std], ["D", np.std]]))
+    exmean = grouped.agg({"C": np.mean, "D": np.mean})
+    exstd = grouped.agg({"C": np.std, "D": np.std})
 
     expected = concat([exmean, exstd], keys=["mean", "std"], axis=1)
     expected = expected.swaplevel(0, 1, axis=1).sort_index(level=0, axis=1)
 
-    d = OrderedDict([["C", [np.mean, np.std]], ["D", [np.mean, np.std]]])
+    d = {"C": [np.mean, np.std], "D": [np.mean, np.std]}
     result = grouped.aggregate(d)
 
     tm.assert_frame_equal(result, expected)
 
     # be careful
-    result = grouped.aggregate(OrderedDict([["C", np.mean], ["D", [np.mean, np.std]]]))
-    expected = grouped.aggregate(
-        OrderedDict([["C", np.mean], ["D", [np.mean, np.std]]])
-    )
+    result = grouped.aggregate({"C": np.mean, "D": [np.mean, np.std]})
+    expected = grouped.aggregate({"C": np.mean, "D": [np.mean, np.std]})
     tm.assert_frame_equal(result, expected)
 
     def foo(x):
@@ -267,16 +278,14 @@ def bar(x):
         return np.std(x, ddof=1)
 
     # this uses column selection & renaming
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        d = OrderedDict(
-            [["C", np.mean], ["D", OrderedDict([["foo", np.mean], ["bar", np.std]])]]
-        )
-        result = grouped.aggregate(d)
-
-    d = OrderedDict([["C", [np.mean]], ["D", [foo, bar]]])
-    expected = grouped.aggregate(d)
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        d = dict([["C", np.mean], ["D", dict([["foo", np.mean], ["bar", np.std]])]])
+        grouped.aggregate(d)
 
-    tm.assert_frame_equal(result, expected)
+    # But without renaming, these functions are OK
+    d = {"C": [np.mean], "D": [foo, bar]}
+    grouped.aggregate(d)
 
 
 def test_multi_function_flexible_mix(df):
@@ -284,30 +293,23 @@ def test_multi_function_flexible_mix(df):
     grouped = df.groupby("A")
 
     # Expected
-    d = OrderedDict(
-        [["C", OrderedDict([["foo", "mean"], ["bar", "std"]])], ["D", {"sum": "sum"}]]
-    )
+    d = {"C": {"foo": "mean", "bar": "std"}, "D": {"sum": "sum"}}
     # this uses column selection & renaming
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        expected = grouped.aggregate(d)
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        grouped.aggregate(d)
 
     # Test 1
-    d = OrderedDict(
-        [["C", OrderedDict([["foo", "mean"], ["bar", "std"]])], ["D", "sum"]]
-    )
+    d = {"C": {"foo": "mean", "bar": "std"}, "D": "sum"}
     # this uses column selection & renaming
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = grouped.aggregate(d)
-    tm.assert_frame_equal(result, expected)
+    with pytest.raises(SpecificationError, match=msg):
+        grouped.aggregate(d)
 
     # Test 2
-    d = OrderedDict(
-        [["C", OrderedDict([["foo", "mean"], ["bar", "std"]])], ["D", ["sum"]]]
-    )
+    d = {"C": {"foo": "mean", "bar": "std"}, "D": "sum"}
     # this uses column selection & renaming
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = grouped.aggregate(d)
-    tm.assert_frame_equal(result, expected)
+    with pytest.raises(SpecificationError, match=msg):
+        grouped.aggregate(d)
 
 
 def test_groupby_agg_coercing_bools():
@@ -350,6 +352,90 @@ def test_uint64_type_handling(dtype, how):
     tm.assert_frame_equal(result, expected, check_exact=True)
 
 
+def test_func_duplicates_raises():
+    # GH28426
+    msg = "Function names"
+    df = pd.DataFrame({"A": [0, 0, 1, 1], "B": [1, 2, 3, 4]})
+    with pytest.raises(SpecificationError, match=msg):
+        df.groupby("A").agg(["min", "min"])
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        pd.CategoricalIndex(list("abc")),
+        pd.interval_range(0, 3),
+        pd.period_range("2020", periods=3, freq="D"),
+        pd.MultiIndex.from_tuples([("a", 0), ("a", 1), ("b", 0)]),
+    ],
+)
+def test_agg_index_has_complex_internals(index):
+    # GH 31223
+    df = DataFrame({"group": [1, 1, 2], "value": [0, 1, 0]}, index=index)
+    result = df.groupby("group").agg({"value": Series.nunique})
+    expected = DataFrame({"group": [1, 2], "value": [2, 1]}).set_index("group")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_split_block():
+    # https://github.com/pandas-dev/pandas/issues/31522
+    df = pd.DataFrame(
+        {
+            "key1": ["a", "a", "b", "b", "a"],
+            "key2": ["one", "two", "one", "two", "one"],
+            "key3": ["three", "three", "three", "six", "six"],
+        }
+    )
+    result = df.groupby("key1").min()
+    expected = pd.DataFrame(
+        {"key2": ["one", "one"], "key3": ["six", "six"]},
+        index=pd.Index(["a", "b"], name="key1"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_split_object_part_datetime():
+    # https://github.com/pandas-dev/pandas/pull/31616
+    df = pd.DataFrame(
+        {
+            "A": pd.date_range("2000", periods=4),
+            "B": ["a", "b", "c", "d"],
+            "C": [1, 2, 3, 4],
+            "D": ["b", "c", "d", "e"],
+            "E": pd.date_range("2000", periods=4),
+            "F": [1, 2, 3, 4],
+        }
+    ).astype(object)
+    result = df.groupby([0, 0, 0, 0]).min()
+    expected = pd.DataFrame(
+        {
+            "A": [pd.Timestamp("2000")],
+            "B": ["a"],
+            "C": [1],
+            "D": ["b"],
+            "E": [pd.Timestamp("2000")],
+            "F": [1],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_cython_category_not_implemented_fallback():
+    # https://github.com/pandas-dev/pandas/issues/31450
+    df = pd.DataFrame({"col_num": [1, 1, 2, 3]})
+    df["col_cat"] = df["col_num"].astype("category")
+
+    result = df.groupby("col_num").col_cat.first()
+    expected = pd.Series(
+        [1, 2, 3], index=pd.Index([1, 2, 3], name="col_num"), name="col_cat"
+    )
+    tm.assert_series_equal(result, expected)
+
+    result = df.groupby("col_num").agg({"col_cat": "first"})
+    expected = expected.to_frame()
+    tm.assert_frame_equal(result, expected)
+
+
 class TestNamedAggregationSeries:
     def test_series_named_agg(self):
         df = pd.Series([1, 2, 3, 4])
@@ -361,9 +447,7 @@ def test_series_named_agg(self):
         tm.assert_frame_equal(result, expected)
 
         result = gr.agg(b="min", a="sum")
-        # sort for 35 and earlier
-        if compat.PY36:
-            expected = expected[["b", "a"]]
+        expected = expected[["b", "a"]]
         tm.assert_frame_equal(result, expected)
 
     def test_no_args_raises(self):
@@ -376,12 +460,12 @@ def test_no_args_raises(self):
         expected = pd.DataFrame()
         tm.assert_frame_equal(result, expected)
 
-    def test_series_named_agg_duplicates_raises(self):
-        # This is a limitation of the named agg implementation reusing
-        # aggregate_multiple_funcs. It could maybe be lifted in the future.
+    def test_series_named_agg_duplicates_no_raises(self):
+        # GH28426
         gr = pd.Series([1, 2, 3]).groupby([0, 0, 1])
-        with pytest.raises(SpecificationError):
-            gr.agg(a="sum", b="sum")
+        grouped = gr.agg(a="sum", b="sum")
+        expected = pd.DataFrame({"a": [3, 3], "b": [3, 3]})
+        tm.assert_frame_equal(expected, grouped)
 
     def test_mangled(self):
         gr = pd.Series([1, 2, 3]).groupby([0, 0, 1])
@@ -425,8 +509,6 @@ def test_agg_relabel(self):
             index=pd.Index(["a", "b"], name="group"),
             columns=["b_min", "a_min", "a_mean", "a_max", "b_max", "a_98"],
         )
-        if not compat.PY36:
-            expected = expected[["a_98", "a_max", "a_mean", "a_min", "b_max", "b_min"]]
         tm.assert_frame_equal(result, expected)
 
     def test_agg_relabel_non_identifier(self):
@@ -440,12 +522,34 @@ def test_agg_relabel_non_identifier(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_duplicate_raises(self):
-        # TODO: we currently raise on multiple lambdas. We could *maybe*
-        # update com.get_callable_name to append `_i` to each lambda.
+    def test_duplicate_no_raises(self):
+        # GH 28426, if use same input function on same column,
+        # no error should raise
         df = pd.DataFrame({"A": [0, 0, 1, 1], "B": [1, 2, 3, 4]})
-        with pytest.raises(SpecificationError, match="Function names"):
-            df.groupby("A").agg(a=("A", "min"), b=("A", "min"))
+
+        grouped = df.groupby("A").agg(a=("B", "min"), b=("B", "min"))
+        expected = pd.DataFrame(
+            {"a": [1, 3], "b": [1, 3]}, index=pd.Index([0, 1], name="A")
+        )
+        tm.assert_frame_equal(grouped, expected)
+
+        quant50 = functools.partial(np.percentile, q=50)
+        quant70 = functools.partial(np.percentile, q=70)
+        quant50.__name__ = "quant50"
+        quant70.__name__ = "quant70"
+
+        test = pd.DataFrame(
+            {"col1": ["a", "a", "b", "b", "b"], "col2": [1, 2, 3, 4, 5]}
+        )
+
+        grouped = test.groupby("col1").agg(
+            quantile_50=("col2", quant50), quantile_70=("col2", quant70)
+        )
+        expected = pd.DataFrame(
+            {"quantile_50": [1.5, 4.0], "quantile_70": [1.7, 4.4]},
+            index=pd.Index(["a", "b"], name="col1"),
+        )
+        tm.assert_frame_equal(grouped, expected)
 
     def test_agg_relabel_with_level(self):
         df = pd.DataFrame(
@@ -495,44 +599,179 @@ def test_mangled(self):
         tm.assert_frame_equal(result, expected)
 
 
-class TestLambdaMangling:
-    def test_maybe_mangle_lambdas_passthrough(self):
-        assert _maybe_mangle_lambdas("mean") == "mean"
-        assert _maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
-        # don't mangel single lambda.
-        assert _maybe_mangle_lambdas([lambda x: x])[0].__name__ == "<lambda>"
-
-    def test_maybe_mangle_lambdas_listlike(self):
-        aggfuncs = [lambda x: 1, lambda x: 2]
-        result = _maybe_mangle_lambdas(aggfuncs)
-        assert result[0].__name__ == "<lambda_0>"
-        assert result[1].__name__ == "<lambda_1>"
-        assert aggfuncs[0](None) == result[0](None)
-        assert aggfuncs[1](None) == result[1](None)
-
-    def test_maybe_mangle_lambdas(self):
-        func = {"A": [lambda x: 0, lambda x: 1]}
-        result = _maybe_mangle_lambdas(func)
-        assert result["A"][0].__name__ == "<lambda_0>"
-        assert result["A"][1].__name__ == "<lambda_1>"
-
-    def test_maybe_mangle_lambdas_args(self):
-        func = {"A": [lambda x, a, b=1: (0, a, b), lambda x: 1]}
-        result = _maybe_mangle_lambdas(func)
-        assert result["A"][0].__name__ == "<lambda_0>"
-        assert result["A"][1].__name__ == "<lambda_1>"
-
-        assert func["A"][0](0, 1) == (0, 1, 1)
-        assert func["A"][0](0, 1, 2) == (0, 1, 2)
-        assert func["A"][0](0, 2, b=3) == (0, 2, 3)
-
-    def test_maybe_mangle_lambdas_named(self):
-        func = OrderedDict(
-            [("C", np.mean), ("D", OrderedDict([("foo", np.mean), ("bar", np.mean)]))]
-        )
-        result = _maybe_mangle_lambdas(func)
-        assert result == func
+@pytest.mark.parametrize(
+    "agg_col1, agg_col2, agg_col3, agg_result1, agg_result2, agg_result3",
+    [
+        (
+            (("y", "A"), "max"),
+            (("y", "A"), np.min),
+            (("y", "B"), "mean"),
+            [1, 3],
+            [0, 2],
+            [5.5, 7.5],
+        ),
+        (
+            (("y", "A"), lambda x: max(x)),
+            (("y", "A"), lambda x: 1),
+            (("y", "B"), "mean"),
+            [1, 3],
+            [1, 1],
+            [5.5, 7.5],
+        ),
+        (
+            pd.NamedAgg(("y", "A"), "max"),
+            pd.NamedAgg(("y", "B"), np.mean),
+            pd.NamedAgg(("y", "A"), lambda x: 1),
+            [1, 3],
+            [5.5, 7.5],
+            [1, 1],
+        ),
+    ],
+)
+def test_agg_relabel_multiindex_column(
+    agg_col1, agg_col2, agg_col3, agg_result1, agg_result2, agg_result3
+):
+    # GH 29422, add tests for multiindex column cases
+    df = DataFrame(
+        {"group": ["a", "a", "b", "b"], "A": [0, 1, 2, 3], "B": [5, 6, 7, 8]}
+    )
+    df.columns = pd.MultiIndex.from_tuples([("x", "group"), ("y", "A"), ("y", "B")])
+    idx = pd.Index(["a", "b"], name=("x", "group"))
+
+    result = df.groupby(("x", "group")).agg(a_max=(("y", "A"), "max"))
+    expected = DataFrame({"a_max": [1, 3]}, index=idx)
+    tm.assert_frame_equal(result, expected)
+
+    result = df.groupby(("x", "group")).agg(
+        col_1=agg_col1, col_2=agg_col2, col_3=agg_col3
+    )
+    expected = DataFrame(
+        {"col_1": agg_result1, "col_2": agg_result2, "col_3": agg_result3}, index=idx
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_relabel_multiindex_raises_not_exist():
+    # GH 29422, add test for raises senario when aggregate column does not exist
+    df = DataFrame(
+        {"group": ["a", "a", "b", "b"], "A": [0, 1, 2, 3], "B": [5, 6, 7, 8]}
+    )
+    df.columns = pd.MultiIndex.from_tuples([("x", "group"), ("y", "A"), ("y", "B")])
+
+    with pytest.raises(KeyError, match="does not exist"):
+        df.groupby(("x", "group")).agg(a=(("Y", "a"), "max"))
+
+
+def test_agg_relabel_multiindex_duplicates():
+    # GH29422, add test for raises senario when getting duplicates
+    # GH28426, after this change, duplicates should also work if the relabelling is
+    # different
+    df = DataFrame(
+        {"group": ["a", "a", "b", "b"], "A": [0, 1, 2, 3], "B": [5, 6, 7, 8]}
+    )
+    df.columns = pd.MultiIndex.from_tuples([("x", "group"), ("y", "A"), ("y", "B")])
+
+    result = df.groupby(("x", "group")).agg(
+        a=(("y", "A"), "min"), b=(("y", "A"), "min")
+    )
+    idx = pd.Index(["a", "b"], name=("x", "group"))
+    expected = DataFrame({"a": [0, 2], "b": [0, 2]}, index=idx)
+    tm.assert_frame_equal(result, expected)
+
+
+def myfunc(s):
+    return np.percentile(s, q=0.90)
+
+
+@pytest.mark.parametrize("func", [lambda s: np.percentile(s, q=0.90), myfunc])
+def test_lambda_named_agg(func):
+    # see gh-28467
+    animals = DataFrame(
+        {
+            "kind": ["cat", "dog", "cat", "dog"],
+            "height": [9.1, 6.0, 9.5, 34.0],
+            "weight": [7.9, 7.5, 9.9, 198.0],
+        }
+    )
+
+    result = animals.groupby("kind").agg(
+        mean_height=("height", "mean"), perc90=("height", func)
+    )
+    expected = DataFrame(
+        [[9.3, 9.1036], [20.0, 6.252]],
+        columns=["mean_height", "perc90"],
+        index=Index(["cat", "dog"], name="kind"),
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_aggregate_mixed_types():
+    # GH 16916
+    df = pd.DataFrame(
+        data=np.array([0] * 9).reshape(3, 3), columns=list("XYZ"), index=list("abc")
+    )
+    df["grouping"] = ["group 1", "group 1", 2]
+    result = df.groupby("grouping").aggregate(lambda x: x.tolist())
+    expected_data = [[[0], [0], [0]], [[0, 0], [0, 0], [0, 0]]]
+    expected = pd.DataFrame(
+        expected_data,
+        index=Index([2, "group 1"], dtype="object", name="grouping"),
+        columns=Index(["X", "Y", "Z"], dtype="object"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.xfail(reason="Not implemented.")
+def test_aggregate_udf_na_extension_type():
+    # https://github.com/pandas-dev/pandas/pull/31359
+    # This is currently failing to cast back to Int64Dtype.
+    # The presence of the NA causes two problems
+    # 1. NA is not an instance of Int64Dtype.type (numpy.int64)
+    # 2. The presence of an NA forces object type, so the non-NA values is
+    #    a Python int rather than a NumPy int64. Python ints aren't
+    #    instances of numpy.int64.
+    def aggfunc(x):
+        if all(x > 2):
+            return 1
+        else:
+            return pd.NA
+
+    df = pd.DataFrame({"A": pd.array([1, 2, 3])})
+    result = df.groupby([1, 1, 2]).agg(aggfunc)
+    expected = pd.DataFrame({"A": pd.array([1, pd.NA], dtype="Int64")}, index=[1, 2])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", ["min", "max"])
+def test_groupby_aggregate_period_column(func):
+    # GH 31471
+    groups = [1, 2]
+    periods = pd.period_range("2020", periods=2, freq="Y")
+    df = pd.DataFrame({"a": groups, "b": periods})
 
+    result = getattr(df.groupby("a")["b"], func)()
+    idx = pd.Int64Index([1, 2], name="a")
+    expected = pd.Series(periods, index=idx, name="b")
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", ["min", "max"])
+def test_groupby_aggregate_period_frame(func):
+    # GH 31471
+    groups = [1, 2]
+    periods = pd.period_range("2020", periods=2, freq="Y")
+    df = pd.DataFrame({"a": groups, "b": periods})
+
+    result = getattr(df.groupby("a"), func)()
+    idx = pd.Int64Index([1, 2], name="a")
+    expected = pd.DataFrame({"b": periods}, index=idx)
+
+    tm.assert_frame_equal(result, expected)
+
+
+class TestLambdaMangling:
     def test_basic(self):
         df = pd.DataFrame({"A": [0, 0, 1, 1], "B": [1, 2, 3, 4]})
         result = df.groupby("A").agg({"B": [lambda x: 0, lambda x: 1]})
@@ -571,10 +810,7 @@ def test_agg_with_one_lambda(self):
             }
         )
 
-        # sort for 35 and earlier
         columns = ["height_sqr_min", "height_max", "weight_max"]
-        if compat.PY35:
-            columns = ["height_max", "height_sqr_min", "weight_max"]
         expected = pd.DataFrame(
             {
                 "height_sqr_min": [82.81, 36.00],
@@ -613,7 +849,6 @@ def test_agg_multiple_lambda(self):
                 "weight": [7.9, 7.5, 9.9, 198.0],
             }
         )
-        # sort for 35 and earlier
         columns = [
             "height_sqr_min",
             "height_max",
@@ -621,14 +856,6 @@ def test_agg_multiple_lambda(self):
             "height_max_2",
             "weight_min",
         ]
-        if compat.PY35:
-            columns = [
-                "height_max",
-                "height_max_2",
-                "height_sqr_min",
-                "weight_max",
-                "weight_min",
-            ]
         expected = pd.DataFrame(
             {
                 "height_sqr_min": [82.81, 36.00],
@@ -662,48 +889,3 @@ def test_agg_multiple_lambda(self):
             weight_min=pd.NamedAgg(column="weight", aggfunc=lambda x: np.min(x)),
         )
         tm.assert_frame_equal(result2, expected)
-
-    @pytest.mark.parametrize(
-        "order, expected_reorder",
-        [
-            (
-                [
-                    ("height", "<lambda>"),
-                    ("height", "max"),
-                    ("weight", "max"),
-                    ("height", "<lambda>"),
-                    ("weight", "<lambda>"),
-                ],
-                [
-                    ("height", "<lambda>_0"),
-                    ("height", "max"),
-                    ("weight", "max"),
-                    ("height", "<lambda>_1"),
-                    ("weight", "<lambda>"),
-                ],
-            ),
-            (
-                [
-                    ("col2", "min"),
-                    ("col1", "<lambda>"),
-                    ("col1", "<lambda>"),
-                    ("col1", "<lambda>"),
-                ],
-                [
-                    ("col2", "min"),
-                    ("col1", "<lambda>_0"),
-                    ("col1", "<lambda>_1"),
-                    ("col1", "<lambda>_2"),
-                ],
-            ),
-            (
-                [("col", "<lambda>"), ("col", "<lambda>"), ("col", "<lambda>")],
-                [("col", "<lambda>_0"), ("col", "<lambda>_1"), ("col", "<lambda>_2")],
-            ),
-        ],
-    )
-    def test_make_unique(self, order, expected_reorder):
-        # GH 27519, test if make_unique function reorders correctly
-        result = _make_unique(order)
-
-        assert result == expected_reorder
diff --git a/pandas/tests/groupby/aggregate/test_cython.py b/pandas/tests/groupby/aggregate/test_cython.py
index 5d50c044cf9f5..5ddda264642de 100644
--- a/pandas/tests/groupby/aggregate/test_cython.py
+++ b/pandas/tests/groupby/aggregate/test_cython.py
@@ -7,8 +7,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, NaT, Series, Timedelta, Timestamp, bdate_range
+import pandas._testing as tm
 from pandas.core.groupby.groupby import DataError
-import pandas.util.testing as tm
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/groupby/aggregate/test_other.py b/pandas/tests/groupby/aggregate/test_other.py
index 103ebf514b702..52ee3e652501c 100644
--- a/pandas/tests/groupby/aggregate/test_other.py
+++ b/pandas/tests/groupby/aggregate/test_other.py
@@ -2,7 +2,6 @@
 test all other .agg behavior
 """
 
-from collections import OrderedDict
 import datetime as dt
 from functools import partial
 
@@ -19,15 +18,15 @@
     date_range,
     period_range,
 )
-from pandas.core.groupby.groupby import SpecificationError
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.base import SpecificationError
 
 from pandas.io.formats.printing import pprint_thing
 
 
 def test_agg_api():
     # GH 6337
-    # http://stackoverflow.com/questions/21706030/pandas-groupby-agg-function-column-dtype-error
+    # https://stackoverflow.com/questions/21706030/pandas-groupby-agg-function-column-dtype-error
     # different api for agg when passed custom function with mixed frame
 
     df = DataFrame(
@@ -96,8 +95,7 @@ def test_agg_period_index():
     index = period_range(start="1999-01", periods=5, freq="M")
     s1 = Series(np.random.rand(len(index)), index=index)
     s2 = Series(np.random.rand(len(index)), index=index)
-    series = [("s1", s1), ("s2", s2)]
-    df = DataFrame.from_dict(OrderedDict(series))
+    df = DataFrame.from_dict({"s1": s1, "s2": s2})
     grouped = df.groupby(df.index.month)
     list(grouped)
 
@@ -211,31 +209,26 @@ def test_aggregate_api_consistency():
     expected = pd.concat([c_mean, c_sum, d_mean, d_sum], axis=1)
     expected.columns = MultiIndex.from_product([["C", "D"], ["mean", "sum"]])
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = grouped[["D", "C"]].agg({"r": np.sum, "r2": np.mean})
-    expected = pd.concat([d_sum, c_sum, d_mean, c_mean], axis=1)
-    expected.columns = MultiIndex.from_product([["r", "r2"], ["D", "C"]])
-    tm.assert_frame_equal(result, expected, check_like=True)
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        grouped[["D", "C"]].agg({"r": np.sum, "r2": np.mean})
 
 
 def test_agg_dict_renaming_deprecation():
     # 15931
     df = pd.DataFrame({"A": [1, 1, 1, 2, 2], "B": range(5), "C": range(5)})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w:
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
         df.groupby("A").agg(
             {"B": {"foo": ["sum", "max"]}, "C": {"bar": ["count", "min"]}}
         )
-        assert "using a dict with renaming" in str(w[0].message)
-        assert "named aggregation" in str(w[0].message)
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+    with pytest.raises(SpecificationError, match=msg):
         df.groupby("A")[["B", "C"]].agg({"ma": "max"})
 
-    with tm.assert_produces_warning(FutureWarning) as w:
+    with pytest.raises(SpecificationError, match=msg):
         df.groupby("A").B.agg({"foo": "count"})
-        assert "using a dict on a Series for aggregation" in str(w[0].message)
-        assert "named aggregation instead." in str(w[0].message)
 
 
 def test_agg_compat():
@@ -251,18 +244,12 @@ def test_agg_compat():
 
     g = df.groupby(["A", "B"])
 
-    expected = pd.concat([g["D"].sum(), g["D"].std()], axis=1)
-    expected.columns = MultiIndex.from_tuples([("C", "sum"), ("C", "std")])
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = g["D"].agg({"C": ["sum", "std"]})
-    tm.assert_frame_equal(result, expected, check_like=True)
-
-    expected = pd.concat([g["D"].sum(), g["D"].std()], axis=1)
-    expected.columns = ["C", "D"]
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        g["D"].agg({"C": ["sum", "std"]})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = g["D"].agg({"C": "sum", "D": "std"})
-    tm.assert_frame_equal(result, expected, check_like=True)
+    with pytest.raises(SpecificationError, match=msg):
+        g["D"].agg({"C": "sum", "D": "std"})
 
 
 def test_agg_nested_dicts():
@@ -278,29 +265,20 @@ def test_agg_nested_dicts():
 
     g = df.groupby(["A", "B"])
 
-    msg = r"cannot perform renaming for r[1-2] with a nested dictionary"
+    msg = r"nested renamer is not supported"
     with pytest.raises(SpecificationError, match=msg):
         g.aggregate({"r1": {"C": ["mean", "sum"]}, "r2": {"D": ["mean", "sum"]}})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = g.agg({"C": {"ra": ["mean", "std"]}, "D": {"rb": ["mean", "std"]}})
-    expected = pd.concat(
-        [g["C"].mean(), g["C"].std(), g["D"].mean(), g["D"].std()], axis=1
-    )
-    expected.columns = pd.MultiIndex.from_tuples(
-        [("ra", "mean"), ("ra", "std"), ("rb", "mean"), ("rb", "std")]
-    )
-    tm.assert_frame_equal(result, expected, check_like=True)
+    with pytest.raises(SpecificationError, match=msg):
+        g.agg({"C": {"ra": ["mean", "std"]}, "D": {"rb": ["mean", "std"]}})
 
     # same name as the original column
     # GH9052
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        expected = g["D"].agg({"result1": np.sum, "result2": np.mean})
-    expected = expected.rename(columns={"result1": "D"})
+    with pytest.raises(SpecificationError, match=msg):
+        g["D"].agg({"result1": np.sum, "result2": np.mean})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = g["D"].agg({"D": np.sum, "result2": np.mean})
-    tm.assert_frame_equal(result, expected, check_like=True)
+    with pytest.raises(SpecificationError, match=msg):
+        g["D"].agg({"D": np.sum, "result2": np.mean})
 
 
 def test_agg_item_by_item_raise_typeerror():
@@ -385,10 +363,7 @@ def test_agg_consistency():
     # agg with ([]) and () not consistent
     # GH 6715
     def P1(a):
-        try:
-            return np.percentile(a.dropna(), q=1)
-        except Exception:
-            return np.nan
+        return np.percentile(a.dropna(), q=1)
 
     df = DataFrame(
         {
@@ -457,6 +432,31 @@ def test_agg_over_numpy_arrays():
     tm.assert_frame_equal(result, expected)
 
 
+def test_agg_tzaware_non_datetime_result():
+    # discussed in GH#29589, fixed in GH#29641, operating on tzaware values
+    #  with function that is not dtype-preserving
+    dti = pd.date_range("2012-01-01", periods=4, tz="UTC")
+    df = pd.DataFrame({"a": [0, 0, 1, 1], "b": dti})
+    gb = df.groupby("a")
+
+    # Case that _does_ preserve the dtype
+    result = gb["b"].agg(lambda x: x.iloc[0])
+    expected = pd.Series(dti[::2], name="b")
+    expected.index.name = "a"
+    tm.assert_series_equal(result, expected)
+
+    # Cases that do _not_ preserve the dtype
+    result = gb["b"].agg(lambda x: x.iloc[0].year)
+    expected = pd.Series([2012, 2012], name="b")
+    expected.index.name = "a"
+    tm.assert_series_equal(result, expected)
+
+    result = gb["b"].agg(lambda x: x.iloc[-1] - x.iloc[0])
+    expected = pd.Series([pd.Timedelta(days=1), pd.Timedelta(days=1)], name="b")
+    expected.index.name = "a"
+    tm.assert_series_equal(result, expected)
+
+
 def test_agg_timezone_round_trip():
     # GH 15426
     ts = pd.Timestamp("2016-01-01 12:00:00", tz="US/Pacific")
@@ -473,8 +473,7 @@ def test_agg_timezone_round_trip():
     assert result3 == ts
 
     dates = [
-        pd.Timestamp("2016-01-0{i:d} 12:00:00".format(i=i), tz="US/Pacific")
-        for i in range(1, 5)
+        pd.Timestamp(f"2016-01-0{i:d} 12:00:00", tz="US/Pacific") for i in range(1, 5)
     ]
     df = pd.DataFrame({"A": ["a", "b"] * 2, "B": dates})
     grouped = df.groupby("A")
@@ -605,3 +604,41 @@ def test_agg_lambda_with_timezone():
         columns=["date"],
     )
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "err_cls",
+    [
+        NotImplementedError,
+        RuntimeError,
+        KeyError,
+        IndexError,
+        OSError,
+        ValueError,
+        ArithmeticError,
+        AttributeError,
+    ],
+)
+def test_groupby_agg_err_catching(err_cls):
+    # make sure we suppress anything other than TypeError or AssertionError
+    #  in _python_agg_general
+
+    # Use a non-standard EA to make sure we don't go down ndarray paths
+    from pandas.tests.extension.decimal.array import DecimalArray, make_data, to_decimal
+
+    data = make_data()[:5]
+    df = pd.DataFrame(
+        {"id1": [0, 0, 0, 1, 1], "id2": [0, 1, 0, 1, 1], "decimals": DecimalArray(data)}
+    )
+
+    expected = pd.Series(to_decimal([data[0], data[3]]))
+
+    def weird_func(x):
+        # weird function that raise something other than TypeError or IndexError
+        #  in _python_agg_general
+        if len(x) == 0:
+            raise err_cls
+        return x.iloc[0]
+
+    result = df["decimals"].groupby(df["id1"]).agg(weird_func)
+    tm.assert_series_equal(result, expected, check_names=False)
diff --git a/pandas/tests/groupby/conftest.py b/pandas/tests/groupby/conftest.py
index 72e60c5099304..ebac36c5f8c78 100644
--- a/pandas/tests/groupby/conftest.py
+++ b/pandas/tests/groupby/conftest.py
@@ -2,8 +2,8 @@
 import pytest
 
 from pandas import DataFrame, MultiIndex
-from pandas.core.groupby.base import reduction_kernels
-from pandas.util import testing as tm
+import pandas._testing as tm
+from pandas.core.groupby.base import reduction_kernels, transformation_kernels
 
 
 @pytest.fixture
@@ -110,3 +110,15 @@ def reduction_func(request):
     """yields the string names of all groupby reduction functions, one at a time.
     """
     return request.param
+
+
+@pytest.fixture(params=sorted(transformation_kernels))
+def transformation_func(request):
+    """yields the string names of all groupby transformation functions."""
+    return request.param
+
+
+@pytest.fixture(params=sorted(reduction_kernels) + sorted(transformation_kernels))
+def groupby_func(request):
+    """yields both aggregation and transformation functions."""
+    return request.param
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index 76588549532b1..41ec70468aaeb 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -6,7 +6,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, bdate_range
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 def test_apply_issues():
@@ -265,7 +265,7 @@ def desc3(group):
         result = group.describe()
 
         # names are different
-        result.index.name = "stat_{:d}".format(len(group))
+        result.index.name = f"stat_{len(group):d}"
 
         result = result[: len(group)]
         # weirdo
@@ -467,6 +467,29 @@ def filt2(x):
     tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize("test_series", [True, False])
+def test_apply_with_duplicated_non_sorted_axis(test_series):
+    # GH 30667
+    df = pd.DataFrame(
+        [["x", "p"], ["x", "p"], ["x", "o"]], columns=["X", "Y"], index=[1, 2, 2]
+    )
+    if test_series:
+        ser = df.set_index("Y")["X"]
+        result = ser.groupby(level=0).apply(lambda x: x)
+
+        # not expecting the order to remain the same for duplicated axis
+        result = result.sort_index()
+        expected = ser.sort_index()
+        tm.assert_series_equal(result, expected)
+    else:
+        result = df.groupby("Y").apply(lambda x: x)
+
+        # not expecting the order to remain the same for duplicated axis
+        result = result.sort_values("Y")
+        expected = df.sort_values("Y")
+        tm.assert_frame_equal(result, expected)
+
+
 def test_apply_corner_cases():
     # #535, can't use sliding iterator
 
@@ -543,6 +566,33 @@ def predictions(tool):
     tm.assert_series_equal(expected, result)
 
 
+def test_apply_aggregating_timedelta_and_datetime():
+    # Regression test for GH 15562
+    # The following groupby caused ValueErrors and IndexErrors pre 0.20.0
+
+    df = pd.DataFrame(
+        {
+            "clientid": ["A", "B", "C"],
+            "datetime": [np.datetime64("2017-02-01 00:00:00")] * 3,
+        }
+    )
+    df["time_delta_zero"] = df.datetime - df.datetime
+    result = df.groupby("clientid").apply(
+        lambda ddf: pd.Series(
+            dict(clientid_age=ddf.time_delta_zero.min(), date=ddf.datetime.min())
+        )
+    )
+    expected = pd.DataFrame(
+        {
+            "clientid": ["A", "B", "C"],
+            "clientid_age": [np.timedelta64(0, "D")] * 3,
+            "date": [np.datetime64("2017-02-01 00:00:00")] * 3,
+        }
+    ).set_index("clientid")
+
+    tm.assert_frame_equal(result, expected)
+
+
 def test_time_field_bug():
     # Test a fix for the following error related to GH issue 11324 When
     # non-key fields in a group-by dataframe contained time-based fields
@@ -657,3 +707,161 @@ def test_apply_with_mixed_types():
 
     result = g.apply(lambda x: x / x.sum())
     tm.assert_frame_equal(result, expected)
+
+
+def test_func_returns_object():
+    # GH 28652
+    df = DataFrame({"a": [1, 2]}, index=pd.Int64Index([1, 2]))
+    result = df.groupby("a").apply(lambda g: g.index)
+    expected = Series(
+        [pd.Int64Index([1]), pd.Int64Index([2])], index=pd.Int64Index([1, 2], name="a")
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "group_column_dtlike",
+    [datetime.today(), datetime.today().date(), datetime.today().time()],
+)
+def test_apply_datetime_issue(group_column_dtlike):
+    # GH-28247
+    # groupby-apply throws an error if one of the columns in the DataFrame
+    #   is a datetime object and the column labels are different from
+    #   standard int values in range(len(num_columns))
+
+    df = pd.DataFrame({"a": ["foo"], "b": [group_column_dtlike]})
+    result = df.groupby("a").apply(lambda x: pd.Series(["spam"], index=[42]))
+
+    expected = pd.DataFrame(
+        ["spam"], Index(["foo"], dtype="object", name="a"), columns=[42]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_series_return_dataframe_groups():
+    # GH 10078
+    tdf = DataFrame(
+        {
+            "day": {
+                0: pd.Timestamp("2015-02-24 00:00:00"),
+                1: pd.Timestamp("2015-02-24 00:00:00"),
+                2: pd.Timestamp("2015-02-24 00:00:00"),
+                3: pd.Timestamp("2015-02-24 00:00:00"),
+                4: pd.Timestamp("2015-02-24 00:00:00"),
+            },
+            "userAgent": {
+                0: "some UA string",
+                1: "some UA string",
+                2: "some UA string",
+                3: "another UA string",
+                4: "some UA string",
+            },
+            "userId": {
+                0: "17661101",
+                1: "17661101",
+                2: "17661101",
+                3: "17661101",
+                4: "17661101",
+            },
+        }
+    )
+
+    def most_common_values(df):
+        return Series({c: s.value_counts().index[0] for c, s in df.iteritems()})
+
+    result = tdf.groupby("day").apply(most_common_values)["userId"]
+    expected = pd.Series(
+        ["17661101"], index=pd.DatetimeIndex(["2015-02-24"], name="day"), name="userId"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("category", [False, True])
+def test_apply_multi_level_name(category):
+    # https://github.com/pandas-dev/pandas/issues/31068
+    b = [1, 2] * 5
+    if category:
+        b = pd.Categorical(b, categories=[1, 2, 3])
+    df = pd.DataFrame(
+        {"A": np.arange(10), "B": b, "C": list(range(10)), "D": list(range(10))}
+    ).set_index(["A", "B"])
+    result = df.groupby("B").apply(lambda x: x.sum())
+    expected = pd.DataFrame(
+        {"C": [20, 25], "D": [20, 25]}, index=pd.Index([1, 2], name="B")
+    )
+    tm.assert_frame_equal(result, expected)
+    assert df.index.names == ["A", "B"]
+
+
+def test_groupby_apply_datetime_result_dtypes():
+    # GH 14849
+    data = pd.DataFrame.from_records(
+        [
+            (pd.Timestamp(2016, 1, 1), "red", "dark", 1, "8"),
+            (pd.Timestamp(2015, 1, 1), "green", "stormy", 2, "9"),
+            (pd.Timestamp(2014, 1, 1), "blue", "bright", 3, "10"),
+            (pd.Timestamp(2013, 1, 1), "blue", "calm", 4, "potato"),
+        ],
+        columns=["observation", "color", "mood", "intensity", "score"],
+    )
+    result = data.groupby("color").apply(lambda g: g.iloc[0]).dtypes
+    expected = Series(
+        [np.dtype("datetime64[ns]"), np.object, np.object, np.int64, np.object],
+        index=["observation", "color", "mood", "intensity", "score"],
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        pd.CategoricalIndex(list("abc")),
+        pd.interval_range(0, 3),
+        pd.period_range("2020", periods=3, freq="D"),
+        pd.MultiIndex.from_tuples([("a", 0), ("a", 1), ("b", 0)]),
+    ],
+)
+def test_apply_index_has_complex_internals(index):
+    # GH 31248
+    df = DataFrame({"group": [1, 1, 2], "value": [0, 1, 0]}, index=index)
+    result = df.groupby("group").apply(lambda x: x)
+    tm.assert_frame_equal(result, df)
+
+
+@pytest.mark.parametrize(
+    "function, expected_values",
+    [
+        (lambda x: x.index.to_list(), [[0, 1], [2, 3]]),
+        (lambda x: set(x.index.to_list()), [{0, 1}, {2, 3}]),
+        (lambda x: tuple(x.index.to_list()), [(0, 1), (2, 3)]),
+        (
+            lambda x: {n: i for (n, i) in enumerate(x.index.to_list())},
+            [{0: 0, 1: 1}, {0: 2, 1: 3}],
+        ),
+        (
+            lambda x: [{n: i} for (n, i) in enumerate(x.index.to_list())],
+            [[{0: 0}, {1: 1}], [{0: 2}, {1: 3}]],
+        ),
+    ],
+)
+def test_apply_function_returns_non_pandas_non_scalar(function, expected_values):
+    # GH 31441
+    df = pd.DataFrame(["A", "A", "B", "B"], columns=["groups"])
+    result = df.groupby("groups").apply(function)
+    expected = pd.Series(expected_values, index=pd.Index(["A", "B"], name="groups"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_function_returns_numpy_array():
+    # GH 31605
+    def fct(group):
+        return group["B"].values.flatten()
+
+    df = pd.DataFrame({"A": ["a", "a", "b", "none"], "B": [1, 2, 3, np.nan]})
+
+    result = df.groupby("A").apply(fct)
+    expected = pd.Series(
+        [[1.0, 2.0], [3.0], [np.nan]], index=pd.Index(["a", "b", "none"], name="A")
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/test_bin_groupby.py b/pandas/tests/groupby/test_bin_groupby.py
index b8f9ecd42bae3..ff74d374e5e3f 100644
--- a/pandas/tests/groupby/test_bin_groupby.py
+++ b/pandas/tests/groupby/test_bin_groupby.py
@@ -1,5 +1,4 @@
 import numpy as np
-from numpy import nan
 import pytest
 
 from pandas._libs import groupby, lib, reduction as libreduction
@@ -7,14 +6,12 @@
 from pandas.core.dtypes.common import ensure_int64
 
 from pandas import Index, Series, isna
-from pandas.core.groupby.ops import generate_bins_generic
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
+import pandas._testing as tm
 
 
 def test_series_grouper():
     obj = Series(np.random.randn(10))
-    dummy = obj[:0]
+    dummy = obj.iloc[:0]
 
     labels = np.array([-1, -1, -1, 0, 0, 0, 1, 1, 1, 1], dtype=np.int64)
 
@@ -22,10 +19,20 @@ def test_series_grouper():
     result, counts = grouper.get_result()
 
     expected = np.array([obj[3:6].mean(), obj[6:].mean()])
-    assert_almost_equal(result, expected)
+    tm.assert_almost_equal(result, expected)
 
     exp_counts = np.array([3, 4], dtype=np.int64)
-    assert_almost_equal(counts, exp_counts)
+    tm.assert_almost_equal(counts, exp_counts)
+
+
+def test_series_grouper_requires_nonempty_raises():
+    # GH#29500
+    obj = Series(np.random.randn(10))
+    dummy = obj.iloc[:0]
+    labels = np.array([-1, -1, -1, 0, 0, 0, 1, 1, 1, 1], dtype=np.int64)
+
+    with pytest.raises(ValueError, match="SeriesGrouper requires non-empty `series`"):
+        libreduction.SeriesGrouper(dummy, np.mean, labels, 2, dummy)
 
 
 def test_series_bin_grouper():
@@ -38,48 +45,37 @@ def test_series_bin_grouper():
     result, counts = grouper.get_result()
 
     expected = np.array([obj[:3].mean(), obj[3:6].mean(), obj[6:].mean()])
-    assert_almost_equal(result, expected)
+    tm.assert_almost_equal(result, expected)
 
     exp_counts = np.array([3, 3, 4], dtype=np.int64)
-    assert_almost_equal(counts, exp_counts)
-
-
-class TestBinGroupers:
-    def setup_method(self, method):
-        self.obj = np.random.randn(10, 1)
-        self.labels = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 2], dtype=np.int64)
-        self.bins = np.array([3, 6], dtype=np.int64)
-
-    def test_generate_bins(self):
-        values = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
-        binner = np.array([0, 3, 6, 9], dtype=np.int64)
-
-        for func in [lib.generate_bins_dt64, generate_bins_generic]:
-            bins = func(values, binner, closed="left")
-            assert (bins == np.array([2, 5, 6])).all()
-
-            bins = func(values, binner, closed="right")
-            assert (bins == np.array([3, 6, 6])).all()
-
-        for func in [lib.generate_bins_dt64, generate_bins_generic]:
-            values = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
-            binner = np.array([0, 3, 6], dtype=np.int64)
-
-            bins = func(values, binner, closed="right")
-            assert (bins == np.array([3, 6])).all()
-
-        msg = "Invalid length for values or for binner"
-        with pytest.raises(ValueError, match=msg):
-            generate_bins_generic(values, [], "right")
-        with pytest.raises(ValueError, match=msg):
-            generate_bins_generic(values[:0], binner, "right")
-
-        msg = "Values falls before first bin"
-        with pytest.raises(ValueError, match=msg):
-            generate_bins_generic(values, [4], "right")
-        msg = "Values falls after last bin"
-        with pytest.raises(ValueError, match=msg):
-            generate_bins_generic(values, [-3, -1], "right")
+    tm.assert_almost_equal(counts, exp_counts)
+
+
+@pytest.mark.parametrize(
+    "binner,closed,expected",
+    [
+        (
+            np.array([0, 3, 6, 9], dtype=np.int64),
+            "left",
+            np.array([2, 5, 6], dtype=np.int64),
+        ),
+        (
+            np.array([0, 3, 6, 9], dtype=np.int64),
+            "right",
+            np.array([3, 6, 6], dtype=np.int64),
+        ),
+        (np.array([0, 3, 6], dtype=np.int64), "left", np.array([2, 5], dtype=np.int64)),
+        (
+            np.array([0, 3, 6], dtype=np.int64),
+            "right",
+            np.array([3, 6], dtype=np.int64),
+        ),
+    ],
+)
+def test_generate_bins(binner, closed, expected):
+    values = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
+    result = lib.generate_bins_dt64(values, binner, closed=closed)
+    tm.assert_numpy_array_equal(result, expected)
 
 
 def test_group_ohlc():
@@ -91,23 +87,23 @@ def _check(dtype):
         counts = np.zeros(len(out), dtype=np.int64)
         labels = ensure_int64(np.repeat(np.arange(3), np.diff(np.r_[0, bins])))
 
-        func = getattr(groupby, "group_ohlc_{dtype}".format(dtype=dtype))
+        func = getattr(groupby, f"group_ohlc_{dtype}")
         func(out, counts, obj[:, None], labels)
 
         def _ohlc(group):
             if isna(group).all():
-                return np.repeat(nan, 4)
+                return np.repeat(np.nan, 4)
             return [group[0], group.max(), group.min(), group[-1]]
 
         expected = np.array([_ohlc(obj[:6]), _ohlc(obj[6:12]), _ohlc(obj[12:])])
 
-        assert_almost_equal(out, expected)
+        tm.assert_almost_equal(out, expected)
         tm.assert_numpy_array_equal(counts, np.array([6, 6, 8], dtype=np.int64))
 
-        obj[:6] = nan
+        obj[:6] = np.nan
         func(out, counts, obj[:, None], labels)
-        expected[0] = nan
-        assert_almost_equal(out, expected)
+        expected[0] = np.nan
+        tm.assert_almost_equal(out, expected)
 
     _check("float32")
     _check("float64")
@@ -120,31 +116,32 @@ class TestMoments:
 class TestReducer:
     def test_int_index(self):
         arr = np.random.randn(100, 4)
-        result = libreduction.compute_reduction(arr, np.sum, labels=Index(np.arange(4)))
-        expected = arr.sum(0)
-        assert_almost_equal(result, expected)
 
-        result = libreduction.compute_reduction(
-            arr, np.sum, axis=1, labels=Index(np.arange(100))
-        )
-        expected = arr.sum(1)
-        assert_almost_equal(result, expected)
+        msg = "Must pass either dummy and labels, or neither"
+        # we must pass either both labels and dummy, or neither
+        with pytest.raises(ValueError, match=msg):
+            libreduction.compute_reduction(arr, np.sum, labels=Index(np.arange(4)))
+
+        with pytest.raises(ValueError, match=msg):
+            libreduction.compute_reduction(
+                arr, np.sum, axis=1, labels=Index(np.arange(100))
+            )
 
         dummy = Series(0.0, index=np.arange(100))
         result = libreduction.compute_reduction(
             arr, np.sum, dummy=dummy, labels=Index(np.arange(4))
         )
         expected = arr.sum(0)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         dummy = Series(0.0, index=np.arange(4))
         result = libreduction.compute_reduction(
             arr, np.sum, axis=1, dummy=dummy, labels=Index(np.arange(100))
         )
         expected = arr.sum(1)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         result = libreduction.compute_reduction(
             arr, np.sum, axis=1, dummy=dummy, labels=Index(np.arange(100))
         )
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index e09af3fd48ee6..9b07269811d8e 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -1,10 +1,9 @@
-from collections import OrderedDict
 from datetime import datetime
 
 import numpy as np
 import pytest
 
-from pandas.compat import PY37, is_platform_windows
+from pandas.compat import PY37
 
 import pandas as pd
 from pandas import (
@@ -16,13 +15,13 @@
     Series,
     qcut,
 )
-import pandas.util.testing as tm
-from pandas.util.testing import assert_equal, assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 def cartesian_product_for_groupers(result, args, names):
     """ Reindex to a cartesian production for the groupers,
-    preserving the nature (Categorical) of each grouper """
+    preserving the nature (Categorical) of each grouper
+    """
 
     def f(a):
         if isinstance(a, (CategoricalIndex, Categorical)):
@@ -159,7 +158,7 @@ def f(x):
     exp_idx = CategoricalIndex(levels, categories=cats.categories, ordered=True)
     expected = expected.reindex(exp_idx)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     grouped = data.groupby(cats, observed=False)
     desc_result = grouped.describe()
@@ -172,7 +171,7 @@ def f(x):
         ord_labels, ordered=True, categories=["foo", "bar", "baz", "qux"]
     )
     expected = ord_data.groupby(exp_cats, sort=False, observed=False).describe()
-    assert_frame_equal(desc_result, expected)
+    tm.assert_frame_equal(desc_result, expected)
 
     # GH 10460
     expc = Categorical.from_codes(np.arange(4).repeat(8), levels, ordered=True)
@@ -206,13 +205,12 @@ def test_level_get_group(observed):
     )
     result = g.get_group("a")
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
-# GH#21636 previously flaky on py37
-@pytest.mark.xfail(
-    is_platform_windows() and PY37, reason="Flaky, GH-27902", strict=False
-)
+# GH#21636 flaky on py37; may be related to older numpy, see discussion
+#  https://github.com/MacPython/pandas-wheels/pull/64
+@pytest.mark.xfail(PY37, reason="Flaky, GH-27902", strict=False)
 @pytest.mark.parametrize("ordered", [True, False])
 def test_apply(ordered):
     # GH 10138
@@ -229,22 +227,25 @@ def test_apply(ordered):
     idx = MultiIndex.from_arrays([missing, dense], names=["missing", "dense"])
     expected = DataFrame([0, 1, 2.0], index=idx, columns=["values"])
 
+    # GH#21636 tracking down the xfail, in some builds np.mean(df.loc[[0]])
+    #  is coming back as Series([0., 1., 0.], index=["missing", "dense", "values"])
+    #  when we expect Series(0., index=["values"])
     result = grouped.apply(lambda x: np.mean(x))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # we coerce back to ints
     expected = expected.astype("int")
     result = grouped.mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = grouped.agg(np.mean)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # but for transform we should still get back the original index
     idx = MultiIndex.from_arrays([missing, dense], names=["missing", "dense"])
     expected = Series(1, index=idx)
     result = grouped.apply(lambda x: 1)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_observed(observed):
@@ -333,7 +334,7 @@ def test_observed(observed):
         c, i = key
         result = groups_double_key.get_group(key)
         expected = df[(df.cat == c) & (df.ints == i)]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     # gh-8869
     # with as_index
@@ -497,10 +498,10 @@ def test_dataframe_categorical_ordered_observed_sort(ordered, observed, sort):
         aggr[aggr.isna()] = "missing"
     if not all(label == aggr):
         msg = (
-            "Labels and aggregation results not consistently sorted\n"
-            + "for (ordered={}, observed={}, sort={})\n"
-            + "Result:\n{}"
-        ).format(ordered, observed, sort, result)
+            f"Labels and aggregation results not consistently sorted\n"
+            + "for (ordered={ordered}, observed={observed}, sort={sort})\n"
+            + "Result:\n{result}"
+        )
         assert False, msg
 
 
@@ -520,7 +521,7 @@ def test_datetime():
         expected.index, categories=expected.index, ordered=True
     )
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     grouped = data.groupby(cats, observed=False)
     desc_result = grouped.describe()
@@ -529,7 +530,7 @@ def test_datetime():
     ord_labels = cats.take(idx)
     ord_data = data.take(idx)
     expected = ord_data.groupby(ord_labels, observed=False).describe()
-    assert_frame_equal(desc_result, expected)
+    tm.assert_frame_equal(desc_result, expected)
     tm.assert_index_equal(desc_result.index, expected.index)
     tm.assert_index_equal(
         desc_result.index.get_level_values(0), expected.index.get_level_values(0)
@@ -558,7 +559,7 @@ def test_categorical_index():
     expected.index = CategoricalIndex(
         Categorical.from_codes([0, 1, 2, 3], levels, ordered=True), name="cats"
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # with a cat column, should produce a cat index
     result = df.groupby("cats", observed=False).sum()
@@ -566,7 +567,7 @@ def test_categorical_index():
     expected.index = CategoricalIndex(
         Categorical.from_codes([0, 1, 2, 3], levels, ordered=True), name="cats"
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_describe_categorical_columns():
@@ -674,7 +675,7 @@ def test_preserve_categories():
 
     # ordered=True
     df = DataFrame({"A": Categorical(list("ba"), categories=categories, ordered=True)})
-    index = CategoricalIndex(categories, categories, ordered=True)
+    index = CategoricalIndex(categories, categories, ordered=True, name="A")
     tm.assert_index_equal(
         df.groupby("A", sort=True, observed=False).first().index, index
     )
@@ -684,8 +685,8 @@ def test_preserve_categories():
 
     # ordered=False
     df = DataFrame({"A": Categorical(list("ba"), categories=categories, ordered=False)})
-    sort_index = CategoricalIndex(categories, categories, ordered=False)
-    nosort_index = CategoricalIndex(list("bac"), list("bac"), ordered=False)
+    sort_index = CategoricalIndex(categories, categories, ordered=False, name="A")
+    nosort_index = CategoricalIndex(list("bac"), list("bac"), ordered=False, name="A")
     tm.assert_index_equal(
         df.groupby("A", sort=True, observed=False).first().index, sort_index
     )
@@ -755,7 +756,7 @@ def test_categorical_no_compress():
     exp.index = CategoricalIndex(
         exp.index, categories=cats.categories, ordered=cats.ordered
     )
-    assert_series_equal(result, exp)
+    tm.assert_series_equal(result, exp)
 
     codes = np.array([0, 0, 0, 1, 1, 1, 3, 3, 3])
     cats = Categorical.from_codes(codes, [0, 1, 2, 3], ordered=True)
@@ -765,7 +766,7 @@ def test_categorical_no_compress():
     exp.index = CategoricalIndex(
         exp.index, categories=cats.categories, ordered=cats.ordered
     )
-    assert_series_equal(result, exp)
+    tm.assert_series_equal(result, exp)
 
     cats = Categorical(
         ["a", "a", "a", "b", "b", "b", "c", "c", "c"],
@@ -780,15 +781,32 @@ def test_categorical_no_compress():
     tm.assert_numpy_array_equal(result, exp)
 
 
+def test_groupby_empty_with_category():
+    # GH-9614
+    # test fix for when group by on None resulted in
+    # coercion of dtype categorical -> float
+    df = pd.DataFrame(
+        {"A": [None] * 3, "B": pd.Categorical(["train", "train", "test"])}
+    )
+    result = df.groupby("A").first()["B"]
+    expected = pd.Series(
+        pd.Categorical([], categories=["test", "train"]),
+        index=pd.Series([], dtype="object", name="A"),
+        name="B",
+    )
+    tm.assert_series_equal(result, expected)
+
+
 def test_sort():
 
-    # http://stackoverflow.com/questions/23814368/sorting-pandas-categorical-labels-after-groupby  # noqa: flake8
+    # https://stackoverflow.com/questions/23814368/sorting-pandas-
+    #        categorical-labels-after-groupby
     # This should result in a properly sorted Series so that the plot
     # has a sorted x axis
     # self.cat.groupby(['value_group'])['value_group'].count().plot(kind='bar')
 
     df = DataFrame({"value": np.random.randint(0, 10000, 100)})
-    labels = ["{0} - {1}".format(i, i + 499) for i in range(0, 10000, 500)]
+    labels = [f"{i} - {i+499}" for i in range(0, 10000, 500)]
     cat_labels = Categorical(labels, labels)
 
     df = df.sort_values(by=["value"], ascending=True)
@@ -826,12 +844,12 @@ def test_sort2():
 
     col = "range"
     result_sort = df.groupby(col, sort=True, observed=False).first()
-    assert_frame_equal(result_sort, expected_sort)
+    tm.assert_frame_equal(result_sort, expected_sort)
 
     # when categories is ordered, group is ordered by category's order
     expected_sort = result_sort
     result_sort = df.groupby(col, sort=False, observed=False).first()
-    assert_frame_equal(result_sort, expected_sort)
+    tm.assert_frame_equal(result_sort, expected_sort)
 
     df["range"] = Categorical(df["range"], ordered=False)
     index = CategoricalIndex(
@@ -854,10 +872,10 @@ def test_sort2():
 
     # this is an unordered categorical, but we allow this ####
     result_sort = df.groupby(col, sort=True, observed=False).first()
-    assert_frame_equal(result_sort, expected_sort)
+    tm.assert_frame_equal(result_sort, expected_sort)
 
     result_nosort = df.groupby(col, sort=False, observed=False).first()
-    assert_frame_equal(result_nosort, expected_nosort)
+    tm.assert_frame_equal(result_nosort, expected_nosort)
 
 
 def test_sort_datetimelike():
@@ -909,10 +927,14 @@ def test_sort_datetimelike():
     )
 
     col = "dt"
-    assert_frame_equal(result_sort, df.groupby(col, sort=True, observed=False).first())
+    tm.assert_frame_equal(
+        result_sort, df.groupby(col, sort=True, observed=False).first()
+    )
 
     # when categories is ordered, group is ordered by category's order
-    assert_frame_equal(result_sort, df.groupby(col, sort=False, observed=False).first())
+    tm.assert_frame_equal(
+        result_sort, df.groupby(col, sort=False, observed=False).first()
+    )
 
     # ordered = False
     df["dt"] = Categorical(df["dt"], ordered=False)
@@ -939,8 +961,10 @@ def test_sort_datetimelike():
     result_nosort.index = CategoricalIndex(index, categories=index, name="dt")
 
     col = "dt"
-    assert_frame_equal(result_sort, df.groupby(col, sort=True, observed=False).first())
-    assert_frame_equal(
+    tm.assert_frame_equal(
+        result_sort, df.groupby(col, sort=True, observed=False).first()
+    )
+    tm.assert_frame_equal(
         result_nosort, df.groupby(col, sort=False, observed=False).first()
     )
 
@@ -1019,7 +1043,7 @@ def test_groupby_multiindex_categorical_datetime():
         names=["key1", "key2"],
     )
     expected = DataFrame({"values": [0, 4, 8, 3, 4, 5, 6, np.nan, 2]}, index=idx)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -1055,7 +1079,7 @@ def test_groupby_agg_observed_true_single_column(as_index, expected):
 
     result = df.groupby(["a", "b"], as_index=as_index, observed=True)["x"].sum()
 
-    assert_equal(result, expected)
+    tm.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("fill_value", [None, np.nan, pd.NaT])
@@ -1067,7 +1091,7 @@ def test_shift(fill_value):
         [None, "a", "b", "c"], categories=["a", "b", "c", "d"], ordered=False
     )
     res = ct.shift(1, fill_value=fill_value)
-    assert_equal(res, expected)
+    tm.assert_equal(res, expected)
 
 
 @pytest.fixture
@@ -1103,13 +1127,13 @@ def test_seriesgroupby_observed_true(df_cat, operation, kwargs):
     index = MultiIndex.from_frame(
         DataFrame(
             {"A": ["foo", "foo", "bar", "bar"], "B": ["one", "two", "one", "three"]},
-            **kwargs
+            **kwargs,
         )
     )
     expected = Series(data=[1, 3, 2, 4], index=index, name="C")
     grouped = df_cat.groupby(["A", "B"], observed=True)["C"]
     result = getattr(grouped, operation)(sum)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("operation", ["agg", "apply"])
@@ -1127,7 +1151,7 @@ def test_seriesgroupby_observed_false_or_none(df_cat, observed, operation):
     expected = Series(data=[2, 4, np.nan, 1, np.nan, 3], index=index, name="C")
     grouped = df_cat.groupby(["A", "B"], observed=observed)["C"]
     result = getattr(grouped, operation)(sum)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -1180,9 +1204,16 @@ def test_seriesgroupby_observed_apply_dict(df_cat, observed, index, data):
     # GH 24880
     expected = Series(data=data, index=index, name="C")
     result = df_cat.groupby(["A", "B"], observed=observed)["C"].apply(
-        lambda x: OrderedDict([("min", x.min()), ("max", x.max())])
+        lambda x: {"min": x.min(), "max": x.max()}
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
+
+
+def test_groupby_categorical_series_dataframe_consistent(df_cat):
+    # GH 20416
+    expected = df_cat.groupby(["A", "B"])["C"].mean()
+    result = df_cat.groupby(["A", "B"]).mean()["C"]
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("code", [([1, 0, 0]), ([0, 0, 0])])
@@ -1192,4 +1223,157 @@ def test_groupby_categorical_axis_1(code):
     cat = pd.Categorical.from_codes(code, categories=list("abc"))
     result = df.groupby(cat, axis=1).mean()
     expected = df.T.groupby(cat, axis=0).mean().T
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_cat_preserves_structure(observed, ordered_fixture):
+    # GH 28787
+    df = DataFrame(
+        {"Name": Categorical(["Bob", "Greg"], ordered=ordered_fixture), "Item": [1, 2]},
+        columns=["Name", "Item"],
+    )
+    expected = df.copy()
+
+    result = (
+        df.groupby("Name", observed=observed)
+        .agg(pd.DataFrame.sum, skipna=True)
+        .reset_index()
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_get_nonexistent_category():
+    # Accessing a Category that is not in the dataframe
+    df = pd.DataFrame({"var": ["a", "a", "b", "b"], "val": range(4)})
+    with pytest.raises(KeyError, match="'vau'"):
+        df.groupby("var").apply(
+            lambda rows: pd.DataFrame(
+                {"var": [rows.iloc[-1]["var"]], "val": [rows.iloc[-1]["vau"]]}
+            )
+        )
+
+
+def test_series_groupby_on_2_categoricals_unobserved(
+    reduction_func: str, observed: bool
+):
+    # GH 17605
+
+    if reduction_func == "ngroup":
+        pytest.skip("ngroup is not truly a reduction")
+
+    df = pd.DataFrame(
+        {
+            "cat_1": pd.Categorical(list("AABB"), categories=list("ABCD")),
+            "cat_2": pd.Categorical(list("AB") * 2, categories=list("ABCD")),
+            "value": [0.1] * 4,
+        }
+    )
+    args = {"nth": [0]}.get(reduction_func, [])
+
+    expected_length = 4 if observed else 16
+
+    series_groupby = df.groupby(["cat_1", "cat_2"], observed=observed)["value"]
+    agg = getattr(series_groupby, reduction_func)
+    result = agg(*args)
+
+    assert len(result) == expected_length
+
+
+@pytest.mark.parametrize(
+    "func, zero_or_nan",
+    [
+        ("all", np.NaN),
+        ("any", np.NaN),
+        ("count", 0),
+        ("first", np.NaN),
+        ("idxmax", np.NaN),
+        ("idxmin", np.NaN),
+        ("last", np.NaN),
+        ("mad", np.NaN),
+        ("max", np.NaN),
+        ("mean", np.NaN),
+        ("median", np.NaN),
+        ("min", np.NaN),
+        ("nth", np.NaN),
+        ("nunique", 0),
+        ("prod", np.NaN),
+        ("quantile", np.NaN),
+        ("sem", np.NaN),
+        ("size", 0),
+        ("skew", np.NaN),
+        ("std", np.NaN),
+        ("sum", np.NaN),
+        ("var", np.NaN),
+    ],
+)
+def test_series_groupby_on_2_categoricals_unobserved_zeroes_or_nans(func, zero_or_nan):
+    # GH 17605
+    # Tests whether the unobserved categories in the result contain 0 or NaN
+    df = pd.DataFrame(
+        {
+            "cat_1": pd.Categorical(list("AABB"), categories=list("ABC")),
+            "cat_2": pd.Categorical(list("AB") * 2, categories=list("ABC")),
+            "value": [0.1] * 4,
+        }
+    )
+    unobserved = [tuple("AC"), tuple("BC"), tuple("CA"), tuple("CB"), tuple("CC")]
+    args = {"nth": [0]}.get(func, [])
+
+    series_groupby = df.groupby(["cat_1", "cat_2"], observed=False)["value"]
+    agg = getattr(series_groupby, func)
+    result = agg(*args)
+
+    for idx in unobserved:
+        val = result.loc[idx]
+        assert (pd.isna(zero_or_nan) and pd.isna(val)) or (val == zero_or_nan)
+
+    # If we expect unobserved values to be zero, we also expect the dtype to be int
+    if zero_or_nan == 0:
+        assert np.issubdtype(result.dtype, np.integer)
+
+
+def test_series_groupby_categorical_aggregation_getitem():
+    # GH 8870
+    d = {"foo": [10, 8, 4, 1], "bar": [10, 20, 30, 40], "baz": ["d", "c", "d", "c"]}
+    df = pd.DataFrame(d)
+    cat = pd.cut(df["foo"], np.linspace(0, 20, 5))
+    df["range"] = cat
+    groups = df.groupby(["range", "baz"], as_index=True, sort=True)
+    result = groups["foo"].agg("mean")
+    expected = groups.agg("mean")["foo"]
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func, expected_values",
+    [(pd.Series.nunique, [1, 1, 2]), (pd.Series.count, [1, 2, 2])],
+)
+def test_groupby_agg_categorical_columns(func, expected_values):
+    # 31256
+    df = pd.DataFrame(
+        {
+            "id": [0, 1, 2, 3, 4],
+            "groups": [0, 1, 1, 2, 2],
+            "value": pd.Categorical([0, 0, 0, 0, 1]),
+        }
+    ).set_index("id")
+    result = df.groupby("groups").agg(func)
+
+    expected = pd.DataFrame(
+        {"value": expected_values}, index=pd.Index([0, 1, 2], name="groups"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_agg_non_numeric():
+    df = pd.DataFrame(
+        {"A": pd.Categorical(["a", "a", "b"], categories=["a", "b", "c"])}
+    )
+    expected = pd.DataFrame({"A": [2, 1]}, index=[1, 2])
+
+    result = df.groupby([1, 2, 1]).agg(pd.Series.nunique)
+    tm.assert_frame_equal(result, expected)
+
+    result = df.groupby([1, 2, 1]).nunique()
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 7e5180a5c7b2b..b4239d7d34a90 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -4,7 +4,7 @@
 import pytest
 
 from pandas import DataFrame, MultiIndex, Period, Series, Timedelta, Timestamp
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 class TestCounting:
@@ -15,18 +15,18 @@ def test_cumcount(self):
 
         expected = Series([0, 1, 2, 0, 3])
 
-        assert_series_equal(expected, g.cumcount())
-        assert_series_equal(expected, sg.cumcount())
+        tm.assert_series_equal(expected, g.cumcount())
+        tm.assert_series_equal(expected, sg.cumcount())
 
     def test_cumcount_empty(self):
         ge = DataFrame().groupby(level=0)
-        se = Series().groupby(level=0)
+        se = Series(dtype=object).groupby(level=0)
 
         # edge case, as this is usually considered float
         e = Series(dtype="int64")
 
-        assert_series_equal(e, ge.cumcount())
-        assert_series_equal(e, se.cumcount())
+        tm.assert_series_equal(e, ge.cumcount())
+        tm.assert_series_equal(e, se.cumcount())
 
     def test_cumcount_dupe_index(self):
         df = DataFrame(
@@ -37,8 +37,8 @@ def test_cumcount_dupe_index(self):
 
         expected = Series([0, 1, 2, 0, 3], index=[0] * 5)
 
-        assert_series_equal(expected, g.cumcount())
-        assert_series_equal(expected, sg.cumcount())
+        tm.assert_series_equal(expected, g.cumcount())
+        tm.assert_series_equal(expected, sg.cumcount())
 
     def test_cumcount_mi(self):
         mi = MultiIndex.from_tuples([[0, 1], [1, 2], [2, 2], [2, 2], [1, 0]])
@@ -48,8 +48,8 @@ def test_cumcount_mi(self):
 
         expected = Series([0, 1, 2, 0, 3], index=mi)
 
-        assert_series_equal(expected, g.cumcount())
-        assert_series_equal(expected, sg.cumcount())
+        tm.assert_series_equal(expected, g.cumcount())
+        tm.assert_series_equal(expected, sg.cumcount())
 
     def test_cumcount_groupby_not_col(self):
         df = DataFrame(
@@ -60,8 +60,8 @@ def test_cumcount_groupby_not_col(self):
 
         expected = Series([0, 1, 2, 0, 3], index=[0] * 5)
 
-        assert_series_equal(expected, g.cumcount())
-        assert_series_equal(expected, sg.cumcount())
+        tm.assert_series_equal(expected, g.cumcount())
+        tm.assert_series_equal(expected, sg.cumcount())
 
     def test_ngroup(self):
         df = DataFrame({"A": list("aaaba")})
@@ -70,8 +70,8 @@ def test_ngroup(self):
 
         expected = Series([0, 0, 0, 1, 0])
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_distinct(self):
         df = DataFrame({"A": list("abcde")})
@@ -80,8 +80,8 @@ def test_ngroup_distinct(self):
 
         expected = Series(range(5), dtype="int64")
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_one_group(self):
         df = DataFrame({"A": [0] * 5})
@@ -90,24 +90,24 @@ def test_ngroup_one_group(self):
 
         expected = Series([0] * 5)
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_empty(self):
         ge = DataFrame().groupby(level=0)
-        se = Series().groupby(level=0)
+        se = Series(dtype=object).groupby(level=0)
 
         # edge case, as this is usually considered float
         e = Series(dtype="int64")
 
-        assert_series_equal(e, ge.ngroup())
-        assert_series_equal(e, se.ngroup())
+        tm.assert_series_equal(e, ge.ngroup())
+        tm.assert_series_equal(e, se.ngroup())
 
     def test_ngroup_series_matches_frame(self):
         df = DataFrame({"A": list("aaaba")})
         s = Series(list("aaaba"))
 
-        assert_series_equal(df.groupby(s).ngroup(), s.groupby(s).ngroup())
+        tm.assert_series_equal(df.groupby(s).ngroup(), s.groupby(s).ngroup())
 
     def test_ngroup_dupe_index(self):
         df = DataFrame({"A": list("aaaba")}, index=[0] * 5)
@@ -116,8 +116,8 @@ def test_ngroup_dupe_index(self):
 
         expected = Series([0, 0, 0, 1, 0], index=[0] * 5)
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_mi(self):
         mi = MultiIndex.from_tuples([[0, 1], [1, 2], [2, 2], [2, 2], [1, 0]])
@@ -126,8 +126,8 @@ def test_ngroup_mi(self):
         sg = g.A
         expected = Series([0, 0, 0, 1, 0], index=mi)
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_groupby_not_col(self):
         df = DataFrame({"A": list("aaaba")}, index=[0] * 5)
@@ -136,8 +136,8 @@ def test_ngroup_groupby_not_col(self):
 
         expected = Series([0, 0, 0, 1, 0], index=[0] * 5)
 
-        assert_series_equal(expected, g.ngroup())
-        assert_series_equal(expected, sg.ngroup())
+        tm.assert_series_equal(expected, g.ngroup())
+        tm.assert_series_equal(expected, sg.ngroup())
 
     def test_ngroup_descending(self):
         df = DataFrame(["a", "a", "b", "a", "b"], columns=["A"])
@@ -146,9 +146,9 @@ def test_ngroup_descending(self):
         ascending = Series([0, 0, 1, 0, 1])
         descending = Series([1, 1, 0, 1, 0])
 
-        assert_series_equal(descending, (g.ngroups - 1) - ascending)
-        assert_series_equal(ascending, g.ngroup(ascending=True))
-        assert_series_equal(descending, g.ngroup(ascending=False))
+        tm.assert_series_equal(descending, (g.ngroups - 1) - ascending)
+        tm.assert_series_equal(ascending, g.ngroup(ascending=True))
+        tm.assert_series_equal(descending, g.ngroup(ascending=False))
 
     def test_ngroup_matches_cumcount(self):
         # verify one manually-worked out case works
@@ -162,8 +162,8 @@ def test_ngroup_matches_cumcount(self):
         expected_ngroup = Series([0, 1, 2, 0, 3])
         expected_cumcount = Series([0, 0, 0, 1, 0])
 
-        assert_series_equal(g_ngroup, expected_ngroup)
-        assert_series_equal(g_cumcount, expected_cumcount)
+        tm.assert_series_equal(g_ngroup, expected_ngroup)
+        tm.assert_series_equal(g_cumcount, expected_cumcount)
 
     def test_ngroup_cumcount_pair(self):
         # brute force comparison for all small series
@@ -175,8 +175,8 @@ def test_ngroup_cumcount_pair(self):
             ngroupd = [order.index(val) for val in p]
             cumcounted = [p[:i].count(val) for i, val in enumerate(p)]
 
-            assert_series_equal(g.ngroup(), Series(ngroupd))
-            assert_series_equal(g.cumcount(), Series(cumcounted))
+            tm.assert_series_equal(g.ngroup(), Series(ngroupd))
+            tm.assert_series_equal(g.cumcount(), Series(cumcounted))
 
     def test_ngroup_respects_groupby_order(self):
         np.random.seed(0)
@@ -191,17 +191,14 @@ def test_ngroup_respects_groupby_order(self):
                 for j, ind in enumerate(group.index):
                     df.loc[ind, "group_index"] = j
 
-            assert_series_equal(Series(df["group_id"].values), g.ngroup())
-            assert_series_equal(Series(df["group_index"].values), g.cumcount())
+            tm.assert_series_equal(Series(df["group_id"].values), g.ngroup())
+            tm.assert_series_equal(Series(df["group_index"].values), g.cumcount())
 
     @pytest.mark.parametrize(
         "datetimelike",
         [
-            [
-                Timestamp("2016-05-{i:02d} 20:09:25+00:00".format(i=i))
-                for i in range(1, 4)
-            ],
-            [Timestamp("2016-05-{i:02d} 20:09:25".format(i=i)) for i in range(1, 4)],
+            [Timestamp(f"2016-05-{i:02d} 20:09:25+00:00") for i in range(1, 4)],
+            [Timestamp(f"2016-05-{i:02d} 20:09:25") for i in range(1, 4)],
             [Timedelta(x, unit="h") for x in range(1, 4)],
             [Period(freq="2W", year=2017, month=x) for x in range(1, 4)],
         ],
@@ -214,7 +211,7 @@ def test_count_with_datetimelike(self, datetimelike):
         res = df.groupby("x").count()
         expected = DataFrame({"y": [2, 1]}, index=["a", "b"])
         expected.index.name = "x"
-        assert_frame_equal(expected, res)
+        tm.assert_frame_equal(expected, res)
 
     def test_count_with_only_nans_in_first_group(self):
         # GH21956
@@ -222,4 +219,4 @@ def test_count_with_only_nans_in_first_group(self):
         result = df.groupby(["A", "B"]).C.count()
         mi = MultiIndex(levels=[[], ["a", "b"]], codes=[[], []], names=["A", "B"])
         expected = Series([], index=mi, dtype=np.int64, name="C")
-        assert_series_equal(result, expected, check_index_type=False)
+        tm.assert_series_equal(result, expected, check_index_type=False)
diff --git a/pandas/tests/groupby/test_filters.py b/pandas/tests/groupby/test_filters.py
index 2ce04fc774083..c16ad812eb634 100644
--- a/pandas/tests/groupby/test_filters.py
+++ b/pandas/tests/groupby/test_filters.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_filter_series():
@@ -593,5 +593,5 @@ def test_filter_dropna_with_empty_groups():
     tm.assert_series_equal(result_false, expected_false)
 
     result_true = groupped.filter(lambda x: x.mean() > 1, dropna=True)
-    expected_true = pd.Series(index=pd.Index([], dtype=int))
+    expected_true = pd.Series(index=pd.Index([], dtype=int), dtype=np.float64)
     tm.assert_series_equal(result_true, expected_true)
diff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py
index afb22a732691c..73e36cb5e6c84 100644
--- a/pandas/tests/groupby/test_function.py
+++ b/pandas/tests/groupby/test_function.py
@@ -20,8 +20,9 @@
     date_range,
     isna,
 )
+import pandas._testing as tm
 import pandas.core.nanops as nanops
-from pandas.util import _test_decorators as td, testing as tm
+from pandas.util import _test_decorators as td
 
 
 @pytest.mark.parametrize("agg_func", ["any", "all"])
@@ -102,9 +103,7 @@ def test_builtins_apply(keys, f):
     result = df.groupby(keys).apply(f)
     ngroups = len(df.drop_duplicates(subset=keys))
 
-    assert_msg = "invalid frame shape: {} (expected ({}, 3))".format(
-        result.shape, ngroups
-    )
+    assert_msg = f"invalid frame shape: {result.shape} (expected ({ngroups}, 3))"
     assert result.shape == (ngroups, 3), assert_msg
 
     tm.assert_frame_equal(
@@ -378,7 +377,7 @@ def test_median_empty_bins(observed):
 
 
 @pytest.mark.parametrize(
-    "dtype", ["int8", "int16", "int32", "int64", "float32", "float64"]
+    "dtype", ["int8", "int16", "int32", "int64", "float32", "float64", "uint64"]
 )
 @pytest.mark.parametrize(
     "method,data",
@@ -607,6 +606,51 @@ def test_nlargest():
     tm.assert_series_equal(gb.nlargest(3, keep="last"), e)
 
 
+def test_nlargest_mi_grouper():
+    # see gh-21411
+    npr = np.random.RandomState(123456789)
+
+    dts = date_range("20180101", periods=10)
+    iterables = [dts, ["one", "two"]]
+
+    idx = MultiIndex.from_product(iterables, names=["first", "second"])
+    s = Series(npr.randn(20), index=idx)
+
+    result = s.groupby("first").nlargest(1)
+
+    exp_idx = MultiIndex.from_tuples(
+        [
+            (dts[0], dts[0], "one"),
+            (dts[1], dts[1], "one"),
+            (dts[2], dts[2], "one"),
+            (dts[3], dts[3], "two"),
+            (dts[4], dts[4], "one"),
+            (dts[5], dts[5], "one"),
+            (dts[6], dts[6], "one"),
+            (dts[7], dts[7], "one"),
+            (dts[8], dts[8], "two"),
+            (dts[9], dts[9], "one"),
+        ],
+        names=["first", "first", "second"],
+    )
+
+    exp_values = [
+        2.2129019979039612,
+        1.8417114045748335,
+        0.858963679564603,
+        1.3759151378258088,
+        0.9430284594687134,
+        0.5296914208183142,
+        0.8318045593815487,
+        -0.8476703342910327,
+        0.3804446884133735,
+        -0.8028845810770998,
+    ]
+
+    expected = Series(exp_values, index=exp_idx)
+    tm.assert_series_equal(result, expected, check_exact=False, check_less_precise=True)
+
+
 def test_nsmallest():
     a = Series([1, 3, 5, 7, 2, 9, 0, 4, 6, 10])
     b = Series(list("a" * 5 + "b" * 5))
@@ -627,7 +671,7 @@ def test_nsmallest():
     tm.assert_series_equal(gb.nsmallest(3, keep="last"), e)
 
 
-@pytest.mark.parametrize("func", ["mean", "var", "std", "cumprod", "cumsum"])
+@pytest.mark.parametrize("func", ["cumprod", "cumsum"])
 def test_numpy_compat(func):
     # see gh-12811
     df = pd.DataFrame({"A": [1, 2, 1], "B": [1, 2, 3]})
@@ -1002,7 +1046,7 @@ def test_nunique_with_object():
 
 def test_nunique_with_empty_series():
     # GH 12553
-    data = pd.Series(name="name")
+    data = pd.Series(name="name", dtype=object)
     result = data.groupby(level=0).nunique()
     expected = pd.Series(name="name", dtype="int64")
     tm.assert_series_equal(result, expected)
@@ -1255,8 +1299,8 @@ def test_size_groupby_all_null():
         ([np.nan, 4.0, np.nan, 2.0, np.nan], [np.nan, 4.0, np.nan, 2.0, np.nan]),
         # Timestamps
         (
-            [x for x in pd.date_range("1/1/18", freq="D", periods=5)],
-            [x for x in pd.date_range("1/1/18", freq="D", periods=5)][::-1],
+            list(pd.date_range("1/1/18", freq="D", periods=5)),
+            list(pd.date_range("1/1/18", freq="D", periods=5))[::-1],
         ),
         # All NA
         ([np.nan] * 5, [np.nan] * 5),
@@ -1353,6 +1397,35 @@ def test_quantile_array_multiple_levels():
     tm.assert_frame_equal(result, expected)
 
 
+@pytest.mark.parametrize("frame_size", [(2, 3), (100, 10)])
+@pytest.mark.parametrize("groupby", [[0], [0, 1]])
+@pytest.mark.parametrize("q", [[0.5, 0.6]])
+def test_groupby_quantile_with_arraylike_q_and_int_columns(frame_size, groupby, q):
+    # GH30289
+    nrow, ncol = frame_size
+    df = pd.DataFrame(
+        np.array([ncol * [_ % 4] for _ in range(nrow)]), columns=range(ncol)
+    )
+
+    idx_levels = [list(range(min(nrow, 4)))] * len(groupby) + [q]
+    idx_codes = [[x for x in range(min(nrow, 4)) for _ in q]] * len(groupby) + [
+        list(range(len(q))) * min(nrow, 4)
+    ]
+    expected_index = pd.MultiIndex(
+        levels=idx_levels, codes=idx_codes, names=groupby + [None]
+    )
+    expected_values = [
+        [float(x)] * (ncol - len(groupby)) for x in range(min(nrow, 4)) for _ in q
+    ]
+    expected_columns = [x for x in range(ncol) if x not in groupby]
+    expected = pd.DataFrame(
+        expected_values, index=expected_index, columns=expected_columns
+    )
+    result = df.groupby(groupby).quantile(q)
+
+    tm.assert_frame_equal(result, expected)
+
+
 def test_quantile_raises():
     df = pd.DataFrame(
         [["foo", "a"], ["foo", "b"], ["foo", "c"]], columns=["key", "val"]
@@ -1373,6 +1446,29 @@ def test_quantile_out_of_bounds_q_raises():
         g.quantile(-1)
 
 
+def test_quantile_missing_group_values_no_segfaults():
+    # GH 28662
+    data = np.array([1.0, np.nan, 1.0])
+    df = pd.DataFrame(dict(key=data, val=range(3)))
+
+    # Random segfaults; would have been guaranteed in loop
+    grp = df.groupby("key")
+    for _ in range(100):
+        grp.quantile()
+
+
+def test_quantile_missing_group_values_correct_results():
+    # GH 28662
+    data = np.array([1.0, np.nan, 3.0, np.nan])
+    df = pd.DataFrame(dict(key=data, val=range(4)))
+
+    result = df.groupby("key").quantile()
+    expected = pd.DataFrame(
+        [1.0, 3.0], index=pd.Index([1.0, 3.0], name="key"), columns=["val"]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
 # pipe
 # --------------------------------
 
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index bec5cbc5fecb8..5662d41e19885 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -1,4 +1,3 @@
-from collections import OrderedDict
 from datetime import datetime
 from decimal import Decimal
 from io import StringIO
@@ -10,13 +9,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, date_range, read_csv
+import pandas._testing as tm
+from pandas.core.base import SpecificationError
 import pandas.core.common as com
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
 
 
 def test_repr():
@@ -43,23 +38,26 @@ def test_basic(dtype):
     agged = grouped.aggregate(np.mean)
     assert agged[1] == 1
 
-    assert_series_equal(agged, grouped.agg(np.mean))  # shorthand
-    assert_series_equal(agged, grouped.mean())
-    assert_series_equal(grouped.agg(np.sum), grouped.sum())
+    tm.assert_series_equal(agged, grouped.agg(np.mean))  # shorthand
+    tm.assert_series_equal(agged, grouped.mean())
+    tm.assert_series_equal(grouped.agg(np.sum), grouped.sum())
 
     expected = grouped.apply(lambda x: x * x.sum())
     transformed = grouped.transform(lambda x: x * x.sum())
     assert transformed[7] == 12
-    assert_series_equal(transformed, expected)
+    tm.assert_series_equal(transformed, expected)
 
     value_grouped = data.groupby(data)
-    assert_series_equal(value_grouped.aggregate(np.mean), agged, check_index_type=False)
+    tm.assert_series_equal(
+        value_grouped.aggregate(np.mean), agged, check_index_type=False
+    )
 
     # complex agg
     agged = grouped.aggregate([np.mean, np.std])
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        agged = grouped.aggregate({"one": np.mean, "two": np.std})
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        grouped.aggregate({"one": np.mean, "two": np.std})
 
     group_constants = {0: 10, 1: 20, 2: 30}
     agged = grouped.agg(lambda x: group_constants[x.name] + x.mean())
@@ -78,7 +76,7 @@ def test_groupby_nonobject_dtype(mframe, df_mixed_floats):
     result = grouped.sum()
 
     expected = mframe.groupby(key.astype("O")).sum()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # GH 3911, mixed frame non-conversion
     df = df_mixed_floats.copy()
@@ -93,7 +91,7 @@ def max_value(group):
         [np.dtype("object")] * 2 + [np.dtype("float64")] * 2 + [np.dtype("int64")],
         index=["A", "B", "C", "D", "value"],
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_return_type():
@@ -151,7 +149,7 @@ def f(grp):
 
     expected = df.groupby("A").first()[["B"]]
     result = df.groupby("A").apply(f)[["B"]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     def f(grp):
         if grp.name == "Tiger":
@@ -161,7 +159,7 @@ def f(grp):
     result = df.groupby("A").apply(f)[["B"]]
     e = expected.copy()
     e.loc["Tiger"] = np.nan
-    assert_frame_equal(result, e)
+    tm.assert_frame_equal(result, e)
 
     def f(grp):
         if grp.name == "Pony":
@@ -171,7 +169,7 @@ def f(grp):
     result = df.groupby("A").apply(f)[["B"]]
     e = expected.copy()
     e.loc["Pony"] = np.nan
-    assert_frame_equal(result, e)
+    tm.assert_frame_equal(result, e)
 
     # 5592 revisited, with datetimes
     def f(grp):
@@ -182,7 +180,7 @@ def f(grp):
     result = df.groupby("A").apply(f)[["C"]]
     e = df.groupby("A").first()[["C"]]
     e.loc["Pony"] = pd.NaT
-    assert_frame_equal(result, e)
+    tm.assert_frame_equal(result, e)
 
     # scalar outputs
     def f(grp):
@@ -194,7 +192,7 @@ def f(grp):
     e = df.groupby("A").first()["C"].copy()
     e.loc["Pony"] = np.nan
     e.name = None
-    assert_series_equal(result, e)
+    tm.assert_series_equal(result, e)
 
 
 def test_pass_args_kwargs(ts, tsframe):
@@ -212,29 +210,29 @@ def f(x, q=None, axis=0):
     agg_expected = ts_grouped.quantile(0.8)
     trans_expected = ts_grouped.transform(g)
 
-    assert_series_equal(apply_result, agg_expected)
-    assert_series_equal(agg_result, agg_expected)
-    assert_series_equal(trans_result, trans_expected)
+    tm.assert_series_equal(apply_result, agg_expected)
+    tm.assert_series_equal(agg_result, agg_expected)
+    tm.assert_series_equal(trans_result, trans_expected)
 
     agg_result = ts_grouped.agg(f, q=80)
     apply_result = ts_grouped.apply(f, q=80)
     trans_result = ts_grouped.transform(f, q=80)
-    assert_series_equal(agg_result, agg_expected)
-    assert_series_equal(apply_result, agg_expected)
-    assert_series_equal(trans_result, trans_expected)
+    tm.assert_series_equal(agg_result, agg_expected)
+    tm.assert_series_equal(apply_result, agg_expected)
+    tm.assert_series_equal(trans_result, trans_expected)
 
     # DataFrame
     df_grouped = tsframe.groupby(lambda x: x.month)
     agg_result = df_grouped.agg(np.percentile, 80, axis=0)
     apply_result = df_grouped.apply(DataFrame.quantile, 0.8)
     expected = df_grouped.quantile(0.8)
-    assert_frame_equal(apply_result, expected, check_names=False)
-    assert_frame_equal(agg_result, expected)
+    tm.assert_frame_equal(apply_result, expected, check_names=False)
+    tm.assert_frame_equal(agg_result, expected)
 
     agg_result = df_grouped.agg(f, q=80)
     apply_result = df_grouped.apply(DataFrame.quantile, q=0.8)
-    assert_frame_equal(agg_result, expected)
-    assert_frame_equal(apply_result, expected, check_names=False)
+    tm.assert_frame_equal(agg_result, expected)
+    tm.assert_frame_equal(apply_result, expected, check_names=False)
 
 
 def test_len():
@@ -280,7 +278,7 @@ def test_with_na_groups(dtype):
     agged = grouped.agg(len)
     expected = Series([4, 2], index=["bar", "foo"])
 
-    assert_series_equal(agged, expected, check_dtype=False)
+    tm.assert_series_equal(agged, expected, check_dtype=False)
 
     # assert issubclass(agged.dtype.type, np.integer)
 
@@ -291,7 +289,7 @@ def f(x):
     agged = grouped.agg(f)
     expected = Series([4, 2], index=["bar", "foo"])
 
-    assert_series_equal(agged, expected, check_dtype=False)
+    tm.assert_series_equal(agged, expected, check_dtype=False)
     assert issubclass(agged.dtype.type, np.dtype(dtype).type)
 
 
@@ -335,7 +333,7 @@ def f3(x):
     # correct result
     result1 = df.groupby("a").apply(f1)
     result2 = df2.groupby("a").apply(f1)
-    assert_frame_equal(result1, result2)
+    tm.assert_frame_equal(result1, result2)
 
     # should fail (not the same number of levels)
     msg = "Cannot concat indices that do not have the same number of levels"
@@ -356,13 +354,13 @@ def test_attr_wrapper(ts):
 
     result = grouped.std()
     expected = grouped.agg(lambda x: np.std(x, ddof=1))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # this is pretty cool
     result = grouped.describe()
     expected = {name: gp.describe() for name, gp in grouped}
     expected = DataFrame(expected).T
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # get attribute
     result = grouped.dtype
@@ -386,7 +384,7 @@ def test_frame_groupby(tsframe):
     tscopy = tsframe.copy()
     tscopy["weekday"] = [x.weekday() for x in tscopy.index]
     stragged = tscopy.groupby("weekday").aggregate(np.mean)
-    assert_frame_equal(stragged, aggregated, check_names=False)
+    tm.assert_frame_equal(stragged, aggregated, check_names=False)
 
     # transform
     grouped = tsframe.head(30).groupby(lambda x: x.weekday())
@@ -426,7 +424,7 @@ def test_frame_groupby_columns(tsframe):
     # transform
     tf = lambda x: x - x.mean()
     groupedT = tsframe.T.groupby(mapping, axis=0)
-    assert_frame_equal(groupedT.transform(tf).T, grouped.transform(tf))
+    tm.assert_frame_equal(groupedT.transform(tf).T, grouped.transform(tf))
 
     # iterate
     for k, v in grouped:
@@ -455,9 +453,9 @@ def test_frame_set_name_single(df):
     result = grouped["C"].agg([np.mean, np.std])
     assert result.index.name == "A"
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = grouped["C"].agg({"foo": np.mean, "bar": np.std})
-    assert result.index.name == "A"
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        grouped["C"].agg({"foo": np.mean, "bar": np.std})
 
 
 def test_multi_func(df):
@@ -469,7 +467,7 @@ def test_multi_func(df):
     expected = df.groupby(["A", "B"]).mean()
 
     # TODO groupby get drops names
-    assert_frame_equal(
+    tm.assert_frame_equal(
         agged.loc[:, ["C", "D"]], expected.loc[:, ["C", "D"]], check_names=False
     )
 
@@ -493,7 +491,7 @@ def test_multi_key_multiple_functions(df):
 
     agged = grouped.agg([np.mean, np.std])
     expected = DataFrame({"mean": grouped.agg(np.mean), "std": grouped.agg(np.std)})
-    assert_frame_equal(agged, expected)
+    tm.assert_frame_equal(agged, expected)
 
 
 def test_frame_multi_key_function_list():
@@ -554,7 +552,7 @@ def test_frame_multi_key_function_list():
     )
     assert isinstance(agged.index, MultiIndex)
     assert isinstance(expected.index, MultiIndex)
-    assert_frame_equal(agged, expected)
+    tm.assert_frame_equal(agged, expected)
 
 
 @pytest.mark.parametrize("op", [lambda x: x.sum(), lambda x: x.mean()])
@@ -580,14 +578,28 @@ def test_groupby_multiple_columns(df, op):
         result_col = op(grouped[col])
         pivoted = result1[col]
         exp = expected[col]
-        assert_series_equal(result_col, exp)
-        assert_series_equal(pivoted, exp)
+        tm.assert_series_equal(result_col, exp)
+        tm.assert_series_equal(pivoted, exp)
 
     # test single series works the same
     result = data["C"].groupby([data["A"], data["B"]]).mean()
     expected = data.groupby(["A", "B"]).mean()["C"]
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
+
+
+def test_as_index_select_column():
+    # GH 5764
+    df = pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=["A", "B"])
+    result = df.groupby("A", as_index=False)["B"].get_group(1)
+    expected = pd.Series([2, 4], name="B")
+    tm.assert_series_equal(result, expected)
+
+    result = df.groupby("A", as_index=False)["B"].apply(lambda x: x.cumsum())
+    expected = pd.Series(
+        [2, 6, 6], name="B", index=pd.MultiIndex.from_tuples([(0, 0), (0, 1), (1, 2)])
+    )
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_as_index_agg(df):
@@ -597,20 +609,18 @@ def test_groupby_as_index_agg(df):
 
     result = grouped.agg(np.mean)
     expected = grouped.mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
-    result2 = grouped.agg(OrderedDict([["C", np.mean], ["D", np.sum]]))
+    result2 = grouped.agg({"C": np.mean, "D": np.sum})
     expected2 = grouped.mean()
     expected2["D"] = grouped.sum()["D"]
-    assert_frame_equal(result2, expected2)
+    tm.assert_frame_equal(result2, expected2)
 
     grouped = df.groupby("A", as_index=True)
-    expected3 = grouped["C"].sum()
-    expected3 = DataFrame(expected3).rename(columns={"C": "Q"})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result3 = grouped["C"].agg({"Q": np.sum})
-    assert_frame_equal(result3, expected3)
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        grouped["C"].agg({"Q": np.sum})
 
     # multi-key
 
@@ -618,17 +628,17 @@ def test_groupby_as_index_agg(df):
 
     result = grouped.agg(np.mean)
     expected = grouped.mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
-    result2 = grouped.agg(OrderedDict([["C", np.mean], ["D", np.sum]]))
+    result2 = grouped.agg({"C": np.mean, "D": np.sum})
     expected2 = grouped.mean()
     expected2["D"] = grouped.sum()["D"]
-    assert_frame_equal(result2, expected2)
+    tm.assert_frame_equal(result2, expected2)
 
     expected3 = grouped["C"].sum()
     expected3 = DataFrame(expected3).rename(columns={"C": "Q"})
     result3 = grouped["C"].agg({"Q": np.sum})
-    assert_frame_equal(result3, expected3)
+    tm.assert_frame_equal(result3, expected3)
 
     # GH7115 & GH8112 & GH8582
     df = DataFrame(np.random.randint(0, 100, (50, 3)), columns=["jim", "joe", "jolie"])
@@ -636,7 +646,7 @@ def test_groupby_as_index_agg(df):
 
     gr = df.groupby(ts)
     gr.nth(0)  # invokes set_selection_from_grouper internally
-    assert_frame_equal(gr.apply(sum), df.groupby(ts).apply(sum))
+    tm.assert_frame_equal(gr.apply(sum), df.groupby(ts).apply(sum))
 
     for attr in ["mean", "max", "count", "idxmax", "cumsum", "all"]:
         gr = df.groupby(ts, as_index=False)
@@ -645,7 +655,7 @@ def test_groupby_as_index_agg(df):
         gr = df.groupby(ts.values, as_index=True)
         right = getattr(gr, attr)().reset_index(drop=True)
 
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
 
 def test_as_index_series_return_frame(df):
@@ -655,22 +665,22 @@ def test_as_index_series_return_frame(df):
     result = grouped["C"].agg(np.sum)
     expected = grouped.agg(np.sum).loc[:, ["A", "C"]]
     assert isinstance(result, DataFrame)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result2 = grouped2["C"].agg(np.sum)
     expected2 = grouped2.agg(np.sum).loc[:, ["A", "B", "C"]]
     assert isinstance(result2, DataFrame)
-    assert_frame_equal(result2, expected2)
+    tm.assert_frame_equal(result2, expected2)
 
     result = grouped["C"].sum()
     expected = grouped.sum().loc[:, ["A", "C"]]
     assert isinstance(result, DataFrame)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result2 = grouped2["C"].sum()
     expected2 = grouped2.sum().loc[:, ["A", "B", "C"]]
     assert isinstance(result2, DataFrame)
-    assert_frame_equal(result2, expected2)
+    tm.assert_frame_equal(result2, expected2)
 
 
 def test_as_index_series_column_slice_raises(df):
@@ -691,7 +701,7 @@ def test_groupby_as_index_cython(df):
     expected = data.groupby(["A"]).mean()
     expected.insert(0, "A", expected.index)
     expected.index = np.arange(len(expected))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # multi-key
     grouped = data.groupby(["A", "B"], as_index=False)
@@ -702,7 +712,7 @@ def test_groupby_as_index_cython(df):
     expected.insert(0, "A", arrays[0])
     expected.insert(1, "B", arrays[1])
     expected.index = np.arange(len(expected))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_as_index_series_scalar(df):
@@ -712,7 +722,7 @@ def test_groupby_as_index_series_scalar(df):
 
     result = grouped["C"].agg(len)
     expected = grouped.agg(len).loc[:, ["A", "B", "C"]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_as_index_corner(df, ts):
@@ -729,7 +739,7 @@ def test_groupby_multiple_key(df):
     df = tm.makeTimeDataFrame()
     grouped = df.groupby([lambda x: x.year, lambda x: x.month, lambda x: x.day])
     agged = grouped.sum()
-    assert_almost_equal(df.values, agged.values)
+    tm.assert_almost_equal(df.values, agged.values)
 
     grouped = df.T.groupby(
         [lambda x: x.year, lambda x: x.month, lambda x: x.day], axis=1
@@ -737,10 +747,10 @@ def test_groupby_multiple_key(df):
 
     agged = grouped.agg(lambda x: x.sum())
     tm.assert_index_equal(agged.index, df.columns)
-    assert_almost_equal(df.T.values, agged.values)
+    tm.assert_almost_equal(df.T.values, agged.values)
 
     agged = grouped.agg(lambda x: x.sum())
-    assert_almost_equal(df.T.values, agged.values)
+    tm.assert_almost_equal(df.T.values, agged.values)
 
 
 def test_groupby_multi_corner(df):
@@ -752,7 +762,7 @@ def test_groupby_multi_corner(df):
     expected = df.groupby(["A", "B"]).mean()
     expected["bad"] = np.nan
 
-    assert_frame_equal(agged, expected)
+    tm.assert_frame_equal(agged, expected)
 
 
 def test_omit_nuisance(df):
@@ -760,26 +770,22 @@ def test_omit_nuisance(df):
 
     result = grouped.mean()
     expected = df.loc[:, ["A", "C", "D"]].groupby("A").mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     agged = grouped.agg(np.mean)
     exp = grouped.mean()
-    assert_frame_equal(agged, exp)
+    tm.assert_frame_equal(agged, exp)
 
     df = df.loc[:, ["A", "C", "D"]]
     df["E"] = datetime.now()
     grouped = df.groupby("A")
     result = grouped.agg(np.sum)
     expected = grouped.sum()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # won't work with axis = 1
     grouped = df.groupby({"A": 0, "C": 0, "D": 1, "E": 1}, axis=1)
-    msg = (
-        r'\("unsupported operand type\(s\) for \+: '
-        "'Timestamp' and 'float'\""
-        r", 'occurred at index 0'\)"
-    )
+    msg = "reduction operation 'sum' not allowed for this dtype"
     with pytest.raises(TypeError, match=msg):
         grouped.agg(lambda x: x.sum(0, numeric_only=False))
 
@@ -789,7 +795,7 @@ def test_omit_nuisance_python_multiple(three_group):
 
     agged = grouped.agg(np.mean)
     exp = grouped.mean()
-    assert_frame_equal(agged, exp)
+    tm.assert_frame_equal(agged, exp)
 
 
 def test_empty_groups_corner(mframe):
@@ -807,12 +813,12 @@ def test_empty_groups_corner(mframe):
     grouped = df.groupby(["k1", "k2"])
     result = grouped.agg(np.mean)
     expected = grouped.mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     grouped = mframe[3:5].groupby(level=0)
     agged = grouped.apply(lambda x: x.mean())
     agged_A = grouped["A"].apply(np.mean)
-    assert_series_equal(agged["A"], agged_A)
+    tm.assert_series_equal(agged["A"], agged_A)
     assert agged.index.name == "first"
 
 
@@ -867,8 +873,8 @@ def test_groupby_level_mapper(mframe):
     expected1 = mframe.groupby(mapped_level1).sum()
     expected0.index.name, expected1.index.name = "first", "second"
 
-    assert_frame_equal(result0, expected0)
-    assert_frame_equal(result1, expected1)
+    tm.assert_frame_equal(result0, expected0)
+    tm.assert_frame_equal(result1, expected1)
 
 
 def test_groupby_level_nonmulti():
@@ -909,10 +915,10 @@ def test_groupby_complex():
     expected = Series((1 + 2j, 5 + 10j))
 
     result = a.groupby(level=0).sum()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = a.sum(level=0)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_mutate_groups():
@@ -929,7 +935,7 @@ def test_mutate_groups():
             + ["c"] * 2
             + ["d"] * 2
             + ["e"] * 2,
-            "cat3": ["g{}".format(x) for x in range(1, 15)],
+            "cat3": [f"g{x}" for x in range(1, 15)],
             "val": np.random.randint(100, size=14),
         }
     )
@@ -945,7 +951,7 @@ def f_no_copy(x):
 
     grpby_copy = df.groupby("cat1").apply(f_copy)
     grpby_no_copy = df.groupby("cat1").apply(f_no_copy)
-    assert_series_equal(grpby_copy, grpby_no_copy)
+    tm.assert_series_equal(grpby_copy, grpby_no_copy)
 
 
 def test_no_mutate_but_looks_like():
@@ -957,7 +963,7 @@ def test_no_mutate_but_looks_like():
 
     result1 = df.groupby("key", group_keys=True).apply(lambda x: x[:].key)
     result2 = df.groupby("key", group_keys=True).apply(lambda x: x.key)
-    assert_series_equal(result1, result2)
+    tm.assert_series_equal(result1, result2)
 
 
 def test_groupby_series_indexed_differently():
@@ -972,7 +978,7 @@ def test_groupby_series_indexed_differently():
     grouped = s1.groupby(s2)
     agged = grouped.mean()
     exp = s1.groupby(s2.reindex(s1.index).get).mean()
-    assert_series_equal(agged, exp)
+    tm.assert_series_equal(agged, exp)
 
 
 def test_groupby_with_hier_columns():
@@ -1018,7 +1024,7 @@ def test_grouping_ndarray(df):
 
     result = grouped.sum()
     expected = df.groupby("A").sum()
-    assert_frame_equal(
+    tm.assert_frame_equal(
         result, expected, check_names=False
     )  # Note: no names when grouping by value
 
@@ -1037,7 +1043,7 @@ def test_groupby_wrong_multi_labels():
 
     result = grouped.agg(np.mean)
     expected = grouped.mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_series_with_name(df):
@@ -1077,7 +1083,7 @@ def test_consistency_name():
 
     expected = df.groupby(["A"]).B.count()
     result = df.B.groupby(df.A).count()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_name_propagation(df):
@@ -1104,7 +1110,7 @@ def test_groupby_nonstring_columns():
     grouped = df.groupby(0)
     result = grouped.mean()
     expected = df.groupby(df[0]).mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_mixed_type_columns():
@@ -1177,13 +1183,13 @@ def test_groupby_dtype_inference_empty():
     result = df.groupby("x").first()
     exp_index = Index([], name="x", dtype=np.float64)
     expected = DataFrame({"range": Series([], index=exp_index, dtype="int64")})
-    assert_frame_equal(result, expected, by_blocks=True)
+    tm.assert_frame_equal(result, expected, by_blocks=True)
 
 
 def test_groupby_list_infer_array_like(df):
     result = df.groupby(list(df["A"])).mean()
     expected = df.groupby(df["A"]).mean()
-    assert_frame_equal(result, expected, check_names=False)
+    tm.assert_frame_equal(result, expected, check_names=False)
 
     with pytest.raises(KeyError, match=r"^'foo'$"):
         df.groupby(list(df["A"][:-1]))
@@ -1205,7 +1211,7 @@ def test_groupby_keys_same_size_as_index():
     result = df.groupby([pd.Grouper(level=0, freq=freq), "metric"]).mean()
     expected = df.set_index([df.index, "metric"])
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_one_row():
@@ -1351,7 +1357,7 @@ def test_dont_clobber_name_column():
     )
 
     result = df.groupby("key").apply(lambda x: x)
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
 
 
 def test_skip_group_keys():
@@ -1364,7 +1370,7 @@ def test_skip_group_keys():
     pieces = [group.sort_values(by="A")[:3] for key, group in grouped]
 
     expected = pd.concat(pieces)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     grouped = tsf["A"].groupby(lambda x: x.month, group_keys=False)
     result = grouped.apply(lambda x: x.sort_values()[:3])
@@ -1372,7 +1378,7 @@ def test_skip_group_keys():
     pieces = [group.sort_values()[:3] for key, group in grouped]
 
     expected = pd.concat(pieces)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_no_nonsense_name(float_frame):
@@ -1406,7 +1412,7 @@ def g(group):
     expected = df.groupby("A")["C"].apply(g)
 
     assert isinstance(result, Series)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("grouper", ["A", ["A", "B"]])
@@ -1477,9 +1483,9 @@ def test_groupby_sort_multiindex_series():
     mseries_result = Series([0, 2, 4], index=index)
 
     result = mseries.groupby(level=["a", "b"], sort=False).first()
-    assert_series_equal(result, mseries_result)
+    tm.assert_series_equal(result, mseries_result)
     result = mseries.groupby(level=["a", "b"], sort=True).first()
-    assert_series_equal(result, mseries_result.sort_index())
+    tm.assert_series_equal(result, mseries_result.sort_index())
 
 
 def test_groupby_reindex_inside_function():
@@ -1490,7 +1496,7 @@ def test_groupby_reindex_inside_function():
 
     def agg_before(hour, func, fix=False):
         """
-            Run an aggregate func on the subset of data.
+        Run an aggregate func on the subset of data.
         """
 
         def _func(data):
@@ -1511,7 +1517,7 @@ def afunc(data):
     closure_bad = grouped.agg({"high": agg_before(11, np.max)})
     closure_good = grouped.agg({"high": agg_before(11, np.max, True)})
 
-    assert_frame_equal(closure_bad, closure_good)
+    tm.assert_frame_equal(closure_bad, closure_good)
 
 
 def test_groupby_multiindex_missing_pair():
@@ -1592,26 +1598,26 @@ def test_index_label_overlaps_location():
     g = df.groupby(list("ababb"))
     actual = g.filter(lambda x: len(x) > 2)
     expected = df.iloc[[1, 3, 4]]
-    assert_frame_equal(actual, expected)
+    tm.assert_frame_equal(actual, expected)
 
     ser = df[0]
     g = ser.groupby(list("ababb"))
     actual = g.filter(lambda x: len(x) > 2)
     expected = ser.take([1, 3, 4])
-    assert_series_equal(actual, expected)
+    tm.assert_series_equal(actual, expected)
 
     # ... and again, with a generic Index of floats
     df.index = df.index.astype(float)
     g = df.groupby(list("ababb"))
     actual = g.filter(lambda x: len(x) > 2)
     expected = df.iloc[[1, 3, 4]]
-    assert_frame_equal(actual, expected)
+    tm.assert_frame_equal(actual, expected)
 
     ser = df[0]
     g = ser.groupby(list("ababb"))
     actual = g.filter(lambda x: len(x) > 2)
     expected = ser.take([1, 3, 4])
-    assert_series_equal(actual, expected)
+    tm.assert_series_equal(actual, expected)
 
 
 def test_transform_doesnt_clobber_ints():
@@ -1656,7 +1662,7 @@ def test_groupby_preserves_sort(sort_column, group_column):
     g = df.groupby(group_column)
 
     def test_sort(x):
-        assert_frame_equal(x, x.sort_values(by=sort_column))
+        tm.assert_frame_equal(x, x.sort_values(by=sort_column))
 
     g.apply(test_sort)
 
@@ -1685,7 +1691,7 @@ def test_group_shift_with_null_key():
     )
     result = g.shift(-1)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_group_shift_with_fill_value():
@@ -1707,16 +1713,23 @@ def test_group_shift_with_fill_value():
     )
     result = g.shift(-1, fill_value=0)[["Z"]]
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_group_shift_lose_timezone():
+    # GH 30134
+    now_dt = pd.Timestamp.utcnow()
+    df = DataFrame({"a": [1, 1], "date": now_dt})
+    result = df.groupby("a").shift(0).iloc[0]
+    expected = Series({"date": now_dt}, name=result.name)
+    tm.assert_series_equal(result, expected)
 
 
 def test_pivot_table_values_key_error():
     # This test is designed to replicate the error in issue #14938
     df = pd.DataFrame(
         {
-            "eventDate": pd.date_range(
-                pd.datetime.today(), periods=20, freq="M"
-            ).tolist(),
+            "eventDate": pd.date_range(datetime.today(), periods=20, freq="M").tolist(),
             "thename": range(0, 20),
         }
     )
@@ -1738,37 +1751,26 @@ def test_empty_dataframe_groupby():
     expected = DataFrame(columns=["B", "C"], dtype=np.float64)
     expected.index.name = "A"
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
-def test_tuple_warns():
+def test_tuple_as_grouping():
     # https://github.com/pandas-dev/pandas/issues/18314
     df = pd.DataFrame(
         {
-            ("a", "b"): [1, 1, 2, 2],
-            "a": [1, 1, 1, 2],
-            "b": [1, 2, 2, 2],
+            ("a", "b"): [1, 1, 1, 1],
+            "a": [2, 2, 2, 2],
+            "b": [2, 2, 2, 2],
             "c": [1, 1, 1, 1],
         }
     )
-    with tm.assert_produces_warning(FutureWarning) as w:
-        df[["a", "b", "c"]].groupby(("a", "b")).c.mean()
-
-    assert "Interpreting tuple 'by' as a list" in str(w[0].message)
 
-    with tm.assert_produces_warning(None):
-        df.groupby(("a", "b")).c.mean()
+    with pytest.raises(KeyError):
+        df[["a", "b", "c"]].groupby(("a", "b"))
 
-
-def test_tuple_warns_unhashable():
-    # https://github.com/pandas-dev/pandas/issues/18314
-    business_dates = date_range(start="4/1/2014", end="6/30/2014", freq="B")
-    df = DataFrame(1, index=business_dates, columns=["a", "b"])
-
-    with tm.assert_produces_warning(FutureWarning) as w:
-        df.groupby((df.index.year, df.index.month)).nth([0, 3, -1])
-
-    assert "Interpreting tuple 'by' as a list" in str(w[0].message)
+    result = df.groupby(("a", "b"))["c"].sum()
+    expected = pd.Series([4], name="c", index=pd.Index([1], name=("a", "b")))
+    tm.assert_series_equal(result, expected)
 
 
 def test_tuple_correct_keyerror():
@@ -1820,7 +1822,7 @@ def test_groupby_multiindex_nat():
 
     result = ser.groupby(level=1).mean()
     expected = pd.Series([3.0, 2.5], index=["a", "b"])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_empty_list_raises():
@@ -1845,7 +1847,7 @@ def test_groupby_multiindex_series_keys_len_equal_group_axis():
     ei = pd.MultiIndex.from_arrays(index_array, names=index_names)
     expected = pd.Series([3], index=ei)
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_groups_in_BaseGrouper():
@@ -1873,7 +1875,7 @@ def test_groupby_axis_1(group_name):
 
     results = df.groupby(group_name, axis=1).sum()
     expected = df.T.groupby(group_name).sum().T
-    assert_frame_equal(results, expected)
+    tm.assert_frame_equal(results, expected)
 
     # test on MI column
     iterables = [["bar", "baz", "foo"], ["one", "two"]]
@@ -1881,7 +1883,7 @@ def test_groupby_axis_1(group_name):
     df = pd.DataFrame(np.arange(18).reshape(3, 6), index=[0, 1, 0], columns=mi)
     results = df.groupby(group_name, axis=1).sum()
     expected = df.T.groupby(group_name).sum().T
-    assert_frame_equal(results, expected)
+    tm.assert_frame_equal(results, expected)
 
 
 @pytest.mark.parametrize(
@@ -1947,4 +1949,111 @@ def test_shift_bfill_ffill_tz(tz_naive_fixture, op, expected):
     grouped = df.groupby("id")
     result = getattr(grouped, op)()
     expected = DataFrame(expected).assign(time=lambda x: x.time.dt.tz_localize(tz))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ffill_missing_arguments():
+    # GH 14955
+    df = pd.DataFrame({"a": [1, 2], "b": [1, 1]})
+    with pytest.raises(ValueError, match="Must specify a fill"):
+        df.groupby("b").fillna()
+
+
+def test_groupby_only_none_group():
+    # see GH21624
+    # this was crashing with "ValueError: Length of passed values is 1, index implies 0"
+    df = pd.DataFrame({"g": [None], "x": 1})
+    actual = df.groupby("g")["x"].transform("sum")
+    expected = pd.Series([np.nan], name="x")
+
+    tm.assert_series_equal(actual, expected)
+
+
+def test_groupby_duplicate_index():
+    # GH#29189 the groupby call here used to raise
+    ser = pd.Series([2, 5, 6, 8], index=[2.0, 4.0, 4.0, 5.0])
+    gb = ser.groupby(level=0)
+
+    result = gb.mean()
+    expected = pd.Series([2, 5.5, 8], index=[2.0, 4.0, 5.0])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
+def test_bool_aggs_dup_column_labels(bool_agg_func):
+    # 21668
+    df = pd.DataFrame([[True, True]], columns=["a", "a"])
+    grp_by = df.groupby([0])
+    result = getattr(grp_by, bool_agg_func)()
+
+    expected = df
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.Index(["a", "a"]), pd.MultiIndex.from_tuples((("a", "a"), ("a", "a")))]
+)
+def test_dup_labels_output_shape(groupby_func, idx):
+    if groupby_func in {"size", "ngroup", "cumcount"}:
+        pytest.skip("Not applicable")
+
+    df = pd.DataFrame([[1, 1]], columns=idx)
+    grp_by = df.groupby([0])
+
+    args = []
+    if groupby_func in {"fillna", "nth"}:
+        args.append(0)
+    elif groupby_func == "corrwith":
+        args.append(df)
+    elif groupby_func == "tshift":
+        df.index = [pd.Timestamp("today")]
+        args.extend([1, "D"])
+
+    result = getattr(grp_by, groupby_func)(*args)
+
+    assert result.shape == (1, 2)
+    tm.assert_index_equal(result.columns, idx)
+
+
+def test_groupby_crash_on_nunique(axis):
+    # Fix following 30253
+    df = pd.DataFrame({("A", "B"): [1, 2], ("A", "C"): [1, 3], ("D", "B"): [0, 0]})
+
+    axis_number = df._get_axis_number(axis)
+    if not axis_number:
+        df = df.T
+
+    result = df.groupby(axis=axis_number, level=0).nunique()
+
+    expected = pd.DataFrame({"A": [1, 2], "D": [1, 1]})
+    if not axis_number:
+        expected = expected.T
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_list_level():
+    # GH 9790
+    expected = pd.DataFrame(np.arange(0, 9).reshape(3, 3))
+    result = expected.groupby(level=[0]).mean()
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "max_seq_items, expected",
+    [
+        (5, "{0: [0], 1: [1], 2: [2], 3: [3], 4: [4]}"),
+        (4, "{0: [0], 1: [1], 2: [2], 3: [3], ...}"),
+    ],
+)
+def test_groups_repr_truncates(max_seq_items, expected):
+    # GH 1135
+    df = pd.DataFrame(np.random.randn(5, 1))
+    df["a"] = df.index
+
+    with pd.option_context("display.max_seq_items", max_seq_items):
+        result = df.groupby("a").groups.__repr__()
+        assert result == expected
+
+        result = df.groupby(np.array(df.a)).groups.__repr__()
+        assert result == expected
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index 403f5f11ee768..efcd22f9c0c82 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -13,13 +13,8 @@
     Timestamp,
     date_range,
 )
+import pandas._testing as tm
 from pandas.core.groupby.grouper import Grouping
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
 
 # selection
 # --------------------------------
@@ -57,12 +52,12 @@ def test_groupby_duplicated_column_errormsg(self):
     def test_column_select_via_attr(self, df):
         result = df.groupby("A").C.sum()
         expected = df.groupby("A")["C"].sum()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df["mean"] = 1.5
         result = df.groupby("A").mean()
         expected = df.groupby("A").agg(np.mean)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_getitem_list_of_columns(self):
         df = DataFrame(
@@ -76,14 +71,12 @@ def test_getitem_list_of_columns(self):
         )
 
         result = df.groupby("A")[["C", "D"]].mean()
-        result2 = df.groupby("A")["C", "D"].mean()
-        result3 = df.groupby("A")[df.columns[2:4]].mean()
+        result2 = df.groupby("A")[df.columns[2:4]].mean()
 
         expected = df.loc[:, ["A", "C", "D"]].groupby("A").mean()
 
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-        assert_frame_equal(result3, expected)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
 
     def test_getitem_numeric_column_names(self):
         # GH #13731
@@ -96,14 +89,40 @@ def test_getitem_numeric_column_names(self):
             }
         )
         result = df.groupby(0)[df.columns[1:3]].mean()
-        result2 = df.groupby(0)[2, 4].mean()
-        result3 = df.groupby(0)[[2, 4]].mean()
+        result2 = df.groupby(0)[[2, 4]].mean()
 
         expected = df.loc[:, [0, 2, 4]].groupby(0).mean()
 
-        assert_frame_equal(result, expected)
-        assert_frame_equal(result2, expected)
-        assert_frame_equal(result3, expected)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        # per GH 23566 this should raise a FutureWarning
+        with tm.assert_produces_warning(FutureWarning):
+            df.groupby(0)[2, 4].mean()
+
+    def test_getitem_single_list_of_columns(self, df):
+        # per GH 23566 this should raise a FutureWarning
+        with tm.assert_produces_warning(FutureWarning):
+            df.groupby("A")["C", "D"].mean()
+
+    def test_getitem_single_column(self):
+        df = DataFrame(
+            {
+                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
+                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
+                "C": np.random.randn(8),
+                "D": np.random.randn(8),
+                "E": np.random.randn(8),
+            }
+        )
+
+        result = df.groupby("A")["C"].mean()
+
+        as_frame = df.loc[:, ["A", "C"]].groupby("A").mean()
+        as_series = as_frame.iloc[:, 0]
+        expected = as_series
+
+        tm.assert_series_equal(result, expected)
 
 
 # grouping
@@ -153,13 +172,13 @@ def test_grouper_multilevel_freq(self):
         result = df.groupby(
             [pd.Grouper(level="foo", freq="W"), pd.Grouper(level="bar", freq="W")]
         ).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Check integer level
         result = df.groupby(
             [pd.Grouper(level=0, freq="W"), pd.Grouper(level=1, freq="W")]
         ).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_grouper_creation_bug(self):
 
@@ -170,14 +189,14 @@ def test_grouper_creation_bug(self):
 
         g = df.groupby(pd.Grouper(key="A"))
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = g.apply(lambda x: x.sum())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         g = df.groupby(pd.Grouper(key="A", axis=0))
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # GH14334
         # pd.Grouper(key=...) may be passed in a list
@@ -188,7 +207,7 @@ def test_grouper_creation_bug(self):
         expected = df.groupby("A").sum()
         g = df.groupby([pd.Grouper(key="A")])
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Group by two columns
         # using a combination of strings and Grouper objects
@@ -197,17 +216,17 @@ def test_grouper_creation_bug(self):
         # Group with two Grouper objects
         g = df.groupby([pd.Grouper(key="A"), pd.Grouper(key="B")])
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Group with a string and a Grouper object
         g = df.groupby(["A", pd.Grouper(key="B")])
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Group with a Grouper object and a string
         g = df.groupby([pd.Grouper(key="A"), "B"])
         result = g.sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # GH8866
         s = Series(
@@ -221,12 +240,12 @@ def test_grouper_creation_bug(self):
         expected = Series(
             [28], index=Index([Timestamp("2013-01-31")], freq="M", name="three")
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # just specifying a level breaks
         result = s.groupby(pd.Grouper(level="one")).sum()
         expected = s.groupby(level="one").sum()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_grouper_column_and_index(self):
         # GH 14327
@@ -243,24 +262,24 @@ def test_grouper_column_and_index(self):
         )
         result = df_multi.groupby(["B", pd.Grouper(level="inner")]).mean()
         expected = df_multi.reset_index().groupby(["B", "inner"]).mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Test the reverse grouping order
         result = df_multi.groupby([pd.Grouper(level="inner"), "B"]).mean()
         expected = df_multi.reset_index().groupby(["inner", "B"]).mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Grouping a single-index frame by a column and the index should
         # be equivalent to resetting the index and grouping by two columns
         df_single = df_multi.reset_index("outer")
         result = df_single.groupby(["B", pd.Grouper(level="inner")]).mean()
         expected = df_single.reset_index().groupby(["B", "inner"]).mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # Test the reverse grouping order
         result = df_single.groupby([pd.Grouper(level="inner"), "B"]).mean()
         expected = df_single.reset_index().groupby(["inner", "B"]).mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_groupby_levels_and_columns(self):
         # GH9344, GH9049
@@ -294,13 +313,13 @@ def test_groupby_categorical_index_and_columns(self, observed):
             categories, categories=categories, ordered=True
         )
         expected = DataFrame(data=expected_data, columns=expected_columns)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # test transposed version
         df = DataFrame(data.T, index=cat_columns)
         result = df.groupby(axis=0, level=0, observed=observed).sum()
         expected = DataFrame(data=expected_data.T, index=expected_columns)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_grouper_getting_correct_binner(self):
 
@@ -323,7 +342,7 @@ def test_grouper_getting_correct_binner(self):
                 names=["one", "two"],
             ),
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_grouper_iter(self, df):
         assert sorted(df.groupby("A").grouper) == ["bar", "foo"]
@@ -347,7 +366,7 @@ def test_groupby_dict_mapping(self):
         s = Series({"T1": 5})
         result = s.groupby({"T1": "T2"}).agg(sum)
         expected = s.groupby(["T2"]).agg(sum)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([1.0, 2.0, 3.0, 4.0], index=list("abcd"))
         mapping = {"a": 0, "b": 0, "c": 1, "d": 1}
@@ -356,9 +375,9 @@ def test_groupby_dict_mapping(self):
         result2 = s.groupby(mapping).agg(np.mean)
         expected = s.groupby([0, 0, 1, 1]).mean()
         expected2 = s.groupby([0, 0, 1, 1]).mean()
-        assert_series_equal(result, expected)
-        assert_series_equal(result, result2)
-        assert_series_equal(result, expected2)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, result2)
+        tm.assert_series_equal(result, expected2)
 
     def test_groupby_grouper_f_sanity_checked(self):
         dates = date_range("01-Jan-2013", periods=12, freq="MS")
@@ -369,7 +388,7 @@ def test_groupby_grouper_f_sanity_checked(self):
         # if it fails on the elements, map tries it on the entire index as
         # a sequence. That can yield invalid results that cause trouble
         # down the line.
-        # the surprise comes from using key[0:6] rather then str(key)[0:6]
+        # the surprise comes from using key[0:6] rather than str(key)[0:6]
         # when the elements are Timestamp.
         # the result is Index[0:6], very confusing.
 
@@ -390,25 +409,25 @@ def test_multiindex_passthru(self):
         df.columns = pd.MultiIndex.from_tuples([(0, 1), (1, 1), (2, 1)])
 
         result = df.groupby(axis=1, level=[0, 1]).first()
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_multiindex_negative_level(self, mframe):
         # GH 13901
         result = mframe.groupby(level=-1).sum()
         expected = mframe.groupby(level="second").sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = mframe.groupby(level=-2).sum()
         expected = mframe.groupby(level="first").sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = mframe.groupby(level=[-2, -1]).sum()
         expected = mframe
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = mframe.groupby(level=[-1, "first"]).sum()
         expected = mframe.groupby(level=["second", "first"]).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multifunc_select_col_integer_cols(self, df):
         df.columns = np.arange(len(df.columns))
@@ -483,38 +502,40 @@ def test_groupby_level(self, sort, mframe, df):
         assert result0.index.name == "first"
         assert result1.index.name == "second"
 
-        assert_frame_equal(result0, expected0)
-        assert_frame_equal(result1, expected1)
+        tm.assert_frame_equal(result0, expected0)
+        tm.assert_frame_equal(result1, expected1)
         assert result0.index.name == frame.index.names[0]
         assert result1.index.name == frame.index.names[1]
 
         # groupby level name
         result0 = frame.groupby(level="first", sort=sort).sum()
         result1 = frame.groupby(level="second", sort=sort).sum()
-        assert_frame_equal(result0, expected0)
-        assert_frame_equal(result1, expected1)
+        tm.assert_frame_equal(result0, expected0)
+        tm.assert_frame_equal(result1, expected1)
 
         # axis=1
 
         result0 = frame.T.groupby(level=0, axis=1, sort=sort).sum()
         result1 = frame.T.groupby(level=1, axis=1, sort=sort).sum()
-        assert_frame_equal(result0, expected0.T)
-        assert_frame_equal(result1, expected1.T)
+        tm.assert_frame_equal(result0, expected0.T)
+        tm.assert_frame_equal(result1, expected1.T)
 
         # raise exception for non-MultiIndex
         msg = "level > 0 or level < -1 only valid with MultiIndex"
         with pytest.raises(ValueError, match=msg):
             df.groupby(level=1)
 
-    def test_groupby_level_index_names(self):
+    def test_groupby_level_index_names(self, axis):
         # GH4014 this used to raise ValueError since 'exp'>1 (in py2)
         df = DataFrame({"exp": ["A"] * 3 + ["B"] * 3, "var1": range(6)}).set_index(
             "exp"
         )
-        df.groupby(level="exp")
-        msg = "level name foo is not the name of the index"
+        if axis in (1, "columns"):
+            df = df.T
+        df.groupby(level="exp", axis=axis)
+        msg = f"level name foo is not the name of the {df._get_axis_name(axis)}"
         with pytest.raises(ValueError, match=msg):
-            df.groupby(level="foo")
+            df.groupby(level="foo", axis=axis)
 
     @pytest.mark.parametrize("sort", [True, False])
     def test_groupby_level_with_nas(self, sort):
@@ -528,7 +549,7 @@ def test_groupby_level_with_nas(self, sort):
         s = Series(np.arange(8.0), index=index)
         result = s.groupby(level=0, sort=sort).sum()
         expected = Series([6.0, 22.0], index=[0, 1])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         index = MultiIndex(
             levels=[[1, 0], [0, 1, 2, 3]],
@@ -539,7 +560,7 @@ def test_groupby_level_with_nas(self, sort):
         s = Series(np.arange(8.0), index=index)
         result = s.groupby(level=0, sort=sort).sum()
         expected = Series([6.0, 18.0], index=[0.0, 1.0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_groupby_args(self, mframe):
         # PR8618 and issue 8015
@@ -564,12 +585,12 @@ def test_level_preserve_order(self, sort, labels, mframe):
         # GH 17537
         grouped = mframe.groupby(level=0, sort=sort)
         exp_labels = np.array(labels, np.intp)
-        assert_almost_equal(grouped.grouper.labels[0], exp_labels)
+        tm.assert_almost_equal(grouped.grouper.codes[0], exp_labels)
 
     def test_grouping_labels(self, mframe):
         grouped = mframe.groupby(mframe.index.get_level_values(0))
         exp_labels = np.array([2, 2, 2, 0, 0, 1, 1, 3, 3, 3], dtype=np.intp)
-        assert_almost_equal(grouped.grouper.labels[0], exp_labels)
+        tm.assert_almost_equal(grouped.grouper.codes[0], exp_labels)
 
     def test_list_grouper_with_nat(self):
         # GH 14715
@@ -590,9 +611,18 @@ def test_list_grouper_with_nat(self):
     @pytest.mark.parametrize(
         "func,expected",
         [
-            ("transform", pd.Series(name=2, index=pd.RangeIndex(0, 0, 1))),
-            ("agg", pd.Series(name=2, index=pd.Float64Index([], name=1))),
-            ("apply", pd.Series(name=2, index=pd.Float64Index([], name=1))),
+            (
+                "transform",
+                pd.Series(name=2, dtype=np.float64, index=pd.RangeIndex(0, 0, 1)),
+            ),
+            (
+                "agg",
+                pd.Series(name=2, dtype=np.float64, index=pd.Float64Index([], name=1)),
+            ),
+            (
+                "apply",
+                pd.Series(name=2, dtype=np.float64, index=pd.Float64Index([], name=1)),
+            ),
         ],
     )
     def test_evaluate_with_empty_groups(self, func, expected):
@@ -603,11 +633,11 @@ def test_evaluate_with_empty_groups(self, func, expected):
         df = pd.DataFrame({1: [], 2: []})
         g = df.groupby(1)
         result = getattr(g[2], func)(lambda x: x)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_groupby_empty(self):
         # https://github.com/pandas-dev/pandas/issues/27190
-        s = pd.Series([], name="name")
+        s = pd.Series([], name="name", dtype="float64")
         gr = s.groupby([])
 
         result = gr.mean()
@@ -628,6 +658,37 @@ def test_groupby_empty(self):
         # check name
         assert s.groupby(s).grouper.names == ["name"]
 
+    def test_groupby_level_index_value_all_na(self):
+        # issue 20519
+        df = DataFrame(
+            [["x", np.nan, 10], [None, np.nan, 20]], columns=["A", "B", "C"]
+        ).set_index(["A", "B"])
+        result = df.groupby(level=["A", "B"]).sum()
+        expected = DataFrame(
+            data=[],
+            index=MultiIndex(
+                levels=[Index(["x"], dtype="object"), Index([], dtype="float64")],
+                codes=[[], []],
+                names=["A", "B"],
+            ),
+            columns=["C"],
+            dtype="int64",
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_multiindex_level_empty(self):
+        # https://github.com/pandas-dev/pandas/issues/31670
+        df = pd.DataFrame(
+            [[123, "a", 1.0], [123, "b", 2.0]], columns=["id", "category", "value"]
+        )
+        df = df.set_index(["id", "category"])
+        empty = df[df.value < 0]
+        result = empty.groupby("id").sum()
+        expected = pd.DataFrame(
+            dtype="float64", columns=["value"], index=pd.Int64Index([], name="id")
+        )
+        tm.assert_frame_equal(result, expected)
+
 
 # get_group
 # --------------------------------
@@ -659,8 +720,8 @@ def test_get_group(self):
         result1 = g.get_group(key)
         result2 = g.get_group(Timestamp(key).to_pydatetime())
         result3 = g.get_group(str(Timestamp(key)))
-        assert_frame_equal(result1, result2)
-        assert_frame_equal(result1, result3)
+        tm.assert_frame_equal(result1, result2)
+        tm.assert_frame_equal(result1, result3)
 
         g = df.groupby(["DATE", "label"])
 
@@ -668,8 +729,8 @@ def test_get_group(self):
         result1 = g.get_group(key)
         result2 = g.get_group((Timestamp(key[0]).to_pydatetime(), key[1]))
         result3 = g.get_group((str(Timestamp(key[0])), key[1]))
-        assert_frame_equal(result1, result2)
-        assert_frame_equal(result1, result3)
+        tm.assert_frame_equal(result1, result2)
+        tm.assert_frame_equal(result1, result3)
 
         # must pass a same-length tuple with multiple keys
         msg = "must supply a tuple to get_group with multiple grouping keys"
@@ -677,10 +738,7 @@ def test_get_group(self):
             g.get_group("foo")
         with pytest.raises(ValueError, match=msg):
             g.get_group(("foo"))
-        msg = (
-            "must supply a same-length tuple to get_group with multiple"
-            " grouping keys"
-        )
+        msg = "must supply a same-length tuple to get_group with multiple grouping keys"
         with pytest.raises(ValueError, match=msg):
             g.get_group(("foo", "bar", "baz"))
 
@@ -694,7 +752,7 @@ def test_get_group_empty_bins(self, observed):
         # IOW '(0, 5]'
         result = g.get_group(pd.Interval(0, 5))
         expected = DataFrame([3, 1], index=[0, 1])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         msg = r"Interval\(10, 15, closed='right'\)"
         with pytest.raises(KeyError, match=msg):
@@ -706,19 +764,19 @@ def test_get_group_grouped_by_tuple(self):
         gr = df.groupby("ids")
         expected = DataFrame({"ids": [(1,), (1,)]}, index=[0, 2])
         result = gr.get_group((1,))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         dt = pd.to_datetime(["2010-01-01", "2010-01-02", "2010-01-01", "2010-01-02"])
         df = DataFrame({"ids": [(x,) for x in dt]})
         gr = df.groupby("ids")
         result = gr.get_group(("2010-01-01",))
         expected = DataFrame({"ids": [(dt[0],), (dt[0],)]}, index=[0, 2])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_groupby_with_empty(self):
         index = pd.DatetimeIndex(())
         data = ()
-        series = pd.Series(data, index)
+        series = pd.Series(data, index, dtype=object)
         grouper = pd.Grouper(freq="D")
         grouped = series.groupby(grouper)
         assert next(iter(grouped), None) is None
@@ -794,7 +852,7 @@ def test_multi_iter(self):
             e1, e2, e3 = expected[i]
             assert e1 == one
             assert e2 == two
-            assert_series_equal(three, e3)
+            tm.assert_series_equal(three, e3)
 
     def test_multi_iter_frame(self, three_group):
         k1 = np.array(["b", "b", "b", "a", "a", "a"])
@@ -819,7 +877,7 @@ def test_multi_iter_frame(self, three_group):
             e1, e2, e3 = expected[i]
             assert e1 == one
             assert e2 == two
-            assert_frame_equal(three, e3)
+            tm.assert_frame_equal(three, e3)
 
         # don't iterate through groups with no data
         df["k1"] = np.array(["b", "b", "b", "a", "a", "a"])
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 71d545e960566..971a447b84cae 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 @pytest.fixture(params=[["inner"], ["inner", "outer"]])
@@ -49,7 +49,7 @@ def series():
 def test_grouper_index_level_as_string(frame, key_strs, groupers):
     result = frame.groupby(key_strs).mean()
     expected = frame.groupby(groupers).mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -79,4 +79,4 @@ def test_grouper_index_level_as_string_series(series, levels):
 
     # Compute and check result
     result = series.groupby(levels).mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/test_nth.py b/pandas/tests/groupby/test_nth.py
index 2c4b56793580c..0f850f2e94581 100644
--- a/pandas/tests/groupby/test_nth.py
+++ b/pandas/tests/groupby/test_nth.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, isna
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+import pandas._testing as tm
 
 
 def test_first_last_nth(df):
@@ -13,24 +13,24 @@ def test_first_last_nth(df):
     expected = df.loc[[1, 0], ["B", "C", "D"]]
     expected.index = Index(["bar", "foo"], name="A")
     expected = expected.sort_index()
-    assert_frame_equal(first, expected)
+    tm.assert_frame_equal(first, expected)
 
     nth = grouped.nth(0)
-    assert_frame_equal(nth, expected)
+    tm.assert_frame_equal(nth, expected)
 
     last = grouped.last()
     expected = df.loc[[5, 7], ["B", "C", "D"]]
     expected.index = Index(["bar", "foo"], name="A")
-    assert_frame_equal(last, expected)
+    tm.assert_frame_equal(last, expected)
 
     nth = grouped.nth(-1)
-    assert_frame_equal(nth, expected)
+    tm.assert_frame_equal(nth, expected)
 
     nth = grouped.nth(1)
     expected = df.loc[[2, 3], ["B", "C", "D"]].copy()
     expected.index = Index(["foo", "bar"], name="A")
     expected = expected.sort_index()
-    assert_frame_equal(nth, expected)
+    tm.assert_frame_equal(nth, expected)
 
     # it works!
     grouped["B"].first()
@@ -47,11 +47,11 @@ def test_first_last_nth(df):
     g = df.groupby("A")
     result = g.first()
     expected = df.iloc[[1, 2]].set_index("A")
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     expected = df.iloc[[1, 2]].set_index("A")
     result = g.nth(0, dropna="any")
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_first_last_nth_dtypes(df_mixed_floats):
@@ -66,19 +66,19 @@ def test_first_last_nth_dtypes(df_mixed_floats):
     expected = df.loc[[1, 0], ["B", "C", "D", "E", "F"]]
     expected.index = Index(["bar", "foo"], name="A")
     expected = expected.sort_index()
-    assert_frame_equal(first, expected)
+    tm.assert_frame_equal(first, expected)
 
     last = grouped.last()
     expected = df.loc[[5, 7], ["B", "C", "D", "E", "F"]]
     expected.index = Index(["bar", "foo"], name="A")
     expected = expected.sort_index()
-    assert_frame_equal(last, expected)
+    tm.assert_frame_equal(last, expected)
 
     nth = grouped.nth(1)
     expected = df.loc[[3, 2], ["B", "C", "D", "E", "F"]]
     expected.index = Index(["bar", "foo"], name="A")
     expected = expected.sort_index()
-    assert_frame_equal(nth, expected)
+    tm.assert_frame_equal(nth, expected)
 
     # GH 2763, first/last shifting dtypes
     idx = list(range(10))
@@ -89,27 +89,46 @@ def test_first_last_nth_dtypes(df_mixed_floats):
     assert f.dtype == "int64"
 
 
+def test_first_strings_timestamps():
+    # GH 11244
+    test = pd.DataFrame(
+        {
+            pd.Timestamp("2012-01-01 00:00:00"): ["a", "b"],
+            pd.Timestamp("2012-01-02 00:00:00"): ["c", "d"],
+            "name": ["e", "e"],
+            "aaaa": ["f", "g"],
+        }
+    )
+    result = test.groupby("name").first()
+    expected = DataFrame(
+        [["a", "c", "f"]],
+        columns=Index([Timestamp("2012-01-01"), Timestamp("2012-01-02"), "aaaa"]),
+        index=Index(["e"], name="name"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
 def test_nth():
     df = DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=["A", "B"])
     g = df.groupby("A")
 
-    assert_frame_equal(g.nth(0), df.iloc[[0, 2]].set_index("A"))
-    assert_frame_equal(g.nth(1), df.iloc[[1]].set_index("A"))
-    assert_frame_equal(g.nth(2), df.loc[[]].set_index("A"))
-    assert_frame_equal(g.nth(-1), df.iloc[[1, 2]].set_index("A"))
-    assert_frame_equal(g.nth(-2), df.iloc[[0]].set_index("A"))
-    assert_frame_equal(g.nth(-3), df.loc[[]].set_index("A"))
-    assert_series_equal(g.B.nth(0), df.set_index("A").B.iloc[[0, 2]])
-    assert_series_equal(g.B.nth(1), df.set_index("A").B.iloc[[1]])
-    assert_frame_equal(g[["B"]].nth(0), df.loc[[0, 2], ["A", "B"]].set_index("A"))
+    tm.assert_frame_equal(g.nth(0), df.iloc[[0, 2]].set_index("A"))
+    tm.assert_frame_equal(g.nth(1), df.iloc[[1]].set_index("A"))
+    tm.assert_frame_equal(g.nth(2), df.loc[[]].set_index("A"))
+    tm.assert_frame_equal(g.nth(-1), df.iloc[[1, 2]].set_index("A"))
+    tm.assert_frame_equal(g.nth(-2), df.iloc[[0]].set_index("A"))
+    tm.assert_frame_equal(g.nth(-3), df.loc[[]].set_index("A"))
+    tm.assert_series_equal(g.B.nth(0), df.set_index("A").B.iloc[[0, 2]])
+    tm.assert_series_equal(g.B.nth(1), df.set_index("A").B.iloc[[1]])
+    tm.assert_frame_equal(g[["B"]].nth(0), df.loc[[0, 2], ["A", "B"]].set_index("A"))
 
     exp = df.set_index("A")
-    assert_frame_equal(g.nth(0, dropna="any"), exp.iloc[[1, 2]])
-    assert_frame_equal(g.nth(-1, dropna="any"), exp.iloc[[1, 2]])
+    tm.assert_frame_equal(g.nth(0, dropna="any"), exp.iloc[[1, 2]])
+    tm.assert_frame_equal(g.nth(-1, dropna="any"), exp.iloc[[1, 2]])
 
     exp["B"] = np.nan
-    assert_frame_equal(g.nth(7, dropna="any"), exp.iloc[[1, 2]])
-    assert_frame_equal(g.nth(2, dropna="any"), exp.iloc[[1, 2]])
+    tm.assert_frame_equal(g.nth(7, dropna="any"), exp.iloc[[1, 2]])
+    tm.assert_frame_equal(g.nth(2, dropna="any"), exp.iloc[[1, 2]])
 
     # out of bounds, regression from 0.13.1
     # GH 6621
@@ -136,11 +155,11 @@ def test_nth():
 
     result = df.groupby(level=0, as_index=False).nth(2)
     expected = df.iloc[[-1]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.groupby(level=0, as_index=False).nth(3)
     expected = df.loc[[]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # GH 7559
     # from the vbench
@@ -149,7 +168,7 @@ def test_nth():
     g = df[0]
     expected = s.groupby(g).first()
     expected2 = s.groupby(g).apply(lambda x: x.iloc[0])
-    assert_series_equal(expected2, expected, check_names=False)
+    tm.assert_series_equal(expected2, expected, check_names=False)
     assert expected.name == 1
     assert expected2.name == 1
 
@@ -163,7 +182,7 @@ def test_nth():
     # related GH 7287
     expected = s.groupby(g, sort=False).first()
     result = s.groupby(g, sort=False).nth(0, dropna="all")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     with pytest.raises(ValueError, match="For a DataFrame groupby"):
         s.groupby(g, sort=False).nth(0, dropna=True)
@@ -173,20 +192,20 @@ def test_nth():
     g = df.groupby("A")
     result = g.B.nth(0, dropna="all")
     expected = g.B.first()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # test multiple nth values
     df = DataFrame([[1, np.nan], [1, 3], [1, 4], [5, 6], [5, 7]], columns=["A", "B"])
     g = df.groupby("A")
 
-    assert_frame_equal(g.nth(0), df.iloc[[0, 3]].set_index("A"))
-    assert_frame_equal(g.nth([0]), df.iloc[[0, 3]].set_index("A"))
-    assert_frame_equal(g.nth([0, 1]), df.iloc[[0, 1, 3, 4]].set_index("A"))
-    assert_frame_equal(g.nth([0, -1]), df.iloc[[0, 2, 3, 4]].set_index("A"))
-    assert_frame_equal(g.nth([0, 1, 2]), df.iloc[[0, 1, 2, 3, 4]].set_index("A"))
-    assert_frame_equal(g.nth([0, 1, -1]), df.iloc[[0, 1, 2, 3, 4]].set_index("A"))
-    assert_frame_equal(g.nth([2]), df.iloc[[2]].set_index("A"))
-    assert_frame_equal(g.nth([3, 4]), df.loc[[]].set_index("A"))
+    tm.assert_frame_equal(g.nth(0), df.iloc[[0, 3]].set_index("A"))
+    tm.assert_frame_equal(g.nth([0]), df.iloc[[0, 3]].set_index("A"))
+    tm.assert_frame_equal(g.nth([0, 1]), df.iloc[[0, 1, 3, 4]].set_index("A"))
+    tm.assert_frame_equal(g.nth([0, -1]), df.iloc[[0, 2, 3, 4]].set_index("A"))
+    tm.assert_frame_equal(g.nth([0, 1, 2]), df.iloc[[0, 1, 2, 3, 4]].set_index("A"))
+    tm.assert_frame_equal(g.nth([0, 1, -1]), df.iloc[[0, 1, 2, 3, 4]].set_index("A"))
+    tm.assert_frame_equal(g.nth([2]), df.iloc[[2]].set_index("A"))
+    tm.assert_frame_equal(g.nth([3, 4]), df.loc[[]].set_index("A"))
 
     business_dates = pd.date_range(start="4/1/2014", end="6/30/2014", freq="B")
     df = DataFrame(1, index=business_dates, columns=["a", "b"])
@@ -210,7 +229,7 @@ def test_nth():
         ]
     )
     expected = DataFrame(1, columns=["a", "b"], index=expected_dates)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_nth_multi_index(three_group):
@@ -219,7 +238,7 @@ def test_nth_multi_index(three_group):
     grouped = three_group.groupby(["A", "B"])
     result = grouped.nth(0)
     expected = grouped.first()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -281,18 +300,18 @@ def test_first_last_tz(data, expected_first, expected_last):
     result = df.groupby("id", as_index=False).first()
     expected = DataFrame(expected_first)
     cols = ["id", "time", "foo"]
-    assert_frame_equal(result[cols], expected[cols])
+    tm.assert_frame_equal(result[cols], expected[cols])
 
     result = df.groupby("id", as_index=False)["time"].first()
-    assert_frame_equal(result, expected[["id", "time"]])
+    tm.assert_frame_equal(result, expected[["id", "time"]])
 
     result = df.groupby("id", as_index=False).last()
     expected = DataFrame(expected_last)
     cols = ["id", "time", "foo"]
-    assert_frame_equal(result[cols], expected[cols])
+    tm.assert_frame_equal(result[cols], expected[cols])
 
     result = df.groupby("id", as_index=False)["time"].last()
-    assert_frame_equal(result, expected[["id", "time"]])
+    tm.assert_frame_equal(result, expected[["id", "time"]])
 
 
 @pytest.mark.parametrize(
@@ -322,7 +341,7 @@ def test_first_last_tz_multi_column(method, ts, alpha):
         },
         index=pd.Index([1, 2], name="group"),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_nth_multi_index_as_expected():
@@ -380,7 +399,7 @@ def test_nth_multi_index_as_expected():
             names=["A", "B"],
         ),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_head_tail():
@@ -389,49 +408,49 @@ def test_groupby_head_tail():
     g_not_as = df.groupby("A", as_index=False)
 
     # as_index= False, much easier
-    assert_frame_equal(df.loc[[0, 2]], g_not_as.head(1))
-    assert_frame_equal(df.loc[[1, 2]], g_not_as.tail(1))
+    tm.assert_frame_equal(df.loc[[0, 2]], g_not_as.head(1))
+    tm.assert_frame_equal(df.loc[[1, 2]], g_not_as.tail(1))
 
     empty_not_as = DataFrame(
         columns=df.columns, index=pd.Index([], dtype=df.index.dtype)
     )
     empty_not_as["A"] = empty_not_as["A"].astype(df.A.dtype)
     empty_not_as["B"] = empty_not_as["B"].astype(df.B.dtype)
-    assert_frame_equal(empty_not_as, g_not_as.head(0))
-    assert_frame_equal(empty_not_as, g_not_as.tail(0))
-    assert_frame_equal(empty_not_as, g_not_as.head(-1))
-    assert_frame_equal(empty_not_as, g_not_as.tail(-1))
+    tm.assert_frame_equal(empty_not_as, g_not_as.head(0))
+    tm.assert_frame_equal(empty_not_as, g_not_as.tail(0))
+    tm.assert_frame_equal(empty_not_as, g_not_as.head(-1))
+    tm.assert_frame_equal(empty_not_as, g_not_as.tail(-1))
 
-    assert_frame_equal(df, g_not_as.head(7))  # contains all
-    assert_frame_equal(df, g_not_as.tail(7))
+    tm.assert_frame_equal(df, g_not_as.head(7))  # contains all
+    tm.assert_frame_equal(df, g_not_as.tail(7))
 
     # as_index=True, (used to be different)
     df_as = df
 
-    assert_frame_equal(df_as.loc[[0, 2]], g_as.head(1))
-    assert_frame_equal(df_as.loc[[1, 2]], g_as.tail(1))
+    tm.assert_frame_equal(df_as.loc[[0, 2]], g_as.head(1))
+    tm.assert_frame_equal(df_as.loc[[1, 2]], g_as.tail(1))
 
     empty_as = DataFrame(index=df_as.index[:0], columns=df.columns)
     empty_as["A"] = empty_not_as["A"].astype(df.A.dtype)
     empty_as["B"] = empty_not_as["B"].astype(df.B.dtype)
-    assert_frame_equal(empty_as, g_as.head(0))
-    assert_frame_equal(empty_as, g_as.tail(0))
-    assert_frame_equal(empty_as, g_as.head(-1))
-    assert_frame_equal(empty_as, g_as.tail(-1))
+    tm.assert_frame_equal(empty_as, g_as.head(0))
+    tm.assert_frame_equal(empty_as, g_as.tail(0))
+    tm.assert_frame_equal(empty_as, g_as.head(-1))
+    tm.assert_frame_equal(empty_as, g_as.tail(-1))
 
-    assert_frame_equal(df_as, g_as.head(7))  # contains all
-    assert_frame_equal(df_as, g_as.tail(7))
+    tm.assert_frame_equal(df_as, g_as.head(7))  # contains all
+    tm.assert_frame_equal(df_as, g_as.tail(7))
 
     # test with selection
-    assert_frame_equal(g_as[[]].head(1), df_as.loc[[0, 2], []])
-    assert_frame_equal(g_as[["A"]].head(1), df_as.loc[[0, 2], ["A"]])
-    assert_frame_equal(g_as[["B"]].head(1), df_as.loc[[0, 2], ["B"]])
-    assert_frame_equal(g_as[["A", "B"]].head(1), df_as.loc[[0, 2]])
+    tm.assert_frame_equal(g_as[[]].head(1), df_as.loc[[0, 2], []])
+    tm.assert_frame_equal(g_as[["A"]].head(1), df_as.loc[[0, 2], ["A"]])
+    tm.assert_frame_equal(g_as[["B"]].head(1), df_as.loc[[0, 2], ["B"]])
+    tm.assert_frame_equal(g_as[["A", "B"]].head(1), df_as.loc[[0, 2]])
 
-    assert_frame_equal(g_not_as[[]].head(1), df_as.loc[[0, 2], []])
-    assert_frame_equal(g_not_as[["A"]].head(1), df_as.loc[[0, 2], ["A"]])
-    assert_frame_equal(g_not_as[["B"]].head(1), df_as.loc[[0, 2], ["B"]])
-    assert_frame_equal(g_not_as[["A", "B"]].head(1), df_as.loc[[0, 2]])
+    tm.assert_frame_equal(g_not_as[[]].head(1), df_as.loc[[0, 2], []])
+    tm.assert_frame_equal(g_not_as[["A"]].head(1), df_as.loc[[0, 2], ["A"]])
+    tm.assert_frame_equal(g_not_as[["B"]].head(1), df_as.loc[[0, 2], ["B"]])
+    tm.assert_frame_equal(g_not_as[["A", "B"]].head(1), df_as.loc[[0, 2]])
 
 
 def test_group_selection_cache():
@@ -442,26 +461,26 @@ def test_group_selection_cache():
     g = df.groupby("A")
     result1 = g.head(n=2)
     result2 = g.nth(0)
-    assert_frame_equal(result1, df)
-    assert_frame_equal(result2, expected)
+    tm.assert_frame_equal(result1, df)
+    tm.assert_frame_equal(result2, expected)
 
     g = df.groupby("A")
     result1 = g.tail(n=2)
     result2 = g.nth(0)
-    assert_frame_equal(result1, df)
-    assert_frame_equal(result2, expected)
+    tm.assert_frame_equal(result1, df)
+    tm.assert_frame_equal(result2, expected)
 
     g = df.groupby("A")
     result1 = g.nth(0)
     result2 = g.head(n=2)
-    assert_frame_equal(result1, expected)
-    assert_frame_equal(result2, df)
+    tm.assert_frame_equal(result1, expected)
+    tm.assert_frame_equal(result2, df)
 
     g = df.groupby("A")
     result1 = g.nth(0)
     result2 = g.tail(n=2)
-    assert_frame_equal(result1, expected)
-    assert_frame_equal(result2, df)
+    tm.assert_frame_equal(result1, expected)
+    tm.assert_frame_equal(result2, df)
 
 
 def test_nth_empty():
@@ -469,13 +488,13 @@ def test_nth_empty():
     df = DataFrame(index=[0], columns=["a", "b", "c"])
     result = df.groupby("a").nth(10)
     expected = DataFrame(index=Index([], name="a"), columns=["b", "c"])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.groupby(["a", "b"]).nth(10)
     expected = DataFrame(
         index=MultiIndex([[], []], [[], []], names=["a", "b"]), columns=["c"]
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_nth_column_order():
@@ -489,13 +508,13 @@ def test_nth_column_order():
     expected = DataFrame(
         [["b", 100.0], ["c", 200.0]], columns=["C", "B"], index=Index([1, 2], name="A")
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.groupby("A").nth(-1, dropna="any")
     expected = DataFrame(
         [["a", 50.0], ["d", 150.0]], columns=["C", "B"], index=Index([1, 2], name="A")
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("dropna", [None, "any", "all"])
@@ -510,4 +529,4 @@ def test_nth_nan_in_grouper(dropna):
         [[2, 3], [6, 7]], columns=list("bc"), index=Index(["abc", "def"], name="a")
     )
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_rank.py b/pandas/tests/groupby/test_rank.py
index a6ea793b53c41..3461bf6e10662 100644
--- a/pandas/tests/groupby/test_rank.py
+++ b/pandas/tests/groupby/test_rank.py
@@ -3,7 +3,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, concat
-from pandas.util import testing as tm
+import pandas._testing as tm
+from pandas.core.base import DataError
 
 
 def test_rank_apply():
@@ -384,7 +385,7 @@ def test_rank_avg_even_vals():
 def test_rank_object_raises(ties_method, ascending, na_option, pct, vals):
     df = DataFrame({"key": ["foo"] * 5, "val": vals})
 
-    with pytest.raises(TypeError, match="not callable"):
+    with pytest.raises(DataError, match="No numeric types to aggregate"):
         df.groupby("key").rank(
             method=ties_method, ascending=ascending, na_option=na_option, pct=pct
         )
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index e1e35d8eb7d18..6b8bd9e805a0c 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -4,16 +4,14 @@
 from io import StringIO
 
 import numpy as np
-from numpy import nan
 import pytest
 import pytz
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, date_range
+import pandas._testing as tm
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.groupby.ops import BinGrouper
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 class TestGroupBy:
@@ -51,14 +49,14 @@ def test_groupby_with_timegrouper(self):
             expected.iloc[[0, 6, 18], 0] = np.array([24, 6, 9], dtype="int64")
 
             result1 = df.resample("5D").sum()
-            assert_frame_equal(result1, expected)
+            tm.assert_frame_equal(result1, expected)
 
             df_sorted = df.sort_index()
             result2 = df_sorted.groupby(pd.Grouper(freq="5D")).sum()
-            assert_frame_equal(result2, expected)
+            tm.assert_frame_equal(result2, expected)
 
             result3 = df.groupby(pd.Grouper(freq="5D")).sum()
-            assert_frame_equal(result3, expected)
+            tm.assert_frame_equal(result3, expected)
 
     @pytest.mark.parametrize("should_sort", [True, False])
     def test_groupby_with_timegrouper_methods(self, should_sort):
@@ -132,7 +130,7 @@ def test_timegrouper_with_reg_groups(self):
             ).set_index(["Date", "Buyer"])
 
             result = df.groupby([pd.Grouper(freq="A"), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             expected = DataFrame(
                 {
@@ -147,7 +145,7 @@ def test_timegrouper_with_reg_groups(self):
                 }
             ).set_index(["Date", "Buyer"])
             result = df.groupby([pd.Grouper(freq="6MS"), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         df_original = DataFrame(
             {
@@ -185,7 +183,7 @@ def test_timegrouper_with_reg_groups(self):
             ).set_index(["Date", "Buyer"])
 
             result = df.groupby([pd.Grouper(freq="1D"), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = df.groupby([pd.Grouper(freq="1M"), "Buyer"]).sum()
             expected = DataFrame(
@@ -199,12 +197,12 @@ def test_timegrouper_with_reg_groups(self):
                     ],
                 }
             ).set_index(["Date", "Buyer"])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # passing the name
             df = df.reset_index()
             result = df.groupby([pd.Grouper(freq="1M", key="Date"), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             with pytest.raises(KeyError, match="'The grouper name foo is not found'"):
                 df.groupby([pd.Grouper(freq="1M", key="foo"), "Buyer"]).sum()
@@ -212,9 +210,9 @@ def test_timegrouper_with_reg_groups(self):
             # passing the level
             df = df.set_index("Date")
             result = df.groupby([pd.Grouper(freq="1M", level="Date"), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
             result = df.groupby([pd.Grouper(freq="1M", level=0), "Buyer"]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             with pytest.raises(ValueError):
                 df.groupby([pd.Grouper(freq="1M", level="foo"), "Buyer"]).sum()
@@ -234,7 +232,7 @@ def test_timegrouper_with_reg_groups(self):
                     ],
                 }
             ).set_index(["Date", "Buyer"])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # error as we have both a level and a name!
             with pytest.raises(ValueError):
@@ -247,19 +245,19 @@ def test_timegrouper_with_reg_groups(self):
                 {"Quantity": [31], "Date": [datetime(2013, 10, 31, 0, 0)]}
             ).set_index("Date")
             result = df.groupby(pd.Grouper(freq="1M")).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = df.groupby([pd.Grouper(freq="1M")]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             expected = DataFrame(
                 {"Quantity": [31], "Date": [datetime(2013, 11, 30, 0, 0)]}
             ).set_index("Date")
             result = df.groupby(pd.Grouper(freq="1M", key="Date")).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = df.groupby([pd.Grouper(freq="1M", key="Date")]).sum()
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("freq", ["D", "M", "A", "Q-APR"])
     def test_timegrouper_with_reg_groups_freq(self, freq):
@@ -317,10 +315,10 @@ def test_timegrouper_with_reg_groups_freq(self, freq):
             .groupby([pd.Grouper(freq=freq), "user_id"])["whole_cost"]
             .sum()
         )
-        assert_series_equal(result1, expected)
+        tm.assert_series_equal(result1, expected)
 
         result2 = df.groupby([pd.Grouper(freq=freq), "user_id"])["whole_cost"].sum()
-        assert_series_equal(result2, expected)
+        tm.assert_series_equal(result2, expected)
 
     def test_timegrouper_get_group(self):
         # GH 6914
@@ -354,7 +352,7 @@ def test_timegrouper_get_group(self):
             for t, expected in zip(dt_list, expected_list):
                 dt = pd.Timestamp(t)
                 result = grouped.get_group(dt)
-                assert_frame_equal(result, expected)
+                tm.assert_frame_equal(result, expected)
 
         # multiple grouping
         expected_list = [
@@ -369,7 +367,7 @@ def test_timegrouper_get_group(self):
             for (b, t), expected in zip(g_list, expected_list):
                 dt = pd.Timestamp(t)
                 result = grouped.get_group((b, dt))
-                assert_frame_equal(result, expected)
+                tm.assert_frame_equal(result, expected)
 
         # with index
         df_original = df_original.set_index("Date")
@@ -386,7 +384,7 @@ def test_timegrouper_get_group(self):
             for t, expected in zip(dt_list, expected_list):
                 dt = pd.Timestamp(t)
                 result = grouped.get_group(dt)
-                assert_frame_equal(result, expected)
+                tm.assert_frame_equal(result, expected)
 
     def test_timegrouper_apply_return_type_series(self):
         # Using `apply` with the `TimeGrouper` should give the
@@ -401,7 +399,7 @@ def sumfunc_series(x):
 
         expected = df.groupby(pd.Grouper(key="date")).apply(sumfunc_series)
         result = df_dt.groupby(pd.Grouper(freq="M", key="date")).apply(sumfunc_series)
-        assert_frame_equal(
+        tm.assert_frame_equal(
             result.reset_index(drop=True), expected.reset_index(drop=True)
         )
 
@@ -418,7 +416,7 @@ def sumfunc_value(x):
 
         expected = df.groupby(pd.Grouper(key="date")).apply(sumfunc_value)
         result = df_dt.groupby(Grouper(freq="M", key="date")).apply(sumfunc_value)
-        assert_series_equal(
+        tm.assert_series_equal(
             result.reset_index(drop=True), expected.reset_index(drop=True)
         )
 
@@ -494,7 +492,7 @@ def test_groupby_groups_datetimeindex_tz(self):
         )
 
         result = df.groupby(["datetime", "label"]).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # by level
         didx = pd.DatetimeIndex(dates, tz="Asia/Tokyo")
@@ -514,7 +512,7 @@ def test_groupby_groups_datetimeindex_tz(self):
         )
 
         result = df.groupby(level=0).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_frame_datetime64_handling_groupby(self):
         # it works!
@@ -551,7 +549,7 @@ def test_groupby_multi_timezone(self):
             name="date",
             dtype=object,
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         tz = "America/Chicago"
         res_values = df.groupby("tz").date.get_group(tz)
@@ -562,7 +560,7 @@ def test_groupby_multi_timezone(self):
             name="date",
         )
         expected = pd.to_datetime(exp_values).dt.tz_localize(tz)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_groupby_groups_periods(self):
         dates = [
@@ -603,7 +601,7 @@ def test_groupby_groups_periods(self):
         )
 
         result = df.groupby(["period", "label"]).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # by level
         didx = pd.PeriodIndex(dates, freq="H")
@@ -623,7 +621,7 @@ def test_groupby_groups_periods(self):
         )
 
         result = df.groupby(level=0).sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_groupby_first_datetime64(self):
         df = DataFrame([(1, 1351036800000000000), (2, 1351036800000000000)])
@@ -645,7 +643,7 @@ def test_groupby_max_datetime64(self):
         df = DataFrame(dict(A=Timestamp("20130101"), B=np.arange(5)))
         expected = df.groupby("A")["A"].apply(lambda x: x.max())
         result = df.groupby("A")["A"].max()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_groupby_datetime64_32_bit(self):
         # GH 6410 / numpy 4328
@@ -654,7 +652,7 @@ def test_groupby_datetime64_32_bit(self):
         df = DataFrame({"A": range(2), "B": [pd.Timestamp("2000-01-1")] * 2})
         result = df.groupby("A")["B"].transform(min)
         expected = Series([pd.Timestamp("2000-01-1")] * 2, name="B")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_groupby_with_timezone_selection(self):
         # GH 11616
@@ -699,13 +697,13 @@ def test_first_last_max_min_on_time_data(self):
         df_test = DataFrame(
             {
                 "dt": [
-                    nan,
+                    np.nan,
                     "2015-07-24 10:10",
                     "2015-07-25 11:11",
                     "2015-07-23 12:12",
-                    nan,
+                    np.nan,
                 ],
-                "td": [nan, td(days=1), td(days=2), td(days=3), nan],
+                "td": [np.nan, td(days=1), td(days=2), td(days=3), np.nan],
             }
         )
         df_test.dt = pd.to_datetime(df_test.dt)
@@ -715,10 +713,10 @@ def test_first_last_max_min_on_time_data(self):
         grouped_test = df_test.groupby("group")
         grouped_ref = df_ref.groupby("group")
 
-        assert_frame_equal(grouped_ref.max(), grouped_test.max())
-        assert_frame_equal(grouped_ref.min(), grouped_test.min())
-        assert_frame_equal(grouped_ref.first(), grouped_test.first())
-        assert_frame_equal(grouped_ref.last(), grouped_test.last())
+        tm.assert_frame_equal(grouped_ref.max(), grouped_test.max())
+        tm.assert_frame_equal(grouped_ref.min(), grouped_test.min())
+        tm.assert_frame_equal(grouped_ref.first(), grouped_test.first())
+        tm.assert_frame_equal(grouped_ref.last(), grouped_test.last())
 
     def test_nunique_with_timegrouper_and_nat(self):
         # GH 17575
@@ -756,4 +754,4 @@ def test_scalar_call_versus_list_call(self):
         grouped = data_frame.groupby([grouper])
         expected = grouped.count()
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_transform.py b/pandas/tests/groupby/test_transform.py
index d3972e6ba9008..8967ef06f50fb 100644
--- a/pandas/tests/groupby/test_transform.py
+++ b/pandas/tests/groupby/test_transform.py
@@ -18,9 +18,8 @@
     concat,
     date_range,
 )
+import pandas._testing as tm
 from pandas.core.groupby.groupby import DataError
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 def assert_fp_equal(a, b):
@@ -54,7 +53,7 @@ def test_transform():
         .mean()
     )
     result = df.groupby(key).transform(lambda x: x - x.mean()).groupby(key).mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     def demean(arr):
         return arr - arr.mean()
@@ -67,7 +66,7 @@ def demean(arr):
     key = ["one", "two", "one", "two", "one"]
     result = people.groupby(key).transform(demean).groupby(key).mean()
     expected = people.groupby(key).apply(demean).groupby(key).mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # GH 8430
     df = tm.makeTimeDataFrame()
@@ -91,10 +90,10 @@ def test_transform_fast():
     expected = pd.Series(values, index=df.index, name="val")
 
     result = grp.transform(np.mean)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = grp.transform("mean")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # GH 12737
     df = pd.DataFrame(
@@ -118,18 +117,18 @@ def test_transform_fast():
         {"f": [1.1, 2.1, 2.1, 4.5], "d": dates, "i": [1, 2, 2, 4]},
         columns=["f", "i", "d"],
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # selection
     result = df.groupby("grouping")[["f", "i"]].transform("first")
     expected = expected[["f", "i"]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # dup columns
     df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=["g", "a", "a"])
     result = df.groupby("g").transform("first")
     expected = df.drop("g", axis=1)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_broadcast(tsframe, ts):
@@ -179,26 +178,26 @@ def test_transform_axis(tsframe):
     grouped = ts.groupby(lambda x: x.weekday())
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: x - x.mean())
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     ts = ts.T
     grouped = ts.groupby(lambda x: x.weekday(), axis=1)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: (x.T - x.mean(1)).T)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # non-monotonic
     ts = tso.iloc[[1, 0] + list(range(2, len(base)))]
     grouped = ts.groupby(lambda x: x.weekday())
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: x - x.mean())
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     ts = ts.T
     grouped = ts.groupby(lambda x: x.weekday(), axis=1)
     result = ts - grouped.transform("mean")
     expected = grouped.apply(lambda x: (x.T - x.mean(1)).T)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_dtype():
@@ -207,7 +206,7 @@ def test_transform_dtype():
     df = DataFrame([[1, 3], [2, 3]])
     result = df.groupby(1).transform("mean")
     expected = DataFrame([[1.5], [1.5]])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_bug():
@@ -216,7 +215,7 @@ def test_transform_bug():
     df = DataFrame(dict(A=Timestamp("20130101"), B=np.arange(5)))
     result = df.groupby("A")["B"].transform(lambda x: x.rank(ascending=False))
     expected = Series(np.arange(5, 0, step=-1), name="B")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_numeric_to_boolean():
@@ -226,11 +225,11 @@ def test_transform_numeric_to_boolean():
 
     df = pd.DataFrame({"A": [1.1, 2.2], "B": [1, 2]})
     result = df.groupby("B").A.transform(lambda x: True)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     df = pd.DataFrame({"A": [1, 2], "B": [1, 2]})
     result = df.groupby("B").A.transform(lambda x: True)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_datetime_to_timedelta():
@@ -245,11 +244,11 @@ def test_transform_datetime_to_timedelta():
         df.groupby("A")["A"].transform(lambda x: x.max() - x.min() + base_time)
         - base_time
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # this does date math and causes the transform to return timedelta
     result = df.groupby("A")["A"].transform(lambda x: x.max() - x.min())
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_datetime_to_numeric():
@@ -261,7 +260,7 @@ def test_transform_datetime_to_numeric():
     )
 
     expected = Series([-0.5, 0.5], name="b")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # convert dt to int
     df = DataFrame({"a": 1, "b": date_range("2015-01-01", periods=2, freq="D")})
@@ -270,7 +269,7 @@ def test_transform_datetime_to_numeric():
     )
 
     expected = Series([0, 1], name="b")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_casting():
@@ -315,17 +314,43 @@ def test_dispatch_transform(tsframe):
     filled = grouped.fillna(method="pad")
     fillit = lambda x: x.fillna(method="pad")
     expected = df.groupby(lambda x: x.month).transform(fillit)
-    assert_frame_equal(filled, expected)
+    tm.assert_frame_equal(filled, expected)
+
+
+def test_transform_transformation_func(transformation_func):
+    # GH 30918
+    df = DataFrame(
+        {
+            "A": ["foo", "foo", "foo", "foo", "bar", "bar", "baz"],
+            "B": [1, 2, np.nan, 3, 3, np.nan, 4],
+        }
+    )
+
+    if transformation_func in ["pad", "backfill", "tshift", "corrwith", "cumcount"]:
+        # These transformation functions are not yet covered in this test
+        pytest.xfail("See GH 31269 and GH 31270")
+    elif transformation_func == "fillna":
+        test_op = lambda x: x.transform("fillna", value=0)
+        mock_op = lambda x: x.fillna(value=0)
+    else:
+        test_op = lambda x: x.transform(transformation_func)
+        mock_op = lambda x: getattr(x, transformation_func)()
+
+    result = test_op(df.groupby("A"))
+    groups = [df[["B"]].iloc[:4], df[["B"]].iloc[4:6], df[["B"]].iloc[6:]]
+    expected = concat([mock_op(g) for g in groups])
+
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_select_columns(df):
     f = lambda x: x.mean()
-    result = df.groupby("A")["C", "D"].transform(f)
+    result = df.groupby("A")[["C", "D"]].transform(f)
 
     selection = df[["C", "D"]]
     expected = selection.groupby(df["A"]).transform(f)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_exclude_nuisance(df):
@@ -339,17 +364,17 @@ def test_transform_exclude_nuisance(df):
     expected = DataFrame(expected)
     result = df.groupby("A").transform(np.mean)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_function_aliases(df):
     result = df.groupby("A").transform("mean")
     expected = df.groupby("A").transform(np.mean)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.groupby("A")["C"].transform("mean")
     expected = df.groupby("A")["C"].transform(np.mean)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_series_fast_transform_date():
@@ -365,7 +390,7 @@ def test_series_fast_transform_date():
         pd.Timestamp("2014-1-4"),
     ]
     expected = pd.Series(dates, name="d")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_length():
@@ -383,7 +408,7 @@ def nsum(x):
         df.groupby("col1")["col2"].transform(nsum),
     ]
     for result in results:
-        assert_series_equal(result, expected, check_names=False)
+        tm.assert_series_equal(result, expected, check_names=False)
 
 
 def test_transform_coercion():
@@ -396,7 +421,7 @@ def test_transform_coercion():
 
     expected = g.transform(np.mean)
     result = g.transform(lambda x: np.mean(x))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_transform_with_int():
@@ -417,14 +442,14 @@ def test_groupby_transform_with_int():
     expected = DataFrame(
         dict(B=np.nan, C=Series([-1, 0, 1, -1, 0, 1], dtype="float64"))
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # int case
     df = DataFrame(dict(A=[1, 1, 1, 2, 2, 2], B=1, C=[1, 2, 3, 1, 2, 3], D="foo"))
     with np.errstate(all="ignore"):
         result = df.groupby("A").transform(lambda x: (x - x.mean()) / x.std())
     expected = DataFrame(dict(B=np.nan, C=[-1, 0, 1, -1, 0, 1]))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # int that needs float conversion
     s = Series([2, 3, 4, 10, 5, -1])
@@ -437,12 +462,12 @@ def test_groupby_transform_with_int():
     s2 = s.iloc[3:6]
     s2 = (s2 - s2.mean()) / s2.std()
     expected = DataFrame(dict(B=np.nan, C=concat([s1, s2])))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # int downcasting
     result = df.groupby("A").transform(lambda x: x * 2 / 2)
     expected = DataFrame(dict(B=1, C=[2, 3, 4, 10, 5, -1]))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_transform_with_nan_group():
@@ -452,7 +477,7 @@ def test_groupby_transform_with_nan_group():
     expected = pd.Series(
         [1.0, 1.0, 2.0, 3.0, np.nan, 6.0, 6.0, 9.0, 9.0, 9.0], name="a"
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform_mixed_type():
@@ -479,7 +504,7 @@ def f(group):
     with pd.option_context("mode.chained_assignment", None):
         for key, group in grouped:
             res = f(group)
-            assert_frame_equal(res, result.loc[key])
+            tm.assert_frame_equal(res, result.loc[key])
 
 
 def _check_cython_group_transform_cumulative(pd_op, np_op, dtype):
@@ -766,9 +791,12 @@ def test_transform_with_non_scalar_group():
     ],
 )
 @pytest.mark.parametrize("agg_func", ["count", "rank", "size"])
-def test_transform_numeric_ret(cols, exp, comp_func, agg_func):
+def test_transform_numeric_ret(cols, exp, comp_func, agg_func, request):
     if agg_func == "size" and isinstance(cols, list):
-        pytest.xfail("'size' transformation not supported with NDFrameGroupy")
+        # https://github.com/pytest-dev/pytest/issues/6300
+        # workaround to xfail fixture/param permutations
+        reason = "'size' transformation not supported with NDFrameGroupy"
+        request.node.add_marker(pytest.mark.xfail(reason=reason))
 
     # GH 19200
     df = pd.DataFrame(
@@ -838,11 +866,11 @@ def interweave(list_obj):
     if as_series:
         result = getattr(df.groupby("key")["val"], fill_method)(limit=limit)
         exp = Series(_exp_vals, name="val")
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
     else:
         result = getattr(df.groupby("key"), fill_method)(limit=limit)
         exp = DataFrame({"val": _exp_vals})
-        assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, exp)
 
 
 @pytest.mark.parametrize("fill_method", ["ffill", "bfill"])
@@ -875,27 +903,19 @@ def test_pad_stable_sorting(fill_method):
         ),
     ],
 )
-@pytest.mark.parametrize(
-    "periods,fill_method,limit",
-    [
-        (1, "ffill", None),
-        (1, "ffill", 1),
-        (1, "bfill", None),
-        (1, "bfill", 1),
-        (-1, "ffill", None),
-        (-1, "ffill", 1),
-        (-1, "bfill", None),
-        (-1, "bfill", 1),
-    ],
-)
+@pytest.mark.parametrize("periods", [1, -1])
+@pytest.mark.parametrize("fill_method", ["ffill", "bfill", None])
+@pytest.mark.parametrize("limit", [None, 1])
 def test_pct_change(test_series, freq, periods, fill_method, limit):
-    # GH  21200, 21621
+    # GH  21200, 21621, 30463
     vals = [3, np.nan, np.nan, np.nan, 1, 2, 4, 10, np.nan, 4]
     keys = ["a", "b"]
     key_v = np.repeat(keys, len(vals))
     df = DataFrame({"key": key_v, "vals": vals * 2})
 
-    df_g = getattr(df.groupby("key"), fill_method)(limit=limit)
+    df_g = df
+    if fill_method is not None:
+        df_g = getattr(df.groupby("key"), fill_method)(limit=limit)
     grp = df_g.groupby(df.key)
 
     expected = grp["vals"].obj / grp["vals"].shift(periods) - 1
@@ -912,6 +932,41 @@ def test_pct_change(test_series, freq, periods, fill_method, limit):
         tm.assert_frame_equal(result, expected.to_frame("vals"))
 
 
+@pytest.mark.parametrize(
+    "func, expected_status",
+    [
+        ("ffill", ["shrt", "shrt", "lng", np.nan, "shrt", "ntrl", "ntrl"]),
+        ("bfill", ["shrt", "lng", "lng", "shrt", "shrt", "ntrl", np.nan]),
+    ],
+)
+def test_ffill_bfill_non_unique_multilevel(func, expected_status):
+    # GH 19437
+    date = pd.to_datetime(
+        [
+            "2018-01-01",
+            "2018-01-01",
+            "2018-01-01",
+            "2018-01-01",
+            "2018-01-02",
+            "2018-01-01",
+            "2018-01-02",
+        ]
+    )
+    symbol = ["MSFT", "MSFT", "MSFT", "AAPL", "AAPL", "TSLA", "TSLA"]
+    status = ["shrt", np.nan, "lng", np.nan, "shrt", "ntrl", np.nan]
+
+    df = DataFrame({"date": date, "symbol": symbol, "status": status})
+    df = df.set_index(["date", "symbol"])
+    result = getattr(df.groupby("symbol")["status"], func)()
+
+    index = MultiIndex.from_tuples(
+        tuples=list(zip(*[date, symbol])), names=["date", "symbol"]
+    )
+    expected = Series(expected_status, index=index, name="status")
+
+    tm.assert_series_equal(result, expected)
+
+
 @pytest.mark.parametrize("func", [np.any, np.all])
 def test_any_all_np_func(func):
     # GH 20653
@@ -933,9 +988,7 @@ def demean_rename(x):
         if isinstance(x, pd.Series):
             return result
 
-        result = result.rename(
-            columns={c: "{}_demeaned".format(c) for c in result.columns}
-        )
+        result = result.rename(columns={c: "{c}_demeaned" for c in result.columns})
 
         return result
 
@@ -989,7 +1042,7 @@ def test_transform_absent_categories(func):
     df = DataFrame(dict(x=Categorical(x_vals, x_cats), y=y))
     result = getattr(df.y.groupby(df.x), func)()
     expected = df.y
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("func", ["ffill", "bfill", "shift"])
@@ -1000,7 +1053,7 @@ def test_ffill_not_in_axis(func, key, val):
     result = getattr(df.groupby(**{key: val}), func)()
     expected = df
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_transform_invalid_name_raises():
@@ -1073,4 +1126,71 @@ def test_transform_lambda_with_datetimetz():
         ],
         name="time",
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
+
+
+def test_transform_fastpath_raises():
+    # GH#29631 case where fastpath defined in groupby.generic _choose_path
+    #  raises, but slow_path does not
+
+    df = pd.DataFrame({"A": [1, 1, 2, 2], "B": [1, -1, 1, 2]})
+    gb = df.groupby("A")
+
+    def func(grp):
+        # we want a function such that func(frame) fails but func.apply(frame)
+        #  works
+        if grp.ndim == 2:
+            # Ensure that fast_path fails
+            raise NotImplementedError("Don't cross the streams")
+        return grp * 2
+
+    # Check that the fastpath raises, see _transform_general
+    obj = gb._obj_with_exclusions
+    gen = gb.grouper.get_iterator(obj, axis=gb.axis)
+    fast_path, slow_path = gb._define_paths(func)
+    _, group = next(gen)
+
+    with pytest.raises(NotImplementedError, match="Don't cross the streams"):
+        fast_path(group)
+
+    result = gb.transform(func)
+
+    expected = pd.DataFrame([2, -2, 2, 4], columns=["B"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_transform_lambda_indexing():
+    # GH 7883
+    df = pd.DataFrame(
+        {
+            "A": ["foo", "bar", "foo", "bar", "foo", "flux", "foo", "flux"],
+            "B": ["one", "one", "two", "three", "two", "six", "five", "three"],
+            "C": range(8),
+            "D": range(8),
+            "E": range(8),
+        }
+    )
+    df = df.set_index(["A", "B"])
+    df = df.sort_index()
+    result = df.groupby(level="A").transform(lambda x: x.iloc[-1])
+    expected = DataFrame(
+        {
+            "C": [3, 3, 7, 7, 4, 4, 4, 4],
+            "D": [3, 3, 7, 7, 4, 4, 4, 4],
+            "E": [3, 3, 7, 7, 4, 4, 4, 4],
+        },
+        index=MultiIndex.from_tuples(
+            [
+                ("bar", "one"),
+                ("bar", "three"),
+                ("flux", "six"),
+                ("flux", "three"),
+                ("foo", "five"),
+                ("foo", "one"),
+                ("foo", "two"),
+                ("foo", "two"),
+            ],
+            names=["A", "B"],
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_value_counts.py b/pandas/tests/groupby/test_value_counts.py
index c7b28822092a8..c86cb4532bc26 100644
--- a/pandas/tests/groupby/test_value_counts.py
+++ b/pandas/tests/groupby/test_value_counts.py
@@ -9,8 +9,8 @@
 import numpy as np
 import pytest
 
-from pandas import DataFrame, MultiIndex, Series, date_range
-from pandas.util import testing as tm
+from pandas import DataFrame, Grouper, MultiIndex, Series, date_range, to_datetime
+import pandas._testing as tm
 
 
 # our starting frame
@@ -47,34 +47,63 @@ def seed_df(seed_nans, n, m):
         keys = "1st", "2nd", ["1st", "2nd"]
         for k, b in product(keys, bins):
             binned.append((df, k, b, n, m))
-            ids.append("{}-{}-{}".format(k, n, m))
+            ids.append(f"{k}-{n}-{m}")
 
 
 @pytest.mark.slow
 @pytest.mark.parametrize("df, keys, bins, n, m", binned, ids=ids)
-def test_series_groupby_value_counts(df, keys, bins, n, m):
+@pytest.mark.parametrize("isort", [True, False])
+@pytest.mark.parametrize("normalize", [True, False])
+@pytest.mark.parametrize("sort", [True, False])
+@pytest.mark.parametrize("ascending", [True, False])
+@pytest.mark.parametrize("dropna", [True, False])
+def test_series_groupby_value_counts(
+    df, keys, bins, n, m, isort, normalize, sort, ascending, dropna
+):
     def rebuild_index(df):
         arr = list(map(df.index.get_level_values, range(df.index.nlevels)))
         df.index = MultiIndex.from_arrays(arr, names=df.index.names)
         return df
 
-    for isort, normalize, sort, ascending, dropna in product((False, True), repeat=5):
+    kwargs = dict(
+        normalize=normalize, sort=sort, ascending=ascending, dropna=dropna, bins=bins
+    )
+
+    gr = df.groupby(keys, sort=isort)
+    left = gr["3rd"].value_counts(**kwargs)
+
+    gr = df.groupby(keys, sort=isort)
+    right = gr["3rd"].apply(Series.value_counts, **kwargs)
+    right.index.names = right.index.names[:-1] + ["3rd"]
+
+    # have to sort on index because of unstable sort on values
+    left, right = map(rebuild_index, (left, right))  # xref GH9212
+    tm.assert_series_equal(left.sort_index(), right.sort_index())
 
-        kwargs = dict(
-            normalize=normalize,
-            sort=sort,
-            ascending=ascending,
-            dropna=dropna,
-            bins=bins,
-        )
 
-        gr = df.groupby(keys, sort=isort)
-        left = gr["3rd"].value_counts(**kwargs)
+def test_series_groupby_value_counts_with_grouper():
+    # GH28479
+    df = DataFrame(
+        {
+            "Timestamp": [
+                1565083561,
+                1565083561 + 86400,
+                1565083561 + 86500,
+                1565083561 + 86400 * 2,
+                1565083561 + 86400 * 3,
+                1565083561 + 86500 * 3,
+                1565083561 + 86400 * 4,
+            ],
+            "Food": ["apple", "apple", "banana", "banana", "orange", "orange", "pear"],
+        }
+    ).drop([3])
+
+    df["Datetime"] = to_datetime(df["Timestamp"].apply(lambda t: str(t)), unit="s")
+    dfg = df.groupby(Grouper(freq="1D", key="Datetime"))
 
-        gr = df.groupby(keys, sort=isort)
-        right = gr["3rd"].apply(Series.value_counts, **kwargs)
-        right.index.names = right.index.names[:-1] + ["3rd"]
+    # have to sort on index because of unstable sort on values xref GH9212
+    result = dfg["Food"].value_counts().sort_index()
+    expected = dfg["Food"].apply(Series.value_counts).sort_index()
+    expected.index.names = result.index.names
 
-        # have to sort on index because of unstable sort on values
-        left, right = map(rebuild_index, (left, right))  # xref GH9212
-        tm.assert_series_equal(left.sort_index(), right.sort_index())
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/test_whitelist.py b/pandas/tests/groupby/test_whitelist.py
index 05d745ccc0e8e..8e387e9202ef6 100644
--- a/pandas/tests/groupby/test_whitelist.py
+++ b/pandas/tests/groupby/test_whitelist.py
@@ -9,12 +9,12 @@
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex, Series, date_range
+import pandas._testing as tm
 from pandas.core.groupby.base import (
     groupby_other_methods,
     reduction_kernels,
     transformation_kernels,
 )
-from pandas.util import testing as tm
 
 AGG_FUNCTIONS = [
     "sum",
@@ -236,16 +236,23 @@ def test_groupby_blacklist(df_letters):
 
     blacklist.extend(to_methods)
 
-    # e.g., to_csv
-    defined_but_not_allowed = "(?:^Cannot.+{0!r}.+{1!r}.+try using the 'apply' method$)"
-
-    # e.g., query, eval
-    not_defined = "(?:^{1!r} object has no attribute {0!r}$)"
-    fmt = defined_but_not_allowed + "|" + not_defined
     for bl in blacklist:
         for obj in (df, s):
             gb = obj.groupby(df.letters)
-            msg = fmt.format(bl, type(gb).__name__)
+
+            # e.g., to_csv
+            defined_but_not_allowed = (
+                f"(?:^Cannot.+{repr(bl)}.+'{type(gb).__name__}'.+try "
+                f"using the 'apply' method$)"
+            )
+
+            # e.g., query, eval
+            not_defined = (
+                f"(?:^'{type(gb).__name__}' object has no attribute {repr(bl)}$)"
+            )
+
+            msg = f"{defined_but_not_allowed}|{not_defined}"
+
             with pytest.raises(AttributeError, match=msg):
                 getattr(gb, bl)
 
@@ -397,7 +404,7 @@ def test_all_methods_categorized(mframe):
 
     # new public method?
     if new_names:
-        msg = """
+        msg = f"""
 There are uncatgeorized methods defined on the Grouper class:
 {names}.
 
@@ -411,19 +418,19 @@ def test_all_methods_categorized(mframe):
 see the comments in pandas/core/groupby/base.py for guidance on
 how to fix this test.
         """
-        raise AssertionError(msg.format(names=names))
+        raise AssertionError(msg)
 
     # removed a public method?
     all_categorized = reduction_kernels | transformation_kernels | groupby_other_methods
     print(names)
     print(all_categorized)
     if not (names == all_categorized):
-        msg = """
+        msg = f"""
 Some methods which are supposed to be on the Grouper class
 are missing:
-{names}.
+{all_categorized - names}.
 
 They're still defined in one of the lists that live in pandas/core/groupby/base.py.
 If you removed a method, you should update them
 """
-        raise AssertionError(msg.format(names=all_categorized - names))
+        raise AssertionError(msg)
diff --git a/pandas/tests/sparse/series/__init__.py b/pandas/tests/indexes/base_class/__init__.py
similarity index 100%
rename from pandas/tests/sparse/series/__init__.py
rename to pandas/tests/indexes/base_class/__init__.py
diff --git a/pandas/tests/indexes/base_class/test_constructors.py b/pandas/tests/indexes/base_class/test_constructors.py
new file mode 100644
index 0000000000000..9e6a8f34c135d
--- /dev/null
+++ b/pandas/tests/indexes/base_class/test_constructors.py
@@ -0,0 +1,36 @@
+import pytest
+
+from pandas import Index, MultiIndex
+
+
+class TestIndexConstructor:
+    # Tests for the Index constructor, specifically for cases that do
+    #  not return a subclass
+
+    def test_constructor_corner(self):
+        # corner case
+        msg = (
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            "kind, 0 was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Index(0)
+
+    @pytest.mark.parametrize("index_vals", [[("A", 1), "B"], ["B", ("A", 1)]])
+    def test_construction_list_mixed_tuples(self, index_vals):
+        # see gh-10697: if we are constructing from a mixed list of tuples,
+        # make sure that we are independent of the sorting order.
+        index = Index(index_vals)
+        assert isinstance(index, Index)
+        assert not isinstance(index, MultiIndex)
+
+    def test_constructor_wrong_kwargs(self):
+        # GH #19348
+        with pytest.raises(TypeError, match="Unexpected keyword arguments {'foo'}"):
+            Index([], foo="bar")
+
+    @pytest.mark.xfail(reason="see GH#21311: Index doesn't enforce dtype argument")
+    def test_constructor_cast(self):
+        msg = "could not convert string to float"
+        with pytest.raises(ValueError, match=msg):
+            Index(["a", "b", "c"], dtype=float)
diff --git a/pandas/tests/indexes/base_class/test_setops.py b/pandas/tests/indexes/base_class/test_setops.py
new file mode 100644
index 0000000000000..e7d5e21d0ba47
--- /dev/null
+++ b/pandas/tests/indexes/base_class/test_setops.py
@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+from pandas import Index, Series
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
+
+
+class TestIndexSetOps:
+    def test_union_base(self):
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[3:]
+        second = index[:5]
+
+        result = first.union(second)
+
+        expected = Index([0, 1, 2, "a", "b", "c"])
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [np.array, Series, list])
+    def test_union_different_type_base(self, klass):
+        # GH 10149
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[3:]
+        second = index[:5]
+
+        result = first.union(klass(second.values))
+
+        assert tm.equalContents(result, index)
+
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_intersection_base(self, sort):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:5]
+        second = index[:3]
+
+        expected = Index([0, 1, "a"]) if sort is None else Index([0, "a", 1])
+        result = first.intersection(second, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [np.array, Series, list])
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_intersection_different_type_base(self, klass, sort):
+        # GH 10149
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:5]
+        second = index[:3]
+
+        result = first.intersection(klass(second.values), sort=sort)
+        assert tm.equalContents(result, second)
+
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_difference_base(self, sort):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:4]
+        second = index[3:]
+
+        result = first.difference(second, sort)
+        expected = Index([0, "a", 1])
+        if sort is None:
+            expected = Index(safe_sort(expected))
+        tm.assert_index_equal(result, expected)
+
+    def test_symmetric_difference(self):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:4]
+        second = index[3:]
+
+        result = first.symmetric_difference(second)
+        expected = Index([0, 1, 2, "a", "c"])
+        tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/sparse/common.py b/pandas/tests/indexes/categorical/__init__.py
similarity index 100%
rename from pandas/tests/sparse/common.py
rename to pandas/tests/indexes/categorical/__init__.py
diff --git a/pandas/tests/indexes/test_category.py b/pandas/tests/indexes/categorical/test_category.py
similarity index 54%
rename from pandas/tests/indexes/test_category.py
rename to pandas/tests/indexes/categorical/test_category.py
index 67bf9bd20e716..c18cd1f252c83 100644
--- a/pandas/tests/indexes/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -5,23 +5,22 @@
 
 from pandas._libs import index as libindex
 
-from pandas.core.dtypes.dtypes import CategoricalDtype, ordered_sentinel
+from pandas.core.dtypes.dtypes import CategoricalDtype
 
 import pandas as pd
 from pandas import Categorical, IntervalIndex
+import pandas._testing as tm
 from pandas.core.indexes.api import CategoricalIndex, Index
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
 
-from .common import Base
+from ..common import Base
 
 
 class TestCategoricalIndex(Base):
     _holder = CategoricalIndex
 
-    def setup_method(self, method):
-        self.indices = dict(catIndex=tm.makeCategoricalIndex(100))
-        self.setup_indices()
+    @pytest.fixture
+    def indices(self, request):
+        return tm.makeCategoricalIndex(100)
 
     def create_index(self, categories=None, ordered=False):
         if categories is None:
@@ -33,147 +32,6 @@ def test_can_hold_identifiers(self):
         key = idx[0]
         assert idx._can_hold_identifiers_and_holds_name(key) is True
 
-    def test_construction(self):
-
-        ci = self.create_index(categories=list("abcd"))
-        categories = ci.categories
-
-        result = Index(ci)
-        tm.assert_index_equal(result, ci, exact=True)
-        assert not result.ordered
-
-        result = Index(ci.values)
-        tm.assert_index_equal(result, ci, exact=True)
-        assert not result.ordered
-
-        # empty
-        result = CategoricalIndex(categories=categories)
-        tm.assert_index_equal(result.categories, Index(categories))
-        tm.assert_numpy_array_equal(result.codes, np.array([], dtype="int8"))
-        assert not result.ordered
-
-        # passing categories
-        result = CategoricalIndex(list("aabbca"), categories=categories)
-        tm.assert_index_equal(result.categories, Index(categories))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
-        )
-
-        c = pd.Categorical(list("aabbca"))
-        result = CategoricalIndex(c)
-        tm.assert_index_equal(result.categories, Index(list("abc")))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
-        )
-        assert not result.ordered
-
-        result = CategoricalIndex(c, categories=categories)
-        tm.assert_index_equal(result.categories, Index(categories))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
-        )
-        assert not result.ordered
-
-        ci = CategoricalIndex(c, categories=list("abcd"))
-        result = CategoricalIndex(ci)
-        tm.assert_index_equal(result.categories, Index(categories))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
-        )
-        assert not result.ordered
-
-        result = CategoricalIndex(ci, categories=list("ab"))
-        tm.assert_index_equal(result.categories, Index(list("ab")))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, -1, 0], dtype="int8")
-        )
-        assert not result.ordered
-
-        result = CategoricalIndex(ci, categories=list("ab"), ordered=True)
-        tm.assert_index_equal(result.categories, Index(list("ab")))
-        tm.assert_numpy_array_equal(
-            result.codes, np.array([0, 0, 1, 1, -1, 0], dtype="int8")
-        )
-        assert result.ordered
-
-        result = pd.CategoricalIndex(ci, categories=list("ab"), ordered=True)
-        expected = pd.CategoricalIndex(
-            ci, categories=list("ab"), ordered=True, dtype="category"
-        )
-        tm.assert_index_equal(result, expected, exact=True)
-
-        # turn me to an Index
-        result = Index(np.array(ci))
-        assert isinstance(result, Index)
-        assert not isinstance(result, CategoricalIndex)
-
-    def test_construction_with_dtype(self):
-
-        # specify dtype
-        ci = self.create_index(categories=list("abc"))
-
-        result = Index(np.array(ci), dtype="category")
-        tm.assert_index_equal(result, ci, exact=True)
-
-        result = Index(np.array(ci).tolist(), dtype="category")
-        tm.assert_index_equal(result, ci, exact=True)
-
-        # these are generally only equal when the categories are reordered
-        ci = self.create_index()
-
-        result = Index(np.array(ci), dtype="category").reorder_categories(ci.categories)
-        tm.assert_index_equal(result, ci, exact=True)
-
-        # make sure indexes are handled
-        expected = CategoricalIndex([0, 1, 2], categories=[0, 1, 2], ordered=True)
-        idx = Index(range(3))
-        result = CategoricalIndex(idx, categories=idx, ordered=True)
-        tm.assert_index_equal(result, expected, exact=True)
-
-    def test_construction_empty_with_bool_categories(self):
-        # see gh-22702
-        cat = pd.CategoricalIndex([], categories=[True, False])
-        categories = sorted(cat.categories.tolist())
-        assert categories == [False, True]
-
-    def test_construction_with_categorical_dtype(self):
-        # construction with CategoricalDtype
-        # GH18109
-        data, cats, ordered = "a a b b".split(), "c b a".split(), True
-        dtype = CategoricalDtype(categories=cats, ordered=ordered)
-
-        result = CategoricalIndex(data, dtype=dtype)
-        expected = CategoricalIndex(data, categories=cats, ordered=ordered)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        # GH 19032
-        result = Index(data, dtype=dtype)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        # error when combining categories/ordered and dtype kwargs
-        msg = "Cannot specify `categories` or `ordered` together with `dtype`."
-        with pytest.raises(ValueError, match=msg):
-            CategoricalIndex(data, categories=cats, dtype=dtype)
-
-        with pytest.raises(ValueError, match=msg):
-            Index(data, categories=cats, dtype=dtype)
-
-        with pytest.raises(ValueError, match=msg):
-            CategoricalIndex(data, ordered=ordered, dtype=dtype)
-
-        with pytest.raises(ValueError, match=msg):
-            Index(data, ordered=ordered, dtype=dtype)
-
-    def test_create_categorical(self):
-        # https://github.com/pandas-dev/pandas/pull/17513
-        # The public CI constructor doesn't hit this code path with
-        # instances of CategoricalIndex, but we still want to test the code
-        ci = CategoricalIndex(["a", "b", "c"])
-        # First ci is self, second ci is data.
-        result = CategoricalIndex._create_categorical(ci, ci)
-        expected = Categorical(["a", "b", "c"])
-        tm.assert_categorical_equal(result, expected)
-
     @pytest.mark.parametrize(
         "func,op_name",
         [
@@ -185,12 +43,12 @@ def test_create_categorical(self):
             (lambda idx: ["a", "b"] + idx, "__radd__"),
         ],
     )
-    def test_disallow_set_ops(self, func, op_name):
+    def test_disallow_addsub_ops(self, func, op_name):
         # GH 10039
         # set ops (+/-) raise TypeError
         idx = pd.Index(pd.Categorical(["a", "b"]))
-        msg = "cannot perform {} with this index type: CategoricalIndex"
-        with pytest.raises(TypeError, match=msg.format(op_name)):
+        msg = f"cannot perform {op_name} with this index type: CategoricalIndex"
+        with pytest.raises(TypeError, match=msg):
             func(idx)
 
     def test_method_delegation(self):
@@ -288,76 +146,6 @@ def test_contains_list(self):
         with pytest.raises(TypeError, match="unhashable type"):
             ["a", "b"] in idx
 
-    def test_map(self):
-        ci = pd.CategoricalIndex(list("ABABC"), categories=list("CBA"), ordered=True)
-        result = ci.map(lambda x: x.lower())
-        exp = pd.CategoricalIndex(list("ababc"), categories=list("cba"), ordered=True)
-        tm.assert_index_equal(result, exp)
-
-        ci = pd.CategoricalIndex(
-            list("ABABC"), categories=list("BAC"), ordered=False, name="XXX"
-        )
-        result = ci.map(lambda x: x.lower())
-        exp = pd.CategoricalIndex(
-            list("ababc"), categories=list("bac"), ordered=False, name="XXX"
-        )
-        tm.assert_index_equal(result, exp)
-
-        # GH 12766: Return an index not an array
-        tm.assert_index_equal(
-            ci.map(lambda x: 1), Index(np.array([1] * 5, dtype=np.int64), name="XXX")
-        )
-
-        # change categories dtype
-        ci = pd.CategoricalIndex(list("ABABC"), categories=list("BAC"), ordered=False)
-
-        def f(x):
-            return {"A": 10, "B": 20, "C": 30}.get(x)
-
-        result = ci.map(f)
-        exp = pd.CategoricalIndex(
-            [10, 20, 10, 20, 30], categories=[20, 10, 30], ordered=False
-        )
-        tm.assert_index_equal(result, exp)
-
-        result = ci.map(pd.Series([10, 20, 30], index=["A", "B", "C"]))
-        tm.assert_index_equal(result, exp)
-
-        result = ci.map({"A": 10, "B": 20, "C": 30})
-        tm.assert_index_equal(result, exp)
-
-    def test_map_with_categorical_series(self):
-        # GH 12756
-        a = pd.Index([1, 2, 3, 4])
-        b = pd.Series(["even", "odd", "even", "odd"], dtype="category")
-        c = pd.Series(["even", "odd", "even", "odd"])
-
-        exp = CategoricalIndex(["odd", "even", "odd", np.nan])
-        tm.assert_index_equal(a.map(b), exp)
-        exp = pd.Index(["odd", "even", "odd", np.nan])
-        tm.assert_index_equal(a.map(c), exp)
-
-    @pytest.mark.parametrize(
-        ("data", "f"),
-        (
-            ([1, 1, np.nan], pd.isna),
-            ([1, 2, np.nan], pd.isna),
-            ([1, 1, np.nan], {1: False}),
-            ([1, 2, np.nan], {1: False, 2: False}),
-            ([1, 1, np.nan], pd.Series([False, False])),
-            ([1, 2, np.nan], pd.Series([False, False, False])),
-        ),
-    )
-    def test_map_with_nan(self, data, f):  # GH 24241
-        values = pd.Categorical(data)
-        result = values.map(f)
-        if data[1] == 1:
-            expected = pd.Categorical([False, False, np.nan])
-            tm.assert_categorical_equal(result, expected)
-        else:
-            expected = pd.Index([False, False, np.nan])
-            tm.assert_index_equal(result, expected)
-
     @pytest.mark.parametrize("klass", [list, tuple, np.array, pd.Series])
     def test_where(self, klass):
         i = self.create_index()
@@ -440,8 +228,8 @@ def test_insert(self):
 
         # invalid
         msg = (
-            "cannot insert an item into a CategoricalIndex that is not"
-            " already an existing category"
+            "cannot insert an item into a CategoricalIndex that is not "
+            "already an existing category"
         )
         with pytest.raises(TypeError, match=msg):
             ci.insert(0, "d")
@@ -526,96 +314,6 @@ def test_astype_category(self, name, dtype_ordered, index_ordered):
             expected = index
             tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "none, warning", [(None, None), (ordered_sentinel, FutureWarning)]
-    )
-    def test_astype_category_ordered_none_deprecated(self, none, warning):
-        # GH 26336: only warn if None is not explicitly passed
-        cdt1 = CategoricalDtype(categories=list("cdab"), ordered=True)
-        cdt2 = CategoricalDtype(categories=list("cedafb"), ordered=none)
-        idx = CategoricalIndex(list("abcdaba"), dtype=cdt1)
-        with tm.assert_produces_warning(warning):
-            idx.astype(cdt2)
-
-    def test_reindex_base(self):
-        # Determined by cat ordering.
-        idx = CategoricalIndex(list("cab"), categories=list("cab"))
-        expected = np.arange(len(idx), dtype=np.intp)
-
-        actual = idx.get_indexer(idx)
-        tm.assert_numpy_array_equal(expected, actual)
-
-        with pytest.raises(ValueError, match="Invalid fill method"):
-            idx.get_indexer(idx, method="invalid")
-
-    def test_reindexing(self):
-        np.random.seed(123456789)
-
-        ci = self.create_index()
-        oidx = Index(np.array(ci))
-
-        for n in [1, 2, 5, len(ci)]:
-            finder = oidx[np.random.randint(0, len(ci), size=n)]
-            expected = oidx.get_indexer_non_unique(finder)[0]
-
-            actual = ci.get_indexer(finder)
-            tm.assert_numpy_array_equal(expected, actual)
-
-        # see gh-17323
-        #
-        # Even when indexer is equal to the
-        # members in the index, we should
-        # respect duplicates instead of taking
-        # the fast-track path.
-        for finder in [list("aabbca"), list("aababca")]:
-            expected = oidx.get_indexer_non_unique(finder)[0]
-
-            actual = ci.get_indexer(finder)
-            tm.assert_numpy_array_equal(expected, actual)
-
-    def test_reindex_dtype(self):
-        c = CategoricalIndex(["a", "b", "c", "a"])
-        res, indexer = c.reindex(["a", "c"])
-        tm.assert_index_equal(res, Index(["a", "a", "c"]), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
-
-        c = CategoricalIndex(["a", "b", "c", "a"])
-        res, indexer = c.reindex(Categorical(["a", "c"]))
-
-        exp = CategoricalIndex(["a", "a", "c"], categories=["a", "c"])
-        tm.assert_index_equal(res, exp, exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
-
-        c = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
-        res, indexer = c.reindex(["a", "c"])
-        exp = Index(["a", "a", "c"], dtype="object")
-        tm.assert_index_equal(res, exp, exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
-
-        c = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
-        res, indexer = c.reindex(Categorical(["a", "c"]))
-        exp = CategoricalIndex(["a", "a", "c"], categories=["a", "c"])
-        tm.assert_index_equal(res, exp, exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
-
-    def test_reindex_duplicate_target(self):
-        # See GH23963
-        c = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
-        with pytest.raises(ValueError, match="non-unique indexer"):
-            c.reindex(["a", "a", "c"])
-
-        with pytest.raises(ValueError, match="non-unique indexer"):
-            c.reindex(
-                CategoricalIndex(["a", "a", "c"], categories=["a", "b", "c", "d"])
-            )
-
-    def test_reindex_empty_index(self):
-        # See GH16770
-        c = CategoricalIndex([])
-        res, indexer = c.reindex(["a", "b"])
-        tm.assert_index_equal(res, Index(["a", "b"]), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([-1, -1], dtype=np.intp))
-
     @pytest.mark.parametrize(
         "data, non_lexsorted_data",
         [[[1, 2, 3], [9, 0, 1, 2, 3]], [list("abc"), list("fabcd")]],
@@ -667,75 +365,6 @@ def test_drop_duplicates(self):
         tm.assert_index_equal(idx.drop_duplicates(), expected)
         tm.assert_index_equal(idx.unique(), expected)
 
-    def test_get_indexer(self):
-
-        idx1 = CategoricalIndex(list("aabcde"), categories=list("edabc"))
-        idx2 = CategoricalIndex(list("abf"))
-
-        for indexer in [idx2, list("abf"), Index(list("abf"))]:
-            r1 = idx1.get_indexer(idx2)
-            assert_almost_equal(r1, np.array([0, 1, 2, -1], dtype=np.intp))
-
-        msg = (
-            "method='pad' and method='backfill' not implemented yet for"
-            " CategoricalIndex"
-        )
-        with pytest.raises(NotImplementedError, match=msg):
-            idx2.get_indexer(idx1, method="pad")
-        with pytest.raises(NotImplementedError, match=msg):
-            idx2.get_indexer(idx1, method="backfill")
-
-        msg = "method='nearest' not implemented yet for CategoricalIndex"
-        with pytest.raises(NotImplementedError, match=msg):
-            idx2.get_indexer(idx1, method="nearest")
-
-    def test_get_loc(self):
-        # GH 12531
-        cidx1 = CategoricalIndex(list("abcde"), categories=list("edabc"))
-        idx1 = Index(list("abcde"))
-        assert cidx1.get_loc("a") == idx1.get_loc("a")
-        assert cidx1.get_loc("e") == idx1.get_loc("e")
-
-        for i in [cidx1, idx1]:
-            with pytest.raises(KeyError, match="'NOT-EXIST'"):
-                i.get_loc("NOT-EXIST")
-
-        # non-unique
-        cidx2 = CategoricalIndex(list("aacded"), categories=list("edabc"))
-        idx2 = Index(list("aacded"))
-
-        # results in bool array
-        res = cidx2.get_loc("d")
-        tm.assert_numpy_array_equal(res, idx2.get_loc("d"))
-        tm.assert_numpy_array_equal(
-            res, np.array([False, False, False, True, False, True])
-        )
-        # unique element results in scalar
-        res = cidx2.get_loc("e")
-        assert res == idx2.get_loc("e")
-        assert res == 4
-
-        for i in [cidx2, idx2]:
-            with pytest.raises(KeyError, match="'NOT-EXIST'"):
-                i.get_loc("NOT-EXIST")
-
-        # non-unique, sliceable
-        cidx3 = CategoricalIndex(list("aabbb"), categories=list("abc"))
-        idx3 = Index(list("aabbb"))
-
-        # results in slice
-        res = cidx3.get_loc("a")
-        assert res == idx3.get_loc("a")
-        assert res == slice(0, 2, None)
-
-        res = cidx3.get_loc("b")
-        assert res == idx3.get_loc("b")
-        assert res == slice(2, 5, None)
-
-        for i in [cidx3, idx3]:
-            with pytest.raises(KeyError, match="'c'"):
-                i.get_loc("c")
-
     def test_repr_roundtrip(self):
 
         ci = CategoricalIndex(["a", "b"], categories=["a", "b"], ordered=True)
@@ -780,21 +409,22 @@ def test_identical(self):
         assert ci1.identical(ci1.copy())
         assert not ci1.identical(ci2)
 
-    def test_ensure_copied_data(self):
+    def test_ensure_copied_data(self, indices):
         # gh-12309: Check the "copy" argument of each
         # Index.__new__ is honored.
         #
         # Must be tested separately from other indexes because
-        # self.value is not an ndarray.
-        _base = lambda ar: ar if ar.base is None else ar.base
+        # self.values is not an ndarray.
+        # GH#29918 Index.base has been removed
+        # FIXME: is this test still meaningful?
+        _base = lambda ar: ar if getattr(ar, "base", None) is None else ar.base
 
-        for index in self.indices.values():
-            result = CategoricalIndex(index.values, copy=True)
-            tm.assert_index_equal(index, result)
-            assert _base(index.values) is not _base(result.values)
+        result = CategoricalIndex(indices.values, copy=True)
+        tm.assert_index_equal(indices, result)
+        assert _base(indices.values) is not _base(result.values)
 
-            result = CategoricalIndex(index.values, copy=False)
-            assert _base(index.values) is _base(result.values)
+        result = CategoricalIndex(indices.values, copy=False)
+        assert _base(indices.values) is _base(result.values)
 
     def test_equals_categorical(self):
         ci1 = CategoricalIndex(["a", "b"], categories=["a", "b"], ordered=True)
@@ -821,8 +451,8 @@ def test_equals_categorical(self):
             ci1 == Index(["a", "b", "c"])
 
         msg = (
-            "categorical index comparisons must have the same categories"
-            " and ordered attributes"
+            "categorical index comparisons must have the same categories "
+            "and ordered attributes"
             "|"
             "Categoricals can only be compared if 'categories' are the same. "
             "Categories are different lengths"
@@ -985,122 +615,6 @@ def test_fillna_categorical(self):
         with pytest.raises(ValueError, match=msg):
             idx.fillna(2.0)
 
-    def test_take_fill_value(self):
-        # GH 12631
-
-        # numeric category
-        idx = pd.CategoricalIndex([1, 2, 3], name="xxx")
-        result = idx.take(np.array([1, 0, -1]))
-        expected = pd.CategoricalIndex([2, 1, 3], name="xxx")
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        # fill_value
-        result = idx.take(np.array([1, 0, -1]), fill_value=True)
-        expected = pd.CategoricalIndex([2, 1, np.nan], categories=[1, 2, 3], name="xxx")
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        # allow_fill=False
-        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = pd.CategoricalIndex([2, 1, 3], name="xxx")
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        # object category
-        idx = pd.CategoricalIndex(
-            list("CBA"), categories=list("ABC"), ordered=True, name="xxx"
-        )
-        result = idx.take(np.array([1, 0, -1]))
-        expected = pd.CategoricalIndex(
-            list("BCA"), categories=list("ABC"), ordered=True, name="xxx"
-        )
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        # fill_value
-        result = idx.take(np.array([1, 0, -1]), fill_value=True)
-        expected = pd.CategoricalIndex(
-            ["B", "C", np.nan], categories=list("ABC"), ordered=True, name="xxx"
-        )
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        # allow_fill=False
-        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = pd.CategoricalIndex(
-            list("BCA"), categories=list("ABC"), ordered=True, name="xxx"
-        )
-        tm.assert_index_equal(result, expected)
-        tm.assert_categorical_equal(result.values, expected.values)
-
-        msg = (
-            "When allow_fill=True and fill_value is not None, "
-            "all indices must be >= -1"
-        )
-        with pytest.raises(ValueError, match=msg):
-            idx.take(np.array([1, 0, -2]), fill_value=True)
-        with pytest.raises(ValueError, match=msg):
-            idx.take(np.array([1, 0, -5]), fill_value=True)
-
-        with pytest.raises(IndexError):
-            idx.take(np.array([1, -5]))
-
-    def test_take_fill_value_datetime(self):
-
-        # datetime category
-        idx = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"], name="xxx")
-        idx = pd.CategoricalIndex(idx)
-        result = idx.take(np.array([1, 0, -1]))
-        expected = pd.DatetimeIndex(
-            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx"
-        )
-        expected = pd.CategoricalIndex(expected)
-        tm.assert_index_equal(result, expected)
-
-        # fill_value
-        result = idx.take(np.array([1, 0, -1]), fill_value=True)
-        expected = pd.DatetimeIndex(["2011-02-01", "2011-01-01", "NaT"], name="xxx")
-        exp_cats = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
-        expected = pd.CategoricalIndex(expected, categories=exp_cats)
-        tm.assert_index_equal(result, expected)
-
-        # allow_fill=False
-        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = pd.DatetimeIndex(
-            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx"
-        )
-        expected = pd.CategoricalIndex(expected)
-        tm.assert_index_equal(result, expected)
-
-        msg = (
-            "When allow_fill=True and fill_value is not None, "
-            "all indices must be >= -1"
-        )
-        with pytest.raises(ValueError, match=msg):
-            idx.take(np.array([1, 0, -2]), fill_value=True)
-        with pytest.raises(ValueError, match=msg):
-            idx.take(np.array([1, 0, -5]), fill_value=True)
-
-        with pytest.raises(IndexError):
-            idx.take(np.array([1, -5]))
-
-    def test_take_invalid_kwargs(self):
-        idx = pd.CategoricalIndex([1, 2, 3], name="foo")
-        indices = [1, 0, -1]
-
-        msg = r"take\(\) got an unexpected keyword argument 'foo'"
-        with pytest.raises(TypeError, match=msg):
-            idx.take(indices, foo=2)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            idx.take(indices, out=indices)
-
-        msg = "the 'mode' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            idx.take(indices, mode="clip")
-
     @pytest.mark.parametrize(
         "dtype, engine_type",
         [
@@ -1123,3 +637,11 @@ def test_engine_type(self, dtype, engine_type):
             ci.values._codes = ci.values._codes.astype("int64")
         assert np.issubdtype(ci.codes.dtype, dtype)
         assert isinstance(ci._engine, engine_type)
+
+    def test_reindex_base(self):
+        # See test_reindex.py
+        pass
+
+    def test_map_str(self):
+        # See test_map.py
+        pass
diff --git a/pandas/tests/indexes/categorical/test_constructors.py b/pandas/tests/indexes/categorical/test_constructors.py
new file mode 100644
index 0000000000000..1df0874e2f947
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_constructors.py
@@ -0,0 +1,147 @@
+import numpy as np
+import pytest
+
+from pandas import Categorical, CategoricalDtype, CategoricalIndex, Index
+import pandas._testing as tm
+
+
+class TestCategoricalIndexConstructors:
+    def test_construction(self):
+
+        ci = CategoricalIndex(list("aabbca"), categories=list("abcd"), ordered=False)
+        categories = ci.categories
+
+        result = Index(ci)
+        tm.assert_index_equal(result, ci, exact=True)
+        assert not result.ordered
+
+        result = Index(ci.values)
+        tm.assert_index_equal(result, ci, exact=True)
+        assert not result.ordered
+
+        # empty
+        result = CategoricalIndex(categories=categories)
+        tm.assert_index_equal(result.categories, Index(categories))
+        tm.assert_numpy_array_equal(result.codes, np.array([], dtype="int8"))
+        assert not result.ordered
+
+        # passing categories
+        result = CategoricalIndex(list("aabbca"), categories=categories)
+        tm.assert_index_equal(result.categories, Index(categories))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
+        )
+
+        c = Categorical(list("aabbca"))
+        result = CategoricalIndex(c)
+        tm.assert_index_equal(result.categories, Index(list("abc")))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
+        )
+        assert not result.ordered
+
+        result = CategoricalIndex(c, categories=categories)
+        tm.assert_index_equal(result.categories, Index(categories))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
+        )
+        assert not result.ordered
+
+        ci = CategoricalIndex(c, categories=list("abcd"))
+        result = CategoricalIndex(ci)
+        tm.assert_index_equal(result.categories, Index(categories))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, 2, 0], dtype="int8")
+        )
+        assert not result.ordered
+
+        result = CategoricalIndex(ci, categories=list("ab"))
+        tm.assert_index_equal(result.categories, Index(list("ab")))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, -1, 0], dtype="int8")
+        )
+        assert not result.ordered
+
+        result = CategoricalIndex(ci, categories=list("ab"), ordered=True)
+        tm.assert_index_equal(result.categories, Index(list("ab")))
+        tm.assert_numpy_array_equal(
+            result.codes, np.array([0, 0, 1, 1, -1, 0], dtype="int8")
+        )
+        assert result.ordered
+
+        result = CategoricalIndex(ci, categories=list("ab"), ordered=True)
+        expected = CategoricalIndex(
+            ci, categories=list("ab"), ordered=True, dtype="category"
+        )
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # turn me to an Index
+        result = Index(np.array(ci))
+        assert isinstance(result, Index)
+        assert not isinstance(result, CategoricalIndex)
+
+    def test_construction_with_dtype(self):
+
+        # specify dtype
+        ci = CategoricalIndex(list("aabbca"), categories=list("abc"), ordered=False)
+
+        result = Index(np.array(ci), dtype="category")
+        tm.assert_index_equal(result, ci, exact=True)
+
+        result = Index(np.array(ci).tolist(), dtype="category")
+        tm.assert_index_equal(result, ci, exact=True)
+
+        # these are generally only equal when the categories are reordered
+        ci = CategoricalIndex(list("aabbca"), categories=list("cab"), ordered=False)
+
+        result = Index(np.array(ci), dtype="category").reorder_categories(ci.categories)
+        tm.assert_index_equal(result, ci, exact=True)
+
+        # make sure indexes are handled
+        expected = CategoricalIndex([0, 1, 2], categories=[0, 1, 2], ordered=True)
+        idx = Index(range(3))
+        result = CategoricalIndex(idx, categories=idx, ordered=True)
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_construction_empty_with_bool_categories(self):
+        # see GH#22702
+        cat = CategoricalIndex([], categories=[True, False])
+        categories = sorted(cat.categories.tolist())
+        assert categories == [False, True]
+
+    def test_construction_with_categorical_dtype(self):
+        # construction with CategoricalDtype
+        # GH#18109
+        data, cats, ordered = "a a b b".split(), "c b a".split(), True
+        dtype = CategoricalDtype(categories=cats, ordered=ordered)
+
+        result = CategoricalIndex(data, dtype=dtype)
+        expected = CategoricalIndex(data, categories=cats, ordered=ordered)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # GH#19032
+        result = Index(data, dtype=dtype)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # error when combining categories/ordered and dtype kwargs
+        msg = "Cannot specify `categories` or `ordered` together with `dtype`."
+        with pytest.raises(ValueError, match=msg):
+            CategoricalIndex(data, categories=cats, dtype=dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            Index(data, categories=cats, dtype=dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            CategoricalIndex(data, ordered=ordered, dtype=dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            Index(data, ordered=ordered, dtype=dtype)
+
+    def test_create_categorical(self):
+        # GH#17513 The public CI constructor doesn't hit this code path with
+        # instances of CategoricalIndex, but we still want to test the code
+        ci = CategoricalIndex(["a", "b", "c"])
+        # First ci is self, second ci is data.
+        result = CategoricalIndex._create_categorical(ci, ci)
+        expected = Categorical(["a", "b", "c"])
+        tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/indexes/categorical/test_indexing.py b/pandas/tests/indexes/categorical/test_indexing.py
new file mode 100644
index 0000000000000..507e38d9acac2
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_indexing.py
@@ -0,0 +1,250 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import CategoricalIndex, Index
+import pandas._testing as tm
+
+
+class TestTake:
+    def test_take_fill_value(self):
+        # GH 12631
+
+        # numeric category
+        idx = pd.CategoricalIndex([1, 2, 3], name="xxx")
+        result = idx.take(np.array([1, 0, -1]))
+        expected = pd.CategoricalIndex([2, 1, 3], name="xxx")
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = pd.CategoricalIndex([2, 1, np.nan], categories=[1, 2, 3], name="xxx")
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = pd.CategoricalIndex([2, 1, 3], name="xxx")
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        # object category
+        idx = pd.CategoricalIndex(
+            list("CBA"), categories=list("ABC"), ordered=True, name="xxx"
+        )
+        result = idx.take(np.array([1, 0, -1]))
+        expected = pd.CategoricalIndex(
+            list("BCA"), categories=list("ABC"), ordered=True, name="xxx"
+        )
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = pd.CategoricalIndex(
+            ["B", "C", np.nan], categories=list("ABC"), ordered=True, name="xxx"
+        )
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = pd.CategoricalIndex(
+            list("BCA"), categories=list("ABC"), ordered=True, name="xxx"
+        )
+        tm.assert_index_equal(result, expected)
+        tm.assert_categorical_equal(result.values, expected.values)
+
+        msg = (
+            "When allow_fill=True and fill_value is not None, "
+            "all indices must be >= -1"
+        )
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        with pytest.raises(IndexError):
+            idx.take(np.array([1, -5]))
+
+    def test_take_fill_value_datetime(self):
+
+        # datetime category
+        idx = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"], name="xxx")
+        idx = pd.CategoricalIndex(idx)
+        result = idx.take(np.array([1, 0, -1]))
+        expected = pd.DatetimeIndex(
+            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx"
+        )
+        expected = pd.CategoricalIndex(expected)
+        tm.assert_index_equal(result, expected)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = pd.DatetimeIndex(["2011-02-01", "2011-01-01", "NaT"], name="xxx")
+        exp_cats = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
+        expected = pd.CategoricalIndex(expected, categories=exp_cats)
+        tm.assert_index_equal(result, expected)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = pd.DatetimeIndex(
+            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx"
+        )
+        expected = pd.CategoricalIndex(expected)
+        tm.assert_index_equal(result, expected)
+
+        msg = (
+            "When allow_fill=True and fill_value is not None, "
+            "all indices must be >= -1"
+        )
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        with pytest.raises(IndexError):
+            idx.take(np.array([1, -5]))
+
+    def test_take_invalid_kwargs(self):
+        idx = pd.CategoricalIndex([1, 2, 3], name="foo")
+        indices = [1, 0, -1]
+
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            idx.take(indices, foo=2)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(indices, out=indices)
+
+        msg = "the 'mode' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(indices, mode="clip")
+
+
+class TestGetLoc:
+    def test_get_loc(self):
+        # GH 12531
+        cidx1 = CategoricalIndex(list("abcde"), categories=list("edabc"))
+        idx1 = Index(list("abcde"))
+        assert cidx1.get_loc("a") == idx1.get_loc("a")
+        assert cidx1.get_loc("e") == idx1.get_loc("e")
+
+        for i in [cidx1, idx1]:
+            with pytest.raises(KeyError, match="'NOT-EXIST'"):
+                i.get_loc("NOT-EXIST")
+
+        # non-unique
+        cidx2 = CategoricalIndex(list("aacded"), categories=list("edabc"))
+        idx2 = Index(list("aacded"))
+
+        # results in bool array
+        res = cidx2.get_loc("d")
+        tm.assert_numpy_array_equal(res, idx2.get_loc("d"))
+        tm.assert_numpy_array_equal(
+            res, np.array([False, False, False, True, False, True])
+        )
+        # unique element results in scalar
+        res = cidx2.get_loc("e")
+        assert res == idx2.get_loc("e")
+        assert res == 4
+
+        for i in [cidx2, idx2]:
+            with pytest.raises(KeyError, match="'NOT-EXIST'"):
+                i.get_loc("NOT-EXIST")
+
+        # non-unique, sliceable
+        cidx3 = CategoricalIndex(list("aabbb"), categories=list("abc"))
+        idx3 = Index(list("aabbb"))
+
+        # results in slice
+        res = cidx3.get_loc("a")
+        assert res == idx3.get_loc("a")
+        assert res == slice(0, 2, None)
+
+        res = cidx3.get_loc("b")
+        assert res == idx3.get_loc("b")
+        assert res == slice(2, 5, None)
+
+        for i in [cidx3, idx3]:
+            with pytest.raises(KeyError, match="'c'"):
+                i.get_loc("c")
+
+    def test_get_loc_unique(self):
+        cidx = pd.CategoricalIndex(list("abc"))
+        result = cidx.get_loc("b")
+        assert result == 1
+
+    def test_get_loc_monotonic_nonunique(self):
+        cidx = pd.CategoricalIndex(list("abbc"))
+        result = cidx.get_loc("b")
+        expected = slice(1, 3, None)
+        assert result == expected
+
+    def test_get_loc_nonmonotonic_nonunique(self):
+        cidx = pd.CategoricalIndex(list("abcb"))
+        result = cidx.get_loc("b")
+        expected = np.array([False, True, False, True], dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestGetIndexer:
+    def test_get_indexer_base(self):
+        # Determined by cat ordering.
+        idx = CategoricalIndex(list("cab"), categories=list("cab"))
+        expected = np.arange(len(idx), dtype=np.intp)
+
+        actual = idx.get_indexer(idx)
+        tm.assert_numpy_array_equal(expected, actual)
+
+        with pytest.raises(ValueError, match="Invalid fill method"):
+            idx.get_indexer(idx, method="invalid")
+
+    def test_get_indexer_non_unique(self):
+        np.random.seed(123456789)
+
+        ci = CategoricalIndex(list("aabbca"), categories=list("cab"), ordered=False)
+        oidx = Index(np.array(ci))
+
+        for n in [1, 2, 5, len(ci)]:
+            finder = oidx[np.random.randint(0, len(ci), size=n)]
+            expected = oidx.get_indexer_non_unique(finder)[0]
+
+            actual = ci.get_indexer(finder)
+            tm.assert_numpy_array_equal(expected, actual)
+
+        # see gh-17323
+        #
+        # Even when indexer is equal to the
+        # members in the index, we should
+        # respect duplicates instead of taking
+        # the fast-track path.
+        for finder in [list("aabbca"), list("aababca")]:
+            expected = oidx.get_indexer_non_unique(finder)[0]
+
+            actual = ci.get_indexer(finder)
+            tm.assert_numpy_array_equal(expected, actual)
+
+    def test_get_indexer(self):
+
+        idx1 = CategoricalIndex(list("aabcde"), categories=list("edabc"))
+        idx2 = CategoricalIndex(list("abf"))
+
+        for indexer in [idx2, list("abf"), Index(list("abf"))]:
+            r1 = idx1.get_indexer(idx2)
+            tm.assert_almost_equal(r1, np.array([0, 1, 2, -1], dtype=np.intp))
+
+        msg = (
+            "method='pad' and method='backfill' not implemented yet for "
+            "CategoricalIndex"
+        )
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method="pad")
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method="backfill")
+
+        msg = "method='nearest' not implemented yet for CategoricalIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method="nearest")
diff --git a/pandas/tests/indexes/categorical/test_map.py b/pandas/tests/indexes/categorical/test_map.py
new file mode 100644
index 0000000000000..943359a72e971
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_map.py
@@ -0,0 +1,95 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import CategoricalIndex, Index
+import pandas._testing as tm
+
+
+class TestMap:
+    @pytest.mark.parametrize(
+        "data, categories",
+        [
+            (list("abcbca"), list("cab")),
+            (pd.interval_range(0, 3).repeat(3), pd.interval_range(0, 3)),
+        ],
+        ids=["string", "interval"],
+    )
+    def test_map_str(self, data, categories, ordered_fixture):
+        # GH 31202 - override base class since we want to maintain categorical/ordered
+        index = CategoricalIndex(data, categories=categories, ordered=ordered_fixture)
+        result = index.map(str)
+        expected = CategoricalIndex(
+            map(str, data), categories=map(str, categories), ordered=ordered_fixture
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_map(self):
+        ci = pd.CategoricalIndex(list("ABABC"), categories=list("CBA"), ordered=True)
+        result = ci.map(lambda x: x.lower())
+        exp = pd.CategoricalIndex(list("ababc"), categories=list("cba"), ordered=True)
+        tm.assert_index_equal(result, exp)
+
+        ci = pd.CategoricalIndex(
+            list("ABABC"), categories=list("BAC"), ordered=False, name="XXX"
+        )
+        result = ci.map(lambda x: x.lower())
+        exp = pd.CategoricalIndex(
+            list("ababc"), categories=list("bac"), ordered=False, name="XXX"
+        )
+        tm.assert_index_equal(result, exp)
+
+        # GH 12766: Return an index not an array
+        tm.assert_index_equal(
+            ci.map(lambda x: 1), Index(np.array([1] * 5, dtype=np.int64), name="XXX")
+        )
+
+        # change categories dtype
+        ci = pd.CategoricalIndex(list("ABABC"), categories=list("BAC"), ordered=False)
+
+        def f(x):
+            return {"A": 10, "B": 20, "C": 30}.get(x)
+
+        result = ci.map(f)
+        exp = pd.CategoricalIndex(
+            [10, 20, 10, 20, 30], categories=[20, 10, 30], ordered=False
+        )
+        tm.assert_index_equal(result, exp)
+
+        result = ci.map(pd.Series([10, 20, 30], index=["A", "B", "C"]))
+        tm.assert_index_equal(result, exp)
+
+        result = ci.map({"A": 10, "B": 20, "C": 30})
+        tm.assert_index_equal(result, exp)
+
+    def test_map_with_categorical_series(self):
+        # GH 12756
+        a = pd.Index([1, 2, 3, 4])
+        b = pd.Series(["even", "odd", "even", "odd"], dtype="category")
+        c = pd.Series(["even", "odd", "even", "odd"])
+
+        exp = CategoricalIndex(["odd", "even", "odd", np.nan])
+        tm.assert_index_equal(a.map(b), exp)
+        exp = pd.Index(["odd", "even", "odd", np.nan])
+        tm.assert_index_equal(a.map(c), exp)
+
+    @pytest.mark.parametrize(
+        ("data", "f"),
+        (
+            ([1, 1, np.nan], pd.isna),
+            ([1, 2, np.nan], pd.isna),
+            ([1, 1, np.nan], {1: False}),
+            ([1, 2, np.nan], {1: False, 2: False}),
+            ([1, 1, np.nan], pd.Series([False, False])),
+            ([1, 2, np.nan], pd.Series([False, False, False])),
+        ),
+    )
+    def test_map_with_nan(self, data, f):  # GH 24241
+        values = pd.Categorical(data)
+        result = values.map(f)
+        if data[1] == 1:
+            expected = pd.Categorical([False, False, np.nan])
+            tm.assert_categorical_equal(result, expected)
+        else:
+            expected = pd.Index([False, False, np.nan])
+            tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/categorical/test_reindex.py b/pandas/tests/indexes/categorical/test_reindex.py
new file mode 100644
index 0000000000000..f59ddc42ce4e4
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_reindex.py
@@ -0,0 +1,53 @@
+import numpy as np
+
+from pandas import Categorical, CategoricalIndex, Index
+import pandas._testing as tm
+
+
+class TestReindex:
+    def test_reindex_dtype(self):
+        c = CategoricalIndex(["a", "b", "c", "a"])
+        res, indexer = c.reindex(["a", "c"])
+        tm.assert_index_equal(res, Index(["a", "a", "c"]), exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
+
+        c = CategoricalIndex(["a", "b", "c", "a"])
+        res, indexer = c.reindex(Categorical(["a", "c"]))
+
+        exp = CategoricalIndex(["a", "a", "c"], categories=["a", "c"])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
+
+        c = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
+        res, indexer = c.reindex(["a", "c"])
+        exp = Index(["a", "a", "c"], dtype="object")
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
+
+        c = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
+        res, indexer = c.reindex(Categorical(["a", "c"]))
+        exp = CategoricalIndex(["a", "a", "c"], categories=["a", "c"])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2], dtype=np.intp))
+
+    def test_reindex_duplicate_target(self):
+        # See GH25459
+        cat = CategoricalIndex(["a", "b", "c"], categories=["a", "b", "c", "d"])
+        res, indexer = cat.reindex(["a", "c", "c"])
+        exp = Index(["a", "c", "c"], dtype="object")
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 2, 2], dtype=np.intp))
+
+        res, indexer = cat.reindex(
+            CategoricalIndex(["a", "c", "c"], categories=["a", "b", "c", "d"])
+        )
+        exp = CategoricalIndex(["a", "c", "c"], categories=["a", "b", "c", "d"])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 2, 2], dtype=np.intp))
+
+    def test_reindex_empty_index(self):
+        # See GH16770
+        c = CategoricalIndex([])
+        res, indexer = c.reindex(["a", "b"])
+        tm.assert_index_equal(res, Index(["a", "b"]), exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([-1, -1], dtype=np.intp))
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index 0e74c87388682..2073aa0727809 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -1,10 +1,12 @@
 import gc
+from typing import Optional, Type
 
 import numpy as np
 import pytest
 
 from pandas._libs.tslib import iNaT
 
+from pandas.core.dtypes.common import is_datetime64tz_dtype
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
 import pandas as pd
@@ -22,26 +24,22 @@
     UInt64Index,
     isna,
 )
+import pandas._testing as tm
 from pandas.core.indexes.base import InvalidIndexError
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
-import pandas.util.testing as tm
 
 
 class Base:
     """ base class for index sub-class tests """
 
-    _holder = None
+    _holder: Optional[Type[Index]] = None
     _compat_props = ["shape", "ndim", "size", "nbytes"]
 
-    def setup_indices(self):
-        for name, idx in self.indices.items():
-            setattr(self, name, idx)
-
     def test_pickle_compat_construction(self):
         # need an object to create with
         msg = (
-            r"Index\(\.\.\.\) must be called with a collection of some"
-            r" kind, None was passed|"
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            r"kind, None was passed|"
             r"__new__\(\) missing 1 required positional argument: 'data'|"
             r"__new__\(\) takes at least 2 arguments \(1 given\)"
         )
@@ -96,24 +94,23 @@ def test_to_frame(self, name):
         df = idx.to_frame(index=False, name=idx_name)
         assert df.index is not idx
 
-    def test_to_frame_datetime_tz(self):
-        # GH 25809
-        idx = pd.date_range(start="2019-01-01", end="2019-01-30", freq="D")
-        idx = idx.tz_localize("UTC")
-        result = idx.to_frame()
-        expected = pd.DataFrame(idx, index=idx)
-        tm.assert_frame_equal(result, expected)
-
     def test_shift(self):
 
         # GH8083 test the base class for shift
         idx = self.create_index()
-        msg = "Not supported for type {}".format(type(idx).__name__)
+        msg = f"Not supported for type {type(idx).__name__}"
         with pytest.raises(NotImplementedError, match=msg):
             idx.shift(1)
         with pytest.raises(NotImplementedError, match=msg):
             idx.shift(1, 2)
 
+    def test_constructor_name_unhashable(self):
+        # GH#29069 check that name is hashable
+        # See also same-named test in tests.series.test_constructors
+        idx = self.create_index()
+        with pytest.raises(TypeError, match="Index.name must be a hashable type"):
+            type(idx)(idx, name=[])
+
     def test_create_index_existing_name(self):
 
         # GH11193, when an existing index is passed, and a new name is not
@@ -170,6 +167,10 @@ def test_create_index_existing_name(self):
     def test_numeric_compat(self):
 
         idx = self.create_index()
+        # Check that this doesn't cover MultiIndex case, if/when it does,
+        #  we can remove multi.test_compat.test_numeric_compat
+        assert not isinstance(idx, MultiIndex)
+
         with pytest.raises(TypeError, match="cannot perform __mul__"):
             idx * 1
         with pytest.raises(TypeError, match="cannot perform __rmul__"):
@@ -213,24 +214,23 @@ def test_reindex_base(self):
         with pytest.raises(ValueError, match="Invalid fill method"):
             idx.get_indexer(idx, method="invalid")
 
-    def test_get_indexer_consistency(self):
+    def test_get_indexer_consistency(self, indices):
         # See GH 16819
-        for name, index in self.indices.items():
-            if isinstance(index, IntervalIndex):
-                continue
-
-            if index.is_unique or isinstance(index, CategoricalIndex):
-                indexer = index.get_indexer(index[0:2])
-                assert isinstance(indexer, np.ndarray)
-                assert indexer.dtype == np.intp
-            else:
-                e = "Reindexing only valid with uniquely valued Index objects"
-                with pytest.raises(InvalidIndexError, match=e):
-                    index.get_indexer(index[0:2])
+        if isinstance(indices, IntervalIndex):
+            return
 
-            indexer, _ = index.get_indexer_non_unique(index[0:2])
+        if indices.is_unique or isinstance(indices, CategoricalIndex):
+            indexer = indices.get_indexer(indices[0:2])
             assert isinstance(indexer, np.ndarray)
             assert indexer.dtype == np.intp
+        else:
+            e = "Reindexing only valid with uniquely valued Index objects"
+            with pytest.raises(InvalidIndexError, match=e):
+                indices.get_indexer(indices[0:2])
+
+        indexer, _ = indices.get_indexer_non_unique(indices[0:2])
+        assert isinstance(indexer, np.ndarray)
+        assert indexer.dtype == np.intp
 
     def test_ndarray_compat_properties(self):
         idx = self.create_index()
@@ -256,7 +256,7 @@ def test_str(self):
         idx = self.create_index()
         idx.name = "foo"
         assert "'foo'" in str(idx)
-        assert idx.__class__.__name__ in str(idx)
+        assert type(idx).__name__ in str(idx)
 
     def test_repr_max_seq_item_setting(self):
         # GH10182
@@ -266,146 +266,141 @@ def test_repr_max_seq_item_setting(self):
             repr(idx)
             assert "..." not in str(idx)
 
-    def test_copy_name(self):
+    def test_copy_name(self, indices):
         # gh-12309: Check that the "name" argument
         # passed at initialization is honored.
+        if isinstance(indices, MultiIndex):
+            return
 
-        for name, index in self.indices.items():
-            if isinstance(index, MultiIndex):
-                continue
-
-            first = index.__class__(index, copy=True, name="mario")
-            second = first.__class__(first, copy=False)
+        first = type(indices)(indices, copy=True, name="mario")
+        second = type(first)(first, copy=False)
 
-            # Even though "copy=False", we want a new object.
-            assert first is not second
+        # Even though "copy=False", we want a new object.
+        assert first is not second
 
-            # Not using tm.assert_index_equal() since names differ.
-            assert index.equals(first)
+        # Not using tm.assert_index_equal() since names differ.
+        assert indices.equals(first)
 
-            assert first.name == "mario"
-            assert second.name == "mario"
+        assert first.name == "mario"
+        assert second.name == "mario"
 
-            s1 = Series(2, index=first)
-            s2 = Series(3, index=second[:-1])
+        s1 = Series(2, index=first)
+        s2 = Series(3, index=second[:-1])
 
-            if not isinstance(index, CategoricalIndex):
-                # See gh-13365
-                s3 = s1 * s2
-                assert s3.index.name == "mario"
+        if not isinstance(indices, CategoricalIndex):
+            # See gh-13365
+            s3 = s1 * s2
+            assert s3.index.name == "mario"
 
-    def test_ensure_copied_data(self):
+    def test_ensure_copied_data(self, indices):
         # Check the "copy" argument of each Index.__new__ is honoured
         # GH12309
-        for name, index in self.indices.items():
-            init_kwargs = {}
-            if isinstance(index, PeriodIndex):
-                # Needs "freq" specification:
-                init_kwargs["freq"] = index.freq
-            elif isinstance(index, (RangeIndex, MultiIndex, CategoricalIndex)):
-                # RangeIndex cannot be initialized from data
-                # MultiIndex and CategoricalIndex are tested separately
-                continue
-
-            index_type = index.__class__
-            result = index_type(index.values, copy=True, **init_kwargs)
-            tm.assert_index_equal(index, result)
+        init_kwargs = {}
+        if isinstance(indices, PeriodIndex):
+            # Needs "freq" specification:
+            init_kwargs["freq"] = indices.freq
+        elif isinstance(indices, (RangeIndex, MultiIndex, CategoricalIndex)):
+            # RangeIndex cannot be initialized from data
+            # MultiIndex and CategoricalIndex are tested separately
+            return
+
+        index_type = type(indices)
+        result = index_type(indices.values, copy=True, **init_kwargs)
+        if is_datetime64tz_dtype(indices.dtype):
+            result = result.tz_localize("UTC").tz_convert(indices.tz)
+
+        tm.assert_index_equal(indices, result)
+        tm.assert_numpy_array_equal(
+            indices._ndarray_values, result._ndarray_values, check_same="copy"
+        )
+
+        if isinstance(indices, PeriodIndex):
+            # .values an object array of Period, thus copied
+            result = index_type(ordinal=indices.asi8, copy=False, **init_kwargs)
             tm.assert_numpy_array_equal(
-                index._ndarray_values, result._ndarray_values, check_same="copy"
+                indices._ndarray_values, result._ndarray_values, check_same="same"
+            )
+        elif isinstance(indices, IntervalIndex):
+            # checked in test_interval.py
+            pass
+        else:
+            result = index_type(indices.values, copy=False, **init_kwargs)
+            tm.assert_numpy_array_equal(
+                indices.values, result.values, check_same="same"
+            )
+            tm.assert_numpy_array_equal(
+                indices._ndarray_values, result._ndarray_values, check_same="same"
             )
 
-            if isinstance(index, PeriodIndex):
-                # .values an object array of Period, thus copied
-                result = index_type(ordinal=index.asi8, copy=False, **init_kwargs)
-                tm.assert_numpy_array_equal(
-                    index._ndarray_values, result._ndarray_values, check_same="same"
-                )
-            elif isinstance(index, IntervalIndex):
-                # checked in test_interval.py
-                pass
-            else:
-                result = index_type(index.values, copy=False, **init_kwargs)
-                tm.assert_numpy_array_equal(
-                    index.values, result.values, check_same="same"
-                )
-                tm.assert_numpy_array_equal(
-                    index._ndarray_values, result._ndarray_values, check_same="same"
-                )
-
-    def test_memory_usage(self):
-        for name, index in self.indices.items():
-            result = index.memory_usage()
-            if len(index):
-                index.get_loc(index[0])
-                result2 = index.memory_usage()
-                result3 = index.memory_usage(deep=True)
-
-                # RangeIndex, IntervalIndex
-                # don't have engines
-                if not isinstance(index, (RangeIndex, IntervalIndex)):
-                    assert result2 > result
-
-                if index.inferred_type == "object":
-                    assert result3 > result2
-
-            else:
-
-                # we report 0 for no-length
-                assert result == 0
-
-    def test_argsort(self):
-        for k, ind in self.indices.items():
-
-            # separately tested
-            if k in ["catIndex"]:
-                continue
-
-            result = ind.argsort()
-            expected = np.array(ind).argsort()
-            tm.assert_numpy_array_equal(result, expected, check_dtype=False)
-
-    def test_numpy_argsort(self):
-        for k, ind in self.indices.items():
-            result = np.argsort(ind)
-            expected = ind.argsort()
-            tm.assert_numpy_array_equal(result, expected)
-
-            # these are the only two types that perform
-            # pandas compatibility input validation - the
-            # rest already perform separate (or no) such
-            # validation via their 'values' attribute as
-            # defined in pandas.core.indexes/base.py - they
-            # cannot be changed at the moment due to
-            # backwards compatibility concerns
-            if isinstance(type(ind), (CategoricalIndex, RangeIndex)):
-                msg = "the 'axis' parameter is not supported"
-                with pytest.raises(ValueError, match=msg):
-                    np.argsort(ind, axis=1)
-
-                msg = "the 'kind' parameter is not supported"
-                with pytest.raises(ValueError, match=msg):
-                    np.argsort(ind, kind="mergesort")
-
-                msg = "the 'order' parameter is not supported"
-                with pytest.raises(ValueError, match=msg):
-                    np.argsort(ind, order=("a", "b"))
-
-    def test_take(self):
+    def test_memory_usage(self, indices):
+        indices._engine.clear_mapping()
+        result = indices.memory_usage()
+        if indices.empty:
+            # we report 0 for no-length
+            assert result == 0
+            return
+
+        # non-zero length
+        indices.get_loc(indices[0])
+        result2 = indices.memory_usage()
+        result3 = indices.memory_usage(deep=True)
+
+        # RangeIndex, IntervalIndex
+        # don't have engines
+        if not isinstance(indices, (RangeIndex, IntervalIndex)):
+            assert result2 > result
+
+        if indices.inferred_type == "object":
+            assert result3 > result2
+
+    def test_argsort(self, request, indices):
+        # separately tested
+        if isinstance(indices, CategoricalIndex):
+            return
+
+        result = indices.argsort()
+        expected = np.array(indices).argsort()
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    def test_numpy_argsort(self, indices):
+        result = np.argsort(indices)
+        expected = indices.argsort()
+        tm.assert_numpy_array_equal(result, expected)
+
+        # these are the only two types that perform
+        # pandas compatibility input validation - the
+        # rest already perform separate (or no) such
+        # validation via their 'values' attribute as
+        # defined in pandas.core.indexes/base.py - they
+        # cannot be changed at the moment due to
+        # backwards compatibility concerns
+        if isinstance(type(indices), (CategoricalIndex, RangeIndex)):
+            msg = "the 'axis' parameter is not supported"
+            with pytest.raises(ValueError, match=msg):
+                np.argsort(indices, axis=1)
+
+            msg = "the 'kind' parameter is not supported"
+            with pytest.raises(ValueError, match=msg):
+                np.argsort(indices, kind="mergesort")
+
+            msg = "the 'order' parameter is not supported"
+            with pytest.raises(ValueError, match=msg):
+                np.argsort(indices, order=("a", "b"))
+
+    def test_take(self, indices):
         indexer = [4, 3, 0, 2]
-        for k, ind in self.indices.items():
-
-            # separate
-            if k in ["boolIndex", "tuples", "empty"]:
-                continue
+        if len(indices) < 5:
+            # not enough elements; ignore
+            return
 
-            result = ind.take(indexer)
-            expected = ind[indexer]
-            assert result.equals(expected)
+        result = indices.take(indexer)
+        expected = indices[indexer]
+        assert result.equals(expected)
 
-            if not isinstance(ind, (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
-                # GH 10791
-                with pytest.raises(AttributeError):
-                    ind.freq
+        if not isinstance(indices, (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
+            # GH 10791
+            with pytest.raises(AttributeError):
+                indices.freq
 
     def test_take_invalid_kwargs(self):
         idx = self.create_index()
@@ -462,173 +457,162 @@ def test_where(self, klass):
     @pytest.mark.parametrize(
         "method", ["intersection", "union", "difference", "symmetric_difference"]
     )
-    def test_set_ops_error_cases(self, case, method):
-        for name, idx in self.indices.items():
-            # non-iterable input
-
-            msg = "Input must be Index or array-like"
+    def test_set_ops_error_cases(self, case, method, indices):
+        # non-iterable input
+        msg = "Input must be Index or array-like"
+        with pytest.raises(TypeError, match=msg):
+            getattr(indices, method)(case)
+
+    def test_intersection_base(self, indices):
+        if isinstance(indices, CategoricalIndex):
+            return
+
+        first = indices[:5]
+        second = indices[:3]
+        intersect = first.intersection(second)
+        assert tm.equalContents(intersect, second)
+
+        if is_datetime64tz_dtype(indices.dtype):
+            # The second.values below will drop tz, so the rest of this test
+            #  is not applicable.
+            return
+
+        # GH 10149
+        cases = [klass(second.values) for klass in [np.array, Series, list]]
+        for case in cases:
+            result = first.intersection(case)
+            assert tm.equalContents(result, second)
+
+        if isinstance(indices, MultiIndex):
+            msg = "other must be a MultiIndex or a list of tuples"
             with pytest.raises(TypeError, match=msg):
-                getattr(idx, method)(case)
-
-    def test_intersection_base(self):
-        for name, idx in self.indices.items():
-            first = idx[:5]
-            second = idx[:3]
-            intersect = first.intersection(second)
-
-            if isinstance(idx, CategoricalIndex):
-                pass
-            else:
-                assert tm.equalContents(intersect, second)
-
-            # GH 10149
-            cases = [klass(second.values) for klass in [np.array, Series, list]]
-            for case in cases:
-                if isinstance(idx, CategoricalIndex):
-                    pass
-                else:
-                    result = first.intersection(case)
-                    assert tm.equalContents(result, second)
-
-            if isinstance(idx, MultiIndex):
-                msg = "other must be a MultiIndex or a list of tuples"
-                with pytest.raises(TypeError, match=msg):
-                    first.intersection([1, 2, 3])
-
-    def test_union_base(self):
-        for name, idx in self.indices.items():
-            first = idx[3:]
-            second = idx[:5]
-            everything = idx
-            union = first.union(second)
-            assert tm.equalContents(union, everything)
-
-            # GH 10149
-            cases = [klass(second.values) for klass in [np.array, Series, list]]
-            for case in cases:
-                if isinstance(idx, CategoricalIndex):
-                    pass
-                else:
-                    result = first.union(case)
-                    assert tm.equalContents(result, everything)
-
-            if isinstance(idx, MultiIndex):
-                msg = "other must be a MultiIndex or a list of tuples"
-                with pytest.raises(TypeError, match=msg):
-                    first.union([1, 2, 3])
+                first.intersection([1, 2, 3])
+
+    def test_union_base(self, indices):
+        first = indices[3:]
+        second = indices[:5]
+        everything = indices
+        union = first.union(second)
+        assert tm.equalContents(union, everything)
+
+        if is_datetime64tz_dtype(indices.dtype):
+            # The second.values below will drop tz, so the rest of this test
+            #  is not applicable.
+            return
+
+        # GH 10149
+        cases = [klass(second.values) for klass in [np.array, Series, list]]
+        for case in cases:
+            if not isinstance(indices, CategoricalIndex):
+                result = first.union(case)
+                assert tm.equalContents(result, everything)
+
+        if isinstance(indices, MultiIndex):
+            msg = "other must be a MultiIndex or a list of tuples"
+            with pytest.raises(TypeError, match=msg):
+                first.union([1, 2, 3])
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_base(self, sort):
-        for name, idx in self.indices.items():
-            first = idx[2:]
-            second = idx[:4]
-            answer = idx[4:]
-            result = first.difference(second, sort)
-
-            if isinstance(idx, CategoricalIndex):
-                pass
-            else:
-                assert tm.equalContents(result, answer)
-
-            # GH 10149
-            cases = [klass(second.values) for klass in [np.array, Series, list]]
-            for case in cases:
-                if isinstance(idx, CategoricalIndex):
-                    pass
-                elif isinstance(idx, (DatetimeIndex, TimedeltaIndex)):
-                    assert result.__class__ == answer.__class__
-                    tm.assert_numpy_array_equal(
-                        result.sort_values().asi8, answer.sort_values().asi8
-                    )
-                else:
-                    result = first.difference(case, sort)
-                    assert tm.equalContents(result, answer)
-
-            if isinstance(idx, MultiIndex):
-                msg = "other must be a MultiIndex or a list of tuples"
-                with pytest.raises(TypeError, match=msg):
-                    first.difference([1, 2, 3], sort)
-
-    def test_symmetric_difference(self):
-        for name, idx in self.indices.items():
-            first = idx[1:]
-            second = idx[:-1]
-            if isinstance(idx, CategoricalIndex):
-                pass
+    def test_difference_base(self, sort, indices):
+        if isinstance(indices, CategoricalIndex):
+            return
+
+        first = indices[2:]
+        second = indices[:4]
+        answer = indices[4:]
+        result = first.difference(second, sort)
+        assert tm.equalContents(result, answer)
+
+        # GH 10149
+        cases = [klass(second.values) for klass in [np.array, Series, list]]
+        for case in cases:
+            if isinstance(indices, (DatetimeIndex, TimedeltaIndex)):
+                assert type(result) == type(answer)
+                tm.assert_numpy_array_equal(
+                    result.sort_values().asi8, answer.sort_values().asi8
+                )
             else:
-                answer = idx[[0, -1]]
-                result = first.symmetric_difference(second)
+                result = first.difference(case, sort)
                 assert tm.equalContents(result, answer)
 
-            # GH 10149
-            cases = [klass(second.values) for klass in [np.array, Series, list]]
-            for case in cases:
-                if isinstance(idx, CategoricalIndex):
-                    pass
-                else:
-                    result = first.symmetric_difference(case)
-                    assert tm.equalContents(result, answer)
-
-            if isinstance(idx, MultiIndex):
-                msg = "other must be a MultiIndex or a list of tuples"
-                with pytest.raises(TypeError, match=msg):
-                    first.symmetric_difference([1, 2, 3])
-
-    def test_insert_base(self):
-
-        for name, idx in self.indices.items():
-            result = idx[1:4]
-
-            if not len(idx):
-                continue
+        if isinstance(indices, MultiIndex):
+            msg = "other must be a MultiIndex or a list of tuples"
+            with pytest.raises(TypeError, match=msg):
+                first.difference([1, 2, 3], sort)
+
+    def test_symmetric_difference(self, indices):
+        if isinstance(indices, CategoricalIndex):
+            return
+
+        first = indices[1:]
+        second = indices[:-1]
+        answer = indices[[0, -1]]
+        result = first.symmetric_difference(second)
+        assert tm.equalContents(result, answer)
+
+        # GH 10149
+        cases = [klass(second.values) for klass in [np.array, Series, list]]
+        for case in cases:
+            result = first.symmetric_difference(case)
+            assert tm.equalContents(result, answer)
+
+        if isinstance(indices, MultiIndex):
+            msg = "other must be a MultiIndex or a list of tuples"
+            with pytest.raises(TypeError, match=msg):
+                first.symmetric_difference([1, 2, 3])
 
-            # test 0th element
-            assert idx[0:4].equals(result.insert(0, idx[0]))
+    def test_insert_base(self, indices):
+        result = indices[1:4]
 
-    def test_delete_base(self):
+        if not len(indices):
+            return
 
-        for name, idx in self.indices.items():
+        # test 0th element
+        assert indices[0:4].equals(result.insert(0, indices[0]))
 
-            if not len(idx):
-                continue
+    def test_delete_base(self, indices):
+        if not len(indices):
+            return
 
-            if isinstance(idx, RangeIndex):
-                # tested in class
-                continue
+        if isinstance(indices, RangeIndex):
+            # tested in class
+            return
 
-            expected = idx[1:]
-            result = idx.delete(0)
-            assert result.equals(expected)
-            assert result.name == expected.name
+        expected = indices[1:]
+        result = indices.delete(0)
+        assert result.equals(expected)
+        assert result.name == expected.name
 
-            expected = idx[:-1]
-            result = idx.delete(-1)
-            assert result.equals(expected)
-            assert result.name == expected.name
+        expected = indices[:-1]
+        result = indices.delete(-1)
+        assert result.equals(expected)
+        assert result.name == expected.name
 
-            with pytest.raises((IndexError, ValueError)):
-                # either depending on numpy version
-                idx.delete(len(idx))
+        with pytest.raises((IndexError, ValueError)):
+            # either depending on numpy version
+            indices.delete(len(indices))
 
-    def test_equals(self):
+    def test_equals(self, indices):
+        if isinstance(indices, IntervalIndex):
+            # IntervalIndex tested separately
+            return
 
-        for name, idx in self.indices.items():
-            assert idx.equals(idx)
-            assert idx.equals(idx.copy())
-            assert idx.equals(idx.astype(object))
+        assert indices.equals(indices)
+        assert indices.equals(indices.copy())
+        assert indices.equals(indices.astype(object))
 
-            assert not idx.equals(list(idx))
-            assert not idx.equals(np.array(idx))
+        assert not indices.equals(list(indices))
+        assert not indices.equals(np.array(indices))
 
-            # Cannot pass in non-int64 dtype to RangeIndex
-            if not isinstance(idx, RangeIndex):
-                same_values = Index(idx, dtype=object)
-                assert idx.equals(same_values)
-                assert same_values.equals(idx)
+        # Cannot pass in non-int64 dtype to RangeIndex
+        if not isinstance(indices, RangeIndex):
+            same_values = Index(indices, dtype=object)
+            assert indices.equals(same_values)
+            assert same_values.equals(indices)
 
-            if idx.nlevels == 1:
-                # do not test MultiIndex
-                assert not idx.equals(pd.Series(idx))
+        if indices.nlevels == 1:
+            # do not test MultiIndex
+            assert not indices.equals(Series(indices))
 
     def test_equals_op(self):
         # GH9947, GH10637
@@ -694,107 +678,99 @@ def test_equals_op(self):
             tm.assert_numpy_array_equal(index_a == item, expected3)
             tm.assert_series_equal(series_a == item, Series(expected3))
 
-    def test_hasnans_isnans(self):
+    def test_hasnans_isnans(self, indices):
         # GH 11343, added tests for hasnans / isnans
+        if isinstance(indices, MultiIndex):
+            return
+
+        # cases in indices doesn't include NaN
+        idx = indices.copy(deep=True)
+        expected = np.array([False] * len(idx), dtype=bool)
+        tm.assert_numpy_array_equal(idx._isnan, expected)
+        assert idx.hasnans is False
+
+        idx = indices.copy(deep=True)
+        values = np.asarray(idx.values)
+
+        if len(indices) == 0:
+            return
+        elif isinstance(indices, DatetimeIndexOpsMixin):
+            values[1] = iNaT
+        elif isinstance(indices, (Int64Index, UInt64Index)):
+            return
+        else:
+            values[1] = np.nan
 
-        for name, index in self.indices.items():
-            if isinstance(index, MultiIndex):
-                pass
-            else:
-                idx = index.copy()
-
-                # cases in indices doesn't include NaN
-                expected = np.array([False] * len(idx), dtype=bool)
-                tm.assert_numpy_array_equal(idx._isnan, expected)
-                assert idx.hasnans is False
-
-                idx = index.copy()
-                values = np.asarray(idx.values)
-
-                if len(index) == 0:
-                    continue
-                elif isinstance(index, DatetimeIndexOpsMixin):
-                    values[1] = iNaT
-                elif isinstance(index, (Int64Index, UInt64Index)):
-                    continue
-                else:
-                    values[1] = np.nan
-
-                if isinstance(index, PeriodIndex):
-                    idx = index.__class__(values, freq=index.freq)
-                else:
-                    idx = index.__class__(values)
-
-                expected = np.array([False] * len(idx), dtype=bool)
-                expected[1] = True
-                tm.assert_numpy_array_equal(idx._isnan, expected)
-                assert idx.hasnans is True
-
-    def test_fillna(self):
+        if isinstance(indices, PeriodIndex):
+            idx = type(indices)(values, freq=indices.freq)
+        else:
+            idx = type(indices)(values)
+
+            expected = np.array([False] * len(idx), dtype=bool)
+            expected[1] = True
+            tm.assert_numpy_array_equal(idx._isnan, expected)
+            assert idx.hasnans is True
+
+    def test_fillna(self, indices):
         # GH 11343
-        for name, index in self.indices.items():
-            if len(index) == 0:
-                pass
-            elif isinstance(index, MultiIndex):
-                idx = index.copy()
-                msg = "isna is not defined for MultiIndex"
-                with pytest.raises(NotImplementedError, match=msg):
-                    idx.fillna(idx[0])
+        if len(indices) == 0:
+            pass
+        elif isinstance(indices, MultiIndex):
+            idx = indices.copy(deep=True)
+            msg = "isna is not defined for MultiIndex"
+            with pytest.raises(NotImplementedError, match=msg):
+                idx.fillna(idx[0])
+        else:
+            idx = indices.copy(deep=True)
+            result = idx.fillna(idx[0])
+            tm.assert_index_equal(result, idx)
+            assert result is not idx
+
+            msg = "'value' must be a scalar, passed: "
+            with pytest.raises(TypeError, match=msg):
+                idx.fillna([idx[0]])
+
+            idx = indices.copy(deep=True)
+            values = np.asarray(idx.values)
+
+            if isinstance(indices, DatetimeIndexOpsMixin):
+                values[1] = iNaT
+            elif isinstance(indices, (Int64Index, UInt64Index)):
+                return
             else:
-                idx = index.copy()
-                result = idx.fillna(idx[0])
-                tm.assert_index_equal(result, idx)
-                assert result is not idx
-
-                msg = "'value' must be a scalar, passed: "
-                with pytest.raises(TypeError, match=msg):
-                    idx.fillna([idx[0]])
-
-                idx = index.copy()
-                values = np.asarray(idx.values)
-
-                if isinstance(index, DatetimeIndexOpsMixin):
-                    values[1] = iNaT
-                elif isinstance(index, (Int64Index, UInt64Index)):
-                    continue
-                else:
-                    values[1] = np.nan
-
-                if isinstance(index, PeriodIndex):
-                    idx = index.__class__(values, freq=index.freq)
-                else:
-                    idx = index.__class__(values)
-
-                expected = np.array([False] * len(idx), dtype=bool)
-                expected[1] = True
-                tm.assert_numpy_array_equal(idx._isnan, expected)
-                assert idx.hasnans is True
-
-    def test_nulls(self):
-        # this is really a smoke test for the methods
-        # as these are adequately tested for function elsewhere
+                values[1] = np.nan
 
-        for name, index in self.indices.items():
-            if len(index) == 0:
-                tm.assert_numpy_array_equal(index.isna(), np.array([], dtype=bool))
-            elif isinstance(index, MultiIndex):
-                idx = index.copy()
-                msg = "isna is not defined for MultiIndex"
-                with pytest.raises(NotImplementedError, match=msg):
-                    idx.isna()
+            if isinstance(indices, PeriodIndex):
+                idx = type(indices)(values, freq=indices.freq)
             else:
+                idx = type(indices)(values)
 
-                if not index.hasnans:
-                    tm.assert_numpy_array_equal(
-                        index.isna(), np.zeros(len(index), dtype=bool)
-                    )
-                    tm.assert_numpy_array_equal(
-                        index.notna(), np.ones(len(index), dtype=bool)
-                    )
-                else:
-                    result = isna(index)
-                    tm.assert_numpy_array_equal(index.isna(), result)
-                    tm.assert_numpy_array_equal(index.notna(), ~result)
+            expected = np.array([False] * len(idx), dtype=bool)
+            expected[1] = True
+            tm.assert_numpy_array_equal(idx._isnan, expected)
+            assert idx.hasnans is True
+
+    def test_nulls(self, indices):
+        # this is really a smoke test for the methods
+        # as these are adequately tested for function elsewhere
+        if len(indices) == 0:
+            tm.assert_numpy_array_equal(indices.isna(), np.array([], dtype=bool))
+        elif isinstance(indices, MultiIndex):
+            idx = indices.copy()
+            msg = "isna is not defined for MultiIndex"
+            with pytest.raises(NotImplementedError, match=msg):
+                idx.isna()
+        elif not indices.hasnans:
+            tm.assert_numpy_array_equal(
+                indices.isna(), np.zeros(len(indices), dtype=bool)
+            )
+            tm.assert_numpy_array_equal(
+                indices.notna(), np.ones(len(indices), dtype=bool)
+            )
+        else:
+            result = isna(indices)
+            tm.assert_numpy_array_equal(indices.isna(), result)
+            tm.assert_numpy_array_equal(indices.notna(), ~result)
 
     def test_empty(self):
         # GH 15270
@@ -832,7 +808,7 @@ def test_map_dictlike(self, mapper):
 
         index = self.create_index()
         if isinstance(index, (pd.CategoricalIndex, pd.IntervalIndex)):
-            pytest.skip("skipping tests for {}".format(type(index)))
+            pytest.skip(f"skipping tests for {type(index)}")
 
         identity = mapper(index.values, index)
 
@@ -850,6 +826,13 @@ def test_map_dictlike(self, mapper):
         result = index.map(mapper(expected, index))
         tm.assert_index_equal(result, expected)
 
+    def test_map_str(self):
+        # GH 31202
+        index = self.create_index()
+        result = index.map(str)
+        expected = Index([str(x) for x in index], dtype=object)
+        tm.assert_index_equal(result, expected)
+
     def test_putmask_with_wrong_mask(self):
         # GH18368
         index = self.create_index()
@@ -917,3 +900,19 @@ def test_engine_reference_cycle(self):
         nrefs_pre = len(gc.get_referrers(index))
         index._engine
         assert len(gc.get_referrers(index)) == nrefs_pre
+
+    def test_getitem_2d_deprecated(self):
+        # GH#30588
+        idx = self.create_index()
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            res = idx[:, None]
+
+        assert isinstance(res, np.ndarray), type(res)
+
+    def test_contains_requires_hashable_raises(self):
+        idx = self.create_index()
+        with pytest.raises(TypeError, match="unhashable type"):
+            [] in idx
+
+        with pytest.raises(TypeError):
+            {} in idx._engine
diff --git a/pandas/tests/indexes/conftest.py b/pandas/tests/indexes/conftest.py
index 12c5fb8339549..57174f206b70d 100644
--- a/pandas/tests/indexes/conftest.py
+++ b/pandas/tests/indexes/conftest.py
@@ -1,51 +1,29 @@
-import numpy as np
 import pytest
 
-import pandas as pd
+import pandas._testing as tm
 from pandas.core.indexes.api import Index, MultiIndex
-import pandas.util.testing as tm
 
-indices_list = [
-    tm.makeUnicodeIndex(100),
-    tm.makeStringIndex(100),
-    tm.makeDateIndex(100),
-    tm.makePeriodIndex(100),
-    tm.makeTimedeltaIndex(100),
-    tm.makeIntIndex(100),
-    tm.makeUIntIndex(100),
-    tm.makeRangeIndex(100),
-    tm.makeFloatIndex(100),
-    Index([True, False]),
-    tm.makeCategoricalIndex(100),
-    tm.makeIntervalIndex(100),
-    Index([]),
-    MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
-    Index([0, 0, 1, 1, 2, 2]),
-]
-
-
-@pytest.fixture(params=indices_list, ids=lambda x: type(x).__name__)
+indices_dict = {
+    "unicode": tm.makeUnicodeIndex(100),
+    "string": tm.makeStringIndex(100),
+    "datetime": tm.makeDateIndex(100),
+    "datetime-tz": tm.makeDateIndex(100, tz="US/Pacific"),
+    "period": tm.makePeriodIndex(100),
+    "timedelta": tm.makeTimedeltaIndex(100),
+    "int": tm.makeIntIndex(100),
+    "uint": tm.makeUIntIndex(100),
+    "range": tm.makeRangeIndex(100),
+    "float": tm.makeFloatIndex(100),
+    "bool": tm.makeBoolIndex(2),
+    "categorical": tm.makeCategoricalIndex(100),
+    "interval": tm.makeIntervalIndex(100),
+    "empty": Index([]),
+    "tuples": MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
+    "repeats": Index([0, 0, 1, 1, 2, 2]),
+}
+
+
+@pytest.fixture(params=indices_dict.keys())
 def indices(request):
-    return request.param
-
-
-@pytest.fixture(params=[1, np.array(1, dtype=np.int64)])
-def one(request):
-    # zero-dim integer array behaves like an integer
-    return request.param
-
-
-zeros = [
-    box([0] * 5, dtype=dtype)
-    for box in [pd.Index, np.array]
-    for dtype in [np.int64, np.uint64, np.float64]
-]
-zeros.extend([np.array(0, dtype=dtype) for dtype in [np.int64, np.uint64, np.float64]])
-zeros.extend([0, 0.0])
-
-
-@pytest.fixture(params=zeros)
-def zero(request):
-    # For testing division by (or of) zero for Index with length 5, this
-    # gives several scalar-zeros and length-5 vector-zeros
-    return request.param
+    # copy to avoid mutation, e.g. setting .name
+    return indices_dict[request.param].copy()
diff --git a/pandas/tests/indexes/datetimelike.py b/pandas/tests/indexes/datetimelike.py
index 7523b250ea291..ba10976a67e9a 100644
--- a/pandas/tests/indexes/datetimelike.py
+++ b/pandas/tests/indexes/datetimelike.py
@@ -3,7 +3,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from .common import Base
 
@@ -36,15 +36,15 @@ def test_str(self):
         # test the string repr
         idx = self.create_index()
         idx.name = "foo"
-        assert not "length={}".format(len(idx)) in str(idx)
+        assert not (f"length={len(idx)}" in str(idx))
         assert "'foo'" in str(idx)
-        assert idx.__class__.__name__ in str(idx)
+        assert type(idx).__name__ in str(idx)
 
         if hasattr(idx, "tz"):
             if idx.tz is not None:
                 assert idx.tz in str(idx)
         if hasattr(idx, "freq"):
-            assert "freq='{idx.freqstr}'".format(idx=idx) in str(idx)
+            assert f"freq='{idx.freqstr}'" in str(idx)
 
     def test_view(self):
         i = self.create_index()
@@ -58,45 +58,40 @@ def test_view(self):
         tm.assert_index_equal(result, i_view)
 
     def test_map_callable(self):
-        expected = self.index + self.index.freq
-        result = self.index.map(lambda x: x + x.freq)
+        index = self.create_index()
+        expected = index + index.freq
+        result = index.map(lambda x: x + x.freq)
         tm.assert_index_equal(result, expected)
 
         # map to NaT
-        result = self.index.map(lambda x: pd.NaT if x == self.index[0] else x)
-        expected = pd.Index([pd.NaT] + self.index[1:].tolist())
+        result = index.map(lambda x: pd.NaT if x == index[0] else x)
+        expected = pd.Index([pd.NaT] + index[1:].tolist())
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
         "mapper",
         [
             lambda values, index: {i: e for e, i in zip(values, index)},
-            lambda values, index: pd.Series(values, index),
+            lambda values, index: pd.Series(values, index, dtype=object),
         ],
     )
     def test_map_dictlike(self, mapper):
-        expected = self.index + self.index.freq
+        index = self.create_index()
+        expected = index + index.freq
 
         # don't compare the freqs
         if isinstance(expected, pd.DatetimeIndex):
-            expected.freq = None
+            expected._data.freq = None
 
-        result = self.index.map(mapper(expected, self.index))
+        result = index.map(mapper(expected, index))
         tm.assert_index_equal(result, expected)
 
-        expected = pd.Index([pd.NaT] + self.index[1:].tolist())
-        result = self.index.map(mapper(expected, self.index))
+        expected = pd.Index([pd.NaT] + index[1:].tolist())
+        result = index.map(mapper(expected, index))
         tm.assert_index_equal(result, expected)
 
         # empty map; these map to np.nan because we cannot know
         # to re-infer things
-        expected = pd.Index([np.nan] * len(self.index))
-        result = self.index.map(mapper([], []))
+        expected = pd.Index([np.nan] * len(index))
+        result = index.map(mapper([], []))
         tm.assert_index_equal(result, expected)
-
-    def test_asobject_deprecated(self):
-        # GH18572
-        d = self.create_index()
-        with tm.assert_produces_warning(FutureWarning):
-            i = d.asobject
-        assert isinstance(i, pd.Index)
diff --git a/pandas/tests/indexes/datetimes/test_astype.py b/pandas/tests/indexes/datetimes/test_astype.py
index eabf293ae915f..916f722247a14 100644
--- a/pandas/tests/indexes/datetimes/test_astype.py
+++ b/pandas/tests/indexes/datetimes/test_astype.py
@@ -1,7 +1,6 @@
 from datetime import datetime
 
 import dateutil
-from dateutil.tz import tzlocal
 import numpy as np
 import pytest
 import pytz
@@ -12,12 +11,12 @@
     Index,
     Int64Index,
     NaT,
-    Period,
+    PeriodIndex,
     Series,
     Timestamp,
     date_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestDatetimeIndex:
@@ -278,81 +277,19 @@ def test_integer_index_astype_datetime(self, tz, dtype):
         expected = pd.DatetimeIndex(["2018-01-01"], tz=tz)
         tm.assert_index_equal(result, expected)
 
+    def test_dti_astype_period(self):
+        idx = DatetimeIndex([NaT, "2011-01-01", "2011-02-01"], name="idx")
 
-class TestToPeriod:
-    def setup_method(self, method):
-        data = [
-            Timestamp("2007-01-01 10:11:12.123456Z"),
-            Timestamp("2007-01-01 10:11:13.789123Z"),
-        ]
-        self.index = DatetimeIndex(data)
-
-    def test_to_period_millisecond(self):
-        index = self.index
-
-        with tm.assert_produces_warning(UserWarning):
-            # warning that timezone info will be lost
-            period = index.to_period(freq="L")
-        assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123Z", "L")
-        assert period[1] == Period("2007-01-01 10:11:13.789Z", "L")
-
-    def test_to_period_microsecond(self):
-        index = self.index
+        res = idx.astype("period[M]")
+        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
+        tm.assert_index_equal(res, exp)
 
-        with tm.assert_produces_warning(UserWarning):
-            # warning that timezone info will be lost
-            period = index.to_period(freq="U")
-        assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "U")
-        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "U")
-
-    @pytest.mark.parametrize(
-        "tz",
-        ["US/Eastern", pytz.utc, tzlocal(), "dateutil/US/Eastern", dateutil.tz.tzutc()],
-    )
-    def test_to_period_tz(self, tz):
-        ts = date_range("1/1/2000", "2/1/2000", tz=tz)
-
-        with tm.assert_produces_warning(UserWarning):
-            # GH#21333 warning that timezone info will be lost
-            result = ts.to_period()[0]
-            expected = ts[0].to_period()
-
-        assert result == expected
-
-        expected = date_range("1/1/2000", "2/1/2000").to_period()
-
-        with tm.assert_produces_warning(UserWarning):
-            # GH#21333 warning that timezone info will be lost
-            result = ts.to_period()
-
-        tm.assert_index_equal(result, expected)
+        res = idx.astype("period[3M]")
+        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
+        tm.assert_index_equal(res, exp)
 
-    @pytest.mark.parametrize("tz", ["Etc/GMT-1", "Etc/GMT+1"])
-    def test_to_period_tz_utc_offset_consistency(self, tz):
-        # GH 22905
-        ts = pd.date_range("1/1/2000", "2/1/2000", tz="Etc/GMT-1")
-        with tm.assert_produces_warning(UserWarning):
-            result = ts.to_period()[0]
-            expected = ts[0].to_period()
-            assert result == expected
-
-    def test_to_period_nofreq(self):
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
-        with pytest.raises(ValueError):
-            idx.to_period()
-
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="infer")
-        assert idx.freqstr == "D"
-        expected = pd.PeriodIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="D")
-        tm.assert_index_equal(idx.to_period(), expected)
-
-        # GH 7606
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"])
-        assert idx.freqstr is None
-        tm.assert_index_equal(idx.to_period(), expected)
 
+class TestAstype:
     @pytest.mark.parametrize("tz", [None, "US/Central"])
     def test_astype_category(self, tz):
         obj = pd.date_range("2000", periods=2, tz=tz)
diff --git a/pandas/tests/indexes/datetimes/test_construction.py b/pandas/tests/indexes/datetimes/test_constructors.py
similarity index 90%
rename from pandas/tests/indexes/datetimes/test_construction.py
rename to pandas/tests/indexes/datetimes/test_constructors.py
index 88bc11c588673..1d1d371fcec1e 100644
--- a/pandas/tests/indexes/datetimes/test_construction.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -1,4 +1,4 @@
-from datetime import timedelta
+from datetime import datetime, timedelta
 from functools import partial
 from operator import attrgetter
 
@@ -10,17 +10,9 @@
 from pandas._libs.tslibs import OutOfBoundsDatetime, conversion
 
 import pandas as pd
-from pandas import (
-    DatetimeIndex,
-    Index,
-    Timestamp,
-    date_range,
-    datetime,
-    offsets,
-    to_datetime,
-)
+from pandas import DatetimeIndex, Index, Timestamp, date_range, offsets, to_datetime
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray, period_array
-import pandas.util.testing as tm
 
 
 class TestDatetimeIndex:
@@ -37,6 +29,25 @@ def test_freq_validation_with_nat(self, dt_cls):
         with pytest.raises(ValueError, match=msg):
             dt_cls([pd.NaT, pd.Timestamp("2011-01-01").value], freq="D")
 
+    # TODO: better place for tests shared by DTI/TDI?
+    @pytest.mark.parametrize(
+        "index",
+        [
+            pd.date_range("2016-01-01", periods=5, tz="US/Pacific"),
+            pd.timedelta_range("1 Day", periods=5),
+        ],
+    )
+    def test_shallow_copy_inherits_array_freq(self, index):
+        # If we pass a DTA/TDA to shallow_copy and dont specify a freq,
+        #  we should inherit the array's freq, not our own.
+        array = index._data
+
+        arr = array[[0, 3, 2, 4, 1]]
+        assert arr.freq is None
+
+        result = index._shallow_copy(arr)
+        assert result.freq is None
+
     def test_categorical_preserves_tz(self):
         # GH#18664 retain tz when going DTI-->Categorical-->DTI
         # TODO: parametrize over DatetimeIndex/DatetimeArray
@@ -70,28 +81,21 @@ def test_dti_with_period_data_raises(self):
         with pytest.raises(TypeError, match="PeriodDtype data is invalid"):
             to_datetime(period_array(data))
 
-    def test_dti_with_timedelta64_data_deprecation(self):
-        # GH#23675
+    def test_dti_with_timedelta64_data_raises(self):
+        # GH#23675 deprecated, enforrced in GH#29794
         data = np.array([0], dtype="m8[ns]")
-        with tm.assert_produces_warning(FutureWarning):
-            result = DatetimeIndex(data)
-
-        assert result[0] == Timestamp("1970-01-01")
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = to_datetime(data)
-
-        assert result[0] == Timestamp("1970-01-01")
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = DatetimeIndex(pd.TimedeltaIndex(data))
+        msg = r"timedelta64\[ns\] cannot be converted to datetime64"
+        with pytest.raises(TypeError, match=msg):
+            DatetimeIndex(data)
 
-        assert result[0] == Timestamp("1970-01-01")
+        with pytest.raises(TypeError, match=msg):
+            to_datetime(data)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = to_datetime(pd.TimedeltaIndex(data))
+        with pytest.raises(TypeError, match=msg):
+            DatetimeIndex(pd.TimedeltaIndex(data))
 
-        assert result[0] == Timestamp("1970-01-01")
+        with pytest.raises(TypeError, match=msg):
+            to_datetime(pd.TimedeltaIndex(data))
 
     def test_construction_caching(self):
 
@@ -129,15 +133,11 @@ def test_construction_with_alt_tz_localize(self, kwargs, tz_aware_fixture):
         i = pd.date_range("20130101", periods=5, freq="H", tz=tz)
         kwargs = {key: attrgetter(val)(i) for key, val in kwargs.items()}
 
-        if str(tz) in ("UTC", "tzutc()", "UTC+00:00"):
-            warn = None
-        else:
-            warn = FutureWarning
+        if "tz" in kwargs:
+            result = DatetimeIndex(i.asi8, tz="UTC").tz_convert(kwargs["tz"])
 
-        with tm.assert_produces_warning(warn, check_stacklevel=False):
-            result = DatetimeIndex(i.tz_localize(None).asi8, **kwargs)
-        expected = DatetimeIndex(i, **kwargs)
-        tm.assert_index_equal(result, expected)
+            expected = DatetimeIndex(i, **kwargs)
+            tm.assert_index_equal(result, expected)
 
         # localize into the provided tz
         i2 = DatetimeIndex(i.tz_localize(None).asi8, tz="UTC")
@@ -492,21 +492,13 @@ def test_construction_with_ndarray(self):
         expected = DatetimeIndex(["2013-10-07", "2013-10-08", "2013-10-09"], freq="B")
         tm.assert_index_equal(result, expected)
 
-    def test_verify_integrity_deprecated(self):
-        # GH#23919
-        with tm.assert_produces_warning(FutureWarning):
-            DatetimeIndex(["1/1/2000"], verify_integrity=False)
+    def test_integer_values_and_tz_interpreted_as_utc(self):
+        # GH-24559
+        val = np.datetime64("2000-01-01 00:00:00", "ns")
+        values = np.array([val.view("i8")])
 
-    def test_range_kwargs_deprecated(self):
-        # GH#23919
-        with tm.assert_produces_warning(FutureWarning):
-            DatetimeIndex(start="1/1/2000", end="1/10/2000", freq="D")
+        result = DatetimeIndex(values).tz_localize("US/Central")
 
-    def test_integer_values_and_tz_deprecated(self):
-        # GH-24559
-        values = np.array([946684800000000000])
-        with tm.assert_produces_warning(FutureWarning):
-            result = DatetimeIndex(values, tz="US/Central")
         expected = pd.DatetimeIndex(["2000-01-01T00:00:00"], tz="US/Central")
         tm.assert_index_equal(result, expected)
 
@@ -524,10 +516,6 @@ def test_constructor_coverage(self):
         with pytest.raises(TypeError, match=msg):
             date_range(start="1/1/2000", periods="foo", freq="D")
 
-        with pytest.raises(ValueError):
-            with tm.assert_produces_warning(FutureWarning):
-                DatetimeIndex(start="1/1/2000", end="1/10/2000")
-
         with pytest.raises(TypeError):
             DatetimeIndex("1/1/2000")
 
@@ -559,15 +547,15 @@ def test_constructor_coverage(self):
 
         # non-conforming
         msg = (
-            "Inferred frequency None from passed values does not conform"
-            " to passed frequency D"
+            "Inferred frequency None from passed values does not conform "
+            "to passed frequency D"
         )
         with pytest.raises(ValueError, match=msg):
             DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"], freq="D")
 
         msg = (
-            "Of the four parameters: start, end, periods, and freq, exactly"
-            " three must be specified"
+            "Of the four parameters: start, end, periods, and freq, exactly "
+            "three must be specified"
         )
         with pytest.raises(ValueError, match=msg):
             date_range(start="2011-01-01", freq="b")
@@ -656,8 +644,8 @@ def test_constructor_dtype(self):
         )
 
         msg = (
-            "cannot supply both a tz and a timezone-naive dtype"
-            r" \(i\.e\. datetime64\[ns\]\)"
+            "cannot supply both a tz and a timezone-naive dtype "
+            r"\(i\.e\. datetime64\[ns\]\)"
         )
         with pytest.raises(ValueError, match=msg):
             DatetimeIndex(idx, dtype="datetime64[ns]")
@@ -734,22 +722,11 @@ def test_constructor_timestamp_near_dst(self):
         expected = DatetimeIndex([ts[0].to_pydatetime(), ts[1].to_pydatetime()])
         tm.assert_index_equal(result, expected)
 
-    # TODO(GH-24559): Remove the xfail for the tz-aware case.
     @pytest.mark.parametrize("klass", [Index, DatetimeIndex])
     @pytest.mark.parametrize("box", [np.array, partial(np.array, dtype=object), list])
     @pytest.mark.parametrize(
         "tz, dtype",
-        [
-            pytest.param(
-                "US/Pacific",
-                "datetime64[ns, US/Pacific]",
-                marks=[
-                    pytest.mark.xfail(),
-                    pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning"),
-                ],
-            ),
-            [None, "datetime64[ns]"],
-        ],
+        [("US/Pacific", "datetime64[ns, US/Pacific]"), (None, "datetime64[ns]")],
     )
     def test_constructor_with_int_tz(self, klass, box, tz, dtype):
         # GH 20997, 20964
@@ -758,15 +735,10 @@ def test_constructor_with_int_tz(self, klass, box, tz, dtype):
         expected = klass([ts])
         assert result == expected
 
-    # This is the desired future behavior
-    # Note: this xfail is not strict because the test passes with
-    #  None or any of the UTC variants for tz_naive_fixture
-    @pytest.mark.xfail(reason="Future behavior", strict=False)
-    @pytest.mark.filterwarnings("ignore:\\n    Passing:FutureWarning")
     def test_construction_int_rountrip(self, tz_naive_fixture):
-        # GH 12619
-        # TODO(GH-24559): Remove xfail
+        # GH 12619, GH#24559
         tz = tz_naive_fixture
+
         result = 1293858000000000000
         expected = DatetimeIndex([result], tz=tz).asi8[0]
         assert result == expected
@@ -807,18 +779,15 @@ def test_construction_with_nat_and_tzlocal(self):
         expected = DatetimeIndex([Timestamp("2018", tz=tz), pd.NaT])
         tm.assert_index_equal(result, expected)
 
-    def test_constructor_no_precision_warns(self):
+    def test_constructor_no_precision_raises(self):
         # GH-24753, GH-24739
-        expected = pd.DatetimeIndex(["2000"], dtype="datetime64[ns]")
 
-        # we set the stacklevel for DatetimeIndex
-        with tm.assert_produces_warning(FutureWarning):
-            result = pd.DatetimeIndex(["2000"], dtype="datetime64")
-        tm.assert_index_equal(result, expected)
+        msg = "with no precision is not allowed"
+        with pytest.raises(ValueError, match=msg):
+            pd.DatetimeIndex(["2000"], dtype="datetime64")
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = pd.Index(["2000"], dtype="datetime64")
-        tm.assert_index_equal(result, expected)
+        with pytest.raises(ValueError, match=msg):
+            pd.Index(["2000"], dtype="datetime64")
 
     def test_constructor_wrong_precision_raises(self):
         with pytest.raises(ValueError):
@@ -981,3 +950,12 @@ def test_datetimeindex_constructor_misc(self):
         )
         assert len(idx1) == len(idx2)
         assert idx1.freq == idx2.freq
+
+    def test_pass_datetimeindex_to_index(self):
+        # Bugs in #1396
+        rng = date_range("1/1/2000", "3/1/2000")
+        idx = Index(rng, dtype=object)
+
+        expected = Index(rng.to_pydatetime(), dtype=object)
+
+        tm.assert_numpy_array_equal(idx.values, expected.values)
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 54c931cd60d20..4d0beecbbf5d3 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -14,8 +14,7 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Timestamp, bdate_range, date_range, offsets
-from pandas.tests.series.common import TestData
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import (
     BDay,
@@ -82,7 +81,7 @@ def test_date_range_timestamp_equiv_preserve_frequency(self):
         assert timestamp_instance == ts
 
 
-class TestDateRanges(TestData):
+class TestDateRanges:
     def test_date_range_nat(self):
         # GH#11587
         msg = "Neither `start` nor `end` can be NaT"
@@ -799,7 +798,7 @@ def test_daterange_bug_456(self):
         # GH #456
         rng1 = bdate_range("12/5/2011", "12/5/2011")
         rng2 = bdate_range("12/2/2011", "12/5/2011")
-        rng2.freq = BDay()
+        rng2._data.freq = BDay()  # TODO: shouldn't this already be set?
 
         result = rng1.union(rng2)
         assert isinstance(result, DatetimeIndex)
@@ -856,7 +855,7 @@ def test_daterange_bug_456(self):
         # GH #456
         rng1 = bdate_range("12/5/2011", "12/5/2011", freq="C")
         rng2 = bdate_range("12/2/2011", "12/5/2011", freq="C")
-        rng2.freq = CDay()
+        rng2._data.freq = CDay()  # TODO: shouldn't this already be set?
 
         result = rng1.union(rng2)
         assert isinstance(result, DatetimeIndex)
@@ -946,3 +945,19 @@ def test_range_with_millisecond_resolution(self, start_end):
         result = pd.date_range(start=start, end=end, periods=2, closed="left")
         expected = DatetimeIndex([start])
         tm.assert_index_equal(result, expected)
+
+
+def test_date_range_with_custom_holidays():
+    # GH 30593
+    freq = pd.offsets.CustomBusinessHour(start="15:00", holidays=["2020-11-26"])
+    result = pd.date_range(start="2020-11-25 15:00", periods=4, freq=freq)
+    expected = pd.DatetimeIndex(
+        [
+            "2020-11-25 15:00:00",
+            "2020-11-25 16:00:00",
+            "2020-11-27 15:00:00",
+            "2020-11-27 16:00:00",
+        ],
+        freq=freq,
+    )
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index bb3fe7a136204..ca18d6fbea11a 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -6,8 +6,7 @@
 
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex, Index, Timestamp, date_range, offsets
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
+import pandas._testing as tm
 
 randn = np.random.randn
 
@@ -90,7 +89,7 @@ def test_week_of_month_frequency(self):
     def test_hash_error(self):
         index = date_range("20010101", periods=10)
         with pytest.raises(
-            TypeError, match=("unhashable type: {0.__name__!r}".format(type(index)))
+            TypeError, match=f"unhashable type: '{type(index).__name__}'"
         ):
             hash(index)
 
@@ -189,25 +188,6 @@ def test_string_index_series_name_converted(self):
         result = df.T["1/3/2000"]
         assert result.name == df.index[2]
 
-    def test_get_duplicates(self):
-        idx = DatetimeIndex(
-            [
-                "2000-01-01",
-                "2000-01-02",
-                "2000-01-02",
-                "2000-01-03",
-                "2000-01-03",
-                "2000-01-04",
-            ]
-        )
-
-        with tm.assert_produces_warning(FutureWarning):
-            # Deprecated - see GH20239
-            result = idx.get_duplicates()
-
-        ex = DatetimeIndex(["2000-01-02", "2000-01-03"])
-        tm.assert_index_equal(result, ex)
-
     def test_argmin_argmax(self):
         idx = DatetimeIndex(["2000-01-04", "2000-01-01", "2000-01-02"])
         assert idx.argmin() == 1
@@ -262,7 +242,7 @@ def test_isin(self):
         result = index.isin(list(index))
         assert result.all()
 
-        assert_almost_equal(
+        tm.assert_almost_equal(
             index.isin([index[2], 5]), np.array([False, False, True, False])
         )
 
@@ -413,15 +393,13 @@ def test_asarray_tz_naive(self):
         # This shouldn't produce a warning.
         idx = pd.date_range("2000", periods=2)
         # M8[ns] by default
-        with tm.assert_produces_warning(None):
-            result = np.asarray(idx)
+        result = np.asarray(idx)
 
         expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
         tm.assert_numpy_array_equal(result, expected)
 
         # optionally, object
-        with tm.assert_produces_warning(None):
-            result = np.asarray(idx, dtype=object)
+        result = np.asarray(idx, dtype=object)
 
         expected = np.array([pd.Timestamp("2000-01-01"), pd.Timestamp("2000-01-02")])
         tm.assert_numpy_array_equal(result, expected)
@@ -430,15 +408,12 @@ def test_asarray_tz_aware(self):
         tz = "US/Central"
         idx = pd.date_range("2000", periods=2, tz=tz)
         expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]")
-        # We warn by default and return an ndarray[M8[ns]]
-        with tm.assert_produces_warning(FutureWarning):
-            result = np.asarray(idx)
+        result = np.asarray(idx, dtype="datetime64[ns]")
 
         tm.assert_numpy_array_equal(result, expected)
 
         # Old behavior with no warning
-        with tm.assert_produces_warning(None):
-            result = np.asarray(idx, dtype="M8[ns]")
+        result = np.asarray(idx, dtype="M8[ns]")
 
         tm.assert_numpy_array_equal(result, expected)
 
@@ -446,7 +421,25 @@ def test_asarray_tz_aware(self):
         expected = np.array(
             [pd.Timestamp("2000-01-01", tz=tz), pd.Timestamp("2000-01-02", tz=tz)]
         )
-        with tm.assert_produces_warning(None):
-            result = np.asarray(idx, dtype=object)
+        result = np.asarray(idx, dtype=object)
 
         tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_frame_datetime_tz(self):
+        # GH 25809
+        idx = date_range(start="2019-01-01", end="2019-01-30", freq="D", tz="UTC")
+        result = idx.to_frame()
+        expected = DataFrame(idx, index=idx)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("name", [None, "name"])
+    def test_index_map(self, name):
+        # see GH20990
+        count = 6
+        index = pd.date_range("2018-01-01", periods=count, freq="M", name=name).map(
+            lambda x: (x.year, x.month)
+        )
+        exp_index = pd.MultiIndex.from_product(
+            ((2018,), range(1, 7)), names=[name, name]
+        )
+        tm.assert_index_equal(index, exp_index)
diff --git a/pandas/tests/indexes/datetimes/test_datetimelike.py b/pandas/tests/indexes/datetimes/test_datetimelike.py
index 0f1d7927ee3b4..da1bd6f091d1a 100644
--- a/pandas/tests/indexes/datetimes/test_datetimelike.py
+++ b/pandas/tests/indexes/datetimes/test_datetimelike.py
@@ -1,7 +1,8 @@
 """ generic tests from the Datetimelike class """
+import pytest
 
 from pandas import DatetimeIndex, date_range
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 from ..datetimelike import DatetimeLike
 
@@ -9,12 +10,12 @@
 class TestDatetimeIndex(DatetimeLike):
     _holder = DatetimeIndex
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=tm.makeDateIndex(10),
-            index_dec=date_range("20130110", periods=10, freq="-1D"),
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[tm.makeDateIndex(10), date_range("20130110", periods=10, freq="-1D")],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return request.param
 
     def create_index(self):
         return date_range("20130101", periods=5)
diff --git a/pandas/tests/indexes/datetimes/test_formats.py b/pandas/tests/indexes/datetimes/test_formats.py
index 33a744cc25ca1..f34019e06fd5f 100644
--- a/pandas/tests/indexes/datetimes/test_formats.py
+++ b/pandas/tests/indexes/datetimes/test_formats.py
@@ -7,7 +7,7 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_to_native_types():
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index cd5efc86320c2..c358e72538788 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -6,7 +6,8 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Index, Timestamp, date_range, notna
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.indexes.base import InvalidIndexError
 
 from pandas.tseries.offsets import BDay, CDay
 
@@ -86,7 +87,9 @@ def test_dti_business_getitem(self):
 
     def test_dti_business_getitem_matplotlib_hackaround(self):
         rng = pd.bdate_range(START, END)
-        values = rng[:, None]
+        with tm.assert_produces_warning(DeprecationWarning):
+            # GH#30588 multi-dimensional indexing deprecated
+            values = rng[:, None]
         expected = rng.values[:, None]
         tm.assert_numpy_array_equal(values, expected)
 
@@ -110,7 +113,9 @@ def test_dti_custom_getitem(self):
 
     def test_dti_custom_getitem_matplotlib_hackaround(self):
         rng = pd.bdate_range(START, END, freq="C")
-        values = rng[:, None]
+        with tm.assert_produces_warning(DeprecationWarning):
+            # GH#30588 multi-dimensional indexing deprecated
+            values = rng[:, None]
         expected = rng.values[:, None]
         tm.assert_numpy_array_equal(values, expected)
 
@@ -132,9 +137,32 @@ def test_where_other(self):
 
         i2 = i.copy()
         i2 = Index([pd.NaT, pd.NaT] + i[2:].tolist())
-        result = i.where(notna(i2), i2.values)
+        result = i.where(notna(i2), i2._values)
         tm.assert_index_equal(result, i2)
 
+    def test_where_invalid_dtypes(self):
+        dti = pd.date_range("20130101", periods=3, tz="US/Eastern")
+
+        i2 = dti.copy()
+        i2 = Index([pd.NaT, pd.NaT] + dti[2:].tolist())
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            # passing tz-naive ndarray to tzaware DTI
+            dti.where(notna(i2), i2.values)
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            # passing tz-aware DTI to tznaive DTI
+            dti.tz_localize(None).where(notna(i2), i2)
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            dti.where(notna(i2), i2.tz_localize(None).to_period("D"))
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            dti.where(notna(i2), i2.asi8.view("timedelta64[ns]"))
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            dti.where(notna(i2), i2.asi8)
+
     def test_where_tz(self):
         i = pd.date_range("20130101", periods=3, tz="US/Eastern")
         result = i.where(notna(i))
@@ -316,8 +344,119 @@ def test_take_fill_value_with_timezone(self):
             idx.take(np.array([1, -5]))
 
 
+class TestGetLoc:
+    @pytest.mark.parametrize("method", [None, "pad", "backfill", "nearest"])
+    def test_get_loc_method_exact_match(self, method):
+        idx = pd.date_range("2000-01-01", periods=3)
+        assert idx.get_loc(idx[1], method) == 1
+        assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
+        assert idx.get_loc(str(idx[1]), method) == 1
+
+        if method is not None:
+            assert idx.get_loc(idx[1], method, tolerance=pd.Timedelta("0 days")) == 1
+
+    def test_get_loc(self):
+        idx = pd.date_range("2000-01-01", periods=3)
+
+        assert idx.get_loc("2000-01-01", method="nearest") == 0
+        assert idx.get_loc("2000-01-01T12", method="nearest") == 1
+
+        assert idx.get_loc("2000-01-01T12", method="nearest", tolerance="1 day") == 1
+        assert (
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance=pd.Timedelta("1D"))
+            == 1
+        )
+        assert (
+            idx.get_loc(
+                "2000-01-01T12", method="nearest", tolerance=np.timedelta64(1, "D")
+            )
+            == 1
+        )
+        assert (
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance=timedelta(1)) == 1
+        )
+        with pytest.raises(ValueError, match="unit abbreviation w/o a number"):
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance="foo")
+        with pytest.raises(KeyError, match="'2000-01-01T03'"):
+            idx.get_loc("2000-01-01T03", method="nearest", tolerance="2 hours")
+        with pytest.raises(
+            ValueError, match="tolerance size must match target index size"
+        ):
+            idx.get_loc(
+                "2000-01-01",
+                method="nearest",
+                tolerance=[
+                    pd.Timedelta("1day").to_timedelta64(),
+                    pd.Timedelta("1day").to_timedelta64(),
+                ],
+            )
+
+        assert idx.get_loc("2000", method="nearest") == slice(0, 3)
+        assert idx.get_loc("2000-01", method="nearest") == slice(0, 3)
+
+        assert idx.get_loc("1999", method="nearest") == 0
+        assert idx.get_loc("2001", method="nearest") == 2
+
+        with pytest.raises(KeyError, match="'1999'"):
+            idx.get_loc("1999", method="pad")
+        with pytest.raises(KeyError, match="'2001'"):
+            idx.get_loc("2001", method="backfill")
+
+        with pytest.raises(KeyError, match="'foobar'"):
+            idx.get_loc("foobar")
+        with pytest.raises(InvalidIndexError, match=r"slice\(None, 2, None\)"):
+            idx.get_loc(slice(2))
+
+        idx = pd.to_datetime(["2000-01-01", "2000-01-04"])
+        assert idx.get_loc("2000-01-02", method="nearest") == 0
+        assert idx.get_loc("2000-01-03", method="nearest") == 1
+        assert idx.get_loc("2000-01", method="nearest") == slice(0, 2)
+
+        # time indexing
+        idx = pd.date_range("2000-01-01", periods=24, freq="H")
+        tm.assert_numpy_array_equal(
+            idx.get_loc(time(12)), np.array([12]), check_dtype=False
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_loc(time(12, 30)), np.array([]), check_dtype=False
+        )
+        with pytest.raises(NotImplementedError):
+            idx.get_loc(time(12, 30), method="pad")
+
+    def test_get_loc_nat(self):
+        # GH#20464
+        index = DatetimeIndex(["1/3/2000", "NaT"])
+        assert index.get_loc(pd.NaT) == 1
+
+        assert index.get_loc(None) == 1
+
+        assert index.get_loc(np.nan) == 1
+
+        assert index.get_loc(pd.NA) == 1
+
+        assert index.get_loc(np.datetime64("NaT")) == 1
+
+        with pytest.raises(KeyError, match="NaT"):
+            index.get_loc(np.timedelta64("NaT"))
+
+    @pytest.mark.parametrize("key", [pd.Timedelta(0), pd.Timedelta(1), timedelta(0)])
+    def test_get_loc_timedelta_invalid_key(self, key):
+        # GH#20464
+        dti = pd.date_range("1970-01-01", periods=10)
+        with pytest.raises(TypeError):
+            dti.get_loc(key)
+
+    def test_get_loc_reasonable_key_error(self):
+        # GH#1062
+        index = DatetimeIndex(["1/3/2000"])
+        with pytest.raises(KeyError, match="2000"):
+            index.get_loc("1/1/2000")
+
+
 class TestDatetimeIndex:
-    @pytest.mark.parametrize("null", [None, np.nan, pd.NaT])
+    @pytest.mark.parametrize(
+        "null", [None, np.nan, np.datetime64("NaT"), pd.NaT, pd.NA]
+    )
     @pytest.mark.parametrize("tz", [None, "UTC", "US/Eastern"])
     def test_insert_nat(self, tz, null):
         # GH#16537, GH#18295 (test missing)
@@ -326,6 +465,12 @@ def test_insert_nat(self, tz, null):
         res = idx.insert(0, null)
         tm.assert_index_equal(res, expected)
 
+    @pytest.mark.parametrize("tz", [None, "UTC", "US/Eastern"])
+    def test_insert_invalid_na(self, tz):
+        idx = pd.DatetimeIndex(["2017-01-01"], tz=tz)
+        with pytest.raises(TypeError, match="incompatible label"):
+            idx.insert(0, np.timedelta64("NaT"))
+
     def test_insert(self):
         idx = DatetimeIndex(["2000-01-04", "2000-01-01", "2000-01-02"], name="idx")
 
@@ -403,9 +548,9 @@ def test_insert(self):
 
         # see gh-7299
         idx = date_range("1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", name="idx")
-        with pytest.raises(ValueError):
+        with pytest.raises(TypeError, match="Cannot compare tz-naive and tz-aware"):
             idx.insert(3, pd.Timestamp("2000-01-04"))
-        with pytest.raises(ValueError):
+        with pytest.raises(TypeError, match="Cannot compare tz-naive and tz-aware"):
             idx.insert(3, datetime(2000, 1, 4))
         with pytest.raises(ValueError):
             idx.insert(3, pd.Timestamp("2000-01-04", tz="US/Eastern"))
@@ -457,7 +602,7 @@ def test_insert(self):
     def test_delete(self):
         idx = date_range(start="2000-01-01", periods=5, freq="M", name="idx")
 
-        # prserve freq
+        # preserve freq
         expected_0 = date_range(start="2000-02-01", periods=4, freq="M", name="idx")
         expected_4 = date_range(start="2000-01-01", periods=4, freq="M", name="idx")
 
@@ -511,7 +656,7 @@ def test_delete(self):
     def test_delete_slice(self):
         idx = date_range(start="2000-01-01", periods=10, freq="D", name="idx")
 
-        # prserve freq
+        # preserve freq
         expected_0_2 = date_range(start="2000-01-04", periods=7, freq="D", name="idx")
         expected_7_9 = date_range(start="2000-01-01", periods=7, freq="D", name="idx")
 
@@ -582,83 +727,26 @@ def test_delete_slice(self):
             assert result.freq == expected.freq
             assert result.tz == expected.tz
 
-    def test_get_loc(self):
-        idx = pd.date_range("2000-01-01", periods=3)
-
-        for method in [None, "pad", "backfill", "nearest"]:
-            assert idx.get_loc(idx[1], method) == 1
-            assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
-            assert idx.get_loc(str(idx[1]), method) == 1
-
-            if method is not None:
-                assert (
-                    idx.get_loc(idx[1], method, tolerance=pd.Timedelta("0 days")) == 1
-                )
-
-        assert idx.get_loc("2000-01-01", method="nearest") == 0
-        assert idx.get_loc("2000-01-01T12", method="nearest") == 1
-
-        assert idx.get_loc("2000-01-01T12", method="nearest", tolerance="1 day") == 1
-        assert (
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance=pd.Timedelta("1D"))
-            == 1
-        )
-        assert (
-            idx.get_loc(
-                "2000-01-01T12", method="nearest", tolerance=np.timedelta64(1, "D")
-            )
-            == 1
-        )
-        assert (
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance=timedelta(1)) == 1
-        )
-        with pytest.raises(ValueError, match="unit abbreviation w/o a number"):
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance="foo")
-        with pytest.raises(KeyError, match="'2000-01-01T03'"):
-            idx.get_loc("2000-01-01T03", method="nearest", tolerance="2 hours")
-        with pytest.raises(
-            ValueError, match="tolerance size must match target index size"
-        ):
-            idx.get_loc(
-                "2000-01-01",
-                method="nearest",
-                tolerance=[
-                    pd.Timedelta("1day").to_timedelta64(),
-                    pd.Timedelta("1day").to_timedelta64(),
-                ],
-            )
+    def test_get_value(self):
+        # specifically make sure we have test for np.datetime64 key
+        dti = pd.date_range("2016-01-01", periods=3)
 
-        assert idx.get_loc("2000", method="nearest") == slice(0, 3)
-        assert idx.get_loc("2000-01", method="nearest") == slice(0, 3)
+        arr = np.arange(6, 9)
+        ser = pd.Series(arr, index=dti)
 
-        assert idx.get_loc("1999", method="nearest") == 0
-        assert idx.get_loc("2001", method="nearest") == 2
+        key = dti[1]
 
-        with pytest.raises(KeyError, match="'1999'"):
-            idx.get_loc("1999", method="pad")
-        with pytest.raises(KeyError, match="'2001'"):
-            idx.get_loc("2001", method="backfill")
+        with pytest.raises(AttributeError, match="has no attribute '_values'"):
+            dti.get_value(arr, key)
 
-        with pytest.raises(KeyError, match="'foobar'"):
-            idx.get_loc("foobar")
-        with pytest.raises(TypeError):
-            idx.get_loc(slice(2))
+        result = dti.get_value(ser, key)
+        assert result == 7
 
-        idx = pd.to_datetime(["2000-01-01", "2000-01-04"])
-        assert idx.get_loc("2000-01-02", method="nearest") == 0
-        assert idx.get_loc("2000-01-03", method="nearest") == 1
-        assert idx.get_loc("2000-01", method="nearest") == slice(0, 2)
+        result = dti.get_value(ser, key.to_pydatetime())
+        assert result == 7
 
-        # time indexing
-        idx = pd.date_range("2000-01-01", periods=24, freq="H")
-        tm.assert_numpy_array_equal(
-            idx.get_loc(time(12)), np.array([12]), check_dtype=False
-        )
-        tm.assert_numpy_array_equal(
-            idx.get_loc(time(12, 30)), np.array([]), check_dtype=False
-        )
-        with pytest.raises(NotImplementedError):
-            idx.get_loc(time(12, 30), method="pad")
+        result = dti.get_value(ser, key.to_datetime64())
+        assert result == 7
 
     def test_get_indexer(self):
         idx = pd.date_range("2000-01-01", periods=3)
@@ -699,21 +787,3 @@ def test_get_indexer(self):
             idx.get_indexer(target, "nearest", tolerance=tol_bad)
         with pytest.raises(ValueError):
             idx.get_indexer(idx[[0]], method="nearest", tolerance="foo")
-
-    def test_reasonable_key_error(self):
-        # GH#1062
-        index = DatetimeIndex(["1/3/2000"])
-        with pytest.raises(KeyError, match="2000"):
-            index.get_loc("1/1/2000")
-
-    @pytest.mark.parametrize("key", [pd.Timedelta(0), pd.Timedelta(1), timedelta(0)])
-    def test_timedelta_invalid_key(self, key):
-        # GH#20464
-        dti = pd.date_range("1970-01-01", periods=10)
-        with pytest.raises(TypeError):
-            dti.get_loc(key)
-
-    def test_get_loc_nat(self):
-        # GH#20464
-        index = DatetimeIndex(["1/3/2000", "NaT"])
-        assert index.get_loc(pd.NaT) == 1
diff --git a/pandas/tests/indexes/datetimes/test_misc.py b/pandas/tests/indexes/datetimes/test_misc.py
index ab3107a0798e5..d0464698e3f24 100644
--- a/pandas/tests/indexes/datetimes/test_misc.py
+++ b/pandas/tests/indexes/datetimes/test_misc.py
@@ -1,4 +1,5 @@
 import calendar
+from datetime import datetime
 import locale
 import unicodedata
 
@@ -6,20 +7,11 @@
 import pytest
 
 import pandas as pd
-from pandas import DatetimeIndex, Index, Timestamp, date_range, datetime, offsets
-import pandas.util.testing as tm
+from pandas import DatetimeIndex, Index, Timestamp, date_range, offsets
+import pandas._testing as tm
 
 
 class TestTimeSeries:
-    def test_pass_datetimeindex_to_index(self):
-        # Bugs in #1396
-        rng = date_range("1/1/2000", "3/1/2000")
-        idx = Index(rng, dtype=object)
-
-        expected = Index(rng.to_pydatetime(), dtype=object)
-
-        tm.assert_numpy_array_equal(idx.values, expected.values)
-
     def test_range_edges(self):
         # GH#13672
         idx = pd.date_range(
@@ -200,7 +192,6 @@ def test_datetimeindex_accessors(self):
             assert len(dti.is_quarter_end) == 365
             assert len(dti.is_year_start) == 365
             assert len(dti.is_year_end) == 365
-            assert len(dti.weekday_name) == 365
 
             dti.name = "name"
 
@@ -339,11 +330,8 @@ def test_datetime_name_accessors(self, time_locale):
         ]
         for day, name, eng_name in zip(range(4, 11), expected_days, english_days):
             name = name.capitalize()
-            assert dti.weekday_name[day] == eng_name
             assert dti.day_name(locale=time_locale)[day] == name
             ts = Timestamp(datetime(2016, 4, day))
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                assert ts.weekday_name == eng_name
             assert ts.day_name(locale=time_locale) == name
         dti = dti.append(DatetimeIndex([pd.NaT]))
         assert np.isnan(dti.day_name(locale=time_locale)[-1])
diff --git a/pandas/tests/indexes/datetimes/test_missing.py b/pandas/tests/indexes/datetimes/test_missing.py
index 6d94319b33b02..3399c8eaf6750 100644
--- a/pandas/tests/indexes/datetimes/test_missing.py
+++ b/pandas/tests/indexes/datetimes/test_missing.py
@@ -1,7 +1,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestDatetimeIndex:
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index d4dff2cbce89b..8ed98410ad9a4 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -7,44 +7,23 @@
 from pandas.core.dtypes.generic import ABCDateOffset
 
 import pandas as pd
-from pandas import (
-    DatetimeIndex,
-    Index,
-    PeriodIndex,
-    Series,
-    Timestamp,
-    bdate_range,
-    date_range,
-)
-from pandas.tests.test_base import Ops
-import pandas.util.testing as tm
+from pandas import DatetimeIndex, Index, Series, Timestamp, bdate_range, date_range
+import pandas._testing as tm
 
 from pandas.tseries.offsets import BDay, BMonthEnd, CDay, Day, Hour
 
 START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
 
 
-class TestDatetimeIndexOps(Ops):
-    def setup_method(self, method):
-        super().setup_method(method)
-        mask = lambda x: (isinstance(x, DatetimeIndex) or isinstance(x, PeriodIndex))
-        self.is_valid_objs = [o for o in self.objs if mask(o)]
-        self.not_valid_objs = [o for o in self.objs if not mask(o)]
-
-    def test_ops_properties(self):
-        f = lambda x: isinstance(x, DatetimeIndex)
-        self.check_ops_properties(DatetimeIndex._field_ops, f)
-        self.check_ops_properties(DatetimeIndex._object_ops, f)
-        self.check_ops_properties(DatetimeIndex._bool_ops, f)
-
-    def test_ops_properties_basic(self):
+class TestDatetimeIndexOps:
+    def test_ops_properties_basic(self, datetime_series):
 
         # sanity check that the behavior didn't change
         # GH#7206
-        msg = "'Series' object has no attribute '{}'"
         for op in ["year", "day", "second", "weekday"]:
-            with pytest.raises(AttributeError, match=msg.format(op)):
-                getattr(self.dt_series, op)
+            msg = f"'Series' object has no attribute '{op}'"
+            with pytest.raises(AttributeError, match=msg):
+                getattr(datetime_series, op)
 
         # attribute access should still work!
         s = Series(dict(year=2000, month=1, day=10))
@@ -393,6 +372,18 @@ def test_equals(self):
         assert not idx.equals(list(idx3))
         assert not idx.equals(pd.Series(idx3))
 
+        # check that we do not raise when comparing with OutOfBounds objects
+        oob = pd.Index([datetime(2500, 1, 1)] * 3, dtype=object)
+        assert not idx.equals(oob)
+        assert not idx2.equals(oob)
+        assert not idx3.equals(oob)
+
+        # check that we do not raise when comparing with OutOfBounds dt64
+        oob2 = oob.map(np.datetime64)
+        assert not idx.equals(oob2)
+        assert not idx2.equals(oob2)
+        assert not idx3.equals(oob2)
+
     @pytest.mark.parametrize("values", [["20180101", "20180103", "20180105"], []])
     @pytest.mark.parametrize("freq", ["2D", Day(2), "2B", BDay(2), "48H", Hour(48)])
     @pytest.mark.parametrize("tz", [None, "US/Eastern"])
@@ -401,12 +392,12 @@ def test_freq_setter(self, values, freq, tz):
         idx = DatetimeIndex(values, tz=tz)
 
         # can set to an offset, converting from string if necessary
-        idx.freq = freq
+        idx._data.freq = freq
         assert idx.freq == freq
         assert isinstance(idx.freq, ABCDateOffset)
 
         # can reset to None
-        idx.freq = None
+        idx._data.freq = None
         assert idx.freq is None
 
     def test_freq_setter_errors(self):
@@ -419,23 +410,11 @@ def test_freq_setter_errors(self):
             "passed frequency 5D"
         )
         with pytest.raises(ValueError, match=msg):
-            idx.freq = "5D"
+            idx._data.freq = "5D"
 
         # setting with non-freq string
         with pytest.raises(ValueError, match="Invalid frequency"):
-            idx.freq = "foo"
-
-    def test_offset_deprecated(self):
-        # GH 20716
-        idx = pd.DatetimeIndex(["20180101", "20180102"])
-
-        # getter deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            idx.offset
-
-        # setter deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            idx.offset = BDay()
+            idx._data.freq = "foo"
 
 
 class TestBusinessDatetimeIndex:
@@ -537,8 +516,6 @@ def test_shift_periods(self):
         idx = pd.date_range(start=START, end=END, periods=3)
         tm.assert_index_equal(idx.shift(periods=0), idx)
         tm.assert_index_equal(idx.shift(0), idx)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=True):
-            tm.assert_index_equal(idx.shift(n=0), idx)
 
     def test_pickle_unpickle(self):
         unpickled = tm.round_trip_pickle(self.rng)
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 5660fa5ffed80..946d658e90132 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -1,7 +1,7 @@
 """ test partial slicing on Series/Frame """
 
 from datetime import datetime
-import operator as op
+import operator
 
 import numpy as np
 import pytest
@@ -16,8 +16,8 @@
     Timestamp,
     date_range,
 )
+import pandas._testing as tm
 from pandas.core.indexing import IndexingError
-from pandas.util import testing as tm
 
 
 class TestSlicing:
@@ -142,6 +142,26 @@ def test_slice_year(self):
         expected = slice(3288, 3653)
         assert result == expected
 
+    @pytest.mark.parametrize(
+        "partial_dtime",
+        [
+            "2019",
+            "2019Q4",
+            "Dec 2019",
+            "2019-12-31",
+            "2019-12-31 23",
+            "2019-12-31 23:59",
+        ],
+    )
+    def test_slice_end_of_period_resolution(self, partial_dtime):
+        # GH#31064
+        dti = date_range("2019-12-31 23:59:55.999999999", periods=10, freq="s")
+
+        ser = pd.Series(range(10), index=dti)
+        result = ser[partial_dtime]
+        expected = ser.iloc[:5]
+        tm.assert_series_equal(result, expected)
+
     def test_slice_quarter(self):
         dti = date_range(freq="D", start=datetime(2000, 6, 1), periods=500)
 
@@ -274,7 +294,7 @@ def test_partial_slicing_dataframe(self):
                 result = df["a"][ts_string]
                 assert isinstance(result, np.int64)
                 assert result == expected
-                msg = r"^'{}'$".format(ts_string)
+                msg = fr"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df[ts_string]
 
@@ -302,7 +322,7 @@ def test_partial_slicing_dataframe(self):
                 result = df["a"][ts_string]
                 assert isinstance(result, np.int64)
                 assert result == 2
-                msg = r"^'{}'$".format(ts_string)
+                msg = fr"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df[ts_string]
 
@@ -311,7 +331,7 @@ def test_partial_slicing_dataframe(self):
             for fmt, res in list(zip(formats, resolutions))[rnum + 1 :]:
                 ts = index[1] + Timedelta("1 " + res)
                 ts_string = ts.strftime(fmt)
-                msg = r"^'{}'$".format(ts_string)
+                msg = fr"^'{ts_string}'$"
                 with pytest.raises(KeyError, match=msg):
                     df["a"][ts_string]
                 with pytest.raises(KeyError, match=msg):
@@ -408,10 +428,10 @@ def test_loc_datetime_length_one(self):
     @pytest.mark.parametrize(
         "op,expected",
         [
-            (op.lt, [True, False, False, False]),
-            (op.le, [True, True, False, False]),
-            (op.eq, [False, True, False, False]),
-            (op.gt, [False, False, False, True]),
+            (operator.lt, [True, False, False, False]),
+            (operator.le, [True, True, False, False]),
+            (operator.eq, [False, True, False, False]),
+            (operator.gt, [False, False, False, True]),
         ],
     )
     def test_selection_by_datetimelike(self, datetimelike, op, expected):
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index 00310f4fba7c7..84eee2419f0b8 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -10,7 +10,7 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Timestamp, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.frequencies import to_offset
 
@@ -50,18 +50,13 @@ def test_dti_date_out_of_range(self, data):
             "is_quarter_end",
             "is_year_start",
             "is_year_end",
-            "weekday_name",
         ],
     )
     def test_dti_timestamp_fields(self, field):
         # extra fields from DatetimeIndex like quarter and week
         idx = tm.makeDateIndex(100)
         expected = getattr(idx, field)[-1]
-        if field == "weekday_name":
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                result = getattr(Timestamp(idx[-1]), field)
-        else:
-            result = getattr(Timestamp(idx[-1]), field)
+        result = getattr(Timestamp(idx[-1]), field)
         assert result == expected
 
     def test_dti_timestamp_freq_fields(self):
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 67fc70c17d7bc..78188c54b1d85 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -16,7 +16,7 @@
     date_range,
     to_datetime,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import BMonthEnd, Minute, MonthEnd
 
@@ -157,12 +157,27 @@ def test_union_bug_4564(self, sort):
     def test_union_freq_both_none(self, sort):
         # GH11086
         expected = bdate_range("20150101", periods=10)
-        expected.freq = None
+        expected._data.freq = None
 
         result = expected.union(expected, sort=sort)
         tm.assert_index_equal(result, expected)
         assert result.freq is None
 
+    def test_union_freq_infer(self):
+        # When taking the union of two DatetimeIndexes, we infer
+        #  a freq even if the arguments don't have freq.  This matches
+        #  TimedeltaIndex behavior.
+        dti = pd.date_range("2016-01-01", periods=5)
+        left = dti[[0, 1, 3, 4]]
+        right = dti[[2, 3, 1]]
+
+        assert left.freq is None
+        assert right.freq is None
+
+        result = left.union(right)
+        tm.assert_index_equal(result, dti)
+        assert result.freq == "D"
+
     def test_union_dataframe_index(self):
         rng1 = date_range("1/1/1999", "1/1/2012", freq="MS")
         s1 = Series(np.random.randn(len(rng1)), rng1)
diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_shift.py
similarity index 90%
rename from pandas/tests/indexes/datetimes/test_arithmetic.py
rename to pandas/tests/indexes/datetimes/test_shift.py
index 4851dd5a55c1e..1c87995931c62 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_shift.py
@@ -7,10 +7,10 @@
 
 import pandas as pd
 from pandas import DatetimeIndex, Series, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
-class TestDatetimeIndexArithmetic:
+class TestDatetimeIndexShift:
 
     # -------------------------------------------------------------
     # DatetimeIndex.shift is used in integer addition
@@ -69,17 +69,11 @@ def test_dti_shift_freqs(self):
     def test_dti_shift_int(self):
         rng = date_range("1/1/2000", periods=20)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng + 5
-
+        result = rng + 5 * rng.freq
         expected = rng.shift(5)
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng - 5
-
+        result = rng - 5 * rng.freq
         expected = rng.shift(-5)
         tm.assert_index_equal(result, expected)
 
@@ -100,9 +94,9 @@ def test_dti_shift_localized(self, tzstr):
     def test_dti_shift_across_dst(self):
         # GH 8616
         idx = date_range("2013-11-03", tz="America/Chicago", periods=7, freq="H")
-        s = Series(index=idx[:-1])
+        s = Series(index=idx[:-1], dtype=object)
         result = s.shift(freq="H")
-        expected = Series(index=idx[1:])
+        expected = Series(index=idx[1:], dtype=object)
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/datetimes/test_snap.py b/pandas/tests/indexes/datetimes/test_snap.py
new file mode 100644
index 0000000000000..8baea9fe8341f
--- /dev/null
+++ b/pandas/tests/indexes/datetimes/test_snap.py
@@ -0,0 +1,41 @@
+import pytest
+
+from pandas import DatetimeIndex, date_range
+import pandas._testing as tm
+
+
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
+@pytest.mark.parametrize("tz", [None, "Asia/Shanghai", "Europe/Berlin"])
+@pytest.mark.parametrize("name", [None, "my_dti"])
+def test_dti_snap(name, tz):
+    dti = DatetimeIndex(
+        [
+            "1/1/2002",
+            "1/2/2002",
+            "1/3/2002",
+            "1/4/2002",
+            "1/5/2002",
+            "1/6/2002",
+            "1/7/2002",
+        ],
+        name=name,
+        tz=tz,
+        freq="D",
+    )
+
+    result = dti.snap(freq="W-MON")
+    expected = date_range("12/31/2001", "1/7/2002", name=name, tz=tz, freq="w-mon")
+    expected = expected.repeat([3, 4])
+    tm.assert_index_equal(result, expected)
+    assert result.tz == expected.tz
+    assert result.freq is None
+    assert expected.freq is None
+
+    result = dti.snap(freq="B")
+
+    expected = date_range("1/1/2002", "1/7/2002", name=name, tz=tz, freq="b")
+    expected = expected.repeat([1, 1, 1, 2, 2])
+    tm.assert_index_equal(result, expected)
+    assert result.tz == expected.tz
+    assert result.freq is None
+    assert expected.freq is None
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 059dbb00019d8..cd8e8c3542cce 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -22,7 +22,7 @@
     isna,
     to_datetime,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class FixedOffset(tzinfo):
@@ -323,13 +323,9 @@ def test_dti_tz_localize_nonexistent_raise_coerce(self):
             index.tz_localize(tz=tz)
 
         with pytest.raises(pytz.NonExistentTimeError):
-            with tm.assert_produces_warning(FutureWarning):
-                index.tz_localize(tz=tz, errors="raise")
+            index.tz_localize(tz=tz, nonexistent="raise")
 
-        with tm.assert_produces_warning(
-            FutureWarning, clear=FutureWarning, check_stacklevel=False
-        ):
-            result = index.tz_localize(tz=tz, errors="coerce")
+        result = index.tz_localize(tz=tz, nonexistent="NaT")
         test_times = ["2015-03-08 01:00-05:00", "NaT", "2015-03-08 03:00-04:00"]
         dti = to_datetime(test_times, utc=True)
         expected = dti.tz_convert("US/Eastern")
@@ -577,13 +573,7 @@ def test_dti_construction_ambiguous_endpoint(self, tz):
             "2013-10-26 23:00", "2013-10-27 01:00", freq="H", tz=tz, ambiguous="infer"
         )
         assert times[0] == Timestamp("2013-10-26 23:00", tz=tz, freq="H")
-
-        if str(tz).startswith("dateutil"):
-            # fixed ambiguous behavior
-            # see GH#14621
-            assert times[-1] == Timestamp("2013-10-27 01:00:00+0100", tz=tz, freq="H")
-        else:
-            assert times[-1] == Timestamp("2013-10-27 01:00:00+0000", tz=tz, freq="H")
+        assert times[-1] == Timestamp("2013-10-27 01:00:00+0000", tz=tz, freq="H")
 
     @pytest.mark.parametrize(
         "tz, option, expected",
@@ -591,12 +581,7 @@ def test_dti_construction_ambiguous_endpoint(self, tz):
             ["US/Pacific", "shift_forward", "2019-03-10 03:00"],
             ["dateutil/US/Pacific", "shift_forward", "2019-03-10 03:00"],
             ["US/Pacific", "shift_backward", "2019-03-10 01:00"],
-            pytest.param(
-                "dateutil/US/Pacific",
-                "shift_backward",
-                "2019-03-10 01:00",
-                marks=pytest.mark.xfail(reason="GH 24329"),
-            ),
+            ["dateutil/US/Pacific", "shift_backward", "2019-03-10 01:00"],
             ["US/Pacific", timedelta(hours=1), "2019-03-10 03:00"],
         ],
     )
@@ -704,20 +689,6 @@ def test_dti_tz_localize_nonexistent_shift_invalid(self, offset, tz_type):
         with pytest.raises(ValueError, match=msg):
             dti.tz_localize(tz, nonexistent=timedelta(seconds=offset))
 
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
-    def test_dti_tz_localize_errors_deprecation(self):
-        # GH 22644
-        tz = "Europe/Warsaw"
-        n = 60
-        dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            with pytest.raises(ValueError):
-                dti.tz_localize(tz, errors="foo")
-            # make sure errors='coerce' gets mapped correctly to nonexistent
-            result = dti.tz_localize(tz, errors="coerce")
-            expected = dti.tz_localize(tz, nonexistent="NaT")
-            tm.assert_index_equal(result, expected)
-
     # -------------------------------------------------------------
     # DatetimeIndex.normalize
 
diff --git a/pandas/tests/indexes/datetimes/test_to_period.py b/pandas/tests/indexes/datetimes/test_to_period.py
new file mode 100644
index 0000000000000..5567f98c52211
--- /dev/null
+++ b/pandas/tests/indexes/datetimes/test_to_period.py
@@ -0,0 +1,161 @@
+import dateutil.tz
+from dateutil.tz import tzlocal
+import pytest
+import pytz
+
+from pandas._libs.tslibs.ccalendar import MONTHS
+from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+
+from pandas import (
+    DatetimeIndex,
+    Period,
+    PeriodIndex,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestToPeriod:
+    def test_dti_to_period(self):
+        dti = date_range(start="1/1/2005", end="12/1/2005", freq="M")
+        pi1 = dti.to_period()
+        pi2 = dti.to_period(freq="D")
+        pi3 = dti.to_period(freq="3D")
+
+        assert pi1[0] == Period("Jan 2005", freq="M")
+        assert pi2[0] == Period("1/31/2005", freq="D")
+        assert pi3[0] == Period("1/31/2005", freq="3D")
+
+        assert pi1[-1] == Period("Nov 2005", freq="M")
+        assert pi2[-1] == Period("11/30/2005", freq="D")
+        assert pi3[-1], Period("11/30/2005", freq="3D")
+
+        tm.assert_index_equal(pi1, period_range("1/1/2005", "11/1/2005", freq="M"))
+        tm.assert_index_equal(
+            pi2, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("D")
+        )
+        tm.assert_index_equal(
+            pi3, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("3D")
+        )
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_to_period_quarterly(self, month):
+        # make sure we can make the round trip
+        freq = "Q-{month}".format(month=month)
+        rng = period_range("1989Q3", "1991Q3", freq=freq)
+        stamps = rng.to_timestamp()
+        result = stamps.to_period(freq)
+        tm.assert_index_equal(rng, result)
+
+    @pytest.mark.parametrize("off", ["BQ", "QS", "BQS"])
+    def test_to_period_quarterlyish(self, off):
+        rng = date_range("01-Jan-2012", periods=8, freq=off)
+        prng = rng.to_period()
+        assert prng.freq == "Q-DEC"
+
+    @pytest.mark.parametrize("off", ["BA", "AS", "BAS"])
+    def test_to_period_annualish(self, off):
+        rng = date_range("01-Jan-2012", periods=8, freq=off)
+        prng = rng.to_period()
+        assert prng.freq == "A-DEC"
+
+    def test_to_period_monthish(self):
+        offsets = ["MS", "BM"]
+        for off in offsets:
+            rng = date_range("01-Jan-2012", periods=8, freq=off)
+            prng = rng.to_period()
+            assert prng.freq == "M"
+
+        rng = date_range("01-Jan-2012", periods=8, freq="M")
+        prng = rng.to_period()
+        assert prng.freq == "M"
+
+        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+            date_range("01-Jan-2012", periods=8, freq="EOM")
+
+    def test_period_dt64_round_trip(self):
+        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        pi = dti.to_period()
+        tm.assert_index_equal(pi.to_timestamp(), dti)
+
+        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        pi = dti.to_period(freq="H")
+        tm.assert_index_equal(pi.to_timestamp(), dti)
+
+    def test_to_period_millisecond(self):
+        index = DatetimeIndex(
+            [
+                Timestamp("2007-01-01 10:11:12.123456Z"),
+                Timestamp("2007-01-01 10:11:13.789123Z"),
+            ]
+        )
+
+        with tm.assert_produces_warning(UserWarning):
+            # warning that timezone info will be lost
+            period = index.to_period(freq="L")
+        assert 2 == len(period)
+        assert period[0] == Period("2007-01-01 10:11:12.123Z", "L")
+        assert period[1] == Period("2007-01-01 10:11:13.789Z", "L")
+
+    def test_to_period_microsecond(self):
+        index = DatetimeIndex(
+            [
+                Timestamp("2007-01-01 10:11:12.123456Z"),
+                Timestamp("2007-01-01 10:11:13.789123Z"),
+            ]
+        )
+
+        with tm.assert_produces_warning(UserWarning):
+            # warning that timezone info will be lost
+            period = index.to_period(freq="U")
+        assert 2 == len(period)
+        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "U")
+        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "U")
+
+    @pytest.mark.parametrize(
+        "tz",
+        ["US/Eastern", pytz.utc, tzlocal(), "dateutil/US/Eastern", dateutil.tz.tzutc()],
+    )
+    def test_to_period_tz(self, tz):
+        ts = date_range("1/1/2000", "2/1/2000", tz=tz)
+
+        with tm.assert_produces_warning(UserWarning):
+            # GH#21333 warning that timezone info will be lost
+            result = ts.to_period()[0]
+            expected = ts[0].to_period()
+
+        assert result == expected
+
+        expected = date_range("1/1/2000", "2/1/2000").to_period()
+
+        with tm.assert_produces_warning(UserWarning):
+            # GH#21333 warning that timezone info will be lost
+            result = ts.to_period()
+
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["Etc/GMT-1", "Etc/GMT+1"])
+    def test_to_period_tz_utc_offset_consistency(self, tz):
+        # GH#22905
+        ts = date_range("1/1/2000", "2/1/2000", tz="Etc/GMT-1")
+        with tm.assert_produces_warning(UserWarning):
+            result = ts.to_period()[0]
+            expected = ts[0].to_period()
+            assert result == expected
+
+    def test_to_period_nofreq(self):
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
+        with pytest.raises(ValueError):
+            idx.to_period()
+
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="infer")
+        assert idx.freqstr == "D"
+        expected = PeriodIndex(["2000-01-01", "2000-01-02", "2000-01-03"], freq="D")
+        tm.assert_index_equal(idx.to_period(), expected)
+
+        # GH#7606
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"])
+        assert idx.freqstr is None
+        tm.assert_index_equal(idx.to_period(), expected)
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index b6f25d45f136a..df3a49fb7c292 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -1,6 +1,7 @@
 """ test to_datetime """
 
 import calendar
+from collections import deque
 from datetime import datetime, time
 import locale
 
@@ -29,10 +30,9 @@
     isna,
     to_datetime,
 )
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray
 from pandas.core.tools import datetimes as tools
-from pandas.util import testing as tm
-from pandas.util.testing import assert_series_equal
 
 
 class TestTimeConversionFormats:
@@ -55,7 +55,7 @@ def test_to_datetime_format(self, cache):
                 expected = expecteds[i]
 
                 if isinstance(expected, Series):
-                    assert_series_equal(result, Series(expected))
+                    tm.assert_series_equal(result, Series(expected))
                 elif isinstance(expected, Timestamp):
                     assert result == expected
                 else:
@@ -67,10 +67,10 @@ def test_to_datetime_format_YYYYMMDD(self, cache):
         expected = Series([Timestamp(x) for x in s.apply(str)])
 
         result = to_datetime(s, format="%Y%m%d", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = to_datetime(s.apply(str), format="%Y%m%d", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # with NaT
         expected = Series(
@@ -80,13 +80,13 @@ def test_to_datetime_format_YYYYMMDD(self, cache):
         s[2] = np.nan
 
         result = to_datetime(s, format="%Y%m%d", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # string with NaT
         s = s.apply(str)
         s[2] = "nat"
         result = to_datetime(s, format="%Y%m%d", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # coercion
         # GH 7930
@@ -102,6 +102,29 @@ def test_to_datetime_format_YYYYMMDD(self, cache):
         expected = Series(["20121231", "20141231", "NaT"], dtype="M8[ns]")
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "input_s",
+        [
+            # Null values with Strings
+            ["19801222", "20010112", None],
+            ["19801222", "20010112", np.nan],
+            ["19801222", "20010112", pd.NaT],
+            ["19801222", "20010112", "NaT"],
+            # Null values with Integers
+            [19801222, 20010112, None],
+            [19801222, 20010112, np.nan],
+            [19801222, 20010112, pd.NaT],
+            [19801222, 20010112, "NaT"],
+        ],
+    )
+    def test_to_datetime_format_YYYYMMDD_with_none(self, input_s):
+        # GH 30011
+        # format='%Y%m%d'
+        # with None
+        expected = Series([Timestamp("19801222"), Timestamp("20010112"), pd.NaT])
+        result = Series(pd.to_datetime(input_s, format="%Y%m%d"))
+        tm.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize(
         "input_s, expected",
         [
@@ -131,7 +154,7 @@ def test_to_datetime_format_YYYYMMDD_overflow(self, input_s, expected):
         # GH 25512
         # format='%Y%m%d', errors='coerce'
         result = pd.to_datetime(input_s, format="%Y%m%d", errors="coerce")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("cache", [True, False])
     def test_to_datetime_format_integer(self, cache):
@@ -140,13 +163,13 @@ def test_to_datetime_format_integer(self, cache):
         expected = Series([Timestamp(x) for x in s.apply(str)])
 
         result = to_datetime(s, format="%Y", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([200001, 200105, 200206])
         expected = Series([Timestamp(x[:4] + "-" + x[4:]) for x in s.apply(str)])
 
         result = to_datetime(s, format="%Y%m", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "int_date, expected",
@@ -216,7 +239,7 @@ def test_to_datetime_with_non_exact(self, cache):
         expected = to_datetime(
             s.str.extract(r"(\d+\w+\d+)", expand=False), format="%d%b%y", cache=cache
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("cache", [True, False])
     def test_parse_nanoseconds_with_formula(self, cache):
@@ -536,9 +559,14 @@ def test_to_datetime_dt64s_out_of_bounds(self, cache, dt):
         assert pd.to_datetime(dt, errors="coerce", cache=cache) is NaT
 
     @pytest.mark.parametrize("cache", [True, False])
-    def test_to_datetime_array_of_dt64s(self, cache):
-        dts = [np.datetime64("2000-01-01"), np.datetime64("2000-01-02")]
-
+    @pytest.mark.parametrize("unit", ["s", "D"])
+    def test_to_datetime_array_of_dt64s(self, cache, unit):
+        # https://github.com/pandas-dev/pandas/issues/31491
+        # Need at least 50 to ensure cache is used.
+        dts = [
+            np.datetime64("2000-01-01", unit),
+            np.datetime64("2000-01-02", unit),
+        ] * 30
         # Assuming all datetimes are in bounds, to_datetime() returns
         # an array that is equal to Timestamp() parsing
         tm.assert_index_equal(
@@ -556,11 +584,8 @@ def test_to_datetime_array_of_dt64s(self, cache):
         tm.assert_index_equal(
             pd.to_datetime(dts_with_oob, errors="coerce", cache=cache),
             pd.DatetimeIndex(
-                [
-                    Timestamp(dts_with_oob[0]).asm8,
-                    Timestamp(dts_with_oob[1]).asm8,
-                    pd.NaT,
-                ]
+                [Timestamp(dts_with_oob[0]).asm8, Timestamp(dts_with_oob[1]).asm8] * 30
+                + [pd.NaT],
             ),
         )
 
@@ -593,8 +618,8 @@ def test_to_datetime_tz(self, cache):
             pd.Timestamp("2013-01-02 14:00:00", tz="US/Eastern"),
         ]
         msg = (
-            "Tz-aware datetime.datetime cannot be converted to datetime64"
-            " unless utc=True"
+            "Tz-aware datetime.datetime cannot be "
+            "converted to datetime64 unless utc=True"
         )
         with pytest.raises(ValueError, match=msg):
             pd.to_datetime(arr, cache=cache)
@@ -697,13 +722,11 @@ def test_to_datetime_utc_true_with_series_datetime_ns(self, cache, date, dtype):
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("cache", [True, False])
+    @td.skip_if_no("psycopg2")
     def test_to_datetime_tz_psycopg2(self, cache):
 
         # xref 8260
-        try:
-            import psycopg2
-        except ImportError:
-            pytest.skip("no psycopg2 installed")
+        import psycopg2
 
         # misc cases
         tz1 = psycopg2.tz.FixedOffsetTimezone(offset=-300, name=None)
@@ -839,7 +862,7 @@ def test_datetime_invalid_index(self, values, format, infer):
 
     @pytest.mark.parametrize("utc", [True, None])
     @pytest.mark.parametrize("format", ["%Y%m%d %H:%M:%S", None])
-    @pytest.mark.parametrize("constructor", [list, tuple, np.array, pd.Index])
+    @pytest.mark.parametrize("constructor", [list, tuple, np.array, pd.Index, deque])
     def test_to_datetime_cache(self, utc, format, constructor):
         date = "20130101 00:00:00"
         test_dates = [date] * 10 ** 5
@@ -850,6 +873,24 @@ def test_to_datetime_cache(self, utc, format, constructor):
 
         tm.assert_index_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "listlike",
+        [
+            (deque([pd.Timestamp("2010-06-02 09:30:00")] * 51)),
+            ([pd.Timestamp("2010-06-02 09:30:00")] * 51),
+            (tuple([pd.Timestamp("2010-06-02 09:30:00")] * 51)),
+        ],
+    )
+    def test_no_slicing_errors_in_should_cache(self, listlike):
+        # GH 29403
+        assert tools.should_cache(listlike) is True
+
+    def test_to_datetime_from_deque(self):
+        # GH 29403
+        result = pd.to_datetime(deque([pd.Timestamp("2010-06-02 09:30:00")] * 51))
+        expected = pd.to_datetime([pd.Timestamp("2010-06-02 09:30:00")] * 51)
+        tm.assert_index_equal(result, expected)
+
     @pytest.mark.parametrize("utc", [True, None])
     @pytest.mark.parametrize("format", ["%Y%m%d %H:%M:%S", None])
     def test_to_datetime_cache_series(self, utc, format):
@@ -922,22 +963,6 @@ def test_iso_8601_strings_with_same_offset(self):
         result = DatetimeIndex([ts_str] * 2)
         tm.assert_index_equal(result, expected)
 
-    def test_iso_8601_strings_same_offset_no_box(self):
-        # GH 22446
-        data = ["2018-01-04 09:01:00+09:00", "2018-01-04 09:02:00+09:00"]
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = pd.to_datetime(data, box=False)
-
-        expected = np.array(
-            [
-                datetime(2018, 1, 4, 9, 1, tzinfo=pytz.FixedOffset(540)),
-                datetime(2018, 1, 4, 9, 2, tzinfo=pytz.FixedOffset(540)),
-            ],
-            dtype=object,
-        )
-        tm.assert_numpy_array_equal(result, expected)
-
     def test_iso_8601_strings_with_different_offsets(self):
         # GH 17697, 11736
         ts_strings = ["2015-11-18 15:30:00+05:30", "2015-11-18 16:30:00+06:30", NaT]
@@ -1025,16 +1050,6 @@ def test_timestamp_utc_true(self, ts, expected):
         result = to_datetime(ts, utc=True)
         assert result == expected
 
-    def test_to_datetime_box_deprecated(self):
-        expected = np.datetime64("2018-09-09")
-
-        # Deprecated - see GH24416
-        with tm.assert_produces_warning(FutureWarning):
-            pd.to_datetime(expected, box=False)
-
-        result = pd.to_datetime(expected).to_datetime64()
-        assert result == expected
-
     @pytest.mark.parametrize("dt_str", ["00010101", "13000101", "30000101", "99990101"])
     def test_to_datetime_with_format_out_of_bounds(self, dt_str):
         # GH 9107
@@ -1046,7 +1061,7 @@ class TestToDatetimeUnit:
     @pytest.mark.parametrize("cache", [True, False])
     def test_unit(self, cache):
         # GH 11758
-        # test proper behavior with erros
+        # test proper behavior with errors
 
         with pytest.raises(ValueError):
             to_datetime([1], unit="D", format="%Y%m%d", cache=cache)
@@ -1204,11 +1219,11 @@ def test_dataframe(self, cache):
         expected = Series(
             [Timestamp("20150204 00:00:00"), Timestamp("20160305 00:0:00")]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # dict-like
         result = to_datetime(df[["year", "month", "day"]].to_dict(), cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # dict but with constructable
         df2 = df[["year", "month", "day"]].to_dict()
@@ -1217,7 +1232,7 @@ def test_dataframe(self, cache):
         expected2 = Series(
             [Timestamp("20150204 00:00:00"), Timestamp("20160205 00:0:00")]
         )
-        assert_series_equal(result, expected2)
+        tm.assert_series_equal(result, expected2)
 
         # unit mappings
         units = [
@@ -1244,7 +1259,7 @@ def test_dataframe(self, cache):
             expected = Series(
                 [Timestamp("20150204 06:58:10"), Timestamp("20160305 07:59:11")]
             )
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         d = {
             "year": "year",
@@ -1265,11 +1280,11 @@ def test_dataframe(self, cache):
                 Timestamp("20160305 07:59:11.001002003"),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # coerce back to int
         result = to_datetime(df.astype(str), cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # passing coerce
         df2 = DataFrame({"year": [2015, 2016], "month": [2, 20], "day": [4, 5]})
@@ -1282,10 +1297,10 @@ def test_dataframe(self, cache):
             to_datetime(df2, cache=cache)
         result = to_datetime(df2, errors="coerce", cache=cache)
         expected = Series([Timestamp("20150204 00:00:00"), NaT])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # extra columns
-        msg = "extra keys have been passed to the datetime assemblage: " r"\[foo\]"
+        msg = r"extra keys have been passed to the datetime assemblage: \[foo\]"
         with pytest.raises(ValueError, match=msg):
             df2 = df.copy()
             df2["foo"] = 1
@@ -1330,7 +1345,7 @@ def test_dataframe_dtypes(self, cache):
         expected = Series(
             [Timestamp("20150204 00:00:00"), Timestamp("20160305 00:00:00")]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # mixed dtypes
         df["month"] = df["month"].astype("int8")
@@ -1339,23 +1354,13 @@ def test_dataframe_dtypes(self, cache):
         expected = Series(
             [Timestamp("20150204 00:00:00"), Timestamp("20160305 00:00:00")]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # float
         df = DataFrame({"year": [2000, 2001], "month": [1.5, 1], "day": [1, 1]})
         with pytest.raises(ValueError):
             to_datetime(df, cache=cache)
 
-    def test_dataframe_box_false(self):
-        # GH 23760
-        df = pd.DataFrame({"year": [2015, 2016], "month": [2, 3], "day": [4, 5]})
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = pd.to_datetime(df, box=False)
-
-        expected = np.array(["2015-02-04", "2016-03-05"], dtype="datetime64[ns]")
-        tm.assert_numpy_array_equal(result, expected)
-
     def test_dataframe_utc_true(self):
         # GH 23760
         df = pd.DataFrame({"year": [2015, 2016], "month": [2, 3], "day": [4, 5]})
@@ -1434,7 +1439,7 @@ def test_to_datetime_with_apply(self, cache):
         td = Series(["May 04", "Jun 02", "Dec 11"], index=[1, 2, 3])
         expected = pd.to_datetime(td, format="%b %y", cache=cache)
         result = td.apply(pd.to_datetime, format="%b %y", cache=cache)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         td = pd.Series(["May 04", "Jun 02", ""], index=[1, 2, 3])
         msg = r"time data '' does not match format '%b %y' \(match\)"
@@ -1447,7 +1452,7 @@ def test_to_datetime_with_apply(self, cache):
         result = td.apply(
             lambda x: pd.to_datetime(x, format="%b %y", errors="coerce", cache=cache)
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("cache", [True, False])
     def test_to_datetime_types(self, cache):
@@ -1580,14 +1585,14 @@ def test_string_na_nat_conversion(self, cache):
         for i in range(5):
             x = series[i]
             if isna(x):
-                expected[i] = iNaT
+                expected[i] = pd.NaT
             else:
                 expected[i] = to_datetime(x, cache=cache)
 
-        assert_series_equal(result, expected, check_names=False)
+        tm.assert_series_equal(result, expected, check_names=False)
         assert result.name == "foo"
 
-        assert_series_equal(dresult, expected, check_names=False)
+        tm.assert_series_equal(dresult, expected, check_names=False)
         assert dresult.name == "foo"
 
     @pytest.mark.parametrize(
@@ -1871,7 +1876,7 @@ def test_parsers(self, date_str, expected, cache):
         # https://github.com/dateutil/dateutil/issues/217
         yearfirst = True
 
-        result1, _, _ = parsing.parse_time_string(date_str, yearfirst=yearfirst)
+        result1, _ = parsing.parse_time_string(date_str, yearfirst=yearfirst)
         result2 = to_datetime(date_str, yearfirst=yearfirst)
         result3 = to_datetime([date_str], yearfirst=yearfirst)
         # result5 is used below
@@ -1907,7 +1912,7 @@ def test_na_values_with_cache(
 
     def test_parsers_nat(self):
         # Test that each of several string-accepting methods return pd.NaT
-        result1, _, _ = parsing.parse_time_string("NaT")
+        result1, _ = parsing.parse_time_string("NaT")
         result2 = to_datetime("NaT")
         result3 = Timestamp("NaT")
         result4 = DatetimeIndex(["NaT"])[0]
@@ -1983,7 +1988,7 @@ def test_parsers_dayfirst_yearfirst(self, cache):
                 )
                 assert dateutil_result == expected
 
-                result1, _, _ = parsing.parse_time_string(
+                result1, _ = parsing.parse_time_string(
                     date_str, dayfirst=dayfirst, yearfirst=yearfirst
                 )
 
@@ -2013,7 +2018,7 @@ def test_parsers_timestring(self, cache):
         }
 
         for date_str, (exp_now, exp_def) in cases.items():
-            result1, _, _ = parsing.parse_time_string(date_str)
+            result1, _ = parsing.parse_time_string(date_str)
             result2 = to_datetime(date_str)
             result3 = to_datetime([date_str])
             result4 = Timestamp(date_str)
@@ -2158,20 +2163,20 @@ def test_to_basic(self, julian_dates):
         expected = Series(
             pd.to_datetime(julian_dates - pd.Timestamp(0).to_julian_date(), unit="D")
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = Series(pd.to_datetime([0, 1, 2], unit="D", origin="unix"))
         expected = Series(
             [Timestamp("1970-01-01"), Timestamp("1970-01-02"), Timestamp("1970-01-03")]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # default
         result = Series(pd.to_datetime([0, 1, 2], unit="D"))
         expected = Series(
             [Timestamp("1970-01-01"), Timestamp("1970-01-02"), Timestamp("1970-01-03")]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_julian_round_trip(self):
         result = pd.to_datetime(2456658, origin="julian", unit="D")
@@ -2204,7 +2209,7 @@ def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
         )
 
         result = Series(pd.to_datetime(units_from_epochs, unit=units, origin=epochs))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "origin, exc",
@@ -2288,3 +2293,25 @@ def test_should_cache_errors(unique_share, check_count, err_message):
 
     with pytest.raises(AssertionError, match=err_message):
         tools.should_cache(arg, unique_share, check_count)
+
+
+def test_nullable_integer_to_datetime():
+    # Test for #30050
+    ser = pd.Series([1, 2, None, 2 ** 61, None])
+    ser = ser.astype("Int64")
+    ser_copy = ser.copy()
+
+    res = pd.to_datetime(ser, unit="ns")
+
+    expected = pd.Series(
+        [
+            np.datetime64("1970-01-01 00:00:00.000000001"),
+            np.datetime64("1970-01-01 00:00:00.000000002"),
+            np.datetime64("NaT"),
+            np.datetime64("2043-01-25 23:56:49.213693952"),
+            np.datetime64("NaT"),
+        ]
+    )
+    tm.assert_series_equal(res, expected)
+    # Check that ser isn't mutated
+    tm.assert_series_equal(ser, ser_copy)
diff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py
index 863b8c9082f07..c94af6c0d533e 100644
--- a/pandas/tests/indexes/interval/test_astype.py
+++ b/pandas/tests/indexes/interval/test_astype.py
@@ -12,7 +12,7 @@
     Timestamp,
     interval_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class Base:
@@ -67,7 +67,7 @@ def test_astype_cannot_cast(self, index, dtype):
             index.astype(dtype)
 
     def test_astype_invalid_dtype(self, index):
-        msg = 'data type "fake_dtype" not understood'
+        msg = "data type [\"']fake_dtype[\"'] not understood"
         with pytest.raises(TypeError, match=msg):
             index.astype("fake_dtype")
 
@@ -143,7 +143,7 @@ def test_subtype_integer(self, subtype):
         tm.assert_index_equal(result, expected)
 
         # raises with NA
-        msg = "Cannot convert NA to integer"
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
         with pytest.raises(ValueError, match=msg):
             index.insert(0, np.nan).astype(dtype)
 
diff --git a/pandas/tests/indexes/interval/test_base.py b/pandas/tests/indexes/interval/test_base.py
new file mode 100644
index 0000000000000..d8c2ba8413cfb
--- /dev/null
+++ b/pandas/tests/indexes/interval/test_base.py
@@ -0,0 +1,88 @@
+import numpy as np
+import pytest
+
+from pandas import IntervalIndex, Series, date_range
+import pandas._testing as tm
+from pandas.tests.indexes.common import Base
+
+
+class TestBase(Base):
+    """
+    Tests specific to the shared common index tests; unrelated tests should be placed
+    in test_interval.py or the specific test file (e.g. test_astype.py)
+    """
+
+    _holder = IntervalIndex
+
+    @pytest.fixture
+    def indices(self):
+        return tm.makeIntervalIndex(10)
+
+    def create_index(self, closed="right"):
+        return IntervalIndex.from_breaks(range(11), closed=closed)
+
+    def test_equals(self, closed):
+        expected = IntervalIndex.from_breaks(np.arange(5), closed=closed)
+        assert expected.equals(expected)
+        assert expected.equals(expected.copy())
+
+        assert not expected.equals(expected.astype(object))
+        assert not expected.equals(np.array(expected))
+        assert not expected.equals(list(expected))
+
+        assert not expected.equals([1, 2])
+        assert not expected.equals(np.array([1, 2]))
+        assert not expected.equals(date_range("20130101", periods=2))
+
+        expected_name1 = IntervalIndex.from_breaks(
+            np.arange(5), closed=closed, name="foo"
+        )
+        expected_name2 = IntervalIndex.from_breaks(
+            np.arange(5), closed=closed, name="bar"
+        )
+        assert expected.equals(expected_name1)
+        assert expected_name1.equals(expected_name2)
+
+        for other_closed in {"left", "right", "both", "neither"} - {closed}:
+            expected_other_closed = IntervalIndex.from_breaks(
+                np.arange(5), closed=other_closed
+            )
+            assert not expected.equals(expected_other_closed)
+
+    def test_repr_max_seq_item_setting(self):
+        # override base test: not a valid repr as we use interval notation
+        pass
+
+    def test_repr_roundtrip(self):
+        # override base test: not a valid repr as we use interval notation
+        pass
+
+    def test_take(self, closed):
+        index = self.create_index(closed=closed)
+
+        result = index.take(range(10))
+        tm.assert_index_equal(result, index)
+
+        result = index.take([0, 0, 1])
+        expected = IntervalIndex.from_arrays([0, 0, 1], [1, 1, 2], closed=closed)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [list, tuple, np.array, Series])
+    def test_where(self, closed, klass):
+        idx = self.create_index(closed=closed)
+        cond = [True] * len(idx)
+        expected = idx
+        result = expected.where(klass(cond))
+        tm.assert_index_equal(result, expected)
+
+        cond = [False] + [True] * len(idx[1:])
+        expected = IntervalIndex([np.nan] + idx[1:].tolist())
+        result = idx.where(klass(cond))
+        tm.assert_index_equal(result, expected)
+
+    def test_getitem_2d_deprecated(self):
+        # GH#30588 multi-dim indexing is deprecated, but raising is also acceptable
+        idx = self.create_index()
+        with pytest.raises(ValueError, match="multi-dimensional indexing not allowed"):
+            with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+                idx[:, None]
diff --git a/pandas/tests/indexes/interval/test_construction.py b/pandas/tests/indexes/interval/test_constructors.py
similarity index 99%
rename from pandas/tests/indexes/interval/test_construction.py
rename to pandas/tests/indexes/interval/test_constructors.py
index 98c1f7c6c2a8a..837c124db2bed 100644
--- a/pandas/tests/indexes/interval/test_construction.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -19,9 +19,9 @@
     period_range,
     timedelta_range,
 )
+import pandas._testing as tm
 from pandas.core.arrays import IntervalArray
 import pandas.core.common as com
-import pandas.util.testing as tm
 
 
 @pytest.fixture(params=[None, "foo"])
@@ -164,7 +164,7 @@ def test_generic_errors(self, constructor):
             constructor(dtype="int64", **filler)
 
         # invalid dtype
-        msg = 'data type "invalid" not understood'
+        msg = "data type [\"']invalid[\"'] not understood"
         with pytest.raises(TypeError, match=msg):
             constructor(dtype="invalid", **filler)
 
diff --git a/pandas/tests/indexes/interval/test_formats.py b/pandas/tests/indexes/interval/test_formats.py
new file mode 100644
index 0000000000000..7acf5c1e0906c
--- /dev/null
+++ b/pandas/tests/indexes/interval/test_formats.py
@@ -0,0 +1,78 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, IntervalIndex, Series, Timedelta, Timestamp
+import pandas._testing as tm
+
+
+class TestIntervalIndexRendering:
+    def test_frame_repr(self):
+        # https://github.com/pandas-dev/pandas/pull/24134/files
+        df = DataFrame(
+            {"A": [1, 2, 3, 4]}, index=IntervalIndex.from_breaks([0, 1, 2, 3, 4])
+        )
+        result = repr(df)
+        expected = "        A\n(0, 1]  1\n(1, 2]  2\n(2, 3]  3\n(3, 4]  4"
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "constructor,expected",
+        [
+            (
+                Series,
+                (
+                    "(0.0, 1.0]    a\n"
+                    "NaN           b\n"
+                    "(2.0, 3.0]    c\n"
+                    "dtype: object"
+                ),
+            ),
+            (DataFrame, ("            0\n(0.0, 1.0]  a\nNaN         b\n(2.0, 3.0]  c")),
+        ],
+    )
+    def test_repr_missing(self, constructor, expected):
+        # GH 25984
+        index = IntervalIndex.from_tuples([(0, 1), np.nan, (2, 3)])
+        obj = constructor(list("abc"), index=index)
+        result = repr(obj)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "tuples, closed, expected_data",
+        [
+            ([(0, 1), (1, 2), (2, 3)], "left", ["[0, 1)", "[1, 2)", "[2, 3)"]),
+            (
+                [(0.5, 1.0), np.nan, (2.0, 3.0)],
+                "right",
+                ["(0.5, 1.0]", "NaN", "(2.0, 3.0]"],
+            ),
+            (
+                [
+                    (Timestamp("20180101"), Timestamp("20180102")),
+                    np.nan,
+                    ((Timestamp("20180102"), Timestamp("20180103"))),
+                ],
+                "both",
+                ["[2018-01-01, 2018-01-02]", "NaN", "[2018-01-02, 2018-01-03]"],
+            ),
+            (
+                [
+                    (Timedelta("0 days"), Timedelta("1 days")),
+                    (Timedelta("1 days"), Timedelta("2 days")),
+                    np.nan,
+                ],
+                "neither",
+                [
+                    "(0 days 00:00:00, 1 days 00:00:00)",
+                    "(1 days 00:00:00, 2 days 00:00:00)",
+                    "NaN",
+                ],
+            ),
+        ],
+    )
+    def test_to_native_types(self, tuples, closed, expected_data):
+        # GH 28210
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        result = index.to_native_types()
+        expected = np.array(expected_data)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/indexes/interval/test_interval_new.py b/pandas/tests/indexes/interval/test_indexing.py
similarity index 62%
rename from pandas/tests/indexes/interval/test_interval_new.py
rename to pandas/tests/indexes/interval/test_indexing.py
index d92559d2e3e49..87b72f702e2aa 100644
--- a/pandas/tests/indexes/interval/test_interval_new.py
+++ b/pandas/tests/indexes/interval/test_indexing.py
@@ -3,12 +3,19 @@
 import numpy as np
 import pytest
 
-from pandas import Interval, IntervalIndex
+from pandas import (
+    CategoricalIndex,
+    Interval,
+    IntervalIndex,
+    Timedelta,
+    date_range,
+    timedelta_range,
+)
+import pandas._testing as tm
 from pandas.core.indexes.base import InvalidIndexError
-import pandas.util.testing as tm
 
 
-class TestIntervalIndex:
+class TestGetLoc:
     @pytest.mark.parametrize("side", ["right", "left", "both", "neither"])
     def test_get_loc_interval(self, closed, side):
 
@@ -56,129 +63,111 @@ def test_get_loc_scalar(self, closed, scalar):
             with pytest.raises(KeyError, match=str(scalar)):
                 idx.get_loc(scalar)
 
-    def test_slice_locs_with_interval(self):
-
-        # increasing monotonically
-        index = IntervalIndex.from_tuples([(0, 2), (1, 3), (2, 4)])
-
-        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
-        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(end=Interval(0, 2)) == (0, 1)
-        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 1)
-
-        # decreasing monotonically
-        index = IntervalIndex.from_tuples([(2, 4), (1, 3), (0, 2)])
-
-        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (2, 1)
-        assert index.slice_locs(start=Interval(0, 2)) == (2, 3)
-        assert index.slice_locs(end=Interval(2, 4)) == (0, 1)
-        assert index.slice_locs(end=Interval(0, 2)) == (0, 3)
-        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (0, 3)
-
-        # sorted duplicates
-        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4)])
-
-        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
-        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
-        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
+    @pytest.mark.parametrize("scalar", [-1, 0, 0.5, 3, 4.5, 5, 6])
+    def test_get_loc_length_one_scalar(self, scalar, closed):
+        # GH 20921
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        if scalar in index[0]:
+            result = index.get_loc(scalar)
+            assert result == 0
+        else:
+            with pytest.raises(KeyError, match=str(scalar)):
+                index.get_loc(scalar)
+
+    @pytest.mark.parametrize("other_closed", ["left", "right", "both", "neither"])
+    @pytest.mark.parametrize("left, right", [(0, 5), (-1, 4), (-1, 6), (6, 7)])
+    def test_get_loc_length_one_interval(self, left, right, closed, other_closed):
+        # GH 20921
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        interval = Interval(left, right, closed=other_closed)
+        if interval == index[0]:
+            result = index.get_loc(interval)
+            assert result == 0
+        else:
+            with pytest.raises(
+                KeyError,
+                match=re.escape(
+                    "Interval({left}, {right}, closed='{other_closed}')".format(
+                        left=left, right=right, other_closed=other_closed
+                    )
+                ),
+            ):
+                index.get_loc(interval)
+
+    # Make consistent with test_interval_new.py (see #16316, #16386)
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            date_range("20180101", periods=4),
+            date_range("20180101", periods=4, tz="US/Eastern"),
+            timedelta_range("0 days", periods=4),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_get_loc_datetimelike_nonoverlapping(self, breaks):
+        # GH 20636
+        # nonoverlapping = IntervalIndex method and no i8 conversion
+        index = IntervalIndex.from_breaks(breaks)
 
-        # unsorted duplicates
-        index = IntervalIndex.from_tuples([(0, 2), (2, 4), (0, 2)])
+        value = index[0].mid
+        result = index.get_loc(value)
+        expected = 0
+        assert result == expected
 
-        with pytest.raises(
-            KeyError,
-            match=re.escape(
-                '"Cannot get left slice bound for non-unique label:'
-                " Interval(0, 2, closed='right')\""
-            ),
-        ):
-            index.slice_locs(start=Interval(0, 2), end=Interval(2, 4))
+        interval = Interval(index[0].left, index[0].right)
+        result = index.get_loc(interval)
+        expected = 0
+        assert result == expected
 
-        with pytest.raises(
-            KeyError,
-            match=re.escape(
-                '"Cannot get left slice bound for non-unique label:'
-                " Interval(0, 2, closed='right')\""
+    @pytest.mark.parametrize(
+        "arrays",
+        [
+            (date_range("20180101", periods=4), date_range("20180103", periods=4)),
+            (
+                date_range("20180101", periods=4, tz="US/Eastern"),
+                date_range("20180103", periods=4, tz="US/Eastern"),
             ),
-        ):
-            index.slice_locs(start=Interval(0, 2))
-
-        assert index.slice_locs(end=Interval(2, 4)) == (0, 2)
-
-        with pytest.raises(
-            KeyError,
-            match=re.escape(
-                '"Cannot get right slice bound for non-unique label:'
-                " Interval(0, 2, closed='right')\""
+            (
+                timedelta_range("0 days", periods=4),
+                timedelta_range("2 days", periods=4),
             ),
-        ):
-            index.slice_locs(end=Interval(0, 2))
-
-        with pytest.raises(
-            KeyError,
-            match=re.escape(
-                '"Cannot get right slice bound for non-unique label:'
-                " Interval(0, 2, closed='right')\""
-            ),
-        ):
-            index.slice_locs(start=Interval(2, 4), end=Interval(0, 2))
-
-        # another unsorted duplicates
-        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4), (1, 3)])
-
-        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(start=Interval(0, 2)) == (0, 4)
-        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
-        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
-        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
-
-    def test_slice_locs_with_ints_and_floats_succeeds(self):
+        ],
+        ids=lambda x: str(x[0].dtype),
+    )
+    def test_get_loc_datetimelike_overlapping(self, arrays):
+        # GH 20636
+        index = IntervalIndex.from_arrays(*arrays)
 
-        # increasing non-overlapping
-        index = IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)])
+        value = index[0].mid + Timedelta("12 hours")
+        result = index.get_loc(value)
+        expected = slice(0, 2, None)
+        assert result == expected
 
-        assert index.slice_locs(0, 1) == (0, 1)
-        assert index.slice_locs(0, 2) == (0, 2)
-        assert index.slice_locs(0, 3) == (0, 2)
-        assert index.slice_locs(3, 1) == (2, 1)
-        assert index.slice_locs(3, 4) == (2, 3)
-        assert index.slice_locs(0, 4) == (0, 3)
+        interval = Interval(index[0].left, index[0].right)
+        result = index.get_loc(interval)
+        expected = 0
+        assert result == expected
 
-        # decreasing non-overlapping
-        index = IntervalIndex.from_tuples([(3, 4), (1, 2), (0, 1)])
-        assert index.slice_locs(0, 1) == (3, 3)
-        assert index.slice_locs(0, 2) == (3, 2)
-        assert index.slice_locs(0, 3) == (3, 1)
-        assert index.slice_locs(3, 1) == (1, 3)
-        assert index.slice_locs(3, 4) == (1, 1)
-        assert index.slice_locs(0, 4) == (3, 1)
-
-    @pytest.mark.parametrize("query", [[0, 1], [0, 2], [0, 3], [0, 4]])
     @pytest.mark.parametrize(
-        "tuples",
+        "values",
         [
-            [(0, 2), (1, 3), (2, 4)],
-            [(2, 4), (1, 3), (0, 2)],
-            [(0, 2), (0, 2), (2, 4)],
-            [(0, 2), (2, 4), (0, 2)],
-            [(0, 2), (0, 2), (2, 4), (1, 3)],
+            date_range("2018-01-04", periods=4, freq="-1D"),
+            date_range("2018-01-04", periods=4, freq="-1D", tz="US/Eastern"),
+            timedelta_range("3 days", periods=4, freq="-1D"),
+            np.arange(3.0, -1.0, -1.0),
+            np.arange(3, -1, -1),
         ],
+        ids=lambda x: str(x.dtype),
     )
-    def test_slice_locs_with_ints_and_floats_errors(self, tuples, query):
-        start, stop = query
-        index = IntervalIndex.from_tuples(tuples)
-        with pytest.raises(
-            KeyError,
-            match=(
-                "'can only get slices from an IntervalIndex if bounds are"
-                " non-overlapping and all monotonic increasing or decreasing'"
-            ),
-        ):
-            index.slice_locs(start, stop)
+    def test_get_loc_decreasing(self, values):
+        # GH 25860
+        index = IntervalIndex.from_arrays(values[1:], values[:-1])
+        result = index.get_loc(index[0])
+        expected = 0
+        assert result == expected
+
 
+class TestGetIndexer:
     @pytest.mark.parametrize(
         "query, expected",
         [
@@ -233,6 +222,41 @@ def test_get_indexer_with_int_and_float(self, query, expected):
         expected = np.array(expected, dtype="intp")
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize("item", [[3], np.arange(0.5, 5, 0.5)])
+    def test_get_indexer_length_one(self, item, closed):
+        # GH 17284
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        result = index.get_indexer(item)
+        expected = np.array([0] * len(item), dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("size", [1, 5])
+    def test_get_indexer_length_one_interval(self, size, closed):
+        # GH 17284
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        result = index.get_indexer([Interval(0, 5, closed)] * size)
+        expected = np.array([0] * size, dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "target",
+        [
+            IntervalIndex.from_tuples([(7, 8), (1, 2), (3, 4), (0, 1)]),
+            IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4), np.nan]),
+            IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)], closed="both"),
+            [-1, 0, 0.5, 1, 2, 2.5, np.nan],
+            ["foo", "foo", "bar", "baz"],
+        ],
+    )
+    def test_get_indexer_categorical(self, target, ordered_fixture):
+        # GH 30063: categorical and non-categorical results should be consistent
+        index = IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)])
+        categorical_target = CategoricalIndex(target, ordered=ordered_fixture)
+
+        result = index.get_indexer(categorical_target)
+        expected = index.get_indexer(target)
+        tm.assert_numpy_array_equal(result, expected)
+
     @pytest.mark.parametrize(
         "tuples, closed",
         [
@@ -288,19 +312,139 @@ def test_get_indexer_non_unique_with_int_and_float(self, query, expected):
         # TODO we may also want to test get_indexer for the case when
         # the intervals are duplicated, decreasing, non-monotonic, etc..
 
-    def test_contains_dunder(self):
+    def test_get_indexer_non_monotonic(self):
+        # GH 16410
+        idx1 = IntervalIndex.from_tuples([(2, 3), (4, 5), (0, 1)])
+        idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (6, 7), (8, 9)])
+        result = idx1.get_indexer(idx2)
+        expected = np.array([2, 0, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = idx1.get_indexer(idx1[1:])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestSliceLocs:
+    def test_slice_locs_with_interval(self):
+
+        # increasing monotonically
+        index = IntervalIndex.from_tuples([(0, 2), (1, 3), (2, 4)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 1)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 1)
+
+        # decreasing monotonically
+        index = IntervalIndex.from_tuples([(2, 4), (1, 3), (0, 2)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (2, 1)
+        assert index.slice_locs(start=Interval(0, 2)) == (2, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 1)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (0, 3)
+
+        # sorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
+
+        # unsorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (2, 4), (0, 2)])
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get left slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(0, 2), end=Interval(2, 4))
 
-        index = IntervalIndex.from_arrays([0, 1], [1, 2], closed="right")
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get left slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(0, 2))
 
-        # __contains__ requires perfect matches to intervals.
-        assert 0 not in index
-        assert 1 not in index
-        assert 2 not in index
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 2)
 
-        assert Interval(0, 1, closed="right") in index
-        assert Interval(0, 2, closed="right") not in index
-        assert Interval(0, 0.5, closed="right") not in index
-        assert Interval(3, 5, closed="right") not in index
-        assert Interval(-1, 0, closed="left") not in index
-        assert Interval(0, 1, closed="left") not in index
-        assert Interval(0, 1, closed="both") not in index
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get right slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(end=Interval(0, 2))
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get right slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(2, 4), end=Interval(0, 2))
+
+        # another unsorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4), (1, 3)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 4)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
+
+    def test_slice_locs_with_ints_and_floats_succeeds(self):
+
+        # increasing non-overlapping
+        index = IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)])
+
+        assert index.slice_locs(0, 1) == (0, 1)
+        assert index.slice_locs(0, 2) == (0, 2)
+        assert index.slice_locs(0, 3) == (0, 2)
+        assert index.slice_locs(3, 1) == (2, 1)
+        assert index.slice_locs(3, 4) == (2, 3)
+        assert index.slice_locs(0, 4) == (0, 3)
+
+        # decreasing non-overlapping
+        index = IntervalIndex.from_tuples([(3, 4), (1, 2), (0, 1)])
+        assert index.slice_locs(0, 1) == (3, 3)
+        assert index.slice_locs(0, 2) == (3, 2)
+        assert index.slice_locs(0, 3) == (3, 1)
+        assert index.slice_locs(3, 1) == (1, 3)
+        assert index.slice_locs(3, 4) == (1, 1)
+        assert index.slice_locs(0, 4) == (3, 1)
+
+    @pytest.mark.parametrize("query", [[0, 1], [0, 2], [0, 3], [0, 4]])
+    @pytest.mark.parametrize(
+        "tuples",
+        [
+            [(0, 2), (1, 3), (2, 4)],
+            [(2, 4), (1, 3), (0, 2)],
+            [(0, 2), (0, 2), (2, 4)],
+            [(0, 2), (2, 4), (0, 2)],
+            [(0, 2), (0, 2), (2, 4), (1, 3)],
+        ],
+    )
+    def test_slice_locs_with_ints_and_floats_errors(self, tuples, query):
+        start, stop = query
+        index = IntervalIndex.from_tuples(tuples)
+        with pytest.raises(
+            KeyError,
+            match=(
+                "'can only get slices from an IntervalIndex if bounds are "
+                "non-overlapping and all monotonic increasing or decreasing'"
+            ),
+        ):
+            index.slice_locs(start, stop)
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index eeb0f43f4b900..d010060880703 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -17,9 +17,8 @@
     notna,
     timedelta_range,
 )
+import pandas._testing as tm
 import pandas.core.common as com
-from pandas.tests.indexes.common import Base
-import pandas.util.testing as tm
 
 
 @pytest.fixture(scope="class", params=[None, "foo"])
@@ -27,13 +26,8 @@ def name(request):
     return request.param
 
 
-class TestIntervalIndex(Base):
-    _holder = IntervalIndex
-
-    def setup_method(self, method):
-        self.index = IntervalIndex.from_arrays([0, 1], [1, 2])
-        self.index_with_nan = IntervalIndex.from_tuples([(0, 1), np.nan, (1, 2)])
-        self.indices = dict(intervalIndex=tm.makeIntervalIndex(10))
+class TestIntervalIndex:
+    index = IntervalIndex.from_arrays([0, 1], [1, 2])
 
     def create_index(self, closed="right"):
         return IntervalIndex.from_breaks(range(11), closed=closed)
@@ -111,11 +105,11 @@ def test_with_nans(self, closed):
         assert index.hasnans is False
 
         result = index.isna()
-        expected = np.repeat(False, len(index))
+        expected = np.zeros(len(index), dtype=bool)
         tm.assert_numpy_array_equal(result, expected)
 
         result = index.notna()
-        expected = np.repeat(True, len(index))
+        expected = np.ones(len(index), dtype=bool)
         tm.assert_numpy_array_equal(result, expected)
 
         index = self.create_index_with_nan(closed=closed)
@@ -161,47 +155,6 @@ def test_ensure_copied_data(self, closed):
             index.right.values, result.right.values, check_same="copy"
         )
 
-    def test_equals(self, closed):
-        expected = IntervalIndex.from_breaks(np.arange(5), closed=closed)
-        assert expected.equals(expected)
-        assert expected.equals(expected.copy())
-
-        assert not expected.equals(expected.astype(object))
-        assert not expected.equals(np.array(expected))
-        assert not expected.equals(list(expected))
-
-        assert not expected.equals([1, 2])
-        assert not expected.equals(np.array([1, 2]))
-        assert not expected.equals(pd.date_range("20130101", periods=2))
-
-        expected_name1 = IntervalIndex.from_breaks(
-            np.arange(5), closed=closed, name="foo"
-        )
-        expected_name2 = IntervalIndex.from_breaks(
-            np.arange(5), closed=closed, name="bar"
-        )
-        assert expected.equals(expected_name1)
-        assert expected_name1.equals(expected_name2)
-
-        for other_closed in {"left", "right", "both", "neither"} - {closed}:
-            expected_other_closed = IntervalIndex.from_breaks(
-                np.arange(5), closed=other_closed
-            )
-            assert not expected.equals(expected_other_closed)
-
-    @pytest.mark.parametrize("klass", [list, tuple, np.array, pd.Series])
-    def test_where(self, closed, klass):
-        idx = self.create_index(closed=closed)
-        cond = [True] * len(idx)
-        expected = idx
-        result = expected.where(klass(cond))
-        tm.assert_index_equal(result, expected)
-
-        cond = [False] + [True] * len(idx[1:])
-        expected = IntervalIndex([np.nan] + idx[1:].tolist())
-        result = idx.where(klass(cond))
-        tm.assert_index_equal(result, expected)
-
     def test_delete(self, closed):
         expected = IntervalIndex.from_breaks(np.arange(1, 11), closed=closed)
         result = self.create_index(closed=closed).delete(0)
@@ -254,16 +207,6 @@ def test_insert(self, data):
             result = data.insert(1, na)
             tm.assert_index_equal(result, expected)
 
-    def test_take(self, closed):
-        index = self.create_index(closed=closed)
-
-        result = index.take(range(10))
-        tm.assert_index_equal(result, index)
-
-        result = index.take([0, 0, 1])
-        expected = IntervalIndex.from_arrays([0, 0, 1], [1, 1, 2], closed=closed)
-        tm.assert_index_equal(result, expected)
-
     def test_is_unique_interval(self, closed):
         """
         Interval specific tests for is_unique in addition to base class tests
@@ -351,112 +294,6 @@ def test_monotonic(self, closed):
         assert idx.is_monotonic_decreasing is True
         assert idx._is_strictly_monotonic_decreasing is True
 
-    @pytest.mark.skip(reason="not a valid repr as we use interval notation")
-    def test_repr(self):
-        i = IntervalIndex.from_tuples([(0, 1), (1, 2)], closed="right")
-        expected = (
-            "IntervalIndex(left=[0, 1],"
-            "\n              right=[1, 2],"
-            "\n              closed='right',"
-            "\n              dtype='interval[int64]')"
-        )
-        assert repr(i) == expected
-
-        i = IntervalIndex.from_tuples(
-            (Timestamp("20130101"), Timestamp("20130102")),
-            (Timestamp("20130102"), Timestamp("20130103")),
-            closed="right",
-        )
-        expected = (
-            "IntervalIndex(left=['2013-01-01', '2013-01-02'],"
-            "\n              right=['2013-01-02', '2013-01-03'],"
-            "\n              closed='right',"
-            "\n              dtype='interval[datetime64[ns]]')"
-        )
-        assert repr(i) == expected
-
-    @pytest.mark.skip(reason="not a valid repr as we use interval notation")
-    def test_repr_max_seq_item_setting(self):
-        super().test_repr_max_seq_item_setting()
-
-    @pytest.mark.skip(reason="not a valid repr as we use interval notation")
-    def test_repr_roundtrip(self):
-        super().test_repr_roundtrip()
-
-    def test_frame_repr(self):
-        # https://github.com/pandas-dev/pandas/pull/24134/files
-        df = pd.DataFrame(
-            {"A": [1, 2, 3, 4]}, index=pd.IntervalIndex.from_breaks([0, 1, 2, 3, 4])
-        )
-        result = repr(df)
-        expected = "        A\n(0, 1]  1\n(1, 2]  2\n(2, 3]  3\n(3, 4]  4"
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "constructor,expected",
-        [
-            (
-                pd.Series,
-                (
-                    "(0.0, 1.0]    a\n"
-                    "NaN           b\n"
-                    "(2.0, 3.0]    c\n"
-                    "dtype: object"
-                ),
-            ),
-            (
-                pd.DataFrame,
-                ("            0\n(0.0, 1.0]  a\nNaN         b\n(2.0, 3.0]  c"),
-            ),
-        ],
-    )
-    def test_repr_missing(self, constructor, expected):
-        # GH 25984
-        index = IntervalIndex.from_tuples([(0, 1), np.nan, (2, 3)])
-        obj = constructor(list("abc"), index=index)
-        result = repr(obj)
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "tuples, closed, expected_data",
-        [
-            ([(0, 1), (1, 2), (2, 3)], "left", ["[0, 1)", "[1, 2)", "[2, 3)"]),
-            (
-                [(0.5, 1.0), np.nan, (2.0, 3.0)],
-                "right",
-                ["(0.5, 1.0]", "NaN", "(2.0, 3.0]"],
-            ),
-            (
-                [
-                    (Timestamp("20180101"), Timestamp("20180102")),
-                    np.nan,
-                    ((Timestamp("20180102"), Timestamp("20180103"))),
-                ],
-                "both",
-                ["[2018-01-01, 2018-01-02]", "NaN", "[2018-01-02, 2018-01-03]"],
-            ),
-            (
-                [
-                    (Timedelta("0 days"), Timedelta("1 days")),
-                    (Timedelta("1 days"), Timedelta("2 days")),
-                    np.nan,
-                ],
-                "neither",
-                [
-                    "(0 days 00:00:00, 1 days 00:00:00)",
-                    "(1 days 00:00:00, 2 days 00:00:00)",
-                    "NaN",
-                ],
-            ),
-        ],
-    )
-    def test_to_native_types(self, tuples, closed, expected_data):
-        # GH 28210
-        index = IntervalIndex.from_tuples(tuples, closed=closed)
-        result = index.to_native_types()
-        expected = np.array(expected_data)
-        tm.assert_numpy_array_equal(result, expected)
-
     def test_get_item(self, closed):
         i = IntervalIndex.from_arrays((0, 1, np.nan), (1, 2, np.nan), closed=closed)
         assert i[0] == Interval(0.0, 1.0, closed=closed)
@@ -477,125 +314,6 @@ def test_get_item(self, closed):
         )
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize("scalar", [-1, 0, 0.5, 3, 4.5, 5, 6])
-    def test_get_loc_length_one_scalar(self, scalar, closed):
-        # GH 20921
-        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
-        if scalar in index[0]:
-            result = index.get_loc(scalar)
-            assert result == 0
-        else:
-            with pytest.raises(KeyError, match=str(scalar)):
-                index.get_loc(scalar)
-
-    @pytest.mark.parametrize("other_closed", ["left", "right", "both", "neither"])
-    @pytest.mark.parametrize("left, right", [(0, 5), (-1, 4), (-1, 6), (6, 7)])
-    def test_get_loc_length_one_interval(self, left, right, closed, other_closed):
-        # GH 20921
-        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
-        interval = Interval(left, right, closed=other_closed)
-        if interval == index[0]:
-            result = index.get_loc(interval)
-            assert result == 0
-        else:
-            with pytest.raises(
-                KeyError,
-                match=re.escape(
-                    "Interval({left}, {right}, closed='{other_closed}')".format(
-                        left=left, right=right, other_closed=other_closed
-                    )
-                ),
-            ):
-                index.get_loc(interval)
-
-    # Make consistent with test_interval_new.py (see #16316, #16386)
-    @pytest.mark.parametrize(
-        "breaks",
-        [
-            date_range("20180101", periods=4),
-            date_range("20180101", periods=4, tz="US/Eastern"),
-            timedelta_range("0 days", periods=4),
-        ],
-        ids=lambda x: str(x.dtype),
-    )
-    def test_get_loc_datetimelike_nonoverlapping(self, breaks):
-        # GH 20636
-        # nonoverlapping = IntervalIndex method and no i8 conversion
-        index = IntervalIndex.from_breaks(breaks)
-
-        value = index[0].mid
-        result = index.get_loc(value)
-        expected = 0
-        assert result == expected
-
-        interval = Interval(index[0].left, index[0].right)
-        result = index.get_loc(interval)
-        expected = 0
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "arrays",
-        [
-            (date_range("20180101", periods=4), date_range("20180103", periods=4)),
-            (
-                date_range("20180101", periods=4, tz="US/Eastern"),
-                date_range("20180103", periods=4, tz="US/Eastern"),
-            ),
-            (
-                timedelta_range("0 days", periods=4),
-                timedelta_range("2 days", periods=4),
-            ),
-        ],
-        ids=lambda x: str(x[0].dtype),
-    )
-    def test_get_loc_datetimelike_overlapping(self, arrays):
-        # GH 20636
-        index = IntervalIndex.from_arrays(*arrays)
-
-        value = index[0].mid + Timedelta("12 hours")
-        result = index.get_loc(value)
-        expected = slice(0, 2, None)
-        assert result == expected
-
-        interval = Interval(index[0].left, index[0].right)
-        result = index.get_loc(interval)
-        expected = 0
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "values",
-        [
-            date_range("2018-01-04", periods=4, freq="-1D"),
-            date_range("2018-01-04", periods=4, freq="-1D", tz="US/Eastern"),
-            timedelta_range("3 days", periods=4, freq="-1D"),
-            np.arange(3.0, -1.0, -1.0),
-            np.arange(3, -1, -1),
-        ],
-        ids=lambda x: str(x.dtype),
-    )
-    def test_get_loc_decreasing(self, values):
-        # GH 25860
-        index = IntervalIndex.from_arrays(values[1:], values[:-1])
-        result = index.get_loc(index[0])
-        expected = 0
-        assert result == expected
-
-    @pytest.mark.parametrize("item", [[3], np.arange(0.5, 5, 0.5)])
-    def test_get_indexer_length_one(self, item, closed):
-        # GH 17284
-        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
-        result = index.get_indexer(item)
-        expected = np.array([0] * len(item), dtype="intp")
-        tm.assert_numpy_array_equal(result, expected)
-
-    @pytest.mark.parametrize("size", [1, 5])
-    def test_get_indexer_length_one_interval(self, size, closed):
-        # GH 17284
-        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
-        result = index.get_indexer([Interval(0, 5, closed)] * size)
-        expected = np.array([0] * size, dtype="intp")
-        tm.assert_numpy_array_equal(result, expected)
-
     @pytest.mark.parametrize(
         "breaks",
         [
@@ -737,6 +455,23 @@ def test_contains_method(self):
         ):
             i.contains(Interval(0, 1))
 
+    def test_contains_dunder(self):
+
+        index = IntervalIndex.from_arrays([0, 1], [1, 2], closed="right")
+
+        # __contains__ requires perfect matches to intervals.
+        assert 0 not in index
+        assert 1 not in index
+        assert 2 not in index
+
+        assert Interval(0, 1, closed="right") in index
+        assert Interval(0, 2, closed="right") not in index
+        assert Interval(0, 0.5, closed="right") not in index
+        assert Interval(3, 5, closed="right") not in index
+        assert Interval(-1, 0, closed="left") not in index
+        assert Interval(0, 1, closed="left") not in index
+        assert Interval(0, 1, closed="both") not in index
+
     def test_dropna(self, closed):
 
         expected = IntervalIndex.from_tuples([(0.0, 1.0), (1.0, 2.0)], closed=closed)
@@ -851,8 +586,8 @@ def test_missing_values(self, closed):
         assert idx.equals(idx2)
 
         msg = (
-            "missing values must be missing in the same location both left"
-            " and right sides"
+            "missing values must be missing in the same location both left "
+            "and right sides"
         )
         with pytest.raises(ValueError, match=msg):
             IntervalIndex.from_arrays(
@@ -938,10 +673,7 @@ def test_append(self, closed):
         )
         tm.assert_index_equal(result, expected)
 
-        msg = (
-            "can only append two IntervalIndex objects that are closed "
-            "on the same side"
-        )
+        msg = "Intervals must all be closed on the same side"
         for other_closed in {"left", "right", "both", "neither"} - {closed}:
             index_other_closed = IntervalIndex.from_arrays(
                 [0, 1], [1, 2], closed=other_closed
@@ -1101,17 +833,6 @@ def test_nbytes(self):
         expected = 64  # 4 * 8 * 2
         assert result == expected
 
-    def test_itemsize(self):
-        # GH 19209
-        left = np.arange(0, 4, dtype="i8")
-        right = np.arange(1, 5, dtype="i8")
-        expected = 16  # 8 * 2
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = IntervalIndex.from_arrays(left, right).itemsize
-
-        assert result == expected
-
     @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
     def test_set_closed(self, name, closed, new_closed):
         # GH 21670
diff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py
index b102444b4ec9c..2f28c33a3bbc6 100644
--- a/pandas/tests/indexes/interval/test_interval_range.py
+++ b/pandas/tests/indexes/interval/test_interval_range.py
@@ -15,7 +15,7 @@
     interval_range,
     timedelta_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import Day
 
@@ -84,7 +84,7 @@ def test_constructor_timestamp(self, closed, name, freq, periods, tz):
         tm.assert_index_equal(result, expected)
 
         # GH 20976: linspace behavior defined from start/end/periods
-        if not breaks.freq.isAnchored() and tz is None:
+        if not breaks.freq.is_anchored() and tz is None:
             # matches expected only for non-anchored offsets and tz naive
             # (anchored/DST transitions cause unequal spacing in expected)
             result = interval_range(
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index 87f9eaa209277..476ec1dd10b4b 100644
--- a/pandas/tests/indexes/interval/test_interval_tree.py
+++ b/pandas/tests/indexes/interval/test_interval_tree.py
@@ -6,7 +6,7 @@
 from pandas._libs.interval import IntervalTree
 
 from pandas import compat
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def skipif_32bit(param):
@@ -20,9 +20,7 @@ def skipif_32bit(param):
     return pytest.param(param, marks=marks)
 
 
-@pytest.fixture(
-    scope="class", params=["int32", "int64", "float32", "float64", "uint64"]
-)
+@pytest.fixture(scope="class", params=["int64", "float64", "uint64"])
 def dtype(request):
     return request.param
 
@@ -39,12 +37,9 @@ def leaf_size(request):
 @pytest.fixture(
     params=[
         np.arange(5, dtype="int64"),
-        np.arange(5, dtype="int32"),
         np.arange(5, dtype="uint64"),
         np.arange(5, dtype="float64"),
-        np.arange(5, dtype="float32"),
         np.array([0, 1, 2, 3, 4, np.nan], dtype="float64"),
-        np.array([0, 1, 2, 3, 4, np.nan], dtype="float32"),
     ]
 )
 def tree(request, leaf_size):
@@ -53,18 +48,6 @@ def tree(request, leaf_size):
 
 
 class TestIntervalTree:
-    def test_get_loc(self, tree):
-        result = tree.get_loc(1)
-        expected = np.array([0], dtype="intp")
-        tm.assert_numpy_array_equal(result, expected)
-
-        result = np.sort(tree.get_loc(2))
-        expected = np.array([0, 1], dtype="intp")
-        tm.assert_numpy_array_equal(result, expected)
-
-        with pytest.raises(KeyError, match="-1"):
-            tree.get_loc(-1)
-
     def test_get_indexer(self, tree):
         result = tree.get_indexer(np.array([1.0, 5.5, 6.5]))
         expected = np.array([0, 4, -1], dtype="intp")
@@ -75,6 +58,18 @@ def test_get_indexer(self, tree):
         ):
             tree.get_indexer(np.array([3.0]))
 
+    @pytest.mark.parametrize(
+        "dtype, target_value, target_dtype",
+        [("int64", 2 ** 63 + 1, "uint64"), ("uint64", -1, "int64")],
+    )
+    def test_get_indexer_overflow(self, dtype, target_value, target_dtype):
+        left, right = np.array([0, 1], dtype=dtype), np.array([1, 2], dtype=dtype)
+        tree = IntervalTree(left, right)
+
+        result = tree.get_indexer(np.array([target_value], dtype=target_dtype))
+        expected = np.array([-1], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_get_indexer_non_unique(self, tree):
         indexer, missing = tree.get_indexer_non_unique(np.array([1.0, 2.0, 6.5]))
 
@@ -94,14 +89,26 @@ def test_get_indexer_non_unique(self, tree):
         expected = np.array([2], dtype="intp")
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "dtype, target_value, target_dtype",
+        [("int64", 2 ** 63 + 1, "uint64"), ("uint64", -1, "int64")],
+    )
+    def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype):
+        left, right = np.array([0, 2], dtype=dtype), np.array([1, 3], dtype=dtype)
+        tree = IntervalTree(left, right)
+        target = np.array([target_value], dtype=target_dtype)
+
+        result_indexer, result_missing = tree.get_indexer_non_unique(target)
+        expected_indexer = np.array([-1], dtype="intp")
+        tm.assert_numpy_array_equal(result_indexer, expected_indexer)
+
+        expected_missing = np.array([0], dtype="intp")
+        tm.assert_numpy_array_equal(result_missing, expected_missing)
+
     def test_duplicates(self, dtype):
         left = np.array([0, 0, 0], dtype=dtype)
         tree = IntervalTree(left, left + 1)
 
-        result = np.sort(tree.get_loc(0.5))
-        expected = np.array([0, 1, 2], dtype="intp")
-        tm.assert_numpy_array_equal(result, expected)
-
         with pytest.raises(
             KeyError, match="'indexer does not intersect a unique set of intervals'"
         ):
@@ -116,17 +123,6 @@ def test_duplicates(self, dtype):
         expected = np.array([], dtype="intp")
         tm.assert_numpy_array_equal(result, expected)
 
-    def test_get_loc_closed(self, closed):
-        tree = IntervalTree([0], [1], closed=closed)
-        for p, errors in [(0, tree.open_left), (1, tree.open_right)]:
-            if errors:
-                with pytest.raises(KeyError, match=str(p)):
-                    tree.get_loc(p)
-            else:
-                result = tree.get_loc(p)
-                expected = np.array([0], dtype="intp")
-                tm.assert_numpy_array_equal(result, expected)
-
     @pytest.mark.parametrize(
         "leaf_size", [skipif_32bit(1), skipif_32bit(10), skipif_32bit(100), 10000]
     )
@@ -147,25 +143,25 @@ def test_get_indexer_closed(self, closed, leaf_size):
     @pytest.mark.parametrize(
         "left, right, expected",
         [
-            (np.array([0, 1, 4]), np.array([2, 3, 5]), True),
-            (np.array([0, 1, 2]), np.array([5, 4, 3]), True),
+            (np.array([0, 1, 4], dtype="int64"), np.array([2, 3, 5]), True),
+            (np.array([0, 1, 2], dtype="int64"), np.array([5, 4, 3]), True),
             (np.array([0, 1, np.nan]), np.array([5, 4, np.nan]), True),
-            (np.array([0, 2, 4]), np.array([1, 3, 5]), False),
+            (np.array([0, 2, 4], dtype="int64"), np.array([1, 3, 5]), False),
             (np.array([0, 2, np.nan]), np.array([1, 3, np.nan]), False),
         ],
     )
-    @pytest.mark.parametrize("order", map(list, permutations(range(3))))
+    @pytest.mark.parametrize("order", (list(x) for x in permutations(range(3))))
     def test_is_overlapping(self, closed, order, left, right, expected):
         # GH 23309
         tree = IntervalTree(left[order], right[order], closed=closed)
         result = tree.is_overlapping
         assert result is expected
 
-    @pytest.mark.parametrize("order", map(list, permutations(range(3))))
+    @pytest.mark.parametrize("order", (list(x) for x in permutations(range(3))))
     def test_is_overlapping_endpoints(self, closed, order):
         """shared endpoints are marked as overlapping"""
         # GH 23309
-        left, right = np.arange(3), np.arange(1, 4)
+        left, right = np.arange(3, dtype="int64"), np.arange(1, 4)
         tree = IntervalTree(left[order], right[order], closed=closed)
         result = tree.is_overlapping
         expected = closed == "both"
@@ -188,7 +184,7 @@ def test_is_overlapping_trivial(self, closed, left, right):
     @pytest.mark.skipif(compat.is_platform_32bit(), reason="GH 23440")
     def test_construction_overflow(self):
         # GH 25485
-        left, right = np.arange(101), [np.iinfo(np.int64).max] * 101
+        left, right = np.arange(101, dtype="int64"), [np.iinfo(np.int64).max] * 101
         tree = IntervalTree(left, right)
 
         # pivot should be average of left/right medians
diff --git a/pandas/tests/indexes/interval/test_setops.py b/pandas/tests/indexes/interval/test_setops.py
index 89e733c30b1e3..3246ac6bafde9 100644
--- a/pandas/tests/indexes/interval/test_setops.py
+++ b/pandas/tests/indexes/interval/test_setops.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import Index, IntervalIndex, Timestamp, interval_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture(scope="class", params=[None, "foo"])
diff --git a/pandas/tests/indexes/multi/conftest.py b/pandas/tests/indexes/multi/conftest.py
index acaea4ff96ff5..67ebfcddf6c2d 100644
--- a/pandas/tests/indexes/multi/conftest.py
+++ b/pandas/tests/indexes/multi/conftest.py
@@ -49,12 +49,6 @@ def index_names():
     return ["first", "second"]
 
 
-@pytest.fixture
-def holder():
-    # the MultiIndex constructor used to base compatibility with pickle
-    return MultiIndex
-
-
 @pytest.fixture
 def compat_props():
     # a MultiIndex must have these properties associated with it
diff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py
index 36152bc4b60cd..a9e02934f27ab 100644
--- a/pandas/tests/indexes/multi/test_analytics.py
+++ b/pandas/tests/indexes/multi/test_analytics.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex, date_range, period_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_shift(idx):
@@ -146,83 +146,6 @@ def test_append_mixed_dtypes():
     tm.assert_index_equal(res, exp)
 
 
-def test_take(idx):
-    indexer = [4, 3, 0, 2]
-    result = idx.take(indexer)
-    expected = idx[indexer]
-    assert result.equals(expected)
-
-    # TODO: Remove Commented Code
-    # if not isinstance(idx,
-    #                   (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
-    # GH 10791
-    msg = "'MultiIndex' object has no attribute 'freq'"
-    with pytest.raises(AttributeError, match=msg):
-        idx.freq
-
-
-def test_take_invalid_kwargs(idx):
-    idx = idx
-    indices = [1, 2]
-
-    msg = r"take\(\) got an unexpected keyword argument 'foo'"
-    with pytest.raises(TypeError, match=msg):
-        idx.take(indices, foo=2)
-
-    msg = "the 'out' parameter is not supported"
-    with pytest.raises(ValueError, match=msg):
-        idx.take(indices, out=indices)
-
-    msg = "the 'mode' parameter is not supported"
-    with pytest.raises(ValueError, match=msg):
-        idx.take(indices, mode="clip")
-
-
-def test_take_fill_value():
-    # GH 12631
-    vals = [["A", "B"], [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]]
-    idx = pd.MultiIndex.from_product(vals, names=["str", "dt"])
-
-    result = idx.take(np.array([1, 0, -1]))
-    exp_vals = [
-        ("A", pd.Timestamp("2011-01-02")),
-        ("A", pd.Timestamp("2011-01-01")),
-        ("B", pd.Timestamp("2011-01-02")),
-    ]
-    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
-    tm.assert_index_equal(result, expected)
-
-    # fill_value
-    result = idx.take(np.array([1, 0, -1]), fill_value=True)
-    exp_vals = [
-        ("A", pd.Timestamp("2011-01-02")),
-        ("A", pd.Timestamp("2011-01-01")),
-        (np.nan, pd.NaT),
-    ]
-    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
-    tm.assert_index_equal(result, expected)
-
-    # allow_fill=False
-    result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-    exp_vals = [
-        ("A", pd.Timestamp("2011-01-02")),
-        ("A", pd.Timestamp("2011-01-01")),
-        ("B", pd.Timestamp("2011-01-02")),
-    ]
-    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
-    tm.assert_index_equal(result, expected)
-
-    msg = "When allow_fill=True and fill_value is not None, all indices must be >= -1"
-    with pytest.raises(ValueError, match=msg):
-        idx.take(np.array([1, 0, -2]), fill_value=True)
-    with pytest.raises(ValueError, match=msg):
-        idx.take(np.array([1, 0, -5]), fill_value=True)
-
-    msg = "index -5 is out of bounds for size 4"
-    with pytest.raises(IndexError, match=msg):
-        idx.take(np.array([1, -5]))
-
-
 def test_iter(idx):
     result = list(idx)
     expected = [
@@ -277,7 +200,7 @@ def test_map(idx):
 def test_map_dictlike(idx, mapper):
 
     if isinstance(idx, (pd.CategoricalIndex, pd.IntervalIndex)):
-        pytest.skip("skipping tests for {}".format(type(idx)))
+        pytest.skip(f"skipping tests for {type(idx)}")
 
     identity = mapper(idx.values, idx)
 
@@ -326,17 +249,17 @@ def test_map_dictlike(idx, mapper):
 )
 def test_numpy_ufuncs(idx, func):
     # test ufuncs of numpy. see:
-    # http://docs.scipy.org/doc/numpy/reference/ufuncs.html
+    # https://docs.scipy.org/doc/numpy/reference/ufuncs.html
 
     if _np_version_under1p17:
         expected_exception = AttributeError
-        msg = "'tuple' object has no attribute '{}'".format(func.__name__)
+        msg = f"'tuple' object has no attribute '{func.__name__}'"
     else:
         expected_exception = TypeError
         msg = (
-            "loop of ufunc does not support argument 0 of type tuple which"
-            " has no callable {} method"
-        ).format(func.__name__)
+            "loop of ufunc does not support argument 0 of type tuple which "
+            f"has no callable {func.__name__} method"
+        )
     with pytest.raises(expected_exception, match=msg):
         func(idx)
 
@@ -348,9 +271,9 @@ def test_numpy_ufuncs(idx, func):
 )
 def test_numpy_type_funcs(idx, func):
     msg = (
-        "ufunc '{}' not supported for the input types, and the inputs"
-        " could not be safely coerced to any supported types according to"
-        " the casting rule ''safe''"
-    ).format(func.__name__)
+        f"ufunc '{func.__name__}' not supported for the input types, and the inputs "
+        "could not be safely coerced to any supported types according to "
+        "the casting rule ''safe''"
+    )
     with pytest.raises(TypeError, match=msg):
         func(idx)
diff --git a/pandas/tests/indexes/multi/test_astype.py b/pandas/tests/indexes/multi/test_astype.py
index 4adcdd0112b26..29908537fbe59 100644
--- a/pandas/tests/indexes/multi/test_astype.py
+++ b/pandas/tests/indexes/multi/test_astype.py
@@ -3,15 +3,15 @@
 
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
-from pandas.util.testing import assert_copy
+import pandas._testing as tm
 
 
 def test_astype(idx):
     expected = idx.copy()
     actual = idx.astype("O")
-    assert_copy(actual.levels, expected.levels)
-    assert_copy(actual.codes, expected.codes)
-    assert [level.name for level in actual.levels] == list(expected.names)
+    tm.assert_copy(actual.levels, expected.levels)
+    tm.assert_copy(actual.codes, expected.codes)
+    assert actual.names == list(expected.names)
 
     with pytest.raises(TypeError, match="^Setting.*dtype.*object"):
         idx.astype(np.dtype(int))
diff --git a/pandas/tests/indexes/multi/test_compat.py b/pandas/tests/indexes/multi/test_compat.py
index b02f87dc4aacb..9a76f0623eb31 100644
--- a/pandas/tests/indexes/multi/test_compat.py
+++ b/pandas/tests/indexes/multi/test_compat.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_numeric_compat(idx):
@@ -112,12 +112,8 @@ def test_ndarray_compat_properties(idx, compat_props):
     idx.values.nbytes
 
 
-def test_compat(indices):
-    assert indices.tolist() == list(indices)
-
-
-def test_pickle_compat_construction(holder):
+def test_pickle_compat_construction():
     # this is testing for pickle compat
     # need an object to create with
     with pytest.raises(TypeError, match="Must pass both levels and codes"):
-        holder()
+        MultiIndex()
diff --git a/pandas/tests/indexes/multi/test_constructor.py b/pandas/tests/indexes/multi/test_constructors.py
similarity index 89%
rename from pandas/tests/indexes/multi/test_constructor.py
rename to pandas/tests/indexes/multi/test_constructors.py
index 86c9ee3455d0b..2c4b3ce04f96d 100644
--- a/pandas/tests/indexes/multi/test_constructor.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 import numpy as np
 import pytest
 
@@ -9,7 +7,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_constructor_single_level():
@@ -67,8 +65,8 @@ def test_constructor_mismatched_codes_levels(idx):
         MultiIndex(levels=levels, codes=codes)
 
     length_error = (
-        r"On level 0, code max \(3\) >= length of level \(1\)\."
-        " NOTE: this index is in an inconsistent state"
+        r"On level 0, code max \(3\) >= length of level \(1\)\. "
+        "NOTE: this index is in an inconsistent state"
     )
     label_error = r"Unequal code lengths: \[4, 2\]"
     code_value_error = r"On level 0, code value \(-2\) < -1"
@@ -128,18 +126,6 @@ def test_na_levels():
     tm.assert_index_equal(result, expected)
 
 
-def test_labels_deprecated(idx):
-    # GH23752
-    with tm.assert_produces_warning(FutureWarning):
-        MultiIndex(
-            levels=[["foo", "bar", "baz", "qux"]],
-            labels=[[0, 1, 2, 3]],
-            names=["first"],
-        )
-    with tm.assert_produces_warning(FutureWarning):
-        idx.labels
-
-
 def test_copy_in_constructor():
     levels = np.array(["a", "b", "c"])
     codes = np.array([1, 1, 2, 0, 0, 1, 1])
@@ -294,6 +280,7 @@ def test_from_arrays_empty():
     assert isinstance(result, MultiIndex)
     expected = Index([], name="A")
     tm.assert_index_equal(result.levels[0], expected)
+    assert result.names == ["A"]
 
     # N levels
     for N in [2, 3]:
@@ -348,6 +335,19 @@ def test_from_arrays_different_lengths(idx1, idx2):
         MultiIndex.from_arrays([idx1, idx2])
 
 
+def test_from_arrays_respects_none_names():
+    # GH27292
+    a = pd.Series([1, 2, 3], name="foo")
+    b = pd.Series(["a", "b", "c"], name="bar")
+
+    result = MultiIndex.from_arrays([a, b], names=None)
+    expected = MultiIndex(
+        levels=[[1, 2, 3], ["a", "b", "c"]], codes=[[0, 1, 2], [0, 1, 2]], names=None
+    )
+
+    tm.assert_index_equal(result, expected)
+
+
 # ----------------------------------------------------------------------------
 # from_tuples
 # ----------------------------------------------------------------------------
@@ -428,6 +428,7 @@ def test_from_product_empty_one_level():
     result = MultiIndex.from_product([[]], names=["A"])
     expected = pd.Index([], name="A")
     tm.assert_index_equal(result.levels[0], expected)
+    assert result.names == ["A"]
 
 
 @pytest.mark.parametrize(
@@ -539,6 +540,54 @@ def test_from_product_iterator():
         MultiIndex.from_product(0)
 
 
+@pytest.mark.parametrize(
+    "a, b, expected_names",
+    [
+        (
+            pd.Series([1, 2, 3], name="foo"),
+            pd.Series(["a", "b"], name="bar"),
+            ["foo", "bar"],
+        ),
+        (pd.Series([1, 2, 3], name="foo"), ["a", "b"], ["foo", None]),
+        ([1, 2, 3], ["a", "b"], None),
+    ],
+)
+def test_from_product_infer_names(a, b, expected_names):
+    # GH27292
+    result = MultiIndex.from_product([a, b])
+    expected = MultiIndex(
+        levels=[[1, 2, 3], ["a", "b"]],
+        codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+        names=expected_names,
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_from_product_respects_none_names():
+    # GH27292
+    a = pd.Series([1, 2, 3], name="foo")
+    b = pd.Series(["a", "b"], name="bar")
+
+    result = MultiIndex.from_product([a, b], names=None)
+    expected = MultiIndex(
+        levels=[[1, 2, 3], ["a", "b"]],
+        codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+        names=None,
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_from_product_readonly():
+    # GH#15286 passing read-only array to from_product
+    a = np.array(range(3))
+    b = ["a", "b"]
+    expected = MultiIndex.from_product([a, b])
+
+    a.setflags(write=False)
+    result = MultiIndex.from_product([a, b])
+    tm.assert_index_equal(result, expected)
+
+
 def test_create_index_existing_name(idx):
 
     # GH11193, when an existing index is passed, and a new name is not
@@ -557,12 +606,11 @@ def test_create_index_existing_name(idx):
                 ("qux", "two"),
             ],
             dtype="object",
-        ),
-        names=["foo", "bar"],
+        )
     )
     tm.assert_index_equal(result, expected)
 
-    result = pd.Index(index, names=["A", "B"])
+    result = pd.Index(index, name="A")
     expected = Index(
         Index(
             [
@@ -575,7 +623,7 @@ def test_create_index_existing_name(idx):
             ],
             dtype="object",
         ),
-        names=["A", "B"],
+        name="A",
     )
     tm.assert_index_equal(result, expected)
 
@@ -615,14 +663,12 @@ def test_from_frame_error(non_frame):
 def test_from_frame_dtype_fidelity():
     # GH 22420
     df = pd.DataFrame(
-        OrderedDict(
-            [
-                ("dates", pd.date_range("19910905", periods=6, tz="US/Eastern")),
-                ("a", [1, 1, 1, 2, 2, 2]),
-                ("b", pd.Categorical(["a", "a", "b", "b", "c", "c"], ordered=True)),
-                ("c", ["x", "x", "y", "z", "x", "y"]),
-            ]
-        )
+        {
+            "dates": pd.date_range("19910905", periods=6, tz="US/Eastern"),
+            "a": [1, 1, 1, 2, 2, 2],
+            "b": pd.Categorical(["a", "a", "b", "b", "c", "c"], ordered=True),
+            "c": ["x", "x", "y", "z", "x", "y"],
+        }
     )
     original_dtypes = df.dtypes.to_dict()
 
@@ -670,3 +716,10 @@ def test_from_frame_invalid_names(names, expected_error_msg):
     )
     with pytest.raises(ValueError, match=expected_error_msg):
         pd.MultiIndex.from_frame(df, names=names)
+
+
+def test_index_equal_empty_iterable():
+    # #16844
+    a = MultiIndex(levels=[[], []], codes=[[], []], names=["a", "b"])
+    b = MultiIndex.from_arrays(arrays=[[], []], names=["a", "b"])
+    tm.assert_index_equal(a, b)
diff --git a/pandas/tests/indexes/multi/test_contains.py b/pandas/tests/indexes/multi/test_contains.py
index 64d2859cd13db..49aa63210cd5e 100644
--- a/pandas/tests/indexes/multi/test_contains.py
+++ b/pandas/tests/indexes/multi/test_contains.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_contains_top_level():
@@ -98,3 +98,27 @@ def test_isin_level_kwarg():
 
     with pytest.raises(KeyError, match="'Level C not found'"):
         idx.isin(vals_1, level="C")
+
+
+def test_contains_with_missing_value():
+    # issue 19132
+    idx = MultiIndex.from_arrays([[1, np.nan, 2]])
+    assert np.nan in idx
+
+    idx = MultiIndex.from_arrays([[1, 2], [np.nan, 3]])
+    assert np.nan not in idx
+    assert (1, np.nan) in idx
+
+
+@pytest.mark.parametrize(
+    "labels,expected,level",
+    [
+        ([("b", np.nan)], np.array([False, False, True]), None,),
+        ([np.nan, "a"], np.array([True, True, False]), 0),
+        (["d", np.nan], np.array([False, True, True]), 1),
+    ],
+)
+def test_isin_multi_index_with_missing_value(labels, expected, level):
+    # GH 19132
+    midx = MultiIndex.from_arrays([[np.nan, "a", "b"], ["c", "d", np.nan]])
+    tm.assert_numpy_array_equal(midx.isin(labels, level=level), expected)
diff --git a/pandas/tests/indexes/multi/test_conversion.py b/pandas/tests/indexes/multi/test_conversion.py
index 3fc73dd05bc72..bfc432a18458a 100644
--- a/pandas/tests/indexes/multi/test_conversion.py
+++ b/pandas/tests/indexes/multi/test_conversion.py
@@ -1,11 +1,9 @@
-from collections import OrderedDict
-
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_tolist(idx):
@@ -107,14 +105,12 @@ def test_to_frame_dtype_fidelity():
     original_dtypes = {name: mi.levels[i].dtype for i, name in enumerate(mi.names)}
 
     expected_df = pd.DataFrame(
-        OrderedDict(
-            [
-                ("dates", pd.date_range("19910905", periods=6, tz="US/Eastern")),
-                ("a", [1, 1, 1, 2, 2, 2]),
-                ("b", pd.Categorical(["a", "a", "b", "b", "c", "c"], ordered=True)),
-                ("c", ["x", "x", "y", "z", "x", "y"]),
-            ]
-        )
+        {
+            "dates": pd.date_range("19910905", periods=6, tz="US/Eastern"),
+            "a": [1, 1, 1, 2, 2, 2],
+            "b": pd.Categorical(["a", "a", "b", "b", "c", "c"], ordered=True),
+            "c": ["x", "x", "y", "z", "x", "y"],
+        }
     )
     df = mi.to_frame(index=False)
     df_dtypes = df.dtypes.to_dict()
@@ -133,59 +129,8 @@ def test_to_frame_resulting_column_order():
     assert result == expected
 
 
-def test_to_hierarchical():
-    index = MultiIndex.from_tuples([(1, "one"), (1, "two"), (2, "one"), (2, "two")])
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = index.to_hierarchical(3)
-    expected = MultiIndex(
-        levels=[[1, 2], ["one", "two"]],
-        codes=[
-            [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
-            [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1],
-        ],
-    )
-    tm.assert_index_equal(result, expected)
-    assert result.names == index.names
-
-    # K > 1
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = index.to_hierarchical(3, 2)
-    expected = MultiIndex(
-        levels=[[1, 2], ["one", "two"]],
-        codes=[
-            [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
-            [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
-        ],
-    )
-    tm.assert_index_equal(result, expected)
-    assert result.names == index.names
-
-    # non-sorted
-    index = MultiIndex.from_tuples(
-        [(2, "c"), (1, "b"), (2, "a"), (2, "b")], names=["N1", "N2"]
-    )
-
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = index.to_hierarchical(2)
-    expected = MultiIndex.from_tuples(
-        [
-            (2, "c"),
-            (2, "c"),
-            (1, "b"),
-            (1, "b"),
-            (2, "a"),
-            (2, "a"),
-            (2, "b"),
-            (2, "b"),
-        ],
-        names=["N1", "N2"],
-    )
-    tm.assert_index_equal(result, expected)
-    assert result.names == index.names
-
-
 def test_roundtrip_pickle_with_tz():
-    return
+    return  # FIXME: this can't be right?
 
     # GH 8367
     # round-trip of timezone
@@ -197,17 +142,6 @@ def test_roundtrip_pickle_with_tz():
     assert index.equal_levels(unpickled)
 
 
-def test_pickle(indices):
-    return
-
-    unpickled = tm.round_trip_pickle(indices)
-    assert indices.equals(unpickled)
-    original_name, indices.name = indices.name, "foo"
-    unpickled = tm.round_trip_pickle(indices)
-    assert indices.equals(unpickled)
-    indices.name = original_name
-
-
 def test_to_series(idx):
     # assert that we are creating a copy of the index
 
diff --git a/pandas/tests/indexes/multi/test_copy.py b/pandas/tests/indexes/multi/test_copy.py
index 35a5cccc0ec45..1acc65aef8b8a 100644
--- a/pandas/tests/indexes/multi/test_copy.py
+++ b/pandas/tests/indexes/multi/test_copy.py
@@ -3,7 +3,7 @@
 import pytest
 
 from pandas import MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def assert_multiindex_copied(copy, original):
@@ -35,12 +35,6 @@ def test_shallow_copy(idx):
     assert_multiindex_copied(i_copy, idx)
 
 
-def test_labels_deprecated(idx):
-    # GH23752
-    with tm.assert_produces_warning(FutureWarning):
-        idx.copy(labels=idx.codes)
-
-
 def test_view(idx):
     i_view = idx.view()
     assert_multiindex_copied(i_view, idx)
@@ -74,7 +68,7 @@ def test_copy_method(deep):
 @pytest.mark.parametrize(
     "kwarg, value",
     [
-        ("names", ["thrid", "fourth"]),
+        ("names", ["third", "fourth"]),
         ("levels", [["foo2", "bar2"], ["fizz2", "buzz2"]]),
         ("codes", [[1, 0, 0, 0], [1, 1, 0, 0]]),
     ],
diff --git a/pandas/tests/indexes/multi/test_drop.py b/pandas/tests/indexes/multi/test_drop.py
index 2c24c5bd57085..b909025b3f2f9 100644
--- a/pandas/tests/indexes/multi/test_drop.py
+++ b/pandas/tests/indexes/multi/test_drop.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_drop(idx):
@@ -108,8 +108,8 @@ def test_droplevel_list():
     assert dropped.equals(expected)
 
     msg = (
-        "Cannot remove 3 levels from an index with 3 levels: at least one"
-        " level must be left"
+        "Cannot remove 3 levels from an index with 3 levels: "
+        "at least one level must be left"
     )
     with pytest.raises(ValueError, match=msg):
         index[:2].droplevel(["one", "two", "three"])
@@ -139,3 +139,52 @@ def test_drop_not_lexsorted():
     tm.assert_index_equal(lexsorted_mi, not_lexsorted_mi)
     with tm.assert_produces_warning(PerformanceWarning):
         tm.assert_index_equal(lexsorted_mi.drop("a"), not_lexsorted_mi.drop("a"))
+
+
+@pytest.mark.parametrize(
+    "msg,labels,level",
+    [
+        (r"labels \[4\] not found in level", 4, "a"),
+        (r"labels \[7\] not found in level", 7, "b"),
+    ],
+)
+def test_drop_raise_exception_if_labels_not_in_level(msg, labels, level):
+    # GH 8594
+    mi = MultiIndex.from_arrays([[1, 2, 3], [4, 5, 6]], names=["a", "b"])
+    s = pd.Series([10, 20, 30], index=mi)
+    df = pd.DataFrame([10, 20, 30], index=mi)
+
+    with pytest.raises(KeyError, match=msg):
+        s.drop(labels, level=level)
+    with pytest.raises(KeyError, match=msg):
+        df.drop(labels, level=level)
+
+
+@pytest.mark.parametrize("labels,level", [(4, "a"), (7, "b")])
+def test_drop_errors_ignore(labels, level):
+    # GH 8594
+    mi = MultiIndex.from_arrays([[1, 2, 3], [4, 5, 6]], names=["a", "b"])
+    s = pd.Series([10, 20, 30], index=mi)
+    df = pd.DataFrame([10, 20, 30], index=mi)
+
+    expected_s = s.drop(labels, level=level, errors="ignore")
+    tm.assert_series_equal(s, expected_s)
+
+    expected_df = df.drop(labels, level=level, errors="ignore")
+    tm.assert_frame_equal(df, expected_df)
+
+
+def test_drop_with_non_unique_datetime_index_and_invalid_keys():
+    # GH 30399
+
+    # define dataframe with unique datetime index
+    df = pd.DataFrame(
+        np.random.randn(5, 3),
+        columns=["a", "b", "c"],
+        index=pd.date_range("2012", freq="H", periods=5),
+    )
+    # create dataframe with non-unique datetime index
+    df = df.iloc[[0, 2, 2, 3]].copy()
+
+    with pytest.raises(KeyError, match="not found in axis"):
+        df.drop(["a", "b"])  # Dropping with labels not exist in the index
diff --git a/pandas/tests/indexes/multi/test_duplicates.py b/pandas/tests/indexes/multi/test_duplicates.py
index 518bd093b23b1..93e1de535835f 100644
--- a/pandas/tests/indexes/multi/test_duplicates.py
+++ b/pandas/tests/indexes/multi/test_duplicates.py
@@ -6,7 +6,7 @@
 from pandas._libs import hashtable
 
 from pandas import DatetimeIndex, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("names", [None, ["first", "second"]])
@@ -251,16 +251,13 @@ def test_duplicated_large(keep):
     tm.assert_numpy_array_equal(result, expected)
 
 
-def test_get_duplicates():
+def test_duplicated2():
+    # TODO: more informative test name
     # GH5873
     for a in [101, 102]:
         mi = MultiIndex.from_arrays([[101, a], [3.5, np.nan]])
         assert not mi.has_duplicates
 
-        with tm.assert_produces_warning(FutureWarning):
-            # Deprecated - see GH20239
-            assert mi.get_duplicates().equals(MultiIndex.from_arrays([[], []]))
-
         tm.assert_numpy_array_equal(mi.duplicated(), np.zeros(2, dtype="bool"))
 
     for n in range(1, 6):  # 1st level shape
@@ -274,10 +271,6 @@ def test_get_duplicates():
             assert len(mi) == (n + 1) * (m + 1)
             assert not mi.has_duplicates
 
-            with tm.assert_produces_warning(FutureWarning):
-                # Deprecated - see GH20239
-                assert mi.get_duplicates().equals(MultiIndex.from_arrays([[], []]))
-
             tm.assert_numpy_array_equal(
                 mi.duplicated(), np.zeros(len(mi), dtype="bool")
             )
diff --git a/pandas/tests/indexes/multi/test_equivalence.py b/pandas/tests/indexes/multi/test_equivalence.py
index f61ba0132ab97..063ede028add7 100644
--- a/pandas/tests/indexes/multi/test_equivalence.py
+++ b/pandas/tests/indexes/multi/test_equivalence.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_equals(idx):
@@ -146,7 +146,10 @@ def test_identical(idx):
     assert mi.identical(mi2)
 
     mi3 = Index(mi.tolist(), names=mi.names)
-    mi4 = Index(mi.tolist(), names=mi.names, tupleize_cols=False)
+    msg = r"Unexpected keyword arguments {'names'}"
+    with pytest.raises(TypeError, match=msg):
+        Index(mi.tolist(), names=mi.names, tupleize_cols=False)
+    mi4 = Index(mi.tolist(), tupleize_cols=False)
     assert mi.identical(mi3)
     assert not mi.identical(mi4)
     assert mi.equals(mi4)
diff --git a/pandas/tests/indexes/multi/test_format.py b/pandas/tests/indexes/multi/test_format.py
index a7f58b9ea78bd..75f23fb2f32ba 100644
--- a/pandas/tests/indexes/multi/test_format.py
+++ b/pandas/tests/indexes/multi/test_format.py
@@ -4,14 +4,7 @@
 
 import pandas as pd
 from pandas import MultiIndex
-import pandas.util.testing as tm
-
-
-def test_dtype_str(indices):
-    with tm.assert_produces_warning(FutureWarning):
-        dtype = indices.dtype_str
-    assert isinstance(dtype, str)
-    assert dtype == str(indices.dtype)
+import pandas._testing as tm
 
 
 def test_format(idx):
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index 5ab817d8468c3..675a1e2e832f3 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import CategoricalIndex, Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def assert_matching(actual, expected, check_dtype=False):
@@ -57,8 +57,6 @@ def test_get_value_duplicates():
     )
 
     assert index.get_loc("D") == slice(0, 3)
-    with pytest.raises(KeyError, match=r"^'D'$"):
-        index._engine.get_value(np.array([]), "D")
 
 
 def test_get_level_values_all_na():
@@ -159,7 +157,7 @@ def test_set_levels_codes_directly(idx):
     minor_codes = [(x + 1) % 1 for x in minor_codes]
     new_codes = [major_codes, minor_codes]
 
-    msg = "can't set attribute"
+    msg = "[Cc]an't set attribute"
     with pytest.raises(AttributeError, match=msg):
         idx.levels = new_levels
     with pytest.raises(AttributeError, match=msg):
@@ -306,27 +304,6 @@ def test_set_codes(idx):
     result.set_codes(codes=new_codes, level=1, inplace=True)
     assert result.equals(expected)
 
-    with tm.assert_produces_warning(FutureWarning):
-        ind.set_codes(labels=new_codes, level=1)
-
-
-def test_set_labels_deprecated():
-    # GH23752
-    ind = pd.MultiIndex.from_tuples([(0, i) for i in range(130)])
-    new_labels = range(129, -1, -1)
-    expected = pd.MultiIndex.from_tuples([(0, i) for i in new_labels])
-
-    # [w/o mutation]
-    with tm.assert_produces_warning(FutureWarning):
-        result = ind.set_labels(labels=new_labels, level=1)
-    assert result.equals(expected)
-
-    # [w/ mutation]
-    result = ind.copy()
-    with tm.assert_produces_warning(FutureWarning):
-        result.set_labels(labels=new_labels, level=1, inplace=True)
-    assert result.equals(expected)
-
 
 def test_set_levels_codes_names_bad_input(idx):
     levels, codes = idx.levels, idx.codes
diff --git a/pandas/tests/indexes/multi/test_indexing.py b/pandas/tests/indexes/multi/test_indexing.py
index d366dbd8bc0a8..21a4773fa3683 100644
--- a/pandas/tests/indexes/multi/test_indexing.py
+++ b/pandas/tests/indexes/multi/test_indexing.py
@@ -12,9 +12,8 @@
     MultiIndex,
     date_range,
 )
+import pandas._testing as tm
 from pandas.core.indexes.base import InvalidIndexError
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
 
 
 def test_slice_locs_partial(idx):
@@ -96,7 +95,6 @@ def test_slice_locs_not_contained():
     index = MultiIndex(
         levels=[[0, 2, 4, 6], [0, 2, 4]],
         codes=[[0, 0, 0, 1, 1, 2, 3, 3, 3], [0, 1, 2, 1, 2, 2, 0, 1, 2]],
-        sortorder=0,
     )
 
     result = index.slice_locs((1, 0), (5, 2))
@@ -146,32 +144,32 @@ def test_get_indexer():
     idx2 = index[[1, 3, 5]]
 
     r1 = idx1.get_indexer(idx2)
-    assert_almost_equal(r1, np.array([1, 3, -1], dtype=np.intp))
+    tm.assert_almost_equal(r1, np.array([1, 3, -1], dtype=np.intp))
 
     r1 = idx2.get_indexer(idx1, method="pad")
     e1 = np.array([-1, 0, 0, 1, 1], dtype=np.intp)
-    assert_almost_equal(r1, e1)
+    tm.assert_almost_equal(r1, e1)
 
     r2 = idx2.get_indexer(idx1[::-1], method="pad")
-    assert_almost_equal(r2, e1[::-1])
+    tm.assert_almost_equal(r2, e1[::-1])
 
     rffill1 = idx2.get_indexer(idx1, method="ffill")
-    assert_almost_equal(r1, rffill1)
+    tm.assert_almost_equal(r1, rffill1)
 
     r1 = idx2.get_indexer(idx1, method="backfill")
     e1 = np.array([0, 0, 1, 1, 2], dtype=np.intp)
-    assert_almost_equal(r1, e1)
+    tm.assert_almost_equal(r1, e1)
 
     r2 = idx2.get_indexer(idx1[::-1], method="backfill")
-    assert_almost_equal(r2, e1[::-1])
+    tm.assert_almost_equal(r2, e1[::-1])
 
     rbfill1 = idx2.get_indexer(idx1, method="bfill")
-    assert_almost_equal(r1, rbfill1)
+    tm.assert_almost_equal(r1, rbfill1)
 
     # pass non-MultiIndex
     r1 = idx1.get_indexer(idx2.values)
     rexp1 = idx1.get_indexer(idx2)
-    assert_almost_equal(r1, rexp1)
+    tm.assert_almost_equal(r1, rexp1)
 
     r1 = idx1.get_indexer([1, 2, 3])
     assert (r1 == [-1, -1, -1]).all()
@@ -394,11 +392,12 @@ def test_get_loc_missing_nan():
     # GH 8569
     idx = MultiIndex.from_arrays([[1.0, 2.0], [3.0, 4.0]])
     assert isinstance(idx.get_loc(1), slice)
-    with pytest.raises(KeyError, match=r"^3\.0$"):
+    with pytest.raises(KeyError, match=r"^3$"):
         idx.get_loc(3)
     with pytest.raises(KeyError, match=r"^nan$"):
         idx.get_loc(np.nan)
-    with pytest.raises(KeyError, match=r"^\[nan\]$"):
+    with pytest.raises(TypeError, match="unhashable type: 'list'"):
+        # listlike/non-hashable raises TypeError
         idx.get_loc([np.nan])
 
 
@@ -439,3 +438,91 @@ def test_timestamp_multiindex_indexer():
     )
     should_be = pd.Series(data=np.arange(24, len(qidx) + 24), index=qidx, name="foo")
     tm.assert_series_equal(result, should_be)
+
+
+def test_get_loc_with_values_including_missing_values():
+    # issue 19132
+    idx = MultiIndex.from_product([[np.nan, 1]] * 2)
+    expected = slice(0, 2, None)
+    assert idx.get_loc(np.nan) == expected
+
+    idx = MultiIndex.from_arrays([[np.nan, 1, 2, np.nan]])
+    expected = np.array([True, False, False, True])
+    tm.assert_numpy_array_equal(idx.get_loc(np.nan), expected)
+
+    idx = MultiIndex.from_product([[np.nan, 1]] * 3)
+    expected = slice(2, 4, None)
+    assert idx.get_loc((np.nan, 1)) == expected
+
+
+@pytest.mark.parametrize(
+    "index_arr,labels,expected",
+    [
+        (
+            [[1, np.nan, 2], [3, 4, 5]],
+            [1, np.nan, 2],
+            np.array([-1, -1, -1], dtype=np.intp),
+        ),
+        ([[1, np.nan, 2], [3, 4, 5]], [(np.nan, 4)], np.array([1], dtype=np.intp)),
+        ([[1, 2, 3], [np.nan, 4, 5]], [(1, np.nan)], np.array([0], dtype=np.intp)),
+        (
+            [[1, 2, 3], [np.nan, 4, 5]],
+            [np.nan, 4, 5],
+            np.array([-1, -1, -1], dtype=np.intp),
+        ),
+    ],
+)
+def test_get_indexer_with_missing_value(index_arr, labels, expected):
+    # issue 19132
+    idx = MultiIndex.from_arrays(index_arr)
+    result = idx.get_indexer(labels)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "index_arr,expected,target,algo",
+    [
+        ([[np.nan, "a", "b"], ["c", "d", "e"]], 0, np.nan, "left"),
+        ([[np.nan, "a", "b"], ["c", "d", "e"]], 1, (np.nan, "c"), "right"),
+        ([["a", "b", "c"], ["d", np.nan, "d"]], 1, ("b", np.nan), "left"),
+    ],
+)
+def test_get_slice_bound_with_missing_value(index_arr, expected, target, algo):
+    # issue 19132
+    idx = MultiIndex.from_arrays(index_arr)
+    result = idx.get_slice_bound(target, side=algo, kind="loc")
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "index_arr,expected,start_idx,end_idx",
+    [
+        ([[np.nan, 1, 2], [3, 4, 5]], slice(0, 2, None), np.nan, 1),
+        ([[np.nan, 1, 2], [3, 4, 5]], slice(0, 3, None), np.nan, (2, 5)),
+        ([[1, 2, 3], [4, np.nan, 5]], slice(1, 3, None), (2, np.nan), 3),
+        ([[1, 2, 3], [4, np.nan, 5]], slice(1, 3, None), (2, np.nan), (3, 5)),
+    ],
+)
+def test_slice_indexer_with_missing_value(index_arr, expected, start_idx, end_idx):
+    # issue 19132
+    idx = MultiIndex.from_arrays(index_arr)
+    result = idx.slice_indexer(start=start_idx, end=end_idx)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "index_arr,expected,start_idx,end_idx",
+    [
+        ([[np.nan, "a", "b"], ["c", "d", "e"]], (0, 3), np.nan, None),
+        ([[np.nan, "a", "b"], ["c", "d", "e"]], (0, 3), np.nan, "b"),
+        ([[np.nan, "a", "b"], ["c", "d", "e"]], (0, 3), np.nan, ("b", "e")),
+        ([["a", "b", "c"], ["d", np.nan, "e"]], (1, 3), ("b", np.nan), None),
+        ([["a", "b", "c"], ["d", np.nan, "e"]], (1, 3), ("b", np.nan), "c"),
+        ([["a", "b", "c"], ["d", np.nan, "e"]], (1, 3), ("b", np.nan), ("c", "e")),
+    ],
+)
+def test_slice_locs_with_missing_value(index_arr, expected, start_idx, end_idx):
+    # issue 19132
+    idx = MultiIndex.from_arrays(index_arr)
+    result = idx.slice_locs(start=start_idx, end=end_idx)
+    assert result == expected
diff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py
index 472a404c2a8ef..fd150bb4d57a2 100644
--- a/pandas/tests/indexes/multi/test_integrity.py
+++ b/pandas/tests/indexes/multi/test_integrity.py
@@ -7,7 +7,7 @@
 
 import pandas as pd
 from pandas import IntervalIndex, MultiIndex, RangeIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_labels_dtypes():
@@ -49,9 +49,8 @@ def test_values_multiindex_datetimeindex():
     # Test to ensure we hit the boxing / nobox part of MI.values
     ints = np.arange(10 ** 18, 10 ** 18 + 5)
     naive = pd.DatetimeIndex(ints)
-    # TODO(GH-24559): Remove the FutureWarning
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        aware = pd.DatetimeIndex(ints, tz="US/Central")
+
+    aware = pd.DatetimeIndex(ints, tz="US/Central")
 
     idx = pd.MultiIndex.from_arrays([naive, aware])
     result = idx.values
@@ -210,7 +209,7 @@ def test_metadata_immutable(idx):
     # ditto for labels
     with pytest.raises(TypeError, match=mutable_regex):
         codes[0] = codes[0]
-    with pytest.raises(TypeError, match=mutable_regex):
+    with pytest.raises(ValueError, match="assignment destination is read-only"):
         codes[0][0] = codes[0][0]
     # and for names
     names = idx.names
@@ -251,27 +250,6 @@ def test_rangeindex_fallback_coercion_bug():
     tm.assert_index_equal(result, expected)
 
 
-def test_hash_error(indices):
-    index = indices
-    with pytest.raises(
-        TypeError, match=("unhashable type: {0.__name__!r}".format(type(index)))
-    ):
-        hash(indices)
-
-
-def test_mutability(indices):
-    if not len(indices):
-        return
-    msg = "Index does not support mutable operations"
-    with pytest.raises(TypeError, match=msg):
-        indices[0] = indices[0]
-
-
-def test_wrong_number_names(indices):
-    with pytest.raises(ValueError, match="^Length"):
-        indices.names = ["apple", "banana", "carrot"]
-
-
 def test_memory_usage(idx):
     result = idx.memory_usage()
     if len(idx):
diff --git a/pandas/tests/indexes/multi/test_join.py b/pandas/tests/indexes/multi/test_join.py
index 42d8cf761842e..062fb92c44552 100644
--- a/pandas/tests/indexes/multi/test_join.py
+++ b/pandas/tests/indexes/multi/test_join.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -87,3 +87,19 @@ def test_join_self_unique(idx, join_type):
     if idx.is_unique:
         joined = idx.join(idx, how=join_type)
         assert (idx == joined).all()
+
+
+def test_join_multi_wrong_order():
+    # GH 25760
+    # GH 28956
+
+    midx1 = pd.MultiIndex.from_product([[1, 2], [3, 4]], names=["a", "b"])
+    midx2 = pd.MultiIndex.from_product([[1, 2], [3, 4]], names=["b", "a"])
+
+    join_idx, lidx, ridx = midx1.join(midx2, return_indexers=False)
+
+    exp_ridx = np.array([-1, -1, -1, -1], dtype=np.intp)
+
+    tm.assert_index_equal(midx1, join_idx)
+    assert lidx is None
+    tm.assert_numpy_array_equal(ridx, exp_ridx)
diff --git a/pandas/tests/indexes/multi/test_missing.py b/pandas/tests/indexes/multi/test_missing.py
index 15bbd2ce97c3c..a17e1e9928bff 100644
--- a/pandas/tests/indexes/multi/test_missing.py
+++ b/pandas/tests/indexes/multi/test_missing.py
@@ -5,8 +5,8 @@
 
 import pandas as pd
 from pandas import Int64Index, MultiIndex, PeriodIndex, UInt64Index
+import pandas._testing as tm
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
-import pandas.util.testing as tm
 
 
 def test_fillna(idx):
@@ -42,9 +42,9 @@ def test_fillna(idx):
                 values[1] = np.nan
 
             if isinstance(index, PeriodIndex):
-                idx = index.__class__(values, freq=index.freq)
+                idx = type(index)(values, freq=index.freq)
             else:
-                idx = index.__class__(values)
+                idx = type(index)(values)
 
             expected = np.array([False] * len(idx), dtype=bool)
             expected[1] = True
@@ -101,7 +101,7 @@ def test_nulls(idx):
         idx.isna()
 
 
-@pytest.mark.xfail
+@pytest.mark.xfail(reason="isna is not defined for MultiIndex")
 def test_hasnans_isnans(idx):
     # GH 11343, added tests for hasnans / isnans
     index = idx.copy()
@@ -115,7 +115,7 @@ def test_hasnans_isnans(idx):
     values = index.values
     values[1] = np.nan
 
-    index = idx.__class__(values)
+    index = type(idx)(values)
 
     expected = np.array([False] * len(index), dtype=bool)
     expected[1] = True
diff --git a/pandas/tests/indexes/multi/test_monotonic.py b/pandas/tests/indexes/multi/test_monotonic.py
index b5c73d5e97745..ca1cb0932f63d 100644
--- a/pandas/tests/indexes/multi/test_monotonic.py
+++ b/pandas/tests/indexes/multi/test_monotonic.py
@@ -1,9 +1,7 @@
 import numpy as np
-import pytest
 
 import pandas as pd
-from pandas import Index, IntervalIndex, MultiIndex
-from pandas.api.types import is_scalar
+from pandas import Index, MultiIndex
 
 
 def test_is_monotonic_increasing():
@@ -176,55 +174,3 @@ def test_is_strictly_monotonic_decreasing():
     )
     assert idx.is_monotonic_decreasing is True
     assert idx._is_strictly_monotonic_decreasing is False
-
-
-def test_searchsorted_monotonic(indices):
-    # GH17271
-    # not implemented for tuple searches in MultiIndex
-    # or Intervals searches in IntervalIndex
-    if isinstance(indices, (MultiIndex, IntervalIndex)):
-        return
-
-    # nothing to test if the index is empty
-    if indices.empty:
-        return
-    value = indices[0]
-
-    # determine the expected results (handle dupes for 'right')
-    expected_left, expected_right = 0, (indices == value).argmin()
-    if expected_right == 0:
-        # all values are the same, expected_right should be length
-        expected_right = len(indices)
-
-    # test _searchsorted_monotonic in all cases
-    # test searchsorted only for increasing
-    if indices.is_monotonic_increasing:
-        ssm_left = indices._searchsorted_monotonic(value, side="left")
-        assert is_scalar(ssm_left)
-        assert expected_left == ssm_left
-
-        ssm_right = indices._searchsorted_monotonic(value, side="right")
-        assert is_scalar(ssm_right)
-        assert expected_right == ssm_right
-
-        ss_left = indices.searchsorted(value, side="left")
-        assert is_scalar(ss_left)
-        assert expected_left == ss_left
-
-        ss_right = indices.searchsorted(value, side="right")
-        assert is_scalar(ss_right)
-        assert expected_right == ss_right
-
-    elif indices.is_monotonic_decreasing:
-        ssm_left = indices._searchsorted_monotonic(value, side="left")
-        assert is_scalar(ssm_left)
-        assert expected_left == ssm_left
-
-        ssm_right = indices._searchsorted_monotonic(value, side="right")
-        assert is_scalar(ssm_right)
-        assert expected_right == ssm_right
-
-    else:
-        # non-monotonic should raise.
-        with pytest.raises(ValueError):
-            indices._searchsorted_monotonic(value, side="left")
diff --git a/pandas/tests/indexes/multi/test_names.py b/pandas/tests/indexes/multi/test_names.py
index 5856cb56b307b..479b5ef0211a0 100644
--- a/pandas/tests/indexes/multi/test_names.py
+++ b/pandas/tests/indexes/multi/test_names.py
@@ -2,7 +2,7 @@
 
 import pandas as pd
 from pandas import MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def check_level_names(index, names):
@@ -27,28 +27,25 @@ def test_index_name_retained():
 
 
 def test_changing_names(idx):
-
-    # names should be applied to levels
-    level_names = [level.name for level in idx.levels]
-    check_level_names(idx, idx.names)
+    assert [level.name for level in idx.levels] == ["first", "second"]
 
     view = idx.view()
     copy = idx.copy()
     shallow_copy = idx._shallow_copy()
 
-    # changing names should change level names on object
+    # changing names should not change level names on object
     new_names = [name + "a" for name in idx.names]
     idx.names = new_names
-    check_level_names(idx, new_names)
+    check_level_names(idx, ["firsta", "seconda"])
 
-    # but not on copies
-    check_level_names(view, level_names)
-    check_level_names(copy, level_names)
-    check_level_names(shallow_copy, level_names)
+    # and not on copies
+    check_level_names(view, ["first", "second"])
+    check_level_names(copy, ["first", "second"])
+    check_level_names(shallow_copy, ["first", "second"])
 
     # and copies shouldn't change original
     shallow_copy.names = [name + "c" for name in shallow_copy.names]
-    check_level_names(idx, new_names)
+    check_level_names(idx, ["firsta", "seconda"])
 
 
 def test_take_preserve_name(idx):
@@ -82,9 +79,9 @@ def test_copy_names():
 def test_names(idx, index_names):
 
     # names are assigned in setup
-    names = index_names
+    assert index_names == ["first", "second"]
     level_names = [level.name for level in idx.levels]
-    assert names == level_names
+    assert level_names == index_names
 
     # setting bad names on existing
     index = idx
@@ -109,11 +106,10 @@ def test_names(idx, index_names):
             names=["first", "second", "third"],
         )
 
-    # names are assigned
+    # names are assigned on index, but not transferred to the levels
     index.names = ["a", "b"]
-    ind_names = list(index.names)
     level_names = [level.name for level in index.levels]
-    assert ind_names == level_names
+    assert level_names == ["a", "b"]
 
 
 def test_duplicate_level_names_access_raises(idx):
@@ -121,3 +117,27 @@ def test_duplicate_level_names_access_raises(idx):
     idx.names = ["foo", "foo"]
     with pytest.raises(ValueError, match="name foo occurs multiple times"):
         idx._get_level_number("foo")
+
+
+def test_get_names_from_levels():
+    idx = pd.MultiIndex.from_product([["a"], [1, 2]], names=["a", "b"])
+
+    assert idx.levels[0].name == "a"
+    assert idx.levels[1].name == "b"
+
+
+def test_setting_names_from_levels_raises():
+    idx = pd.MultiIndex.from_product([["a"], [1, 2]], names=["a", "b"])
+    with pytest.raises(RuntimeError, match="set_names"):
+        idx.levels[0].name = "foo"
+
+    with pytest.raises(RuntimeError, match="set_names"):
+        idx.levels[1].name = "foo"
+
+    new = pd.Series(1, index=idx.levels[0])
+    with pytest.raises(RuntimeError, match="set_names"):
+        new.index.name = "bar"
+
+    assert pd.Index._no_setting_name is False
+    assert pd.Int64Index._no_setting_name is False
+    assert pd.RangeIndex._no_setting_name is False
diff --git a/pandas/tests/indexes/multi/test_partial_indexing.py b/pandas/tests/indexes/multi/test_partial_indexing.py
index 5db1296d828ca..b00018d2ceb69 100644
--- a/pandas/tests/indexes/multi/test_partial_indexing.py
+++ b/pandas/tests/indexes/multi/test_partial_indexing.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_partial_string_timestamp_multiindex():
diff --git a/pandas/tests/indexes/multi/test_reindex.py b/pandas/tests/indexes/multi/test_reindex.py
index 88de4d1e80386..ceb14aa82a76c 100644
--- a/pandas/tests/indexes/multi/test_reindex.py
+++ b/pandas/tests/indexes/multi/test_reindex.py
@@ -3,22 +3,20 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex
-import pandas.util.testing as tm
-
-
-def check_level_names(index, names):
-    assert [level.name for level in index.levels] == list(names)
+import pandas._testing as tm
 
 
 def test_reindex(idx):
     result, indexer = idx.reindex(list(idx[:4]))
     assert isinstance(result, MultiIndex)
-    check_level_names(result, idx[:4].names)
+    assert result.names == ["first", "second"]
+    assert [level.name for level in result.levels] == ["first", "second"]
 
     result, indexer = idx.reindex(list(idx))
     assert isinstance(result, MultiIndex)
     assert indexer is None
-    check_level_names(result, idx.names)
+    assert result.names == ["first", "second"]
+    assert [level.name for level in result.levels] == ["first", "second"]
 
 
 def test_reindex_level(idx):
diff --git a/pandas/tests/indexes/multi/test_reshape.py b/pandas/tests/indexes/multi/test_reshape.py
index a30e6f33d1499..2e39c714ca7af 100644
--- a/pandas/tests/indexes/multi/test_reshape.py
+++ b/pandas/tests/indexes/multi/test_reshape.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_insert(idx):
@@ -17,6 +17,7 @@ def test_insert(idx):
 
     exp0 = Index(list(idx.levels[0]) + ["abc"], name="first")
     tm.assert_index_equal(new_index.levels[0], exp0)
+    assert new_index.names == ["first", "second"]
 
     exp1 = Index(list(idx.levels[1]) + ["three"], name="second")
     tm.assert_index_equal(new_index.levels[1], exp1)
diff --git a/pandas/tests/indexes/multi/test_set_ops.py b/pandas/tests/indexes/multi/test_setops.py
similarity index 97%
rename from pandas/tests/indexes/multi/test_set_ops.py
rename to pandas/tests/indexes/multi/test_setops.py
index 835784054261e..f949db537de67 100644
--- a/pandas/tests/indexes/multi/test_set_ops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import MultiIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("case", [0.5, "xxx"])
@@ -110,6 +110,17 @@ def test_symmetric_difference(idx, sort):
         first.symmetric_difference([1, 2, 3], sort=sort)
 
 
+def test_multiindex_symmetric_difference():
+    # GH 13490
+    idx = MultiIndex.from_product([["a", "b"], ["A", "B"]], names=["a", "b"])
+    result = idx ^ idx
+    assert result.names == idx.names
+
+    idx2 = idx.copy().rename(["A", "B"])
+    result = idx ^ idx2
+    assert result.names == [None, None]
+
+
 def test_empty(idx):
     # GH 15270
     assert not idx.empty
diff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py
index 3dee1dbecf3ba..bb40612b9a55a 100644
--- a/pandas/tests/indexes/multi/test_sorting.py
+++ b/pandas/tests/indexes/multi/test_sorting.py
@@ -1,3 +1,5 @@
+import random
+
 import numpy as np
 import pytest
 
@@ -5,12 +7,10 @@
 
 import pandas as pd
 from pandas import CategoricalIndex, DataFrame, Index, MultiIndex, RangeIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_sortlevel(idx):
-    import random
-
     tuples = list(idx)
     random.shuffle(tuples)
 
@@ -66,11 +66,6 @@ def test_sortlevel_deterministic():
     assert sorted_idx.equals(expected[::-1])
 
 
-def test_sort(indices):
-    with pytest.raises(TypeError):
-        indices.sort()
-
-
 def test_numpy_argsort(idx):
     result = np.argsort(idx)
     expected = idx.argsort()
@@ -120,7 +115,7 @@ def test_unsortedindex():
 
 
 def test_unsortedindex_doc_examples():
-    # http://pandas.pydata.org/pandas-docs/stable/advanced.html#sorting-a-multiindex  # noqa
+    # https://pandas.pydata.org/pandas-docs/stable/advanced.html#sorting-a-multiindex  # noqa
     dfm = DataFrame(
         {"jim": [0, 0, 1, 1], "joe": ["x", "x", "z", "y"], "jolie": np.random.rand(4)}
     )
diff --git a/pandas/tests/indexes/multi/test_take.py b/pandas/tests/indexes/multi/test_take.py
new file mode 100644
index 0000000000000..85043ff8812af
--- /dev/null
+++ b/pandas/tests/indexes/multi/test_take.py
@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_take(idx):
+    indexer = [4, 3, 0, 2]
+    result = idx.take(indexer)
+    expected = idx[indexer]
+    assert result.equals(expected)
+
+    # FIXME: Remove Commented Code
+    # if not isinstance(idx,
+    #                   (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
+    # GH 10791
+    msg = "'MultiIndex' object has no attribute 'freq'"
+    with pytest.raises(AttributeError, match=msg):
+        idx.freq
+
+
+def test_take_invalid_kwargs(idx):
+    idx = idx
+    indices = [1, 2]
+
+    msg = r"take\(\) got an unexpected keyword argument 'foo'"
+    with pytest.raises(TypeError, match=msg):
+        idx.take(indices, foo=2)
+
+    msg = "the 'out' parameter is not supported"
+    with pytest.raises(ValueError, match=msg):
+        idx.take(indices, out=indices)
+
+    msg = "the 'mode' parameter is not supported"
+    with pytest.raises(ValueError, match=msg):
+        idx.take(indices, mode="clip")
+
+
+def test_take_fill_value():
+    # GH 12631
+    vals = [["A", "B"], [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]]
+    idx = pd.MultiIndex.from_product(vals, names=["str", "dt"])
+
+    result = idx.take(np.array([1, 0, -1]))
+    exp_vals = [
+        ("A", pd.Timestamp("2011-01-02")),
+        ("A", pd.Timestamp("2011-01-01")),
+        ("B", pd.Timestamp("2011-01-02")),
+    ]
+    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
+    tm.assert_index_equal(result, expected)
+
+    # fill_value
+    result = idx.take(np.array([1, 0, -1]), fill_value=True)
+    exp_vals = [
+        ("A", pd.Timestamp("2011-01-02")),
+        ("A", pd.Timestamp("2011-01-01")),
+        (np.nan, pd.NaT),
+    ]
+    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
+    tm.assert_index_equal(result, expected)
+
+    # allow_fill=False
+    result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+    exp_vals = [
+        ("A", pd.Timestamp("2011-01-02")),
+        ("A", pd.Timestamp("2011-01-01")),
+        ("B", pd.Timestamp("2011-01-02")),
+    ]
+    expected = pd.MultiIndex.from_tuples(exp_vals, names=["str", "dt"])
+    tm.assert_index_equal(result, expected)
+
+    msg = "When allow_fill=True and fill_value is not None, all indices must be >= -1"
+    with pytest.raises(ValueError, match=msg):
+        idx.take(np.array([1, 0, -2]), fill_value=True)
+    with pytest.raises(ValueError, match=msg):
+        idx.take(np.array([1, 0, -5]), fill_value=True)
+
+    msg = "index -5 is out of bounds for( axis 0 with)? size 4"
+    with pytest.raises(IndexError, match=msg):
+        idx.take(np.array([1, -5]))
diff --git a/pandas/tests/indexes/period/test_asfreq.py b/pandas/tests/indexes/period/test_asfreq.py
index 2a6e84da229e1..8c04ac1177676 100644
--- a/pandas/tests/indexes/period/test_asfreq.py
+++ b/pandas/tests/indexes/period/test_asfreq.py
@@ -1,9 +1,7 @@
-import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import DataFrame, PeriodIndex, Series, period_range
-from pandas.util import testing as tm
+from pandas import PeriodIndex, period_range
+import pandas._testing as tm
 
 
 class TestPeriodIndex:
@@ -98,7 +96,7 @@ def test_asfreq_mult_pi(self, freq):
         assert result.freq == exp.freq
 
     def test_asfreq_combined_pi(self):
-        pi = pd.PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
+        pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
         exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="25H")
         for freq, how in zip(["1D1H", "1H1D"], ["S", "E"]):
             result = pi.asfreq(freq, how=how)
@@ -106,38 +104,18 @@ def test_asfreq_combined_pi(self):
             assert result.freq == exp.freq
 
         for freq in ["1D1H", "1H1D"]:
-            pi = pd.PeriodIndex(
-                ["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq
-            )
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
             result = pi.asfreq("H")
             exp = PeriodIndex(["2001-01-02 00:00", "2001-01-03 02:00", "NaT"], freq="H")
             tm.assert_index_equal(result, exp)
             assert result.freq == exp.freq
 
-            pi = pd.PeriodIndex(
-                ["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq
-            )
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
             result = pi.asfreq("H", how="S")
             exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="H")
             tm.assert_index_equal(result, exp)
             assert result.freq == exp.freq
 
-    def test_asfreq_ts(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
-        ts = Series(np.random.randn(len(index)), index=index)
-        df = DataFrame(np.random.randn(len(index), 3), index=index)
-
-        result = ts.asfreq("D", how="end")
-        df_result = df.asfreq("D", how="end")
-        exp_index = index.asfreq("D", how="end")
-        assert len(result) == len(ts)
-        tm.assert_index_equal(result.index, exp_index)
-        tm.assert_index_equal(df_result.index, exp_index)
-
-        result = ts.asfreq("D", how="start")
-        assert len(result) == len(ts)
-        tm.assert_index_equal(result.index, index.asfreq("D", how="start"))
-
     def test_astype_asfreq(self):
         pi1 = PeriodIndex(["2011-01-01", "2011-02-01", "2011-03-01"], freq="D")
         exp = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
diff --git a/pandas/tests/indexes/period/test_astype.py b/pandas/tests/indexes/period/test_astype.py
index fa57ec2b1f7ca..2f10e45193d5d 100644
--- a/pandas/tests/indexes/period/test_astype.py
+++ b/pandas/tests/indexes/period/test_astype.py
@@ -1,9 +1,19 @@
 import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import Index, Int64Index, NaT, Period, PeriodIndex, period_range
-import pandas.util.testing as tm
+from pandas import (
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    Int64Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Timedelta,
+    UInt64Index,
+    period_range,
+)
+import pandas._testing as tm
 
 
 class TestPeriodIndexAsType:
@@ -41,39 +51,39 @@ def test_astype_conversion(self):
 
     def test_astype_uint(self):
         arr = period_range("2000", periods=2)
-        expected = pd.UInt64Index(np.array([10957, 10958], dtype="uint64"))
+        expected = UInt64Index(np.array([10957, 10958], dtype="uint64"))
         tm.assert_index_equal(arr.astype("uint64"), expected)
         tm.assert_index_equal(arr.astype("uint32"), expected)
 
     def test_astype_object(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=object)
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
-        exp = np.array([pd.Period("2011-01", freq="M"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
-        exp = np.array([pd.Period("2011-01-01", freq="D"), pd.NaT], dtype=object)
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
         tm.assert_numpy_array_equal(idx.astype(object).values, exp)
         tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
 
     # TODO: de-duplicate this version (from test_ops) with the one above
     # (from test_period)
     def test_astype_object2(self):
-        idx = pd.period_range(start="2013-01-01", periods=4, freq="M", name="idx")
+        idx = period_range(start="2013-01-01", periods=4, freq="M", name="idx")
         expected_list = [
-            pd.Period("2013-01-31", freq="M"),
-            pd.Period("2013-02-28", freq="M"),
-            pd.Period("2013-03-31", freq="M"),
-            pd.Period("2013-04-30", freq="M"),
+            Period("2013-01-31", freq="M"),
+            Period("2013-02-28", freq="M"),
+            Period("2013-03-31", freq="M"),
+            Period("2013-04-30", freq="M"),
         ]
-        expected = pd.Index(expected_list, dtype=object, name="idx")
+        expected = Index(expected_list, dtype=object, name="idx")
         result = idx.astype(object)
         assert isinstance(result, Index)
         assert result.dtype == object
@@ -85,31 +95,31 @@ def test_astype_object2(self):
             ["2013-01-01", "2013-01-02", "NaT", "2013-01-04"], freq="D", name="idx"
         )
         expected_list = [
-            pd.Period("2013-01-01", freq="D"),
-            pd.Period("2013-01-02", freq="D"),
-            pd.Period("NaT", freq="D"),
-            pd.Period("2013-01-04", freq="D"),
+            Period("2013-01-01", freq="D"),
+            Period("2013-01-02", freq="D"),
+            Period("NaT", freq="D"),
+            Period("2013-01-04", freq="D"),
         ]
-        expected = pd.Index(expected_list, dtype=object, name="idx")
+        expected = Index(expected_list, dtype=object, name="idx")
         result = idx.astype(object)
         assert isinstance(result, Index)
         assert result.dtype == object
         tm.assert_index_equal(result, expected)
         for i in [0, 1, 3]:
             assert result[i] == expected[i]
-        assert result[2] is pd.NaT
+        assert result[2] is NaT
         assert result.name == expected.name
 
         result_list = idx.tolist()
         for i in [0, 1, 3]:
             assert result_list[i] == expected_list[i]
-        assert result_list[2] is pd.NaT
+        assert result_list[2] is NaT
 
     def test_astype_category(self):
-        obj = pd.period_range("2000", periods=2)
+        obj = period_range("2000", periods=2)
         result = obj.astype("category")
-        expected = pd.CategoricalIndex(
-            [pd.Period("2000-01-01", freq="D"), pd.Period("2000-01-02", freq="D")]
+        expected = CategoricalIndex(
+            [Period("2000-01-01", freq="D"), Period("2000-01-02", freq="D")]
         )
         tm.assert_index_equal(result, expected)
 
@@ -118,11 +128,30 @@ def test_astype_category(self):
         tm.assert_categorical_equal(result, expected)
 
     def test_astype_array_fallback(self):
-        obj = pd.period_range("2000", periods=2)
+        obj = period_range("2000", periods=2)
         result = obj.astype(bool)
-        expected = pd.Index(np.array([True, True]))
+        expected = Index(np.array([True, True]))
         tm.assert_index_equal(result, expected)
 
         result = obj._data.astype(bool)
         expected = np.array([True, True])
         tm.assert_numpy_array_equal(result, expected)
+
+    def test_period_astype_to_timestamp(self):
+        pi = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
+
+        exp = DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
+        tm.assert_index_equal(pi.astype("datetime64[ns]"), exp)
+
+        exp = DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"])
+        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(pi.astype("datetime64[ns]", how="end"), exp)
+
+        exp = DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"], tz="US/Eastern")
+        res = pi.astype("datetime64[ns, US/Eastern]")
+        tm.assert_index_equal(pi.astype("datetime64[ns, US/Eastern]"), exp)
+
+        exp = DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"], tz="US/Eastern")
+        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
+        res = pi.astype("datetime64[ns, US/Eastern]", how="end")
+        tm.assert_index_equal(res, exp)
diff --git a/pandas/tests/indexes/period/test_construction.py b/pandas/tests/indexes/period/test_constructors.py
similarity index 72%
rename from pandas/tests/indexes/period/test_construction.py
rename to pandas/tests/indexes/period/test_constructors.py
index 8c75fbbae7de3..fcbadce3d63b1 100644
--- a/pandas/tests/indexes/period/test_construction.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -6,39 +6,64 @@
 from pandas.core.dtypes.dtypes import PeriodDtype
 
 import pandas as pd
-from pandas import Index, Period, PeriodIndex, Series, date_range, offsets, period_range
-import pandas.core.indexes.period as period
-import pandas.util.testing as tm
+from pandas import (
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    date_range,
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import PeriodArray
 
 
 class TestPeriodIndex:
-    def setup_method(self, method):
-        pass
-
     def test_construction_base_constructor(self):
         # GH 13664
-        arr = [pd.Period("2011-01", freq="M"), pd.NaT, pd.Period("2011-03", freq="M")]
-        tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
-        tm.assert_index_equal(pd.Index(np.array(arr)), pd.PeriodIndex(np.array(arr)))
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
 
-        arr = [np.nan, pd.NaT, pd.Period("2011-03", freq="M")]
-        tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
-        tm.assert_index_equal(pd.Index(np.array(arr)), pd.PeriodIndex(np.array(arr)))
+        arr = [np.nan, NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
 
-        arr = [pd.Period("2011-01", freq="M"), pd.NaT, pd.Period("2011-03", freq="D")]
-        tm.assert_index_equal(pd.Index(arr), pd.Index(arr, dtype=object))
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="D")]
+        tm.assert_index_equal(Index(arr), Index(arr, dtype=object))
 
-        tm.assert_index_equal(
-            pd.Index(np.array(arr)), pd.Index(np.array(arr), dtype=object)
-        )
+        tm.assert_index_equal(Index(np.array(arr)), Index(np.array(arr), dtype=object))
+
+    def test_base_constructor_with_period_dtype(self):
+        dtype = PeriodDtype("D")
+        values = ["2011-01-01", "2012-03-04", "2014-05-01"]
+        result = Index(values, dtype=dtype)
+
+        expected = PeriodIndex(values, dtype=dtype)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values_constructor", [list, np.array, PeriodIndex, PeriodArray._from_sequence]
+    )
+    def test_index_object_dtype(self, values_constructor):
+        # Index(periods, dtype=object) is an Index (not an PeriodIndex)
+        periods = [
+            Period("2011-01", freq="M"),
+            NaT,
+            Period("2011-03", freq="M"),
+        ]
+        values = values_constructor(periods)
+        result = Index(values, dtype=object)
+
+        assert type(result) is Index
+        tm.assert_numpy_array_equal(result.values, np.array(values))
 
     def test_constructor_use_start_freq(self):
         # GH #1118
         p = Period("4/2/2012", freq="B")
-        with tm.assert_produces_warning(FutureWarning):
-            index = PeriodIndex(start=p, periods=10)
         expected = period_range(start="4/2/2012", periods=10, freq="B")
-        tm.assert_index_equal(index, expected)
 
         index = period_range(start=p, periods=10)
         tm.assert_index_equal(index, expected)
@@ -68,12 +93,6 @@ def test_constructor_field_arrays(self):
         with pytest.raises(ValueError, match=msg):
             PeriodIndex(year=years, month=months, freq="2M")
 
-        msg = "Can either instantiate from fields or endpoints, but not both"
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(
-                year=years, month=months, freq="M", start=Period("2007-01", freq="M")
-            )
-
         years = [2007, 2007, 2007]
         months = [1, 2, 3]
         idx = PeriodIndex(year=years, month=months, freq="M")
@@ -106,8 +125,8 @@ def test_constructor_arrays_negative_year(self):
 
         pindex = PeriodIndex(year=years, quarter=quarters)
 
-        tm.assert_index_equal(pindex.year, pd.Index(years))
-        tm.assert_index_equal(pindex.quarter, pd.Index(quarters))
+        tm.assert_index_equal(pindex.year, Index(years))
+        tm.assert_index_equal(pindex.quarter, Index(quarters))
 
     def test_constructor_invalid_quarters(self):
         msg = "Quarter must be 1 <= q <= 4"
@@ -115,26 +134,6 @@ def test_constructor_invalid_quarters(self):
             PeriodIndex(year=range(2000, 2004), quarter=list(range(4)), freq="Q-DEC")
 
     def test_constructor_corner(self):
-        msg = "Not enough parameters to construct Period range"
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(periods=10, freq="A")
-
-        start = Period("2007", freq="A-JUN")
-        end = Period("2010", freq="A-DEC")
-
-        msg = "start and end must have same freq"
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(start=start, end=end)
-
-        msg = (
-            "Of the three parameters: start, end, and periods, exactly two"
-            " must be specified"
-        )
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(start=start)
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(end=end)
-
         result = period_range("2007-01", periods=10.5, freq="M")
         exp = period_range("2007-01", periods=10, freq="M")
         tm.assert_index_equal(result, exp)
@@ -192,7 +191,7 @@ def test_constructor_datetime64arr(self):
     @pytest.mark.parametrize("box", [None, "series", "index"])
     def test_constructor_datetime64arr_ok(self, box):
         # https://github.com/pandas-dev/pandas/issues/23438
-        data = pd.date_range("2017", periods=4, freq="M")
+        data = date_range("2017", periods=4, freq="M")
         if box is None:
             data = data._values
         elif box == "series":
@@ -230,56 +229,51 @@ def test_constructor_dtype(self):
         assert res.dtype == "period[M]"
 
         msg = "specified freq and dtype are different"
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(["2011-01"], freq="M", dtype="period[D]")
 
     def test_constructor_empty(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
         assert isinstance(idx, PeriodIndex)
         assert len(idx) == 0
         assert idx.freq == "M"
 
         with pytest.raises(ValueError, match="freq not specified"):
-            pd.PeriodIndex([])
+            PeriodIndex([])
 
     def test_constructor_pi_nat(self):
         idx = PeriodIndex(
-            [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="M")]
+            [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")]
         )
         exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
-            np.array([Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="M")])
+            np.array([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")])
         )
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
-            [pd.NaT, pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
+            [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
         )
         exp = PeriodIndex(["NaT", "NaT", "2011-01", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         idx = PeriodIndex(
             np.array(
-                [
-                    pd.NaT,
-                    pd.NaT,
-                    Period("2011-01", freq="M"),
-                    Period("2011-01", freq="M"),
-                ]
+                [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
             )
         )
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex([pd.NaT, pd.NaT, "2011-01", "2011-01"], freq="M")
+        idx = PeriodIndex([NaT, NaT, "2011-01", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
         with pytest.raises(ValueError, match="freq not specified"):
-            PeriodIndex([pd.NaT, pd.NaT])
+            PeriodIndex([NaT, NaT])
 
         with pytest.raises(ValueError, match="freq not specified"):
-            PeriodIndex(np.array([pd.NaT, pd.NaT]))
+            PeriodIndex(np.array([NaT, NaT]))
 
         with pytest.raises(ValueError, match="freq not specified"):
             PeriodIndex(["NaT", "NaT"])
@@ -290,67 +284,74 @@ def test_constructor_pi_nat(self):
     def test_constructor_incompat_freq(self):
         msg = "Input has different freq=D from PeriodIndex\\(freq=M\\)"
 
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
-            PeriodIndex(
-                [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="D")]
-            )
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")])
 
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(
                 np.array(
-                    [Period("2011-01", freq="M"), pd.NaT, Period("2011-01", freq="D")]
+                    [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")]
                 )
             )
 
-        # first element is pd.NaT
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
-            PeriodIndex(
-                [pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
-            )
+        # first element is NaT
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex([NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")])
 
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(
                 np.array(
-                    [pd.NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
+                    [NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
                 )
             )
 
     def test_constructor_mixed(self):
-        idx = PeriodIndex(["2011-01", pd.NaT, Period("2011-01", freq="M")])
+        idx = PeriodIndex(["2011-01", NaT, Period("2011-01", freq="M")])
         exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex(["NaT", pd.NaT, Period("2011-01", freq="M")])
+        idx = PeriodIndex(["NaT", NaT, Period("2011-01", freq="M")])
         exp = PeriodIndex(["NaT", "NaT", "2011-01"], freq="M")
         tm.assert_index_equal(idx, exp)
 
-        idx = PeriodIndex([Period("2011-01-01", freq="D"), pd.NaT, "2012-01-01"])
+        idx = PeriodIndex([Period("2011-01-01", freq="D"), NaT, "2012-01-01"])
         exp = PeriodIndex(["2011-01-01", "NaT", "2012-01-01"], freq="D")
         tm.assert_index_equal(idx, exp)
 
     def test_constructor_simple_new(self):
         idx = period_range("2007-01", name="p", periods=2, freq="M")
-        result = idx._simple_new(idx, name="p", freq=idx.freq)
+
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p", freq=idx.freq)
+
+        result = idx._simple_new(idx._data, name="p", freq=idx.freq)
         tm.assert_index_equal(result, idx)
 
-        result = idx._simple_new(idx.astype("i8"), name="p", freq=idx.freq)
+        with pytest.raises(AssertionError):
+            # Need ndarray, not Int64Index
+            type(idx._data)._simple_new(idx.astype("i8"), freq=idx.freq)
+
+        arr = type(idx._data)._simple_new(idx.asi8, freq=idx.freq)
+        result = idx._simple_new(arr, name="p")
         tm.assert_index_equal(result, idx)
 
     def test_constructor_simple_new_empty(self):
         # GH13079
         idx = PeriodIndex([], freq="M", name="p")
-        result = idx._simple_new(idx, name="p", freq="M")
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p", freq="M")
+
+        result = idx._simple_new(idx._data, name="p", freq="M")
         tm.assert_index_equal(result, idx)
 
     @pytest.mark.parametrize("floats", [[1.1, 2.1], np.array([1.1, 2.1])])
     def test_constructor_floats(self, floats):
-        msg = r"PeriodIndex\._simple_new does not accept floats"
-        with pytest.raises(TypeError, match=msg):
-            pd.PeriodIndex._simple_new(floats, freq="M")
+        with pytest.raises(AssertionError, match="<class "):
+            PeriodIndex._simple_new(floats, freq="M")
 
         msg = "PeriodIndex does not allow floating point in construction"
         with pytest.raises(TypeError, match=msg):
-            pd.PeriodIndex(floats, freq="M")
+            PeriodIndex(floats, freq="M")
 
     def test_constructor_nat(self):
         msg = "start and end must not be NaT"
@@ -368,27 +369,20 @@ def test_constructor_year_and_quarter(self):
         p = PeriodIndex(lops)
         tm.assert_index_equal(p, idx)
 
-    @pytest.mark.parametrize(
-        "func, warning", [(PeriodIndex, FutureWarning), (period_range, None)]
-    )
-    def test_constructor_freq_mult(self, func, warning):
+    def test_constructor_freq_mult(self):
         # GH #7811
-        with tm.assert_produces_warning(warning):
-            # must be the same, but for sure...
-            pidx = func(start="2014-01", freq="2M", periods=4)
+        pidx = period_range(start="2014-01", freq="2M", periods=4)
         expected = PeriodIndex(["2014-01", "2014-03", "2014-05", "2014-07"], freq="2M")
         tm.assert_index_equal(pidx, expected)
 
-        with tm.assert_produces_warning(warning):
-            pidx = func(start="2014-01-02", end="2014-01-15", freq="3D")
+        pidx = period_range(start="2014-01-02", end="2014-01-15", freq="3D")
         expected = PeriodIndex(
             ["2014-01-02", "2014-01-05", "2014-01-08", "2014-01-11", "2014-01-14"],
             freq="3D",
         )
         tm.assert_index_equal(pidx, expected)
 
-        with tm.assert_produces_warning(warning):
-            pidx = func(end="2014-01-01 17:00", freq="4H", periods=3)
+        pidx = period_range(end="2014-01-01 17:00", freq="4H", periods=3)
         expected = PeriodIndex(
             ["2014-01-01 09:00", "2014-01-01 13:00", "2014-01-01 17:00"], freq="4H"
         )
@@ -425,18 +419,6 @@ def test_constructor_freq_combined(self):
             expected = PeriodIndex(["2016-01-01 00:00", "2016-01-02 01:00"], freq="25H")
             tm.assert_index_equal(pidx, expected)
 
-    def test_constructor_range_based_deprecated(self):
-        with tm.assert_produces_warning(FutureWarning):
-            pi = PeriodIndex(freq="A", start="1/1/2001", end="12/1/2009")
-        assert len(pi) == 9
-
-    def test_constructor_range_based_deprecated_different_freq(self):
-        with tm.assert_produces_warning(FutureWarning) as m:
-            PeriodIndex(start="2000", periods=2)
-
-        warning, = m
-        assert 'freq="A-DEC"' in str(warning.message)
-
     def test_constructor(self):
         pi = period_range(freq="A", start="1/1/2001", end="12/1/2009")
         assert len(pi) == 9
@@ -507,21 +489,6 @@ def test_constructor(self):
         with pytest.raises(IncompatibleFrequency, match=msg):
             PeriodIndex(vals)
 
-    def test_constructor_error(self):
-        start = Period("02-Apr-2005", "B")
-        end_intv = Period("2006-12-31", ("w", 1))
-
-        msg = "start and end must have same freq"
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(start=start, end=end_intv)
-
-        msg = (
-            "Of the three parameters: start, end, and periods, "
-            "exactly two must be specified"
-        )
-        with pytest.raises(ValueError, match=msg):
-            PeriodIndex(start=start)
-
     @pytest.mark.parametrize(
         "freq", ["M", "Q", "A", "D", "B", "T", "S", "L", "U", "N", "H"]
     )
diff --git a/pandas/tests/indexes/period/test_formats.py b/pandas/tests/indexes/period/test_formats.py
index 2a88b79f381c4..5db373a9f07ae 100644
--- a/pandas/tests/indexes/period/test_formats.py
+++ b/pandas/tests/indexes/period/test_formats.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import PeriodIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_to_native_types():
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index cf03e2c7847f0..077fa2a0b1c56 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta
+import re
 
 import numpy as np
 import pytest
@@ -6,8 +7,19 @@
 from pandas._libs.tslibs import period as libperiod
 
 import pandas as pd
-from pandas import DatetimeIndex, Period, PeriodIndex, Series, notna, period_range
-from pandas.util import testing as tm
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    date_range,
+    notna,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.indexes.base import InvalidIndexError
 
 
 class TestGetItem:
@@ -20,23 +32,23 @@ def test_ellipsis(self):
         assert result is not idx
 
     def test_getitem(self):
-        idx1 = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
 
         for idx in [idx1]:
             result = idx[0]
-            assert result == pd.Period("2011-01-01", freq="D")
+            assert result == Period("2011-01-01", freq="D")
 
             result = idx[-1]
-            assert result == pd.Period("2011-01-31", freq="D")
+            assert result == Period("2011-01-31", freq="D")
 
             result = idx[0:5]
-            expected = pd.period_range("2011-01-01", "2011-01-05", freq="D", name="idx")
+            expected = period_range("2011-01-01", "2011-01-05", freq="D", name="idx")
             tm.assert_index_equal(result, expected)
             assert result.freq == expected.freq
             assert result.freq == "D"
 
             result = idx[0:10:2]
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-01", "2011-01-03", "2011-01-05", "2011-01-07", "2011-01-09"],
                 freq="D",
                 name="idx",
@@ -46,7 +58,7 @@ def test_getitem(self):
             assert result.freq == "D"
 
             result = idx[-20:-5:3]
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-12", "2011-01-15", "2011-01-18", "2011-01-21", "2011-01-24"],
                 freq="D",
                 name="idx",
@@ -69,11 +81,11 @@ def test_getitem_index(self):
         idx = period_range("2007-01", periods=10, freq="M", name="x")
 
         result = idx[[1, 3, 5]]
-        exp = pd.PeriodIndex(["2007-02", "2007-04", "2007-06"], freq="M", name="x")
+        exp = PeriodIndex(["2007-02", "2007-04", "2007-06"], freq="M", name="x")
         tm.assert_index_equal(result, exp)
 
         result = idx[[True, True, False, False, False, True, True, False, False, False]]
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2007-01", "2007-02", "2007-06", "2007-07"], freq="M", name="x"
         )
         tm.assert_index_equal(result, exp)
@@ -123,16 +135,16 @@ def test_getitem_datetime(self):
         tm.assert_series_equal(rs, ts)
 
     def test_getitem_nat(self):
-        idx = pd.PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
-        assert idx[0] == pd.Period("2011-01", freq="M")
-        assert idx[1] is pd.NaT
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert idx[0] == Period("2011-01", freq="M")
+        assert idx[1] is NaT
 
         s = pd.Series([0, 1, 2], index=idx)
-        assert s[pd.NaT] == 1
+        assert s[NaT] == 1
 
         s = pd.Series(idx, index=idx)
-        assert s[pd.Period("2011-01", freq="M")] == pd.Period("2011-01", freq="M")
-        assert s[pd.NaT] is pd.NaT
+        assert s[Period("2011-01", freq="M")] == Period("2011-01", freq="M")
+        assert s[NaT] is NaT
 
     def test_getitem_list_periods(self):
         # GH 7710
@@ -143,7 +155,7 @@ def test_getitem_list_periods(self):
 
     def test_getitem_seconds(self):
         # GH#6716
-        didx = pd.date_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
+        didx = date_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
         pidx = period_range(start="2013/01/01 09:00:00", freq="S", periods=4000)
 
         for idx in [didx, pidx]:
@@ -172,7 +184,7 @@ def test_getitem_seconds(self):
     def test_getitem_day(self):
         # GH#6716
         # Confirm DatetimeIndex and PeriodIndex works identically
-        didx = pd.date_range(start="2013/01/01", freq="D", periods=400)
+        didx = date_range(start="2013/01/01", freq="D", periods=400)
         pidx = period_range(start="2013/01/01", freq="D", periods=400)
 
         for idx in [didx, pidx]:
@@ -214,48 +226,63 @@ def test_where(self, klass):
         tm.assert_index_equal(result, expected)
 
         cond = [False] + [True] * (len(i) - 1)
-        expected = PeriodIndex([pd.NaT] + i[1:].tolist(), freq="D")
+        expected = PeriodIndex([NaT] + i[1:].tolist(), freq="D")
         result = i.where(klass(cond))
         tm.assert_index_equal(result, expected)
 
     def test_where_other(self):
         i = period_range("20130101", periods=5, freq="D")
-        for arr in [np.nan, pd.NaT]:
+        for arr in [np.nan, NaT]:
             result = i.where(notna(i), other=np.nan)
             expected = i
             tm.assert_index_equal(result, expected)
 
         i2 = i.copy()
-        i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(), freq="D")
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
         result = i.where(notna(i2), i2)
         tm.assert_index_equal(result, i2)
 
         i2 = i.copy()
-        i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(), freq="D")
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
         result = i.where(notna(i2), i2.values)
         tm.assert_index_equal(result, i2)
 
+    def test_where_invalid_dtypes(self):
+        pi = period_range("20130101", periods=5, freq="D")
+
+        i2 = pi.copy()
+        i2 = PeriodIndex([NaT, NaT] + pi[2:].tolist(), freq="D")
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            pi.where(notna(i2), i2.asi8)
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            pi.where(notna(i2), i2.asi8.view("timedelta64[ns]"))
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            pi.where(notna(i2), i2.to_timestamp("S"))
+
 
 class TestTake:
     def test_take(self):
         # GH#10295
-        idx1 = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
 
         for idx in [idx1]:
             result = idx.take([0])
-            assert result == pd.Period("2011-01-01", freq="D")
+            assert result == Period("2011-01-01", freq="D")
 
             result = idx.take([5])
-            assert result == pd.Period("2011-01-06", freq="D")
+            assert result == Period("2011-01-06", freq="D")
 
             result = idx.take([0, 1, 2])
-            expected = pd.period_range("2011-01-01", "2011-01-03", freq="D", name="idx")
+            expected = period_range("2011-01-01", "2011-01-03", freq="D", name="idx")
             tm.assert_index_equal(result, expected)
             assert result.freq == "D"
             assert result.freq == expected.freq
 
             result = idx.take([0, 2, 4])
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-01", "2011-01-03", "2011-01-05"], freq="D", name="idx"
             )
             tm.assert_index_equal(result, expected)
@@ -263,7 +290,7 @@ def test_take(self):
             assert result.freq == "D"
 
             result = idx.take([7, 4, 1])
-            expected = pd.PeriodIndex(
+            expected = PeriodIndex(
                 ["2011-01-08", "2011-01-05", "2011-01-02"], freq="D", name="idx"
             )
             tm.assert_index_equal(result, expected)
@@ -310,25 +337,25 @@ def test_take_misc(self):
 
     def test_take_fill_value(self):
         # GH#12631
-        idx = pd.PeriodIndex(
+        idx = PeriodIndex(
             ["2011-01-01", "2011-02-01", "2011-03-01"], name="xxx", freq="D"
         )
         result = idx.take(np.array([1, 0, -1]))
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
 
         # fill_value
         result = idx.take(np.array([1, 0, -1]), fill_value=True)
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "NaT"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
 
         # allow_fill=False
         result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
-        expected = pd.PeriodIndex(
+        expected = PeriodIndex(
             ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
         )
         tm.assert_index_equal(result, expected)
@@ -342,7 +369,7 @@ def test_take_fill_value(self):
         with pytest.raises(ValueError, match=msg):
             idx.take(np.array([1, 0, -5]), fill_value=True)
 
-        msg = "index -5 is out of bounds for size 3"
+        msg = "index -5 is out of bounds for( axis 0 with)? size 3"
         with pytest.raises(IndexError, match=msg):
             idx.take(np.array([1, -5]))
 
@@ -365,20 +392,20 @@ def test_get_loc_nat(self):
 
         # check DatetimeIndex compat
         for idx in [didx, pidx]:
-            assert idx.get_loc(pd.NaT) == 1
+            assert idx.get_loc(NaT) == 1
             assert idx.get_loc(None) == 1
             assert idx.get_loc(float("nan")) == 1
             assert idx.get_loc(np.nan) == 1
 
     def test_get_loc(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
         # get the location of p1/p2 from
         # monotonic increasing PeriodIndex with non-duplicate
-        idx0 = pd.PeriodIndex([p0, p1, p2])
+        idx0 = PeriodIndex([p0, p1, p2])
         expected_idx1_p1 = 1
         expected_idx1_p2 = 2
 
@@ -393,16 +420,12 @@ def test_get_loc(self):
         with pytest.raises(KeyError, match=r"^1\.1$"):
             idx0.get_loc(1.1)
 
-        msg = (
-            r"'PeriodIndex\(\['2017-09-01', '2017-09-02', '2017-09-03'\],"
-            r" dtype='period\[D\]', freq='D'\)' is an invalid key"
-        )
-        with pytest.raises(TypeError, match=msg):
+        with pytest.raises(InvalidIndexError, match=re.escape(str(idx0))):
             idx0.get_loc(idx0)
 
         # get the location of p1/p2 from
         # monotonic increasing PeriodIndex with duplicate
-        idx1 = pd.PeriodIndex([p1, p1, p2])
+        idx1 = PeriodIndex([p1, p1, p2])
         expected_idx1_p1 = slice(0, 2)
         expected_idx1_p2 = 2
 
@@ -418,16 +441,12 @@ def test_get_loc(self):
         with pytest.raises(KeyError, match=r"^1\.1$"):
             idx1.get_loc(1.1)
 
-        msg = (
-            r"'PeriodIndex\(\['2017-09-02', '2017-09-02', '2017-09-03'\],"
-            r" dtype='period\[D\]', freq='D'\)' is an invalid key"
-        )
-        with pytest.raises(TypeError, match=msg):
+        with pytest.raises(InvalidIndexError, match=re.escape(str(idx1))):
             idx1.get_loc(idx1)
 
         # get the location of p1/p2 from
         # non-monotonic increasing/decreasing PeriodIndex with duplicate
-        idx2 = pd.PeriodIndex([p2, p1, p2])
+        idx2 = PeriodIndex([p2, p1, p2])
         expected_idx2_p1 = 1
         expected_idx2_p2 = np.array([True, False, True])
 
@@ -436,17 +455,71 @@ def test_get_loc(self):
         tm.assert_numpy_array_equal(idx2.get_loc(p2), expected_idx2_p2)
         tm.assert_numpy_array_equal(idx2.get_loc(str(p2)), expected_idx2_p2)
 
+    def test_get_loc_integer(self):
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        with pytest.raises(KeyError, match="16801"):
+            pi.get_loc(16801)
+
+        pi2 = dti.to_period("Y")  # duplicates, ordinals are all 46
+        with pytest.raises(KeyError, match="46"):
+            pi2.get_loc(46)
+
+    @pytest.mark.parametrize("freq", ["H", "D"])
+    def test_get_value_datetime_hourly(self, freq):
+        # get_loc and get_value should treat datetime objects symmetrically
+        dti = date_range("2016-01-01", periods=3, freq="MS")
+        pi = dti.to_period(freq)
+        ser = pd.Series(range(7, 10), index=pi)
+
+        ts = dti[0]
+
+        assert pi.get_loc(ts) == 0
+        assert pi.get_value(ser, ts) == 7
+        assert ser[ts] == 7
+        assert ser.loc[ts] == 7
+
+        ts2 = ts + Timedelta(hours=3)
+        if freq == "H":
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                pi.get_loc(ts2)
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                pi.get_value(ser, ts2)
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                ser[ts2]
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                ser.loc[ts2]
+        else:
+            assert pi.get_loc(ts2) == 0
+            assert pi.get_value(ser, ts2) == 7
+            assert ser[ts2] == 7
+            assert ser.loc[ts2] == 7
+
+    def test_get_value_integer(self):
+        msg = "index 16801 is out of bounds for axis 0 with size 3"
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        ser = pd.Series(range(3), index=pi)
+        with pytest.raises(IndexError, match=msg):
+            pi.get_value(ser, 16801)
+
+        msg = "index 46 is out of bounds for axis 0 with size 3"
+        pi2 = dti.to_period("Y")  # duplicates, ordinals are all 46
+        ser2 = pd.Series(range(3), index=pi2)
+        with pytest.raises(IndexError, match=msg):
+            pi2.get_value(ser2, 46)
+
     def test_is_monotonic_increasing(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx_inc0 = pd.PeriodIndex([p0, p1, p2])
-        idx_inc1 = pd.PeriodIndex([p0, p1, p1])
-        idx_dec0 = pd.PeriodIndex([p2, p1, p0])
-        idx_dec1 = pd.PeriodIndex([p2, p1, p1])
-        idx = pd.PeriodIndex([p1, p2, p0])
+        idx_inc0 = PeriodIndex([p0, p1, p2])
+        idx_inc1 = PeriodIndex([p0, p1, p1])
+        idx_dec0 = PeriodIndex([p2, p1, p0])
+        idx_dec1 = PeriodIndex([p2, p1, p1])
+        idx = PeriodIndex([p1, p2, p0])
 
         assert idx_inc0.is_monotonic_increasing is True
         assert idx_inc1.is_monotonic_increasing is True
@@ -456,15 +529,15 @@ def test_is_monotonic_increasing(self):
 
     def test_is_monotonic_decreasing(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx_inc0 = pd.PeriodIndex([p0, p1, p2])
-        idx_inc1 = pd.PeriodIndex([p0, p1, p1])
-        idx_dec0 = pd.PeriodIndex([p2, p1, p0])
-        idx_dec1 = pd.PeriodIndex([p2, p1, p1])
-        idx = pd.PeriodIndex([p1, p2, p0])
+        idx_inc0 = PeriodIndex([p0, p1, p2])
+        idx_inc1 = PeriodIndex([p0, p1, p1])
+        idx_dec0 = PeriodIndex([p2, p1, p0])
+        idx_dec1 = PeriodIndex([p2, p1, p1])
+        idx = PeriodIndex([p1, p2, p0])
 
         assert idx_inc0.is_monotonic_decreasing is False
         assert idx_inc1.is_monotonic_decreasing is False
@@ -474,19 +547,27 @@ def test_is_monotonic_decreasing(self):
 
     def test_contains(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
-        p3 = pd.Period("2017-09-04")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
 
         ps0 = [p0, p1, p2]
-        idx0 = pd.PeriodIndex(ps0)
+        idx0 = PeriodIndex(ps0)
+        ser = pd.Series(range(6, 9), index=idx0)
 
         for p in ps0:
             assert p in idx0
             assert str(p) in idx0
 
-        assert "2017-09-01 00:00:01" in idx0
+        # GH#31172
+        # Higher-resolution period-like are _not_ considered as contained
+        key = "2017-09-01 00:00:01"
+        assert key not in idx0
+        with pytest.raises(KeyError, match=key):
+            idx0.get_loc(key)
+        with pytest.raises(KeyError, match=key):
+            idx0.get_value(ser, key)
 
         assert "2017-09" in idx0
 
@@ -494,49 +575,49 @@ def test_contains(self):
 
     def test_get_value(self):
         # GH 17717
-        p0 = pd.Period("2017-09-01")
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
 
-        idx0 = pd.PeriodIndex([p0, p1, p2])
-        input0 = np.array([1, 2, 3])
+        idx0 = PeriodIndex([p0, p1, p2])
+        input0 = pd.Series(np.array([1, 2, 3]), index=idx0)
         expected0 = 2
 
         result0 = idx0.get_value(input0, p1)
         assert result0 == expected0
 
-        idx1 = pd.PeriodIndex([p1, p1, p2])
-        input1 = np.array([1, 2, 3])
-        expected1 = np.array([1, 2])
+        idx1 = PeriodIndex([p1, p1, p2])
+        input1 = pd.Series(np.array([1, 2, 3]), index=idx1)
+        expected1 = input1.iloc[[0, 1]]
 
         result1 = idx1.get_value(input1, p1)
-        tm.assert_numpy_array_equal(result1, expected1)
+        tm.assert_series_equal(result1, expected1)
 
-        idx2 = pd.PeriodIndex([p1, p2, p1])
-        input2 = np.array([1, 2, 3])
-        expected2 = np.array([1, 3])
+        idx2 = PeriodIndex([p1, p2, p1])
+        input2 = pd.Series(np.array([1, 2, 3]), index=idx2)
+        expected2 = input2.iloc[[0, 2]]
 
         result2 = idx2.get_value(input2, p1)
-        tm.assert_numpy_array_equal(result2, expected2)
+        tm.assert_series_equal(result2, expected2)
 
     def test_get_indexer(self):
         # GH 17717
-        p1 = pd.Period("2017-09-01")
-        p2 = pd.Period("2017-09-04")
-        p3 = pd.Period("2017-09-07")
+        p1 = Period("2017-09-01")
+        p2 = Period("2017-09-04")
+        p3 = Period("2017-09-07")
 
-        tp0 = pd.Period("2017-08-31")
-        tp1 = pd.Period("2017-09-02")
-        tp2 = pd.Period("2017-09-05")
-        tp3 = pd.Period("2017-09-09")
+        tp0 = Period("2017-08-31")
+        tp1 = Period("2017-09-02")
+        tp2 = Period("2017-09-05")
+        tp3 = Period("2017-09-09")
 
-        idx = pd.PeriodIndex([p1, p2, p3])
+        idx = PeriodIndex([p1, p2, p3])
 
         tm.assert_numpy_array_equal(
             idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
         )
 
-        target = pd.PeriodIndex([tp0, tp1, tp2, tp3])
+        target = PeriodIndex([tp0, tp1, tp2, tp3])
         tm.assert_numpy_array_equal(
             idx.get_indexer(target, "pad"), np.array([-1, 0, 1, 2], dtype=np.intp)
         )
@@ -547,18 +628,47 @@ def test_get_indexer(self):
             idx.get_indexer(target, "nearest"), np.array([0, 0, 1, 2], dtype=np.intp)
         )
 
-        res = idx.get_indexer(target, "nearest", tolerance=pd.Timedelta("1 day"))
+        res = idx.get_indexer(target, "nearest", tolerance=Timedelta("1 day"))
         tm.assert_numpy_array_equal(res, np.array([0, 0, 1, -1], dtype=np.intp))
 
+    def test_get_indexer_mismatched_dtype(self):
+        # Check that we return all -1s and do not raise or cast incorrectly
+
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        pi2 = dti.to_period("W")
+
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+
+        result = pi.get_indexer(dti)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # This should work in both directions
+        result = dti.get_indexer(pi)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pi.get_indexer(pi2)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # We expect the same from get_indexer_non_unique
+        result = pi.get_indexer_non_unique(dti)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = dti.get_indexer_non_unique(pi)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pi.get_indexer_non_unique(pi2)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_get_indexer_non_unique(self):
         # GH 17717
-        p1 = pd.Period("2017-09-02")
-        p2 = pd.Period("2017-09-03")
-        p3 = pd.Period("2017-09-04")
-        p4 = pd.Period("2017-09-05")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
+        p4 = Period("2017-09-05")
 
-        idx1 = pd.PeriodIndex([p1, p2, p1])
-        idx2 = pd.PeriodIndex([p2, p1, p3, p4])
+        idx1 = PeriodIndex([p1, p2, p1])
+        idx2 = PeriodIndex([p2, p1, p3, p4])
 
         result = idx1.get_indexer_non_unique(idx2)
         expected_indexer = np.array([1, 0, 2, -1, -1], dtype=np.intp)
@@ -569,7 +679,7 @@ def test_get_indexer_non_unique(self):
 
     # TODO: This method came from test_period; de-dup with version above
     def test_get_loc2(self):
-        idx = pd.period_range("2000-01-01", periods=3)
+        idx = period_range("2000-01-01", periods=3)
 
         for method in [None, "pad", "backfill", "nearest"]:
             assert idx.get_loc(idx[1], method) == 1
@@ -578,10 +688,10 @@ def test_get_loc2(self):
             assert idx.get_loc(idx[1].to_timestamp().to_pydatetime(), method) == 1
             assert idx.get_loc(str(idx[1]), method) == 1
 
-        idx = pd.period_range("2000-01-01", periods=5)[::2]
+        idx = period_range("2000-01-01", periods=5)[::2]
         assert idx.get_loc("2000-01-02T12", method="nearest", tolerance="1 day") == 1
         assert (
-            idx.get_loc("2000-01-02T12", method="nearest", tolerance=pd.Timedelta("1D"))
+            idx.get_loc("2000-01-02T12", method="nearest", tolerance=Timedelta("1D"))
             == 1
         )
         assert (
@@ -610,19 +720,19 @@ def test_get_loc2(self):
                 "2000-01-10",
                 method="nearest",
                 tolerance=[
-                    pd.Timedelta("1 day").to_timedelta64(),
-                    pd.Timedelta("1 day").to_timedelta64(),
+                    Timedelta("1 day").to_timedelta64(),
+                    Timedelta("1 day").to_timedelta64(),
                 ],
             )
 
     # TODO: This method came from test_period; de-dup with version above
     def test_get_indexer2(self):
-        idx = pd.period_range("2000-01-01", periods=3).asfreq("H", how="start")
+        idx = period_range("2000-01-01", periods=3).asfreq("H", how="start")
         tm.assert_numpy_array_equal(
             idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
         )
 
-        target = pd.PeriodIndex(
+        target = PeriodIndex(
             ["1999-12-31T23", "2000-01-01T12", "2000-01-02T01"], freq="H"
         )
         tm.assert_numpy_array_equal(
@@ -648,8 +758,8 @@ def test_get_indexer2(self):
             np.array([0, 1, 1], dtype=np.intp),
         )
         tol_raw = [
-            pd.Timedelta("1 hour"),
-            pd.Timedelta("1 hour"),
+            Timedelta("1 hour"),
+            Timedelta("1 hour"),
             np.timedelta64(1, "D"),
         ]
         tm.assert_numpy_array_equal(
@@ -659,8 +769,8 @@ def test_get_indexer2(self):
             np.array([0, -1, 1], dtype=np.intp),
         )
         tol_bad = [
-            pd.Timedelta("2 hour").to_timedelta64(),
-            pd.Timedelta("1 hour").to_timedelta64(),
+            Timedelta("2 hour").to_timedelta64(),
+            Timedelta("1 hour").to_timedelta64(),
             np.timedelta64(1, "M"),
         ]
         with pytest.raises(
@@ -678,8 +788,8 @@ def test_indexing(self):
 
     def test_period_index_indexer(self):
         # GH4125
-        idx = pd.period_range("2002-01", "2003-12", freq="M")
-        df = pd.DataFrame(pd.np.random.randn(24, 10), index=idx)
+        idx = period_range("2002-01", "2003-12", freq="M")
+        df = pd.DataFrame(np.random.randn(24, 10), index=idx)
         tm.assert_frame_equal(df, df.loc[idx])
         tm.assert_frame_equal(df, df.loc[list(idx)])
         tm.assert_frame_equal(df, df.loc[list(idx)])
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index 96042f4dbaba2..196946e696c8d 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -2,25 +2,11 @@
 import pytest
 
 import pandas as pd
-from pandas import DatetimeIndex, Index, NaT, PeriodIndex, Series
-from pandas.core.arrays import PeriodArray
-from pandas.tests.test_base import Ops
-import pandas.util.testing as tm
+from pandas import Index, NaT, PeriodIndex, Series
+import pandas._testing as tm
 
 
-class TestPeriodIndexOps(Ops):
-    def setup_method(self, method):
-        super().setup_method(method)
-        mask = lambda x: (isinstance(x, DatetimeIndex) or isinstance(x, PeriodIndex))
-        self.is_valid_objs = [o for o in self.objs if mask(o)]
-        self.not_valid_objs = [o for o in self.objs if not mask(o)]
-
-    def test_ops_properties(self):
-        f = lambda x: isinstance(x, PeriodIndex)
-        self.check_ops_properties(PeriodArray._field_ops, f)
-        self.check_ops_properties(PeriodArray._object_ops, f)
-        self.check_ops_properties(PeriodArray._bool_ops, f)
-
+class TestPeriodIndexOps:
     def test_resolution(self):
         for freq, expected in zip(
             ["A", "Q", "M", "D", "H", "T", "S", "L", "U"],
@@ -280,10 +266,6 @@ def test_order(self):
             tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
             assert ordered.freq == "D"
 
-    def test_shift(self):
-        # This is tested in test_arithmetic
-        pass
-
     def test_nat(self):
         assert pd.PeriodIndex._na_value is NaT
         assert pd.PeriodIndex([], freq="M")._na_value is NaT
@@ -343,5 +325,5 @@ def test_freq_setter_deprecated(self):
             idx.freq
 
         # warning for setter
-        with tm.assert_produces_warning(FutureWarning):
+        with pytest.raises(AttributeError, match="can't set attribute"):
             idx.freq = pd.offsets.Day()
diff --git a/pandas/tests/indexes/period/test_partial_slicing.py b/pandas/tests/indexes/period/test_partial_slicing.py
index 00b9803980bc8..833901ea7ba22 100644
--- a/pandas/tests/indexes/period/test_partial_slicing.py
+++ b/pandas/tests/indexes/period/test_partial_slicing.py
@@ -3,13 +3,10 @@
 
 import pandas as pd
 from pandas import DataFrame, Period, Series, period_range
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestPeriodIndex:
-    def setup_method(self, method):
-        pass
-
     def test_slice_with_negative_step(self):
         ts = Series(np.arange(20), period_range("2014-01", periods=20, freq="M"))
         SLC = pd.IndexSlice
@@ -123,7 +120,7 @@ def test_range_slice_outofbounds(self):
 
         for idx in [didx, pidx]:
             df = DataFrame(dict(units=[100 + i for i in range(10)]), index=idx)
-            empty = DataFrame(index=idx.__class__([], freq="D"), columns=["units"])
+            empty = DataFrame(index=type(idx)([], freq="D"), columns=["units"])
             empty["units"] = empty["units"].astype("int64")
 
             tm.assert_frame_equal(df["2013/09/01":"2013/09/30"], empty)
@@ -133,3 +130,53 @@ def test_range_slice_outofbounds(self):
             tm.assert_frame_equal(df["2013/10/15":"2013/10/17"], empty)
             tm.assert_frame_equal(df["2013-06":"2013-09"], empty)
             tm.assert_frame_equal(df["2013-11":"2013-12"], empty)
+
+    def test_partial_slice_doesnt_require_monotonicity(self):
+        # See also: DatetimeIndex test ofm the same name
+        dti = pd.date_range("2014-01-01", periods=30, freq="30D")
+        pi = dti.to_period("D")
+
+        ser_montonic = pd.Series(np.arange(30), index=pi)
+
+        shuffler = list(range(0, 30, 2)) + list(range(1, 31, 2))
+        ser = ser_montonic[shuffler]
+        nidx = ser.index
+
+        # Manually identified locations of year==2014
+        indexer_2014 = np.array(
+            [0, 1, 2, 3, 4, 5, 6, 15, 16, 17, 18, 19, 20], dtype=np.intp
+        )
+        assert (nidx[indexer_2014].year == 2014).all()
+        assert not (nidx[~indexer_2014].year == 2014).any()
+
+        result = nidx.get_loc("2014")
+        tm.assert_numpy_array_equal(result, indexer_2014)
+
+        expected = ser[indexer_2014]
+
+        result = nidx.get_value(ser, "2014")
+        tm.assert_series_equal(result, expected)
+
+        result = ser.loc["2014"]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["2014"]
+        tm.assert_series_equal(result, expected)
+
+        # Manually identified locations where ser.index is within Mat 2015
+        indexer_may2015 = np.array([23], dtype=np.intp)
+        assert nidx[23].year == 2015 and nidx[23].month == 5
+
+        result = nidx.get_loc("May 2015")
+        tm.assert_numpy_array_equal(result, indexer_may2015)
+
+        expected = ser[indexer_may2015]
+
+        result = nidx.get_value(ser, "May 2015")
+        tm.assert_series_equal(result, expected)
+
+        result = ser.loc["May 2015"]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["May 2015"]
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index ee37be7ab4c14..4db93e850f579 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -17,7 +17,7 @@
     offsets,
     period_range,
 )
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 from ..datetimelike import DatetimeLike
 
@@ -25,12 +25,15 @@
 class TestPeriodIndex(DatetimeLike):
     _holder = PeriodIndex
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=tm.makePeriodIndex(10),
-            index_dec=period_range("20130101", periods=10, freq="D")[::-1],
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[
+            tm.makePeriodIndex(10),
+            period_range("20130101", periods=10, freq="D")[::-1],
+        ],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return request.param
 
     def create_index(self):
         return period_range("20130101", periods=5, freq="D")
@@ -52,9 +55,9 @@ def test_where(self):
     @pytest.mark.parametrize(
         "index",
         [
-            pd.period_range("2000-01-01", periods=3, freq="D"),
-            pd.period_range("2001-01-01", periods=3, freq="2D"),
-            pd.PeriodIndex(["2001-01", "NaT", "2003-01"], freq="M"),
+            period_range("2000-01-01", periods=3, freq="D"),
+            period_range("2001-01-01", periods=3, freq="2D"),
+            PeriodIndex(["2001-01", "NaT", "2003-01"], freq="M"),
         ],
     )
     def test_repeat_freqstr(self, index, use_numpy):
@@ -66,32 +69,32 @@ def test_repeat_freqstr(self, index, use_numpy):
 
     def test_fillna_period(self):
         # GH 11343
-        idx = pd.PeriodIndex(["2011-01-01 09:00", pd.NaT, "2011-01-01 11:00"], freq="H")
+        idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="H")
 
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"], freq="H"
         )
-        tm.assert_index_equal(idx.fillna(pd.Period("2011-01-01 10:00", freq="H")), exp)
+        tm.assert_index_equal(idx.fillna(Period("2011-01-01 10:00", freq="H")), exp)
 
-        exp = pd.Index(
+        exp = Index(
             [
-                pd.Period("2011-01-01 09:00", freq="H"),
+                Period("2011-01-01 09:00", freq="H"),
                 "x",
-                pd.Period("2011-01-01 11:00", freq="H"),
+                Period("2011-01-01 11:00", freq="H"),
             ],
             dtype=object,
         )
         tm.assert_index_equal(idx.fillna("x"), exp)
 
-        exp = pd.Index(
+        exp = Index(
             [
-                pd.Period("2011-01-01 09:00", freq="H"),
-                pd.Period("2011-01-01", freq="D"),
-                pd.Period("2011-01-01 11:00", freq="H"),
+                Period("2011-01-01 09:00", freq="H"),
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-01 11:00", freq="H"),
             ],
             dtype=object,
         )
-        tm.assert_index_equal(idx.fillna(pd.Period("2011-01-01", freq="D")), exp)
+        tm.assert_index_equal(idx.fillna(Period("2011-01-01", freq="D")), exp)
 
     def test_no_millisecond_field(self):
         msg = "type object 'DatetimeIndex' has no attribute 'millisecond'"
@@ -102,28 +105,9 @@ def test_no_millisecond_field(self):
         with pytest.raises(AttributeError, match=msg):
             DatetimeIndex([]).millisecond
 
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_freq(self, sort):
-        # GH14323: difference of Period MUST preserve frequency
-        # but the ability to union results must be preserved
-
-        index = period_range("20160920", "20160925", freq="D")
-
-        other = period_range("20160921", "20160924", freq="D")
-        expected = PeriodIndex(["20160920", "20160925"], freq="D")
-        idx_diff = index.difference(other, sort)
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
-        other = period_range("20160922", "20160925", freq="D")
-        idx_diff = index.difference(other, sort)
-        expected = PeriodIndex(["20160920", "20160921"], freq="D")
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
     def test_hash_error(self):
         index = period_range("20010101", periods=10)
-        msg = "unhashable type: '{}'".format(type(index).__name__)
+        msg = f"unhashable type: '{type(index).__name__}'"
         with pytest.raises(TypeError, match=msg):
             hash(index)
 
@@ -153,57 +137,45 @@ def test_shallow_copy_changing_freq_raises(self):
         with pytest.raises(IncompatibleFrequency, match=msg):
             pi._shallow_copy(pi, freq="H")
 
-    def test_dtype_str(self):
-        pi = pd.PeriodIndex([], freq="M")
-        with tm.assert_produces_warning(FutureWarning):
-            assert pi.dtype_str == "period[M]"
-            assert pi.dtype_str == str(pi.dtype)
-
-        with tm.assert_produces_warning(FutureWarning):
-            pi = pd.PeriodIndex([], freq="3M")
-            assert pi.dtype_str == "period[3M]"
-            assert pi.dtype_str == str(pi.dtype)
-
     def test_view_asi8(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=np.int64)
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
         exp = np.array([492, -9223372036854775808], dtype=np.int64)
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
         exp = np.array([14975, -9223372036854775808], dtype=np.int64)
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
         tm.assert_numpy_array_equal(idx.view("i8"), exp)
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
     def test_values(self):
-        idx = pd.PeriodIndex([], freq="M")
+        idx = PeriodIndex([], freq="M")
 
         exp = np.array([], dtype=np.object)
         tm.assert_numpy_array_equal(idx.values, exp)
         tm.assert_numpy_array_equal(idx.to_numpy(), exp)
-        with tm.assert_produces_warning(FutureWarning):
-            tm.assert_numpy_array_equal(idx.get_values(), exp)
+
         exp = np.array([], dtype=np.int64)
         tm.assert_numpy_array_equal(idx._ndarray_values, exp)
 
-        idx = pd.PeriodIndex(["2011-01", pd.NaT], freq="M")
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
 
-        exp = np.array([pd.Period("2011-01", freq="M"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.values, exp)
         tm.assert_numpy_array_equal(idx.to_numpy(), exp)
         exp = np.array([492, -9223372036854775808], dtype=np.int64)
         tm.assert_numpy_array_equal(idx._ndarray_values, exp)
 
-        idx = pd.PeriodIndex(["2011-01-01", pd.NaT], freq="D")
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
 
-        exp = np.array([pd.Period("2011-01-01", freq="D"), pd.NaT], dtype=object)
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
         tm.assert_numpy_array_equal(idx.values, exp)
         tm.assert_numpy_array_equal(idx.to_numpy(), exp)
         exp = np.array([14975, -9223372036854775808], dtype=np.int64)
@@ -251,8 +223,8 @@ def test_period_index_length(self):
         i1 = period_range(start=start, end=end_intv)
 
         msg = (
-            "Of the three parameters: start, end, and periods, exactly two"
-            " must be specified"
+            "Of the three parameters: start, end, and periods, exactly two "
+            "must be specified"
         )
         with pytest.raises(ValueError, match=msg):
             period_range(start=start)
@@ -399,7 +371,7 @@ def test_factorize(self):
         tm.assert_numpy_array_equal(arr, exp_arr)
         tm.assert_index_equal(idx, exp_idx)
 
-        idx2 = pd.PeriodIndex(
+        idx2 = PeriodIndex(
             ["2014-03", "2014-03", "2014-02", "2014-01", "2014-03", "2014-01"], freq="M"
         )
 
@@ -442,44 +414,31 @@ def test_contains(self):
     def test_contains_nat(self):
         # see gh-13582
         idx = period_range("2007-01", freq="M", periods=10)
-        assert pd.NaT not in idx
+        assert NaT not in idx
         assert None not in idx
         assert float("nan") not in idx
         assert np.nan not in idx
 
-        idx = pd.PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
-        assert pd.NaT in idx
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert NaT in idx
         assert None in idx
         assert float("nan") in idx
         assert np.nan in idx
 
     def test_periods_number_check(self):
         msg = (
-            "Of the three parameters: start, end, and periods, exactly two"
-            " must be specified"
+            "Of the three parameters: start, end, and periods, exactly two "
+            "must be specified"
         )
         with pytest.raises(ValueError, match=msg):
             period_range("2011-1-1", "2012-1-1", "B")
 
-    def test_start_time(self):
-        # GH 17157
-        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
-        expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
-        tm.assert_index_equal(index.start_time, expected_index)
-
-    def test_end_time(self):
-        # GH 17157
-        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
-        expected_index = date_range("2016-01-01", end="2016-05-31", freq="M")
-        expected_index = expected_index.shift(1, freq="D").shift(-1, freq="ns")
-        tm.assert_index_equal(index.end_time, expected_index)
-
     def test_index_duplicate_periods(self):
         # monotonic
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
         ts = Series(np.random.randn(len(idx)), index=idx)
 
-        result = ts[2007]
+        result = ts["2007"]
         expected = ts[1:3]
         tm.assert_series_equal(result, expected)
         result[:] = 1
@@ -489,8 +448,8 @@ def test_index_duplicate_periods(self):
         idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="A-JUN")
         ts = Series(np.random.randn(len(idx)), index=idx)
 
-        result = ts[2007]
-        expected = ts[idx == 2007]
+        result = ts["2007"]
+        expected = ts[idx == "2007"]
         tm.assert_series_equal(result, expected)
 
     def test_index_unique(self):
@@ -537,15 +496,10 @@ def test_pindex_qaccess(self):
         assert s["05Q4"] == s[2]
 
     def test_pindex_multiples(self):
-        with tm.assert_produces_warning(FutureWarning):
-            pi = PeriodIndex(start="1/1/11", end="12/31/11", freq="2M")
         expected = PeriodIndex(
             ["2011-01", "2011-03", "2011-05", "2011-07", "2011-09", "2011-11"],
             freq="2M",
         )
-        tm.assert_index_equal(pi, expected)
-        assert pi.freq == offsets.MonthEnd(2)
-        assert pi.freqstr == "2M"
 
         pi = period_range(start="1/1/11", end="12/31/11", freq="2M")
         tm.assert_index_equal(pi, expected)
@@ -598,7 +552,7 @@ def test_convert_array_of_periods(self):
         rng = period_range("1/1/2000", periods=20, freq="D")
         periods = list(rng)
 
-        result = pd.Index(periods)
+        result = Index(periods)
         assert isinstance(result, PeriodIndex)
 
     def test_append_concat(self):
@@ -639,13 +593,49 @@ def test_join_self(self, join_type):
 
     def test_insert(self):
         # GH 18295 (test missing)
-        expected = PeriodIndex(
-            ["2017Q1", pd.NaT, "2017Q2", "2017Q3", "2017Q4"], freq="Q"
-        )
-        for na in (np.nan, pd.NaT, None):
+        expected = PeriodIndex(["2017Q1", NaT, "2017Q2", "2017Q3", "2017Q4"], freq="Q")
+        for na in (np.nan, NaT, None):
             result = period_range("2017Q1", periods=4, freq="Q").insert(1, na)
             tm.assert_index_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "msg, key",
+        [
+            (r"Period\('2019', 'A-DEC'\), 'foo', 'bar'", (Period(2019), "foo", "bar")),
+            (r"Period\('2019', 'A-DEC'\), 'y1', 'bar'", (Period(2019), "y1", "bar")),
+            (r"Period\('2019', 'A-DEC'\), 'foo', 'z1'", (Period(2019), "foo", "z1")),
+            (
+                r"Period\('2018', 'A-DEC'\), Period\('2016', 'A-DEC'\), 'bar'",
+                (Period(2018), Period(2016), "bar"),
+            ),
+            (r"Period\('2018', 'A-DEC'\), 'foo', 'y1'", (Period(2018), "foo", "y1")),
+            (
+                r"Period\('2017', 'A-DEC'\), 'foo', Period\('2015', 'A-DEC'\)",
+                (Period(2017), "foo", Period(2015)),
+            ),
+            (r"Period\('2017', 'A-DEC'\), 'z1', 'bar'", (Period(2017), "z1", "bar")),
+        ],
+    )
+    def test_contains_raise_error_if_period_index_is_in_multi_index(self, msg, key):
+        # issue 20684
+        """
+        parse_time_string return parameter if type not matched.
+        PeriodIndex.get_loc takes returned value from parse_time_string as a tuple.
+        If first argument is Period and a tuple has 3 items,
+        process go on not raise exception
+        """
+        df = DataFrame(
+            {
+                "A": [Period(2019), "x1", "x2"],
+                "B": [Period(2018), Period(2016), "y1"],
+                "C": [Period(2017), "z1", Period(2015)],
+                "V1": [1, 2, 3],
+                "V2": [10, 20, 30],
+            }
+        ).set_index(["A", "B", "C"])
+        with pytest.raises(KeyError, match=msg):
+            df.loc[key]
+
 
 def test_maybe_convert_timedelta():
     pi = PeriodIndex(["2000", "2001"], freq="D")
@@ -657,3 +647,44 @@ def test_maybe_convert_timedelta():
     msg = r"Input has different freq=B from PeriodIndex\(freq=D\)"
     with pytest.raises(ValueError, match=msg):
         pi._maybe_convert_timedelta(offset)
+
+
+def test_is_monotonic_with_nat():
+    # GH#31437
+    # PeriodIndex.is_monotonic should behave analogously to DatetimeIndex,
+    #  in particular never be monotonic when we have NaT
+    dti = date_range("2016-01-01", periods=3)
+    pi = dti.to_period("D")
+    tdi = Index(dti.view("timedelta64[ns]"))
+
+    for obj in [pi, pi._engine, dti, dti._engine, tdi, tdi._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert obj.is_monotonic
+        assert obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique
+
+    dti1 = dti.insert(0, NaT)
+    pi1 = dti1.to_period("D")
+    tdi1 = Index(dti1.view("timedelta64[ns]"))
+
+    for obj in [pi1, pi1._engine, dti1, dti1._engine, tdi1, tdi1._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert not obj.is_monotonic
+        assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique
+
+    dti2 = dti.insert(3, NaT)
+    pi2 = dti2.to_period("H")
+    tdi2 = Index(dti2.view("timedelta64[ns]"))
+
+    for obj in [pi2, pi2._engine, dti2, dti2._engine, tdi2, tdi2._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert not obj.is_monotonic
+        assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique
diff --git a/pandas/tests/indexes/period/test_period_range.py b/pandas/tests/indexes/period/test_period_range.py
index 828fab08daceb..2c3d22198df9f 100644
--- a/pandas/tests/indexes/period/test_period_range.py
+++ b/pandas/tests/indexes/period/test_period_range.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import NaT, Period, PeriodIndex, date_range, period_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestPeriodRange:
diff --git a/pandas/tests/indexes/period/test_scalar_compat.py b/pandas/tests/indexes/period/test_scalar_compat.py
index 7956b9f26e6ef..0f92b7a4e168b 100644
--- a/pandas/tests/indexes/period/test_scalar_compat.py
+++ b/pandas/tests/indexes/period/test_scalar_compat.py
@@ -1,16 +1,18 @@
 """Tests for PeriodIndex behaving like a vectorized Period scalar"""
 
 from pandas import Timedelta, date_range, period_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestPeriodIndexOps:
     def test_start_time(self):
+        # GH#17157
         index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
         expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
         tm.assert_index_equal(index.start_time, expected_index)
 
     def test_end_time(self):
+        # GH#17157
         index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
         expected_index = date_range("2016-01-01", end="2016-05-31", freq="M")
         expected_index += Timedelta(1, "D") - Timedelta(1, "ns")
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index 03e4bd5834166..6f254b7b4408d 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -1,10 +1,11 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs import IncompatibleFrequency
+
 import pandas as pd
 from pandas import Index, PeriodIndex, date_range, period_range
-import pandas.core.indexes.period as period
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _permute(obj):
@@ -43,9 +44,9 @@ def test_join_does_not_recur(self):
     @pytest.mark.parametrize("sort", [None, False])
     def test_union(self, sort):
         # union
-        other1 = pd.period_range("1/1/2000", freq="D", periods=5)
-        rng1 = pd.period_range("1/6/2000", freq="D", periods=5)
-        expected1 = pd.PeriodIndex(
+        other1 = period_range("1/1/2000", freq="D", periods=5)
+        rng1 = period_range("1/6/2000", freq="D", periods=5)
+        expected1 = PeriodIndex(
             [
                 "2000-01-06",
                 "2000-01-07",
@@ -61,17 +62,17 @@ def test_union(self, sort):
             freq="D",
         )
 
-        rng2 = pd.period_range("1/1/2000", freq="D", periods=5)
-        other2 = pd.period_range("1/4/2000", freq="D", periods=5)
-        expected2 = pd.period_range("1/1/2000", freq="D", periods=8)
+        rng2 = period_range("1/1/2000", freq="D", periods=5)
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = period_range("1/1/2000", freq="D", periods=8)
 
-        rng3 = pd.period_range("1/1/2000", freq="D", periods=5)
-        other3 = pd.PeriodIndex([], freq="D")
-        expected3 = pd.period_range("1/1/2000", freq="D", periods=5)
+        rng3 = period_range("1/1/2000", freq="D", periods=5)
+        other3 = PeriodIndex([], freq="D")
+        expected3 = period_range("1/1/2000", freq="D", periods=5)
 
-        rng4 = pd.period_range("2000-01-01 09:00", freq="H", periods=5)
-        other4 = pd.period_range("2000-01-02 09:00", freq="H", periods=5)
-        expected4 = pd.PeriodIndex(
+        rng4 = period_range("2000-01-01 09:00", freq="H", periods=5)
+        other4 = period_range("2000-01-02 09:00", freq="H", periods=5)
+        expected4 = PeriodIndex(
             [
                 "2000-01-01 09:00",
                 "2000-01-01 10:00",
@@ -87,13 +88,13 @@ def test_union(self, sort):
             freq="H",
         )
 
-        rng5 = pd.PeriodIndex(
+        rng5 = PeriodIndex(
             ["2000-01-01 09:01", "2000-01-01 09:03", "2000-01-01 09:05"], freq="T"
         )
-        other5 = pd.PeriodIndex(
+        other5 = PeriodIndex(
             ["2000-01-01 09:01", "2000-01-01 09:05", "2000-01-01 09:08"], freq="T"
         )
-        expected5 = pd.PeriodIndex(
+        expected5 = PeriodIndex(
             [
                 "2000-01-01 09:01",
                 "2000-01-01 09:03",
@@ -103,13 +104,13 @@ def test_union(self, sort):
             freq="T",
         )
 
-        rng6 = pd.period_range("2000-01-01", freq="M", periods=7)
-        other6 = pd.period_range("2000-04-01", freq="M", periods=7)
-        expected6 = pd.period_range("2000-01-01", freq="M", periods=10)
+        rng6 = period_range("2000-01-01", freq="M", periods=7)
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = period_range("2000-01-01", freq="M", periods=10)
 
-        rng7 = pd.period_range("2003-01-01", freq="A", periods=5)
-        other7 = pd.period_range("1998-01-01", freq="A", periods=8)
-        expected7 = pd.PeriodIndex(
+        rng7 = period_range("2003-01-01", freq="A", periods=5)
+        other7 = period_range("1998-01-01", freq="A", periods=8)
+        expected7 = PeriodIndex(
             [
                 "2003",
                 "2004",
@@ -125,11 +126,11 @@ def test_union(self, sort):
             freq="A",
         )
 
-        rng8 = pd.PeriodIndex(
+        rng8 = PeriodIndex(
             ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"], freq="D"
         )
-        other8 = pd.period_range("1/6/2000", freq="D", periods=5)
-        expected8 = pd.PeriodIndex(
+        other8 = period_range("1/6/2000", freq="D", periods=5)
+        expected8 = PeriodIndex(
             [
                 "1/3/2000",
                 "1/2/2000",
@@ -177,22 +178,23 @@ def test_union_misc(self, sort):
         # raise if different frequencies
         index = period_range("1/1/2000", "1/20/2000", freq="D")
         index2 = period_range("1/1/2000", "1/20/2000", freq="W-WED")
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             index.union(index2, sort=sort)
 
         index3 = period_range("1/1/2000", "1/20/2000", freq="2D")
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             index.join(index3)
 
+    # TODO: belongs elsewhere
     def test_union_dataframe_index(self):
-        rng1 = pd.period_range("1/1/1999", "1/1/2012", freq="M")
+        rng1 = period_range("1/1/1999", "1/1/2012", freq="M")
         s1 = pd.Series(np.random.randn(len(rng1)), rng1)
 
-        rng2 = pd.period_range("1/1/1980", "12/1/2001", freq="M")
+        rng2 = period_range("1/1/1980", "12/1/2001", freq="M")
         s2 = pd.Series(np.random.randn(len(rng2)), rng2)
         df = pd.DataFrame({"s1": s1, "s2": s2})
 
-        exp = pd.period_range("1/1/1980", "1/1/2012", freq="M")
+        exp = period_range("1/1/1980", "1/1/2012", freq="M")
         tm.assert_index_equal(df.index, exp)
 
     @pytest.mark.parametrize("sort", [None, False])
@@ -213,11 +215,11 @@ def test_intersection(self, sort):
         # raise if different frequencies
         index = period_range("1/1/2000", "1/20/2000", freq="D")
         index2 = period_range("1/1/2000", "1/20/2000", freq="W-WED")
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             index.intersection(index2, sort=sort)
 
         index3 = period_range("1/1/2000", "1/20/2000", freq="2D")
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             index.intersection(index3, sort=sort)
 
     @pytest.mark.parametrize("sort", [None, False])
@@ -293,16 +295,16 @@ def test_intersection_cases(self, sort):
     def test_difference(self, sort):
         # diff
         period_rng = ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"]
-        rng1 = pd.PeriodIndex(period_rng, freq="D")
-        other1 = pd.period_range("1/6/2000", freq="D", periods=5)
+        rng1 = PeriodIndex(period_rng, freq="D")
+        other1 = period_range("1/6/2000", freq="D", periods=5)
         expected1 = rng1
 
-        rng2 = pd.PeriodIndex(period_rng, freq="D")
-        other2 = pd.period_range("1/4/2000", freq="D", periods=5)
-        expected2 = pd.PeriodIndex(["1/3/2000", "1/2/2000", "1/1/2000"], freq="D")
+        rng2 = PeriodIndex(period_rng, freq="D")
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = PeriodIndex(["1/3/2000", "1/2/2000", "1/1/2000"], freq="D")
 
-        rng3 = pd.PeriodIndex(period_rng, freq="D")
-        other3 = pd.PeriodIndex([], freq="D")
+        rng3 = PeriodIndex(period_rng, freq="D")
+        other3 = PeriodIndex([], freq="D")
         expected3 = rng3
 
         period_rng = [
@@ -312,15 +314,15 @@ def test_difference(self, sort):
             "2000-01-01 11:00",
             "2000-01-01 13:00",
         ]
-        rng4 = pd.PeriodIndex(period_rng, freq="H")
-        other4 = pd.period_range("2000-01-02 09:00", freq="H", periods=5)
+        rng4 = PeriodIndex(period_rng, freq="H")
+        other4 = period_range("2000-01-02 09:00", freq="H", periods=5)
         expected4 = rng4
 
-        rng5 = pd.PeriodIndex(
+        rng5 = PeriodIndex(
             ["2000-01-01 09:03", "2000-01-01 09:01", "2000-01-01 09:05"], freq="T"
         )
-        other5 = pd.PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="T")
-        expected5 = pd.PeriodIndex(["2000-01-01 09:03"], freq="T")
+        other5 = PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="T")
+        expected5 = PeriodIndex(["2000-01-01 09:03"], freq="T")
 
         period_rng = [
             "2000-02-01",
@@ -331,14 +333,14 @@ def test_difference(self, sort):
             "2000-03-01",
             "2000-04-01",
         ]
-        rng6 = pd.PeriodIndex(period_rng, freq="M")
-        other6 = pd.period_range("2000-04-01", freq="M", periods=7)
-        expected6 = pd.PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
+        rng6 = PeriodIndex(period_rng, freq="M")
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
 
         period_rng = ["2003", "2007", "2006", "2005", "2004"]
-        rng7 = pd.PeriodIndex(period_rng, freq="A")
-        other7 = pd.period_range("1998-01-01", freq="A", periods=8)
-        expected7 = pd.PeriodIndex(["2007", "2006"], freq="A")
+        rng7 = PeriodIndex(period_rng, freq="A")
+        other7 = period_range("1998-01-01", freq="A", periods=8)
+        expected7 = PeriodIndex(["2007", "2006"], freq="A")
 
         for rng, other, expected in [
             (rng1, other1, expected1),
@@ -353,3 +355,22 @@ def test_difference(self, sort):
             if sort is None:
                 expected = expected.sort_values()
             tm.assert_index_equal(result_difference, expected)
+
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_difference_freq(self, sort):
+        # GH14323: difference of Period MUST preserve frequency
+        # but the ability to union results must be preserved
+
+        index = period_range("20160920", "20160925", freq="D")
+
+        other = period_range("20160921", "20160924", freq="D")
+        expected = PeriodIndex(["20160920", "20160925"], freq="D")
+        idx_diff = index.difference(other, sort)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+        other = period_range("20160922", "20160925", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = PeriodIndex(["20160920", "20160921"], freq="D")
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_shift.py
similarity index 90%
rename from pandas/tests/indexes/period/test_arithmetic.py
rename to pandas/tests/indexes/period/test_shift.py
index 80e4b1fe1e430..b4c9810f3a554 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_shift.py
@@ -1,12 +1,11 @@
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import PeriodIndex, period_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
-class TestPeriodIndexArithmetic:
+class TestPeriodIndexShift:
     # ---------------------------------------------------------------
     # PeriodIndex.shift is used by __add__ and __sub__
 
@@ -62,7 +61,7 @@ def test_shift(self):
 
     def test_shift_corner_cases(self):
         # GH#9903
-        idx = pd.PeriodIndex([], name="xxx", freq="H")
+        idx = PeriodIndex([], name="xxx", freq="H")
 
         with pytest.raises(TypeError):
             # period shift doesn't accept freq
@@ -71,19 +70,19 @@ def test_shift_corner_cases(self):
         tm.assert_index_equal(idx.shift(0), idx)
         tm.assert_index_equal(idx.shift(3), idx)
 
-        idx = pd.PeriodIndex(
+        idx = PeriodIndex(
             ["2011-01-01 10:00", "2011-01-01 11:00", "2011-01-01 12:00"],
             name="xxx",
             freq="H",
         )
         tm.assert_index_equal(idx.shift(0), idx)
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 13:00", "2011-01-01 14:00", "2011-01-01 15:00"],
             name="xxx",
             freq="H",
         )
         tm.assert_index_equal(idx.shift(3), exp)
-        exp = pd.PeriodIndex(
+        exp = PeriodIndex(
             ["2011-01-01 07:00", "2011-01-01 08:00", "2011-01-01 09:00"],
             name="xxx",
             freq="H",
@@ -104,7 +103,7 @@ def test_shift_nat(self):
     def test_shift_gh8083(self):
         # test shift for PeriodIndex
         # GH#8083
-        drange = pd.period_range("20130101", periods=5, freq="D")
+        drange = period_range("20130101", periods=5, freq="D")
         result = drange.shift(1)
         expected = PeriodIndex(
             ["2013-01-02", "2013-01-03", "2013-01-04", "2013-01-05", "2013-01-06"],
@@ -117,5 +116,3 @@ def test_shift_periods(self):
         idx = period_range(freq="A", start="1/1/2001", end="12/1/2009")
         tm.assert_index_equal(idx.shift(periods=0), idx)
         tm.assert_index_equal(idx.shift(0), idx)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=True):
-            tm.assert_index_equal(idx.shift(n=0), idx)
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index a9c0ecd1a3041..dae220006ebe0 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -1,24 +1,21 @@
-from datetime import datetime, timedelta
+from datetime import datetime
 
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs.ccalendar import MONTHS
+from pandas._libs.tslibs import IncompatibleFrequency
 
-import pandas as pd
 from pandas import (
     DatetimeIndex,
+    NaT,
     Period,
     PeriodIndex,
-    Series,
     Timedelta,
     Timestamp,
     date_range,
     period_range,
-    to_datetime,
 )
-import pandas.core.indexes.period as period
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestPeriodRepresentation:
@@ -42,202 +39,62 @@ def test_monthly(self):
     def test_freq(self, freq):
         self._check_freq(freq, "1970-01-01")
 
-    def test_negone_ordinals(self):
-        freqs = ["A", "M", "Q", "D", "H", "T", "S"]
 
-        period = Period(ordinal=-1, freq="D")
-        for freq in freqs:
-            repr(period.asfreq(freq))
-
-        for freq in freqs:
-            period = Period(ordinal=-1, freq=freq)
-            repr(period)
-            assert period.year == 1969
-
-        period = Period(ordinal=-1, freq="B")
-        repr(period)
-        period = Period(ordinal=-1, freq="W")
-        repr(period)
-
-
-class TestPeriodIndex:
-    def test_to_timestamp(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
-        series = Series(1, index=index, name="foo")
-
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
-        result = series.to_timestamp(how="end")
-        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-        assert result.name == "foo"
-
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
-        result = series.to_timestamp(how="start")
-        tm.assert_index_equal(result.index, exp_index)
-
-        def _get_with_delta(delta, freq="A-DEC"):
-            return date_range(
-                to_datetime("1/1/2001") + delta,
-                to_datetime("12/31/2009") + delta,
-                freq=freq,
-            )
-
-        delta = timedelta(hours=23)
-        result = series.to_timestamp("H", "end")
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        delta = timedelta(hours=23, minutes=59)
-        result = series.to_timestamp("T", "end")
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        result = series.to_timestamp("S", "end")
-        delta = timedelta(hours=23, minutes=59, seconds=59)
-        exp_index = _get_with_delta(delta)
-        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-
-        index = period_range(freq="H", start="1/1/2001", end="1/2/2001")
-        series = Series(1, index=index, name="foo")
-
-        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="H")
-        result = series.to_timestamp(how="end")
-        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
-        tm.assert_index_equal(result.index, exp_index)
-        assert result.name == "foo"
-
-    def test_to_timestamp_freq(self):
-        idx = pd.period_range("2017", periods=12, freq="A-DEC")
-        result = idx.to_timestamp()
-        expected = pd.date_range("2017", periods=12, freq="AS-JAN")
-        tm.assert_index_equal(result, expected)
-
-    def test_to_timestamp_repr_is_code(self):
-        zs = [
-            Timestamp("99-04-17 00:00:00", tz="UTC"),
-            Timestamp("2001-04-17 00:00:00", tz="UTC"),
-            Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"),
-            Timestamp("2001-04-17 00:00:00", tz=None),
-        ]
-        for z in zs:
-            assert eval(repr(z)) == z
-
-    def test_to_timestamp_to_period_astype(self):
-        idx = DatetimeIndex([pd.NaT, "2011-01-01", "2011-02-01"], name="idx")
-
-        res = idx.astype("period[M]")
-        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
-        tm.assert_index_equal(res, exp)
+class TestSearchsorted:
+    @pytest.mark.parametrize("freq", ["D", "2D"])
+    def test_searchsorted(self, freq):
+        pidx = PeriodIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+            freq=freq,
+        )
 
-        res = idx.astype("period[3M]")
-        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
-        tm.assert_index_equal(res, exp)
+        p1 = Period("2014-01-01", freq=freq)
+        assert pidx.searchsorted(p1) == 0
 
-    def test_dti_to_period(self):
-        dti = pd.date_range(start="1/1/2005", end="12/1/2005", freq="M")
-        pi1 = dti.to_period()
-        pi2 = dti.to_period(freq="D")
-        pi3 = dti.to_period(freq="3D")
+        p2 = Period("2014-01-04", freq=freq)
+        assert pidx.searchsorted(p2) == 3
 
-        assert pi1[0] == Period("Jan 2005", freq="M")
-        assert pi2[0] == Period("1/31/2005", freq="D")
-        assert pi3[0] == Period("1/31/2005", freq="3D")
+        assert pidx.searchsorted(NaT) == 0
 
-        assert pi1[-1] == Period("Nov 2005", freq="M")
-        assert pi2[-1] == Period("11/30/2005", freq="D")
-        assert pi3[-1], Period("11/30/2005", freq="3D")
+        msg = "Input has different freq=H from PeriodArray"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            pidx.searchsorted(Period("2014-01-01", freq="H"))
 
-        tm.assert_index_equal(pi1, period_range("1/1/2005", "11/1/2005", freq="M"))
-        tm.assert_index_equal(
-            pi2, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("D")
-        )
-        tm.assert_index_equal(
-            pi3, period_range("1/1/2005", "11/1/2005", freq="M").asfreq("3D")
-        )
+        msg = "Input has different freq=5D from PeriodArray"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            pidx.searchsorted(Period("2014-01-01", freq="5D"))
 
-    @pytest.mark.parametrize("month", MONTHS)
-    def test_to_period_quarterly(self, month):
-        # make sure we can make the round trip
-        freq = "Q-{month}".format(month=month)
-        rng = period_range("1989Q3", "1991Q3", freq=freq)
-        stamps = rng.to_timestamp()
-        result = stamps.to_period(freq)
-        tm.assert_index_equal(rng, result)
-
-    @pytest.mark.parametrize("off", ["BQ", "QS", "BQS"])
-    def test_to_period_quarterlyish(self, off):
-        rng = date_range("01-Jan-2012", periods=8, freq=off)
-        prng = rng.to_period()
-        assert prng.freq == "Q-DEC"
-
-    @pytest.mark.parametrize("off", ["BA", "AS", "BAS"])
-    def test_to_period_annualish(self, off):
-        rng = date_range("01-Jan-2012", periods=8, freq=off)
-        prng = rng.to_period()
-        assert prng.freq == "A-DEC"
-
-    def test_to_period_monthish(self):
-        offsets = ["MS", "BM"]
-        for off in offsets:
-            rng = date_range("01-Jan-2012", periods=8, freq=off)
-            prng = rng.to_period()
-            assert prng.freq == "M"
-
-        rng = date_range("01-Jan-2012", periods=8, freq="M")
-        prng = rng.to_period()
-        assert prng.freq == "M"
-
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
-        with pytest.raises(ValueError, match=msg):
-            date_range("01-Jan-2012", periods=8, freq="EOM")
-
-    def test_period_dt64_round_trip(self):
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
-        pi = dti.to_period()
-        tm.assert_index_equal(pi.to_timestamp(), dti)
-
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
-        pi = dti.to_period(freq="H")
-        tm.assert_index_equal(pi.to_timestamp(), dti)
-
-    def test_combine_first(self):
-        # GH#3367
-        didx = pd.date_range(start="1950-01-31", end="1950-07-31", freq="M")
-        pidx = pd.period_range(
-            start=pd.Period("1950-1"), end=pd.Period("1950-7"), freq="M"
+    def test_searchsorted_invalid(self):
+        pidx = PeriodIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+            freq="D",
         )
-        # check to be consistent with DatetimeIndex
-        for idx in [didx, pidx]:
-            a = pd.Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
-            b = pd.Series([9, 9, 9, 9, 9, 9, 9], index=idx)
 
-            result = a.combine_first(b)
-            expected = pd.Series([1, 9, 9, 4, 5, 9, 7], index=idx, dtype=np.float64)
-            tm.assert_series_equal(result, expected)
+        other = np.array([0, 1], dtype=np.int64)
 
-    @pytest.mark.parametrize("freq", ["D", "2D"])
-    def test_searchsorted(self, freq):
-        pidx = pd.PeriodIndex(
-            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
-            freq=freq,
+        msg = "|".join(
+            [
+                "searchsorted requires compatible dtype or scalar",
+                "Unexpected type for 'value'",
+            ]
         )
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(other)
 
-        p1 = pd.Period("2014-01-01", freq=freq)
-        assert pidx.searchsorted(p1) == 0
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(other.astype("timedelta64[ns]"))
 
-        p2 = pd.Period("2014-01-04", freq=freq)
-        assert pidx.searchsorted(p2) == 3
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.timedelta64(4))
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.timedelta64("NaT", "ms"))
 
-        msg = "Input has different freq=H from PeriodIndex"
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
-            pidx.searchsorted(pd.Period("2014-01-01", freq="H"))
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.datetime64(4, "ns"))
 
-        msg = "Input has different freq=5D from PeriodIndex"
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
-            pidx.searchsorted(pd.Period("2014-01-01", freq="5D"))
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.datetime64("NaT", "ns"))
 
 
 class TestPeriodIndexConversion:
@@ -250,13 +107,21 @@ def test_tolist(self):
         recon = PeriodIndex(rs)
         tm.assert_index_equal(index, recon)
 
+
+class TestToTimestamp:
+    def test_to_timestamp_freq(self):
+        idx = period_range("2017", periods=12, freq="A-DEC")
+        result = idx.to_timestamp()
+        expected = date_range("2017", periods=12, freq="AS-JAN")
+        tm.assert_index_equal(result, expected)
+
     def test_to_timestamp_pi_nat(self):
         # GH#7228
         index = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
 
         result = index.to_timestamp("D")
         expected = DatetimeIndex(
-            [pd.NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)], name="idx"
+            [NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)], name="idx"
         )
         tm.assert_index_equal(result, expected)
         assert result.name == "idx"
@@ -322,29 +187,6 @@ def test_to_timestamp_pi_combined(self):
         expected = expected + Timedelta(1, "h") - Timedelta(1, "ns")
         tm.assert_index_equal(result, expected)
 
-    def test_period_astype_to_timestamp(self):
-        pi = pd.PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
-
-        exp = pd.DatetimeIndex(["2011-01-01", "2011-02-01", "2011-03-01"])
-        tm.assert_index_equal(pi.astype("datetime64[ns]"), exp)
-
-        exp = pd.DatetimeIndex(["2011-01-31", "2011-02-28", "2011-03-31"])
-        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
-        tm.assert_index_equal(pi.astype("datetime64[ns]", how="end"), exp)
-
-        exp = pd.DatetimeIndex(
-            ["2011-01-01", "2011-02-01", "2011-03-01"], tz="US/Eastern"
-        )
-        res = pi.astype("datetime64[ns, US/Eastern]")
-        tm.assert_index_equal(pi.astype("datetime64[ns, US/Eastern]"), exp)
-
-        exp = pd.DatetimeIndex(
-            ["2011-01-31", "2011-02-28", "2011-03-31"], tz="US/Eastern"
-        )
-        exp = exp + Timedelta(1, "D") - Timedelta(1, "ns")
-        res = pi.astype("datetime64[ns, US/Eastern]", how="end")
-        tm.assert_index_equal(res, exp)
-
     def test_to_timestamp_1703(self):
         index = period_range("1/1/2012", periods=4, freq="D")
 
diff --git a/pandas/tests/indexes/ranges/__init__.py b/pandas/tests/indexes/ranges/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/indexes/ranges/test_constructors.py b/pandas/tests/indexes/ranges/test_constructors.py
new file mode 100644
index 0000000000000..ba1de6d551d6b
--- /dev/null
+++ b/pandas/tests/indexes/ranges/test_constructors.py
@@ -0,0 +1,154 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import Index, RangeIndex, Series
+import pandas._testing as tm
+
+
+class TestRangeIndexConstructors:
+    @pytest.mark.parametrize("name", [None, "foo"])
+    @pytest.mark.parametrize(
+        "args, kwargs, start, stop, step",
+        [
+            ((5,), dict(), 0, 5, 1),
+            ((1, 5), dict(), 1, 5, 1),
+            ((1, 5, 2), dict(), 1, 5, 2),
+            ((0,), dict(), 0, 0, 1),
+            ((0, 0), dict(), 0, 0, 1),
+            (tuple(), dict(start=0), 0, 0, 1),
+            (tuple(), dict(stop=0), 0, 0, 1),
+        ],
+    )
+    def test_constructor(self, args, kwargs, start, stop, step, name):
+        result = RangeIndex(*args, name=name, **kwargs)
+        expected = Index(np.arange(start, stop, step, dtype=np.int64), name=name)
+        assert isinstance(result, RangeIndex)
+        assert result.name is name
+        assert result._range == range(start, stop, step)
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_invalid_args(self):
+        msg = "RangeIndex\\(\\.\\.\\.\\) must be called with integers"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex()
+
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex(name="Foo")
+
+        # invalid args
+        for i in [
+            Index(["a", "b"]),
+            Series(["a", "b"]),
+            np.array(["a", "b"]),
+            [],
+            "foo",
+            datetime(2000, 1, 1, 0, 0),
+            np.arange(0, 10),
+            np.array([1]),
+            [1],
+        ]:
+            with pytest.raises(TypeError):
+                RangeIndex(i)
+
+        # we don't allow on a bare Index
+        msg = (
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            r"kind, 0 was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Index(0, 1000)
+
+    def test_constructor_same(self):
+
+        # pass thru w and w/o copy
+        index = RangeIndex(1, 5, 2)
+        result = RangeIndex(index, copy=False)
+        assert result.identical(index)
+
+        result = RangeIndex(index, copy=True)
+        tm.assert_index_equal(result, index, exact=True)
+
+        result = RangeIndex(index)
+        tm.assert_index_equal(result, index, exact=True)
+
+        with pytest.raises(
+            ValueError,
+            match="Incorrect `dtype` passed: expected signed integer, received float64",
+        ):
+            RangeIndex(index, dtype="float64")
+
+    def test_constructor_range(self):
+
+        msg = "Value needs to be a scalar value, was type <class 'range'>"
+        with pytest.raises(TypeError, match=msg):
+            result = RangeIndex(range(1, 5, 2))
+
+        result = RangeIndex.from_range(range(1, 5, 2))
+        expected = RangeIndex(1, 5, 2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = RangeIndex.from_range(range(5, 6))
+        expected = RangeIndex(5, 6, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # an invalid range
+        result = RangeIndex.from_range(range(5, 1))
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = RangeIndex.from_range(range(5))
+        expected = RangeIndex(0, 5, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = Index(range(1, 5, 2))
+        expected = RangeIndex(1, 5, 2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        with pytest.raises(
+            ValueError,
+            match="Incorrect `dtype` passed: expected signed integer, received float64",
+        ):
+            Index(range(1, 5, 2), dtype="float64")
+        msg = r"^from_range\(\) got an unexpected keyword argument"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex.from_range(range(10), copy=True)
+
+    def test_constructor_name(self):
+        # GH#12288
+        orig = RangeIndex(10)
+        orig.name = "original"
+
+        copy = RangeIndex(orig)
+        copy.name = "copy"
+
+        assert orig.name == "original"
+        assert copy.name == "copy"
+
+        new = Index(copy)
+        assert new.name == "copy"
+
+        new.name = "new"
+        assert orig.name == "original"
+        assert copy.name == "copy"
+        assert new.name == "new"
+
+    def test_constructor_corner(self):
+        arr = np.array([1, 2, 3, 4], dtype=object)
+        index = RangeIndex(1, 5)
+        assert index.values.dtype == np.int64
+        tm.assert_index_equal(index, Index(arr))
+
+        # non-int raise Exception
+        with pytest.raises(TypeError):
+            RangeIndex("1", "10", "1")
+        with pytest.raises(TypeError):
+            RangeIndex(1.1, 10.2, 1.3)
+
+        # invalid passed type
+        with pytest.raises(
+            ValueError,
+            match="Incorrect `dtype` passed: expected signed integer, received float64",
+        ):
+            RangeIndex(1, 5, dtype="float64")
diff --git a/pandas/tests/indexes/test_range.py b/pandas/tests/indexes/ranges/test_range.py
similarity index 53%
rename from pandas/tests/indexes/test_range.py
rename to pandas/tests/indexes/ranges/test_range.py
index 58b98297f00f3..0e5d1d45ad6db 100644
--- a/pandas/tests/indexes/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -1,15 +1,13 @@
-from datetime import datetime
-
 import numpy as np
 import pytest
 
 from pandas.core.dtypes.common import ensure_platform_int
 
 import pandas as pd
-from pandas import Float64Index, Index, Int64Index, RangeIndex, Series
-import pandas.util.testing as tm
+from pandas import Float64Index, Index, Int64Index, RangeIndex
+import pandas._testing as tm
 
-from .test_numeric import Numeric
+from ..test_numeric import Numeric
 
 # aliases to make some tests easier to read
 RI = RangeIndex
@@ -22,15 +20,18 @@ class TestRangeIndex(Numeric):
     _holder = RangeIndex
     _compat_props = ["shape", "ndim", "size"]
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=RangeIndex(0, 20, 2, name="foo"),
-            index_dec=RangeIndex(18, -1, -2, name="bar"),
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[
+            RangeIndex(start=0, stop=20, step=2, name="foo"),
+            RangeIndex(start=18, stop=-1, step=-2, name="bar"),
+        ],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return request.param
 
     def create_index(self):
-        return RangeIndex(5)
+        return RangeIndex(start=0, stop=20, step=2)
 
     def test_can_hold_identifiers(self):
         idx = self.create_index()
@@ -38,144 +39,9 @@ def test_can_hold_identifiers(self):
         assert idx._can_hold_identifiers_and_holds_name(key) is False
 
     def test_too_many_names(self):
+        index = self.create_index()
         with pytest.raises(ValueError, match="^Length"):
-            self.index.names = ["roger", "harold"]
-
-    @pytest.mark.parametrize("name", [None, "foo"])
-    @pytest.mark.parametrize(
-        "args, kwargs, start, stop, step",
-        [
-            ((5,), dict(), 0, 5, 1),
-            ((1, 5), dict(), 1, 5, 1),
-            ((1, 5, 2), dict(), 1, 5, 2),
-            ((0,), dict(), 0, 0, 1),
-            ((0, 0), dict(), 0, 0, 1),
-            (tuple(), dict(start=0), 0, 0, 1),
-            (tuple(), dict(stop=0), 0, 0, 1),
-        ],
-    )
-    def test_constructor(self, args, kwargs, start, stop, step, name):
-        result = RangeIndex(*args, name=name, **kwargs)
-        expected = Index(np.arange(start, stop, step, dtype=np.int64), name=name)
-        assert isinstance(result, RangeIndex)
-        assert result.name is name
-        assert result._range == range(start, stop, step)
-        tm.assert_index_equal(result, expected)
-
-    def test_constructor_invalid_args(self):
-        msg = "RangeIndex\\(\\.\\.\\.\\) must be called with integers"
-        with pytest.raises(TypeError, match=msg):
-            RangeIndex()
-
-        with pytest.raises(TypeError, match=msg):
-            RangeIndex(name="Foo")
-
-        # invalid args
-        for i in [
-            Index(["a", "b"]),
-            Series(["a", "b"]),
-            np.array(["a", "b"]),
-            [],
-            "foo",
-            datetime(2000, 1, 1, 0, 0),
-            np.arange(0, 10),
-            np.array([1]),
-            [1],
-        ]:
-            with pytest.raises(TypeError):
-                RangeIndex(i)
-
-        # we don't allow on a bare Index
-        msg = (
-            r"Index\(\.\.\.\) must be called with a collection of some "
-            r"kind, 0 was passed"
-        )
-        with pytest.raises(TypeError, match=msg):
-            Index(0, 1000)
-
-    def test_constructor_same(self):
-
-        # pass thru w and w/o copy
-        index = RangeIndex(1, 5, 2)
-        result = RangeIndex(index, copy=False)
-        assert result.identical(index)
-
-        result = RangeIndex(index, copy=True)
-        tm.assert_index_equal(result, index, exact=True)
-
-        result = RangeIndex(index)
-        tm.assert_index_equal(result, index, exact=True)
-
-        with pytest.raises(TypeError):
-            RangeIndex(index, dtype="float64")
-
-    def test_constructor_range(self):
-
-        msg = "Value needs to be a scalar value, was type <class 'range'>"
-        with pytest.raises(TypeError, match=msg):
-            result = RangeIndex(range(1, 5, 2))
-
-        result = RangeIndex.from_range(range(1, 5, 2))
-        expected = RangeIndex(1, 5, 2)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        result = RangeIndex.from_range(range(5, 6))
-        expected = RangeIndex(5, 6, 1)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        # an invalid range
-        result = RangeIndex.from_range(range(5, 1))
-        expected = RangeIndex(0, 0, 1)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        result = RangeIndex.from_range(range(5))
-        expected = RangeIndex(0, 5, 1)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        result = Index(range(1, 5, 2))
-        expected = RangeIndex(1, 5, 2)
-        tm.assert_index_equal(result, expected, exact=True)
-
-        with pytest.raises(TypeError):
-            Index(range(1, 5, 2), dtype="float64")
-        msg = r"^from_range\(\) got an unexpected keyword argument"
-        with pytest.raises(TypeError, match=msg):
-            pd.RangeIndex.from_range(range(10), copy=True)
-
-    def test_constructor_name(self):
-        # GH12288
-        orig = RangeIndex(10)
-        orig.name = "original"
-
-        copy = RangeIndex(orig)
-        copy.name = "copy"
-
-        assert orig.name == "original"
-        assert copy.name == "copy"
-
-        new = Index(copy)
-        assert new.name == "copy"
-
-        new.name = "new"
-        assert orig.name == "original"
-        assert copy.name == "copy"
-        assert new.name == "new"
-
-    def test_constructor_corner(self):
-        arr = np.array([1, 2, 3, 4], dtype=object)
-        index = RangeIndex(1, 5)
-        assert index.values.dtype == np.int64
-        tm.assert_index_equal(index, Index(arr))
-
-        # non-int raise Exception
-        with pytest.raises(TypeError):
-            RangeIndex("1", "10", "1")
-        with pytest.raises(TypeError):
-            RangeIndex(1.1, 10.2, 1.3)
-
-        # invalid passed type
-        with pytest.raises(TypeError):
-            RangeIndex(1, 5, dtype="float64")
+            index.names = ["roger", "harold"]
 
     @pytest.mark.parametrize(
         "index, start, stop, step",
@@ -196,7 +62,7 @@ def test_start_stop_step_attrs(self, index, start, stop, step):
     def test_deprecated_start_stop_step_attrs(self, attr_name):
         # GH 26581
         idx = self.create_index()
-        with tm.assert_produces_warning(DeprecationWarning):
+        with tm.assert_produces_warning(FutureWarning):
             getattr(idx, attr_name)
 
     def test_copy(self):
@@ -267,7 +133,8 @@ def test_view(self):
         tm.assert_index_equal(i, i_view)
 
     def test_dtype(self):
-        assert self.index.dtype == np.int64
+        index = self.create_index()
+        assert index.dtype == np.int64
 
     def test_cached_data(self):
         # GH 26565, GH26617
@@ -292,14 +159,6 @@ def test_cached_data(self):
         91 in idx
         assert idx._cached_data is None
 
-        with tm.assert_produces_warning(FutureWarning):
-            idx.contains(90)
-        assert idx._cached_data is None
-
-        with tm.assert_produces_warning(FutureWarning):
-            idx.contains(91)
-        assert idx._cached_data is None
-
         idx.all()
         assert idx._cached_data is None
 
@@ -326,11 +185,12 @@ def test_cached_data(self):
         assert isinstance(idx._cached_data, np.ndarray)
 
     def test_is_monotonic(self):
-        assert self.index.is_monotonic is True
-        assert self.index.is_monotonic_increasing is True
-        assert self.index.is_monotonic_decreasing is False
-        assert self.index._is_strictly_monotonic_increasing is True
-        assert self.index._is_strictly_monotonic_decreasing is False
+        index = RangeIndex(0, 20, 2)
+        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is False
+        assert index._is_strictly_monotonic_increasing is True
+        assert index._is_strictly_monotonic_decreasing is False
 
         index = RangeIndex(4, 0, -1)
         assert index.is_monotonic is False
@@ -376,52 +236,71 @@ def test_logical_compat(self):
         assert idx.any() == idx.values.any()
 
     def test_identical(self):
-        i = Index(self.index.copy())
-        assert i.identical(self.index)
+        index = self.create_index()
+        i = Index(index.copy())
+        assert i.identical(index)
 
         # we don't allow object dtype for RangeIndex
-        if isinstance(self.index, RangeIndex):
+        if isinstance(index, RangeIndex):
             return
 
         same_values_different_type = Index(i, dtype=object)
         assert not i.identical(same_values_different_type)
 
-        i = self.index.copy(dtype=object)
+        i = index.copy(dtype=object)
         i = i.rename("foo")
         same_values = Index(i, dtype=object)
-        assert same_values.identical(self.index.copy(dtype=object))
+        assert same_values.identical(index.copy(dtype=object))
 
-        assert not i.identical(self.index)
+        assert not i.identical(index)
         assert Index(same_values, name="foo", dtype=object).identical(i)
 
-        assert not self.index.copy(dtype=object).identical(
-            self.index.copy(dtype="int64")
-        )
+        assert not index.copy(dtype=object).identical(index.copy(dtype="int64"))
 
     def test_get_indexer(self):
+        index = self.create_index()
         target = RangeIndex(10)
-        indexer = self.index.get_indexer(target)
+        indexer = index.get_indexer(target)
         expected = np.array([0, -1, 1, -1, 2, -1, 3, -1, 4, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
     def test_get_indexer_pad(self):
+        index = self.create_index()
         target = RangeIndex(10)
-        indexer = self.index.get_indexer(target, method="pad")
+        indexer = index.get_indexer(target, method="pad")
         expected = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
     def test_get_indexer_backfill(self):
+        index = self.create_index()
         target = RangeIndex(10)
-        indexer = self.index.get_indexer(target, method="backfill")
+        indexer = index.get_indexer(target, method="backfill")
         expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
+    def test_get_indexer_limit(self):
+        # GH 28631
+        idx = RangeIndex(4)
+        target = RangeIndex(6)
+        result = idx.get_indexer(target, method="pad", limit=1)
+        expected = np.array([0, 1, 2, 3, 3, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("stop", [0, -1, -2])
+    def test_get_indexer_decreasing(self, stop):
+        # GH 28678
+        index = RangeIndex(7, stop, -3)
+        result = index.get_indexer(range(9))
+        expected = np.array([-1, 2, -1, -1, 1, -1, -1, 0, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_join_outer(self):
         # join with Int64Index
+        index = self.create_index()
         other = Int64Index(np.arange(25, 14, -1))
 
-        res, lidx, ridx = self.index.join(other, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other, how="outer")
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         eres = Int64Index(
@@ -445,8 +324,8 @@ def test_join_outer(self):
         # join with RangeIndex
         other = RangeIndex(25, 14, -1)
 
-        res, lidx, ridx = self.index.join(other, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other, how="outer")
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         assert isinstance(res, Int64Index)
@@ -457,9 +336,10 @@ def test_join_outer(self):
 
     def test_join_inner(self):
         # Join with non-RangeIndex
+        index = self.create_index()
         other = Int64Index(np.arange(25, 14, -1))
 
-        res, lidx, ridx = self.index.join(other, how="inner", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
 
         # no guarantee of sortedness, so sort for comparison purposes
         ind = res.argsort()
@@ -479,7 +359,7 @@ def test_join_inner(self):
         # Join two RangeIndex
         other = RangeIndex(25, 14, -1)
 
-        res, lidx, ridx = self.index.join(other, how="inner", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
 
         assert isinstance(res, RangeIndex)
         tm.assert_index_equal(res, eres)
@@ -488,10 +368,11 @@ def test_join_inner(self):
 
     def test_join_left(self):
         # Join with Int64Index
+        index = self.create_index()
         other = Int64Index(np.arange(25, 14, -1))
 
-        res, lidx, ridx = self.index.join(other, how="left", return_indexers=True)
-        eres = self.index
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
+        eres = index
         eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 9, 7], dtype=np.intp)
 
         assert isinstance(res, RangeIndex)
@@ -502,7 +383,7 @@ def test_join_left(self):
         # Join withRangeIndex
         other = Int64Index(np.arange(25, 14, -1))
 
-        res, lidx, ridx = self.index.join(other, how="left", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
 
         assert isinstance(res, RangeIndex)
         tm.assert_index_equal(res, eres)
@@ -511,9 +392,10 @@ def test_join_left(self):
 
     def test_join_right(self):
         # Join with Int64Index
+        index = self.create_index()
         other = Int64Index(np.arange(25, 14, -1))
 
-        res, lidx, ridx = self.index.join(other, how="right", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
         eres = other
         elidx = np.array([-1, -1, -1, -1, -1, -1, -1, 9, -1, 8, -1], dtype=np.intp)
 
@@ -525,7 +407,7 @@ def test_join_right(self):
         # Join withRangeIndex
         other = RangeIndex(25, 14, -1)
 
-        res, lidx, ridx = self.index.join(other, how="right", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
         eres = other
 
         assert isinstance(other, RangeIndex)
@@ -534,36 +416,38 @@ def test_join_right(self):
         assert ridx is None
 
     def test_join_non_int_index(self):
+        index = self.create_index()
         other = Index([3, 6, 7, 8, 10], dtype=object)
 
-        outer = self.index.join(other, how="outer")
-        outer2 = other.join(self.index, how="outer")
+        outer = index.join(other, how="outer")
+        outer2 = other.join(index, how="outer")
         expected = Index([0, 2, 3, 4, 6, 7, 8, 10, 12, 14, 16, 18])
         tm.assert_index_equal(outer, outer2)
         tm.assert_index_equal(outer, expected)
 
-        inner = self.index.join(other, how="inner")
-        inner2 = other.join(self.index, how="inner")
+        inner = index.join(other, how="inner")
+        inner2 = other.join(index, how="inner")
         expected = Index([6, 8, 10])
         tm.assert_index_equal(inner, inner2)
         tm.assert_index_equal(inner, expected)
 
-        left = self.index.join(other, how="left")
-        tm.assert_index_equal(left, self.index.astype(object))
+        left = index.join(other, how="left")
+        tm.assert_index_equal(left, index.astype(object))
 
-        left2 = other.join(self.index, how="left")
+        left2 = other.join(index, how="left")
         tm.assert_index_equal(left2, other)
 
-        right = self.index.join(other, how="right")
+        right = index.join(other, how="right")
         tm.assert_index_equal(right, other)
 
-        right2 = other.join(self.index, how="right")
-        tm.assert_index_equal(right2, self.index.astype(object))
+        right2 = other.join(index, how="right")
+        tm.assert_index_equal(right2, index.astype(object))
 
     def test_join_non_unique(self):
+        index = self.create_index()
         other = Index([4, 4, 3, 3])
 
-        res, lidx, ridx = self.index.join(other, return_indexers=True)
+        res, lidx, ridx = index.join(other, return_indexers=True)
 
         eres = Int64Index([0, 2, 4, 4, 6, 8, 10, 12, 14, 16, 18])
         elidx = np.array([0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.intp)
@@ -573,182 +457,10 @@ def test_join_non_unique(self):
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
 
-    def test_join_self(self):
-        kinds = "outer", "inner", "left", "right"
-        for kind in kinds:
-            joined = self.index.join(self.index, how=kind)
-            assert self.index is joined
-
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_intersection(self, sort):
-        # intersect with Int64Index
-        other = Index(np.arange(1, 6))
-        result = self.index.intersection(other, sort=sort)
-        expected = Index(np.sort(np.intersect1d(self.index.values, other.values)))
-        tm.assert_index_equal(result, expected)
-
-        result = other.intersection(self.index, sort=sort)
-        expected = Index(
-            np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))
-        )
-        tm.assert_index_equal(result, expected)
-
-        # intersect with increasing RangeIndex
-        other = RangeIndex(1, 6)
-        result = self.index.intersection(other, sort=sort)
-        expected = Index(np.sort(np.intersect1d(self.index.values, other.values)))
-        tm.assert_index_equal(result, expected)
-
-        # intersect with decreasing RangeIndex
-        other = RangeIndex(5, 0, -1)
-        result = self.index.intersection(other, sort=sort)
-        expected = Index(np.sort(np.intersect1d(self.index.values, other.values)))
-        tm.assert_index_equal(result, expected)
-
-        # reversed (GH 17296)
-        result = other.intersection(self.index, sort=sort)
-        tm.assert_index_equal(result, expected)
-
-        # GH 17296: intersect two decreasing RangeIndexes
-        first = RangeIndex(10, -2, -2)
-        other = RangeIndex(5, -4, -1)
-        expected = first.astype(int).intersection(other.astype(int), sort=sort)
-        result = first.intersection(other, sort=sort).astype(int)
-        tm.assert_index_equal(result, expected)
-
-        # reversed
-        result = other.intersection(first, sort=sort).astype(int)
-        tm.assert_index_equal(result, expected)
-
-        index = RangeIndex(5)
-
-        # intersect of non-overlapping indices
-        other = RangeIndex(5, 10, 1)
-        result = index.intersection(other, sort=sort)
-        expected = RangeIndex(0, 0, 1)
-        tm.assert_index_equal(result, expected)
-
-        other = RangeIndex(-1, -5, -1)
-        result = index.intersection(other, sort=sort)
-        expected = RangeIndex(0, 0, 1)
-        tm.assert_index_equal(result, expected)
-
-        # intersection of empty indices
-        other = RangeIndex(0, 0, 1)
-        result = index.intersection(other, sort=sort)
-        expected = RangeIndex(0, 0, 1)
-        tm.assert_index_equal(result, expected)
-
-        result = other.intersection(index, sort=sort)
-        tm.assert_index_equal(result, expected)
-
-        # intersection of non-overlapping values based on start value and gcd
-        index = RangeIndex(1, 10, 2)
-        other = RangeIndex(0, 10, 4)
-        result = index.intersection(other, sort=sort)
-        expected = RangeIndex(0, 0, 1)
-        tm.assert_index_equal(result, expected)
-
-    @pytest.mark.parametrize("sort", [False, None])
-    def test_union_noncomparable(self, sort):
-        from datetime import datetime, timedelta
-
-        # corner case, non-Int64Index
-        now = datetime.now()
-        other = Index([now + timedelta(i) for i in range(4)], dtype=object)
-        result = self.index.union(other, sort=sort)
-        expected = Index(np.concatenate((self.index, other)))
-        tm.assert_index_equal(result, expected)
-
-        result = other.union(self.index, sort=sort)
-        expected = Index(np.concatenate((other, self.index)))
-        tm.assert_index_equal(result, expected)
-
-    @pytest.fixture(
-        params=[
-            (RI(0, 10, 1), RI(0, 10, 1), RI(0, 10, 1), RI(0, 10, 1)),
-            (RI(0, 10, 1), RI(5, 20, 1), RI(0, 20, 1), I64(range(20))),
-            (RI(0, 10, 1), RI(10, 20, 1), RI(0, 20, 1), I64(range(20))),
-            (RI(0, -10, -1), RI(0, -10, -1), RI(0, -10, -1), RI(0, -10, -1)),
-            (RI(0, -10, -1), RI(-10, -20, -1), RI(-19, 1, 1), I64(range(0, -20, -1))),
-            (
-                RI(0, 10, 2),
-                RI(1, 10, 2),
-                RI(0, 10, 1),
-                I64(list(range(0, 10, 2)) + list(range(1, 10, 2))),
-            ),
-            (
-                RI(0, 11, 2),
-                RI(1, 12, 2),
-                RI(0, 12, 1),
-                I64(list(range(0, 11, 2)) + list(range(1, 12, 2))),
-            ),
-            (
-                RI(0, 21, 4),
-                RI(-2, 24, 4),
-                RI(-2, 24, 2),
-                I64(list(range(0, 21, 4)) + list(range(-2, 24, 4))),
-            ),
-            (
-                RI(0, -20, -2),
-                RI(-1, -21, -2),
-                RI(-19, 1, 1),
-                I64(list(range(0, -20, -2)) + list(range(-1, -21, -2))),
-            ),
-            (RI(0, 100, 5), RI(0, 100, 20), RI(0, 100, 5), I64(range(0, 100, 5))),
-            (
-                RI(0, -100, -5),
-                RI(5, -100, -20),
-                RI(-95, 10, 5),
-                I64(list(range(0, -100, -5)) + [5]),
-            ),
-            (
-                RI(0, -11, -1),
-                RI(1, -12, -4),
-                RI(-11, 2, 1),
-                I64(list(range(0, -11, -1)) + [1, -11]),
-            ),
-            (RI(0), RI(0), RI(0), RI(0)),
-            (RI(0, -10, -2), RI(0), RI(0, -10, -2), RI(0, -10, -2)),
-            (RI(0, 100, 2), RI(100, 150, 200), RI(0, 102, 2), I64(range(0, 102, 2))),
-            (
-                RI(0, -100, -2),
-                RI(-100, 50, 102),
-                RI(-100, 4, 2),
-                I64(list(range(0, -100, -2)) + [-100, 2]),
-            ),
-            (
-                RI(0, -100, -1),
-                RI(0, -50, -3),
-                RI(-99, 1, 1),
-                I64(list(range(0, -100, -1))),
-            ),
-            (RI(0, 1, 1), RI(5, 6, 10), RI(0, 6, 5), I64([0, 5])),
-            (RI(0, 10, 5), RI(-5, -6, -20), RI(-5, 10, 5), I64([0, 5, -5])),
-            (RI(0, 3, 1), RI(4, 5, 1), I64([0, 1, 2, 4]), I64([0, 1, 2, 4])),
-            (RI(0, 10, 1), I64([]), RI(0, 10, 1), RI(0, 10, 1)),
-            (RI(0), I64([1, 5, 6]), I64([1, 5, 6]), I64([1, 5, 6])),
-        ]
-    )
-    def unions(self, request):
-        """Inputs and expected outputs for RangeIndex.union tests"""
-
-        return request.param
-
-    def test_union_sorted(self, unions):
-
-        idx1, idx2, expected_sorted, expected_notsorted = unions
-
-        res1 = idx1.union(idx2, sort=None)
-        tm.assert_index_equal(res1, expected_sorted, exact=True)
-
-        res1 = idx1.union(idx2, sort=False)
-        tm.assert_index_equal(res1, expected_notsorted, exact=True)
-
-        res2 = idx2.union(idx1, sort=None)
-        res3 = idx1._int64index.union(idx2, sort=None)
-        tm.assert_index_equal(res2, expected_sorted, exact=True)
-        tm.assert_index_equal(res3, expected_sorted)
+    def test_join_self(self, join_type):
+        index = self.create_index()
+        joined = index.join(index, how=join_type)
+        assert index is joined
 
     def test_nbytes(self):
 
@@ -769,11 +481,13 @@ def test_cant_or_shouldnt_cast(self):
         with pytest.raises(TypeError):
             RangeIndex("0", "1", "2")
 
-    def test_view_Index(self):
-        self.index.view(Index)
+    def test_view_index(self):
+        index = self.create_index()
+        index.view(Index)
 
     def test_prevent_casting(self):
-        result = self.index.astype("O")
+        index = self.create_index()
+        result = index.astype("O")
         assert result.dtype == np.object_
 
     def test_take_preserve_name(self):
@@ -812,7 +526,8 @@ def test_print_unicode_columns(self):
         repr(df.columns)  # should not raise UnicodeDecodeError
 
     def test_repr_roundtrip(self):
-        tm.assert_index_equal(eval(repr(self.index)), self.index)
+        index = self.create_index()
+        tm.assert_index_equal(eval(repr(index)), index)
 
     def test_slice_keep_name(self):
         idx = RangeIndex(1, 2, name="asdf")
@@ -843,20 +558,17 @@ def test_explicit_conversions(self):
         result = a - fidx
         tm.assert_index_equal(result, expected)
 
-    def test_has_duplicates(self):
-        for ind in self.indices:
-            if not len(ind):
-                continue
-            idx = self.indices[ind]
-            assert idx.is_unique
-            assert not idx.has_duplicates
+    def test_has_duplicates(self, indices):
+        assert indices.is_unique
+        assert not indices.has_duplicates
 
     def test_extended_gcd(self):
-        result = self.index._extended_gcd(6, 10)
+        index = self.create_index()
+        result = index._extended_gcd(6, 10)
         assert result[0] == result[1] * 6 + result[2] * 10
         assert 2 == result[0]
 
-        result = self.index._extended_gcd(10, 6)
+        result = index._extended_gcd(10, 6)
         assert 2 == result[1] * 10 + result[2] * 6
         assert 2 == result[0]
 
@@ -901,80 +613,71 @@ def test_pickle_compat_construction(self):
         pass
 
     def test_slice_specialised(self):
+        index = self.create_index()
+        index.name = "foo"
 
         # scalar indexing
-        res = self.index[1]
+        res = index[1]
         expected = 2
         assert res == expected
 
-        res = self.index[-1]
+        res = index[-1]
         expected = 18
         assert res == expected
 
         # slicing
         # slice value completion
-        index = self.index[:]
-        expected = self.index
-        tm.assert_index_equal(index, expected)
+        index_slice = index[:]
+        expected = index
+        tm.assert_index_equal(index_slice, expected)
 
         # positive slice values
-        index = self.index[7:10:2]
+        index_slice = index[7:10:2]
         expected = Index(np.array([14, 18]), name="foo")
-        tm.assert_index_equal(index, expected)
+        tm.assert_index_equal(index_slice, expected)
 
         # negative slice values
-        index = self.index[-1:-5:-2]
+        index_slice = index[-1:-5:-2]
         expected = Index(np.array([18, 14]), name="foo")
-        tm.assert_index_equal(index, expected)
+        tm.assert_index_equal(index_slice, expected)
 
         # stop overshoot
-        index = self.index[2:100:4]
+        index_slice = index[2:100:4]
         expected = Index(np.array([4, 12]), name="foo")
-        tm.assert_index_equal(index, expected)
+        tm.assert_index_equal(index_slice, expected)
 
         # reverse
-        index = self.index[::-1]
-        expected = Index(self.index.values[::-1], name="foo")
-        tm.assert_index_equal(index, expected)
+        index_slice = index[::-1]
+        expected = Index(index.values[::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected)
 
-        index = self.index[-8::-1]
+        index_slice = index[-8::-1]
         expected = Index(np.array([4, 2, 0]), name="foo")
-        tm.assert_index_equal(index, expected)
+        tm.assert_index_equal(index_slice, expected)
 
-        index = self.index[-40::-1]
+        index_slice = index[-40::-1]
         expected = Index(np.array([], dtype=np.int64), name="foo")
-        tm.assert_index_equal(index, expected)
+        tm.assert_index_equal(index_slice, expected)
 
-        index = self.index[40::-1]
-        expected = Index(self.index.values[40::-1], name="foo")
-        tm.assert_index_equal(index, expected)
+        index_slice = index[40::-1]
+        expected = Index(index.values[40::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected)
 
-        index = self.index[10::-1]
-        expected = Index(self.index.values[::-1], name="foo")
-        tm.assert_index_equal(index, expected)
+        index_slice = index[10::-1]
+        expected = Index(index.values[::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected)
 
-    def test_len_specialised(self):
+    @pytest.mark.parametrize("step", set(range(-5, 6)) - {0})
+    def test_len_specialised(self, step):
+        # make sure that our len is the same as np.arange calc
+        start, stop = (0, 5) if step > 0 else (5, 0)
 
-        # make sure that our len is the same as
-        # np.arange calc
+        arr = np.arange(start, stop, step)
+        index = RangeIndex(start, stop, step)
+        assert len(index) == len(arr)
 
-        for step in np.arange(1, 6, 1):
-
-            arr = np.arange(0, 5, step)
-            i = RangeIndex(0, 5, step)
-            assert len(i) == len(arr)
-
-            i = RangeIndex(5, 0, step)
-            assert len(i) == 0
-
-        for step in np.arange(-6, -1, 1):
-
-            arr = np.arange(5, 0, step)
-            i = RangeIndex(5, 0, step)
-            assert len(i) == len(arr)
-
-            i = RangeIndex(0, 5, step)
-            assert len(i) == 0
+        index = RangeIndex(stop, start, step)
+        assert len(index) == 0
 
     @pytest.fixture(
         params=[
@@ -1032,8 +735,9 @@ def test_engineless_lookup(self):
 
         assert "_engine" not in idx._cache
 
-        # The engine is still required for lookup of a different dtype scalar:
+        # Different types of scalars can be excluded immediately, no need to
+        #  use the _engine
         with pytest.raises(KeyError, match="'a'"):
-            assert idx.get_loc("a") == -1
+            idx.get_loc("a")
 
-        assert "_engine" in idx._cache
+        assert "_engine" not in idx._cache
diff --git a/pandas/tests/indexes/ranges/test_setops.py b/pandas/tests/indexes/ranges/test_setops.py
new file mode 100644
index 0000000000000..5bedc4089feba
--- /dev/null
+++ b/pandas/tests/indexes/ranges/test_setops.py
@@ -0,0 +1,244 @@
+from datetime import datetime, timedelta
+
+import numpy as np
+import pytest
+
+from pandas import Index, Int64Index, RangeIndex
+import pandas._testing as tm
+
+
+class TestRangeIndexSetOps:
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_intersection(self, sort):
+        # intersect with Int64Index
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(1, 6))
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index, sort=sort)
+        expected = Index(
+            np.sort(np.asarray(np.intersect1d(index.values, other.values)))
+        )
+        tm.assert_index_equal(result, expected)
+
+        # intersect with increasing RangeIndex
+        other = RangeIndex(1, 6)
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        # intersect with decreasing RangeIndex
+        other = RangeIndex(5, 0, -1)
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        # reversed (GH 17296)
+        result = other.intersection(index, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        # GH 17296: intersect two decreasing RangeIndexes
+        first = RangeIndex(10, -2, -2)
+        other = RangeIndex(5, -4, -1)
+        expected = first.astype(int).intersection(other.astype(int), sort=sort)
+        result = first.intersection(other, sort=sort).astype(int)
+        tm.assert_index_equal(result, expected)
+
+        # reversed
+        result = other.intersection(first, sort=sort).astype(int)
+        tm.assert_index_equal(result, expected)
+
+        index = RangeIndex(5)
+
+        # intersect of non-overlapping indices
+        other = RangeIndex(5, 10, 1)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+        other = RangeIndex(-1, -5, -1)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+        # intersection of empty indices
+        other = RangeIndex(0, 0, 1)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        # intersection of non-overlapping values based on start value and gcd
+        index = RangeIndex(1, 10, 2)
+        other = RangeIndex(0, 10, 4)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("sort", [False, None])
+    def test_union_noncomparable(self, sort):
+        # corner case, non-Int64Index
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index([datetime.now() + timedelta(i) for i in range(4)], dtype=object)
+        result = index.union(other, sort=sort)
+        expected = Index(np.concatenate((index, other)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index, sort=sort)
+        expected = Index(np.concatenate((other, index)))
+        tm.assert_index_equal(result, expected)
+
+    @pytest.fixture(
+        params=[
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(5, 20, 1),
+                RangeIndex(0, 20, 1),
+                Int64Index(range(20)),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(10, 20, 1),
+                RangeIndex(0, 20, 1),
+                Int64Index(range(20)),
+            ),
+            (
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+            ),
+            (
+                RangeIndex(0, -10, -1),
+                RangeIndex(-10, -20, -1),
+                RangeIndex(-19, 1, 1),
+                Int64Index(range(0, -20, -1)),
+            ),
+            (
+                RangeIndex(0, 10, 2),
+                RangeIndex(1, 10, 2),
+                RangeIndex(0, 10, 1),
+                Int64Index(list(range(0, 10, 2)) + list(range(1, 10, 2))),
+            ),
+            (
+                RangeIndex(0, 11, 2),
+                RangeIndex(1, 12, 2),
+                RangeIndex(0, 12, 1),
+                Int64Index(list(range(0, 11, 2)) + list(range(1, 12, 2))),
+            ),
+            (
+                RangeIndex(0, 21, 4),
+                RangeIndex(-2, 24, 4),
+                RangeIndex(-2, 24, 2),
+                Int64Index(list(range(0, 21, 4)) + list(range(-2, 24, 4))),
+            ),
+            (
+                RangeIndex(0, -20, -2),
+                RangeIndex(-1, -21, -2),
+                RangeIndex(-19, 1, 1),
+                Int64Index(list(range(0, -20, -2)) + list(range(-1, -21, -2))),
+            ),
+            (
+                RangeIndex(0, 100, 5),
+                RangeIndex(0, 100, 20),
+                RangeIndex(0, 100, 5),
+                Int64Index(range(0, 100, 5)),
+            ),
+            (
+                RangeIndex(0, -100, -5),
+                RangeIndex(5, -100, -20),
+                RangeIndex(-95, 10, 5),
+                Int64Index(list(range(0, -100, -5)) + [5]),
+            ),
+            (
+                RangeIndex(0, -11, -1),
+                RangeIndex(1, -12, -4),
+                RangeIndex(-11, 2, 1),
+                Int64Index(list(range(0, -11, -1)) + [1, -11]),
+            ),
+            (RangeIndex(0), RangeIndex(0), RangeIndex(0), RangeIndex(0)),
+            (
+                RangeIndex(0, -10, -2),
+                RangeIndex(0),
+                RangeIndex(0, -10, -2),
+                RangeIndex(0, -10, -2),
+            ),
+            (
+                RangeIndex(0, 100, 2),
+                RangeIndex(100, 150, 200),
+                RangeIndex(0, 102, 2),
+                Int64Index(range(0, 102, 2)),
+            ),
+            (
+                RangeIndex(0, -100, -2),
+                RangeIndex(-100, 50, 102),
+                RangeIndex(-100, 4, 2),
+                Int64Index(list(range(0, -100, -2)) + [-100, 2]),
+            ),
+            (
+                RangeIndex(0, -100, -1),
+                RangeIndex(0, -50, -3),
+                RangeIndex(-99, 1, 1),
+                Int64Index(list(range(0, -100, -1))),
+            ),
+            (
+                RangeIndex(0, 1, 1),
+                RangeIndex(5, 6, 10),
+                RangeIndex(0, 6, 5),
+                Int64Index([0, 5]),
+            ),
+            (
+                RangeIndex(0, 10, 5),
+                RangeIndex(-5, -6, -20),
+                RangeIndex(-5, 10, 5),
+                Int64Index([0, 5, -5]),
+            ),
+            (
+                RangeIndex(0, 3, 1),
+                RangeIndex(4, 5, 1),
+                Int64Index([0, 1, 2, 4]),
+                Int64Index([0, 1, 2, 4]),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                Int64Index([]),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+            ),
+            (
+                RangeIndex(0),
+                Int64Index([1, 5, 6]),
+                Int64Index([1, 5, 6]),
+                Int64Index([1, 5, 6]),
+            ),
+        ]
+    )
+    def unions(self, request):
+        """Inputs and expected outputs for RangeIndex.union tests"""
+
+        return request.param
+
+    def test_union_sorted(self, unions):
+
+        idx1, idx2, expected_sorted, expected_notsorted = unions
+
+        res1 = idx1.union(idx2, sort=None)
+        tm.assert_index_equal(res1, expected_sorted, exact=True)
+
+        res1 = idx1.union(idx2, sort=False)
+        tm.assert_index_equal(res1, expected_notsorted, exact=True)
+
+        res2 = idx2.union(idx1, sort=None)
+        res3 = idx1._int64index.union(idx2, sort=None)
+        tm.assert_index_equal(res2, expected_sorted, exact=True)
+        tm.assert_index_equal(res3, expected_sorted)
diff --git a/pandas/tests/indexes/test_any_index.py b/pandas/tests/indexes/test_any_index.py
new file mode 100644
index 0000000000000..0db63f615c4f8
--- /dev/null
+++ b/pandas/tests/indexes/test_any_index.py
@@ -0,0 +1,34 @@
+"""
+Tests that can be parametrized over _any_ Index object.
+
+TODO: consider using hypothesis for these.
+"""
+import pytest
+
+
+def test_sort(indices):
+    with pytest.raises(TypeError):
+        indices.sort()
+
+
+def test_hash_error(indices):
+    index = indices
+    with pytest.raises(TypeError, match=f"unhashable type: '{type(index).__name__}'"):
+        hash(indices)
+
+
+def test_mutability(indices):
+    if not len(indices):
+        return
+    msg = "Index does not support mutable operations"
+    with pytest.raises(TypeError, match=msg):
+        indices[0] = indices[0]
+
+
+def test_wrong_number_names(indices):
+    with pytest.raises(ValueError, match="^Length"):
+        indices.names = ["apple", "banana", "carrot"]
+
+
+def test_tolist_matches_list(indices):
+    assert indices.tolist() == list(indices)
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index d1ed79118d2fa..04af9b09bbf89 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -11,8 +11,8 @@
 import pandas._config.config as cf
 
 from pandas._libs.tslib import Timestamp
-from pandas.compat import PY36
 from pandas.compat.numpy import np_datetime64_compat
+from pandas.util._test_decorators import async_mark
 
 from pandas.core.dtypes.common import is_unsigned_integer_dtype
 from pandas.core.dtypes.generic import ABCIndex
@@ -33,110 +33,80 @@
     isna,
     period_range,
 )
-from pandas.core.index import (
+import pandas._testing as tm
+from pandas.core.indexes.api import (
+    Index,
+    MultiIndex,
     _get_combined_index,
     ensure_index,
     ensure_index_from_sequences,
 )
-from pandas.core.indexes.api import Index, MultiIndex
-from pandas.core.sorting import safe_sort
 from pandas.tests.indexes.common import Base
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
+from pandas.tests.indexes.conftest import indices_dict
 
 
 class TestIndex(Base):
     _holder = Index
 
-    def setup_method(self, method):
-        self.indices = dict(
-            unicodeIndex=tm.makeUnicodeIndex(100),
-            strIndex=tm.makeStringIndex(100),
-            dateIndex=tm.makeDateIndex(100),
-            periodIndex=tm.makePeriodIndex(100),
-            tdIndex=tm.makeTimedeltaIndex(100),
-            intIndex=tm.makeIntIndex(100),
-            uintIndex=tm.makeUIntIndex(100),
-            rangeIndex=tm.makeRangeIndex(100),
-            floatIndex=tm.makeFloatIndex(100),
-            boolIndex=Index([True, False]),
-            catIndex=tm.makeCategoricalIndex(100),
-            empty=Index([]),
-            tuples=MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
-            repeats=Index([0, 0, 1, 1, 2, 2]),
-        )
-        self.setup_indices()
+    @pytest.fixture
+    def index(self, request):
+        """
+        Fixture for selectively parametrizing indices_dict via indirect parametrization
+        (parametrize over indices_dict keys with indirect=True). Defaults to string
+        index if no keys are provided.
+        """
+        key = getattr(request, "param", "string")
+
+        # copy to avoid mutation, e.g. setting .name
+        return indices_dict[key].copy()
 
     def create_index(self):
         return Index(list("abcde"))
 
-    def generate_index_types(self, skip_index_keys=[]):
-        """
-        Return a generator of the various index types, leaving
-        out the ones with a key in skip_index_keys
-        """
-        for key, index in self.indices.items():
-            if key not in skip_index_keys:
-                yield key, index
-
     def test_can_hold_identifiers(self):
         index = self.create_index()
         key = index[0]
         assert index._can_hold_identifiers_and_holds_name(key) is True
 
-    def test_new_axis(self):
-        new_index = self.dateIndex[None, :]
+    @pytest.mark.parametrize("index", ["datetime"], indirect=True)
+    def test_new_axis(self, index):
+        with tm.assert_produces_warning(DeprecationWarning):
+            # GH#30588 multi-dimensional indexing deprecated
+            new_index = index[None, :]
         assert new_index.ndim == 2
         assert isinstance(new_index, np.ndarray)
 
-    def test_copy_and_deepcopy(self):
-        new_copy2 = self.intIndex.copy(dtype=int)
+    @pytest.mark.parametrize("index", ["int", "uint", "float"], indirect=True)
+    def test_copy_and_deepcopy(self, index):
+        new_copy2 = index.copy(dtype=int)
         assert new_copy2.dtype.kind == "i"
 
-    @pytest.mark.parametrize("attr", ["strIndex", "dateIndex"])
-    def test_constructor_regular(self, attr):
-        # regular instance creation
-        index = getattr(self, attr)
-        tm.assert_contains_all(index, index)
+    def test_constructor_regular(self, indices):
+        tm.assert_contains_all(indices, indices)
 
-    def test_constructor_casting(self):
+    def test_constructor_casting(self, index):
         # casting
-        arr = np.array(self.strIndex)
-        index = Index(arr)
-        tm.assert_contains_all(arr, index)
-        tm.assert_index_equal(self.strIndex, index)
+        arr = np.array(index)
+        new_index = Index(arr)
+        tm.assert_contains_all(arr, new_index)
+        tm.assert_index_equal(index, new_index)
 
-    def test_constructor_copy(self):
+    def test_constructor_copy(self, index):
         # copy
-        arr = np.array(self.strIndex)
-        index = Index(arr, copy=True, name="name")
-        assert isinstance(index, Index)
-        assert index.name == "name"
-        tm.assert_numpy_array_equal(arr, index.values)
+        # index = self.create_index()
+        arr = np.array(index)
+        new_index = Index(arr, copy=True, name="name")
+        assert isinstance(new_index, Index)
+        assert new_index.name == "name"
+        tm.assert_numpy_array_equal(arr, new_index.values)
         arr[0] = "SOMEBIGLONGSTRING"
-        assert index[0] != "SOMEBIGLONGSTRING"
+        assert new_index[0] != "SOMEBIGLONGSTRING"
 
+        # FIXME: dont leave commented-out
         # what to do here?
         # arr = np.array(5.)
         # pytest.raises(Exception, arr.view, Index)
 
-    def test_constructor_corner(self):
-        # corner case
-        msg = (
-            r"Index\(\.\.\.\) must be called with a collection of some"
-            " kind, 0 was passed"
-        )
-        with pytest.raises(TypeError, match=msg):
-            Index(0)
-
-    @pytest.mark.parametrize("index_vals", [[("A", 1), "B"], ["B", ("A", 1)]])
-    def test_construction_list_mixed_tuples(self, index_vals):
-        # see gh-10697: if we are constructing from a mixed list of tuples,
-        # make sure that we are independent of the sorting order.
-        index = Index(index_vals)
-        assert isinstance(index, Index)
-        assert not isinstance(index, MultiIndex)
-
     @pytest.mark.parametrize("na_value", [None, np.nan])
     @pytest.mark.parametrize("vtype", [list, tuple, iter])
     def test_construction_list_tuples_nan(self, na_value, vtype):
@@ -259,7 +229,7 @@ class ArrayLike:
             def __init__(self, array):
                 self.array = array
 
-            def __array__(self, dtype=None):
+            def __array__(self, dtype=None) -> np.ndarray:
                 return self.array
 
         expected = pd.Index(array)
@@ -469,9 +439,9 @@ def test_constructor_dtypes_to_timedelta(self, cast_index, vals):
             index = Index(vals)
             assert isinstance(index, TimedeltaIndex)
 
-    @pytest.mark.parametrize("attr, utc", [["values", False], ["asi8", True]])
+    @pytest.mark.parametrize("attr", ["values", "asi8"])
     @pytest.mark.parametrize("klass", [pd.Index, pd.DatetimeIndex])
-    def test_constructor_dtypes_datetime(self, tz_naive_fixture, attr, utc, klass):
+    def test_constructor_dtypes_datetime(self, tz_naive_fixture, attr, klass):
         # Test constructing with a datetimetz dtype
         # .values produces numpy datetimes, so these are considered naive
         # .asi8 produces integers, so these are considered epoch timestamps
@@ -482,30 +452,27 @@ def test_constructor_dtypes_datetime(self, tz_naive_fixture, attr, utc, klass):
         index = index.tz_localize(tz_naive_fixture)
         dtype = index.dtype
 
-        if (
-            tz_naive_fixture
-            and attr == "asi8"
-            and str(tz_naive_fixture) not in ("UTC", "tzutc()", "UTC+00:00")
-        ):
-            ex_warn = FutureWarning
+        if attr == "asi8":
+            result = pd.DatetimeIndex(arg).tz_localize(tz_naive_fixture)
         else:
-            ex_warn = None
-
-        # stacklevel is checked elsewhere. We don't do it here since
-        # Index will have an frame, throwing off the expected.
-        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
             result = klass(arg, tz=tz_naive_fixture)
         tm.assert_index_equal(result, index)
 
-        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+        if attr == "asi8":
+            result = pd.DatetimeIndex(arg).astype(dtype)
+        else:
             result = klass(arg, dtype=dtype)
         tm.assert_index_equal(result, index)
 
-        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+        if attr == "asi8":
+            result = pd.DatetimeIndex(list(arg)).tz_localize(tz_naive_fixture)
+        else:
             result = klass(list(arg), tz=tz_naive_fixture)
         tm.assert_index_equal(result, index)
 
-        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+        if attr == "asi8":
+            result = pd.DatetimeIndex(list(arg)).astype(dtype)
+        else:
             result = klass(list(arg), dtype=dtype)
         tm.assert_index_equal(result, index)
 
@@ -523,7 +490,7 @@ def test_constructor_dtypes_timedelta(self, attr, klass):
         result = klass(list(values), dtype=dtype)
         tm.assert_index_equal(result, index)
 
-    @pytest.mark.parametrize("value", [[], iter([]), (x for x in [])])
+    @pytest.mark.parametrize("value", [[], iter([]), (_ for _ in [])])
     @pytest.mark.parametrize(
         "klass",
         [
@@ -546,7 +513,7 @@ def test_constructor_empty(self, value, klass):
         [
             (PeriodIndex([], freq="B"), PeriodIndex),
             (PeriodIndex(iter([]), freq="B"), PeriodIndex),
-            (PeriodIndex((x for x in []), freq="B"), PeriodIndex),
+            (PeriodIndex((_ for _ in []), freq="B"), PeriodIndex),
             (RangeIndex(step=1), pd.RangeIndex),
             (MultiIndex(levels=[[1, 2], ["blue", "red"]], codes=[[], []]), MultiIndex),
         ],
@@ -564,43 +531,50 @@ def test_constructor_overflow_int64(self):
         with pytest.raises(OverflowError, match=msg):
             Index([np.iinfo(np.uint64).max - 1], dtype="int64")
 
-    @pytest.mark.xfail(reason="see GH#21311: Index doesn't enforce dtype argument")
-    def test_constructor_cast(self):
-        msg = "could not convert string to float"
-        with pytest.raises(ValueError, match=msg):
-            Index(["a", "b", "c"], dtype=float)
-
-    def test_view_with_args(self):
-        restricted = ["unicodeIndex", "strIndex", "catIndex", "boolIndex", "empty"]
-        for i in list(set(self.indices.keys()) - set(restricted)):
-            ind = self.indices[i]
-            ind.view("i8")
+    @pytest.mark.parametrize(
+        "index",
+        [
+            "datetime",
+            "float",
+            "int",
+            "period",
+            "range",
+            "repeats",
+            "timedelta",
+            "tuples",
+            "uint",
+        ],
+        indirect=True,
+    )
+    def test_view_with_args(self, index):
+        index.view("i8")
 
     @pytest.mark.parametrize(
-        "index_type",
+        "index",
         [
-            "unicodeIndex",
-            "strIndex",
-            pytest.param("catIndex", marks=pytest.mark.xfail(reason="gh-25464")),
-            "boolIndex",
+            "unicode",
+            "string",
+            pytest.param("categorical", marks=pytest.mark.xfail(reason="gh-25464")),
+            "bool",
             "empty",
         ],
+        indirect=True,
     )
-    def test_view_with_args_object_array_raises(self, index_type):
-        ind = self.indices[index_type]
+    def test_view_with_args_object_array_raises(self, index):
         msg = "Cannot change data-type for object array"
         with pytest.raises(TypeError, match=msg):
-            ind.view("i8")
+            index.view("i8")
 
-    def test_astype(self):
-        casted = self.intIndex.astype("i8")
+    @pytest.mark.parametrize("index", ["int", "range"], indirect=True)
+    def test_astype(self, index):
+        casted = index.astype("i8")
 
         # it works!
         casted.get_loc(5)
 
         # pass on name
-        self.intIndex.name = "foobar"
-        casted = self.intIndex.astype("i8")
+        index.name = "foobar"
+        casted = index.astype("i8")
         assert casted.name == "foobar"
 
     def test_equals_object(self):
@@ -700,16 +674,17 @@ def test_is_(self):
         ind2 = Index(arr, copy=False)
         assert not ind1.is_(ind2)
 
-    def test_asof(self):
-        d = self.dateIndex[0]
-        assert self.dateIndex.asof(d) == d
-        assert isna(self.dateIndex.asof(d - timedelta(1)))
+    @pytest.mark.parametrize("index", ["datetime"], indirect=True)
+    def test_asof(self, index):
+        d = index[0]
+        assert index.asof(d) == d
+        assert isna(index.asof(d - timedelta(1)))
 
-        d = self.dateIndex[-1]
-        assert self.dateIndex.asof(d + timedelta(1)) == d
+        d = index[-1]
+        assert index.asof(d + timedelta(1)) == d
 
-        d = self.dateIndex[0].to_pydatetime()
-        assert isinstance(self.dateIndex.asof(d), Timestamp)
+        d = index[0].to_pydatetime()
+        assert isinstance(index.asof(d), Timestamp)
 
     def test_asof_datetime_partial(self):
         index = pd.date_range("2010-01-01", periods=2, freq="m")
@@ -731,41 +706,40 @@ def test_nanosecond_index_access(self):
         expected_ts = np_datetime64_compat("2013-01-01 00:00:00.000000050+0000", "ns")
         assert first_value == x[Timestamp(expected_ts)]
 
-    def test_booleanindex(self):
-        boolIndex = np.repeat(True, len(self.strIndex)).astype(bool)
-        boolIndex[5:30:2] = False
+    def test_booleanindex(self, index):
+        bool_index = np.ones(len(index), dtype=bool)
+        bool_index[5:30:2] = False
 
-        subIndex = self.strIndex[boolIndex]
+        sub_index = index[bool_index]
 
-        for i, val in enumerate(subIndex):
-            assert subIndex.get_loc(val) == i
+        for i, val in enumerate(sub_index):
+            assert sub_index.get_loc(val) == i
 
-        subIndex = self.strIndex[list(boolIndex)]
-        for i, val in enumerate(subIndex):
-            assert subIndex.get_loc(val) == i
+        sub_index = index[list(bool_index)]
+        for i, val in enumerate(sub_index):
+            assert sub_index.get_loc(val) == i
 
     def test_fancy(self):
-        sl = self.strIndex[[1, 2, 3]]
+        index = self.create_index()
+        sl = index[[1, 2, 3]]
         for i in sl:
             assert i == sl[sl.get_loc(i)]
 
-    @pytest.mark.parametrize("attr", ["strIndex", "intIndex", "floatIndex"])
+    @pytest.mark.parametrize("index", ["string", "int", "float"], indirect=True)
     @pytest.mark.parametrize("dtype", [np.int_, np.bool_])
-    def test_empty_fancy(self, attr, dtype):
+    def test_empty_fancy(self, index, dtype):
         empty_arr = np.array([], dtype=dtype)
-        index = getattr(self, attr)
-        empty_index = index.__class__([])
+        empty_index = type(index)([])
 
         assert index[[]].identical(empty_index)
         assert index[empty_arr].identical(empty_index)
 
-    @pytest.mark.parametrize("attr", ["strIndex", "intIndex", "floatIndex"])
-    def test_empty_fancy_raises(self, attr):
+    @pytest.mark.parametrize("index", ["string", "int", "float"], indirect=True)
+    def test_empty_fancy_raises(self, index):
         # pd.DatetimeIndex is excluded, because it overrides getitem and should
         # be tested separately.
         empty_farr = np.array([], dtype=np.float_)
-        index = getattr(self, attr)
-        empty_index = index.__class__([])
+        empty_index = type(index)([])
 
         assert index[[]].identical(empty_index)
         # np.ndarray only accepts ndarray of int & bool dtypes, so should Index
@@ -774,9 +748,9 @@ def test_empty_fancy_raises(self, attr):
             index[empty_farr]
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_intersection(self, sort):
-        first = self.strIndex[:20]
-        second = self.strIndex[:10]
+    def test_intersection(self, index, sort):
+        first = index[:20]
+        second = index[:10]
         intersect = first.intersection(second, sort=sort)
         if sort is None:
             tm.assert_index_equal(intersect, second.sort_values())
@@ -812,10 +786,10 @@ def test_intersection_name_preservation(self, index2, keeps_name, sort):
     )
     @pytest.mark.parametrize("sort", [None, False])
     def test_intersection_name_preservation2(
-        self, first_name, second_name, expected_name, sort
+        self, index, first_name, second_name, expected_name, sort
     ):
-        first = self.strIndex[5:20]
-        second = self.strIndex[:10]
+        first = index[5:20]
+        second = index[:10]
         first.name = first_name
         second.name = second_name
         intersect = first.intersection(second, sort=sort)
@@ -900,11 +874,10 @@ def test_chained_union(self, sort):
         tm.assert_index_equal(union, expected)
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_union(self, sort):
-        # TODO: Replace with fixturesult
-        first = self.strIndex[5:20]
-        second = self.strIndex[:10]
-        everything = self.strIndex[:20]
+    def test_union(self, index, sort):
+        first = index[5:20]
+        second = index[:10]
+        everything = index[:20]
 
         union = first.union(second, sort=sort)
         if sort is None:
@@ -965,12 +938,11 @@ def test_union_sort_other_incomparable_true(self):
 
     @pytest.mark.parametrize("klass", [np.array, Series, list])
     @pytest.mark.parametrize("sort", [None, False])
-    def test_union_from_iterables(self, klass, sort):
+    def test_union_from_iterables(self, index, klass, sort):
         # GH 10149
-        # TODO: Replace with fixturesult
-        first = self.strIndex[5:20]
-        second = self.strIndex[:10]
-        everything = self.strIndex[:20]
+        first = index[5:20]
+        second = index[:10]
+        everything = index[:20]
 
         case = klass(second.values)
         result = first.union(case, sort=sort)
@@ -979,9 +951,8 @@ def test_union_from_iterables(self, klass, sort):
         assert tm.equalContents(result, everything)
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_union_identity(self, sort):
-        # TODO: replace with fixturesult
-        first = self.strIndex[5:20]
+    def test_union_identity(self, index, sort):
+        first = index[5:20]
 
         union = first.union(first, sort=sort)
         # i.e. identity is not preserved when sort is True
@@ -1021,19 +992,21 @@ def test_union_name_preservation(
     @pytest.mark.parametrize("sort", [None, False])
     def test_union_dt_as_obj(self, sort):
         # TODO: Replace with fixturesult
-        firstCat = self.strIndex.union(self.dateIndex)
-        secondCat = self.strIndex.union(self.strIndex)
+        index = self.create_index()
+        date_index = pd.date_range("2019-01-01", periods=10)
+        first_cat = index.union(date_index)
+        second_cat = index.union(index)
 
-        if self.dateIndex.dtype == np.object_:
-            appended = np.append(self.strIndex, self.dateIndex)
+        if date_index.dtype == np.object_:
+            appended = np.append(index, date_index)
         else:
-            appended = np.append(self.strIndex, self.dateIndex.astype("O"))
+            appended = np.append(index, date_index.astype("O"))
 
-        assert tm.equalContents(firstCat, appended)
-        assert tm.equalContents(secondCat, self.strIndex)
-        tm.assert_contains_all(self.strIndex, firstCat)
-        tm.assert_contains_all(self.strIndex, secondCat)
-        tm.assert_contains_all(self.dateIndex, firstCat)
+        assert tm.equalContents(first_cat, appended)
+        assert tm.equalContents(second_cat, index)
+        tm.assert_contains_all(index, first_cat)
+        tm.assert_contains_all(index, second_cat)
+        tm.assert_contains_all(date_index, first_cat)
 
     @pytest.mark.parametrize(
         "method", ["union", "intersection", "difference", "symmetric_difference"]
@@ -1045,11 +1018,35 @@ def test_setops_disallow_true(self, method):
         with pytest.raises(ValueError, match="The 'sort' keyword only takes"):
             getattr(idx1, method)(idx2, sort=True)
 
-    def test_map_identity_mapping(self):
+    def test_setops_preserve_object_dtype(self):
+        idx = pd.Index([1, 2, 3], dtype=object)
+        result = idx.intersection(idx[1:])
+        expected = idx[1:]
+        tm.assert_index_equal(result, expected)
+
+        # if other is not monotonic increasing, intersection goes through
+        #  a different route
+        result = idx.intersection(idx[1:][::-1])
+        tm.assert_index_equal(result, expected)
+
+        result = idx._union(idx[1:], sort=None)
+        expected = idx
+        tm.assert_index_equal(result, expected)
+
+        result = idx.union(idx[1:], sort=None)
+        tm.assert_index_equal(result, expected)
+
+        # if other is not monotonic increasing, _union goes through
+        #  a different route
+        result = idx._union(idx[1:][::-1], sort=None)
+        tm.assert_index_equal(result, expected)
+
+        result = idx.union(idx[1:][::-1], sort=None)
+        tm.assert_index_equal(result, expected)
+
+    def test_map_identity_mapping(self, indices):
         # GH 12766
-        # TODO: replace with fixture
-        for name, cur_index in self.indices.items():
-            tm.assert_index_equal(cur_index, cur_index.map(lambda x: x))
+        tm.assert_index_equal(indices, indices.map(lambda x: x))
 
     def test_map_with_tuples(self):
         # GH 12766
@@ -1096,31 +1093,37 @@ def test_map_tseries_indices_accsr_return_index(self):
             lambda values, index: pd.Series(values, index),
         ],
     )
-    def test_map_dictlike(self, mapper):
+    def test_map_dictlike_simple(self, mapper):
         # GH 12756
         expected = Index(["foo", "bar", "baz"])
         index = tm.makeIntIndex(3)
         result = index.map(mapper(expected.values, index))
         tm.assert_index_equal(result, expected)
 
-        # TODO: replace with fixture
-        for name in self.indices.keys():
-            if name == "catIndex":
-                # Tested in test_categorical
-                continue
-            elif name == "repeats":
-                # Cannot map duplicated index
-                continue
-
-            index = self.indices[name]
-            expected = Index(np.arange(len(index), 0, -1))
-
+    @pytest.mark.parametrize(
+        "mapper",
+        [
+            lambda values, index: {i: e for e, i in zip(values, index)},
+            lambda values, index: pd.Series(values, index),
+        ],
+    )
+    def test_map_dictlike(self, indices, mapper):
+        # GH 12756
+        if isinstance(indices, CategoricalIndex):
+            # Tested in test_categorical
+            return
+        elif not indices.is_unique:
+            # Cannot map duplicated index
+            return
+
+        if indices.empty:
             # to match proper result coercion for uints
-            if name == "empty":
-                expected = Index([])
+            expected = Index([])
+        else:
+            expected = Index(np.arange(len(indices), 0, -1))
 
-            result = index.map(mapper(expected, index))
-            tm.assert_index_equal(result, expected)
+        result = indices.map(mapper(expected, indices))
+        tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
         "mapper",
@@ -1169,11 +1172,10 @@ def test_append_empty_preserve_name(self, name, expected):
 
     @pytest.mark.parametrize("second_name,expected", [(None, None), ("name", "name")])
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_name_preservation(self, second_name, expected, sort):
-        # TODO: replace with fixturesult
-        first = self.strIndex[5:20]
-        second = self.strIndex[:10]
-        answer = self.strIndex[10:20]
+    def test_difference_name_preservation(self, index, second_name, expected, sort):
+        first = index[5:20]
+        second = index[:10]
+        answer = index[10:20]
 
         first.name = "name"
         second.name = second_name
@@ -1187,8 +1189,8 @@ def test_difference_name_preservation(self, second_name, expected, sort):
             assert result.name == expected
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_empty_arg(self, sort):
-        first = self.strIndex[5:20]
+    def test_difference_empty_arg(self, index, sort):
+        first = index[5:20]
         first.name == "name"
         result = first.difference([], sort)
 
@@ -1196,8 +1198,8 @@ def test_difference_empty_arg(self, sort):
         assert result.name == first.name
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_identity(self, sort):
-        first = self.strIndex[5:20]
+    def test_difference_identity(self, index, sort):
+        first = index[5:20]
         first.name == "name"
         result = first.difference(first, sort)
 
@@ -1205,12 +1207,12 @@ def test_difference_identity(self, sort):
         assert result.name == first.name
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_sort(self, sort):
-        first = self.strIndex[5:20]
-        second = self.strIndex[:10]
+    def test_difference_sort(self, index, sort):
+        first = index[5:20]
+        second = index[:10]
 
         result = first.difference(second, sort)
-        expected = self.strIndex[10:20]
+        expected = index[10:20]
 
         if sort is None:
             expected = expected.sort_values()
@@ -1267,7 +1269,7 @@ def test_difference_incomparable_true(self, opname):
 
     @pytest.mark.parametrize("sort", [None, False])
     def test_symmetric_difference_mi(self, sort):
-        index1 = MultiIndex.from_tuples(self.tuples)
+        index1 = MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3]))
         index2 = MultiIndex.from_tuples([("foo", 1), ("bar", 3)])
         result = index1.symmetric_difference(index2, sort=sort)
         expected = MultiIndex.from_tuples([("bar", 2), ("baz", 3), ("bar", 3)])
@@ -1308,89 +1310,88 @@ def test_symmetric_difference_non_index(self, sort):
         assert result.name == "new_name"
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_type(self, sort):
+    def test_difference_type(self, indices, sort):
         # GH 20040
         # If taking difference of a set and itself, it
         # needs to preserve the type of the index
-        skip_index_keys = ["repeats"]
-        for key, index in self.generate_index_types(skip_index_keys):
-            result = index.difference(index, sort=sort)
-            expected = index.drop(index)
-            tm.assert_index_equal(result, expected)
+        if not indices.is_unique:
+            return
+        result = indices.difference(indices, sort=sort)
+        expected = indices.drop(indices)
+        tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize("sort", [None, False])
-    def test_intersection_difference(self, sort):
+    def test_intersection_difference(self, indices, sort):
         # GH 20040
         # Test that the intersection of an index with an
         # empty index produces the same index as the difference
         # of an index with itself.  Test for all types
-        skip_index_keys = ["repeats"]
-        for key, index in self.generate_index_types(skip_index_keys):
-            inter = index.intersection(index.drop(index))
-            diff = index.difference(index, sort=sort)
-            tm.assert_index_equal(inter, diff)
+        if not indices.is_unique:
+            return
+        inter = indices.intersection(indices.drop(indices))
+        diff = indices.difference(indices, sort=sort)
+        tm.assert_index_equal(inter, diff)
 
     @pytest.mark.parametrize(
-        "attr,expected",
+        "index, expected",
         [
-            ("strIndex", False),
-            ("boolIndex", False),
-            ("catIndex", False),
-            ("intIndex", True),
-            ("dateIndex", False),
-            ("floatIndex", True),
+            ("string", False),
+            ("bool", False),
+            ("categorical", False),
+            ("int", True),
+            ("datetime", False),
+            ("float", True),
         ],
+        indirect=["index"],
     )
-    def test_is_numeric(self, attr, expected):
-        assert getattr(self, attr).is_numeric() == expected
+    def test_is_numeric(self, index, expected):
+        assert index.is_numeric() is expected
 
     @pytest.mark.parametrize(
-        "attr,expected",
+        "index, expected",
         [
-            ("strIndex", True),
-            ("boolIndex", True),
-            ("catIndex", False),
-            ("intIndex", False),
-            ("dateIndex", False),
-            ("floatIndex", False),
+            ("string", True),
+            ("bool", True),
+            ("categorical", False),
+            ("int", False),
+            ("datetime", False),
+            ("float", False),
         ],
+        indirect=["index"],
     )
-    def test_is_object(self, attr, expected):
-        assert getattr(self, attr).is_object() == expected
+    def test_is_object(self, index, expected):
+        assert index.is_object() is expected
 
     @pytest.mark.parametrize(
-        "attr,expected",
+        "index, expected",
         [
-            ("strIndex", False),
-            ("boolIndex", False),
-            ("catIndex", False),
-            ("intIndex", False),
-            ("dateIndex", True),
-            ("floatIndex", False),
+            ("string", False),
+            ("bool", False),
+            ("categorical", False),
+            ("int", False),
+            ("datetime", True),
+            ("float", False),
         ],
+        indirect=["index"],
     )
-    def test_is_all_dates(self, attr, expected):
-        assert getattr(self, attr).is_all_dates == expected
+    def test_is_all_dates(self, index, expected):
+        assert index.is_all_dates is expected
+
+    def test_summary(self, indices):
+        self._check_method_works(Index._summary, indices)
 
-    def test_summary(self):
-        self._check_method_works(Index._summary)
-        # GH3869
+    def test_summary_bug(self):
+        # GH3869`
         ind = Index(["{other}%s", "~:{range}:0"], name="A")
         result = ind._summary()
         # shouldn't be formatted accidentally.
         assert "~:{range}:0" in result
         assert "{other}%s" in result
 
-    # GH18217
-    def test_summary_deprecated(self):
-        ind = Index(["{other}%s", "~:{range}:0"], name="A")
-
-        with tm.assert_produces_warning(FutureWarning):
-            ind.summary()
-
-    def test_format(self):
-        self._check_method_works(Index.format)
+    def test_format(self, indices):
+        self._check_method_works(Index.format, indices)
 
+    def test_format_bug(self):
         # GH 14626
         # windows has different precision on datetime.datetime.now (it doesn't
         # include us since the default for Timestamp shows these but Index
@@ -1402,7 +1403,7 @@ def test_format(self):
             expected = [str(index[0])]
             assert formatted == expected
 
-        self.strIndex[:0].format()
+        Index([]).format()
 
     @pytest.mark.parametrize("vals", [[1, 2.0 + 3.0j, 4.0], ["a", "b", "c"]])
     def test_format_missing(self, vals, nulls_fixture):
@@ -1419,8 +1420,7 @@ def test_format_missing(self, vals, nulls_fixture):
 
     def test_format_with_name_time_info(self):
         # bug I fixed 12/20/2011
-        inc = timedelta(hours=4)
-        dates = Index([dt + inc for dt in self.dateIndex], name="something")
+        dates = date_range("2011-01-01 04:00:00", periods=10, name="something")
 
         formatted = dates.format(name=True)
         assert formatted[0] == "something"
@@ -1438,15 +1438,8 @@ def test_logical_compat(self, op):
         index = self.create_index()
         assert getattr(index, op)() == getattr(index.values, op)()
 
-    def _check_method_works(self, method):
-        # TODO: make this a dedicated test with parametrized methods
-        method(self.empty)
-        method(self.dateIndex)
-        method(self.unicodeIndex)
-        method(self.strIndex)
-        method(self.intIndex)
-        method(self.tuples)
-        method(self.catIndex)
+    def _check_method_works(self, method, index):
+        method(index)
 
     def test_get_indexer(self):
         index1 = Index([1, 2, 3, 4, 5])
@@ -1454,7 +1447,7 @@ def test_get_indexer(self):
 
         r1 = index1.get_indexer(index2)
         e1 = np.array([1, 3, -1], dtype=np.intp)
-        assert_almost_equal(r1, e1)
+        tm.assert_almost_equal(r1, e1)
 
     @pytest.mark.parametrize("reverse", [True, False])
     @pytest.mark.parametrize(
@@ -1475,7 +1468,7 @@ def test_get_indexer_methods(self, reverse, expected, method):
             expected = expected[::-1]
 
         result = index2.get_indexer(index1, method=method)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
     def test_get_indexer_invalid(self):
         # GH10411
@@ -1619,11 +1612,7 @@ def test_get_loc(self, method):
     def test_get_loc_raises_bad_label(self, method):
         index = pd.Index([0, 1, 2])
         if method:
-            # Messages vary across versions
-            if PY36:
-                msg = "not supported between"
-            else:
-                msg = "unorderable types"
+            msg = "not supported between"
         else:
             msg = "invalid key"
 
@@ -1740,22 +1729,22 @@ def test_slice_locs_na_raises(self):
         "in_slice,expected",
         [
             (pd.IndexSlice[::-1], "yxdcb"),
-            (pd.IndexSlice["b":"y":-1], ""),
-            (pd.IndexSlice["b"::-1], "b"),
-            (pd.IndexSlice[:"b":-1], "yxdcb"),
-            (pd.IndexSlice[:"y":-1], "y"),
-            (pd.IndexSlice["y"::-1], "yxdcb"),
-            (pd.IndexSlice["y"::-4], "yb"),
+            (pd.IndexSlice["b":"y":-1], ""),  # type: ignore
+            (pd.IndexSlice["b"::-1], "b"),  # type: ignore
+            (pd.IndexSlice[:"b":-1], "yxdcb"),  # type: ignore
+            (pd.IndexSlice[:"y":-1], "y"),  # type: ignore
+            (pd.IndexSlice["y"::-1], "yxdcb"),  # type: ignore
+            (pd.IndexSlice["y"::-4], "yb"),  # type: ignore
             # absent labels
-            (pd.IndexSlice[:"a":-1], "yxdcb"),
-            (pd.IndexSlice[:"a":-2], "ydb"),
-            (pd.IndexSlice["z"::-1], "yxdcb"),
-            (pd.IndexSlice["z"::-3], "yc"),
-            (pd.IndexSlice["m"::-1], "dcb"),
-            (pd.IndexSlice[:"m":-1], "yx"),
-            (pd.IndexSlice["a":"a":-1], ""),
-            (pd.IndexSlice["z":"z":-1], ""),
-            (pd.IndexSlice["m":"m":-1], ""),
+            (pd.IndexSlice[:"a":-1], "yxdcb"),  # type: ignore
+            (pd.IndexSlice[:"a":-2], "ydb"),  # type: ignore
+            (pd.IndexSlice["z"::-1], "yxdcb"),  # type: ignore
+            (pd.IndexSlice["z"::-3], "yc"),  # type: ignore
+            (pd.IndexSlice["m"::-1], "dcb"),  # type: ignore
+            (pd.IndexSlice[:"m":-1], "yx"),  # type: ignore
+            (pd.IndexSlice["a":"a":-1], ""),  # type: ignore
+            (pd.IndexSlice["z":"z":-1], ""),  # type: ignore
+            (pd.IndexSlice["m":"m":-1], ""),  # type: ignore
         ],
     )
     def test_slice_locs_negative_step(self, in_slice, expected):
@@ -1766,38 +1755,37 @@ def test_slice_locs_negative_step(self, in_slice, expected):
         expected = pd.Index(list(expected))
         tm.assert_index_equal(result, expected)
 
-    def test_drop_by_str_label(self):
-        # TODO: Parametrize these after replacing self.strIndex with fixture
-        n = len(self.strIndex)
-        drop = self.strIndex[list(range(5, 10))]
-        dropped = self.strIndex.drop(drop)
+    @pytest.mark.parametrize("index", ["string", "int", "float"], indirect=True)
+    def test_drop_by_str_label(self, index):
+        n = len(index)
+        drop = index[list(range(5, 10))]
+        dropped = index.drop(drop)
 
-        expected = self.strIndex[list(range(5)) + list(range(10, n))]
+        expected = index[list(range(5)) + list(range(10, n))]
         tm.assert_index_equal(dropped, expected)
 
-        dropped = self.strIndex.drop(self.strIndex[0])
-        expected = self.strIndex[1:]
+        dropped = index.drop(index[0])
+        expected = index[1:]
         tm.assert_index_equal(dropped, expected)
 
+    @pytest.mark.parametrize("index", ["string", "int", "float"], indirect=True)
     @pytest.mark.parametrize("keys", [["foo", "bar"], ["1", "bar"]])
-    def test_drop_by_str_label_raises_missing_keys(self, keys):
+    def test_drop_by_str_label_raises_missing_keys(self, index, keys):
         with pytest.raises(KeyError, match=""):
-            self.strIndex.drop(keys)
-
-    def test_drop_by_str_label_errors_ignore(self):
-        # TODO: Parametrize these after replacing self.strIndex with fixture
+            index.drop(keys)
 
-        # errors='ignore'
-        n = len(self.strIndex)
-        drop = self.strIndex[list(range(5, 10))]
+    @pytest.mark.parametrize("index", ["string", "int", "float"], indirect=True)
+    def test_drop_by_str_label_errors_ignore(self, index):
+        n = len(index)
+        drop = index[list(range(5, 10))]
         mixed = drop.tolist() + ["foo"]
-        dropped = self.strIndex.drop(mixed, errors="ignore")
+        dropped = index.drop(mixed, errors="ignore")
 
-        expected = self.strIndex[list(range(5)) + list(range(10, n))]
+        expected = index[list(range(5)) + list(range(10, n))]
         tm.assert_index_equal(dropped, expected)
 
-        dropped = self.strIndex.drop(["foo", "bar"], errors="ignore")
-        expected = self.strIndex[list(range(n))]
+        dropped = index.drop(["foo", "bar"], errors="ignore")
+        expected = index[list(range(n))]
         tm.assert_index_equal(dropped, expected)
 
     def test_drop_by_numeric_label_loc(self):
@@ -1841,7 +1829,7 @@ def test_drop_tuple(self, values, to_drop):
             tm.assert_index_equal(result, expected)
 
         removed = index.drop(to_drop[1])
-        msg = r"\"\[{}\] not found in axis\"".format(re.escape(to_drop[1].__repr__()))
+        msg = fr"\"\[{re.escape(to_drop[1].__repr__())}\] not found in axis\""
         for drop_me in to_drop[1], [to_drop[1]]:
             with pytest.raises(KeyError, match=msg):
                 removed.drop(drop_me)
@@ -1908,15 +1896,28 @@ def test_is_monotonic_incomparable(self, attr):
         index = Index([5, datetime.now(), 7])
         assert not getattr(index, attr)
 
-    def test_get_set_value(self):
+    def test_set_value_deprecated(self):
+        # GH 28621
+        idx = self.create_index()
+        arr = np.array([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            idx.set_value(arr, idx[1], 80)
+        assert arr[1] == 80
+
+    @pytest.mark.parametrize(
+        "index", ["string", "int", "datetime", "timedelta"], indirect=True
+    )
+    def test_get_value(self, index):
         # TODO: Remove function? GH 19728
         values = np.random.randn(100)
-        date = self.dateIndex[67]
+        value = index[67]
 
-        assert_almost_equal(self.dateIndex.get_value(values, date), values[67])
+        with pytest.raises(AttributeError, match="has no attribute '_values'"):
+            # Index.get_value requires a Series, not an ndarray
+            index.get_value(values, value)
 
-        self.dateIndex.set_value(values, date, 10)
-        assert values[67] == 10
+        result = index.get_value(Series(values, index=values), value)
+        tm.assert_almost_equal(result, values[67])
 
     @pytest.mark.parametrize("values", [["foo", "bar", "quux"], {"foo", "bar", "quux"}])
     @pytest.mark.parametrize(
@@ -2001,14 +2002,14 @@ def test_isin_level_kwarg_bad_label_raises(self, label, indices):
         index = indices
         if isinstance(index, MultiIndex):
             index = index.rename(["foo", "bar"])
-            msg = "'Level {} not found'"
+            msg = f"'Level {label} not found'"
         else:
             index = index.rename("foo")
-            msg = r"Requested level \({}\) does not match index name \(foo\)"
-        with pytest.raises(KeyError, match=msg.format(label)):
+            msg = fr"Requested level \({label}\) does not match index name \(foo\)"
+        with pytest.raises(KeyError, match=msg):
             index.isin([], level=label)
 
-    @pytest.mark.parametrize("empty", [[], Series(), np.array([])])
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
     def test_isin_empty(self, empty):
         # see gh-16991
         index = Index(["a", "b"])
@@ -2035,8 +2036,8 @@ def test_boolean_cmp(self, values):
         tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize("name,level", [(None, 0), ("a", "a")])
-    def test_get_level_values(self, name, level):
-        expected = self.strIndex.copy()
+    def test_get_level_values(self, index, name, level):
+        expected = index.copy()
         if name:
             expected.name = name
 
@@ -2047,14 +2048,12 @@ def test_slice_keep_name(self):
         index = Index(["a", "b"], name="asdf")
         assert index.name == index[1:].name
 
-    # instance attributes of the form self.<name>Index
-    @pytest.mark.parametrize("index_kind", ["unicode", "str", "date", "int", "float"])
-    def test_join_self(self, join_type, index_kind):
-
-        res = getattr(self, "{0}Index".format(index_kind))
-
-        joined = res.join(res, how=join_type)
-        assert res is joined
+    @pytest.mark.parametrize(
+        "index", ["unicode", "string", "datetime", "int", "float"], indirect=True
+    )
+    def test_join_self(self, index, join_type):
+        joined = index.join(index, how=join_type)
+        assert index is joined
 
     @pytest.mark.parametrize("method", ["strip", "rstrip", "lstrip"])
     def test_str_attribute(self, method):
@@ -2403,26 +2402,35 @@ def test_cached_properties_not_settable(self):
         with pytest.raises(AttributeError, match="Can't set attribute"):
             index.is_unique = False
 
-    def test_get_duplicates_deprecated(self):
-        index = pd.Index([1, 2, 3])
-        with tm.assert_produces_warning(FutureWarning):
-            index.get_duplicates()
-
-    def test_tab_complete_warning(self, ip):
+    @async_mark()
+    async def test_tab_complete_warning(self, ip):
         # https://github.com/pandas-dev/pandas/issues/16409
         pytest.importorskip("IPython", minversion="6.0.0")
         from IPython.core.completer import provisionalcompleter
 
         code = "import pandas as pd; idx = pd.Index([1, 2])"
-        ip.run_code(code)
-        with tm.assert_produces_warning(None):
+        await ip.run_code(code)
+
+        # GH 31324 newer jedi version raises Deprecation warning
+        import jedi
+
+        if jedi.__version__ < "0.16.0":
+            warning = tm.assert_produces_warning(None)
+        else:
+            warning = tm.assert_produces_warning(
+                DeprecationWarning, check_stacklevel=False
+            )
+        with warning:
             with provisionalcompleter("ignore"):
                 list(ip.Completer.completions("idx.", 4))
 
-    def test_deprecated_contains(self):
-        for index in self.indices.values():
-            with tm.assert_produces_warning(FutureWarning):
-                index.contains(1)
+    def test_contains_method_removed(self, indices):
+        # GH#30103 method removed for all types except IntervalIndex
+        if isinstance(indices, pd.IntervalIndex):
+            indices.contains(1)
+        else:
+            with pytest.raises(AttributeError):
+                indices.contains(1)
 
 
 class TestMixedIntIndex(Base):
@@ -2432,38 +2440,30 @@ class TestMixedIntIndex(Base):
 
     _holder = Index
 
-    def setup_method(self, method):
-        self.indices = dict(mixedIndex=Index([0, "a", 1, "b", 2, "c"]))
-        self.setup_indices()
+    @pytest.fixture(params=[[0, "a", 1, "b", 2, "c"]], ids=["mixedIndex"])
+    def indices(self, request):
+        return Index(request.param)
 
     def create_index(self):
-        return self.mixedIndex
+        return Index([0, "a", 1, "b", 2, "c"])
 
     def test_argsort(self):
         index = self.create_index()
-        if PY36:
-            with pytest.raises(TypeError, match="'>|<' not supported"):
-                index.argsort()
-        else:
-            with pytest.raises(TypeError, match="unorderable types"):
-                index.argsort()
+        with pytest.raises(TypeError, match="'>|<' not supported"):
+            index.argsort()
 
     def test_numpy_argsort(self):
         index = self.create_index()
-        if PY36:
-            with pytest.raises(TypeError, match="'>|<' not supported"):
-                np.argsort(index)
-        else:
-            with pytest.raises(TypeError, match="unorderable types"):
-                np.argsort(index)
+        with pytest.raises(TypeError, match="'>|<' not supported"):
+            np.argsort(index)
 
     def test_copy_name(self):
         # Check that "name" argument passed at initialization is honoured
         # GH12309
         index = self.create_index()
 
-        first = index.__class__(index, copy=True, name="mario")
-        second = first.__class__(first, copy=False)
+        first = type(index)(index, copy=True, name="mario")
+        second = type(first)(first, copy=False)
 
         # Even though "copy=False", we want a new object.
         assert first is not second
@@ -2499,78 +2499,12 @@ def test_copy_name2(self):
         assert index3.name == "NewName"
         assert index3.names == ["NewName"]
 
-    def test_union_base(self):
-        index = self.create_index()
-        first = index[3:]
-        second = index[:5]
-
-        result = first.union(second)
-
-        expected = Index([0, 1, 2, "a", "b", "c"])
-        tm.assert_index_equal(result, expected)
-
-    @pytest.mark.parametrize("klass", [np.array, Series, list])
-    def test_union_different_type_base(self, klass):
-        # GH 10149
-        index = self.create_index()
-        first = index[3:]
-        second = index[:5]
-
-        result = first.union(klass(second.values))
-
-        assert tm.equalContents(result, index)
-
     def test_unique_na(self):
         idx = pd.Index([2, np.nan, 2, 1], name="my_index")
         expected = pd.Index([2, np.nan, 1], name="my_index")
         result = idx.unique()
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_intersection_base(self, sort):
-        # (same results for py2 and py3 but sortedness not tested elsewhere)
-        index = self.create_index()
-        first = index[:5]
-        second = index[:3]
-
-        expected = Index([0, 1, "a"]) if sort is None else Index([0, "a", 1])
-        result = first.intersection(second, sort=sort)
-        tm.assert_index_equal(result, expected)
-
-    @pytest.mark.parametrize("klass", [np.array, Series, list])
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_intersection_different_type_base(self, klass, sort):
-        # GH 10149
-        index = self.create_index()
-        first = index[:5]
-        second = index[:3]
-
-        result = first.intersection(klass(second.values), sort=sort)
-        assert tm.equalContents(result, second)
-
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_base(self, sort):
-        # (same results for py2 and py3 but sortedness not tested elsewhere)
-        index = self.create_index()
-        first = index[:4]
-        second = index[3:]
-
-        result = first.difference(second, sort)
-        expected = Index([0, "a", 1])
-        if sort is None:
-            expected = Index(safe_sort(expected))
-        tm.assert_index_equal(result, expected)
-
-    def test_symmetric_difference(self):
-        # (same results for py2 and py3 but sortedness not tested elsewhere)
-        index = self.create_index()
-        first = index[:4]
-        second = index[3:]
-
-        result = first.symmetric_difference(second)
-        expected = Index([0, 1, 2, "a", "c"])
-        tm.assert_index_equal(result, expected)
-
     def test_logical_compat(self):
         index = self.create_index()
         assert index.all() == index.values.all()
@@ -2761,13 +2695,12 @@ def test_ensure_index_mixed_closed_intervals(self):
     ],
 )
 def test_generated_op_names(opname, indices):
-    index = indices
-    if isinstance(index, ABCIndex) and opname == "rsub":
+    if isinstance(indices, ABCIndex) and opname == "rsub":
         # pd.Index.__rsub__ does not exist; though the method does exist
         # for subclasses.  see GH#19723
         return
-    opname = "__{name}__".format(name=opname)
-    method = getattr(index, opname)
+    opname = f"__{opname}__"
+    method = getattr(indices, opname)
     assert method.__name__ == opname
 
 
@@ -2779,32 +2712,18 @@ def test_index_subclass_constructor_wrong_kwargs(index_maker):
 
 
 def test_deprecated_fastpath():
+    msg = "[Uu]nexpected keyword argument"
+    with pytest.raises(TypeError, match=msg):
+        pd.Index(np.array(["a", "b"], dtype=object), name="test", fastpath=True)
 
-    with tm.assert_produces_warning(FutureWarning):
-        idx = pd.Index(np.array(["a", "b"], dtype=object), name="test", fastpath=True)
-
-    expected = pd.Index(["a", "b"], name="test")
-    tm.assert_index_equal(idx, expected)
-
-    with tm.assert_produces_warning(FutureWarning):
-        idx = pd.Int64Index(
-            np.array([1, 2, 3], dtype="int64"), name="test", fastpath=True
-        )
-
-    expected = pd.Index([1, 2, 3], name="test", dtype="int64")
-    tm.assert_index_equal(idx, expected)
-
-    with tm.assert_produces_warning(FutureWarning):
-        idx = pd.RangeIndex(0, 5, 2, name="test", fastpath=True)
+    with pytest.raises(TypeError, match=msg):
+        pd.Int64Index(np.array([1, 2, 3], dtype="int64"), name="test", fastpath=True)
 
-    expected = pd.RangeIndex(0, 5, 2, name="test")
-    tm.assert_index_equal(idx, expected)
+    with pytest.raises(TypeError, match=msg):
+        pd.RangeIndex(0, 5, 2, name="test", fastpath=True)
 
-    with tm.assert_produces_warning(FutureWarning):
-        idx = pd.CategoricalIndex(["a", "b", "c"], name="test", fastpath=True)
-
-    expected = pd.CategoricalIndex(["a", "b", "c"], name="test")
-    tm.assert_index_equal(idx, expected)
+    with pytest.raises(TypeError, match=msg):
+        pd.CategoricalIndex(["a", "b", "c"], name="test", fastpath=True)
 
 
 def test_shape_of_invalid_index():
@@ -2813,9 +2732,35 @@ def test_shape_of_invalid_index():
     # about this). However, as long as this is not solved in general,this test ensures
     # that the returned shape is consistent with this underlying array for
     # compat with matplotlib (see https://github.com/pandas-dev/pandas/issues/27775)
-    a = np.arange(8).reshape(2, 2, 2)
-    idx = pd.Index(a)
-    assert idx.shape == a.shape
-
     idx = pd.Index([0, 1, 2, 3])
-    assert idx[:, None].shape == (4, 1)
+    with tm.assert_produces_warning(DeprecationWarning):
+        # GH#30588 multi-dimensional indexing deprecated
+        assert idx[:, None].shape == (4, 1)
+
+
+def test_validate_1d_input():
+    # GH#27125 check that we do not have >1-dimensional input
+    msg = "Index data must be 1-dimensional"
+
+    arr = np.arange(8).reshape(2, 2, 2)
+    with pytest.raises(ValueError, match=msg):
+        pd.Index(arr)
+
+    with pytest.raises(ValueError, match=msg):
+        pd.Float64Index(arr.astype(np.float64))
+
+    with pytest.raises(ValueError, match=msg):
+        pd.Int64Index(arr.astype(np.int64))
+
+    with pytest.raises(ValueError, match=msg):
+        pd.UInt64Index(arr.astype(np.uint64))
+
+    df = pd.DataFrame(arr.reshape(4, 2))
+    with pytest.raises(ValueError, match=msg):
+        pd.Index(df)
+
+    # GH#13601 trying to assign a multi-dimensional array to an index is not
+    #  allowed
+    ser = pd.Series(0, range(4))
+    with pytest.raises(ValueError, match=msg):
+        ser.index = np.array([[2, 3]] * 4)
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index ae1a21e9b3980..7e30233353553 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -14,7 +14,7 @@
 
 import pandas as pd
 from pandas import CategoricalIndex, MultiIndex, RangeIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestCommon:
@@ -158,16 +158,10 @@ def test_set_name_methods(self, indices):
         assert indices.name == name
         assert indices.names == [name]
 
-    def test_dtype_str(self, indices):
-        with tm.assert_produces_warning(FutureWarning):
-            dtype = indices.dtype_str
-            assert isinstance(dtype, str)
-            assert dtype == str(indices.dtype)
-
     def test_hash_error(self, indices):
         index = indices
         with pytest.raises(
-            TypeError, match=("unhashable type: {0.__name__!r}".format(type(index)))
+            TypeError, match=f"unhashable type: '{type(index).__name__}'"
         ):
             hash(indices)
 
@@ -201,8 +195,9 @@ def test_unique(self, indices):
         with pytest.raises(IndexError, match=msg):
             indices.unique(level=3)
 
-        msg = r"Requested level \(wrong\) does not match index name \({}\)".format(
-            re.escape(indices.name.__repr__())
+        msg = (
+            fr"Requested level \(wrong\) does not match index name "
+            fr"\({re.escape(indices.name.__repr__())}\)"
         )
         with pytest.raises(KeyError, match=msg):
             indices.unique(level="wrong")
diff --git a/pandas/tests/indexing/test_indexing_engines.py b/pandas/tests/indexes/test_engines.py
similarity index 68%
rename from pandas/tests/indexing/test_indexing_engines.py
rename to pandas/tests/indexes/test_engines.py
index 7303c1ff3d111..9ea70a457e516 100644
--- a/pandas/tests/indexing/test_indexing_engines.py
+++ b/pandas/tests/indexes/test_engines.py
@@ -1,8 +1,83 @@
+import re
+
 import numpy as np
+import pytest
 
 from pandas._libs import algos as libalgos, index as libindex
 
-import pandas.util.testing as tm
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.fixture(
+    params=[
+        (libindex.Int64Engine, np.int64),
+        (libindex.Int32Engine, np.int32),
+        (libindex.Int16Engine, np.int16),
+        (libindex.Int8Engine, np.int8),
+        (libindex.UInt64Engine, np.uint64),
+        (libindex.UInt32Engine, np.uint32),
+        (libindex.UInt16Engine, np.uint16),
+        (libindex.UInt8Engine, np.uint8),
+        (libindex.Float64Engine, np.float64),
+        (libindex.Float32Engine, np.float32),
+    ],
+    ids=lambda x: x[0].__name__,
+)
+def numeric_indexing_engine_type_and_dtype(request):
+    return request.param
+
+
+class TestDatetimeEngine:
+    @pytest.mark.parametrize(
+        "scalar",
+        [
+            pd.Timedelta(pd.Timestamp("2016-01-01").asm8.view("m8[ns]")),
+            pd.Timestamp("2016-01-01").value,
+            pd.Timestamp("2016-01-01").to_pydatetime(),
+            pd.Timestamp("2016-01-01").to_datetime64(),
+        ],
+    )
+    def test_not_contains_requires_timestamp(self, scalar):
+        dti1 = pd.date_range("2016-01-01", periods=3)
+        dti2 = dti1.insert(1, pd.NaT)  # non-monotonic
+        dti3 = dti1.insert(3, dti1[0])  # non-unique
+        dti4 = pd.date_range("2016-01-01", freq="ns", periods=2_000_000)
+        dti5 = dti4.insert(0, dti4[0])  # over size threshold, not unique
+
+        msg = "|".join([re.escape(str(scalar)), re.escape(repr(scalar))])
+        for dti in [dti1, dti2, dti3, dti4, dti5]:
+            with pytest.raises(TypeError, match=msg):
+                scalar in dti._engine
+
+            with pytest.raises(KeyError, match=msg):
+                dti._engine.get_loc(scalar)
+
+
+class TestTimedeltaEngine:
+    @pytest.mark.parametrize(
+        "scalar",
+        [
+            pd.Timestamp(pd.Timedelta(days=42).asm8.view("datetime64[ns]")),
+            pd.Timedelta(days=42).value,
+            pd.Timedelta(days=42).to_pytimedelta(),
+            pd.Timedelta(days=42).to_timedelta64(),
+        ],
+    )
+    def test_not_contains_requires_timestamp(self, scalar):
+        tdi1 = pd.timedelta_range("42 days", freq="9h", periods=1234)
+        tdi2 = tdi1.insert(1, pd.NaT)  # non-monotonic
+        tdi3 = tdi1.insert(3, tdi1[0])  # non-unique
+        tdi4 = pd.timedelta_range("42 days", freq="ns", periods=2_000_000)
+        tdi5 = tdi4.insert(0, tdi4[0])  # over size threshold, not unique
+
+        msg = "|".join([re.escape(str(scalar)), re.escape(repr(scalar))])
+        for tdi in [tdi1, tdi2, tdi3, tdi4, tdi5]:
+            with pytest.raises(TypeError, match=msg):
+                scalar in tdi._engine
+
+            with pytest.raises(KeyError, match=msg):
+                tdi._engine.get_loc(scalar)
 
 
 class TestNumericEngine:
diff --git a/pandas/tests/indexes/test_frozen.py b/pandas/tests/indexes/test_frozen.py
index 57acc8ee72b70..2e53e29c3fab1 100644
--- a/pandas/tests/indexes/test_frozen.py
+++ b/pandas/tests/indexes/test_frozen.py
@@ -1,21 +1,68 @@
-import warnings
+import re
 
-import numpy as np
 import pytest
 
-from pandas.core.indexes.frozen import FrozenList, FrozenNDArray
-from pandas.tests.test_base import CheckImmutable, CheckStringMixin
-from pandas.util import testing as tm
+from pandas.core.indexes.frozen import FrozenList
 
 
-class TestFrozenList(CheckImmutable, CheckStringMixin):
-    mutable_methods = ("extend", "pop", "remove", "insert")
+class TestFrozenList:
+
     unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])
 
     def setup_method(self, _):
         self.lst = [1, 2, 3, 4, 5]
         self.container = FrozenList(self.lst)
-        self.klass = FrozenList
+
+    def check_mutable_error(self, *args, **kwargs):
+        # Pass whatever function you normally would to pytest.raises
+        # (after the Exception kind).
+        mutable_regex = re.compile("does not support mutable operations")
+        with pytest.raises(TypeError):
+            mutable_regex(*args, **kwargs)
+
+    def test_no_mutable_funcs(self):
+        def setitem():
+            self.container[0] = 5
+
+        self.check_mutable_error(setitem)
+
+        def setslice():
+            self.container[1:2] = 3
+
+        self.check_mutable_error(setslice)
+
+        def delitem():
+            del self.container[0]
+
+        self.check_mutable_error(delitem)
+
+        def delslice():
+            del self.container[0:3]
+
+        self.check_mutable_error(delslice)
+
+        mutable_methods = ("extend", "pop", "remove", "insert")
+
+        for meth in mutable_methods:
+            self.check_mutable_error(getattr(self.container, meth))
+
+    def test_slicing_maintains_type(self):
+        result = self.container[1:2]
+        expected = self.lst[1:2]
+        self.check_result(result, expected)
+
+    def check_result(self, result, expected):
+        assert isinstance(result, FrozenList)
+        assert result == expected
+
+    def test_string_methods_dont_fail(self):
+        repr(self.container)
+        str(self.container)
+        bytes(self.container)
+
+    def test_tricky_container(self):
+        repr(self.unicode_container)
+        str(self.unicode_container)
 
     def test_add(self):
         result = self.container + (1, 2, 3)
@@ -55,62 +102,3 @@ def test_tricky_container_to_bytes_raises(self):
         msg = "^'str' object cannot be interpreted as an integer$"
         with pytest.raises(TypeError, match=msg):
             bytes(self.unicode_container)
-
-
-class TestFrozenNDArray(CheckImmutable, CheckStringMixin):
-    mutable_methods = ("put", "itemset", "fill")
-
-    def setup_method(self, _):
-        self.lst = [3, 5, 7, -2]
-        self.klass = FrozenNDArray
-
-        with warnings.catch_warnings(record=True):
-            warnings.simplefilter("ignore", FutureWarning)
-
-            self.container = FrozenNDArray(self.lst)
-            self.unicode_container = FrozenNDArray(["\u05d0", "\u05d1", "c"])
-
-    def test_constructor_warns(self):
-        # see gh-9031
-        with tm.assert_produces_warning(FutureWarning):
-            FrozenNDArray([1, 2, 3])
-
-    def test_tricky_container_to_bytes(self):
-        bytes(self.unicode_container)
-
-    def test_shallow_copying(self):
-        original = self.container.copy()
-        assert isinstance(self.container.view(), FrozenNDArray)
-        assert not isinstance(self.container.view(np.ndarray), FrozenNDArray)
-        assert self.container.view() is not self.container
-        tm.assert_numpy_array_equal(self.container, original)
-
-        # Shallow copy should be the same too
-        assert isinstance(self.container._shallow_copy(), FrozenNDArray)
-
-        # setting should not be allowed
-        def testit(container):
-            container[0] = 16
-
-        self.check_mutable_error(testit, self.container)
-
-    def test_values(self):
-        original = self.container.view(np.ndarray).copy()
-        n = original[0] + 15
-
-        vals = self.container.values()
-        tm.assert_numpy_array_equal(original, vals)
-
-        assert original is not vals
-        vals[0] = n
-
-        assert isinstance(self.container, FrozenNDArray)
-        tm.assert_numpy_array_equal(self.container.values(), original)
-        assert vals[0] == n
-
-    def test_searchsorted(self):
-        expected = 2
-        assert self.container.searchsorted(7) == expected
-
-        with tm.assert_produces_warning(FutureWarning):
-            assert self.container.searchsorted(v=7) == expected
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index f246307e63e3b..1b504ce99604d 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 import re
 
 import numpy as np
@@ -8,9 +8,9 @@
 
 import pandas as pd
 from pandas import Float64Index, Index, Int64Index, Series, UInt64Index
+import pandas._testing as tm
 from pandas.api.types import pandas_dtype
 from pandas.tests.indexes.common import Base
-import pandas.util.testing as tm
 
 
 class Numeric(Base):
@@ -87,32 +87,42 @@ def test_where(self, klass):
         result = i.where(klass(cond))
         tm.assert_index_equal(result, expected)
 
-    def test_insert(self):
+    def test_insert(self, nulls_fixture):
         # GH 18295 (test missing)
-        expected = Float64Index([0, np.nan, 1, 2, 3, 4])
-        for na in (np.nan, pd.NaT, None):
-            result = self.create_index().insert(1, na)
-            tm.assert_index_equal(result, expected)
+        index = self.create_index()
+        expected = Float64Index([index[0], np.nan] + list(index[1:]))
+        result = index.insert(1, nulls_fixture)
+        tm.assert_index_equal(result, expected)
 
 
 class TestFloat64Index(Numeric):
     _holder = Float64Index
 
-    def setup_method(self, method):
-        self.indices = dict(
-            mixed=Float64Index([1.5, 2, 3, 4, 5]),
-            float=Float64Index(np.arange(5) * 2.5),
-            mixed_dec=Float64Index([5, 4, 3, 2, 1.5]),
-            float_dec=Float64Index(np.arange(4, -1, -1) * 2.5),
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[
+            [1.5, 2, 3, 4, 5],
+            [0.0, 2.5, 5.0, 7.5, 10.0],
+            [5, 4, 3, 2, 1.5],
+            [10.0, 7.5, 5.0, 2.5, 0.0],
+        ],
+        ids=["mixed", "float", "mixed_dec", "float_dec"],
+    )
+    def indices(self, request):
+        return Float64Index(request.param)
+
+    @pytest.fixture
+    def mixed_index(self):
+        return Float64Index([1.5, 2, 3, 4, 5])
+
+    @pytest.fixture
+    def float_index(self):
+        return Float64Index([0.0, 2.5, 5.0, 7.5, 10.0])
 
     def create_index(self):
         return Float64Index(np.arange(5, dtype="float64"))
 
-    def test_repr_roundtrip(self):
-        for ind in (self.mixed, self.float):
-            tm.assert_index_equal(eval(repr(ind)), ind)
+    def test_repr_roundtrip(self, indices):
+        tm.assert_index_equal(eval(repr(indices)), indices)
 
     def check_is_index(self, i):
         assert isinstance(i, Index)
@@ -157,18 +167,35 @@ def test_constructor(self):
         result = Index(np.array([np.nan]))
         assert pd.isna(result.values).all()
 
+    @pytest.mark.parametrize(
+        "index, dtype",
+        [
+            (pd.Int64Index, "float64"),
+            (pd.UInt64Index, "categorical"),
+            (pd.Float64Index, "datetime64"),
+            (pd.RangeIndex, "float64"),
+        ],
+    )
+    def test_invalid_dtype(self, index, dtype):
+        # GH 29539
+        with pytest.raises(
+            ValueError,
+            match=rf"Incorrect `dtype` passed: expected \w+(?: \w+)?, received {dtype}",
+        ):
+            index([1, 2, 3], dtype=dtype)
+
     def test_constructor_invalid(self):
 
         # invalid
         msg = (
-            r"Float64Index\(\.\.\.\) must be called with a collection of"
-            r" some kind, 0\.0 was passed"
+            r"Float64Index\(\.\.\.\) must be called with a collection of "
+            r"some kind, 0\.0 was passed"
         )
         with pytest.raises(TypeError, match=msg):
             Float64Index(0.0)
         msg = (
-            "String dtype not supported, you may need to explicitly cast to"
-            " a numeric type"
+            "String dtype not supported, "
+            "you may need to explicitly cast to a numeric type"
         )
         with pytest.raises(TypeError, match=msg):
             Float64Index(["a", "b", 0.0])
@@ -176,30 +203,32 @@ def test_constructor_invalid(self):
         with pytest.raises(TypeError, match=msg):
             Float64Index([Timestamp("20130101")])
 
-    def test_constructor_coerce(self):
+    def test_constructor_coerce(self, mixed_index, float_index):
 
-        self.check_coerce(self.mixed, Index([1.5, 2, 3, 4, 5]))
-        self.check_coerce(self.float, Index(np.arange(5) * 2.5))
-        self.check_coerce(self.float, Index(np.array(np.arange(5) * 2.5, dtype=object)))
+        self.check_coerce(mixed_index, Index([1.5, 2, 3, 4, 5]))
+        self.check_coerce(float_index, Index(np.arange(5) * 2.5))
+        self.check_coerce(
+            float_index, Index(np.array(np.arange(5) * 2.5, dtype=object))
+        )
 
-    def test_constructor_explicit(self):
+    def test_constructor_explicit(self, mixed_index, float_index):
 
         # these don't auto convert
         self.check_coerce(
-            self.float, Index((np.arange(5) * 2.5), dtype=object), is_float_index=False
+            float_index, Index((np.arange(5) * 2.5), dtype=object), is_float_index=False
         )
         self.check_coerce(
-            self.mixed, Index([1.5, 2, 3, 4, 5], dtype=object), is_float_index=False
+            mixed_index, Index([1.5, 2, 3, 4, 5], dtype=object), is_float_index=False
         )
 
-    def test_astype(self):
+    def test_astype(self, mixed_index, float_index):
 
-        result = self.float.astype(object)
-        assert result.equals(self.float)
-        assert self.float.equals(result)
+        result = float_index.astype(object)
+        assert result.equals(float_index)
+        assert float_index.equals(result)
         self.check_is_index(result)
 
-        i = self.mixed.copy()
+        i = mixed_index.copy()
         i.name = "foo"
         result = i.astype(object)
         assert result.equals(i)
@@ -233,19 +262,26 @@ def test_astype(self):
         # invalid
         for dtype in ["M8[ns]", "m8[ns]"]:
             msg = (
-                "Cannot convert Float64Index to dtype {}; integer values"
-                " are required for conversion"
-            ).format(pandas_dtype(dtype))
+                f"Cannot convert Float64Index to dtype {pandas_dtype(dtype)}; "
+                f"integer values are required for conversion"
+            )
             with pytest.raises(TypeError, match=re.escape(msg)):
                 i.astype(dtype)
 
         # GH 13149
         for dtype in ["int16", "int32", "int64"]:
             i = Float64Index([0, 1.1, np.NAN])
-            msg = "Cannot convert NA to integer"
+            msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
             with pytest.raises(ValueError, match=msg):
                 i.astype(dtype)
 
+    def test_cannot_cast_inf_to_int(self):
+        idx = pd.Float64Index([1, 2, np.inf])
+
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(ValueError, match=msg):
+            idx.astype(int)
+
     def test_type_coercion_fail(self, any_int_dtype):
         # see gh-15832
         msg = "Trying to coerce float values to integers"
@@ -349,13 +385,56 @@ def test_get_loc_missing_nan(self):
         # GH 8569
         idx = Float64Index([1, 2])
         assert idx.get_loc(1) == 0
-        with pytest.raises(KeyError, match=r"^3\.0$"):
+        with pytest.raises(KeyError, match=r"^3$"):
             idx.get_loc(3)
         with pytest.raises(KeyError, match="^nan$"):
             idx.get_loc(np.nan)
-        with pytest.raises(KeyError, match=r"^\[nan\]$"):
+        with pytest.raises(TypeError, match=r"'\[nan\]' is an invalid key"):
+            # listlike/non-hashable raises TypeError
             idx.get_loc([np.nan])
 
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            pd.date_range("2016-01-01", periods=3),
+            pd.timedelta_range("1 Day", periods=3),
+        ],
+    )
+    def test_lookups_datetimelike_values(self, vals):
+        # If we have datetime64 or timedelta64 values, make sure they are
+        #  wrappped correctly  GH#31163
+        ser = pd.Series(vals, index=range(3, 6))
+        ser.index = ser.index.astype("float64")
+
+        expected = vals[1]
+
+        result = ser.index.get_value(ser, 4.0)
+        assert isinstance(result, type(expected)) and result == expected
+        result = ser.index.get_value(ser, 4)
+        assert isinstance(result, type(expected)) and result == expected
+
+        result = ser[4.0]
+        assert isinstance(result, type(expected)) and result == expected
+        result = ser[4]
+        assert isinstance(result, type(expected)) and result == expected
+
+        result = ser.loc[4.0]
+        assert isinstance(result, type(expected)) and result == expected
+        result = ser.loc[4]
+        assert isinstance(result, type(expected)) and result == expected
+
+        result = ser.at[4.0]
+        assert isinstance(result, type(expected)) and result == expected
+        # GH#31329 .at[4] should cast to 4.0, matching .loc behavior
+        result = ser.at[4]
+        assert isinstance(result, type(expected)) and result == expected
+
+        result = ser.iloc[1]
+        assert isinstance(result, type(expected)) and result == expected
+
+        result = ser.iat[1]
+        assert isinstance(result, type(expected)) and result == expected
+
     def test_contains_nans(self):
         i = Float64Index([1.0, 2.0, np.nan])
         assert np.nan in i
@@ -444,11 +523,12 @@ def test_view(self):
         tm.assert_index_equal(i, self._holder(i_view, name="Foo"))
 
     def test_is_monotonic(self):
-        assert self.index.is_monotonic is True
-        assert self.index.is_monotonic_increasing is True
-        assert self.index._is_strictly_monotonic_increasing is True
-        assert self.index.is_monotonic_decreasing is False
-        assert self.index._is_strictly_monotonic_decreasing is False
+        index = self._holder([1, 2, 3, 4])
+        assert index.is_monotonic is True
+        assert index.is_monotonic_increasing is True
+        assert index._is_strictly_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is False
+        assert index._is_strictly_monotonic_decreasing is False
 
         index = self._holder([4, 3, 2, 1])
         assert index.is_monotonic is False
@@ -483,23 +563,22 @@ def test_logical_compat(self):
         assert idx.any() == idx.values.any()
 
     def test_identical(self):
-        i = Index(self.index.copy())
-        assert i.identical(self.index)
+        index = self.create_index()
+        i = Index(index.copy())
+        assert i.identical(index)
 
         same_values_different_type = Index(i, dtype=object)
         assert not i.identical(same_values_different_type)
 
-        i = self.index.copy(dtype=object)
+        i = index.copy(dtype=object)
         i = i.rename("foo")
         same_values = Index(i, dtype=object)
         assert same_values.identical(i)
 
-        assert not i.identical(self.index)
+        assert not i.identical(index)
         assert Index(same_values, name="foo", dtype=object).identical(i)
 
-        assert not self.index.copy(dtype=object).identical(
-            self.index.copy(dtype=self._dtype)
-        )
+        assert not index.copy(dtype=object).identical(index.copy(dtype=self._dtype))
 
     def test_join_non_unique(self):
         left = Index([4, 4, 3, 3])
@@ -515,29 +594,27 @@ def test_join_non_unique(self):
         exp_ridx = np.array([2, 3, 2, 3, 0, 1, 0, 1], dtype=np.intp)
         tm.assert_numpy_array_equal(ridx, exp_ridx)
 
-    @pytest.mark.parametrize("kind", ["outer", "inner", "left", "right"])
-    def test_join_self(self, kind):
-        joined = self.index.join(self.index, how=kind)
-        assert self.index is joined
+    def test_join_self(self, join_type):
+        index = self.create_index()
+        joined = index.join(index, how=join_type)
+        assert index is joined
 
     def test_union_noncomparable(self):
-        from datetime import datetime, timedelta
-
         # corner case, non-Int64Index
-        now = datetime.now()
-        other = Index([now + timedelta(i) for i in range(4)], dtype=object)
-        result = self.index.union(other)
-        expected = Index(np.concatenate((self.index, other)))
+        index = self.create_index()
+        other = Index([datetime.now() + timedelta(i) for i in range(4)], dtype=object)
+        result = index.union(other)
+        expected = Index(np.concatenate((index, other)))
         tm.assert_index_equal(result, expected)
 
-        result = other.union(self.index)
-        expected = Index(np.concatenate((other, self.index)))
+        result = other.union(index)
+        expected = Index(np.concatenate((other, index)))
         tm.assert_index_equal(result, expected)
 
     def test_cant_or_shouldnt_cast(self):
         msg = (
-            "String dtype not supported, you may need to explicitly cast to"
-            " a numeric type"
+            "String dtype not supported, "
+            "you may need to explicitly cast to a numeric type"
         )
         # can't
         data = ["foo", "bar", "baz"]
@@ -550,10 +627,12 @@ def test_cant_or_shouldnt_cast(self):
             self._holder(data)
 
     def test_view_index(self):
-        self.index.view(Index)
+        index = self.create_index()
+        index.view(Index)
 
     def test_prevent_casting(self):
-        result = self.index.astype("O")
+        index = self.create_index()
+        result = index.astype("O")
         assert result.dtype == np.object_
 
     def test_take_preserve_name(self):
@@ -569,7 +648,7 @@ def test_take_fill_value(self):
         tm.assert_index_equal(result, expected)
 
         name = self._holder.__name__
-        msg = "Unable to fill values because {name} cannot contain NA".format(name=name)
+        msg = f"Unable to fill values because {name} cannot contain NA"
 
         # fill_value=True
         with pytest.raises(ValueError, match=msg):
@@ -597,15 +676,15 @@ class TestInt64Index(NumericInt):
     _dtype = "int64"
     _holder = Int64Index
 
-    def setup_method(self, method):
-        self.indices = dict(
-            index=Int64Index(np.arange(0, 20, 2)),
-            index_dec=Int64Index(np.arange(19, -1, -1)),
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[range(0, 20, 2), range(19, -1, -1)], ids=["index_inc", "index_dec"]
+    )
+    def indices(self, request):
+        return Int64Index(request.param)
 
     def create_index(self):
-        return Int64Index(np.arange(5, dtype="int64"))
+        # return Int64Index(np.arange(5, dtype="int64"))
+        return Int64Index(range(0, 20, 2))
 
     def test_constructor(self):
         # pass list, coerce fine
@@ -619,16 +698,16 @@ def test_constructor(self):
 
         # scalar raise Exception
         msg = (
-            r"Int64Index\(\.\.\.\) must be called with a collection of some"
-            " kind, 5 was passed"
+            r"Int64Index\(\.\.\.\) must be called with a collection of some "
+            "kind, 5 was passed"
         )
         with pytest.raises(TypeError, match=msg):
             Int64Index(5)
 
         # copy
-        arr = self.index.values
+        arr = index.values
         new_index = Int64Index(arr, copy=True)
-        tm.assert_index_equal(new_index, self.index)
+        tm.assert_index_equal(new_index, index)
         val = arr[0] + 3000
 
         # this should not change index
@@ -684,39 +763,48 @@ def test_coerce_list(self):
         assert isinstance(arr, Index)
 
     def test_get_indexer(self):
+        index = self.create_index()
         target = Int64Index(np.arange(10))
-        indexer = self.index.get_indexer(target)
+        indexer = index.get_indexer(target)
         expected = np.array([0, -1, 1, -1, 2, -1, 3, -1, 4, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
         target = Int64Index(np.arange(10))
-        indexer = self.index.get_indexer(target, method="pad")
+        indexer = index.get_indexer(target, method="pad")
         expected = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
         target = Int64Index(np.arange(10))
-        indexer = self.index.get_indexer(target, method="backfill")
+        indexer = index.get_indexer(target, method="backfill")
         expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
+    def test_get_indexer_nan(self):
+        # GH 7820
+        result = Index([1, 2, np.nan]).get_indexer([np.nan])
+        expected = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_intersection(self):
+        index = self.create_index()
         other = Index([1, 2, 3, 4, 5])
-        result = self.index.intersection(other)
-        expected = Index(np.sort(np.intersect1d(self.index.values, other.values)))
+        result = index.intersection(other)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
         tm.assert_index_equal(result, expected)
 
-        result = other.intersection(self.index)
+        result = other.intersection(index)
         expected = Index(
-            np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))
+            np.sort(np.asarray(np.intersect1d(index.values, other.values)))
         )
         tm.assert_index_equal(result, expected)
 
     def test_join_inner(self):
+        index = self.create_index()
         other = Int64Index([7, 12, 25, 1, 2, 5])
         other_mono = Int64Index([1, 2, 5, 7, 12, 25])
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="inner", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
 
         # no guarantee of sortedness, so sort for comparison purposes
         ind = res.argsort()
@@ -734,9 +822,9 @@ def test_join_inner(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="inner", return_indexers=True)
+        res, lidx, ridx = index.join(other_mono, how="inner", return_indexers=True)
 
-        res2 = self.index.intersection(other_mono)
+        res2 = index.intersection(other_mono)
         tm.assert_index_equal(res, res2)
 
         elidx = np.array([1, 6], dtype=np.intp)
@@ -747,12 +835,13 @@ def test_join_inner(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_left(self):
+        index = self.create_index()
         other = Int64Index([7, 12, 25, 1, 2, 5])
         other_mono = Int64Index([1, 2, 5, 7, 12, 25])
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="left", return_indexers=True)
-        eres = self.index
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
+        eres = index
         eridx = np.array([-1, 4, -1, -1, -1, -1, 1, -1, -1, -1], dtype=np.intp)
 
         assert isinstance(res, Int64Index)
@@ -761,7 +850,7 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="left", return_indexers=True)
+        res, lidx, ridx = index.join(other_mono, how="left", return_indexers=True)
         eridx = np.array([-1, 1, -1, -1, -1, -1, 4, -1, -1, -1], dtype=np.intp)
         assert isinstance(res, Int64Index)
         tm.assert_index_equal(res, eres)
@@ -780,11 +869,12 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_right(self):
+        index = self.create_index()
         other = Int64Index([7, 12, 25, 1, 2, 5])
         other_mono = Int64Index([1, 2, 5, 7, 12, 25])
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="right", return_indexers=True)
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
         eres = other
         elidx = np.array([-1, 6, -1, -1, 1, -1], dtype=np.intp)
 
@@ -794,7 +884,7 @@ def test_join_right(self):
         assert ridx is None
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="right", return_indexers=True)
+        res, lidx, ridx = index.join(other_mono, how="right", return_indexers=True)
         eres = other_mono
         elidx = np.array([-1, 1, -1, -1, 6, -1], dtype=np.intp)
         assert isinstance(other, Int64Index)
@@ -814,40 +904,42 @@ def test_join_right(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_non_int_index(self):
+        index = self.create_index()
         other = Index([3, 6, 7, 8, 10], dtype=object)
 
-        outer = self.index.join(other, how="outer")
-        outer2 = other.join(self.index, how="outer")
+        outer = index.join(other, how="outer")
+        outer2 = other.join(index, how="outer")
         expected = Index([0, 2, 3, 4, 6, 7, 8, 10, 12, 14, 16, 18])
         tm.assert_index_equal(outer, outer2)
         tm.assert_index_equal(outer, expected)
 
-        inner = self.index.join(other, how="inner")
-        inner2 = other.join(self.index, how="inner")
+        inner = index.join(other, how="inner")
+        inner2 = other.join(index, how="inner")
         expected = Index([6, 8, 10])
         tm.assert_index_equal(inner, inner2)
         tm.assert_index_equal(inner, expected)
 
-        left = self.index.join(other, how="left")
-        tm.assert_index_equal(left, self.index.astype(object))
+        left = index.join(other, how="left")
+        tm.assert_index_equal(left, index.astype(object))
 
-        left2 = other.join(self.index, how="left")
+        left2 = other.join(index, how="left")
         tm.assert_index_equal(left2, other)
 
-        right = self.index.join(other, how="right")
+        right = index.join(other, how="right")
         tm.assert_index_equal(right, other)
 
-        right2 = other.join(self.index, how="right")
-        tm.assert_index_equal(right2, self.index.astype(object))
+        right2 = other.join(index, how="right")
+        tm.assert_index_equal(right2, index.astype(object))
 
     def test_join_outer(self):
+        index = self.create_index()
         other = Int64Index([7, 12, 25, 1, 2, 5])
         other_mono = Int64Index([1, 2, 5, 7, 12, 25])
 
         # not monotonic
         # guarantee of sortedness
-        res, lidx, ridx = self.index.join(other, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other, how="outer")
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         eres = Int64Index([0, 1, 2, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 25])
@@ -862,8 +954,8 @@ def test_join_outer(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other_mono, how="outer")
+        res, lidx, ridx = index.join(other_mono, how="outer", return_indexers=True)
+        noidx_res = index.join(other_mono, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         elidx = np.array([0, -1, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, 9, -1], dtype=np.intp)
@@ -881,14 +973,24 @@ class TestUInt64Index(NumericInt):
     _dtype = "uint64"
     _holder = UInt64Index
 
-    def setup_method(self, method):
-        vals = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
-        self.indices = dict(
-            index=UInt64Index(vals), index_dec=UInt64Index(reversed(vals))
-        )
-        self.setup_indices()
+    @pytest.fixture(
+        params=[
+            [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25],
+            [2 ** 63 + 25, 2 ** 63 + 20, 2 ** 63 + 15, 2 ** 63 + 10, 2 ** 63],
+        ],
+        ids=["index_inc", "index_dec"],
+    )
+    def indices(self, request):
+        return UInt64Index(request.param)
+
+    @pytest.fixture
+    def index_large(self):
+        # large values used in TestUInt64Index where no compat needed with Int64/Float64
+        large = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
+        return UInt64Index(large)
 
     def create_index(self):
+        # compat with shared Int64/Float64 tests; use index_large for UInt64 only tests
         return UInt64Index(np.arange(5, dtype="uint64"))
 
     def test_constructor(self):
@@ -908,42 +1010,47 @@ def test_constructor(self):
         res = Index(np.array([-1, 2 ** 63], dtype=object))
         tm.assert_index_equal(res, idx)
 
-    def test_get_indexer(self):
+        # https://github.com/pandas-dev/pandas/issues/29526
+        idx = UInt64Index([1, 2 ** 63 + 1], dtype=np.uint64)
+        res = Index([1, 2 ** 63 + 1], dtype=np.uint64)
+        tm.assert_index_equal(res, idx)
+
+    def test_get_indexer(self, index_large):
         target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
-        indexer = self.index.get_indexer(target)
+        indexer = index_large.get_indexer(target)
         expected = np.array([0, -1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
         target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
-        indexer = self.index.get_indexer(target, method="pad")
+        indexer = index_large.get_indexer(target, method="pad")
         expected = np.array([0, 0, 1, 2, 3, 4, 4, 4, 4, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
         target = UInt64Index(np.arange(10).astype("uint64") * 5 + 2 ** 63)
-        indexer = self.index.get_indexer(target, method="backfill")
+        indexer = index_large.get_indexer(target, method="backfill")
         expected = np.array([0, 1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
-    def test_intersection(self):
+    def test_intersection(self, index_large):
         other = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20])
-        result = self.index.intersection(other)
-        expected = Index(np.sort(np.intersect1d(self.index.values, other.values)))
+        result = index_large.intersection(other)
+        expected = Index(np.sort(np.intersect1d(index_large.values, other.values)))
         tm.assert_index_equal(result, expected)
 
-        result = other.intersection(self.index)
+        result = other.intersection(index_large)
         expected = Index(
-            np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))
+            np.sort(np.asarray(np.intersect1d(index_large.values, other.values)))
         )
         tm.assert_index_equal(result, expected)
 
-    def test_join_inner(self):
+    def test_join_inner(self, index_large):
         other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
             2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="inner", return_indexers=True)
+        res, lidx, ridx = index_large.join(other, how="inner", return_indexers=True)
 
         # no guarantee of sortedness, so sort for comparison purposes
         ind = res.argsort()
@@ -961,9 +1068,11 @@ def test_join_inner(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="inner", return_indexers=True)
+        res, lidx, ridx = index_large.join(
+            other_mono, how="inner", return_indexers=True
+        )
 
-        res2 = self.index.intersection(other_mono)
+        res2 = index_large.intersection(other_mono)
         tm.assert_index_equal(res, res2)
 
         elidx = np.array([1, 4], dtype=np.intp)
@@ -974,15 +1083,15 @@ def test_join_inner(self):
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
 
-    def test_join_left(self):
+    def test_join_left(self, index_large):
         other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
             2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="left", return_indexers=True)
-        eres = self.index
+        res, lidx, ridx = index_large.join(other, how="left", return_indexers=True)
+        eres = index_large
         eridx = np.array([-1, 5, -1, -1, 2], dtype=np.intp)
 
         assert isinstance(res, UInt64Index)
@@ -991,7 +1100,7 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="left", return_indexers=True)
+        res, lidx, ridx = index_large.join(other_mono, how="left", return_indexers=True)
         eridx = np.array([-1, 3, -1, -1, 5], dtype=np.intp)
 
         assert isinstance(res, UInt64Index)
@@ -1013,14 +1122,14 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
 
-    def test_join_right(self):
+    def test_join_right(self, index_large):
         other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
             2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
         )
 
         # not monotonic
-        res, lidx, ridx = self.index.join(other, how="right", return_indexers=True)
+        res, lidx, ridx = index_large.join(other, how="right", return_indexers=True)
         eres = other
         elidx = np.array([-1, -1, 4, -1, -1, 1], dtype=np.intp)
 
@@ -1030,7 +1139,9 @@ def test_join_right(self):
         assert ridx is None
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="right", return_indexers=True)
+        res, lidx, ridx = index_large.join(
+            other_mono, how="right", return_indexers=True
+        )
         eres = other_mono
         elidx = np.array([-1, -1, -1, 1, -1, 4], dtype=np.intp)
 
@@ -1053,38 +1164,38 @@ def test_join_right(self):
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
 
-    def test_join_non_int_index(self):
+    def test_join_non_int_index(self, index_large):
         other = Index(
             2 ** 63 + np.array([1, 5, 7, 10, 20], dtype="uint64"), dtype=object
         )
 
-        outer = self.index.join(other, how="outer")
-        outer2 = other.join(self.index, how="outer")
+        outer = index_large.join(other, how="outer")
+        outer2 = other.join(index_large, how="outer")
         expected = Index(
             2 ** 63 + np.array([0, 1, 5, 7, 10, 15, 20, 25], dtype="uint64")
         )
         tm.assert_index_equal(outer, outer2)
         tm.assert_index_equal(outer, expected)
 
-        inner = self.index.join(other, how="inner")
-        inner2 = other.join(self.index, how="inner")
+        inner = index_large.join(other, how="inner")
+        inner2 = other.join(index_large, how="inner")
         expected = Index(2 ** 63 + np.array([10, 20], dtype="uint64"))
         tm.assert_index_equal(inner, inner2)
         tm.assert_index_equal(inner, expected)
 
-        left = self.index.join(other, how="left")
-        tm.assert_index_equal(left, self.index.astype(object))
+        left = index_large.join(other, how="left")
+        tm.assert_index_equal(left, index_large.astype(object))
 
-        left2 = other.join(self.index, how="left")
+        left2 = other.join(index_large, how="left")
         tm.assert_index_equal(left2, other)
 
-        right = self.index.join(other, how="right")
+        right = index_large.join(other, how="right")
         tm.assert_index_equal(right, other)
 
-        right2 = other.join(self.index, how="right")
-        tm.assert_index_equal(right2, self.index.astype(object))
+        right2 = other.join(index_large, how="right")
+        tm.assert_index_equal(right2, index_large.astype(object))
 
-    def test_join_outer(self):
+    def test_join_outer(self, index_large):
         other = UInt64Index(2 ** 63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
         other_mono = UInt64Index(
             2 ** 63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64")
@@ -1092,8 +1203,8 @@ def test_join_outer(self):
 
         # not monotonic
         # guarantee of sortedness
-        res, lidx, ridx = self.index.join(other, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other, how="outer")
+        res, lidx, ridx = index_large.join(other, how="outer", return_indexers=True)
+        noidx_res = index_large.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         eres = UInt64Index(
@@ -1108,8 +1219,10 @@ def test_join_outer(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
-        res, lidx, ridx = self.index.join(other_mono, how="outer", return_indexers=True)
-        noidx_res = self.index.join(other_mono, how="outer")
+        res, lidx, ridx = index_large.join(
+            other_mono, how="outer", return_indexers=True
+        )
+        noidx_res = index_large.join(other_mono, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
         elidx = np.array([0, -1, -1, -1, 1, -1, 2, 3, 4], dtype=np.intp)
@@ -1145,3 +1258,29 @@ def test_range_float_union_dtype():
 
     result = other.union(index)
     tm.assert_index_equal(result, expected)
+
+
+def test_uint_index_does_not_convert_to_float64():
+    # https://github.com/pandas-dev/pandas/issues/28279
+    # https://github.com/pandas-dev/pandas/issues/28023
+    series = pd.Series(
+        [0, 1, 2, 3, 4, 5],
+        index=[
+            7606741985629028552,
+            17876870360202815256,
+            17876870360202815256,
+            13106359306506049338,
+            8991270399732411471,
+            8991270399732411472,
+        ],
+    )
+
+    result = series.loc[[7606741985629028552, 17876870360202815256]]
+
+    expected = UInt64Index(
+        [7606741985629028552, 17876870360202815256, 17876870360202815256],
+        dtype="uint64",
+    )
+    tm.assert_index_equal(result.index, expected)
+
+    tm.assert_equal(result, series[:3])
diff --git a/pandas/tests/indexes/test_numpy_compat.py b/pandas/tests/indexes/test_numpy_compat.py
index 645ad19ea4cc9..8b62de7030096 100644
--- a/pandas/tests/indexes/test_numpy_compat.py
+++ b/pandas/tests/indexes/test_numpy_compat.py
@@ -6,12 +6,14 @@
     Float64Index,
     Index,
     Int64Index,
+    PeriodIndex,
     TimedeltaIndex,
     UInt64Index,
     _np_version_under1p17,
+    _np_version_under1p18,
 )
+import pandas._testing as tm
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
-from pandas.util import testing as tm
 
 
 @pytest.mark.parametrize(
@@ -44,7 +46,7 @@
 )
 def test_numpy_ufuncs_basic(indices, func):
     # test ufuncs of numpy, see:
-    # http://docs.scipy.org/doc/numpy/reference/ufuncs.html
+    # https://docs.scipy.org/doc/numpy/reference/ufuncs.html
 
     idx = indices
     if isinstance(idx, DatetimeIndexOpsMixin):
@@ -75,23 +77,30 @@ def test_numpy_ufuncs_basic(indices, func):
 )
 def test_numpy_ufuncs_other(indices, func):
     # test ufuncs of numpy, see:
-    # http://docs.scipy.org/doc/numpy/reference/ufuncs.html
+    # https://docs.scipy.org/doc/numpy/reference/ufuncs.html
 
     idx = indices
     if isinstance(idx, (DatetimeIndex, TimedeltaIndex)):
+        if isinstance(idx, DatetimeIndex) and idx.tz is not None:
+            if func in [np.isfinite, np.isnan, np.isinf]:
+                pytest.xfail(reason="__array_ufunc__ is not defined")
 
-        # ok under numpy >= 1.17
-        if not _np_version_under1p17 and func in [np.isfinite]:
+        if not _np_version_under1p18 and func in [np.isfinite, np.isinf, np.isnan]:
+            # numpy 1.18(dev) changed isinf and isnan to not raise on dt64/tfd64
+            result = func(idx)
+            assert isinstance(result, np.ndarray)
+
+        elif not _np_version_under1p17 and func in [np.isfinite]:
+            # ok under numpy >= 1.17
             # Results in bool array
             result = func(idx)
             assert isinstance(result, np.ndarray)
-            assert not isinstance(result, Index)
         else:
             # raise TypeError or ValueError (PeriodIndex)
             with pytest.raises(Exception):
                 func(idx)
 
-    elif isinstance(idx, DatetimeIndexOpsMixin):
+    elif isinstance(idx, PeriodIndex):
         # raise TypeError or ValueError (PeriodIndex)
         with pytest.raises(Exception):
             func(idx)
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index b3850f7a4e09e..abfa413d56655 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -2,7 +2,6 @@
 The tests in this package are to ensure the proper resultant dtypes of
 set operations.
 """
-from collections import OrderedDict
 import itertools as it
 
 import numpy as np
@@ -12,29 +11,24 @@
 
 import pandas as pd
 from pandas import Float64Index, Int64Index, RangeIndex, UInt64Index
+import pandas._testing as tm
 from pandas.api.types import pandas_dtype
-from pandas.tests.indexes.conftest import indices_list
-import pandas.util.testing as tm
+from pandas.tests.indexes.conftest import indices_dict
 
-COMPATIBLE_INCONSISTENT_PAIRS = OrderedDict(
-    [
-        ((Int64Index, RangeIndex), (tm.makeIntIndex, tm.makeRangeIndex)),
-        ((Float64Index, Int64Index), (tm.makeFloatIndex, tm.makeIntIndex)),
-        ((Float64Index, RangeIndex), (tm.makeFloatIndex, tm.makeIntIndex)),
-        ((Float64Index, UInt64Index), (tm.makeFloatIndex, tm.makeUIntIndex)),
-    ]
-)
+COMPATIBLE_INCONSISTENT_PAIRS = {
+    (Int64Index, RangeIndex): (tm.makeIntIndex, tm.makeRangeIndex),
+    (Float64Index, Int64Index): (tm.makeFloatIndex, tm.makeIntIndex),
+    (Float64Index, RangeIndex): (tm.makeFloatIndex, tm.makeIntIndex),
+    (Float64Index, UInt64Index): (tm.makeFloatIndex, tm.makeUIntIndex),
+}
 
 
-@pytest.fixture(
-    params=list(it.combinations(indices_list, 2)),
-    ids=lambda x: type(x[0]).__name__ + type(x[1]).__name__,
-)
+@pytest.fixture(params=it.combinations(indices_dict, 2), ids="-".join)
 def index_pair(request):
     """
     Create all combinations of 2 index types.
     """
-    return request.param
+    return indices_dict[request.param[0]], indices_dict[request.param[1]]
 
 
 def test_union_same_types(indices):
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
deleted file mode 100644
index 4544657f79af7..0000000000000
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ /dev/null
@@ -1,292 +0,0 @@
-from datetime import timedelta
-
-import numpy as np
-import pytest
-
-from pandas.errors import NullFrequencyError
-
-import pandas as pd
-from pandas import Timedelta, TimedeltaIndex, timedelta_range
-import pandas.util.testing as tm
-
-
-@pytest.fixture(
-    params=[
-        pd.offsets.Hour(2),
-        timedelta(hours=2),
-        np.timedelta64(2, "h"),
-        Timedelta(hours=2),
-    ],
-    ids=str,
-)
-def delta(request):
-    # Several ways of representing two hours
-    return request.param
-
-
-@pytest.fixture(params=["B", "D"])
-def freq(request):
-    return request.param
-
-
-class TestTimedeltaIndexArithmetic:
-    # Addition and Subtraction Operations
-
-    # -------------------------------------------------------------
-    # TimedeltaIndex.shift is used by __add__/__sub__
-
-    def test_tdi_shift_empty(self):
-        # GH#9903
-        idx = pd.TimedeltaIndex([], name="xxx")
-        tm.assert_index_equal(idx.shift(0, freq="H"), idx)
-        tm.assert_index_equal(idx.shift(3, freq="H"), idx)
-
-    def test_tdi_shift_hours(self):
-        # GH#9903
-        idx = pd.TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
-        tm.assert_index_equal(idx.shift(0, freq="H"), idx)
-        exp = pd.TimedeltaIndex(["8 hours", "9 hours", "12 hours"], name="xxx")
-        tm.assert_index_equal(idx.shift(3, freq="H"), exp)
-        exp = pd.TimedeltaIndex(["2 hours", "3 hours", "6 hours"], name="xxx")
-        tm.assert_index_equal(idx.shift(-3, freq="H"), exp)
-
-    def test_tdi_shift_minutes(self):
-        # GH#9903
-        idx = pd.TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
-        tm.assert_index_equal(idx.shift(0, freq="T"), idx)
-        exp = pd.TimedeltaIndex(["05:03:00", "06:03:00", "9:03:00"], name="xxx")
-        tm.assert_index_equal(idx.shift(3, freq="T"), exp)
-        exp = pd.TimedeltaIndex(["04:57:00", "05:57:00", "8:57:00"], name="xxx")
-        tm.assert_index_equal(idx.shift(-3, freq="T"), exp)
-
-    def test_tdi_shift_int(self):
-        # GH#8083
-        trange = pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
-        result = trange.shift(1)
-        expected = TimedeltaIndex(
-            [
-                "1 days 01:00:00",
-                "2 days 01:00:00",
-                "3 days 01:00:00",
-                "4 days 01:00:00",
-                "5 days 01:00:00",
-            ],
-            freq="D",
-        )
-        tm.assert_index_equal(result, expected)
-
-    def test_tdi_shift_nonstandard_freq(self):
-        # GH#8083
-        trange = pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
-        result = trange.shift(3, freq="2D 1s")
-        expected = TimedeltaIndex(
-            [
-                "6 days 01:00:03",
-                "7 days 01:00:03",
-                "8 days 01:00:03",
-                "9 days 01:00:03",
-                "10 days 01:00:03",
-            ],
-            freq="D",
-        )
-        tm.assert_index_equal(result, expected)
-
-    def test_shift_no_freq(self):
-        # GH#19147
-        tdi = TimedeltaIndex(["1 days 01:00:00", "2 days 01:00:00"], freq=None)
-        with pytest.raises(NullFrequencyError):
-            tdi.shift(2)
-
-    # -------------------------------------------------------------
-    # Binary operations TimedeltaIndex and integer
-
-    def test_tdi_add_int(self, one):
-        # Variants of `one` for #19012
-        rng = timedelta_range("1 days 09:00:00", freq="H", periods=10)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng + one
-        expected = timedelta_range("1 days 10:00:00", freq="H", periods=10)
-        tm.assert_index_equal(result, expected)
-
-    def test_tdi_iadd_int(self, one):
-        rng = timedelta_range("1 days 09:00:00", freq="H", periods=10)
-        expected = timedelta_range("1 days 10:00:00", freq="H", periods=10)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            rng += one
-        tm.assert_index_equal(rng, expected)
-
-    def test_tdi_sub_int(self, one):
-        rng = timedelta_range("1 days 09:00:00", freq="H", periods=10)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng - one
-        expected = timedelta_range("1 days 08:00:00", freq="H", periods=10)
-        tm.assert_index_equal(result, expected)
-
-    def test_tdi_isub_int(self, one):
-        rng = timedelta_range("1 days 09:00:00", freq="H", periods=10)
-        expected = timedelta_range("1 days 08:00:00", freq="H", periods=10)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            rng -= one
-        tm.assert_index_equal(rng, expected)
-
-    # -------------------------------------------------------------
-    # __add__/__sub__ with integer arrays
-
-    @pytest.mark.parametrize("box", [np.array, pd.Index])
-    def test_tdi_add_integer_array(self, box):
-        # GH#19959
-        rng = timedelta_range("1 days 09:00:00", freq="H", periods=3)
-        other = box([4, 3, 2])
-        expected = TimedeltaIndex(["1 day 13:00:00"] * 3)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng + other
-            tm.assert_index_equal(result, expected)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = other + rng
-            tm.assert_index_equal(result, expected)
-
-    @pytest.mark.parametrize("box", [np.array, pd.Index])
-    def test_tdi_sub_integer_array(self, box):
-        # GH#19959
-        rng = timedelta_range("9H", freq="H", periods=3)
-        other = box([4, 3, 2])
-        expected = TimedeltaIndex(["5H", "7H", "9H"])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = rng - other
-            tm.assert_index_equal(result, expected)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # GH#22535
-            result = other - rng
-            tm.assert_index_equal(result, -expected)
-
-    @pytest.mark.parametrize("box", [np.array, pd.Index])
-    def test_tdi_addsub_integer_array_no_freq(self, box):
-        # GH#19959
-        tdi = TimedeltaIndex(["1 Day", "NaT", "3 Hours"])
-        other = box([14, -1, 16])
-        with pytest.raises(NullFrequencyError):
-            tdi + other
-        with pytest.raises(NullFrequencyError):
-            other + tdi
-        with pytest.raises(NullFrequencyError):
-            tdi - other
-        with pytest.raises(NullFrequencyError):
-            other - tdi
-
-    # -------------------------------------------------------------
-    # Binary operations TimedeltaIndex and timedelta-like
-    # Note: add and sub are tested in tests.test_arithmetic, in-place
-    #  tests are kept here because their behavior is Index-specific
-
-    def test_tdi_iadd_timedeltalike(self, delta):
-        # only test adding/sub offsets as + is now numeric
-        rng = timedelta_range("1 days", "10 days")
-        expected = timedelta_range("1 days 02:00:00", "10 days 02:00:00", freq="D")
-        rng += delta
-        tm.assert_index_equal(rng, expected)
-
-    def test_tdi_isub_timedeltalike(self, delta):
-        # only test adding/sub offsets as - is now numeric
-        rng = timedelta_range("1 days", "10 days")
-        expected = timedelta_range("0 days 22:00:00", "9 days 22:00:00")
-        rng -= delta
-        tm.assert_index_equal(rng, expected)
-
-    # -------------------------------------------------------------
-
-    # TODO: after #24365 this probably belongs in scalar tests
-    def test_ops_ndarray(self):
-        td = Timedelta("1 day")
-
-        # timedelta, timedelta
-        other = pd.to_timedelta(["1 day"]).values
-        expected = pd.to_timedelta(["2 days"]).values
-        tm.assert_numpy_array_equal(td + other, expected)
-        tm.assert_numpy_array_equal(other + td, expected)
-        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
-        with pytest.raises(TypeError, match=msg):
-            td + np.array([1])
-        msg = r"unsupported operand type\(s\) for \+: 'numpy.ndarray' and 'Timedelta'"
-        with pytest.raises(TypeError, match=msg):
-            np.array([1]) + td
-
-        expected = pd.to_timedelta(["0 days"]).values
-        tm.assert_numpy_array_equal(td - other, expected)
-        tm.assert_numpy_array_equal(-other + td, expected)
-        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
-        with pytest.raises(TypeError, match=msg):
-            td - np.array([1])
-        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
-        with pytest.raises(TypeError, match=msg):
-            np.array([1]) - td
-
-        expected = pd.to_timedelta(["2 days"]).values
-        tm.assert_numpy_array_equal(td * np.array([2]), expected)
-        tm.assert_numpy_array_equal(np.array([2]) * td, expected)
-        msg = (
-            "ufunc '?multiply'? cannot use operands with types"
-            r" dtype\('<m8\[ns\]'\) and dtype\('<m8\[ns\]'\)"
-        )
-        with pytest.raises(TypeError, match=msg):
-            td * other
-        with pytest.raises(TypeError, match=msg):
-            other * td
-
-        tm.assert_numpy_array_equal(td / other, np.array([1], dtype=np.float64))
-        tm.assert_numpy_array_equal(other / td, np.array([1], dtype=np.float64))
-
-        # timedelta, datetime
-        other = pd.to_datetime(["2000-01-01"]).values
-        expected = pd.to_datetime(["2000-01-02"]).values
-        tm.assert_numpy_array_equal(td + other, expected)
-        tm.assert_numpy_array_equal(other + td, expected)
-
-        expected = pd.to_datetime(["1999-12-31"]).values
-        tm.assert_numpy_array_equal(-td + other, expected)
-        tm.assert_numpy_array_equal(other - td, expected)
-
-    def test_tdi_ops_attributes(self):
-        rng = timedelta_range("2 days", periods=5, freq="2D", name="x")
-
-        result = rng + 1 * rng.freq
-        exp = timedelta_range("4 days", periods=5, freq="2D", name="x")
-        tm.assert_index_equal(result, exp)
-        assert result.freq == "2D"
-
-        result = rng - 2 * rng.freq
-        exp = timedelta_range("-2 days", periods=5, freq="2D", name="x")
-        tm.assert_index_equal(result, exp)
-        assert result.freq == "2D"
-
-        result = rng * 2
-        exp = timedelta_range("4 days", periods=5, freq="4D", name="x")
-        tm.assert_index_equal(result, exp)
-        assert result.freq == "4D"
-
-        result = rng / 2
-        exp = timedelta_range("1 days", periods=5, freq="D", name="x")
-        tm.assert_index_equal(result, exp)
-        assert result.freq == "D"
-
-        result = -rng
-        exp = timedelta_range("-2 days", periods=5, freq="-2D", name="x")
-        tm.assert_index_equal(result, exp)
-        assert result.freq == "-2D"
-
-        rng = pd.timedelta_range("-2 days", periods=5, freq="D", name="x")
-
-        result = abs(rng)
-        exp = TimedeltaIndex(
-            ["2 days", "1 days", "0 days", "1 days", "2 days"], name="x"
-        )
-        tm.assert_index_equal(result, exp)
-        assert result.freq is None
diff --git a/pandas/tests/indexes/timedeltas/test_astype.py b/pandas/tests/indexes/timedeltas/test_astype.py
index e479d93af2902..82c9d995c9c7c 100644
--- a/pandas/tests/indexes/timedeltas/test_astype.py
+++ b/pandas/tests/indexes/timedeltas/test_astype.py
@@ -13,7 +13,7 @@
     TimedeltaIndex,
     timedelta_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestTimedeltaIndex:
diff --git a/pandas/tests/indexes/timedeltas/test_construction.py b/pandas/tests/indexes/timedeltas/test_constructors.py
similarity index 83%
rename from pandas/tests/indexes/timedeltas/test_construction.py
rename to pandas/tests/indexes/timedeltas/test_constructors.py
index 2e00d558958e1..0de10b5d82171 100644
--- a/pandas/tests/indexes/timedeltas/test_construction.py
+++ b/pandas/tests/indexes/timedeltas/test_constructors.py
@@ -5,20 +5,16 @@
 
 import pandas as pd
 from pandas import Timedelta, TimedeltaIndex, timedelta_range, to_timedelta
+import pandas._testing as tm
 from pandas.core.arrays import TimedeltaArray
-import pandas.util.testing as tm
 
 
 class TestTimedeltaIndex:
-    def test_verify_integrity_deprecated(self):
-        # GH#23919
-        with tm.assert_produces_warning(FutureWarning):
-            TimedeltaIndex(["1 Day"], verify_integrity=False)
-
-    def test_range_kwargs_deprecated(self):
-        # GH#23919
-        with tm.assert_produces_warning(FutureWarning):
-            TimedeltaIndex(start="1 Day", end="3 Days", freq="D")
+    @pytest.mark.parametrize("unit", ["Y", "y", "M"])
+    def test_unit_m_y_raises(self, unit):
+        msg = "Units 'M' and 'Y' are no longer supported"
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex([1, 3, 7], unit)
 
     def test_int64_nocopy(self):
         # GH#23539 check that a copy isn't made when we pass int64 data
@@ -57,20 +53,26 @@ def test_infer_from_tdi_mismatch(self):
             # GH#23789
             TimedeltaArray(tdi, freq="D")
 
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(tdi._data, freq="D")
+
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaArray(tdi._data, freq="D")
+
     def test_dt64_data_invalid(self):
         # GH#23539
         # passing tz-aware DatetimeIndex raises, naive or ndarray[datetime64]
-        #  does not yet, but will in the future
+        #  raise as of GH#29794
         dti = pd.date_range("2016-01-01", periods=3)
 
         msg = "cannot be converted to timedelta64"
         with pytest.raises(TypeError, match=msg):
             TimedeltaIndex(dti.tz_localize("Europe/Brussels"))
 
-        with tm.assert_produces_warning(FutureWarning):
+        with pytest.raises(TypeError, match=msg):
             TimedeltaIndex(dti)
 
-        with tm.assert_produces_warning(FutureWarning):
+        with pytest.raises(TypeError, match=msg):
             TimedeltaIndex(np.asarray(dti))
 
     def test_float64_ns_rounded(self):
@@ -166,10 +168,6 @@ def test_constructor_coverage(self):
         with pytest.raises(TypeError, match=msg):
             timedelta_range(start="1 days", periods="foo", freq="D")
 
-        with pytest.raises(ValueError):
-            with tm.assert_produces_warning(FutureWarning):
-                TimedeltaIndex(start="1 days", end="10 days")
-
         with pytest.raises(TypeError):
             TimedeltaIndex("1 days")
 
@@ -190,15 +188,15 @@ def test_constructor_coverage(self):
 
         # non-conforming freq
         msg = (
-            "Inferred frequency None from passed values does not conform to"
-            " passed frequency D"
+            "Inferred frequency None from passed values does not conform to "
+            "passed frequency D"
         )
         with pytest.raises(ValueError, match=msg):
             TimedeltaIndex(["1 days", "2 days", "4 days"], freq="D")
 
         msg = (
-            "Of the four parameters: start, end, periods, and freq, exactly"
-            " three must be specified"
+            "Of the four parameters: start, end, periods, and freq, exactly "
+            "three must be specified"
         )
         with pytest.raises(ValueError, match=msg):
             timedelta_range(periods=10, freq="D")
@@ -211,18 +209,15 @@ def test_constructor_name(self):
         idx2 = TimedeltaIndex(idx, name="something else")
         assert idx2.name == "something else"
 
-    def test_constructor_no_precision_warns(self):
+    def test_constructor_no_precision_raises(self):
         # GH-24753, GH-24739
-        expected = pd.TimedeltaIndex(["2000"], dtype="timedelta64[ns]")
 
-        # we set the stacklevel for DatetimeIndex
-        with tm.assert_produces_warning(FutureWarning):
-            result = pd.TimedeltaIndex(["2000"], dtype="timedelta64")
-        tm.assert_index_equal(result, expected)
+        msg = "with no precision is not allowed"
+        with pytest.raises(ValueError, match=msg):
+            pd.TimedeltaIndex(["2000"], dtype="timedelta64")
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = pd.Index(["2000"], dtype="timedelta64")
-        tm.assert_index_equal(result, expected)
+        with pytest.raises(ValueError, match=msg):
+            pd.Index(["2000"], dtype="timedelta64")
 
     def test_constructor_wrong_precision_raises(self):
         with pytest.raises(ValueError):
diff --git a/pandas/tests/indexes/timedeltas/test_indexing.py b/pandas/tests/indexes/timedeltas/test_indexing.py
index d24f91a2c9e13..14fff6f9c85b5 100644
--- a/pandas/tests/indexes/timedeltas/test_indexing.py
+++ b/pandas/tests/indexes/timedeltas/test_indexing.py
@@ -1,11 +1,12 @@
 from datetime import datetime, timedelta
+import re
 
 import numpy as np
 import pytest
 
 import pandas as pd
-from pandas import Index, Timedelta, TimedeltaIndex, timedelta_range
-import pandas.util.testing as tm
+from pandas import Index, Timedelta, TimedeltaIndex, notna, timedelta_range
+import pandas._testing as tm
 
 
 class TestGetItem:
@@ -48,18 +49,37 @@ def test_getitem(self):
 
     @pytest.mark.parametrize(
         "key",
-        [pd.Timestamp("1970-01-01"), pd.Timestamp("1970-01-02"), datetime(1970, 1, 1)],
+        [
+            pd.Timestamp("1970-01-01"),
+            pd.Timestamp("1970-01-02"),
+            datetime(1970, 1, 1),
+            pd.Timestamp("1970-01-03").to_datetime64(),
+            # non-matching NA values
+            np.datetime64("NaT"),
+        ],
     )
     def test_timestamp_invalid_key(self, key):
         # GH#20464
         tdi = pd.timedelta_range(0, periods=10)
-        with pytest.raises(TypeError):
+        with pytest.raises(KeyError, match=re.escape(repr(key))):
             tdi.get_loc(key)
 
 
 class TestWhere:
-    # placeholder for symmetry with DatetimeIndex and PeriodIndex tests
-    pass
+    def test_where_invalid_dtypes(self):
+        tdi = timedelta_range("1 day", periods=3, freq="D", name="idx")
+
+        i2 = tdi.copy()
+        i2 = Index([pd.NaT, pd.NaT] + tdi[2:].tolist())
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            tdi.where(notna(i2), i2.asi8)
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            tdi.where(notna(i2), i2 + pd.Timestamp.now())
+
+        with pytest.raises(TypeError, match="Where requires matching dtype"):
+            tdi.where(notna(i2), (i2 + pd.Timestamp.now()).to_period("D"))
 
 
 class TestTake:
@@ -161,6 +181,15 @@ def test_take_fill_value(self):
 
 
 class TestTimedeltaIndex:
+    def test_insert_empty(self):
+        # Corner case inserting with length zero doesnt raise IndexError
+        idx = timedelta_range("1 Day", periods=3)
+        td = idx[0]
+
+        idx[:0].insert(0, td)
+        idx[:0].insert(1, td)
+        idx[:0].insert(-1, td)
+
     def test_insert(self):
 
         idx = TimedeltaIndex(["4day", "1day", "2day"], name="idx")
@@ -219,16 +248,34 @@ def test_insert(self):
             assert result.name == expected.name
             assert result.freq == expected.freq
 
+    @pytest.mark.parametrize(
+        "null", [None, np.nan, np.timedelta64("NaT"), pd.NaT, pd.NA]
+    )
+    def test_insert_nat(self, null):
         # GH 18295 (test missing)
+        idx = timedelta_range("1day", "3day")
+        result = idx.insert(1, null)
         expected = TimedeltaIndex(["1day", pd.NaT, "2day", "3day"])
-        for na in (np.nan, pd.NaT, None):
-            result = timedelta_range("1day", "3day").insert(1, na)
-            tm.assert_index_equal(result, expected)
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_invalid_na(self):
+        idx = TimedeltaIndex(["4day", "1day", "2day"], name="idx")
+        with pytest.raises(TypeError, match="incompatible label"):
+            idx.insert(0, np.datetime64("NaT"))
+
+    def test_insert_dont_cast_strings(self):
+        # To match DatetimeIndex and PeriodIndex behavior, dont try to
+        #  parse strings to Timedelta
+        idx = timedelta_range("1day", "3day")
+
+        result = idx.insert(0, "1 Day")
+        assert result.dtype == object
+        assert result[0] == "1 Day"
 
     def test_delete(self):
         idx = timedelta_range(start="1 Days", periods=5, freq="D", name="idx")
 
-        # prserve freq
+        # preserve freq
         expected_0 = timedelta_range(start="2 Days", periods=4, freq="D", name="idx")
         expected_4 = timedelta_range(start="1 Days", periods=4, freq="D", name="idx")
 
@@ -257,7 +304,7 @@ def test_delete(self):
     def test_delete_slice(self):
         idx = timedelta_range(start="1 days", periods=10, freq="D", name="idx")
 
-        # prserve freq
+        # preserve freq
         expected_0_2 = timedelta_range(start="4 days", periods=7, freq="D", name="idx")
         expected_7_9 = timedelta_range(start="1 days", periods=7, freq="D", name="idx")
 
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index d7d8b10347861..6606507dabc29 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -1,3 +1,5 @@
+from datetime import timedelta
+
 import numpy as np
 import pytest
 
@@ -5,27 +7,14 @@
 
 import pandas as pd
 from pandas import Series, TimedeltaIndex, timedelta_range
-from pandas.tests.test_base import Ops
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import Day, Hour
 
 
-class TestTimedeltaIndexOps(Ops):
-    def setup_method(self, method):
-        super().setup_method(method)
-        mask = lambda x: isinstance(x, TimedeltaIndex)
-        self.is_valid_objs = [o for o in self.objs if mask(o)]
-        self.not_valid_objs = []
-
-    def test_ops_properties(self):
-        f = lambda x: isinstance(x, TimedeltaIndex)
-        self.check_ops_properties(TimedeltaIndex._field_ops, f)
-        self.check_ops_properties(TimedeltaIndex._object_ops, f)
-
+class TestTimedeltaIndexOps:
     def test_value_counts_unique(self):
         # GH 7735
-
         idx = timedelta_range("1 days 09:00:00", freq="H", periods=10)
         # create repeated values, 'n'th element is repeated by n+1 times
         idx = TimedeltaIndex(np.repeat(idx.values, range(1, len(idx) + 1)))
@@ -124,15 +113,6 @@ def test_order(self):
             ["1 day", "3 day", "5 day", "2 day", "1 day"], name="idx2"
         )
 
-        # TODO(wesm): unused?
-        # exp2 = TimedeltaIndex(['1 day', '1 day', '2 day',
-        #                        '3 day', '5 day'], name='idx2')
-
-        # idx3 = TimedeltaIndex([pd.NaT, '3 minute', '5 minute',
-        #                        '2 minute', pd.NaT], name='idx3')
-        # exp3 = TimedeltaIndex([pd.NaT, pd.NaT, '2 minute', '3 minute',
-        #                        '5 minute'], name='idx3')
-
         for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
             ordered = idx.sort_values()
             tm.assert_index_equal(ordered, expected)
@@ -200,9 +180,6 @@ def test_infer_freq(self, freq):
         tm.assert_index_equal(idx, result)
         assert result.freq == freq
 
-    def test_shift(self):
-        pass  # handled in test_arithmetic.py
-
     def test_repeat(self):
         index = pd.timedelta_range("1 days", periods=2, freq="D")
         exp = pd.TimedeltaIndex(["1 days", "1 days", "2 days", "2 days"])
@@ -266,6 +243,17 @@ def test_equals(self):
         assert not idx.equals(list(idx2))
         assert not idx.equals(pd.Series(idx2))
 
+        # Check that we dont raise OverflowError on comparisons outside the
+        #  implementation range
+        oob = pd.Index([timedelta(days=10 ** 6)] * 3, dtype=object)
+        assert not idx.equals(oob)
+        assert not idx2.equals(oob)
+
+        # FIXME: oob.apply(np.timedelta64) incorrectly overflows
+        oob2 = pd.Index([np.timedelta64(x) for x in oob], dtype=object)
+        assert not idx.equals(oob2)
+        assert not idx2.equals(oob2)
+
     @pytest.mark.parametrize("values", [["0 days", "2 days", "4 days"], []])
     @pytest.mark.parametrize("freq", ["2D", Day(2), "48H", Hour(48)])
     def test_freq_setter(self, values, freq):
@@ -273,12 +261,12 @@ def test_freq_setter(self, values, freq):
         idx = TimedeltaIndex(values)
 
         # can set to an offset, converting from string if necessary
-        idx.freq = freq
+        idx._data.freq = freq
         assert idx.freq == freq
         assert isinstance(idx.freq, ABCDateOffset)
 
         # can reset to None
-        idx.freq = None
+        idx._data.freq = None
         assert idx.freq is None
 
     def test_freq_setter_errors(self):
@@ -291,13 +279,13 @@ def test_freq_setter_errors(self):
             "passed frequency 5D"
         )
         with pytest.raises(ValueError, match=msg):
-            idx.freq = "5D"
+            idx._data.freq = "5D"
 
         # setting with a non-fixed frequency
         msg = r"<2 \* BusinessDays> is a non-fixed frequency"
         with pytest.raises(ValueError, match=msg):
-            idx.freq = "2B"
+            idx._data.freq = "2B"
 
         # setting with non-freq string
         with pytest.raises(ValueError, match="Invalid frequency"):
-            idx.freq = "foo"
+            idx._data.freq = "foo"
diff --git a/pandas/tests/indexes/timedeltas/test_partial_slicing.py b/pandas/tests/indexes/timedeltas/test_partial_slicing.py
index 446b67d5f501d..29e2c7dd20be0 100644
--- a/pandas/tests/indexes/timedeltas/test_partial_slicing.py
+++ b/pandas/tests/indexes/timedeltas/test_partial_slicing.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Series, Timedelta, timedelta_range
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 
 class TestSlicing:
@@ -18,15 +18,15 @@ def test_partial_slice(self):
 
         result = s["5 day":"6 day"]
         expected = s.iloc[86:134]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s["5 day":]
         expected = s.iloc[86:]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s[:"6 day"]
         expected = s.iloc[:134]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s["6 days, 23:11:12"]
         assert result == s.iloc[133]
@@ -43,11 +43,11 @@ def test_partial_slice_high_reso(self):
 
         result = s["1 day 10:11:12":]
         expected = s.iloc[0:]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s["1 day 10:11:12.001":]
         expected = s.iloc[1000:]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s["1 days, 10:11:12.001001"]
         assert result == s.iloc[1001]
@@ -57,9 +57,9 @@ def test_slice_with_negative_step(self):
         SLC = pd.IndexSlice
 
         def assert_slices_equivalent(l_slc, i_slc):
-            assert_series_equal(ts[l_slc], ts.iloc[i_slc])
-            assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
-            assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
+            tm.assert_series_equal(ts[l_slc], ts.iloc[i_slc])
+            tm.assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
+            tm.assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
 
         assert_slices_equivalent(SLC[Timedelta(hours=7) :: -1], SLC[7::-1])
         assert_slices_equivalent(SLC["7 hours"::-1], SLC[7::-1])
diff --git a/pandas/tests/indexes/timedeltas/test_scalar_compat.py b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
index 38f1d2c7d4a1b..44f4a2adedaad 100644
--- a/pandas/tests/indexes/timedeltas/test_scalar_compat.py
+++ b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
@@ -7,7 +7,7 @@
 
 import pandas as pd
 from pandas import Index, Series, Timedelta, TimedeltaIndex, timedelta_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestVectorizedTimedelta:
diff --git a/pandas/tests/indexes/timedeltas/test_setops.py b/pandas/tests/indexes/timedeltas/test_setops.py
index 861067480b5fa..0aa784cbb7710 100644
--- a/pandas/tests/indexes/timedeltas/test_setops.py
+++ b/pandas/tests/indexes/timedeltas/test_setops.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Int64Index, TimedeltaIndex, timedelta_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import Hour
 
@@ -22,6 +22,22 @@ def test_union(self):
         i1.union(i2)  # Works
         i2.union(i1)  # Fails with "AttributeError: can't set attribute"
 
+    def test_union_sort_false(self):
+        tdi = timedelta_range("1day", periods=5)
+
+        left = tdi[3:]
+        right = tdi[:3]
+
+        # Check that we are testing the desired code path
+        assert left._can_fast_union(right)
+
+        result = left.union(right)
+        tm.assert_index_equal(result, tdi)
+
+        result = left.union(right, sort=False)
+        expected = pd.TimedeltaIndex(["4 Days", "5 Days", "1 Days", "2 Day", "3 Days"])
+        tm.assert_index_equal(result, expected)
+
     def test_union_coverage(self):
 
         idx = TimedeltaIndex(["3d", "1d", "2d"])
@@ -39,7 +55,7 @@ def test_union_bug_1730(self):
         rng_b = timedelta_range("1 day", periods=4, freq="4H")
 
         result = rng_a.union(rng_b)
-        exp = TimedeltaIndex(sorted(set(list(rng_a)) | set(list(rng_b))))
+        exp = TimedeltaIndex(sorted(set(rng_a) | set(rng_b)))
         tm.assert_index_equal(result, exp)
 
     def test_union_bug_1745(self):
@@ -50,7 +66,7 @@ def test_union_bug_1745(self):
         )
 
         result = left.union(right)
-        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        exp = TimedeltaIndex(sorted(set(left) | set(right)))
         tm.assert_index_equal(result, exp)
 
     def test_union_bug_4564(self):
@@ -59,9 +75,24 @@ def test_union_bug_4564(self):
         right = left + pd.offsets.Minute(15)
 
         result = left.union(right)
-        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        exp = TimedeltaIndex(sorted(set(left) | set(right)))
         tm.assert_index_equal(result, exp)
 
+    def test_union_freq_infer(self):
+        # When taking the union of two TimedeltaIndexes, we infer
+        #  a freq even if the arguments don't have freq.  This matches
+        #  DatetimeIndex behavior.
+        tdi = pd.timedelta_range("1 Day", periods=5)
+        left = tdi[[0, 1, 3, 4]]
+        right = tdi[[2, 3, 1]]
+
+        assert left.freq is None
+        assert right.freq is None
+
+        result = left.union(right)
+        tm.assert_index_equal(result, tdi)
+        assert result.freq == "D"
+
     def test_intersection_bug_1708(self):
         index_1 = timedelta_range("1 day", periods=4, freq="h")
         index_2 = index_1 + pd.offsets.Hour(5)
@@ -179,3 +210,51 @@ def test_intersection_non_monotonic(self, rng, expected, sort):
             assert isinstance(result.freq, Hour)
         else:
             assert result.freq is None
+
+
+class TestTimedeltaIndexDifference:
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_difference_freq(self, sort):
+        # GH14323: Difference of TimedeltaIndex should not preserve frequency
+
+        index = timedelta_range("0 days", "5 days", freq="D")
+
+        other = timedelta_range("1 days", "4 days", freq="D")
+        expected = TimedeltaIndex(["0 days", "5 days"], freq=None)
+        idx_diff = index.difference(other, sort)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+        other = timedelta_range("2 days", "5 days", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = TimedeltaIndex(["0 days", "1 days"], freq=None)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_difference_sort(self, sort):
+
+        index = pd.TimedeltaIndex(
+            ["5 days", "3 days", "2 days", "4 days", "1 days", "0 days"]
+        )
+
+        other = timedelta_range("1 days", "4 days", freq="D")
+        idx_diff = index.difference(other, sort)
+
+        expected = TimedeltaIndex(["5 days", "0 days"], freq=None)
+
+        if sort is None:
+            expected = expected.sort_values()
+
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+        other = timedelta_range("2 days", "5 days", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = TimedeltaIndex(["1 days", "0 days"], freq=None)
+
+        if sort is None:
+            expected = expected.sort_values()
+
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
diff --git a/pandas/tests/indexes/timedeltas/test_shift.py b/pandas/tests/indexes/timedeltas/test_shift.py
new file mode 100644
index 0000000000000..98933ff0423ab
--- /dev/null
+++ b/pandas/tests/indexes/timedeltas/test_shift.py
@@ -0,0 +1,75 @@
+import pytest
+
+from pandas.errors import NullFrequencyError
+
+import pandas as pd
+from pandas import TimedeltaIndex
+import pandas._testing as tm
+
+
+class TestTimedeltaIndexShift:
+
+    # -------------------------------------------------------------
+    # TimedeltaIndex.shift is used by __add__/__sub__
+
+    def test_tdi_shift_empty(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex([], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="H"), idx)
+        tm.assert_index_equal(idx.shift(3, freq="H"), idx)
+
+    def test_tdi_shift_hours(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="H"), idx)
+        exp = pd.TimedeltaIndex(["8 hours", "9 hours", "12 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(3, freq="H"), exp)
+        exp = pd.TimedeltaIndex(["2 hours", "3 hours", "6 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(-3, freq="H"), exp)
+
+    def test_tdi_shift_minutes(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="T"), idx)
+        exp = pd.TimedeltaIndex(["05:03:00", "06:03:00", "9:03:00"], name="xxx")
+        tm.assert_index_equal(idx.shift(3, freq="T"), exp)
+        exp = pd.TimedeltaIndex(["04:57:00", "05:57:00", "8:57:00"], name="xxx")
+        tm.assert_index_equal(idx.shift(-3, freq="T"), exp)
+
+    def test_tdi_shift_int(self):
+        # GH#8083
+        trange = pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
+        result = trange.shift(1)
+        expected = TimedeltaIndex(
+            [
+                "1 days 01:00:00",
+                "2 days 01:00:00",
+                "3 days 01:00:00",
+                "4 days 01:00:00",
+                "5 days 01:00:00",
+            ],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_tdi_shift_nonstandard_freq(self):
+        # GH#8083
+        trange = pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
+        result = trange.shift(3, freq="2D 1s")
+        expected = TimedeltaIndex(
+            [
+                "6 days 01:00:03",
+                "7 days 01:00:03",
+                "8 days 01:00:03",
+                "9 days 01:00:03",
+                "10 days 01:00:03",
+            ],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_shift_no_freq(self):
+        # GH#19147
+        tdi = TimedeltaIndex(["1 days 01:00:00", "2 days 01:00:00"], freq=None)
+        with pytest.raises(NullFrequencyError):
+            tdi.shift(2)
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index e790a913fcac2..8a91c9d5e09c8 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -1,5 +1,4 @@
 from datetime import timedelta
-import re
 
 import numpy as np
 import pytest
@@ -15,12 +14,7 @@
     date_range,
     timedelta_range,
 )
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_index_equal,
-    assert_series_equal,
-)
+import pandas._testing as tm
 
 from ..datetimelike import DatetimeLike
 
@@ -30,9 +24,9 @@
 class TestTimedeltaIndex(DatetimeLike):
     _holder = TimedeltaIndex
 
-    def setup_method(self, method):
-        self.indices = dict(index=tm.makeTimedeltaIndex(10))
-        self.setup_indices()
+    @pytest.fixture
+    def indices(self):
+        return tm.makeTimedeltaIndex(10)
 
     def create_index(self):
         return pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
@@ -63,52 +57,6 @@ def test_fillna_timedelta(self):
         )
         tm.assert_index_equal(idx.fillna("x"), exp)
 
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_freq(self, sort):
-        # GH14323: Difference of TimedeltaIndex should not preserve frequency
-
-        index = timedelta_range("0 days", "5 days", freq="D")
-
-        other = timedelta_range("1 days", "4 days", freq="D")
-        expected = TimedeltaIndex(["0 days", "5 days"], freq=None)
-        idx_diff = index.difference(other, sort)
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
-        other = timedelta_range("2 days", "5 days", freq="D")
-        idx_diff = index.difference(other, sort)
-        expected = TimedeltaIndex(["0 days", "1 days"], freq=None)
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_difference_sort(self, sort):
-
-        index = pd.TimedeltaIndex(
-            ["5 days", "3 days", "2 days", "4 days", "1 days", "0 days"]
-        )
-
-        other = timedelta_range("1 days", "4 days", freq="D")
-        idx_diff = index.difference(other, sort)
-
-        expected = TimedeltaIndex(["5 days", "0 days"], freq=None)
-
-        if sort is None:
-            expected = expected.sort_values()
-
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
-        other = timedelta_range("2 days", "5 days", freq="D")
-        idx_diff = index.difference(other, sort)
-        expected = TimedeltaIndex(["1 days", "0 days"], freq=None)
-
-        if sort is None:
-            expected = expected.sort_values()
-
-        tm.assert_index_equal(idx_diff, expected)
-        tm.assert_attr_equal("freq", idx_diff, expected)
-
     def test_isin(self):
 
         index = tm.makeTimedeltaIndex(4)
@@ -118,7 +66,7 @@ def test_isin(self):
         result = index.isin(list(index))
         assert result.all()
 
-        assert_almost_equal(
+        tm.assert_almost_equal(
             index.isin([index[2], 5]), np.array([False, False, True, False])
         )
 
@@ -184,16 +132,6 @@ def test_sort_values(self):
 
         tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1]), check_dtype=False)
 
-    def test_get_duplicates(self):
-        idx = TimedeltaIndex(["1 day", "2 day", "2 day", "3 day", "3day", "4day"])
-
-        with tm.assert_produces_warning(FutureWarning):
-            # Deprecated - see GH20239
-            result = idx.get_duplicates()
-
-        ex = TimedeltaIndex(["2 day", "3day"])
-        tm.assert_index_equal(result, ex)
-
     def test_argmin_argmax(self):
         idx = TimedeltaIndex(["1 day 00:00:05", "1 day 00:00:01", "1 day 00:00:02"])
         assert idx.argmin() == 1
@@ -239,7 +177,7 @@ def test_pickle(self):
     def test_hash_error(self):
         index = timedelta_range("1 days", periods=10)
         with pytest.raises(
-            TypeError, match=("unhashable type: {0.__name__!r}".format(type(index)))
+            TypeError, match=(f"unhashable type: {repr(type(index).__name__)}")
         ):
             hash(index)
 
@@ -263,6 +201,13 @@ def test_append_numpy_bug_1681(self):
         result = a.append(c)
         assert (result["B"] == td).all()
 
+    def test_delete_doesnt_infer_freq(self):
+        # GH#30655 behavior matches DatetimeIndex
+
+        tdi = pd.TimedeltaIndex(["1 Day", "2 Days", None, "3 Days", "4 Days"])
+        result = tdi.delete(2)
+        assert result.freq is None
+
     def test_fields(self):
         rng = timedelta_range("1 days, 10:11:12.100123456", periods=2, freq="s")
         tm.assert_index_equal(rng.days, Index([1, 1], dtype="int64"))
@@ -309,48 +254,33 @@ def test_freq_conversion(self):
 
         result = td / np.timedelta64(1, "D")
         expected = Series([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td.astype("timedelta64[D]")
         expected = Series([31, 31, 31, np.nan])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td / np.timedelta64(1, "s")
         expected = Series([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3, np.nan])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td.astype("timedelta64[s]")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # tdi
         td = TimedeltaIndex(td)
 
         result = td / np.timedelta64(1, "D")
         expected = Index([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan])
-        assert_index_equal(result, expected)
+        tm.assert_index_equal(result, expected)
 
         result = td.astype("timedelta64[D]")
         expected = Index([31, 31, 31, np.nan])
-        assert_index_equal(result, expected)
+        tm.assert_index_equal(result, expected)
 
         result = td / np.timedelta64(1, "s")
         expected = Index([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3, np.nan])
-        assert_index_equal(result, expected)
+        tm.assert_index_equal(result, expected)
 
         result = td.astype("timedelta64[s]")
-        assert_index_equal(result, expected)
-
-    @pytest.mark.parametrize("unit", ["Y", "y", "M"])
-    def test_unit_m_y_deprecated(self, unit):
-        with tm.assert_produces_warning(FutureWarning) as w:
-            TimedeltaIndex([1, 3, 7], unit)
-        msg = r".* units are deprecated .*"
-        assert re.match(msg, str(w[0].message))
-
-
-class TestTimeSeries:
-    def test_series_box_timedelta(self):
-        rng = timedelta_range("1 day 1 s", periods=5, freq="h")
-        s = Series(rng)
-        assert isinstance(s[1], Timedelta)
-        assert isinstance(s.iat[2], Timedelta)
+        tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta_range.py b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
index 1c1d0f1a735cf..9f12af9a96104 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta_range.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
@@ -1,9 +1,8 @@
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import timedelta_range, to_timedelta
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import Day, Second
 
@@ -31,23 +30,6 @@ def test_timedelta_range(self):
         result = timedelta_range("0 days", freq="30T", periods=50)
         tm.assert_index_equal(result, expected)
 
-        # GH 11776
-        arr = np.arange(10).reshape(2, 5)
-        df = pd.DataFrame(np.arange(10).reshape(2, 5))
-        for arg in (arr, df):
-            with pytest.raises(TypeError, match="1-d array"):
-                to_timedelta(arg)
-            for errors in ["ignore", "raise", "coerce"]:
-                with pytest.raises(TypeError, match="1-d array"):
-                    to_timedelta(arg, errors=errors)
-
-        # issue10583
-        df = pd.DataFrame(np.random.normal(size=(10, 4)))
-        df.index = pd.timedelta_range(start="0s", periods=10, freq="s")
-        expected = df.loc[pd.Timedelta("0s") :, :]
-        result = df.loc["0s":, :]
-        tm.assert_frame_equal(expected, result)
-
     @pytest.mark.parametrize(
         "periods, freq", [(3, "2D"), (5, "D"), (6, "19H12T"), (7, "16H"), (9, "12H")]
     )
diff --git a/pandas/tests/indexes/timedeltas/test_tools.py b/pandas/tests/indexes/timedeltas/test_tools.py
index 4aed0b1af81a6..e3cf3a7f16a82 100644
--- a/pandas/tests/indexes/timedeltas/test_tools.py
+++ b/pandas/tests/indexes/timedeltas/test_tools.py
@@ -3,36 +3,13 @@
 import numpy as np
 import pytest
 
-from pandas._libs.tslib import iNaT
-
 import pandas as pd
 from pandas import Series, TimedeltaIndex, isna, to_timedelta
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 
 class TestTimedeltas:
     def test_to_timedelta(self):
-        def conv(v):
-            return v.astype("m8[ns]")
-
-        d1 = np.timedelta64(1, "D")
-
-        with tm.assert_produces_warning(FutureWarning):
-            assert to_timedelta("1 days 06:05:01.00003", box=False) == conv(
-                d1
-                + np.timedelta64(6 * 3600 + 5 * 60 + 1, "s")
-                + np.timedelta64(30, "us")
-            )
-
-        with tm.assert_produces_warning(FutureWarning):
-            assert to_timedelta("15.5us", box=False) == conv(
-                np.timedelta64(15500, "ns")
-            )
-
-            # empty string
-            result = to_timedelta("", box=False)
-            assert result.astype("int64") == iNaT
 
         result = to_timedelta(["", ""])
         assert isna(result).all()
@@ -42,12 +19,6 @@ def conv(v):
         expected = pd.Index(np.array([np.timedelta64(1, "s")]))
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            # ints
-            result = np.timedelta64(0, "ns")
-            expected = to_timedelta(0, box=False)
-            assert result == expected
-
         # Series
         expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
         result = to_timedelta(Series(["1d", "1days 00:00:01"]))
@@ -60,19 +31,6 @@ def conv(v):
         expected = to_timedelta([0, 10], unit="s")
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            # single element conversion
-            v = timedelta(seconds=1)
-            result = to_timedelta(v, box=False)
-            expected = np.timedelta64(timedelta(seconds=1))
-            assert result == expected
-
-        with tm.assert_produces_warning(FutureWarning):
-            v = np.timedelta64(timedelta(seconds=1))
-            result = to_timedelta(v, box=False)
-            expected = np.timedelta64(timedelta(seconds=1))
-            assert result == expected
-
         # arrays of various dtypes
         arr = np.array([1] * 5, dtype="int64")
         result = to_timedelta(arr, unit="s")
@@ -99,27 +57,16 @@ def conv(v):
         expected = TimedeltaIndex([np.timedelta64(1, "D")] * 5)
         tm.assert_index_equal(result, expected)
 
-        with tm.assert_produces_warning(FutureWarning):
-            # Test with lists as input when box=false
-            expected = np.array(np.arange(3) * 1000000000, dtype="timedelta64[ns]")
-            result = to_timedelta(range(3), unit="s", box=False)
-            tm.assert_numpy_array_equal(expected, result)
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = to_timedelta(np.arange(3), unit="s", box=False)
-            tm.assert_numpy_array_equal(expected, result)
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = to_timedelta([0, 1, 2], unit="s", box=False)
-            tm.assert_numpy_array_equal(expected, result)
-
-        with tm.assert_produces_warning(FutureWarning):
-            # Tests with fractional seconds as input:
-            expected = np.array(
-                [0, 500000000, 800000000, 1200000000], dtype="timedelta64[ns]"
-            )
-            result = to_timedelta([0.0, 0.5, 0.8, 1.2], unit="s", box=False)
-            tm.assert_numpy_array_equal(expected, result)
+    def test_to_timedelta_dataframe(self):
+        # GH 11776
+        arr = np.arange(10).reshape(2, 5)
+        df = pd.DataFrame(np.arange(10).reshape(2, 5))
+        for arg in (arr, df):
+            with pytest.raises(TypeError, match="1-d array"):
+                to_timedelta(arg)
+            for errors in ["ignore", "raise", "coerce"]:
+                with pytest.raises(TypeError, match="1-d array"):
+                    to_timedelta(arg, errors=errors)
 
     def test_to_timedelta_invalid(self):
 
@@ -137,8 +84,7 @@ def test_to_timedelta_invalid(self):
 
         # time not supported ATM
         msg = (
-            "Value must be Timedelta, string, integer, float, timedelta or"
-            " convertible"
+            "Value must be Timedelta, string, integer, float, timedelta or convertible"
         )
         with pytest.raises(ValueError, match=msg):
             to_timedelta(time(second=1))
@@ -192,10 +138,10 @@ def test_to_timedelta_on_missing_values(self):
         expected = Series(
             [np.timedelta64(1000000000, "ns"), timedelta_NaT], dtype="<m8[ns]"
         )
-        assert_series_equal(actual, expected)
+        tm.assert_series_equal(actual, expected)
 
         actual = pd.to_timedelta(Series(["00:00:01", pd.NaT]))
-        assert_series_equal(actual, expected)
+        tm.assert_series_equal(actual, expected)
 
         actual = pd.to_timedelta(np.nan)
         assert actual.value == timedelta_NaT.astype("int64")
@@ -209,13 +155,3 @@ def test_to_timedelta_float(self):
         result = pd.to_timedelta(arr, unit="s")
         expected_asi8 = np.arange(999990000, int(1e9), 1000, dtype="int64")
         tm.assert_numpy_array_equal(result.asi8, expected_asi8)
-
-    def test_to_timedelta_box_deprecated(self):
-        result = np.timedelta64(0, "ns")
-
-        # Deprecated - see GH24416
-        with tm.assert_produces_warning(FutureWarning):
-            to_timedelta(0, box=False)
-
-        expected = to_timedelta(0).to_timedelta64()
-        assert result == expected
diff --git a/pandas/tests/indexing/common.py b/pandas/tests/indexing/common.py
index 9ceeb06b6fd86..6f6981a30d7e4 100644
--- a/pandas/tests/indexing/common.py
+++ b/pandas/tests/indexing/common.py
@@ -1,22 +1,14 @@
 """ common utilities """
-
 import itertools
-from warnings import catch_warnings, filterwarnings
 
 import numpy as np
 
-from pandas.core.dtypes.common import is_scalar
-
 from pandas import DataFrame, Float64Index, MultiIndex, Series, UInt64Index, date_range
-from pandas.util import testing as tm
-
-from pandas.io.formats.printing import pprint_thing
-
-_verbose = False
+import pandas._testing as tm
 
 
 def _mklbl(prefix, n):
-    return ["{prefix}{i}".format(prefix=prefix, i=i) for i in range(n)]
+    return [f"{prefix}{i}" for i in range(n)]
 
 
 def _axify(obj, key, axis):
@@ -29,7 +21,7 @@ def _axify(obj, key, axis):
 class Base:
     """ indexing comprehensive base class """
 
-    _objs = {"series", "frame"}
+    _kinds = {"series", "frame"}
     _typs = {
         "ints",
         "uints",
@@ -98,16 +90,15 @@ def setup_method(self, method):
         self.frame_ts_rev = DataFrame(np.random.randn(4, 4), index=dates_rev)
 
         self.frame_empty = DataFrame()
-        self.series_empty = Series()
+        self.series_empty = Series(dtype=object)
 
         # form agglomerates
-        for o in self._objs:
-
+        for kind in self._kinds:
             d = dict()
-            for t in self._typs:
-                d[t] = getattr(self, "{o}_{t}".format(o=o, t=t), None)
+            for typ in self._typs:
+                d[typ] = getattr(self, f"{kind}_{typ}")
 
-            setattr(self, o, d)
+            setattr(self, kind, d)
 
     def generate_indices(self, f, values=False):
         """ generate the indices
@@ -117,46 +108,22 @@ def generate_indices(self, f, values=False):
 
         axes = f.axes
         if values:
-            axes = (list(range(len(a))) for a in axes)
+            axes = (list(range(len(ax))) for ax in axes)
 
         return itertools.product(*axes)
 
-    def get_result(self, obj, method, key, axis):
-        """ return the result for this obj with this key and this axis """
-
-        if isinstance(key, dict):
-            key = key[axis]
-
-        # use an artificial conversion to map the key as integers to the labels
-        # so ix can work for comparisons
-        if method == "indexer":
-            method = "ix"
-            key = obj._get_axis(axis)[key]
-
-        # in case we actually want 0 index slicing
-        with catch_warnings(record=True):
-            try:
-                xp = getattr(obj, method).__getitem__(_axify(obj, key, axis))
-            except AttributeError:
-                xp = getattr(obj, method).__getitem__(key)
-
-        return xp
-
-    def get_value(self, f, i, values=False):
+    def get_value(self, name, f, i, values=False):
         """ return the value for the location i """
 
         # check against values
         if values:
             return f.values[i]
 
-        # this is equiv of f[col][row].....
-        # v = f
-        # for a in reversed(i):
-        #    v = v.__getitem__(a)
-        # return v
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            return f.ix[i]
+        elif name == "iat":
+            return f.iloc[i]
+        else:
+            assert name == "at"
+            return f.loc[i]
 
     def check_values(self, f, func, values=False):
 
@@ -179,114 +146,40 @@ def check_values(self, f, func, values=False):
             tm.assert_almost_equal(result, expected)
 
     def check_result(
-        self,
-        name,
-        method1,
-        key1,
-        method2,
-        key2,
-        typs=None,
-        objs=None,
-        axes=None,
-        fails=None,
+        self, method, key, typs=None, axes=None, fails=None,
     ):
-        def _eq(t, o, a, obj, k1, k2):
+        def _eq(axis, obj, key):
             """ compare equal for these 2 keys """
 
-            if a is not None and a > obj.ndim - 1:
-                return
-
-            def _print(result, error=None):
-                if error is not None:
-                    error = str(error)
-                v = (
-                    "%-16.16s [%-16.16s]: [typ->%-8.8s,obj->%-8.8s,"
-                    "key1->(%-4.4s),key2->(%-4.4s),axis->%s] %s"
-                    % (name, result, t, o, method1, method2, a, error or "")
-                )
-                if _verbose:
-                    pprint_thing(v)
-
+            axified = _axify(obj, key, axis)
             try:
-                rs = getattr(obj, method1).__getitem__(_axify(obj, k1, a))
-
-                try:
-                    xp = self.get_result(obj, method2, k2, a)
-                except Exception:
-                    result = "no comp"
-                    _print(result)
-                    return
-
-                detail = None
-
-                try:
-                    if is_scalar(rs) and is_scalar(xp):
-                        assert rs == xp
-                    elif xp.ndim == 1:
-                        tm.assert_series_equal(rs, xp)
-                    elif xp.ndim == 2:
-                        tm.assert_frame_equal(rs, xp)
-                    result = "ok"
-                except AssertionError as e:
-                    detail = str(e)
-                    result = "fail"
-
-                # reverse the checks
-                if fails is True:
-                    if result == "fail":
-                        result = "ok (fail)"
-
-                _print(result)
-                if not result.startswith("ok"):
-                    raise AssertionError(detail)
-
-            except AssertionError:
-                raise
-            except Exception as detail:
+                getattr(obj, method).__getitem__(axified)
+
+            except (IndexError, TypeError, KeyError) as detail:
 
                 # if we are in fails, the ok, otherwise raise it
                 if fails is not None:
                     if isinstance(detail, fails):
-                        result = "ok ({0.__name__})".format(type(detail))
-                        _print(result)
                         return
-
-                result = type(detail).__name__
-                raise AssertionError(_print(result, error=detail))
+                raise
 
         if typs is None:
             typs = self._typs
 
-        if objs is None:
-            objs = self._objs
-
-        if axes is not None:
-            if not isinstance(axes, (tuple, list)):
-                axes = [axes]
-            else:
-                axes = list(axes)
-        else:
+        if axes is None:
             axes = [0, 1]
+        else:
+            assert axes in [0, 1]
+            axes = [axes]
 
         # check
-        for o in objs:
-            if o not in self._objs:
-                continue
-
-            d = getattr(self, o)
-            for a in axes:
-                for t in typs:
-                    if t not in self._typs:
-                        continue
-
-                    obj = d[t]
-                    if obj is None:
-                        continue
-
-                    def _call(obj=obj):
-                        obj = obj.copy()
+        for kind in self._kinds:
 
-                        k2 = key2
-                        _eq(t, o, a, obj, key1, k2)
+            d = getattr(self, kind)
+            for ax in axes:
+                for typ in typs:
+                    assert typ in self._typs
 
-                    _call()
+                    obj = d[typ]
+                    if ax < obj.ndim:
+                        _eq(axis=ax, obj=obj, key=key)
diff --git a/pandas/tests/indexing/conftest.py b/pandas/tests/indexing/conftest.py
deleted file mode 100644
index 142bedaa943a6..0000000000000
--- a/pandas/tests/indexing/conftest.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas._libs import index as libindex
-
-
-@pytest.fixture(
-    params=[
-        (libindex.Int64Engine, np.int64),
-        (libindex.Int32Engine, np.int32),
-        (libindex.Int16Engine, np.int16),
-        (libindex.Int8Engine, np.int8),
-        (libindex.UInt64Engine, np.uint64),
-        (libindex.UInt32Engine, np.uint32),
-        (libindex.UInt16Engine, np.uint16),
-        (libindex.UInt8Engine, np.uint8),
-        (libindex.Float64Engine, np.float64),
-        (libindex.Float32Engine, np.float32),
-    ],
-    ids=lambda x: x[0].__name__,
-)
-def numeric_indexing_engine_type_and_dtype(request):
-    return request.param
diff --git a/pandas/tests/indexing/interval/test_interval.py b/pandas/tests/indexing/interval/test_interval.py
index bbce786fc07ba..634020982b1c2 100644
--- a/pandas/tests/indexing/interval/test_interval.py
+++ b/pandas/tests/indexing/interval/test_interval.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import DataFrame, IntervalIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestIntervalIndex:
@@ -64,7 +64,7 @@ def test_non_matching(self):
         s = self.s
 
         # this is a departure from our current
-        # indexin scheme, but simpler
+        # indexing scheme, but simpler
         with pytest.raises(KeyError, match="^$"):
             s.loc[[-1, 3, 4, 5]]
 
diff --git a/pandas/tests/indexing/interval/test_interval_new.py b/pandas/tests/indexing/interval/test_interval_new.py
index a86a9d16d3f9f..43036fbbd9844 100644
--- a/pandas/tests/indexing/interval/test_interval_new.py
+++ b/pandas/tests/indexing/interval/test_interval_new.py
@@ -4,7 +4,7 @@
 import pytest
 
 from pandas import Interval, IntervalIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestIntervalIndex:
diff --git a/pandas/tests/indexing/multiindex/conftest.py b/pandas/tests/indexing/multiindex/conftest.py
index 23149944f3c38..48e090b242208 100644
--- a/pandas/tests/indexing/multiindex/conftest.py
+++ b/pandas/tests/indexing/multiindex/conftest.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -21,7 +21,8 @@ def multiindex_dataframe_random_data():
 @pytest.fixture
 def multiindex_year_month_day_dataframe_random_data():
     """DataFrame with 3 level MultiIndex (year, month, day) covering
-    first 100 business days from 2000-01-01 with random data"""
+    first 100 business days from 2000-01-01 with random data
+    """
     tdf = tm.makeTimeDataFrame(100)
     ymd = tdf.groupby([lambda x: x.year, lambda x: x.month, lambda x: x.day]).sum()
     # use Int64Index, to make sure things work
diff --git a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
index 3183721eeb54f..8bfba8c12e934 100644
--- a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
@@ -2,13 +2,13 @@
 import pytest
 
 from pandas import DataFrame, MultiIndex, Series
-from pandas.core import common as com
-import pandas.util.testing as tm
+import pandas._testing as tm
+import pandas.core.common as com
 
 
 def test_detect_chained_assignment():
     # Inplace ops, originally from:
-    # http://stackoverflow.com/questions/20508968/series-fillna-in-a-multiindex-dataframe-does-not-fill-is-this-a-bug
+    # https://stackoverflow.com/questions/20508968/series-fillna-in-a-multiindex-dataframe-does-not-fill-is-this-a-bug
     a = [12, 23]
     b = [123, None]
     c = [1234, 2345]
diff --git a/pandas/tests/indexing/multiindex/test_getitem.py b/pandas/tests/indexing/multiindex/test_getitem.py
index 145bfe168390e..7e75b5324445e 100644
--- a/pandas/tests/indexing/multiindex/test_getitem.py
+++ b/pandas/tests/indexing/multiindex/test_getitem.py
@@ -2,8 +2,8 @@
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex, Series
+import pandas._testing as tm
 from pandas.core.indexing import IndexingError
-from pandas.util import testing as tm
 
 # ----------------------------------------------------------------------------
 # test indexing of Series with multi-level Index
@@ -87,8 +87,8 @@ def test_series_getitem_returns_scalar(
         (lambda s: s[(2000, 3, 4)], KeyError, r"^\(2000, 3, 4\)$"),
         (lambda s: s.loc[(2000, 3, 4)], KeyError, r"^\(2000, 3, 4\)$"),
         (lambda s: s.loc[(2000, 3, 4, 5)], IndexingError, "Too many indexers"),
-        (lambda s: s.__getitem__(len(s)), IndexError, "index out of bounds"),
-        (lambda s: s[len(s)], IndexError, "index out of bounds"),
+        (lambda s: s.__getitem__(len(s)), IndexError, "is out of bounds"),
+        (lambda s: s[len(s)], IndexError, "is out of bounds"),
         (
             lambda s: s.iloc[len(s)],
             IndexError,
@@ -108,7 +108,7 @@ def test_series_getitem_indexing_errors(
 
 
 def test_series_getitem_corner_generator(
-    multiindex_year_month_day_dataframe_random_data
+    multiindex_year_month_day_dataframe_random_data,
 ):
     s = multiindex_year_month_day_dataframe_random_data["A"]
     result = s[(x > 0 for x in s)]
@@ -250,3 +250,13 @@ def test_frame_mi_access_returns_frame(dataframe_with_duplicate_index):
     ).T
     result = df["A"]["B2"]
     tm.assert_frame_equal(result, expected)
+
+
+def test_frame_mi_empty_slice():
+    # GH 15454
+    df = DataFrame(0, index=range(2), columns=MultiIndex.from_product([[1], [2]]))
+    result = df[[]]
+    expected = DataFrame(
+        index=[0, 1], columns=MultiIndex(levels=[[1], [2]], codes=[[], []])
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/multiindex/test_iloc.py b/pandas/tests/indexing/multiindex/test_iloc.py
index 1335ee9dc2bdf..9859c7235c380 100644
--- a/pandas/tests/indexing/multiindex/test_iloc.py
+++ b/pandas/tests/indexing/multiindex/test_iloc.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, MultiIndex, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture
diff --git a/pandas/tests/indexing/multiindex/test_indexing_slow.py b/pandas/tests/indexing/multiindex/test_indexing_slow.py
index aab44daf8d17f..8ea1cebd7bf7b 100644
--- a/pandas/tests/indexing/multiindex/test_indexing_slow.py
+++ b/pandas/tests/indexing/multiindex/test_indexing_slow.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.slow
diff --git a/pandas/tests/indexing/multiindex/test_set_ops.py b/pandas/tests/indexing/multiindex/test_insert.py
similarity index 70%
rename from pandas/tests/indexing/multiindex/test_set_ops.py
rename to pandas/tests/indexing/multiindex/test_insert.py
index 5d0bc61e9957c..835e61da2fb3e 100644
--- a/pandas/tests/indexing/multiindex/test_set_ops.py
+++ b/pandas/tests/indexing/multiindex/test_insert.py
@@ -1,20 +1,10 @@
 from numpy.random import randn
 
 from pandas import DataFrame, MultiIndex, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
-class TestMultiIndexSetOps:
-    def test_multiindex_symmetric_difference(self):
-        # GH 13490
-        idx = MultiIndex.from_product([["a", "b"], ["A", "B"]], names=["a", "b"])
-        result = idx ^ idx
-        assert result.names == idx.names
-
-        idx2 = idx.copy().rename(["A", "B"])
-        result = idx ^ idx2
-        assert result.names == [None, None]
-
+class TestMultiIndexInsertion:
     def test_mixed_depth_insert(self):
         arrays = [
             ["a", "top", "top", "routine1", "routine1", "routine2"],
diff --git a/pandas/tests/indexing/multiindex/test_ix.py b/pandas/tests/indexing/multiindex/test_ix.py
index 2e7a5a08a16f0..01b0b392d52a3 100644
--- a/pandas/tests/indexing/multiindex/test_ix.py
+++ b/pandas/tests/indexing/multiindex/test_ix.py
@@ -4,7 +4,7 @@
 from pandas.errors import PerformanceWarning
 
 from pandas import DataFrame, MultiIndex
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestMultiIndex:
diff --git a/pandas/tests/indexing/multiindex/test_loc.py b/pandas/tests/indexing/multiindex/test_loc.py
index 8b48c2bf7169f..b7802d9b8fe0c 100644
--- a/pandas/tests/indexing/multiindex/test_loc.py
+++ b/pandas/tests/indexing/multiindex/test_loc.py
@@ -1,12 +1,10 @@
-import itertools
-
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
+import pandas._testing as tm
 from pandas.core.indexing import IndexingError
-from pandas.util import testing as tm
 
 
 @pytest.fixture
@@ -50,7 +48,9 @@ def test_loc_getitem_series(self):
 
         empty = Series(data=[], dtype=np.float64)
         expected = Series(
-            [], index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64)
+            [],
+            index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64),
+            dtype=np.float64,
         )
         result = x.loc[empty]
         tm.assert_series_equal(result, expected)
@@ -72,7 +72,9 @@ def test_loc_getitem_array(self):
         # empty array:
         empty = np.array([])
         expected = Series(
-            [], index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64)
+            [],
+            index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64),
+            dtype="float64",
         )
         result = x.loc[empty]
         tm.assert_series_equal(result, expected)
@@ -223,17 +225,13 @@ def test_loc_getitem_int_slice(self):
         # GH 3053
         # loc should treat integer slices like label slices
 
-        index = MultiIndex.from_tuples(
-            [t for t in itertools.product([6, 7, 8], ["a", "b"])]
-        )
+        index = MultiIndex.from_product([[6, 7, 8], ["a", "b"]])
         df = DataFrame(np.random.randn(6, 6), index, index)
         result = df.loc[6:8, :]
         expected = df
         tm.assert_frame_equal(result, expected)
 
-        index = MultiIndex.from_tuples(
-            [t for t in itertools.product([10, 20, 30], ["a", "b"])]
-        )
+        index = MultiIndex.from_product([[10, 20, 30], ["a", "b"]])
         df = DataFrame(np.random.randn(6, 6), index, index)
         result = df.loc[20:30, :]
         expected = df.iloc[2:]
@@ -413,3 +411,79 @@ def test_loc_setitem_single_column_slice():
     df.loc[:, "B"] = np.arange(4)
     expected.iloc[:, 2] = np.arange(4)
     tm.assert_frame_equal(df, expected)
+
+
+def test_loc_nan_multiindex():
+    # GH 5286
+    tups = [
+        ("Good Things", "C", np.nan),
+        ("Good Things", "R", np.nan),
+        ("Bad Things", "C", np.nan),
+        ("Bad Things", "T", np.nan),
+        ("Okay Things", "N", "B"),
+        ("Okay Things", "N", "D"),
+        ("Okay Things", "B", np.nan),
+        ("Okay Things", "D", np.nan),
+    ]
+    df = DataFrame(
+        np.ones((8, 4)),
+        columns=Index(["d1", "d2", "d3", "d4"]),
+        index=MultiIndex.from_tuples(tups, names=["u1", "u2", "u3"]),
+    )
+    result = df.loc["Good Things"].loc["C"]
+    expected = DataFrame(
+        np.ones((1, 4)),
+        index=Index([np.nan], dtype="object", name="u3"),
+        columns=Index(["d1", "d2", "d3", "d4"], dtype="object"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_period_string_indexing():
+    # GH 9892
+    a = pd.period_range("2013Q1", "2013Q4", freq="Q")
+    i = (1111, 2222, 3333)
+    idx = pd.MultiIndex.from_product((a, i), names=("Periode", "CVR"))
+    df = pd.DataFrame(
+        index=idx,
+        columns=(
+            "OMS",
+            "OMK",
+            "RES",
+            "DRIFT_IND",
+            "OEVRIG_IND",
+            "FIN_IND",
+            "VARE_UD",
+            "LOEN_UD",
+            "FIN_UD",
+        ),
+    )
+    result = df.loc[("2013Q1", 1111), "OMS"]
+    expected = pd.Series(
+        [np.nan],
+        dtype=object,
+        name="OMS",
+        index=pd.MultiIndex.from_tuples(
+            [(pd.Period("2013Q1"), 1111)], names=["Periode", "CVR"]
+        ),
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_datetime_mask_slicing():
+    # GH 16699
+    dt_idx = pd.to_datetime(["2017-05-04", "2017-05-05"])
+    m_idx = pd.MultiIndex.from_product([dt_idx, dt_idx], names=["Idx1", "Idx2"])
+    df = pd.DataFrame(
+        data=[[1, 2], [3, 4], [5, 6], [7, 6]], index=m_idx, columns=["C1", "C2"]
+    )
+    result = df.loc[(dt_idx[0], (df.index.get_level_values(1) > "2017-05-04")), "C1"]
+    expected = pd.Series(
+        [3],
+        name="C1",
+        index=MultiIndex.from_tuples(
+            [(pd.Timestamp("2017-05-04"), pd.Timestamp("2017-05-05"))],
+            names=["Idx1", "Idx2"],
+        ),
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index ccaaa2ae02499..0064187a94265 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -1,12 +1,11 @@
 import numpy as np
-import pytest
 
 import pandas._libs.index as _index
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestMultiIndexBasic:
@@ -20,7 +19,7 @@ def test_multiindex_perf_warn(self):
             }
         ).set_index(["jim", "joe"])
 
-        with tm.assert_produces_warning(PerformanceWarning, clear=[pd.core.index]):
+        with tm.assert_produces_warning(PerformanceWarning):
             df.loc[(1, "z")]
 
         df = df.iloc[[2, 1, 3, 0]]
@@ -47,17 +46,6 @@ def test_multiindex_contains_dropped(self):
         assert "a" in idx.levels[0]
         assert "a" not in idx
 
-    @pytest.mark.parametrize(
-        "data, expected",
-        [
-            (MultiIndex.from_product([(), ()]), True),
-            (MultiIndex.from_product([(1, 2), (3, 4)]), True),
-            (MultiIndex.from_product([("a", "b"), (1, 2)]), False),
-        ],
-    )
-    def test_multiindex_is_homogeneous_type(self, data, expected):
-        assert data._is_homogeneous_type is expected
-
     def test_indexing_over_hashtable_size_cutoff(self):
         n = 10000
 
@@ -104,3 +92,22 @@ def test_contains(self):
         assert tx[0] in idx
         assert "element_not_exit" not in idx
         assert "0 day 09:30:00" in idx
+
+    def test_nested_tuples_duplicates(self):
+        # GH#30892
+
+        dti = pd.to_datetime(["20190101", "20190101", "20190102"])
+        idx = pd.Index(["a", "a", "c"])
+        mi = pd.MultiIndex.from_arrays([dti, idx], names=["index1", "index2"])
+
+        df = pd.DataFrame({"c1": [1, 2, 3], "c2": [np.nan, np.nan, np.nan]}, index=mi)
+
+        expected = pd.DataFrame({"c1": df["c1"], "c2": [1.0, 1.0, np.nan]}, index=mi)
+
+        df2 = df.copy(deep=True)
+        df2.loc[(dti[0], "a"), "c2"] = 1.0
+        tm.assert_frame_equal(df2, expected)
+
+        df3 = df.copy(deep=True)
+        df3.loc[[(dti[0], "a")], "c2"] = 1.0
+        tm.assert_frame_equal(df3, expected)
diff --git a/pandas/tests/indexing/multiindex/test_partial.py b/pandas/tests/indexing/multiindex/test_partial.py
index 692b57ff98f94..9d181bdcb9491 100644
--- a/pandas/tests/indexing/multiindex/test_partial.py
+++ b/pandas/tests/indexing/multiindex/test_partial.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, MultiIndex
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestMultiIndexPartial:
diff --git a/pandas/tests/indexing/multiindex/test_setitem.py b/pandas/tests/indexing/multiindex/test_setitem.py
index c383c38958692..1e641760f7e8d 100644
--- a/pandas/tests/indexing/multiindex/test_setitem.py
+++ b/pandas/tests/indexing/multiindex/test_setitem.py
@@ -4,8 +4,8 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range, isna, notna
+import pandas._testing as tm
 import pandas.core.common as com
-from pandas.util import testing as tm
 
 
 class TestMultiIndexSetItem:
@@ -141,7 +141,7 @@ def test_multiindex_setitem(self):
             df.loc["bar"] *= 2
 
         # from SO
-        # http://stackoverflow.com/questions/24572040/pandas-access-the-level-of-multiindex-for-inplace-operation
+        # https://stackoverflow.com/questions/24572040/pandas-access-the-level-of-multiindex-for-inplace-operation
         df_orig = DataFrame.from_dict(
             {
                 "price": {
@@ -414,6 +414,16 @@ def test_astype_assignment_with_dups(self):
         df["A"] = df["A"].astype(np.float64)
         tm.assert_index_equal(df.index, index)
 
+    def test_setitem_nonmonotonic(self):
+        # https://github.com/pandas-dev/pandas/issues/31449
+        index = pd.MultiIndex.from_tuples(
+            [("a", "c"), ("b", "x"), ("a", "d")], names=["l1", "l2"]
+        )
+        df = pd.DataFrame(data=[0, 1, 2], index=index, columns=["e"])
+        df.loc["a", "e"] = np.arange(99, 101, dtype="int64")
+        expected = pd.DataFrame({"e": [99, 1, 100]}, index=index)
+        tm.assert_frame_equal(df, expected)
+
 
 def test_frame_setitem_view_direct(multiindex_dataframe_random_data):
     # this works because we are modifying the underlying array
diff --git a/pandas/tests/indexing/multiindex/test_slice.py b/pandas/tests/indexing/multiindex/test_slice.py
index 692a86aa1a338..6fa9d3bd2cdbb 100644
--- a/pandas/tests/indexing/multiindex/test_slice.py
+++ b/pandas/tests/indexing/multiindex/test_slice.py
@@ -1,5 +1,3 @@
-from warnings import catch_warnings
-
 import numpy as np
 import pytest
 
@@ -7,12 +5,11 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, Timestamp
+import pandas._testing as tm
 from pandas.core.indexing import _non_reducing_slice
 from pandas.tests.indexing.common import _mklbl
-from pandas.util import testing as tm
 
 
-@pytest.mark.filterwarnings("ignore:\\n.ix:FutureWarning")
 class TestMultiIndexSlicers:
     def test_per_axis_per_level_getitem(self):
 
@@ -492,6 +489,44 @@ def test_loc_axis_arguments(self):
         with pytest.raises(ValueError):
             df.loc(axis="foo")[:, :, ["C1", "C3"]]
 
+    def test_loc_axis_single_level_multi_col_indexing_multiindex_col_df(self):
+
+        # GH29519
+        df = pd.DataFrame(
+            np.arange(27).reshape(3, 9),
+            columns=pd.MultiIndex.from_product(
+                [["a1", "a2", "a3"], ["b1", "b2", "b3"]]
+            ),
+        )
+        result = df.loc(axis=1)["a1":"a2"]
+        expected = df.iloc[:, :-3]
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_axis_single_level_single_col_indexing_multiindex_col_df(self):
+
+        # GH29519
+        df = pd.DataFrame(
+            np.arange(27).reshape(3, 9),
+            columns=pd.MultiIndex.from_product(
+                [["a1", "a2", "a3"], ["b1", "b2", "b3"]]
+            ),
+        )
+        result = df.loc(axis=1)["a1"]
+        expected = df.iloc[:, :3]
+        expected.columns = ["b1", "b2", "b3"]
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_ax_single_level_indexer_simple_df(self):
+
+        # GH29519
+        # test single level indexing on single index column data frame
+        df = pd.DataFrame(np.arange(9).reshape(3, 3), columns=["a", "b", "c"])
+        result = df.loc(axis=1)["a"]
+        expected = pd.Series(np.array([0, 3, 6]), name="a")
+        tm.assert_series_equal(result, expected)
+
     def test_per_axis_per_level_setitem(self):
 
         # test index maker
@@ -637,8 +672,6 @@ def test_multiindex_label_slicing_with_negative_step(self):
         def assert_slices_equivalent(l_slc, i_slc):
             tm.assert_series_equal(s.loc[l_slc], s.iloc[i_slc])
             tm.assert_series_equal(s[l_slc], s.iloc[i_slc])
-            with catch_warnings(record=True):
-                tm.assert_series_equal(s.ix[l_slc], s.iloc[i_slc])
 
         assert_slices_equivalent(SLC[::-1], SLC[::-1])
 
diff --git a/pandas/tests/indexing/multiindex/test_sorted.py b/pandas/tests/indexing/multiindex/test_sorted.py
index 43ad66b7d1116..4bec0f429a34e 100644
--- a/pandas/tests/indexing/multiindex/test_sorted.py
+++ b/pandas/tests/indexing/multiindex/test_sorted.py
@@ -2,7 +2,7 @@
 from numpy.random import randn
 
 from pandas import DataFrame, MultiIndex, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestMultiIndexSorted:
diff --git a/pandas/tests/indexing/multiindex/test_xs.py b/pandas/tests/indexing/multiindex/test_xs.py
index 5e58b3ec155ed..db8c0c643a623 100644
--- a/pandas/tests/indexing/multiindex/test_xs.py
+++ b/pandas/tests/indexing/multiindex/test_xs.py
@@ -1,11 +1,9 @@
-from itertools import product
-
 import numpy as np
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex, Series, concat, date_range
+import pandas._testing as tm
 import pandas.core.common as com
-from pandas.util import testing as tm
 
 
 @pytest.fixture
@@ -159,10 +157,8 @@ def test_xs_setting_with_copy_error_multiple(four_level_index_dataframe):
 def test_xs_integer_key():
     # see gh-2107
     dates = range(20111201, 20111205)
-    ids = "abcde"
-    index = MultiIndex.from_tuples(
-        [x for x in product(dates, ids)], names=["date", "secid"]
-    )
+    ids = list("abcde")
+    index = MultiIndex.from_product([dates, ids], names=["date", "secid"])
     df = DataFrame(np.random.randn(len(index), 3), index, ["X", "Y", "Z"])
 
     result = df.xs(20111201, level="date")
@@ -211,7 +207,7 @@ def test_xs_level_series_ymd(multiindex_year_month_day_dataframe_random_data):
 
 
 def test_xs_level_series_slice_not_implemented(
-    multiindex_year_month_day_dataframe_random_data
+    multiindex_year_month_day_dataframe_random_data,
 ):
     # this test is not explicitly testing .xs functionality
     # TODO: move to another module or refactor
diff --git a/pandas/tests/indexing/test_callable.py b/pandas/tests/indexing/test_callable.py
index aa73bd728595f..621417eb38d94 100644
--- a/pandas/tests/indexing/test_callable.py
+++ b/pandas/tests/indexing/test_callable.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestIndexingCallable:
@@ -17,10 +17,14 @@ def test_frame_loc_callable(self):
         res = df.loc[lambda x: x.A > 2]
         tm.assert_frame_equal(res, df.loc[df.A > 2])
 
-        res = df.loc[lambda x: x.A > 2,]  # noqa: E231
+        res = df.loc[
+            lambda x: x.A > 2,
+        ]  # noqa: E231
         tm.assert_frame_equal(res, df.loc[df.A > 2,])  # noqa: E231
 
-        res = df.loc[lambda x: x.A > 2,]  # noqa: E231
+        res = df.loc[
+            lambda x: x.A > 2,
+        ]  # noqa: E231
         tm.assert_frame_equal(res, df.loc[df.A > 2,])  # noqa: E231
 
         res = df.loc[lambda x: x.B == "b", :]
@@ -90,7 +94,9 @@ def test_frame_loc_callable_labels(self):
         res = df.loc[lambda x: ["A", "C"]]
         tm.assert_frame_equal(res, df.loc[["A", "C"]])
 
-        res = df.loc[lambda x: ["A", "C"],]  # noqa: E231
+        res = df.loc[
+            lambda x: ["A", "C"],
+        ]  # noqa: E231
         tm.assert_frame_equal(res, df.loc[["A", "C"],])  # noqa: E231
 
         res = df.loc[lambda x: ["A", "C"], :]
diff --git a/pandas/tests/indexing/test_categorical.py b/pandas/tests/indexing/test_categorical.py
index c365c985eb4b6..da935b1c911d0 100644
--- a/pandas/tests/indexing/test_categorical.py
+++ b/pandas/tests/indexing/test_categorical.py
@@ -12,11 +12,12 @@
     Index,
     Interval,
     Series,
+    Timedelta,
     Timestamp,
+    conftest,
 )
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype as CDT
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 class TestCategoricalIndex:
@@ -52,7 +53,7 @@ def test_loc_scalar(self):
         expected = DataFrame(
             {"A": [0, 1, 5], "B": (Series(list("aaa")).astype(CDT(list("cab"))))}
         ).set_index("B")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = self.df.copy()
         df.loc["a"] = 20
@@ -62,7 +63,7 @@ def test_loc_scalar(self):
                 "B": (Series(list("aabbca")).astype(CDT(list("cab")))),
             }
         ).set_index("B")
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         # value not in the categories
         with pytest.raises(KeyError, match=r"^'d'$"):
@@ -73,14 +74,21 @@ def test_loc_scalar(self):
             df.loc["d"] = 10
 
         msg = (
-            "cannot insert an item into a CategoricalIndex that is not"
-            " already an existing category"
+            "cannot insert an item into a CategoricalIndex that is not "
+            "already an existing category"
         )
         with pytest.raises(TypeError, match=msg):
             df.loc["d", "A"] = 10
         with pytest.raises(TypeError, match=msg):
             df.loc["d", "C"] = 10
 
+        msg = (
+            "cannot do label indexing on CategoricalIndex with these "
+            r"indexers \[1\] of type int"
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.loc[1]
+
     def test_getitem_scalar(self):
 
         cats = Categorical([Timestamp("12-31-1999"), Timestamp("12-31-2000")])
@@ -329,12 +337,12 @@ def test_loc_listlike(self):
         # list of labels
         result = self.df.loc[["c", "a"]]
         expected = self.df.iloc[[4, 0, 1, 5]]
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         result = self.df2.loc[["a", "b", "e"]]
         exp_index = CategoricalIndex(list("aaabbe"), categories=list("cabe"), name="B")
         expected = DataFrame({"A": [0, 1, 5, 2, 3, np.nan]}, index=exp_index)
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # element in the categories but not in the values
         with pytest.raises(KeyError, match=r"^'e'$"):
@@ -346,19 +354,20 @@ def test_loc_listlike(self):
         result = df.loc[["a", "b", "e"]]
         exp_index = CategoricalIndex(list("aaabbe"), categories=list("cabe"), name="B")
         expected = DataFrame({"A": [0, 1, 5, 2, 3, 20]}, index=exp_index)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = self.df2.copy()
         result = df.loc[["a", "b", "e"]]
         exp_index = CategoricalIndex(list("aaabbe"), categories=list("cabe"), name="B")
         expected = DataFrame({"A": [0, 1, 5, 2, 3, np.nan]}, index=exp_index)
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # not all labels in the categories
         with pytest.raises(
             KeyError,
-            match="'a list-indexer must only include values that are in the"
-            " categories'",
+            match=(
+                "'a list-indexer must only include values that are in the categories'"
+            ),
         ):
             self.df2.loc[["a", "d"]]
 
@@ -473,8 +482,8 @@ def test_getitem_with_listlike(self):
             [[1, 0], [0, 1]], dtype="uint8", index=[0, 1], columns=cats
         )
         dummies = pd.get_dummies(cats)
-        result = dummies[[c for c in dummies.columns]]
-        assert_frame_equal(result, expected)
+        result = dummies[list(dummies.columns)]
+        tm.assert_frame_equal(result, expected)
 
     def test_setitem_listlike(self):
 
@@ -500,18 +509,18 @@ def test_ix_categorical_index(self):
         cdf.columns = CategoricalIndex(df.columns)
 
         expect = Series(df.loc["A", :], index=cdf.columns, name="A")
-        assert_series_equal(cdf.loc["A", :], expect)
+        tm.assert_series_equal(cdf.loc["A", :], expect)
 
         expect = Series(df.loc[:, "X"], index=cdf.index, name="X")
-        assert_series_equal(cdf.loc[:, "X"], expect)
+        tm.assert_series_equal(cdf.loc[:, "X"], expect)
 
         exp_index = CategoricalIndex(list("AB"), categories=["A", "B", "C"])
         expect = DataFrame(df.loc[["A", "B"], :], columns=cdf.columns, index=exp_index)
-        assert_frame_equal(cdf.loc[["A", "B"], :], expect)
+        tm.assert_frame_equal(cdf.loc[["A", "B"], :], expect)
 
         exp_columns = CategoricalIndex(list("XY"), categories=["X", "Y", "Z"])
         expect = DataFrame(df.loc[:, ["X", "Y"]], index=cdf.index, columns=exp_columns)
-        assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
+        tm.assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
 
         # non-unique
         df = DataFrame(np.random.randn(3, 3), index=list("ABA"), columns=list("XYX"))
@@ -521,25 +530,25 @@ def test_ix_categorical_index(self):
 
         exp_index = CategoricalIndex(list("AA"), categories=["A", "B"])
         expect = DataFrame(df.loc["A", :], columns=cdf.columns, index=exp_index)
-        assert_frame_equal(cdf.loc["A", :], expect)
+        tm.assert_frame_equal(cdf.loc["A", :], expect)
 
         exp_columns = CategoricalIndex(list("XX"), categories=["X", "Y"])
         expect = DataFrame(df.loc[:, "X"], index=cdf.index, columns=exp_columns)
-        assert_frame_equal(cdf.loc[:, "X"], expect)
+        tm.assert_frame_equal(cdf.loc[:, "X"], expect)
 
         expect = DataFrame(
             df.loc[["A", "B"], :],
             columns=cdf.columns,
             index=CategoricalIndex(list("AAB")),
         )
-        assert_frame_equal(cdf.loc[["A", "B"], :], expect)
+        tm.assert_frame_equal(cdf.loc[["A", "B"], :], expect)
 
         expect = DataFrame(
             df.loc[:, ["X", "Y"]],
             index=cdf.index,
             columns=CategoricalIndex(list("XXY")),
         )
-        assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
+        tm.assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
 
     def test_read_only_source(self):
         # GH 10043
@@ -550,121 +559,109 @@ def test_read_only_source(self):
         ro_array.setflags(write=False)
         ro_df = DataFrame(ro_array)
 
-        assert_frame_equal(rw_df.iloc[[1, 2, 3]], ro_df.iloc[[1, 2, 3]])
-        assert_frame_equal(rw_df.iloc[[1]], ro_df.iloc[[1]])
-        assert_series_equal(rw_df.iloc[1], ro_df.iloc[1])
-        assert_frame_equal(rw_df.iloc[1:3], ro_df.iloc[1:3])
+        tm.assert_frame_equal(rw_df.iloc[[1, 2, 3]], ro_df.iloc[[1, 2, 3]])
+        tm.assert_frame_equal(rw_df.iloc[[1]], ro_df.iloc[[1]])
+        tm.assert_series_equal(rw_df.iloc[1], ro_df.iloc[1])
+        tm.assert_frame_equal(rw_df.iloc[1:3], ro_df.iloc[1:3])
 
-        assert_frame_equal(rw_df.loc[[1, 2, 3]], ro_df.loc[[1, 2, 3]])
-        assert_frame_equal(rw_df.loc[[1]], ro_df.loc[[1]])
-        assert_series_equal(rw_df.loc[1], ro_df.loc[1])
-        assert_frame_equal(rw_df.loc[1:3], ro_df.loc[1:3])
+        tm.assert_frame_equal(rw_df.loc[[1, 2, 3]], ro_df.loc[[1, 2, 3]])
+        tm.assert_frame_equal(rw_df.loc[[1]], ro_df.loc[[1]])
+        tm.assert_series_equal(rw_df.loc[1], ro_df.loc[1])
+        tm.assert_frame_equal(rw_df.loc[1:3], ro_df.loc[1:3])
 
     def test_reindexing(self):
+        df = DataFrame(
+            {
+                "A": np.arange(3, dtype="int64"),
+                "B": Series(list("abc")).astype(CDT(list("cabe"))),
+            }
+        ).set_index("B")
 
         # reindexing
         # convert to a regular index
-        result = self.df2.reindex(["a", "b", "e"])
-        expected = DataFrame(
-            {"A": [0, 1, 5, 2, 3, np.nan], "B": Series(list("aaabbe"))}
-        ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        result = df.reindex(["a", "b", "e"])
+        expected = DataFrame({"A": [0, 1, np.nan], "B": Series(list("abe"))}).set_index(
+            "B"
+        )
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["a", "b"])
-        expected = DataFrame(
-            {"A": [0, 1, 5, 2, 3], "B": Series(list("aaabb"))}
-        ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        result = df.reindex(["a", "b"])
+        expected = DataFrame({"A": [0, 1], "B": Series(list("ab"))}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["e"])
+        result = df.reindex(["e"])
         expected = DataFrame({"A": [np.nan], "B": Series(["e"])}).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["d"])
+        result = df.reindex(["d"])
         expected = DataFrame({"A": [np.nan], "B": Series(["d"])}).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # since we are actually reindexing with a Categorical
         # then return a Categorical
         cats = list("cabe")
 
-        result = self.df2.reindex(Categorical(["a", "d"], categories=cats))
+        result = df.reindex(Categorical(["a", "e"], categories=cats))
         expected = DataFrame(
-            {"A": [0, 1, 5, np.nan], "B": Series(list("aaad")).astype(CDT(cats))}
+            {"A": [0, np.nan], "B": Series(list("ae")).astype(CDT(cats))}
         ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(Categorical(["a"], categories=cats))
+        result = df.reindex(Categorical(["a"], categories=cats))
         expected = DataFrame(
-            {"A": [0, 1, 5], "B": Series(list("aaa")).astype(CDT(cats))}
+            {"A": [0], "B": Series(list("a")).astype(CDT(cats))}
         ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["a", "b", "e"])
-        expected = DataFrame(
-            {"A": [0, 1, 5, 2, 3, np.nan], "B": Series(list("aaabbe"))}
-        ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        result = df.reindex(["a", "b", "e"])
+        expected = DataFrame({"A": [0, 1, np.nan], "B": Series(list("abe"))}).set_index(
+            "B"
+        )
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["a", "b"])
-        expected = DataFrame(
-            {"A": [0, 1, 5, 2, 3], "B": Series(list("aaabb"))}
-        ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        result = df.reindex(["a", "b"])
+        expected = DataFrame({"A": [0, 1], "B": Series(list("ab"))}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(["e"])
+        result = df.reindex(["e"])
         expected = DataFrame({"A": [np.nan], "B": Series(["e"])}).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # give back the type of categorical that we received
-        result = self.df2.reindex(
-            Categorical(["a", "d"], categories=cats, ordered=True)
-        )
+        result = df.reindex(Categorical(["a", "e"], categories=cats, ordered=True))
         expected = DataFrame(
-            {
-                "A": [0, 1, 5, np.nan],
-                "B": Series(list("aaad")).astype(CDT(cats, ordered=True)),
-            }
+            {"A": [0, np.nan], "B": Series(list("ae")).astype(CDT(cats, ordered=True))}
         ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
-        result = self.df2.reindex(Categorical(["a", "d"], categories=["a", "d"]))
+        result = df.reindex(Categorical(["a", "d"], categories=["a", "d"]))
         expected = DataFrame(
-            {"A": [0, 1, 5, np.nan], "B": Series(list("aaad")).astype(CDT(["a", "d"]))}
+            {"A": [0, np.nan], "B": Series(list("ad")).astype(CDT(["a", "d"]))}
         ).set_index("B")
-        assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
 
         # passed duplicate indexers are not allowed
-        msg = "cannot reindex with a non-unique indexer"
+        msg = "cannot reindex from a duplicate axis"
         with pytest.raises(ValueError, match=msg):
-            self.df2.reindex(["a", "a"])
+            self.df2.reindex(["a", "b"])
 
         # args NotImplemented ATM
         msg = r"argument {} is not implemented for CategoricalIndex\.reindex"
         with pytest.raises(NotImplementedError, match=msg.format("method")):
-            self.df2.reindex(["a"], method="ffill")
+            df.reindex(["a"], method="ffill")
         with pytest.raises(NotImplementedError, match=msg.format("level")):
-            self.df2.reindex(["a"], level=1)
+            df.reindex(["a"], level=1)
         with pytest.raises(NotImplementedError, match=msg.format("limit")):
-            self.df2.reindex(["a"], limit=2)
+            df.reindex(["a"], limit=2)
 
     def test_loc_slice(self):
-        # slicing
-        # not implemented ATM
         # GH9748
-
-        msg = (
-            "cannot do slice indexing on {klass} with these "
-            r"indexers \[1\] of {kind}".format(
-                klass=str(CategoricalIndex), kind=str(int)
-            )
-        )
-        with pytest.raises(TypeError, match=msg):
+        with pytest.raises(KeyError, match="1"):
             self.df.loc[1:5]
 
-        # result = df.loc[1:5]
-        # expected = df.iloc[[1,2,3,4]]
-        # assert_frame_equal(result, expected)
+        result = self.df.loc["b":"c"]
+        expected = self.df.iloc[[2, 3, 4]]
+        tm.assert_frame_equal(result, expected)
 
     def test_loc_and_at_with_categorical_index(self):
         # GH 20629
@@ -684,19 +681,19 @@ def test_boolean_selection(self):
 
         result = df3[df3.index == "a"]
         expected = df3.iloc[[]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df4[df4.index == "a"]
         expected = df4.iloc[[]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df3[df3.index == 1]
         expected = df3.iloc[[0, 1, 3]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df4[df4.index == 1]
         expected = df4.iloc[[0, 1, 3]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # since we have an ordered categorical
 
@@ -706,11 +703,11 @@ def test_boolean_selection(self):
         #         name='B')
         result = df3[df3.index < 2]
         expected = df3.iloc[[4]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df3[df3.index > 1]
         expected = df3.iloc[[]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # unordered
         # cannot be compared
@@ -758,3 +755,68 @@ def test_map_with_dict_or_series(self):
         output = cur_index.map(mapper)
         # Order of categories in output can be different
         tm.assert_index_equal(expected, output)
+
+    @pytest.mark.parametrize(
+        "idx_values",
+        [
+            # python types
+            [1, 2, 3],
+            [-1, -2, -3],
+            [1.5, 2.5, 3.5],
+            [-1.5, -2.5, -3.5],
+            # numpy int/uint
+            *[np.array([1, 2, 3], dtype=dtype) for dtype in conftest.ALL_INT_DTYPES],
+            # numpy floats
+            *[np.array([1.5, 2.5, 3.5], dtype=dtyp) for dtyp in conftest.FLOAT_DTYPES],
+            # numpy object
+            np.array([1, "b", 3.5], dtype=object),
+            # pandas scalars
+            [Interval(1, 4), Interval(4, 6), Interval(6, 9)],
+            [Timestamp(2019, 1, 1), Timestamp(2019, 2, 1), Timestamp(2019, 3, 1)],
+            [Timedelta(1, "d"), Timedelta(2, "d"), Timedelta(3, "D")],
+            # pandas Integer arrays
+            *[pd.array([1, 2, 3], dtype=dtype) for dtype in conftest.ALL_EA_INT_DTYPES],
+            # other pandas arrays
+            pd.IntervalIndex.from_breaks([1, 4, 6, 9]).array,
+            pd.date_range("2019-01-01", periods=3).array,
+            pd.timedelta_range(start="1d", periods=3).array,
+        ],
+    )
+    def test_loc_with_non_string_categories(self, idx_values, ordered_fixture):
+        # GH-17569
+        cat_idx = CategoricalIndex(idx_values, ordered=ordered_fixture)
+        df = DataFrame({"A": ["foo", "bar", "baz"]}, index=cat_idx)
+        sl = slice(idx_values[0], idx_values[1])
+
+        # scalar selection
+        result = df.loc[idx_values[0]]
+        expected = Series(["foo"], index=["A"], name=idx_values[0])
+        tm.assert_series_equal(result, expected)
+
+        # list selection
+        result = df.loc[idx_values[:2]]
+        expected = DataFrame(["foo", "bar"], index=cat_idx[:2], columns=["A"])
+        tm.assert_frame_equal(result, expected)
+
+        # slice selection
+        result = df.loc[sl]
+        expected = DataFrame(["foo", "bar"], index=cat_idx[:2], columns=["A"])
+        tm.assert_frame_equal(result, expected)
+
+        # scalar assignment
+        result = df.copy()
+        result.loc[idx_values[0]] = "qux"
+        expected = DataFrame({"A": ["qux", "bar", "baz"]}, index=cat_idx)
+        tm.assert_frame_equal(result, expected)
+
+        # list assignment
+        result = df.copy()
+        result.loc[idx_values[:2], "A"] = ["qux", "qux2"]
+        expected = DataFrame({"A": ["qux", "qux2", "baz"]}, index=cat_idx)
+        tm.assert_frame_equal(result, expected)
+
+        # slice assignment
+        result = df.copy()
+        result.loc[sl, "A"] = ["qux", "qux2"]
+        expected = DataFrame({"A": ["qux", "qux2", "baz"]}, index=cat_idx)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index 702bf0b15dec9..e845487ffca9a 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -3,8 +3,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp, date_range, option_context
-from pandas.core import common as com
-from pandas.util import testing as tm
+import pandas._testing as tm
+import pandas.core.common as com
 
 
 class TestCaching:
@@ -273,7 +273,7 @@ def random_text(nobs=100):
         str(df)
 
         # from SO:
-        # http://stackoverflow.com/questions/24054495/potential-bug-setting-value-for-undefined-column-using-iloc
+        # https://stackoverflow.com/questions/24054495/potential-bug-setting-value-for-undefined-column-using-iloc
         df = DataFrame(np.arange(0, 9), columns=["count"])
         df["group"] = "b"
 
@@ -361,13 +361,12 @@ def check(result, expected):
         result4 = df["A"].iloc[2]
         check(result4, expected)
 
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
     def test_cache_updating(self):
         # GH 4939, make sure to update the cache on setitem
 
         df = tm.makeDataFrame()
         df["A"]  # cache series
-        df.ix["Hello Friend"] = df.ix[0]
+        df.loc["Hello Friend"] = df.iloc[0]
         assert "Hello Friend" in df["A"].index
         assert "Hello Friend" in df["B"].index
 
@@ -393,14 +392,3 @@ def test_cache_updating(self):
         tm.assert_frame_equal(df, expected)
         expected = Series([0, 0, 0, 2, 0], name="f")
         tm.assert_series_equal(df.f, expected)
-
-    def test_deprecate_is_copy(self):
-        # GH18801
-        df = DataFrame({"A": [1, 2, 3]})
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # getter
-            df.is_copy
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # setter
-            df.is_copy = "test deprecated is_copy"
diff --git a/pandas/tests/indexing/test_check_indexer.py b/pandas/tests/indexing/test_check_indexer.py
new file mode 100644
index 0000000000000..82f8c12229824
--- /dev/null
+++ b/pandas/tests/indexing/test_check_indexer.py
@@ -0,0 +1,97 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.api.indexers import check_array_indexer
+
+
+@pytest.mark.parametrize(
+    "indexer, expected",
+    [
+        # integer
+        ([1, 2], np.array([1, 2], dtype=np.intp)),
+        (np.array([1, 2], dtype="int64"), np.array([1, 2], dtype=np.intp)),
+        (pd.array([1, 2], dtype="Int32"), np.array([1, 2], dtype=np.intp)),
+        (pd.Index([1, 2]), np.array([1, 2], dtype=np.intp)),
+        # boolean
+        ([True, False, True], np.array([True, False, True], dtype=np.bool_)),
+        (np.array([True, False, True]), np.array([True, False, True], dtype=np.bool_)),
+        (
+            pd.array([True, False, True], dtype="boolean"),
+            np.array([True, False, True], dtype=np.bool_),
+        ),
+        # other
+        ([], np.array([], dtype=np.intp)),
+    ],
+)
+def test_valid_input(indexer, expected):
+    array = np.array([1, 2, 3])
+    result = check_array_indexer(array, indexer)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer", [[True, False, None], pd.array([True, False, None], dtype="boolean")],
+)
+def test_bool_raise_missing_values(indexer):
+    array = np.array([1, 2, 3])
+
+    msg = "Cannot mask with a boolean indexer containing NA values"
+    with pytest.raises(ValueError, match=msg):
+        check_array_indexer(array, indexer)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [
+        [True, False],
+        pd.array([True, False], dtype="boolean"),
+        np.array([True, False], dtype=np.bool_),
+    ],
+)
+def test_bool_raise_length(indexer):
+    array = np.array([1, 2, 3])
+
+    msg = "Boolean index has wrong length"
+    with pytest.raises(IndexError, match=msg):
+        check_array_indexer(array, indexer)
+
+
+@pytest.mark.parametrize(
+    "indexer", [[0, 1, None], pd.array([0, 1, pd.NA], dtype="Int64")],
+)
+def test_int_raise_missing_values(indexer):
+    array = np.array([1, 2, 3])
+
+    msg = "Cannot index with an integer indexer containing NA values"
+    with pytest.raises(ValueError, match=msg):
+        check_array_indexer(array, indexer)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [
+        [0.0, 1.0],
+        np.array([1.0, 2.0], dtype="float64"),
+        np.array([True, False], dtype=object),
+        pd.Index([True, False], dtype=object),
+        pd.array(["a", "b"], dtype="string"),
+    ],
+)
+def test_raise_invalid_array_dtypes(indexer):
+    array = np.array([1, 2, 3])
+
+    msg = "arrays used as indices must be of integer or boolean type"
+    with pytest.raises(IndexError, match=msg):
+        check_array_indexer(array, indexer)
+
+
+@pytest.mark.parametrize(
+    "indexer", [None, Ellipsis, slice(0, 3), (None,)],
+)
+def test_pass_through_non_array_likes(indexer):
+    array = np.array([1, 2, 3])
+
+    result = check_array_indexer(array, indexer)
+    assert result == indexer
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index 05b58b0eca9b8..bea8eae9bb850 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -1,4 +1,5 @@
 import itertools
+from typing import Dict, List
 
 import numpy as np
 import pytest
@@ -6,7 +7,7 @@
 import pandas.compat as compat
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 ###############################################################
 # Index / Series common tests which may trigger dtype coercions
@@ -431,13 +432,19 @@ def test_insert_index_datetimes(self, fill_val, exp_dtype):
         )
         self._assert_insert_conversion(obj, fill_val, exp, exp_dtype)
 
-        msg = "Passed item and index have different timezone"
         if fill_val.tz:
-            with pytest.raises(ValueError, match=msg):
+            msg = "Cannot compare tz-naive and tz-aware"
+            with pytest.raises(TypeError, match=msg):
                 obj.insert(1, pd.Timestamp("2012-01-01"))
 
-        with pytest.raises(ValueError, match=msg):
-            obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
+            msg = "Timezones don't match"
+            with pytest.raises(ValueError, match=msg):
+                obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
+
+        else:
+            msg = "Cannot compare tz-naive and tz-aware"
+            with pytest.raises(TypeError, match=msg):
+                obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
 
         msg = "cannot insert DatetimeIndex with incompatible label"
         with pytest.raises(TypeError, match=msg):
@@ -478,22 +485,20 @@ def test_insert_index_period(self, insert, coerced_val, coerced_dtype):
         obj = pd.PeriodIndex(["2011-01", "2011-02", "2011-03", "2011-04"], freq="M")
         assert obj.dtype == "period[M]"
 
+        data = [
+            pd.Period("2011-01", freq="M"),
+            coerced_val,
+            pd.Period("2011-02", freq="M"),
+            pd.Period("2011-03", freq="M"),
+            pd.Period("2011-04", freq="M"),
+        ]
         if isinstance(insert, pd.Period):
-            index_type = pd.PeriodIndex
+            exp = pd.PeriodIndex(data, freq="M")
+            self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
         else:
-            index_type = pd.Index
-
-        exp = index_type(
-            [
-                pd.Period("2011-01", freq="M"),
-                coerced_val,
-                pd.Period("2011-02", freq="M"),
-                pd.Period("2011-03", freq="M"),
-                pd.Period("2011-04", freq="M"),
-            ],
-            freq="M",
-        )
-        self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
+            msg = r"Unexpected keyword arguments {'freq'}"
+            with pytest.raises(TypeError, match=msg):
+                pd.Index(data, freq="M")
 
     def test_insert_index_complex128(self):
         pass
@@ -514,12 +519,12 @@ def _assert_where_conversion(
         res = target.where(cond, values)
         self._assert(res, expected, expected_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
         [(1, np.object), (1.1, np.object), (1 + 1j, np.object), (True, np.object)],
     )
-    def test_where_object(self, klass, fill_val, exp_dtype):
+    def test_where_object(self, index_or_series, fill_val, exp_dtype):
+        klass = index_or_series
         obj = klass(list("abcd"))
         assert obj.dtype == np.object
         cond = klass([True, False, True, False])
@@ -540,12 +545,12 @@ def test_where_object(self, klass, fill_val, exp_dtype):
         exp = klass(["a", values[1], "c", values[3]])
         self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val,exp_dtype",
         [(1, np.int64), (1.1, np.float64), (1 + 1j, np.complex128), (True, np.object)],
     )
-    def test_where_int64(self, klass, fill_val, exp_dtype):
+    def test_where_int64(self, index_or_series, fill_val, exp_dtype):
+        klass = index_or_series
         if klass is pd.Index and exp_dtype is np.complex128:
             pytest.skip("Complex Index not supported")
         obj = klass([1, 2, 3, 4])
@@ -562,7 +567,6 @@ def test_where_int64(self, klass, fill_val, exp_dtype):
         exp = klass([1, values[1], 3, values[3]])
         self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val, exp_dtype",
         [
@@ -572,7 +576,8 @@ def test_where_int64(self, klass, fill_val, exp_dtype):
             (True, np.object),
         ],
     )
-    def test_where_float64(self, klass, fill_val, exp_dtype):
+    def test_where_float64(self, index_or_series, fill_val, exp_dtype):
+        klass = index_or_series
         if klass is pd.Index and exp_dtype is np.complex128:
             pytest.skip("Complex Index not supported")
         obj = klass([1.1, 2.2, 3.3, 4.4])
@@ -782,19 +787,18 @@ def _assert_fillna_conversion(self, original, value, expected, expected_dtype):
         res = target.fillna(value)
         self._assert(res, expected, expected_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val, fill_dtype",
         [(1, np.object), (1.1, np.object), (1 + 1j, np.object), (True, np.object)],
     )
-    def test_fillna_object(self, klass, fill_val, fill_dtype):
+    def test_fillna_object(self, index_or_series, fill_val, fill_dtype):
+        klass = index_or_series
         obj = klass(["a", np.nan, "c", "d"])
         assert obj.dtype == np.object
 
         exp = klass(["a", fill_val, "c", "d"])
         self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val,fill_dtype",
         [
@@ -804,7 +808,8 @@ def test_fillna_object(self, klass, fill_val, fill_dtype):
             (True, np.object),
         ],
     )
-    def test_fillna_float64(self, klass, fill_val, fill_dtype):
+    def test_fillna_float64(self, index_or_series, fill_val, fill_dtype):
+        klass = index_or_series
         obj = klass([1.1, np.nan, 3.3, 4.4])
         assert obj.dtype == np.float64
 
@@ -832,7 +837,6 @@ def test_fillna_series_complex128(self, fill_val, fill_dtype):
         exp = pd.Series([1 + 1j, fill_val, 3 + 3j, 4 + 4j])
         self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index], ids=["series", "index"])
     @pytest.mark.parametrize(
         "fill_val,fill_dtype",
         [
@@ -843,7 +847,8 @@ def test_fillna_series_complex128(self, fill_val, fill_dtype):
         ],
         ids=["datetime64", "datetime64tz", "object", "object"],
     )
-    def test_fillna_datetime(self, klass, fill_val, fill_dtype):
+    def test_fillna_datetime(self, index_or_series, fill_val, fill_dtype):
+        klass = index_or_series
         obj = klass(
             [
                 pd.Timestamp("2011-01-01"),
@@ -864,7 +869,6 @@ def test_fillna_datetime(self, klass, fill_val, fill_dtype):
         )
         self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.Index])
     @pytest.mark.parametrize(
         "fill_val,fill_dtype",
         [
@@ -875,7 +879,8 @@ def test_fillna_datetime(self, klass, fill_val, fill_dtype):
             ("x", np.object),
         ],
     )
-    def test_fillna_datetime64tz(self, klass, fill_val, fill_dtype):
+    def test_fillna_datetime64tz(self, index_or_series, fill_val, fill_dtype):
+        klass = index_or_series
         tz = "US/Eastern"
 
         obj = klass(
@@ -928,7 +933,7 @@ class TestReplaceSeriesCoercion(CoercionBase):
     klasses = ["series"]
     method = "replace"
 
-    rep = {}
+    rep: Dict[str, List] = {}
     rep["object"] = ["a", "b"]
     rep["int64"] = [4, 5]
     rep["float64"] = [1.1, 2.2]
@@ -938,7 +943,7 @@ class TestReplaceSeriesCoercion(CoercionBase):
 
     for tz in ["UTC", "US/Eastern"]:
         # to test tz => different tz replacement
-        key = "datetime64[ns, {0}]".format(tz)
+        key = f"datetime64[ns, {tz}]"
         rep[key] = [
             pd.Timestamp("2011-01-01", tz=tz),
             pd.Timestamp("2011-01-03", tz=tz),
@@ -987,10 +992,6 @@ class TestReplaceSeriesCoercion(CoercionBase):
         ],
     )
     def test_replace_series(self, how, to_key, from_key):
-        if from_key == "bool" and how == "series":
-            # doesn't work in PY3, though ...dict_from_bool works fine
-            pytest.skip("doesn't work as in PY3")
-
         index = pd.Index([3, 4], name="xxx")
         obj = pd.Series(self.rep[from_key], index=index, name="yyy")
         assert obj.dtype == from_key
@@ -1016,9 +1017,7 @@ def test_replace_series(self, how, to_key, from_key):
         ):
 
             if compat.is_platform_32bit() or compat.is_platform_windows():
-                pytest.skip(
-                    "32-bit platform buggy: {0} -> {1}".format(from_key, to_key)
-                )
+                pytest.skip(f"32-bit platform buggy: {from_key} -> {to_key}")
 
             # Expected: do not downcast by replacement
             exp = pd.Series(self.rep[to_key], index=index, name="yyy", dtype=from_key)
diff --git a/pandas/tests/indexing/test_datetime.py b/pandas/tests/indexing/test_datetime.py
index fb8f62d7a06c5..c8c2d1ed587cf 100644
--- a/pandas/tests/indexing/test_datetime.py
+++ b/pandas/tests/indexing/test_datetime.py
@@ -1,11 +1,12 @@
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
 
 from dateutil import tz
 import numpy as np
+import pytest
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, date_range
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestDatetimeIndex:
@@ -242,11 +243,8 @@ def test_series_partial_set_datetime(self):
             Timestamp("2011-01-02"),
             Timestamp("2011-01-03"),
         ]
-        exp = Series(
-            [np.nan, 0.2, np.nan], index=pd.DatetimeIndex(keys, name="idx"), name="s"
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            tm.assert_series_equal(ser.loc[keys], exp, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[keys]
 
     def test_series_partial_set_period(self):
         # GH 11497
@@ -273,12 +271,8 @@ def test_series_partial_set_period(self):
             pd.Period("2011-01-02", freq="D"),
             pd.Period("2011-01-03", freq="D"),
         ]
-        exp = Series(
-            [np.nan, 0.2, np.nan], index=pd.PeriodIndex(keys, name="idx"), name="s"
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[keys]
-        tm.assert_series_equal(result, exp)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[keys]
 
     def test_nanosecond_getitem_setitem_with_tz(self):
         # GH 11679
@@ -356,3 +350,23 @@ def test_loc_label_slicing(self):
         expected = ser.iloc[:-1]
 
         tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "slice_, positions",
+        [
+            [slice(date(2018, 1, 1), None), [0, 1, 2]],
+            [slice(date(2019, 1, 2), None), [2]],
+            [slice(date(2020, 1, 1), None), []],
+            [slice(None, date(2020, 1, 1)), [0, 1, 2]],
+            [slice(None, date(2019, 1, 1)), [0]],
+        ],
+    )
+    def test_getitem_slice_date(self, slice_, positions):
+        # https://github.com/pandas-dev/pandas/issues/31501
+        s = pd.Series(
+            [0, 1, 2],
+            pd.DatetimeIndex(["2019-01-01", "2019-01-01T06:00:00", "2019-01-02"]),
+        )
+        result = s[slice_]
+        expected = s.take(positions)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py
index 56a78081bc624..b3f6d65da5db5 100644
--- a/pandas/tests/indexing/test_floats.py
+++ b/pandas/tests/indexing/test_floats.py
@@ -2,8 +2,7 @@
 import pytest
 
 from pandas import DataFrame, Float64Index, Index, Int64Index, RangeIndex, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal, assert_series_equal
+import pandas._testing as tm
 
 
 class TestFloatIndexers:
@@ -21,18 +20,11 @@ def check(self, result, original, indexer, getitem):
             else:
                 expected = original.iloc[indexer]
 
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
-    def test_scalar_error(self):
-
-        # GH 4892
-        # float_indexers should raise exceptions
-        # on appropriate Index types & accessors
-        # this duplicates the code below
-        # but is specifically testing for the error
-        # message
-
-        for index in [
+    @pytest.mark.parametrize(
+        "index_func",
+        [
             tm.makeStringIndex,
             tm.makeUnicodeIndex,
             tm.makeCategoricalIndex,
@@ -41,128 +33,143 @@ def test_scalar_error(self):
             tm.makePeriodIndex,
             tm.makeIntIndex,
             tm.makeRangeIndex,
-        ]:
+        ],
+    )
+    def test_scalar_error(self, index_func):
 
-            i = index(5)
-
-            s = Series(np.arange(len(i)), index=i)
+        # GH 4892
+        # float_indexers should raise exceptions
+        # on appropriate Index types & accessors
+        # this duplicates the code below
+        # but is specifically testing for the error
+        # message
 
-            msg = "Cannot index by location index"
-            with pytest.raises(TypeError, match=msg):
-                s.iloc[3.0]
+        i = index_func(5)
 
-            msg = (
-                "cannot do positional indexing on {klass} with these "
-                r"indexers \[3\.0\] of {kind}".format(klass=type(i), kind=str(float))
-            )
-            with pytest.raises(TypeError, match=msg):
-                s.iloc[3.0] = 0
+        s = Series(np.arange(len(i)), index=i)
 
-    def test_scalar_non_numeric(self):
+        msg = "Cannot index by location index"
+        with pytest.raises(TypeError, match=msg):
+            s.iloc[3.0]
 
-        # GH 4892
-        # float_indexers should raise exceptions
-        # on appropriate Index types & accessors
+        msg = (
+            "cannot do positional indexing on {klass} with these "
+            r"indexers \[3\.0\] of type float".format(klass=type(i).__name__)
+        )
+        with pytest.raises(TypeError, match=msg):
+            s.iloc[3.0] = 0
 
-        for index in [
+    @pytest.mark.parametrize(
+        "index_func",
+        [
             tm.makeStringIndex,
             tm.makeUnicodeIndex,
             tm.makeCategoricalIndex,
             tm.makeDateIndex,
             tm.makeTimedeltaIndex,
             tm.makePeriodIndex,
-        ]:
+        ],
+    )
+    def test_scalar_non_numeric(self, index_func):
 
-            i = index(5)
+        # GH 4892
+        # float_indexers should raise exceptions
+        # on appropriate Index types & accessors
 
-            for s in [
-                Series(np.arange(len(i)), index=i),
-                DataFrame(np.random.randn(len(i), len(i)), index=i, columns=i),
-            ]:
+        i = index_func(5)
 
-                # getting
-                for idxr, getitem in [(lambda x: x.iloc, False), (lambda x: x, True)]:
+        for s in [
+            Series(np.arange(len(i)), index=i),
+            DataFrame(np.random.randn(len(i), len(i)), index=i, columns=i),
+        ]:
 
-                    # gettitem on a DataFrame is a KeyError as it is indexing
-                    # via labels on the columns
-                    if getitem and isinstance(s, DataFrame):
-                        error = KeyError
-                        msg = r"^3(\.0)?$"
-                    else:
-                        error = TypeError
-                        msg = (
-                            r"cannot do (label|index|positional) indexing"
-                            r" on {klass} with these indexers \[3\.0\] of"
-                            r" {kind}|"
-                            "Cannot index by location index with a"
-                            " non-integer key".format(klass=type(i), kind=str(float))
-                        )
-                    with pytest.raises(error, match=msg):
-                        idxr(s)[3.0]
-
-                # label based can be a TypeError or KeyError
-                if s.index.inferred_type in ["string", "unicode", "mixed"]:
+            # getting
+            for idxr, getitem in [(lambda x: x.iloc, False), (lambda x: x, True)]:
+
+                # gettitem on a DataFrame is a KeyError as it is indexing
+                # via labels on the columns
+                if getitem and isinstance(s, DataFrame):
                     error = KeyError
-                    msg = r"^3$"
+                    msg = r"^3(\.0)?$"
                 else:
                     error = TypeError
                     msg = (
-                        r"cannot do (label|index) indexing"
-                        r" on {klass} with these indexers \[3\.0\] of"
-                        r" {kind}".format(klass=type(i), kind=str(float))
+                        r"cannot do (label|positional) indexing "
+                        r"on {klass} with these indexers \[3\.0\] of "
+                        r"type float|"
+                        "Cannot index by location index with a "
+                        "non-integer key".format(klass=type(i).__name__)
                     )
                 with pytest.raises(error, match=msg):
-                    s.loc[3.0]
-
-                # contains
-                assert 3.0 not in s
-
-                # setting with a float fails with iloc
+                    idxr(s)[3.0]
+
+            # label based can be a TypeError or KeyError
+            if s.index.inferred_type in {
+                "categorical",
+                "string",
+                "unicode",
+                "mixed",
+            }:
+                error = KeyError
+                msg = r"^3\.0$"
+            else:
+                error = TypeError
                 msg = (
-                    r"cannot do (label|index|positional) indexing"
-                    r" on {klass} with these indexers \[3\.0\] of"
-                    r" {kind}".format(klass=type(i), kind=str(float))
+                    r"cannot do (label|positional) indexing "
+                    r"on {klass} with these indexers \[3\.0\] of "
+                    r"type float".format(klass=type(i).__name__)
                 )
-                with pytest.raises(TypeError, match=msg):
-                    s.iloc[3.0] = 0
-
-                # setting with an indexer
-                if s.index.inferred_type in ["categorical"]:
-                    # Value or Type Error
-                    pass
-                elif s.index.inferred_type in ["datetime64", "timedelta64", "period"]:
-
-                    # these should prob work
-                    # and are inconsisten between series/dataframe ATM
-                    # for idxr in [lambda x: x.ix,
-                    #             lambda x: x]:
-                    #    s2 = s.copy()
-                    #
-                    #    with pytest.raises(TypeError):
-                    #        idxr(s2)[3.0] = 0
-                    pass
-
-                else:
-
-                    s2 = s.copy()
-                    s2.loc[3.0] = 10
-                    assert s2.index.is_object()
+            with pytest.raises(error, match=msg):
+                s.loc[3.0]
 
-                    for idxr in [lambda x: x]:
-                        s2 = s.copy()
-                        idxr(s2)[3.0] = 0
-                        assert s2.index.is_object()
+            # contains
+            assert 3.0 not in s
 
-            # fallsback to position selection, series only
-            s = Series(np.arange(len(i)), index=i)
-            s[3]
+            # setting with a float fails with iloc
             msg = (
-                r"cannot do (label|index) indexing"
-                r" on {klass} with these indexers \[3\.0\] of"
-                r" {kind}".format(klass=type(i), kind=str(float))
+                r"cannot do (label|positional) indexing "
+                r"on {klass} with these indexers \[3\.0\] of "
+                r"type float".format(klass=type(i).__name__)
             )
             with pytest.raises(TypeError, match=msg):
-                s[3.0]
+                s.iloc[3.0] = 0
+
+            # setting with an indexer
+            if s.index.inferred_type in ["categorical"]:
+                # Value or Type Error
+                pass
+            elif s.index.inferred_type in ["datetime64", "timedelta64", "period"]:
+
+                # these should prob work
+                # and are inconsistent between series/dataframe ATM
+                # for idxr in [lambda x: x]:
+                #    s2 = s.copy()
+                #
+                #    with pytest.raises(TypeError):
+                #        idxr(s2)[3.0] = 0
+                pass
+
+            else:
+
+                s2 = s.copy()
+                s2.loc[3.0] = 10
+                assert s2.index.is_object()
+
+                for idxr in [lambda x: x]:
+                    s2 = s.copy()
+                    idxr(s2)[3.0] = 0
+                    assert s2.index.is_object()
+
+        # fallsback to position selection, series only
+        s = Series(np.arange(len(i)), index=i)
+        s[3]
+        msg = (
+            r"cannot do (label|positional) indexing "
+            r"on {klass} with these indexers \[3\.0\] of "
+            r"type float".format(klass=type(i).__name__)
+        )
+        with pytest.raises(TypeError, match=msg):
+            s[3.0]
 
     def test_scalar_with_mixed(self):
 
@@ -174,17 +181,17 @@ def test_scalar_with_mixed(self):
         for idxr in [lambda x: x, lambda x: x.iloc]:
 
             msg = (
-                r"cannot do label indexing"
-                r" on {klass} with these indexers \[1\.0\] of"
-                r" {kind}|"
+                r"cannot do label indexing "
+                r"on {klass} with these indexers \[1\.0\] of "
+                r"type float|"
                 "Cannot index by location index with a non-integer key".format(
-                    klass=str(Index), kind=str(float)
+                    klass=Index.__name__
                 )
             )
             with pytest.raises(TypeError, match=msg):
                 idxr(s2)[1.0]
 
-        with pytest.raises(KeyError, match=r"^1$"):
+        with pytest.raises(KeyError, match=r"^1\.0$"):
             s2.loc[1.0]
 
         result = s2.loc["b"]
@@ -196,9 +203,9 @@ def test_scalar_with_mixed(self):
         for idxr in [lambda x: x]:
 
             msg = (
-                r"cannot do label indexing"
-                r" on {klass} with these indexers \[1\.0\] of"
-                r" {kind}".format(klass=str(Index), kind=str(float))
+                r"cannot do label indexing "
+                r"on {klass} with these indexers \[1\.0\] of "
+                r"type float".format(klass=Index.__name__)
             )
             with pytest.raises(TypeError, match=msg):
                 idxr(s3)[1.0]
@@ -210,59 +217,63 @@ def test_scalar_with_mixed(self):
         msg = "Cannot index by location index with a non-integer key"
         with pytest.raises(TypeError, match=msg):
             s3.iloc[1.0]
-        with pytest.raises(KeyError, match=r"^1$"):
+        with pytest.raises(KeyError, match=r"^1\.0$"):
             s3.loc[1.0]
 
         result = s3.loc[1.5]
         expected = 3
         assert result == expected
 
-    def test_scalar_integer(self):
+    @pytest.mark.parametrize(
+        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
+    )
+    @pytest.mark.parametrize("klass", [Series, DataFrame])
+    def test_scalar_integer(self, index_func, klass):
 
         # test how scalar float indexers work on int indexes
 
         # integer index
-        for i in [Int64Index(range(5)), RangeIndex(5)]:
+        i = index_func(5)
 
-            for s in [
-                Series(np.arange(len(i))),
-                DataFrame(np.random.randn(len(i), len(i)), index=i, columns=i),
-            ]:
+        if klass is Series:
+            obj = Series(np.arange(len(i)))
+        else:
+            obj = DataFrame(np.random.randn(len(i), len(i)), index=i, columns=i)
 
-                # coerce to equal int
-                for idxr, getitem in [(lambda x: x.loc, False), (lambda x: x, True)]:
+        # coerce to equal int
+        for idxr, getitem in [(lambda x: x.loc, False), (lambda x: x, True)]:
 
-                    result = idxr(s)[3.0]
-                    self.check(result, s, 3, getitem)
+            result = idxr(obj)[3.0]
+            self.check(result, obj, 3, getitem)
 
-                # coerce to equal int
-                for idxr, getitem in [(lambda x: x.loc, False), (lambda x: x, True)]:
+        # coerce to equal int
+        for idxr, getitem in [(lambda x: x.loc, False), (lambda x: x, True)]:
 
-                    if isinstance(s, Series):
+            if isinstance(obj, Series):
 
-                        def compare(x, y):
-                            assert x == y
+                def compare(x, y):
+                    assert x == y
 
-                        expected = 100
-                    else:
-                        compare = tm.assert_series_equal
-                        if getitem:
-                            expected = Series(100, index=range(len(s)), name=3)
-                        else:
-                            expected = Series(100.0, index=range(len(s)), name=3)
+                expected = 100
+            else:
+                compare = tm.assert_series_equal
+                if getitem:
+                    expected = Series(100, index=range(len(obj)), name=3)
+                else:
+                    expected = Series(100.0, index=range(len(obj)), name=3)
 
-                    s2 = s.copy()
-                    idxr(s2)[3.0] = 100
+            s2 = obj.copy()
+            idxr(s2)[3.0] = 100
 
-                    result = idxr(s2)[3.0]
-                    compare(result, expected)
+            result = idxr(s2)[3.0]
+            compare(result, expected)
 
-                    result = idxr(s2)[3]
-                    compare(result, expected)
+            result = idxr(s2)[3]
+            compare(result, expected)
 
-                # contains
-                # coerce to equal int
-                assert 3.0 in s
+        # contains
+        # coerce to equal int
+        assert 3.0 in obj
 
     def test_scalar_float(self):
 
@@ -310,83 +321,77 @@ def test_scalar_float(self):
                 s.iloc[3.0]
 
             msg = (
-                r"cannot do positional indexing"
-                r" on {klass} with these indexers \[3\.0\] of"
-                r" {kind}".format(klass=str(Float64Index), kind=str(float))
+                r"cannot do positional indexing "
+                r"on {klass} with these indexers \[3\.0\] of "
+                r"type float".format(klass=Float64Index.__name__)
             )
             with pytest.raises(TypeError, match=msg):
                 s2.iloc[3.0] = 0
 
-    def test_slice_non_numeric(self):
-
-        # GH 4892
-        # float_indexers should raise exceptions
-        # on appropriate Index types & accessors
-
-        for index in [
+    @pytest.mark.parametrize(
+        "index_func",
+        [
             tm.makeStringIndex,
             tm.makeUnicodeIndex,
             tm.makeDateIndex,
             tm.makeTimedeltaIndex,
             tm.makePeriodIndex,
+        ],
+    )
+    def test_slice_non_numeric(self, index_func):
+
+        # GH 4892
+        # float_indexers should raise exceptions
+        # on appropriate Index types & accessors
+
+        index = index_func(5)
+        for s in [
+            Series(range(5), index=index),
+            DataFrame(np.random.randn(5, 2), index=index),
         ]:
 
-            index = index(5)
-            for s in [
-                Series(range(5), index=index),
-                DataFrame(np.random.randn(5, 2), index=index),
-            ]:
+            # getitem
+            for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+
+                msg = (
+                    "cannot do positional indexing "
+                    r"on {klass} with these indexers \[(3|4)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
+                )
+                with pytest.raises(TypeError, match=msg):
+                    s.iloc[l]
 
-                # getitem
-                for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+                for idxr in [lambda x: x.loc, lambda x: x.iloc, lambda x: x]:
 
                     msg = (
-                        "cannot do slice indexing"
-                        r" on {klass} with these indexers \[(3|4)\.0\] of"
-                        " {kind}".format(klass=type(index), kind=str(float))
+                        "cannot do (slice|positional) indexing "
+                        r"on {klass} with these indexers "
+                        r"\[(3|4)(\.0)?\] "
+                        r"of type (float|int)".format(klass=type(index).__name__)
                     )
                     with pytest.raises(TypeError, match=msg):
-                        s.iloc[l]
-
-                    for idxr in [lambda x: x.loc, lambda x: x.iloc, lambda x: x]:
-
-                        msg = (
-                            "cannot do slice indexing"
-                            r" on {klass} with these indexers"
-                            r" \[(3|4)(\.0)?\]"
-                            r" of ({kind_float}|{kind_int})".format(
-                                klass=type(index),
-                                kind_float=str(float),
-                                kind_int=str(int),
-                            )
-                        )
-                        with pytest.raises(TypeError, match=msg):
-                            idxr(s)[l]
-
-                # setitem
-                for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+                        idxr(s)[l]
 
+            # setitem
+            for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+
+                msg = (
+                    "cannot do positional indexing "
+                    r"on {klass} with these indexers \[(3|4)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
+                )
+                with pytest.raises(TypeError, match=msg):
+                    s.iloc[l] = 0
+
+                for idxr in [lambda x: x.loc, lambda x: x.iloc, lambda x: x]:
                     msg = (
-                        "cannot do slice indexing"
-                        r" on {klass} with these indexers \[(3|4)\.0\] of"
-                        " {kind}".format(klass=type(index), kind=str(float))
+                        "cannot do (slice|positional) indexing "
+                        r"on {klass} with these indexers "
+                        r"\[(3|4)(\.0)?\] "
+                        r"of type (float|int)".format(klass=type(index).__name__)
                     )
                     with pytest.raises(TypeError, match=msg):
-                        s.iloc[l] = 0
-
-                    for idxr in [lambda x: x.loc, lambda x: x.iloc, lambda x: x]:
-                        msg = (
-                            "cannot do slice indexing"
-                            r" on {klass} with these indexers"
-                            r" \[(3|4)(\.0)?\]"
-                            r" of ({kind_float}|{kind_int})".format(
-                                klass=type(index),
-                                kind_float=str(float),
-                                kind_int=str(int),
-                            )
-                        )
-                        with pytest.raises(TypeError, match=msg):
-                            idxr(s)[l] = 0
+                        idxr(s)[l] = 0
 
     def test_slice_integer(self):
 
@@ -421,9 +426,9 @@ def test_slice_integer(self):
 
                 # positional indexing
                 msg = (
-                    "cannot do slice indexing"
-                    r" on {klass} with these indexers \[(3|4)\.0\] of"
-                    " {kind}".format(klass=type(index), kind=str(float))
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[(3|4)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
                 )
                 with pytest.raises(TypeError, match=msg):
                     s[l]
@@ -445,9 +450,9 @@ def test_slice_integer(self):
 
             # positional indexing
             msg = (
-                "cannot do slice indexing"
-                r" on {klass} with these indexers \[-6\.0\] of"
-                " {kind}".format(klass=type(index), kind=str(float))
+                "cannot do slice indexing "
+                r"on {klass} with these indexers \[-6\.0\] of "
+                "type float".format(klass=type(index).__name__)
             )
             with pytest.raises(TypeError, match=msg):
                 s[slice(-6.0, 6.0)]
@@ -471,9 +476,9 @@ def test_slice_integer(self):
 
                 # positional indexing
                 msg = (
-                    "cannot do slice indexing"
-                    r" on {klass} with these indexers \[(2|3)\.5\] of"
-                    " {kind}".format(klass=type(index), kind=str(float))
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[(2|3)\.5\] of "
+                    "type float".format(klass=type(index).__name__)
                 )
                 with pytest.raises(TypeError, match=msg):
                     s[l]
@@ -489,22 +494,23 @@ def test_slice_integer(self):
 
                 # positional indexing
                 msg = (
-                    "cannot do slice indexing"
-                    r" on {klass} with these indexers \[(3|4)\.0\] of"
-                    " {kind}".format(klass=type(index), kind=str(float))
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[(3|4)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
                 )
                 with pytest.raises(TypeError, match=msg):
                     s[l] = 0
 
     def test_integer_positional_indexing(self):
         """ make sure that we are raising on positional indexing
-        w.r.t. an integer index """
+        w.r.t. an integer index
+        """
 
         s = Series(range(2, 6), index=range(2, 6))
 
         result = s[2:4]
         expected = s.iloc[2:4]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         for idxr in [lambda x: x, lambda x: x.iloc]:
 
@@ -512,90 +518,93 @@ def test_integer_positional_indexing(self):
 
                 klass = RangeIndex
                 msg = (
-                    "cannot do slice indexing"
-                    r" on {klass} with these indexers \[(2|4)\.0\] of"
-                    " {kind}".format(klass=str(klass), kind=str(float))
+                    "cannot do (slice|positional) indexing "
+                    r"on {klass} with these indexers \[(2|4)\.0\] of "
+                    "type float".format(klass=klass.__name__)
                 )
                 with pytest.raises(TypeError, match=msg):
                     idxr(s)[l]
 
-    def test_slice_integer_frame_getitem(self):
+    @pytest.mark.parametrize(
+        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
+    )
+    def test_slice_integer_frame_getitem(self, index_func):
 
         # similar to above, but on the getitem dim (of a DataFrame)
-        for index in [Int64Index(range(5)), RangeIndex(5)]:
+        index = index_func(5)
 
-            s = DataFrame(np.random.randn(5, 2), index=index)
+        s = DataFrame(np.random.randn(5, 2), index=index)
 
-            def f(idxr):
-
-                # getitem
-                for l in [slice(0.0, 1), slice(0, 1.0), slice(0.0, 1.0)]:
-
-                    result = idxr(s)[l]
-                    indexer = slice(0, 2)
-                    self.check(result, s, indexer, False)
+        def f(idxr):
 
-                    # positional indexing
-                    msg = (
-                        "cannot do slice indexing"
-                        r" on {klass} with these indexers \[(0|1)\.0\] of"
-                        " {kind}".format(klass=type(index), kind=str(float))
-                    )
-                    with pytest.raises(TypeError, match=msg):
-                        s[l]
-
-                # getitem out-of-bounds
-                for l in [slice(-10, 10), slice(-10.0, 10.0)]:
+            # getitem
+            for l in [slice(0.0, 1), slice(0, 1.0), slice(0.0, 1.0)]:
 
-                    result = idxr(s)[l]
-                    self.check(result, s, slice(-10, 10), True)
+                result = idxr(s)[l]
+                indexer = slice(0, 2)
+                self.check(result, s, indexer, False)
 
                 # positional indexing
                 msg = (
-                    "cannot do slice indexing"
-                    r" on {klass} with these indexers \[-10\.0\] of"
-                    " {kind}".format(klass=type(index), kind=str(float))
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[(0|1)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
                 )
                 with pytest.raises(TypeError, match=msg):
-                    s[slice(-10.0, 10.0)]
+                    s[l]
+
+            # getitem out-of-bounds
+            for l in [slice(-10, 10), slice(-10.0, 10.0)]:
 
-                # getitem odd floats
-                for l, res in [
-                    (slice(0.5, 1), slice(1, 2)),
-                    (slice(0, 0.5), slice(0, 1)),
-                    (slice(0.5, 1.5), slice(1, 2)),
-                ]:
+                result = idxr(s)[l]
+                self.check(result, s, slice(-10, 10), True)
 
-                    result = idxr(s)[l]
-                    self.check(result, s, res, False)
+            # positional indexing
+            msg = (
+                "cannot do slice indexing "
+                r"on {klass} with these indexers \[-10\.0\] of "
+                "type float".format(klass=type(index).__name__)
+            )
+            with pytest.raises(TypeError, match=msg):
+                s[slice(-10.0, 10.0)]
 
-                    # positional indexing
-                    msg = (
-                        "cannot do slice indexing"
-                        r" on {klass} with these indexers \[0\.5\] of"
-                        " {kind}".format(klass=type(index), kind=str(float))
-                    )
-                    with pytest.raises(TypeError, match=msg):
-                        s[l]
+            # getitem odd floats
+            for l, res in [
+                (slice(0.5, 1), slice(1, 2)),
+                (slice(0, 0.5), slice(0, 1)),
+                (slice(0.5, 1.5), slice(1, 2)),
+            ]:
 
-                # setitem
-                for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+                result = idxr(s)[l]
+                self.check(result, s, res, False)
 
-                    sc = s.copy()
-                    idxr(sc)[l] = 0
-                    result = idxr(sc)[l].values.ravel()
-                    assert (result == 0).all()
+                # positional indexing
+                msg = (
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[0\.5\] of "
+                    "type float".format(klass=type(index).__name__)
+                )
+                with pytest.raises(TypeError, match=msg):
+                    s[l]
 
-                    # positional indexing
-                    msg = (
-                        "cannot do slice indexing"
-                        r" on {klass} with these indexers \[(3|4)\.0\] of"
-                        " {kind}".format(klass=type(index), kind=str(float))
-                    )
-                    with pytest.raises(TypeError, match=msg):
-                        s[l] = 0
+            # setitem
+            for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
 
-            f(lambda x: x.loc)
+                sc = s.copy()
+                idxr(sc)[l] = 0
+                result = idxr(sc)[l].values.ravel()
+                assert (result == 0).all()
+
+                # positional indexing
+                msg = (
+                    "cannot do slice indexing "
+                    r"on {klass} with these indexers \[(3|4)\.0\] of "
+                    "type float".format(klass=type(index).__name__)
+                )
+                with pytest.raises(TypeError, match=msg):
+                    s[l] = 0
+
+        f(lambda x: x.loc)
 
     def test_slice_float(self):
 
@@ -642,8 +651,8 @@ def test_floating_misc(self):
         result1 = s[1.0:3.0]
         result2 = s.loc[1.0:3.0]
         result3 = s.loc[1.0:3.0]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
 
         # exact indexing when found
         result1 = s[5.0]
@@ -663,101 +672,91 @@ def test_floating_misc(self):
         # value not found (and no fallbacking at all)
 
         # scalar integers
-        with pytest.raises(KeyError, match=r"^4\.0$"):
+        with pytest.raises(KeyError, match=r"^4$"):
             s.loc[4]
-        with pytest.raises(KeyError, match=r"^4\.0$"):
+        with pytest.raises(KeyError, match=r"^4$"):
             s.loc[4]
-        with pytest.raises(KeyError, match=r"^4\.0$"):
+        with pytest.raises(KeyError, match=r"^4$"):
             s[4]
 
         # fancy floats/integers create the correct entry (as nan)
         # fancy tests
         expected = Series([2, 0], index=Float64Index([5.0, 0.0]))
         for fancy_idx in [[5.0, 0.0], np.array([5.0, 0.0])]:  # float
-            assert_series_equal(s[fancy_idx], expected)
-            assert_series_equal(s.loc[fancy_idx], expected)
-            assert_series_equal(s.loc[fancy_idx], expected)
+            tm.assert_series_equal(s[fancy_idx], expected)
+            tm.assert_series_equal(s.loc[fancy_idx], expected)
+            tm.assert_series_equal(s.loc[fancy_idx], expected)
 
         expected = Series([2, 0], index=Index([5, 0], dtype="int64"))
         for fancy_idx in [[5, 0], np.array([5, 0])]:  # int
-            assert_series_equal(s[fancy_idx], expected)
-            assert_series_equal(s.loc[fancy_idx], expected)
-            assert_series_equal(s.loc[fancy_idx], expected)
+            tm.assert_series_equal(s[fancy_idx], expected)
+            tm.assert_series_equal(s.loc[fancy_idx], expected)
+            tm.assert_series_equal(s.loc[fancy_idx], expected)
 
         # all should return the same as we are slicing 'the same'
         result1 = s.loc[2:5]
         result2 = s.loc[2.0:5.0]
         result3 = s.loc[2.0:5]
         result4 = s.loc[2.1:5]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, result4)
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result4)
 
         # previously this did fallback indexing
         result1 = s[2:5]
         result2 = s[2.0:5.0]
         result3 = s[2.0:5]
         result4 = s[2.1:5]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, result4)
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result4)
 
         result1 = s.loc[2:5]
         result2 = s.loc[2.0:5.0]
         result3 = s.loc[2.0:5]
         result4 = s.loc[2.1:5]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, result4)
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result4)
 
         # combined test
         result1 = s.loc[2:5]
         result2 = s.loc[2:5]
         result3 = s[2:5]
 
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
 
         # list selection
         result1 = s[[0.0, 5, 10]]
         result2 = s.loc[[0.0, 5, 10]]
         result3 = s.loc[[0.0, 5, 10]]
         result4 = s.iloc[[0, 2, 4]]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, result4)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result1 = s[[1.6, 5, 10]]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result2 = s.loc[[1.6, 5, 10]]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result3 = s.loc[[1.6, 5, 10]]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, Series([np.nan, 2, 4], index=[1.6, 5, 10]))
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result1 = s[[0, 1, 2]]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result2 = s.loc[[0, 1, 2]]
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result3 = s.loc[[0, 1, 2]]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, Series([0.0, np.nan, np.nan], index=[0, 1, 2]))
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, result4)
+
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s[[1.6, 5, 10]]
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[1.6, 5, 10]]
+
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s[[0, 1, 2]]
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[0, 1, 2]]
 
         result1 = s.loc[[2.5, 5]]
         result2 = s.loc[[2.5, 5]]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, Series([1, 2], index=[2.5, 5.0]))
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, Series([1, 2], index=[2.5, 5.0]))
 
         result1 = s[[2.5]]
         result2 = s.loc[[2.5]]
         result3 = s.loc[[2.5]]
-        assert_series_equal(result1, result2)
-        assert_series_equal(result1, result3)
-        assert_series_equal(result1, Series([1], index=[2.5]))
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+        tm.assert_series_equal(result1, Series([1], index=[2.5]))
 
     def test_floating_tuples(self):
         # see gh-13509
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 85eab91af3c48..500bd1853e9a4 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -1,18 +1,52 @@
 """ test positional based indexing with iloc """
 
-from warnings import catch_warnings, filterwarnings, simplefilter
+from datetime import datetime
+from warnings import catch_warnings, simplefilter
 
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Series, concat, date_range, isna
+import pandas._testing as tm
 from pandas.api.types import is_scalar
+from pandas.core.indexing import IndexingError
 from pandas.tests.indexing.common import Base
-from pandas.util import testing as tm
 
 
 class TestiLoc(Base):
+    def test_iloc_getitem_int(self):
+        # integer
+        self.check_result(
+            "iloc",
+            2,
+            typs=["labels", "mixed", "ts", "floats", "empty"],
+            fails=IndexError,
+        )
+
+    def test_iloc_getitem_neg_int(self):
+        # neg integer
+        self.check_result(
+            "iloc",
+            -1,
+            typs=["labels", "mixed", "ts", "floats", "empty"],
+            fails=IndexError,
+        )
+
+    def test_iloc_getitem_list_int(self):
+        self.check_result(
+            "iloc",
+            [0, 1, 2],
+            typs=["labels", "mixed", "ts", "floats", "empty"],
+            fails=IndexError,
+        )
+
+        # array of ints (GH5006), make sure that a single indexer is returning
+        # the correct type
+
+
+class TestiLoc2:
+    # TODO: better name, just separating out things that dont rely on base class
     def test_iloc_exceeds_bounds(self):
 
         # GH6296
@@ -121,7 +155,7 @@ def check(result, expected):
         [
             ([slice(None), ["A", "D"]]),
             (["1", "2"], slice(None)),
-            ([pd.datetime(2019, 1, 1)], slice(None)),
+            ([datetime(2019, 1, 1)], slice(None)),
         ],
     )
     def test_iloc_non_integer_raises(self, index, columns, index_vals, column_vals):
@@ -133,38 +167,6 @@ def test_iloc_non_integer_raises(self, index, columns, index_vals, column_vals):
         with pytest.raises(IndexError, match=msg):
             df.iloc[index_vals, column_vals]
 
-    def test_iloc_getitem_int(self):
-
-        # integer
-        self.check_result(
-            "integer", "iloc", 2, "ix", {0: 4, 1: 6, 2: 8}, typs=["ints", "uints"]
-        )
-        self.check_result(
-            "integer",
-            "iloc",
-            2,
-            "indexer",
-            2,
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
-
-    def test_iloc_getitem_neg_int(self):
-
-        # neg integer
-        self.check_result(
-            "neg int", "iloc", -1, "ix", {0: 6, 1: 9, 2: 12}, typs=["ints", "uints"]
-        )
-        self.check_result(
-            "neg int",
-            "iloc",
-            -1,
-            "indexer",
-            -1,
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
-
     @pytest.mark.parametrize("dims", [1, 2])
     def test_iloc_getitem_invalid_scalar(self, dims):
         # GH 21982
@@ -191,63 +193,6 @@ def test_iloc_array_not_mutating_negative_indices(self):
         df.iloc[:, array_with_neg_numbers]
         tm.assert_numpy_array_equal(array_with_neg_numbers, array_copy)
 
-    def test_iloc_getitem_list_int(self):
-
-        # list of ints
-        self.check_result(
-            "list int",
-            "iloc",
-            [0, 1, 2],
-            "ix",
-            {0: [0, 2, 4], 1: [0, 3, 6], 2: [0, 4, 8]},
-            typs=["ints", "uints"],
-        )
-        self.check_result(
-            "list int",
-            "iloc",
-            [2],
-            "ix",
-            {0: [4], 1: [6], 2: [8]},
-            typs=["ints", "uints"],
-        )
-        self.check_result(
-            "list int",
-            "iloc",
-            [0, 1, 2],
-            "indexer",
-            [0, 1, 2],
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
-
-        # array of ints (GH5006), make sure that a single indexer is returning
-        # the correct type
-        self.check_result(
-            "array int",
-            "iloc",
-            np.array([0, 1, 2]),
-            "ix",
-            {0: [0, 2, 4], 1: [0, 3, 6], 2: [0, 4, 8]},
-            typs=["ints", "uints"],
-        )
-        self.check_result(
-            "array int",
-            "iloc",
-            np.array([2]),
-            "ix",
-            {0: [4], 1: [6], 2: [8]},
-            typs=["ints", "uints"],
-        )
-        self.check_result(
-            "array int",
-            "iloc",
-            np.array([0, 1, 2]),
-            "indexer",
-            [0, 1, 2],
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
-
     def test_iloc_getitem_neg_int_can_reach_first_index(self):
         # GH10547 and GH10779
         # negative integers should be able to reach index 0
@@ -276,17 +221,6 @@ def test_iloc_getitem_neg_int_can_reach_first_index(self):
         tm.assert_series_equal(result, expected)
 
     def test_iloc_getitem_dups(self):
-
-        self.check_result(
-            "list int (dups)",
-            "iloc",
-            [0, 1, 1, 3],
-            "ix",
-            {0: [0, 2, 2, 6], 1: [0, 3, 3, 9]},
-            objs=["series", "frame"],
-            typs=["ints", "uints"],
-        )
-
         # GH 6766
         df1 = DataFrame([{"A": None, "B": 1}, {"A": 2, "B": 2}])
         df2 = DataFrame([{"A": 3, "B": 3}, {"A": 4, "B": 4}])
@@ -301,63 +235,24 @@ def test_iloc_getitem_dups(self):
         tm.assert_series_equal(result, expected)
 
     def test_iloc_getitem_array(self):
-
-        # array like
-        s = Series(index=range(1, 4))
-        self.check_result(
-            "array like",
-            "iloc",
-            s.index,
-            "ix",
-            {0: [2, 4, 6], 1: [3, 6, 9], 2: [4, 8, 12]},
-            typs=["ints", "uints"],
-        )
+        # TODO: test something here?
+        pass
 
     def test_iloc_getitem_bool(self):
-
-        # boolean indexers
-        b = [True, False, True, False]
-        self.check_result("bool", "iloc", b, "ix", b, typs=["ints", "uints"])
-        self.check_result(
-            "bool",
-            "iloc",
-            b,
-            "ix",
-            b,
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
+        # TODO: test something here?
+        pass
 
     @pytest.mark.parametrize("index", [[True, False], [True, False, True, False]])
     def test_iloc_getitem_bool_diff_len(self, index):
         # GH26658
         s = Series([1, 2, 3])
-        with pytest.raises(
-            IndexError,
-            match=("Item wrong length {} instead of {}.".format(len(index), len(s))),
-        ):
+        msg = f"Boolean index has wrong length: {len(index)} instead of {len(s)}"
+        with pytest.raises(IndexError, match=msg):
             _ = s.iloc[index]
 
     def test_iloc_getitem_slice(self):
-
-        # slices
-        self.check_result(
-            "slice",
-            "iloc",
-            slice(1, 3),
-            "ix",
-            {0: [2, 4], 1: [3, 6], 2: [4, 8]},
-            typs=["ints", "uints"],
-        )
-        self.check_result(
-            "slice",
-            "iloc",
-            slice(1, 3),
-            "indexer",
-            slice(1, 3),
-            typs=["labels", "mixed", "ts", "floats", "empty"],
-            fails=IndexError,
-        )
+        # TODO: test something here?
+        pass
 
     def test_iloc_getitem_slice_dups(self):
 
@@ -386,7 +281,9 @@ def test_iloc_getitem_slice_dups(self):
         tm.assert_frame_equal(df.iloc[10:, 2:], df1)
 
     def test_iloc_setitem(self):
-        df = self.frame_ints
+        df = DataFrame(
+            np.random.randn(4, 4), index=np.arange(0, 8, 2), columns=np.arange(0, 12, 3)
+        )
 
         df.iloc[1, 1] = 1
         result = df.iloc[1, 1]
@@ -462,69 +359,53 @@ def test_iloc_setitem_dups(self):
         df.iloc[[1, 0], [0, 1]] = df.iloc[[1, 0], [0, 1]].reset_index(drop=True)
         tm.assert_frame_equal(df, expected)
 
+    # TODO: GH#27620 this test used to compare iloc against ix; check if this
+    #  is redundant with another test comparing iloc against loc
     def test_iloc_getitem_frame(self):
         df = DataFrame(
             np.random.randn(10, 4), index=range(0, 20, 2), columns=range(0, 8, 2)
         )
 
         result = df.iloc[2]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            exp = df.ix[4]
+        exp = df.loc[4]
         tm.assert_series_equal(result, exp)
 
         result = df.iloc[2, 2]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            exp = df.ix[4, 4]
+        exp = df.loc[4, 4]
         assert result == exp
 
         # slice
         result = df.iloc[4:8]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[8:14]
+        expected = df.loc[8:14]
         tm.assert_frame_equal(result, expected)
 
         result = df.iloc[:, 2:3]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[:, 4:5]
+        expected = df.loc[:, 4:5]
         tm.assert_frame_equal(result, expected)
 
         # list of integers
         result = df.iloc[[0, 1, 3]]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[[0, 2, 6]]
+        expected = df.loc[[0, 2, 6]]
         tm.assert_frame_equal(result, expected)
 
         result = df.iloc[[0, 1, 3], [0, 1]]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[[0, 2, 6], [0, 2]]
+        expected = df.loc[[0, 2, 6], [0, 2]]
         tm.assert_frame_equal(result, expected)
 
         # neg indices
         result = df.iloc[[-1, 1, 3], [-1, 1]]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[[18, 2, 6], [6, 2]]
+        expected = df.loc[[18, 2, 6], [6, 2]]
         tm.assert_frame_equal(result, expected)
 
         # dups indices
         result = df.iloc[[-1, -1, 1, 3], [-1, 1]]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[[18, 18, 2, 6], [6, 2]]
+        expected = df.loc[[18, 18, 2, 6], [6, 2]]
         tm.assert_frame_equal(result, expected)
 
         # with index-like
-        s = Series(index=range(1, 5))
+        s = Series(index=range(1, 5), dtype=object)
         result = df.iloc[s.index]
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            expected = df.ix[[2, 4, 6, 8]]
+        expected = df.loc[[2, 4, 6, 8]]
         tm.assert_frame_equal(result, expected)
 
     def test_iloc_getitem_labelled_frame(self):
@@ -553,9 +434,9 @@ def test_iloc_getitem_labelled_frame(self):
 
         # trying to use a label
         msg = (
-            r"Location based indexing can only have \[integer, integer"
-            r" slice \(START point is INCLUDED, END point is EXCLUDED\),"
-            r" listlike of integers, boolean array\] types"
+            r"Location based indexing can only have \[integer, integer "
+            r"slice \(START point is INCLUDED, END point is EXCLUDED\), "
+            r"listlike of integers, boolean array\] types"
         )
         with pytest.raises(ValueError, match=msg):
             df.iloc["j", "D"]
@@ -722,16 +603,14 @@ def test_iloc_mask(self):
                         else:
                             accessor = df
                         ans = str(bin(accessor[mask]["nums"].sum()))
-                    except Exception as e:
+                    except (ValueError, IndexingError, NotImplementedError) as e:
                         ans = str(e)
 
                     key = tuple([idx, method])
                     r = expected.get(key)
                     if r != ans:
                         raise AssertionError(
-                            "[{key}] does not match [{ans}], received [{r}]".format(
-                                key=key, ans=ans, r=r
-                            )
+                            f"[{key}] does not match [{ans}], received [{r}]"
                         )
 
     def test_iloc_non_unique_indexing(self):
@@ -749,25 +628,12 @@ def test_iloc_non_unique_indexing(self):
         df2 = DataFrame({"A": [0.1] * 1000, "B": [1] * 1000})
         df2 = concat([df2, 2 * df2, 3 * df2])
 
-        sidx = df2.index.to_series()
-        expected = df2.iloc[idx[idx <= sidx.max()]]
-
-        new_list = []
-        for r, s in expected.iterrows():
-            new_list.append(s)
-            new_list.append(s * 2)
-            new_list.append(s * 3)
-
-        expected = DataFrame(new_list)
-        expected = concat([expected, DataFrame(index=idx[idx > sidx.max()])], sort=True)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df2.loc[idx]
-        tm.assert_frame_equal(result, expected, check_index_type=False)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df2.loc[idx]
 
     def test_iloc_empty_list_indexer_is_ok(self):
-        from pandas.util.testing import makeCustomDataframe as mkdf
 
-        df = mkdf(5, 2)
+        df = tm.makeCustomDataframe(5, 2)
         # vertical empty
         tm.assert_frame_equal(
             df.iloc[:, []],
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index e375bd459e66f..1b3e301b0fef0 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -7,24 +7,23 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PY36
 from pandas.errors import AbstractMethodError
 
 from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype
 
 import pandas as pd
 from pandas import DataFrame, Index, NaT, Series
+import pandas._testing as tm
 from pandas.core.generic import NDFrame
 from pandas.core.indexers import validate_indices
 from pandas.core.indexing import _maybe_numeric_slice, _non_reducing_slice
-from pandas.tests.indexing.common import Base, _mklbl
-import pandas.util.testing as tm
+from pandas.tests.indexing.common import _mklbl
 
 # ------------------------------------------------------------------------
 # Indexing test cases
 
 
-class TestFancy(Base):
+class TestFancy:
     """ pure get/set item & fancy indexing """
 
     def test_setitem_ndarray_1d(self):
@@ -81,44 +80,17 @@ def test_getitem_ndarray_3d(self, index, obj, idxr, idxr_id):
         idxr = idxr(obj)
         nd3 = np.random.randint(5, size=(2, 2, 2))
 
-        msg = (
-            r"Buffer has wrong number of dimensions \(expected 1,"
-            r" got 3\)|"
-            "The truth value of an array with more than one element is"
-            " ambiguous|"
-            "Cannot index with multidimensional key|"
-            r"Wrong number of dimensions. values.ndim != ndim \[3 != 1\]|"
-            "No matching signature found|"  # TypeError
-            "unhashable type: 'numpy.ndarray'"  # TypeError
+        msg = "|".join(
+            [
+                r"Buffer has wrong number of dimensions \(expected 1, got 3\)",
+                "Cannot index with multidimensional key",
+                r"Wrong number of dimensions. values.ndim != ndim \[3 != 1\]",
+                "Index data must be 1-dimensional",
+            ]
         )
 
-        if (
-            isinstance(obj, Series)
-            and idxr_id == "getitem"
-            and index.inferred_type
-            in [
-                "string",
-                "datetime64",
-                "period",
-                "timedelta64",
-                "boolean",
-                "categorical",
-            ]
-        ):
-            idxr[nd3]
-        else:
-            if (
-                isinstance(obj, DataFrame)
-                and idxr_id == "getitem"
-                and index.inferred_type == "boolean"
-            ):
-                error = TypeError
-            elif idxr_id == "getitem" and index.inferred_type == "interval":
-                error = TypeError
-            else:
-                error = ValueError
-
-            with pytest.raises(error, match=msg):
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
                 idxr[nd3]
 
     @pytest.mark.parametrize(
@@ -146,42 +118,24 @@ def test_setitem_ndarray_3d(self, index, obj, idxr, idxr_id):
         idxr = idxr(obj)
         nd3 = np.random.randint(5, size=(2, 2, 2))
 
-        msg = (
-            r"Buffer has wrong number of dimensions \(expected 1,"
-            r" got 3\)|"
-            "The truth value of an array with more than one element is"
-            " ambiguous|"
-            "Only 1-dimensional input arrays are supported|"
-            "'pandas._libs.interval.IntervalTree' object has no attribute"
-            " 'set_value'|"  # AttributeError
-            "unhashable type: 'numpy.ndarray'|"  # TypeError
-            "No matching signature found|"  # TypeError
-            r"^\[\[\["  # pandas.core.indexing.IndexingError
-        )
-
-        if (idxr_id == "iloc") or (
-            (
-                isinstance(obj, Series)
-                and idxr_id == "setitem"
-                and index.inferred_type
-                in [
-                    "floating",
-                    "string",
-                    "datetime64",
-                    "period",
-                    "timedelta64",
-                    "boolean",
-                    "categorical",
-                ]
-            )
+        if idxr_id == "iloc":
+            err = ValueError
+            msg = f"Cannot set values with ndim > {obj.ndim}"
+        elif (
+            isinstance(index, pd.IntervalIndex)
+            and idxr_id == "setitem"
+            and obj.ndim == 1
         ):
-            idxr[nd3] = 0
+            err = AttributeError
+            msg = (
+                "'pandas._libs.interval.IntervalTree' object has no attribute 'get_loc'"
+            )
         else:
-            with pytest.raises(
-                (ValueError, AttributeError, TypeError, pd.core.indexing.IndexingError),
-                match=msg,
-            ):
-                idxr[nd3] = 0
+            err = ValueError
+            msg = r"Buffer has wrong number of dimensions \(expected 1, got 3\)|"
+
+        with pytest.raises(err, match=msg):
+            idxr[nd3] = 0
 
     def test_inf_upcast(self):
         # GH 16957
@@ -222,7 +176,7 @@ def test_setitem_dtype_upcast(self):
         expected = DataFrame(
             [{"a": 1, "b": np.nan, "c": "foo"}, {"a": 3, "b": 2, "c": np.nan}]
         )
-        tm.assert_frame_equal(df, expected, check_like=not PY36)
+        tm.assert_frame_equal(df, expected)
 
         # GH10280
         df = DataFrame(
@@ -264,9 +218,8 @@ def test_setitem_dtype_upcast(self):
     def test_dups_fancy_indexing(self):
 
         # GH 3455
-        from pandas.util.testing import makeCustomDataframe as mkdf
 
-        df = mkdf(10, 3)
+        df = tm.makeCustomDataframe(10, 3)
         df.columns = ["a", "a", "b"]
         result = df[["b", "a"]].columns
         expected = Index(["b", "a", "a"])
@@ -301,32 +254,13 @@ def test_dups_fancy_indexing(self):
         tm.assert_frame_equal(result, expected)
 
         rows = ["C", "B", "E"]
-        expected = DataFrame(
-            {
-                "test": [11, 9, np.nan],
-                "test1": [7.0, 6, np.nan],
-                "other": ["d", "c", np.nan],
-            },
-            index=rows,
-        )
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[rows]
-        tm.assert_frame_equal(result, expected)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[rows]
 
         # see GH5553, make sure we use the right indexer
         rows = ["F", "G", "H", "C", "B", "E"]
-        expected = DataFrame(
-            {
-                "test": [np.nan, np.nan, np.nan, 11, 9, np.nan],
-                "test1": [np.nan, np.nan, np.nan, 7.0, 6, np.nan],
-                "other": [np.nan, np.nan, np.nan, "d", "c", np.nan],
-            },
-            index=rows,
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[rows]
-        tm.assert_frame_equal(result, expected)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[rows]
 
         # List containing only missing label
         dfnu = DataFrame(np.random.randn(5, 3), index=list("AABCD"))
@@ -342,38 +276,25 @@ def test_dups_fancy_indexing(self):
 
         # GH 4619; duplicate indexer with missing label
         df = DataFrame({"A": [0, 1, 2]})
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[[0, 8, 0]]
-        expected = DataFrame({"A": [0, np.nan, 0]}, index=[0, 8, 0])
-        tm.assert_frame_equal(result, expected, check_index_type=False)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[[0, 8, 0]]
 
         df = DataFrame({"A": list("abc")})
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[[0, 8, 0]]
-        expected = DataFrame({"A": ["a", np.nan, "a"]}, index=[0, 8, 0])
-        tm.assert_frame_equal(result, expected, check_index_type=False)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[[0, 8, 0]]
 
         # non unique with non unique selector
         df = DataFrame({"test": [5, 7, 9, 11]}, index=["A", "A", "B", "C"])
-        expected = DataFrame(
-            {"test": [5, 7, 5, 7, np.nan]}, index=["A", "A", "A", "A", "E"]
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[["A", "A", "E"]]
-        tm.assert_frame_equal(result, expected)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[["A", "A", "E"]]
 
     def test_dups_fancy_indexing2(self):
         # GH 5835
         # dups on index and missing values
         df = DataFrame(np.random.randn(5, 5), columns=["A", "B", "B", "B", "A"])
 
-        expected = pd.concat(
-            [df.loc[:, ["A", "B"]], DataFrame(np.nan, columns=["C"], index=df.index)],
-            axis=1,
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.loc[:, ["A", "B", "C"]]
-        tm.assert_frame_equal(result, expected)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            df.loc[:, ["A", "B", "C"]]
 
         # GH 6504, multi-axis indexing
         df = DataFrame(
@@ -592,12 +513,12 @@ class TO:
             def __init__(self, value):
                 self.value = value
 
-            def __str__(self):
-                return "[{0}]".format(self.value)
+            def __str__(self) -> str:
+                return f"[{self.value}]"
 
             __repr__ = __str__
 
-            def __eq__(self, other):
+            def __eq__(self, other) -> bool:
                 return self.value == other.value
 
             def view(self):
@@ -800,7 +721,7 @@ def test_index_type_coercion(self):
                 assert s2.index.is_object()
 
 
-class TestMisc(Base):
+class TestMisc:
     def test_float_index_to_mixed(self):
         df = DataFrame({0.0: np.random.rand(10), 1.0: np.random.rand(10)})
         df["a"] = 10
@@ -925,21 +846,21 @@ def test_indexing_dtypes_on_empty(self):
         assert df2.loc[:, "a"].dtype == np.int64
         tm.assert_series_equal(df2.loc[:, "a"], df2.iloc[:, 0])
 
-    def test_range_in_series_indexing(self):
+    @pytest.mark.parametrize("size", [5, 999999, 1000000])
+    def test_range_in_series_indexing(self, size):
         # range can cause an indexing error
         # GH 11652
-        for x in [5, 999999, 1000000]:
-            s = Series(index=range(x))
-            s.loc[range(1)] = 42
-            tm.assert_series_equal(s.loc[range(1)], Series(42.0, index=[0]))
-
-            s.loc[range(2)] = 43
-            tm.assert_series_equal(s.loc[range(2)], Series(43.0, index=[0, 1]))
+        s = Series(index=range(size), dtype=np.float64)
+        s.loc[range(1)] = 42
+        tm.assert_series_equal(s.loc[range(1)], Series(42.0, index=[0]))
 
-    def test_non_reducing_slice(self):
-        df = DataFrame([[0, 1], [2, 3]])
+        s.loc[range(2)] = 43
+        tm.assert_series_equal(s.loc[range(2)], Series(43.0, index=[0, 1]))
 
-        slices = [
+    @pytest.mark.parametrize(
+        "slc",
+        [
+            # FIXME: dont leave commented-out
             # pd.IndexSlice[:, :],
             pd.IndexSlice[:, 1],
             pd.IndexSlice[1, :],
@@ -952,10 +873,13 @@ def test_non_reducing_slice(self):
             [0, 1],
             np.array([0, 1]),
             Series([0, 1]),
-        ]
-        for slice_ in slices:
-            tslice_ = _non_reducing_slice(slice_)
-            assert isinstance(df.loc[tslice_], DataFrame)
+        ],
+    )
+    def test_non_reducing_slice(self, slc):
+        df = DataFrame([[0, 1], [2, 3]])
+
+        tslice_ = _non_reducing_slice(slc)
+        assert isinstance(df.loc[tslice_], DataFrame)
 
     def test_list_slice(self):
         # like dataframe getitem
@@ -1015,37 +939,37 @@ class TestSeriesNoneCoercion:
         (["foo", "bar", "baz"], [None, "bar", "baz"]),
     ]
 
-    def test_coercion_with_setitem(self):
-        for start_data, expected_result in self.EXPECTED_RESULTS:
-            start_series = Series(start_data)
-            start_series[0] = None
+    @pytest.mark.parametrize("start_data,expected_result", EXPECTED_RESULTS)
+    def test_coercion_with_setitem(self, start_data, expected_result):
+        start_series = Series(start_data)
+        start_series[0] = None
 
-            expected_series = Series(expected_result)
-            tm.assert_series_equal(start_series, expected_series)
+        expected_series = Series(expected_result)
+        tm.assert_series_equal(start_series, expected_series)
 
-    def test_coercion_with_loc_setitem(self):
-        for start_data, expected_result in self.EXPECTED_RESULTS:
-            start_series = Series(start_data)
-            start_series.loc[0] = None
+    @pytest.mark.parametrize("start_data,expected_result", EXPECTED_RESULTS)
+    def test_coercion_with_loc_setitem(self, start_data, expected_result):
+        start_series = Series(start_data)
+        start_series.loc[0] = None
 
-            expected_series = Series(expected_result)
-            tm.assert_series_equal(start_series, expected_series)
+        expected_series = Series(expected_result)
+        tm.assert_series_equal(start_series, expected_series)
 
-    def test_coercion_with_setitem_and_series(self):
-        for start_data, expected_result in self.EXPECTED_RESULTS:
-            start_series = Series(start_data)
-            start_series[start_series == start_series[0]] = None
+    @pytest.mark.parametrize("start_data,expected_result", EXPECTED_RESULTS)
+    def test_coercion_with_setitem_and_series(self, start_data, expected_result):
+        start_series = Series(start_data)
+        start_series[start_series == start_series[0]] = None
 
-            expected_series = Series(expected_result)
-            tm.assert_series_equal(start_series, expected_series)
+        expected_series = Series(expected_result)
+        tm.assert_series_equal(start_series, expected_series)
 
-    def test_coercion_with_loc_and_series(self):
-        for start_data, expected_result in self.EXPECTED_RESULTS:
-            start_series = Series(start_data)
-            start_series.loc[start_series == start_series[0]] = None
+    @pytest.mark.parametrize("start_data,expected_result", EXPECTED_RESULTS)
+    def test_coercion_with_loc_and_series(self, start_data, expected_result):
+        start_series = Series(start_data)
+        start_series.loc[start_series == start_series[0]] = None
 
-            expected_series = Series(expected_result)
-            tm.assert_series_equal(start_series, expected_series)
+        expected_series = Series(expected_result)
+        tm.assert_series_equal(start_series, expected_series)
 
 
 class TestDataframeNoneCoercion:
@@ -1062,31 +986,35 @@ class TestDataframeNoneCoercion:
         (["foo", "bar", "baz"], [None, "bar", "baz"]),
     ]
 
-    def test_coercion_with_loc(self):
-        for start_data, expected_result in self.EXPECTED_SINGLE_ROW_RESULTS:
-            start_dataframe = DataFrame({"foo": start_data})
-            start_dataframe.loc[0, ["foo"]] = None
+    @pytest.mark.parametrize("expected", EXPECTED_SINGLE_ROW_RESULTS)
+    def test_coercion_with_loc(self, expected):
+        start_data, expected_result = expected
+
+        start_dataframe = DataFrame({"foo": start_data})
+        start_dataframe.loc[0, ["foo"]] = None
+
+        expected_dataframe = DataFrame({"foo": expected_result})
+        tm.assert_frame_equal(start_dataframe, expected_dataframe)
 
-            expected_dataframe = DataFrame({"foo": expected_result})
-            tm.assert_frame_equal(start_dataframe, expected_dataframe)
+    @pytest.mark.parametrize("expected", EXPECTED_SINGLE_ROW_RESULTS)
+    def test_coercion_with_setitem_and_dataframe(self, expected):
+        start_data, expected_result = expected
 
-    def test_coercion_with_setitem_and_dataframe(self):
-        for start_data, expected_result in self.EXPECTED_SINGLE_ROW_RESULTS:
-            start_dataframe = DataFrame({"foo": start_data})
-            start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
+        start_dataframe = DataFrame({"foo": start_data})
+        start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
 
-            expected_dataframe = DataFrame({"foo": expected_result})
-            tm.assert_frame_equal(start_dataframe, expected_dataframe)
+        expected_dataframe = DataFrame({"foo": expected_result})
+        tm.assert_frame_equal(start_dataframe, expected_dataframe)
 
-    def test_none_coercion_loc_and_dataframe(self):
-        for start_data, expected_result in self.EXPECTED_SINGLE_ROW_RESULTS:
-            start_dataframe = DataFrame({"foo": start_data})
-            start_dataframe.loc[
-                start_dataframe["foo"] == start_dataframe["foo"][0]
-            ] = None
+    @pytest.mark.parametrize("expected", EXPECTED_SINGLE_ROW_RESULTS)
+    def test_none_coercion_loc_and_dataframe(self, expected):
+        start_data, expected_result = expected
 
-            expected_dataframe = DataFrame({"foo": expected_result})
-            tm.assert_frame_equal(start_dataframe, expected_dataframe)
+        start_dataframe = DataFrame({"foo": start_data})
+        start_dataframe.loc[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
+
+        expected_dataframe = DataFrame({"foo": expected_result})
+        tm.assert_frame_equal(start_dataframe, expected_dataframe)
 
     def test_none_coercion_mixed_dtypes(self):
         start_dataframe = DataFrame(
@@ -1173,12 +1101,12 @@ def test_extension_array_cross_section_converts():
         (
             lambda x: x.loc,
             AttributeError,
-            "type object 'NDFrame' has no attribute '_AXIS_ALIASES'",
+            "type object 'NDFrame' has no attribute '_AXIS_NAMES'",
         ),
         (
             lambda x: x.iloc,
             AttributeError,
-            "type object 'NDFrame' has no attribute '_AXIS_ALIASES'",
+            "type object 'NDFrame' has no attribute '_AXIS_NAMES'",
         ),
     ],
 )
@@ -1202,3 +1130,35 @@ def test_readonly_indices():
     result = df["data"].iloc[indices]
     expected = df["data"].loc[[1, 3, 6]]
     tm.assert_series_equal(result, expected)
+
+
+def test_1tuple_without_multiindex():
+    ser = pd.Series(range(5))
+    key = (slice(3),)
+
+    result = ser[key]
+    expected = ser[key[0]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicate_index_mistyped_key_raises_keyerror():
+    # GH#29189 float_index.get_loc(None) should raise KeyError, not TypeError
+    ser = pd.Series([2, 5, 6, 8], index=[2.0, 4.0, 4.0, 5.0])
+    with pytest.raises(KeyError):
+        ser[None]
+
+    with pytest.raises(KeyError):
+        ser.index.get_loc(None)
+
+    with pytest.raises(KeyError):
+        ser.index._engine.get_loc(None)
+
+
+def test_setitem_with_bool_mask_and_values_matching_n_trues_in_length():
+    # GH 30567
+    ser = pd.Series([None] * 10)
+    mask = [False] * 3 + [True] * 5 + [False] * 2
+    ser[mask] = range(5)
+    result = ser
+    expected = pd.Series([None] * 3 + list(range(5)) + [None] * 2).astype("object")
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexing/test_indexing_slow.py b/pandas/tests/indexing/test_indexing_slow.py
index bf8c6afd00561..2ffa44bec14a6 100644
--- a/pandas/tests/indexing/test_indexing_slow.py
+++ b/pandas/tests/indexing/test_indexing_slow.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestIndexingSlow:
diff --git a/pandas/tests/indexing/test_ix.py b/pandas/tests/indexing/test_ix.py
deleted file mode 100644
index 6029db8ed66f6..0000000000000
--- a/pandas/tests/indexing/test_ix.py
+++ /dev/null
@@ -1,355 +0,0 @@
-""" test indexing with ix """
-
-from warnings import catch_warnings
-
-import numpy as np
-import pytest
-
-from pandas.core.dtypes.common import is_scalar
-
-import pandas as pd
-from pandas import DataFrame, Series, option_context
-from pandas.util import testing as tm
-
-
-def test_ix_deprecation():
-    # GH 15114
-
-    df = DataFrame({"A": [1, 2, 3]})
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=True):
-        df.ix[1, "A"]
-
-
-@pytest.mark.filterwarnings("ignore:\\n.ix:FutureWarning")
-class TestIX:
-    def test_ix_loc_setitem_consistency(self):
-
-        # GH 5771
-        # loc with slice and series
-        s = Series(0, index=[4, 5, 6])
-        s.loc[4:5] += 1
-        expected = Series([1, 1, 0], index=[4, 5, 6])
-        tm.assert_series_equal(s, expected)
-
-        # GH 5928
-        # chained indexing assignment
-        df = DataFrame({"a": [0, 1, 2]})
-        expected = df.copy()
-        with catch_warnings(record=True):
-            expected.ix[[0, 1, 2], "a"] = -expected.ix[[0, 1, 2], "a"]
-
-        with catch_warnings(record=True):
-            df["a"].ix[[0, 1, 2]] = -df["a"].ix[[0, 1, 2]]
-        tm.assert_frame_equal(df, expected)
-
-        df = DataFrame({"a": [0, 1, 2], "b": [0, 1, 2]})
-        with catch_warnings(record=True):
-            df["a"].ix[[0, 1, 2]] = -df["a"].ix[[0, 1, 2]].astype("float64") + 0.5
-        expected = DataFrame({"a": [0.5, -0.5, -1.5], "b": [0, 1, 2]})
-        tm.assert_frame_equal(df, expected)
-
-        # GH 8607
-        # ix setitem consistency
-        df = DataFrame(
-            {
-                "delta": [1174, 904, 161],
-                "elapsed": [7673, 9277, 1470],
-                "timestamp": [1413840976, 1413842580, 1413760580],
-            }
-        )
-        expected = DataFrame(
-            {
-                "delta": [1174, 904, 161],
-                "elapsed": [7673, 9277, 1470],
-                "timestamp": pd.to_datetime(
-                    [1413840976, 1413842580, 1413760580], unit="s"
-                ),
-            }
-        )
-
-        df2 = df.copy()
-        df2["timestamp"] = pd.to_datetime(df["timestamp"], unit="s")
-        tm.assert_frame_equal(df2, expected)
-
-        df2 = df.copy()
-        df2.loc[:, "timestamp"] = pd.to_datetime(df["timestamp"], unit="s")
-        tm.assert_frame_equal(df2, expected)
-
-        df2 = df.copy()
-        with catch_warnings(record=True):
-            df2.ix[:, 2] = pd.to_datetime(df["timestamp"], unit="s")
-        tm.assert_frame_equal(df2, expected)
-
-    def test_ix_loc_consistency(self):
-
-        # GH 8613
-        # some edge cases where ix/loc should return the same
-        # this is not an exhaustive case
-
-        def compare(result, expected):
-            if is_scalar(expected):
-                assert result == expected
-            else:
-                assert expected.equals(result)
-
-        # failure cases for .loc, but these work for .ix
-        df = DataFrame(np.random.randn(5, 4), columns=list("ABCD"))
-        for key in [
-            slice(1, 3),
-            tuple([slice(0, 2), slice(0, 2)]),
-            tuple([slice(0, 2), df.columns[0:2]]),
-        ]:
-
-            for index in [
-                tm.makeStringIndex,
-                tm.makeUnicodeIndex,
-                tm.makeDateIndex,
-                tm.makePeriodIndex,
-                tm.makeTimedeltaIndex,
-            ]:
-                df.index = index(len(df.index))
-                with catch_warnings(record=True):
-                    df.ix[key]
-
-                msg = (
-                    r"cannot do slice indexing"
-                    r" on {klass} with these indexers \[(0|1)\] of"
-                    r" {kind}".format(klass=type(df.index), kind=str(int))
-                )
-                with pytest.raises(TypeError, match=msg):
-                    df.loc[key]
-
-        df = DataFrame(
-            np.random.randn(5, 4),
-            columns=list("ABCD"),
-            index=pd.date_range("2012-01-01", periods=5),
-        )
-
-        for key in [
-            "2012-01-03",
-            "2012-01-31",
-            slice("2012-01-03", "2012-01-03"),
-            slice("2012-01-03", "2012-01-04"),
-            slice("2012-01-03", "2012-01-06", 2),
-            slice("2012-01-03", "2012-01-31"),
-            tuple([[True, True, True, False, True]]),
-        ]:
-
-            # getitem
-
-            # if the expected raises, then compare the exceptions
-            try:
-                with catch_warnings(record=True):
-                    expected = df.ix[key]
-            except KeyError:
-                with pytest.raises(KeyError, match=r"^'2012-01-31'$"):
-                    df.loc[key]
-                continue
-
-            result = df.loc[key]
-            compare(result, expected)
-
-            # setitem
-            df1 = df.copy()
-            df2 = df.copy()
-
-            with catch_warnings(record=True):
-                df1.ix[key] = 10
-            df2.loc[key] = 10
-            compare(df2, df1)
-
-        # edge cases
-        s = Series([1, 2, 3, 4], index=list("abde"))
-
-        result1 = s["a":"c"]
-        with catch_warnings(record=True):
-            result2 = s.ix["a":"c"]
-        result3 = s.loc["a":"c"]
-        tm.assert_series_equal(result1, result2)
-        tm.assert_series_equal(result1, result3)
-
-        # now work rather than raising KeyError
-        s = Series(range(5), [-2, -1, 1, 2, 3])
-
-        with catch_warnings(record=True):
-            result1 = s.ix[-10:3]
-        result2 = s.loc[-10:3]
-        tm.assert_series_equal(result1, result2)
-
-        with catch_warnings(record=True):
-            result1 = s.ix[0:3]
-        result2 = s.loc[0:3]
-        tm.assert_series_equal(result1, result2)
-
-    def test_ix_weird_slicing(self):
-        # http://stackoverflow.com/q/17056560/1240268
-        df = DataFrame({"one": [1, 2, 3, np.nan, np.nan], "two": [1, 2, 3, 4, 5]})
-        df.loc[df["one"] > 1, "two"] = -df["two"]
-
-        expected = DataFrame(
-            {
-                "one": {0: 1.0, 1: 2.0, 2: 3.0, 3: np.nan, 4: np.nan},
-                "two": {0: 1, 1: -2, 2: -3, 3: 4, 4: 5},
-            }
-        )
-        tm.assert_frame_equal(df, expected)
-
-    def test_ix_assign_column_mixed(self, float_frame):
-        # GH #1142
-        df = float_frame
-        df["foo"] = "bar"
-
-        orig = df.loc[:, "B"].copy()
-        df.loc[:, "B"] = df.loc[:, "B"] + 1
-        tm.assert_series_equal(df.B, orig + 1)
-
-        # GH 3668, mixed frame with series value
-        df = DataFrame({"x": np.arange(10), "y": np.arange(10, 20), "z": "bar"})
-        expected = df.copy()
-
-        for i in range(5):
-            indexer = i * 2
-            v = 1000 + i * 200
-            expected.loc[indexer, "y"] = v
-            assert expected.loc[indexer, "y"] == v
-
-        df.loc[df.x % 2 == 0, "y"] = df.loc[df.x % 2 == 0, "y"] * 100
-        tm.assert_frame_equal(df, expected)
-
-        # GH 4508, making sure consistency of assignments
-        df = DataFrame({"a": [1, 2, 3], "b": [0, 1, 2]})
-        df.loc[[0, 2], "b"] = [100, -100]
-        expected = DataFrame({"a": [1, 2, 3], "b": [100, 1, -100]})
-        tm.assert_frame_equal(df, expected)
-
-        df = DataFrame({"a": list(range(4))})
-        df["b"] = np.nan
-        df.loc[[1, 3], "b"] = [100, -100]
-        expected = DataFrame({"a": [0, 1, 2, 3], "b": [np.nan, 100, np.nan, -100]})
-        tm.assert_frame_equal(df, expected)
-
-        # ok, but chained assignments are dangerous
-        # if we turn off chained assignment it will work
-        with option_context("chained_assignment", None):
-            df = DataFrame({"a": list(range(4))})
-            df["b"] = np.nan
-            df["b"].loc[[1, 3]] = [100, -100]
-            tm.assert_frame_equal(df, expected)
-
-    def test_ix_get_set_consistency(self):
-
-        # GH 4544
-        # ix/loc get/set not consistent when
-        # a mixed int/string index
-        df = DataFrame(
-            np.arange(16).reshape((4, 4)),
-            columns=["a", "b", 8, "c"],
-            index=["e", 7, "f", "g"],
-        )
-
-        with catch_warnings(record=True):
-            assert df.ix["e", 8] == 2
-        assert df.loc["e", 8] == 2
-
-        with catch_warnings(record=True):
-            df.ix["e", 8] = 42
-            assert df.ix["e", 8] == 42
-        assert df.loc["e", 8] == 42
-
-        df.loc["e", 8] = 45
-        with catch_warnings(record=True):
-            assert df.ix["e", 8] == 45
-        assert df.loc["e", 8] == 45
-
-    def test_ix_slicing_strings(self):
-        # see gh-3836
-        data = {
-            "Classification": ["SA EQUITY CFD", "bbb", "SA EQUITY", "SA SSF", "aaa"],
-            "Random": [1, 2, 3, 4, 5],
-            "X": ["correct", "wrong", "correct", "correct", "wrong"],
-        }
-        df = DataFrame(data)
-        x = df[~df.Classification.isin(["SA EQUITY CFD", "SA EQUITY", "SA SSF"])]
-        with catch_warnings(record=True):
-            df.ix[x.index, "X"] = df["Classification"]
-
-        expected = DataFrame(
-            {
-                "Classification": {
-                    0: "SA EQUITY CFD",
-                    1: "bbb",
-                    2: "SA EQUITY",
-                    3: "SA SSF",
-                    4: "aaa",
-                },
-                "Random": {0: 1, 1: 2, 2: 3, 3: 4, 4: 5},
-                "X": {0: "correct", 1: "bbb", 2: "correct", 3: "correct", 4: "aaa"},
-            }
-        )  # bug was 4: 'bbb'
-
-        tm.assert_frame_equal(df, expected)
-
-    def test_ix_setitem_out_of_bounds_axis_0(self):
-        df = DataFrame(
-            np.random.randn(2, 5),
-            index=["row{i}".format(i=i) for i in range(2)],
-            columns=["col{i}".format(i=i) for i in range(5)],
-        )
-        with catch_warnings(record=True):
-            msg = "cannot set by positional indexing with enlargement"
-            with pytest.raises(ValueError, match=msg):
-                df.ix[2, 0] = 100
-
-    def test_ix_setitem_out_of_bounds_axis_1(self):
-        df = DataFrame(
-            np.random.randn(5, 2),
-            index=["row{i}".format(i=i) for i in range(5)],
-            columns=["col{i}".format(i=i) for i in range(2)],
-        )
-        with catch_warnings(record=True):
-            msg = "cannot set by positional indexing with enlargement"
-            with pytest.raises(ValueError, match=msg):
-                df.ix[0, 2] = 100
-
-    def test_ix_empty_list_indexer_is_ok(self):
-        with catch_warnings(record=True):
-            from pandas.util.testing import makeCustomDataframe as mkdf
-
-            df = mkdf(5, 2)
-            # vertical empty
-            tm.assert_frame_equal(
-                df.ix[:, []],
-                df.iloc[:, :0],
-                check_index_type=True,
-                check_column_type=True,
-            )
-            # horizontal empty
-            tm.assert_frame_equal(
-                df.ix[[], :],
-                df.iloc[:0, :],
-                check_index_type=True,
-                check_column_type=True,
-            )
-            # horizontal empty
-            tm.assert_frame_equal(
-                df.ix[[]], df.iloc[:0, :], check_index_type=True, check_column_type=True
-            )
-
-    def test_ix_duplicate_returns_series(self):
-        df = DataFrame(
-            np.random.randn(3, 3), index=[0.1, 0.2, 0.2], columns=list("abc")
-        )
-        with catch_warnings(record=True):
-            r = df.ix[0.2, "a"]
-        e = df.loc[0.2, "a"]
-        tm.assert_series_equal(r, e)
-
-    def test_ix_intervalindex(self):
-        # https://github.com/pandas-dev/pandas/issues/27865
-        df = DataFrame(
-            np.random.randn(5, 2),
-            index=pd.IntervalIndex.from_breaks([-np.inf, 0, 1, 2, 3, np.inf]),
-        )
-        result = df.ix[0:2, 0]
-        expected = df.iloc[0:2, 0]
-        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 35291efecd1ac..71d85ed8bda9b 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -1,19 +1,116 @@
 """ test label based indexing with loc """
 from io import StringIO
 import re
-from warnings import catch_warnings, filterwarnings
 
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp, date_range
+import pandas._testing as tm
 from pandas.api.types import is_scalar
 from pandas.tests.indexing.common import Base
-from pandas.util import testing as tm
 
 
 class TestLoc(Base):
+    def test_loc_getitem_int(self):
+
+        # int label
+        self.check_result("loc", 2, typs=["labels"], fails=TypeError)
+
+    def test_loc_getitem_label(self):
+
+        # label
+        self.check_result("loc", "c", typs=["empty"], fails=KeyError)
+
+    def test_loc_getitem_label_out_of_range(self):
+
+        # out of range label
+        self.check_result(
+            "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError,
+        )
+        self.check_result("loc", "f", typs=["floats"], fails=KeyError)
+        self.check_result("loc", "f", typs=["floats"], fails=KeyError)
+        self.check_result(
+            "loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError,
+        )
+        self.check_result("loc", 20, typs=["labels"], fails=TypeError)
+        self.check_result("loc", 20, typs=["ts"], axes=0, fails=TypeError)
+        self.check_result("loc", 20, typs=["floats"], axes=0, fails=KeyError)
+
+    def test_loc_getitem_label_list(self):
+        # TODO: test something here?
+        # list of labels
+        pass
+
+    def test_loc_getitem_label_list_with_missing(self):
+        self.check_result(
+            "loc", [0, 1, 2], typs=["empty"], fails=KeyError,
+        )
+        self.check_result(
+            "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError,
+        )
+
+        self.check_result(
+            "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError,
+        )
+
+        # GH 17758 - MultiIndex and missing keys
+        self.check_result(
+            "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError,
+        )
+
+    def test_loc_getitem_label_list_fails(self):
+        # fails
+        self.check_result(
+            "loc", [20, 30, 40], typs=["ints", "uints"], axes=1, fails=KeyError,
+        )
+
+    def test_loc_getitem_label_array_like(self):
+        # TODO: test something?
+        # array like
+        pass
+
+    def test_loc_getitem_bool(self):
+        # boolean indexers
+        b = [True, False, True, False]
+
+        self.check_result("loc", b, typs=["empty"], fails=IndexError)
+
+    def test_loc_getitem_label_slice(self):
+
+        # label slices (with ints)
+
+        # real label slices
+
+        # GH 14316
+
+        self.check_result(
+            "loc",
+            slice(1, 3),
+            typs=["labels", "mixed", "empty", "ts", "floats"],
+            fails=TypeError,
+        )
+
+        self.check_result(
+            "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError,
+        )
+
+        self.check_result(
+            "loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError,
+        )
+        self.check_result(
+            "loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError,
+        )
+
+        self.check_result(
+            "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError,
+        )
+
+
+class TestLoc2:
+    # TODO: better name, just separating out things that rely on base class
+
     def test_loc_getitem_dups(self):
         # GH 5678
         # repeated getitems on a dup index returning a ndarray
@@ -93,259 +190,40 @@ def test_loc_setitem_slice(self):
         expected = DataFrame({"a": [0, 1, 1], "b": [100, 200, 300]}, dtype="uint64")
         tm.assert_frame_equal(df2, expected)
 
-    def test_loc_getitem_int(self):
-
-        # int label
-        self.check_result(
-            "int label", "loc", 2, "ix", 2, typs=["ints", "uints"], axes=0
-        )
-        self.check_result(
-            "int label", "loc", 3, "ix", 3, typs=["ints", "uints"], axes=1
-        )
-        self.check_result(
-            "int label", "loc", 2, "ix", 2, typs=["label"], fails=KeyError
-        )
-
-    def test_loc_getitem_label(self):
-
-        # label
-        self.check_result("label", "loc", "c", "ix", "c", typs=["labels"], axes=0)
-        self.check_result("label", "loc", "null", "ix", "null", typs=["mixed"], axes=0)
-        self.check_result("label", "loc", 8, "ix", 8, typs=["mixed"], axes=0)
-        self.check_result(
-            "label", "loc", Timestamp("20130102"), "ix", 1, typs=["ts"], axes=0
-        )
-        self.check_result(
-            "label", "loc", "c", "ix", "c", typs=["empty"], fails=KeyError
-        )
-
-    def test_loc_getitem_label_out_of_range(self):
-
-        # out of range label
-        self.check_result(
-            "label range",
-            "loc",
-            "f",
-            "ix",
-            "f",
-            typs=["ints", "uints", "labels", "mixed", "ts"],
-            fails=KeyError,
-        )
-        self.check_result(
-            "label range", "loc", "f", "ix", "f", typs=["floats"], fails=KeyError
-        )
-        self.check_result(
-            "label range",
-            "loc",
-            20,
-            "ix",
-            20,
-            typs=["ints", "uints", "mixed"],
-            fails=KeyError,
-        )
-        self.check_result(
-            "label range", "loc", 20, "ix", 20, typs=["labels"], fails=TypeError
-        )
-        self.check_result(
-            "label range", "loc", 20, "ix", 20, typs=["ts"], axes=0, fails=TypeError
-        )
-        self.check_result(
-            "label range", "loc", 20, "ix", 20, typs=["floats"], axes=0, fails=KeyError
-        )
-
-    def test_loc_getitem_label_list(self):
-
-        # list of labels
-        self.check_result(
-            "list lbl",
-            "loc",
-            [0, 2, 4],
-            "ix",
-            [0, 2, 4],
-            typs=["ints", "uints"],
-            axes=0,
-        )
-        self.check_result(
-            "list lbl",
-            "loc",
-            [3, 6, 9],
-            "ix",
-            [3, 6, 9],
-            typs=["ints", "uints"],
-            axes=1,
-        )
-        self.check_result(
-            "list lbl",
-            "loc",
-            ["a", "b", "d"],
-            "ix",
-            ["a", "b", "d"],
-            typs=["labels"],
-            axes=0,
-        )
-        self.check_result(
-            "list lbl",
-            "loc",
-            ["A", "B", "C"],
-            "ix",
-            ["A", "B", "C"],
-            typs=["labels"],
-            axes=1,
-        )
-        self.check_result(
-            "list lbl",
-            "loc",
-            [2, 8, "null"],
-            "ix",
-            [2, 8, "null"],
-            typs=["mixed"],
-            axes=0,
-        )
-        self.check_result(
-            "list lbl",
-            "loc",
-            [Timestamp("20130102"), Timestamp("20130103")],
-            "ix",
-            [Timestamp("20130102"), Timestamp("20130103")],
-            typs=["ts"],
-            axes=0,
-        )
-
-    def test_loc_getitem_label_list_with_missing(self):
-        self.check_result(
-            "list lbl",
-            "loc",
-            [0, 1, 2],
-            "indexer",
-            [0, 1, 2],
-            typs=["empty"],
-            fails=KeyError,
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            self.check_result(
-                "list lbl",
-                "loc",
-                [0, 2, 10],
-                "ix",
-                [0, 2, 10],
-                typs=["ints", "uints", "floats"],
-                axes=0,
-                fails=KeyError,
-            )
+    def test_loc_setitem_dtype(self):
+        # GH31340
+        df = DataFrame({"id": ["A"], "a": [1.2], "b": [0.0], "c": [-2.5]})
+        cols = ["a", "b", "c"]
+        df.loc[:, cols] = df.loc[:, cols].astype("float32")
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            self.check_result(
-                "list lbl",
-                "loc",
-                [3, 6, 7],
-                "ix",
-                [3, 6, 7],
-                typs=["ints", "uints", "floats"],
-                axes=1,
-                fails=KeyError,
-            )
+        expected = DataFrame(
+            {"id": ["A"], "a": [1.2], "b": [0.0], "c": [-2.5]}, dtype="float32"
+        )  # id is inferred as object
 
-        # GH 17758 - MultiIndex and missing keys
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            self.check_result(
-                "list lbl",
-                "loc",
-                [(1, 3), (1, 4), (2, 5)],
-                "ix",
-                [(1, 3), (1, 4), (2, 5)],
-                typs=["multi"],
-                axes=0,
-            )
+        tm.assert_frame_equal(df, expected)
 
     def test_getitem_label_list_with_missing(self):
         s = Series(range(3), index=["a", "b", "c"])
 
         # consistency
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(KeyError, match="with any missing labels"):
             s[["a", "d"]]
 
         s = Series(range(3))
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(KeyError, match="with any missing labels"):
             s[[0, 3]]
 
-    def test_loc_getitem_label_list_fails(self):
-        # fails
-        self.check_result(
-            "list lbl",
-            "loc",
-            [20, 30, 40],
-            "ix",
-            [20, 30, 40],
-            typs=["ints", "uints"],
-            axes=1,
-            fails=KeyError,
-        )
-
-    def test_loc_getitem_label_array_like(self):
-        # array like
-        self.check_result(
-            "array like",
-            "loc",
-            Series(index=[0, 2, 4]).index,
-            "ix",
-            [0, 2, 4],
-            typs=["ints", "uints"],
-            axes=0,
-        )
-        self.check_result(
-            "array like",
-            "loc",
-            Series(index=[3, 6, 9]).index,
-            "ix",
-            [3, 6, 9],
-            typs=["ints", "uints"],
-            axes=1,
-        )
-
-    def test_loc_getitem_bool(self):
-        # boolean indexers
-        b = [True, False, True, False]
-        self.check_result(
-            "bool",
-            "loc",
-            b,
-            "ix",
-            b,
-            typs=["ints", "uints", "labels", "mixed", "ts", "floats"],
-        )
-        self.check_result("bool", "loc", b, "ix", b, typs=["empty"], fails=IndexError)
-
     @pytest.mark.parametrize("index", [[True, False], [True, False, True, False]])
     def test_loc_getitem_bool_diff_len(self, index):
         # GH26658
         s = Series([1, 2, 3])
-        with pytest.raises(
-            IndexError,
-            match=("Item wrong length {} instead of {}.".format(len(index), len(s))),
-        ):
+        msg = f"Boolean index has wrong length: {len(index)} instead of {len(s)}"
+        with pytest.raises(IndexError, match=msg):
             _ = s.loc[index]
 
     def test_loc_getitem_int_slice(self):
-
-        # ok
-        self.check_result(
-            "int slice2",
-            "loc",
-            slice(2, 4),
-            "ix",
-            [2, 4],
-            typs=["ints", "uints"],
-            axes=0,
-        )
-        self.check_result(
-            "int slice2",
-            "loc",
-            slice(3, 6),
-            "ix",
-            [3, 6],
-            typs=["ints", "uints"],
-            axes=1,
-        )
+        # TODO: test something here?
+        pass
 
     def test_loc_to_fail(self):
 
@@ -356,8 +234,8 @@ def test_loc_to_fail(self):
 
         # raise a KeyError?
         msg = (
-            r"\"None of \[Int64Index\(\[1, 2\], dtype='int64'\)\] are"
-            r" in the \[index\]\""
+            r"\"None of \[Int64Index\(\[1, 2\], dtype='int64'\)\] are "
+            r"in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             df.loc[[1, 2], [1, 2]]
@@ -365,7 +243,7 @@ def test_loc_to_fail(self):
         # GH  7496
         # loc should not fallback
 
-        s = Series()
+        s = Series(dtype=object)
         s.loc[1] = 1
         s.loc["a"] = 2
 
@@ -373,28 +251,24 @@ def test_loc_to_fail(self):
             s.loc[-1]
 
         msg = (
-            r"\"None of \[Int64Index\(\[-1, -2\], dtype='int64'\)\] are"
-            r" in the \[index\]\""
+            r"\"None of \[Int64Index\(\[-1, -2\], dtype='int64'\)\] are "
+            r"in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             s.loc[[-1, -2]]
 
-        msg = (
-            r"\"None of \[Index\(\['4'\], dtype='object'\)\] are" r" in the \[index\]\""
-        )
+        msg = r"\"None of \[Index\(\['4'\], dtype='object'\)\] are in the \[index\]\""
         with pytest.raises(KeyError, match=msg):
             s.loc[["4"]]
 
         s.loc[-1] = 3
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[-1, -2]]
-        expected = Series([3, np.nan], index=[-1, -2])
-        tm.assert_series_equal(result, expected)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[-1, -2]]
 
         s["a"] = 2
         msg = (
-            r"\"None of \[Int64Index\(\[-2\], dtype='int64'\)\] are"
-            r" in the \[index\]\""
+            r"\"None of \[Int64Index\(\[-2\], dtype='int64'\)\] are "
+            r"in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             s.loc[[-2]]
@@ -409,8 +283,8 @@ def test_loc_to_fail(self):
         df = DataFrame([["a"], ["b"]], index=[1, 2], columns=["value"])
 
         msg = (
-            r"\"None of \[Int64Index\(\[3\], dtype='int64'\)\] are"
-            r" in the \[index\]\""
+            r"\"None of \[Int64Index\(\[3\], dtype='int64'\)\] are "
+            r"in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             df.loc[[3], :]
@@ -435,106 +309,8 @@ def test_loc_getitem_list_with_fail(self):
             s.loc[[3]]
 
         # a non-match and a match
-        with tm.assert_produces_warning(FutureWarning):
-            expected = s.loc[[2, 3]]
-        result = s.reindex([2, 3])
-        tm.assert_series_equal(result, expected)
-
-    def test_loc_getitem_label_slice(self):
-
-        # label slices (with ints)
-        self.check_result(
-            "lab slice",
-            "loc",
-            slice(1, 3),
-            "ix",
-            slice(1, 3),
-            typs=["labels", "mixed", "empty", "ts", "floats"],
-            fails=TypeError,
-        )
-
-        # real label slices
-        self.check_result(
-            "lab slice",
-            "loc",
-            slice("a", "c"),
-            "ix",
-            slice("a", "c"),
-            typs=["labels"],
-            axes=0,
-        )
-        self.check_result(
-            "lab slice",
-            "loc",
-            slice("A", "C"),
-            "ix",
-            slice("A", "C"),
-            typs=["labels"],
-            axes=1,
-        )
-
-        self.check_result(
-            "ts  slice",
-            "loc",
-            slice("20130102", "20130104"),
-            "ix",
-            slice("20130102", "20130104"),
-            typs=["ts"],
-            axes=0,
-        )
-        self.check_result(
-            "ts  slice",
-            "loc",
-            slice("20130102", "20130104"),
-            "ix",
-            slice("20130102", "20130104"),
-            typs=["ts"],
-            axes=1,
-            fails=TypeError,
-        )
-
-        # GH 14316
-        self.check_result(
-            "ts slice rev",
-            "loc",
-            slice("20130104", "20130102"),
-            "indexer",
-            [0, 1, 2],
-            typs=["ts_rev"],
-            axes=0,
-        )
-
-        self.check_result(
-            "mixed slice",
-            "loc",
-            slice(2, 8),
-            "ix",
-            slice(2, 8),
-            typs=["mixed"],
-            axes=0,
-            fails=TypeError,
-        )
-        self.check_result(
-            "mixed slice",
-            "loc",
-            slice(2, 8),
-            "ix",
-            slice(2, 8),
-            typs=["mixed"],
-            axes=1,
-            fails=KeyError,
-        )
-
-        self.check_result(
-            "mixed slice",
-            "loc",
-            slice(2, 4, 2),
-            "ix",
-            slice(2, 4, 2),
-            typs=["mixed"],
-            axes=0,
-            fails=TypeError,
-        )
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[2, 3]]
 
     def test_loc_index(self):
         # gh-17131
@@ -554,6 +330,9 @@ def test_loc_index(self):
         result = df.loc[mask.values]
         tm.assert_frame_equal(result, expected)
 
+        result = df.loc[pd.array(mask, dtype="boolean")]
+        tm.assert_frame_equal(result, expected)
+
     def test_loc_general(self):
 
         df = DataFrame(
@@ -703,17 +482,39 @@ def test_loc_assign_non_ns_datetime(self, unit):
             }
         )
 
-        df.loc[:, unit] = df.loc[:, "timestamp"].values.astype(
-            "datetime64[{unit}]".format(unit=unit)
-        )
-        df["expected"] = df.loc[:, "timestamp"].values.astype(
-            "datetime64[{unit}]".format(unit=unit)
-        )
+        df.loc[:, unit] = df.loc[:, "timestamp"].values.astype(f"datetime64[{unit}]")
+        df["expected"] = df.loc[:, "timestamp"].values.astype(f"datetime64[{unit}]")
         expected = Series(df.loc[:, "expected"], name=unit)
         tm.assert_series_equal(df.loc[:, unit], expected)
 
+    def test_loc_modify_datetime(self):
+        # see gh-28837
+        df = DataFrame.from_dict(
+            {"date": [1485264372711, 1485265925110, 1540215845888, 1540282121025]}
+        )
+
+        df["date_dt"] = pd.to_datetime(df["date"], unit="ms", cache=True)
+
+        df.loc[:, "date_dt_cp"] = df.loc[:, "date_dt"]
+        df.loc[[2, 3], "date_dt_cp"] = df.loc[[2, 3], "date_dt"]
+
+        expected = DataFrame(
+            [
+                [1485264372711, "2017-01-24 13:26:12.711", "2017-01-24 13:26:12.711"],
+                [1485265925110, "2017-01-24 13:52:05.110", "2017-01-24 13:52:05.110"],
+                [1540215845888, "2018-10-22 13:44:05.888", "2018-10-22 13:44:05.888"],
+                [1540282121025, "2018-10-23 08:08:41.025", "2018-10-23 08:08:41.025"],
+            ],
+            columns=["date", "date_dt", "date_dt_cp"],
+        )
+
+        columns = ["date_dt", "date_dt_cp"]
+        expected[columns] = expected[columns].apply(pd.to_datetime)
+
+        tm.assert_frame_equal(df, expected)
+
     def test_loc_setitem_frame(self):
-        df = self.frame_labels
+        df = DataFrame(np.random.randn(4, 4), index=list("abcd"), columns=list("ABCD"))
 
         result = df.iloc[0, 0]
 
@@ -874,13 +675,13 @@ def test_setitem_new_key_tz(self):
         ]
         expected = pd.Series(vals, index=["foo", "bar"])
 
-        ser = pd.Series()
+        ser = pd.Series(dtype=object)
         ser["foo"] = vals[0]
         ser["bar"] = vals[1]
 
         tm.assert_series_equal(ser, expected)
 
-        ser = pd.Series()
+        ser = pd.Series(dtype=object)
         ser.loc["foo"] = vals[0]
         ser.loc["bar"] = vals[1]
 
@@ -978,18 +779,12 @@ def test_loc_name(self):
         result = df.iloc[[0, 1]].index.name
         assert result == "index_name"
 
-        with catch_warnings(record=True):
-            filterwarnings("ignore", "\\n.ix", FutureWarning)
-            result = df.ix[[0, 1]].index.name
-        assert result == "index_name"
-
         result = df.loc[[0, 1]].index.name
         assert result == "index_name"
 
     def test_loc_empty_list_indexer_is_ok(self):
-        from pandas.util.testing import makeCustomDataframe as mkdf
 
-        df = mkdf(5, 2)
+        df = tm.makeCustomDataframe(5, 2)
         # vertical empty
         tm.assert_frame_equal(
             df.loc[:, []], df.iloc[:, :0], check_index_type=True, check_column_type=True
@@ -1097,7 +892,7 @@ def test_loc_reverse_assignment(self):
         data = [1, 2, 3, 4, 5, 6] + [None] * 4
         expected = Series(data, index=range(2010, 2020))
 
-        result = pd.Series(index=range(2010, 2020))
+        result = pd.Series(index=range(2010, 2020), dtype=np.float64)
         result.loc[2015:2010:-1] = [6, 5, 4, 3, 2, 1]
 
         tm.assert_series_equal(result, expected)
@@ -1109,10 +904,8 @@ def test_series_loc_getitem_label_list_missing_values():
         ["2001-01-04", "2001-01-02", "2001-01-04", "2001-01-14"], dtype="datetime64"
     )
     s = Series([2, 5, 8, 11], date_range("2001-01-01", freq="D", periods=4))
-    expected = Series([11.0, 5.0, 11.0, np.nan], index=key)
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = s.loc[key]
-    tm.assert_series_equal(result, expected)
+    with pytest.raises(KeyError, match="with any missing labels"):
+        s.loc[key]
 
 
 @pytest.mark.parametrize(
@@ -1131,3 +924,46 @@ def test_loc_getitem_label_list_integer_labels(
     expected = df.iloc[:, expected_columns]
     result = df.loc[["A", "B", "C"], column_key]
     tm.assert_frame_equal(result, expected, check_column_type=check_column_type)
+
+
+def test_loc_setitem_float_intindex():
+    # GH 8720
+    rand_data = np.random.randn(8, 4)
+    result = pd.DataFrame(rand_data)
+    result.loc[:, 0.5] = np.nan
+    expected_data = np.hstack((rand_data, np.array([np.nan] * 8).reshape(8, 1)))
+    expected = pd.DataFrame(expected_data, columns=[0.0, 1.0, 2.0, 3.0, 0.5])
+    tm.assert_frame_equal(result, expected)
+
+    result = pd.DataFrame(rand_data)
+    result.loc[:, 0.5] = np.nan
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_axis_1_slice():
+    # GH 10586
+    cols = [(yr, m) for yr in [2014, 2015] for m in [7, 8, 9, 10]]
+    df = pd.DataFrame(
+        np.ones((10, 8)),
+        index=tuple("ABCDEFGHIJ"),
+        columns=pd.MultiIndex.from_tuples(cols),
+    )
+    result = df.loc(axis=1)[(2014, 9):(2015, 8)]
+    expected = pd.DataFrame(
+        np.ones((10, 4)),
+        index=tuple("ABCDEFGHIJ"),
+        columns=pd.MultiIndex.from_tuples(
+            [(2014, 9), (2014, 10), (2015, 7), (2015, 8)]
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_set_dataframe_multiindex():
+    # GH 14592
+    expected = pd.DataFrame(
+        "a", index=range(2), columns=pd.MultiIndex.from_product([range(2), range(2)])
+    )
+    result = expected.copy()
+    result.loc[0, [(0, 1)]] = result.loc[0, [(0, 1)]]
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/test_na_indexing.py b/pandas/tests/indexing/test_na_indexing.py
new file mode 100644
index 0000000000000..befe4fee8ecf8
--- /dev/null
+++ b/pandas/tests/indexing/test_na_indexing.py
@@ -0,0 +1,79 @@
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "values, dtype",
+    [
+        ([1, 2, 3], "int64"),
+        ([1.0, 2.0, 3.0], "float64"),
+        (["a", "b", "c"], "object"),
+        (["a", "b", "c"], "string"),
+        ([1, 2, 3], "datetime64[ns]"),
+        ([1, 2, 3], "datetime64[ns, CET]"),
+        ([1, 2, 3], "timedelta64[ns]"),
+        (["2000", "2001", "2002"], "Period[D]"),
+        ([1, 0, 3], "Sparse"),
+        ([pd.Interval(0, 1), pd.Interval(1, 2), pd.Interval(3, 4)], "interval"),
+    ],
+)
+@pytest.mark.parametrize(
+    "mask", [[True, False, False], [True, True, True], [False, False, False]]
+)
+@pytest.mark.parametrize("box_mask", [True, False])
+@pytest.mark.parametrize("frame", [True, False])
+def test_series_mask_boolean(values, dtype, mask, box_mask, frame):
+    ser = pd.Series(values, dtype=dtype, index=["a", "b", "c"])
+    if frame:
+        ser = ser.to_frame()
+    mask = pd.array(mask, dtype="boolean")
+    if box_mask:
+        mask = pd.Series(mask, index=ser.index)
+
+    expected = ser[mask.astype("bool")]
+
+    result = ser[mask]
+    tm.assert_equal(result, expected)
+
+    if not box_mask:
+        # Series.iloc[Series[bool]] isn't allowed
+        result = ser.iloc[mask]
+        tm.assert_equal(result, expected)
+
+    result = ser.loc[mask]
+    tm.assert_equal(result, expected)
+
+    # empty
+    mask = mask[:0]
+    ser = ser.iloc[:0]
+    expected = ser[mask.astype("bool")]
+    result = ser[mask]
+    tm.assert_equal(result, expected)
+
+    if not box_mask:
+        # Series.iloc[Series[bool]] isn't allowed
+        result = ser.iloc[mask]
+        tm.assert_equal(result, expected)
+
+    result = ser.loc[mask]
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("frame", [True, False])
+def test_indexing_with_na_raises(frame):
+    s = pd.Series([1, 2, 3], name="name")
+
+    if frame:
+        s = s.to_frame()
+    mask = pd.array([True, False, None], dtype="boolean")
+    match = "cannot mask with array containing NA / NaN values"
+    with pytest.raises(ValueError, match=match):
+        s[mask]
+
+    with pytest.raises(ValueError, match=match):
+        s.loc[mask]
+
+    with pytest.raises(ValueError, match=match):
+        s.iloc[mask]
diff --git a/pandas/tests/indexing/test_partial.py b/pandas/tests/indexing/test_partial.py
index c4505231932c6..2ce07ec41758f 100644
--- a/pandas/tests/indexing/test_partial.py
+++ b/pandas/tests/indexing/test_partial.py
@@ -1,21 +1,18 @@
 """
 test setting *parts* of objects both positionally and label based
 
-TOD: these should be split among the indexer tests
+TODO: these should be split among the indexer tests
 """
 
-from warnings import catch_warnings
-
 import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, date_range
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestPartialSetting:
-    @pytest.mark.filterwarnings("ignore:\\n.ix:FutureWarning")
     def test_partial_setting(self):
 
         # GH2578, allow ix and friends to partially set
@@ -87,32 +84,28 @@ def test_partial_setting(self):
         # single dtype frame, overwrite
         expected = DataFrame(dict({"A": [0, 2, 4], "B": [0, 2, 4]}))
         df = df_orig.copy()
-        with catch_warnings(record=True):
-            df.ix[:, "B"] = df.ix[:, "A"]
+        df.loc[:, "B"] = df.loc[:, "A"]
         tm.assert_frame_equal(df, expected)
 
         # mixed dtype frame, overwrite
         expected = DataFrame(dict({"A": [0, 2, 4], "B": Series([0, 2, 4])}))
         df = df_orig.copy()
         df["B"] = df["B"].astype(np.float64)
-        with catch_warnings(record=True):
-            df.ix[:, "B"] = df.ix[:, "A"]
+        df.loc[:, "B"] = df.loc[:, "A"]
         tm.assert_frame_equal(df, expected)
 
         # single dtype frame, partial setting
         expected = df_orig.copy()
         expected["C"] = df["A"]
         df = df_orig.copy()
-        with catch_warnings(record=True):
-            df.ix[:, "C"] = df.ix[:, "A"]
+        df.loc[:, "C"] = df.loc[:, "A"]
         tm.assert_frame_equal(df, expected)
 
         # mixed frame, partial setting
         expected = df_orig.copy()
         expected["C"] = df["A"]
         df = df_orig.copy()
-        with catch_warnings(record=True):
-            df.ix[:, "C"] = df.ix[:, "A"]
+        df.loc[:, "C"] = df.loc[:, "A"]
         tm.assert_frame_equal(df, expected)
 
         # GH 8473
@@ -186,17 +179,15 @@ def test_series_partial_set(self):
 
         # loc equiv to .reindex
         expected = Series([np.nan, 0.2, np.nan], index=[3, 2, 3])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(KeyError, match="with any missing labels"):
             result = ser.loc[[3, 2, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
 
         result = ser.reindex([3, 2, 3])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         expected = Series([np.nan, 0.2, np.nan, np.nan], index=[3, 2, 3, "x"])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(KeyError, match="with any missing labels"):
             result = ser.loc[[3, 2, 3, "x"]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
 
         result = ser.reindex([3, 2, 3, "x"])
         tm.assert_series_equal(result, expected, check_index_type=True)
@@ -206,70 +197,63 @@ def test_series_partial_set(self):
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         expected = Series([0.2, 0.2, np.nan, 0.1], index=[2, 2, "x", 1])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with pytest.raises(KeyError, match="with any missing labels"):
             result = ser.loc[[2, 2, "x", 1]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
 
         result = ser.reindex([2, 2, "x", 1])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         # raises as nothing in in the index
         msg = (
-            r"\"None of \[Int64Index\(\[3, 3, 3\], dtype='int64'\)\] are"
-            r" in the \[index\]\""
+            r"\"None of \[Int64Index\(\[3, 3, 3\], dtype='int64'\)\] are "
+            r"in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             ser.loc[[3, 3, 3]]
 
         expected = Series([0.2, 0.2, np.nan], index=[2, 2, 3])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[[2, 2, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[[2, 2, 3]]
 
         result = ser.reindex([2, 2, 3])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         s = Series([0.1, 0.2, 0.3], index=[1, 2, 3])
         expected = Series([0.3, np.nan, np.nan], index=[3, 4, 4])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[3, 4, 4]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[3, 4, 4]]
 
         result = s.reindex([3, 4, 4])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         s = Series([0.1, 0.2, 0.3, 0.4], index=[1, 2, 3, 4])
         expected = Series([np.nan, 0.3, 0.3], index=[5, 3, 3])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[5, 3, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[5, 3, 3]]
 
         result = s.reindex([5, 3, 3])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         s = Series([0.1, 0.2, 0.3, 0.4], index=[1, 2, 3, 4])
         expected = Series([np.nan, 0.4, 0.4], index=[5, 4, 4])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[5, 4, 4]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[5, 4, 4]]
 
         result = s.reindex([5, 4, 4])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         s = Series([0.1, 0.2, 0.3, 0.4], index=[4, 5, 6, 7])
         expected = Series([0.4, np.nan, np.nan], index=[7, 2, 2])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[7, 2, 2]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[7, 2, 2]]
 
         result = s.reindex([7, 2, 2])
         tm.assert_series_equal(result, expected, check_index_type=True)
 
         s = Series([0.1, 0.2, 0.3, 0.4], index=[1, 2, 3, 4])
         expected = Series([0.4, np.nan, np.nan], index=[4, 5, 5])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = s.loc[[4, 5, 5]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            s.loc[[4, 5, 5]]
 
         result = s.reindex([4, 5, 5])
         tm.assert_series_equal(result, expected, check_index_type=True)
@@ -286,77 +270,50 @@ def test_series_partial_set_with_name(self):
         ser = Series([0.1, 0.2], index=idx, name="s")
 
         # loc
-        exp_idx = Index([3, 2, 3], dtype="int64", name="idx")
-        expected = Series([np.nan, 0.2, np.nan], index=exp_idx, name="s")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[[3, 2, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[[3, 2, 3]]
 
-        exp_idx = Index([3, 2, 3, "x"], dtype="object", name="idx")
-        expected = Series([np.nan, 0.2, np.nan, np.nan], index=exp_idx, name="s")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[[3, 2, 3, "x"]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[[3, 2, 3, "x"]]
 
         exp_idx = Index([2, 2, 1], dtype="int64", name="idx")
         expected = Series([0.2, 0.2, 0.1], index=exp_idx, name="s")
         result = ser.loc[[2, 2, 1]]
         tm.assert_series_equal(result, expected, check_index_type=True)
 
-        exp_idx = Index([2, 2, "x", 1], dtype="object", name="idx")
-        expected = Series([0.2, 0.2, np.nan, 0.1], index=exp_idx, name="s")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[[2, 2, "x", 1]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[[2, 2, "x", 1]]
 
         # raises as nothing in in the index
         msg = (
-            r"\"None of \[Int64Index\(\[3, 3, 3\], dtype='int64',"
-            r" name='idx'\)\] are in the \[index\]\""
+            r"\"None of \[Int64Index\(\[3, 3, 3\], dtype='int64', "
+            r"name='idx'\)\] are in the \[index\]\""
         )
         with pytest.raises(KeyError, match=msg):
             ser.loc[[3, 3, 3]]
 
-        exp_idx = Index([2, 2, 3], dtype="int64", name="idx")
-        expected = Series([0.2, 0.2, np.nan], index=exp_idx, name="s")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = ser.loc[[2, 2, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            ser.loc[[2, 2, 3]]
 
-        exp_idx = Index([3, 4, 4], dtype="int64", name="idx")
-        expected = Series([0.3, np.nan, np.nan], index=exp_idx, name="s")
         idx = Index([1, 2, 3], dtype="int64", name="idx")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = Series([0.1, 0.2, 0.3], index=idx, name="s").loc[[3, 4, 4]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            Series([0.1, 0.2, 0.3], index=idx, name="s").loc[[3, 4, 4]]
 
-        exp_idx = Index([5, 3, 3], dtype="int64", name="idx")
-        expected = Series([np.nan, 0.3, 0.3], index=exp_idx, name="s")
         idx = Index([1, 2, 3, 4], dtype="int64", name="idx")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[5, 3, 3]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[5, 3, 3]]
 
-        exp_idx = Index([5, 4, 4], dtype="int64", name="idx")
-        expected = Series([np.nan, 0.4, 0.4], index=exp_idx, name="s")
         idx = Index([1, 2, 3, 4], dtype="int64", name="idx")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[5, 4, 4]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[5, 4, 4]]
 
-        exp_idx = Index([7, 2, 2], dtype="int64", name="idx")
-        expected = Series([0.4, np.nan, np.nan], index=exp_idx, name="s")
         idx = Index([4, 5, 6, 7], dtype="int64", name="idx")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[7, 2, 2]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[7, 2, 2]]
 
-        exp_idx = Index([4, 5, 5], dtype="int64", name="idx")
-        expected = Series([0.4, np.nan, np.nan], index=exp_idx, name="s")
         idx = Index([1, 2, 3, 4], dtype="int64", name="idx")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[4, 5, 5]]
-        tm.assert_series_equal(result, expected, check_index_type=True)
+        with pytest.raises(KeyError, match="with any missing labels"):
+            Series([0.1, 0.2, 0.3, 0.4], index=idx, name="s").loc[[4, 5, 5]]
 
         # iloc
         exp_idx = Index([2, 2, 1, 1], dtype="int64", name="idx")
@@ -364,7 +321,6 @@ def test_series_partial_set_with_name(self):
         result = ser.iloc[[1, 1, 0, 0]]
         tm.assert_series_equal(result, expected, check_index_type=True)
 
-    @pytest.mark.filterwarnings("ignore:\\n.ix")
     def test_partial_set_invalid(self):
 
         # GH 4940
@@ -375,26 +331,15 @@ def test_partial_set_invalid(self):
 
         # don't allow not string inserts
         with pytest.raises(TypeError):
-            with catch_warnings(record=True):
-                df.loc[100.0, :] = df.ix[0]
-
-        with pytest.raises(TypeError):
-            with catch_warnings(record=True):
-                df.loc[100, :] = df.ix[0]
+            df.loc[100.0, :] = df.iloc[0]
 
         with pytest.raises(TypeError):
-            with catch_warnings(record=True):
-                df.ix[100.0, :] = df.ix[0]
-
-        with pytest.raises(ValueError):
-            with catch_warnings(record=True):
-                df.ix[100, :] = df.ix[0]
+            df.loc[100, :] = df.iloc[0]
 
         # allow object conversion here
         df = orig.copy()
-        with catch_warnings(record=True):
-            df.loc["a", :] = df.ix[0]
-            exp = orig.append(Series(df.ix[0], name="a"))
+        df.loc["a", :] = df.iloc[0]
+        exp = orig.append(Series(df.iloc[0], name="a"))
         tm.assert_frame_equal(df, exp)
         tm.assert_index_equal(df.index, Index(orig.index.tolist() + ["a"]))
         assert df.index.dtype == "object"
@@ -404,19 +349,19 @@ def test_partial_set_empty_series(self):
         # GH5226
 
         # partially set with an empty object series
-        s = Series()
+        s = Series(dtype=object)
         s.loc[1] = 1
         tm.assert_series_equal(s, Series([1], index=[1]))
         s.loc[3] = 3
         tm.assert_series_equal(s, Series([1, 3], index=[1, 3]))
 
-        s = Series()
+        s = Series(dtype=object)
         s.loc[1] = 1.0
         tm.assert_series_equal(s, Series([1.0], index=[1]))
         s.loc[3] = 3.0
         tm.assert_series_equal(s, Series([1.0, 3.0], index=[1, 3]))
 
-        s = Series()
+        s = Series(dtype=object)
         s.loc["foo"] = 1
         tm.assert_series_equal(s, Series([1], index=["foo"]))
         s.loc["bar"] = 3
@@ -548,11 +493,11 @@ def test_partial_set_empty_frame_row(self):
     def test_partial_set_empty_frame_set_series(self):
         # GH 5756
         # setting with empty Series
-        df = DataFrame(Series())
-        tm.assert_frame_equal(df, DataFrame({0: Series()}))
+        df = DataFrame(Series(dtype=object))
+        tm.assert_frame_equal(df, DataFrame({0: Series(dtype=object)}))
 
-        df = DataFrame(Series(name="foo"))
-        tm.assert_frame_equal(df, DataFrame({"foo": Series()}))
+        df = DataFrame(Series(name="foo", dtype=object))
+        tm.assert_frame_equal(df, DataFrame({"foo": Series(dtype=object)}))
 
     def test_partial_set_empty_frame_empty_copy_assignment(self):
         # GH 5932
diff --git a/pandas/tests/indexing/test_scalar.py b/pandas/tests/indexing/test_scalar.py
index 0b8f3af760f1d..899c58eb5edea 100644
--- a/pandas/tests/indexing/test_scalar.py
+++ b/pandas/tests/indexing/test_scalar.py
@@ -4,66 +4,68 @@
 import pytest
 
 from pandas import DataFrame, Series, Timedelta, Timestamp, date_range
+import pandas._testing as tm
 from pandas.tests.indexing.common import Base
-from pandas.util import testing as tm
 
 
 class TestScalar(Base):
-    def test_at_and_iat_get(self):
+    @pytest.mark.parametrize("kind", ["series", "frame"])
+    def test_at_and_iat_get(self, kind):
         def _check(f, func, values=False):
 
             if f is not None:
-                indicies = self.generate_indices(f, values)
-                for i in indicies:
+                indices = self.generate_indices(f, values)
+                for i in indices:
                     result = getattr(f, func)[i]
-                    expected = self.get_value(f, i, values)
+                    expected = self.get_value(func, f, i, values)
                     tm.assert_almost_equal(result, expected)
 
-        for o in self._objs:
+        d = getattr(self, kind)
 
-            d = getattr(self, o)
+        # iat
+        for f in [d["ints"], d["uints"]]:
+            _check(f, "iat", values=True)
 
-            # iat
-            for f in [d["ints"], d["uints"]]:
-                _check(f, "iat", values=True)
-
-            for f in [d["labels"], d["ts"], d["floats"]]:
-                if f is not None:
-                    msg = "iAt based indexing can only have integer indexers"
-                    with pytest.raises(ValueError, match=msg):
-                        self.check_values(f, "iat")
+        for f in [d["labels"], d["ts"], d["floats"]]:
+            if f is not None:
+                msg = "iAt based indexing can only have integer indexers"
+                with pytest.raises(ValueError, match=msg):
+                    self.check_values(f, "iat")
 
-            # at
-            for f in [d["ints"], d["uints"], d["labels"], d["ts"], d["floats"]]:
-                _check(f, "at")
+        # at
+        for f in [d["ints"], d["uints"], d["labels"], d["ts"], d["floats"]]:
+            _check(f, "at")
 
-    def test_at_and_iat_set(self):
+    @pytest.mark.parametrize("kind", ["series", "frame"])
+    def test_at_and_iat_set(self, kind):
         def _check(f, func, values=False):
 
             if f is not None:
-                indicies = self.generate_indices(f, values)
-                for i in indicies:
+                indices = self.generate_indices(f, values)
+                for i in indices:
                     getattr(f, func)[i] = 1
-                    expected = self.get_value(f, i, values)
+                    expected = self.get_value(func, f, i, values)
                     tm.assert_almost_equal(expected, 1)
 
-        for t in self._objs:
+        d = getattr(self, kind)
 
-            d = getattr(self, t)
+        # iat
+        for f in [d["ints"], d["uints"]]:
+            _check(f, "iat", values=True)
 
-            # iat
-            for f in [d["ints"], d["uints"]]:
-                _check(f, "iat", values=True)
+        for f in [d["labels"], d["ts"], d["floats"]]:
+            if f is not None:
+                msg = "iAt based indexing can only have integer indexers"
+                with pytest.raises(ValueError, match=msg):
+                    _check(f, "iat")
 
-            for f in [d["labels"], d["ts"], d["floats"]]:
-                if f is not None:
-                    msg = "iAt based indexing can only have integer indexers"
-                    with pytest.raises(ValueError, match=msg):
-                        _check(f, "iat")
+        # at
+        for f in [d["ints"], d["uints"], d["labels"], d["ts"], d["floats"]]:
+            _check(f, "at")
 
-            # at
-            for f in [d["ints"], d["uints"], d["labels"], d["ts"], d["floats"]]:
-                _check(f, "at")
+
+class TestScalar2:
+    # TODO: Better name, just separating things that dont need Base class
 
     def test_at_iat_coercion(self):
 
@@ -125,38 +127,79 @@ def test_imethods_with_dups(self):
         result = df.iat[2, 0]
         assert result == 2
 
-    def test_at_to_fail(self):
+    def test_series_at_raises_type_error(self):
         # at should not fallback
         # GH 7814
-        s = Series([1, 2, 3], index=list("abc"))
-        result = s.at["a"]
+        # GH#31724 .at should match .loc
+        ser = Series([1, 2, 3], index=list("abc"))
+        result = ser.at["a"]
+        assert result == 1
+        result = ser.loc["a"]
         assert result == 1
+
         msg = (
-            "At based indexing on an non-integer index can only have"
-            " non-integer indexers"
+            "cannot do label indexing on Index "
+            r"with these indexers \[0\] of type int"
         )
-        with pytest.raises(ValueError, match=msg):
-            s.at[0]
+        with pytest.raises(TypeError, match=msg):
+            ser.at[0]
+        with pytest.raises(TypeError, match=msg):
+            ser.loc[0]
 
+    def test_frame_raises_type_error(self):
+        # GH#31724 .at should match .loc
         df = DataFrame({"A": [1, 2, 3]}, index=list("abc"))
         result = df.at["a", "A"]
         assert result == 1
-        with pytest.raises(ValueError, match=msg):
+        result = df.loc["a", "A"]
+        assert result == 1
+
+        msg = (
+            "cannot do label indexing on Index "
+            r"with these indexers \[0\] of type int"
+        )
+        with pytest.raises(TypeError, match=msg):
             df.at["a", 0]
+        with pytest.raises(TypeError, match=msg):
+            df.loc["a", 0]
+
+    def test_series_at_raises_key_error(self):
+        # GH#31724 .at should match .loc
 
-        s = Series([1, 2, 3], index=[3, 2, 1])
-        result = s.at[1]
+        ser = Series([1, 2, 3], index=[3, 2, 1])
+        result = ser.at[1]
+        assert result == 3
+        result = ser.loc[1]
         assert result == 3
-        msg = "At based indexing on an integer index can only have integer indexers"
-        with pytest.raises(ValueError, match=msg):
-            s.at["a"]
+
+        with pytest.raises(KeyError, match="a"):
+            ser.at["a"]
+        with pytest.raises(KeyError, match="a"):
+            # .at should match .loc
+            ser.loc["a"]
+
+    def test_frame_at_raises_key_error(self):
+        # GH#31724 .at should match .loc
 
         df = DataFrame({0: [1, 2, 3]}, index=[3, 2, 1])
+
         result = df.at[1, 0]
         assert result == 3
-        with pytest.raises(ValueError, match=msg):
+        result = df.loc[1, 0]
+        assert result == 3
+
+        with pytest.raises(KeyError, match="a"):
             df.at["a", 0]
+        with pytest.raises(KeyError, match="a"):
+            df.loc["a", 0]
+
+        with pytest.raises(KeyError, match="a"):
+            df.at[1, "a"]
+        with pytest.raises(KeyError, match="a"):
+            df.loc[1, "a"]
 
+    # TODO: belongs somewhere else?
+    def test_getitem_list_missing_key(self):
         # GH 13822, incorrect error string with non-unique columns when missing
         # column is accessed
         df = DataFrame({"x": [1.0], "y": [2.0], "z": [3.0]})
diff --git a/pandas/tests/indexing/test_timedelta.py b/pandas/tests/indexing/test_timedelta.py
index 7628aa53ef3cb..dd4750123c0b5 100644
--- a/pandas/tests/indexing/test_timedelta.py
+++ b/pandas/tests/indexing/test_timedelta.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestTimedeltaIndexing:
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index f87d6dba72e68..aa966caa63238 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1,10 +1,8 @@
 from collections import OrderedDict
 from datetime import date, datetime
-from distutils.version import LooseVersion
 import itertools
 import operator
 import re
-import sys
 
 import numpy as np
 import pytest
@@ -12,28 +10,11 @@
 from pandas._libs.internals import BlockPlacement
 
 import pandas as pd
-from pandas import (
-    Categorical,
-    DataFrame,
-    DatetimeIndex,
-    Index,
-    MultiIndex,
-    Series,
-    SparseArray,
-)
+from pandas import Categorical, DataFrame, DatetimeIndex, Index, MultiIndex, Series
+import pandas._testing as tm
 import pandas.core.algorithms as algos
-from pandas.core.arrays import DatetimeArray, TimedeltaArray
+from pandas.core.arrays import DatetimeArray, SparseArray, TimedeltaArray
 from pandas.core.internals import BlockManager, SingleBlockManager, make_block
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-    randn,
-)
-
-# in 3.6.1 a c-api slicing function changed, see src/compat_helper.h
-PY361 = LooseVersion(sys.version) >= LooseVersion("3.6.1")
 
 
 @pytest.fixture
@@ -145,7 +126,7 @@ def create_block(typestr, placement, item_shape=None, num_offset=0):
         arr = values.sp_values.view()
         arr += num_offset - 1
     else:
-        raise ValueError('Unsupported typestr: "%s"' % typestr)
+        raise ValueError(f'Unsupported typestr: "{typestr}"')
 
     return make_block(values, placement=placement, ndim=len(shape))
 
@@ -261,8 +242,8 @@ def test_attrs(self):
         assert len(self.fblock) == len(self.fblock.values)
 
     def test_merge(self):
-        avals = randn(2, 10)
-        bvals = randn(2, 10)
+        avals = tm.randn(2, 10)
+        bvals = tm.randn(2, 10)
 
         ref_cols = Index(["e", "a", "b", "d", "f"])
 
@@ -316,30 +297,38 @@ def test_delete(self):
         assert (newb.values[1] == 1).all()
 
         newb = self.fblock.copy()
-        with pytest.raises(Exception):
-            newb.delete(3)
 
-    def test_make_block_same_class(self):
-        # issue 19431
-        block = create_block("M8[ns, US/Eastern]", [3])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            block.make_block_same_class(block.values, dtype=block.values.dtype)
+        with pytest.raises(IndexError, match=None):
+            newb.delete(3)
 
 
 class TestDatetimeBlock:
-    def test_try_coerce_arg(self):
+    def test_can_hold_element(self):
         block = create_block("datetime", [0])
 
+        # We will check that block._can_hold_element iff arr.__setitem__ works
+        arr = pd.array(block.values.ravel())
+
         # coerce None
-        none_coerced = block._try_coerce_args(None)
-        assert pd.Timestamp(none_coerced) is pd.NaT
+        assert block._can_hold_element(None)
+        arr[0] = None
+        assert arr[0] is pd.NaT
 
-        # coerce different types of date bojects
-        vals = (np.datetime64("2010-10-10"), datetime(2010, 10, 10), date(2010, 10, 10))
+        # coerce different types of datetime objects
+        vals = [np.datetime64("2010-10-10"), datetime(2010, 10, 10)]
         for val in vals:
-            coerced = block._try_coerce_args(val)
-            assert np.datetime64 == type(coerced)
-            assert pd.Timestamp("2010-10-10") == pd.Timestamp(coerced)
+            assert block._can_hold_element(val)
+            arr[0] = val
+
+        val = date(2010, 10, 10)
+        assert not block._can_hold_element(val)
+
+        msg = (
+            "'value' should be a 'Timestamp', 'NaT', "
+            "or array of those. Got 'date' instead."
+        )
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = val
 
 
 class TestBlockManager:
@@ -367,7 +356,10 @@ def test_duplicate_ref_loc_failure(self):
         blocks[1].mgr_locs = np.array([0])
 
         # test trying to create block manager with overlapping ref locs
-        with pytest.raises(AssertionError):
+
+        msg = "Gaps in blk ref_locs"
+
+        with pytest.raises(AssertionError, match=msg):
             BlockManager(blocks, axes)
 
         blocks[0].mgr_locs = np.array([0])
@@ -382,7 +374,7 @@ def test_contains(self, mgr):
     def test_pickle(self, mgr):
 
         mgr2 = tm.round_trip_pickle(mgr)
-        assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
+        tm.assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
 
         # share ref_items
         # assert mgr2.blocks[0].ref_items is mgr2.blocks[1].ref_items
@@ -399,20 +391,20 @@ def test_non_unique_pickle(self):
 
         mgr = create_mgr("a,a,a:f8")
         mgr2 = tm.round_trip_pickle(mgr)
-        assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
+        tm.assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
 
         mgr = create_mgr("a: f8; a: i8")
         mgr2 = tm.round_trip_pickle(mgr)
-        assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
+        tm.assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
 
     def test_categorical_block_pickle(self):
         mgr = create_mgr("a: category")
         mgr2 = tm.round_trip_pickle(mgr)
-        assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
+        tm.assert_frame_equal(DataFrame(mgr), DataFrame(mgr2))
 
         smgr = create_single_mgr("category")
         smgr2 = tm.round_trip_pickle(smgr)
-        assert_series_equal(Series(smgr), Series(smgr2))
+        tm.assert_series_equal(Series(smgr), Series(smgr2))
 
     def test_get(self):
         cols = Index(list("abc"))
@@ -420,9 +412,9 @@ def test_get(self):
         block = make_block(values=values.copy(), placement=np.arange(3))
         mgr = BlockManager(blocks=[block], axes=[cols, np.arange(3)])
 
-        assert_almost_equal(mgr.get("a").internal_values(), values[0])
-        assert_almost_equal(mgr.get("b").internal_values(), values[1])
-        assert_almost_equal(mgr.get("c").internal_values(), values[2])
+        tm.assert_almost_equal(mgr.get("a").internal_values(), values[0])
+        tm.assert_almost_equal(mgr.get("b").internal_values(), values[1])
+        tm.assert_almost_equal(mgr.get("c").internal_values(), values[2])
 
     def test_set(self):
         mgr = create_mgr("a,b,c: int", item_shape=(3,))
@@ -448,10 +440,10 @@ def test_set_change_dtype(self, mgr):
         mgr2.set("baz", np.repeat("foo", N))
         assert mgr2.get("baz").dtype == np.object_
 
-        mgr2.set("quux", randn(N).astype(int))
+        mgr2.set("quux", tm.randn(N).astype(int))
         assert mgr2.get("quux").dtype == np.int_
 
-        mgr2.set("quux", randn(N))
+        mgr2.set("quux", tm.randn(N))
         assert mgr2.get("quux").dtype == np.float_
 
     def test_set_change_dtype_slice(self):  # GH8850
@@ -461,10 +453,10 @@ def test_set_change_dtype_slice(self):  # GH8850
 
         blocks = df._to_dict_of_blocks()
         assert sorted(blocks.keys()) == ["float64", "int64"]
-        assert_frame_equal(
+        tm.assert_frame_equal(
             blocks["float64"], DataFrame([[1.0, 4.0], [4.0, 10.0]], columns=cols[:2])
         )
-        assert_frame_equal(blocks["int64"], DataFrame([[3], [6]], columns=cols[2:]))
+        tm.assert_frame_equal(blocks["int64"], DataFrame([[3], [6]], columns=cols[2:]))
 
     def test_copy(self, mgr):
         cp = mgr.copy(deep=False)
@@ -528,32 +520,33 @@ def test_as_array_datetime_tz(self):
         assert mgr.get("g").dtype == "datetime64[ns, CET]"
         assert mgr.as_array().dtype == "object"
 
-    def test_astype(self):
+    @pytest.mark.parametrize("t", ["float16", "float32", "float64", "int32", "int64"])
+    def test_astype(self, t):
         # coerce all
         mgr = create_mgr("c: f4; d: f2; e: f8")
-        for t in ["float16", "float32", "float64", "int32", "int64"]:
-            t = np.dtype(t)
-            tmgr = mgr.astype(t)
-            assert tmgr.get("c").dtype.type == t
-            assert tmgr.get("d").dtype.type == t
-            assert tmgr.get("e").dtype.type == t
+
+        t = np.dtype(t)
+        tmgr = mgr.astype(t)
+        assert tmgr.get("c").dtype.type == t
+        assert tmgr.get("d").dtype.type == t
+        assert tmgr.get("e").dtype.type == t
 
         # mixed
         mgr = create_mgr("a,b: object; c: bool; d: datetime; e: f4; f: f2; g: f8")
-        for t in ["float16", "float32", "float64", "int32", "int64"]:
-            t = np.dtype(t)
-            tmgr = mgr.astype(t, errors="ignore")
-            assert tmgr.get("c").dtype.type == t
-            assert tmgr.get("e").dtype.type == t
-            assert tmgr.get("f").dtype.type == t
-            assert tmgr.get("g").dtype.type == t
-
-            assert tmgr.get("a").dtype.type == np.object_
-            assert tmgr.get("b").dtype.type == np.object_
-            if t != np.int64:
-                assert tmgr.get("d").dtype.type == np.datetime64
-            else:
-                assert tmgr.get("d").dtype.type == t
+
+        t = np.dtype(t)
+        tmgr = mgr.astype(t, errors="ignore")
+        assert tmgr.get("c").dtype.type == t
+        assert tmgr.get("e").dtype.type == t
+        assert tmgr.get("f").dtype.type == t
+        assert tmgr.get("g").dtype.type == t
+
+        assert tmgr.get("a").dtype.type == np.object_
+        assert tmgr.get("b").dtype.type == np.object_
+        if t != np.int64:
+            assert tmgr.get("d").dtype.type == np.datetime64
+        else:
+            assert tmgr.get("d").dtype.type == t
 
     def test_convert(self):
         def _compare(old_mgr, new_mgr):
@@ -679,11 +672,11 @@ def test_consolidate(self):
         pass
 
     def test_consolidate_ordering_issues(self, mgr):
-        mgr.set("f", randn(N))
-        mgr.set("d", randn(N))
-        mgr.set("b", randn(N))
-        mgr.set("g", randn(N))
-        mgr.set("h", randn(N))
+        mgr.set("f", tm.randn(N))
+        mgr.set("d", tm.randn(N))
+        mgr.set("b", tm.randn(N))
+        mgr.set("g", tm.randn(N))
+        mgr.set("h", tm.randn(N))
 
         # we have datetime/tz blocks in mgr
         cons = mgr.consolidate()
@@ -706,16 +699,16 @@ def test_reindex_items(self):
         reindexed = mgr.reindex_axis(["g", "c", "a", "d"], axis=0)
         assert reindexed.nblocks == 2
         tm.assert_index_equal(reindexed.items, pd.Index(["g", "c", "a", "d"]))
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("g").internal_values(), reindexed.get("g").internal_values()
         )
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("c").internal_values(), reindexed.get("c").internal_values()
         )
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("a").internal_values(), reindexed.get("a").internal_values()
         )
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("d").internal_values(), reindexed.get("d").internal_values()
         )
 
@@ -731,13 +724,13 @@ def test_get_numeric_data(self):
         tm.assert_index_equal(
             numeric.items, pd.Index(["int", "float", "complex", "bool"])
         )
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("float").internal_values(), numeric.get("float").internal_values()
         )
 
         # Check sharing
         numeric.set("float", np.array([100.0, 200.0, 300.0]))
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("float").internal_values(), np.array([100.0, 200.0, 300.0])
         )
 
@@ -746,7 +739,7 @@ def test_get_numeric_data(self):
             numeric.items, pd.Index(["int", "float", "complex", "bool"])
         )
         numeric2.set("float", np.array([1000.0, 2000.0, 3000.0]))
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("float").internal_values(), np.array([100.0, 200.0, 300.0])
         )
 
@@ -760,7 +753,7 @@ def test_get_bool_data(self):
 
         bools = mgr.get_bool_data()
         tm.assert_index_equal(bools.items, pd.Index(["bool"]))
-        assert_almost_equal(
+        tm.assert_almost_equal(
             mgr.get("bool").internal_values(), bools.get("bool").internal_values()
         )
 
@@ -824,7 +817,11 @@ def test_validate_bool_args(self):
         bm1 = create_mgr("a,b,c: i8-1; d,e,f: i8-2")
 
         for value in invalid_values:
-            with pytest.raises(ValueError):
+            msg = (
+                'For argument "inplace" expected type bool, '
+                f"received type {type(value).__name__}."
+            )
+            with pytest.raises(ValueError, match=msg):
                 bm1.replace_list([1], [2], inplace=value)
 
 
@@ -1043,9 +1040,11 @@ def test_slice_len(self):
         assert len(BlockPlacement(slice(1, 0, -1))) == 1
 
     def test_zero_step_raises(self):
-        with pytest.raises(ValueError):
+        msg = "slice step cannot be zero"
+
+        with pytest.raises(ValueError, match=msg):
             BlockPlacement(slice(1, 1, 0))
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=msg):
             BlockPlacement(slice(1, 2, 0))
 
     def test_unbounded_slice_raises(self):
@@ -1093,10 +1092,6 @@ def assert_as_slice_equals(arr, slc):
 
         assert_as_slice_equals([2, 1], slice(2, 0, -1))
 
-        if not PY361:
-            assert_as_slice_equals([2, 1, 0], slice(2, None, -1))
-            assert_as_slice_equals([100, 0], slice(100, None, -100))
-
     def test_not_slice_like_arrays(self):
         def assert_not_slice_like(arr):
             assert not BlockPlacement(arr).is_slice_like
@@ -1116,10 +1111,6 @@ def test_slice_iter(self):
         assert list(BlockPlacement(slice(0, 0))) == []
         assert list(BlockPlacement(slice(3, 0))) == []
 
-        if not PY361:
-            assert list(BlockPlacement(slice(3, 0, -1))) == [3, 2, 1]
-            assert list(BlockPlacement(slice(3, None, -1))) == [3, 2, 1, 0]
-
     def test_slice_to_array_conversion(self):
         def assert_as_array_equals(slc, asarray):
             tm.assert_numpy_array_equal(
@@ -1132,10 +1123,6 @@ def assert_as_array_equals(slc, asarray):
 
         assert_as_array_equals(slice(3, 0, -1), [3, 2, 1])
 
-        if not PY361:
-            assert_as_array_equals(slice(3, None, -1), [3, 2, 1, 0])
-            assert_as_array_equals(slice(31, None, -10), [31, 21, 11, 1])
-
     def test_blockplacement_add(self):
         bpl = BlockPlacement(slice(0, 5))
         assert bpl.add(1).as_slice == slice(1, 6, 1)
@@ -1160,19 +1147,13 @@ def assert_add_equals(val, inc, result):
         assert_add_equals(slice(1, 4), -1, [0, 1, 2])
         assert_add_equals([1, 2, 4], -1, [0, 1, 3])
 
-        with pytest.raises(ValueError):
+        msg = "iadd causes length change"
+
+        with pytest.raises(ValueError, match=msg):
             BlockPlacement(slice(1, 4)).add(-10)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=msg):
             BlockPlacement([1, 2, 4]).add(-10)
 
-        if not PY361:
-            assert_add_equals(slice(3, 0, -1), -1, [2, 1, 0])
-            assert_add_equals(slice(2, None, -1), 0, [2, 1, 0])
-            assert_add_equals(slice(2, None, -1), 10, [12, 11, 10])
-
-            with pytest.raises(ValueError):
-                BlockPlacement(slice(2, None, -1)).add(-1)
-
 
 class DummyElement:
     def __init__(self, value, dtype):
@@ -1182,10 +1163,10 @@ def __init__(self, value, dtype):
     def __array__(self):
         return np.array(self.value, dtype=self.dtype)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "DummyElement({}, {})".format(self.value, self.dtype)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self)
 
     def astype(self, dtype, copy=False):
@@ -1236,7 +1217,7 @@ def test_binop_other(self, op, value, dtype):
             (operator.pow, "bool"),
         }
         if (op, dtype) in skip:
-            pytest.skip("Invalid combination {},{}".format(op, dtype))
+            pytest.skip(f"Invalid combination {op},{dtype}")
 
         e = DummyElement(value, dtype)
         s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
@@ -1252,14 +1233,24 @@ def test_binop_other(self, op, value, dtype):
         }
 
         if (op, dtype) in invalid:
-            with pytest.raises(TypeError):
+            msg = (
+                None
+                if (dtype == "<M8[ns]" and op == operator.add)
+                or (dtype == "<m8[ns]" and op == operator.mul)
+                else (
+                    f"cannot perform __{op.__name__}__ with this "
+                    "index type: (DatetimeArray|TimedeltaArray)"
+                )
+            )
+
+            with pytest.raises(TypeError, match=msg):
                 op(s, e.value)
         else:
             # FIXME: Since dispatching to Series, this test no longer
             # asserts anything meaningful
             result = op(s, e.value).dtypes
             expected = op(s, value).dtypes
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -1277,13 +1268,6 @@ def test_holder(typestr, holder):
     assert blk._holder is holder
 
 
-def test_deprecated_fastpath():
-    # GH#19265
-    values = np.random.rand(3, 3)
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        make_block(values, placement=np.arange(3), fastpath=True)
-
-
 def test_validate_ndim():
     values = np.array([1.0, 2.0])
     placement = slice(2)
@@ -1303,7 +1287,7 @@ def test_block_shape():
 
 def test_make_block_no_pandas_array():
     # https://github.com/pandas-dev/pandas/pull/24866
-    arr = pd.array([1, 2])
+    arr = pd.arrays.PandasArray(np.array([1, 2]))
 
     # PandasArray, no dtype
     result = make_block(arr, slice(len(arr)))
@@ -1319,3 +1303,10 @@ def test_make_block_no_pandas_array():
     result = make_block(arr.to_numpy(), slice(len(arr)), dtype=arr.dtype)
     assert result.is_integer is True
     assert result.is_extension is False
+
+
+def test_dataframe_not_equal():
+    # see GH28839
+    df1 = pd.DataFrame({"a": [1, 2], "b": ["s", "d"]})
+    df2 = pd.DataFrame({"a": ["s", "d"], "b": [1, 2]})
+    assert df1.equals(df2) is False
diff --git a/pandas/tests/io/conftest.py b/pandas/tests/io/conftest.py
index 7b6b9b6380a36..7810778602e12 100644
--- a/pandas/tests/io/conftest.py
+++ b/pandas/tests/io/conftest.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.parsers import read_csv
 
@@ -40,7 +40,7 @@ def s3_resource(tips_file, jsonl_file):
     A private bucket "cant_get_it" is also created. The boto3 s3 resource
     is yielded by the fixture.
     """
-    pytest.importorskip("s3fs")
+    s3fs = pytest.importorskip("s3fs")
     boto3 = pytest.importorskip("boto3")
 
     with tm.ensure_safe_environment_variables():
@@ -77,6 +77,7 @@ def add_tips_files(bucket_name):
 
             conn.create_bucket(Bucket="cant_get_it", ACL="private")
             add_tips_files("cant_get_it")
+            s3fs.S3FileSystem.clear_instance_cache()
             yield conn
         finally:
             s3.stop()
diff --git a/pandas/tests/io/data/categorical_0_14_1.pickle b/pandas/tests/io/data/categorical_0_14_1.pickle
deleted file mode 100644
index 94f882b2f3027..0000000000000
--- a/pandas/tests/io/data/categorical_0_14_1.pickle
+++ /dev/null
@@ -1,94 +0,0 @@
-ccopy_reg
-_reconstructor
-p0
-(cpandas.core.categorical
-Categorical
-p1
-c__builtin__
-object
-p2
-Ntp3
-Rp4
-(dp5
-S'_levels'
-p6
-cnumpy.core.multiarray
-_reconstruct
-p7
-(cpandas.core.index
-Index
-p8
-(I0
-tp9
-S'b'
-p10
-tp11
-Rp12
-((I1
-(I4
-tp13
-cnumpy
-dtype
-p14
-(S'O8'
-p15
-I0
-I1
-tp16
-Rp17
-(I3
-S'|'
-p18
-NNNI-1
-I-1
-I63
-tp19
-bI00
-(lp20
-S'a'
-p21
-ag10
-aS'c'
-p22
-aS'd'
-p23
-atp24
-(Ntp25
-tp26
-bsS'labels'
-p27
-g7
-(cnumpy
-ndarray
-p28
-(I0
-tp29
-g10
-tp30
-Rp31
-(I1
-(I3
-tp32
-g14
-(S'i8'
-p33
-I0
-I1
-tp34
-Rp35
-(I3
-S'<'
-p36
-NNNI-1
-I-1
-I0
-tp37
-bI00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00'
-p38
-tp39
-bsS'name'
-p40
-S'foobar'
-p41
-sb.
\ No newline at end of file
diff --git a/pandas/tests/io/data/categorical_0_15_2.pickle b/pandas/tests/io/data/categorical_0_15_2.pickle
deleted file mode 100644
index 25cd862976cab..0000000000000
Binary files a/pandas/tests/io/data/categorical_0_15_2.pickle and /dev/null differ
diff --git a/pandas/tests/io/data/computer_sales_page.html b/pandas/tests/io/data/computer_sales_page.html
deleted file mode 100644
index ff2b031b58d64..0000000000000
--- a/pandas/tests/io/data/computer_sales_page.html
+++ /dev/null
@@ -1,619 +0,0 @@
-<table width="100%" border="0" cellspacing="0" cellpadding="0">
-<tbody><tr><!-- TABLE COLUMN WIDTHS SET -->
-<td width="" style="font-family:times;"></td>
-<td width="12pt" style="font-family:times;"></td>
-<td width="7pt" align="RIGHT" style="font-family:times;"></td>
-<td width="45pt" style="font-family:times;"></td>
-<td width="12pt" style="font-family:times;"></td>
-<td width="7pt" align="RIGHT" style="font-family:times;"></td>
-<td width="45pt" style="font-family:times;"></td>
-<td width="12pt" style="font-family:times;"></td>
-<td width="7pt" align="RIGHT" style="font-family:times;"></td>
-<td width="45pt" style="font-family:times;"></td>
-<td width="12pt" style="font-family:times;"></td>
-<td width="7pt" align="RIGHT" style="font-family:times;"></td>
-<td width="45pt" style="font-family:times;"></td>
-<td width="12pt" style="font-family:times;"></td>
-<!-- TABLE COLUMN WIDTHS END --></tr>
-
-<tr valign="BOTTOM">
-<th align="LEFT" style="font-family:times;"><font size="2">&nbsp;</font><br></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="5" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>Three months ended<br>
-April&nbsp;30 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="5" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>Six months ended<br>
-April&nbsp;30 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-</tr>
-<tr valign="BOTTOM">
-<th align="LEFT" style="font-family:times;"><font size="1">&nbsp;</font><br></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="2" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>2013 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="2" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>2012 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="2" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>2013 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="2" align="CENTER" style="font-family:times;border-bottom:solid #000000 1.0pt;"><font size="1"><b>2012 </b></font></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-</tr>
-<tr valign="BOTTOM">
-<th align="LEFT" style="font-family:times;"><font size="1">&nbsp;</font><br></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-<th colspan="11" align="CENTER" style="font-family:times;"><font size="1"><b>In millions</b></font><br></th>
-<th style="font-family:times;"><font size="1">&nbsp;</font></th>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Net revenue:</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Notebooks</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,718</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,900</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,846</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">9,842</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Desktops</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,103</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,827</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,424</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,033</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Workstations</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">521</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">537</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,056</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,072</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Other</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">242</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">206</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">462</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">415</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Personal Systems</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,584</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">9,470</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">15,788</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">18,362</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Supplies</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,122</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,060</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">8,015</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">8,139</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Commercial Hardware</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,398</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,479</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,752</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,968</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Consumer Hardware</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">561</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">593</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,240</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,283</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Printing</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,081</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,132</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">12,007</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">12,390</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Printing and Personal Systems Group</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">13,665</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">15,602</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">27,795</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">30,752</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Industry Standard Servers</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,806</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,186</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">5,800</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,258</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Technology Services</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,272</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,335</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,515</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,599</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Storage</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">857</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">990</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,690</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,945</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Networking</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">618</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">614</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,226</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,200</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Business Critical Systems</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">266</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">421</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">572</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">826</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Enterprise Group</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,819</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,546</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">13,803</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">14,828</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Infrastructure Technology Outsourcing</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,721</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">3,954</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,457</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7,934</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:20pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Application and Business Services</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,278</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">2,535</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,461</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">4,926</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Enterprise Services</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">5,999</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">6,489</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">11,918</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">12,860</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Software</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">941</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">970</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,867</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,916</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">HP Financial Services</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">881</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">968</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,838</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">1,918</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Corporate Investments</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">10</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">7</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">14</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">37</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Total segments</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">28,315</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">31,582</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">57,235</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">62,311</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="#CCEEFF" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:10pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Eliminations of intersegment net revenue and other</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">(733</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">)</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">(889</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">)</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">(1,294</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">)</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">(1,582</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">)</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:solid #000000 1.0pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-<tr bgcolor="White" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;"><p style="font-family:times;margin-left:30pt;text-indent:-10pt;"><font size="2"> </font><font size="2">Total HP consolidated net revenue</font></p></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">27,582</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">30,693</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">55,941</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">$</font></td>
-<td align="RIGHT" valign="BOTTOM" style="font-family:times;"><font size="2">60,729</font></td>
-<td valign="BOTTOM" style="font-family:times;"><font size="2">&nbsp;</font></td>
-</tr>
-<tr style="font-size:1.5pt;" valign="TOP">
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:double #000000 2.25pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:double #000000 2.25pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:double #000000 2.25pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-<td colspan="2" align="RIGHT" valign="BOTTOM" style="font-family:times;border-bottom:double #000000 2.25pt;">&nbsp;</td>
-<td valign="BOTTOM" style="font-family:times;">&nbsp;</td>
-</tr>
-</tbody></table>
diff --git a/pandas/tests/io/data/banklist.csv b/pandas/tests/io/data/csv/banklist.csv
similarity index 100%
rename from pandas/tests/io/data/banklist.csv
rename to pandas/tests/io/data/csv/banklist.csv
diff --git a/pandas/tests/io/data/iris.csv b/pandas/tests/io/data/csv/iris.csv
similarity index 100%
rename from pandas/tests/io/data/iris.csv
rename to pandas/tests/io/data/csv/iris.csv
diff --git a/pandas/tests/io/data/test1.csv b/pandas/tests/io/data/csv/test1.csv
similarity index 100%
rename from pandas/tests/io/data/test1.csv
rename to pandas/tests/io/data/csv/test1.csv
diff --git a/pandas/tests/io/data/test_mmap.csv b/pandas/tests/io/data/csv/test_mmap.csv
similarity index 100%
rename from pandas/tests/io/data/test_mmap.csv
rename to pandas/tests/io/data/csv/test_mmap.csv
diff --git a/pandas/tests/io/data/tips.csv b/pandas/tests/io/data/csv/tips.csv
similarity index 100%
rename from pandas/tests/io/data/tips.csv
rename to pandas/tests/io/data/csv/tips.csv
diff --git a/pandas/tests/io/data/blank.ods b/pandas/tests/io/data/excel/blank.ods
similarity index 100%
rename from pandas/tests/io/data/blank.ods
rename to pandas/tests/io/data/excel/blank.ods
diff --git a/pandas/tests/io/data/blank.xls b/pandas/tests/io/data/excel/blank.xls
similarity index 100%
rename from pandas/tests/io/data/blank.xls
rename to pandas/tests/io/data/excel/blank.xls
diff --git a/pandas/tests/io/data/excel/blank.xlsb b/pandas/tests/io/data/excel/blank.xlsb
new file mode 100644
index 0000000000000..d72fd68ab3dbf
Binary files /dev/null and b/pandas/tests/io/data/excel/blank.xlsb differ
diff --git a/pandas/tests/io/data/blank.xlsm b/pandas/tests/io/data/excel/blank.xlsm
similarity index 100%
rename from pandas/tests/io/data/blank.xlsm
rename to pandas/tests/io/data/excel/blank.xlsm
diff --git a/pandas/tests/io/data/blank.xlsx b/pandas/tests/io/data/excel/blank.xlsx
similarity index 100%
rename from pandas/tests/io/data/blank.xlsx
rename to pandas/tests/io/data/excel/blank.xlsx
diff --git a/pandas/tests/io/data/blank_with_header.ods b/pandas/tests/io/data/excel/blank_with_header.ods
similarity index 100%
rename from pandas/tests/io/data/blank_with_header.ods
rename to pandas/tests/io/data/excel/blank_with_header.ods
diff --git a/pandas/tests/io/data/blank_with_header.xls b/pandas/tests/io/data/excel/blank_with_header.xls
similarity index 100%
rename from pandas/tests/io/data/blank_with_header.xls
rename to pandas/tests/io/data/excel/blank_with_header.xls
diff --git a/pandas/tests/io/data/excel/blank_with_header.xlsb b/pandas/tests/io/data/excel/blank_with_header.xlsb
new file mode 100644
index 0000000000000..3c241513d221a
Binary files /dev/null and b/pandas/tests/io/data/excel/blank_with_header.xlsb differ
diff --git a/pandas/tests/io/data/blank_with_header.xlsm b/pandas/tests/io/data/excel/blank_with_header.xlsm
similarity index 100%
rename from pandas/tests/io/data/blank_with_header.xlsm
rename to pandas/tests/io/data/excel/blank_with_header.xlsm
diff --git a/pandas/tests/io/data/blank_with_header.xlsx b/pandas/tests/io/data/excel/blank_with_header.xlsx
similarity index 100%
rename from pandas/tests/io/data/blank_with_header.xlsx
rename to pandas/tests/io/data/excel/blank_with_header.xlsx
diff --git a/pandas/tests/io/data/invalid_value_type.ods b/pandas/tests/io/data/excel/invalid_value_type.ods
similarity index 100%
rename from pandas/tests/io/data/invalid_value_type.ods
rename to pandas/tests/io/data/excel/invalid_value_type.ods
diff --git a/pandas/tests/io/data/test1.ods b/pandas/tests/io/data/excel/test1.ods
similarity index 100%
rename from pandas/tests/io/data/test1.ods
rename to pandas/tests/io/data/excel/test1.ods
diff --git a/pandas/tests/io/data/test1.xls b/pandas/tests/io/data/excel/test1.xls
similarity index 100%
rename from pandas/tests/io/data/test1.xls
rename to pandas/tests/io/data/excel/test1.xls
diff --git a/pandas/tests/io/data/excel/test1.xlsb b/pandas/tests/io/data/excel/test1.xlsb
new file mode 100644
index 0000000000000..d0b8a1f2735bd
Binary files /dev/null and b/pandas/tests/io/data/excel/test1.xlsb differ
diff --git a/pandas/tests/io/data/test1.xlsm b/pandas/tests/io/data/excel/test1.xlsm
similarity index 100%
rename from pandas/tests/io/data/test1.xlsm
rename to pandas/tests/io/data/excel/test1.xlsm
diff --git a/pandas/tests/io/data/test1.xlsx b/pandas/tests/io/data/excel/test1.xlsx
similarity index 100%
rename from pandas/tests/io/data/test1.xlsx
rename to pandas/tests/io/data/excel/test1.xlsx
diff --git a/pandas/tests/io/data/test2.ods b/pandas/tests/io/data/excel/test2.ods
similarity index 100%
rename from pandas/tests/io/data/test2.ods
rename to pandas/tests/io/data/excel/test2.ods
diff --git a/pandas/tests/io/data/test2.xls b/pandas/tests/io/data/excel/test2.xls
similarity index 100%
rename from pandas/tests/io/data/test2.xls
rename to pandas/tests/io/data/excel/test2.xls
diff --git a/pandas/tests/io/data/excel/test2.xlsb b/pandas/tests/io/data/excel/test2.xlsb
new file mode 100644
index 0000000000000..e19a0f1e067c8
Binary files /dev/null and b/pandas/tests/io/data/excel/test2.xlsb differ
diff --git a/pandas/tests/io/data/test2.xlsm b/pandas/tests/io/data/excel/test2.xlsm
similarity index 100%
rename from pandas/tests/io/data/test2.xlsm
rename to pandas/tests/io/data/excel/test2.xlsm
diff --git a/pandas/tests/io/data/test2.xlsx b/pandas/tests/io/data/excel/test2.xlsx
similarity index 100%
rename from pandas/tests/io/data/test2.xlsx
rename to pandas/tests/io/data/excel/test2.xlsx
diff --git a/pandas/tests/io/data/test3.ods b/pandas/tests/io/data/excel/test3.ods
similarity index 100%
rename from pandas/tests/io/data/test3.ods
rename to pandas/tests/io/data/excel/test3.ods
diff --git a/pandas/tests/io/data/test3.xls b/pandas/tests/io/data/excel/test3.xls
similarity index 100%
rename from pandas/tests/io/data/test3.xls
rename to pandas/tests/io/data/excel/test3.xls
diff --git a/pandas/tests/io/data/excel/test3.xlsb b/pandas/tests/io/data/excel/test3.xlsb
new file mode 100644
index 0000000000000..617d27630e8a0
Binary files /dev/null and b/pandas/tests/io/data/excel/test3.xlsb differ
diff --git a/pandas/tests/io/data/test3.xlsm b/pandas/tests/io/data/excel/test3.xlsm
similarity index 100%
rename from pandas/tests/io/data/test3.xlsm
rename to pandas/tests/io/data/excel/test3.xlsm
diff --git a/pandas/tests/io/data/test3.xlsx b/pandas/tests/io/data/excel/test3.xlsx
similarity index 100%
rename from pandas/tests/io/data/test3.xlsx
rename to pandas/tests/io/data/excel/test3.xlsx
diff --git a/pandas/tests/io/data/test4.ods b/pandas/tests/io/data/excel/test4.ods
similarity index 100%
rename from pandas/tests/io/data/test4.ods
rename to pandas/tests/io/data/excel/test4.ods
diff --git a/pandas/tests/io/data/test4.xls b/pandas/tests/io/data/excel/test4.xls
similarity index 100%
rename from pandas/tests/io/data/test4.xls
rename to pandas/tests/io/data/excel/test4.xls
diff --git a/pandas/tests/io/data/excel/test4.xlsb b/pandas/tests/io/data/excel/test4.xlsb
new file mode 100644
index 0000000000000..2e5bb229939be
Binary files /dev/null and b/pandas/tests/io/data/excel/test4.xlsb differ
diff --git a/pandas/tests/io/data/test4.xlsm b/pandas/tests/io/data/excel/test4.xlsm
similarity index 100%
rename from pandas/tests/io/data/test4.xlsm
rename to pandas/tests/io/data/excel/test4.xlsm
diff --git a/pandas/tests/io/data/test4.xlsx b/pandas/tests/io/data/excel/test4.xlsx
similarity index 100%
rename from pandas/tests/io/data/test4.xlsx
rename to pandas/tests/io/data/excel/test4.xlsx
diff --git a/pandas/tests/io/data/test5.ods b/pandas/tests/io/data/excel/test5.ods
similarity index 100%
rename from pandas/tests/io/data/test5.ods
rename to pandas/tests/io/data/excel/test5.ods
diff --git a/pandas/tests/io/data/test5.xls b/pandas/tests/io/data/excel/test5.xls
similarity index 100%
rename from pandas/tests/io/data/test5.xls
rename to pandas/tests/io/data/excel/test5.xls
diff --git a/pandas/tests/io/data/excel/test5.xlsb b/pandas/tests/io/data/excel/test5.xlsb
new file mode 100644
index 0000000000000..022ebef25aee2
Binary files /dev/null and b/pandas/tests/io/data/excel/test5.xlsb differ
diff --git a/pandas/tests/io/data/test5.xlsm b/pandas/tests/io/data/excel/test5.xlsm
similarity index 100%
rename from pandas/tests/io/data/test5.xlsm
rename to pandas/tests/io/data/excel/test5.xlsm
diff --git a/pandas/tests/io/data/test5.xlsx b/pandas/tests/io/data/excel/test5.xlsx
similarity index 100%
rename from pandas/tests/io/data/test5.xlsx
rename to pandas/tests/io/data/excel/test5.xlsx
diff --git a/pandas/tests/io/data/test_converters.ods b/pandas/tests/io/data/excel/test_converters.ods
similarity index 100%
rename from pandas/tests/io/data/test_converters.ods
rename to pandas/tests/io/data/excel/test_converters.ods
diff --git a/pandas/tests/io/data/test_converters.xls b/pandas/tests/io/data/excel/test_converters.xls
similarity index 100%
rename from pandas/tests/io/data/test_converters.xls
rename to pandas/tests/io/data/excel/test_converters.xls
diff --git a/pandas/tests/io/data/excel/test_converters.xlsb b/pandas/tests/io/data/excel/test_converters.xlsb
new file mode 100644
index 0000000000000..c39c33d8dd94f
Binary files /dev/null and b/pandas/tests/io/data/excel/test_converters.xlsb differ
diff --git a/pandas/tests/io/data/test_converters.xlsm b/pandas/tests/io/data/excel/test_converters.xlsm
similarity index 100%
rename from pandas/tests/io/data/test_converters.xlsm
rename to pandas/tests/io/data/excel/test_converters.xlsm
diff --git a/pandas/tests/io/data/test_converters.xlsx b/pandas/tests/io/data/excel/test_converters.xlsx
similarity index 100%
rename from pandas/tests/io/data/test_converters.xlsx
rename to pandas/tests/io/data/excel/test_converters.xlsx
diff --git a/pandas/tests/io/data/test_index_name_pre17.ods b/pandas/tests/io/data/excel/test_index_name_pre17.ods
similarity index 100%
rename from pandas/tests/io/data/test_index_name_pre17.ods
rename to pandas/tests/io/data/excel/test_index_name_pre17.ods
diff --git a/pandas/tests/io/data/test_index_name_pre17.xls b/pandas/tests/io/data/excel/test_index_name_pre17.xls
similarity index 100%
rename from pandas/tests/io/data/test_index_name_pre17.xls
rename to pandas/tests/io/data/excel/test_index_name_pre17.xls
diff --git a/pandas/tests/io/data/excel/test_index_name_pre17.xlsb b/pandas/tests/io/data/excel/test_index_name_pre17.xlsb
new file mode 100644
index 0000000000000..5251b8f3b3194
Binary files /dev/null and b/pandas/tests/io/data/excel/test_index_name_pre17.xlsb differ
diff --git a/pandas/tests/io/data/test_index_name_pre17.xlsm b/pandas/tests/io/data/excel/test_index_name_pre17.xlsm
similarity index 100%
rename from pandas/tests/io/data/test_index_name_pre17.xlsm
rename to pandas/tests/io/data/excel/test_index_name_pre17.xlsm
diff --git a/pandas/tests/io/data/test_index_name_pre17.xlsx b/pandas/tests/io/data/excel/test_index_name_pre17.xlsx
similarity index 100%
rename from pandas/tests/io/data/test_index_name_pre17.xlsx
rename to pandas/tests/io/data/excel/test_index_name_pre17.xlsx
diff --git a/pandas/tests/io/data/test_multisheet.ods b/pandas/tests/io/data/excel/test_multisheet.ods
similarity index 100%
rename from pandas/tests/io/data/test_multisheet.ods
rename to pandas/tests/io/data/excel/test_multisheet.ods
diff --git a/pandas/tests/io/data/test_multisheet.xls b/pandas/tests/io/data/excel/test_multisheet.xls
similarity index 100%
rename from pandas/tests/io/data/test_multisheet.xls
rename to pandas/tests/io/data/excel/test_multisheet.xls
diff --git a/pandas/tests/io/data/excel/test_multisheet.xlsb b/pandas/tests/io/data/excel/test_multisheet.xlsb
new file mode 100644
index 0000000000000..39b15568a7121
Binary files /dev/null and b/pandas/tests/io/data/excel/test_multisheet.xlsb differ
diff --git a/pandas/tests/io/data/test_multisheet.xlsm b/pandas/tests/io/data/excel/test_multisheet.xlsm
similarity index 100%
rename from pandas/tests/io/data/test_multisheet.xlsm
rename to pandas/tests/io/data/excel/test_multisheet.xlsm
diff --git a/pandas/tests/io/data/test_multisheet.xlsx b/pandas/tests/io/data/excel/test_multisheet.xlsx
similarity index 100%
rename from pandas/tests/io/data/test_multisheet.xlsx
rename to pandas/tests/io/data/excel/test_multisheet.xlsx
diff --git a/pandas/tests/io/data/test_squeeze.ods b/pandas/tests/io/data/excel/test_squeeze.ods
similarity index 100%
rename from pandas/tests/io/data/test_squeeze.ods
rename to pandas/tests/io/data/excel/test_squeeze.ods
diff --git a/pandas/tests/io/data/test_squeeze.xls b/pandas/tests/io/data/excel/test_squeeze.xls
similarity index 100%
rename from pandas/tests/io/data/test_squeeze.xls
rename to pandas/tests/io/data/excel/test_squeeze.xls
diff --git a/pandas/tests/io/data/excel/test_squeeze.xlsb b/pandas/tests/io/data/excel/test_squeeze.xlsb
new file mode 100644
index 0000000000000..6aadd727e957b
Binary files /dev/null and b/pandas/tests/io/data/excel/test_squeeze.xlsb differ
diff --git a/pandas/tests/io/data/test_squeeze.xlsm b/pandas/tests/io/data/excel/test_squeeze.xlsm
similarity index 100%
rename from pandas/tests/io/data/test_squeeze.xlsm
rename to pandas/tests/io/data/excel/test_squeeze.xlsm
diff --git a/pandas/tests/io/data/test_squeeze.xlsx b/pandas/tests/io/data/excel/test_squeeze.xlsx
similarity index 100%
rename from pandas/tests/io/data/test_squeeze.xlsx
rename to pandas/tests/io/data/excel/test_squeeze.xlsx
diff --git a/pandas/tests/io/data/test_types.ods b/pandas/tests/io/data/excel/test_types.ods
similarity index 100%
rename from pandas/tests/io/data/test_types.ods
rename to pandas/tests/io/data/excel/test_types.ods
diff --git a/pandas/tests/io/data/test_types.xls b/pandas/tests/io/data/excel/test_types.xls
similarity index 100%
rename from pandas/tests/io/data/test_types.xls
rename to pandas/tests/io/data/excel/test_types.xls
diff --git a/pandas/tests/io/data/excel/test_types.xlsb b/pandas/tests/io/data/excel/test_types.xlsb
new file mode 100644
index 0000000000000..e7403aa288263
Binary files /dev/null and b/pandas/tests/io/data/excel/test_types.xlsb differ
diff --git a/pandas/tests/io/data/test_types.xlsm b/pandas/tests/io/data/excel/test_types.xlsm
similarity index 100%
rename from pandas/tests/io/data/test_types.xlsm
rename to pandas/tests/io/data/excel/test_types.xlsm
diff --git a/pandas/tests/io/data/test_types.xlsx b/pandas/tests/io/data/excel/test_types.xlsx
similarity index 100%
rename from pandas/tests/io/data/test_types.xlsx
rename to pandas/tests/io/data/excel/test_types.xlsx
diff --git a/pandas/tests/io/data/testdateoverflow.ods b/pandas/tests/io/data/excel/testdateoverflow.ods
similarity index 100%
rename from pandas/tests/io/data/testdateoverflow.ods
rename to pandas/tests/io/data/excel/testdateoverflow.ods
diff --git a/pandas/tests/io/data/testdateoverflow.xls b/pandas/tests/io/data/excel/testdateoverflow.xls
similarity index 100%
rename from pandas/tests/io/data/testdateoverflow.xls
rename to pandas/tests/io/data/excel/testdateoverflow.xls
diff --git a/pandas/tests/io/data/excel/testdateoverflow.xlsb b/pandas/tests/io/data/excel/testdateoverflow.xlsb
new file mode 100644
index 0000000000000..3d279396924b9
Binary files /dev/null and b/pandas/tests/io/data/excel/testdateoverflow.xlsb differ
diff --git a/pandas/tests/io/data/testdateoverflow.xlsm b/pandas/tests/io/data/excel/testdateoverflow.xlsm
similarity index 100%
rename from pandas/tests/io/data/testdateoverflow.xlsm
rename to pandas/tests/io/data/excel/testdateoverflow.xlsm
diff --git a/pandas/tests/io/data/testdateoverflow.xlsx b/pandas/tests/io/data/excel/testdateoverflow.xlsx
similarity index 100%
rename from pandas/tests/io/data/testdateoverflow.xlsx
rename to pandas/tests/io/data/excel/testdateoverflow.xlsx
diff --git a/pandas/tests/io/data/testdtype.ods b/pandas/tests/io/data/excel/testdtype.ods
similarity index 100%
rename from pandas/tests/io/data/testdtype.ods
rename to pandas/tests/io/data/excel/testdtype.ods
diff --git a/pandas/tests/io/data/testdtype.xls b/pandas/tests/io/data/excel/testdtype.xls
similarity index 100%
rename from pandas/tests/io/data/testdtype.xls
rename to pandas/tests/io/data/excel/testdtype.xls
diff --git a/pandas/tests/io/data/excel/testdtype.xlsb b/pandas/tests/io/data/excel/testdtype.xlsb
new file mode 100644
index 0000000000000..1c1d45f0d783b
Binary files /dev/null and b/pandas/tests/io/data/excel/testdtype.xlsb differ
diff --git a/pandas/tests/io/data/testdtype.xlsm b/pandas/tests/io/data/excel/testdtype.xlsm
similarity index 100%
rename from pandas/tests/io/data/testdtype.xlsm
rename to pandas/tests/io/data/excel/testdtype.xlsm
diff --git a/pandas/tests/io/data/testdtype.xlsx b/pandas/tests/io/data/excel/testdtype.xlsx
similarity index 100%
rename from pandas/tests/io/data/testdtype.xlsx
rename to pandas/tests/io/data/excel/testdtype.xlsx
diff --git a/pandas/tests/io/data/testmultiindex.ods b/pandas/tests/io/data/excel/testmultiindex.ods
similarity index 100%
rename from pandas/tests/io/data/testmultiindex.ods
rename to pandas/tests/io/data/excel/testmultiindex.ods
diff --git a/pandas/tests/io/data/testmultiindex.xls b/pandas/tests/io/data/excel/testmultiindex.xls
similarity index 100%
rename from pandas/tests/io/data/testmultiindex.xls
rename to pandas/tests/io/data/excel/testmultiindex.xls
diff --git a/pandas/tests/io/data/excel/testmultiindex.xlsb b/pandas/tests/io/data/excel/testmultiindex.xlsb
new file mode 100644
index 0000000000000..b66d6dab17ee0
Binary files /dev/null and b/pandas/tests/io/data/excel/testmultiindex.xlsb differ
diff --git a/pandas/tests/io/data/testmultiindex.xlsm b/pandas/tests/io/data/excel/testmultiindex.xlsm
similarity index 100%
rename from pandas/tests/io/data/testmultiindex.xlsm
rename to pandas/tests/io/data/excel/testmultiindex.xlsm
diff --git a/pandas/tests/io/data/testmultiindex.xlsx b/pandas/tests/io/data/excel/testmultiindex.xlsx
similarity index 100%
rename from pandas/tests/io/data/testmultiindex.xlsx
rename to pandas/tests/io/data/excel/testmultiindex.xlsx
diff --git a/pandas/tests/io/data/testskiprows.ods b/pandas/tests/io/data/excel/testskiprows.ods
similarity index 100%
rename from pandas/tests/io/data/testskiprows.ods
rename to pandas/tests/io/data/excel/testskiprows.ods
diff --git a/pandas/tests/io/data/testskiprows.xls b/pandas/tests/io/data/excel/testskiprows.xls
similarity index 100%
rename from pandas/tests/io/data/testskiprows.xls
rename to pandas/tests/io/data/excel/testskiprows.xls
diff --git a/pandas/tests/io/data/excel/testskiprows.xlsb b/pandas/tests/io/data/excel/testskiprows.xlsb
new file mode 100644
index 0000000000000..a5ff4ed22e70c
Binary files /dev/null and b/pandas/tests/io/data/excel/testskiprows.xlsb differ
diff --git a/pandas/tests/io/data/testskiprows.xlsm b/pandas/tests/io/data/excel/testskiprows.xlsm
similarity index 100%
rename from pandas/tests/io/data/testskiprows.xlsm
rename to pandas/tests/io/data/excel/testskiprows.xlsm
diff --git a/pandas/tests/io/data/testskiprows.xlsx b/pandas/tests/io/data/excel/testskiprows.xlsx
similarity index 100%
rename from pandas/tests/io/data/testskiprows.xlsx
rename to pandas/tests/io/data/excel/testskiprows.xlsx
diff --git a/pandas/tests/io/data/times_1900.ods b/pandas/tests/io/data/excel/times_1900.ods
similarity index 100%
rename from pandas/tests/io/data/times_1900.ods
rename to pandas/tests/io/data/excel/times_1900.ods
diff --git a/pandas/tests/io/data/times_1900.xls b/pandas/tests/io/data/excel/times_1900.xls
similarity index 100%
rename from pandas/tests/io/data/times_1900.xls
rename to pandas/tests/io/data/excel/times_1900.xls
diff --git a/pandas/tests/io/data/excel/times_1900.xlsb b/pandas/tests/io/data/excel/times_1900.xlsb
new file mode 100644
index 0000000000000..ceb7bccb0c66e
Binary files /dev/null and b/pandas/tests/io/data/excel/times_1900.xlsb differ
diff --git a/pandas/tests/io/data/times_1900.xlsm b/pandas/tests/io/data/excel/times_1900.xlsm
similarity index 100%
rename from pandas/tests/io/data/times_1900.xlsm
rename to pandas/tests/io/data/excel/times_1900.xlsm
diff --git a/pandas/tests/io/data/times_1900.xlsx b/pandas/tests/io/data/excel/times_1900.xlsx
similarity index 100%
rename from pandas/tests/io/data/times_1900.xlsx
rename to pandas/tests/io/data/excel/times_1900.xlsx
diff --git a/pandas/tests/io/data/times_1904.ods b/pandas/tests/io/data/excel/times_1904.ods
similarity index 100%
rename from pandas/tests/io/data/times_1904.ods
rename to pandas/tests/io/data/excel/times_1904.ods
diff --git a/pandas/tests/io/data/times_1904.xls b/pandas/tests/io/data/excel/times_1904.xls
similarity index 100%
rename from pandas/tests/io/data/times_1904.xls
rename to pandas/tests/io/data/excel/times_1904.xls
diff --git a/pandas/tests/io/data/excel/times_1904.xlsb b/pandas/tests/io/data/excel/times_1904.xlsb
new file mode 100644
index 0000000000000..e426dc959da49
Binary files /dev/null and b/pandas/tests/io/data/excel/times_1904.xlsb differ
diff --git a/pandas/tests/io/data/times_1904.xlsm b/pandas/tests/io/data/excel/times_1904.xlsm
similarity index 100%
rename from pandas/tests/io/data/times_1904.xlsm
rename to pandas/tests/io/data/excel/times_1904.xlsm
diff --git a/pandas/tests/io/data/times_1904.xlsx b/pandas/tests/io/data/excel/times_1904.xlsx
similarity index 100%
rename from pandas/tests/io/data/times_1904.xlsx
rename to pandas/tests/io/data/excel/times_1904.xlsx
diff --git a/pandas/tests/io/data/writertable.odt b/pandas/tests/io/data/excel/writertable.odt
similarity index 100%
rename from pandas/tests/io/data/writertable.odt
rename to pandas/tests/io/data/excel/writertable.odt
diff --git a/pandas/tests/io/data/feather-0_3_1.feather b/pandas/tests/io/data/feather/feather-0_3_1.feather
similarity index 100%
rename from pandas/tests/io/data/feather-0_3_1.feather
rename to pandas/tests/io/data/feather/feather-0_3_1.feather
diff --git a/pandas/tests/io/data/fixed_width_format.txt b/pandas/tests/io/data/fixed_width/fixed_width_format.txt
similarity index 100%
rename from pandas/tests/io/data/fixed_width_format.txt
rename to pandas/tests/io/data/fixed_width/fixed_width_format.txt
diff --git a/pandas/tests/io/data/banklist.html b/pandas/tests/io/data/html/banklist.html
similarity index 100%
rename from pandas/tests/io/data/banklist.html
rename to pandas/tests/io/data/html/banklist.html
diff --git a/pandas/tests/io/data/spam.html b/pandas/tests/io/data/html/spam.html
similarity index 100%
rename from pandas/tests/io/data/spam.html
rename to pandas/tests/io/data/html/spam.html
diff --git a/pandas/tests/io/data/valid_markup.html b/pandas/tests/io/data/html/valid_markup.html
similarity index 100%
rename from pandas/tests/io/data/valid_markup.html
rename to pandas/tests/io/data/html/valid_markup.html
diff --git a/pandas/tests/io/data/wikipedia_states.html b/pandas/tests/io/data/html/wikipedia_states.html
similarity index 100%
rename from pandas/tests/io/data/wikipedia_states.html
rename to pandas/tests/io/data/html/wikipedia_states.html
diff --git a/pandas/tests/io/data/legacy_hdf/legacy_table_fixed_datetime_py2.h5 b/pandas/tests/io/data/legacy_hdf/legacy_table_fixed_datetime_py2.h5
new file mode 100644
index 0000000000000..18cfae15a3a78
Binary files /dev/null and b/pandas/tests/io/data/legacy_hdf/legacy_table_fixed_datetime_py2.h5 differ
diff --git a/pandas/tests/io/data/legacy_pickle/0.20.3/0.20.3_x86_64_darwin_3.5.6.pickle b/pandas/tests/io/data/legacy_pickle/0.20.3/0.20.3_x86_64_darwin_3.5.6.pickle
new file mode 100644
index 0000000000000..88bb6989f5b08
Binary files /dev/null and b/pandas/tests/io/data/legacy_pickle/0.20.3/0.20.3_x86_64_darwin_3.5.6.pickle differ
diff --git a/pandas/tests/io/data/macau.html b/pandas/tests/io/data/macau.html
deleted file mode 100644
index edc4ea96f0f20..0000000000000
--- a/pandas/tests/io/data/macau.html
+++ /dev/null
@@ -1,3691 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- saved from url=(0037)http://www.camacau.com/statistic_list -->
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-<link rel="stylesheet" type="text/css" href="./macau_files/style.css" media="screen">
-<script type="text/javascript" src="./macau_files/jquery.js"></script>
-
-
-
-
-
-<script type="text/javascript">
-
-function slideSwitch() {
-
-    var $active = $('#banner1 a.active');
-
-    var totalTmp=document.getElementById("bannerTotal").innerHTML;
-
-    var randomTmp=Math.floor(Math.random()*totalTmp+1);
-
-    var $next = $('#image'+randomTmp).length?$('#image'+randomTmp):$('#banner1 a:first');
-
-    if($next.attr("id")==$active.attr("id")){
-
-      $next =  $active.next().length ? $active.next():$('#banner1 a:first');
-    }
-
-    $active.removeClass("active");
-
-	$next.addClass("active").show();
-
-    $active.hide();
-
-}
-
-jQuery(function() {
-
-    var totalTmp=document.getElementById("bannerTotal").innerHTML;
-    if(totalTmp>1){
-       setInterval( "slideSwitch()", 5000 );
-    }
-
-});
-
-</script>
-<script type="text/javascript">
-function close_notice(){
-jQuery("#tbNotice").hide();
-}
-</script>
-
-<title>Traffic Statistics - Passengers</title>
-
-<!--  GOOGLE STATISTICS
-<script type="text/javascript">
-
-  var _gaq = _gaq || [];
-  _gaq.push(['_setAccount', 'UA-24989877-2']);
-  _gaq.push(['_trackPageview']);
-
-  (function() {
-    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
-    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
-    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
-  })();
-
-</script>
--->
-<style type="text/css"></style><style type="text/css"></style><script id="fireplug-jssdk" src="./macau_files/all.js"></script><style type="text/css">.fireplug-credit-widget-overlay{z-index:9999999999999999999;background-color:rgba(91,91,91,0.6)}.fireplug-credit-widget-overlay div,.fireplug-credit-widget-overlay span,.fireplug-credit-widget-overlay applet,.fireplug-credit-widget-overlay object,.fireplug-credit-widget-overlay iframe,.fireplug-credit-widget-overlay h1,.fireplug-credit-widget-overlay h2,.fireplug-credit-widget-overlay h3,.fireplug-credit-widget-overlay h4,.fireplug-credit-widget-overlay h5,.fireplug-credit-widget-overlay h6,.fireplug-credit-widget-overlay p,.fireplug-credit-widget-overlay blockquote,.fireplug-credit-widget-overlay pre,.fireplug-credit-widget-overlay a,.fireplug-credit-widget-overlay abbr,.fireplug-credit-widget-overlay acronym,.fireplug-credit-widget-overlay address,.fireplug-credit-widget-overlay big,.fireplug-credit-widget-overlay cite,.fireplug-credit-widget-overlay code,.fireplug-credit-widget-overlay del,.fireplug-credit-widget-overlay dfn,.fireplug-credit-widget-overlay em,.fireplug-credit-widget-overlay img,.fireplug-credit-widget-overlay ins,.fireplug-credit-widget-overlay kbd,.fireplug-credit-widget-overlay q,.fireplug-credit-widget-overlay s,.fireplug-credit-widget-overlay samp,.fireplug-credit-widget-overlay small,.fireplug-credit-widget-overlay strike,.fireplug-credit-widget-overlay strong,.fireplug-credit-widget-overlay sub,.fireplug-credit-widget-overlay sup,.fireplug-credit-widget-overlay tt,.fireplug-credit-widget-overlay var,.fireplug-credit-widget-overlay b,.fireplug-credit-widget-overlay u,.fireplug-credit-widget-overlay i,.fireplug-credit-widget-overlay center,.fireplug-credit-widget-overlay dl,.fireplug-credit-widget-overlay dt,.fireplug-credit-widget-overlay dd,.fireplug-credit-widget-overlay ol,.fireplug-credit-widget-overlay ul,.fireplug-credit-widget-overlay li,.fireplug-credit-widget-overlay fieldset,.fireplug-credit-widget-overlay form,.fireplug-credit-widget-overlay label,.fireplug-credit-widget-overlay legend,.fireplug-credit-widget-overlay table,.fireplug-credit-widget-overlay caption,.fireplug-credit-widget-overlay tbody,.fireplug-credit-widget-overlay tfoot,.fireplug-credit-widget-overlay thead,.fireplug-credit-widget-overlay tr,.fireplug-credit-widget-overlay th,.fireplug-credit-widget-overlay td,.fireplug-credit-widget-overlay article,.fireplug-credit-widget-overlay aside,.fireplug-credit-widget-overlay canvas,.fireplug-credit-widget-overlay details,.fireplug-credit-widget-overlay embed,.fireplug-credit-widget-overlay figure,.fireplug-credit-widget-overlay figcaption,.fireplug-credit-widget-overlay footer,.fireplug-credit-widget-overlay header,.fireplug-credit-widget-overlay hgroup,.fireplug-credit-widget-overlay menu,.fireplug-credit-widget-overlay nav,.fireplug-credit-widget-overlay output,.fireplug-credit-widget-overlay ruby,.fireplug-credit-widget-overlay section,.fireplug-credit-widget-overlay summary,.fireplug-credit-widget-overlay time,.fireplug-credit-widget-overlay mark,.fireplug-credit-widget-overlay audio,.fireplug-credit-widget-overlay video{margin:0;padding:0;border:0;font:inherit;font-size:100%;vertical-align:baseline}.fireplug-credit-widget-overlay table{border-collapse:collapse;border-spacing:0}.fireplug-credit-widget-overlay caption,.fireplug-credit-widget-overlay th,.fireplug-credit-widget-overlay td{text-align:left;font-weight:normal;vertical-align:middle}.fireplug-credit-widget-overlay q,.fireplug-credit-widget-overlay blockquote{quotes:none}.fireplug-credit-widget-overlay q:before,.fireplug-credit-widget-overlay q:after,.fireplug-credit-widget-overlay blockquote:before,.fireplug-credit-widget-overlay blockquote:after{content:"";content:none}.fireplug-credit-widget-overlay a img{border:none}.fireplug-credit-widget-overlay .fireplug-credit-widget-overlay-item{z-index:9999999999999999999;-webkit-box-shadow:#333 0px 0px 10px;-moz-box-shadow:#333 0px 0px 10px;box-shadow:#333 0px 0px 10px}.fireplug-credit-widget-overlay-body{height:100% !important;overflow:hidden !important}.fp-getcredit iframe{border:none;overflow:hidden;height:20px;width:145px}
-</style></head>
-<body>
-<div id="full">
-<div id="container">
-
-
-<div id="top">
-		<div id="lang">
-
-		  <a href="http://www.camacau.com/changeLang?lang=zh_TW&url=/statistic_list">繁體中文</a> |
-		  <a href="http://www.camacau.com/changeLang?lang=zh_CN&url=/statistic_list">簡體中文</a>
-		  <!--<a href="changeLang?lang=pt_PT&url=/statistic_list" >Portuguese</a>
-		  -->
-		  </div>
-</div>
-
-<div id="header">
-  <div id="sitelogo"><a href="http://www.camacau.com/index" style="color : #FFF;"><img src="./macau_files/cam h04.jpg"></a></div>
-  <div id="navcontainer">
-		  <div id="menu">
-		  <div id="search">
-		  <form id="searchForm" name="searchForm" action="http://www.camacau.com/search" method="POST">
-			<input id="keyword" name="keyword" type="text">
-			<a href="javascript:document.searchForm.submit();">Search</a> |
-			<a href="mailto:mkd@macau-airport.com">Contact Us</a>  |
-			<a href="http://www.camacau.com/sitemap">SiteMap</a> |
-
-		  	<a href="http://www.camacau.com/rssBuilder.action"><img src="./macau_files/rssIcon.png" alt="RSS">RSS</a>
-			</form></div>
-		</div>
-</div>
-</div>
-<div id="menu2">
-			<div>
-
-
-		    <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" id="FlashID4" title="Main Page">
-				<param name="movie" value="flash/button_index_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				<!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				<!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				<!--[if !IE]>-->
-				<object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_index_EN.swf" width="92" height="20">
-				  <!--<![endif]-->
-				  <param name="quality" value="high">
-				  <param name="scale" value="exactfit">
-				  <param name="wmode" value="opaque">
-				  <param name="swfversion" value="6.0.65.0">
-				  <param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-				  </div>
-				  <!--[if !IE]>-->
-				</object>
-				<!--<![endif]-->
-			  </object>
-
-			<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" id="FlashID4" title="Our Business">
-				<param name="movie" value="flash/button_our business_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				<!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				<!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				<!--[if !IE]>-->
-				<object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_our%20business_EN.swf" width="92" height="20">
-				  <!--<![endif]-->
-				  <param name="quality" value="high">
-				  <param name="scale" value="exactfit">
-				  <param name="wmode" value="opaque">
-				  <param name="swfversion" value="6.0.65.0">
-				  <param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-				  </div>
-				  <!--[if !IE]>-->
-				</object>
-				<!--<![endif]-->
-			  </object>
-
-			  <object id="FlashID" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" title="About Us">
-				<param name="movie" value="flash/button_about us_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				  <!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				  <!--[if !IE]>-->
-				  <object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_about%20us_EN.swf" width="92" height="20">
-					<!--<![endif]-->
-					<param name="quality" value="high">
-					<param name="scale" value="exactfit">
-					<param name="wmode" value="opaque">
-					<param name="swfversion" value="6.0.65.0">
-					<param name="expressinstall" value="flash/expressInstall.swf">
-					<!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-					<div>
-					  <h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					  <p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-					</div>
-					<!--[if !IE]>-->
-				</object>
-				  <!--<![endif]-->
-			  </object>
-
-			  <object id="FlashID3" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" title="Media Centre">
-				<param name="movie" value="flash/button_media centre_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				<!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				<!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				<!--[if !IE]>-->
-				<object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_media%20centre_EN.swf" width="92" height="20">
-				  <!--<![endif]-->
-				  <param name="quality" value="high">
-				  <param name="wmode" value="opaque">
-				  <param name="scale" value="exactfit">
-				  <param name="swfversion" value="6.0.65.0">
-				  <param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-				  </div>
-				  <!--[if !IE]>-->
-				</object>
-				<!--<![endif]-->
-			  </object>
-
-			  <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" id="FlashID5" title="Related Links">
-				<param name="movie" value="flash/button_related links_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				<!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				<!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				<!--[if !IE]>-->
-				<object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_related%20links_EN.swf" width="92" height="20">
-				  <!--<![endif]-->
-				  <param name="quality" value="high">
-				  <param name="scale" value="exactfit">
-				  <param name="wmode" value="opaque">
-				  <param name="swfversion" value="6.0.65.0">
-				  <param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-				  </div>
-				  <!--[if !IE]>-->
-				</object>
-				<!--<![endif]-->
-			  </object>
-
-			  <object id="FlashID2" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" title="Interactive">
-				<param name="movie" value="flash/button_interactive_EN.swf">
-				<param name="quality" value="high">
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque">
-				<param name="swfversion" value="6.0.65.0">
-				<!-- 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。 -->
-				<param name="expressinstall" value="flash/expressInstall.swf">
-				<!-- 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。 -->
-				<!--[if !IE]>-->
-				<object type="application/x-shockwave-flash" data="http://www.camacau.com/flash/button_interactive_EN.swf" width="92" height="20">
-				  <!--<![endif]-->
-				  <param name="quality" value="high">
-				  <param name="scale" value="exactfit">
-				  <param name="wmode" value="opaque">
-				  <param name="swfversion" value="6.0.65.0">
-				  <param name="expressinstall" value="flash/expressInstall.swf">
-				  <!-- 瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。 -->
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="./macau_files/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33"></a></p>
-				  </div>
-				  <!--[if !IE]>-->
-				</object>
-				<!--<![endif]-->
-			  </object>
-
-			  <!--<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="95" height="20" id="FlashID4" title="Group of Public">
-				<param name="movie" value="flash/button_pressRelease_EN.swf" />
-				<param name="quality" value="high" />
-				<param name="scale" value="exactfit">
-				<param name="wmode" value="opaque" />
-				<param name="swfversion" value="6.0.65.0" />
-				 此 param 標籤會提示使用 Flash Player 6.0 r65 和更新版本的使用者下載最新版本的 Flash Player。如果您不想讓使用者看到這項提示，請將其刪除。
-				<param name="expressinstall" value="flash/expressInstall.swf" />
-				 下一個物件標籤僅供非 IE 瀏覽器使用。因此，請使用 IECC 將其自 IE 隱藏。
-				[if !IE]>
-				<object type="application/x-shockwave-flash" data="flash/button_pressRelease_EN.swf" width="92" height="20">
-				  <![endif]
-				  <param name="quality" value="high" />
-				  <param name="scale" value="exactfit">
-				  <param name="wmode" value="opaque" />
-				  <param name="swfversion" value="6.0.65.0" />
-				  <param name="expressinstall" value="flash/expressInstall.swf" />
-				   瀏覽器會為使用 Flash Player 6.0 和更早版本的使用者顯示下列替代內容。
-				  <div>
-					<h4>這個頁面上的內容需要較新版本的 Adobe Flash Player。</h4>
-					<p><a href="http://www.adobe.com/go/getflashplayer"><img src="http://www.adobe.com/images/shared/download_buttons/get_flash_player.gif" alt="取得 Adobe Flash Player" width="112" height="33" /></a></p>
-				  </div>
-				  [if !IE]>
-				</object>
-				<![endif]
-			  </object>
-
-			  --></div>
-		  </div>
-
-
-
-
-
-
-
-<style>
-#slider ul li
-{
-height: 90px;
-list-style:none;
-width:95%;
-font-size:11pt;
-text-indent:2em;
-text-align:justify;
-text-justify:inter-ideograph;
-color:#663300;
-}
-
-
-#slider
-{
-margin: auto;
-overflow: hidden;
-/* Non Core */
-background: #f6f7f8;
-box-shadow: 4px 4px 15px #aaa;
--o-box-shadow: 4px 4px 15px #aaa;
--icab-box-shadow: 4px 4px 15px #aaa;
--khtml-box-shadow: 4px 4px 15px #aaa;
--moz-box-shadow: 4px 4px 15px #aaa;
--webkit-box-shadow: 4px 4px 15px #aaa;
-border: 4px solid #bcc5cb;
-
-border-width: 1px 2px 2px 1px;
-
--o-border-radius: 10px;
--icab-border-radius: 10px;
--khtml-border-radius: 10px;
--moz-border-radius: 10px;
--webkit-border-radius: 10px;
-border-radius: 10px;
-
-}
-
-#close_tbNotice img
-{
-width:20px;
-height:20px;
-align:right;
-cursor:pointer;
-}
-</style>
-
-<div id="banner">
-	<!--<div id="leftGradient"></div>-->
-
-			<table id="tbNotice" style="display:none;width:800px;z-index:999;position:absolute;left:20%;" align="center">
-				<tbody><tr height="40px"><td></td></tr>
-				<tr><td>
-
-					<div id="slider">
-				<div id="close_tbNotice"><img src="./macau_files/delete.png" onclick="close_notice()"></div>
-				<ul>
-					<li>
-
-
-
-
-					</li>
-				</ul>
-
-			</div>
-			<div id="show_notice" style="display:none;">
-
-			</div>
-
-				</td>
-
-				</tr>
-				<tr><td align="right"></td></tr>
-			</tbody></table>
-
-
-	<div class="gradient">
-
-	</div>
-	<div class="banner1" id="banner1">
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: none;" id="image1" class="">
-		     <img src="./macau_files/41.jpeg" alt="Slideshow Image 1">
-	         </a>
-
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: none;" id="image2" class="">
-		     <img src="./macau_files/45.jpeg" alt="Slideshow Image 2">
-	         </a>
-
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: none;" id="image3" class="">
-		     <img src="./macau_files/46.jpeg" alt="Slideshow Image 3">
-	         </a>
-
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: inline;" id="image4" class="active">
-		     <img src="./macau_files/47.jpeg" alt="Slideshow Image 4">
-	         </a>
-
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: none;" id="image5" class="">
-		     <img src="./macau_files/48.jpeg" alt="Slideshow Image 5">
-	         </a>
-
-
-
-
-
-             <a href="http://www.macau-airport.com/" target="_blank" style="display: none;" id="image6" class="">
-		     <img src="./macau_files/49.jpeg" alt="Slideshow Image 6">
-	         </a>
-
-
-
-
-
-             <a href="http://www.4cpscac.com/" target="_blank" style="display: none;" id="image7" class="">
-		     <img src="./macau_files/50.jpg" alt="Slideshow Image 7">
-	         </a>
-
-
-
-
-	</div>
-	<div id="bannerTotal" style="display:none;">7</div>
-</div>
-
-<div id="content">
-        <div id="leftnav">
-
-                <div id="navmenu">
-
-
-
-
-
-<link href="./macau_files/ddaccordion.css" rel="stylesheet" type="text/css">
-<script type="text/javascript" src="./macau_files/ddaccordion.js"></script>
-
-
-
-<script type="text/javascript">
-	ddaccordion.init({
-	headerclass: "leftmenu_silverheader", //Shared CSS class name of headers group
-	contentclass: "leftmenu_submenu", //Shared CSS class name of contents group
-	revealtype: "clickgo", //Reveal content when user clicks or onmouseover the header? Valid value: "click", "clickgo", or "mouseover"
-	mouseoverdelay: 100, //if revealtype="mouseover", set delay in milliseconds before header expands onMouseover
-	collapseprev: true, //Collapse previous content (so only one open at any time)? true/false
-	defaultexpanded: [0], //index of content(s) open by default [index1, index2, etc] [] denotes no content
-	onemustopen: false, //Specify whether at least one header should be open always (so never all headers closed)
-	animatedefault: true, //Should contents open by default be animated into view?
-	persiststate: true, //persist state of opened contents within browser session?
-	toggleclass: ["", "selected"], //Two CSS classes to be applied to the header when it's collapsed and expanded, respectively ["class1", "class2"]
-	togglehtml: ["", "", ""], //Additional HTML added to the header when it's collapsed and expanded, respectively  ["position", "html1", "html2"] (see docs)
-	animatespeed: "normal", //speed of animation: integer in milliseconds (ie: 200), or keywords "fast", "normal", or "slow"
-	oninit:function(headers, expandedindices){ //custom code to run when headers have initialized
-		//do nothing
-	},
-	onopenclose:function(header, index, state, isuseractivated){ //custom code to run whenever a header is opened or closed
-		//do nothing
-
-	}
-});
-</script><style type="text/css">
-.leftmenu_submenu{display: none}
-a.hiddenajaxlink{display: none}
-</style>
-
-
-				<table>
-				<tbody><tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/geographic_information">MIA Geographical Information</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/airport_services">Scope of Service</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/services_agreement">Air Services Agreement</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/airport_charges" class="leftmenu_silverheader selected" headerindex="0h"><span>Airport Charges</span></a></td></tr>
-				<tr><td colspan="2" style="padding-top:0px;padding-bottom:0px;padding-right:0px;">
-				<table class="leftmenu_submenu" contentindex="0c" style="display: block;">
-				<tbody><tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/airport_charges1">Passenger Service Fees</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/airport_charges2">Aircraft Parking fees</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/airport_charges3">Airport Security Fee</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/airport_charges4">Utilization fees</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/airport_charges5">Refuelling Charge</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/calculation">Calculation of Landing fee Rate</a></td></tr></tbody></table></td></tr>
-				</tbody></table>
-				</td>
-				</tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/application_facilities">Application of Credit Facilities</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="javascript:void(0)" class="leftmenu_silverheader " headerindex="1h"><span>Passenger Flight Incentive Program</span></a></td></tr>
-				<tr><td colspan="2" style="padding-top:0px;padding-bottom:0px;padding-right:0px;">
-				<table class="leftmenu_submenu" contentindex="1c" style="display: none;">
-				<tbody><tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/incentive_program1">Incentive policy for new routes and additional flights</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/incentive_program1_1">Passenger flights</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/incentive_program1_2">Charter flights</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/docs/MIA_Route_Development_IncentiveApp_Form.pdf" target="_blank">Route Development Incentive Application Form</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/online_application">Online Application</a></td></tr></tbody></table></td></tr>
-				</tbody></table>
-				</td>
-				</tr>
-
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/slot_application">Slot Application</a></td></tr>
-
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/freighter_forwards">Macau Freight Forwarders</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/ctplatform">Cargo Tracking Platform</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/for_rent">For Rent</a></td></tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/capacity">Airport Capacity</a></td></tr>
-
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td style="color: #606060;text-decoration: none;"><a href="javascript:void(0)" class="leftmenu_silverheader " headerindex="2h">Airport Characteristics &amp; Traffic Statistics</a></td></tr>
-				<tr><td colspan="2" style="padding-top:0px;padding-bottom:0px;padding-right:0px;">
-				<table class="leftmenu_submenu" contentindex="2c" style="display: none;">
-				<!--<tr><td>&nbsp;</td><td><table class="submenu"><tr><td><img width="20" height="15" src="images/sub_icon.gif"/></td><td><a href="airport_characteristics">Airport Characteristics</a></td></tr></table></td></tr>
-				-->
-				<tbody><tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="./macau_files/macau.html">Traffic Statistics - Passengers</a></td></tr></tbody></table></td></tr>
-				<tr><td>&nbsp;</td><td><table class="submenu"><tbody><tr><td><img width="20" height="15" src="./macau_files/sub_icon.gif"></td><td><a href="http://www.camacau.com/statistics_cargo">Traffic Statistics - Cargo</a></td></tr></tbody></table></td></tr>
-				</tbody></table>
-				</td>
-				</tr>
-				<tr><td><img width="20" height="15" src="./macau_files/double.gif"></td><td><a href="http://www.camacau.com/operational_routes">Operational Routes</a></td></tr>
-
-				<!--<tr><td><img width="20" height="15" src="images/double.gif"/></td><td><a href="route_development">Member Registration</a></td></tr>
-
-				--><!--<tr><td><img width="20" height="15" src="images/double.gif"/></td><td><a href="cargo_arrival">Cargo Flight Information</a></td></tr>-->
-
-				<!--<tr><td><img width="20" height="15" src="images/double.gif"/></td><td><a href="/mvnforum/mvnforum/index">Forum</a></td></tr>-->
-
-				</tbody></table>
-
-
-        		</div>
-		</div>
-
-<div id="under">
-			<div id="contextTitle">
-          			<h2 class="con">Traffic Statistics - Passengers</h2>
-
-          </div>
-			<div class="contextTitleAfter"></div>
-	<div>
-
-
-    	  <div id="context">
-          <!--/*begin context*/-->
-          <div class="Container">
-                     <div id="Scroller-1">
-                           <div class="Scroller-Container">
-          		<div id="statisticspassengers" style="width:550px;">
-
-
-   <span id="title">Traffic Statistics</span>
-
-
-
-
-
-   <br><br><br>
-   <span id="title">Passengers Figure(2008-2013) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2013</th>
-
-   <th align="center">2012</th>
-
-   <th align="center">2011</th>
-
-   <th align="center">2010</th>
-
-   <th align="center">2009</th>
-
-   <th align="center">2008</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    374,917
-   </td>
-
-   <td align="center">
-
-    362,379
-   </td>
-
-   <td align="center">
-
-    301,503
-   </td>
-
-   <td align="center">
-
-    358,902
-   </td>
-
-   <td align="center">
-
-    342,323
-   </td>
-
-   <td align="center">
-
-    420,574
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    393,152
-   </td>
-
-   <td align="center">
-
-    312,405
-   </td>
-
-   <td align="center">
-
-    301,259
-   </td>
-
-   <td align="center">
-
-    351,654
-   </td>
-
-   <td align="center">
-
-    297,755
-   </td>
-
-   <td align="center">
-
-    442,809
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    408,755
-   </td>
-
-   <td align="center">
-
-    334,000
-   </td>
-
-   <td align="center">
-
-    318,908
-   </td>
-
-   <td align="center">
-
-    360,365
-   </td>
-
-   <td align="center">
-
-    387,879
-   </td>
-
-   <td align="center">
-
-    468,540
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    408,860
-   </td>
-
-   <td align="center">
-
-    358,198
-   </td>
-
-   <td align="center">
-
-    339,060
-   </td>
-
-   <td align="center">
-
-    352,976
-   </td>
-
-   <td align="center">
-
-    400,553
-   </td>
-
-   <td align="center">
-
-    492,930
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    374,397
-   </td>
-
-   <td align="center">
-
-    329,218
-   </td>
-
-   <td align="center">
-
-    321,060
-   </td>
-
-   <td align="center">
-
-    330,407
-   </td>
-
-   <td align="center">
-
-    335,967
-   </td>
-
-   <td align="center">
-
-    465,045
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    401,995
-   </td>
-
-   <td align="center">
-
-    356,679
-   </td>
-
-   <td align="center">
-
-    343,006
-   </td>
-
-   <td align="center">
-
-    326,724
-   </td>
-
-   <td align="center">
-
-    296,748
-   </td>
-
-   <td align="center">
-
-    426,764
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    423,081
-   </td>
-
-   <td align="center">
-
-    378,993
-   </td>
-
-   <td align="center">
-
-    356,580
-   </td>
-
-   <td align="center">
-
-    351,110
-   </td>
-
-   <td align="center">
-
-    439,425
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    453,391
-   </td>
-
-   <td align="center">
-
-    395,883
-   </td>
-
-   <td align="center">
-
-    364,011
-   </td>
-
-   <td align="center">
-
-    404,076
-   </td>
-
-   <td align="center">
-
-    425,814
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    384,887
-   </td>
-
-   <td align="center">
-
-    325,124
-   </td>
-
-   <td align="center">
-
-    308,940
-   </td>
-
-   <td align="center">
-
-    317,226
-   </td>
-
-   <td align="center">
-
-    379,898
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    383,889
-   </td>
-
-   <td align="center">
-
-    333,102
-   </td>
-
-   <td align="center">
-
-    317,040
-   </td>
-
-   <td align="center">
-
-    355,935
-   </td>
-
-   <td align="center">
-
-    415,339
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    379,065
-   </td>
-
-   <td align="center">
-
-    327,803
-   </td>
-
-   <td align="center">
-
-    303,186
-   </td>
-
-   <td align="center">
-
-    372,104
-   </td>
-
-   <td align="center">
-
-    366,411
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    413,873
-   </td>
-
-   <td align="center">
-
-    359,313
-   </td>
-
-   <td align="center">
-
-    348,051
-   </td>
-
-   <td align="center">
-
-    388,573
-   </td>
-
-   <td align="center">
-
-    354,253
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    2,362,076
-   </td>
-
-   <td align="center">
-
-    4,491,065
-   </td>
-
-   <td align="center">
-
-    4,045,014
-   </td>
-
-   <td align="center">
-
-    4,078,836
-   </td>
-
-   <td align="center">
-
-    4,250,249
-   </td>
-
-   <td align="center">
-
-    5,097,802
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Passengers Figure(2002-2007) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2007</th>
-
-   <th align="center">2006</th>
-
-   <th align="center">2005</th>
-
-   <th align="center">2004</th>
-
-   <th align="center">2003</th>
-
-   <th align="center">2002</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    381,887
-   </td>
-
-   <td align="center">
-
-    323,282
-   </td>
-
-   <td align="center">
-
-    289,701
-   </td>
-
-   <td align="center">
-
-    288,507
-   </td>
-
-   <td align="center">
-
-    290,140
-   </td>
-
-   <td align="center">
-
-    268,783
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    426,014
-   </td>
-
-   <td align="center">
-
-    360,820
-   </td>
-
-   <td align="center">
-
-    348,723
-   </td>
-
-   <td align="center">
-
-    207,710
-   </td>
-
-   <td align="center">
-
-    323,264
-   </td>
-
-   <td align="center">
-
-    323,654
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    443,805
-   </td>
-
-   <td align="center">
-
-    389,125
-   </td>
-
-   <td align="center">
-
-    321,953
-   </td>
-
-   <td align="center">
-
-    273,910
-   </td>
-
-   <td align="center">
-
-    295,052
-   </td>
-
-   <td align="center">
-
-    360,668
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    500,917
-   </td>
-
-   <td align="center">
-
-    431,550
-   </td>
-
-   <td align="center">
-
-    367,976
-   </td>
-
-   <td align="center">
-
-    324,931
-   </td>
-
-   <td align="center">
-
-    144,082
-   </td>
-
-   <td align="center">
-
-    380,648
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    468,637
-   </td>
-
-   <td align="center">
-
-    399,743
-   </td>
-
-   <td align="center">
-
-    359,298
-   </td>
-
-   <td align="center">
-
-    250,601
-   </td>
-
-   <td align="center">
-
-    47,333
-   </td>
-
-   <td align="center">
-
-    359,547
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    463,676
-   </td>
-
-   <td align="center">
-
-    393,713
-   </td>
-
-   <td align="center">
-
-    360,147
-   </td>
-
-   <td align="center">
-
-    296,000
-   </td>
-
-   <td align="center">
-
-    94,294
-   </td>
-
-   <td align="center">
-
-    326,508
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-    490,404
-   </td>
-
-   <td align="center">
-
-    465,497
-   </td>
-
-   <td align="center">
-
-    413,131
-   </td>
-
-   <td align="center">
-
-    365,454
-   </td>
-
-   <td align="center">
-
-    272,784
-   </td>
-
-   <td align="center">
-
-    388,061
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-    490,830
-   </td>
-
-   <td align="center">
-
-    478,474
-   </td>
-
-   <td align="center">
-
-    409,281
-   </td>
-
-   <td align="center">
-
-    372,802
-   </td>
-
-   <td align="center">
-
-    333,840
-   </td>
-
-   <td align="center">
-
-    384,719
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-    446,594
-   </td>
-
-   <td align="center">
-
-    412,444
-   </td>
-
-   <td align="center">
-
-    354,751
-   </td>
-
-   <td align="center">
-
-    321,456
-   </td>
-
-   <td align="center">
-
-    295,447
-   </td>
-
-   <td align="center">
-
-    334,029
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-    465,757
-   </td>
-
-   <td align="center">
-
-    461,215
-   </td>
-
-   <td align="center">
-
-    390,435
-   </td>
-
-   <td align="center">
-
-    358,362
-   </td>
-
-   <td align="center">
-
-    291,193
-   </td>
-
-   <td align="center">
-
-    372,706
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    455,132
-   </td>
-
-   <td align="center">
-
-    425,116
-   </td>
-
-   <td align="center">
-
-    323,347
-   </td>
-
-   <td align="center">
-
-    327,593
-   </td>
-
-   <td align="center">
-
-    268,282
-   </td>
-
-   <td align="center">
-
-    350,324
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    465,225
-   </td>
-
-   <td align="center">
-
-    435,114
-   </td>
-
-   <td align="center">
-
-    308,999
-   </td>
-
-   <td align="center">
-
-    326,933
-   </td>
-
-   <td align="center">
-
-    249,855
-   </td>
-
-   <td align="center">
-
-    322,056
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    5,498,878
-   </td>
-
-   <td align="center">
-
-    4,976,093
-   </td>
-
-   <td align="center">
-
-    4,247,742
-   </td>
-
-   <td align="center">
-
-    3,714,259
-   </td>
-
-   <td align="center">
-
-    2,905,566
-   </td>
-
-   <td align="center">
-
-    4,171,703
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Passengers Figure(1996-2001) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2001</th>
-
-   <th align="center">2000</th>
-
-   <th align="center">1999</th>
-
-   <th align="center">1998</th>
-
-   <th align="center">1997</th>
-
-   <th align="center">1996</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    265,603
-   </td>
-
-   <td align="center">
-
-    184,381
-   </td>
-
-   <td align="center">
-
-    161,264
-   </td>
-
-   <td align="center">
-
-    161,432
-   </td>
-
-   <td align="center">
-
-    117,984
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    249,259
-   </td>
-
-   <td align="center">
-
-    264,066
-   </td>
-
-   <td align="center">
-
-    209,569
-   </td>
-
-   <td align="center">
-
-    168,777
-   </td>
-
-   <td align="center">
-
-    150,772
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    312,319
-   </td>
-
-   <td align="center">
-
-    226,483
-   </td>
-
-   <td align="center">
-
-    186,965
-   </td>
-
-   <td align="center">
-
-    172,060
-   </td>
-
-   <td align="center">
-
-    149,795
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    351,793
-   </td>
-
-   <td align="center">
-
-    296,541
-   </td>
-
-   <td align="center">
-
-    237,449
-   </td>
-
-   <td align="center">
-
-    180,241
-   </td>
-
-   <td align="center">
-
-    179,049
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    338,692
-   </td>
-
-   <td align="center">
-
-    288,949
-   </td>
-
-   <td align="center">
-
-    230,691
-   </td>
-
-   <td align="center">
-
-    172,391
-   </td>
-
-   <td align="center">
-
-    189,925
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    332,630
-   </td>
-
-   <td align="center">
-
-    271,181
-   </td>
-
-   <td align="center">
-
-    231,328
-   </td>
-
-   <td align="center">
-
-    157,519
-   </td>
-
-   <td align="center">
-
-    175,402
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-    344,658
-   </td>
-
-   <td align="center">
-
-    304,276
-   </td>
-
-   <td align="center">
-
-    243,534
-   </td>
-
-   <td align="center">
-
-    205,595
-   </td>
-
-   <td align="center">
-
-    173,103
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-    360,899
-   </td>
-
-   <td align="center">
-
-    300,418
-   </td>
-
-   <td align="center">
-
-    257,616
-   </td>
-
-   <td align="center">
-
-    241,140
-   </td>
-
-   <td align="center">
-
-    178,118
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-    291,817
-   </td>
-
-   <td align="center">
-
-    280,803
-   </td>
-
-   <td align="center">
-
-    210,885
-   </td>
-
-   <td align="center">
-
-    183,954
-   </td>
-
-   <td align="center">
-
-    163,385
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-    327,232
-   </td>
-
-   <td align="center">
-
-    298,873
-   </td>
-
-   <td align="center">
-
-    231,251
-   </td>
-
-   <td align="center">
-
-    205,726
-   </td>
-
-   <td align="center">
-
-    176,879
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    315,538
-   </td>
-
-   <td align="center">
-
-    265,528
-   </td>
-
-   <td align="center">
-
-    228,637
-   </td>
-
-   <td align="center">
-
-    181,677
-   </td>
-
-   <td align="center">
-
-    146,804
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    314,866
-   </td>
-
-   <td align="center">
-
-    257,929
-   </td>
-
-   <td align="center">
-
-    210,922
-   </td>
-
-   <td align="center">
-
-    183,975
-   </td>
-
-   <td align="center">
-
-    151,362
-   </td>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    3,805,306
-   </td>
-
-   <td align="center">
-
-    3,239,428
-   </td>
-
-   <td align="center">
-
-    2,640,111
-   </td>
-
-   <td align="center">
-
-    2,214,487
-   </td>
-
-   <td align="center">
-
-    1,952,578
-   </td>
-
-   <td align="center">
-
-    0
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Passengers Figure(1995-1995) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">1995</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    6,601
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    37,041
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    43,642
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-
-   <br><br><br>
-   <div align="right"><img src="./macau_files/pass_stat.jpg" alt="passenger statistic picture" width="565" height="318"></div>
-   <br><br><br>
-
-
-   <!--statistics-movement  -->
-
-   <br><br><br>
-   <span id="title">Movement Statistics(2008-2013) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2013</th>
-
-   <th align="center">2012</th>
-
-   <th align="center">2011</th>
-
-   <th align="center">2010</th>
-
-   <th align="center">2009</th>
-
-   <th align="center">2008</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    3,925
-   </td>
-
-   <td align="center">
-
-    3,463
-   </td>
-
-   <td align="center">
-
-    3,289
-   </td>
-
-   <td align="center">
-
-    3,184
-   </td>
-
-   <td align="center">
-
-    3,488
-   </td>
-
-   <td align="center">
-
-    4,568
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    3,632
-   </td>
-
-   <td align="center">
-
-    2,983
-   </td>
-
-   <td align="center">
-
-    2,902
-   </td>
-
-   <td align="center">
-
-    3,053
-   </td>
-
-   <td align="center">
-
-    3,347
-   </td>
-
-   <td align="center">
-
-    4,527
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    3,909
-   </td>
-
-   <td align="center">
-
-    3,166
-   </td>
-
-   <td align="center">
-
-    3,217
-   </td>
-
-   <td align="center">
-
-    3,175
-   </td>
-
-   <td align="center">
-
-    3,636
-   </td>
-
-   <td align="center">
-
-    4,594
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    3,903
-   </td>
-
-   <td align="center">
-
-    3,258
-   </td>
-
-   <td align="center">
-
-    3,146
-   </td>
-
-   <td align="center">
-
-    3,023
-   </td>
-
-   <td align="center">
-
-    3,709
-   </td>
-
-   <td align="center">
-
-    4,574
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    4,075
-   </td>
-
-   <td align="center">
-
-    3,234
-   </td>
-
-   <td align="center">
-
-    3,266
-   </td>
-
-   <td align="center">
-
-    3,033
-   </td>
-
-   <td align="center">
-
-    3,603
-   </td>
-
-   <td align="center">
-
-    4,511
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    4,038
-   </td>
-
-   <td align="center">
-
-    3,272
-   </td>
-
-   <td align="center">
-
-    3,316
-   </td>
-
-   <td align="center">
-
-    2,909
-   </td>
-
-   <td align="center">
-
-    3,057
-   </td>
-
-   <td align="center">
-
-    4,081
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,661
-   </td>
-
-   <td align="center">
-
-    3,359
-   </td>
-
-   <td align="center">
-
-    3,062
-   </td>
-
-   <td align="center">
-
-    3,354
-   </td>
-
-   <td align="center">
-
-    4,215
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,942
-   </td>
-
-   <td align="center">
-
-    3,417
-   </td>
-
-   <td align="center">
-
-    3,077
-   </td>
-
-   <td align="center">
-
-    3,395
-   </td>
-
-   <td align="center">
-
-    4,139
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,703
-   </td>
-
-   <td align="center">
-
-    3,169
-   </td>
-
-   <td align="center">
-
-    3,095
-   </td>
-
-   <td align="center">
-
-    3,100
-   </td>
-
-   <td align="center">
-
-    3,752
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,727
-   </td>
-
-   <td align="center">
-
-    3,469
-   </td>
-
-   <td align="center">
-
-    3,179
-   </td>
-
-   <td align="center">
-
-    3,375
-   </td>
-
-   <td align="center">
-
-    3,874
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,722
-   </td>
-
-   <td align="center">
-
-    3,145
-   </td>
-
-   <td align="center">
-
-    3,159
-   </td>
-
-   <td align="center">
-
-    3,213
-   </td>
-
-   <td align="center">
-
-    3,567
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-
-   </td>
-
-   <td align="center">
-
-    3,866
-   </td>
-
-   <td align="center">
-
-    3,251
-   </td>
-
-   <td align="center">
-
-    3,199
-   </td>
-
-   <td align="center">
-
-    3,324
-   </td>
-
-   <td align="center">
-
-    3,362
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    23,482
-   </td>
-
-   <td align="center">
-
-    41,997
-   </td>
-
-   <td align="center">
-
-    38,946
-   </td>
-
-   <td align="center">
-
-    37,148
-   </td>
-
-   <td align="center">
-
-    40,601
-   </td>
-
-   <td align="center">
-
-    49,764
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Movement Statistics(2002-2007) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2007</th>
-
-   <th align="center">2006</th>
-
-   <th align="center">2005</th>
-
-   <th align="center">2004</th>
-
-   <th align="center">2003</th>
-
-   <th align="center">2002</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    4,384
-   </td>
-
-   <td align="center">
-
-    3,933
-   </td>
-
-   <td align="center">
-
-    3,528
-   </td>
-
-   <td align="center">
-
-    3,051
-   </td>
-
-   <td align="center">
-
-    3,257
-   </td>
-
-   <td align="center">
-
-    2,711
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    4,131
-   </td>
-
-   <td align="center">
-
-    3,667
-   </td>
-
-   <td align="center">
-
-    3,331
-   </td>
-
-   <td align="center">
-
-    2,372
-   </td>
-
-   <td align="center">
-
-    3,003
-   </td>
-
-   <td align="center">
-
-    2,747
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    4,349
-   </td>
-
-   <td align="center">
-
-    4,345
-   </td>
-
-   <td align="center">
-
-    3,549
-   </td>
-
-   <td align="center">
-
-    3,049
-   </td>
-
-   <td align="center">
-
-    3,109
-   </td>
-
-   <td align="center">
-
-    2,985
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    4,460
-   </td>
-
-   <td align="center">
-
-    4,490
-   </td>
-
-   <td align="center">
-
-    3,832
-   </td>
-
-   <td align="center">
-
-    3,359
-   </td>
-
-   <td align="center">
-
-    2,033
-   </td>
-
-   <td align="center">
-
-    2,928
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    4,629
-   </td>
-
-   <td align="center">
-
-    4,245
-   </td>
-
-   <td align="center">
-
-    3,663
-   </td>
-
-   <td align="center">
-
-    3,251
-   </td>
-
-   <td align="center">
-
-    1,229
-   </td>
-
-   <td align="center">
-
-    3,109
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    4,365
-   </td>
-
-   <td align="center">
-
-    4,124
-   </td>
-
-   <td align="center">
-
-    3,752
-   </td>
-
-   <td align="center">
-
-    3,414
-   </td>
-
-   <td align="center">
-
-    1,217
-   </td>
-
-   <td align="center">
-
-    3,049
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-    4,612
-   </td>
-
-   <td align="center">
-
-    4,386
-   </td>
-
-   <td align="center">
-
-    3,876
-   </td>
-
-   <td align="center">
-
-    3,664
-   </td>
-
-   <td align="center">
-
-    2,423
-   </td>
-
-   <td align="center">
-
-    3,078
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-    4,446
-   </td>
-
-   <td align="center">
-
-    4,373
-   </td>
-
-   <td align="center">
-
-    3,987
-   </td>
-
-   <td align="center">
-
-    3,631
-   </td>
-
-   <td align="center">
-
-    3,040
-   </td>
-
-   <td align="center">
-
-    3,166
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-    4,414
-   </td>
-
-   <td align="center">
-
-    4,311
-   </td>
-
-   <td align="center">
-
-    3,782
-   </td>
-
-   <td align="center">
-
-    3,514
-   </td>
-
-   <td align="center">
-
-    2,809
-   </td>
-
-   <td align="center">
-
-    3,239
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-    4,445
-   </td>
-
-   <td align="center">
-
-    4,455
-   </td>
-
-   <td align="center">
-
-    3,898
-   </td>
-
-   <td align="center">
-
-    3,744
-   </td>
-
-   <td align="center">
-
-    3,052
-   </td>
-
-   <td align="center">
-
-    3,562
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    4,563
-   </td>
-
-   <td align="center">
-
-    4,285
-   </td>
-
-   <td align="center">
-
-    3,951
-   </td>
-
-   <td align="center">
-
-    3,694
-   </td>
-
-   <td align="center">
-
-    3,125
-   </td>
-
-   <td align="center">
-
-    3,546
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    4,588
-   </td>
-
-   <td align="center">
-
-    4,435
-   </td>
-
-   <td align="center">
-
-    3,855
-   </td>
-
-   <td align="center">
-
-    3,763
-   </td>
-
-   <td align="center">
-
-    2,996
-   </td>
-
-   <td align="center">
-
-    3,444
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    53,386
-   </td>
-
-   <td align="center">
-
-    51,049
-   </td>
-
-   <td align="center">
-
-    45,004
-   </td>
-
-   <td align="center">
-
-    40,506
-   </td>
-
-   <td align="center">
-
-    31,293
-   </td>
-
-   <td align="center">
-
-    37,564
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Movement Statistics(1996-2001) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">2001</th>
-
-   <th align="center">2000</th>
-
-   <th align="center">1999</th>
-
-   <th align="center">1998</th>
-
-   <th align="center">1997</th>
-
-   <th align="center">1996</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-    2,694
-   </td>
-
-   <td align="center">
-
-    2,201
-   </td>
-
-   <td align="center">
-
-    1,835
-   </td>
-
-   <td align="center">
-
-    2,177
-   </td>
-
-   <td align="center">
-
-    1,353
-   </td>
-
-   <td align="center">
-
-    744
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-    2,364
-   </td>
-
-   <td align="center">
-
-    2,357
-   </td>
-
-   <td align="center">
-
-    1,826
-   </td>
-
-   <td align="center">
-
-    1,740
-   </td>
-
-   <td align="center">
-
-    1,339
-   </td>
-
-   <td align="center">
-
-    692
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-    2,543
-   </td>
-
-   <td align="center">
-
-    2,206
-   </td>
-
-   <td align="center">
-
-    1,895
-   </td>
-
-   <td align="center">
-
-    1,911
-   </td>
-
-   <td align="center">
-
-    1,533
-   </td>
-
-   <td align="center">
-
-    872
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-    2,531
-   </td>
-
-   <td align="center">
-
-    2,311
-   </td>
-
-   <td align="center">
-
-    2,076
-   </td>
-
-   <td align="center">
-
-    1,886
-   </td>
-
-   <td align="center">
-
-    1,587
-   </td>
-
-   <td align="center">
-
-    1,026
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-    2,579
-   </td>
-
-   <td align="center">
-
-    2,383
-   </td>
-
-   <td align="center">
-
-    1,914
-   </td>
-
-   <td align="center">
-
-    2,102
-   </td>
-
-   <td align="center">
-
-    1,720
-   </td>
-
-   <td align="center">
-
-    1,115
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-    2,681
-   </td>
-
-   <td align="center">
-
-    2,370
-   </td>
-
-   <td align="center">
-
-    1,890
-   </td>
-
-   <td align="center">
-
-    2,038
-   </td>
-
-   <td align="center">
-
-    1,716
-   </td>
-
-   <td align="center">
-
-    1,037
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-    2,903
-   </td>
-
-   <td align="center">
-
-    2,609
-   </td>
-
-   <td align="center">
-
-    1,916
-   </td>
-
-   <td align="center">
-
-    2,078
-   </td>
-
-   <td align="center">
-
-    1,693
-   </td>
-
-   <td align="center">
-
-    1,209
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-    3,037
-   </td>
-
-   <td align="center">
-
-    2,487
-   </td>
-
-   <td align="center">
-
-    1,968
-   </td>
-
-   <td align="center">
-
-    2,061
-   </td>
-
-   <td align="center">
-
-    1,676
-   </td>
-
-   <td align="center">
-
-    1,241
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-    2,767
-   </td>
-
-   <td align="center">
-
-    2,329
-   </td>
-
-   <td align="center">
-
-    1,955
-   </td>
-
-   <td align="center">
-
-    1,970
-   </td>
-
-   <td align="center">
-
-    1,681
-   </td>
-
-   <td align="center">
-
-    1,263
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-    2,922
-   </td>
-
-   <td align="center">
-
-    2,417
-   </td>
-
-   <td align="center">
-
-    2,267
-   </td>
-
-   <td align="center">
-
-    1,969
-   </td>
-
-   <td align="center">
-
-    1,809
-   </td>
-
-   <td align="center">
-
-    1,368
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    2,670
-   </td>
-
-   <td align="center">
-
-    2,273
-   </td>
-
-   <td align="center">
-
-    2,132
-   </td>
-
-   <td align="center">
-
-    2,102
-   </td>
-
-   <td align="center">
-
-    1,786
-   </td>
-
-   <td align="center">
-
-    1,433
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    2,815
-   </td>
-
-   <td align="center">
-
-    2,749
-   </td>
-
-   <td align="center">
-
-    2,187
-   </td>
-
-   <td align="center">
-
-    1,981
-   </td>
-
-   <td align="center">
-
-    1,944
-   </td>
-
-   <td align="center">
-
-    1,386
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    32,506
-   </td>
-
-   <td align="center">
-
-    28,692
-   </td>
-
-   <td align="center">
-
-    23,861
-   </td>
-
-   <td align="center">
-
-    24,015
-   </td>
-
-   <td align="center">
-
-    19,837
-   </td>
-
-   <td align="center">
-
-    13,386
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-   <br><br><br>
-   <span id="title">Movement Statistics(1995-1995) </span><br><br>
-   <table class="style1">
-   <tbody>
-   <tr height="17">
-   <th align="right">&nbsp; </th>
-
-   <th align="center">1995</th>
-
-   </tr>
-   <tr height="17">
-   <th align="right">January</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">February</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">March</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">April</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">May</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">June</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">July</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">August</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">September</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">October</th>
-
-   <td align="center">
-
-
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">November</th>
-
-   <td align="center">
-
-    126
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">December</th>
-
-   <td align="center">
-
-    536
-   </td>
-
-   </tr>
-   <tr height="17">
-   <th align="right">Total</th>
-
-   <td align="center">
-
-    662
-   </td>
-
-   </tr>
-   </tbody>
-   </table>
-
-
-   <br><br><br>
-   <div align="right"><img src="./macau_files/mov_stat.jpg" alt="passenger statistic picture" width="565" height="318"></div>
-
-
-  </div>
-
-          </div>
-                     </div>
-            </div>
-
-
-          <!--/*end context*/-->
-          </div>
-    </div>
-
-	<div id="buttombar"><img height="100" src="./macau_files/buttombar.gif"></div>
-	<div id="logo">
-
-
-
-		<div>
-
-          <a href="http://www.macau-airport.com/envirop/zh/default.php" style="display: inline;"><img height="80" src="./macau_files/38.jpg"></a>
-
-		</div>
-
-
-		<div>
-
-          <a href="http://www.macau-airport.com/envirop/en/default.php" style="display: inline;"><img height="80" src="./macau_files/36.jpg"></a>
-
-		</div>
-
-</div>
-</div>
-
-
-
-</div>
-
-
-<div id="footer">
-<hr>
-  <div id="footer-left">
-  <a href="http://www.camacau.com/index">Main Page</a> |
-  <a href="http://www.camacau.com/geographic_information">Our Business</a> |
-  <a href="http://www.camacau.com/about_us">About Us</a> |
-  <a href="http://www.camacau.com/pressReleases_list">Media Centre</a> |
-  <a href="http://www.camacau.com/rlinks2">Related Links</a> |
-  <a href="http://www.camacau.com/download_list">Interactive</a>
-  </div>
-  <div id="footer-right">Macau International Airport Co. Ltd. | Copyright 2013 | All rights reserved</div>
-</div>
-</div>
-</div>
-
-<div id="___fireplug_chrome_extension___" style="display: none;"></div><iframe id="rdbIndicator" width="100%" height="270" border="0" src="./macau_files/indicator.html" style="display: none; border: 0; position: fixed; left: 0; top: 0; z-index: 2147483647"></iframe><link rel="stylesheet" type="text/css" media="screen" href="chrome-extension://fcdjadjbdihbaodagojiomdljhjhjfho/css/atd.css"></body></html>
\ No newline at end of file
diff --git a/pandas/tests/io/data/nyse_wsj.html b/pandas/tests/io/data/nyse_wsj.html
deleted file mode 100644
index 2360bd49e9950..0000000000000
--- a/pandas/tests/io/data/nyse_wsj.html
+++ /dev/null
@@ -1,1207 +0,0 @@
-<table border="0" cellpadding="0" cellspacing="0" class="autocompleteContainer">
-    <tbody>
-    <tr>
-        <td>
-            <div class="symbolCompleteContainer">
-                <div><input autocomplete="off" maxlength="80" name="KEYWORDS" type="text" value=""/></div>
-            </div>
-            <div class="hat_button">
-                <span class="hat_button_text">SEARCH</span>
-            </div>
-            <div style="clear: both;"><div class="subSymbolCompleteResults"></div></div>
-        </td>
-    </tr>
-    </tbody>
-</table>
-<table bgcolor="" border="0" cellpadding="0" cellspacing="0" width="100%"><tbody><tr>
-        <td height="0"><img alt="" border="0" height="0" src="null/img/b.gif" width="1"/></td>
-</tr></tbody></table>
-<table border="0" cellpadding="0" cellspacing="0" class="mdcTable" width="100%">
-    <tbody><tr>
-        <td class="colhead" style="text-align:left"> </td>
-        <td class="colhead" style="text-align:left">Issue<span class="textb10gray" style="margin-left: 8px;">(Roll over for charts and headlines)</span>
-        </td>
-        <td class="colhead">Volume</td>
-        <td class="colhead">Price</td>
-        <td class="colhead" style="width:35px;">Chg</td>
-        <td class="colhead">% Chg</td>
-    </tr>
-    <tr>
-        <td class="num">1</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=JCP" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'JCP')">J.C. Penney (JCP)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">250,697,455</td>
-        <td class="nnum">$9.05</td>
-        <td class="nnum">-1.37</td>
-        <td class="nnum" style="border-right:0px">-13.15</td>
-    </tr>
-    <tr>
-        <td class="num">2</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=BAC" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'BAC')">Bank of America (BAC)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">77,162,103</td>
-        <td class="nnum">13.90</td>
-        <td class="nnum">-0.18</td>
-        <td class="nnum" style="border-right:0px">-1.28</td>
-    </tr>
-    <tr>
-        <td class="num">3</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=RAD" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'RAD')">Rite Aid (RAD)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">52,140,382</td>
-        <td class="nnum">4.70</td>
-        <td class="nnum">-0.08</td>
-        <td class="nnum" style="border-right:0px">-1.67</td>
-    </tr>
-    <tr>
-        <td class="num">4</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=F" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'F')">Ford Motor (F)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">33,745,287</td>
-        <td class="nnum">17.05</td>
-        <td class="nnum">-0.22</td>
-        <td class="nnum" style="border-right:0px">-1.27</td>
-    </tr>
-    <tr>
-        <td class="num">5</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=PFE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'PFE')">Pfizer (PFE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">27,801,853</td>
-        <td class="pnum">28.88</td>
-        <td class="pnum">0.36</td>
-        <td class="pnum" style="border-right:0px">1.26</td>
-    </tr>
-    <tr>
-        <td class="num">6</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=HTZ" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'HTZ')">Hertz Global Hldgs (HTZ)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">25,821,264</td>
-        <td class="pnum">22.32</td>
-        <td class="pnum">0.69</td>
-        <td class="pnum" style="border-right:0px">3.19</td>
-    </tr>
-    <tr>
-        <td class="num">7</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=GE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'GE')">General Electric (GE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">25,142,064</td>
-        <td class="nnum">24.05</td>
-        <td class="nnum">-0.20</td>
-        <td class="nnum" style="border-right:0px">-0.82</td>
-    </tr>
-    <tr>
-        <td class="num">8</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ELN" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ELN')">Elan ADS (ELN)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">24,725,209</td>
-        <td class="pnum">15.59</td>
-        <td class="pnum">0.08</td>
-        <td class="pnum" style="border-right:0px">0.52</td>
-    </tr>
-    <tr>
-        <td class="num">9</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=JPM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'JPM')">JPMorgan Chase (JPM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">22,402,756</td>
-        <td class="pnum">52.24</td>
-        <td class="pnum">0.35</td>
-        <td class="pnum" style="border-right:0px">0.67</td>
-    </tr>
-    <tr>
-        <td class="num">10</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=RF" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'RF')">Regions Financial (RF)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">20,790,532</td>
-        <td class="pnum">9.30</td>
-        <td class="pnum">0.12</td>
-        <td class="pnum" style="border-right:0px">1.31</td>
-    </tr>
-    <tr>
-        <td class="num">11</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=VMEM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'VMEM')">Violin Memory (VMEM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">20,669,846</td>
-        <td class="nnum">7.02</td>
-        <td class="nnum">-1.98</td>
-        <td class="nnum" style="border-right:0px">-22.00</td>
-    </tr>
-    <tr>
-        <td class="num">12</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=C" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'C')">Citigroup (C)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">19,979,932</td>
-        <td class="nnum">48.89</td>
-        <td class="nnum">-0.04</td>
-        <td class="nnum" style="border-right:0px">-0.08</td>
-    </tr>
-    <tr>
-        <td class="num">13</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=NOK" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'NOK')">Nokia ADS (NOK)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">19,585,075</td>
-        <td class="pnum">6.66</td>
-        <td class="pnum">0.02</td>
-        <td class="pnum" style="border-right:0px">0.30</td>
-    </tr>
-    <tr>
-        <td class="num">14</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=WFC" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'WFC')">Wells Fargo (WFC)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">19,478,590</td>
-        <td class="nnum">41.59</td>
-        <td class="nnum">-0.02</td>
-        <td class="nnum" style="border-right:0px">-0.05</td>
-    </tr>
-    <tr>
-        <td class="num">15</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=VALE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'VALE')">Vale ADS (VALE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">18,781,987</td>
-        <td class="nnum">15.60</td>
-        <td class="nnum">-0.52</td>
-        <td class="nnum" style="border-right:0px">-3.23</td>
-    </tr>
-    <tr>
-        <td class="num">16</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=DAL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'DAL')">Delta Air Lines (DAL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">16,013,956</td>
-        <td class="nnum">23.57</td>
-        <td class="nnum">-0.44</td>
-        <td class="nnum" style="border-right:0px">-1.83</td>
-    </tr>
-    <tr>
-        <td class="num">17</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=EMC" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'EMC')">EMC (EMC)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">15,771,252</td>
-        <td class="nnum">26.07</td>
-        <td class="nnum">-0.11</td>
-        <td class="nnum" style="border-right:0px">-0.42</td>
-    </tr>
-    <tr>
-        <td class="num">18</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=NKE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'NKE')">Nike Cl B (NKE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">15,514,717</td>
-        <td class="pnum">73.64</td>
-        <td class="pnum">3.30</td>
-        <td class="pnum" style="border-right:0px">4.69</td>
-    </tr>
-    <tr>
-        <td class="num">19</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=AA" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'AA')">Alcoa (AA)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">14,061,073</td>
-        <td class="nnum">8.20</td>
-        <td class="nnum">-0.07</td>
-        <td class="nnum" style="border-right:0px">-0.85</td>
-    </tr>
-    <tr>
-        <td class="num">20</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=GM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'GM')">General Motors (GM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">13,984,004</td>
-        <td class="nnum">36.37</td>
-        <td class="nnum">-0.58</td>
-        <td class="nnum" style="border-right:0px">-1.57</td>
-    </tr>
-    <tr>
-        <td class="num">21</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ORCL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ORCL')">Oracle (ORCL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">13,856,671</td>
-        <td class="nnum">33.78</td>
-        <td class="nnum">-0.03</td>
-        <td class="nnum" style="border-right:0px">-0.09</td>
-    </tr>
-    <tr>
-        <td class="num">22</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=T" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'T')">AT&amp;T (T)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">13,736,948</td>
-        <td class="nnum">33.98</td>
-        <td class="nnum">-0.25</td>
-        <td class="nnum" style="border-right:0px">-0.73</td>
-    </tr>
-    <tr>
-        <td class="num">23</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=TSL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'TSL')">Trina Solar ADS (TSL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">13,284,202</td>
-        <td class="pnum">14.83</td>
-        <td class="pnum">1.99</td>
-        <td class="pnum" style="border-right:0px">15.50</td>
-    </tr>
-    <tr>
-        <td class="num">24</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=YGE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'YGE')">Yingli Green Energy Holding ADS (YGE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">12,978,378</td>
-        <td class="pnum">6.73</td>
-        <td class="pnum">0.63</td>
-        <td class="pnum" style="border-right:0px">10.33</td>
-    </tr>
-    <tr>
-        <td class="num">25</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=PBR" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'PBR')">Petroleo Brasileiro ADS (PBR)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">12,833,660</td>
-        <td class="nnum">15.40</td>
-        <td class="nnum">-0.21</td>
-        <td class="nnum" style="border-right:0px">-1.35</td>
-    </tr>
-    <tr>
-        <td class="num">26</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=UAL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'UAL')">United Continental Holdings (UAL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">12,603,225</td>
-        <td class="nnum">30.91</td>
-        <td class="nnum">-3.16</td>
-        <td class="nnum" style="border-right:0px">-9.28</td>
-    </tr>
-    <tr>
-        <td class="num">27</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=KO" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'KO')">Coca-Cola (KO)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">12,343,452</td>
-        <td class="nnum">38.40</td>
-        <td class="nnum">-0.34</td>
-        <td class="nnum" style="border-right:0px">-0.88</td>
-    </tr>
-    <tr>
-        <td class="num">28</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ACI" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ACI')">Arch Coal (ACI)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">12,261,138</td>
-        <td class="nnum">4.25</td>
-        <td class="nnum">-0.28</td>
-        <td class="nnum" style="border-right:0px">-6.18</td>
-    </tr>
-    <tr>
-        <td class="num">29</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MS" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MS')">Morgan Stanley (MS)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,956,345</td>
-        <td class="nnum">27.08</td>
-        <td class="nnum">-0.07</td>
-        <td class="nnum" style="border-right:0px">-0.26</td>
-    </tr>
-    <tr>
-        <td class="num">30</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=P" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'P')">Pandora Media (P)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,829,963</td>
-        <td class="pnum">25.52</td>
-        <td class="pnum">0.13</td>
-        <td class="pnum" style="border-right:0px">0.51</td>
-    </tr>
-    <tr>
-        <td class="num">31</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ABX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ABX')">Barrick Gold (ABX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,775,585</td>
-        <td class="num">18.53</td>
-        <td class="num">0.00</td>
-        <td class="num" style="border-right:0px">0.00</td>
-    </tr>
-    <tr>
-        <td class="num">32</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ABT" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ABT')">Abbott Laboratories (ABT)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,755,718</td>
-        <td class="nnum">33.14</td>
-        <td class="nnum">-0.52</td>
-        <td class="nnum" style="border-right:0px">-1.54</td>
-    </tr>
-    <tr>
-        <td class="num">33</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=BSBR" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'BSBR')">Banco Santander Brasil ADS (BSBR)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,587,310</td>
-        <td class="pnum">7.01</td>
-        <td class="pnum">0.46</td>
-        <td class="pnum" style="border-right:0px">7.02</td>
-    </tr>
-    <tr>
-        <td class="num">34</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=AMD" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'AMD')">Advanced Micro Devices (AMD)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,337,609</td>
-        <td class="nnum">3.86</td>
-        <td class="nnum">-0.03</td>
-        <td class="nnum" style="border-right:0px">-0.77</td>
-    </tr>
-    <tr>
-        <td class="num">35</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=NLY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'NLY')">Annaly Capital Management (NLY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">11,004,440</td>
-        <td class="nnum">11.63</td>
-        <td class="nnum">-0.07</td>
-        <td class="nnum" style="border-right:0px">-0.60</td>
-    </tr>
-    <tr>
-        <td class="num">36</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ANR" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ANR')">Alpha Natural Resources (ANR)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,941,074</td>
-        <td class="nnum">6.08</td>
-        <td class="nnum">-0.19</td>
-        <td class="nnum" style="border-right:0px">-3.03</td>
-    </tr>
-    <tr>
-        <td class="num">37</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=XOM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'XOM')">Exxon Mobil (XOM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,668,115</td>
-        <td class="nnum">86.90</td>
-        <td class="nnum">-0.17</td>
-        <td class="nnum" style="border-right:0px">-0.20</td>
-    </tr>
-    <tr>
-        <td class="num">38</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ITUB" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ITUB')">Itau Unibanco Holding ADS (ITUB)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,638,803</td>
-        <td class="pnum">14.30</td>
-        <td class="pnum">0.23</td>
-        <td class="pnum" style="border-right:0px">1.63</td>
-    </tr>
-    <tr>
-        <td class="num">39</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MRK" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MRK')">Merck&amp;Co (MRK)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,388,152</td>
-        <td class="pnum">47.79</td>
-        <td class="pnum">0.11</td>
-        <td class="pnum" style="border-right:0px">0.23</td>
-    </tr>
-    <tr>
-        <td class="num">40</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ALU" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ALU')">Alcatel-Lucent ADS (ALU)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,181,833</td>
-        <td class="pnum">3.65</td>
-        <td class="pnum">0.01</td>
-        <td class="pnum" style="border-right:0px">0.27</td>
-    </tr>
-    <tr>
-        <td class="num">41</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=VZ" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'VZ')">Verizon Communications (VZ)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,139,321</td>
-        <td class="nnum">47.00</td>
-        <td class="nnum">-0.67</td>
-        <td class="nnum" style="border-right:0px">-1.41</td>
-    </tr>
-    <tr>
-        <td class="num">42</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MHR" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MHR')">Magnum Hunter Resources (MHR)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">10,004,303</td>
-        <td class="pnum">6.33</td>
-        <td class="pnum">0.46</td>
-        <td class="pnum" style="border-right:0px">7.84</td>
-    </tr>
-    <tr>
-        <td class="num">43</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=HPQ" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'HPQ')">Hewlett-Packard (HPQ)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,948,935</td>
-        <td class="nnum">21.17</td>
-        <td class="nnum">-0.13</td>
-        <td class="nnum" style="border-right:0px">-0.61</td>
-    </tr>
-    <tr>
-        <td class="num">44</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=PHM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'PHM')">PulteGroup (PHM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,899,141</td>
-        <td class="nnum">16.57</td>
-        <td class="nnum">-0.41</td>
-        <td class="nnum" style="border-right:0px">-2.41</td>
-    </tr>
-    <tr>
-        <td class="num">45</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SOL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SOL')">ReneSola ADS (SOL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,667,438</td>
-        <td class="pnum">4.84</td>
-        <td class="pnum">0.39</td>
-        <td class="pnum" style="border-right:0px">8.76</td>
-    </tr>
-    <tr>
-        <td class="num">46</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=GLW" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'GLW')">Corning (GLW)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,547,265</td>
-        <td class="nnum">14.73</td>
-        <td class="nnum">-0.21</td>
-        <td class="nnum" style="border-right:0px">-1.41</td>
-    </tr>
-    <tr>
-        <td class="num">47</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=COLE" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'COLE')">Cole Real Estate Investments (COLE)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,544,021</td>
-        <td class="pnum">12.21</td>
-        <td class="pnum">0.01</td>
-        <td class="pnum" style="border-right:0px">0.08</td>
-    </tr>
-    <tr>
-        <td class="num">48</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=DOW" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'DOW')">Dow Chemical (DOW)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,150,479</td>
-        <td class="nnum">39.02</td>
-        <td class="nnum">-0.97</td>
-        <td class="nnum" style="border-right:0px">-2.43</td>
-    </tr>
-    <tr>
-        <td class="num">49</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=IGT" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'IGT')">International Game Technology (IGT)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">9,129,123</td>
-        <td class="nnum">19.23</td>
-        <td class="nnum">-1.44</td>
-        <td class="nnum" style="border-right:0px">-6.97</td>
-    </tr>
-    <tr>
-        <td class="num">50</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ACN" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ACN')">Accenture Cl A (ACN)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,773,260</td>
-        <td class="nnum">74.09</td>
-        <td class="nnum">-1.78</td>
-        <td class="nnum" style="border-right:0px">-2.35</td>
-    </tr>
-    <tr>
-        <td class="num">51</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=KEY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'KEY')">KeyCorp (KEY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,599,333</td>
-        <td class="pnum">11.36</td>
-        <td class="pnum">0.02</td>
-        <td class="pnum" style="border-right:0px">0.18</td>
-    </tr>
-    <tr>
-        <td class="num">52</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=BMY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'BMY')">Bristol-Myers Squibb (BMY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,440,709</td>
-        <td class="nnum">46.20</td>
-        <td class="nnum">-0.73</td>
-        <td class="nnum" style="border-right:0px">-1.56</td>
-    </tr>
-    <tr>
-        <td class="num">53</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SID" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SID')">Companhia Siderurgica Nacional ADS (SID)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,437,636</td>
-        <td class="nnum">4.36</td>
-        <td class="nnum">-0.05</td>
-        <td class="nnum" style="border-right:0px">-1.13</td>
-    </tr>
-    <tr>
-        <td class="num">54</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=HRB" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'HRB')">H&amp;R Block (HRB)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,240,984</td>
-        <td class="pnum">26.36</td>
-        <td class="pnum">0.31</td>
-        <td class="pnum" style="border-right:0px">1.19</td>
-    </tr>
-    <tr>
-        <td class="num">55</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MTG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MTG')">MGIC Investment (MTG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,135,037</td>
-        <td class="nnum">7.26</td>
-        <td class="nnum">-0.10</td>
-        <td class="nnum" style="border-right:0px">-1.36</td>
-    </tr>
-    <tr>
-        <td class="num">56</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=RNG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'RNG')">RingCentral Cl A (RNG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,117,469</td>
-        <td class="pnum">18.20</td>
-        <td class="pnum">5.20</td>
-        <td class="pnum" style="border-right:0px">40.00</td>
-    </tr>
-    <tr>
-        <td class="num">57</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=X" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'X')">United States Steel (X)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,107,899</td>
-        <td class="nnum">20.44</td>
-        <td class="nnum">-0.66</td>
-        <td class="nnum" style="border-right:0px">-3.13</td>
-    </tr>
-    <tr>
-        <td class="num">58</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CLF" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CLF')">Cliffs Natural Resources (CLF)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,041,572</td>
-        <td class="nnum">21.00</td>
-        <td class="nnum">-0.83</td>
-        <td class="nnum" style="border-right:0px">-3.80</td>
-    </tr>
-    <tr>
-        <td class="num">59</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=NEM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'NEM')">Newmont Mining (NEM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">8,014,250</td>
-        <td class="nnum">27.98</td>
-        <td class="nnum">-0.19</td>
-        <td class="nnum" style="border-right:0px">-0.67</td>
-    </tr>
-    <tr>
-        <td class="num">60</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MO" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MO')">Altria Group (MO)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,786,048</td>
-        <td class="nnum">34.71</td>
-        <td class="nnum">-0.29</td>
-        <td class="nnum" style="border-right:0px">-0.83</td>
-    </tr>
-    <tr>
-        <td class="num">61</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SD" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SD')">SandRidge Energy (SD)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,782,745</td>
-        <td class="nnum">5.93</td>
-        <td class="nnum">-0.06</td>
-        <td class="nnum" style="border-right:0px">-1.00</td>
-    </tr>
-    <tr>
-        <td class="num">62</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MCP" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MCP')">Molycorp (MCP)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,735,831</td>
-        <td class="nnum">6.73</td>
-        <td class="nnum">-0.45</td>
-        <td class="nnum" style="border-right:0px">-6.27</td>
-    </tr>
-    <tr>
-        <td class="num">63</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=HAL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'HAL')">Halliburton (HAL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,728,735</td>
-        <td class="nnum">48.39</td>
-        <td class="nnum">-0.32</td>
-        <td class="nnum" style="border-right:0px">-0.66</td>
-    </tr>
-    <tr>
-        <td class="num">64</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=TSM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'TSM')">Taiwan Semiconductor Manufacturing ADS (TSM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,661,397</td>
-        <td class="nnum">17.07</td>
-        <td class="nnum">-0.25</td>
-        <td class="nnum" style="border-right:0px">-1.44</td>
-    </tr>
-    <tr>
-        <td class="num">65</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=FCX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'FCX')">Freeport-McMoRan Copper&amp;Gold (FCX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,622,803</td>
-        <td class="nnum">33.42</td>
-        <td class="nnum">-0.45</td>
-        <td class="nnum" style="border-right:0px">-1.33</td>
-    </tr>
-    <tr>
-        <td class="num">66</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=KOG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'KOG')">Kodiak Oil&amp;Gas (KOG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,543,806</td>
-        <td class="pnum">11.94</td>
-        <td class="pnum">0.16</td>
-        <td class="pnum" style="border-right:0px">1.36</td>
-    </tr>
-    <tr>
-        <td class="num">67</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=XRX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'XRX')">Xerox (XRX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,440,689</td>
-        <td class="nnum">10.37</td>
-        <td class="nnum">-0.01</td>
-        <td class="nnum" style="border-right:0px">-0.10</td>
-    </tr>
-    <tr>
-        <td class="num">68</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=S" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'S')">Sprint (S)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,291,351</td>
-        <td class="nnum">6.16</td>
-        <td class="nnum">-0.14</td>
-        <td class="nnum" style="border-right:0px">-2.22</td>
-    </tr>
-    <tr>
-        <td class="num">69</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=TWO" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'TWO')">Two Harbors Investment (TWO)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,153,803</td>
-        <td class="pnum">9.79</td>
-        <td class="pnum">0.05</td>
-        <td class="pnum" style="border-right:0px">0.51</td>
-    </tr>
-    <tr>
-        <td class="num">70</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=WLT" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'WLT')">Walter Energy (WLT)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,152,192</td>
-        <td class="nnum">14.19</td>
-        <td class="nnum">-0.36</td>
-        <td class="nnum" style="border-right:0px">-2.47</td>
-    </tr>
-    <tr>
-        <td class="num">71</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=IP" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'IP')">International Paper (IP)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,123,722</td>
-        <td class="nnum">45.44</td>
-        <td class="nnum">-1.85</td>
-        <td class="nnum" style="border-right:0px">-3.91</td>
-    </tr>
-    <tr>
-        <td class="num">72</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=PPL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'PPL')">PPL (PPL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">7,026,292</td>
-        <td class="nnum">30.34</td>
-        <td class="nnum">-0.13</td>
-        <td class="nnum" style="border-right:0px">-0.43</td>
-    </tr>
-    <tr>
-        <td class="num">73</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=GG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'GG')">Goldcorp (GG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,857,447</td>
-        <td class="pnum">25.76</td>
-        <td class="pnum">0.08</td>
-        <td class="pnum" style="border-right:0px">0.31</td>
-    </tr>
-    <tr>
-        <td class="num">74</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=TWX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'TWX')">Time Warner (TWX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,807,237</td>
-        <td class="pnum">66.20</td>
-        <td class="pnum">1.33</td>
-        <td class="pnum" style="border-right:0px">2.05</td>
-    </tr>
-    <tr>
-        <td class="num">75</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SNV" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SNV')">Synovus Financial (SNV)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,764,805</td>
-        <td class="pnum">3.29</td>
-        <td class="pnum">0.02</td>
-        <td class="pnum" style="border-right:0px">0.61</td>
-    </tr>
-    <tr>
-        <td class="num">76</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=AKS" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'AKS')">AK Steel Holding (AKS)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,662,599</td>
-        <td class="nnum">3.83</td>
-        <td class="nnum">-0.11</td>
-        <td class="nnum" style="border-right:0px">-2.79</td>
-    </tr>
-    <tr>
-        <td class="num">77</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=BSX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'BSX')">Boston Scientific (BSX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,629,084</td>
-        <td class="nnum">11.52</td>
-        <td class="nnum">-0.15</td>
-        <td class="nnum" style="border-right:0px">-1.29</td>
-    </tr>
-    <tr>
-        <td class="num">78</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=EGO" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'EGO')">Eldorado Gold (EGO)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,596,902</td>
-        <td class="nnum">6.65</td>
-        <td class="nnum">-0.03</td>
-        <td class="nnum" style="border-right:0px">-0.45</td>
-    </tr>
-    <tr>
-        <td class="num">79</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=NR" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'NR')">Newpark Resources (NR)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,552,453</td>
-        <td class="pnum">12.56</td>
-        <td class="pnum">0.09</td>
-        <td class="pnum" style="border-right:0px">0.72</td>
-    </tr>
-    <tr>
-        <td class="num">80</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=ABBV" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'ABBV')">AbbVie (ABBV)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,525,524</td>
-        <td class="nnum">44.33</td>
-        <td class="nnum">-0.67</td>
-        <td class="nnum" style="border-right:0px">-1.49</td>
-    </tr>
-    <tr>
-        <td class="num">81</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MBI" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MBI')">MBIA (MBI)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,416,587</td>
-        <td class="nnum">10.38</td>
-        <td class="nnum">-0.43</td>
-        <td class="nnum" style="border-right:0px">-3.98</td>
-    </tr>
-    <tr>
-        <td class="num">82</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SAI" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SAI')">SAIC (SAI)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,404,587</td>
-        <td class="pnum">16.03</td>
-        <td class="pnum">0.13</td>
-        <td class="pnum" style="border-right:0px">0.82</td>
-    </tr>
-    <tr>
-        <td class="num">83</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=PG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'PG')">Procter&amp;Gamble (PG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,389,143</td>
-        <td class="nnum">77.21</td>
-        <td class="nnum">-0.84</td>
-        <td class="nnum" style="border-right:0px">-1.08</td>
-    </tr>
-    <tr>
-        <td class="num">84</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=IAG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'IAG')">IAMGOLD (IAG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,293,001</td>
-        <td class="nnum">4.77</td>
-        <td class="nnum">-0.06</td>
-        <td class="nnum" style="border-right:0px">-1.24</td>
-    </tr>
-    <tr>
-        <td class="num">85</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=SWY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'SWY')">Safeway (SWY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,268,184</td>
-        <td class="nnum">32.25</td>
-        <td class="nnum">-0.29</td>
-        <td class="nnum" style="border-right:0px">-0.89</td>
-    </tr>
-    <tr>
-        <td class="num">86</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=KGC" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'KGC')">Kinross Gold (KGC)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">6,112,658</td>
-        <td class="nnum">4.99</td>
-        <td class="nnum">-0.03</td>
-        <td class="nnum" style="border-right:0px">-0.60</td>
-    </tr>
-    <tr>
-        <td class="num">87</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MGM" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MGM')">MGM Resorts International (MGM)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,986,143</td>
-        <td class="nnum">20.22</td>
-        <td class="nnum">-0.05</td>
-        <td class="nnum" style="border-right:0px">-0.25</td>
-    </tr>
-    <tr>
-        <td class="num">88</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CX')">Cemex ADS (CX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,907,040</td>
-        <td class="nnum">11.27</td>
-        <td class="nnum">-0.06</td>
-        <td class="nnum" style="border-right:0px">-0.53</td>
-    </tr>
-    <tr>
-        <td class="num">89</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=AIG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'AIG')">American International Group (AIG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,900,133</td>
-        <td class="nnum">49.15</td>
-        <td class="nnum">-0.30</td>
-        <td class="nnum" style="border-right:0px">-0.61</td>
-    </tr>
-    <tr>
-        <td class="num">90</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CHK" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CHK')">Chesapeake Energy (CHK)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,848,016</td>
-        <td class="nnum">26.21</td>
-        <td class="nnum">-0.20</td>
-        <td class="nnum" style="border-right:0px">-0.76</td>
-    </tr>
-    <tr>
-        <td class="num">91</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=RSH" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'RSH')">RadioShack (RSH)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,837,833</td>
-        <td class="nnum">3.44</td>
-        <td class="nnum">-0.43</td>
-        <td class="nnum" style="border-right:0px">-11.11</td>
-    </tr>
-    <tr>
-        <td class="num">92</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=USB" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'USB')">U.S. Bancorp (USB)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,814,373</td>
-        <td class="nnum">36.50</td>
-        <td class="nnum">-0.04</td>
-        <td class="nnum" style="border-right:0px">-0.11</td>
-    </tr>
-    <tr>
-        <td class="num">93</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=LLY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'LLY')">Eli Lilly (LLY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,776,991</td>
-        <td class="nnum">50.50</td>
-        <td class="nnum">-0.54</td>
-        <td class="nnum" style="border-right:0px">-1.06</td>
-    </tr>
-    <tr>
-        <td class="num">94</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MET" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MET')">MetLife (MET)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,774,996</td>
-        <td class="nnum">47.21</td>
-        <td class="nnum">-0.37</td>
-        <td class="nnum" style="border-right:0px">-0.78</td>
-    </tr>
-    <tr>
-        <td class="num">95</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=AUY" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'AUY')">Yamana Gold (AUY)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,742,426</td>
-        <td class="pnum">10.37</td>
-        <td class="pnum">0.03</td>
-        <td class="pnum" style="border-right:0px">0.29</td>
-    </tr>
-    <tr>
-        <td class="num">96</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CBS" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CBS')">CBS Cl B (CBS)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,718,858</td>
-        <td class="nnum">55.50</td>
-        <td class="nnum">-0.06</td>
-        <td class="nnum" style="border-right:0px">-0.11</td>
-    </tr>
-    <tr>
-        <td class="num">97</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CSX" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CSX')">CSX (CSX)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,710,066</td>
-        <td class="nnum">25.85</td>
-        <td class="nnum">-0.13</td>
-        <td class="nnum" style="border-right:0px">-0.50</td>
-    </tr>
-    <tr>
-        <td class="num">98</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=CCL" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'CCL')">Carnival (CCL)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,661,325</td>
-        <td class="nnum">32.88</td>
-        <td class="nnum">-0.05</td>
-        <td class="nnum" style="border-right:0px">-0.15</td>
-    </tr>
-    <tr>
-        <td class="num">99</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=MOS" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'MOS')">Mosaic (MOS)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,595,592</td>
-        <td class="nnum">43.43</td>
-        <td class="nnum">-0.76</td>
-        <td class="nnum" style="border-right:0px">-1.72</td>
-    </tr>
-    <tr>
-        <td class="num">100</td>
-        <td class="text" style="max-width:307px">
-            <a class="linkb" href="/public/quotes/main.html?symbol=WAG" onmouseout="com.dowjones.rolloverQuotes.hidelater();" onmouseover="com.dowjones.rolloverQuotes.show(this,'WAG')">Walgreen (WAG)
-            </a>
-        </td>
-        <td align="right" class="num" style="font-weight:bold;">5,568,310</td>
-        <td class="nnum">54.51</td>
-        <td class="nnum">-0.22</td>
-        <td class="nnum" style="border-right:0px">-0.40</td>
-    </tr>
-</tbody></table>
-<table bgcolor="" border="0" cellpadding="0" cellspacing="0" width="100%">
-    <tbody><tr><td height="20px"><img alt="" border="0" height="20px" src="/img/b.gif" width="1"/></td></tr>
-</tbody></table>
-<table align="center" bgcolor="#ffffff" border="0" cellpadding="0" cellspacing="0" style="border:1px solid #cfc7b7;margin-bottom:5px;" width="575px">
-    <tbody><tr>
-        <td bgcolor="#e9e7e0" class="b12" colspan="3" style="padding:3px 0px 3px 0px;"><span class="p10" style="color:#000; float:right">An Advertising Feature  </span>  PARTNER CENTER</td>
-    </tr>
-
-    <tr>
-        <td align="center" class="p10" style="padding:10px 0px 5px 0px;border-right:1px solid #cfc7b7;" valign="top">
-
-
-
-            <script type="text/javascript">
-<!--
-            var tempHTML = '';
-            var adURL = 'http://ad.doubleclick.net/adi/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=1;sz=170x67;ord=26093260932609326093;';
-            if ( isSafari ) {
-                tempHTML += '<iframe id="mdc_tradingcenter1" src="'+adURL+'" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170">';
-            } else {
-                tempHTML += '<iframe id="mdc_tradingcenter1" src="/static_html_files/blank.htm" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170px;">';
-                ListOfIframes.mdc_tradingcenter1= adURL;
-            }
-            tempHTML += '<a href="http://ad.doubleclick.net/jump/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=1;sz=170x67;ord=26093260932609326093;" target="_new">';
-            tempHTML += '<img src="http://ad.doubleclick.net/ad/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=1;sz=170x67;ord=26093260932609326093;" border="0" width="170" height="67" vspace="0" alt="Advertisement" /></a><br /></iframe>';
-            document.write(tempHTML);
-            // -->
-            </script>
-        </td>
-
-        <td align="center" class="p10" style="padding:10px 0px 5px 0px;border-right:1px solid #cfc7b7;" valign="top">
-
-
-
-            <script type="text/javascript">
-<!--
-            var tempHTML = '';
-            var adURL = 'http://ad.doubleclick.net/adi/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=2;sz=170x67;ord=26093260932609326093;';
-            if ( isSafari ) {
-                tempHTML += '<iframe id="mdc_tradingcenter2" src="'+adURL+'" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170">';
-            } else {
-                tempHTML += '<iframe id="mdc_tradingcenter2" src="/static_html_files/blank.htm" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170px;">';
-                ListOfIframes.mdc_tradingcenter2= adURL;
-            }
-            tempHTML += '<a href="http://ad.doubleclick.net/jump/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=2;sz=170x67;ord=26093260932609326093;" target="_new">';
-            tempHTML += '<img src="http://ad.doubleclick.net/ad/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=2;sz=170x67;ord=26093260932609326093;" border="0" width="170" height="67" vspace="0" alt="Advertisement" /></a><br /></iframe>';
-            document.write(tempHTML);
-            // -->
-            </script>
-        </td>
-
-        <td align="center" class="p10" style="padding:10px 0px 5px 0px;" valign="top">
-
-
-
-            <script type="text/javascript">
-<!--
-            var tempHTML = '';
-            var adURL = 'http://ad.doubleclick.net/adi/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=3;sz=170x67;ord=26093260932609326093;';
-            if ( isSafari ) {
-                tempHTML += '<iframe id="mdc_tradingcenter3" src="'+adURL+'" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170">';
-            } else {
-                tempHTML += '<iframe id="mdc_tradingcenter3" src="/static_html_files/blank.htm" width="170" height="67" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" bordercolor="#000000" style="width:170px;">';
-                ListOfIframes.mdc_tradingcenter3= adURL;
-            }
-            tempHTML += '<a href="http://ad.doubleclick.net/jump/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=3;sz=170x67;ord=26093260932609326093;" target="_new">';
-            tempHTML += '<img src="http://ad.doubleclick.net/ad/'+((GetCookie('etsFlag'))?'ets.wsj.com':'brokerbuttons.wsj.com')+'/markets_front;!category=;msrc=' + msrc + ';' + segQS + ';' + mc + ';tile=3;sz=170x67;ord=26093260932609326093;" border="0" width="170" height="67" vspace="0" alt="Advertisement" /></a><br /></iframe>';
-            document.write(tempHTML);
-            // -->
-            </script>
-        </td>
-
-    </tr>
-
-</tbody></table>
-<table bgcolor="" border="0" cellpadding="0" cellspacing="0" width="100%">
-    <tbody><tr><td height="20px"><img alt="" border="0" height="20px" src="/img/b.gif" width="1"/></td></tr>
-</tbody></table>
diff --git a/pandas/tests/io/data/orc/TestOrcFile.decimal.orc b/pandas/tests/io/data/orc/TestOrcFile.decimal.orc
new file mode 100644
index 0000000000000..cb0f7b9d767a3
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.decimal.orc differ
diff --git a/pandas/tests/io/data/orc/TestOrcFile.emptyFile.orc b/pandas/tests/io/data/orc/TestOrcFile.emptyFile.orc
new file mode 100644
index 0000000000000..ecdadcbff1346
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.emptyFile.orc differ
diff --git a/pandas/tests/io/data/orc/TestOrcFile.test1.orc b/pandas/tests/io/data/orc/TestOrcFile.test1.orc
new file mode 100644
index 0000000000000..4fb0beff86897
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.test1.orc differ
diff --git a/pandas/tests/io/data/orc/TestOrcFile.testDate1900.orc b/pandas/tests/io/data/orc/TestOrcFile.testDate1900.orc
new file mode 100644
index 0000000000000..f51ffdbd03a43
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.testDate1900.orc differ
diff --git a/pandas/tests/io/data/orc/TestOrcFile.testDate2038.orc b/pandas/tests/io/data/orc/TestOrcFile.testDate2038.orc
new file mode 100644
index 0000000000000..cd11fa8a4e91d
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.testDate2038.orc differ
diff --git a/pandas/tests/io/data/orc/TestOrcFile.testSnappy.orc b/pandas/tests/io/data/orc/TestOrcFile.testSnappy.orc
new file mode 100644
index 0000000000000..aa6cc9c9ba1a7
Binary files /dev/null and b/pandas/tests/io/data/orc/TestOrcFile.testSnappy.orc differ
diff --git a/pandas/tests/io/data/pickle/categorical.0.25.0.pickle b/pandas/tests/io/data/pickle/categorical.0.25.0.pickle
new file mode 100644
index 0000000000000..b756060c83d94
Binary files /dev/null and b/pandas/tests/io/data/pickle/categorical.0.25.0.pickle differ
diff --git a/pandas/tests/io/data/pickle/sparseframe-0.20.3.pickle.gz b/pandas/tests/io/data/pickle/sparseframe-0.20.3.pickle.gz
new file mode 100644
index 0000000000000..f4ff0dbaa1ff9
Binary files /dev/null and b/pandas/tests/io/data/pickle/sparseframe-0.20.3.pickle.gz differ
diff --git a/pandas/tests/io/data/pickle/sparseseries-0.20.3.pickle.gz b/pandas/tests/io/data/pickle/sparseseries-0.20.3.pickle.gz
new file mode 100644
index 0000000000000..b299e7d85808e
Binary files /dev/null and b/pandas/tests/io/data/pickle/sparseseries-0.20.3.pickle.gz differ
diff --git a/pandas/tests/io/data/pickle/test_py27.pkl b/pandas/tests/io/data/pickle/test_py27.pkl
new file mode 100644
index 0000000000000..5308b864bc0c7
Binary files /dev/null and b/pandas/tests/io/data/pickle/test_py27.pkl differ
diff --git a/pandas/tests/io/data/labelled-num-na.sav b/pandas/tests/io/data/spss/labelled-num-na.sav
similarity index 100%
rename from pandas/tests/io/data/labelled-num-na.sav
rename to pandas/tests/io/data/spss/labelled-num-na.sav
diff --git a/pandas/tests/io/data/labelled-num.sav b/pandas/tests/io/data/spss/labelled-num.sav
similarity index 100%
rename from pandas/tests/io/data/labelled-num.sav
rename to pandas/tests/io/data/spss/labelled-num.sav
diff --git a/pandas/tests/io/data/labelled-str.sav b/pandas/tests/io/data/spss/labelled-str.sav
similarity index 100%
rename from pandas/tests/io/data/labelled-str.sav
rename to pandas/tests/io/data/spss/labelled-str.sav
diff --git a/pandas/tests/io/data/umlauts.sav b/pandas/tests/io/data/spss/umlauts.sav
similarity index 100%
rename from pandas/tests/io/data/umlauts.sav
rename to pandas/tests/io/data/spss/umlauts.sav
diff --git a/pandas/tests/io/data/S4_EDUC1.dta b/pandas/tests/io/data/stata/S4_EDUC1.dta
similarity index 100%
rename from pandas/tests/io/data/S4_EDUC1.dta
rename to pandas/tests/io/data/stata/S4_EDUC1.dta
diff --git a/pandas/tests/io/data/stata10_115.dta b/pandas/tests/io/data/stata/stata10_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata10_115.dta
rename to pandas/tests/io/data/stata/stata10_115.dta
diff --git a/pandas/tests/io/data/stata10_117.dta b/pandas/tests/io/data/stata/stata10_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata10_117.dta
rename to pandas/tests/io/data/stata/stata10_117.dta
diff --git a/pandas/tests/io/data/stata11_115.dta b/pandas/tests/io/data/stata/stata11_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata11_115.dta
rename to pandas/tests/io/data/stata/stata11_115.dta
diff --git a/pandas/tests/io/data/stata11_117.dta b/pandas/tests/io/data/stata/stata11_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata11_117.dta
rename to pandas/tests/io/data/stata/stata11_117.dta
diff --git a/pandas/tests/io/data/stata12_117.dta b/pandas/tests/io/data/stata/stata12_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata12_117.dta
rename to pandas/tests/io/data/stata/stata12_117.dta
diff --git a/pandas/tests/io/data/stata13_dates.dta b/pandas/tests/io/data/stata/stata13_dates.dta
similarity index 100%
rename from pandas/tests/io/data/stata13_dates.dta
rename to pandas/tests/io/data/stata/stata13_dates.dta
diff --git a/pandas/tests/io/data/stata14_118.dta b/pandas/tests/io/data/stata/stata14_118.dta
similarity index 100%
rename from pandas/tests/io/data/stata14_118.dta
rename to pandas/tests/io/data/stata/stata14_118.dta
diff --git a/pandas/tests/io/data/stata15.dta b/pandas/tests/io/data/stata/stata15.dta
similarity index 100%
rename from pandas/tests/io/data/stata15.dta
rename to pandas/tests/io/data/stata/stata15.dta
diff --git a/pandas/tests/io/data/stata16_118.dta b/pandas/tests/io/data/stata/stata16_118.dta
similarity index 100%
rename from pandas/tests/io/data/stata16_118.dta
rename to pandas/tests/io/data/stata/stata16_118.dta
diff --git a/pandas/tests/io/data/stata1_114.dta b/pandas/tests/io/data/stata/stata1_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata1_114.dta
rename to pandas/tests/io/data/stata/stata1_114.dta
diff --git a/pandas/tests/io/data/stata1_117.dta b/pandas/tests/io/data/stata/stata1_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata1_117.dta
rename to pandas/tests/io/data/stata/stata1_117.dta
diff --git a/pandas/tests/io/data/stata/stata1_119.dta.gz b/pandas/tests/io/data/stata/stata1_119.dta.gz
new file mode 100644
index 0000000000000..0f75d8b92db14
Binary files /dev/null and b/pandas/tests/io/data/stata/stata1_119.dta.gz differ
diff --git a/pandas/tests/io/data/stata1_encoding.dta b/pandas/tests/io/data/stata/stata1_encoding.dta
similarity index 100%
rename from pandas/tests/io/data/stata1_encoding.dta
rename to pandas/tests/io/data/stata/stata1_encoding.dta
diff --git a/pandas/tests/io/data/stata1_encoding_118.dta b/pandas/tests/io/data/stata/stata1_encoding_118.dta
similarity index 100%
rename from pandas/tests/io/data/stata1_encoding_118.dta
rename to pandas/tests/io/data/stata/stata1_encoding_118.dta
diff --git a/pandas/tests/io/data/stata2_113.dta b/pandas/tests/io/data/stata/stata2_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata2_113.dta
rename to pandas/tests/io/data/stata/stata2_113.dta
diff --git a/pandas/tests/io/data/stata2_114.dta b/pandas/tests/io/data/stata/stata2_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata2_114.dta
rename to pandas/tests/io/data/stata/stata2_114.dta
diff --git a/pandas/tests/io/data/stata2_115.dta b/pandas/tests/io/data/stata/stata2_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata2_115.dta
rename to pandas/tests/io/data/stata/stata2_115.dta
diff --git a/pandas/tests/io/data/stata2_117.dta b/pandas/tests/io/data/stata/stata2_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata2_117.dta
rename to pandas/tests/io/data/stata/stata2_117.dta
diff --git a/pandas/tests/io/data/stata3.csv b/pandas/tests/io/data/stata/stata3.csv
similarity index 100%
rename from pandas/tests/io/data/stata3.csv
rename to pandas/tests/io/data/stata/stata3.csv
diff --git a/pandas/tests/io/data/stata3_113.dta b/pandas/tests/io/data/stata/stata3_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata3_113.dta
rename to pandas/tests/io/data/stata/stata3_113.dta
diff --git a/pandas/tests/io/data/stata3_114.dta b/pandas/tests/io/data/stata/stata3_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata3_114.dta
rename to pandas/tests/io/data/stata/stata3_114.dta
diff --git a/pandas/tests/io/data/stata3_115.dta b/pandas/tests/io/data/stata/stata3_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata3_115.dta
rename to pandas/tests/io/data/stata/stata3_115.dta
diff --git a/pandas/tests/io/data/stata3_117.dta b/pandas/tests/io/data/stata/stata3_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata3_117.dta
rename to pandas/tests/io/data/stata/stata3_117.dta
diff --git a/pandas/tests/io/data/stata4_113.dta b/pandas/tests/io/data/stata/stata4_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata4_113.dta
rename to pandas/tests/io/data/stata/stata4_113.dta
diff --git a/pandas/tests/io/data/stata4_114.dta b/pandas/tests/io/data/stata/stata4_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata4_114.dta
rename to pandas/tests/io/data/stata/stata4_114.dta
diff --git a/pandas/tests/io/data/stata4_115.dta b/pandas/tests/io/data/stata/stata4_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata4_115.dta
rename to pandas/tests/io/data/stata/stata4_115.dta
diff --git a/pandas/tests/io/data/stata4_117.dta b/pandas/tests/io/data/stata/stata4_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata4_117.dta
rename to pandas/tests/io/data/stata/stata4_117.dta
diff --git a/pandas/tests/io/data/stata5.csv b/pandas/tests/io/data/stata/stata5.csv
similarity index 100%
rename from pandas/tests/io/data/stata5.csv
rename to pandas/tests/io/data/stata/stata5.csv
diff --git a/pandas/tests/io/data/stata5_113.dta b/pandas/tests/io/data/stata/stata5_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata5_113.dta
rename to pandas/tests/io/data/stata/stata5_113.dta
diff --git a/pandas/tests/io/data/stata5_114.dta b/pandas/tests/io/data/stata/stata5_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata5_114.dta
rename to pandas/tests/io/data/stata/stata5_114.dta
diff --git a/pandas/tests/io/data/stata5_115.dta b/pandas/tests/io/data/stata/stata5_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata5_115.dta
rename to pandas/tests/io/data/stata/stata5_115.dta
diff --git a/pandas/tests/io/data/stata5_117.dta b/pandas/tests/io/data/stata/stata5_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata5_117.dta
rename to pandas/tests/io/data/stata/stata5_117.dta
diff --git a/pandas/tests/io/data/stata6.csv b/pandas/tests/io/data/stata/stata6.csv
similarity index 100%
rename from pandas/tests/io/data/stata6.csv
rename to pandas/tests/io/data/stata/stata6.csv
diff --git a/pandas/tests/io/data/stata6_113.dta b/pandas/tests/io/data/stata/stata6_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata6_113.dta
rename to pandas/tests/io/data/stata/stata6_113.dta
diff --git a/pandas/tests/io/data/stata6_114.dta b/pandas/tests/io/data/stata/stata6_114.dta
similarity index 100%
rename from pandas/tests/io/data/stata6_114.dta
rename to pandas/tests/io/data/stata/stata6_114.dta
diff --git a/pandas/tests/io/data/stata6_115.dta b/pandas/tests/io/data/stata/stata6_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata6_115.dta
rename to pandas/tests/io/data/stata/stata6_115.dta
diff --git a/pandas/tests/io/data/stata6_117.dta b/pandas/tests/io/data/stata/stata6_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata6_117.dta
rename to pandas/tests/io/data/stata/stata6_117.dta
diff --git a/pandas/tests/io/data/stata7_111.dta b/pandas/tests/io/data/stata/stata7_111.dta
similarity index 100%
rename from pandas/tests/io/data/stata7_111.dta
rename to pandas/tests/io/data/stata/stata7_111.dta
diff --git a/pandas/tests/io/data/stata7_115.dta b/pandas/tests/io/data/stata/stata7_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata7_115.dta
rename to pandas/tests/io/data/stata/stata7_115.dta
diff --git a/pandas/tests/io/data/stata7_117.dta b/pandas/tests/io/data/stata/stata7_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata7_117.dta
rename to pandas/tests/io/data/stata/stata7_117.dta
diff --git a/pandas/tests/io/data/stata8_113.dta b/pandas/tests/io/data/stata/stata8_113.dta
similarity index 100%
rename from pandas/tests/io/data/stata8_113.dta
rename to pandas/tests/io/data/stata/stata8_113.dta
diff --git a/pandas/tests/io/data/stata8_115.dta b/pandas/tests/io/data/stata/stata8_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata8_115.dta
rename to pandas/tests/io/data/stata/stata8_115.dta
diff --git a/pandas/tests/io/data/stata8_117.dta b/pandas/tests/io/data/stata/stata8_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata8_117.dta
rename to pandas/tests/io/data/stata/stata8_117.dta
diff --git a/pandas/tests/io/data/stata9_115.dta b/pandas/tests/io/data/stata/stata9_115.dta
similarity index 100%
rename from pandas/tests/io/data/stata9_115.dta
rename to pandas/tests/io/data/stata/stata9_115.dta
diff --git a/pandas/tests/io/data/stata9_117.dta b/pandas/tests/io/data/stata/stata9_117.dta
similarity index 100%
rename from pandas/tests/io/data/stata9_117.dta
rename to pandas/tests/io/data/stata/stata9_117.dta
diff --git a/pandas/tests/io/excel/__init__.py b/pandas/tests/io/excel/__init__.py
index e69de29bb2d1d..550172329fc57 100644
--- a/pandas/tests/io/excel/__init__.py
+++ b/pandas/tests/io/excel/__init__.py
@@ -0,0 +1,6 @@
+import pytest
+
+pytestmark = pytest.mark.filterwarnings(
+    # Looks like tree.getiterator is deprecated in favor of tree.iter
+    "ignore:This method will be removed in future versions:PendingDeprecationWarning"
+)
diff --git a/pandas/tests/io/excel/conftest.py b/pandas/tests/io/excel/conftest.py
index 54acd2128369d..0455e0d61ad97 100644
--- a/pandas/tests/io/excel/conftest.py
+++ b/pandas/tests/io/excel/conftest.py
@@ -1,12 +1,17 @@
 import pytest
 
-import pandas.util.testing as tm
+import pandas.util._test_decorators as td
+
+import pandas._testing as tm
 
 from pandas.io.parsers import read_csv
 
 
 @pytest.fixture
 def frame(float_frame):
+    """
+    Returns the first ten items in fixture "float_frame".
+    """
     return float_frame[:10]
 
 
@@ -21,17 +26,40 @@ def merge_cells(request):
 
 
 @pytest.fixture
-def df_ref():
+def df_ref(datapath):
     """
     Obtain the reference data from read_csv with the Python engine.
     """
-    df_ref = read_csv("test1.csv", index_col=0, parse_dates=True, engine="python")
+    filepath = datapath("io", "data", "csv", "test1.csv")
+    df_ref = read_csv(filepath, index_col=0, parse_dates=True, engine="python")
     return df_ref
 
 
-@pytest.fixture(params=[".xls", ".xlsx", ".xlsm", ".ods"])
+@pytest.fixture(params=[".xls", ".xlsx", ".xlsm", ".ods", ".xlsb"])
 def read_ext(request):
     """
     Valid extensions for reading Excel files.
     """
     return request.param
+
+
+@pytest.fixture(autouse=True)
+def check_for_file_leaks():
+    """
+    Fixture to run around every test to ensure that we are not leaking files.
+
+    See also
+    --------
+    _test_decorators.check_file_leaks
+    """
+    # GH#30162
+    psutil = td.safe_import("psutil")
+    if not psutil:
+        yield
+
+    else:
+        proc = psutil.Process()
+        flist = proc.open_files()
+        yield
+        flist2 = proc.open_files()
+        assert flist == flist2
diff --git a/pandas/tests/io/excel/test_odf.py b/pandas/tests/io/excel/test_odf.py
index 76871eddf1cee..b9a3e8b59b133 100644
--- a/pandas/tests/io/excel/test_odf.py
+++ b/pandas/tests/io/excel/test_odf.py
@@ -4,7 +4,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 pytest.importorskip("odf")
 
@@ -13,7 +13,7 @@
 def cd_and_set_engine(monkeypatch, datapath):
     func = functools.partial(pd.read_excel, engine="odf")
     monkeypatch.setattr(pd, "read_excel", func)
-    monkeypatch.chdir(datapath("io", "data"))
+    monkeypatch.chdir(datapath("io", "data", "excel"))
 
 
 def test_read_invalid_types_raises():
@@ -36,3 +36,11 @@ def test_read_writer_table():
     result = pd.read_excel("writertable.odt", "Table1", index_col=0)
 
     tm.assert_frame_equal(result, expected)
+
+
+def test_nonexistent_sheetname_raises(read_ext):
+    # GH-27676
+    # Specifying a non-existent sheet_name parameter should throw an error
+    # with the sheet name.
+    with pytest.raises(ValueError, match="sheet xyz not found"):
+        pd.read_excel("blank.ods", sheet_name="xyz")
diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index 79fc87a62ad08..10ed192062d9c 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -1,7 +1,11 @@
+import os
+
+import numpy as np
 import pytest
 
+import pandas as pd
 from pandas import DataFrame
-from pandas.util.testing import ensure_clean
+import pandas._testing as tm
 
 from pandas.io.excel import ExcelWriter, _OpenpyxlWriter
 
@@ -65,7 +69,7 @@ def test_write_cells_merge_styled(ext):
         )
     ]
 
-    with ensure_clean(ext) as path:
+    with tm.ensure_clean(ext) as path:
         writer = _OpenpyxlWriter(path)
         writer.write_cells(initial_cells, sheet_name=sheet_name)
         writer.write_cells(merge_cells, sheet_name=sheet_name)
@@ -83,7 +87,7 @@ def test_write_cells_merge_styled(ext):
 def test_write_append_mode(ext, mode, expected):
     df = DataFrame([1], columns=["baz"])
 
-    with ensure_clean(ext) as f:
+    with tm.ensure_clean(ext) as f:
         wb = openpyxl.Workbook()
         wb.worksheets[0].title = "foo"
         wb.worksheets[0]["A1"].value = "foo"
@@ -101,3 +105,20 @@ def test_write_append_mode(ext, mode, expected):
 
         for index, cell_value in enumerate(expected):
             assert wb2.worksheets[index]["A1"].value == cell_value
+
+
+def test_to_excel_with_openpyxl_engine(ext, tmpdir):
+    # GH 29854
+    # TODO: Fix this once newer version of openpyxl fixes the bug
+    df1 = DataFrame({"A": np.linspace(1, 10, 10)})
+    df2 = DataFrame({"B": np.linspace(1, 20, 10)})
+    df = pd.concat([df1, df2], axis=1)
+    styled = df.style.applymap(
+        lambda val: "color: %s" % "red" if val < 0 else "black"
+    ).highlight_max()
+
+    filename = tmpdir / "styled.xlsx"
+    styled.to_excel(filename, engine="openpyxl")
+
+    assert filename.exists()
+    os.remove(filename)
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index 5326f2df68972..8d00ef1b7fe3e 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -13,7 +13,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @contextlib.contextmanager
@@ -31,85 +31,123 @@ def ignore_xlrd_time_clock_warning():
         yield
 
 
+read_ext_params = [".xls", ".xlsx", ".xlsm", ".xlsb", ".ods"]
+engine_params = [
+    # Add any engines to test here
+    # When defusedxml is installed it triggers deprecation warnings for
+    # xlrd and openpyxl, so catch those here
+    pytest.param(
+        "xlrd",
+        marks=[
+            td.skip_if_no("xlrd"),
+            pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
+        ],
+    ),
+    pytest.param(
+        "openpyxl",
+        marks=[
+            td.skip_if_no("openpyxl"),
+            pytest.mark.filterwarnings("ignore:.*html argument"),
+        ],
+    ),
+    pytest.param(
+        None,
+        marks=[
+            td.skip_if_no("xlrd"),
+            pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
+        ],
+    ),
+    pytest.param("pyxlsb", marks=td.skip_if_no("pyxlsb")),
+    pytest.param("odf", marks=td.skip_if_no("odf")),
+]
+
+
+def _is_valid_engine_ext_pair(engine, read_ext: str) -> bool:
+    """
+    Filter out invalid (engine, ext) pairs instead of skipping, as that
+    produces 500+ pytest.skips.
+    """
+    engine = engine.values[0]
+    if engine == "openpyxl" and read_ext == ".xls":
+        return False
+    if engine == "odf" and read_ext != ".ods":
+        return False
+    if read_ext == ".ods" and engine != "odf":
+        return False
+    if engine == "pyxlsb" and read_ext != ".xlsb":
+        return False
+    if read_ext == ".xlsb" and engine != "pyxlsb":
+        return False
+    return True
+
+
+def _transfer_marks(engine, read_ext):
+    """
+    engine gives us a pytest.param objec with some marks, read_ext is just
+    a string.  We need to generate a new pytest.param inheriting the marks.
+    """
+    values = engine.values + (read_ext,)
+    new_param = pytest.param(values, marks=engine.marks)
+    return new_param
+
+
 @pytest.fixture(
+    autouse=True,
     params=[
-        # Add any engines to test here
-        # When defusedxml is installed it triggers deprecation warnings for
-        # xlrd and openpyxl, so catch those here
-        pytest.param(
-            "xlrd",
-            marks=[
-                td.skip_if_no("xlrd"),
-                pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
-            ],
-        ),
-        pytest.param(
-            "openpyxl",
-            marks=[
-                td.skip_if_no("openpyxl"),
-                pytest.mark.filterwarnings("ignore:.*html argument"),
-            ],
-        ),
-        pytest.param(
-            None,
-            marks=[
-                td.skip_if_no("xlrd"),
-                pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
-            ],
-        ),
-        pytest.param("odf", marks=td.skip_if_no("odf")),
-    ]
+        _transfer_marks(eng, ext)
+        for eng in engine_params
+        for ext in read_ext_params
+        if _is_valid_engine_ext_pair(eng, ext)
+    ],
 )
-def engine(request):
+def engine_and_read_ext(request):
     """
-    A fixture for Excel reader engines.
+    Fixture for Excel reader engine and read_ext, only including valid pairs.
     """
     return request.param
 
 
+@pytest.fixture
+def engine(engine_and_read_ext):
+    engine, read_ext = engine_and_read_ext
+    return engine
+
+
+@pytest.fixture
+def read_ext(engine_and_read_ext):
+    engine, read_ext = engine_and_read_ext
+    return read_ext
+
+
 class TestReaders:
     @pytest.fixture(autouse=True)
-    def cd_and_set_engine(self, engine, datapath, monkeypatch, read_ext):
+    def cd_and_set_engine(self, engine, datapath, monkeypatch):
         """
         Change directory and set engine for read_excel calls.
         """
-        if engine == "openpyxl" and read_ext == ".xls":
-            pytest.skip()
-        if engine == "odf" and read_ext != ".ods":
-            pytest.skip()
-        if read_ext == ".ods" and engine != "odf":
-            pytest.skip()
-
         func = partial(pd.read_excel, engine=engine)
-        monkeypatch.chdir(datapath("io", "data"))
+        monkeypatch.chdir(datapath("io", "data", "excel"))
         monkeypatch.setattr(pd, "read_excel", func)
 
     def test_usecols_int(self, read_ext, df_ref):
         df_ref = df_ref.reindex(columns=["A", "B", "C"])
 
         # usecols as int
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
+        msg = "Passing an integer for `usecols`"
+        with pytest.raises(ValueError, match=msg):
             with ignore_xlrd_time_clock_warning():
-                df1 = pd.read_excel(
-                    "test1" + read_ext, "Sheet1", index_col=0, usecols=3
-                )
+                pd.read_excel("test1" + read_ext, "Sheet1", index_col=0, usecols=3)
 
         # usecols as int
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
+        with pytest.raises(ValueError, match=msg):
             with ignore_xlrd_time_clock_warning():
-                df2 = pd.read_excel(
+                pd.read_excel(
                     "test1" + read_ext, "Sheet2", skiprows=[1], index_col=0, usecols=3
                 )
 
-        # TODO add index to xls file)
-        tm.assert_frame_equal(df1, df_ref, check_names=False)
-        tm.assert_frame_equal(df2, df_ref, check_names=False)
-
     def test_usecols_list(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         df_ref = df_ref.reindex(columns=["B", "C"])
         df1 = pd.read_excel(
@@ -124,6 +162,8 @@ def test_usecols_list(self, read_ext, df_ref):
         tm.assert_frame_equal(df2, df_ref, check_names=False)
 
     def test_usecols_str(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         df1 = df_ref.reindex(columns=["A", "B", "C"])
         df2 = pd.read_excel("test1" + read_ext, "Sheet1", index_col=0, usecols="A:D")
@@ -156,6 +196,9 @@ def test_usecols_str(self, read_ext, df_ref):
         "usecols", [[0, 1, 3], [0, 3, 1], [1, 0, 3], [1, 3, 0], [3, 0, 1], [3, 1, 0]]
     )
     def test_usecols_diff_positional_int_columns_order(self, read_ext, usecols, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         expected = df_ref[["A", "C"]]
         result = pd.read_excel(
             "test1" + read_ext, "Sheet1", index_col=0, usecols=usecols
@@ -171,11 +214,17 @@ def test_usecols_diff_positional_str_columns_order(self, read_ext, usecols, df_r
         tm.assert_frame_equal(result, expected, check_names=False)
 
     def test_read_excel_without_slicing(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         expected = df_ref
         result = pd.read_excel("test1" + read_ext, "Sheet1", index_col=0)
         tm.assert_frame_equal(result, expected, check_names=False)
 
     def test_usecols_excel_range_str(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         expected = df_ref[["C", "D"]]
         result = pd.read_excel(
             "test1" + read_ext, "Sheet1", index_col=0, usecols="A,D:E"
@@ -242,12 +291,16 @@ def test_excel_stop_iterator(self, read_ext):
         tm.assert_frame_equal(parsed, expected)
 
     def test_excel_cell_error_na(self, read_ext):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         parsed = pd.read_excel("test3" + read_ext, "Sheet1")
         expected = DataFrame([[np.nan]], columns=["Test"])
         tm.assert_frame_equal(parsed, expected)
 
     def test_excel_table(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         df1 = pd.read_excel("test1" + read_ext, "Sheet1", index_col=0)
         df2 = pd.read_excel("test1" + read_ext, "Sheet2", skiprows=[1], index_col=0)
@@ -259,6 +312,8 @@ def test_excel_table(self, read_ext, df_ref):
         tm.assert_frame_equal(df3, df1.iloc[:-1])
 
     def test_reader_special_dtypes(self, read_ext):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         expected = DataFrame.from_dict(
             OrderedDict(
@@ -456,6 +511,9 @@ def test_read_excel_blank_with_header(self, read_ext):
 
     def test_date_conversion_overflow(self, read_ext):
         # GH 10001 : pandas.ExcelFile ignore parse_dates=False
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         expected = pd.DataFrame(
             [
                 [pd.Timestamp("2016-03-12"), "Marc Johnson"],
@@ -472,9 +530,14 @@ def test_date_conversion_overflow(self, read_ext):
         tm.assert_frame_equal(result, expected)
 
     def test_sheet_name(self, read_ext, df_ref):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
         filename = "test1"
         sheet_name = "Sheet1"
 
+        if pd.read_excel.keywords["engine"] == "openpyxl":
+            pytest.xfail("Maybe not supported by openpyxl")
+
         df1 = pd.read_excel(
             filename + read_ext, sheet_name=sheet_name, index_col=0
         )  # doc
@@ -499,12 +562,9 @@ def test_bad_engine_raises(self, read_ext):
 
     @tm.network
     def test_read_from_http_url(self, read_ext):
-        if read_ext == ".ods":  # TODO: remove once on master
-            pytest.skip()
-
         url = (
-            "https://raw.github.com/pandas-dev/pandas/master/"
-            "pandas/tests/io/data/test1" + read_ext
+            "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+            "pandas/tests/io/data/excel/test1" + read_ext
         )
         url_table = pd.read_excel(url)
         local_table = pd.read_excel("test1" + read_ext)
@@ -527,7 +587,7 @@ def test_read_from_s3_url(self, read_ext, s3_resource):
     def test_read_from_file_url(self, read_ext, datapath):
 
         # FILE
-        localtable = os.path.join(datapath("io", "data"), "test1" + read_ext)
+        localtable = os.path.join(datapath("io", "data", "excel"), "test1" + read_ext)
         local_table = pd.read_excel(localtable)
 
         try:
@@ -554,6 +614,7 @@ def test_read_from_pathlib_path(self, read_ext):
         tm.assert_frame_equal(expected, actual)
 
     @td.skip_if_no("py.path")
+    @td.check_file_leaks
     def test_read_from_py_localpath(self, read_ext):
 
         # GH12655
@@ -568,6 +629,8 @@ def test_read_from_py_localpath(self, read_ext):
         tm.assert_frame_equal(expected, actual)
 
     def test_reader_seconds(self, read_ext):
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         # Test reading times with and without milliseconds. GH5945.
         expected = DataFrame.from_dict(
@@ -596,6 +659,9 @@ def test_reader_seconds(self, read_ext):
 
     def test_read_excel_multiindex(self, read_ext):
         # see gh-4679
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         mi = MultiIndex.from_product([["foo", "bar"], ["a", "b"]])
         mi_file = "testmultiindex" + read_ext
 
@@ -755,6 +821,9 @@ def test_read_excel_chunksize(self, read_ext):
 
     def test_read_excel_skiprows_list(self, read_ext):
         # GH 4903
+        if pd.read_excel.keywords["engine"] == "pyxlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         actual = pd.read_excel(
             "testskiprows" + read_ext, "skiprows_list", skiprows=[0, 2]
         )
@@ -816,23 +885,15 @@ def test_read_excel_squeeze(self, read_ext):
 
 class TestExcelFileRead:
     @pytest.fixture(autouse=True)
-    def cd_and_set_engine(self, engine, datapath, monkeypatch, read_ext):
+    def cd_and_set_engine(self, engine, datapath, monkeypatch):
         """
         Change directory and set engine for ExcelFile objects.
         """
-        if engine == "odf" and read_ext != ".ods":
-            pytest.skip()
-        if read_ext == ".ods" and engine != "odf":
-            pytest.skip()
-        if engine == "openpyxl" and read_ext == ".xls":
-            pytest.skip()
-
         func = partial(pd.ExcelFile, engine=engine)
-        monkeypatch.chdir(datapath("io", "data"))
+        monkeypatch.chdir(datapath("io", "data", "excel"))
         monkeypatch.setattr(pd, "ExcelFile", func)
 
     def test_excel_passes_na(self, read_ext):
-
         with pd.ExcelFile("test4" + read_ext) as excel:
             parsed = pd.read_excel(
                 excel, "Sheet1", keep_default_na=False, na_values=["apple"]
@@ -870,17 +931,43 @@ def test_excel_passes_na(self, read_ext):
         )
         tm.assert_frame_equal(parsed, expected)
 
+    @pytest.mark.parametrize("na_filter", [None, True, False])
+    def test_excel_passes_na_filter(self, read_ext, na_filter):
+        # gh-25453
+        kwargs = {}
+
+        if na_filter is not None:
+            kwargs["na_filter"] = na_filter
+
+        with pd.ExcelFile("test5" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel, "Sheet1", keep_default_na=True, na_values=["apple"], **kwargs
+            )
+
+        if na_filter is False:
+            expected = [["1.#QNAN"], [1], ["nan"], ["apple"], ["rabbit"]]
+        else:
+            expected = [[np.nan], [1], [np.nan], [np.nan], ["rabbit"]]
+
+        expected = DataFrame(expected, columns=["Test"])
+        tm.assert_frame_equal(parsed, expected)
+
     @pytest.mark.parametrize("arg", ["sheet", "sheetname", "parse_cols"])
+    @td.check_file_leaks
     def test_unexpected_kwargs_raises(self, read_ext, arg):
         # gh-17964
         kwarg = {arg: "Sheet1"}
-        msg = "unexpected keyword argument `{}`".format(arg)
+        msg = r"unexpected keyword argument `{}`".format(arg)
 
         with pd.ExcelFile("test1" + read_ext) as excel:
             with pytest.raises(TypeError, match=msg):
                 pd.read_excel(excel, **kwarg)
 
     def test_excel_table_sheet_by_index(self, read_ext, df_ref):
+        # For some reason pd.read_excel has no attribute 'keywords' here.
+        # Skipping based on read_ext instead.
+        if read_ext == ".xlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
 
         with pd.ExcelFile("test1" + read_ext) as excel:
             df1 = pd.read_excel(excel, 0, index_col=0)
@@ -898,20 +985,17 @@ def test_excel_table_sheet_by_index(self, read_ext, df_ref):
             df3 = pd.read_excel(excel, 0, index_col=0, skipfooter=1)
         tm.assert_frame_equal(df3, df1.iloc[:-1])
 
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
-            with pd.ExcelFile("test1" + read_ext) as excel:
-                df4 = pd.read_excel(excel, 0, index_col=0, skip_footer=1)
-
-            tm.assert_frame_equal(df3, df4)
-
         with pd.ExcelFile("test1" + read_ext) as excel:
             df3 = excel.parse(0, index_col=0, skipfooter=1)
 
         tm.assert_frame_equal(df3, df1.iloc[:-1])
 
     def test_sheet_name(self, read_ext, df_ref):
+        # For some reason pd.read_excel has no attribute 'keywords' here.
+        # Skipping based on read_ext instead.
+        if read_ext == ".xlsb":
+            pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
+
         filename = "test1"
         sheet_name = "Sheet1"
 
@@ -949,3 +1033,13 @@ def test_conflicting_excel_engines(self, read_ext):
         with pd.ExcelFile("test1" + read_ext) as xl:
             with pytest.raises(ValueError, match=msg):
                 pd.read_excel(xl, engine="foo")
+
+    def test_excel_read_binary(self, engine, read_ext):
+        # GH 15914
+        expected = pd.read_excel("test1" + read_ext, engine=engine)
+
+        with open("test1" + read_ext, "rb") as f:
+            data = f.read()
+
+        actual = pd.read_excel(data, engine=engine)
+        tm.assert_frame_equal(expected, actual)
diff --git a/pandas/tests/io/excel/test_style.py b/pandas/tests/io/excel/test_style.py
index 8862f85ae9ab4..88f4c3736bc0d 100644
--- a/pandas/tests/io/excel/test_style.py
+++ b/pandas/tests/io/excel/test_style.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame
-from pandas.util.testing import ensure_clean
+import pandas._testing as tm
 
 from pandas.io.excel import ExcelWriter
 from pandas.io.formats.excel import ExcelFormatter
@@ -70,7 +70,7 @@ def custom_converter(css):
     # Prepare spreadsheets
 
     df = DataFrame(np.random.randn(11, 3))
-    with ensure_clean(".xlsx" if engine != "xlwt" else ".xls") as path:
+    with tm.ensure_clean(".xlsx" if engine != "xlwt" else ".xls") as path:
         writer = ExcelWriter(path, engine=engine)
         df.to_excel(writer, sheet_name="frame")
         df.style.to_excel(writer, sheet_name="unstyled")
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 8ad09549f3cbe..91665a24fc4c5 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -4,16 +4,13 @@
 import os
 
 import numpy as np
-from numpy import nan
 import pytest
 
-from pandas.compat import PY36
 import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, get_option, set_option
-import pandas.util.testing as tm
-from pandas.util.testing import ensure_clean, makeCustomDataframe as mkdf
+import pandas._testing as tm
 
 from pandas.io.excel import (
     ExcelFile,
@@ -25,6 +22,32 @@
 )
 
 
+@pytest.fixture
+def path(ext):
+    """
+    Fixture to open file for use in each test case.
+    """
+    with tm.ensure_clean(ext) as file_path:
+        yield file_path
+
+
+@pytest.fixture
+def set_engine(engine, ext):
+    """
+    Fixture to set engine for use in each test case.
+
+    Rather than requiring `engine=...` to be provided explicitly as an
+    argument in each test, this fixture sets a global option to dictate
+    which engine should be used to write Excel files. After executing
+    the test it rolls back said change to the global option.
+    """
+    option_name = "io.excel.{ext}.writer".format(ext=ext.strip("."))
+    prev_engine = get_option(option_name)
+    set_option(option_name, engine)
+    yield
+    set_option(option_name, prev_engine)  # Roll back option change
+
+
 @td.skip_if_no("xlrd")
 @pytest.mark.parametrize("ext", [".xls", ".xlsx", ".xlsm"])
 class TestRoundTrip:
@@ -39,7 +62,7 @@ def test_read_one_empty_col_no_header(self, ext, header, expected):
         filename = "no_header"
         df = pd.DataFrame([["", 1, 100], ["", 2, 200], ["", 3, 300], ["", 4, 400]])
 
-        with ensure_clean(ext) as path:
+        with tm.ensure_clean(ext) as path:
             df.to_excel(path, filename, index=False, header=False)
             result = pd.read_excel(path, filename, usecols=[0], header=header)
 
@@ -55,7 +78,7 @@ def test_read_one_empty_col_with_header(self, ext, header, expected):
         filename = "with_header"
         df = pd.DataFrame([["", 1, 100], ["", 2, 200], ["", 3, 300], ["", 4, 400]])
 
-        with ensure_clean(ext) as path:
+        with tm.ensure_clean(ext) as path:
             df.to_excel(path, "with_header", index=False, header=True)
             result = pd.read_excel(path, filename, usecols=[0], header=header)
 
@@ -68,7 +91,7 @@ def test_set_column_names_in_parameter(self, ext):
         # keyword argument names
         refdf = pd.DataFrame([[1, "foo"], [2, "bar"], [3, "baz"]], columns=["a", "b"])
 
-        with ensure_clean(ext) as pth:
+        with tm.ensure_clean(ext) as pth:
             with ExcelWriter(pth) as writer:
                 refdf.to_excel(writer, "Data_no_head", header=False, index=False)
                 refdf.to_excel(writer, "Data_with_head", index=False)
@@ -102,7 +125,7 @@ def tdf(col_sheet_name):
         dfs = [tdf(s) for s in sheets]
         dfs = dict(zip(sheets, dfs))
 
-        with ensure_clean(ext) as pth:
+        with tm.ensure_clean(ext) as pth:
             with ExcelWriter(pth) as ew:
                 for sheetname, df in dfs.items():
                     df.to_excel(ew, sheetname)
@@ -115,7 +138,7 @@ def tdf(col_sheet_name):
     @td.skip_if_no("xlsxwriter")
     def test_read_excel_multiindex_empty_level(self, ext):
         # see gh-12453
-        with ensure_clean(ext) as path:
+        with tm.ensure_clean(ext) as path:
             df = DataFrame(
                 {
                     ("One", "x"): {0: 1},
@@ -169,7 +192,7 @@ def test_excel_multindex_roundtrip(
         self, ext, c_idx_names, r_idx_names, c_idx_levels, r_idx_levels
     ):
         # see gh-4679
-        with ensure_clean(ext) as pth:
+        with tm.ensure_clean(ext) as pth:
             if c_idx_levels == 1 and c_idx_names:
                 pytest.skip(
                     "Column index name cannot be serialized unless it's a MultiIndex"
@@ -179,7 +202,9 @@ def test_excel_multindex_roundtrip(
             # unnamed levels, not Nones.
             check_names = r_idx_names or r_idx_levels <= 1
 
-            df = mkdf(5, 5, c_idx_names, r_idx_names, c_idx_levels, r_idx_levels)
+            df = tm.makeCustomDataframe(
+                5, 5, c_idx_names, r_idx_names, c_idx_levels, r_idx_levels
+            )
             df.to_excel(pth)
 
             act = pd.read_excel(
@@ -218,7 +243,7 @@ def test_read_excel_parse_dates(self, ext):
         df2 = df.copy()
         df2["date_strings"] = df2["date_strings"].dt.strftime("%m/%d/%Y")
 
-        with ensure_clean(ext) as pth:
+        with tm.ensure_clean(ext) as pth:
             df2.to_excel(pth)
 
             res = pd.read_excel(pth, index_col=0)
@@ -227,39 +252,41 @@ def test_read_excel_parse_dates(self, ext):
             res = pd.read_excel(pth, parse_dates=["date_strings"], index_col=0)
             tm.assert_frame_equal(df, res)
 
-            date_parser = lambda x: pd.datetime.strptime(x, "%m/%d/%Y")
+            date_parser = lambda x: datetime.strptime(x, "%m/%d/%Y")
             res = pd.read_excel(
                 pth, parse_dates=["date_strings"], date_parser=date_parser, index_col=0
             )
             tm.assert_frame_equal(df, res)
 
-
-class _WriterBase:
-    @pytest.fixture(autouse=True)
-    def set_engine_and_path(self, engine, ext):
-        """Fixture to set engine and open file for use in each test case
-
-        Rather than requiring `engine=...` to be provided explicitly as an
-        argument in each test, this fixture sets a global option to dictate
-        which engine should be used to write Excel files. After executing
-        the test it rolls back said change to the global option.
-
-        It also uses a context manager to open a temporary excel file for
-        the function to write to, accessible via `self.path`
-
-        Notes
-        -----
-        This fixture will run as part of each test method defined in the
-        class and any subclasses, on account of the `autouse=True`
-        argument
-        """
-        option_name = "io.excel.{ext}.writer".format(ext=ext.strip("."))
-        prev_engine = get_option(option_name)
-        set_option(option_name, engine)
-        with ensure_clean(ext) as path:
-            self.path = path
-            yield
-        set_option(option_name, prev_engine)  # Roll back option change
+    def test_multiindex_interval_datetimes(self, ext):
+        # GH 30986
+        midx = pd.MultiIndex.from_arrays(
+            [
+                range(4),
+                pd.interval_range(
+                    start=pd.Timestamp("2020-01-01"), periods=4, freq="6M"
+                ),
+            ]
+        )
+        df = pd.DataFrame(range(4), index=midx)
+        with tm.ensure_clean(ext) as pth:
+            df.to_excel(pth)
+            result = pd.read_excel(pth, index_col=[0, 1])
+        expected = pd.DataFrame(
+            range(4),
+            pd.MultiIndex.from_arrays(
+                [
+                    range(4),
+                    [
+                        "(2020-01-31, 2020-07-31]",
+                        "(2020-07-31, 2021-01-31]",
+                        "(2021-01-31, 2021-07-31]",
+                        "(2021-07-31, 2022-01-31]",
+                    ],
+                ]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
 
 
 @td.skip_if_no("xlrd")
@@ -272,10 +299,9 @@ class and any subclasses, on account of the `autouse=True`
         pytest.param("xlsxwriter", ".xlsx", marks=td.skip_if_no("xlsxwriter")),
     ],
 )
-class TestExcelWriter(_WriterBase):
-    # Base class for test cases to run with different Excel writers.
-
-    def test_excel_sheet_size(self, engine, ext):
+@pytest.mark.usefixtures("set_engine")
+class TestExcelWriter:
+    def test_excel_sheet_size(self, path):
 
         # GH 26080
         breaking_row_count = 2 ** 20 + 1
@@ -288,18 +314,18 @@ def test_excel_sheet_size(self, engine, ext):
 
         msg = "sheet is too large"
         with pytest.raises(ValueError, match=msg):
-            row_df.to_excel(self.path)
+            row_df.to_excel(path)
 
         with pytest.raises(ValueError, match=msg):
-            col_df.to_excel(self.path)
+            col_df.to_excel(path)
 
-    def test_excel_sheet_by_name_raise(self, engine, ext):
+    def test_excel_sheet_by_name_raise(self, path):
         import xlrd
 
         gt = DataFrame(np.random.randn(10, 2))
-        gt.to_excel(self.path)
+        gt.to_excel(path)
 
-        xl = ExcelFile(self.path)
+        xl = ExcelFile(path)
         df = pd.read_excel(xl, 0, index_col=0)
 
         tm.assert_frame_equal(gt, df)
@@ -307,162 +333,162 @@ def test_excel_sheet_by_name_raise(self, engine, ext):
         with pytest.raises(xlrd.XLRDError):
             pd.read_excel(xl, "0")
 
-    def test_excel_writer_context_manager(self, frame, engine, ext):
-        with ExcelWriter(self.path) as writer:
+    def test_excel_writer_context_manager(self, frame, path):
+        with ExcelWriter(path) as writer:
             frame.to_excel(writer, "Data1")
             frame2 = frame.copy()
             frame2.columns = frame.columns[::-1]
             frame2.to_excel(writer, "Data2")
 
-        with ExcelFile(self.path) as reader:
+        with ExcelFile(path) as reader:
             found_df = pd.read_excel(reader, "Data1", index_col=0)
             found_df2 = pd.read_excel(reader, "Data2", index_col=0)
 
             tm.assert_frame_equal(found_df, frame)
             tm.assert_frame_equal(found_df2, frame2)
 
-    def test_roundtrip(self, engine, ext, frame):
+    def test_roundtrip(self, frame, path):
         frame = frame.copy()
-        frame["A"][:5] = nan
+        frame["A"][:5] = np.nan
 
-        frame.to_excel(self.path, "test1")
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", index=False)
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
 
         # test roundtrip
-        frame.to_excel(self.path, "test1")
-        recons = pd.read_excel(self.path, "test1", index_col=0)
+        frame.to_excel(path, "test1")
+        recons = pd.read_excel(path, "test1", index_col=0)
         tm.assert_frame_equal(frame, recons)
 
-        frame.to_excel(self.path, "test1", index=False)
-        recons = pd.read_excel(self.path, "test1", index_col=None)
+        frame.to_excel(path, "test1", index=False)
+        recons = pd.read_excel(path, "test1", index_col=None)
         recons.index = frame.index
         tm.assert_frame_equal(frame, recons)
 
-        frame.to_excel(self.path, "test1", na_rep="NA")
-        recons = pd.read_excel(self.path, "test1", index_col=0, na_values=["NA"])
+        frame.to_excel(path, "test1", na_rep="NA")
+        recons = pd.read_excel(path, "test1", index_col=0, na_values=["NA"])
         tm.assert_frame_equal(frame, recons)
 
         # GH 3611
-        frame.to_excel(self.path, "test1", na_rep="88")
-        recons = pd.read_excel(self.path, "test1", index_col=0, na_values=["88"])
+        frame.to_excel(path, "test1", na_rep="88")
+        recons = pd.read_excel(path, "test1", index_col=0, na_values=["88"])
         tm.assert_frame_equal(frame, recons)
 
-        frame.to_excel(self.path, "test1", na_rep="88")
-        recons = pd.read_excel(self.path, "test1", index_col=0, na_values=[88, 88.0])
+        frame.to_excel(path, "test1", na_rep="88")
+        recons = pd.read_excel(path, "test1", index_col=0, na_values=[88, 88.0])
         tm.assert_frame_equal(frame, recons)
 
         # GH 6573
-        frame.to_excel(self.path, "Sheet1")
-        recons = pd.read_excel(self.path, index_col=0)
+        frame.to_excel(path, "Sheet1")
+        recons = pd.read_excel(path, index_col=0)
         tm.assert_frame_equal(frame, recons)
 
-        frame.to_excel(self.path, "0")
-        recons = pd.read_excel(self.path, index_col=0)
+        frame.to_excel(path, "0")
+        recons = pd.read_excel(path, index_col=0)
         tm.assert_frame_equal(frame, recons)
 
         # GH 8825 Pandas Series should provide to_excel method
         s = frame["A"]
-        s.to_excel(self.path)
-        recons = pd.read_excel(self.path, index_col=0)
+        s.to_excel(path)
+        recons = pd.read_excel(path, index_col=0)
         tm.assert_frame_equal(s.to_frame(), recons)
 
-    def test_mixed(self, engine, ext, frame):
+    def test_mixed(self, frame, path):
         mixed_frame = frame.copy()
         mixed_frame["foo"] = "bar"
 
-        mixed_frame.to_excel(self.path, "test1")
-        reader = ExcelFile(self.path)
+        mixed_frame.to_excel(path, "test1")
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(mixed_frame, recons)
 
-    def test_ts_frame(self, tsframe, engine, ext):
+    def test_ts_frame(self, tsframe, path):
         df = tsframe
 
-        df.to_excel(self.path, "test1")
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1")
+        reader = ExcelFile(path)
 
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(df, recons)
 
-    def test_basics_with_nan(self, engine, ext, frame):
+    def test_basics_with_nan(self, frame, path):
         frame = frame.copy()
-        frame["A"][:5] = nan
-        frame.to_excel(self.path, "test1")
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", index=False)
+        frame["A"][:5] = np.nan
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
 
     @pytest.mark.parametrize("np_type", [np.int8, np.int16, np.int32, np.int64])
-    def test_int_types(self, engine, ext, np_type):
+    def test_int_types(self, np_type, path):
         # Test np.int values read come back as int
         # (rather than float which is Excel's format).
         df = DataFrame(np.random.randint(-10, 10, size=(10, 2)), dtype=np_type)
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0)
 
         int_frame = df.astype(np.int64)
         tm.assert_frame_equal(int_frame, recons)
 
-        recons2 = pd.read_excel(self.path, "test1", index_col=0)
+        recons2 = pd.read_excel(path, "test1", index_col=0)
         tm.assert_frame_equal(int_frame, recons2)
 
         # Test with convert_float=False comes back as float.
         float_frame = df.astype(float)
-        recons = pd.read_excel(self.path, "test1", convert_float=False, index_col=0)
+        recons = pd.read_excel(path, "test1", convert_float=False, index_col=0)
         tm.assert_frame_equal(
             recons, float_frame, check_index_type=False, check_column_type=False
         )
 
     @pytest.mark.parametrize("np_type", [np.float16, np.float32, np.float64])
-    def test_float_types(self, engine, ext, np_type):
+    def test_float_types(self, np_type, path):
         # Test np.float values read come back as float.
         df = DataFrame(np.random.random_sample(10), dtype=np_type)
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0).astype(np_type)
 
         tm.assert_frame_equal(df, recons, check_dtype=False)
 
     @pytest.mark.parametrize("np_type", [np.bool8, np.bool_])
-    def test_bool_types(self, engine, ext, np_type):
+    def test_bool_types(self, np_type, path):
         # Test np.bool values read come back as float.
         df = DataFrame([1, 0, True, False], dtype=np_type)
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0).astype(np_type)
 
         tm.assert_frame_equal(df, recons)
 
-    def test_inf_roundtrip(self, engine, ext):
+    def test_inf_roundtrip(self, path):
         df = DataFrame([(1, np.inf), (2, 3), (5, -np.inf)])
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0)
 
         tm.assert_frame_equal(df, recons)
 
-    def test_sheets(self, engine, ext, frame, tsframe):
+    def test_sheets(self, frame, tsframe, path):
         frame = frame.copy()
-        frame["A"][:5] = nan
+        frame["A"][:5] = np.nan
 
-        frame.to_excel(self.path, "test1")
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", index=False)
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
 
         # Test writing to separate sheets
-        writer = ExcelWriter(self.path)
+        writer = ExcelWriter(path)
         frame.to_excel(writer, "test1")
         tsframe.to_excel(writer, "test2")
         writer.save()
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(frame, recons)
         recons = pd.read_excel(reader, "test2", index_col=0)
@@ -471,62 +497,62 @@ def test_sheets(self, engine, ext, frame, tsframe):
         assert "test1" == reader.sheet_names[0]
         assert "test2" == reader.sheet_names[1]
 
-    def test_colaliases(self, engine, ext, frame):
+    def test_colaliases(self, frame, path):
         frame = frame.copy()
-        frame["A"][:5] = nan
+        frame["A"][:5] = np.nan
 
-        frame.to_excel(self.path, "test1")
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", index=False)
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
 
         # column aliases
         col_aliases = Index(["AA", "X", "Y", "Z"])
-        frame.to_excel(self.path, "test1", header=col_aliases)
-        reader = ExcelFile(self.path)
+        frame.to_excel(path, "test1", header=col_aliases)
+        reader = ExcelFile(path)
         rs = pd.read_excel(reader, "test1", index_col=0)
         xp = frame.copy()
         xp.columns = col_aliases
         tm.assert_frame_equal(xp, rs)
 
-    def test_roundtrip_indexlabels(self, merge_cells, engine, ext, frame):
+    def test_roundtrip_indexlabels(self, merge_cells, frame, path):
         frame = frame.copy()
-        frame["A"][:5] = nan
+        frame["A"][:5] = np.nan
 
-        frame.to_excel(self.path, "test1")
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", index=False)
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
 
         # test index_label
         df = DataFrame(np.random.randn(10, 2)) >= 0
-        df.to_excel(self.path, "test1", index_label=["test"], merge_cells=merge_cells)
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1", index_label=["test"], merge_cells=merge_cells)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0).astype(np.int64)
         df.index.names = ["test"]
         assert df.index.names == recons.index.names
 
         df = DataFrame(np.random.randn(10, 2)) >= 0
         df.to_excel(
-            self.path,
+            path,
             "test1",
             index_label=["test", "dummy", "dummy2"],
             merge_cells=merge_cells,
         )
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0).astype(np.int64)
         df.index.names = ["test"]
         assert df.index.names == recons.index.names
 
         df = DataFrame(np.random.randn(10, 2)) >= 0
-        df.to_excel(self.path, "test1", index_label="test", merge_cells=merge_cells)
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1", index_label="test", merge_cells=merge_cells)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0).astype(np.int64)
         df.index.names = ["test"]
         tm.assert_frame_equal(df, recons.astype(bool))
 
         frame.to_excel(
-            self.path,
+            path,
             "test1",
             columns=["A", "B", "C", "D"],
             index=False,
@@ -536,35 +562,35 @@ def test_roundtrip_indexlabels(self, merge_cells, engine, ext, frame):
         df = frame.copy()
         df = df.set_index(["A", "B"])
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=[0, 1])
         tm.assert_frame_equal(df, recons, check_less_precise=True)
 
-    def test_excel_roundtrip_indexname(self, merge_cells, engine, ext):
+    def test_excel_roundtrip_indexname(self, merge_cells, path):
         df = DataFrame(np.random.randn(10, 4))
         df.index.name = "foo"
 
-        df.to_excel(self.path, merge_cells=merge_cells)
+        df.to_excel(path, merge_cells=merge_cells)
 
-        xf = ExcelFile(self.path)
+        xf = ExcelFile(path)
         result = pd.read_excel(xf, xf.sheet_names[0], index_col=0)
 
         tm.assert_frame_equal(result, df)
         assert result.index.name == "foo"
 
-    def test_excel_roundtrip_datetime(self, merge_cells, tsframe, engine, ext):
+    def test_excel_roundtrip_datetime(self, merge_cells, tsframe, path):
         # datetime.date, not sure what to test here exactly
         tsf = tsframe.copy()
 
         tsf.index = [x.date() for x in tsframe.index]
-        tsf.to_excel(self.path, "test1", merge_cells=merge_cells)
+        tsf.to_excel(path, "test1", merge_cells=merge_cells)
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=0)
 
         tm.assert_frame_equal(tsframe, recons)
 
-    def test_excel_date_datetime_format(self, engine, ext):
+    def test_excel_date_datetime_format(self, engine, ext, path):
         # see gh-4133
         #
         # Excel output format strings
@@ -585,8 +611,8 @@ def test_excel_date_datetime_format(self, engine, ext):
             columns=["X", "Y"],
         )
 
-        with ensure_clean(ext) as filename2:
-            writer1 = ExcelWriter(self.path)
+        with tm.ensure_clean(ext) as filename2:
+            writer1 = ExcelWriter(path)
             writer2 = ExcelWriter(
                 filename2,
                 date_format="DD.MM.YYYY",
@@ -599,7 +625,7 @@ def test_excel_date_datetime_format(self, engine, ext):
             writer1.close()
             writer2.close()
 
-            reader1 = ExcelFile(self.path)
+            reader1 = ExcelFile(path)
             reader2 = ExcelFile(filename2)
 
             rs1 = pd.read_excel(reader1, "test1", index_col=0)
@@ -611,7 +637,7 @@ def test_excel_date_datetime_format(self, engine, ext):
             # we need to use df_expected to check the result.
             tm.assert_frame_equal(rs2, df_expected)
 
-    def test_to_excel_interval_no_labels(self, engine, ext):
+    def test_to_excel_interval_no_labels(self, path):
         # see gh-19242
         #
         # Test writing Interval without labels.
@@ -621,13 +647,13 @@ def test_to_excel_interval_no_labels(self, engine, ext):
         df["new"] = pd.cut(df[0], 10)
         expected["new"] = pd.cut(expected[0], 10).astype(str)
 
-        df.to_excel(self.path, "test1")
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1")
+        reader = ExcelFile(path)
 
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(expected, recons)
 
-    def test_to_excel_interval_labels(self, engine, ext):
+    def test_to_excel_interval_labels(self, path):
         # see gh-19242
         #
         # Test writing Interval with labels.
@@ -639,13 +665,13 @@ def test_to_excel_interval_labels(self, engine, ext):
         df["new"] = intervals
         expected["new"] = pd.Series(list(intervals))
 
-        df.to_excel(self.path, "test1")
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1")
+        reader = ExcelFile(path)
 
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(expected, recons)
 
-    def test_to_excel_timedelta(self, engine, ext):
+    def test_to_excel_timedelta(self, path):
         # see gh-19242, gh-9155
         #
         # Test writing timedelta to xls.
@@ -659,50 +685,50 @@ def test_to_excel_timedelta(self, engine, ext):
             lambda x: timedelta(seconds=x).total_seconds() / float(86400)
         )
 
-        df.to_excel(self.path, "test1")
-        reader = ExcelFile(self.path)
+        df.to_excel(path, "test1")
+        reader = ExcelFile(path)
 
         recons = pd.read_excel(reader, "test1", index_col=0)
         tm.assert_frame_equal(expected, recons)
 
-    def test_to_excel_periodindex(self, engine, ext, tsframe):
+    def test_to_excel_periodindex(self, tsframe, path):
         xp = tsframe.resample("M", kind="period").mean()
 
-        xp.to_excel(self.path, "sht1")
+        xp.to_excel(path, "sht1")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         rs = pd.read_excel(reader, "sht1", index_col=0)
         tm.assert_frame_equal(xp, rs.to_period("M"))
 
-    def test_to_excel_multiindex(self, merge_cells, engine, ext, frame):
+    def test_to_excel_multiindex(self, merge_cells, frame, path):
         arrays = np.arange(len(frame.index) * 2).reshape(2, -1)
         new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
         frame.index = new_index
 
-        frame.to_excel(self.path, "test1", header=False)
-        frame.to_excel(self.path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", columns=["A", "B"])
 
         # round trip
-        frame.to_excel(self.path, "test1", merge_cells=merge_cells)
-        reader = ExcelFile(self.path)
+        frame.to_excel(path, "test1", merge_cells=merge_cells)
+        reader = ExcelFile(path)
         df = pd.read_excel(reader, "test1", index_col=[0, 1])
         tm.assert_frame_equal(frame, df)
 
     # GH13511
-    def test_to_excel_multiindex_nan_label(self, merge_cells, engine, ext):
+    def test_to_excel_multiindex_nan_label(self, merge_cells, path):
         df = pd.DataFrame(
             {"A": [None, 2, 3], "B": [10, 20, 30], "C": np.random.sample(3)}
         )
         df = df.set_index(["A", "B"])
 
-        df.to_excel(self.path, merge_cells=merge_cells)
-        df1 = pd.read_excel(self.path, index_col=[0, 1])
+        df.to_excel(path, merge_cells=merge_cells)
+        df1 = pd.read_excel(path, index_col=[0, 1])
         tm.assert_frame_equal(df, df1)
 
     # Test for Issue 11328. If column indices are integers, make
     # sure they are handled correctly for either setting of
     # merge_cells
-    def test_to_excel_multiindex_cols(self, merge_cells, engine, ext, frame):
+    def test_to_excel_multiindex_cols(self, merge_cells, frame, path):
         arrays = np.arange(len(frame.index) * 2).reshape(2, -1)
         new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
         frame.index = new_index
@@ -714,28 +740,28 @@ def test_to_excel_multiindex_cols(self, merge_cells, engine, ext, frame):
             header = 0
 
         # round trip
-        frame.to_excel(self.path, "test1", merge_cells=merge_cells)
-        reader = ExcelFile(self.path)
+        frame.to_excel(path, "test1", merge_cells=merge_cells)
+        reader = ExcelFile(path)
         df = pd.read_excel(reader, "test1", header=header, index_col=[0, 1])
         if not merge_cells:
             fm = frame.columns.format(sparsify=False, adjoin=False, names=False)
             frame.columns = [".".join(map(str, q)) for q in zip(*fm)]
         tm.assert_frame_equal(frame, df)
 
-    def test_to_excel_multiindex_dates(self, merge_cells, engine, ext, tsframe):
+    def test_to_excel_multiindex_dates(self, merge_cells, tsframe, path):
         # try multiindex with dates
         new_index = [tsframe.index, np.arange(len(tsframe.index))]
         tsframe.index = MultiIndex.from_arrays(new_index)
 
         tsframe.index.names = ["time", "foo"]
-        tsframe.to_excel(self.path, "test1", merge_cells=merge_cells)
-        reader = ExcelFile(self.path)
+        tsframe.to_excel(path, "test1", merge_cells=merge_cells)
+        reader = ExcelFile(path)
         recons = pd.read_excel(reader, "test1", index_col=[0, 1])
 
         tm.assert_frame_equal(tsframe, recons)
         assert recons.index.names == ("time", "foo")
 
-    def test_to_excel_multiindex_no_write_index(self, engine, ext):
+    def test_to_excel_multiindex_no_write_index(self, path):
         # Test writing and re-reading a MI without the index. GH 5616.
 
         # Initial non-MI frame.
@@ -747,24 +773,24 @@ def test_to_excel_multiindex_no_write_index(self, engine, ext):
         frame2.index = multi_index
 
         # Write out to Excel without the index.
-        frame2.to_excel(self.path, "test1", index=False)
+        frame2.to_excel(path, "test1", index=False)
 
         # Read it back in.
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         frame3 = pd.read_excel(reader, "test1")
 
         # Test that it is the same as the initial frame.
         tm.assert_frame_equal(frame1, frame3)
 
-    def test_to_excel_float_format(self, engine, ext):
+    def test_to_excel_float_format(self, path):
         df = DataFrame(
             [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
             index=["A", "B"],
             columns=["X", "Y", "Z"],
         )
-        df.to_excel(self.path, "test1", float_format="%.2f")
+        df.to_excel(path, "test1", float_format="%.2f")
 
-        reader = ExcelFile(self.path)
+        reader = ExcelFile(path)
         result = pd.read_excel(reader, "test1", index_col=0)
 
         expected = DataFrame(
@@ -774,7 +800,7 @@ def test_to_excel_float_format(self, engine, ext):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_to_excel_output_encoding(self, engine, ext):
+    def test_to_excel_output_encoding(self, ext):
         # Avoid mixed inferred_type.
         df = DataFrame(
             [["\u0192", "\u0193", "\u0194"], ["\u0195", "\u0196", "\u0197"]],
@@ -782,13 +808,13 @@ def test_to_excel_output_encoding(self, engine, ext):
             columns=["X\u0193", "Y", "Z"],
         )
 
-        with ensure_clean("__tmp_to_excel_float_format__." + ext) as filename:
+        with tm.ensure_clean("__tmp_to_excel_float_format__." + ext) as filename:
             df.to_excel(filename, sheet_name="TestSheet", encoding="utf8")
             result = pd.read_excel(filename, "TestSheet", encoding="utf8", index_col=0)
             tm.assert_frame_equal(result, df)
 
-    def test_to_excel_unicode_filename(self, engine, ext):
-        with ensure_clean("\u0192u." + ext) as filename:
+    def test_to_excel_unicode_filename(self, ext, path):
+        with tm.ensure_clean("\u0192u." + ext) as filename:
             try:
                 f = open(filename, "wb")
             except UnicodeEncodeError:
@@ -813,6 +839,7 @@ def test_to_excel_unicode_filename(self, engine, ext):
             )
             tm.assert_frame_equal(result, expected)
 
+    # FIXME: dont leave commented-out
     # def test_to_excel_header_styling_xls(self, engine, ext):
 
     #     import StringIO
@@ -917,14 +944,12 @@ def test_to_excel_unicode_filename(self, engine, ext):
     @pytest.mark.parametrize("r_idx_nlevels", [1, 2, 3])
     @pytest.mark.parametrize("c_idx_nlevels", [1, 2, 3])
     def test_excel_010_hemstring(
-        self, merge_cells, engine, ext, c_idx_nlevels, r_idx_nlevels, use_headers
+        self, merge_cells, c_idx_nlevels, r_idx_nlevels, use_headers, path
     ):
         def roundtrip(data, header=True, parser_hdr=0, index=True):
-            data.to_excel(
-                self.path, header=header, merge_cells=merge_cells, index=index
-            )
+            data.to_excel(path, header=header, merge_cells=merge_cells, index=index)
 
-            xf = ExcelFile(self.path)
+            xf = ExcelFile(path)
             return pd.read_excel(xf, xf.sheet_names[0], header=parser_hdr)
 
         # Basic test.
@@ -938,12 +963,10 @@ def roundtrip(data, header=True, parser_hdr=0, index=True):
         nrows = 5
         ncols = 3
 
-        from pandas.util.testing import makeCustomDataframe as mkdf
-
         # ensure limited functionality in 0.10
         # override of gh-2370 until sorted out in 0.11
 
-        df = mkdf(
+        df = tm.makeCustomDataframe(
             nrows, ncols, r_idx_nlevels=r_idx_nlevels, c_idx_nlevels=c_idx_nlevels
         )
 
@@ -966,128 +989,145 @@ def roundtrip(data, header=True, parser_hdr=0, index=True):
                 for c in range(len(res.columns)):
                     assert res.iloc[r, c] is not np.nan
 
-    def test_duplicated_columns(self, engine, ext):
+    def test_duplicated_columns(self, path):
         # see gh-5235
         df = DataFrame([[1, 2, 3], [1, 2, 3], [1, 2, 3]], columns=["A", "B", "B"])
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
         expected = DataFrame(
             [[1, 2, 3], [1, 2, 3], [1, 2, 3]], columns=["A", "B", "B.1"]
         )
 
         # By default, we mangle.
-        result = pd.read_excel(self.path, "test1", index_col=0)
+        result = pd.read_excel(path, "test1", index_col=0)
         tm.assert_frame_equal(result, expected)
 
         # Explicitly, we pass in the parameter.
-        result = pd.read_excel(self.path, "test1", index_col=0, mangle_dupe_cols=True)
+        result = pd.read_excel(path, "test1", index_col=0, mangle_dupe_cols=True)
         tm.assert_frame_equal(result, expected)
 
         # see gh-11007, gh-10970
         df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "A", "B"])
-        df.to_excel(self.path, "test1")
+        df.to_excel(path, "test1")
 
-        result = pd.read_excel(self.path, "test1", index_col=0)
+        result = pd.read_excel(path, "test1", index_col=0)
         expected = DataFrame(
             [[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "A.1", "B.1"]
         )
         tm.assert_frame_equal(result, expected)
 
         # see gh-10982
-        df.to_excel(self.path, "test1", index=False, header=False)
-        result = pd.read_excel(self.path, "test1", header=None)
+        df.to_excel(path, "test1", index=False, header=False)
+        result = pd.read_excel(path, "test1", header=None)
 
         expected = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]])
         tm.assert_frame_equal(result, expected)
 
         msg = "Setting mangle_dupe_cols=False is not supported yet"
         with pytest.raises(ValueError, match=msg):
-            pd.read_excel(self.path, "test1", header=None, mangle_dupe_cols=False)
+            pd.read_excel(path, "test1", header=None, mangle_dupe_cols=False)
 
-    def test_swapped_columns(self, engine, ext):
+    def test_swapped_columns(self, path):
         # Test for issue #5427.
         write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2]})
-        write_frame.to_excel(self.path, "test1", columns=["B", "A"])
+        write_frame.to_excel(path, "test1", columns=["B", "A"])
 
-        read_frame = pd.read_excel(self.path, "test1", header=0)
+        read_frame = pd.read_excel(path, "test1", header=0)
 
         tm.assert_series_equal(write_frame["A"], read_frame["A"])
         tm.assert_series_equal(write_frame["B"], read_frame["B"])
 
-    def test_invalid_columns(self, engine, ext):
+    def test_invalid_columns(self, path):
         # see gh-10982
         write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2]})
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            write_frame.to_excel(self.path, "test1", columns=["B", "C"])
-
-        expected = write_frame.reindex(columns=["B", "C"])
-        read_frame = pd.read_excel(self.path, "test1", index_col=0)
-        tm.assert_frame_equal(expected, read_frame)
+        with pytest.raises(KeyError, match="Not all names specified"):
+            write_frame.to_excel(path, "test1", columns=["B", "C"])
 
         with pytest.raises(
             KeyError, match="'passes columns are not ALL present dataframe'"
         ):
-            write_frame.to_excel(self.path, "test1", columns=["C", "D"])
+            write_frame.to_excel(path, "test1", columns=["C", "D"])
+
+    @pytest.mark.parametrize(
+        "to_excel_index,read_excel_index_col",
+        [
+            (True, 0),  # Include index in write to file
+            (False, None),  # Dont include index in write to file
+        ],
+    )
+    def test_write_subset_columns(self, path, to_excel_index, read_excel_index_col):
+        # GH 31677
+        write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2], "C": [3, 3, 3]})
+        write_frame.to_excel(
+            path, "col_subset_bug", columns=["A", "B"], index=to_excel_index
+        )
 
-    def test_comment_arg(self, engine, ext):
+        expected = write_frame[["A", "B"]]
+        read_frame = pd.read_excel(
+            path, "col_subset_bug", index_col=read_excel_index_col
+        )
+
+        tm.assert_frame_equal(expected, read_frame)
+
+    def test_comment_arg(self, path):
         # see gh-18735
         #
         # Test the comment argument functionality to pd.read_excel.
 
         # Create file to read in.
         df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
-        df.to_excel(self.path, "test_c")
+        df.to_excel(path, "test_c")
 
         # Read file without comment arg.
-        result1 = pd.read_excel(self.path, "test_c", index_col=0)
+        result1 = pd.read_excel(path, "test_c", index_col=0)
 
         result1.iloc[1, 0] = None
         result1.iloc[1, 1] = None
         result1.iloc[2, 1] = None
 
-        result2 = pd.read_excel(self.path, "test_c", comment="#", index_col=0)
+        result2 = pd.read_excel(path, "test_c", comment="#", index_col=0)
         tm.assert_frame_equal(result1, result2)
 
-    def test_comment_default(self, engine, ext):
+    def test_comment_default(self, path):
         # Re issue #18735
         # Test the comment argument default to pd.read_excel
 
         # Create file to read in
         df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
-        df.to_excel(self.path, "test_c")
+        df.to_excel(path, "test_c")
 
         # Read file with default and explicit comment=None
-        result1 = pd.read_excel(self.path, "test_c")
-        result2 = pd.read_excel(self.path, "test_c", comment=None)
+        result1 = pd.read_excel(path, "test_c")
+        result2 = pd.read_excel(path, "test_c", comment=None)
         tm.assert_frame_equal(result1, result2)
 
-    def test_comment_used(self, engine, ext):
+    def test_comment_used(self, path):
         # see gh-18735
         #
         # Test the comment argument is working as expected when used.
 
         # Create file to read in.
         df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
-        df.to_excel(self.path, "test_c")
+        df.to_excel(path, "test_c")
 
         # Test read_frame_comment against manually produced expected output.
         expected = DataFrame({"A": ["one", None, "one"], "B": ["two", None, None]})
-        result = pd.read_excel(self.path, "test_c", comment="#", index_col=0)
+        result = pd.read_excel(path, "test_c", comment="#", index_col=0)
         tm.assert_frame_equal(result, expected)
 
-    def test_comment_empty_line(self, engine, ext):
+    def test_comment_empty_line(self, path):
         # Re issue #18735
         # Test that pd.read_excel ignores commented lines at the end of file
 
         df = DataFrame({"a": ["1", "#2"], "b": ["2", "3"]})
-        df.to_excel(self.path, index=False)
+        df.to_excel(path, index=False)
 
         # Test that all-comment lines at EoF are ignored
         expected = DataFrame({"a": [1], "b": [2]})
-        result = pd.read_excel(self.path, comment="#")
+        result = pd.read_excel(path, comment="#")
         tm.assert_frame_equal(result, expected)
 
-    def test_datetimes(self, engine, ext):
+    def test_datetimes(self, path):
 
         # Test writing and reading datetimes. For issue #9139. (xref #9185)
         datetimes = [
@@ -1105,12 +1145,12 @@ def test_datetimes(self, engine, ext):
         ]
 
         write_frame = DataFrame({"A": datetimes})
-        write_frame.to_excel(self.path, "Sheet1")
-        read_frame = pd.read_excel(self.path, "Sheet1", header=0)
+        write_frame.to_excel(path, "Sheet1")
+        read_frame = pd.read_excel(path, "Sheet1", header=0)
 
         tm.assert_series_equal(write_frame["A"], read_frame["A"])
 
-    def test_bytes_io(self, engine, ext):
+    def test_bytes_io(self, engine):
         # see gh-7074
         bio = BytesIO()
         df = DataFrame(np.random.randn(10, 2))
@@ -1124,7 +1164,7 @@ def test_bytes_io(self, engine, ext):
         reread_df = pd.read_excel(bio, index_col=0)
         tm.assert_frame_equal(df, reread_df)
 
-    def test_write_lists_dict(self, engine, ext):
+    def test_write_lists_dict(self, path):
         # see gh-8188.
         df = DataFrame(
             {
@@ -1133,8 +1173,8 @@ def test_write_lists_dict(self, engine, ext):
                 "str": ["apple", "banana", "cherry"],
             }
         )
-        df.to_excel(self.path, "Sheet1")
-        read = pd.read_excel(self.path, "Sheet1", header=0, index_col=0)
+        df.to_excel(path, "Sheet1")
+        read = pd.read_excel(path, "Sheet1", header=0, index_col=0)
 
         expected = df.copy()
         expected.mixed = expected.mixed.apply(str)
@@ -1142,23 +1182,23 @@ def test_write_lists_dict(self, engine, ext):
 
         tm.assert_frame_equal(read, expected)
 
-    def test_true_and_false_value_options(self, engine, ext):
+    def test_true_and_false_value_options(self, path):
         # see gh-13347
         df = pd.DataFrame([["foo", "bar"]], columns=["col1", "col2"])
         expected = df.replace({"foo": True, "bar": False})
 
-        df.to_excel(self.path)
+        df.to_excel(path)
         read_frame = pd.read_excel(
-            self.path, true_values=["foo"], false_values=["bar"], index_col=0
+            path, true_values=["foo"], false_values=["bar"], index_col=0
         )
         tm.assert_frame_equal(read_frame, expected)
 
-    def test_freeze_panes(self, engine, ext):
+    def test_freeze_panes(self, path):
         # see gh-15160
         expected = DataFrame([[1, 2], [3, 4]], columns=["col1", "col2"])
-        expected.to_excel(self.path, "Sheet1", freeze_panes=(1, 1))
+        expected.to_excel(path, "Sheet1", freeze_panes=(1, 1))
 
-        result = pd.read_excel(self.path, index_col=0)
+        result = pd.read_excel(path, index_col=0)
         tm.assert_frame_equal(result, expected)
 
     def test_path_path_lib(self, engine, ext):
@@ -1177,7 +1217,7 @@ def test_path_local_path(self, engine, ext):
         result = tm.round_trip_pathlib(writer, reader, path="foo.{ext}".format(ext=ext))
         tm.assert_frame_equal(result, df)
 
-    def test_merged_cell_custom_objects(self, engine, merge_cells, ext):
+    def test_merged_cell_custom_objects(self, merge_cells, path):
         # see GH-27006
         mi = MultiIndex.from_tuples(
             [
@@ -1186,10 +1226,8 @@ def test_merged_cell_custom_objects(self, engine, merge_cells, ext):
             ]
         )
         expected = DataFrame(np.ones((2, 2)), columns=mi)
-        expected.to_excel(self.path)
-        result = pd.read_excel(
-            self.path, header=[0, 1], index_col=0, convert_float=False
-        )
+        expected.to_excel(path)
+        result = pd.read_excel(path, header=[0, 1], index_col=0, convert_float=False)
         # need to convert PeriodIndexes to standard Indexes for assert equal
         expected.columns.set_levels(
             [[str(i) for i in mi.levels[0]], [str(i) for i in mi.levels[1]]],
@@ -1200,18 +1238,18 @@ def test_merged_cell_custom_objects(self, engine, merge_cells, ext):
         tm.assert_frame_equal(expected, result)
 
     @pytest.mark.parametrize("dtype", [None, object])
-    def test_raise_when_saving_timezones(self, engine, ext, dtype, tz_aware_fixture):
+    def test_raise_when_saving_timezones(self, dtype, tz_aware_fixture, path):
         # GH 27008, GH 7056
         tz = tz_aware_fixture
         data = pd.Timestamp("2019", tz=tz)
         df = DataFrame([data], dtype=dtype)
         with pytest.raises(ValueError, match="Excel does not support"):
-            df.to_excel(self.path)
+            df.to_excel(path)
 
         data = data.to_pydatetime()
         df = DataFrame([data], dtype=dtype)
         with pytest.raises(ValueError, match="Excel does not support"):
-            df.to_excel(self.path)
+            df.to_excel(path)
 
 
 class TestExcelWriterEngineTests:
@@ -1224,7 +1262,7 @@ class TestExcelWriterEngineTests:
         ],
     )
     def test_ExcelWriter_dispatch(self, klass, ext):
-        with ensure_clean(ext) as path:
+        with tm.ensure_clean(ext) as path:
             writer = ExcelWriter(path)
             if ext == ".xlsx" and td.safe_import("xlsxwriter"):
                 # xlsxwriter has preference over openpyxl if both installed
@@ -1271,7 +1309,6 @@ def check_called(func):
 
 @td.skip_if_no("xlrd")
 @td.skip_if_no("openpyxl")
-@pytest.mark.skipif(not PY36, reason="requires fspath")
 class TestFSPath:
     def test_excelfile_fspath(self):
         with tm.ensure_clean("foo.xlsx") as path:
diff --git a/pandas/tests/io/excel/test_xlrd.py b/pandas/tests/io/excel/test_xlrd.py
index c4d99c827318d..cc7e2311f362a 100644
--- a/pandas/tests/io/excel/test_xlrd.py
+++ b/pandas/tests/io/excel/test_xlrd.py
@@ -1,8 +1,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
-from pandas.util.testing import ensure_clean
+import pandas._testing as tm
 
 from pandas.io.excel import ExcelFile
 
@@ -11,9 +10,11 @@
 
 
 @pytest.fixture(autouse=True)
-def skip_ods_files(read_ext):
+def skip_ods_and_xlsb_files(read_ext):
     if read_ext == ".ods":
         pytest.skip("Not valid for xlrd")
+    if read_ext == ".xlsb":
+        pytest.skip("Not valid for xlrd")
 
 
 def test_read_xlrd_book(read_ext, frame):
@@ -22,7 +23,7 @@ def test_read_xlrd_book(read_ext, frame):
     engine = "xlrd"
     sheet_name = "SheetA"
 
-    with ensure_clean(read_ext) as pth:
+    with tm.ensure_clean(read_ext) as pth:
         df.to_excel(pth, sheet_name)
         book = xlrd.open_workbook(pth)
 
@@ -36,7 +37,7 @@ def test_read_xlrd_book(read_ext, frame):
 
 # TODO: test for openpyxl as well
 def test_excel_table_sheet_by_index(datapath, read_ext):
-    path = datapath("io", "data", "test1{}".format(read_ext))
+    path = datapath("io", "data", "excel", "test1{}".format(read_ext))
     with pd.ExcelFile(path) as excel:
         with pytest.raises(xlrd.XLRDError):
             pd.read_excel(excel, "asdf")
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 4dae3db2e7abd..b6f791434a92b 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -3,7 +3,7 @@
 import pytest
 
 from pandas import DataFrame
-from pandas.util.testing import ensure_clean
+import pandas._testing as tm
 
 from pandas.io.excel import ExcelWriter
 
@@ -20,7 +20,7 @@ def test_column_format(ext):
         warnings.simplefilter("ignore")
         openpyxl = pytest.importorskip("openpyxl")
 
-    with ensure_clean(ext) as path:
+    with tm.ensure_clean(ext) as path:
         frame = DataFrame({"A": [123456, 123456], "B": [123456, 123456]})
 
         writer = ExcelWriter(path)
@@ -50,7 +50,7 @@ def test_column_format(ext):
 
         try:
             read_num_format = cell.number_format
-        except Exception:
+        except AttributeError:
             read_num_format = cell.style.number_format._format_code
 
         assert read_num_format == num_format
@@ -59,6 +59,6 @@ def test_column_format(ext):
 def test_write_append_mode_raises(ext):
     msg = "Append mode is not supported with xlsxwriter!"
 
-    with ensure_clean(ext) as f:
+    with tm.ensure_clean(ext) as f:
         with pytest.raises(ValueError, match=msg):
             ExcelWriter(f, engine="xlsxwriter", mode="a")
diff --git a/pandas/tests/io/excel/test_xlwt.py b/pandas/tests/io/excel/test_xlwt.py
index 51f94a2f01b84..01feab08eb5e3 100644
--- a/pandas/tests/io/excel/test_xlwt.py
+++ b/pandas/tests/io/excel/test_xlwt.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex
-from pandas.util.testing import ensure_clean
+import pandas._testing as tm
 
 from pandas.io.excel import ExcelWriter, _XlwtWriter
 
@@ -19,7 +19,7 @@ def test_excel_raise_error_on_multiindex_columns_and_no_index(ext):
     )
     df = DataFrame(np.random.randn(10, 3), columns=cols)
     with pytest.raises(NotImplementedError):
-        with ensure_clean(ext) as path:
+        with tm.ensure_clean(ext) as path:
             df.to_excel(path, index=False)
 
 
@@ -28,7 +28,7 @@ def test_excel_multiindex_columns_and_index_true(ext):
         [("site", ""), ("2014", "height"), ("2014", "weight")]
     )
     df = pd.DataFrame(np.random.randn(10, 3), columns=cols)
-    with ensure_clean(ext) as path:
+    with tm.ensure_clean(ext) as path:
         df.to_excel(path, index=True)
 
 
@@ -38,7 +38,7 @@ def test_excel_multiindex_index(ext):
         [("site", ""), ("2014", "height"), ("2014", "weight")]
     )
     df = DataFrame(np.random.randn(3, 10), index=cols)
-    with ensure_clean(ext) as path:
+    with tm.ensure_clean(ext) as path:
         df.to_excel(path, index=False)
 
 
@@ -62,6 +62,6 @@ def test_to_excel_styleconverter(ext):
 def test_write_append_mode_raises(ext):
     msg = "Append mode is not supported with xlwt!"
 
-    with ensure_clean(ext) as f:
+    with tm.ensure_clean(ext) as f:
         with pytest.raises(ValueError, match=msg):
             ExcelWriter(f, engine="xlwt", mode="a")
diff --git a/pandas/tests/io/formats/data/html/render_links_false.html b/pandas/tests/io/formats/data/html/render_links_false.html
index 6509a0e985597..6feb403d63051 100644
--- a/pandas/tests/io/formats/data/html/render_links_false.html
+++ b/pandas/tests/io/formats/data/html/render_links_false.html
@@ -11,7 +11,7 @@
     <tr>
       <th>0</th>
       <td>0</td>
-      <td>http://pandas.pydata.org/?q1=a&amp;q2=b</td>
+      <td>https://pandas.pydata.org/?q1=a&amp;q2=b</td>
       <td>pydata.org</td>
     </tr>
     <tr>
diff --git a/pandas/tests/io/formats/data/html/render_links_true.html b/pandas/tests/io/formats/data/html/render_links_true.html
index e9cb5632aad1d..3eb53f3160a77 100644
--- a/pandas/tests/io/formats/data/html/render_links_true.html
+++ b/pandas/tests/io/formats/data/html/render_links_true.html
@@ -11,7 +11,7 @@
     <tr>
       <th>0</th>
       <td>0</td>
-      <td><a href="http://pandas.pydata.org/?q1=a&q2=b" target="_blank">http://pandas.pydata.org/?q1=a&amp;q2=b</a></td>
+      <td><a href="https://pandas.pydata.org/?q1=a&q2=b" target="_blank">https://pandas.pydata.org/?q1=a&amp;q2=b</a></td>
       <td>pydata.org</td>
     </tr>
     <tr>
diff --git a/pandas/tests/io/formats/data/html/truncate_formatter.html b/pandas/tests/io/formats/data/html/truncate_formatter.html
new file mode 100644
index 0000000000000..7615ef89d85d1
--- /dev/null
+++ b/pandas/tests/io/formats/data/html/truncate_formatter.html
@@ -0,0 +1,36 @@
+<table border="1" class="dataframe">
+  <thead>
+    <tr style="text-align: right;">
+      <th></th>
+      <th>A</th>
+      <th>...</th>
+      <th>D</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th>0</th>
+      <td>1_mod</td>
+      <td>...</td>
+      <td>4</td>
+    </tr>
+    <tr>
+      <th>1</th>
+      <td>5_mod</td>
+      <td>...</td>
+      <td>8</td>
+    </tr>
+    <tr>
+      <th>2</th>
+      <td>9_mod</td>
+      <td>...</td>
+      <td>12</td>
+    </tr>
+    <tr>
+      <th>3</th>
+      <td>13_mod</td>
+      <td>...</td>
+      <td>16</td>
+    </tr>
+  </tbody>
+</table>
diff --git a/pandas/tests/io/formats/test_css.py b/pandas/tests/io/formats/test_css.py
index 74e78b033bac9..7008cef7b28fa 100644
--- a/pandas/tests/io/formats/test_css.py
+++ b/pandas/tests/io/formats/test_css.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 from pandas.io.formats.css import CSSResolver, CSSWarning
 
@@ -101,29 +101,25 @@ def test_css_side_shorthands(shorthand, expansions):
     top, right, bottom, left = expansions
 
     assert_resolves(
-        "{shorthand}: 1pt".format(shorthand=shorthand),
-        {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"},
+        f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"},
     )
 
     assert_resolves(
-        "{shorthand}: 1pt 4pt".format(shorthand=shorthand),
-        {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"},
+        f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"},
     )
 
     assert_resolves(
-        "{shorthand}: 1pt 4pt 2pt".format(shorthand=shorthand),
+        f"{shorthand}: 1pt 4pt 2pt",
         {top: "1pt", right: "4pt", bottom: "2pt", left: "4pt"},
     )
 
     assert_resolves(
-        "{shorthand}: 1pt 4pt 2pt 0pt".format(shorthand=shorthand),
+        f"{shorthand}: 1pt 4pt 2pt 0pt",
         {top: "1pt", right: "4pt", bottom: "2pt", left: "0pt"},
     )
 
     with tm.assert_produces_warning(CSSWarning):
-        assert_resolves(
-            "{shorthand}: 1pt 1pt 1pt 1pt 1pt".format(shorthand=shorthand), {}
-        )
+        assert_resolves(f"{shorthand}: 1pt 1pt 1pt 1pt 1pt", {})
 
 
 @pytest.mark.parametrize(
@@ -174,10 +170,10 @@ def test_css_none_absent(style, equiv):
     "size,resolved",
     [
         ("xx-small", "6pt"),
-        ("x-small", "{pt:f}pt".format(pt=7.5)),
-        ("small", "{pt:f}pt".format(pt=9.6)),
+        ("x-small", f"{7.5:f}pt"),
+        ("small", f"{9.6:f}pt"),
         ("medium", "12pt"),
-        ("large", "{pt:f}pt".format(pt=13.5)),
+        ("large", f"{13.5:f}pt"),
         ("x-large", "18pt"),
         ("xx-large", "24pt"),
         ("8px", "6pt"),
@@ -196,9 +192,7 @@ def test_css_absolute_font_size(size, relative_to, resolved):
     else:
         inherited = {"font-size": relative_to}
     assert_resolves(
-        "font-size: {size}".format(size=size),
-        {"font-size": resolved},
-        inherited=inherited,
+        f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
     )
 
 
@@ -224,7 +218,7 @@ def test_css_absolute_font_size(size, relative_to, resolved):
         ("inherit", "16pt", "16pt"),
         ("smaller", None, "10pt"),
         ("smaller", "18pt", "15pt"),
-        ("larger", None, "{pt:f}pt".format(pt=14.4)),
+        ("larger", None, f"{14.4:f}pt"),
         ("larger", "15pt", "18pt"),
     ],
 )
@@ -234,7 +228,5 @@ def test_css_relative_font_size(size, relative_to, resolved):
     else:
         inherited = {"font-size": relative_to}
     assert_resolves(
-        "font-size: {size}".format(size=size),
-        {"font-size": resolved},
-        inherited=inherited,
+        f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
     )
diff --git a/pandas/tests/io/formats/test_eng_formatting.py b/pandas/tests/io/formats/test_eng_formatting.py
index d2a2d0a6a9706..6801316ada8a3 100644
--- a/pandas/tests/io/formats/test_eng_formatting.py
+++ b/pandas/tests/io/formats/test_eng_formatting.py
@@ -2,7 +2,7 @@
 
 import pandas as pd
 from pandas import DataFrame
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 import pandas.io.formats.format as fmt
 
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index c0451a0672c89..bf7b98eb78f11 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -18,7 +18,7 @@
 import pytest
 import pytz
 
-from pandas.compat import PY36, is_platform_32bit, is_platform_windows
+from pandas.compat import is_platform_32bit, is_platform_windows
 
 import pandas as pd
 from pandas import (
@@ -35,7 +35,7 @@
     reset_option,
     set_option,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.formats.format as fmt
 import pandas.io.formats.printing as printing
@@ -54,7 +54,7 @@ def filepath_or_buffer_id(request):
 @pytest.fixture
 def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
     """
-    A fixture yeilding a string representing a filepath, a path-like object
+    A fixture yielding a string representing a filepath, a path-like object
     and a StringIO buffer. Also checks that buffer is not closed.
     """
     if filepath_or_buffer_id == "buffer":
@@ -62,10 +62,7 @@ def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
         yield buf
         assert not buf.closed
     else:
-        if PY36:
-            assert isinstance(tmp_path, Path)
-        else:
-            assert hasattr(tmp_path, "__fspath__")
+        assert isinstance(tmp_path, Path)
         if filepath_or_buffer_id == "pathlike":
             yield tmp_path / "foo"
         else:
@@ -73,17 +70,19 @@ def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
 
 
 @pytest.fixture
-def assert_filepath_or_buffer_equals(filepath_or_buffer, filepath_or_buffer_id):
+def assert_filepath_or_buffer_equals(
+    filepath_or_buffer, filepath_or_buffer_id, encoding
+):
     """
     Assertion helper for checking filepath_or_buffer.
     """
 
     def _assert_filepath_or_buffer_equals(expected):
         if filepath_or_buffer_id == "string":
-            with open(filepath_or_buffer) as f:
+            with open(filepath_or_buffer, encoding=encoding) as f:
                 result = f.read()
         elif filepath_or_buffer_id == "pathlike":
-            result = filepath_or_buffer.read_text()
+            result = filepath_or_buffer.read_text(encoding=encoding)
         elif filepath_or_buffer_id == "buffer":
             result = filepath_or_buffer.getvalue()
         assert result == expected
@@ -240,6 +239,15 @@ def test_repr_truncation(self):
         with option_context("display.max_colwidth", max_len + 2):
             assert "..." not in repr(df)
 
+    def test_repr_deprecation_negative_int(self):
+        # FIXME: remove in future version after deprecation cycle
+        # Non-regression test for:
+        # https://github.com/pandas-dev/pandas/issues/31532
+        width = get_option("display.max_colwidth")
+        with tm.assert_produces_warning(FutureWarning):
+            set_option("display.max_colwidth", -1)
+        set_option("display.max_colwidth", width)
+
     def test_repr_chop_threshold(self):
         df = DataFrame([[0.1, 0.5], [0.5, -0.1]])
         pd.reset_option("display.chop_threshold")  # default None
@@ -297,7 +305,7 @@ def test_repr_set(self):
         assert printing.pprint_thing({1}) == "{1}"
 
     def test_repr_is_valid_construction_code(self):
-        # for the case of Index, where the repr is traditional rather then
+        # for the case of Index, where the repr is traditional rather than
         # stylized
         idx = Index(["a", "b"])
         res = eval("pd." + repr(idx))
@@ -422,12 +430,10 @@ def test_repr_truncation_column_size(self):
     def test_repr_max_columns_max_rows(self):
         term_width, term_height = get_terminal_size()
         if term_width < 10 or term_height < 10:
-            pytest.skip(
-                "terminal size too small, {0} x {1}".format(term_width, term_height)
-            )
+            pytest.skip(f"terminal size too small, {term_width} x {term_height}")
 
         def mkframe(n):
-            index = ["{i:05d}".format(i=i) for i in range(n)]
+            index = [f"{i:05d}" for i in range(n)]
             return DataFrame(0, index, index)
 
         df6 = mkframe(6)
@@ -447,7 +453,7 @@ def mkframe(n):
                     assert not has_truncated_repr(df6)
 
                 with option_context("display.max_rows", 9, "display.max_columns", 10):
-                    # out vertical bounds can not result in exanded repr
+                    # out vertical bounds can not result in expanded repr
                     assert not has_expanded_repr(df10)
                     assert has_vertically_truncated_repr(df10)
 
@@ -527,6 +533,45 @@ def test_str_max_colwidth(self):
                 "1  foo  bar                stuff  1"
             )
 
+    def test_to_string_truncate(self):
+        # GH 9784 - dont truncate when calling DataFrame.to_string
+        df = pd.DataFrame(
+            [
+                {
+                    "a": "foo",
+                    "b": "bar",
+                    "c": "let's make this a very VERY long line that is longer "
+                    "than the default 50 character limit",
+                    "d": 1,
+                },
+                {"a": "foo", "b": "bar", "c": "stuff", "d": 1},
+            ]
+        )
+        df.set_index(["a", "b", "c"])
+        assert df.to_string() == (
+            "     a    b                                         "
+            "                                                c  d\n"
+            "0  foo  bar  let's make this a very VERY long line t"
+            "hat is longer than the default 50 character limit  1\n"
+            "1  foo  bar                                         "
+            "                                            stuff  1"
+        )
+        with option_context("max_colwidth", 20):
+            # the display option has no effect on the to_string method
+            assert df.to_string() == (
+                "     a    b                                         "
+                "                                                c  d\n"
+                "0  foo  bar  let's make this a very VERY long line t"
+                "hat is longer than the default 50 character limit  1\n"
+                "1  foo  bar                                         "
+                "                                            stuff  1"
+            )
+        assert df.to_string(max_colwidth=20) == (
+            "     a    b                    c  d\n"
+            "0  foo  bar  let's make this ...  1\n"
+            "1  foo  bar                stuff  1"
+        )
+
     def test_auto_detect(self):
         term_width, term_height = get_terminal_size()
         fac = 1.05  # Arbitrary large factor to exceed term width
@@ -629,9 +674,9 @@ def test_to_string_with_formatters(self):
         )
 
         formatters = [
-            ("int", lambda x: "0x{x:x}".format(x=x)),
-            ("float", lambda x: "[{x: 4.1f}]".format(x=x)),
-            ("object", lambda x: "-{x!s}-".format(x=x)),
+            ("int", lambda x: f"0x{x:x}"),
+            ("float", lambda x: f"[{x: 4.1f}]"),
+            ("object", lambda x: f"-{x!s}-"),
         ]
         result = df.to_string(formatters=dict(formatters))
         result2 = df.to_string(formatters=list(zip(*formatters))[1])
@@ -673,7 +718,7 @@ def format_func(x):
 
     def test_to_string_with_formatters_unicode(self):
         df = DataFrame({"c/\u03c3": [1, 2, 3]})
-        result = df.to_string(formatters={"c/\u03c3": lambda x: "{x}".format(x=x)})
+        result = df.to_string(formatters={"c/\u03c3": str})
         assert result == "  c/\u03c3\n" + "0   1\n1   2\n2   3"
 
     def test_east_asian_unicode_false(self):
@@ -979,7 +1024,7 @@ def test_east_asian_unicode_true(self):
     def test_to_string_buffer_all_unicode(self):
         buf = StringIO()
 
-        empty = DataFrame({"c/\u03c3": Series()})
+        empty = DataFrame({"c/\u03c3": Series(dtype=object)})
         nonempty = DataFrame({"c/\u03c3": Series([1, 2, 3])})
 
         print(empty, file=buf)
@@ -1068,6 +1113,15 @@ def test_truncate_with_different_dtypes(self):
             assert "None" in result
             assert "NaN" not in result
 
+    def test_truncate_with_different_dtypes_multiindex(self):
+        # GH#13000
+        df = DataFrame({"Vals": range(100)})
+        frame = pd.concat([df], keys=["Sweep"], names=["Sweep", "Index"])
+        result = repr(frame)
+
+        result2 = repr(frame.iloc[:5])
+        assert result.startswith(result2)
+
     def test_datetimelike_frame(self):
 
         # GH 12211
@@ -1193,7 +1247,7 @@ def test_wide_repr(self):
             set_option("display.expand_frame_repr", False)
             rep_str = repr(df)
 
-            assert "10 rows x {c} columns".format(c=max_cols - 1) in rep_str
+            assert f"10 rows x {max_cols - 1} columns" in rep_str
             set_option("display.expand_frame_repr", True)
             wide_repr = repr(df)
             assert rep_str != wide_repr
@@ -1304,7 +1358,7 @@ def test_long_series(self):
         n = 1000
         s = Series(
             np.random.randint(-50, 50, n),
-            index=["s{x:04d}".format(x=x) for x in range(n)],
+            index=[f"s{x:04d}" for x in range(n)],
             dtype="int64",
         )
 
@@ -1430,9 +1484,7 @@ def test_to_string(self):
         expected = ["A"]
         assert header == expected
 
-        biggie.to_string(
-            columns=["B", "A"], formatters={"A": lambda x: "{x:.1f}".format(x=x)}
-        )
+        biggie.to_string(columns=["B", "A"], formatters={"A": lambda x: f"{x:.1f}"})
 
         biggie.to_string(columns=["B", "A"], float_format=str)
         biggie.to_string(columns=["B", "A"], col_space=12, float_format=str)
@@ -1563,7 +1615,7 @@ def test_to_string_small_float_values(self):
 
         result = df.to_string()
         # sadness per above
-        if "{x:.4g}".format(x=1.7e8) == "1.7e+008":
+        if _three_digit_exp():
             expected = (
                 "               a\n"
                 "0  1.500000e+000\n"
@@ -1875,7 +1927,7 @@ def test_repr_html_long(self):
             long_repr = df._repr_html_()
             assert ".." in long_repr
             assert str(41 + max_rows // 2) not in long_repr
-            assert "{h} rows ".format(h=h) in long_repr
+            assert f"{h} rows " in long_repr
             assert "2 columns" in long_repr
 
     def test_repr_html_float(self):
@@ -1892,7 +1944,7 @@ def test_repr_html_float(self):
             ).set_index("idx")
             reg_repr = df._repr_html_()
             assert ".." not in reg_repr
-            assert "<td>{val}</td>".format(val=str(40 + h)) in reg_repr
+            assert f"<td>{40 + h}</td>" in reg_repr
 
             h = max_rows + 1
             df = DataFrame(
@@ -1904,8 +1956,8 @@ def test_repr_html_float(self):
             ).set_index("idx")
             long_repr = df._repr_html_()
             assert ".." in long_repr
-            assert "<td>{val}</td>".format(val="31") not in long_repr
-            assert "{h} rows ".format(h=h) in long_repr
+            assert "<td>31</td>" not in long_repr
+            assert f"{h} rows " in long_repr
             assert "2 columns" in long_repr
 
     def test_repr_html_long_multiindex(self):
@@ -2134,9 +2186,7 @@ def test_to_string(self):
         cp.name = "foo"
         result = cp.to_string(length=True, name=True, dtype=True)
         last_line = result.split("\n")[-1].strip()
-        assert last_line == (
-            "Freq: B, Name: foo, Length: {cp}, dtype: float64".format(cp=len(cp))
-        )
+        assert last_line == (f"Freq: B, Name: foo, Length: {len(cp)}, dtype: float64")
 
     def test_freq_name_separation(self):
         s = Series(
@@ -2338,7 +2388,8 @@ def test_east_asian_unicode_series(self):
 
             # object dtype, longer than unicode repr
             s = Series(
-                [1, 22, 3333, 44444], index=[1, "AB", pd.Timestamp("2011-01-01"), "あああ"]
+                [1, 22, 3333, 44444],
+                index=[1, "AB", pd.Timestamp("2011-01-01"), "あああ"],
             )
             expected = (
                 "1                          1\n"
@@ -2617,14 +2668,14 @@ def test_format_explicit(self):
             assert exp == res
             res = repr(test_sers["asc"])
             exp = (
-                "0         a\n1        ab\n      ...  \n4     abcde\n5"
-                "    abcdef\ndtype: object"
+                "0         a\n1        ab\n      ...  \n4     abcde\n5    "
+                "abcdef\ndtype: object"
             )
             assert exp == res
             res = repr(test_sers["desc"])
             exp = (
-                "5    abcdef\n4     abcde\n      ...  \n1        ab\n0"
-                "         a\ndtype: object"
+                "5    abcdef\n4     abcde\n      ...  \n1        ab\n0         "
+                "a\ndtype: object"
             )
             assert exp == res
 
@@ -2727,14 +2778,14 @@ def test_to_string_length(self):
         assert res == exp
 
     def test_to_string_na_rep(self):
-        s = pd.Series(index=range(100))
+        s = pd.Series(index=range(100), dtype=np.float64)
         res = s.to_string(na_rep="foo", max_rows=2)
         exp = "0    foo\n      ..\n99   foo"
         assert res == exp
 
     def test_to_string_float_format(self):
         s = pd.Series(range(10), dtype="float64")
-        res = s.to_string(float_format=lambda x: "{0:2.1f}".format(x), max_rows=2)
+        res = s.to_string(float_format=lambda x: f"{x:2.1f}", max_rows=2)
         exp = "0   0.0\n     ..\n9   9.0"
         assert res == exp
 
@@ -2759,7 +2810,7 @@ def test_to_string_multindex_header(self):
 
 
 def _three_digit_exp():
-    return "{x:.4g}".format(x=1.7e8) == "1.7e+008"
+    return f"{1.7e8:.4g}" == "1.7e+008"
 
 
 class TestFloatArrayFormatter:
@@ -3201,14 +3252,33 @@ def test_repr_html_ipython_config(ip):
 
 
 @pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
+@pytest.mark.parametrize(
+    "encoding, data",
+    [(None, "abc"), ("utf-8", "abc"), ("gbk", "造成输出中文显示乱码"), ("foo", "abc")],
+)
 def test_filepath_or_buffer_arg(
-    float_frame, method, filepath_or_buffer, assert_filepath_or_buffer_equals
+    method,
+    filepath_or_buffer,
+    assert_filepath_or_buffer_equals,
+    encoding,
+    data,
+    filepath_or_buffer_id,
 ):
-    df = float_frame
-    expected = getattr(df, method)()
+    df = DataFrame([data])
 
-    getattr(df, method)(buf=filepath_or_buffer)
-    assert_filepath_or_buffer_equals(expected)
+    if filepath_or_buffer_id not in ["string", "pathlike"] and encoding is not None:
+        with pytest.raises(
+            ValueError, match="buf is not a file name and encoding is specified."
+        ):
+            getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+    elif encoding == "foo":
+        with tm.assert_produces_warning(None):
+            with pytest.raises(LookupError, match="unknown encoding"):
+                getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+    else:
+        expected = getattr(df, method)()
+        getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+        assert_filepath_or_buffer_equals(expected)
 
 
 @pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index 61c163d2cdaac..a2659079be7c0 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -9,7 +9,7 @@
 
 import pandas as pd
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 jinja2 = pytest.importorskip("jinja2")
 from pandas.io.formats.style import Styler, _get_level_lengths  # noqa  # isort:skip
@@ -24,7 +24,7 @@ def setup_method(self, method):
         self.g = lambda x: x
 
         def h(x, foo="bar"):
-            return pd.Series("color: {foo}".format(foo=foo), index=x.index, name=x.name)
+            return pd.Series(f"color: {foo}", index=x.index, name=x.name)
 
         self.h = h
         self.styler = Styler(self.df)
@@ -278,7 +278,7 @@ def test_numeric_columns(self):
 
     def test_apply_axis(self):
         df = pd.DataFrame({"A": [0, 0], "B": [1, 1]})
-        f = lambda x: ["val: {max}".format(max=x.max()) for v in x]
+        f = lambda x: [f"val: {x.max()}" for v in x]
         result = df.style.apply(f, axis=1)
         assert len(result._todo) == 1
         assert len(result.ctx) == 0
@@ -362,7 +362,7 @@ def color_negative_red(val):
             strings, black otherwise.
             """
             color = "red" if val < 0 else "black"
-            return "color: {color}".format(color=color)
+            return f"color: {color}"
 
         dic = {
             ("a", "d"): [-1.12, 2.11],
@@ -376,6 +376,25 @@ def color_negative_red(val):
 
         (df.style.applymap(color_negative_red, subset=idx[:, idx["b", "d"]]).render())
 
+    def test_applymap_subset_multiindex_code(self):
+        # https://github.com/pandas-dev/pandas/issues/25858
+        # Checks styler.applymap works with multindex when codes are provided
+        codes = np.array([[0, 0, 1, 1], [0, 1, 0, 1]])
+        columns = pd.MultiIndex(
+            levels=[["a", "b"], ["%", "#"]], codes=codes, names=["", ""]
+        )
+        df = DataFrame(
+            [[1, -1, 1, 1], [-1, 1, 1, 1]], index=["hello", "world"], columns=columns
+        )
+        pct_subset = pd.IndexSlice[:, pd.IndexSlice[:, "%":"%"]]
+
+        def color_negative_red(val):
+            color = "red" if val < 0 else "black"
+            return f"color: {color}"
+
+        df.loc[pct_subset]
+        df.style.applymap(color_negative_red, subset=pct_subset)
+
     def test_where_with_one_style(self):
         # GH 17474
         def f(x):
@@ -453,8 +472,19 @@ def test_empty(self):
 
         result = s._translate()["cellstyle"]
         expected = [
-            {"props": [["color", " red"]], "selector": "row0_col0"},
-            {"props": [["", ""]], "selector": "row1_col0"},
+            {"props": [("color", " red")], "selectors": ["row0_col0"]},
+            {"props": [("", "")], "selectors": ["row1_col0"]},
+        ]
+        assert result == expected
+
+    def test_duplicate(self):
+        df = pd.DataFrame({"A": [1, 0]})
+        s = df.style
+        s.ctx = {(0, 0): ["color: red"], (1, 0): ["color: red"]}
+
+        result = s._translate()["cellstyle"]
+        expected = [
+            {"props": [("color", " red")], "selectors": ["row0_col0", "row1_col0"]}
         ]
         assert result == expected
 
@@ -511,20 +541,17 @@ def test_bar_align_left_0points(self):
             (1, 0): [
                 "width: 10em",
                 " height: 80%",
-                "background: linear-gradient(90deg,#d65f5f 50.0%,"
-                " transparent 50.0%)",
+                "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
             ],
             (1, 1): [
                 "width: 10em",
                 " height: 80%",
-                "background: linear-gradient(90deg,#d65f5f 50.0%,"
-                " transparent 50.0%)",
+                "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
             ],
             (1, 2): [
                 "width: 10em",
                 " height: 80%",
-                "background: linear-gradient(90deg,#d65f5f 50.0%,"
-                " transparent 50.0%)",
+                "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
             ],
             (2, 0): [
                 "width: 10em",
@@ -553,8 +580,7 @@ def test_bar_align_left_0points(self):
             (0, 1): [
                 "width: 10em",
                 " height: 80%",
-                "background: linear-gradient(90deg,#d65f5f 50.0%,"
-                " transparent 50.0%)",
+                "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
             ],
             (0, 2): [
                 "width: 10em",
@@ -990,6 +1016,75 @@ def test_bar_bad_align_raises(self):
         with pytest.raises(ValueError):
             df.style.bar(align="poorly", color=["#d65f5f", "#5fba7d"])
 
+    def test_format_with_na_rep(self):
+        # GH 21527 28358
+        df = pd.DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+
+        ctx = df.style.format(None, na_rep="-")._translate()
+        assert ctx["body"][0][1]["display_value"] == "-"
+        assert ctx["body"][0][2]["display_value"] == "-"
+
+        ctx = df.style.format("{:.2%}", na_rep="-")._translate()
+        assert ctx["body"][0][1]["display_value"] == "-"
+        assert ctx["body"][0][2]["display_value"] == "-"
+        assert ctx["body"][1][1]["display_value"] == "110.00%"
+        assert ctx["body"][1][2]["display_value"] == "120.00%"
+
+        ctx = df.style.format("{:.2%}", na_rep="-", subset=["B"])._translate()
+        assert ctx["body"][0][2]["display_value"] == "-"
+        assert ctx["body"][1][2]["display_value"] == "120.00%"
+
+    def test_init_with_na_rep(self):
+        # GH 21527 28358
+        df = pd.DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+
+        ctx = Styler(df, na_rep="NA")._translate()
+        assert ctx["body"][0][1]["display_value"] == "NA"
+        assert ctx["body"][0][2]["display_value"] == "NA"
+
+    def test_set_na_rep(self):
+        # GH 21527 28358
+        df = pd.DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+
+        ctx = df.style.set_na_rep("NA")._translate()
+        assert ctx["body"][0][1]["display_value"] == "NA"
+        assert ctx["body"][0][2]["display_value"] == "NA"
+
+        ctx = (
+            df.style.set_na_rep("NA")
+            .format(None, na_rep="-", subset=["B"])
+            ._translate()
+        )
+        assert ctx["body"][0][1]["display_value"] == "NA"
+        assert ctx["body"][0][2]["display_value"] == "-"
+
+    def test_format_non_numeric_na(self):
+        # GH 21527 28358
+        df = pd.DataFrame(
+            {
+                "object": [None, np.nan, "foo"],
+                "datetime": [None, pd.NaT, pd.Timestamp("20120101")],
+            }
+        )
+
+        ctx = df.style.set_na_rep("NA")._translate()
+        assert ctx["body"][0][1]["display_value"] == "NA"
+        assert ctx["body"][0][2]["display_value"] == "NA"
+        assert ctx["body"][1][1]["display_value"] == "NA"
+        assert ctx["body"][1][2]["display_value"] == "NA"
+
+        ctx = df.style.format(None, na_rep="-")._translate()
+        assert ctx["body"][0][1]["display_value"] == "-"
+        assert ctx["body"][0][2]["display_value"] == "-"
+        assert ctx["body"][1][1]["display_value"] == "-"
+        assert ctx["body"][1][2]["display_value"] == "-"
+
+    def test_format_with_bad_na_rep(self):
+        # GH 21527 28358
+        df = pd.DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+        with pytest.raises(TypeError):
+            df.style.format(None, na_rep=-1)
+
     def test_highlight_null(self, null_color="red"):
         df = pd.DataFrame({"A": [0, np.nan]})
         result = df.style.highlight_null()._compute().ctx
@@ -1127,13 +1222,9 @@ def test_highlight_max(self):
 
     def test_export(self):
         f = lambda x: "color: red" if x > 0 else "color: blue"
-        g = (
-            lambda x, y, z: "color: {z}".format(z=z)
-            if x > 0
-            else "color: {z}".format(z=z)
-        )
+        g = lambda x, z: f"color: {z}" if x > 0 else f"color: {z}"
         style1 = self.styler
-        style1.applymap(f).applymap(g, y="a", z="b").highlight_max()
+        style1.applymap(f).applymap(g, z="b").highlight_max()
         result = style1.export()
         style2 = self.df.style
         style2.use(result)
@@ -1157,20 +1248,43 @@ def test_display_format_raises(self):
         with pytest.raises(TypeError):
             df.style.format(True)
 
+    def test_display_set_precision(self):
+        # Issue #13257
+        df = pd.DataFrame(data=[[1.0, 2.0090], [3.2121, 4.566]], columns=["a", "b"])
+        s = Styler(df)
+
+        ctx = s.set_precision(1)._translate()
+
+        assert s.precision == 1
+        assert ctx["body"][0][1]["display_value"] == "1.0"
+        assert ctx["body"][0][2]["display_value"] == "2.0"
+        assert ctx["body"][1][1]["display_value"] == "3.2"
+        assert ctx["body"][1][2]["display_value"] == "4.6"
+
+        ctx = s.set_precision(2)._translate()
+        assert s.precision == 2
+        assert ctx["body"][0][1]["display_value"] == "1.00"
+        assert ctx["body"][0][2]["display_value"] == "2.01"
+        assert ctx["body"][1][1]["display_value"] == "3.21"
+        assert ctx["body"][1][2]["display_value"] == "4.57"
+
+        ctx = s.set_precision(3)._translate()
+        assert s.precision == 3
+        assert ctx["body"][0][1]["display_value"] == "1.000"
+        assert ctx["body"][0][2]["display_value"] == "2.009"
+        assert ctx["body"][1][1]["display_value"] == "3.212"
+        assert ctx["body"][1][2]["display_value"] == "4.566"
+
     def test_display_subset(self):
         df = pd.DataFrame([[0.1234, 0.1234], [1.1234, 1.1234]], columns=["a", "b"])
         ctx = df.style.format(
             {"a": "{:0.1f}", "b": "{0:.2%}"}, subset=pd.IndexSlice[0, :]
         )._translate()
         expected = "0.1"
-        assert ctx["body"][0][1]["display_value"] == expected
-        assert ctx["body"][1][1]["display_value"] == "1.1234"
-        assert ctx["body"][0][2]["display_value"] == "12.34%"
-
-        raw_11 = "1.1234"
-        ctx = df.style.format("{:0.1f}", subset=pd.IndexSlice[0, :])._translate()
+        raw_11 = "1.123400"
         assert ctx["body"][0][1]["display_value"] == expected
         assert ctx["body"][1][1]["display_value"] == raw_11
+        assert ctx["body"][0][2]["display_value"] == "12.34%"
 
         ctx = df.style.format("{:0.1f}", subset=pd.IndexSlice[0, :])._translate()
         assert ctx["body"][0][1]["display_value"] == expected
@@ -1178,7 +1292,7 @@ def test_display_subset(self):
 
         ctx = df.style.format("{:0.1f}", subset=pd.IndexSlice["a"])._translate()
         assert ctx["body"][0][1]["display_value"] == expected
-        assert ctx["body"][0][2]["display_value"] == "0.1234"
+        assert ctx["body"][0][2]["display_value"] == "0.123400"
 
         ctx = df.style.format("{:0.1f}", subset=pd.IndexSlice[0, "a"])._translate()
         assert ctx["body"][0][1]["display_value"] == expected
@@ -1189,8 +1303,8 @@ def test_display_subset(self):
         )._translate()
         assert ctx["body"][0][1]["display_value"] == expected
         assert ctx["body"][1][1]["display_value"] == "1.1"
-        assert ctx["body"][0][2]["display_value"] == "0.1234"
-        assert ctx["body"][1][2]["display_value"] == "1.1234"
+        assert ctx["body"][0][2]["display_value"] == "0.123400"
+        assert ctx["body"][1][2]["display_value"] == raw_11
 
     def test_display_dict(self):
         df = pd.DataFrame([[0.1234, 0.1234], [1.1234, 1.1234]], columns=["a", "b"])
@@ -1534,9 +1648,7 @@ def test_hide_columns_mult_levels(self):
 
     def test_pipe(self):
         def set_caption_from_template(styler, a, b):
-            return styler.set_caption(
-                "Dataframe with a = {a} and b = {b}".format(a=a, b=b)
-            )
+            return styler.set_caption(f"Dataframe with a = {a} and b = {b}")
 
         styler = self.df.style.pipe(set_caption_from_template, "A", b="B")
         assert "Dataframe with a = A and b = B" in styler.render()
@@ -1625,6 +1737,23 @@ def test_background_gradient_axis(self):
         assert result[(1, 0)] == mid
         assert result[(1, 1)] == high
 
+    def test_background_gradient_vmin_vmax(self):
+        # GH 12145
+        df = pd.DataFrame(range(5))
+        ctx = df.style.background_gradient(vmin=1, vmax=3)._compute().ctx
+        assert ctx[(0, 0)] == ctx[(1, 0)]
+        assert ctx[(4, 0)] == ctx[(3, 0)]
+
+    def test_background_gradient_int64(self):
+        # GH 28869
+        df1 = pd.Series(range(3)).to_frame()
+        df2 = pd.Series(range(3), dtype="Int64").to_frame()
+        ctx1 = df1.style.background_gradient()._compute().ctx
+        ctx2 = df2.style.background_gradient()._compute().ctx
+        assert ctx2[(0, 0)] == ctx1[(0, 0)]
+        assert ctx2[(1, 0)] == ctx1[(1, 0)]
+        assert ctx2[(2, 0)] == ctx1[(2, 0)]
+
 
 def test_block_names():
     # catch accidental removal of a block
diff --git a/pandas/tests/io/formats/test_to_csv.py b/pandas/tests/io/formats/test_to_csv.py
index a85f3677bc3ab..b3ee8da52dece 100644
--- a/pandas/tests/io/formats/test_to_csv.py
+++ b/pandas/tests/io/formats/test_to_csv.py
@@ -1,3 +1,4 @@
+import io
 import os
 import sys
 
@@ -6,12 +7,12 @@
 
 import pandas as pd
 from pandas import DataFrame, compat
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestToCSV:
     @pytest.mark.xfail(
-        (3, 6, 5) > sys.version_info >= (3, 5),
+        (3, 6, 5) > sys.version_info,
         reason=("Python csv library bug (see https://bugs.python.org/issue32255)"),
     )
     def test_to_csv_with_single_column(self):
@@ -204,6 +205,14 @@ def test_to_csv_na_rep(self):
         assert df.set_index("a").to_csv(na_rep="_") == expected
         assert df.set_index(["a", "b"]).to_csv(na_rep="_") == expected
 
+        # GH 29975
+        # Make sure full na_rep shows up when a dtype is provided
+        csv = pd.Series(["a", pd.NA, "c"]).to_csv(na_rep="ZZZZZ")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,a", "1,ZZZZZ", "2,c"])
+        assert expected == csv
+        csv = pd.Series(["a", pd.NA, "c"], dtype="string").to_csv(na_rep="ZZZZZ")
+        assert expected == csv
+
     def test_to_csv_date_format(self):
         # GH 10209
         df_sec = DataFrame({"A": pd.date_range("20130101", periods=5, freq="s")})
@@ -376,16 +385,14 @@ def test_to_csv_string_with_lf(self):
                 assert f.read() == expected_noarg
         with tm.ensure_clean("lf_test.csv") as path:
             # case 2: LF as line terminator
-            expected_lf = b"int,str_lf\n" b"1,abc\n" b'2,"d\nef"\n' b'3,"g\nh\n\ni"\n'
+            expected_lf = b'int,str_lf\n1,abc\n2,"d\nef"\n3,"g\nh\n\ni"\n'
             df.to_csv(path, line_terminator="\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_lf
         with tm.ensure_clean("lf_test.csv") as path:
             # case 3: CRLF as line terminator
             # 'line_terminator' should not change inner element
-            expected_crlf = (
-                b"int,str_lf\r\n" b"1,abc\r\n" b'2,"d\nef"\r\n' b'3,"g\nh\n\ni"\r\n'
-            )
+            expected_crlf = b'int,str_lf\r\n1,abc\r\n2,"d\nef"\r\n3,"g\nh\n\ni"\r\n'
             df.to_csv(path, line_terminator="\r\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_crlf
@@ -412,9 +419,7 @@ def test_to_csv_string_with_crlf(self):
                 assert f.read() == expected_noarg
         with tm.ensure_clean("crlf_test.csv") as path:
             # case 2: LF as line terminator
-            expected_lf = (
-                b"int,str_crlf\n" b"1,abc\n" b'2,"d\r\nef"\n' b'3,"g\r\nh\r\n\r\ni"\n'
-            )
+            expected_lf = b'int,str_crlf\n1,abc\n2,"d\r\nef"\n3,"g\r\nh\r\n\r\ni"\n'
             df.to_csv(path, line_terminator="\n", index=False)
             with open(path, "rb") as f:
                 assert f.read() == expected_lf
@@ -490,10 +495,7 @@ def test_to_csv_compression(self, compression_only, read_infer, to_infer):
         compression = compression_only
 
         if compression == "zip":
-            pytest.skip(
-                "{compression} is not supported "
-                "for to_csv".format(compression=compression)
-            )
+            pytest.skip(f"{compression} is not supported for to_csv")
 
         # We'll complete file extension subsequently.
         filename = "test."
@@ -567,3 +569,31 @@ def test_to_csv_na_rep_long_string(self, df_new_type):
         result = df.to_csv(index=False, na_rep="mynull", encoding="ascii")
 
         assert expected == result
+
+    def test_to_csv_timedelta_precision(self):
+        # GH 6783
+        s = pd.Series([1, 1]).astype("timedelta64[ns]")
+        buf = io.StringIO()
+        s.to_csv(buf)
+        result = buf.getvalue()
+        expected_rows = [
+            ",0",
+            "0,0 days 00:00:00.000000001",
+            "1,0 days 00:00:00.000000001",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_na_rep_truncated(self):
+        # https://github.com/pandas-dev/pandas/issues/31447
+        result = pd.Series(range(8, 12)).to_csv(na_rep="-")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,8", "1,9", "2,10", "3,11"])
+        assert result == expected
+
+        result = pd.Series([True, False]).to_csv(na_rep="nan")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,True", "1,False"])
+        assert result == expected
+
+        result = pd.Series([1.1, 2.2]).to_csv(na_rep=".")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,1.1", "1,2.2"])
+        assert result == expected
diff --git a/pandas/tests/io/formats/test_to_excel.py b/pandas/tests/io/formats/test_to_excel.py
index 1440b0a6f06f1..883240b74c32c 100644
--- a/pandas/tests/io/formats/test_to_excel.py
+++ b/pandas/tests/io/formats/test_to_excel.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.formats.css import CSSWarning
 from pandas.io.formats.excel import CSSToExcelConverter
@@ -262,7 +262,7 @@ def test_css_to_excel_inherited(css, inherited, expected):
 @pytest.mark.parametrize(
     "input_color,output_color",
     (
-        [(name, rgb) for name, rgb in CSSToExcelConverter.NAMED_COLORS.items()]
+        list(CSSToExcelConverter.NAMED_COLORS.items())
         + [("#" + rgb, rgb) for rgb in CSSToExcelConverter.NAMED_COLORS.values()]
         + [("#F0F", "FF00FF"), ("#ABC", "AABBCC")]
     ),
@@ -270,13 +270,13 @@ def test_css_to_excel_inherited(css, inherited, expected):
 def test_css_to_excel_good_colors(input_color, output_color):
     # see gh-18392
     css = (
-        "border-top-color: {color}; "
-        "border-right-color: {color}; "
-        "border-bottom-color: {color}; "
-        "border-left-color: {color}; "
-        "background-color: {color}; "
-        "color: {color}"
-    ).format(color=input_color)
+        f"border-top-color: {input_color}; "
+        f"border-right-color: {input_color}; "
+        f"border-bottom-color: {input_color}; "
+        f"border-left-color: {input_color}; "
+        f"background-color: {input_color}; "
+        f"color: {input_color}"
+    )
 
     expected = dict()
 
@@ -297,13 +297,13 @@ def test_css_to_excel_good_colors(input_color, output_color):
 def test_css_to_excel_bad_colors(input_color):
     # see gh-18392
     css = (
-        "border-top-color: {color}; "
-        "border-right-color: {color}; "
-        "border-bottom-color: {color}; "
-        "border-left-color: {color}; "
-        "background-color: {color}; "
-        "color: {color}"
-    ).format(color=input_color)
+        f"border-top-color: {input_color}; "
+        f"border-right-color: {input_color}; "
+        f"border-bottom-color: {input_color}; "
+        f"border-left-color: {input_color}; "
+        f"background-color: {input_color}; "
+        f"color: {input_color}"
+    )
 
     expected = dict()
 
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 52c7b89220f06..d3f044a42eb28 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -7,18 +7,18 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, option_context
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 import pandas.io.formats.format as fmt
 
 lorem_ipsum = (
-    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod"
-    " tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim"
-    " veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex"
-    " ea commodo consequat. Duis aute irure dolor in reprehenderit in"
-    " voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur"
-    " sint occaecat cupidatat non proident, sunt in culpa qui officia"
-    " deserunt mollit anim id est laborum."
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod "
+    "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim "
+    "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex "
+    "ea commodo consequat. Duis aute irure dolor in reprehenderit in "
+    "voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur "
+    "sint occaecat cupidatat non proident, sunt in culpa qui officia "
+    "deserunt mollit anim id est laborum."
 )
 
 
@@ -99,6 +99,14 @@ def test_to_html_unicode(df, expected, datapath):
     assert result == expected
 
 
+def test_to_html_encoding(float_frame, tmp_path):
+    # GH 28663
+    path = tmp_path / "test.html"
+    float_frame.to_html(path, encoding="gbk")
+    with open(str(path), "r", encoding="gbk") as f:
+        assert float_frame.to_html() == f.read()
+
+
 def test_to_html_decimal(datapath):
     # GH 12031
     df = DataFrame({"A": [6.0, 3.1, 2.2]})
@@ -235,6 +243,32 @@ def test_to_html_truncate(datapath):
     assert result == expected
 
 
+@pytest.mark.parametrize("size", [1, 5])
+def test_html_invalid_formatters_arg_raises(size):
+    # issue-28469
+    df = DataFrame(columns=["a", "b", "c"])
+    msg = "Formatters length({}) should match DataFrame number of columns(3)"
+    with pytest.raises(ValueError, match=re.escape(msg.format(size))):
+        df.to_html(formatters=["{}".format] * size)
+
+
+def test_to_html_truncate_formatter(datapath):
+    # issue-25955
+    data = [
+        {"A": 1, "B": 2, "C": 3, "D": 4},
+        {"A": 5, "B": 6, "C": 7, "D": 8},
+        {"A": 9, "B": 10, "C": 11, "D": 12},
+        {"A": 13, "B": 14, "C": 15, "D": 16},
+    ]
+
+    df = DataFrame(data)
+    fmt = lambda x: str(x) + "_mod"
+    formatters = [fmt, fmt, None, None]
+    result = df.to_html(formatters=formatters, max_cols=3)
+    expected = expected_html(datapath, "truncate_formatter")
+    assert result == expected
+
+
 @pytest.mark.parametrize(
     "sparsify,expected",
     [(True, "truncate_multi_index"), (False, "truncate_multi_index_sparse_off")],
@@ -654,7 +688,7 @@ def test_to_html_float_format_no_fixed_width(value, float_format, expected, data
 def test_to_html_render_links(render_links, expected, datapath):
     # GH 2679
     data = [
-        [0, "http://pandas.pydata.org/?q1=a&q2=b", "pydata.org"],
+        [0, "https://pandas.pydata.org/?q1=a&q2=b", "pydata.org"],
         [0, "www.pydata.org", "pydata.org"],
     ]
     df = DataFrame(data, columns=["foo", "bar", None])
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index 9ffb54d23e37e..bd681032f155d 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestToLatex:
diff --git a/pandas/tests/io/formats/test_to_markdown.py b/pandas/tests/io/formats/test_to_markdown.py
new file mode 100644
index 0000000000000..8893e4294353f
--- /dev/null
+++ b/pandas/tests/io/formats/test_to_markdown.py
@@ -0,0 +1,55 @@
+from io import StringIO
+
+import pytest
+
+import pandas as pd
+
+pytest.importorskip("tabulate")
+
+
+def test_simple():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf)
+    result = buf.getvalue()
+    assert (
+        result == "|    |   0 |\n|---:|----:|\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+    )
+
+
+def test_other_tablefmt():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf, tablefmt="jira")
+    result = buf.getvalue()
+    assert result == "||    ||   0 ||\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+
+
+def test_other_headers():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf, headers=["foo", "bar"])
+    result = buf.getvalue()
+    assert result == (
+        "|   foo |   bar |\n|------:|------:|\n|     0 "
+        "|     1 |\n|     1 |     2 |\n|     2 |     3 |"
+    )
+
+
+def test_series():
+    buf = StringIO()
+    s = pd.Series([1, 2, 3], name="foo")
+    s.to_markdown(buf=buf)
+    result = buf.getvalue()
+    assert result == (
+        "|    |   foo |\n|---:|------:|\n|  0 |     1 "
+        "|\n|  1 |     2 |\n|  2 |     3 |"
+    )
+
+
+def test_no_buf(capsys):
+    df = pd.DataFrame([1, 2, 3])
+    result = df.to_markdown()
+    assert (
+        result == "|    |   0 |\n|---:|----:|\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+    )
diff --git a/pandas/tests/io/generate_legacy_storage_files.py b/pandas/tests/io/generate_legacy_storage_files.py
index 2d2938697bd80..67b767a337a89 100755
--- a/pandas/tests/io/generate_legacy_storage_files.py
+++ b/pandas/tests/io/generate_legacy_storage_files.py
@@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 """
-self-contained to write legacy storage (pickle/msgpack) files
+self-contained to write legacy storage pickle files
 
 To use this script. Create an environment where you want
 generate pickles, say its for 0.20.3, with your pandas clone
@@ -11,12 +11,12 @@
 cd ~/
 
 $ python pandas/pandas/tests/io/generate_legacy_storage_files.py \
-    pandas/pandas/tests/io/data/legacy_pickle/0.18.1/ pickle
+    pandas/pandas/tests/io/data/legacy_pickle/0.20.3/ pickle
 
 This script generates a storage file for the current arch, system,
 and python version
   pandas version: 0.20.3
-  output dir    : pandas/pandas/tests/io/data/legacy_pickle/0.18.1/
+  output dir    : pandas/pandas/tests/io/data/legacy_pickle/0.20.3/
   storage format: pickle
 created pickle file: 0.20.3_x86_64_darwin_3.5.2.pickle
 
@@ -53,14 +53,11 @@
     Period,
     RangeIndex,
     Series,
-    SparseDataFrame,
-    SparseSeries,
     Timestamp,
     bdate_range,
     date_range,
     period_range,
     timedelta_range,
-    to_msgpack,
 )
 
 from pandas.tseries.offsets import (
@@ -86,6 +83,13 @@
     YearEnd,
 )
 
+try:
+    # TODO: remove try/except when 0.24.0 is the legacy version.
+    from pandas.arrays import SparseArray
+except ImportError:
+    from pandas.core.sparse.api import SparseArray
+
+
 _loose_version = LooseVersion(pandas.__version__)
 
 
@@ -97,7 +101,7 @@ def _create_sp_series():
     arr[7:12] = nan
     arr[-1:] = nan
 
-    bseries = SparseSeries(arr, kind="block")
+    bseries = Series(SparseArray(arr, kind="block"))
     bseries.name = "bseries"
     return bseries
 
@@ -111,7 +115,7 @@ def _create_sp_tsseries():
     arr[-1:] = nan
 
     date_index = bdate_range("1/1/2011", periods=len(arr))
-    bseries = SparseSeries(arr, index=date_index, kind="block")
+    bseries = Series(SparseArray(arr, kind="block"), index=date_index)
     bseries.name = "btsseries"
     return bseries
 
@@ -127,11 +131,11 @@ def _create_sp_frame():
     }
 
     dates = bdate_range("1/1/2011", periods=10)
-    return SparseDataFrame(data, index=dates)
+    return DataFrame(data, index=dates).apply(SparseArray)
 
 
 def create_data():
-    """ create the pickle/msgpack data """
+    """ create the pickle data """
 
     data = {
         "A": [0.0, 1.0, 2.0, 3.0, np.nan],
@@ -301,28 +305,6 @@ def create_pickle_data():
     return data
 
 
-def _u(x):
-    return {k: _u(x[k]) for k in x} if isinstance(x, dict) else x
-
-
-def create_msgpack_data():
-    data = create_data()
-    # Not supported
-    del data["sp_series"]
-    del data["sp_frame"]
-    del data["series"]["cat"]
-    del data["series"]["period"]
-    del data["frame"]["cat_onecol"]
-    del data["frame"]["cat_and_float"]
-    del data["scalars"]["period"]
-    if _loose_version >= LooseVersion("0.21") and (
-        _loose_version < LooseVersion("0.23.0")
-    ):
-        del data["index"]["interval"]
-    del data["offsets"]
-    return _u(data)
-
-
 def platform_name():
     return "_".join(
         [
@@ -355,23 +337,6 @@ def write_legacy_pickles(output_dir):
     print("created pickle file: {pth}".format(pth=pth))
 
 
-def write_legacy_msgpack(output_dir, compress):
-
-    version = pandas.__version__
-
-    print(
-        "This script generates a storage file for the current arch, "
-        "system, and python version"
-    )
-    print("  pandas version: {0}".format(version))
-    print("  output dir    : {0}".format(output_dir))
-    print("  storage format: msgpack")
-    pth = "{0}.msgpack".format(platform_name())
-    to_msgpack(os.path.join(output_dir, pth), create_msgpack_data(), compress=compress)
-
-    print("created msgpack file: {pth}".format(pth=pth))
-
-
 def write_legacy_file():
     # force our cwd to be the first searched
     sys.path.insert(0, ".")
@@ -380,22 +345,15 @@ def write_legacy_file():
         exit(
             "Specify output directory and storage type: generate_legacy_"
             "storage_files.py <output_dir> <storage_type> "
-            "<msgpack_compress_type>"
         )
 
     output_dir = str(sys.argv[1])
     storage_type = str(sys.argv[2])
-    try:
-        compress_type = str(sys.argv[3])
-    except IndexError:
-        compress_type = None
 
     if storage_type == "pickle":
         write_legacy_pickles(output_dir=output_dir)
-    elif storage_type == "msgpack":
-        write_legacy_msgpack(output_dir=output_dir, compress=compress_type)
     else:
-        exit("storage_type must be one of {'pickle', 'msgpack'}")
+        exit("storage_type must be one of {'pickle'}")
 
 
 if __name__ == "__main__":
diff --git a/pandas/tests/io/json/conftest.py b/pandas/tests/io/json/conftest.py
new file mode 100644
index 0000000000000..4e848cd48b42d
--- /dev/null
+++ b/pandas/tests/io/json/conftest.py
@@ -0,0 +1,9 @@
+import pytest
+
+
+@pytest.fixture(params=["split", "records", "index", "columns", "values"])
+def orient(request):
+    """
+    Fixture for orients excluding the table format.
+    """
+    return request.param
diff --git a/pandas/tests/io/json/test_compression.py b/pandas/tests/io/json/test_compression.py
index 56be84bccc51a..182c21ed1d416 100644
--- a/pandas/tests/io/json/test_compression.py
+++ b/pandas/tests/io/json/test_compression.py
@@ -3,8 +3,7 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 def test_compression_roundtrip(compression):
@@ -16,12 +15,12 @@ def test_compression_roundtrip(compression):
 
     with tm.ensure_clean() as path:
         df.to_json(path, compression=compression)
-        assert_frame_equal(df, pd.read_json(path, compression=compression))
+        tm.assert_frame_equal(df, pd.read_json(path, compression=compression))
 
         # explicitly ensure file was compressed.
         with tm.decompress_file(path, compression) as fh:
             result = fh.read().decode("utf8")
-        assert_frame_equal(df, pd.read_json(result))
+        tm.assert_frame_equal(df, pd.read_json(result))
 
 
 def test_read_zipped_json(datapath):
@@ -31,7 +30,7 @@ def test_read_zipped_json(datapath):
     compressed_path = datapath("io", "json", "data", "tsframe_v012.json.zip")
     compressed_df = pd.read_json(compressed_path, compression="zip")
 
-    assert_frame_equal(uncompressed_df, compressed_df)
+    tm.assert_frame_equal(uncompressed_df, compressed_df)
 
 
 @td.skip_if_not_us_locale
@@ -46,7 +45,7 @@ def test_with_s3_url(compression, s3_resource):
             s3_resource.Bucket("pandas-test").put_object(Key="test-1", Body=f)
 
     roundtripped_df = pd.read_json("s3://pandas-test/test-1", compression=compression)
-    assert_frame_equal(df, roundtripped_df)
+    tm.assert_frame_equal(df, roundtripped_df)
 
 
 def test_lines_with_compression(compression):
@@ -55,7 +54,7 @@ def test_lines_with_compression(compression):
         df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
         df.to_json(path, orient="records", lines=True, compression=compression)
         roundtripped_df = pd.read_json(path, lines=True, compression=compression)
-        assert_frame_equal(df, roundtripped_df)
+        tm.assert_frame_equal(df, roundtripped_df)
 
 
 def test_chunksize_with_compression(compression):
@@ -66,7 +65,7 @@ def test_chunksize_with_compression(compression):
 
         res = pd.read_json(path, lines=True, chunksize=1, compression=compression)
         roundtripped_df = pd.concat(res)
-        assert_frame_equal(df, roundtripped_df)
+        tm.assert_frame_equal(df, roundtripped_df)
 
 
 def test_write_unsupported_compression_type():
@@ -91,10 +90,7 @@ def test_to_json_compression(compression_only, read_infer, to_infer):
     compression = compression_only
 
     if compression == "zip":
-        pytest.skip(
-            "{compression} is not supported "
-            "for to_csv".format(compression=compression)
-        )
+        pytest.skip(f"{compression} is not supported for to_csv")
 
     # We'll complete file extension subsequently.
     filename = "test."
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index b2fc9ec217ca6..2ac2acc6748d1 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -9,7 +9,7 @@
 
 import pandas as pd
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.json._table_schema import (
     as_json_table_type,
@@ -234,6 +234,7 @@ def test_build_series(self):
                 ),
             ]
         )
+
         assert result == expected
 
     def test_to_json(self):
@@ -323,6 +324,7 @@ def test_to_json(self):
             ),
         ]
         expected = OrderedDict([("schema", schema), ("data", data)])
+
         assert result == expected
 
     def test_to_json_float_index(self):
@@ -352,6 +354,7 @@ def test_to_json_float_index(self):
                 ),
             ]
         )
+
         assert result == expected
 
     def test_to_json_period_index(self):
@@ -372,6 +375,7 @@ def test_to_json_period_index(self):
             OrderedDict([("index", "2016-02-01T00:00:00.000Z"), ("values", 1)]),
         ]
         expected = OrderedDict([("schema", schema), ("data", data)])
+
         assert result == expected
 
     def test_to_json_categorical_index(self):
@@ -406,6 +410,7 @@ def test_to_json_categorical_index(self):
                 ),
             ]
         )
+
         assert result == expected
 
     def test_date_format_raises(self):
@@ -416,15 +421,15 @@ def test_date_format_raises(self):
         self.df.to_json(orient="table", date_format="iso")
         self.df.to_json(orient="table")
 
-    @pytest.mark.parametrize("kind", [pd.Series, pd.Index])
-    def test_convert_pandas_type_to_json_field_int(self, kind):
+    def test_convert_pandas_type_to_json_field_int(self, index_or_series):
+        kind = index_or_series
         data = [1, 2, 3]
         result = convert_pandas_type_to_json_field(kind(data, name="name"))
         expected = {"name": "name", "type": "integer"}
         assert result == expected
 
-    @pytest.mark.parametrize("kind", [pd.Series, pd.Index])
-    def test_convert_pandas_type_to_json_field_float(self, kind):
+    def test_convert_pandas_type_to_json_field_float(self, index_or_series):
+        kind = index_or_series
         data = [1.0, 2.0, 3.0]
         result = convert_pandas_type_to_json_field(kind(data, name="name"))
         expected = {"name": "name", "type": "number"}
@@ -508,7 +513,7 @@ def test_convert_json_field_to_pandas_type(self, inp, exp):
     def test_convert_json_field_to_pandas_type_raises(self, inp):
         field = {"type": inp}
         with pytest.raises(
-            ValueError, match=("Unsupported or invalid field type: {}".format(inp))
+            ValueError, match=f"Unsupported or invalid field type: {inp}"
         ):
             convert_json_field_to_pandas_type(field)
 
@@ -542,6 +547,7 @@ def test_categorical(self):
                 ),
             ]
         )
+
         assert result == expected
 
     @pytest.mark.parametrize(
@@ -596,7 +602,8 @@ def test_timestamp_in_columns(self):
         )
         result = df.to_json(orient="table")
         js = json.loads(result)
-        assert js["schema"]["fields"][1]["name"] == 1451606400000
+        assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000Z"
+        # TODO - below expectation is not correct; see GH 28256
         assert js["schema"]["fields"][2]["name"] == 10000
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index 3ceddfc3c1db4..91b204ed41ebc 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -3,12 +3,9 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PY36
+from pandas import DataFrame, Index, Series, json_normalize
+import pandas._testing as tm
 
-from pandas import DataFrame, Index
-import pandas.util.testing as tm
-
-from pandas.io.json import json_normalize
 from pandas.io.json._normalize import nested_to_record
 
 
@@ -382,7 +379,7 @@ def test_missing_field(self, author_missing_data):
             },
         ]
         expected = DataFrame(ex_data)
-        tm.assert_frame_equal(result, expected, check_like=not PY36)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "max_level,expected",
@@ -457,6 +454,38 @@ def test_max_level_with_records_path(self, max_level, expected):
         expected_df = DataFrame(data=expected, columns=result.columns.values)
         tm.assert_equal(expected_df, result)
 
+    def test_nested_flattening_consistent(self):
+        # see gh-21537
+        df1 = json_normalize([{"A": {"B": 1}}])
+        df2 = json_normalize({"dummy": [{"A": {"B": 1}}]}, "dummy")
+
+        # They should be the same.
+        tm.assert_frame_equal(df1, df2)
+
+    def test_nonetype_record_path(self, nulls_fixture):
+        # see gh-30148
+        # should not raise TypeError
+        result = json_normalize(
+            [
+                {"state": "Texas", "info": nulls_fixture},
+                {"state": "Florida", "info": [{"i": 2}]},
+            ],
+            record_path=["info"],
+        )
+        expected = DataFrame({"i": 2}, index=[0])
+        tm.assert_equal(result, expected)
+
+    def test_non_interable_record_path_errors(self):
+        # see gh-30148
+        test_input = {"state": "Texas", "info": 1}
+        test_path = "info"
+        msg = (
+            f"{test_input} has non iterable value 1 for path {test_path}. "
+            "Must be iterable or null."
+        )
+        with pytest.raises(TypeError, match=msg):
+            json_normalize([test_input], record_path=[test_path])
+
 
 class TestNestedToRecord:
     def test_flat_stays_flat(self):
@@ -516,7 +545,7 @@ def test_missing_meta(self, missing_metadata):
         columns = ["city", "number", "state", "street", "zip", "name"]
         columns = ["number", "street", "city", "state", "zip", "name"]
         expected = DataFrame(ex_data, columns=columns)
-        tm.assert_frame_equal(result, expected, check_like=not PY36)
+        tm.assert_frame_equal(result, expected)
 
     def test_donot_drop_nonevalues(self):
         # GH21356
@@ -546,7 +575,7 @@ def test_donot_drop_nonevalues(self):
 
     def test_nonetype_top_level_bottom_level(self):
         # GH21158: If inner level json has a key with a null value
-        # make sure it doesnt do a new_d.pop twice and except
+        # make sure it does not do a new_d.pop twice and except
         data = {
             "id": None,
             "location": {
@@ -578,7 +607,7 @@ def test_nonetype_top_level_bottom_level(self):
 
     def test_nonetype_multiple_levels(self):
         # GH21158: If inner level json has a key with a null value
-        # make sure it doesnt do a new_d.pop twice and except
+        # make sure it does not do a new_d.pop twice and except
         data = {
             "id": None,
             "location": {
@@ -692,3 +721,31 @@ def test_with_large_max_level(self):
         ]
         output = nested_to_record(input_data, max_level=max_level)
         assert output == expected
+
+    def test_deprecated_import(self):
+        with tm.assert_produces_warning(FutureWarning):
+            from pandas.io.json import json_normalize
+
+            recs = [{"a": 1, "b": 2, "c": 3}, {"a": 4, "b": 5, "c": 6}]
+            json_normalize(recs)
+
+    def test_series_non_zero_index(self):
+        # GH 19020
+        data = {
+            0: {"id": 1, "name": "Foo", "elements": {"a": 1}},
+            1: {"id": 2, "name": "Bar", "elements": {"b": 2}},
+            2: {"id": 3, "name": "Baz", "elements": {"c": 3}},
+        }
+        s = Series(data)
+        s.index = [1, 2, 3]
+        result = json_normalize(s)
+        expected = DataFrame(
+            {
+                "id": [1, 2, 3],
+                "name": ["Foo", "Bar", "Baz"],
+                "elements.a": [1.0, np.nan, np.nan],
+                "elements.b": [np.nan, 2.0, np.nan],
+                "elements.c": [np.nan, np.nan, 3.0],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 9842a706f43d7..f2d35bfb3b5ae 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -1,4 +1,5 @@
 from collections import OrderedDict
+import datetime
 from datetime import timedelta
 from io import StringIO
 import json
@@ -7,20 +8,12 @@
 import numpy as np
 import pytest
 
-from pandas.compat import is_platform_32bit
+from pandas.compat import is_platform_32bit, is_platform_windows
 import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex, Series, Timestamp, read_json
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-    ensure_clean,
-    network,
-)
+import pandas._testing as tm
 
 _seriesd = tm.getSeriesData()
 _tsd = tm.getTimeSeriesData()
@@ -39,6 +32,15 @@
 _mixed_frame = _frame.copy()
 
 
+def assert_json_roundtrip_equal(result, expected, orient):
+    if orient == "records" or orient == "values":
+        expected = expected.reset_index(drop=True)
+    if orient == "values":
+        expected.columns = range(len(expected.columns))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore:the 'numpy' keyword is deprecated:FutureWarning")
 class TestPandasContainer:
     @pytest.fixture(scope="function", autouse=True)
     def setup(self, datapath):
@@ -53,7 +55,7 @@ def setup(self, datapath):
         self.objSeries = tm.makeObjectSeries()
         self.objSeries.name = "objects"
 
-        self.empty_series = Series([], index=[])
+        self.empty_series = Series([], index=[], dtype=np.float64)
         self.empty_frame = DataFrame()
 
         self.frame = _frame.copy()
@@ -82,489 +84,322 @@ def setup(self, datapath):
         del self.tsframe
         del self.mixed_frame
 
-    def test_frame_double_encoded_labels(self):
+    def test_frame_double_encoded_labels(self, orient):
         df = DataFrame(
             [["a", "b"], ["c", "d"]],
             index=['index " 1', "index / 2"],
             columns=["a \\ b", "y / z"],
         )
 
-        assert_frame_equal(df, read_json(df.to_json(orient="split"), orient="split"))
-        assert_frame_equal(
-            df, read_json(df.to_json(orient="columns"), orient="columns")
-        )
-        assert_frame_equal(df, read_json(df.to_json(orient="index"), orient="index"))
-        df_unser = read_json(df.to_json(orient="records"), orient="records")
-        assert_index_equal(df.columns, df_unser.columns)
-        tm.assert_numpy_array_equal(df.values, df_unser.values)
+        result = read_json(df.to_json(orient=orient), orient=orient)
+        expected = df.copy()
 
-    def test_frame_non_unique_index(self):
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "values"])
+    def test_frame_non_unique_index(self, orient):
         df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        result = read_json(df.to_json(orient=orient), orient=orient)
+        expected = df.copy()
 
-        msg = "DataFrame index must be unique for orient='index'"
-        with pytest.raises(ValueError, match=msg):
-            df.to_json(orient="index")
-        msg = "DataFrame index must be unique for orient='columns'"
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["index", "columns"])
+    def test_frame_non_unique_index_raises(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        msg = f"DataFrame index must be unique for orient='{orient}'"
         with pytest.raises(ValueError, match=msg):
-            df.to_json(orient="columns")
+            df.to_json(orient=orient)
 
-        assert_frame_equal(df, read_json(df.to_json(orient="split"), orient="split"))
-        unser = read_json(df.to_json(orient="records"), orient="records")
-        tm.assert_index_equal(df.columns, unser.columns)
-        tm.assert_almost_equal(df.values, unser.values)
-        unser = read_json(df.to_json(orient="values"), orient="values")
-        tm.assert_numpy_array_equal(df.values, unser.values)
+    @pytest.mark.parametrize("orient", ["split", "values"])
+    @pytest.mark.parametrize(
+        "data",
+        [
+            [["a", "b"], ["c", "d"]],
+            [[1.5, 2.5], [3.5, 4.5]],
+            [[1, 2.5], [3, 4.5]],
+            [[Timestamp("20130101"), 3.5], [Timestamp("20130102"), 4.5]],
+        ],
+    )
+    def test_frame_non_unique_columns(self, orient, data):
+        df = DataFrame(data, index=[1, 2], columns=["x", "x"])
 
-    def test_frame_non_unique_columns(self):
+        result = read_json(
+            df.to_json(orient=orient), orient=orient, convert_dates=["x"]
+        )
+        if orient == "values":
+            expected = pd.DataFrame(data)
+            if expected.iloc[:, 0].dtype == "datetime64[ns]":
+                # orient == "values" by default will write Timestamp objects out
+                # in milliseconds; these are internally stored in nanosecond,
+                # so divide to get where we need
+                # TODO: a to_epoch method would also solve; see GH 14772
+                expected.iloc[:, 0] = expected.iloc[:, 0].astype(np.int64) // 1000000
+        elif orient == "split":
+            expected = df
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["index", "columns", "records"])
+    def test_frame_non_unique_columns_raises(self, orient):
         df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 2], columns=["x", "x"])
 
-        msg = "DataFrame columns must be unique for orient='index'"
+        msg = f"DataFrame columns must be unique for orient='{orient}'"
         with pytest.raises(ValueError, match=msg):
-            df.to_json(orient="index")
-        msg = "DataFrame columns must be unique for orient='columns'"
-        with pytest.raises(ValueError, match=msg):
-            df.to_json(orient="columns")
-        msg = "DataFrame columns must be unique for orient='records'"
-        with pytest.raises(ValueError, match=msg):
-            df.to_json(orient="records")
+            df.to_json(orient=orient)
+
+    def test_frame_default_orient(self):
+        assert self.frame.to_json() == self.frame.to_json(orient="columns")
 
-        assert_frame_equal(
-            df, read_json(df.to_json(orient="split"), orient="split", dtype=False)
+    @pytest.mark.parametrize("dtype", [False, float])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_simple(self, orient, convert_axes, numpy, dtype):
+        data = self.frame.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy, dtype=dtype
         )
-        unser = read_json(df.to_json(orient="values"), orient="values")
-        tm.assert_numpy_array_equal(df.values, unser.values)
 
-        # GH4377; duplicate columns not processing correctly
-        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 2], columns=["x", "y"])
-        result = read_json(df.to_json(orient="split"), orient="split")
-        assert_frame_equal(result, df)
+        expected = self.frame.copy()
 
-        def _check(df):
-            result = read_json(
-                df.to_json(orient="split"), orient="split", convert_dates=["x"]
-            )
-            assert_frame_equal(result, df)
+        assert_json_roundtrip_equal(result, expected, orient)
 
-        for o in [
-            [["a", "b"], ["c", "d"]],
-            [[1.5, 2.5], [3.5, 4.5]],
-            [[1, 2.5], [3, 4.5]],
-            [[Timestamp("20130101"), 3.5], [Timestamp("20130102"), 4.5]],
-        ]:
-            _check(DataFrame(o, index=[1, 2], columns=["x", "x"]))
-
-    def test_frame_from_json_to_json(self):
-        def _check_orient(
-            df,
-            orient,
-            dtype=None,
-            numpy=False,
-            convert_axes=True,
-            check_dtype=True,
-            raise_ok=None,
-            sort=None,
-            check_index_type=True,
-            check_column_type=True,
-            check_numpy_dtype=False,
-        ):
-            if sort is not None:
-                df = df.sort_values(sort)
-            else:
-                df = df.sort_index()
-
-            # if we are not unique, then check that we are raising ValueError
-            # for the appropriate orients
-            if not df.index.is_unique and orient in ["index", "columns"]:
-                msg = "DataFrame index must be unique for orient='{}'".format(orient)
-                with pytest.raises(ValueError, match=msg):
-                    df.to_json(orient=orient)
-                return
-            if not df.columns.is_unique and orient in ["index", "columns", "records"]:
-                # TODO: not executed. fix this.
-                with pytest.raises(ValueError, match="ksjkajksfjksjfkjs"):
-                    df.to_json(orient=orient)
-                return
-
-            dfjson = df.to_json(orient=orient)
-
-            try:
-                unser = read_json(
-                    dfjson,
-                    orient=orient,
-                    dtype=dtype,
-                    numpy=numpy,
-                    convert_axes=convert_axes,
-                )
-            except Exception as detail:
-                if raise_ok is not None:
-                    if isinstance(detail, raise_ok):
-                        return
-                raise
-
-            if sort is not None and sort in unser.columns:
-                unser = unser.sort_values(sort)
-            else:
-                unser = unser.sort_index()
-
-            if not dtype:
-                check_dtype = False
-
-            if not convert_axes and df.index.dtype.type == np.datetime64:
-                unser.index = DatetimeIndex(unser.index.values.astype("i8") * 1e6)
-            if orient == "records":
-                # index is not captured in this orientation
-                tm.assert_almost_equal(
-                    df.values, unser.values, check_dtype=check_numpy_dtype
-                )
-                tm.assert_index_equal(
-                    df.columns, unser.columns, exact=check_column_type
-                )
-            elif orient == "values":
-                # index and cols are not captured in this orientation
-                if numpy is True and df.shape == (0, 0):
-                    assert unser.shape[0] == 0
-                else:
-                    tm.assert_almost_equal(
-                        df.values, unser.values, check_dtype=check_numpy_dtype
-                    )
-            elif orient == "split":
-                # index and col labels might not be strings
-                unser.index = [str(i) for i in unser.index]
-                unser.columns = [str(i) for i in unser.columns]
-
-                if sort is None:
-                    unser = unser.sort_index()
-                tm.assert_almost_equal(
-                    df.values, unser.values, check_dtype=check_numpy_dtype
-                )
-            else:
-                if convert_axes:
-                    tm.assert_frame_equal(
-                        df,
-                        unser,
-                        check_dtype=check_dtype,
-                        check_index_type=check_index_type,
-                        check_column_type=check_column_type,
-                    )
-                else:
-                    tm.assert_frame_equal(
-                        df, unser, check_less_precise=False, check_dtype=check_dtype
-                    )
-
-        def _check_all_orients(
-            df,
-            dtype=None,
-            convert_axes=True,
-            raise_ok=None,
-            sort=None,
-            check_index_type=True,
-            check_column_type=True,
+    @pytest.mark.parametrize("dtype", [False, np.int64])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_intframe(self, orient, convert_axes, numpy, dtype):
+        data = self.intframe.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy, dtype=dtype
+        )
+        expected = self.intframe.copy()
+        if (
+            numpy
+            and (is_platform_32bit() or is_platform_windows())
+            and not dtype
+            and orient != "split"
         ):
+            # TODO: see what is causing roundtrip dtype loss
+            expected = expected.astype(np.int32)
 
-            # numpy=False
-            if convert_axes:
-                _check_orient(
-                    df,
-                    "columns",
-                    dtype=dtype,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "records",
-                    dtype=dtype,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "split",
-                    dtype=dtype,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "index",
-                    dtype=dtype,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "values",
-                    dtype=dtype,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-
-            _check_orient(df, "columns", dtype=dtype, convert_axes=False, sort=sort)
-            _check_orient(df, "records", dtype=dtype, convert_axes=False, sort=sort)
-            _check_orient(df, "split", dtype=dtype, convert_axes=False, sort=sort)
-            _check_orient(df, "index", dtype=dtype, convert_axes=False, sort=sort)
-            _check_orient(df, "values", dtype=dtype, convert_axes=False, sort=sort)
-
-            # numpy=True and raise_ok might be not None, so ignore the error
-            if convert_axes:
-                _check_orient(
-                    df,
-                    "columns",
-                    dtype=dtype,
-                    numpy=True,
-                    raise_ok=raise_ok,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "records",
-                    dtype=dtype,
-                    numpy=True,
-                    raise_ok=raise_ok,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "split",
-                    dtype=dtype,
-                    numpy=True,
-                    raise_ok=raise_ok,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "index",
-                    dtype=dtype,
-                    numpy=True,
-                    raise_ok=raise_ok,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-                _check_orient(
-                    df,
-                    "values",
-                    dtype=dtype,
-                    numpy=True,
-                    raise_ok=raise_ok,
-                    sort=sort,
-                    check_index_type=False,
-                    check_column_type=False,
-                )
-
-            _check_orient(
-                df,
-                "columns",
-                dtype=dtype,
-                numpy=True,
-                convert_axes=False,
-                raise_ok=raise_ok,
-                sort=sort,
-            )
-            _check_orient(
-                df,
-                "records",
-                dtype=dtype,
-                numpy=True,
-                convert_axes=False,
-                raise_ok=raise_ok,
-                sort=sort,
-            )
-            _check_orient(
-                df,
-                "split",
-                dtype=dtype,
-                numpy=True,
-                convert_axes=False,
-                raise_ok=raise_ok,
-                sort=sort,
-            )
-            _check_orient(
-                df,
-                "index",
-                dtype=dtype,
-                numpy=True,
-                convert_axes=False,
-                raise_ok=raise_ok,
-                sort=sort,
-            )
-            _check_orient(
-                df,
-                "values",
-                dtype=dtype,
-                numpy=True,
-                convert_axes=False,
-                raise_ok=raise_ok,
-                sort=sort,
-            )
-
-        # basic
-        _check_all_orients(self.frame)
-        assert self.frame.to_json() == self.frame.to_json(orient="columns")
-
-        _check_all_orients(self.intframe, dtype=self.intframe.values.dtype)
-        _check_all_orients(self.intframe, dtype=False)
+        assert_json_roundtrip_equal(result, expected, orient)
 
-        # big one
-        # index and columns are strings as all unserialised JSON object keys
-        # are assumed to be strings
-        biggie = DataFrame(
+    @pytest.mark.parametrize("dtype", [None, np.float64, np.int, "U3"])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_str_axes(self, orient, convert_axes, numpy, dtype):
+        df = DataFrame(
             np.zeros((200, 4)),
             columns=[str(i) for i in range(4)],
             index=[str(i) for i in range(200)],
+            dtype=dtype,
         )
-        _check_all_orients(biggie, dtype=False, convert_axes=False)
 
-        # dtypes
-        _check_all_orients(
-            DataFrame(biggie, dtype=np.float64), dtype=np.float64, convert_axes=False
-        )
-        _check_all_orients(
-            DataFrame(biggie, dtype=np.int), dtype=np.int, convert_axes=False
+        # TODO: do we even need to support U3 dtypes?
+        if numpy and dtype == "U3" and orient != "split":
+            pytest.xfail("Can't decode directly to array")
+
+        data = df.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy, dtype=dtype
         )
-        _check_all_orients(
-            DataFrame(biggie, dtype="U3"),
-            dtype="U3",
-            convert_axes=False,
-            raise_ok=ValueError,
+
+        expected = df.copy()
+        if not dtype:
+            expected = expected.astype(np.int64)
+
+        # index columns, and records orients cannot fully preserve the string
+        # dtype for axes as the index and column labels are used as keys in
+        # JSON objects. JSON keys are by definition strings, so there's no way
+        # to disambiguate whether those keys actually were strings or numeric
+        # beforehand and numeric wins out.
+        # TODO: Split should be able to support this
+        if convert_axes and (orient in ("split", "index", "columns")):
+            expected.columns = expected.columns.astype(np.int64)
+            expected.index = expected.index.astype(np.int64)
+        elif orient == "records" and convert_axes:
+            expected.columns = expected.columns.astype(np.int64)
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_categorical(self, orient, convert_axes, numpy):
+        # TODO: create a better frame to test with and improve coverage
+        if orient in ("index", "columns"):
+            pytest.xfail(f"Can't have duplicate index values for orient '{orient}')")
+
+        data = self.categorical.to_json(orient=orient)
+        if numpy and orient in ("records", "values"):
+            pytest.xfail(f"Orient {orient} is broken with numpy=True")
+
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy
         )
 
-        # categorical
-        _check_all_orients(self.categorical, sort="sort", raise_ok=ValueError)
+        expected = self.categorical.copy()
+        expected.index = expected.index.astype(str)  # Categorical not preserved
+        expected.index.name = None  # index names aren't preserved in JSON
+
+        if not numpy and orient == "index":
+            expected = expected.sort_index()
 
-        # empty
-        _check_all_orients(
-            self.empty_frame, check_index_type=False, check_column_type=False
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_empty(self, orient, convert_axes, numpy):
+        data = self.empty_frame.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy
+        )
+        expected = self.empty_frame.copy()
+
+        # TODO: both conditions below are probably bugs
+        if convert_axes:
+            expected.index = expected.index.astype(float)
+            expected.columns = expected.columns.astype(float)
+        if numpy and orient == "values":
+            expected = expected.reindex([0], axis=1).reset_index(drop=True)
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_timestamp(self, orient, convert_axes, numpy):
+        # TODO: improve coverage with date_format parameter
+        data = self.tsframe.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy
         )
+        expected = self.tsframe.copy()
 
-        # time series data
-        _check_all_orients(self.tsframe)
+        if not convert_axes:  # one off for ts handling
+            # DTI gets converted to epoch values
+            idx = expected.index.astype(np.int64) // 1000000
+            if orient != "split":  # TODO: handle consistently across orients
+                idx = idx.astype(str)
+
+            expected.index = idx
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_roundtrip_mixed(self, orient, convert_axes, numpy):
+        if numpy and orient != "split":
+            pytest.xfail("Can't decode directly to array")
 
-        # mixed data
         index = pd.Index(["a", "b", "c", "d", "e"])
-        data = {
+        values = {
             "A": [0.0, 1.0, 2.0, 3.0, 4.0],
             "B": [0.0, 1.0, 0.0, 1.0, 0.0],
             "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
             "D": [True, False, True, False, True],
         }
-        df = DataFrame(data=data, index=index)
-        _check_orient(df, "split", check_dtype=False)
-        _check_orient(df, "records", check_dtype=False)
-        _check_orient(df, "values", check_dtype=False)
-        _check_orient(df, "columns", check_dtype=False)
-        # index oriented is problematic as it is read back in in a transposed
-        # state, so the columns are interpreted as having mixed data and
-        # given object dtypes.
-        # force everything to have object dtype beforehand
-        _check_orient(df.transpose().transpose(), "index", dtype=False)
-
-    def test_frame_from_json_bad_data(self):
-        with pytest.raises(ValueError, match="Expected object or value"):
-            read_json(StringIO('{"key":b:a:d}'))
-
-        # too few indices
-        json = StringIO(
-            '{"columns":["A","B"],'
-            '"index":["2","3"],'
-            '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}'
-        )
-        msg = r"Shape of passed values is \(3, 2\), indices imply \(2, 2\)"
-        with pytest.raises(ValueError, match=msg):
-            read_json(json, orient="split")
 
-        # too many columns
-        json = StringIO(
-            '{"columns":["A","B","C"],'
-            '"index":["1","2","3"],'
-            '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}'
+        df = DataFrame(data=values, index=index)
+
+        data = df.to_json(orient=orient)
+        result = pd.read_json(
+            data, orient=orient, convert_axes=convert_axes, numpy=numpy
         )
-        msg = "3 columns passed, passed data had 2 columns"
+
+        expected = df.copy()
+        expected = expected.assign(**expected.select_dtypes("number").astype(np.int64))
+
+        if not numpy and orient == "index":
+            expected = expected.sort_index()
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize(
+        "data,msg,orient",
+        [
+            ('{"key":b:a:d}', "Expected object or value", "columns"),
+            # too few indices
+            (
+                '{"columns":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                r"Shape of passed values is \(3, 2\), indices imply \(2, 2\)",
+                "split",
+            ),
+            # too many columns
+            (
+                '{"columns":["A","B","C"],'
+                '"index":["1","2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                "3 columns passed, passed data had 2 columns",
+                "split",
+            ),
+            # bad key
+            (
+                '{"badkey":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                r"unexpected key\(s\): badkey",
+                "split",
+            ),
+        ],
+    )
+    def test_frame_from_json_bad_data_raises(self, data, msg, orient):
         with pytest.raises(ValueError, match=msg):
-            read_json(json, orient="split")
+            read_json(StringIO(data), orient=orient)
 
-        # bad key
-        json = StringIO(
-            '{"badkey":["A","B"],'
-            '"index":["2","3"],'
-            '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}'
+    @pytest.mark.parametrize("dtype", [True, False])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_frame_from_json_missing_data(self, orient, convert_axes, numpy, dtype):
+        num_df = DataFrame([[1, 2], [4, 5, 6]])
+        result = read_json(
+            num_df.to_json(orient=orient),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
         )
-        with pytest.raises(ValueError, match=r"unexpected key\(s\): badkey"):
-            read_json(json, orient="split")
+        assert np.isnan(result.iloc[0, 2])
 
-    def test_frame_from_json_nones(self):
-        df = DataFrame([[1, 2], [4, 5, 6]])
-        unser = read_json(df.to_json())
-        assert np.isnan(unser[2][0])
-
-        df = DataFrame([["1", "2"], ["4", "5", "6"]])
-        unser = read_json(df.to_json())
-        assert np.isnan(unser[2][0])
-        unser = read_json(df.to_json(), dtype=False)
-        assert unser[2][0] is None
-        unser = read_json(df.to_json(), convert_axes=False, dtype=False)
-        assert unser["2"]["0"] is None
-
-        unser = read_json(df.to_json(), numpy=False)
-        assert np.isnan(unser[2][0])
-        unser = read_json(df.to_json(), numpy=False, dtype=False)
-        assert unser[2][0] is None
-        unser = read_json(df.to_json(), numpy=False, convert_axes=False, dtype=False)
-        assert unser["2"]["0"] is None
+        obj_df = DataFrame([["1", "2"], ["4", "5", "6"]])
+        result = read_json(
+            obj_df.to_json(orient=orient),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
+        )
+        if not dtype:  # TODO: Special case for object data; maybe a bug?
+            assert result.iloc[0, 2] is None
+        else:
+            assert np.isnan(result.iloc[0, 2])
 
+    @pytest.mark.parametrize("inf", [np.inf, np.NINF])
+    @pytest.mark.parametrize("dtype", [True, False])
+    def test_frame_infinity(self, orient, inf, dtype):
         # infinities get mapped to nulls which get mapped to NaNs during
         # deserialisation
         df = DataFrame([[1, 2], [4, 5, 6]])
-        df.loc[0, 2] = np.inf
-        unser = read_json(df.to_json())
-        assert np.isnan(unser[2][0])
-        unser = read_json(df.to_json(), dtype=False)
-        assert np.isnan(unser[2][0])
-
-        df.loc[0, 2] = np.NINF
-        unser = read_json(df.to_json())
-        assert np.isnan(unser[2][0])
-        unser = read_json(df.to_json(), dtype=False)
-        assert np.isnan(unser[2][0])
+        df.loc[0, 2] = inf
+        result = read_json(df.to_json(), dtype=dtype)
+        assert np.isnan(result.iloc[0, 2])
 
     @pytest.mark.skipif(
         is_platform_32bit(), reason="not compliant on 32-bit, xref #15865"
     )
-    def test_frame_to_json_float_precision(self):
-        df = pd.DataFrame([dict(a_float=0.95)])
-        encoded = df.to_json(double_precision=1)
-        assert encoded == '{"a_float":{"0":1.0}}'
-
-        df = pd.DataFrame([dict(a_float=1.95)])
-        encoded = df.to_json(double_precision=1)
-        assert encoded == '{"a_float":{"0":2.0}}'
-
-        df = pd.DataFrame([dict(a_float=-1.95)])
-        encoded = df.to_json(double_precision=1)
-        assert encoded == '{"a_float":{"0":-2.0}}'
-
-        df = pd.DataFrame([dict(a_float=0.995)])
-        encoded = df.to_json(double_precision=2)
-        assert encoded == '{"a_float":{"0":1.0}}'
-
-        df = pd.DataFrame([dict(a_float=0.9995)])
-        encoded = df.to_json(double_precision=3)
-        assert encoded == '{"a_float":{"0":1.0}}'
-
-        df = pd.DataFrame([dict(a_float=0.99999999999999944)])
-        encoded = df.to_json(double_precision=15)
-        assert encoded == '{"a_float":{"0":1.0}}'
+    @pytest.mark.parametrize(
+        "value,precision,expected_val",
+        [
+            (0.95, 1, 1.0),
+            (1.95, 1, 2.0),
+            (-1.95, 1, -2.0),
+            (0.995, 2, 1.0),
+            (0.9995, 3, 1.0),
+            (0.99999999999999944, 15, 1.0),
+        ],
+    )
+    def test_frame_to_json_float_precision(self, value, precision, expected_val):
+        df = pd.DataFrame([dict(a_float=value)])
+        encoded = df.to_json(double_precision=precision)
+        assert encoded == f'{{"a_float":{{"0":{expected_val}}}}}'
 
     def test_frame_to_json_except(self):
         df = DataFrame([1, 2, 3])
@@ -575,7 +410,7 @@ def test_frame_to_json_except(self):
     def test_frame_empty(self):
         df = DataFrame(columns=["jim", "joe"])
         assert not df._is_mixed_type
-        assert_frame_equal(
+        tm.assert_frame_equal(
             read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False
         )
         # GH 7445
@@ -588,7 +423,7 @@ def test_frame_empty_mixedtype(self):
         df = DataFrame(columns=["jim", "joe"])
         df["joe"] = df["joe"].astype("i8")
         assert df._is_mixed_type
-        assert_frame_equal(
+        tm.assert_frame_equal(
             read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False
         )
 
@@ -610,17 +445,17 @@ def test_frame_mixedtype_orient(self):  # GH10289
         for orient in ["split", "index", "columns"]:
             inp = df.to_json(orient=orient)
             left = read_json(inp, orient=orient, convert_axes=False)
-            assert_frame_equal(left, right)
+            tm.assert_frame_equal(left, right)
 
         right.index = np.arange(len(df))
         inp = df.to_json(orient="records")
         left = read_json(inp, orient="records", convert_axes=False)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
         right.columns = np.arange(df.shape[1])
         inp = df.to_json(orient="values")
         left = read_json(inp, orient="values", convert_axes=False)
-        assert_frame_equal(left, right)
+        tm.assert_frame_equal(left, right)
 
     def test_v12_compat(self):
         df = DataFrame(
@@ -641,12 +476,12 @@ def test_v12_compat(self):
 
         v12_json = os.path.join(self.dirpath, "tsframe_v012.json")
         df_unser = pd.read_json(v12_json)
-        assert_frame_equal(df, df_unser)
+        tm.assert_frame_equal(df, df_unser)
 
         df_iso = df.drop(["modified"], axis=1)
         v12_iso_json = os.path.join(self.dirpath, "tsframe_iso_v012.json")
         df_unser_iso = pd.read_json(v12_iso_json)
-        assert_frame_equal(df_iso, df_unser_iso)
+        tm.assert_frame_equal(df_iso, df_unser_iso)
 
     def test_blocks_compat_GH9037(self):
         index = pd.date_range("20000101", periods=10, freq="H")
@@ -732,7 +567,7 @@ def test_blocks_compat_GH9037(self):
         df_mixed.columns = df_mixed.columns.astype("unicode")
 
         df_roundtrip = pd.read_json(df_mixed.to_json(orient="split"), orient="split")
-        assert_frame_equal(
+        tm.assert_frame_equal(
             df_mixed,
             df_roundtrip,
             check_index_type=True,
@@ -750,7 +585,7 @@ def __init__(self, hexed):
                 self.hexed = hexed
                 self.binary = bytes.fromhex(hexed)
 
-            def __str__(self):
+            def __str__(self) -> str:
                 return self.hexed
 
         hexed = "574b4454ba8c5eb4f98a8f45"
@@ -758,7 +593,7 @@ def __str__(self):
 
         # verify the proper conversion of printable content
         df_printable = DataFrame({"A": [binthing.hexed]})
-        assert df_printable.to_json() == '{{"A":{{"0":"{hex}"}}}}'.format(hex=hexed)
+        assert df_printable.to_json() == f'{{"A":{{"0":"{hexed}"}}}}'
 
         # check if non-printable content throws appropriate Exception
         df_nonprintable = DataFrame({"A": [binthing]})
@@ -772,19 +607,19 @@ def __str__(self):
             df_mixed.to_json()
 
         # default_handler should resolve exceptions for non-string types
-        assert df_nonprintable.to_json(
-            default_handler=str
-        ) == '{{"A":{{"0":"{hex}"}}}}'.format(hex=hexed)
-        assert df_mixed.to_json(
-            default_handler=str
-        ) == '{{"A":{{"0":"{hex}"}},"B":{{"0":1}}}}'.format(hex=hexed)
+        result = df_nonprintable.to_json(default_handler=str)
+        expected = f'{{"A":{{"0":"{hexed}"}}}}'
+        assert result == expected
+        assert (
+            df_mixed.to_json(default_handler=str)
+            == f'{{"A":{{"0":"{hexed}"}},"B":{{"0":1}}}}'
+        )
 
     def test_label_overflow(self):
         # GH14256: buffer length not checked when writing label
-        df = pd.DataFrame({"bar" * 100000: [1], "foo": [1337]})
-        assert df.to_json() == '{{"{bar}":{{"0":1}},"foo":{{"0":1337}}}}'.format(
-            bar=("bar" * 100000)
-        )
+        result = pd.DataFrame({"bar" * 100000: [1], "foo": [1337]}).to_json()
+        expected = f'{{"{"bar" * 100000}":{{"0":1}},"foo":{{"0":1337}}}}'
+        assert result == expected
 
     def test_series_non_unique_index(self):
         s = Series(["a", "b"], index=[1, 1])
@@ -793,113 +628,83 @@ def test_series_non_unique_index(self):
         with pytest.raises(ValueError, match=msg):
             s.to_json(orient="index")
 
-        assert_series_equal(
+        tm.assert_series_equal(
             s, read_json(s.to_json(orient="split"), orient="split", typ="series")
         )
         unser = read_json(s.to_json(orient="records"), orient="records", typ="series")
         tm.assert_numpy_array_equal(s.values, unser.values)
 
-    def test_series_from_json_to_json(self):
-        def _check_orient(
-            series, orient, dtype=None, numpy=False, check_index_type=True
-        ):
-            series = series.sort_index()
-            unser = read_json(
-                series.to_json(orient=orient),
-                typ="series",
-                orient=orient,
-                numpy=numpy,
-                dtype=dtype,
-            )
-            unser = unser.sort_index()
-            if orient == "records" or orient == "values":
-                assert_almost_equal(series.values, unser.values)
-            else:
-                if orient == "split":
-                    assert_series_equal(
-                        series, unser, check_index_type=check_index_type
-                    )
-                else:
-                    assert_series_equal(
-                        series,
-                        unser,
-                        check_names=False,
-                        check_index_type=check_index_type,
-                    )
-
-        def _check_all_orients(series, dtype=None, check_index_type=True):
-            _check_orient(
-                series, "columns", dtype=dtype, check_index_type=check_index_type
-            )
-            _check_orient(
-                series, "records", dtype=dtype, check_index_type=check_index_type
-            )
-            _check_orient(
-                series, "split", dtype=dtype, check_index_type=check_index_type
-            )
-            _check_orient(
-                series, "index", dtype=dtype, check_index_type=check_index_type
-            )
-            _check_orient(series, "values", dtype=dtype)
-
-            _check_orient(
-                series,
-                "columns",
-                dtype=dtype,
-                numpy=True,
-                check_index_type=check_index_type,
-            )
-            _check_orient(
-                series,
-                "records",
-                dtype=dtype,
-                numpy=True,
-                check_index_type=check_index_type,
-            )
-            _check_orient(
-                series,
-                "split",
-                dtype=dtype,
-                numpy=True,
-                check_index_type=check_index_type,
-            )
-            _check_orient(
-                series,
-                "index",
-                dtype=dtype,
-                numpy=True,
-                check_index_type=check_index_type,
-            )
-            _check_orient(
-                series,
-                "values",
-                dtype=dtype,
-                numpy=True,
-                check_index_type=check_index_type,
-            )
-
-        # basic
-        _check_all_orients(self.series)
+    def test_series_default_orient(self):
         assert self.series.to_json() == self.series.to_json(orient="index")
 
-        objSeries = Series(
-            [str(d) for d in self.objSeries],
-            index=self.objSeries.index,
-            name=self.objSeries.name,
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_series_roundtrip_simple(self, orient, numpy):
+        data = self.series.to_json(orient=orient)
+        result = pd.read_json(data, typ="series", orient=orient, numpy=numpy)
+        expected = self.series.copy()
+
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [False, None])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_series_roundtrip_object(self, orient, numpy, dtype):
+        data = self.objSeries.to_json(orient=orient)
+        result = pd.read_json(
+            data, typ="series", orient=orient, numpy=numpy, dtype=dtype
         )
-        _check_all_orients(objSeries, dtype=False)
+        expected = self.objSeries.copy()
+
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_series_roundtrip_empty(self, orient, numpy):
+        data = self.empty_series.to_json(orient=orient)
+        result = pd.read_json(data, typ="series", orient=orient, numpy=numpy)
+        expected = self.empty_series.copy()
 
-        # empty_series has empty index with object dtype
-        # which cannot be revert
-        assert self.empty_series.index.dtype == np.object_
-        _check_all_orients(self.empty_series, check_index_type=False)
+        # TODO: see what causes inconsistency
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        else:
+            expected.index = expected.index.astype(float)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_series_roundtrip_timeseries(self, orient, numpy):
+        data = self.ts.to_json(orient=orient)
+        result = pd.read_json(data, typ="series", orient=orient, numpy=numpy)
+        expected = self.ts.copy()
+
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
 
-        _check_all_orients(self.ts)
+        tm.assert_series_equal(result, expected)
 
-        # dtype
+    @pytest.mark.parametrize("dtype", [np.float64, np.int])
+    @pytest.mark.parametrize("numpy", [True, False])
+    def test_series_roundtrip_numeric(self, orient, numpy, dtype):
         s = Series(range(6), index=["a", "b", "c", "d", "e", "f"])
-        _check_all_orients(Series(s, dtype=np.float64), dtype=np.float64)
-        _check_all_orients(Series(s, dtype=np.int), dtype=np.int)
+        data = s.to_json(orient=orient)
+        result = pd.read_json(data, typ="series", orient=orient, numpy=numpy)
+
+        expected = s.copy()
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+
+        tm.assert_series_equal(result, expected)
 
     def test_series_to_json_except(self):
         s = Series([1, 2, 3])
@@ -910,39 +715,54 @@ def test_series_to_json_except(self):
     def test_series_from_json_precise_float(self):
         s = Series([4.56, 4.56, 4.56])
         result = read_json(s.to_json(), typ="series", precise_float=True)
-        assert_series_equal(result, s, check_index_type=False)
+        tm.assert_series_equal(result, s, check_index_type=False)
 
     def test_series_with_dtype(self):
         # GH 21986
         s = Series([4.56, 4.56, 4.56])
         result = read_json(s.to_json(), typ="series", dtype=np.int64)
         expected = Series([4] * 3)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype,expected",
+        [
+            (True, Series(["2000-01-01"], dtype="datetime64[ns]")),
+            (False, Series([946684800000])),
+        ],
+    )
+    def test_series_with_dtype_datetime(self, dtype, expected):
+        s = Series(["2000-01-01"], dtype="datetime64[ns]")
+        data = s.to_json()
+        result = pd.read_json(data, typ="series", dtype=dtype)
+        tm.assert_series_equal(result, expected)
 
     def test_frame_from_json_precise_float(self):
         df = DataFrame([[4.56, 4.56, 4.56], [4.56, 4.56, 4.56]])
         result = read_json(df.to_json(), precise_float=True)
-        assert_frame_equal(result, df, check_index_type=False, check_column_type=False)
+        tm.assert_frame_equal(
+            result, df, check_index_type=False, check_column_type=False
+        )
 
     def test_typ(self):
 
         s = Series(range(6), index=["a", "b", "c", "d", "e", "f"], dtype="int64")
         result = read_json(s.to_json(), typ=None)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
     def test_reconstruction_index(self):
 
         df = DataFrame([[1, 2, 3], [4, 5, 6]])
         result = read_json(df.to_json())
 
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["A", "B", "C"])
         result = read_json(df.to_json())
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_path(self):
-        with ensure_clean("test.json") as path:
+        with tm.ensure_clean("test.json") as path:
             for df in [
                 self.frame,
                 self.frame2,
@@ -958,12 +778,12 @@ def test_axis_dates(self):
         # frame
         json = self.tsframe.to_json()
         result = read_json(json)
-        assert_frame_equal(result, self.tsframe)
+        tm.assert_frame_equal(result, self.tsframe)
 
         # series
         json = self.ts.to_json()
         result = read_json(json, typ="series")
-        assert_series_equal(result, self.ts, check_names=False)
+        tm.assert_series_equal(result, self.ts, check_names=False)
         assert result.name is None
 
     def test_convert_dates(self):
@@ -974,7 +794,7 @@ def test_convert_dates(self):
 
         json = df.to_json()
         result = read_json(json)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         df["foo"] = 1.0
         json = df.to_json(date_unit="ns")
@@ -983,19 +803,42 @@ def test_convert_dates(self):
         expected = df.copy()
         expected["date"] = expected["date"].values.view("i8")
         expected["foo"] = expected["foo"].astype("int64")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # series
         ts = Series(Timestamp("20130101"), index=self.ts.index)
         json = ts.to_json()
         result = read_json(json, typ="series")
-        assert_series_equal(result, ts)
+        tm.assert_series_equal(result, ts)
 
-    def test_convert_dates_infer(self):
-        # GH10747
-        from pandas.io.json import dumps
+    @pytest.mark.parametrize("date_format", ["epoch", "iso"])
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize(
+        "date_typ", [datetime.date, datetime.datetime, pd.Timestamp]
+    )
+    def test_date_index_and_values(self, date_format, as_object, date_typ):
+        data = [date_typ(year=2020, month=1, day=1), pd.NaT]
+        if as_object:
+            data.append("a")
 
-        infer_words = [
+        ser = pd.Series(data, index=data)
+        result = ser.to_json(date_format=date_format)
+
+        if date_format == "epoch":
+            expected = '{"1577836800000":1577836800000,"null":null}'
+        else:
+            expected = (
+                '{"2020-01-01T00:00:00.000Z":"2020-01-01T00:00:00.000Z","null":null}'
+            )
+
+        if as_object:
+            expected = expected.replace("}", ',"a":"a"}')
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "infer_word",
+        [
             "trade_time",
             "date",
             "datetime",
@@ -1003,14 +846,18 @@ def test_convert_dates_infer(self):
             "modified",
             "timestamp",
             "timestamps",
-        ]
-        for infer_word in infer_words:
-            data = [{"id": 1, infer_word: 1036713600000}, {"id": 2}]
-            expected = DataFrame(
-                [[1, Timestamp("2002-11-08")], [2, pd.NaT]], columns=["id", infer_word]
-            )
-            result = read_json(dumps(data))[["id", infer_word]]
-            assert_frame_equal(result, expected)
+        ],
+    )
+    def test_convert_dates_infer(self, infer_word):
+        # GH10747
+        from pandas.io.json import dumps
+
+        data = [{"id": 1, infer_word: 1036713600000}, {"id": 2}]
+        expected = DataFrame(
+            [[1, Timestamp("2002-11-08")], [2, pd.NaT]], columns=["id", infer_word]
+        )
+        result = read_json(dumps(data))[["id", infer_word]]
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "date,date_unit",
@@ -1034,9 +881,9 @@ def test_date_format_frame(self, date, date_unit):
             json = df.to_json(date_format="iso")
         result = read_json(json)
         expected = df.copy()
-        # expected.index = expected.index.tz_localize("UTC")
+        expected.index = expected.index.tz_localize("UTC")
         expected["date"] = expected["date"].dt.tz_localize("UTC")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_date_format_frame_raises(self):
         df = self.tsframe.copy()
@@ -1064,9 +911,9 @@ def test_date_format_series(self, date, date_unit):
             json = ts.to_json(date_format="iso")
         result = read_json(json, typ="series")
         expected = ts.copy()
-        # expected.index = expected.index.tz_localize("UTC")
+        expected.index = expected.index.tz_localize("UTC")
         expected = expected.dt.tz_localize("UTC")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_date_format_series_raises(self):
         ts = Series(Timestamp("20130101 20:43:42.123"), index=self.ts.index)
@@ -1087,11 +934,11 @@ def test_date_unit(self, unit):
 
         # force date unit
         result = read_json(json, date_unit=unit)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         # detect date unit
         result = read_json(json, date_unit=None)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_weird_nested_json(self):
         # this used to core dump the parser
@@ -1124,7 +971,7 @@ def test_doc_example(self):
 
         json = dfj2.to_json()
         result = read_json(json, dtype={"ints": np.int64, "bools": np.bool_})
-        assert_frame_equal(result, result)
+        tm.assert_frame_equal(result, result)
 
     def test_misc_example(self):
 
@@ -1138,13 +985,13 @@ def test_misc_example(self):
 \\[left\\]:  Index\\(\\['a', 'b'\\], dtype='object'\\)
 \\[right\\]: RangeIndex\\(start=0, stop=2, step=1\\)"""
         with pytest.raises(AssertionError, match=error_msg):
-            assert_frame_equal(result, expected, check_index_type=False)
+            tm.assert_frame_equal(result, expected, check_index_type=False)
 
         result = read_json('[{"a": 1, "b": 2}, {"b":2, "a" :1}]')
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
-    @network
+    @tm.network
     @pytest.mark.single
     def test_round_trip_exception_(self):
         # GH 3867
@@ -1152,9 +999,9 @@ def test_round_trip_exception_(self):
         df = pd.read_csv(csv)
         s = df.to_json()
         result = pd.read_json(s)
-        assert_frame_equal(result.reindex(index=df.index, columns=df.columns), df)
+        tm.assert_frame_equal(result.reindex(index=df.index, columns=df.columns), df)
 
-    @network
+    @tm.network
     @pytest.mark.single
     @pytest.mark.parametrize(
         "field,dtype",
@@ -1176,16 +1023,16 @@ def test_timedelta(self):
         assert s.dtype == "timedelta64[ns]"
 
         result = pd.read_json(s.to_json(), typ="series").apply(converter)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         s = Series([timedelta(23), timedelta(seconds=5)], index=pd.Index([0, 1]))
         assert s.dtype == "timedelta64[ns]"
         result = pd.read_json(s.to_json(), typ="series").apply(converter)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         frame = DataFrame([timedelta(23), timedelta(seconds=5)])
         assert frame[0].dtype == "timedelta64[ns]"
-        assert_frame_equal(frame, pd.read_json(frame.to_json()).apply(converter))
+        tm.assert_frame_equal(frame, pd.read_json(frame.to_json()).apply(converter))
 
         frame = DataFrame(
             {
@@ -1198,7 +1045,7 @@ def test_timedelta(self):
         result = pd.read_json(frame.to_json(date_unit="ns"))
         result["a"] = pd.to_timedelta(result.a, unit="ns")
         result["c"] = pd.to_datetime(result.c)
-        assert_frame_equal(frame, result)
+        tm.assert_frame_equal(frame, result)
 
     def test_mixed_timedelta_datetime(self):
         frame = DataFrame(
@@ -1209,14 +1056,14 @@ def test_mixed_timedelta_datetime(self):
             {"a": [pd.Timedelta(frame.a[0]).value, pd.Timestamp(frame.a[1]).value]}
         )
         result = pd.read_json(frame.to_json(date_unit="ns"), dtype={"a": "int64"})
-        assert_frame_equal(result, expected, check_index_type=False)
+        tm.assert_frame_equal(result, expected, check_index_type=False)
 
     def test_default_handler(self):
         value = object()
         frame = DataFrame({"a": [7, value]})
         expected = DataFrame({"a": [7, str(value)]})
         result = pd.read_json(frame.to_json(default_handler=str))
-        assert_frame_equal(expected, result, check_index_type=False)
+        tm.assert_frame_equal(expected, result, check_index_type=False)
 
     def test_default_handler_indirect(self):
         from pandas.io.json import dumps
@@ -1296,46 +1143,48 @@ def test_datetime_tz(self):
         s_naive = Series(tz_naive)
         assert stz.to_json() == s_naive.to_json()
 
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
     def test_sparse(self):
         # GH4377 df.to_json segfaults with non-ndarray blocks
         df = pd.DataFrame(np.random.randn(10, 4))
         df.loc[:8] = np.nan
 
-        sdf = df.to_sparse()
+        sdf = df.astype("Sparse")
         expected = df.to_json()
         assert expected == sdf.to_json()
 
         s = pd.Series(np.random.randn(10))
         s.loc[:8] = np.nan
-        ss = s.to_sparse()
+        ss = s.astype("Sparse")
 
         expected = s.to_json()
         assert expected == ss.to_json()
 
-    def test_tz_is_utc(self):
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("2013-01-10 05:00:00Z"),
+            Timestamp("2013-01-10 00:00:00", tz="US/Eastern"),
+            Timestamp("2013-01-10 00:00:00-0500"),
+        ],
+    )
+    def test_tz_is_utc(self, ts):
         from pandas.io.json import dumps
 
         exp = '"2013-01-10T05:00:00.000Z"'
 
-        ts = Timestamp("2013-01-10 05:00:00Z")
         assert dumps(ts, iso_dates=True) == exp
         dt = ts.to_pydatetime()
         assert dumps(dt, iso_dates=True) == exp
 
-        ts = Timestamp("2013-01-10 00:00:00", tz="US/Eastern")
-        assert dumps(ts, iso_dates=True) == exp
-        dt = ts.to_pydatetime()
-        assert dumps(dt, iso_dates=True) == exp
-
-        ts = Timestamp("2013-01-10 00:00:00-0500")
-        assert dumps(ts, iso_dates=True) == exp
-        dt = ts.to_pydatetime()
-        assert dumps(dt, iso_dates=True) == exp
-
-    def test_tz_range_is_utc(self):
+    @pytest.mark.parametrize(
+        "tz_range",
+        [
+            pd.date_range("2013-01-01 05:00:00Z", periods=2),
+            pd.date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern"),
+            pd.date_range("2013-01-01 00:00:00-0500", periods=2),
+        ],
+    )
+    def test_tz_range_is_utc(self, tz_range):
         from pandas.io.json import dumps
 
         exp = '["2013-01-01T05:00:00.000Z","2013-01-02T05:00:00.000Z"]'
@@ -1345,7 +1194,6 @@ def test_tz_range_is_utc(self):
             '"1":"2013-01-02T05:00:00.000Z"}}'
         )
 
-        tz_range = pd.date_range("2013-01-01 05:00:00Z", periods=2)
         assert dumps(tz_range, iso_dates=True) == exp
         dti = pd.DatetimeIndex(tz_range)
         assert dumps(dti, iso_dates=True) == exp
@@ -1353,25 +1201,11 @@ def test_tz_range_is_utc(self):
         result = dumps(df, iso_dates=True)
         assert result == dfexp
 
-        tz_range = pd.date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern")
-        assert dumps(tz_range, iso_dates=True) == exp
-        dti = pd.DatetimeIndex(tz_range)
-        assert dumps(dti, iso_dates=True) == exp
-        df = DataFrame({"DT": dti})
-        assert dumps(df, iso_dates=True) == dfexp
-
-        tz_range = pd.date_range("2013-01-01 00:00:00-0500", periods=2)
-        assert dumps(tz_range, iso_dates=True) == exp
-        dti = pd.DatetimeIndex(tz_range)
-        assert dumps(dti, iso_dates=True) == exp
-        df = DataFrame({"DT": dti})
-        assert dumps(df, iso_dates=True) == dfexp
-
     def test_read_inline_jsonl(self):
         # GH9180
         result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @td.skip_if_not_us_locale
     def test_read_s3_jsonl(self, s3_resource):
@@ -1379,16 +1213,16 @@ def test_read_s3_jsonl(self, s3_resource):
 
         result = read_json("s3n://pandas-test/items.jsonl", lines=True)
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_local_jsonl(self):
         # GH17200
-        with ensure_clean("tmp_items.json") as path:
+        with tm.ensure_clean("tmp_items.json") as path:
             with open(path, "w") as infile:
                 infile.write('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n')
             result = read_json(path, lines=True)
             expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_read_jsonl_unicode_chars(self):
         # GH15132: non-ascii unicode characters
@@ -1399,13 +1233,13 @@ def test_read_jsonl_unicode_chars(self):
         json = StringIO(json)
         result = read_json(json, lines=True)
         expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # simulate string
         json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
         result = read_json(json, lines=True)
         expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_json_large_numbers(self):
         # GH18842
@@ -1413,13 +1247,13 @@ def test_read_json_large_numbers(self):
         json = StringIO(json)
         result = read_json(json, typ="series")
         expected = Series(1.404366e21, index=["articleId"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         json = '{"0": {"articleId": "1404366058080022500245"}}'
         json = StringIO(json)
         result = read_json(json)
         expected = DataFrame(1.404366e21, index=["articleId"], columns=[0])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_to_jsonl(self):
         # GH9180
@@ -1432,14 +1266,14 @@ def test_to_jsonl(self):
         result = df.to_json(orient="records", lines=True)
         expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}'
         assert result == expected
-        assert_frame_equal(pd.read_json(result, lines=True), df)
+        tm.assert_frame_equal(pd.read_json(result, lines=True), df)
 
         # GH15096: escaped characters in columns and data
         df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
         result = df.to_json(orient="records", lines=True)
-        expected = '{"a\\\\":"foo\\\\","b":"bar"}\n' '{"a\\\\":"foo\\"","b":"bar"}'
+        expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}'
         assert result == expected
-        assert_frame_equal(pd.read_json(result, lines=True), df)
+        tm.assert_frame_equal(pd.read_json(result, lines=True), df)
 
     # TODO: there is a near-identical test for pytables; can we share?
     def test_latin_encoding(self):
@@ -1458,14 +1292,10 @@ def test_latin_encoding(self):
             [b"A\xf8\xfc", np.nan, b"", b"b", b"c"],
         ]
 
-        def _try_decode(x, encoding="latin-1"):
-            try:
-                return x.decode(encoding)
-            except AttributeError:
-                return x
-
-        # not sure how to remove latin-1 from code in python 2 and 3
-        values = [[_try_decode(x) for x in y] for y in values]
+        values = [
+            [x.decode("latin-1") if isinstance(x, bytes) else x for x in y]
+            for y in values
+        ]
 
         examples = []
         for dtype in ["category", object]:
@@ -1473,10 +1303,10 @@ def _try_decode(x, encoding="latin-1"):
                 examples.append(Series(val, dtype=dtype))
 
         def roundtrip(s, encoding="latin-1"):
-            with ensure_clean("test.json") as path:
+            with tm.ensure_clean("test.json") as path:
                 s.to_json(path, encoding=encoding)
                 retr = read_json(path, encoding=encoding)
-                assert_series_equal(s, retr, check_categorical=False)
+                tm.assert_series_equal(s, retr, check_categorical=False)
 
         for s in examples:
             roundtrip(s)
@@ -1500,14 +1330,14 @@ def test_from_json_to_json_table_index_and_columns(self, index, columns):
         expected = DataFrame([[1, 2], [3, 4]], index=index, columns=columns)
         dfjson = expected.to_json(orient="table")
         result = pd.read_json(dfjson, orient="table")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_from_json_to_json_table_dtypes(self):
         # GH21345
         expected = pd.DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
         dfjson = expected.to_json(orient="table")
         result = pd.read_json(dfjson, orient="table")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("dtype", [True, {"b": int, "c": int}])
     def test_read_json_table_dtype_raises(self, dtype):
@@ -1611,7 +1441,7 @@ def test_index_false_from_json_to_json(self, orient, index):
         expected = DataFrame({"a": [1, 2], "b": [3, 4]})
         dfjson = expected.to_json(orient=orient, index=index)
         result = read_json(dfjson, orient=orient)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_timezone_information(self):
         # GH 25546
@@ -1619,14 +1449,14 @@ def test_read_timezone_information(self):
             '{"2019-01-01T11:00:00.000Z":88}', typ="series", orient="index"
         )
         expected = Series([88], index=DatetimeIndex(["2019-01-01 11:00:00"], tz="UTC"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "date_format,key", [("epoch", 86400000), ("iso", "P1DT0H0M0S")]
     )
     def test_timedelta_as_label(self, date_format, key):
         df = pd.DataFrame([[1]], columns=[pd.Timedelta("1D")])
-        expected = '{{"{key}":{{"0":1}}}}'.format(key=key)
+        expected = f'{{"{key}":{{"0":1}}}}'
         result = df.to_json(date_format=date_format)
 
         assert result == expected
@@ -1647,3 +1477,207 @@ def test_tuple_labels(self, orient, expected):
         df = pd.DataFrame([[1]], index=[("a", "b")], columns=[("c", "d")])
         result = df.to_json(orient=orient)
         assert result == expected
+
+    @pytest.mark.parametrize("indent", [1, 2, 4])
+    def test_to_json_indent(self, indent):
+        # GH 12004
+        df = pd.DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+
+        result = df.to_json(indent=indent)
+        spaces = " " * indent
+        expected = f"""{{
+{spaces}"a":{{
+{spaces}{spaces}"0":"foo",
+{spaces}{spaces}"1":"baz"
+{spaces}}},
+{spaces}"b":{{
+{spaces}{spaces}"0":"bar",
+{spaces}{spaces}"1":"qux"
+{spaces}}}
+}}"""
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "orient,expected",
+        [
+            (
+                "split",
+                """{
+    "columns":[
+        "a",
+        "b"
+    ],
+    "index":[
+        0,
+        1
+    ],
+    "data":[
+        [
+            "foo",
+            "bar"
+        ],
+        [
+            "baz",
+            "qux"
+        ]
+    ]
+}""",
+            ),
+            (
+                "records",
+                """[
+    {
+        "a":"foo",
+        "b":"bar"
+    },
+    {
+        "a":"baz",
+        "b":"qux"
+    }
+]""",
+            ),
+            (
+                "index",
+                """{
+    "0":{
+        "a":"foo",
+        "b":"bar"
+    },
+    "1":{
+        "a":"baz",
+        "b":"qux"
+    }
+}""",
+            ),
+            (
+                "columns",
+                """{
+    "a":{
+        "0":"foo",
+        "1":"baz"
+    },
+    "b":{
+        "0":"bar",
+        "1":"qux"
+    }
+}""",
+            ),
+            (
+                "values",
+                """[
+    [
+        "foo",
+        "bar"
+    ],
+    [
+        "baz",
+        "qux"
+    ]
+]""",
+            ),
+            (
+                "table",
+                """{
+    "schema":{
+        "fields":[
+            {
+                "name":"index",
+                "type":"integer"
+            },
+            {
+                "name":"a",
+                "type":"string"
+            },
+            {
+                "name":"b",
+                "type":"string"
+            }
+        ],
+        "primaryKey":[
+            "index"
+        ],
+        "pandas_version":"0.20.0"
+    },
+    "data":[
+        {
+            "index":0,
+            "a":"foo",
+            "b":"bar"
+        },
+        {
+            "index":1,
+            "a":"baz",
+            "b":"qux"
+        }
+    ]
+}""",
+            ),
+        ],
+    )
+    def test_json_indent_all_orients(self, orient, expected):
+        # GH 12004
+        df = pd.DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+        result = df.to_json(orient=orient, indent=4)
+        assert result == expected
+
+    def test_json_negative_indent_raises(self):
+        with pytest.raises(ValueError, match="must be a nonnegative integer"):
+            pd.DataFrame().to_json(indent=-1)
+
+    def test_emca_262_nan_inf_support(self):
+        # GH 12213
+        data = '["a", NaN, "NaN", Infinity, "Infinity", -Infinity, "-Infinity"]'
+        result = pd.read_json(data)
+        expected = pd.DataFrame(
+            ["a", np.nan, "NaN", np.inf, "Infinity", -np.inf, "-Infinity"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_deprecate_numpy_argument_read_json(self):
+        # GH 28512
+        expected = DataFrame([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            result = read_json(expected.to_json(), numpy=True)
+            tm.assert_frame_equal(result, expected)
+
+    def test_frame_int_overflow(self):
+        # GH 30320
+        encoded_json = json.dumps([{"col": "31900441201190696999"}, {"col": "Text"}])
+        expected = DataFrame({"col": ["31900441201190696999", "Text"]})
+        result = read_json(encoded_json)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dataframe,expected",
+        [
+            (
+                pd.DataFrame({"x": [1, 2, 3], "y": ["a", "b", "c"]}),
+                '{"(0, \'x\')":1,"(0, \'y\')":"a","(1, \'x\')":2,'
+                '"(1, \'y\')":"b","(2, \'x\')":3,"(2, \'y\')":"c"}',
+            )
+        ],
+    )
+    def test_json_multiindex(self, dataframe, expected):
+        series = dataframe.stack()
+        result = series.to_json(orient="index")
+        assert result == expected
+
+    def test_to_s3(self, s3_resource):
+        # GH 28375
+        mock_bucket_name, target_file = "pandas-test", "test.json"
+        df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
+        df.to_json(f"s3://{mock_bucket_name}/{target_file}")
+        assert target_file in (
+            obj.key for obj in s3_resource.Bucket("pandas-test").objects.all()
+        )
+
+    def test_json_pandas_na(self):
+        # GH 31615
+        result = pd.DataFrame([[pd.NA]]).to_json()
+        assert result == '{"0":{"0":null}}'
+
+    def test_json_pandas_nulls(self, nulls_fixture):
+        # GH 31615
+        result = pd.DataFrame([[nulls_fixture]]).to_json()
+        assert result == '{"0":{"0":null}}'
diff --git a/pandas/tests/io/json/test_readlines.py b/pandas/tests/io/json/test_readlines.py
index 821bf0287c6f1..e531457627342 100644
--- a/pandas/tests/io/json/test_readlines.py
+++ b/pandas/tests/io/json/test_readlines.py
@@ -4,8 +4,7 @@
 
 import pandas as pd
 from pandas import DataFrame, read_json
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal, ensure_clean
+import pandas._testing as tm
 
 from pandas.io.json._json import JsonReader
 
@@ -20,7 +19,7 @@ def test_read_jsonl():
     # GH9180
     result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
     expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_read_jsonl_unicode_chars():
@@ -32,13 +31,13 @@ def test_read_jsonl_unicode_chars():
     json = StringIO(json)
     result = read_json(json, lines=True)
     expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # simulate string
     json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
     result = read_json(json, lines=True)
     expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_to_jsonl():
@@ -52,14 +51,14 @@ def test_to_jsonl():
     result = df.to_json(orient="records", lines=True)
     expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}'
     assert result == expected
-    assert_frame_equal(read_json(result, lines=True), df)
+    tm.assert_frame_equal(read_json(result, lines=True), df)
 
     # GH15096: escaped characters in columns and data
     df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
     result = df.to_json(orient="records", lines=True)
-    expected = '{"a\\\\":"foo\\\\","b":"bar"}\n' '{"a\\\\":"foo\\"","b":"bar"}'
+    expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}'
     assert result == expected
-    assert_frame_equal(read_json(result, lines=True), df)
+    tm.assert_frame_equal(read_json(result, lines=True), df)
 
 
 @pytest.mark.parametrize("chunksize", [1, 1.0])
@@ -72,7 +71,7 @@ def test_readjson_chunks(lines_json_df, chunksize):
     reader = read_json(StringIO(lines_json_df), lines=True, chunksize=chunksize)
     chunked = pd.concat(reader)
 
-    assert_frame_equal(chunked, unchunked)
+    tm.assert_frame_equal(chunked, unchunked)
 
 
 def test_readjson_chunksize_requires_lines(lines_json_df):
@@ -91,7 +90,7 @@ def test_readjson_chunks_series():
     strio = StringIO(s.to_json(lines=True, orient="records"))
     chunked = pd.concat(pd.read_json(strio, lines=True, typ="Series", chunksize=1))
 
-    assert_series_equal(chunked, unchunked)
+    tm.assert_series_equal(chunked, unchunked)
 
 
 def test_readjson_each_chunk(lines_json_df):
@@ -103,17 +102,17 @@ def test_readjson_each_chunk(lines_json_df):
 
 
 def test_readjson_chunks_from_file():
-    with ensure_clean("test.json") as path:
+    with tm.ensure_clean("test.json") as path:
         df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
         df.to_json(path, lines=True, orient="records")
         chunked = pd.concat(pd.read_json(path, lines=True, chunksize=1))
         unchunked = pd.read_json(path, lines=True)
-        assert_frame_equal(unchunked, chunked)
+        tm.assert_frame_equal(unchunked, chunked)
 
 
 @pytest.mark.parametrize("chunksize", [None, 1])
 def test_readjson_chunks_closes(chunksize):
-    with ensure_clean("test.json") as path:
+    with tm.ensure_clean("test.json") as path:
         df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
         df.to_json(path, lines=True, orient="records")
         reader = JsonReader(
@@ -135,10 +134,7 @@ def test_readjson_chunks_closes(chunksize):
         reader.read()
         assert (
             reader.open_stream.closed
-        ), "didn't close stream with \
-            chunksize = {chunksize}".format(
-            chunksize=chunksize
-        )
+        ), f"didn't close stream with chunksize = {chunksize}"
 
 
 @pytest.mark.parametrize("chunksize", [0, -1, 2.2, "foo"])
@@ -171,6 +167,15 @@ def test_readjson_chunks_multiple_empty_lines(chunksize):
     test = pd.read_json(j, lines=True, chunksize=chunksize)
     if chunksize is not None:
         test = pd.concat(test)
-    tm.assert_frame_equal(
-        orig, test, obj="chunksize: {chunksize}".format(chunksize=chunksize)
-    )
+    tm.assert_frame_equal(orig, test, obj=f"chunksize: {chunksize}")
+
+
+def test_readjson_unicode(monkeypatch):
+    with tm.ensure_clean("test.json") as path:
+        monkeypatch.setattr("_bootlocale.getpreferredencoding", lambda l: "cp949")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write('{"£©µÀÆÖÞßéöÿ":["АБВГДабвгд가"]}')
+
+        result = read_json(path)
+        expected = pd.DataFrame({"£©µÀÆÖÞßéöÿ": ["АБВГДабвгд가"]})
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index 69a246487ddf1..bedd60084124c 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -1,10 +1,7 @@
-try:
-    import json
-except ImportError:
-    import simplejson as json
 import calendar
 import datetime
 import decimal
+import json
 import locale
 import math
 import re
@@ -20,7 +17,7 @@
 import pandas.compat as compat
 
 from pandas import DataFrame, DatetimeIndex, Index, NaT, Series, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _clean_dict(d):
@@ -114,9 +111,9 @@ def test_encode_decimal(self):
     @pytest.mark.parametrize("ensure_ascii", [True, False])
     def test_encode_string_conversion(self, ensure_ascii):
         string_input = "A string \\ / \b \f \n \r \t </script> &"
-        not_html_encoded = '"A string \\\\ \\/ \\b \\f \\n ' '\\r \\t <\\/script> &"'
+        not_html_encoded = '"A string \\\\ \\/ \\b \\f \\n \\r \\t <\\/script> &"'
         html_encoded = (
-            '"A string \\\\ \\/ \\b \\f \\n \\r \\t ' '\\u003c\\/script\\u003e \\u0026"'
+            '"A string \\\\ \\/ \\b \\f \\n \\r \\t \\u003c\\/script\\u003e \\u0026"'
         )
 
         def helper(expected_output, **encode_kwargs):
@@ -365,21 +362,21 @@ def test_encode_date_conversion(self):
     )
     def test_encode_time_conversion_basic(self, test):
         output = ujson.encode(test)
-        expected = '"{iso}"'.format(iso=test.isoformat())
+        expected = f'"{test.isoformat()}"'
         assert expected == output
 
     def test_encode_time_conversion_pytz(self):
         # see gh-11473: to_json segfaults with timezone-aware datetimes
         test = datetime.time(10, 12, 15, 343243, pytz.utc)
         output = ujson.encode(test)
-        expected = '"{iso}"'.format(iso=test.isoformat())
+        expected = f'"{test.isoformat()}"'
         assert expected == output
 
     def test_encode_time_conversion_dateutil(self):
         # see gh-11473: to_json segfaults with timezone-aware datetimes
         test = datetime.time(10, 12, 15, 343243, dateutil.tz.tzutc())
         output = ujson.encode(test)
-        expected = '"{iso}"'.format(iso=test.isoformat())
+        expected = f'"{test.isoformat()}"'
         assert expected == output
 
     @pytest.mark.parametrize(
@@ -562,11 +559,6 @@ def test_loads_non_str_bytes_raises(self):
         with pytest.raises(TypeError, match=msg):
             ujson.loads(None)
 
-    def test_version(self):
-        assert re.match(
-            r"^\d+\.\d+(\.\d+)?$", ujson.__version__
-        ), "ujson.__version__ must be a string like '1.4.0'"
-
     def test_encode_numeric_overflow(self):
         with pytest.raises(OverflowError):
             ujson.encode(12839128391289382193812939)
@@ -583,7 +575,7 @@ class Nested:
     def test_decode_number_with_32bit_sign_bit(self, val):
         # Test that numbers that fit within 32 bits but would have the
         # sign bit set (2**31 <= x < 2**32) are decoded properly.
-        doc = '{{"id": {val}}}'.format(val=val)
+        doc = f'{{"id": {val}}}'
         assert ujson.decode(doc)["id"] == val
 
     def test_encode_big_escape(self):
@@ -624,7 +616,7 @@ def __init__(self, val):
             def recursive_attr(self):
                 return _TestObject("recursive_attr")
 
-            def __str__(self):
+            def __str__(self) -> str:
                 return str(self.val)
 
         msg = "Maximum recursion level reached"
@@ -764,8 +756,9 @@ def test_array_list(self):
             ["a", "b"],
             {"key": "val"},
         ]
-        arr = np.array(arr_list)
-        tm.assert_numpy_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr)
+        arr = np.array(arr_list, dtype=object)
+        result = np.array(ujson.decode(ujson.encode(arr)), dtype=object)
+        tm.assert_numpy_array_equal(result, arr)
 
     def test_array_float(self):
         dtype = np.float32
@@ -780,7 +773,9 @@ def test_array_float(self):
         tm.assert_almost_equal(arr, arr_out)
 
     def test_0d_array(self):
-        with pytest.raises(TypeError):
+        # gh-18878
+        msg = re.escape("array(1) (0d array) is not JSON serializable at the moment")
+        with pytest.raises(TypeError, match=msg):
             ujson.encode(np.array(1))
 
     @pytest.mark.parametrize(
@@ -816,7 +811,7 @@ def test_array_numpy_labelled(self):
 
         # see gh-10837: write out the dump explicitly
         # so there is no dependency on iteration order
-        input_dumps = '[{"a": 42, "b":31}, {"a": 24, "c": 99}, ' '{"a": 2.4, "b": 78}]'
+        input_dumps = '[{"a": 42, "b":31}, {"a": 24, "c": 99}, {"a": 2.4, "b": 78}]'
         output = ujson.loads(input_dumps, numpy=True, labelled=True)
         expected_vals = np.array([42, 31, 24, 99, 2.4, 78], dtype=int).reshape((3, 2))
         assert (expected_vals == output[0]).all()
diff --git a/pandas/tests/io/msgpack/common.py b/pandas/tests/io/msgpack/common.py
deleted file mode 100644
index 60c1c0db18de8..0000000000000
--- a/pandas/tests/io/msgpack/common.py
+++ /dev/null
@@ -1,2 +0,0 @@
-frombytes = lambda obj, data: obj.frombytes(data)
-tobytes = lambda obj: obj.tobytes()
diff --git a/pandas/tests/io/msgpack/data/frame.mp b/pandas/tests/io/msgpack/data/frame.mp
deleted file mode 100644
index 21e20d262b26c..0000000000000
Binary files a/pandas/tests/io/msgpack/data/frame.mp and /dev/null differ
diff --git a/pandas/tests/io/msgpack/test_buffer.py b/pandas/tests/io/msgpack/test_buffer.py
deleted file mode 100644
index fe1f4e73eba24..0000000000000
--- a/pandas/tests/io/msgpack/test_buffer.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# coding: utf-8
-
-from pandas.io.msgpack import packb, unpackb
-
-from .common import frombytes
-
-
-def test_unpack_buffer():
-    from array import array
-
-    buf = array("b")
-    frombytes(buf, packb((b"foo", b"bar")))
-    obj = unpackb(buf, use_list=1)
-    assert [b"foo", b"bar"] == obj
-
-
-def test_unpack_bytearray():
-    buf = bytearray(packb(("foo", "bar")))
-    obj = unpackb(buf, use_list=1)
-    assert [b"foo", b"bar"] == obj
-    expected_type = bytes
-    assert all(type(s) == expected_type for s in obj)
diff --git a/pandas/tests/io/msgpack/test_case.py b/pandas/tests/io/msgpack/test_case.py
deleted file mode 100644
index a868da69d5459..0000000000000
--- a/pandas/tests/io/msgpack/test_case.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# coding: utf-8
-
-from pandas.io.msgpack import packb, unpackb
-
-
-def check(length, obj):
-    v = packb(obj)
-    assert (
-        len(v) == length
-    ), "{obj!r} length should be {length!r} but get {got:!r}".format(
-        obj=obj, length=length, got=len(v)
-    )
-    assert unpackb(v, use_list=0) == obj
-
-
-def test_1():
-    for o in [
-        None,
-        True,
-        False,
-        0,
-        1,
-        (1 << 6),
-        (1 << 7) - 1,
-        -1,
-        -((1 << 5) - 1),
-        -(1 << 5),
-    ]:
-        check(1, o)
-
-
-def test_2():
-    for o in [1 << 7, (1 << 8) - 1, -((1 << 5) + 1), -(1 << 7)]:
-        check(2, o)
-
-
-def test_3():
-    for o in [1 << 8, (1 << 16) - 1, -((1 << 7) + 1), -(1 << 15)]:
-        check(3, o)
-
-
-def test_5():
-    for o in [1 << 16, (1 << 32) - 1, -((1 << 15) + 1), -(1 << 31)]:
-        check(5, o)
-
-
-def test_9():
-    for o in [
-        1 << 32,
-        (1 << 64) - 1,
-        -((1 << 31) + 1),
-        -(1 << 63),
-        1.0,
-        0.1,
-        -0.1,
-        -1.0,
-    ]:
-        check(9, o)
-
-
-def check_raw(overhead, num):
-    check(num + overhead, b" " * num)
-
-
-def test_fixraw():
-    check_raw(1, 0)
-    check_raw(1, (1 << 5) - 1)
-
-
-def test_raw16():
-    check_raw(3, 1 << 5)
-    check_raw(3, (1 << 16) - 1)
-
-
-def test_raw32():
-    check_raw(5, 1 << 16)
-
-
-def check_array(overhead, num):
-    check(num + overhead, (None,) * num)
-
-
-def test_fixarray():
-    check_array(1, 0)
-    check_array(1, (1 << 4) - 1)
-
-
-def test_array16():
-    check_array(3, 1 << 4)
-    check_array(3, (1 << 16) - 1)
-
-
-def test_array32():
-    check_array(5, (1 << 16))
-
-
-def match(obj, buf):
-    assert packb(obj) == buf
-    assert unpackb(buf, use_list=0) == obj
-
-
-def test_match():
-    cases = [
-        (None, b"\xc0"),
-        (False, b"\xc2"),
-        (True, b"\xc3"),
-        (0, b"\x00"),
-        (127, b"\x7f"),
-        (128, b"\xcc\x80"),
-        (256, b"\xcd\x01\x00"),
-        (-1, b"\xff"),
-        (-33, b"\xd0\xdf"),
-        (-129, b"\xd1\xff\x7f"),
-        ({1: 1}, b"\x81\x01\x01"),
-        (1.0, b"\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"),
-        ((), b"\x90"),
-        (
-            tuple(range(15)),
-            (b"\x9f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09" b"\x0a\x0b\x0c\x0d\x0e"),
-        ),
-        (
-            tuple(range(16)),
-            (
-                b"\xdc\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07"
-                b"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
-            ),
-        ),
-        ({}, b"\x80"),
-        (
-            {x: x for x in range(15)},
-            (
-                b"\x8f\x00\x00\x01\x01\x02\x02\x03\x03\x04\x04\x05\x05\x06\x06\x07"
-                b"\x07\x08\x08\t\t\n\n\x0b\x0b\x0c\x0c\r\r\x0e\x0e"
-            ),
-        ),
-        (
-            {x: x for x in range(16)},
-            (
-                b"\xde\x00\x10\x00\x00\x01\x01\x02\x02\x03\x03\x04\x04\x05\x05\x06"
-                b"\x06\x07\x07\x08\x08\t\t\n\n\x0b\x0b\x0c\x0c\r\r\x0e\x0e"
-                b"\x0f\x0f"
-            ),
-        ),
-    ]
-
-    for v, p in cases:
-        match(v, p)
-
-
-def test_unicode():
-    assert unpackb(packb("foobar"), use_list=1) == b"foobar"
diff --git a/pandas/tests/io/msgpack/test_except.py b/pandas/tests/io/msgpack/test_except.py
deleted file mode 100644
index 60c1dcca162a9..0000000000000
--- a/pandas/tests/io/msgpack/test_except.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# coding: utf-8
-
-from datetime import datetime
-
-import pytest
-
-from pandas.io.msgpack import packb, unpackb
-
-
-class DummyException(Exception):
-    pass
-
-
-class TestExceptions:
-    def test_raise_on_find_unsupported_value(self):
-        msg = "can't serialize datetime"
-        with pytest.raises(TypeError, match=msg):
-            packb(datetime.now())
-
-    def test_raise_from_object_hook(self):
-        def hook(_):
-            raise DummyException()
-
-        with pytest.raises(DummyException):
-            unpackb(packb({}), object_hook=hook)
-        with pytest.raises(DummyException):
-            unpackb(packb({"fizz": "buzz"}), object_hook=hook)
-        with pytest.raises(DummyException):
-            unpackb(packb({"fizz": "buzz"}), object_pairs_hook=hook)
-        with pytest.raises(DummyException):
-            unpackb(packb({"fizz": {"buzz": "spam"}}), object_hook=hook)
-        with pytest.raises(DummyException):
-            unpackb(packb({"fizz": {"buzz": "spam"}}), object_pairs_hook=hook)
-
-    def test_invalid_value(self):
-        msg = "Unpack failed: error"
-        with pytest.raises(ValueError, match=msg):
-            unpackb(b"\xd9\x97#DL_")
diff --git a/pandas/tests/io/msgpack/test_extension.py b/pandas/tests/io/msgpack/test_extension.py
deleted file mode 100644
index 85ed43fa01079..0000000000000
--- a/pandas/tests/io/msgpack/test_extension.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import array
-
-import pandas.io.msgpack as msgpack
-from pandas.io.msgpack import ExtType
-
-from .common import frombytes, tobytes
-
-
-def test_pack_ext_type():
-    def p(s):
-        packer = msgpack.Packer()
-        packer.pack_ext_type(0x42, s)
-        return packer.bytes()
-
-    assert p(b"A") == b"\xd4\x42A"  # fixext 1
-    assert p(b"AB") == b"\xd5\x42AB"  # fixext 2
-    assert p(b"ABCD") == b"\xd6\x42ABCD"  # fixext 4
-    assert p(b"ABCDEFGH") == b"\xd7\x42ABCDEFGH"  # fixext 8
-    assert p(b"A" * 16) == b"\xd8\x42" + b"A" * 16  # fixext 16
-    assert p(b"ABC") == b"\xc7\x03\x42ABC"  # ext 8
-    assert p(b"A" * 0x0123) == b"\xc8\x01\x23\x42" + b"A" * 0x0123  # ext 16
-    assert (
-        p(b"A" * 0x00012345) == b"\xc9\x00\x01\x23\x45\x42" + b"A" * 0x00012345
-    )  # ext 32
-
-
-def test_unpack_ext_type():
-    def check(b, expected):
-        assert msgpack.unpackb(b) == expected
-
-    check(b"\xd4\x42A", ExtType(0x42, b"A"))  # fixext 1
-    check(b"\xd5\x42AB", ExtType(0x42, b"AB"))  # fixext 2
-    check(b"\xd6\x42ABCD", ExtType(0x42, b"ABCD"))  # fixext 4
-    check(b"\xd7\x42ABCDEFGH", ExtType(0x42, b"ABCDEFGH"))  # fixext 8
-    check(b"\xd8\x42" + b"A" * 16, ExtType(0x42, b"A" * 16))  # fixext 16
-    check(b"\xc7\x03\x42ABC", ExtType(0x42, b"ABC"))  # ext 8
-    check(b"\xc8\x01\x23\x42" + b"A" * 0x0123, ExtType(0x42, b"A" * 0x0123))  # ext 16
-    check(
-        b"\xc9\x00\x01\x23\x45\x42" + b"A" * 0x00012345,
-        ExtType(0x42, b"A" * 0x00012345),
-    )  # ext 32
-
-
-def test_extension_type():
-    def default(obj):
-        print("default called", obj)
-        if isinstance(obj, array.array):
-            typecode = 123  # application specific typecode
-            data = tobytes(obj)
-            return ExtType(typecode, data)
-        raise TypeError("Unknown type object {obj!r}".format(obj))
-
-    def ext_hook(code, data):
-        print("ext_hook called", code, data)
-        assert code == 123
-        obj = array.array("d")
-        frombytes(obj, data)
-        return obj
-
-    obj = [42, b"hello", array.array("d", [1.1, 2.2, 3.3])]
-    s = msgpack.packb(obj, default=default)
-    obj2 = msgpack.unpackb(s, ext_hook=ext_hook)
-    assert obj == obj2
diff --git a/pandas/tests/io/msgpack/test_format.py b/pandas/tests/io/msgpack/test_format.py
deleted file mode 100644
index 46d0116bc3926..0000000000000
--- a/pandas/tests/io/msgpack/test_format.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# coding: utf-8
-
-from pandas.io.msgpack import unpackb
-
-
-def check(src, should, use_list=0):
-    assert unpackb(src, use_list=use_list) == should
-
-
-def testSimpleValue():
-    check(b"\x93\xc0\xc2\xc3", (None, False, True))
-
-
-def testFixnum():
-    check(b"\x92\x93\x00\x40\x7f\x93\xe0\xf0\xff", ((0, 64, 127), (-32, -16, -1)))
-
-
-def testFixArray():
-    check(b"\x92\x90\x91\x91\xc0", ((), ((None,),)))
-
-
-def testFixRaw():
-    check(b"\x94\xa0\xa1a\xa2bc\xa3def", (b"", b"a", b"bc", b"def"))
-
-
-def testFixMap():
-    check(
-        b"\x82\xc2\x81\xc0\xc0\xc3\x81\xc0\x80", {False: {None: None}, True: {None: {}}}
-    )
-
-
-def testUnsignedInt():
-    check(
-        b"\x99\xcc\x00\xcc\x80\xcc\xff\xcd\x00\x00\xcd\x80\x00"
-        b"\xcd\xff\xff\xce\x00\x00\x00\x00\xce\x80\x00\x00\x00"
-        b"\xce\xff\xff\xff\xff",
-        (0, 128, 255, 0, 32768, 65535, 0, 2147483648, 4294967295),
-    )
-
-
-def testSignedInt():
-    check(
-        b"\x99\xd0\x00\xd0\x80\xd0\xff\xd1\x00\x00\xd1\x80\x00"
-        b"\xd1\xff\xff\xd2\x00\x00\x00\x00\xd2\x80\x00\x00\x00"
-        b"\xd2\xff\xff\xff\xff",
-        (0, -128, -1, 0, -32768, -1, 0, -2147483648, -1),
-    )
-
-
-def testRaw():
-    check(
-        b"\x96\xda\x00\x00\xda\x00\x01a\xda\x00\x02ab\xdb\x00\x00"
-        b"\x00\x00\xdb\x00\x00\x00\x01a\xdb\x00\x00\x00\x02ab",
-        (b"", b"a", b"ab", b"", b"a", b"ab"),
-    )
-
-
-def testArray():
-    check(
-        b"\x96\xdc\x00\x00\xdc\x00\x01\xc0\xdc\x00\x02\xc2\xc3\xdd\x00"
-        b"\x00\x00\x00\xdd\x00\x00\x00\x01\xc0\xdd\x00\x00\x00\x02"
-        b"\xc2\xc3",
-        ((), (None,), (False, True), (), (None,), (False, True)),
-    )
-
-
-def testMap():
-    check(
-        b"\x96"
-        b"\xde\x00\x00"
-        b"\xde\x00\x01\xc0\xc2"
-        b"\xde\x00\x02\xc0\xc2\xc3\xc2"
-        b"\xdf\x00\x00\x00\x00"
-        b"\xdf\x00\x00\x00\x01\xc0\xc2"
-        b"\xdf\x00\x00\x00\x02\xc0\xc2\xc3\xc2",
-        (
-            {},
-            {None: False},
-            {True: False, None: False},
-            {},
-            {None: False},
-            {True: False, None: False},
-        ),
-    )
diff --git a/pandas/tests/io/msgpack/test_limits.py b/pandas/tests/io/msgpack/test_limits.py
deleted file mode 100644
index 4c0697f8faf64..0000000000000
--- a/pandas/tests/io/msgpack/test_limits.py
+++ /dev/null
@@ -1,107 +0,0 @@
-# coding: utf-8
-import pytest
-
-from pandas.io.msgpack import ExtType, Packer, Unpacker, packb, unpackb
-
-
-class TestLimits:
-    def test_integer(self):
-        x = -(2 ** 63)
-        assert unpackb(packb(x)) == x
-        msg = (
-            r"((long |Python )?(int )?too (big|large) to convert"
-            r"( to C (unsigned )?long))?"
-        )
-        with pytest.raises((OverflowError, ValueError), match=msg):
-            packb(x - 1)
-        x = 2 ** 64 - 1
-        assert unpackb(packb(x)) == x
-        with pytest.raises((OverflowError, ValueError), match=msg):
-            packb(x + 1)
-
-    def test_array_header(self):
-        packer = Packer()
-        packer.pack_array_header(2 ** 32 - 1)
-        with pytest.raises((OverflowError, ValueError)):
-            packer.pack_array_header(2 ** 32)
-
-    def test_map_header(self):
-        packer = Packer()
-        packer.pack_map_header(2 ** 32 - 1)
-        with pytest.raises((OverflowError, ValueError)):
-            packer.pack_array_header(2 ** 32)
-
-    def test_max_str_len(self):
-        d = "x" * 3
-        packed = packb(d)
-
-        unpacker = Unpacker(max_str_len=3, encoding="utf-8")
-        unpacker.feed(packed)
-        assert unpacker.unpack() == d
-
-        unpacker = Unpacker(max_str_len=2, encoding="utf-8")
-        unpacker.feed(packed)
-
-        msg = "3 exceeds max_str_len"
-        with pytest.raises(ValueError, match=msg):
-            unpacker.unpack()
-
-    def test_max_bin_len(self):
-        d = b"x" * 3
-        packed = packb(d, use_bin_type=True)
-
-        unpacker = Unpacker(max_bin_len=3)
-        unpacker.feed(packed)
-        assert unpacker.unpack() == d
-
-        unpacker = Unpacker(max_bin_len=2)
-        unpacker.feed(packed)
-
-        msg = "3 exceeds max_bin_len"
-        with pytest.raises(ValueError, match=msg):
-            unpacker.unpack()
-
-    def test_max_array_len(self):
-        d = [1, 2, 3]
-        packed = packb(d)
-
-        unpacker = Unpacker(max_array_len=3)
-        unpacker.feed(packed)
-        assert unpacker.unpack() == d
-
-        unpacker = Unpacker(max_array_len=2)
-        unpacker.feed(packed)
-
-        msg = "3 exceeds max_array_len"
-        with pytest.raises(ValueError, match=msg):
-            unpacker.unpack()
-
-    def test_max_map_len(self):
-        d = {1: 2, 3: 4, 5: 6}
-        packed = packb(d)
-
-        unpacker = Unpacker(max_map_len=3)
-        unpacker.feed(packed)
-        assert unpacker.unpack() == d
-
-        unpacker = Unpacker(max_map_len=2)
-        unpacker.feed(packed)
-
-        msg = "3 exceeds max_map_len"
-        with pytest.raises(ValueError, match=msg):
-            unpacker.unpack()
-
-    def test_max_ext_len(self):
-        d = ExtType(42, b"abc")
-        packed = packb(d)
-
-        unpacker = Unpacker(max_ext_len=3)
-        unpacker.feed(packed)
-        assert unpacker.unpack() == d
-
-        unpacker = Unpacker(max_ext_len=2)
-        unpacker.feed(packed)
-
-        msg = "4 exceeds max_ext_len"
-        with pytest.raises(ValueError, match=msg):
-            unpacker.unpack()
diff --git a/pandas/tests/io/msgpack/test_newspec.py b/pandas/tests/io/msgpack/test_newspec.py
deleted file mode 100644
index a1cf966b9d253..0000000000000
--- a/pandas/tests/io/msgpack/test_newspec.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# coding: utf-8
-
-from pandas.io.msgpack import ExtType, packb, unpackb
-
-
-def test_str8():
-    header = b"\xd9"
-    data = b"x" * 32
-    b = packb(data.decode(), use_bin_type=True)
-    assert len(b) == len(data) + 2
-    assert b[0:2] == header + b"\x20"
-    assert b[2:] == data
-    assert unpackb(b) == data
-
-    data = b"x" * 255
-    b = packb(data.decode(), use_bin_type=True)
-    assert len(b) == len(data) + 2
-    assert b[0:2] == header + b"\xff"
-    assert b[2:] == data
-    assert unpackb(b) == data
-
-
-def test_bin8():
-    header = b"\xc4"
-    data = b""
-    b = packb(data, use_bin_type=True)
-    assert len(b) == len(data) + 2
-    assert b[0:2] == header + b"\x00"
-    assert b[2:] == data
-    assert unpackb(b) == data
-
-    data = b"x" * 255
-    b = packb(data, use_bin_type=True)
-    assert len(b) == len(data) + 2
-    assert b[0:2] == header + b"\xff"
-    assert b[2:] == data
-    assert unpackb(b) == data
-
-
-def test_bin16():
-    header = b"\xc5"
-    data = b"x" * 256
-    b = packb(data, use_bin_type=True)
-    assert len(b) == len(data) + 3
-    assert b[0:1] == header
-    assert b[1:3] == b"\x01\x00"
-    assert b[3:] == data
-    assert unpackb(b) == data
-
-    data = b"x" * 65535
-    b = packb(data, use_bin_type=True)
-    assert len(b) == len(data) + 3
-    assert b[0:1] == header
-    assert b[1:3] == b"\xff\xff"
-    assert b[3:] == data
-    assert unpackb(b) == data
-
-
-def test_bin32():
-    header = b"\xc6"
-    data = b"x" * 65536
-    b = packb(data, use_bin_type=True)
-    assert len(b) == len(data) + 5
-    assert b[0:1] == header
-    assert b[1:5] == b"\x00\x01\x00\x00"
-    assert b[5:] == data
-    assert unpackb(b) == data
-
-
-def test_ext():
-    def check(ext, packed):
-        assert packb(ext) == packed
-        assert unpackb(packed) == ext
-
-    check(ExtType(0x42, b"Z"), b"\xd4\x42Z")  # fixext 1
-    check(ExtType(0x42, b"ZZ"), b"\xd5\x42ZZ")  # fixext 2
-    check(ExtType(0x42, b"Z" * 4), b"\xd6\x42" + b"Z" * 4)  # fixext 4
-    check(ExtType(0x42, b"Z" * 8), b"\xd7\x42" + b"Z" * 8)  # fixext 8
-    check(ExtType(0x42, b"Z" * 16), b"\xd8\x42" + b"Z" * 16)  # fixext 16
-    # ext 8
-    check(ExtType(0x42, b""), b"\xc7\x00\x42")
-    check(ExtType(0x42, b"Z" * 255), b"\xc7\xff\x42" + b"Z" * 255)
-    # ext 16
-    check(ExtType(0x42, b"Z" * 256), b"\xc8\x01\x00\x42" + b"Z" * 256)
-    check(ExtType(0x42, b"Z" * 0xFFFF), b"\xc8\xff\xff\x42" + b"Z" * 0xFFFF)
-    # ext 32
-    check(ExtType(0x42, b"Z" * 0x10000), b"\xc9\x00\x01\x00\x00\x42" + b"Z" * 0x10000)
-    # needs large memory
-    # check(ExtType(0x42, b'Z'*0xffffffff),
-    #              b'\xc9\xff\xff\xff\xff\x42' + b'Z'*0xffffffff)
diff --git a/pandas/tests/io/msgpack/test_obj.py b/pandas/tests/io/msgpack/test_obj.py
deleted file mode 100644
index 03d8807c0922c..0000000000000
--- a/pandas/tests/io/msgpack/test_obj.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# coding: utf-8
-
-import pytest
-
-from pandas.io.msgpack import packb, unpackb
-
-
-class DecodeError(Exception):
-    pass
-
-
-class TestObj:
-    def _arr_to_str(self, arr):
-        return "".join(str(c) for c in arr)
-
-    def bad_complex_decoder(self, o):
-        raise DecodeError("Ooops!")
-
-    def _decode_complex(self, obj):
-        if b"__complex__" in obj:
-            return complex(obj[b"real"], obj[b"imag"])
-        return obj
-
-    def _encode_complex(self, obj):
-        if isinstance(obj, complex):
-            return {b"__complex__": True, b"real": 1, b"imag": 2}
-        return obj
-
-    def test_encode_hook(self):
-        packed = packb([3, 1 + 2j], default=self._encode_complex)
-        unpacked = unpackb(packed, use_list=1)
-        assert unpacked[1] == {b"__complex__": True, b"real": 1, b"imag": 2}
-
-    def test_decode_hook(self):
-        packed = packb([3, {b"__complex__": True, b"real": 1, b"imag": 2}])
-        unpacked = unpackb(packed, object_hook=self._decode_complex, use_list=1)
-        assert unpacked[1] == 1 + 2j
-
-    def test_decode_pairs_hook(self):
-        packed = packb([3, {1: 2, 3: 4}])
-        prod_sum = 1 * 2 + 3 * 4
-        unpacked = unpackb(
-            packed, object_pairs_hook=lambda l: sum(k * v for k, v in l), use_list=1
-        )
-        assert unpacked[1] == prod_sum
-
-    def test_only_one_obj_hook(self):
-        msg = "object_pairs_hook and object_hook are mutually exclusive"
-        with pytest.raises(TypeError, match=msg):
-            unpackb(b"", object_hook=lambda x: x, object_pairs_hook=lambda x: x)
-
-    def test_bad_hook(self):
-        msg = r"can't serialize \(1\+2j\)"
-        with pytest.raises(TypeError, match=msg):
-            packed = packb([3, 1 + 2j], default=lambda o: o)
-            unpacked = unpackb(packed, use_list=1)  # noqa
-
-    def test_array_hook(self):
-        packed = packb([1, 2, 3])
-        unpacked = unpackb(packed, list_hook=self._arr_to_str, use_list=1)
-        assert unpacked == "123"
-
-    def test_an_exception_in_objecthook1(self):
-        with pytest.raises(DecodeError, match="Ooops!"):
-            packed = packb({1: {"__complex__": True, "real": 1, "imag": 2}})
-            unpackb(packed, object_hook=self.bad_complex_decoder)
-
-    def test_an_exception_in_objecthook2(self):
-        with pytest.raises(DecodeError, match="Ooops!"):
-            packed = packb({1: [{"__complex__": True, "real": 1, "imag": 2}]})
-            unpackb(packed, list_hook=self.bad_complex_decoder, use_list=1)
diff --git a/pandas/tests/io/msgpack/test_pack.py b/pandas/tests/io/msgpack/test_pack.py
deleted file mode 100644
index 5fc24027589cb..0000000000000
--- a/pandas/tests/io/msgpack/test_pack.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# coding: utf-8
-from collections import OrderedDict
-from io import BytesIO
-import struct
-
-import pytest
-
-from pandas.io.msgpack import Packer, Unpacker, packb, unpackb
-
-
-class TestPack:
-    def check(self, data, use_list=False):
-        re = unpackb(packb(data), use_list=use_list)
-        assert re == data
-
-    def testPack(self):
-        test_data = [
-            0,
-            1,
-            127,
-            128,
-            255,
-            256,
-            65535,
-            65536,
-            -1,
-            -32,
-            -33,
-            -128,
-            -129,
-            -32768,
-            -32769,
-            1.0,
-            b"",
-            b"a",
-            b"a" * 31,
-            b"a" * 32,
-            None,
-            True,
-            False,
-            (),
-            ((),),
-            ((), None),
-            {None: 0},
-            (1 << 23),
-        ]
-        for td in test_data:
-            self.check(td)
-
-    def testPackUnicode(self):
-        test_data = ["", "abcd", ["defgh"], "Русский текст"]
-        for td in test_data:
-            re = unpackb(packb(td, encoding="utf-8"), use_list=1, encoding="utf-8")
-            assert re == td
-            packer = Packer(encoding="utf-8")
-            data = packer.pack(td)
-            re = Unpacker(BytesIO(data), encoding="utf-8", use_list=1).unpack()
-            assert re == td
-
-    def testPackUTF32(self):
-        test_data = ["", "abcd", ["defgh"], "Русский текст"]
-        for td in test_data:
-            re = unpackb(packb(td, encoding="utf-32"), use_list=1, encoding="utf-32")
-            assert re == td
-
-    def testPackBytes(self):
-        test_data = [b"", b"abcd", (b"defgh",)]
-        for td in test_data:
-            self.check(td)
-
-    def testIgnoreUnicodeErrors(self):
-        re = unpackb(
-            packb(b"abc\xeddef"), encoding="utf-8", unicode_errors="ignore", use_list=1
-        )
-        assert re == "abcdef"
-
-    def testStrictUnicodeUnpack(self):
-        msg = (
-            r"'utf-*8' codec can't decode byte 0xed in position 3:"
-            " invalid continuation byte"
-        )
-        with pytest.raises(UnicodeDecodeError, match=msg):
-            unpackb(packb(b"abc\xeddef"), encoding="utf-8", use_list=1)
-
-    def testStrictUnicodePack(self):
-        msg = (
-            r"'ascii' codec can't encode character '\\xed' in position 3:"
-            r" ordinal not in range\(128\)"
-        )
-        with pytest.raises(UnicodeEncodeError, match=msg):
-            packb("abc\xeddef", encoding="ascii", unicode_errors="strict")
-
-    def testIgnoreErrorsPack(self):
-        re = unpackb(
-            packb("abcФФФdef", encoding="ascii", unicode_errors="ignore"),
-            encoding="utf-8",
-            use_list=1,
-        )
-        assert re == "abcdef"
-
-    def testNoEncoding(self):
-        msg = "Can't encode unicode string: no encoding is specified"
-        with pytest.raises(TypeError, match=msg):
-            packb("abc", encoding=None)
-
-    def testDecodeBinary(self):
-        re = unpackb(packb("abc"), encoding=None, use_list=1)
-        assert re == b"abc"
-
-    def testPackFloat(self):
-        assert packb(1.0, use_single_float=True) == b"\xca" + struct.pack(">f", 1.0)
-        assert packb(1.0, use_single_float=False) == b"\xcb" + struct.pack(">d", 1.0)
-
-    def testArraySize(self, sizes=[0, 5, 50, 1000]):
-        bio = BytesIO()
-        packer = Packer()
-        for size in sizes:
-            bio.write(packer.pack_array_header(size))
-            for i in range(size):
-                bio.write(packer.pack(i))
-
-        bio.seek(0)
-        unpacker = Unpacker(bio, use_list=1)
-        for size in sizes:
-            assert unpacker.unpack() == list(range(size))
-
-    def test_manualreset(self, sizes=[0, 5, 50, 1000]):
-        packer = Packer(autoreset=False)
-        for size in sizes:
-            packer.pack_array_header(size)
-            for i in range(size):
-                packer.pack(i)
-
-        bio = BytesIO(packer.bytes())
-        unpacker = Unpacker(bio, use_list=1)
-        for size in sizes:
-            assert unpacker.unpack() == list(range(size))
-
-        packer.reset()
-        assert packer.bytes() == b""
-
-    def testMapSize(self, sizes=[0, 5, 50, 1000]):
-        bio = BytesIO()
-        packer = Packer()
-        for size in sizes:
-            bio.write(packer.pack_map_header(size))
-            for i in range(size):
-                bio.write(packer.pack(i))  # key
-                bio.write(packer.pack(i * 2))  # value
-
-        bio.seek(0)
-        unpacker = Unpacker(bio)
-        for size in sizes:
-            assert unpacker.unpack() == {i: i * 2 for i in range(size)}
-
-    def test_odict(self):
-        seq = [(b"one", 1), (b"two", 2), (b"three", 3), (b"four", 4)]
-        od = OrderedDict(seq)
-        assert unpackb(packb(od), use_list=1) == dict(seq)
-
-        def pair_hook(seq):
-            return list(seq)
-
-        assert unpackb(packb(od), object_pairs_hook=pair_hook, use_list=1) == seq
-
-    def test_pairlist(self):
-        pairlist = [(b"a", 1), (2, b"b"), (b"foo", b"bar")]
-        packer = Packer()
-        packed = packer.pack_map_pairs(pairlist)
-        unpacked = unpackb(packed, object_pairs_hook=list)
-        assert pairlist == unpacked
diff --git a/pandas/tests/io/msgpack/test_read_size.py b/pandas/tests/io/msgpack/test_read_size.py
deleted file mode 100644
index 7d2b539f12085..0000000000000
--- a/pandas/tests/io/msgpack/test_read_size.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""Test Unpacker's read_array_header and read_map_header methods"""
-from pandas.io.msgpack import OutOfData, Unpacker, packb
-
-UnexpectedTypeException = ValueError
-
-
-def test_read_array_header():
-    unpacker = Unpacker()
-    unpacker.feed(packb(["a", "b", "c"]))
-    assert unpacker.read_array_header() == 3
-    assert unpacker.unpack() == b"a"
-    assert unpacker.unpack() == b"b"
-    assert unpacker.unpack() == b"c"
-    try:
-        unpacker.unpack()
-        assert 0, "should raise exception"
-    except OutOfData:
-        assert 1, "okay"
-
-
-def test_read_map_header():
-    unpacker = Unpacker()
-    unpacker.feed(packb({"a": "A"}))
-    assert unpacker.read_map_header() == 1
-    assert unpacker.unpack() == b"a"
-    assert unpacker.unpack() == b"A"
-    try:
-        unpacker.unpack()
-        assert 0, "should raise exception"
-    except OutOfData:
-        assert 1, "okay"
-
-
-def test_incorrect_type_array():
-    unpacker = Unpacker()
-    unpacker.feed(packb(1))
-    try:
-        unpacker.read_array_header()
-        assert 0, "should raise exception"
-    except UnexpectedTypeException:
-        assert 1, "okay"
-
-
-def test_incorrect_type_map():
-    unpacker = Unpacker()
-    unpacker.feed(packb(1))
-    try:
-        unpacker.read_map_header()
-        assert 0, "should raise exception"
-    except UnexpectedTypeException:
-        assert 1, "okay"
-
-
-def test_correct_type_nested_array():
-    unpacker = Unpacker()
-    unpacker.feed(packb({"a": ["b", "c", "d"]}))
-    try:
-        unpacker.read_array_header()
-        assert 0, "should raise exception"
-    except UnexpectedTypeException:
-        assert 1, "okay"
-
-
-def test_incorrect_type_nested_map():
-    unpacker = Unpacker()
-    unpacker.feed(packb([{"a": "b"}]))
-    try:
-        unpacker.read_map_header()
-        assert 0, "should raise exception"
-    except UnexpectedTypeException:
-        assert 1, "okay"
diff --git a/pandas/tests/io/msgpack/test_seq.py b/pandas/tests/io/msgpack/test_seq.py
deleted file mode 100644
index c4ac13980bc67..0000000000000
--- a/pandas/tests/io/msgpack/test_seq.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# coding: utf-8
-
-import io
-
-import pandas.io.msgpack as msgpack
-
-binarydata = bytes(bytearray(range(256)))
-
-
-def gen_binary_data(idx):
-    return binarydata[: idx % 300]
-
-
-def test_exceeding_unpacker_read_size():
-    dumpf = io.BytesIO()
-
-    packer = msgpack.Packer()
-
-    NUMBER_OF_STRINGS = 6
-    read_size = 16
-
-    # 5 ok for read_size=16, while 6 glibc detected *** python: double free or
-    # corruption (fasttop):
-
-    # 20 ok for read_size=256, while 25 segfaults / glibc detected *** python:
-    # double free or corruption (!prev)
-
-    # 40 ok for read_size=1024, while 50 introduces errors
-    # 7000 ok for read_size=1024*1024, while 8000 leads to glibc detected ***
-    # python: double free or corruption (!prev):
-
-    for idx in range(NUMBER_OF_STRINGS):
-        data = gen_binary_data(idx)
-        dumpf.write(packer.pack(data))
-
-    f = io.BytesIO(dumpf.getvalue())
-    dumpf.close()
-
-    unpacker = msgpack.Unpacker(f, read_size=read_size, use_list=1)
-
-    read_count = 0
-    for idx, o in enumerate(unpacker):
-        assert type(o) == bytes
-        assert o == gen_binary_data(idx)
-        read_count += 1
-
-    assert read_count == NUMBER_OF_STRINGS
diff --git a/pandas/tests/io/msgpack/test_sequnpack.py b/pandas/tests/io/msgpack/test_sequnpack.py
deleted file mode 100644
index 79feb78b3b013..0000000000000
--- a/pandas/tests/io/msgpack/test_sequnpack.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# coding: utf-8
-from io import BytesIO
-
-import pytest
-
-from pandas.io.msgpack import BufferFull, OutOfData, Unpacker
-
-
-class TestPack:
-    def test_partial_data(self):
-        unpacker = Unpacker()
-        msg = "No more data to unpack"
-
-        for data in [b"\xa5", b"h", b"a", b"l", b"l"]:
-            unpacker.feed(data)
-            with pytest.raises(StopIteration, match=msg):
-                next(iter(unpacker))
-
-        unpacker.feed(b"o")
-        assert next(iter(unpacker)) == b"hallo"
-
-    def test_foobar(self):
-        unpacker = Unpacker(read_size=3, use_list=1)
-        unpacker.feed(b"foobar")
-        assert unpacker.unpack() == ord(b"f")
-        assert unpacker.unpack() == ord(b"o")
-        assert unpacker.unpack() == ord(b"o")
-        assert unpacker.unpack() == ord(b"b")
-        assert unpacker.unpack() == ord(b"a")
-        assert unpacker.unpack() == ord(b"r")
-        msg = "No more data to unpack"
-        with pytest.raises(OutOfData, match=msg):
-            unpacker.unpack()
-
-        unpacker.feed(b"foo")
-        unpacker.feed(b"bar")
-
-        k = 0
-        for o, e in zip(unpacker, "foobarbaz"):
-            assert o == ord(e)
-            k += 1
-        assert k == len(b"foobar")
-
-    def test_foobar_skip(self):
-        unpacker = Unpacker(read_size=3, use_list=1)
-        unpacker.feed(b"foobar")
-        assert unpacker.unpack() == ord(b"f")
-        unpacker.skip()
-        assert unpacker.unpack() == ord(b"o")
-        unpacker.skip()
-        assert unpacker.unpack() == ord(b"a")
-        unpacker.skip()
-        msg = "No more data to unpack"
-        with pytest.raises(OutOfData, match=msg):
-            unpacker.unpack()
-
-    def test_maxbuffersize_read_size_exceeds_max_buffer_size(self):
-        msg = "read_size should be less or equal to max_buffer_size"
-        with pytest.raises(ValueError, match=msg):
-            Unpacker(read_size=5, max_buffer_size=3)
-
-    def test_maxbuffersize_bufferfull(self):
-        unpacker = Unpacker(read_size=3, max_buffer_size=3, use_list=1)
-        unpacker.feed(b"foo")
-        with pytest.raises(BufferFull, match=r"^$"):
-            unpacker.feed(b"b")
-
-    def test_maxbuffersize(self):
-        unpacker = Unpacker(read_size=3, max_buffer_size=3, use_list=1)
-        unpacker.feed(b"foo")
-        assert ord("f") == next(unpacker)
-        unpacker.feed(b"b")
-        assert ord("o") == next(unpacker)
-        assert ord("o") == next(unpacker)
-        assert ord("b") == next(unpacker)
-
-    def test_readbytes(self):
-        unpacker = Unpacker(read_size=3)
-        unpacker.feed(b"foobar")
-        assert unpacker.unpack() == ord(b"f")
-        assert unpacker.read_bytes(3) == b"oob"
-        assert unpacker.unpack() == ord(b"a")
-        assert unpacker.unpack() == ord(b"r")
-
-        # Test buffer refill
-        unpacker = Unpacker(BytesIO(b"foobar"), read_size=3)
-        assert unpacker.unpack() == ord(b"f")
-        assert unpacker.read_bytes(3) == b"oob"
-        assert unpacker.unpack() == ord(b"a")
-        assert unpacker.unpack() == ord(b"r")
-
-    def test_issue124(self):
-        unpacker = Unpacker()
-        unpacker.feed(b"\xa1?\xa1!")
-        assert tuple(unpacker) == (b"?", b"!")
-        assert tuple(unpacker) == ()
-        unpacker.feed(b"\xa1?\xa1")
-        assert tuple(unpacker) == (b"?",)
-        assert tuple(unpacker) == ()
-        unpacker.feed(b"!")
-        assert tuple(unpacker) == (b"!",)
-        assert tuple(unpacker) == ()
diff --git a/pandas/tests/io/msgpack/test_subtype.py b/pandas/tests/io/msgpack/test_subtype.py
deleted file mode 100644
index c82f6f6d3bf4e..0000000000000
--- a/pandas/tests/io/msgpack/test_subtype.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# coding: utf-8
-
-from collections import namedtuple
-
-from pandas.io.msgpack import packb
-
-
-class MyList(list):
-    pass
-
-
-class MyDict(dict):
-    pass
-
-
-class MyTuple(tuple):
-    pass
-
-
-MyNamedTuple = namedtuple("MyNamedTuple", "x y")
-
-
-def test_types():
-    assert packb(MyDict()) == packb(dict())
-    assert packb(MyList()) == packb(list())
-    assert packb(MyNamedTuple(1, 2)) == packb((1, 2))
diff --git a/pandas/tests/io/msgpack/test_unpack.py b/pandas/tests/io/msgpack/test_unpack.py
deleted file mode 100644
index 483e09efe6bb8..0000000000000
--- a/pandas/tests/io/msgpack/test_unpack.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from io import BytesIO
-import sys
-
-import pytest
-
-from pandas.io.msgpack import ExtType, OutOfData, Unpacker, packb
-
-
-class TestUnpack:
-    def test_unpack_array_header_from_file(self):
-        f = BytesIO(packb([1, 2, 3, 4]))
-        unpacker = Unpacker(f)
-        assert unpacker.read_array_header() == 4
-        assert unpacker.unpack() == 1
-        assert unpacker.unpack() == 2
-        assert unpacker.unpack() == 3
-        assert unpacker.unpack() == 4
-        msg = "No more data to unpack"
-        with pytest.raises(OutOfData, match=msg):
-            unpacker.unpack()
-
-    def test_unpacker_hook_refcnt(self):
-        if not hasattr(sys, "getrefcount"):
-            pytest.skip("no sys.getrefcount()")
-        result = []
-
-        def hook(x):
-            result.append(x)
-            return x
-
-        basecnt = sys.getrefcount(hook)
-
-        up = Unpacker(object_hook=hook, list_hook=hook)
-
-        assert sys.getrefcount(hook) >= basecnt + 2
-
-        up.feed(packb([{}]))
-        up.feed(packb([{}]))
-        assert up.unpack() == [{}]
-        assert up.unpack() == [{}]
-        assert result == [{}, [{}], {}, [{}]]
-
-        del up
-
-        assert sys.getrefcount(hook) == basecnt
-
-    def test_unpacker_ext_hook(self):
-        class MyUnpacker(Unpacker):
-            def __init__(self):
-                super().__init__(ext_hook=self._hook, encoding="utf-8")
-
-            def _hook(self, code, data):
-                if code == 1:
-                    return int(data)
-                else:
-                    return ExtType(code, data)
-
-        unpacker = MyUnpacker()
-        unpacker.feed(packb({"a": 1}, encoding="utf-8"))
-        assert unpacker.unpack() == {"a": 1}
-        unpacker.feed(packb({"a": ExtType(1, b"123")}, encoding="utf-8"))
-        assert unpacker.unpack() == {"a": 123}
-        unpacker.feed(packb({"a": ExtType(2, b"321")}, encoding="utf-8"))
-        assert unpacker.unpack() == {"a": ExtType(2, b"321")}
diff --git a/pandas/tests/io/msgpack/test_unpack_raw.py b/pandas/tests/io/msgpack/test_unpack_raw.py
deleted file mode 100644
index f844553bfc34a..0000000000000
--- a/pandas/tests/io/msgpack/test_unpack_raw.py
+++ /dev/null
@@ -1,30 +0,0 @@
-"""Tests for cases where the user seeks to obtain packed msgpack objects"""
-
-import io
-
-from pandas.io.msgpack import Unpacker, packb
-
-
-def test_write_bytes():
-    unpacker = Unpacker()
-    unpacker.feed(b"abc")
-    f = io.BytesIO()
-    assert unpacker.unpack(f.write) == ord("a")
-    assert f.getvalue() == b"a"
-    f = io.BytesIO()
-    assert unpacker.skip(f.write) is None
-    assert f.getvalue() == b"b"
-    f = io.BytesIO()
-    assert unpacker.skip() is None
-    assert f.getvalue() == b""
-
-
-def test_write_bytes_multi_buffer():
-    long_val = (5) * 100
-    expected = packb(long_val)
-    unpacker = Unpacker(io.BytesIO(expected), read_size=3, max_buffer_size=3)
-
-    f = io.BytesIO()
-    unpacked = unpacker.unpack(f.write)
-    assert unpacked == long_val
-    assert f.getvalue() == expected
diff --git a/pandas/tests/io/parser/conftest.py b/pandas/tests/io/parser/conftest.py
index 2c347a096006a..15967e3be176a 100644
--- a/pandas/tests/io/parser/conftest.py
+++ b/pandas/tests/io/parser/conftest.py
@@ -1,4 +1,5 @@
 import os
+from typing import List, Optional
 
 import pytest
 
@@ -6,9 +7,9 @@
 
 
 class BaseParser:
-    engine = None
+    engine: Optional[str] = None
     low_memory = True
-    float_precision_choices = []
+    float_precision_choices: List[Optional[str]] = []
 
     def update_kwargs(self, kwargs):
         kwargs = kwargs.copy()
@@ -45,11 +46,17 @@ class PythonParser(BaseParser):
 
 @pytest.fixture
 def csv_dir_path(datapath):
+    """
+    The directory path to the data files needed for parser tests.
+    """
     return datapath("io", "parser", "data")
 
 
 @pytest.fixture
 def csv1(csv_dir_path):
+    """
+    The path to the data file "test1.csv" needed for parser tests.
+    """
     return os.path.join(csv_dir_path, "test1.csv")
 
 
@@ -59,23 +66,58 @@ def csv1(csv_dir_path):
 
 _py_parsers_only = [_pythonParser]
 _c_parsers_only = [_cParserHighMemory, _cParserLowMemory]
-_all_parsers = _c_parsers_only + _py_parsers_only
+_all_parsers = [*_c_parsers_only, *_py_parsers_only]
 
 _py_parser_ids = ["python"]
 _c_parser_ids = ["c_high", "c_low"]
-_all_parser_ids = _c_parser_ids + _py_parser_ids
+_all_parser_ids = [*_c_parser_ids, *_py_parser_ids]
 
 
 @pytest.fixture(params=_all_parsers, ids=_all_parser_ids)
 def all_parsers(request):
+    """
+    Fixture all of the CSV parsers.
+    """
     return request.param
 
 
 @pytest.fixture(params=_c_parsers_only, ids=_c_parser_ids)
 def c_parser_only(request):
+    """
+    Fixture all of the CSV parsers using the C engine.
+    """
     return request.param
 
 
 @pytest.fixture(params=_py_parsers_only, ids=_py_parser_ids)
 def python_parser_only(request):
+    """
+    Fixture all of the CSV parsers using the Python engine.
+    """
+    return request.param
+
+
+_utf_values = [8, 16, 32]
+
+_encoding_seps = ["", "-", "_"]
+_encoding_prefixes = ["utf", "UTF"]
+
+_encoding_fmts = [
+    f"{prefix}{sep}" + "{0}" for sep in _encoding_seps for prefix in _encoding_prefixes
+]
+
+
+@pytest.fixture(params=_utf_values)
+def utf_value(request):
+    """
+    Fixture for all possible integer values for a UTF encoding.
+    """
+    return request.param
+
+
+@pytest.fixture(params=_encoding_fmts)
+def encoding_fmt(request):
+    """
+    Fixture for all possible string formats of a UTF encoding.
+    """
     return request.param
diff --git a/pandas/tests/io/parser/data/utf32_ex_small.zip b/pandas/tests/io/parser/data/utf32_ex_small.zip
new file mode 100644
index 0000000000000..9a6d5c08da9db
Binary files /dev/null and b/pandas/tests/io/parser/data/utf32_ex_small.zip differ
diff --git a/pandas/tests/io/parser/data/utf8_ex_small.zip b/pandas/tests/io/parser/data/utf8_ex_small.zip
new file mode 100644
index 0000000000000..a4c5440bdffa7
Binary files /dev/null and b/pandas/tests/io/parser/data/utf8_ex_small.zip differ
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index 77b52eb90d61f..1737f14e7adf9 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -17,7 +17,7 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, concat
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -597,3 +597,14 @@ def test_file_binary_mode(c_parser_only):
         with open(path, "rb") as f:
             result = parser.read_csv(f, header=None)
             tm.assert_frame_equal(result, expected)
+
+
+def test_unix_style_breaks(c_parser_only):
+    # GH 11020
+    parser = c_parser_only
+    with tm.ensure_clean() as path:
+        with open(path, "w", newline="\n") as f:
+            f.write("blah\n\ncol_1,col_2,col_3\n\n")
+        result = parser.read_csv(path, skiprows=2, encoding="utf-8", engine="c")
+    expected = DataFrame(columns=["col_1", "col_2", "col_3"])
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_comment.py b/pandas/tests/io/parser/test_comment.py
index e1d422142ab0b..60e32d7c27200 100644
--- a/pandas/tests/io/parser/test_comment.py
+++ b/pandas/tests/io/parser/test_comment.py
@@ -8,7 +8,7 @@
 import pytest
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("na_values", [None, ["NaN"]])
diff --git a/pandas/tests/io/parser/test_common.py b/pandas/tests/io/parser/test_common.py
index 756463e9d8d33..c19056d434ec3 100644
--- a/pandas/tests/io/parser/test_common.py
+++ b/pandas/tests/io/parser/test_common.py
@@ -2,15 +2,12 @@
 Tests that work on both the Python and C engines but do not have a
 specific classification into the other test modules.
 """
-
 import codecs
-from collections import OrderedDict
 import csv
 from datetime import datetime
-from io import BytesIO, StringIO
+from io import StringIO
 import os
 import platform
-from tempfile import TemporaryFile
 from urllib.error import URLError
 
 import numpy as np
@@ -20,7 +17,7 @@
 from pandas.errors import DtypeWarning, EmptyDataError, ParserError
 
 from pandas import DataFrame, Index, MultiIndex, Series, compat, concat
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.parsers import CParserWrapper, TextFileReader, TextParser
 
@@ -71,17 +68,6 @@ def _set_noconvert_columns(self):
     tm.assert_frame_equal(result, expected)
 
 
-def test_bytes_io_input(all_parsers):
-    encoding = "cp1255"
-    parser = all_parsers
-
-    data = BytesIO("שלום:1234\n562:123".encode(encoding))
-    result = parser.read_csv(data, sep=":", encoding=encoding)
-
-    expected = DataFrame([[562, 123]], columns=["שלום", "1234"])
-    tm.assert_frame_equal(result, expected)
-
-
 def test_empty_decimal_marker(all_parsers):
     data = """A|B|C
 1|2,334|5
@@ -318,15 +304,6 @@ def test_read_csv_no_index_name(all_parsers, csv_dir_path):
     tm.assert_frame_equal(result, expected)
 
 
-def test_read_csv_unicode(all_parsers):
-    parser = all_parsers
-    data = BytesIO("\u0141aski, Jan;1".encode("utf-8"))
-
-    result = parser.read_csv(data, sep=";", encoding="utf-8", header=None)
-    expected = DataFrame([["\u0141aski, Jan", 1]])
-    tm.assert_frame_equal(result, expected)
-
-
 def test_read_csv_wrong_num_columns(all_parsers):
     # Too few columns.
     data = """A,B,C,D,E,F
@@ -978,15 +955,15 @@ def test_path_local_path(all_parsers):
 def test_nonexistent_path(all_parsers):
     # gh-2428: pls no segfault
     # gh-14086: raise more helpful FileNotFoundError
+    # GH#29233 "File foo" instead of "File b'foo'"
     parser = all_parsers
     path = "{}.csv".format(tm.rands(10))
 
-    msg = "does not exist" if parser.engine == "c" else r"\[Errno 2\]"
+    msg = f"File {path} does not exist" if parser.engine == "c" else r"\[Errno 2\]"
     with pytest.raises(FileNotFoundError, match=msg) as e:
         parser.read_csv(path)
 
         filename = e.value.filename
-        filename = filename.decode() if isinstance(filename, bytes) else filename
 
         assert path == filename
 
@@ -1066,59 +1043,6 @@ def test_skip_initial_space(all_parsers):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize("sep", [",", "\t"])
-@pytest.mark.parametrize("encoding", ["utf-16", "utf-16le", "utf-16be"])
-def test_utf16_bom_skiprows(all_parsers, sep, encoding):
-    # see gh-2298
-    parser = all_parsers
-    data = """skip this
-skip this too
-A,B,C
-1,2,3
-4,5,6""".replace(
-        ",", sep
-    )
-    path = "__{}__.csv".format(tm.rands(10))
-    kwargs = dict(sep=sep, skiprows=2)
-    utf8 = "utf-8"
-
-    with tm.ensure_clean(path) as path:
-        from io import TextIOWrapper
-
-        bytes_data = data.encode(encoding)
-
-        with open(path, "wb") as f:
-            f.write(bytes_data)
-
-        bytes_buffer = BytesIO(data.encode(utf8))
-        bytes_buffer = TextIOWrapper(bytes_buffer, encoding=utf8)
-
-        result = parser.read_csv(path, encoding=encoding, **kwargs)
-        expected = parser.read_csv(bytes_buffer, encoding=utf8, **kwargs)
-
-        bytes_buffer.close()
-        tm.assert_frame_equal(result, expected)
-
-
-def test_utf16_example(all_parsers, csv_dir_path):
-    path = os.path.join(csv_dir_path, "utf16_ex.txt")
-    parser = all_parsers
-    result = parser.read_csv(path, encoding="utf-16", sep="\t")
-    assert len(result) == 50
-
-
-def test_unicode_encoding(all_parsers, csv_dir_path):
-    path = os.path.join(csv_dir_path, "unicode_series.csv")
-    parser = all_parsers
-
-    result = parser.read_csv(path, header=None, encoding="latin-1")
-    result = result.set_index(0)
-    got = result[1][1632]
-
-    expected = "\xc1 k\xf6ldum klaka (Cold Fever) (1994)"
-    assert got == expected
-
-
 def test_trailing_delimiters(all_parsers):
     # see gh-2442
     data = """A,B,C
@@ -1133,7 +1057,7 @@ def test_trailing_delimiters(all_parsers):
 
 
 def test_escapechar(all_parsers):
-    # http://stackoverflow.com/questions/13824840/feature-request-for-
+    # https://stackoverflow.com/questions/13824840/feature-request-for-
     # pandas-read-csv
     data = '''SEARCH_TERM,ACTUAL_URL
 "bra tv bord","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"
@@ -1145,9 +1069,8 @@ def test_escapechar(all_parsers):
         StringIO(data), escapechar="\\", quotechar='"', encoding="utf-8"
     )
 
-    assert result["SEARCH_TERM"][2] == (
-        'SLAGBORD, "Bergslagen", ' "IKEA:s 1700-tals serie"
-    )
+    assert result["SEARCH_TERM"][2] == 'SLAGBORD, "Bergslagen", IKEA:s 1700-tals serie'
+
     tm.assert_index_equal(result.columns, Index(["SEARCH_TERM", "ACTUAL_URL"]))
 
 
@@ -1318,9 +1241,7 @@ def test_float_parser(all_parsers):
 
 def test_scientific_no_exponent(all_parsers):
     # see gh-12215
-    df = DataFrame.from_dict(
-        OrderedDict([("w", ["2e"]), ("x", ["3E"]), ("y", ["42e"]), ("z", ["632E"])])
-    )
+    df = DataFrame.from_dict({"w": ["2e"], "x": ["3E"], "y": ["42e"], "z": ["632E"]})
     data = df.to_csv(index=False)
     parser = all_parsers
 
@@ -1915,76 +1836,25 @@ def test_null_byte_char(all_parsers):
         out = parser.read_csv(StringIO(data), names=names)
         tm.assert_frame_equal(out, expected)
     else:
-        if compat.PY38:
-            msg = "line contains NUL"
-        else:
-            msg = "NULL byte detected"
+        msg = "NULL byte detected"
         with pytest.raises(ParserError, match=msg):
             parser.read_csv(StringIO(data), names=names)
 
 
-@pytest.mark.parametrize(
-    "data,kwargs,expected",
-    [
-        # Basic test
-        ("a\n1", dict(), DataFrame({"a": [1]})),
-        # "Regular" quoting
-        ('"a"\n1', dict(quotechar='"'), DataFrame({"a": [1]})),
-        # Test in a data row instead of header
-        ("b\n1", dict(names=["a"]), DataFrame({"a": ["b", "1"]})),
-        # Test in empty data row with skipping
-        ("\n1", dict(names=["a"], skip_blank_lines=True), DataFrame({"a": [1]})),
-        # Test in empty data row without skipping
-        (
-            "\n1",
-            dict(names=["a"], skip_blank_lines=False),
-            DataFrame({"a": [np.nan, 1]}),
-        ),
-    ],
-)
-def test_utf8_bom(all_parsers, data, kwargs, expected):
-    # see gh-4793
-    parser = all_parsers
-    bom = "\ufeff"
-    utf8 = "utf-8"
-
-    def _encode_data_with_bom(_data):
-        bom_data = (bom + _data).encode(utf8)
-        return BytesIO(bom_data)
-
-    result = parser.read_csv(_encode_data_with_bom(data), encoding=utf8, **kwargs)
-    tm.assert_frame_equal(result, expected)
-
-
 def test_temporary_file(all_parsers):
     # see gh-13398
     parser = all_parsers
     data = "0 0"
 
-    new_file = TemporaryFile("w+")
-    new_file.write(data)
-    new_file.flush()
-    new_file.seek(0)
-
-    result = parser.read_csv(new_file, sep=r"\s+", header=None)
-    new_file.close()
-
-    expected = DataFrame([[0, 0]])
-    tm.assert_frame_equal(result, expected)
-
+    with tm.ensure_clean(mode="w+", return_filelike=True) as new_file:
+        new_file.write(data)
+        new_file.flush()
+        new_file.seek(0)
 
-@pytest.mark.parametrize("byte", [8, 16])
-@pytest.mark.parametrize("fmt", ["utf-{0}", "utf_{0}", "UTF-{0}", "UTF_{0}"])
-def test_read_csv_utf_aliases(all_parsers, byte, fmt):
-    # see gh-13549
-    expected = DataFrame({"mb_num": [4.8], "multibyte": ["test"]})
-    parser = all_parsers
-
-    encoding = fmt.format(byte)
-    data = "mb_num,multibyte\n4.8,test".encode(encoding)
+        result = parser.read_csv(new_file, sep=r"\s+", header=None)
 
-    result = parser.read_csv(BytesIO(data), encoding=encoding)
-    tm.assert_frame_equal(result, expected)
+        expected = DataFrame([[0, 0]])
+        tm.assert_frame_equal(result, expected)
 
 
 def test_internal_eof_byte(all_parsers):
@@ -2046,30 +1916,6 @@ def test_file_handles_with_open(all_parsers, csv1):
             assert not f.closed
 
 
-@pytest.mark.parametrize(
-    "fname,encoding",
-    [
-        ("test1.csv", "utf-8"),
-        ("unicode_series.csv", "latin-1"),
-        ("sauron.SHIFT_JIS.csv", "shiftjis"),
-    ],
-)
-def test_binary_mode_file_buffers(all_parsers, csv_dir_path, fname, encoding):
-    # gh-23779: Python csv engine shouldn't error on files opened in binary.
-    parser = all_parsers
-
-    fpath = os.path.join(csv_dir_path, fname)
-    expected = parser.read_csv(fpath, encoding=encoding)
-
-    with open(fpath, mode="r", encoding=encoding) as fa:
-        result = parser.read_csv(fa)
-    tm.assert_frame_equal(expected, result)
-
-    with open(fpath, mode="rb") as fb:
-        result = parser.read_csv(fb, encoding=encoding)
-    tm.assert_frame_equal(expected, result)
-
-
 def test_invalid_file_buffer_class(all_parsers):
     # see gh-15337
     class InvalidBuffer:
@@ -2163,11 +2009,7 @@ def test_suppress_error_output(all_parsers, capsys):
     assert captured.err == ""
 
 
-@pytest.mark.skipif(
-    compat.is_platform_windows() and not compat.PY36,
-    reason="On Python < 3.6 won't pass on Windows",
-)
-@pytest.mark.parametrize("filename", ["sé-es-vé.csv", "ru-sй.csv"])
+@pytest.mark.parametrize("filename", ["sé-es-vé.csv", "ru-sй.csv", "中文文件名.csv"])
 def test_filename_with_special_chars(all_parsers, filename):
     # see gh-15086.
     parser = all_parsers
@@ -2198,6 +2040,17 @@ def test_read_csv_memory_growth_chunksize(all_parsers):
             pass
 
 
+def test_read_csv_raises_on_header_prefix(all_parsers):
+    # gh-27394
+    parser = all_parsers
+    msg = "Argument prefix must be None if argument header is not None"
+
+    s = StringIO("0,1\n2,3")
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(s, header=0, prefix="_X")
+
+
 def test_read_table_equivalency_to_read_csv(all_parsers):
     # see gh-21948
     # As of 0.25.0, read_table is undeprecated
@@ -2216,3 +2069,13 @@ def test_first_row_bom(all_parsers):
     result = parser.read_csv(StringIO(data), delimiter="\t")
     expected = DataFrame(columns=["Head1", "Head2", "Head3"])
     tm.assert_frame_equal(result, expected)
+
+
+def test_integer_precision(all_parsers):
+    # Gh 7072
+    s = """1,1;0;0;0;1;1;3844;3844;3844;1;1;1;1;1;1;0;0;1;1;0;0,,,4321583677327450765
+5,1;0;0;0;1;1;843;843;843;1;1;1;1;1;1;0;0;1;1;0;0,64.0,;,4321113141090630389"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(s), header=None)[4]
+    expected = Series([4321583677327450765, 4321113141090630389], name=4)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_compression.py b/pandas/tests/io/parser/test_compression.py
index 9d0eab0b9a907..dc03370daa1e2 100644
--- a/pandas/tests/io/parser/test_compression.py
+++ b/pandas/tests/io/parser/test_compression.py
@@ -9,7 +9,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture(params=[True, False])
@@ -123,12 +123,13 @@ def test_infer_compression(all_parsers, csv1, buffer, ext):
     tm.assert_frame_equal(result, expected)
 
 
-def test_compression_utf16_encoding(all_parsers, csv_dir_path):
-    # see gh-18071
+def test_compression_utf_encoding(all_parsers, csv_dir_path, utf_value, encoding_fmt):
+    # see gh-18071, gh-24130
     parser = all_parsers
-    path = os.path.join(csv_dir_path, "utf16_ex_small.zip")
+    encoding = encoding_fmt.format(utf_value)
+    path = os.path.join(csv_dir_path, f"utf{utf_value}_ex_small.zip")
 
-    result = parser.read_csv(path, encoding="utf-16", compression="zip", sep="\t")
+    result = parser.read_csv(path, encoding=encoding, compression="zip", sep="\t")
     expected = pd.DataFrame(
         {
             "Country": ["Venezuela", "Venezuela"],
diff --git a/pandas/tests/io/parser/test_converters.py b/pandas/tests/io/parser/test_converters.py
index 2a3b1dc82fc59..88b400d9a11df 100644
--- a/pandas/tests/io/parser/test_converters.py
+++ b/pandas/tests/io/parser/test_converters.py
@@ -10,7 +10,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_converters_type_must_be_dict(all_parsers):
diff --git a/pandas/tests/io/parser/test_dialect.py b/pandas/tests/io/parser/test_dialect.py
index dc10352bc6460..cc65def0fd096 100644
--- a/pandas/tests/io/parser/test_dialect.py
+++ b/pandas/tests/io/parser/test_dialect.py
@@ -11,7 +11,7 @@
 from pandas.errors import ParserWarning
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture
diff --git a/pandas/tests/io/parser/test_dtypes.py b/pandas/tests/io/parser/test_dtypes.py
index a68d46e8a6c15..11dcf7f04f76b 100644
--- a/pandas/tests/io/parser/test_dtypes.py
+++ b/pandas/tests/io/parser/test_dtypes.py
@@ -14,7 +14,7 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Index, MultiIndex, Series, Timestamp, concat
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("dtype", [str, object])
@@ -79,7 +79,7 @@ def test_invalid_dtype_per_column(all_parsers):
 3,4.5
 4,5.5"""
 
-    with pytest.raises(TypeError, match='data type "foo" not understood'):
+    with pytest.raises(TypeError, match="data type [\"']foo[\"'] not understood"):
         parser.read_csv(StringIO(data), dtype={"one": "foo", 1: "int"})
 
 
@@ -550,3 +550,35 @@ def test_numeric_dtype(all_parsers, dtype):
 
     result = parser.read_csv(StringIO(data), header=None, dtype=dtype)
     tm.assert_frame_equal(expected, result)
+
+
+def test_boolean_dtype(all_parsers):
+    parser = all_parsers
+    data = "\n".join(
+        [
+            "a",
+            "True",
+            "TRUE",
+            "true",
+            "False",
+            "FALSE",
+            "false",
+            "NaN",
+            "nan",
+            "NA",
+            "null",
+            "NULL",
+        ]
+    )
+
+    result = parser.read_csv(StringIO(data), dtype="boolean")
+    expected = pd.DataFrame(
+        {
+            "a": pd.array(
+                [True, True, True, False, False, False, None, None, None, None, None],
+                dtype="boolean",
+            )
+        }
+    )
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_encoding.py b/pandas/tests/io/parser/test_encoding.py
new file mode 100644
index 0000000000000..13f72a0414bac
--- /dev/null
+++ b/pandas/tests/io/parser/test_encoding.py
@@ -0,0 +1,176 @@
+"""
+Tests encoding functionality during parsing
+for all of the parsers defined in parsers.py
+"""
+
+from io import BytesIO
+import os
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+def test_bytes_io_input(all_parsers):
+    encoding = "cp1255"
+    parser = all_parsers
+
+    data = BytesIO("שלום:1234\n562:123".encode(encoding))
+    result = parser.read_csv(data, sep=":", encoding=encoding)
+
+    expected = DataFrame([[562, 123]], columns=["שלום", "1234"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_unicode(all_parsers):
+    parser = all_parsers
+    data = BytesIO("\u0141aski, Jan;1".encode("utf-8"))
+
+    result = parser.read_csv(data, sep=";", encoding="utf-8", header=None)
+    expected = DataFrame([["\u0141aski, Jan", 1]])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("sep", [",", "\t"])
+@pytest.mark.parametrize("encoding", ["utf-16", "utf-16le", "utf-16be"])
+def test_utf16_bom_skiprows(all_parsers, sep, encoding):
+    # see gh-2298
+    parser = all_parsers
+    data = """skip this
+skip this too
+A,B,C
+1,2,3
+4,5,6""".replace(
+        ",", sep
+    )
+    path = "__{}__.csv".format(tm.rands(10))
+    kwargs = dict(sep=sep, skiprows=2)
+    utf8 = "utf-8"
+
+    with tm.ensure_clean(path) as path:
+        from io import TextIOWrapper
+
+        bytes_data = data.encode(encoding)
+
+        with open(path, "wb") as f:
+            f.write(bytes_data)
+
+        bytes_buffer = BytesIO(data.encode(utf8))
+        bytes_buffer = TextIOWrapper(bytes_buffer, encoding=utf8)
+
+        result = parser.read_csv(path, encoding=encoding, **kwargs)
+        expected = parser.read_csv(bytes_buffer, encoding=utf8, **kwargs)
+
+        bytes_buffer.close()
+        tm.assert_frame_equal(result, expected)
+
+
+def test_utf16_example(all_parsers, csv_dir_path):
+    path = os.path.join(csv_dir_path, "utf16_ex.txt")
+    parser = all_parsers
+    result = parser.read_csv(path, encoding="utf-16", sep="\t")
+    assert len(result) == 50
+
+
+def test_unicode_encoding(all_parsers, csv_dir_path):
+    path = os.path.join(csv_dir_path, "unicode_series.csv")
+    parser = all_parsers
+
+    result = parser.read_csv(path, header=None, encoding="latin-1")
+    result = result.set_index(0)
+    got = result[1][1632]
+
+    expected = "\xc1 k\xf6ldum klaka (Cold Fever) (1994)"
+    assert got == expected
+
+
+@pytest.mark.parametrize(
+    "data,kwargs,expected",
+    [
+        # Basic test
+        ("a\n1", dict(), DataFrame({"a": [1]})),
+        # "Regular" quoting
+        ('"a"\n1', dict(quotechar='"'), DataFrame({"a": [1]})),
+        # Test in a data row instead of header
+        ("b\n1", dict(names=["a"]), DataFrame({"a": ["b", "1"]})),
+        # Test in empty data row with skipping
+        ("\n1", dict(names=["a"], skip_blank_lines=True), DataFrame({"a": [1]})),
+        # Test in empty data row without skipping
+        (
+            "\n1",
+            dict(names=["a"], skip_blank_lines=False),
+            DataFrame({"a": [np.nan, 1]}),
+        ),
+    ],
+)
+def test_utf8_bom(all_parsers, data, kwargs, expected):
+    # see gh-4793
+    parser = all_parsers
+    bom = "\ufeff"
+    utf8 = "utf-8"
+
+    def _encode_data_with_bom(_data):
+        bom_data = (bom + _data).encode(utf8)
+        return BytesIO(bom_data)
+
+    result = parser.read_csv(_encode_data_with_bom(data), encoding=utf8, **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_utf_aliases(all_parsers, utf_value, encoding_fmt):
+    # see gh-13549
+    expected = DataFrame({"mb_num": [4.8], "multibyte": ["test"]})
+    parser = all_parsers
+
+    encoding = encoding_fmt.format(utf_value)
+    data = "mb_num,multibyte\n4.8,test".encode(encoding)
+
+    result = parser.read_csv(BytesIO(data), encoding=encoding)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "fname,encoding",
+    [
+        ("test1.csv", "utf-8"),
+        ("unicode_series.csv", "latin-1"),
+        ("sauron.SHIFT_JIS.csv", "shiftjis"),
+    ],
+)
+def test_binary_mode_file_buffers(all_parsers, csv_dir_path, fname, encoding):
+    # gh-23779: Python csv engine shouldn't error on files opened in binary.
+    # gh-31575: Python csv engine shouldn't error on files opened in raw binary.
+    parser = all_parsers
+
+    fpath = os.path.join(csv_dir_path, fname)
+    expected = parser.read_csv(fpath, encoding=encoding)
+
+    with open(fpath, mode="r", encoding=encoding) as fa:
+        result = parser.read_csv(fa)
+    tm.assert_frame_equal(expected, result)
+
+    with open(fpath, mode="rb") as fb:
+        result = parser.read_csv(fb, encoding=encoding)
+    tm.assert_frame_equal(expected, result)
+
+    with open(fpath, mode="rb", buffering=0) as fb:
+        result = parser.read_csv(fb, encoding=encoding)
+    tm.assert_frame_equal(expected, result)
+
+
+@pytest.mark.parametrize("pass_encoding", [True, False])
+def test_encoding_temp_file(all_parsers, utf_value, encoding_fmt, pass_encoding):
+    # see gh-24130
+    parser = all_parsers
+    encoding = encoding_fmt.format(utf_value)
+
+    expected = DataFrame({"foo": ["bar"]})
+
+    with tm.ensure_clean(mode="w+", encoding=encoding, return_filelike=True) as f:
+        f.write("foo\nbar")
+        f.seek(0)
+
+        result = parser.read_csv(f, encoding=encoding if pass_encoding else None)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_header.py b/pandas/tests/io/parser/test_header.py
index 0ecd8be7ddc78..7dc106ef0c186 100644
--- a/pandas/tests/io/parser/test_header.py
+++ b/pandas/tests/io/parser/test_header.py
@@ -12,7 +12,7 @@
 from pandas.errors import ParserError
 
 from pandas import DataFrame, Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_read_with_bad_header(all_parsers):
@@ -540,3 +540,34 @@ def test_multi_index_unnamed(all_parsers, index_col, columns):
         columns = MultiIndex.from_tuples(zip(exp_columns, ["0", "1"]))
         expected = DataFrame([[2, 3], [4, 5]], columns=columns)
         tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_multiindex_columns(all_parsers):
+    # GH#6051
+    parser = all_parsers
+
+    s1 = "Male, Male, Male, Female, Female\nR, R, L, R, R\n.86, .67, .88, .78, .81"
+    s2 = (
+        "Male, Male, Male, Female, Female\n"
+        "R, R, L, R, R\n"
+        ".86, .67, .88, .78, .81\n"
+        ".86, .67, .88, .78, .82"
+    )
+
+    mi = MultiIndex.from_tuples(
+        [
+            ("Male", "R"),
+            (" Male", " R"),
+            (" Male", " L"),
+            (" Female", " R"),
+            (" Female", " R.1"),
+        ]
+    )
+    expected = DataFrame(
+        [[0.86, 0.67, 0.88, 0.78, 0.81], [0.86, 0.67, 0.88, 0.78, 0.82]], columns=mi
+    )
+
+    df1 = parser.read_csv(StringIO(s1), header=[0, 1])
+    tm.assert_frame_equal(df1, expected.iloc[:1])
+    df2 = parser.read_csv(StringIO(s2), header=[0, 1])
+    tm.assert_frame_equal(df2, expected)
diff --git a/pandas/tests/io/parser/test_index_col.py b/pandas/tests/io/parser/test_index_col.py
index 4dfb8d3bd2dc8..f67a658cadfa2 100644
--- a/pandas/tests/io/parser/test_index_col.py
+++ b/pandas/tests/io/parser/test_index_col.py
@@ -5,10 +5,11 @@
 """
 from io import StringIO
 
+import numpy as np
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("with_header", [True, False])
@@ -21,9 +22,7 @@ def test_index_col_named(all_parsers, with_header):
 KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
 KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
 KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""  # noqa
-    header = (
-        "ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\n"
-    )  # noqa
+    header = "ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\n"
 
     if with_header:
         data = header + no_header
@@ -174,3 +173,14 @@ def test_multi_index_naming_not_all_at_beginning(all_parsers):
         ),
     )
     tm.assert_frame_equal(result, expected)
+
+
+def test_no_multi_index_level_names_empty(all_parsers):
+    # GH 10984
+    parser = all_parsers
+    midx = MultiIndex.from_tuples([("A", 1, 2), ("A", 1, 2), ("B", 1, 2)])
+    expected = DataFrame(np.random.randn(3, 3), index=midx, columns=["x", "y", "z"])
+    with tm.ensure_clean() as path:
+        expected.to_csv(path)
+        result = parser.read_csv(path, index_col=[0, 1, 2])
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_mangle_dupes.py b/pandas/tests/io/parser/test_mangle_dupes.py
index d144421090274..5c4e642115798 100644
--- a/pandas/tests/io/parser/test_mangle_dupes.py
+++ b/pandas/tests/io/parser/test_mangle_dupes.py
@@ -8,7 +8,7 @@
 import pytest
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("kwargs", [dict(), dict(mangle_dupe_cols=True)])
diff --git a/pandas/tests/io/parser/test_multi_thread.py b/pandas/tests/io/parser/test_multi_thread.py
index c94adf9da0bf3..64ccaf60ec230 100644
--- a/pandas/tests/io/parser/test_multi_thread.py
+++ b/pandas/tests/io/parser/test_multi_thread.py
@@ -9,7 +9,7 @@
 
 import pandas as pd
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _construct_dataframe(num_rows):
diff --git a/pandas/tests/io/parser/test_na_values.py b/pandas/tests/io/parser/test_na_values.py
index f154d09358dc1..f9a083d7f5d22 100644
--- a/pandas/tests/io/parser/test_na_values.py
+++ b/pandas/tests/io/parser/test_na_values.py
@@ -7,10 +7,10 @@
 import numpy as np
 import pytest
 
-from pandas import DataFrame, Index, MultiIndex
-import pandas.util.testing as tm
+from pandas._libs.parsers import STR_NA_VALUES
 
-import pandas.io.common as com
+from pandas import DataFrame, Index, MultiIndex
+import pandas._testing as tm
 
 
 def test_string_nas(all_parsers):
@@ -89,6 +89,7 @@ def test_default_na_values(all_parsers):
         "N/A",
         "n/a",
         "NA",
+        "<NA>",
         "#NA",
         "NULL",
         "null",
@@ -99,7 +100,7 @@ def test_default_na_values(all_parsers):
         "#N/A N/A",
         "",
     }
-    assert _NA_VALUES == com._NA_VALUES
+    assert _NA_VALUES == STR_NA_VALUES
 
     parser = all_parsers
     nv = len(_NA_VALUES)
@@ -536,3 +537,31 @@ def test_cast_NA_to_bool_raises_error(all_parsers, data, na_values):
             dtype={"a": "bool"},
             na_values=na_values,
         )
+
+
+def test_str_nan_dropped(all_parsers):
+    # see gh-21131
+    parser = all_parsers
+
+    data = """File: small.csv,,
+10010010233,0123,654
+foo,,bar
+01001000155,4530,898"""
+
+    result = parser.read_csv(
+        StringIO(data),
+        header=None,
+        names=["col1", "col2", "col3"],
+        dtype={"col1": str, "col2": str, "col3": str},
+    ).dropna()
+
+    expected = DataFrame(
+        {
+            "col1": ["10010010233", "01001000155"],
+            "col2": ["0123", "4530"],
+            "col3": ["654", "898"],
+        },
+        index=[1, 3],
+    )
+
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_network.py b/pandas/tests/io/parser/test_network.py
index dbe721b10a3ce..b7164477c31f2 100644
--- a/pandas/tests/io/parser/test_network.py
+++ b/pandas/tests/io/parser/test_network.py
@@ -11,7 +11,7 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.parsers import read_csv
 
@@ -166,7 +166,7 @@ def test_s3_fails(self):
         # Receive a permission error when trying to read a private bucket.
         # It's irrelevant here that this isn't actually a table.
         with pytest.raises(IOError):
-            read_csv("s3://cant_get_it/")
+            read_csv("s3://cant_get_it/file.csv")
 
     def test_read_csv_handles_boto_s3_object(self, s3_resource, tips_file):
         # see gh-16135
@@ -184,6 +184,8 @@ def test_read_csv_handles_boto_s3_object(self, s3_resource, tips_file):
 
     def test_read_csv_chunked_download(self, s3_resource, caplog):
         # 8 MB, S3FS usees 5MB chunks
+        import s3fs
+
         df = DataFrame(np.random.randn(100000, 4), columns=list("abcd"))
         buf = BytesIO()
         str_buf = StringIO()
@@ -194,10 +196,16 @@ def test_read_csv_chunked_download(self, s3_resource, caplog):
 
         s3_resource.Bucket("pandas-test").put_object(Key="large-file.csv", Body=buf)
 
-        with caplog.at_level(logging.DEBUG, logger="s3fs.core"):
+        # Possibly some state leaking in between tests.
+        # If we don't clear this cache, we saw `GetObject operation: Forbidden`.
+        # Presumably the s3fs instance is being cached, with the directory listing
+        # from *before* we add the large-file.csv in the pandas-test bucket.
+        s3fs.S3FileSystem.clear_instance_cache()
+
+        with caplog.at_level(logging.DEBUG, logger="s3fs"):
             read_csv("s3://pandas-test/large-file.csv", nrows=5)
             # log of fetch_range (start, stop)
-            assert (0, 5505024) in {x.args[-2:] for x in caplog.records}
+            assert (0, 5505024) in (x.args[-2:] for x in caplog.records)
 
     def test_read_s3_with_hash_in_key(self, tips_df):
         # GH 25945
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index 36391e19a102e..b01b22e811ee3 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -20,8 +20,8 @@
 
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex, Index, MultiIndex, Series
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
 
 import pandas.io.date_converters as conv
 
diff --git a/pandas/tests/io/parser/test_python_parser_only.py b/pandas/tests/io/parser/test_python_parser_only.py
index 5b381e43e3e19..7367b19b40dc3 100644
--- a/pandas/tests/io/parser/test_python_parser_only.py
+++ b/pandas/tests/io/parser/test_python_parser_only.py
@@ -13,7 +13,7 @@
 from pandas.errors import ParserError
 
 from pandas import DataFrame, Index, MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_default_separator(python_parser_only):
diff --git a/pandas/tests/io/parser/test_quoting.py b/pandas/tests/io/parser/test_quoting.py
index 94858226d0b44..14773dfbea20e 100644
--- a/pandas/tests/io/parser/test_quoting.py
+++ b/pandas/tests/io/parser/test_quoting.py
@@ -11,7 +11,7 @@
 from pandas.errors import ParserError
 
 from pandas import DataFrame
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/io/parser/test_read_fwf.py b/pandas/tests/io/parser/test_read_fwf.py
index 9ddaccc4d38b7..27aef2376e87d 100644
--- a/pandas/tests/io/parser/test_read_fwf.py
+++ b/pandas/tests/io/parser/test_read_fwf.py
@@ -12,7 +12,7 @@
 
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.parsers import EmptyDataError, read_csv, read_fwf
 
diff --git a/pandas/tests/io/parser/test_skiprows.py b/pandas/tests/io/parser/test_skiprows.py
index d4f219d13ac53..fdccef1127c7e 100644
--- a/pandas/tests/io/parser/test_skiprows.py
+++ b/pandas/tests/io/parser/test_skiprows.py
@@ -12,7 +12,7 @@
 from pandas.errors import EmptyDataError
 
 from pandas import DataFrame, Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("skiprows", [list(range(6)), 6])
diff --git a/pandas/tests/io/parser/test_textreader.py b/pandas/tests/io/parser/test_textreader.py
index 73638fe8ab7c8..8d5af85c20d33 100644
--- a/pandas/tests/io/parser/test_textreader.py
+++ b/pandas/tests/io/parser/test_textreader.py
@@ -6,15 +6,13 @@
 import os
 
 import numpy as np
-from numpy import nan
 import pytest
 
 import pandas._libs.parsers as parser
 from pandas._libs.parsers import TextReader
 
 from pandas import DataFrame
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 from pandas.io.parsers import TextFileReader, read_csv
 
@@ -181,7 +179,7 @@ def test_header_not_enough_lines(self):
         assert_array_dicts_equal(recs, expected)
 
     def test_escapechar(self):
-        data = '\\"hello world"\n' '\\"hello world"\n' '\\"hello world"'
+        data = '\\"hello world"\n\\"hello world"\n\\"hello world"'
 
         reader = TextReader(StringIO(data), delimiter=",", header=None, escapechar="\\")
         result = reader.read()
@@ -309,29 +307,34 @@ def test_empty_field_eof(self):
         assert_array_dicts_equal(result, expected)
 
         # GH5664
-        a = DataFrame([["b"], [nan]], columns=["a"], index=["a", "c"])
+        a = DataFrame([["b"], [np.nan]], columns=["a"], index=["a", "c"])
         b = DataFrame([[1, 1, 1, 0], [1, 1, 1, 0]], columns=list("abcd"), index=[1, 1])
         c = DataFrame(
-            [[1, 2, 3, 4], [6, nan, nan, nan], [8, 9, 10, 11], [13, 14, nan, nan]],
+            [
+                [1, 2, 3, 4],
+                [6, np.nan, np.nan, np.nan],
+                [8, 9, 10, 11],
+                [13, 14, np.nan, np.nan],
+            ],
             columns=list("abcd"),
             index=[0, 5, 7, 12],
         )
 
         for _ in range(100):
             df = read_csv(StringIO("a,b\nc\n"), skiprows=0, names=["a"], engine="c")
-            assert_frame_equal(df, a)
+            tm.assert_frame_equal(df, a)
 
             df = read_csv(
                 StringIO("1,1,1,1,0\n" * 2 + "\n" * 2), names=list("abcd"), engine="c"
             )
-            assert_frame_equal(df, b)
+            tm.assert_frame_equal(df, b)
 
             df = read_csv(
                 StringIO("0,1,2,3,4\n5,6\n7,8,9,10,11\n12,13,14"),
                 names=list("abcd"),
                 engine="c",
             )
-            assert_frame_equal(df, c)
+            tm.assert_frame_equal(df, c)
 
     def test_empty_csv_input(self):
         # GH14867
diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index b23ddf5bd9292..267fae760398a 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -12,7 +12,7 @@
 
 from pandas.errors import ParserError
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.parsers as parsers
 from pandas.io.parsers import read_csv
@@ -96,9 +96,9 @@ def test_python_engine(self, python_engine):
 
         for default in py_unsupported:
             msg = (
-                "The {default!r} option is not supported with the {python_engine!r}"
-                " engine"
-            ).format(default=default, python_engine=python_engine)
+                f"The {repr(default)} option is not "
+                f"supported with the {repr(python_engine)} engine"
+            )
 
             kwargs = {default: object()}
             with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/io/parser/test_usecols.py b/pandas/tests/io/parser/test_usecols.py
index afe19608ea5c6..979eb4702cc84 100644
--- a/pandas/tests/io/parser/test_usecols.py
+++ b/pandas/tests/io/parser/test_usecols.py
@@ -10,7 +10,7 @@
 from pandas._libs.tslib import Timestamp
 
 from pandas import DataFrame, Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 _msg_validate_usecols_arg = (
     "'usecols' must either be list-like "
@@ -199,7 +199,7 @@ def test_usecols_with_whitespace(all_parsers):
         # Column selection by index.
         ([0, 1], DataFrame(data=[[1000, 2000], [4000, 5000]], columns=["2", "0"])),
         # Column selection by name.
-        (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"])),
+        (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"]),),
     ],
 )
 def test_usecols_with_integer_like_header(all_parsers, usecols, expected):
diff --git a/pandas/tests/io/pytables/common.py b/pandas/tests/io/pytables/common.py
new file mode 100644
index 0000000000000..7f0b3ab7957e6
--- /dev/null
+++ b/pandas/tests/io/pytables/common.py
@@ -0,0 +1,83 @@
+from contextlib import contextmanager
+import os
+import tempfile
+
+import pytest
+
+from pandas.io.pytables import HDFStore
+
+tables = pytest.importorskip("tables")
+# set these parameters so we don't have file sharing
+tables.parameters.MAX_NUMEXPR_THREADS = 1
+tables.parameters.MAX_BLOSC_THREADS = 1
+tables.parameters.MAX_THREADS = 1
+
+
+def safe_remove(path):
+    if path is not None:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def safe_close(store):
+    try:
+        if store is not None:
+            store.close()
+    except IOError:
+        pass
+
+
+def create_tempfile(path):
+    """ create an unopened named temporary file """
+    return os.path.join(tempfile.gettempdir(), path)
+
+
+# contextmanager to ensure the file cleanup
+@contextmanager
+def ensure_clean_store(path, mode="a", complevel=None, complib=None, fletcher32=False):
+
+    try:
+
+        # put in the temporary path if we don't have one already
+        if not len(os.path.dirname(path)):
+            path = create_tempfile(path)
+
+        store = HDFStore(
+            path, mode=mode, complevel=complevel, complib=complib, fletcher32=False
+        )
+        yield store
+    finally:
+        safe_close(store)
+        if mode == "w" or mode == "a":
+            safe_remove(path)
+
+
+@contextmanager
+def ensure_clean_path(path):
+    """
+    return essentially a named temporary file that is not opened
+    and deleted on exiting; if path is a list, then create and
+    return list of filenames
+    """
+    try:
+        if isinstance(path, list):
+            filenames = [create_tempfile(p) for p in path]
+            yield filenames
+        else:
+            filenames = [create_tempfile(path)]
+            yield filenames[0]
+    finally:
+        for f in filenames:
+            safe_remove(f)
+
+
+def _maybe_remove(store, key):
+    """For tests using tables, try removing the table to be sure there is
+    no content from previous tests using the same table name.
+    """
+    try:
+        store.remove(key)
+    except (ValueError, KeyError):
+        pass
diff --git a/pandas/tests/io/pytables/conftest.py b/pandas/tests/io/pytables/conftest.py
new file mode 100644
index 0000000000000..214f95c6fb441
--- /dev/null
+++ b/pandas/tests/io/pytables/conftest.py
@@ -0,0 +1,17 @@
+import pytest
+
+import pandas._testing as tm
+
+
+@pytest.fixture
+def setup_path():
+    """Fixture for setup path"""
+    return "tmp.__{}__.h5".format(tm.rands(10))
+
+
+@pytest.fixture(scope="module", autouse=True)
+def setup_mode():
+    """ Reset testing mode fixture"""
+    tm.reset_testing_mode()
+    yield
+    tm.set_testing_mode()
diff --git a/pandas/tests/io/pytables/test_compat.py b/pandas/tests/io/pytables/test_compat.py
index f5f73beab6d60..c7200385aa998 100644
--- a/pandas/tests/io/pytables/test_compat.py
+++ b/pandas/tests/io/pytables/test_compat.py
@@ -1,29 +1,30 @@
 import pytest
 
 import pandas as pd
-from pandas.tests.io.pytables.test_pytables import ensure_clean_path
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
+from pandas.tests.io.pytables.common import ensure_clean_path
 
 tables = pytest.importorskip("tables")
 
 
 @pytest.fixture
 def pytables_hdf5_file():
-    """Use PyTables to create a simple HDF5 file."""
-
+    """
+    Use PyTables to create a simple HDF5 file.
+    """
     table_schema = {
         "c0": tables.Time64Col(pos=0),
         "c1": tables.StringCol(5, pos=1),
         "c2": tables.Int64Col(pos=2),
     }
 
-    t0 = 1561105000.0
+    t0 = 1_561_105_000.0
 
     testsamples = [
         {"c0": t0, "c1": "aaaaa", "c2": 1},
         {"c0": t0 + 1, "c1": "bbbbb", "c2": 2},
         {"c0": t0 + 2, "c1": "ccccc", "c2": 10 ** 5},
-        {"c0": t0 + 3, "c1": "ddddd", "c2": 4294967295},
+        {"c0": t0 + 3, "c1": "ddddd", "c2": 4_294_967_295},
     ]
 
     objname = "pandas_test_timeseries"
@@ -52,25 +53,25 @@ def test_read_complete(self, pytables_hdf5_file):
         path, objname, df = pytables_hdf5_file
         result = pd.read_hdf(path, key=objname)
         expected = df
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_with_start(self, pytables_hdf5_file):
         path, objname, df = pytables_hdf5_file
         # This is a regression test for pandas-dev/pandas/issues/11188
         result = pd.read_hdf(path, key=objname, start=1)
         expected = df[1:].reset_index(drop=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_with_stop(self, pytables_hdf5_file):
         path, objname, df = pytables_hdf5_file
         # This is a regression test for pandas-dev/pandas/issues/11188
         result = pd.read_hdf(path, key=objname, stop=1)
         expected = df[:1].reset_index(drop=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_read_with_startstop(self, pytables_hdf5_file):
         path, objname, df = pytables_hdf5_file
         # This is a regression test for pandas-dev/pandas/issues/11188
         result = pd.read_hdf(path, key=objname, start=1, stop=2)
         expected = df[1:2].reset_index(drop=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/pytables/test_complex.py b/pandas/tests/io/pytables/test_complex.py
new file mode 100644
index 0000000000000..543940e674dba
--- /dev/null
+++ b/pandas/tests/io/pytables/test_complex.py
@@ -0,0 +1,185 @@
+from warnings import catch_warnings
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame, Series
+import pandas._testing as tm
+from pandas.tests.io.pytables.common import ensure_clean_path, ensure_clean_store
+
+from pandas.io.pytables import read_hdf
+
+# GH10447
+
+
+def test_complex_fixed(setup_path):
+    df = DataFrame(
+        np.random.rand(4, 5).astype(np.complex64),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+    df = DataFrame(
+        np.random.rand(4, 5).astype(np.complex128),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+
+def test_complex_table(setup_path):
+    df = DataFrame(
+        np.random.rand(4, 5).astype(np.complex64),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df", format="table")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+    df = DataFrame(
+        np.random.rand(4, 5).astype(np.complex128),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df", format="table", mode="w")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+
+@td.xfail_non_writeable
+def test_complex_mixed_fixed(setup_path):
+    complex64 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
+    )
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "d"],
+            "C": complex64,
+            "D": complex128,
+            "E": [1.0, 2.0, 3.0, 4.0],
+        },
+        index=list("abcd"),
+    )
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+
+def test_complex_mixed_table(setup_path):
+    complex64 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
+    )
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "d"],
+            "C": complex64,
+            "D": complex128,
+            "E": [1.0, 2.0, 3.0, 4.0],
+        },
+        index=list("abcd"),
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("df", df, data_columns=["A", "B"])
+        result = store.select("df", where="A>2")
+        tm.assert_frame_equal(df.loc[df.A > 2], result)
+
+    with ensure_clean_path(setup_path) as path:
+        df.to_hdf(path, "df", format="table")
+        reread = read_hdf(path, "df")
+        tm.assert_frame_equal(df, reread)
+
+
+def test_complex_across_dimensions_fixed(setup_path):
+    with catch_warnings(record=True):
+        complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+        s = Series(complex128, index=list("abcd"))
+        df = DataFrame({"A": s, "B": s})
+
+        objs = [s, df]
+        comps = [tm.assert_series_equal, tm.assert_frame_equal]
+        for obj, comp in zip(objs, comps):
+            with ensure_clean_path(setup_path) as path:
+                obj.to_hdf(path, "obj", format="fixed")
+                reread = read_hdf(path, "obj")
+                comp(obj, reread)
+
+
+def test_complex_across_dimensions(setup_path):
+    complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+    s = Series(complex128, index=list("abcd"))
+    df = DataFrame({"A": s, "B": s})
+
+    with catch_warnings(record=True):
+
+        objs = [df]
+        comps = [tm.assert_frame_equal]
+        for obj, comp in zip(objs, comps):
+            with ensure_clean_path(setup_path) as path:
+                obj.to_hdf(path, "obj", format="table")
+                reread = read_hdf(path, "obj")
+                comp(obj, reread)
+
+
+def test_complex_indexing_error(setup_path):
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {"A": [1, 2, 3, 4], "B": ["a", "b", "c", "d"], "C": complex128},
+        index=list("abcd"),
+    )
+    with ensure_clean_store(setup_path) as store:
+        with pytest.raises(TypeError):
+            store.append("df", df, data_columns=["C"])
+
+
+def test_complex_series_error(setup_path):
+    complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+    s = Series(complex128, index=list("abcd"))
+
+    with ensure_clean_path(setup_path) as path:
+        with pytest.raises(TypeError):
+            s.to_hdf(path, "obj", format="t")
+
+    with ensure_clean_path(setup_path) as path:
+        s.to_hdf(path, "obj", format="t", index=False)
+        reread = read_hdf(path, "obj")
+        tm.assert_series_equal(s, reread)
+
+
+def test_complex_append(setup_path):
+    df = DataFrame(
+        {"a": np.random.randn(100).astype(np.complex128), "b": np.random.randn(100)}
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("df", df, data_columns=["b"])
+        store.append("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(pd.concat([df, df], 0), result)
diff --git a/pandas/tests/io/pytables/test_pytables_missing.py b/pandas/tests/io/pytables/test_pytables_missing.py
index 4ceb80889c989..9adb0a6d227da 100644
--- a/pandas/tests/io/pytables/test_pytables_missing.py
+++ b/pandas/tests/io/pytables/test_pytables_missing.py
@@ -3,7 +3,7 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @td.skip_if_installed("tables")
diff --git a/pandas/tests/io/pytables/test_pytables.py b/pandas/tests/io/pytables/test_store.py
similarity index 75%
rename from pandas/tests/io/pytables/test_pytables.py
rename to pandas/tests/io/pytables/test_store.py
index 77cac00882771..547de39eec5e0 100644
--- a/pandas/tests/io/pytables/test_pytables.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -1,17 +1,16 @@
-from contextlib import contextmanager
 import datetime
 from datetime import timedelta
 from distutils.version import LooseVersion
 from io import BytesIO
 import os
+from pathlib import Path
 import re
-import tempfile
 from warnings import catch_warnings, simplefilter
 
 import numpy as np
 import pytest
 
-from pandas.compat import PY36, is_platform_little_endian, is_platform_windows
+from pandas.compat import is_platform_little_endian, is_platform_windows
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import is_categorical_dtype
@@ -34,10 +33,17 @@
     isna,
     timedelta_range,
 )
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal, set_timezone
+import pandas._testing as tm
+from pandas.tests.io.pytables.common import (
+    _maybe_remove,
+    create_tempfile,
+    ensure_clean_path,
+    ensure_clean_store,
+    safe_close,
+    safe_remove,
+    tables,
+)
 
-from pandas.io.formats.printing import pprint_thing
 from pandas.io.pytables import (
     ClosedFileError,
     HDFStore,
@@ -49,143 +55,36 @@
 from pandas.io import pytables as pytables  # noqa: E402 isort:skip
 from pandas.io.pytables import TableIterator  # noqa: E402 isort:skip
 
-tables = pytest.importorskip("tables")
-
-
-# TODO:
-# remove when gh-24839 is fixed; this affects numpy 1.16
-# and pytables 3.4.4
-xfail_non_writeable = pytest.mark.xfail(
-    LooseVersion(np.__version__) >= LooseVersion("1.16")
-    and LooseVersion(tables.__version__) < LooseVersion("3.5.1"),
-    reason=(
-        "gh-25511, gh-24839. pytables needs a "
-        "release beyong 3.4.4 to support numpy 1.16x"
-    ),
-)
-
 
 _default_compressor = "blosc"
-
-
 ignore_natural_naming_warning = pytest.mark.filterwarnings(
     "ignore:object name:tables.exceptions.NaturalNameWarning"
 )
-ignore_sparse = pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-ignore_dataframe_tosparse = pytest.mark.filterwarnings(
-    "ignore:DataFrame.to_sparse:FutureWarning"
-)
-ignore_series_tosparse = pytest.mark.filterwarnings(
-    "ignore:Series.to_sparse:FutureWarning"
-)
-
-# contextmanager to ensure the file cleanup
-
-
-def safe_remove(path):
-    if path is not None:
-        try:
-            os.remove(path)
-        except OSError:
-            pass
-
-
-def safe_close(store):
-    try:
-        if store is not None:
-            store.close()
-    except IOError:
-        pass
-
-
-def create_tempfile(path):
-    """ create an unopened named temporary file """
-    return os.path.join(tempfile.gettempdir(), path)
-
-
-@contextmanager
-def ensure_clean_store(path, mode="a", complevel=None, complib=None, fletcher32=False):
-
-    try:
-
-        # put in the temporary path if we don't have one already
-        if not len(os.path.dirname(path)):
-            path = create_tempfile(path)
 
-        store = HDFStore(
-            path, mode=mode, complevel=complevel, complib=complib, fletcher32=False
-        )
-        yield store
-    finally:
-        safe_close(store)
-        if mode == "w" or mode == "a":
-            safe_remove(path)
-
-
-@contextmanager
-def ensure_clean_path(path):
-    """
-    return essentially a named temporary file that is not opened
-    and deleted on exiting; if path is a list, then create and
-    return list of filenames
-    """
-    try:
-        if isinstance(path, list):
-            filenames = [create_tempfile(p) for p in path]
-            yield filenames
-        else:
-            filenames = [create_tempfile(path)]
-            yield filenames[0]
-    finally:
-        for f in filenames:
-            safe_remove(f)
-
-
-# set these parameters so we don't have file sharing
-tables.parameters.MAX_NUMEXPR_THREADS = 1
-tables.parameters.MAX_BLOSC_THREADS = 1
-tables.parameters.MAX_THREADS = 1
-
-
-def _maybe_remove(store, key):
-    """For tests using tables, try removing the table to be sure there is
-    no content from previous tests using the same table name."""
-    try:
-        store.remove(key)
-    except (ValueError, KeyError):
-        pass
-
-
-class Base:
-    @classmethod
-    def setup_class(cls):
-
-        # Pytables 3.0.0 deprecates lots of things
-        tm.reset_testing_mode()
 
-    @classmethod
-    def teardown_class(cls):
-
-        # Pytables 3.0.0 deprecates lots of things
-        tm.set_testing_mode()
+@pytest.mark.single
+class TestHDFStore:
+    def test_format_type(self, setup_path):
+        df = pd.DataFrame({"A": [1, 2]})
+        with ensure_clean_path(setup_path) as path:
+            with HDFStore(path) as store:
+                store.put("a", df, format="fixed")
+                store.put("b", df, format="table")
 
-    def setup_method(self, method):
-        self.path = "tmp.__{}__.h5".format(tm.rands(10))
+                assert store.get_storer("a").format_type == "fixed"
+                assert store.get_storer("b").format_type == "table"
 
-    def teardown_method(self, method):
-        pass
+    def test_format_kwarg_in_constructor(self, setup_path):
+        # GH 13291
 
+        msg = "format is not a defined argument for HDFStore"
 
-@pytest.mark.single
-class TestHDFStore(Base):
-    def test_format_kwarg_in_constructor(self):
-        # GH 13291
-        with ensure_clean_path(self.path) as path:
-            with pytest.raises(ValueError):
+        with ensure_clean_path(setup_path) as path:
+            with pytest.raises(ValueError, match=msg):
                 HDFStore(path, format="table")
 
-    def test_context(self):
-        path = create_tempfile(self.path)
+    def test_context(self, setup_path):
+        path = create_tempfile(setup_path)
         try:
             with HDFStore(path) as tbl:
                 raise ValueError("blah")
@@ -204,8 +103,8 @@ def test_context(self):
         finally:
             safe_remove(path)
 
-    def test_conv_read_write(self):
-        path = create_tempfile(self.path)
+    def test_conv_read_write(self, setup_path):
+        path = create_tempfile(setup_path)
         try:
 
             def roundtrip(key, obj, **kwargs):
@@ -213,80 +112,80 @@ def roundtrip(key, obj, **kwargs):
                 return read_hdf(path, key)
 
             o = tm.makeTimeSeries()
-            assert_series_equal(o, roundtrip("series", o))
+            tm.assert_series_equal(o, roundtrip("series", o))
 
             o = tm.makeStringSeries()
-            assert_series_equal(o, roundtrip("string_series", o))
+            tm.assert_series_equal(o, roundtrip("string_series", o))
 
             o = tm.makeDataFrame()
-            assert_frame_equal(o, roundtrip("frame", o))
+            tm.assert_frame_equal(o, roundtrip("frame", o))
 
             # table
             df = DataFrame(dict(A=range(5), B=range(5)))
             df.to_hdf(path, "table", append=True)
             result = read_hdf(path, "table", where=["index>2"])
-            assert_frame_equal(df[df.index > 2], result)
+            tm.assert_frame_equal(df[df.index > 2], result)
 
         finally:
             safe_remove(path)
 
-    def test_long_strings(self):
+    def test_long_strings(self, setup_path):
 
         # GH6166
         df = DataFrame(
             {"a": tm.rands_array(100, size=10)}, index=tm.rands_array(100, size=10)
         )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df", df, data_columns=["a"])
 
             result = store.select("df")
-            assert_frame_equal(df, result)
+            tm.assert_frame_equal(df, result)
 
-    def test_api(self):
+    def test_api(self, setup_path):
 
         # GH4584
         # API issue when to_hdf doesn't accept append AND format args
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
             df.iloc[:10].to_hdf(path, "df", append=True, format="table")
             df.iloc[10:].to_hdf(path, "df", append=True, format="table")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
             # append to False
             df.iloc[:10].to_hdf(path, "df", append=False, format="table")
             df.iloc[10:].to_hdf(path, "df", append=True, format="table")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
             df.iloc[:10].to_hdf(path, "df", append=True)
             df.iloc[10:].to_hdf(path, "df", append=True, format="table")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
             # append to False
             df.iloc[:10].to_hdf(path, "df", append=False, format="table")
             df.iloc[10:].to_hdf(path, "df", append=True)
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
             df.to_hdf(path, "df", append=False, format="fixed")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
             df.to_hdf(path, "df", append=False, format="f")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
             df.to_hdf(path, "df", append=False)
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
             df.to_hdf(path, "df")
-            assert_frame_equal(read_hdf(path, "df"), df)
+            tm.assert_frame_equal(read_hdf(path, "df"), df)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             path = store._path
             df = tm.makeDataFrame()
@@ -294,57 +193,66 @@ def test_api(self):
             _maybe_remove(store, "df")
             store.append("df", df.iloc[:10], append=True, format="table")
             store.append("df", df.iloc[10:], append=True, format="table")
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
 
             # append to False
             _maybe_remove(store, "df")
             store.append("df", df.iloc[:10], append=False, format="table")
             store.append("df", df.iloc[10:], append=True, format="table")
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
 
             # formats
             _maybe_remove(store, "df")
             store.append("df", df.iloc[:10], append=False, format="table")
             store.append("df", df.iloc[10:], append=True, format="table")
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
 
             _maybe_remove(store, "df")
             store.append("df", df.iloc[:10], append=False, format="table")
             store.append("df", df.iloc[10:], append=True, format=None)
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             # Invalid.
             df = tm.makeDataFrame()
 
-            with pytest.raises(ValueError):
+            msg = "Can only append to Tables"
+
+            with pytest.raises(ValueError, match=msg):
                 df.to_hdf(path, "df", append=True, format="f")
 
-            with pytest.raises(ValueError):
+            with pytest.raises(ValueError, match=msg):
                 df.to_hdf(path, "df", append=True, format="fixed")
 
-            with pytest.raises(TypeError):
+            msg = r"invalid HDFStore format specified \[foo\]"
+
+            with pytest.raises(TypeError, match=msg):
                 df.to_hdf(path, "df", append=True, format="foo")
 
-            with pytest.raises(TypeError):
-                df.to_hdf(path, "df", append=False, format="bar")
+            with pytest.raises(TypeError, match=msg):
+                df.to_hdf(path, "df", append=False, format="foo")
 
         # File path doesn't exist
         path = ""
-        with pytest.raises(FileNotFoundError):
+        msg = f"File {path} does not exist"
+
+        with pytest.raises(FileNotFoundError, match=msg):
             read_hdf(path, "df")
 
-    def test_api_default_format(self):
+    def test_api_default_format(self, setup_path):
 
         # default_format option
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = tm.makeDataFrame()
 
             pd.set_option("io.hdf.default_format", "fixed")
             _maybe_remove(store, "df")
             store.put("df", df)
             assert not store.get_storer("df").is_table
-            with pytest.raises(ValueError):
+
+            msg = "Can only append to Tables"
+
+            with pytest.raises(ValueError, match=msg):
                 store.append("df2", df)
 
             pd.set_option("io.hdf.default_format", "table")
@@ -357,7 +265,7 @@ def test_api_default_format(self):
 
             pd.set_option("io.hdf.default_format", None)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
 
@@ -365,7 +273,7 @@ def test_api_default_format(self):
             df.to_hdf(path, "df")
             with HDFStore(path) as store:
                 assert not store.get_storer("df").is_table
-            with pytest.raises(ValueError):
+            with pytest.raises(ValueError, match=msg):
                 df.to_hdf(path, "df2", append=True)
 
             pd.set_option("io.hdf.default_format", "table")
@@ -378,9 +286,9 @@ def test_api_default_format(self):
 
             pd.set_option("io.hdf.default_format", None)
 
-    def test_keys(self):
+    def test_keys(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeSeries()
             store["b"] = tm.makeStringSeries()
             store["c"] = tm.makeDataFrame()
@@ -390,12 +298,12 @@ def test_keys(self):
             assert set(store.keys()) == expected
             assert set(store) == expected
 
-    def test_keys_ignore_hdf_softlink(self):
+    def test_keys_ignore_hdf_softlink(self, setup_path):
 
         # GH 20523
         # Puts a softlink into HDF file and rereads
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(dict(A=range(5), B=range(5)))
             store.put("df", df)
@@ -407,15 +315,15 @@ def test_keys_ignore_hdf_softlink(self):
             # Should ignore the softlink
             assert store.keys() == ["/df"]
 
-    def test_iter_empty(self):
+    def test_iter_empty(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # GH 12221
             assert list(store) == []
 
-    def test_repr(self):
+    def test_repr(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             repr(store)
             store.info()
             store["a"] = tm.makeTimeSeries()
@@ -449,7 +357,7 @@ def test_repr(self):
             store.info()
 
         # storers
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = tm.makeDataFrame()
             store.append("df", df)
@@ -459,9 +367,9 @@ def test_repr(self):
             str(s)
 
     @ignore_natural_naming_warning
-    def test_contains(self):
+    def test_contains(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeSeries()
             store["b"] = tm.makeDataFrame()
             store["foo/bar"] = tm.makeDataFrame()
@@ -478,9 +386,9 @@ def test_contains(self):
                 store["node())"] = tm.makeDataFrame()
             assert "node())" in store
 
-    def test_versioning(self):
+    def test_versioning(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeSeries()
             store["b"] = tm.makeDataFrame()
             df = tm.makeTimeDataFrame()
@@ -498,16 +406,19 @@ def test_versioning(self):
             # this is an error because its table_type is appendable, but no
             # version info
             store.get_node("df2")._v_attrs.pandas_version = None
-            with pytest.raises(Exception):
+
+            msg = "'NoneType' object has no attribute 'startswith'"
+
+            with pytest.raises(Exception, match=msg):
                 store.select("df2")
 
-    def test_mode(self):
+    def test_mode(self, setup_path):
 
         df = tm.makeTimeDataFrame()
 
         def check(mode):
 
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
 
                 # constructor
                 if mode in ["r", "r+"]:
@@ -519,7 +430,7 @@ def check(mode):
                     assert store._handle.mode == mode
                     store.close()
 
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
 
                 # context
                 if mode in ["r", "r+"]:
@@ -530,7 +441,7 @@ def check(mode):
                     with HDFStore(path, mode=mode) as store:
                         assert store._handle.mode == mode
 
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
 
                 # conv write
                 if mode in ["r", "r+"]:
@@ -542,19 +453,23 @@ def check(mode):
 
                 # conv read
                 if mode in ["w"]:
-                    with pytest.raises(ValueError):
+                    msg = (
+                        "mode w is not allowed while performing a read. "
+                        r"Allowed modes are r, r\+ and a."
+                    )
+                    with pytest.raises(ValueError, match=msg):
                         read_hdf(path, "df", mode=mode)
                 else:
                     result = read_hdf(path, "df", mode=mode)
-                    assert_frame_equal(result, df)
+                    tm.assert_frame_equal(result, df)
 
         def check_default_mode():
 
             # read_hdf uses default mode
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
                 df.to_hdf(path, "df", mode="w")
                 result = read_hdf(path, "df")
-                assert_frame_equal(result, df)
+                tm.assert_frame_equal(result, df)
 
         check("r")
         check("r+")
@@ -562,9 +477,9 @@ def check_default_mode():
         check("w")
         check_default_mode()
 
-    def test_reopen_handle(self):
+    def test_reopen_handle(self, setup_path):
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             store = HDFStore(path, mode="a")
             store["a"] = tm.makeTimeSeries()
@@ -610,9 +525,9 @@ def test_reopen_handle(self):
             store.close()
             assert not store.is_open
 
-    def test_open_args(self):
+    def test_open_args(self, setup_path):
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
 
@@ -631,16 +546,16 @@ def test_open_args(self):
             # the file should not have actually been written
             assert not os.path.exists(path)
 
-    def test_flush(self):
+    def test_flush(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeSeries()
             store.flush()
             store.flush(fsync=True)
 
-    def test_get(self):
+    def test_get(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeSeries()
             left = store.get("a")
             right = store["a"]
@@ -674,7 +589,7 @@ def test_get(self):
             ),
         ],
     )
-    def test_walk(self, where, expected):
+    def test_walk(self, where, expected, setup_path):
         # GH10143
         objs = {
             "df1": pd.DataFrame([1, 2, 3]),
@@ -713,9 +628,9 @@ def test_walk(self, where, expected):
                     else:
                         tm.assert_series_equal(obj, objs[leaf])
 
-    def test_getattr(self):
+    def test_getattr(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             s = tm.makeTimeSeries()
             store["a"] = s
@@ -740,9 +655,9 @@ def test_getattr(self):
             for x in ["mode", "path", "handle", "complib"]:
                 getattr(store, "_{x}".format(x=x))
 
-    def test_put(self):
+    def test_put(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             ts = tm.makeTimeSeries()
             df = tm.makeTimeDataFrame()
@@ -771,9 +686,9 @@ def test_put(self):
             store.put("c", df[:10], format="table", append=False)
             tm.assert_frame_equal(df[:10], store["c"])
 
-    def test_put_string_index(self):
+    def test_put_string_index(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             index = Index(
                 ["I am a very long string index: {i}".format(i=i) for i in range(20)]
@@ -800,9 +715,9 @@ def test_put_string_index(self):
             store["b"] = df
             tm.assert_frame_equal(store["b"], df)
 
-    def test_put_compression(self):
+    def test_put_compression(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = tm.makeTimeDataFrame()
 
             store.put("c", df, format="table", complib="zlib")
@@ -813,10 +728,10 @@ def test_put_compression(self):
                 store.put("b", df, format="fixed", complib="zlib")
 
     @td.skip_if_windows_python_3
-    def test_put_compression_blosc(self):
+    def test_put_compression_blosc(self, setup_path):
         df = tm.makeTimeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # can't compress if format='fixed'
             with pytest.raises(ValueError):
@@ -825,13 +740,13 @@ def test_put_compression_blosc(self):
             store.put("c", df, format="table", complib="blosc")
             tm.assert_frame_equal(store["c"], df)
 
-    def test_complibs_default_settings(self):
+    def test_complibs_default_settings(self, setup_path):
         # GH15943
         df = tm.makeDataFrame()
 
         # Set complevel and check if complib is automatically set to
         # default value
-        with ensure_clean_path(self.path) as tmpfile:
+        with ensure_clean_path(setup_path) as tmpfile:
             df.to_hdf(tmpfile, "df", complevel=9)
             result = pd.read_hdf(tmpfile, "df")
             tm.assert_frame_equal(result, df)
@@ -842,7 +757,7 @@ def test_complibs_default_settings(self):
                     assert node.filters.complib == "zlib"
 
         # Set complib and check to see if compression is disabled
-        with ensure_clean_path(self.path) as tmpfile:
+        with ensure_clean_path(setup_path) as tmpfile:
             df.to_hdf(tmpfile, "df", complib="zlib")
             result = pd.read_hdf(tmpfile, "df")
             tm.assert_frame_equal(result, df)
@@ -853,7 +768,7 @@ def test_complibs_default_settings(self):
                     assert node.filters.complib is None
 
         # Check if not setting complib or complevel results in no compression
-        with ensure_clean_path(self.path) as tmpfile:
+        with ensure_clean_path(setup_path) as tmpfile:
             df.to_hdf(tmpfile, "df")
             result = pd.read_hdf(tmpfile, "df")
             tm.assert_frame_equal(result, df)
@@ -864,7 +779,7 @@ def test_complibs_default_settings(self):
                     assert node.filters.complib is None
 
         # Check if file-defaults can be overridden on a per table basis
-        with ensure_clean_path(self.path) as tmpfile:
+        with ensure_clean_path(setup_path) as tmpfile:
             store = pd.HDFStore(tmpfile)
             store.append("dfc", df, complevel=9, complib="blosc")
             store.append("df", df)
@@ -878,7 +793,7 @@ def test_complibs_default_settings(self):
                     assert node.filters.complevel == 9
                     assert node.filters.complib == "blosc"
 
-    def test_complibs(self):
+    def test_complibs(self, setup_path):
         # GH14478
         df = tm.makeDataFrame()
 
@@ -895,7 +810,7 @@ def test_complibs(self):
         all_tests = [(lib, lvl) for lib in all_complibs for lvl in all_levels]
 
         for (lib, lvl) in all_tests:
-            with ensure_clean_path(self.path) as tmpfile:
+            with ensure_clean_path(setup_path) as tmpfile:
                 gname = "foo"
 
                 # Write and read file to see if data is consistent
@@ -914,13 +829,13 @@ def test_complibs(self):
                         assert node.filters.complib == lib
                 h5table.close()
 
-    def test_put_integer(self):
+    def test_put_integer(self, setup_path):
         # non-date, non-string index
         df = DataFrame(np.random.randn(50, 100))
-        self._check_roundtrip(df, tm.assert_frame_equal)
+        self._check_roundtrip(df, tm.assert_frame_equal, setup_path)
 
-    @xfail_non_writeable
-    def test_put_mixed_type(self):
+    @td.xfail_non_writeable
+    def test_put_mixed_type(self, setup_path):
         df = tm.makeTimeDataFrame()
         df["obj1"] = "foo"
         df["obj2"] = "bar"
@@ -936,7 +851,7 @@ def test_put_mixed_type(self):
         df.loc[3:6, ["obj1"]] = np.nan
         df = df._consolidate()._convert(datetime=True)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             _maybe_remove(store, "df")
 
             # PerformanceWarning
@@ -950,9 +865,9 @@ def test_put_mixed_type(self):
     @pytest.mark.filterwarnings(
         "ignore:object name:tables.exceptions.NaturalNameWarning"
     )
-    def test_append(self):
+    def test_append(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # this is allowed by almost always don't want to do it
             # tables.NaturalNameWarning):
@@ -1018,9 +933,9 @@ def test_append(self):
                 store.append("uints", uint_data, data_columns=["u08", "u16", "u32"])
                 tm.assert_frame_equal(store["uints"], uint_data)
 
-    def test_append_series(self):
+    def test_append_series(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # basic
             ss = tm.makeStringSeries()
@@ -1064,11 +979,11 @@ def test_append_series(self):
             store.append("mi", s)
             tm.assert_series_equal(store["mi"], s)
 
-    def test_store_index_types(self):
+    def test_store_index_types(self, setup_path):
         # GH5386
         # test storing various index types
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             def check(format, index):
                 df = DataFrame(np.random.randn(10, 2), columns=list("AB"))
@@ -1076,7 +991,7 @@ def check(format, index):
 
                 _maybe_remove(store, "df")
                 store.put("df", df, format=format)
-                assert_frame_equal(df, store["df"])
+                tm.assert_frame_equal(df, store["df"])
 
             for index in [
                 tm.makeFloatIndex,
@@ -1101,9 +1016,9 @@ def check(format, index):
     @pytest.mark.skipif(
         not is_platform_little_endian(), reason="reason platform is not little endian"
     )
-    def test_encoding(self):
+    def test_encoding(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = DataFrame(dict(A="foo", B="bar"), index=range(5))
             df.loc[2, "A"] = np.nan
             df.loc[3, "B"] = np.nan
@@ -1130,7 +1045,7 @@ def test_encoding(self):
         ],
     )
     @pytest.mark.parametrize("dtype", ["category", object])
-    def test_latin_encoding(self, dtype, val):
+    def test_latin_encoding(self, setup_path, dtype, val):
         enc = "latin-1"
         nan_rep = ""
         key = "data"
@@ -1138,7 +1053,7 @@ def test_latin_encoding(self, dtype, val):
         val = [x.decode(enc) if isinstance(x, bytes) else x for x in val]
         ser = pd.Series(val, dtype=dtype)
 
-        with ensure_clean_path(self.path) as store:
+        with ensure_clean_path(setup_path) as store:
             ser.to_hdf(store, key, format="table", encoding=enc, nan_rep=nan_rep)
             retr = read_hdf(store, key)
 
@@ -1146,18 +1061,20 @@ def test_latin_encoding(self, dtype, val):
 
         if is_categorical_dtype(s_nan):
             assert is_categorical_dtype(retr)
-            assert_series_equal(s_nan, retr, check_dtype=False, check_categorical=False)
+            tm.assert_series_equal(
+                s_nan, retr, check_dtype=False, check_categorical=False
+            )
         else:
-            assert_series_equal(s_nan, retr)
+            tm.assert_series_equal(s_nan, retr)
 
         # FIXME: don't leave commented-out
         # fails:
         # for x in examples:
         #     roundtrip(s, nan_rep=b'\xf8\xfc')
 
-    def test_append_some_nans(self):
+    def test_append_some_nans(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = DataFrame(
                 {
                     "A": Series(np.random.randn(20)).astype("int32"),
@@ -1201,9 +1118,9 @@ def test_append_some_nans(self):
             store.append("df3", df3[10:])
             tm.assert_frame_equal(store["df3"], df3)
 
-    def test_append_all_nans(self):
+    def test_append_all_nans(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(
                 {"A1": np.random.randn(20), "A2": np.random.randn(20)},
@@ -1291,14 +1208,14 @@ def test_append_all_nans(self):
             {"col1": [0, np.nan, 2], "col2": [1, np.nan, np.nan]}
         )
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df_with_missing.to_hdf(path, "df_with_missing", format="table")
             reloaded = read_hdf(path, "df_with_missing")
             tm.assert_frame_equal(df_with_missing, reloaded)
 
-    def test_read_missing_key_close_store(self):
+    def test_read_missing_key_close_store(self, setup_path):
         # GH 25766
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df = pd.DataFrame({"a": range(2), "b": range(2)})
             df.to_hdf(path, "k1")
 
@@ -1309,9 +1226,23 @@ def test_read_missing_key_close_store(self):
             # read with KeyError before another write
             df.to_hdf(path, "k2")
 
-    def test_append_frame_column_oriented(self):
+    def test_read_missing_key_opened_store(self, setup_path):
+        # GH 28699
+        with ensure_clean_path(setup_path) as path:
+            df = pd.DataFrame({"a": range(2), "b": range(2)})
+            df.to_hdf(path, "k1")
+
+            store = pd.HDFStore(path, "r")
+
+            with pytest.raises(KeyError, match="'No object named k2 in the file'"):
+                pd.read_hdf(store, "k2")
+
+            # Test that the file is still open after a KeyError and that we can
+            # still read from it.
+            pd.read_hdf(store, "k1")
 
-        with ensure_clean_store(self.path) as store:
+    def test_append_frame_column_oriented(self, setup_path):
+        with ensure_clean_store(setup_path) as store:
 
             # column oriented
             df = tm.makeTimeDataFrame()
@@ -1333,10 +1264,10 @@ def test_append_frame_column_oriented(self):
             with pytest.raises(TypeError):
                 store.select("df1", "columns=A and index>df.index[4]")
 
-    def test_append_with_different_block_ordering(self):
+    def test_append_with_different_block_ordering(self, setup_path):
 
         # GH 4096; using same frames, but different block orderings
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             for i in range(10):
 
@@ -1359,7 +1290,7 @@ def test_append_with_different_block_ordering(self):
 
         # test a different ordering but with more fields (like invalid
         # combinate)
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(np.random.randn(10, 2), columns=list("AB"), dtype="float64")
             df["int64"] = Series([1] * len(df), dtype="int64")
@@ -1371,14 +1302,14 @@ def test_append_with_different_block_ordering(self):
             with pytest.raises(ValueError):
                 store.append("df", df)
 
-            # store multile additional fields in different blocks
+            # store multiple additional fields in different blocks
             df["float_3"] = Series([1.0] * len(df), dtype="float64")
             with pytest.raises(ValueError):
                 store.append("df", df)
 
-    def test_append_with_strings(self):
+    def test_append_with_strings(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             with catch_warnings(record=True):
 
                 def check_col(key, name, size):
@@ -1452,7 +1383,7 @@ def check_col(key, name, size):
                 result = store.select("df")
                 tm.assert_frame_equal(result, df)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             def check_col(key, name, size):
                 assert getattr(
@@ -1492,9 +1423,9 @@ def check_col(key, name, size):
             with pytest.raises(ValueError):
                 store.append("df", df, min_itemsize={"foo": 20, "foobar": 20})
 
-    def test_append_with_empty_string(self):
+    def test_append_with_empty_string(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # with all empty strings (GH 12242)
             df = DataFrame({"x": ["a", "b", "c", "d", "e", "f", ""]})
@@ -1502,9 +1433,9 @@ def test_append_with_empty_string(self):
             store.append("df", df[-1:], min_itemsize={"x": 1})
             tm.assert_frame_equal(store.select("df"), df)
 
-    def test_to_hdf_with_min_itemsize(self):
+    def test_to_hdf_with_min_itemsize(self, setup_path):
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             # min_itemsize in index with to_hdf (GH 10381)
             df = tm.makeMixedDataFrame().set_index("C")
@@ -1522,22 +1453,22 @@ def test_to_hdf_with_min_itemsize(self):
             )
 
     @pytest.mark.parametrize(
-        "format", [pytest.param("fixed", marks=xfail_non_writeable), "table"]
+        "format", [pytest.param("fixed", marks=td.xfail_non_writeable), "table"]
     )
-    def test_to_hdf_errors(self, format):
+    def test_to_hdf_errors(self, format, setup_path):
 
         data = ["\ud800foo"]
         ser = pd.Series(data, index=pd.Index(data))
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             # GH 20835
             ser.to_hdf(path, "table", format=format, errors="surrogatepass")
 
             result = pd.read_hdf(path, "table", errors="surrogatepass")
             tm.assert_series_equal(result, ser)
 
-    def test_append_with_data_columns(self):
+    def test_append_with_data_columns(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = tm.makeTimeDataFrame()
             df.iloc[0, df.columns.get_loc("B")] = 1.0
             _maybe_remove(store, "df")
@@ -1578,7 +1509,7 @@ def check_col(key, name, size):
                     == size
                 )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             _maybe_remove(store, "df")
             store.append(
                 "df", df_new, data_columns=["string"], min_itemsize={"string": 30}
@@ -1593,7 +1524,7 @@ def check_col(key, name, size):
             )
             check_col("df", "string", 30)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df_new["string2"] = "foobarbah"
             df_new["string_block1"] = "foobarbah1"
             df_new["string_block2"] = "foobarbah2"
@@ -1608,7 +1539,7 @@ def check_col(key, name, size):
             check_col("df", "string2", 40)
             check_col("df", "values_block_1", 50)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # multiple data columns
             df_new = df.copy()
             df_new.iloc[0, df_new.columns.get_loc("A")] = 1.0
@@ -1641,7 +1572,7 @@ def check_col(key, name, size):
             expected = df_new[(df_new.string == "foo") & (df_new.string2 == "cool")]
             tm.assert_frame_equal(result, expected, check_index_type=False)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # doc example
             df_dc = df.copy()
             df_dc["string"] = "foo"
@@ -1665,7 +1596,7 @@ def check_col(key, name, size):
             expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) & (df_dc.string == "foo")]
             tm.assert_frame_equal(result, expected, check_index_type=False)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # doc example part 2
             np.random.seed(1234)
             index = date_range("1/1/2000", periods=8)
@@ -1689,9 +1620,9 @@ def check_col(key, name, size):
             expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) & (df_dc.string == "foo")]
             tm.assert_frame_equal(result, expected)
 
-    def test_create_table_index(self):
+    def test_create_table_index(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             with catch_warnings(record=True):
 
@@ -1721,7 +1652,7 @@ def col(t, column):
                 with pytest.raises(TypeError):
                     store.create_table_index("f2")
 
-    def test_append_hierarchical(self):
+    def test_append_hierarchical(self, setup_path):
         index = MultiIndex(
             levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
             codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
@@ -1729,7 +1660,7 @@ def test_append_hierarchical(self):
         )
         df = DataFrame(np.random.randn(10, 3), index=index, columns=["A", "B", "C"])
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("mi", df)
             result = store.select("mi")
             tm.assert_frame_equal(result, df)
@@ -1745,7 +1676,7 @@ def test_append_hierarchical(self):
             expected = df.reindex(columns=["A", "B"])
             tm.assert_frame_equal(result, expected)
 
-    def test_column_multiindex(self):
+    def test_column_multiindex(self, setup_path):
         # GH 4710
         # recreate multi-indexes properly
 
@@ -1757,7 +1688,7 @@ def test_column_multiindex(self):
         if isinstance(expected.index, RangeIndex):
             expected.index = Int64Index(expected.index)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             store.put("df", df)
             tm.assert_frame_equal(
@@ -1775,7 +1706,7 @@ def test_column_multiindex(self):
                 store.put("df3", df, format="table", data_columns=True)
 
         # appending multi-column on existing table (see GH 6167)
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df2", df)
             store.append("df2", df)
 
@@ -1789,18 +1720,18 @@ def test_column_multiindex(self):
         if isinstance(expected.index, RangeIndex):
             expected.index = Int64Index(expected.index)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             store.put("df1", df, format="table")
             tm.assert_frame_equal(
                 store["df1"], expected, check_index_type=True, check_column_type=True
             )
 
-    def test_store_multiindex(self):
+    def test_store_multiindex(self, setup_path):
 
         # validate multi-index names
         # GH 5527
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             def make_index(names=None):
                 return MultiIndex.from_tuples(
@@ -1866,7 +1797,7 @@ def make_index(names=None):
             store.append("df", df)
             tm.assert_frame_equal(store.select("df"), df)
 
-    def test_select_columns_in_where(self):
+    def test_select_columns_in_where(self, setup_path):
 
         # GH 6169
         # recreate multi-indexes when columns is passed
@@ -1880,7 +1811,7 @@ def test_select_columns_in_where(self):
         # With a DataFrame
         df = DataFrame(np.random.randn(10, 3), index=index, columns=["A", "B", "C"])
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df, format="table")
             expected = df[["A"]]
 
@@ -1890,39 +1821,39 @@ def test_select_columns_in_where(self):
 
         # With a Series
         s = Series(np.random.randn(10), index=index, name="A")
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("s", s, format="table")
             tm.assert_series_equal(store.select("s", where="columns=['A']"), s)
 
-    def test_mi_data_columns(self):
+    def test_mi_data_columns(self, setup_path):
         # GH 14435
         idx = pd.MultiIndex.from_arrays(
             [date_range("2000-01-01", periods=5), range(5)], names=["date", "id"]
         )
         df = pd.DataFrame({"a": [1.1, 1.2, 1.3, 1.4, 1.5]}, index=idx)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df", df, data_columns=True)
 
             actual = store.select("df", where="id == 1")
             expected = df.iloc[[1], :]
             tm.assert_frame_equal(actual, expected)
 
-    def test_pass_spec_to_storer(self):
+    def test_pass_spec_to_storer(self, setup_path):
 
         df = tm.makeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df)
             with pytest.raises(TypeError):
                 store.select("df", columns=["A"])
             with pytest.raises(TypeError):
                 store.select("df", where=[("columns=A")])
 
-    @xfail_non_writeable
-    def test_append_misc(self):
+    @td.xfail_non_writeable
+    def test_append_misc(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = tm.makeDataFrame()
             store.append("df", df, chunksize=1)
             result = store.select("df")
@@ -1935,7 +1866,7 @@ def test_append_misc(self):
         # more chunksize in append tests
         def check(obj, comparator):
             for c in [10, 200, 1000]:
-                with ensure_clean_store(self.path, mode="w") as store:
+                with ensure_clean_store(setup_path, mode="w") as store:
                     store.append("obj", obj, chunksize=c)
                     result = store.select("obj")
                     comparator(result, obj)
@@ -1950,7 +1881,7 @@ def check(obj, comparator):
         check(df, tm.assert_frame_equal)
 
         # empty frame, GH4273
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # 0 len
             df_empty = DataFrame(columns=list("ABC"))
@@ -1961,18 +1892,18 @@ def check(obj, comparator):
             # repeated append of 0/non-zero frames
             df = DataFrame(np.random.rand(10, 3), columns=list("ABC"))
             store.append("df", df)
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
             store.append("df", df_empty)
-            assert_frame_equal(store.select("df"), df)
+            tm.assert_frame_equal(store.select("df"), df)
 
             # store
             df = DataFrame(columns=list("ABC"))
             store.put("df2", df)
-            assert_frame_equal(store.select("df2"), df)
+            tm.assert_frame_equal(store.select("df2"), df)
 
-    def test_append_raise(self):
+    def test_append_raise(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # test append with invalid input to get good error messages
 
@@ -2015,25 +1946,25 @@ def test_append_raise(self):
             with pytest.raises(ValueError):
                 store.append("df", df)
 
-    def test_table_index_incompatible_dtypes(self):
+    def test_table_index_incompatible_dtypes(self, setup_path):
         df1 = DataFrame({"a": [1, 2, 3]})
         df2 = DataFrame({"a": [4, 5, 6]}, index=date_range("1/1/2000", periods=3))
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("frame", df1, format="table")
             with pytest.raises(TypeError):
                 store.put("frame", df2, format="table", append=True)
 
-    def test_table_values_dtypes_roundtrip(self):
+    def test_table_values_dtypes_roundtrip(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df1 = DataFrame({"a": [1, 2, 3]}, dtype="f8")
             store.append("df_f8", df1)
-            assert_series_equal(df1.dtypes, store["df_f8"].dtypes)
+            tm.assert_series_equal(df1.dtypes, store["df_f8"].dtypes)
 
             df2 = DataFrame({"a": [1, 2, 3]}, dtype="i8")
             store.append("df_i8", df2)
-            assert_series_equal(df2.dtypes, store["df_i8"].dtypes)
+            tm.assert_series_equal(df2.dtypes, store["df_i8"].dtypes)
 
             # incompatible dtype
             with pytest.raises(ValueError):
@@ -2043,7 +1974,7 @@ def test_table_values_dtypes_roundtrip(self):
             # actually create them thought)
             df1 = DataFrame(np.array([[1], [2], [3]], dtype="f4"), columns=["A"])
             store.append("df_f4", df1)
-            assert_series_equal(df1.dtypes, store["df_f4"].dtypes)
+            tm.assert_series_equal(df1.dtypes, store["df_f4"].dtypes)
             assert df1.dtypes[0] == "float32"
 
             # check with mixed dtypes
@@ -2080,7 +2011,7 @@ def test_table_values_dtypes_roundtrip(self):
             expected = expected.sort_index()
             tm.assert_series_equal(result, expected)
 
-    def test_table_mixed_dtypes(self):
+    def test_table_mixed_dtypes(self, setup_path):
 
         # frame
         df = tm.makeDataFrame()
@@ -2098,13 +2029,13 @@ def test_table_mixed_dtypes(self):
         df.loc[3:6, ["obj1"]] = np.nan
         df = df._consolidate()._convert(datetime=True)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df1_mixed", df)
             tm.assert_frame_equal(store.select("df1_mixed"), df)
 
-    def test_unimplemented_dtypes_table_columns(self):
+    def test_unimplemented_dtypes_table_columns(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             dtypes = [("date", datetime.date(2001, 1, 2))]
 
@@ -2122,12 +2053,12 @@ def test_unimplemented_dtypes_table_columns(self):
         df["datetime1"] = datetime.date(2001, 1, 2)
         df = df._consolidate()._convert(datetime=True)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # this fails because we have a date in the object block......
             with pytest.raises(TypeError):
                 store.append("df_unimplemented", df)
 
-    @xfail_non_writeable
+    @td.xfail_non_writeable
     @pytest.mark.skipif(
         LooseVersion(np.__version__) == LooseVersion("1.15.0"),
         reason=(
@@ -2135,7 +2066,7 @@ def test_unimplemented_dtypes_table_columns(self):
             "exactly equal to 1.15.0: gh-22098"
         ),
     )
-    def test_calendar_roundtrip_issue(self):
+    def test_calendar_roundtrip_issue(self, setup_path):
 
         # 8591
         # doc example from tseries holiday section
@@ -2153,28 +2084,28 @@ def test_calendar_roundtrip_issue(self):
 
         s = Series(dts.weekday, dts).map(Series("Mon Tue Wed Thu Fri Sat Sun".split()))
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             store.put("fixed", s)
             result = store.select("fixed")
-            assert_series_equal(result, s)
+            tm.assert_series_equal(result, s)
 
             store.append("table", s)
             result = store.select("table")
-            assert_series_equal(result, s)
+            tm.assert_series_equal(result, s)
 
-    def test_roundtrip_tz_aware_index(self):
+    def test_roundtrip_tz_aware_index(self, setup_path):
         # GH 17618
         time = pd.Timestamp("2000-01-01 01:00:00", tz="US/Eastern")
         df = pd.DataFrame(data=[0], index=[time])
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("frame", df, format="fixed")
             recons = store["frame"]
             tm.assert_frame_equal(recons, df)
             assert recons.index[0].value == 946706400000000000
 
-    def test_append_with_timedelta(self):
+    def test_append_with_timedelta(self, setup_path):
         # GH 3577
         # append timedelta
 
@@ -2190,42 +2121,42 @@ def test_append_with_timedelta(self):
         df["C"] = df["A"] - df["B"]
         df.loc[3:5, "C"] = np.nan
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # table
             _maybe_remove(store, "df")
             store.append("df", df, data_columns=True)
             result = store.select("df")
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
             result = store.select("df", where="C<100000")
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
             result = store.select("df", where="C<pd.Timedelta('-3D')")
-            assert_frame_equal(result, df.iloc[3:])
+            tm.assert_frame_equal(result, df.iloc[3:])
 
             result = store.select("df", "C<'-3D'")
-            assert_frame_equal(result, df.iloc[3:])
+            tm.assert_frame_equal(result, df.iloc[3:])
 
             # a bit hacky here as we don't really deal with the NaT properly
 
             result = store.select("df", "C<'-500000s'")
             result = result.dropna(subset=["C"])
-            assert_frame_equal(result, df.iloc[6:])
+            tm.assert_frame_equal(result, df.iloc[6:])
 
             result = store.select("df", "C<'-3.5D'")
             result = result.iloc[1:]
-            assert_frame_equal(result, df.iloc[4:])
+            tm.assert_frame_equal(result, df.iloc[4:])
 
             # fixed
             _maybe_remove(store, "df2")
             store.put("df2", df)
             result = store.select("df2")
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
 
-    def test_remove(self):
+    def test_remove(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             ts = tm.makeTimeSeries()
             df = tm.makeDataFrame()
@@ -2263,9 +2194,9 @@ def test_remove(self):
             del store["b"]
             assert len(store) == 0
 
-    def test_invalid_terms(self):
+    def test_invalid_terms(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             with catch_warnings(record=True):
 
@@ -2287,7 +2218,7 @@ def test_invalid_terms(self):
                     store.select("df", "index>")
 
         # from the docs
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             dfq = DataFrame(
                 np.random.randn(10, 4),
                 columns=list("ABCD"),
@@ -2302,7 +2233,7 @@ def test_invalid_terms(self):
             read_hdf(path, "dfq", where="A>0 or C>0")
 
         # catch the invalid reference
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             dfq = DataFrame(
                 np.random.randn(10, 4),
                 columns=list("ABCD"),
@@ -2313,9 +2244,9 @@ def test_invalid_terms(self):
             with pytest.raises(ValueError):
                 read_hdf(path, "dfq", where="A>0 or C>0")
 
-    def test_same_name_scoping(self):
+    def test_same_name_scoping(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             import pandas as pd
 
@@ -2328,72 +2259,42 @@ def test_same_name_scoping(self):
             import datetime  # noqa
 
             result = store.select("df", "index>datetime.datetime(2013,1,5)")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             from datetime import datetime  # noqa
 
             # technically an error, but allow it
             result = store.select("df", "index>datetime.datetime(2013,1,5)")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = store.select("df", "index>datetime(2013,1,5)")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
-    def test_series(self):
+    def test_series(self, setup_path):
 
         s = tm.makeStringSeries()
-        self._check_roundtrip(s, tm.assert_series_equal)
+        self._check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
         ts = tm.makeTimeSeries()
-        self._check_roundtrip(ts, tm.assert_series_equal)
+        self._check_roundtrip(ts, tm.assert_series_equal, path=setup_path)
 
         ts2 = Series(ts.index, Index(ts.index, dtype=object))
-        self._check_roundtrip(ts2, tm.assert_series_equal)
+        self._check_roundtrip(ts2, tm.assert_series_equal, path=setup_path)
 
         ts3 = Series(ts.values, Index(np.asarray(ts.index, dtype=object), dtype=object))
-        self._check_roundtrip(ts3, tm.assert_series_equal, check_index_type=False)
-
-    @ignore_sparse
-    @ignore_series_tosparse
-    def test_sparse_series(self):
-
-        s = tm.makeStringSeries()
-        s.iloc[3:5] = np.nan
-        ss = s.to_sparse()
-        self._check_roundtrip(ss, tm.assert_series_equal, check_series_type=True)
-
-        ss2 = s.to_sparse(kind="integer")
-        self._check_roundtrip(ss2, tm.assert_series_equal, check_series_type=True)
-
-        ss3 = s.to_sparse(fill_value=0)
-        self._check_roundtrip(ss3, tm.assert_series_equal, check_series_type=True)
-
-    @ignore_sparse
-    @ignore_dataframe_tosparse
-    def test_sparse_frame(self):
-
-        s = tm.makeDataFrame()
-        s.iloc[3:5, 1:3] = np.nan
-        s.iloc[8:10, -2] = np.nan
-        ss = s.to_sparse()
-
-        self._check_double_roundtrip(ss, tm.assert_frame_equal, check_frame_type=True)
-
-        ss2 = s.to_sparse(kind="integer")
-        self._check_double_roundtrip(ss2, tm.assert_frame_equal, check_frame_type=True)
-
-        ss3 = s.to_sparse(fill_value=0)
-        self._check_double_roundtrip(ss3, tm.assert_frame_equal, check_frame_type=True)
+        self._check_roundtrip(
+            ts3, tm.assert_series_equal, path=setup_path, check_index_type=False
+        )
 
-    def test_float_index(self):
+    def test_float_index(self, setup_path):
 
         # GH #454
         index = np.random.randn(10)
         s = Series(np.random.randn(10), index=index)
-        self._check_roundtrip(s, tm.assert_series_equal)
+        self._check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
-    @xfail_non_writeable
-    def test_tuple_index(self):
+    @td.xfail_non_writeable
+    def test_tuple_index(self, setup_path):
 
         # GH #492
         col = np.arange(10)
@@ -2403,11 +2304,11 @@ def test_tuple_index(self):
 
         with catch_warnings(record=True):
             simplefilter("ignore", pd.errors.PerformanceWarning)
-            self._check_roundtrip(DF, tm.assert_frame_equal)
+            self._check_roundtrip(DF, tm.assert_frame_equal, path=setup_path)
 
-    @xfail_non_writeable
+    @td.xfail_non_writeable
     @pytest.mark.filterwarnings("ignore::pandas.errors.PerformanceWarning")
-    def test_index_types(self):
+    def test_index_types(self, setup_path):
 
         with catch_warnings(record=True):
             values = np.random.randn(2)
@@ -2418,62 +2319,62 @@ def test_index_types(self):
 
         with catch_warnings(record=True):
             ser = Series(values, [0, "y"])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
         with catch_warnings(record=True):
             ser = Series(values, [datetime.datetime.today(), 0])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
         with catch_warnings(record=True):
             ser = Series(values, ["y", 0])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
         with catch_warnings(record=True):
             ser = Series(values, [datetime.date.today(), "a"])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
         with catch_warnings(record=True):
 
             ser = Series(values, [0, "y"])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, [datetime.datetime.today(), 0])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, ["y", 0])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, [datetime.date.today(), "a"])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, [1.23, "b"])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, [1, 1.53])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(values, [1, 5])
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
             ser = Series(
                 values, [datetime.datetime(2012, 1, 1), datetime.datetime(2012, 1, 2)]
             )
-            self._check_roundtrip(ser, func)
+            self._check_roundtrip(ser, func, path=setup_path)
 
-    def test_timeseries_preepoch(self):
+    def test_timeseries_preepoch(self, setup_path):
 
         dr = bdate_range("1/1/1940", "1/1/1960")
         ts = Series(np.random.randn(len(dr)), index=dr)
         try:
-            self._check_roundtrip(ts, tm.assert_series_equal)
+            self._check_roundtrip(ts, tm.assert_series_equal, path=setup_path)
         except OverflowError:
             pytest.skip("known failer on some windows platforms")
 
-    @xfail_non_writeable
+    @td.xfail_non_writeable
     @pytest.mark.parametrize(
         "compression", [False, pytest.param(True, marks=td.skip_if_windows_python_3)]
     )
-    def test_frame(self, compression):
+    def test_frame(self, compression, setup_path):
 
         df = tm.makeDataFrame()
 
@@ -2481,13 +2382,19 @@ def test_frame(self, compression):
         df.values[0, 0] = np.nan
         df.values[5, 3] = np.nan
 
-        self._check_roundtrip_table(df, tm.assert_frame_equal, compression=compression)
-        self._check_roundtrip(df, tm.assert_frame_equal, compression=compression)
+        self._check_roundtrip_table(
+            df, tm.assert_frame_equal, path=setup_path, compression=compression
+        )
+        self._check_roundtrip(
+            df, tm.assert_frame_equal, path=setup_path, compression=compression
+        )
 
         tdf = tm.makeTimeDataFrame()
-        self._check_roundtrip(tdf, tm.assert_frame_equal, compression=compression)
+        self._check_roundtrip(
+            tdf, tm.assert_frame_equal, path=setup_path, compression=compression
+        )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # not consolidated
             df["foo"] = np.random.randn(len(df))
             store["df"] = df
@@ -2495,38 +2402,38 @@ def test_frame(self, compression):
             assert recons._data.is_consolidated()
 
         # empty
-        self._check_roundtrip(df[:0], tm.assert_frame_equal)
+        self._check_roundtrip(df[:0], tm.assert_frame_equal, path=setup_path)
 
-    @xfail_non_writeable
-    def test_empty_series_frame(self):
-        s0 = Series()
-        s1 = Series(name="myseries")
+    @td.xfail_non_writeable
+    def test_empty_series_frame(self, setup_path):
+        s0 = Series(dtype=object)
+        s1 = Series(name="myseries", dtype=object)
         df0 = DataFrame()
         df1 = DataFrame(index=["a", "b", "c"])
         df2 = DataFrame(columns=["d", "e", "f"])
 
-        self._check_roundtrip(s0, tm.assert_series_equal)
-        self._check_roundtrip(s1, tm.assert_series_equal)
-        self._check_roundtrip(df0, tm.assert_frame_equal)
-        self._check_roundtrip(df1, tm.assert_frame_equal)
-        self._check_roundtrip(df2, tm.assert_frame_equal)
+        self._check_roundtrip(s0, tm.assert_series_equal, path=setup_path)
+        self._check_roundtrip(s1, tm.assert_series_equal, path=setup_path)
+        self._check_roundtrip(df0, tm.assert_frame_equal, path=setup_path)
+        self._check_roundtrip(df1, tm.assert_frame_equal, path=setup_path)
+        self._check_roundtrip(df2, tm.assert_frame_equal, path=setup_path)
 
-    @xfail_non_writeable
+    @td.xfail_non_writeable
     @pytest.mark.parametrize(
         "dtype", [np.int64, np.float64, np.object, "m8[ns]", "M8[ns]"]
     )
-    def test_empty_series(self, dtype):
+    def test_empty_series(self, dtype, setup_path):
         s = Series(dtype=dtype)
-        self._check_roundtrip(s, tm.assert_series_equal)
+        self._check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
-    def test_can_serialize_dates(self):
+    def test_can_serialize_dates(self, setup_path):
 
         rng = [x.date() for x in bdate_range("1/1/2000", "1/30/2000")]
         frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
 
-        self._check_roundtrip(frame, tm.assert_frame_equal)
+        self._check_roundtrip(frame, tm.assert_frame_equal, path=setup_path)
 
-    def test_store_hierarchical(self):
+    def test_store_hierarchical(self, setup_path):
         index = MultiIndex(
             levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
             codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
@@ -2534,39 +2441,39 @@ def test_store_hierarchical(self):
         )
         frame = DataFrame(np.random.randn(10, 3), index=index, columns=["A", "B", "C"])
 
-        self._check_roundtrip(frame, tm.assert_frame_equal)
-        self._check_roundtrip(frame.T, tm.assert_frame_equal)
-        self._check_roundtrip(frame["A"], tm.assert_series_equal)
+        self._check_roundtrip(frame, tm.assert_frame_equal, path=setup_path)
+        self._check_roundtrip(frame.T, tm.assert_frame_equal, path=setup_path)
+        self._check_roundtrip(frame["A"], tm.assert_series_equal, path=setup_path)
 
         # check that the names are stored
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["frame"] = frame
             recons = store["frame"]
             tm.assert_frame_equal(recons, frame)
 
-    def test_store_index_name(self):
+    def test_store_index_name(self, setup_path):
         df = tm.makeDataFrame()
         df.index.name = "foo"
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["frame"] = df
             recons = store["frame"]
             tm.assert_frame_equal(recons, df)
 
-    def test_store_index_name_with_tz(self):
+    def test_store_index_name_with_tz(self, setup_path):
         # GH 13884
         df = pd.DataFrame({"A": [1, 2]})
         df.index = pd.DatetimeIndex([1234567890123456787, 1234567890123456788])
         df.index = df.index.tz_localize("UTC")
         df.index.name = "foo"
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("frame", df, format="table")
             recons = store["frame"]
             tm.assert_frame_equal(recons, df)
 
     @pytest.mark.parametrize("table_format", ["table", "fixed"])
-    def test_store_index_name_numpy_str(self, table_format):
+    def test_store_index_name_numpy_str(self, table_format, setup_path):
         # GH #13492
         idx = pd.Index(
             pd.to_datetime([datetime.date(2000, 1, 1), datetime.date(2000, 1, 2)]),
@@ -2579,29 +2486,29 @@ def test_store_index_name_numpy_str(self, table_format):
         df = pd.DataFrame(np.arange(4).reshape(2, 2), columns=idx, index=idx1)
 
         # This used to fail, returning numpy strings instead of python strings.
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", format=table_format)
             df2 = read_hdf(path, "df")
 
-            assert_frame_equal(df, df2, check_names=True)
+            tm.assert_frame_equal(df, df2, check_names=True)
 
             assert type(df2.index.name) == str
             assert type(df2.columns.name) == str
 
-    def test_store_series_name(self):
+    def test_store_series_name(self, setup_path):
         df = tm.makeDataFrame()
         series = df["A"]
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["series"] = series
             recons = store["series"]
             tm.assert_series_equal(recons, series)
 
-    @xfail_non_writeable
+    @td.xfail_non_writeable
     @pytest.mark.parametrize(
         "compression", [False, pytest.param(True, marks=td.skip_if_windows_python_3)]
     )
-    def test_store_mixed(self, compression):
+    def test_store_mixed(self, compression, setup_path):
         def _make_one():
             df = tm.makeDataFrame()
             df["obj1"] = "foo"
@@ -2615,10 +2522,10 @@ def _make_one():
         df1 = _make_one()
         df2 = _make_one()
 
-        self._check_roundtrip(df1, tm.assert_frame_equal)
-        self._check_roundtrip(df2, tm.assert_frame_equal)
+        self._check_roundtrip(df1, tm.assert_frame_equal, path=setup_path)
+        self._check_roundtrip(df2, tm.assert_frame_equal, path=setup_path)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["obj"] = df1
             tm.assert_frame_equal(store["obj"], df1)
             store["obj"] = df2
@@ -2626,38 +2533,47 @@ def _make_one():
 
         # check that can store Series of all of these types
         self._check_roundtrip(
-            df1["obj1"], tm.assert_series_equal, compression=compression
+            df1["obj1"],
+            tm.assert_series_equal,
+            path=setup_path,
+            compression=compression,
         )
         self._check_roundtrip(
-            df1["bool1"], tm.assert_series_equal, compression=compression
+            df1["bool1"],
+            tm.assert_series_equal,
+            path=setup_path,
+            compression=compression,
         )
         self._check_roundtrip(
-            df1["int1"], tm.assert_series_equal, compression=compression
+            df1["int1"],
+            tm.assert_series_equal,
+            path=setup_path,
+            compression=compression,
         )
 
     @pytest.mark.filterwarnings(
         "ignore:\\nduplicate:pandas.io.pytables.DuplicateWarning"
     )
-    def test_select_with_dups(self):
+    def test_select_with_dups(self, setup_path):
 
         # single dtypes
         df = DataFrame(np.random.randn(10, 4), columns=["A", "A", "B", "B"])
         df.index = date_range("20130101 9:30", periods=10, freq="T")
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df", df)
 
             result = store.select("df")
             expected = df
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
             result = store.select("df", columns=df.columns)
             expected = df
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
             result = store.select("df", columns=["A"])
             expected = df.loc[:, ["A"]]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         # dups across dtypes
         df = concat(
@@ -2671,81 +2587,47 @@ def test_select_with_dups(self):
         )
         df.index = date_range("20130101 9:30", periods=10, freq="T")
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df", df)
 
             result = store.select("df")
             expected = df
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
             result = store.select("df", columns=df.columns)
             expected = df
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
             expected = df.loc[:, ["A"]]
             result = store.select("df", columns=["A"])
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
             expected = df.loc[:, ["B", "A"]]
             result = store.select("df", columns=["B", "A"])
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
         # duplicates on both index and columns
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("df", df)
             store.append("df", df)
 
             expected = df.loc[:, ["B", "A"]]
             expected = concat([expected, expected])
             result = store.select("df", columns=["B", "A"])
-            assert_frame_equal(result, expected, by_blocks=True)
+            tm.assert_frame_equal(result, expected, by_blocks=True)
 
-    def test_overwrite_node(self):
+    def test_overwrite_node(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store["a"] = tm.makeTimeDataFrame()
             ts = tm.makeTimeSeries()
             store["a"] = ts
 
             tm.assert_series_equal(store["a"], ts)
 
-    @ignore_sparse
-    @ignore_dataframe_tosparse
-    def test_sparse_with_compression(self):
-
-        # GH 2931
-
-        # make sparse dataframe
-        arr = np.random.binomial(n=1, p=0.01, size=(1000, 10))
-        df = DataFrame(arr).to_sparse(fill_value=0)
-
-        # case 1: store uncompressed
-        self._check_double_roundtrip(
-            df, tm.assert_frame_equal, compression=False, check_frame_type=True
-        )
-
-        # case 2: store compressed (works)
-        self._check_double_roundtrip(
-            df, tm.assert_frame_equal, compression="zlib", check_frame_type=True
-        )
-
-        # set one series to be completely sparse
-        df[0] = np.zeros(1000)
-
-        # case 3: store df with completely sparse series uncompressed
-        self._check_double_roundtrip(
-            df, tm.assert_frame_equal, compression=False, check_frame_type=True
-        )
-
-        # case 4: try storing df with completely sparse series compressed
-        # (fails)
-        self._check_double_roundtrip(
-            df, tm.assert_frame_equal, compression="zlib", check_frame_type=True
-        )
-
-    def test_select(self):
+    def test_select(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             with catch_warnings(record=True):
 
@@ -2783,9 +2665,9 @@ def test_select(self):
                 expected = df[df.A > 0].reindex(columns=["C", "D"])
                 tm.assert_frame_equal(expected, result)
 
-    def test_select_dtypes(self):
+    def test_select_dtypes(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             # with a Timestamp data column (GH #2637)
             df = DataFrame(
                 dict(ts=bdate_range("2012-01-01", periods=300), A=np.random.randn(300))
@@ -2841,7 +2723,7 @@ def test_select_dtypes(self):
             expected = df.reindex(index=list(df.index)[0:10], columns=["A"])
             tm.assert_frame_equal(expected, result)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # floats w/o NaN
             df = DataFrame(dict(cols=range(11), values=range(11)), dtype="float64")
@@ -2880,7 +2762,7 @@ def test_select_dtypes(self):
 
         # test selection with comparison against numpy scalar
         # GH 11283
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             df = tm.makeDataFrame()
 
             expected = df[df["A"] > 0]
@@ -2890,9 +2772,9 @@ def test_select_dtypes(self):
             result = store.select("df", where=["A>np_zero"])
             tm.assert_frame_equal(expected, result)
 
-    def test_select_with_many_inputs(self):
+    def test_select_with_many_inputs(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(
                 dict(
@@ -2943,10 +2825,10 @@ def test_select_with_many_inputs(self):
             tm.assert_frame_equal(expected, result)
             assert len(result) == 100
 
-    def test_select_iterator(self):
+    def test_select_iterator(self, setup_path):
 
         # single table
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = tm.makeTimeDataFrame(500)
             _maybe_remove(store, "df")
@@ -2954,20 +2836,20 @@ def test_select_iterator(self):
 
             expected = store.select("df")
 
-            results = [s for s in store.select("df", iterator=True)]
+            results = list(store.select("df", iterator=True))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-            results = [s for s in store.select("df", chunksize=100)]
+            results = list(store.select("df", chunksize=100))
             assert len(results) == 5
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-            results = [s for s in store.select("df", chunksize=150)]
+            results = list(store.select("df", chunksize=150))
             result = concat(results)
             tm.assert_frame_equal(result, expected)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeTimeDataFrame(500)
             df.to_hdf(path, "df_non_table")
@@ -2978,12 +2860,12 @@ def test_select_iterator(self):
             with pytest.raises(TypeError):
                 read_hdf(path, "df_non_table", iterator=True)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeTimeDataFrame(500)
             df.to_hdf(path, "df", format="table")
 
-            results = [s for s in read_hdf(path, "df", chunksize=100)]
+            results = list(read_hdf(path, "df", chunksize=100))
             result = concat(results)
 
             assert len(results) == 5
@@ -2992,7 +2874,7 @@ def test_select_iterator(self):
 
         # multiple
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df1 = tm.makeTimeDataFrame(500)
             store.append("df1", df1, data_columns=True)
@@ -3004,23 +2886,20 @@ def test_select_iterator(self):
 
             # full selection
             expected = store.select_as_multiple(["df1", "df2"], selector="df1")
-            results = [
-                s
-                for s in store.select_as_multiple(
-                    ["df1", "df2"], selector="df1", chunksize=150
-                )
-            ]
+            results = list(
+                store.select_as_multiple(["df1", "df2"], selector="df1", chunksize=150)
+            )
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-    def test_select_iterator_complete_8014(self):
+    def test_select_iterator_complete_8014(self, setup_path):
 
         # GH 8014
         # using iterator and where clause
         chunksize = 1e4
 
         # no iterator
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             expected = tm.makeTimeDataFrame(100064, "S")
             _maybe_remove(store, "df")
@@ -3054,7 +2933,7 @@ def test_select_iterator_complete_8014(self):
             tm.assert_frame_equal(expected, result)
 
         # with iterator, full range
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             expected = tm.makeTimeDataFrame(100064, "S")
             _maybe_remove(store, "df")
@@ -3064,19 +2943,19 @@ def test_select_iterator_complete_8014(self):
             end_dt = expected.index[-1]
 
             # select w/iterator and no where clause works
-            results = [s for s in store.select("df", chunksize=chunksize)]
+            results = list(store.select("df", chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
@@ -3084,18 +2963,18 @@ def test_select_iterator_complete_8014(self):
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-    def test_select_iterator_non_complete_8014(self):
+    def test_select_iterator_non_complete_8014(self, setup_path):
 
         # GH 8014
         # using iterator and where clause
         chunksize = 1e4
 
         # with iterator, non complete range
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             expected = tm.makeTimeDataFrame(100064, "S")
             _maybe_remove(store, "df")
@@ -3106,14 +2985,14 @@ def test_select_iterator_non_complete_8014(self):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index >= beg_dt]
             tm.assert_frame_equal(rexpected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index <= end_dt]
             tm.assert_frame_equal(rexpected, result)
@@ -3122,7 +3001,7 @@ def test_select_iterator_non_complete_8014(self):
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[
                 (expected.index >= beg_dt) & (expected.index <= end_dt)
@@ -3130,7 +3009,7 @@ def test_select_iterator_non_complete_8014(self):
             tm.assert_frame_equal(rexpected, result)
 
         # with iterator, empty where
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             expected = tm.makeTimeDataFrame(100064, "S")
             _maybe_remove(store, "df")
@@ -3140,10 +3019,10 @@ def test_select_iterator_non_complete_8014(self):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index > '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             assert 0 == len(results)
 
-    def test_select_iterator_many_empty_frames(self):
+    def test_select_iterator_many_empty_frames(self, setup_path):
 
         # GH 8014
         # using iterator and where clause can return many empty
@@ -3151,7 +3030,7 @@ def test_select_iterator_many_empty_frames(self):
         chunksize = int(1e4)
 
         # with iterator, range limited to the first chunk
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             expected = tm.makeTimeDataFrame(100000, "S")
             _maybe_remove(store, "df")
@@ -3162,14 +3041,14 @@ def test_select_iterator_many_empty_frames(self):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index >= beg_dt]
             tm.assert_frame_equal(rexpected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             assert len(results) == 1
             result = concat(results)
@@ -3180,7 +3059,7 @@ def test_select_iterator_many_empty_frames(self):
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             # should be 1, is 10
             assert len(results) == 1
@@ -3200,7 +3079,7 @@ def test_select_iterator_many_empty_frames(self):
             where = "index <= '{beg_dt}' & index >= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             # should be []
             assert len(results) == 0
@@ -3208,14 +3087,14 @@ def test_select_iterator_many_empty_frames(self):
     @pytest.mark.filterwarnings(
         "ignore:\\nthe :pandas.io.pytables.AttributeConflictWarning"
     )
-    def test_retain_index_attributes(self):
+    def test_retain_index_attributes(self, setup_path):
 
         # GH 3499, losing frequency info on index recreation
         df = DataFrame(
             dict(A=Series(range(3), index=date_range("2000-1-1", periods=3, freq="H")))
         )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             _maybe_remove(store, "data")
             store.put("data", df, format="table")
 
@@ -3268,8 +3147,8 @@ def test_retain_index_attributes(self):
     @pytest.mark.filterwarnings(
         "ignore:\\nthe :pandas.io.pytables.AttributeConflictWarning"
     )
-    def test_retain_index_attributes2(self):
-        with ensure_clean_path(self.path) as path:
+    def test_retain_index_attributes2(self, setup_path):
+        with ensure_clean_path(setup_path) as path:
 
             with catch_warnings(record=True):
 
@@ -3306,11 +3185,11 @@ def test_retain_index_attributes2(self):
 
             assert read_hdf(path, "data").index.name is None
 
-    def test_frame_select(self):
+    def test_frame_select(self, setup_path):
 
         df = tm.makeTimeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("frame", df, format="table")
             date = df.index[len(df) // 2]
 
@@ -3339,14 +3218,14 @@ def test_frame_select(self):
             # with pytest.raises(ValueError):
             #     store.select('frame', [crit1, crit2])
 
-    def test_frame_select_complex(self):
+    def test_frame_select_complex(self, setup_path):
         # select via complex criteria
 
         df = tm.makeTimeDataFrame()
         df["string"] = "foo"
         df.loc[df.index[0:4], "string"] = "bar"
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df, format="table", data_columns=["string"])
 
             # empty
@@ -3364,7 +3243,7 @@ def test_frame_select_complex(self):
             tm.assert_frame_equal(result, expected)
 
             result = store.select(
-                "df", "(index>df.index[3] & " 'index<=df.index[6]) | string="bar"'
+                "df", '(index>df.index[3] & index<=df.index[6]) | string="bar"'
             )
             expected = df.loc[
                 ((df.index > df.index[3]) & (df.index <= df.index[6]))
@@ -3391,7 +3270,7 @@ def test_frame_select_complex(self):
             expected = df.loc[df.index > df.index[3]].reindex(columns=["A", "B"])
             tm.assert_frame_equal(result, expected)
 
-    def test_frame_select_complex2(self):
+    def test_frame_select_complex2(self, setup_path):
 
         with ensure_clean_path(["parms.hdf", "hist.hdf"]) as paths:
 
@@ -3418,50 +3297,50 @@ def test_frame_select_complex2(self):
             l = selection.index.tolist()  # noqa
             store = HDFStore(hh)
             result = store.select("df", where="l1=l")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
             store.close()
 
             result = read_hdf(hh, "df", where="l1=l")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # index
             index = selection.index  # noqa
             result = read_hdf(hh, "df", where="l1=index")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = read_hdf(hh, "df", where="l1=selection.index")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = read_hdf(hh, "df", where="l1=selection.index.tolist()")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = read_hdf(hh, "df", where="l1=list(selection.index)")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # scope with index
             store = HDFStore(hh)
 
             result = store.select("df", where="l1=index")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = store.select("df", where="l1=selection.index")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = store.select("df", where="l1=selection.index.tolist()")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = store.select("df", where="l1=list(selection.index)")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             store.close()
 
-    def test_invalid_filtering(self):
+    def test_invalid_filtering(self, setup_path):
 
         # can't use more than one filter (atm)
 
         df = tm.makeTimeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df, format="table")
 
             # not implemented
@@ -3472,9 +3351,9 @@ def test_invalid_filtering(self):
             with pytest.raises(NotImplementedError):
                 store.select("df", "columns=['A','B'] & columns=['C']")
 
-    def test_string_select(self):
+    def test_string_select(self, setup_path):
         # GH 2973
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = tm.makeTimeDataFrame()
 
@@ -3486,16 +3365,11 @@ def test_string_select(self):
 
             result = store.select("df", "x=none")
             expected = df[df.x == "none"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
-            try:
-                result = store.select("df", "x!=none")
-                expected = df[df.x != "none"]
-                assert_frame_equal(result, expected)
-            except Exception as detail:
-                pprint_thing("[{0}]".format(detail))
-                pprint_thing(store)
-                pprint_thing(expected)
+            result = store.select("df", "x!=none")
+            expected = df[df.x != "none"]
+            tm.assert_frame_equal(result, expected)
 
             df2 = df.copy()
             df2.loc[df2.x == "", "x"] = np.nan
@@ -3503,7 +3377,7 @@ def test_string_select(self):
             store.append("df2", df2, data_columns=["x"])
             result = store.select("df2", "x!=none")
             expected = df2[isna(df2.x)]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # int ==/!=
             df["int"] = 1
@@ -3513,17 +3387,17 @@ def test_string_select(self):
 
             result = store.select("df3", "int=2")
             expected = df[df.int == 2]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = store.select("df3", "int!=2")
             expected = df[df.int != 2]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
-    def test_read_column(self):
+    def test_read_column(self, setup_path):
 
         df = tm.makeTimeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             _maybe_remove(store, "df")
 
             # GH 17912
@@ -3592,10 +3466,10 @@ def test_read_column(self):
             result = store.select_column("df4", "B")
             tm.assert_series_equal(result, expected)
 
-    def test_coordinates(self):
+    def test_coordinates(self, setup_path):
         df = tm.makeTimeDataFrame()
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             _maybe_remove(store, "df")
             store.append("df", df)
@@ -3640,7 +3514,7 @@ def test_coordinates(self):
             tm.assert_frame_equal(result, expected)
 
         # pass array/mask as the coordinates
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(
                 np.random.randn(1000, 2), index=date_range("20000101", periods=1000)
@@ -3696,13 +3570,13 @@ def test_coordinates(self):
             expected = df[5:10]
             tm.assert_frame_equal(result, expected)
 
-    def test_append_to_multiple(self):
+    def test_append_to_multiple(self, setup_path):
         df1 = tm.makeTimeDataFrame()
         df2 = tm.makeTimeDataFrame().rename(columns="{}_2".format)
         df2["foo"] = "bar"
         df = concat([df1, df2], axis=1)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # exceptions
             with pytest.raises(ValueError):
@@ -3726,13 +3600,13 @@ def test_append_to_multiple(self):
             expected = df[(df.A > 0) & (df.B > 0)]
             tm.assert_frame_equal(result, expected)
 
-    def test_append_to_multiple_dropna(self):
+    def test_append_to_multiple_dropna(self, setup_path):
         df1 = tm.makeTimeDataFrame()
         df2 = tm.makeTimeDataFrame().rename(columns="{}_2".format)
         df1.iloc[1, df1.columns.get_indexer(["A", "B"])] = np.nan
         df = concat([df1, df2], axis=1)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # dropna=True should guarantee rows are synchronized
             store.append_to_multiple(
@@ -3746,13 +3620,13 @@ def test_append_to_multiple_dropna(self):
     @pytest.mark.xfail(
         run=False, reason="append_to_multiple_dropna_false is not raising as failed"
     )
-    def test_append_to_multiple_dropna_false(self):
+    def test_append_to_multiple_dropna_false(self, setup_path):
         df1 = tm.makeTimeDataFrame()
         df2 = tm.makeTimeDataFrame().rename(columns="{}_2".format)
         df1.iloc[1, df1.columns.get_indexer(["A", "B"])] = np.nan
         df = concat([df1, df2], axis=1)
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # dropna=False shouldn't synchronize row indexes
             store.append_to_multiple(
@@ -3764,13 +3638,13 @@ def test_append_to_multiple_dropna_false(self):
 
             assert not store.select("df1a").index.equals(store.select("df2a").index)
 
-    def test_select_as_multiple(self):
+    def test_select_as_multiple(self, setup_path):
 
         df1 = tm.makeTimeDataFrame()
         df2 = tm.makeTimeDataFrame().rename(columns="{}_2".format)
         df2["foo"] = "bar"
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # no tables stored
             with pytest.raises(Exception):
@@ -3838,9 +3712,9 @@ def test_select_as_multiple(self):
         LooseVersion(tables.__version__) < LooseVersion("3.1.0"),
         reason=("tables version does not support fix for nan selection bug: GH 4858"),
     )
-    def test_nan_selection_bug_4858(self):
+    def test_nan_selection_bug_4858(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame(dict(cols=range(6), values=range(6)), dtype="float64")
             df["cols"] = (df["cols"] + 10).apply(str)
@@ -3854,11 +3728,11 @@ def test_nan_selection_bug_4858(self):
             # write w/o the index on that particular column
             store.append("df", df, data_columns=True, index=["cols"])
             result = store.select("df", where="values>2.0")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
-    def test_start_stop_table(self):
+    def test_start_stop_table(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # table
             df = DataFrame(dict(A=np.random.rand(20), B=np.random.rand(20)))
@@ -3874,10 +3748,10 @@ def test_start_stop_table(self):
             expected = df.loc[30:40, ["A"]]
             tm.assert_frame_equal(result, expected)
 
-    def test_start_stop_multiple(self):
+    def test_start_stop_multiple(self, setup_path):
 
         # GH 16209
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             df = DataFrame({"foo": [1, 2], "bar": [1, 2]})
 
@@ -3890,11 +3764,9 @@ def test_start_stop_multiple(self):
             expected = df.loc[[0], ["foo", "bar"]]
             tm.assert_frame_equal(result, expected)
 
-    @ignore_sparse
-    @ignore_dataframe_tosparse
-    def test_start_stop_fixed(self):
+    def test_start_stop_fixed(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # fixed, GH 8287
             df = DataFrame(
@@ -3931,18 +3803,14 @@ def test_start_stop_fixed(self):
             df = tm.makeDataFrame()
             df.iloc[3:5, 1:3] = np.nan
             df.iloc[8:10, -2] = np.nan
-            dfs = df.to_sparse()
-            store.put("dfs", dfs)
-            with pytest.raises(NotImplementedError):
-                store.select("dfs", start=0, stop=5)
 
-    def test_select_filter_corner(self):
+    def test_select_filter_corner(self, setup_path):
 
         df = DataFrame(np.random.randn(50, 100))
         df.index = ["{c:3d}".format(c=c) for c in df.index]
         df.columns = ["{c:3d}".format(c=c) for c in df.columns]
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("frame", df, format="table")
 
             crit = "columns=df.columns[:75]"
@@ -3953,7 +3821,7 @@ def test_select_filter_corner(self):
             result = store.select("frame", [crit])
             tm.assert_frame_equal(result, df.loc[:, df.columns[:75:2]])
 
-    def test_path_pathlib(self):
+    def test_path_pathlib(self, setup_path):
         df = tm.makeDataFrame()
 
         result = tm.round_trip_pathlib(
@@ -3962,7 +3830,7 @@ def test_path_pathlib(self):
         tm.assert_frame_equal(df, result)
 
     @pytest.mark.parametrize("start, stop", [(0, 2), (1, 2), (None, None)])
-    def test_contiguous_mixed_data_table(self, start, stop):
+    def test_contiguous_mixed_data_table(self, start, stop, setup_path):
         # GH 17021
         # ValueError when reading a contiguous mixed-data table ft. VLArray
         df = DataFrame(
@@ -3972,13 +3840,13 @@ def test_contiguous_mixed_data_table(self, start, stop):
             }
         )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("test_dataset", df)
 
             result = store.select("test_dataset", start=start, stop=stop)
-            assert_frame_equal(df[start:stop], result)
+            tm.assert_frame_equal(df[start:stop], result)
 
-    def test_path_pathlib_hdfstore(self):
+    def test_path_pathlib_hdfstore(self, setup_path):
         df = tm.makeDataFrame()
 
         def writer(path):
@@ -3992,14 +3860,14 @@ def reader(path):
         result = tm.round_trip_pathlib(writer, reader)
         tm.assert_frame_equal(df, result)
 
-    def test_pickle_path_localpath(self):
+    def test_pickle_path_localpath(self, setup_path):
         df = tm.makeDataFrame()
         result = tm.round_trip_pathlib(
             lambda p: df.to_hdf(p, "df"), lambda p: pd.read_hdf(p, "df")
         )
         tm.assert_frame_equal(df, result)
 
-    def test_path_localpath_hdfstore(self):
+    def test_path_localpath_hdfstore(self, setup_path):
         df = tm.makeDataFrame()
 
         def writer(path):
@@ -4013,23 +3881,25 @@ def reader(path):
         result = tm.round_trip_localpath(writer, reader)
         tm.assert_frame_equal(df, result)
 
-    def _check_roundtrip(self, obj, comparator, compression=False, **kwargs):
+    def _check_roundtrip(self, obj, comparator, path, compression=False, **kwargs):
 
         options = {}
         if compression:
             options["complib"] = _default_compressor
 
-        with ensure_clean_store(self.path, "w", **options) as store:
+        with ensure_clean_store(path, "w", **options) as store:
             store["obj"] = obj
             retrieved = store["obj"]
             comparator(retrieved, obj, **kwargs)
 
-    def _check_double_roundtrip(self, obj, comparator, compression=False, **kwargs):
+    def _check_double_roundtrip(
+        self, obj, comparator, path, compression=False, **kwargs
+    ):
         options = {}
         if compression:
             options["complib"] = compression or _default_compressor
 
-        with ensure_clean_store(self.path, "w", **options) as store:
+        with ensure_clean_store(path, "w", **options) as store:
             store["obj"] = obj
             retrieved = store["obj"]
             comparator(retrieved, obj, **kwargs)
@@ -4037,21 +3907,21 @@ def _check_double_roundtrip(self, obj, comparator, compression=False, **kwargs):
             again = store["obj"]
             comparator(again, obj, **kwargs)
 
-    def _check_roundtrip_table(self, obj, comparator, compression=False):
+    def _check_roundtrip_table(self, obj, comparator, path, compression=False):
         options = {}
         if compression:
             options["complib"] = _default_compressor
 
-        with ensure_clean_store(self.path, "w", **options) as store:
+        with ensure_clean_store(path, "w", **options) as store:
             store.put("obj", obj, format="table")
             retrieved = store["obj"]
 
             comparator(retrieved, obj)
 
-    def test_multiple_open_close(self):
+    def test_multiple_open_close(self, setup_path):
         # gh-4409: open & close multiple times
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
             df.to_hdf(path, "df", mode="w", format="table")
@@ -4065,7 +3935,7 @@ def test_multiple_open_close(self):
             assert "CLOSED" in store.info()
             assert not store.is_open
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             if pytables._table_file_open_policy_is_strict:
 
@@ -4127,7 +3997,7 @@ def test_multiple_open_close(self):
                 assert not store2.is_open
 
         # ops on a closed store
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
 
             df = tm.makeDataFrame()
             df.to_hdf(path, "df", mode="w", format="table")
@@ -4171,7 +4041,7 @@ def test_multiple_open_close(self):
             with pytest.raises(ClosedFileError, match="file is not open"):
                 store.select("df")
 
-    def test_pytables_native_read(self, datapath):
+    def test_pytables_native_read(self, datapath, setup_path):
         with ensure_clean_store(
             datapath("io", "data", "legacy_hdf/pytables_native.h5"), mode="r"
         ) as store:
@@ -4181,7 +4051,7 @@ def test_pytables_native_read(self, datapath):
     @pytest.mark.skipif(
         is_platform_windows(), reason="native2 read fails oddly on windows"
     )
-    def test_pytables_native2_read(self, datapath):
+    def test_pytables_native2_read(self, datapath, setup_path):
         with ensure_clean_store(
             datapath("io", "data", "legacy_hdf", "pytables_native2.h5"), mode="r"
         ) as store:
@@ -4189,8 +4059,8 @@ def test_pytables_native2_read(self, datapath):
             d1 = store["detector"]
             assert isinstance(d1, DataFrame)
 
-    @xfail_non_writeable
-    def test_legacy_table_fixed_format_read_py2(self, datapath):
+    @td.xfail_non_writeable
+    def test_legacy_table_fixed_format_read_py2(self, datapath, setup_path):
         # GH 24510
         # legacy table with fixed format written in Python 2
         with ensure_clean_store(
@@ -4202,9 +4072,24 @@ def test_legacy_table_fixed_format_read_py2(self, datapath):
                 columns=["A", "B", "C", "D"],
                 index=pd.Index(["ABC"], name="INDEX_NAME"),
             )
-            assert_frame_equal(expected, result)
+            tm.assert_frame_equal(expected, result)
+
+    def test_legacy_table_fixed_format_read_datetime_py2(self, datapath, setup_path):
+        # GH 31750
+        # legacy table with fixed format and datetime64 column written in Python 2
+        with ensure_clean_store(
+            datapath("io", "data", "legacy_hdf", "legacy_table_fixed_datetime_py2.h5"),
+            mode="r",
+        ) as store:
+            result = store.select("df")
+            expected = pd.DataFrame(
+                [[pd.Timestamp("2020-02-06T18:00")]],
+                columns=["A"],
+                index=pd.Index(["date"]),
+            )
+            tm.assert_frame_equal(expected, result)
 
-    def test_legacy_table_read_py2(self, datapath):
+    def test_legacy_table_read_py2(self, datapath, setup_path):
         # issue: 24925
         # legacy table written in Python 2
         with ensure_clean_store(
@@ -4213,9 +4098,9 @@ def test_legacy_table_read_py2(self, datapath):
             result = store.select("table")
 
         expected = pd.DataFrame({"a": ["a", "b"], "b": [2, 3]})
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
-    def test_copy(self):
+    def test_copy(self, setup_path):
 
         with catch_warnings(record=True):
 
@@ -4264,7 +4149,7 @@ def do_copy(f, new_f=None, keys=None, propindexes=True, **kwargs):
             df = tm.makeDataFrame()
 
             try:
-                path = create_tempfile(self.path)
+                path = create_tempfile(setup_path)
                 st = HDFStore(path)
                 st.append("df", df, data_columns=["A"])
                 st.close()
@@ -4273,17 +4158,17 @@ def do_copy(f, new_f=None, keys=None, propindexes=True, **kwargs):
             finally:
                 safe_remove(path)
 
-    def test_store_datetime_fractional_secs(self):
+    def test_store_datetime_fractional_secs(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             dt = datetime.datetime(2012, 1, 2, 3, 4, 5, 123456)
             series = Series([0], [dt])
             store["a"] = series
             assert store["a"].index[0] == dt
 
-    def test_tseries_indices_series(self):
+    def test_tseries_indices_series(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             idx = tm.makeDateIndex(10)
             ser = Series(np.random.randn(len(idx)), idx)
             store["a"] = ser
@@ -4302,15 +4187,15 @@ def test_tseries_indices_series(self):
             assert result.index.freq == ser.index.freq
             tm.assert_class_equal(result.index, ser.index, obj="series index")
 
-    def test_tseries_indices_frame(self):
+    def test_tseries_indices_frame(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             idx = tm.makeDateIndex(10)
             df = DataFrame(np.random.randn(len(idx), 3), index=idx)
             store["a"] = df
             result = store["a"]
 
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
             assert result.index.freq == df.index.freq
             tm.assert_class_equal(result.index, df.index, obj="dataframe index")
 
@@ -4319,11 +4204,11 @@ def test_tseries_indices_frame(self):
             store["a"] = df
             result = store["a"]
 
-            assert_frame_equal(result, df)
+            tm.assert_frame_equal(result, df)
             assert result.index.freq == df.index.freq
             tm.assert_class_equal(result.index, df.index, obj="dataframe index")
 
-    def test_unicode_index(self):
+    def test_unicode_index(self, setup_path):
 
         unicode_values = ["\u03c3", "\u03c3\u03c3"]
 
@@ -4331,30 +4216,30 @@ def test_unicode_index(self):
         with catch_warnings(record=True):
             simplefilter("ignore", pd.errors.PerformanceWarning)
             s = Series(np.random.randn(len(unicode_values)), unicode_values)
-            self._check_roundtrip(s, tm.assert_series_equal)
+            self._check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
-    def test_unicode_longer_encoded(self):
+    def test_unicode_longer_encoded(self, setup_path):
         # GH 11234
         char = "\u0394"
         df = pd.DataFrame({"A": [char]})
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df, format="table", encoding="utf-8")
             result = store.get("df")
             tm.assert_frame_equal(result, df)
 
         df = pd.DataFrame({"A": ["a", char], "B": ["b", "b"]})
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.put("df", df, format="table", encoding="utf-8")
             result = store.get("df")
             tm.assert_frame_equal(result, df)
 
-    @xfail_non_writeable
-    def test_store_datetime_mixed(self):
+    @td.xfail_non_writeable
+    def test_store_datetime_mixed(self, setup_path):
 
         df = DataFrame({"a": [1, 2, 3], "b": [1.0, 2.0, 3.0], "c": ["a", "b", "c"]})
         ts = tm.makeTimeSeries()
         df["d"] = ts.index[:3]
-        self._check_roundtrip(df, tm.assert_frame_equal)
+        self._check_roundtrip(df, tm.assert_frame_equal, path=setup_path)
 
     # FIXME: don't leave commented-out code
     # def test_cant_write_multiindex_table(self):
@@ -4366,14 +4251,14 @@ def test_store_datetime_mixed(self):
     #     with pytest.raises(Exception):
     #         store.put('foo', df, format='table')
 
-    def test_append_with_diff_col_name_types_raises_value_error(self):
+    def test_append_with_diff_col_name_types_raises_value_error(self, setup_path):
         df = DataFrame(np.random.randn(10, 1))
         df2 = DataFrame({"a": np.random.randn(10)})
         df3 = DataFrame({(1, 2): np.random.randn(10)})
         df4 = DataFrame({("1", 2): np.random.randn(10)})
         df5 = DataFrame({("1", 2, object): np.random.randn(10)})
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             name = "df_{}".format(tm.rands(10))
             store.append(name, df)
 
@@ -4381,7 +4266,7 @@ def test_append_with_diff_col_name_types_raises_value_error(self):
                 with pytest.raises(ValueError):
                     store.append(name, d)
 
-    def test_query_with_nested_special_character(self):
+    def test_query_with_nested_special_character(self, setup_path):
         df = DataFrame(
             {
                 "a": ["a", "a", "c", "b", "test & test", "c", "b", "e"],
@@ -4389,14 +4274,14 @@ def test_query_with_nested_special_character(self):
             }
         )
         expected = df[df.a == "test & test"]
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("test", df, format="table", data_columns=True)
             result = store.select("test", 'a = "test & test"')
         tm.assert_frame_equal(expected, result)
 
-    def test_categorical(self):
+    def test_categorical(self, setup_path):
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             # Basic
             _maybe_remove(store, "s")
@@ -4514,7 +4399,7 @@ def test_categorical(self):
             ):
                 store.select("df3/meta/s/meta")
 
-    def test_categorical_conversion(self):
+    def test_categorical_conversion(self, setup_path):
 
         # GH13322
         # Check that read_hdf with categorical columns doesn't return rows if
@@ -4528,7 +4413,7 @@ def test_categorical_conversion(self):
 
         # We are expecting an empty DataFrame matching types of df
         expected = df.iloc[[], :]
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", format="table", data_columns=True)
             result = read_hdf(path, "df", where="obsids=B")
             tm.assert_frame_equal(result, expected)
@@ -4539,12 +4424,12 @@ def test_categorical_conversion(self):
 
         # We are expecting an empty DataFrame matching types of df
         expected = df.iloc[[], :]
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", format="table", data_columns=True)
             result = read_hdf(path, "df", where="obsids=B")
             tm.assert_frame_equal(result, expected)
 
-    def test_categorical_nan_only_columns(self):
+    def test_categorical_nan_only_columns(self, setup_path):
         # GH18413
         # Check that read_hdf with categorical columns with NaN-only values can
         # be read back.
@@ -4560,15 +4445,15 @@ def test_categorical_nan_only_columns(self):
         df["b"] = df.b.astype("category")
         df["d"] = df.b.astype("category")
         expected = df
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", format="table", data_columns=True)
             result = read_hdf(path, "df")
             tm.assert_frame_equal(result, expected)
 
-    def test_duplicate_column_name(self):
+    def test_duplicate_column_name(self, setup_path):
         df = DataFrame(columns=["a", "a"], data=[[0, 0]])
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             with pytest.raises(ValueError):
                 df.to_hdf(path, "df", format="fixed")
 
@@ -4579,30 +4464,30 @@ def test_duplicate_column_name(self):
             assert df.equals(other)
             assert other.equals(df)
 
-    def test_round_trip_equals(self):
+    def test_round_trip_equals(self, setup_path):
         # GH 9330
         df = DataFrame({"B": [1, 2], "A": ["x", "y"]})
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", format="table")
             other = read_hdf(path, "df")
             tm.assert_frame_equal(df, other)
             assert df.equals(other)
             assert other.equals(df)
 
-    def test_preserve_timedeltaindex_type(self):
+    def test_preserve_timedeltaindex_type(self, setup_path):
         # GH9635
         # Storing TimedeltaIndexed DataFrames in fixed stores did not preserve
         # the type of the index.
         df = DataFrame(np.random.normal(size=(10, 5)))
         df.index = timedelta_range(start="0s", periods=10, freq="1s", name="example")
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
 
             store["df"] = df
-            assert_frame_equal(store["df"], df)
+            tm.assert_frame_equal(store["df"], df)
 
-    def test_columns_multiindex_modified(self):
+    def test_columns_multiindex_modified(self, setup_path):
         # BUG: 7212
         # read_hdf store.select modified the passed columns parameters
         # when multi-indexed.
@@ -4612,7 +4497,7 @@ def test_columns_multiindex_modified(self):
         df = df.set_index(keys="E", append=True)
 
         data_columns = df.index.names + df.columns.tolist()
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(
                 path,
                 "df",
@@ -4627,7 +4512,7 @@ def test_columns_multiindex_modified(self):
             assert cols2load_original == cols2load
 
     @ignore_natural_naming_warning
-    def test_to_hdf_with_object_column_names(self):
+    def test_to_hdf_with_object_column_names(self, setup_path):
         # GH9057
         # Writing HDF5 table format should only work for string-like
         # column types
@@ -4647,7 +4532,7 @@ def test_to_hdf_with_object_column_names(self):
 
         for index in types_should_fail:
             df = DataFrame(np.random.randn(10, 2), columns=index(2))
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
                 with catch_warnings(record=True):
                     msg = "cannot have non-object label DataIndexableCol"
                     with pytest.raises(ValueError, match=msg):
@@ -4655,7 +4540,7 @@ def test_to_hdf_with_object_column_names(self):
 
         for index in types_should_run:
             df = DataFrame(np.random.randn(10, 2), columns=index(2))
-            with ensure_clean_path(self.path) as path:
+            with ensure_clean_path(setup_path) as path:
                 with catch_warnings(record=True):
                     df.to_hdf(path, "df", format="table", data_columns=True)
                     result = pd.read_hdf(
@@ -4663,14 +4548,14 @@ def test_to_hdf_with_object_column_names(self):
                     )
                     assert len(result)
 
-    def test_read_hdf_open_store(self):
+    def test_read_hdf_open_store(self, setup_path):
         # GH10330
         # No check for non-string path_or-buf, and no test of open store
         df = DataFrame(np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE"))
         df.index.name = "letters"
         df = df.set_index(keys="E", append=True)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", mode="w")
             direct = read_hdf(path, "df")
             store = HDFStore(path, mode="r")
@@ -4679,12 +4564,12 @@ def test_read_hdf_open_store(self):
             assert store.is_open
             store.close()
 
-    def test_read_hdf_iterator(self):
+    def test_read_hdf_iterator(self, setup_path):
         df = DataFrame(np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE"))
         df.index.name = "letters"
         df = df.set_index(keys="E", append=True)
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", mode="w", format="t")
             direct = read_hdf(path, "df")
             iterator = read_hdf(path, "df", iterator=True)
@@ -4693,10 +4578,10 @@ def test_read_hdf_iterator(self):
             tm.assert_frame_equal(direct, indirect)
             iterator.store.close()
 
-    def test_read_hdf_errors(self):
+    def test_read_hdf_errors(self, setup_path):
         df = DataFrame(np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE"))
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             with pytest.raises(IOError):
                 read_hdf(path, "key")
 
@@ -4711,59 +4596,56 @@ def test_read_hdf_generic_buffer_errors(self):
         with pytest.raises(NotImplementedError):
             read_hdf(BytesIO(b""), "df")
 
-    def test_invalid_complib(self):
+    def test_invalid_complib(self, setup_path):
         df = DataFrame(np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE"))
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             with pytest.raises(ValueError):
                 df.to_hdf(path, "df", complib="foolib")
 
     # GH10443
 
-    def test_read_nokey(self):
+    def test_read_nokey(self, setup_path):
         df = DataFrame(np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE"))
 
         # Categorical dtype not supported for "fixed" format. So no need
         # to test with that dtype in the dataframe here.
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", mode="a")
             reread = read_hdf(path)
-            assert_frame_equal(df, reread)
+            tm.assert_frame_equal(df, reread)
             df.to_hdf(path, "df2", mode="a")
 
             with pytest.raises(ValueError):
                 read_hdf(path)
 
-    def test_read_nokey_table(self):
+    def test_read_nokey_table(self, setup_path):
         # GH13231
         df = DataFrame({"i": range(5), "c": Series(list("abacd"), dtype="category")})
 
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             df.to_hdf(path, "df", mode="a", format="table")
             reread = read_hdf(path)
-            assert_frame_equal(df, reread)
+            tm.assert_frame_equal(df, reread)
             df.to_hdf(path, "df2", mode="a", format="table")
 
             with pytest.raises(ValueError):
                 read_hdf(path)
 
-    def test_read_nokey_empty(self):
-        with ensure_clean_path(self.path) as path:
+    def test_read_nokey_empty(self, setup_path):
+        with ensure_clean_path(setup_path) as path:
             store = HDFStore(path)
             store.close()
 
             with pytest.raises(ValueError):
                 read_hdf(path)
 
-    @td.skip_if_no("pathlib")
-    def test_read_from_pathlib_path(self):
+    def test_read_from_pathlib_path(self, setup_path):
 
         # GH11773
-        from pathlib import Path
-
         expected = DataFrame(
             np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE")
         )
-        with ensure_clean_path(self.path) as filename:
+        with ensure_clean_path(setup_path) as filename:
             path_obj = Path(filename)
 
             expected.to_hdf(path_obj, "df", mode="a")
@@ -4772,7 +4654,7 @@ def test_read_from_pathlib_path(self):
         tm.assert_frame_equal(expected, actual)
 
     @td.skip_if_no("py.path")
-    def test_read_from_py_localpath(self):
+    def test_read_from_py_localpath(self, setup_path):
 
         # GH11773
         from py.path import local as LocalPath
@@ -4780,7 +4662,7 @@ def test_read_from_py_localpath(self):
         expected = DataFrame(
             np.random.rand(4, 5), index=list("abcd"), columns=list("ABCDE")
         )
-        with ensure_clean_path(self.path) as filename:
+        with ensure_clean_path(setup_path) as filename:
             path_obj = LocalPath(filename)
 
             expected.to_hdf(path_obj, "df", mode="a")
@@ -4788,11 +4670,11 @@ def test_read_from_py_localpath(self):
 
         tm.assert_frame_equal(expected, actual)
 
-    def test_query_long_float_literal(self):
+    def test_query_long_float_literal(self, setup_path):
         # GH 14241
         df = pd.DataFrame({"A": [1000000000.0009, 1000000000.0011, 1000000000.0015]})
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("test", df, format="table", data_columns=True)
 
             cutoff = 1000000000.0006
@@ -4809,7 +4691,7 @@ def test_query_long_float_literal(self):
             expected = df.loc[[1], :]
             tm.assert_frame_equal(expected, result)
 
-    def test_query_compare_column_type(self):
+    def test_query_compare_column_type(self, setup_path):
         # GH 15492
         df = pd.DataFrame(
             {
@@ -4821,7 +4703,7 @@ def test_query_compare_column_type(self):
             columns=["date", "real_date", "float", "int"],
         )
 
-        with ensure_clean_store(self.path) as store:
+        with ensure_clean_store(setup_path) as store:
             store.append("test", df, format="table", data_columns=True)
 
             ts = pd.Timestamp("2014-01-01")  # noqa
@@ -4858,17 +4740,16 @@ def test_query_compare_column_type(self):
                     tm.assert_frame_equal(expected, result)
 
     @pytest.mark.parametrize("format", ["fixed", "table"])
-    def test_read_hdf_series_mode_r(self, format):
+    def test_read_hdf_series_mode_r(self, format, setup_path):
         # GH 16583
         # Tests that reading a Series saved to an HDF file
         # still works if a mode='r' argument is supplied
         series = tm.makeFloatSeries()
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             series.to_hdf(path, key="data", format=format)
             result = pd.read_hdf(path, key="data", mode="r")
         tm.assert_series_equal(result, series)
 
-    @pytest.mark.skipif(not PY36, reason="Need python 3.6")
     def test_fspath(self):
         with tm.ensure_clean("foo.h5") as path:
             with pd.HDFStore(path) as store:
@@ -4897,7 +4778,7 @@ def test_read_py2_hdf_file_in_py3(self, datapath):
             mode="r",
         ) as store:
             result = store["p"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("where", ["", (), (None,), [], [None]])
     def test_select_empty_where(self, where):
@@ -4912,7 +4793,7 @@ def test_select_empty_where(self, where):
             with pd.HDFStore(path) as store:
                 store.put("df", df, "t")
                 result = pd.read_hdf(store, "df", where=where)
-                assert_frame_equal(result, df)
+                tm.assert_frame_equal(result, df)
 
     @pytest.mark.parametrize(
         "idx",
@@ -4921,542 +4802,10 @@ def test_select_empty_where(self, where):
             CategoricalIndex(list("abc")),
         ],
     )
-    def test_to_hdf_multiindex_extension_dtype(self, idx):
+    def test_to_hdf_multiindex_extension_dtype(self, idx, setup_path):
         # GH 7775
         mi = MultiIndex.from_arrays([idx, idx])
         df = pd.DataFrame(0, index=mi, columns=["a"])
-        with ensure_clean_path(self.path) as path:
+        with ensure_clean_path(setup_path) as path:
             with pytest.raises(NotImplementedError, match="Saving a MultiIndex"):
                 df.to_hdf(path, "df")
-
-
-class TestHDFComplexValues(Base):
-    # GH10447
-
-    def test_complex_fixed(self):
-        df = DataFrame(
-            np.random.rand(4, 5).astype(np.complex64),
-            index=list("abcd"),
-            columns=list("ABCDE"),
-        )
-
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-        df = DataFrame(
-            np.random.rand(4, 5).astype(np.complex128),
-            index=list("abcd"),
-            columns=list("ABCDE"),
-        )
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-    def test_complex_table(self):
-        df = DataFrame(
-            np.random.rand(4, 5).astype(np.complex64),
-            index=list("abcd"),
-            columns=list("ABCDE"),
-        )
-
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df", format="table")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-        df = DataFrame(
-            np.random.rand(4, 5).astype(np.complex128),
-            index=list("abcd"),
-            columns=list("ABCDE"),
-        )
-
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df", format="table", mode="w")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-    @xfail_non_writeable
-    def test_complex_mixed_fixed(self):
-        complex64 = np.array(
-            [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
-        )
-        complex128 = np.array(
-            [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
-        )
-        df = DataFrame(
-            {
-                "A": [1, 2, 3, 4],
-                "B": ["a", "b", "c", "d"],
-                "C": complex64,
-                "D": complex128,
-                "E": [1.0, 2.0, 3.0, 4.0],
-            },
-            index=list("abcd"),
-        )
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-    def test_complex_mixed_table(self):
-        complex64 = np.array(
-            [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
-        )
-        complex128 = np.array(
-            [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
-        )
-        df = DataFrame(
-            {
-                "A": [1, 2, 3, 4],
-                "B": ["a", "b", "c", "d"],
-                "C": complex64,
-                "D": complex128,
-                "E": [1.0, 2.0, 3.0, 4.0],
-            },
-            index=list("abcd"),
-        )
-
-        with ensure_clean_store(self.path) as store:
-            store.append("df", df, data_columns=["A", "B"])
-            result = store.select("df", where="A>2")
-            assert_frame_equal(df.loc[df.A > 2], result)
-
-        with ensure_clean_path(self.path) as path:
-            df.to_hdf(path, "df", format="table")
-            reread = read_hdf(path, "df")
-            assert_frame_equal(df, reread)
-
-    def test_complex_across_dimensions_fixed(self):
-        with catch_warnings(record=True):
-            complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
-            s = Series(complex128, index=list("abcd"))
-            df = DataFrame({"A": s, "B": s})
-
-            objs = [s, df]
-            comps = [tm.assert_series_equal, tm.assert_frame_equal]
-            for obj, comp in zip(objs, comps):
-                with ensure_clean_path(self.path) as path:
-                    obj.to_hdf(path, "obj", format="fixed")
-                    reread = read_hdf(path, "obj")
-                    comp(obj, reread)
-
-    def test_complex_across_dimensions(self):
-        complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
-        s = Series(complex128, index=list("abcd"))
-        df = DataFrame({"A": s, "B": s})
-
-        with catch_warnings(record=True):
-
-            objs = [df]
-            comps = [tm.assert_frame_equal]
-            for obj, comp in zip(objs, comps):
-                with ensure_clean_path(self.path) as path:
-                    obj.to_hdf(path, "obj", format="table")
-                    reread = read_hdf(path, "obj")
-                    comp(obj, reread)
-
-    def test_complex_indexing_error(self):
-        complex128 = np.array(
-            [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
-        )
-        df = DataFrame(
-            {"A": [1, 2, 3, 4], "B": ["a", "b", "c", "d"], "C": complex128},
-            index=list("abcd"),
-        )
-        with ensure_clean_store(self.path) as store:
-            with pytest.raises(TypeError):
-                store.append("df", df, data_columns=["C"])
-
-    def test_complex_series_error(self):
-        complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
-        s = Series(complex128, index=list("abcd"))
-
-        with ensure_clean_path(self.path) as path:
-            with pytest.raises(TypeError):
-                s.to_hdf(path, "obj", format="t")
-
-        with ensure_clean_path(self.path) as path:
-            s.to_hdf(path, "obj", format="t", index=False)
-            reread = read_hdf(path, "obj")
-            tm.assert_series_equal(s, reread)
-
-    def test_complex_append(self):
-        df = DataFrame(
-            {"a": np.random.randn(100).astype(np.complex128), "b": np.random.randn(100)}
-        )
-
-        with ensure_clean_store(self.path) as store:
-            store.append("df", df, data_columns=["b"])
-            store.append("df", df)
-            result = store.select("df")
-            assert_frame_equal(pd.concat([df, df], 0), result)
-
-
-class TestTimezones(Base):
-    def _compare_with_tz(self, a, b):
-        tm.assert_frame_equal(a, b)
-
-        # compare the zones on each element
-        for c in a.columns:
-            for i in a.index:
-                a_e = a.loc[i, c]
-                b_e = b.loc[i, c]
-                if not (a_e == b_e and a_e.tz == b_e.tz):
-                    raise AssertionError(
-                        "invalid tz comparison [{a_e}] [{b_e}]".format(a_e=a_e, b_e=b_e)
-                    )
-
-    def test_append_with_timezones_dateutil(self):
-
-        from datetime import timedelta
-
-        # use maybe_get_tz instead of dateutil.tz.gettz to handle the windows
-        # filename issues.
-        from pandas._libs.tslibs.timezones import maybe_get_tz
-
-        gettz = lambda x: maybe_get_tz("dateutil/" + x)
-
-        # as columns
-        with ensure_clean_store(self.path) as store:
-
-            _maybe_remove(store, "df_tz")
-            df = DataFrame(
-                dict(
-                    A=[
-                        Timestamp("20130102 2:00:00", tz=gettz("US/Eastern"))
-                        + timedelta(hours=1) * i
-                        for i in range(5)
-                    ]
-                )
-            )
-
-            store.append("df_tz", df, data_columns=["A"])
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            # select with tz aware
-            expected = df[df.A >= df.A[3]]
-            result = store.select("df_tz", where="A>=df.A[3]")
-            self._compare_with_tz(result, expected)
-
-            # ensure we include dates in DST and STD time here.
-            _maybe_remove(store, "df_tz")
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz=gettz("US/Eastern")),
-                    B=Timestamp("20130603", tz=gettz("US/Eastern")),
-                ),
-                index=range(5),
-            )
-            store.append("df_tz", df)
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz=gettz("US/Eastern")),
-                    B=Timestamp("20130102", tz=gettz("EET")),
-                ),
-                index=range(5),
-            )
-            with pytest.raises(ValueError):
-                store.append("df_tz", df)
-
-            # this is ok
-            _maybe_remove(store, "df_tz")
-            store.append("df_tz", df, data_columns=["A", "B"])
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            # can't append with diff timezone
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz=gettz("US/Eastern")),
-                    B=Timestamp("20130102", tz=gettz("CET")),
-                ),
-                index=range(5),
-            )
-            with pytest.raises(ValueError):
-                store.append("df_tz", df)
-
-        # as index
-        with ensure_clean_store(self.path) as store:
-
-            # GH 4098 example
-            df = DataFrame(
-                dict(
-                    A=Series(
-                        range(3),
-                        index=date_range(
-                            "2000-1-1", periods=3, freq="H", tz=gettz("US/Eastern")
-                        ),
-                    )
-                )
-            )
-
-            _maybe_remove(store, "df")
-            store.put("df", df)
-            result = store.select("df")
-            assert_frame_equal(result, df)
-
-            _maybe_remove(store, "df")
-            store.append("df", df)
-            result = store.select("df")
-            assert_frame_equal(result, df)
-
-    def test_append_with_timezones_pytz(self):
-
-        from datetime import timedelta
-
-        # as columns
-        with ensure_clean_store(self.path) as store:
-
-            _maybe_remove(store, "df_tz")
-            df = DataFrame(
-                dict(
-                    A=[
-                        Timestamp("20130102 2:00:00", tz="US/Eastern")
-                        + timedelta(hours=1) * i
-                        for i in range(5)
-                    ]
-                )
-            )
-            store.append("df_tz", df, data_columns=["A"])
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            # select with tz aware
-            self._compare_with_tz(
-                store.select("df_tz", where="A>=df.A[3]"), df[df.A >= df.A[3]]
-            )
-
-            _maybe_remove(store, "df_tz")
-            # ensure we include dates in DST and STD time here.
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz="US/Eastern"),
-                    B=Timestamp("20130603", tz="US/Eastern"),
-                ),
-                index=range(5),
-            )
-            store.append("df_tz", df)
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz="US/Eastern"),
-                    B=Timestamp("20130102", tz="EET"),
-                ),
-                index=range(5),
-            )
-            with pytest.raises(ValueError):
-                store.append("df_tz", df)
-
-            # this is ok
-            _maybe_remove(store, "df_tz")
-            store.append("df_tz", df, data_columns=["A", "B"])
-            result = store["df_tz"]
-            self._compare_with_tz(result, df)
-            assert_frame_equal(result, df)
-
-            # can't append with diff timezone
-            df = DataFrame(
-                dict(
-                    A=Timestamp("20130102", tz="US/Eastern"),
-                    B=Timestamp("20130102", tz="CET"),
-                ),
-                index=range(5),
-            )
-            with pytest.raises(ValueError):
-                store.append("df_tz", df)
-
-        # as index
-        with ensure_clean_store(self.path) as store:
-
-            # GH 4098 example
-            df = DataFrame(
-                dict(
-                    A=Series(
-                        range(3),
-                        index=date_range(
-                            "2000-1-1", periods=3, freq="H", tz="US/Eastern"
-                        ),
-                    )
-                )
-            )
-
-            _maybe_remove(store, "df")
-            store.put("df", df)
-            result = store.select("df")
-            assert_frame_equal(result, df)
-
-            _maybe_remove(store, "df")
-            store.append("df", df)
-            result = store.select("df")
-            assert_frame_equal(result, df)
-
-    def test_tseries_select_index_column(self):
-        # GH7777
-        # selecting a UTC datetimeindex column did
-        # not preserve UTC tzinfo set before storing
-
-        # check that no tz still works
-        rng = date_range("1/1/2000", "1/30/2000")
-        frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
-
-        with ensure_clean_store(self.path) as store:
-            store.append("frame", frame)
-            result = store.select_column("frame", "index")
-            assert rng.tz == DatetimeIndex(result.values).tz
-
-        # check utc
-        rng = date_range("1/1/2000", "1/30/2000", tz="UTC")
-        frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
-
-        with ensure_clean_store(self.path) as store:
-            store.append("frame", frame)
-            result = store.select_column("frame", "index")
-            assert rng.tz == result.dt.tz
-
-        # double check non-utc
-        rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
-        frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
-
-        with ensure_clean_store(self.path) as store:
-            store.append("frame", frame)
-            result = store.select_column("frame", "index")
-            assert rng.tz == result.dt.tz
-
-    def test_timezones_fixed(self):
-        with ensure_clean_store(self.path) as store:
-
-            # index
-            rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
-            df = DataFrame(np.random.randn(len(rng), 4), index=rng)
-            store["df"] = df
-            result = store["df"]
-            assert_frame_equal(result, df)
-
-            # as data
-            # GH11411
-            _maybe_remove(store, "df")
-            df = DataFrame(
-                {
-                    "A": rng,
-                    "B": rng.tz_convert("UTC").tz_localize(None),
-                    "C": rng.tz_convert("CET"),
-                    "D": range(len(rng)),
-                },
-                index=rng,
-            )
-            store["df"] = df
-            result = store["df"]
-            assert_frame_equal(result, df)
-
-    def test_fixed_offset_tz(self):
-        rng = date_range("1/1/2000 00:00:00-07:00", "1/30/2000 00:00:00-07:00")
-        frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
-
-        with ensure_clean_store(self.path) as store:
-            store["frame"] = frame
-            recons = store["frame"]
-            tm.assert_index_equal(recons.index, rng)
-            assert rng.tz == recons.index.tz
-
-    @td.skip_if_windows
-    def test_store_timezone(self):
-        # GH2852
-        # issue storing datetime.date with a timezone as it resets when read
-        # back in a new timezone
-
-        # original method
-        with ensure_clean_store(self.path) as store:
-
-            today = datetime.date(2013, 9, 10)
-            df = DataFrame([1, 2, 3], index=[today, today, today])
-            store["obj1"] = df
-            result = store["obj1"]
-            assert_frame_equal(result, df)
-
-        # with tz setting
-        with ensure_clean_store(self.path) as store:
-
-            with set_timezone("EST5EDT"):
-                today = datetime.date(2013, 9, 10)
-                df = DataFrame([1, 2, 3], index=[today, today, today])
-                store["obj1"] = df
-
-            with set_timezone("CST6CDT"):
-                result = store["obj1"]
-
-            assert_frame_equal(result, df)
-
-    def test_legacy_datetimetz_object(self, datapath):
-        # legacy from < 0.17.0
-        # 8260
-        expected = DataFrame(
-            dict(
-                A=Timestamp("20130102", tz="US/Eastern"),
-                B=Timestamp("20130603", tz="CET"),
-            ),
-            index=range(5),
-        )
-        with ensure_clean_store(
-            datapath("io", "data", "legacy_hdf", "datetimetz_object.h5"), mode="r"
-        ) as store:
-            result = store["df"]
-            assert_frame_equal(result, expected)
-
-    def test_dst_transitions(self):
-        # make sure we are not failing on transitions
-        with ensure_clean_store(self.path) as store:
-            times = pd.date_range(
-                "2013-10-26 23:00",
-                "2013-10-27 01:00",
-                tz="Europe/London",
-                freq="H",
-                ambiguous="infer",
-            )
-
-            for i in [times, times + pd.Timedelta("10min")]:
-                _maybe_remove(store, "df")
-                df = DataFrame({"A": range(len(i)), "B": i}, index=i)
-                store.append("df", df)
-                result = store.select("df")
-                assert_frame_equal(result, df)
-
-    def test_read_with_where_tz_aware_index(self):
-        # GH 11926
-        periods = 10
-        dts = pd.date_range("20151201", periods=periods, freq="D", tz="UTC")
-        mi = pd.MultiIndex.from_arrays([dts, range(periods)], names=["DATE", "NO"])
-        expected = pd.DataFrame({"MYCOL": 0}, index=mi)
-
-        key = "mykey"
-        with ensure_clean_path(self.path) as path:
-            with pd.HDFStore(path) as store:
-                store.append(key, expected, format="table", append=True)
-            result = pd.read_hdf(path, key, where="DATE > 20151130")
-            assert_frame_equal(result, expected)
-
-    def test_py2_created_with_datetimez(self, datapath):
-        # The test HDF5 file was created in Python 2, but could not be read in
-        # Python 3.
-        #
-        # GH26443
-        index = [pd.Timestamp("2019-01-01T18:00").tz_localize("America/New_York")]
-        expected = DataFrame({"data": 123}, index=index)
-        with ensure_clean_store(
-            datapath("io", "data", "legacy_hdf", "gh26443.h5"), mode="r"
-        ) as store:
-            result = store["key"]
-            assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/pytables/test_timezones.py b/pandas/tests/io/pytables/test_timezones.py
new file mode 100644
index 0000000000000..2bf22d982e5fe
--- /dev/null
+++ b/pandas/tests/io/pytables/test_timezones.py
@@ -0,0 +1,386 @@
+import datetime
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame, DatetimeIndex, Series, Timestamp, date_range
+import pandas._testing as tm
+from pandas.tests.io.pytables.common import (
+    _maybe_remove,
+    ensure_clean_path,
+    ensure_clean_store,
+)
+
+
+def _compare_with_tz(a, b):
+    tm.assert_frame_equal(a, b)
+
+    # compare the zones on each element
+    for c in a.columns:
+        for i in a.index:
+            a_e = a.loc[i, c]
+            b_e = b.loc[i, c]
+            if not (a_e == b_e and a_e.tz == b_e.tz):
+                raise AssertionError(
+                    "invalid tz comparison [{a_e}] [{b_e}]".format(a_e=a_e, b_e=b_e)
+                )
+
+
+def test_append_with_timezones_dateutil(setup_path):
+
+    from datetime import timedelta
+
+    # use maybe_get_tz instead of dateutil.tz.gettz to handle the windows
+    # filename issues.
+    from pandas._libs.tslibs.timezones import maybe_get_tz
+
+    gettz = lambda x: maybe_get_tz("dateutil/" + x)
+
+    # as columns
+    with ensure_clean_store(setup_path) as store:
+
+        _maybe_remove(store, "df_tz")
+        df = DataFrame(
+            dict(
+                A=[
+                    Timestamp("20130102 2:00:00", tz=gettz("US/Eastern"))
+                    + timedelta(hours=1) * i
+                    for i in range(5)
+                ]
+            )
+        )
+
+        store.append("df_tz", df, data_columns=["A"])
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        # select with tz aware
+        expected = df[df.A >= df.A[3]]
+        result = store.select("df_tz", where="A>=df.A[3]")
+        _compare_with_tz(result, expected)
+
+        # ensure we include dates in DST and STD time here.
+        _maybe_remove(store, "df_tz")
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz=gettz("US/Eastern")),
+                B=Timestamp("20130603", tz=gettz("US/Eastern")),
+            ),
+            index=range(5),
+        )
+        store.append("df_tz", df)
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz=gettz("US/Eastern")),
+                B=Timestamp("20130102", tz=gettz("EET")),
+            ),
+            index=range(5),
+        )
+        with pytest.raises(ValueError):
+            store.append("df_tz", df)
+
+        # this is ok
+        _maybe_remove(store, "df_tz")
+        store.append("df_tz", df, data_columns=["A", "B"])
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        # can't append with diff timezone
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz=gettz("US/Eastern")),
+                B=Timestamp("20130102", tz=gettz("CET")),
+            ),
+            index=range(5),
+        )
+        with pytest.raises(ValueError):
+            store.append("df_tz", df)
+
+    # as index
+    with ensure_clean_store(setup_path) as store:
+
+        # GH 4098 example
+        df = DataFrame(
+            dict(
+                A=Series(
+                    range(3),
+                    index=date_range(
+                        "2000-1-1", periods=3, freq="H", tz=gettz("US/Eastern")
+                    ),
+                )
+            )
+        )
+
+        _maybe_remove(store, "df")
+        store.put("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+        _maybe_remove(store, "df")
+        store.append("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+
+def test_append_with_timezones_pytz(setup_path):
+
+    from datetime import timedelta
+
+    # as columns
+    with ensure_clean_store(setup_path) as store:
+
+        _maybe_remove(store, "df_tz")
+        df = DataFrame(
+            dict(
+                A=[
+                    Timestamp("20130102 2:00:00", tz="US/Eastern")
+                    + timedelta(hours=1) * i
+                    for i in range(5)
+                ]
+            )
+        )
+        store.append("df_tz", df, data_columns=["A"])
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        # select with tz aware
+        _compare_with_tz(store.select("df_tz", where="A>=df.A[3]"), df[df.A >= df.A[3]])
+
+        _maybe_remove(store, "df_tz")
+        # ensure we include dates in DST and STD time here.
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz="US/Eastern"),
+                B=Timestamp("20130603", tz="US/Eastern"),
+            ),
+            index=range(5),
+        )
+        store.append("df_tz", df)
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz="US/Eastern"),
+                B=Timestamp("20130102", tz="EET"),
+            ),
+            index=range(5),
+        )
+        with pytest.raises(ValueError):
+            store.append("df_tz", df)
+
+        # this is ok
+        _maybe_remove(store, "df_tz")
+        store.append("df_tz", df, data_columns=["A", "B"])
+        result = store["df_tz"]
+        _compare_with_tz(result, df)
+        tm.assert_frame_equal(result, df)
+
+        # can't append with diff timezone
+        df = DataFrame(
+            dict(
+                A=Timestamp("20130102", tz="US/Eastern"),
+                B=Timestamp("20130102", tz="CET"),
+            ),
+            index=range(5),
+        )
+        with pytest.raises(ValueError):
+            store.append("df_tz", df)
+
+    # as index
+    with ensure_clean_store(setup_path) as store:
+
+        # GH 4098 example
+        df = DataFrame(
+            dict(
+                A=Series(
+                    range(3),
+                    index=date_range("2000-1-1", periods=3, freq="H", tz="US/Eastern"),
+                )
+            )
+        )
+
+        _maybe_remove(store, "df")
+        store.put("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+        _maybe_remove(store, "df")
+        store.append("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+
+def test_tseries_select_index_column(setup_path):
+    # GH7777
+    # selecting a UTC datetimeindex column did
+    # not preserve UTC tzinfo set before storing
+
+    # check that no tz still works
+    rng = date_range("1/1/2000", "1/30/2000")
+    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("frame", frame)
+        result = store.select_column("frame", "index")
+        assert rng.tz == DatetimeIndex(result.values).tz
+
+    # check utc
+    rng = date_range("1/1/2000", "1/30/2000", tz="UTC")
+    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("frame", frame)
+        result = store.select_column("frame", "index")
+        assert rng.tz == result.dt.tz
+
+    # double check non-utc
+    rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
+    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("frame", frame)
+        result = store.select_column("frame", "index")
+        assert rng.tz == result.dt.tz
+
+
+def test_timezones_fixed(setup_path):
+    with ensure_clean_store(setup_path) as store:
+
+        # index
+        rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
+        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
+        store["df"] = df
+        result = store["df"]
+        tm.assert_frame_equal(result, df)
+
+        # as data
+        # GH11411
+        _maybe_remove(store, "df")
+        df = DataFrame(
+            {
+                "A": rng,
+                "B": rng.tz_convert("UTC").tz_localize(None),
+                "C": rng.tz_convert("CET"),
+                "D": range(len(rng)),
+            },
+            index=rng,
+        )
+        store["df"] = df
+        result = store["df"]
+        tm.assert_frame_equal(result, df)
+
+
+def test_fixed_offset_tz(setup_path):
+    rng = date_range("1/1/2000 00:00:00-07:00", "1/30/2000 00:00:00-07:00")
+    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)
+
+    with ensure_clean_store(setup_path) as store:
+        store["frame"] = frame
+        recons = store["frame"]
+        tm.assert_index_equal(recons.index, rng)
+        assert rng.tz == recons.index.tz
+
+
+@td.skip_if_windows
+def test_store_timezone(setup_path):
+    # GH2852
+    # issue storing datetime.date with a timezone as it resets when read
+    # back in a new timezone
+
+    # original method
+    with ensure_clean_store(setup_path) as store:
+
+        today = datetime.date(2013, 9, 10)
+        df = DataFrame([1, 2, 3], index=[today, today, today])
+        store["obj1"] = df
+        result = store["obj1"]
+        tm.assert_frame_equal(result, df)
+
+    # with tz setting
+    with ensure_clean_store(setup_path) as store:
+
+        with tm.set_timezone("EST5EDT"):
+            today = datetime.date(2013, 9, 10)
+            df = DataFrame([1, 2, 3], index=[today, today, today])
+            store["obj1"] = df
+
+        with tm.set_timezone("CST6CDT"):
+            result = store["obj1"]
+
+        tm.assert_frame_equal(result, df)
+
+
+def test_legacy_datetimetz_object(datapath, setup_path):
+    # legacy from < 0.17.0
+    # 8260
+    expected = DataFrame(
+        dict(
+            A=Timestamp("20130102", tz="US/Eastern"), B=Timestamp("20130603", tz="CET")
+        ),
+        index=range(5),
+    )
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "datetimetz_object.h5"), mode="r"
+    ) as store:
+        result = store["df"]
+        tm.assert_frame_equal(result, expected)
+
+
+def test_dst_transitions(setup_path):
+    # make sure we are not failing on transitions
+    with ensure_clean_store(setup_path) as store:
+        times = pd.date_range(
+            "2013-10-26 23:00",
+            "2013-10-27 01:00",
+            tz="Europe/London",
+            freq="H",
+            ambiguous="infer",
+        )
+
+        for i in [times, times + pd.Timedelta("10min")]:
+            _maybe_remove(store, "df")
+            df = DataFrame({"A": range(len(i)), "B": i}, index=i)
+            store.append("df", df)
+            result = store.select("df")
+            tm.assert_frame_equal(result, df)
+
+
+def test_read_with_where_tz_aware_index(setup_path):
+    # GH 11926
+    periods = 10
+    dts = pd.date_range("20151201", periods=periods, freq="D", tz="UTC")
+    mi = pd.MultiIndex.from_arrays([dts, range(periods)], names=["DATE", "NO"])
+    expected = pd.DataFrame({"MYCOL": 0}, index=mi)
+
+    key = "mykey"
+    with ensure_clean_path(setup_path) as path:
+        with pd.HDFStore(path) as store:
+            store.append(key, expected, format="table", append=True)
+        result = pd.read_hdf(path, key, where="DATE > 20151130")
+        tm.assert_frame_equal(result, expected)
+
+
+def test_py2_created_with_datetimez(datapath, setup_path):
+    # The test HDF5 file was created in Python 2, but could not be read in
+    # Python 3.
+    #
+    # GH26443
+    index = [pd.Timestamp("2019-01-01T18:00").tz_localize("America/New_York")]
+    expected = DataFrame({"data": 123}, index=index)
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "gh26443.h5"), mode="r"
+    ) as store:
+        result = store["key"]
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/sas/test_sas.py b/pandas/tests/io/sas/test_sas.py
index fcd2e0e35ad9e..5d2643c20ceb2 100644
--- a/pandas/tests/io/sas/test_sas.py
+++ b/pandas/tests/io/sas/test_sas.py
@@ -3,7 +3,7 @@
 import pytest
 
 from pandas import read_sas
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestSas:
diff --git a/pandas/tests/io/sas/test_sas7bdat.py b/pandas/tests/io/sas/test_sas7bdat.py
index e37561c865c7a..62e9ac6929c8e 100644
--- a/pandas/tests/io/sas/test_sas7bdat.py
+++ b/pandas/tests/io/sas/test_sas7bdat.py
@@ -1,5 +1,7 @@
+from datetime import datetime
 import io
 import os
+from pathlib import Path
 
 import numpy as np
 import pytest
@@ -8,7 +10,7 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 # https://github.com/cython/cython/issues/1720
@@ -20,9 +22,9 @@ def setup_method(self, datapath):
         self.data = []
         self.test_ix = [list(range(1, 16)), [16]]
         for j in 1, 2:
-            fname = os.path.join(self.dirpath, "test_sas7bdat_{j}.csv".format(j=j))
+            fname = os.path.join(self.dirpath, f"test_sas7bdat_{j}.csv")
             df = pd.read_csv(fname)
-            epoch = pd.datetime(1960, 1, 1)
+            epoch = datetime(1960, 1, 1)
             t1 = pd.to_timedelta(df["Column4"], unit="d")
             df["Column4"] = epoch + t1
             t2 = pd.to_timedelta(df["Column12"], unit="d")
@@ -37,7 +39,7 @@ def test_from_file(self):
         for j in 0, 1:
             df0 = self.data[j]
             for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
+                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
                 df = pd.read_sas(fname, encoding="utf-8")
                 tm.assert_frame_equal(df, df0)
 
@@ -45,7 +47,7 @@ def test_from_buffer(self):
         for j in 0, 1:
             df0 = self.data[j]
             for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
+                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
                 with open(fname, "rb") as f:
                     byts = f.read()
                 buf = io.BytesIO(byts)
@@ -60,7 +62,7 @@ def test_from_iterator(self):
         for j in 0, 1:
             df0 = self.data[j]
             for k in self.test_ix[j]:
-                fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
+                fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
                 rdr = pd.read_sas(fname, iterator=True, encoding="utf-8")
                 df = rdr.read(2)
                 tm.assert_frame_equal(df, df0.iloc[0:2, :])
@@ -68,14 +70,11 @@ def test_from_iterator(self):
                 tm.assert_frame_equal(df, df0.iloc[2:5, :])
                 rdr.close()
 
-    @td.skip_if_no("pathlib")
     def test_path_pathlib(self):
-        from pathlib import Path
-
         for j in 0, 1:
             df0 = self.data[j]
             for k in self.test_ix[j]:
-                fname = Path(os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k)))
+                fname = Path(os.path.join(self.dirpath, f"test{k}.sas7bdat"))
                 df = pd.read_sas(fname, encoding="utf-8")
                 tm.assert_frame_equal(df, df0)
 
@@ -86,9 +85,7 @@ def test_path_localpath(self):
         for j in 0, 1:
             df0 = self.data[j]
             for k in self.test_ix[j]:
-                fname = LocalPath(
-                    os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
-                )
+                fname = LocalPath(os.path.join(self.dirpath, f"test{k}.sas7bdat"))
                 df = pd.read_sas(fname, encoding="utf-8")
                 tm.assert_frame_equal(df, df0)
 
@@ -97,7 +94,7 @@ def test_iterator_loop(self):
         for j in 0, 1:
             for k in self.test_ix[j]:
                 for chunksize in 3, 5, 10, 11:
-                    fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
+                    fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
                     rdr = pd.read_sas(fname, chunksize=10, encoding="utf-8")
                     y = 0
                     for x in rdr:
@@ -108,7 +105,7 @@ def test_iterator_loop(self):
     def test_iterator_read_too_much(self):
         # github #14734
         k = self.test_ix[0][0]
-        fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
+        fname = os.path.join(self.dirpath, f"test{k}.sas7bdat")
         rdr = pd.read_sas(fname, format="sas7bdat", iterator=True, encoding="utf-8")
         d1 = rdr.read(rdr.row_count + 20)
         rdr.close()
diff --git a/pandas/tests/io/sas/test_xport.py b/pandas/tests/io/sas/test_xport.py
index 7893877be2033..ee97f08ef9400 100644
--- a/pandas/tests/io/sas/test_xport.py
+++ b/pandas/tests/io/sas/test_xport.py
@@ -4,7 +4,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.io.sas.sasreader import read_sas
 
@@ -104,7 +104,7 @@ def test1_incremental(self):
 
         reader = read_sas(self.file01, index="SEQN", chunksize=1000)
 
-        all_data = [x for x in reader]
+        all_data = list(reader)
         data = pd.concat(all_data, axis=0)
 
         tm.assert_frame_equal(data, data_csv, check_index_type=False)
diff --git a/pandas/tests/io/test_clipboard.py b/pandas/tests/io/test_clipboard.py
index fccd52f9916b8..652cacaf14ffb 100644
--- a/pandas/tests/io/test_clipboard.py
+++ b/pandas/tests/io/test_clipboard.py
@@ -6,17 +6,9 @@
 
 import pandas as pd
 from pandas import DataFrame, get_option, read_clipboard
-from pandas.util import testing as tm
-from pandas.util.testing import makeCustomDataframe as mkdf
+import pandas._testing as tm
 
 from pandas.io.clipboard import clipboard_get, clipboard_set
-from pandas.io.clipboard.exceptions import PyperclipException
-
-try:
-    DataFrame({"A": [1, 2]}).to_clipboard()
-    _DEPS_INSTALLED = 1
-except (PyperclipException, RuntimeError):
-    _DEPS_INSTALLED = 0
 
 
 def build_kwargs(sep, excel):
@@ -54,12 +46,12 @@ def df(request):
             {"a": ["\U0001f44d\U0001f44d", "\U0001f44d\U0001f44d"], "b": ["abc", "def"]}
         )
     elif data_type == "string":
-        return mkdf(
+        return tm.makeCustomDataframe(
             5, 3, c_idx_type="s", r_idx_type="i", c_idx_names=[None], r_idx_names=[None]
         )
     elif data_type == "long":
         max_rows = get_option("display.max_rows")
-        return mkdf(
+        return tm.makeCustomDataframe(
             max_rows + 1,
             3,
             data_gen_f=lambda *args: randint(2),
@@ -72,7 +64,7 @@ def df(request):
         return pd.DataFrame({"en": "in English".split(), "es": "en español".split()})
     elif data_type == "colwidth":
         _cw = get_option("display.max_colwidth") + 1
-        return mkdf(
+        return tm.makeCustomDataframe(
             5,
             3,
             data_gen_f=lambda *args: "x" * _cw,
@@ -86,7 +78,7 @@ def df(request):
             {"a": np.arange(1.0, 6.0) + 0.01, "b": np.arange(1, 6), "c": list("abcde")}
         )
     elif data_type == "float":
-        return mkdf(
+        return tm.makeCustomDataframe(
             5,
             3,
             data_gen_f=lambda r, c: float(r) + 0.01,
@@ -96,7 +88,7 @@ def df(request):
             r_idx_names=[None],
         )
     elif data_type == "int":
-        return mkdf(
+        return tm.makeCustomDataframe(
             5,
             3,
             data_gen_f=lambda *args: randint(2),
@@ -150,7 +142,6 @@ def test_mock_clipboard(mock_clipboard):
 
 @pytest.mark.single
 @pytest.mark.clipboard
-@pytest.mark.skipif(not _DEPS_INSTALLED, reason="clipboard primitives not installed")
 @pytest.mark.usefixtures("mock_clipboard")
 class TestClipboard:
     def check_round_trip_frame(self, data, excel=None, sep=None, encoding=None):
@@ -258,7 +249,6 @@ def test_round_trip_valid_encodings(self, enc, df):
 
 @pytest.mark.single
 @pytest.mark.clipboard
-@pytest.mark.skipif(not _DEPS_INSTALLED, reason="clipboard primitives not installed")
 @pytest.mark.parametrize("data", ["\U0001f44d...", "Ωœ∑´...", "abcd..."])
 def test_raw_roundtrip(data):
     # PR #25040 wide unicode wasn't copied correctly on PY3 on windows
diff --git a/pandas/tests/io/test_common.py b/pandas/tests/io/test_common.py
index 8e09e96fbd471..404f5a477187b 100644
--- a/pandas/tests/io/test_common.py
+++ b/pandas/tests/io/test_common.py
@@ -4,6 +4,7 @@
 from io import StringIO
 import mmap
 import os
+from pathlib import Path
 
 import pytest
 
@@ -11,7 +12,7 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.common as icom
 
@@ -27,14 +28,7 @@ def __fspath__(self):
 
 
 # Functions that consume a string path and return a string or path-like object
-path_types = [str, CustomFSPath]
-
-try:
-    from pathlib import Path
-
-    path_types.append(Path)
-except ImportError:
-    pass
+path_types = [str, CustomFSPath, Path]
 
 try:
     from py.path import local as LocalPath
@@ -48,7 +42,6 @@ def __fspath__(self):
 
 # https://github.com/cython/cython/issues/1720
 @pytest.mark.filterwarnings("ignore:can't resolve package:ImportWarning")
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
 class TestCommonIOCapabilities:
     data1 = """index,A,B,C,D
 foo,2,3,4,5
@@ -74,11 +67,10 @@ def test_expand_user_normal_path(self):
         assert expanded_name == filename
         assert os.path.expanduser(filename) == expanded_name
 
-    @td.skip_if_no("pathlib")
     def test_stringify_path_pathlib(self):
-        rel_path = icom._stringify_path(Path("."))
+        rel_path = icom.stringify_path(Path("."))
         assert rel_path == "."
-        redundant_path = icom._stringify_path(Path("foo//bar"))
+        redundant_path = icom.stringify_path(Path("foo//bar"))
         assert redundant_path == os.path.join("foo", "bar")
 
     @td.skip_if_no("py.path")
@@ -86,11 +78,11 @@ def test_stringify_path_localpath(self):
         path = os.path.join("foo", "bar")
         abs_path = os.path.abspath(path)
         lpath = LocalPath(path)
-        assert icom._stringify_path(lpath) == abs_path
+        assert icom.stringify_path(lpath) == abs_path
 
     def test_stringify_path_fspath(self):
         p = CustomFSPath("foo/bar.csv")
-        result = icom._stringify_path(p)
+        result = icom.stringify_path(p)
         assert result == "foo/bar.csv"
 
     @pytest.mark.parametrize(
@@ -100,7 +92,7 @@ def test_stringify_path_fspath(self):
     @pytest.mark.parametrize("path_type", path_types)
     def test_infer_compression_from_path(self, extension, expected, path_type):
         path = path_type("foo/bar.csv" + extension)
-        compression = icom._infer_compression(path, compression="infer")
+        compression = icom.infer_compression(path, compression="infer")
         assert compression == expected
 
     def test_get_filepath_or_buffer_with_path(self):
@@ -137,12 +129,11 @@ def test_iterator(self):
             (pd.read_csv, "os", FileNotFoundError, "csv"),
             (pd.read_fwf, "os", FileNotFoundError, "txt"),
             (pd.read_excel, "xlrd", FileNotFoundError, "xlsx"),
-            (pd.read_feather, "feather", Exception, "feather"),
+            (pd.read_feather, "pyarrow", IOError, "feather"),
             (pd.read_hdf, "tables", FileNotFoundError, "h5"),
             (pd.read_stata, "os", FileNotFoundError, "dta"),
             (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
             (pd.read_json, "os", ValueError, "json"),
-            (pd.read_msgpack, "os", FileNotFoundError, "mp"),
             (pd.read_pickle, "os", FileNotFoundError, "pickle"),
         ],
     )
@@ -150,19 +141,7 @@ def test_read_non_existant(self, reader, module, error_class, fn_ext):
         pytest.importorskip(module)
 
         path = os.path.join(HERE, "data", "does_not_exist." + fn_ext)
-        msg1 = r"File (b')?.+does_not_exist\.{}'? does not exist".format(fn_ext)
-        msg2 = (
-            r"\[Errno 2\] No such file or directory: '.+does_not_exist" r"\.{}'"
-        ).format(fn_ext)
-        msg3 = "Expected object or value"
-        msg4 = "path_or_buf needs to be a string file path or file-like"
-        msg5 = (
-            r"\[Errno 2\] File .+does_not_exist\.{} does not exist:"
-            r" '.+does_not_exist\.{}'"
-        ).format(fn_ext, fn_ext)
-        with pytest.raises(
-            error_class, match=r"({}|{}|{}|{}|{})".format(msg1, msg2, msg3, msg4, msg5)
-        ):
+        with tm.external_error_raised(error_class):
             reader(path)
 
     @pytest.mark.parametrize(
@@ -172,12 +151,11 @@ def test_read_non_existant(self, reader, module, error_class, fn_ext):
             (pd.read_table, "os", FileNotFoundError, "csv"),
             (pd.read_fwf, "os", FileNotFoundError, "txt"),
             (pd.read_excel, "xlrd", FileNotFoundError, "xlsx"),
-            (pd.read_feather, "feather", Exception, "feather"),
+            (pd.read_feather, "pyarrow", IOError, "feather"),
             (pd.read_hdf, "tables", FileNotFoundError, "h5"),
             (pd.read_stata, "os", FileNotFoundError, "dta"),
             (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
             (pd.read_json, "os", ValueError, "json"),
-            (pd.read_msgpack, "os", FileNotFoundError, "mp"),
             (pd.read_pickle, "os", FileNotFoundError, "pickle"),
         ],
     )
@@ -189,40 +167,38 @@ def test_read_expands_user_home_dir(
         path = os.path.join("~", "does_not_exist." + fn_ext)
         monkeypatch.setattr(icom, "_expand_user", lambda x: os.path.join("foo", x))
 
-        msg1 = r"File (b')?.+does_not_exist\.{}'? does not exist".format(fn_ext)
-        msg2 = (
-            r"\[Errno 2\] No such file or directory:" r" '.+does_not_exist\.{}'"
-        ).format(fn_ext)
-        msg3 = "Unexpected character found when decoding 'false'"
-        msg4 = "path_or_buf needs to be a string file path or file-like"
-        msg5 = (
-            r"\[Errno 2\] File .+does_not_exist\.{} does not exist:"
-            r" '.+does_not_exist\.{}'"
-        ).format(fn_ext, fn_ext)
-
-        with pytest.raises(
-            error_class, match=r"({}|{}|{}|{}|{})".format(msg1, msg2, msg3, msg4, msg5)
-        ):
+        with tm.external_error_raised(error_class):
             reader(path)
 
     @pytest.mark.parametrize(
         "reader, module, path",
         [
-            (pd.read_csv, "os", ("io", "data", "iris.csv")),
-            (pd.read_table, "os", ("io", "data", "iris.csv")),
-            (pd.read_fwf, "os", ("io", "data", "fixed_width_format.txt")),
-            (pd.read_excel, "xlrd", ("io", "data", "test1.xlsx")),
-            (pd.read_feather, "feather", ("io", "data", "feather-0_3_1.feather")),
+            (pd.read_csv, "os", ("data", "iris.csv")),
+            (pd.read_table, "os", ("data", "iris.csv")),
+            (
+                pd.read_fwf,
+                "os",
+                ("io", "data", "fixed_width", "fixed_width_format.txt"),
+            ),
+            (pd.read_excel, "xlrd", ("io", "data", "excel", "test1.xlsx")),
+            (
+                pd.read_feather,
+                "pyarrow",
+                ("io", "data", "feather", "feather-0_3_1.feather"),
+            ),
             (
                 pd.read_hdf,
                 "tables",
                 ("io", "data", "legacy_hdf", "datetimetz_object.h5"),
             ),
-            (pd.read_stata, "os", ("io", "data", "stata10_115.dta")),
+            (pd.read_stata, "os", ("io", "data", "stata", "stata10_115.dta")),
             (pd.read_sas, "os", ("io", "sas", "data", "test1.sas7bdat")),
             (pd.read_json, "os", ("io", "json", "data", "tsframe_v012.json")),
-            (pd.read_msgpack, "os", ("io", "msgpack", "data", "frame.mp")),
-            (pd.read_pickle, "os", ("io", "data", "categorical_0_14_1.pickle")),
+            (
+                pd.read_pickle,
+                "os",
+                ("io", "data", "pickle", "categorical.0.25.0.pickle"),
+            ),
         ],
     )
     def test_read_fspath_all(self, reader, module, path, datapath):
@@ -244,11 +220,10 @@ def test_read_fspath_all(self, reader, module, path, datapath):
         [
             ("to_csv", {}, "os"),
             ("to_excel", {"engine": "xlwt"}, "xlwt"),
-            ("to_feather", {}, "feather"),
+            ("to_feather", {}, "pyarrow"),
             ("to_html", {}, "os"),
             ("to_json", {}, "os"),
             ("to_latex", {}, "os"),
-            ("to_msgpack", {}, "os"),
             ("to_pickle", {}, "os"),
             ("to_stata", {"time_stamp": pd.to_datetime("2019-01-01 00:00")}, "os"),
         ],
@@ -296,7 +271,7 @@ def test_write_fspath_hdf5(self):
 
 @pytest.fixture
 def mmap_file(datapath):
-    return datapath("io", "data", "test_mmap.csv")
+    return datapath("io", "data", "csv", "test_mmap.csv")
 
 
 class TestMMapWrapper:
@@ -313,18 +288,18 @@ def test_constructor_bad_file(self, mmap_file):
             err = mmap.error
 
         with pytest.raises(err, match=msg):
-            icom.MMapWrapper(non_file)
+            icom._MMapWrapper(non_file)
 
         target = open(mmap_file, "r")
         target.close()
 
         msg = "I/O operation on closed file"
         with pytest.raises(ValueError, match=msg):
-            icom.MMapWrapper(target)
+            icom._MMapWrapper(target)
 
     def test_get_attr(self, mmap_file):
         with open(mmap_file, "r") as target:
-            wrapper = icom.MMapWrapper(target)
+            wrapper = icom._MMapWrapper(target)
 
         attrs = dir(wrapper.mmap)
         attrs = [attr for attr in attrs if not attr.startswith("__")]
@@ -337,7 +312,7 @@ def test_get_attr(self, mmap_file):
 
     def test_next(self, mmap_file):
         with open(mmap_file, "r") as target:
-            wrapper = icom.MMapWrapper(target)
+            wrapper = icom._MMapWrapper(target)
             lines = target.readlines()
 
         for line in lines:
diff --git a/pandas/tests/io/test_compression.py b/pandas/tests/io/test_compression.py
index d68b6a1effaa0..841241d5124e0 100644
--- a/pandas/tests/io/test_compression.py
+++ b/pandas/tests/io/test_compression.py
@@ -1,29 +1,16 @@
-import contextlib
 import os
 import subprocess
 import sys
 import textwrap
-import warnings
 
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.common as icom
 
 
-@contextlib.contextmanager
-def catch_to_csv_depr():
-    # Catching warnings because Series.to_csv has
-    # been deprecated. Remove this context when
-    # Series.to_csv has been aligned.
-
-    with warnings.catch_warnings(record=True):
-        warnings.simplefilter("ignore", FutureWarning)
-        yield
-
-
 @pytest.mark.parametrize(
     "obj",
     [
@@ -37,12 +24,11 @@ def catch_to_csv_depr():
 @pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
 def test_compression_size(obj, method, compression_only):
     with tm.ensure_clean() as path:
-        with catch_to_csv_depr():
-            getattr(obj, method)(path, compression=compression_only)
-            compressed_size = os.path.getsize(path)
-            getattr(obj, method)(path, compression=None)
-            uncompressed_size = os.path.getsize(path)
-            assert uncompressed_size > compressed_size
+        getattr(obj, method)(path, compression=compression_only)
+        compressed_size = os.path.getsize(path)
+        getattr(obj, method)(path, compression=None)
+        uncompressed_size = os.path.getsize(path)
+        assert uncompressed_size > compressed_size
 
 
 @pytest.mark.parametrize(
@@ -58,19 +44,17 @@ def test_compression_size(obj, method, compression_only):
 @pytest.mark.parametrize("method", ["to_csv", "to_json"])
 def test_compression_size_fh(obj, method, compression_only):
     with tm.ensure_clean() as path:
-        f, handles = icom._get_handle(path, "w", compression=compression_only)
-        with catch_to_csv_depr():
-            with f:
-                getattr(obj, method)(f)
-                assert not f.closed
-            assert f.closed
-            compressed_size = os.path.getsize(path)
+        f, handles = icom.get_handle(path, "w", compression=compression_only)
+        with f:
+            getattr(obj, method)(f)
+            assert not f.closed
+        assert f.closed
+        compressed_size = os.path.getsize(path)
     with tm.ensure_clean() as path:
-        f, handles = icom._get_handle(path, "w", compression=None)
-        with catch_to_csv_depr():
-            with f:
-                getattr(obj, method)(f)
-                assert not f.closed
+        f, handles = icom.get_handle(path, "w", compression=None)
+        with f:
+            getattr(obj, method)(f)
+            assert not f.closed
         assert f.closed
         uncompressed_size = os.path.getsize(path)
         assert uncompressed_size > compressed_size
@@ -124,7 +108,7 @@ def test_compression_warning(compression_only):
         columns=["X", "Y", "Z"],
     )
     with tm.ensure_clean() as path:
-        f, handles = icom._get_handle(path, "w", compression=compression_only)
+        f, handles = icom.get_handle(path, "w", compression=compression_only)
         with tm.assert_produces_warning(RuntimeWarning, check_stacklevel=False):
             with f:
                 df.to_csv(f, compression=compression_only)
@@ -140,12 +124,13 @@ def test_with_missing_lzma():
         import pandas
         """
     )
-    subprocess.check_output([sys.executable, "-c", code])
+    subprocess.check_output([sys.executable, "-c", code], stderr=subprocess.PIPE)
 
 
 def test_with_missing_lzma_runtime():
     """Tests if RuntimeError is hit when calling lzma without
-    having the module available."""
+    having the module available.
+    """
     code = textwrap.dedent(
         """
         import sys
@@ -157,4 +142,4 @@ def test_with_missing_lzma_runtime():
             df.to_csv('foo.csv', compression='xz')
         """
     )
-    subprocess.check_output([sys.executable, "-c", code])
+    subprocess.check_output([sys.executable, "-c", code], stderr=subprocess.PIPE)
diff --git a/pandas/tests/io/test_date_converters.py b/pandas/tests/io/test_date_converters.py
index 2fa5e3b30d6af..cdb8eca02a3e5 100644
--- a/pandas/tests/io/test_date_converters.py
+++ b/pandas/tests/io/test_date_converters.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.date_converters as conv
 
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index ee668d6890756..0038df78dd866 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -5,8 +5,7 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, ensure_clean
+import pandas._testing as tm
 
 from pandas.io.feather_format import read_feather, to_feather  # noqa: E402 isort:skip
 
@@ -14,8 +13,10 @@
 
 
 pyarrow_version = LooseVersion(pyarrow.__version__)
+filter_sparse = pytest.mark.filterwarnings("ignore:The Sparse")
 
 
+@filter_sparse
 @pytest.mark.single
 class TestFeather:
     def check_error_on_write(self, df, exc):
@@ -23,7 +24,7 @@ def check_error_on_write(self, df, exc):
         # on writing
 
         with pytest.raises(exc):
-            with ensure_clean() as path:
+            with tm.ensure_clean() as path:
                 to_feather(df, path)
 
     def check_round_trip(self, df, expected=None, **kwargs):
@@ -31,11 +32,11 @@ def check_round_trip(self, df, expected=None, **kwargs):
         if expected is None:
             expected = df
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             to_feather(df, path)
 
             result = read_feather(path, **kwargs)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_error(self):
 
@@ -106,23 +107,6 @@ def test_unsupported_other(self):
         # Some versions raise ValueError, others raise ArrowInvalid.
         self.check_error_on_write(df, Exception)
 
-    def test_rw_nthreads(self):
-        df = pd.DataFrame({"A": np.arange(100000)})
-        expected_warning = (
-            "the 'nthreads' keyword is deprecated, use 'use_threads' instead"
-        )
-        # TODO: make the warning work with check_stacklevel=True
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w:
-            self.check_round_trip(df, nthreads=2)
-        # we have an extra FutureWarning because of #GH23752
-        assert any(expected_warning in str(x) for x in w)
-
-        # TODO: make the warning work with check_stacklevel=True
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w:
-            self.check_round_trip(df, nthreads=1)
-        # we have an extra FutureWarnings because of #GH23752
-        assert any(expected_warning in str(x) for x in w)
-
     def test_rw_use_threads(self):
         df = pd.DataFrame({"A": np.arange(100000)})
         self.check_round_trip(df, use_threads=True)
@@ -152,7 +136,7 @@ def test_write_with_index(self):
 
         # column multi-index
         df.index = [0, 1, 2]
-        df.columns = (pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1)]),)
+        df.columns = pd.MultiIndex.from_tuples([("a", 1)])
         self.check_error_on_write(df, ValueError)
 
     def test_path_pathlib(self):
diff --git a/pandas/tests/io/test_gbq.py b/pandas/tests/io/test_gbq.py
index 52147f4e1afc7..7a5eba5264421 100644
--- a/pandas/tests/io/test_gbq.py
+++ b/pandas/tests/io/test_gbq.py
@@ -1,6 +1,9 @@
+from contextlib import ExitStack as does_not_raise
 from datetime import datetime
 import os
 import platform
+import random
+import string
 
 import numpy as np
 import pytest
@@ -18,11 +21,6 @@
 PRIVATE_KEY_JSON_PATH = None
 PRIVATE_KEY_JSON_CONTENTS = None
 
-DATASET_ID = "pydata_pandas_bq_testing_py3"
-
-TABLE_ID = "new_test"
-DESTINATION_TABLE = "{0}.{1}".format(DATASET_ID + "1", TABLE_ID)
-
 VERSION = platform.python_version()
 
 
@@ -70,6 +68,10 @@ def _get_client():
     return bigquery.Client(project=project_id, credentials=credentials)
 
 
+def generate_rand_str(length: int = 10) -> str:
+    return "".join(random.choices(string.ascii_lowercase, k=length))
+
+
 def make_mixed_dataframe_v2(test_size):
     # create df to test for all BQ datatypes except RECORD
     bools = np.random.randint(2, size=(1, test_size)).astype(bool)
@@ -89,21 +91,6 @@ def make_mixed_dataframe_v2(test_size):
     )
 
 
-def test_read_gbq_with_deprecated_kwargs(monkeypatch):
-    captured_kwargs = {}
-
-    def mock_read_gbq(sql, **kwargs):
-        captured_kwargs.update(kwargs)
-        return DataFrame([[1.0]])
-
-    monkeypatch.setattr("pandas_gbq.read_gbq", mock_read_gbq)
-    private_key = object()
-    pd.read_gbq("SELECT 1", verbose=True, private_key=private_key)
-
-    assert captured_kwargs["verbose"]
-    assert captured_kwargs["private_key"] is private_key
-
-
 def test_read_gbq_without_deprecated_kwargs(monkeypatch):
     captured_kwargs = {}
 
@@ -144,36 +131,49 @@ def mock_read_gbq(sql, **kwargs):
     assert "use_bqstorage_api" not in captured_kwargs
 
 
+@pytest.mark.parametrize("progress_bar", [None, "foo"])
+def test_read_gbq_progress_bar_type_kwarg(monkeypatch, progress_bar):
+    # GH 29857
+    captured_kwargs = {}
+
+    def mock_read_gbq(sql, **kwargs):
+        captured_kwargs.update(kwargs)
+        return DataFrame([[1.0]])
+
+    monkeypatch.setattr("pandas_gbq.read_gbq", mock_read_gbq)
+    pd.read_gbq("SELECT 1", progress_bar_type=progress_bar)
+
+    if progress_bar:
+        assert "progress_bar_type" in captured_kwargs
+    else:
+        assert "progress_bar_type" not in captured_kwargs
+
+
 @pytest.mark.single
 class TestToGBQIntegrationWithServiceAccountKeyPath:
-    @classmethod
-    def setup_class(cls):
-        # - GLOBAL CLASS FIXTURES -
-        # put here any instruction you want to execute only *ONCE* *BEFORE*
-        # executing *ALL* tests described below.
-
+    @pytest.fixture()
+    def gbq_dataset(self):
+        # Setup Dataset
         _skip_if_no_project_id()
         _skip_if_no_private_key_path()
 
-        cls.client = _get_client()
-        cls.dataset = cls.client.dataset(DATASET_ID + "1")
-        try:
-            # Clean-up previous test runs.
-            cls.client.delete_dataset(cls.dataset, delete_contents=True)
-        except api_exceptions.NotFound:
-            pass  # It's OK if the dataset doesn't already exist.
+        dataset_id = "pydata_pandas_bq_testing_" + generate_rand_str()
+
+        self.client = _get_client()
+        self.dataset = self.client.dataset(dataset_id)
 
-        cls.client.create_dataset(bigquery.Dataset(cls.dataset))
+        # Create the dataset
+        self.client.create_dataset(bigquery.Dataset(self.dataset))
 
-    @classmethod
-    def teardown_class(cls):
-        # - GLOBAL CLASS FIXTURES -
-        # put here any instruction you want to execute only *ONCE* *AFTER*
-        # executing all tests.
-        cls.client.delete_dataset(cls.dataset, delete_contents=True)
+        table_name = generate_rand_str()
+        destination_table = f"{dataset_id}.{table_name}"
+        yield destination_table
 
-    def test_roundtrip(self):
-        destination_table = DESTINATION_TABLE + "1"
+        # Teardown Dataset
+        self.client.delete_dataset(self.dataset, delete_contents=True)
+
+    def test_roundtrip(self, gbq_dataset):
+        destination_table = gbq_dataset
 
         test_size = 20001
         df = make_mixed_dataframe_v2(test_size)
@@ -186,9 +186,50 @@ def test_roundtrip(self):
         )
 
         result = pd.read_gbq(
-            "SELECT COUNT(*) AS num_rows FROM {0}".format(destination_table),
+            f"SELECT COUNT(*) AS num_rows FROM {destination_table}",
             project_id=_get_project_id(),
             credentials=_get_credentials(),
             dialect="standard",
         )
         assert result["num_rows"][0] == test_size
+
+    @pytest.mark.parametrize(
+        "if_exists, expected_num_rows, expectation",
+        [
+            ("append", 300, does_not_raise()),
+            ("fail", 200, pytest.raises(pandas_gbq.gbq.TableCreationError)),
+            ("replace", 100, does_not_raise()),
+        ],
+    )
+    def test_gbq_if_exists(
+        self, if_exists, expected_num_rows, expectation, gbq_dataset
+    ):
+        # GH 29598
+        destination_table = gbq_dataset
+
+        test_size = 200
+        df = make_mixed_dataframe_v2(test_size)
+
+        df.to_gbq(
+            destination_table,
+            _get_project_id(),
+            chunksize=None,
+            credentials=_get_credentials(),
+        )
+
+        with expectation:
+            df.iloc[:100].to_gbq(
+                destination_table,
+                _get_project_id(),
+                if_exists=if_exists,
+                chunksize=None,
+                credentials=_get_credentials(),
+            )
+
+        result = pd.read_gbq(
+            f"SELECT COUNT(*) AS num_rows FROM {destination_table}",
+            project_id=_get_project_id(),
+            credentials=_get_credentials(),
+            dialect="standard",
+        )
+        assert result["num_rows"][0] == expected_num_rows
diff --git a/pandas/tests/io/test_gcs.py b/pandas/tests/io/test_gcs.py
index 2ca56230b5b8c..557a9d5c13987 100644
--- a/pandas/tests/io/test_gcs.py
+++ b/pandas/tests/io/test_gcs.py
@@ -1,11 +1,12 @@
 from io import StringIO
+import os
 
 import numpy as np
 import pytest
 
 from pandas import DataFrame, date_range, read_csv
+import pandas._testing as tm
 from pandas.util import _test_decorators as td
-from pandas.util.testing import assert_frame_equal
 
 from pandas.io.common import is_gcs_url
 
@@ -34,7 +35,7 @@ def open(*args):
     monkeypatch.setattr("gcsfs.GCSFileSystem", MockGCSFileSystem)
     df2 = read_csv("gs://test/test.csv", parse_dates=["dt"])
 
-    assert_frame_equal(df1, df2)
+    tm.assert_frame_equal(df1, df2)
 
 
 @td.skip_if_no("gcsfs")
@@ -57,7 +58,32 @@ def open(*args):
     df1.to_csv("gs://test/test.csv", index=True)
     df2 = read_csv(StringIO(s.getvalue()), parse_dates=["dt"], index_col=0)
 
-    assert_frame_equal(df1, df2)
+    tm.assert_frame_equal(df1, df2)
+
+
+@td.skip_if_no("fastparquet")
+@td.skip_if_no("gcsfs")
+def test_to_parquet_gcs_new_file(monkeypatch, tmpdir):
+    """Regression test for writing to a not-yet-existent GCS Parquet file."""
+    df1 = DataFrame(
+        {
+            "int": [1, 3],
+            "float": [2.0, np.nan],
+            "str": ["t", "s"],
+            "dt": date_range("2018-06-18", periods=2),
+        }
+    )
+
+    class MockGCSFileSystem:
+        def open(self, path, mode="r", *args):
+            if "w" not in mode:
+                raise FileNotFoundError
+            return open(os.path.join(tmpdir, "test.parquet"), mode)
+
+    monkeypatch.setattr("gcsfs.GCSFileSystem", MockGCSFileSystem)
+    df1.to_parquet(
+        "gs://test/test.csv", index=True, engine="fastparquet", compression=None
+    )
 
 
 @td.skip_if_no("gcsfs")
@@ -79,12 +105,10 @@ def mock_get_filepath_or_buffer(*args, **kwargs):
     )
     df2 = read_csv("gs://test/test.csv", parse_dates=["dt"])
 
-    assert_frame_equal(df1, df2)
+    tm.assert_frame_equal(df1, df2)
 
 
-@pytest.mark.skipif(
-    td.safe_import("gcsfs"), reason="Only check when gcsfs not installed"
-)
+@td.skip_if_installed("gcsfs")
 def test_gcs_not_present_exception():
     with pytest.raises(ImportError) as e:
         read_csv("gs://test/test.csv")
diff --git a/pandas/tests/io/test_html.py b/pandas/tests/io/test_html.py
index 183d217eb09d6..b649e394c780b 100644
--- a/pandas/tests/io/test_html.py
+++ b/pandas/tests/io/test_html.py
@@ -14,9 +14,8 @@
 from pandas.errors import ParserError
 import pandas.util._test_decorators as td
 
-from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, date_range, read_csv
-import pandas.util.testing as tm
-from pandas.util.testing import makeCustomDataframe as mkdf, network
+from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range, read_csv
+import pandas._testing as tm
 
 from pandas.io.common import file_path_to_url
 import pandas.io.html
@@ -64,7 +63,7 @@ def test_bs4_version_fails(monkeypatch, datapath):
 
     monkeypatch.setattr(bs4, "__version__", "4.2")
     with pytest.raises(ImportError, match="Pandas requires version"):
-        read_html(datapath("io", "data", "spam.html"), flavor="bs4")
+        read_html(datapath("io", "data", "html", "spam.html"), flavor="bs4")
 
 
 def test_invalid_flavor():
@@ -79,7 +78,7 @@ def test_invalid_flavor():
 @td.skip_if_no("bs4")
 @td.skip_if_no("lxml")
 def test_same_ordering(datapath):
-    filename = datapath("io", "data", "valid_markup.html")
+    filename = datapath("io", "data", "html", "valid_markup.html")
     dfs_lxml = read_html(filename, index_col=0, flavor=["lxml"])
     dfs_bs4 = read_html(filename, index_col=0, flavor=["bs4"])
     assert_framelist_equal(dfs_lxml, dfs_bs4)
@@ -88,7 +87,7 @@ def test_same_ordering(datapath):
 @pytest.mark.parametrize(
     "flavor",
     [
-        pytest.param("bs4", marks=td.skip_if_no("lxml")),
+        pytest.param("bs4", marks=td.skip_if_no("bs4")),
         pytest.param("lxml", marks=td.skip_if_no("lxml")),
     ],
     scope="class",
@@ -96,10 +95,10 @@ def test_same_ordering(datapath):
 class TestReadHtml:
     @pytest.fixture(autouse=True)
     def set_files(self, datapath):
-        self.spam_data = datapath("io", "data", "spam.html")
+        self.spam_data = datapath("io", "data", "html", "spam.html")
         self.spam_data_kwargs = {}
         self.spam_data_kwargs["encoding"] = "UTF-8"
-        self.banklist_data = datapath("io", "data", "banklist.html")
+        self.banklist_data = datapath("io", "data", "html", "banklist.html")
 
     @pytest.fixture(autouse=True, scope="function")
     def set_defaults(self, flavor, request):
@@ -108,7 +107,7 @@ def set_defaults(self, flavor, request):
 
     def test_to_html_compat(self):
         df = (
-            mkdf(
+            tm.makeCustomDataframe(
                 4,
                 3,
                 data_gen_f=lambda *args: rand(),
@@ -122,7 +121,7 @@ def test_to_html_compat(self):
         res = self.read_html(out, attrs={"class": "dataframe"}, index_col=0)[0]
         tm.assert_frame_equal(res, df)
 
-    @network
+    @tm.network
     def test_banklist_url(self):
         url = "http://www.fdic.gov/bank/individual/failed/banklist.html"
         df1 = self.read_html(
@@ -132,11 +131,11 @@ def test_banklist_url(self):
 
         assert_framelist_equal(df1, df2)
 
-    @network
+    @tm.network
     def test_spam_url(self):
         url = (
-            "http://ndb.nal.usda.gov/ndb/foods/show/300772?fg=&man=&"
-            "lfacet=&format=&count=&max=25&offset=&sort=&qlookup=spam"
+            "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+            "pandas/tests/io/data/html/spam.html"
         )
         df1 = self.read_html(url, ".*Water.*")
         df2 = self.read_html(url, "Unit")
@@ -179,7 +178,7 @@ def test_skiprows_int(self):
 
         assert_framelist_equal(df1, df2)
 
-    def test_skiprows_xrange(self):
+    def test_skiprows_range(self):
         df1 = self.read_html(self.spam_data, ".*Water.*", skiprows=range(2))[0]
         df2 = self.read_html(self.spam_data, "Unit", skiprows=range(2))[0]
         tm.assert_frame_equal(df1, df2)
@@ -275,12 +274,12 @@ def test_file_like(self):
 
         assert_framelist_equal(df1, df2)
 
-    @network
+    @tm.network
     def test_bad_url_protocol(self):
         with pytest.raises(URLError):
             self.read_html("git://github.com", match=".*Water.*")
 
-    @network
+    @tm.network
     @pytest.mark.slow
     def test_invalid_url(self):
         try:
@@ -361,43 +360,24 @@ def test_negative_skiprows(self):
         with pytest.raises(ValueError, match=msg):
             self.read_html(self.spam_data, "Water", skiprows=-1)
 
-    @network
+    @tm.network
     def test_multiple_matches(self):
         url = "https://docs.python.org/2/"
         dfs = self.read_html(url, match="Python")
         assert len(dfs) > 1
 
-    @network
+    @tm.network
     def test_python_docs_table(self):
         url = "https://docs.python.org/2/"
         dfs = self.read_html(url, match="Python")
         zz = [df.iloc[0, 0][0:4] for df in dfs]
         assert sorted(zz) == sorted(["Repo", "What"])
 
-    @pytest.mark.slow
-    def test_thousands_macau_stats(self, datapath):
-        all_non_nan_table_index = -2
-        macau_data = datapath("io", "data", "macau.html")
-        dfs = self.read_html(macau_data, index_col=0, attrs={"class": "style1"})
-        df = dfs[all_non_nan_table_index]
-
-        assert not any(s.isna().any() for _, s in df.items())
-
-    @pytest.mark.slow
-    def test_thousands_macau_index_col(self, datapath):
-        all_non_nan_table_index = -2
-        macau_data = datapath("io", "data", "macau.html")
-        dfs = self.read_html(macau_data, index_col=0, header=0)
-        df = dfs[all_non_nan_table_index]
-
-        assert not any(s.isna().any() for _, s in df.items())
-
     def test_empty_tables(self):
         """
         Make sure that read_html ignores empty tables.
         """
-        result = self.read_html(
-            """
+        html = """
             <table>
                 <thead>
                     <tr>
@@ -417,8 +397,7 @@ def test_empty_tables(self):
                 </tbody>
             </table>
         """
-        )
-
+        result = self.read_html(html)
         assert len(result) == 1
 
     def test_multiple_tbody(self):
@@ -566,23 +545,6 @@ def test_parse_header_of_non_string_column(self):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_nyse_wsj_commas_table(self, datapath):
-        data = datapath("io", "data", "nyse_wsj.html")
-        df = self.read_html(data, index_col=0, header=0, attrs={"class": "mdcTable"})[0]
-
-        expected = Index(
-            [
-                "Issue(Roll over for charts and headlines)",
-                "Volume",
-                "Price",
-                "Chg",
-                "% Chg",
-            ]
-        )
-        nrows = 100
-        assert df.shape[0] == nrows
-        tm.assert_index_equal(df.columns, expected)
-
     @pytest.mark.slow
     def test_banklist_header(self, datapath):
         from pandas.io.html import _remove_whitespace
@@ -595,7 +557,7 @@ def try_remove_ws(x):
 
         df = self.read_html(self.banklist_data, "Metcalf", attrs={"id": "table"})[0]
         ground_truth = read_csv(
-            datapath("io", "data", "banklist.csv"),
+            datapath("io", "data", "csv", "banklist.csv"),
             converters={"Updated Date": Timestamp, "Closing Date": Timestamp},
         )
         assert df.shape == ground_truth.shape
@@ -889,24 +851,23 @@ def test_parse_dates_combine(self):
         newdf = DataFrame({"datetime": raw_dates})
         tm.assert_frame_equal(newdf, res[0])
 
-    def test_computer_sales_page(self, datapath):
-        data = datapath("io", "data", "computer_sales_page.html")
-        msg = (
-            r"Passed header=\[0,1\] are too many "
-            r"rows for this multi_index of columns"
-        )
-        with pytest.raises(ParserError, match=msg):
-            self.read_html(data, header=[0, 1])
-
-        data = datapath("io", "data", "computer_sales_page.html")
-        assert self.read_html(data, header=[1, 2])
-
     def test_wikipedia_states_table(self, datapath):
-        data = datapath("io", "data", "wikipedia_states.html")
-        assert os.path.isfile(data), "{data!r} is not a file".format(data=data)
-        assert os.path.getsize(data), "{data!r} is an empty file".format(data=data)
+        data = datapath("io", "data", "html", "wikipedia_states.html")
+        assert os.path.isfile(data), f"{repr(data)} is not a file"
+        assert os.path.getsize(data), f"{repr(data)} is an empty file"
         result = self.read_html(data, "Arizona", header=1)[0]
+        assert result.shape == (60, 12)
+        assert "Unnamed" in result.columns[-1]
         assert result["sq mi"].dtype == np.dtype("float64")
+        assert np.allclose(result.loc[0, "sq mi"], 665384.04)
+
+    def test_wikipedia_states_multiindex(self, datapath):
+        data = datapath("io", "data", "html", "wikipedia_states.html")
+        result = self.read_html(data, "Arizona", index_col=0)[0]
+        assert result.shape == (60, 11)
+        assert "Unnamed" in result.columns[-1][1]
+        assert result.columns.nlevels == 2
+        assert np.allclose(result.loc["Alaska", ("Total area[2]", "sq mi")], 665384.04)
 
     def test_parser_error_on_empty_header_row(self):
         msg = (
@@ -1096,14 +1057,14 @@ def test_multiple_header_rows(self):
         tm.assert_frame_equal(expected_df, html_df)
 
     def test_works_on_valid_markup(self, datapath):
-        filename = datapath("io", "data", "valid_markup.html")
+        filename = datapath("io", "data", "html", "valid_markup.html")
         dfs = self.read_html(filename, index_col=0)
         assert isinstance(dfs, list)
         assert isinstance(dfs[0], DataFrame)
 
     @pytest.mark.slow
     def test_fallback_success(self, datapath):
-        banklist_data = datapath("io", "data", "banklist.html")
+        banklist_data = datapath("io", "data", "html", "banklist.html")
         self.read_html(banklist_data, ".*Water.*", flavor=["lxml", "html5lib"])
 
     def test_to_html_timestamp(self):
@@ -1153,9 +1114,9 @@ def test_displayed_only(self, displayed_only, exp0, exp1):
             assert len(dfs) == 1  # Should not parse hidden table
 
     def test_encode(self, html_encoding_file):
-        _, encoding = os.path.splitext(os.path.basename(html_encoding_file))[0].split(
-            "_"
-        )
+        base_path = os.path.basename(html_encoding_file)
+        root = os.path.splitext(base_path)[0]
+        _, encoding = root.split("_")
 
         try:
             with open(html_encoding_file, "rb") as fobj:
@@ -1178,7 +1139,7 @@ def test_encode(self, html_encoding_file):
             if is_platform_windows():
                 if "16" in encoding or "32" in encoding:
                     pytest.skip()
-                raise
+            raise
 
     def test_parse_failure_unseekable(self):
         # Issue #17975
@@ -1233,15 +1194,15 @@ class ErrorThread(threading.Thread):
             def run(self):
                 try:
                     super().run()
-                except Exception as e:
-                    self.err = e
+                except Exception as err:
+                    self.err = err
                 else:
                     self.err = None
 
         # force import check by reinitalising global vars in html.py
         reload(pandas.io.html)
 
-        filename = datapath("io", "data", "valid_markup.html")
+        filename = datapath("io", "data", "html", "valid_markup.html")
         helper_thread1 = ErrorThread(target=self.read_html, args=(filename,))
         helper_thread2 = ErrorThread(target=self.read_html, args=(filename,))
 
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
new file mode 100644
index 0000000000000..a1f9c6f6af51a
--- /dev/null
+++ b/pandas/tests/io/test_orc.py
@@ -0,0 +1,227 @@
+""" test orc compat """
+import datetime
+import os
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import read_orc
+import pandas._testing as tm
+
+pytest.importorskip("pyarrow", minversion="0.13.0")
+pytest.importorskip("pyarrow.orc")
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:RangeIndex.* is deprecated:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def dirpath(datapath):
+    return datapath("io", "data", "orc")
+
+
+def test_orc_reader_empty(dirpath):
+    columns = [
+        "boolean1",
+        "byte1",
+        "short1",
+        "int1",
+        "long1",
+        "float1",
+        "double1",
+        "bytes1",
+        "string1",
+    ]
+    dtypes = [
+        "bool",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "object",
+        "object",
+    ]
+    expected = pd.DataFrame(index=pd.RangeIndex(0))
+    for colname, dtype in zip(columns, dtypes):
+        expected[colname] = pd.Series(dtype=dtype)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.emptyFile.orc")
+    got = read_orc(inputfile, columns=columns)
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_basic(dirpath):
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.test1.orc")
+    got = read_orc(inputfile, columns=data.keys())
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_decimal(dirpath):
+    from decimal import Decimal
+
+    # Only testing the first 10 rows of data
+    data = {
+        "_col0": np.array(
+            [
+                Decimal("-1000.50000"),
+                Decimal("-999.60000"),
+                Decimal("-998.70000"),
+                Decimal("-997.80000"),
+                Decimal("-996.90000"),
+                Decimal("-995.10000"),
+                Decimal("-994.11000"),
+                Decimal("-993.12000"),
+                Decimal("-992.13000"),
+                Decimal("-991.14000"),
+            ],
+            dtype="object",
+        )
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.decimal.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_date_low(dirpath):
+    data = {
+        "time": np.array(
+            [
+                "1900-05-05 12:34:56.100000",
+                "1900-05-05 12:34:56.100100",
+                "1900-05-05 12:34:56.100200",
+                "1900-05-05 12:34:56.100300",
+                "1900-05-05 12:34:56.100400",
+                "1900-05-05 12:34:56.100500",
+                "1900-05-05 12:34:56.100600",
+                "1900-05-05 12:34:56.100700",
+                "1900-05-05 12:34:56.100800",
+                "1900-05-05 12:34:56.100900",
+            ],
+            dtype="datetime64[ns]",
+        ),
+        "date": np.array(
+            [
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testDate1900.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_date_high(dirpath):
+    data = {
+        "time": np.array(
+            [
+                "2038-05-05 12:34:56.100000",
+                "2038-05-05 12:34:56.100100",
+                "2038-05-05 12:34:56.100200",
+                "2038-05-05 12:34:56.100300",
+                "2038-05-05 12:34:56.100400",
+                "2038-05-05 12:34:56.100500",
+                "2038-05-05 12:34:56.100600",
+                "2038-05-05 12:34:56.100700",
+                "2038-05-05 12:34:56.100800",
+                "2038-05-05 12:34:56.100900",
+            ],
+            dtype="datetime64[ns]",
+        ),
+        "date": np.array(
+            [
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testDate2038.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_snappy_compressed(dirpath):
+    data = {
+        "int1": np.array(
+            [
+                -1160101563,
+                1181413113,
+                2065821249,
+                -267157795,
+                172111193,
+                1752363137,
+                1406072123,
+                1911809390,
+                -1308542224,
+                -467100286,
+            ],
+            dtype="int32",
+        ),
+        "string1": np.array(
+            [
+                "f50dcb8",
+                "382fdaaa",
+                "90758c6",
+                "9e8caf3f",
+                "ee97332b",
+                "d634da1",
+                "2bea4396",
+                "d67d89e8",
+                "ad71007e",
+                "e8c82066",
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testSnappy.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
diff --git a/pandas/tests/io/test_packers.py b/pandas/tests/io/test_packers.py
deleted file mode 100644
index 33a11087f622d..0000000000000
--- a/pandas/tests/io/test_packers.py
+++ /dev/null
@@ -1,962 +0,0 @@
-import datetime
-import glob
-from io import BytesIO
-import os
-from warnings import catch_warnings, filterwarnings
-
-import numpy as np
-import pytest
-
-from pandas._libs.tslib import iNaT
-from pandas.errors import PerformanceWarning
-
-import pandas
-from pandas import (
-    Categorical,
-    DataFrame,
-    Index,
-    Interval,
-    MultiIndex,
-    NaT,
-    Period,
-    Series,
-    Timestamp,
-    bdate_range,
-    date_range,
-    period_range,
-)
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_categorical_equal,
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-    ensure_clean,
-)
-
-from pandas.io.packers import read_msgpack, to_msgpack
-
-nan = np.nan
-
-try:
-    import blosc  # NOQA
-except ImportError:
-    _BLOSC_INSTALLED = False
-else:
-    _BLOSC_INSTALLED = True
-
-try:
-    import zlib  # NOQA
-except ImportError:
-    _ZLIB_INSTALLED = False
-else:
-    _ZLIB_INSTALLED = True
-
-
-@pytest.fixture(scope="module")
-def current_packers_data():
-    # our current version packers data
-    from pandas.tests.io.generate_legacy_storage_files import create_msgpack_data
-
-    return create_msgpack_data()
-
-
-@pytest.fixture(scope="module")
-def all_packers_data():
-    # our all of our current version packers data
-    from pandas.tests.io.generate_legacy_storage_files import create_data
-
-    return create_data()
-
-
-def check_arbitrary(a, b):
-
-    if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
-        assert len(a) == len(b)
-        for a_, b_ in zip(a, b):
-            check_arbitrary(a_, b_)
-    elif isinstance(a, DataFrame):
-        assert_frame_equal(a, b)
-    elif isinstance(a, Series):
-        assert_series_equal(a, b)
-    elif isinstance(a, Index):
-        assert_index_equal(a, b)
-    elif isinstance(a, Categorical):
-        # Temp,
-        # Categorical.categories is changed from str to bytes in PY3
-        # maybe the same as GH 13591
-        if b.categories.inferred_type == "string":
-            pass
-        else:
-            tm.assert_categorical_equal(a, b)
-    elif a is NaT:
-        assert b is NaT
-    elif isinstance(a, Timestamp):
-        assert a == b
-        assert a.freq == b.freq
-    else:
-        assert a == b
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestPackers:
-    def setup_method(self, method):
-        self.path = "__{}__.msg".format(tm.rands(10))
-
-    def teardown_method(self, method):
-        pass
-
-    def encode_decode(self, x, compress=None, **kwargs):
-        with ensure_clean(self.path) as p:
-            to_msgpack(p, x, compress=compress, **kwargs)
-            return read_msgpack(p, **kwargs)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestAPI(TestPackers):
-    def test_string_io(self):
-
-        df = DataFrame(np.random.randn(10, 2))
-        s = df.to_msgpack(None)
-        result = read_msgpack(s)
-        tm.assert_frame_equal(result, df)
-
-        s = df.to_msgpack()
-        result = read_msgpack(s)
-        tm.assert_frame_equal(result, df)
-
-        s = df.to_msgpack()
-        result = read_msgpack(BytesIO(s))
-        tm.assert_frame_equal(result, df)
-
-        s = to_msgpack(None, df)
-        result = read_msgpack(s)
-        tm.assert_frame_equal(result, df)
-
-        with ensure_clean(self.path) as p:
-
-            s = df.to_msgpack()
-            with open(p, "wb") as fh:
-                fh.write(s)
-            result = read_msgpack(p)
-            tm.assert_frame_equal(result, df)
-
-    def test_path_pathlib(self):
-        df = tm.makeDataFrame()
-        result = tm.round_trip_pathlib(df.to_msgpack, read_msgpack)
-        tm.assert_frame_equal(df, result)
-
-    def test_path_localpath(self):
-        df = tm.makeDataFrame()
-        result = tm.round_trip_localpath(df.to_msgpack, read_msgpack)
-        tm.assert_frame_equal(df, result)
-
-    def test_iterator_with_string_io(self):
-
-        dfs = [DataFrame(np.random.randn(10, 2)) for i in range(5)]
-        s = to_msgpack(None, *dfs)
-        for i, result in enumerate(read_msgpack(s, iterator=True)):
-            tm.assert_frame_equal(result, dfs[i])
-
-    def test_invalid_arg(self):
-        # GH10369
-        class A:
-            def __init__(self):
-                self.read = 0
-
-        msg = "Invalid file path or buffer object type: <class '{}'>"
-        invalid_path = os.path.join("nonexistent_dir", "df.msgpack")
-        with pytest.raises(ValueError, match=msg.format("NoneType")):
-            read_msgpack(path_or_buf=None)
-        with pytest.raises(ValueError, match=msg.format("dict")):
-            read_msgpack(path_or_buf={})
-        with pytest.raises(ValueError, match=msg.format(r".*\.A")):
-            read_msgpack(path_or_buf=A())
-        with pytest.raises(FileNotFoundError, match="does not exist"):
-            read_msgpack(path_or_buf=invalid_path)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestNumpy(TestPackers):
-    def test_numpy_scalar_float(self):
-        x = np.float32(np.random.rand())
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-    def test_numpy_scalar_complex(self):
-        x = np.complex64(np.random.rand() + 1j * np.random.rand())
-        x_rec = self.encode_decode(x)
-        assert np.allclose(x, x_rec)
-
-    def test_scalar_float(self):
-        x = np.random.rand()
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-    def test_scalar_bool(self):
-        x = np.bool_(1)
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-        x = np.bool_(0)
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-    def test_scalar_complex(self):
-        x = np.random.rand() + 1j * np.random.rand()
-        x_rec = self.encode_decode(x)
-        assert np.allclose(x, x_rec)
-
-    def test_list_numpy_float(self):
-        x = [np.float32(np.random.rand()) for i in range(5)]
-        x_rec = self.encode_decode(x)
-        # current msgpack cannot distinguish list/tuple
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-        x_rec = self.encode_decode(tuple(x))
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-    def test_list_numpy_float_complex(self):
-        if not hasattr(np, "complex128"):
-            pytest.skip("numpy can not handle complex128")
-
-        x = [np.float32(np.random.rand()) for i in range(5)] + [
-            np.complex128(np.random.rand() + 1j * np.random.rand()) for i in range(5)
-        ]
-        x_rec = self.encode_decode(x)
-        assert np.allclose(x, x_rec)
-
-    def test_list_float(self):
-        x = [np.random.rand() for i in range(5)]
-        x_rec = self.encode_decode(x)
-        # current msgpack cannot distinguish list/tuple
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-        x_rec = self.encode_decode(tuple(x))
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-    def test_list_float_complex(self):
-        x = [np.random.rand() for i in range(5)] + [
-            (np.random.rand() + 1j * np.random.rand()) for i in range(5)
-        ]
-        x_rec = self.encode_decode(x)
-        assert np.allclose(x, x_rec)
-
-    def test_dict_float(self):
-        x = {"foo": 1.0, "bar": 2.0}
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-    def test_dict_complex(self):
-        x = {"foo": 1.0 + 1.0j, "bar": 2.0 + 2.0j}
-        x_rec = self.encode_decode(x)
-        tm.assert_dict_equal(x, x_rec)
-
-        for key in x:
-            tm.assert_class_equal(x[key], x_rec[key], obj="complex value")
-
-    def test_dict_numpy_float(self):
-        x = {"foo": np.float32(1.0), "bar": np.float32(2.0)}
-        x_rec = self.encode_decode(x)
-        tm.assert_almost_equal(x, x_rec)
-
-    def test_dict_numpy_complex(self):
-        x = {"foo": np.complex128(1.0 + 1.0j), "bar": np.complex128(2.0 + 2.0j)}
-        x_rec = self.encode_decode(x)
-        tm.assert_dict_equal(x, x_rec)
-
-        for key in x:
-            tm.assert_class_equal(x[key], x_rec[key], obj="numpy complex128")
-
-    def test_numpy_array_float(self):
-
-        # run multiple times
-        for n in range(10):
-            x = np.random.rand(10)
-            for dtype in ["float32", "float64"]:
-                x = x.astype(dtype)
-                x_rec = self.encode_decode(x)
-                tm.assert_almost_equal(x, x_rec)
-
-    def test_numpy_array_complex(self):
-        x = (np.random.rand(5) + 1j * np.random.rand(5)).astype(np.complex128)
-        x_rec = self.encode_decode(x)
-        assert all(map(lambda x, y: x == y, x, x_rec)) and x.dtype == x_rec.dtype
-
-    def test_list_mixed(self):
-        x = [1.0, np.float32(3.5), np.complex128(4.25), "foo", np.bool_(1)]
-        x_rec = self.encode_decode(x)
-        # current msgpack cannot distinguish list/tuple
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-        x_rec = self.encode_decode(tuple(x))
-        tm.assert_almost_equal(tuple(x), x_rec)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestBasic(TestPackers):
-    def test_timestamp(self):
-
-        for i in [
-            Timestamp("20130101"),
-            Timestamp("20130101", tz="US/Eastern"),
-            Timestamp("201301010501"),
-        ]:
-            i_rec = self.encode_decode(i)
-            assert i == i_rec
-
-    def test_nat(self):
-        nat_rec = self.encode_decode(NaT)
-        assert NaT is nat_rec
-
-    def test_datetimes(self):
-
-        for i in [
-            datetime.datetime(2013, 1, 1),
-            datetime.datetime(2013, 1, 1, 5, 1),
-            datetime.date(2013, 1, 1),
-            np.datetime64(datetime.datetime(2013, 1, 5, 2, 15)),
-        ]:
-            i_rec = self.encode_decode(i)
-            assert i == i_rec
-
-    def test_timedeltas(self):
-
-        for i in [
-            datetime.timedelta(days=1),
-            datetime.timedelta(days=1, seconds=10),
-            np.timedelta64(1000000),
-        ]:
-            i_rec = self.encode_decode(i)
-            assert i == i_rec
-
-    def test_periods(self):
-        # 13463
-        for i in [Period("2010-09", "M"), Period("2014-Q1", "Q")]:
-            i_rec = self.encode_decode(i)
-            assert i == i_rec
-
-    def test_intervals(self):
-        # 19967
-        for i in [Interval(0, 1), Interval(0, 1, "left"), Interval(10, 25.0, "right")]:
-            i_rec = self.encode_decode(i)
-            assert i == i_rec
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestIndex(TestPackers):
-    def setup_method(self, method):
-        super().setup_method(method)
-
-        self.d = {
-            "string": tm.makeStringIndex(100),
-            "date": tm.makeDateIndex(100),
-            "int": tm.makeIntIndex(100),
-            "rng": tm.makeRangeIndex(100),
-            "float": tm.makeFloatIndex(100),
-            "empty": Index([]),
-            "tuple": Index(zip(["foo", "bar", "baz"], [1, 2, 3])),
-            "period": Index(period_range("2012-1-1", freq="M", periods=3)),
-            "date2": Index(date_range("2013-01-1", periods=10)),
-            "bdate": Index(bdate_range("2013-01-02", periods=10)),
-            "cat": tm.makeCategoricalIndex(100),
-            "interval": tm.makeIntervalIndex(100),
-            "timedelta": tm.makeTimedeltaIndex(100, "H"),
-        }
-
-        self.mi = {
-            "reg": MultiIndex.from_tuples(
-                [
-                    ("bar", "one"),
-                    ("baz", "two"),
-                    ("foo", "two"),
-                    ("qux", "one"),
-                    ("qux", "two"),
-                ],
-                names=["first", "second"],
-            )
-        }
-
-    def test_basic_index(self):
-
-        for s, i in self.d.items():
-            i_rec = self.encode_decode(i)
-            tm.assert_index_equal(i, i_rec)
-
-        # datetime with no freq (GH5506)
-        i = Index([Timestamp("20130101"), Timestamp("20130103")])
-        i_rec = self.encode_decode(i)
-        tm.assert_index_equal(i, i_rec)
-
-        # datetime with timezone
-        i = Index(
-            [Timestamp("20130101 9:00:00"), Timestamp("20130103 11:00:00")]
-        ).tz_localize("US/Eastern")
-        i_rec = self.encode_decode(i)
-        tm.assert_index_equal(i, i_rec)
-
-    def test_multi_index(self):
-
-        for s, i in self.mi.items():
-            i_rec = self.encode_decode(i)
-            tm.assert_index_equal(i, i_rec)
-
-    def test_unicode(self):
-        i = tm.makeUnicodeIndex(100)
-
-        i_rec = self.encode_decode(i)
-        tm.assert_index_equal(i, i_rec)
-
-    def categorical_index(self):
-        # GH15487
-        df = DataFrame(np.random.randn(10, 2))
-        df = df.astype({0: "category"}).set_index(0)
-        result = self.encode_decode(df)
-        tm.assert_frame_equal(result, df)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestSeries(TestPackers):
-    def setup_method(self, method):
-        super().setup_method(method)
-
-        self.d = {}
-
-        s = tm.makeStringSeries()
-        s.name = "string"
-        self.d["string"] = s
-
-        s = tm.makeObjectSeries()
-        s.name = "object"
-        self.d["object"] = s
-
-        s = Series(iNaT, dtype="M8[ns]", index=range(5))
-        self.d["date"] = s
-
-        data = {
-            "A": [0.0, 1.0, 2.0, 3.0, np.nan],
-            "B": [0, 1, 0, 1, 0],
-            "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
-            "D": date_range("1/1/2009", periods=5),
-            "E": [0.0, 1, Timestamp("20100101"), "foo", 2.0],
-            "F": [Timestamp("20130102", tz="US/Eastern")] * 2
-            + [Timestamp("20130603", tz="CET")] * 3,
-            "G": [Timestamp("20130102", tz="US/Eastern")] * 5,
-            "H": Categorical([1, 2, 3, 4, 5]),
-            "I": Categorical([1, 2, 3, 4, 5], ordered=True),
-            "J": (np.bool_(1), 2, 3, 4, 5),
-        }
-
-        self.d["float"] = Series(data["A"])
-        self.d["int"] = Series(data["B"])
-        self.d["mixed"] = Series(data["E"])
-        self.d["dt_tz_mixed"] = Series(data["F"])
-        self.d["dt_tz"] = Series(data["G"])
-        self.d["cat_ordered"] = Series(data["H"])
-        self.d["cat_unordered"] = Series(data["I"])
-        self.d["numpy_bool_mixed"] = Series(data["J"])
-
-    def test_basic(self):
-
-        # run multiple times here
-        for n in range(10):
-            for s, i in self.d.items():
-                i_rec = self.encode_decode(i)
-                assert_series_equal(i, i_rec)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestCategorical(TestPackers):
-    def setup_method(self, method):
-        super().setup_method(method)
-
-        self.d = {}
-
-        self.d["plain_str"] = Categorical(["a", "b", "c", "d", "e"])
-        self.d["plain_str_ordered"] = Categorical(
-            ["a", "b", "c", "d", "e"], ordered=True
-        )
-
-        self.d["plain_int"] = Categorical([5, 6, 7, 8])
-        self.d["plain_int_ordered"] = Categorical([5, 6, 7, 8], ordered=True)
-
-    def test_basic(self):
-
-        # run multiple times here
-        for n in range(10):
-            for s, i in self.d.items():
-                i_rec = self.encode_decode(i)
-                assert_categorical_equal(i, i_rec)
-
-
-@pytest.mark.filterwarnings("ignore:msgpack:FutureWarning")
-class TestNDFrame(TestPackers):
-    def setup_method(self, method):
-        super().setup_method(method)
-
-        data = {
-            "A": [0.0, 1.0, 2.0, 3.0, np.nan],
-            "B": [0, 1, 0, 1, 0],
-            "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
-            "D": date_range("1/1/2009", periods=5),
-            "E": [0.0, 1, Timestamp("20100101"), "foo", 2.0],
-            "F": [Timestamp("20130102", tz="US/Eastern")] * 5,
-            "G": [Timestamp("20130603", tz="CET")] * 5,
-            "H": Categorical(["a", "b", "c", "d", "e"]),
-            "I": Categorical(["a", "b", "c", "d", "e"], ordered=True),
-        }
-
-        self.frame = {
-            "float": DataFrame(dict(A=data["A"], B=Series(data["A"]) + 1)),
-            "int": DataFrame(dict(A=data["B"], B=Series(data["B"]) + 1)),
-            "mixed": DataFrame(data),
-        }
-
-    def test_basic_frame(self):
-
-        for s, i in self.frame.items():
-            i_rec = self.encode_decode(i)
-            assert_frame_equal(i, i_rec)
-
-    def test_multi(self):
-
-        i_rec = self.encode_decode(self.frame)
-        for k in self.frame.keys():
-            assert_frame_equal(self.frame[k], i_rec[k])
-
-        packed_items = tuple(
-            [self.frame["float"], self.frame["float"].A, self.frame["float"].B, None]
-        )
-        l_rec = self.encode_decode(packed_items)
-        check_arbitrary(packed_items, l_rec)
-
-        # this is an oddity in that packed lists will be returned as tuples
-        packed_items = [
-            self.frame["float"],
-            self.frame["float"].A,
-            self.frame["float"].B,
-            None,
-        ]
-        l_rec = self.encode_decode(packed_items)
-        assert isinstance(l_rec, tuple)
-        check_arbitrary(packed_items, l_rec)
-
-    def test_iterator(self):
-
-        packed_items = [
-            self.frame["float"],
-            self.frame["float"].A,
-            self.frame["float"].B,
-            None,
-        ]
-
-        with ensure_clean(self.path) as path:
-            to_msgpack(path, *packed_items)
-            for i, packed in enumerate(read_msgpack(path, iterator=True)):
-                check_arbitrary(packed, packed_items[i])
-
-    def tests_datetimeindex_freq_issue(self):
-
-        # GH 5947
-        # inferring freq on the datetimeindex
-        df = DataFrame([1, 2, 3], index=date_range("1/1/2013", "1/3/2013"))
-        result = self.encode_decode(df)
-        assert_frame_equal(result, df)
-
-        df = DataFrame([1, 2], index=date_range("1/1/2013", "1/2/2013"))
-        result = self.encode_decode(df)
-        assert_frame_equal(result, df)
-
-    def test_dataframe_duplicate_column_names(self):
-
-        # GH 9618
-        expected_1 = DataFrame(columns=["a", "a"])
-        expected_2 = DataFrame(columns=[1] * 100)
-        expected_2.loc[0] = np.random.randn(100)
-        expected_3 = DataFrame(columns=[1, 1])
-        expected_3.loc[0] = ["abc", np.nan]
-
-        result_1 = self.encode_decode(expected_1)
-        result_2 = self.encode_decode(expected_2)
-        result_3 = self.encode_decode(expected_3)
-
-        assert_frame_equal(result_1, expected_1)
-        assert_frame_equal(result_2, expected_2)
-        assert_frame_equal(result_3, expected_3)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestSparse(TestPackers):
-    def _check_roundtrip(self, obj, comparator, **kwargs):
-
-        # currently these are not implemetned
-        # i_rec = self.encode_decode(obj)
-        # comparator(obj, i_rec, **kwargs)
-        msg = r"msgpack sparse (series|frame) is not implemented"
-        with pytest.raises(NotImplementedError, match=msg):
-            self.encode_decode(obj)
-
-    def test_sparse_series(self):
-
-        s = tm.makeStringSeries()
-        s[3:5] = np.nan
-        ss = s.to_sparse()
-        self._check_roundtrip(ss, tm.assert_series_equal, check_series_type=True)
-
-        ss2 = s.to_sparse(kind="integer")
-        self._check_roundtrip(ss2, tm.assert_series_equal, check_series_type=True)
-
-        ss3 = s.to_sparse(fill_value=0)
-        self._check_roundtrip(ss3, tm.assert_series_equal, check_series_type=True)
-
-    def test_sparse_frame(self):
-
-        s = tm.makeDataFrame()
-        s.loc[3:5, 1:3] = np.nan
-        s.loc[8:10, -2] = np.nan
-        ss = s.to_sparse()
-
-        self._check_roundtrip(ss, tm.assert_frame_equal, check_frame_type=True)
-
-        ss2 = s.to_sparse(kind="integer")
-        self._check_roundtrip(ss2, tm.assert_frame_equal, check_frame_type=True)
-
-        ss3 = s.to_sparse(fill_value=0)
-        self._check_roundtrip(ss3, tm.assert_frame_equal, check_frame_type=True)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestCompression(TestPackers):
-    """See https://github.com/pandas-dev/pandas/pull/9783
-    """
-
-    def setup_method(self, method):
-        try:
-            from sqlalchemy import create_engine
-
-            self._create_sql_engine = create_engine
-        except ImportError:
-            self._SQLALCHEMY_INSTALLED = False
-        else:
-            self._SQLALCHEMY_INSTALLED = True
-
-        super().setup_method(method)
-        data = {
-            "A": np.arange(1000, dtype=np.float64),
-            "B": np.arange(1000, dtype=np.int32),
-            "C": list(100 * "abcdefghij"),
-            "D": date_range(datetime.datetime(2015, 4, 1), periods=1000),
-            "E": [datetime.timedelta(days=x) for x in range(1000)],
-        }
-        self.frame = {
-            "float": DataFrame({k: data[k] for k in ["A", "A"]}),
-            "int": DataFrame({k: data[k] for k in ["B", "B"]}),
-            "mixed": DataFrame(data),
-        }
-
-    def test_plain(self):
-        i_rec = self.encode_decode(self.frame)
-        for k in self.frame.keys():
-            assert_frame_equal(self.frame[k], i_rec[k])
-
-    def _test_compression(self, compress):
-        i_rec = self.encode_decode(self.frame, compress=compress)
-        for k in self.frame.keys():
-            value = i_rec[k]
-            expected = self.frame[k]
-            assert_frame_equal(value, expected)
-            # make sure that we can write to the new frames
-            for block in value._data.blocks:
-                assert block.values.flags.writeable
-
-    def test_compression_zlib(self):
-        if not _ZLIB_INSTALLED:
-            pytest.skip("no zlib")
-        self._test_compression("zlib")
-
-    def test_compression_blosc(self):
-        if not _BLOSC_INSTALLED:
-            pytest.skip("no blosc")
-        self._test_compression("blosc")
-
-    def _test_compression_warns_when_decompress_caches(self, monkeypatch, compress):
-        not_garbage = []
-        control = []  # copied data
-
-        compress_module = globals()[compress]
-        real_decompress = compress_module.decompress
-
-        def decompress(ob):
-            """mock decompress function that delegates to the real
-            decompress but caches the result and a copy of the result.
-            """
-            res = real_decompress(ob)
-            not_garbage.append(res)  # hold a reference to this bytes object
-            control.append(bytearray(res))  # copy the data here to check later
-            return res
-
-        # types mapped to values to add in place.
-        rhs = {
-            np.dtype("float64"): 1.0,
-            np.dtype("int32"): 1,
-            np.dtype("object"): "a",
-            np.dtype("datetime64[ns]"): np.timedelta64(1, "ns"),
-            np.dtype("timedelta64[ns]"): np.timedelta64(1, "ns"),
-        }
-
-        with monkeypatch.context() as m, tm.assert_produces_warning(
-            PerformanceWarning
-        ) as ws:
-            m.setattr(compress_module, "decompress", decompress)
-
-            with catch_warnings():
-                filterwarnings("ignore", category=FutureWarning)
-                i_rec = self.encode_decode(self.frame, compress=compress)
-                for k in self.frame.keys():
-
-                    value = i_rec[k]
-                    expected = self.frame[k]
-                    assert_frame_equal(value, expected)
-                    # make sure that we can write to the new frames even though
-                    # we needed to copy the data
-                    for block in value._data.blocks:
-                        assert block.values.flags.writeable
-                        # mutate the data in some way
-                        block.values[0] += rhs[block.dtype]
-
-        for w in ws:
-            # check the messages from our warnings
-            assert str(w.message) == (
-                "copying data after decompressing; "
-                "this may mean that decompress is "
-                "caching its result"
-            )
-
-        for buf, control_buf in zip(not_garbage, control):
-            # make sure none of our mutations above affected the
-            # original buffers
-            assert buf == control_buf
-
-    def test_compression_warns_when_decompress_caches_zlib(self, monkeypatch):
-        if not _ZLIB_INSTALLED:
-            pytest.skip("no zlib")
-        self._test_compression_warns_when_decompress_caches(monkeypatch, "zlib")
-
-    def test_compression_warns_when_decompress_caches_blosc(self, monkeypatch):
-        if not _BLOSC_INSTALLED:
-            pytest.skip("no blosc")
-        self._test_compression_warns_when_decompress_caches(monkeypatch, "blosc")
-
-    def _test_small_strings_no_warn(self, compress):
-        empty = np.array([], dtype="uint8")
-        with tm.assert_produces_warning(None):
-            with catch_warnings():
-                filterwarnings("ignore", category=FutureWarning)
-                empty_unpacked = self.encode_decode(empty, compress=compress)
-
-        tm.assert_numpy_array_equal(empty_unpacked, empty)
-        assert empty_unpacked.flags.writeable
-
-        char = np.array([ord(b"a")], dtype="uint8")
-        with tm.assert_produces_warning(None):
-            with catch_warnings():
-                filterwarnings("ignore", category=FutureWarning)
-                char_unpacked = self.encode_decode(char, compress=compress)
-
-        tm.assert_numpy_array_equal(char_unpacked, char)
-        assert char_unpacked.flags.writeable
-        # if this test fails I am sorry because the interpreter is now in a
-        # bad state where b'a' points to 98 == ord(b'b').
-        char_unpacked[0] = ord(b"b")
-
-        # we compare the ord of bytes b'a' with unicode 'a' because the should
-        # always be the same (unless we were able to mutate the shared
-        # character singleton in which case ord(b'a') == ord(b'b').
-        assert ord(b"a") == ord("a")
-        tm.assert_numpy_array_equal(char_unpacked, np.array([ord(b"b")], dtype="uint8"))
-
-    def test_small_strings_no_warn_zlib(self):
-        if not _ZLIB_INSTALLED:
-            pytest.skip("no zlib")
-        self._test_small_strings_no_warn("zlib")
-
-    def test_small_strings_no_warn_blosc(self):
-        if not _BLOSC_INSTALLED:
-            pytest.skip("no blosc")
-        self._test_small_strings_no_warn("blosc")
-
-    def test_readonly_axis_blosc(self):
-        # GH11880
-        if not _BLOSC_INSTALLED:
-            pytest.skip("no blosc")
-        df1 = DataFrame({"A": list("abcd")})
-        df2 = DataFrame(df1, index=[1.0, 2.0, 3.0, 4.0])
-        assert 1 in self.encode_decode(df1["A"], compress="blosc")
-        assert 1.0 in self.encode_decode(df2["A"], compress="blosc")
-
-    def test_readonly_axis_zlib(self):
-        # GH11880
-        df1 = DataFrame({"A": list("abcd")})
-        df2 = DataFrame(df1, index=[1.0, 2.0, 3.0, 4.0])
-        assert 1 in self.encode_decode(df1["A"], compress="zlib")
-        assert 1.0 in self.encode_decode(df2["A"], compress="zlib")
-
-    def test_readonly_axis_blosc_to_sql(self):
-        # GH11880
-        if not _BLOSC_INSTALLED:
-            pytest.skip("no blosc")
-        if not self._SQLALCHEMY_INSTALLED:
-            pytest.skip("no sqlalchemy")
-        expected = DataFrame({"A": list("abcd")})
-        df = self.encode_decode(expected, compress="blosc")
-        eng = self._create_sql_engine("sqlite:///:memory:")
-        df.to_sql("test", eng, if_exists="append")
-        result = pandas.read_sql_table("test", eng, index_col="index")
-        result.index.names = [None]
-        assert_frame_equal(expected, result)
-
-    def test_readonly_axis_zlib_to_sql(self):
-        # GH11880
-        if not _ZLIB_INSTALLED:
-            pytest.skip("no zlib")
-        if not self._SQLALCHEMY_INSTALLED:
-            pytest.skip("no sqlalchemy")
-        expected = DataFrame({"A": list("abcd")})
-        df = self.encode_decode(expected, compress="zlib")
-        eng = self._create_sql_engine("sqlite:///:memory:")
-        df.to_sql("test", eng, if_exists="append")
-        result = pandas.read_sql_table("test", eng, index_col="index")
-        result.index.names = [None]
-        assert_frame_equal(expected, result)
-
-
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestEncoding(TestPackers):
-    def setup_method(self, method):
-        super().setup_method(method)
-        data = {
-            "A": ["\u2019"] * 1000,
-            "B": np.arange(1000, dtype=np.int32),
-            "C": list(100 * "abcdefghij"),
-            "D": date_range(datetime.datetime(2015, 4, 1), periods=1000),
-            "E": [datetime.timedelta(days=x) for x in range(1000)],
-            "G": [400] * 1000,
-        }
-        self.frame = {
-            "float": DataFrame({k: data[k] for k in ["A", "A"]}),
-            "int": DataFrame({k: data[k] for k in ["B", "B"]}),
-            "mixed": DataFrame(data),
-        }
-        self.utf_encodings = ["utf8", "utf16", "utf32"]
-
-    def test_utf(self):
-        # GH10581
-        for encoding in self.utf_encodings:
-            for frame in self.frame.values():
-                result = self.encode_decode(frame, encoding=encoding)
-                assert_frame_equal(result, frame)
-
-    def test_default_encoding(self):
-        for frame in self.frame.values():
-            result = frame.to_msgpack()
-            expected = frame.to_msgpack(encoding="utf8")
-            assert result == expected
-            result = self.encode_decode(frame)
-            assert_frame_equal(result, frame)
-
-
-files = glob.glob(
-    os.path.join(os.path.dirname(__file__), "data", "legacy_msgpack", "*", "*.msgpack")
-)
-
-
-@pytest.fixture(params=files)
-def legacy_packer(request, datapath):
-    return datapath(request.param)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:.*msgpack:FutureWarning")
-class TestMsgpack:
-    """
-    How to add msgpack tests:
-
-    1. Install pandas version intended to output the msgpack.
-    2. Execute "generate_legacy_storage_files.py" to create the msgpack.
-    $ python generate_legacy_storage_files.py <output_dir> msgpack
-
-    3. Move the created pickle to "data/legacy_msgpack/<version>" directory.
-    """
-
-    minimum_structure = {
-        "series": ["float", "int", "mixed", "ts", "mi", "dup"],
-        "frame": ["float", "int", "mixed", "mi"],
-        "index": ["int", "date", "period"],
-        "mi": ["reg2"],
-    }
-
-    def check_min_structure(self, data, version):
-        for typ, v in self.minimum_structure.items():
-
-            assert typ in data, '"{0}" not found in unpacked data'.format(typ)
-            for kind in v:
-                msg = '"{0}" not found in data["{1}"]'.format(kind, typ)
-                assert kind in data[typ], msg
-
-    def compare(self, current_data, all_data, vf, version):
-        data = read_msgpack(vf)
-
-        self.check_min_structure(data, version)
-        for typ, dv in data.items():
-            assert typ in all_data, "unpacked data contains " 'extra key "{0}"'.format(
-                typ
-            )
-            for dt, result in dv.items():
-                assert (
-                    dt in current_data[typ]
-                ), 'data["{0}"] contains extra ' 'key "{1}"'.format(typ, dt)
-                try:
-                    expected = current_data[typ][dt]
-                except KeyError:
-                    continue
-
-                # use a specific comparator
-                # if available
-                comp_method = "compare_{typ}_{dt}".format(typ=typ, dt=dt)
-                comparator = getattr(self, comp_method, None)
-                if comparator is not None:
-                    comparator(result, expected, typ, version)
-                else:
-                    check_arbitrary(result, expected)
-
-        return data
-
-    def compare_series_dt_tz(self, result, expected, typ, version):
-        tm.assert_series_equal(result, expected)
-
-    def compare_frame_dt_mixed_tzs(self, result, expected, typ, version):
-        tm.assert_frame_equal(result, expected)
-
-    def test_msgpacks_legacy(
-        self, current_packers_data, all_packers_data, legacy_packer, datapath
-    ):
-
-        version = os.path.basename(os.path.dirname(legacy_packer))
-
-        try:
-            with catch_warnings(record=True):
-                self.compare(
-                    current_packers_data, all_packers_data, legacy_packer, version
-                )
-        except ImportError:
-            # blosc not installed
-            pass
-
-    def test_msgpack_period_freq(self):
-        # https://github.com/pandas-dev/pandas/issues/24135
-        s = Series(np.random.rand(5), index=date_range("20130101", periods=5))
-        r = read_msgpack(s.to_msgpack())
-        repr(r)
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index efc2b6d6c5b3d..7ed8d8f22764c 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -10,7 +10,7 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 from pandas.io.parquet import (
     FastParquetImpl,
@@ -167,6 +167,7 @@ def compare(repeat):
             df.to_parquet(path, **write_kwargs)
             with catch_warnings(record=True):
                 actual = read_parquet(path, **read_kwargs)
+
             tm.assert_frame_equal(expected, actual, check_names=check_names)
 
     if path is None:
@@ -404,7 +405,7 @@ def test_write_ignoring_index(self, engine):
             ["one", "two", "one", "two", "one", "two", "one", "two"],
         ]
         df = pd.DataFrame(
-            {"one": [i for i in range(8)], "two": [-i for i in range(8)]}, index=arrays
+            {"one": list(range(8)), "two": [-i for i in range(8)]}, index=arrays
         )
 
         expected = df.reset_index(drop=True)
@@ -442,11 +443,12 @@ def test_duplicate_columns(self, pa):
         self.check_error_on_write(df, pa, ValueError)
 
     def test_unsupported(self, pa):
-        # period
-        df = pd.DataFrame({"a": pd.period_range("2013", freq="M", periods=3)})
-        # pyarrow 0.11 raises ArrowTypeError
-        # older pyarrows raise ArrowInvalid
-        self.check_error_on_write(df, pa, Exception)
+        if LooseVersion(pyarrow.__version__) < LooseVersion("0.15.1.dev"):
+            # period - will be supported using an extension type with pyarrow 1.0
+            df = pd.DataFrame({"a": pd.period_range("2013", freq="M", periods=3)})
+            # pyarrow 0.11 raises ArrowTypeError
+            # older pyarrows raise ArrowInvalid
+            self.check_error_on_write(df, pa, Exception)
 
         # timedelta
         df = pd.DataFrame({"a": pd.timedelta_range("1 day", periods=3)})
@@ -461,11 +463,26 @@ def test_unsupported(self, pa):
     def test_categorical(self, pa):
 
         # supported in >= 0.7.0
-        df = pd.DataFrame({"a": pd.Categorical(list("abc"))})
+        df = pd.DataFrame()
+        df["a"] = pd.Categorical(list("abcdef"))
 
-        # de-serialized as object
-        expected = df.assign(a=df.a.astype(object))
-        check_round_trip(df, pa, expected=expected)
+        # test for null, out-of-order values, and unobserved category
+        df["b"] = pd.Categorical(
+            ["bar", "foo", "foo", "bar", None, "bar"],
+            dtype=pd.CategoricalDtype(["foo", "bar", "baz"]),
+        )
+
+        # test for ordered flag
+        df["c"] = pd.Categorical(
+            ["a", "b", "c", "a", "c", "b"], categories=["b", "c", "d"], ordered=True
+        )
+
+        if LooseVersion(pyarrow.__version__) >= LooseVersion("0.15.0"):
+            check_round_trip(df, pa)
+        else:
+            # de-serialized as object for pyarrow < 0.15
+            expected = df.astype(object)
+            check_round_trip(df, pa, expected=expected)
 
     def test_s3_roundtrip(self, df_compat, s3_resource, pa):
         # GH #19134
@@ -483,26 +500,80 @@ def test_partition_cols_supported(self, pa, df_full):
             assert len(dataset.partitions.partition_names) == 2
             assert dataset.partitions.partition_names == set(partition_cols)
 
+    def test_partition_cols_string(self, pa, df_full):
+        # GH #27117
+        partition_cols = "bool"
+        partition_cols_list = [partition_cols]
+        df = df_full
+        with tm.ensure_clean_dir() as path:
+            df.to_parquet(path, partition_cols=partition_cols, compression=None)
+            import pyarrow.parquet as pq
+
+            dataset = pq.ParquetDataset(path, validate_schema=False)
+            assert len(dataset.partitions.partition_names) == 1
+            assert dataset.partitions.partition_names == set(partition_cols_list)
+
     def test_empty_dataframe(self, pa):
         # GH #27339
         df = pd.DataFrame()
         check_round_trip(df, pa)
 
-    @td.skip_if_no("pyarrow", min_version="0.14.1.dev")
-    def test_nullable_integer(self, pa):
-        df = pd.DataFrame({"a": pd.Series([1, 2, 3], dtype="Int64")})
-        # currently de-serialized as plain int
-        expected = df.assign(a=df.a.astype("int64"))
+    def test_write_with_schema(self, pa):
+        import pyarrow
+
+        df = pd.DataFrame({"x": [0, 1]})
+        schema = pyarrow.schema([pyarrow.field("x", type=pyarrow.bool_())])
+        out_df = df.astype(bool)
+        check_round_trip(df, pa, write_kwargs={"schema": schema}, expected=out_df)
+
+    @td.skip_if_no("pyarrow", min_version="0.15.0")
+    def test_additional_extension_arrays(self, pa):
+        # test additional ExtensionArrays that are supported through the
+        # __arrow_array__ protocol
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype="Int64"),
+                "b": pd.Series(["a", None, "c"], dtype="string"),
+            }
+        )
+        if LooseVersion(pyarrow.__version__) >= LooseVersion("0.15.1.dev"):
+            expected = df
+        else:
+            # de-serialized as plain int / object
+            expected = df.assign(a=df.a.astype("int64"), b=df.b.astype("object"))
         check_round_trip(df, pa, expected=expected)
 
         df = pd.DataFrame({"a": pd.Series([1, 2, 3, None], dtype="Int64")})
-        # if missing values currently de-serialized as float
-        expected = df.assign(a=df.a.astype("float64"))
+        if LooseVersion(pyarrow.__version__) >= LooseVersion("0.15.1.dev"):
+            expected = df
+        else:
+            # if missing values in integer, currently de-serialized as float
+            expected = df.assign(a=df.a.astype("float64"))
         check_round_trip(df, pa, expected=expected)
 
+    @td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+    def test_additional_extension_types(self, pa):
+        # test additional ExtensionArrays that are supported through the
+        # __arrow_array__ protocol + by defining a custom ExtensionType
+        df = pd.DataFrame(
+            {
+                # Arrow does not yet support struct in writing to Parquet (ARROW-1644)
+                # "c": pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2), (3, 4)]),
+                "d": pd.period_range("2012-01-01", periods=3, freq="D"),
+            }
+        )
+        check_round_trip(df, pa)
+
+    @td.skip_if_no("pyarrow", min_version="0.14")
+    def test_timestamp_nanoseconds(self, pa):
+        # with version 2.0, pyarrow defaults to writing the nanoseconds, so
+        # this should work without error
+        df = pd.DataFrame({"a": pd.date_range("2017-01-01", freq="1n", periods=10)})
+        check_round_trip(df, pa, write_kwargs={"version": "2.0"})
+
 
 class TestParquetFastParquet(Base):
-    @td.skip_if_no("fastparquet", min_version="0.2.1")
+    @td.skip_if_no("fastparquet", min_version="0.3.2")
     def test_basic(self, fp, df_full):
         df = df_full
 
@@ -565,6 +636,23 @@ def test_partition_cols_supported(self, fp, df_full):
             actual_partition_cols = fastparquet.ParquetFile(path, False).cats
             assert len(actual_partition_cols) == 2
 
+    def test_partition_cols_string(self, fp, df_full):
+        # GH #27117
+        partition_cols = "bool"
+        df = df_full
+        with tm.ensure_clean_dir() as path:
+            df.to_parquet(
+                path,
+                engine="fastparquet",
+                partition_cols=partition_cols,
+                compression=None,
+            )
+            assert os.path.exists(path)
+            import fastparquet  # noqa: F811
+
+            actual_partition_cols = fastparquet.ParquetFile(path, False).cats
+            assert len(actual_partition_cols) == 1
+
     def test_partition_on_supported(self, fp, df_full):
         # GH #23283
         partition_cols = ["bool", "int"]
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index 30555508f0998..78b630bb5ada1 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -11,6 +11,7 @@
 3. Move the created pickle to "data/legacy_pickle/<version>" directory.
 """
 import bz2
+import datetime
 import glob
 import gzip
 import os
@@ -22,10 +23,11 @@
 import pytest
 
 from pandas.compat import _get_lzma_file, _import_lzma, is_platform_little_endian
+import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.offsets import Day, MonthEnd
 
@@ -49,8 +51,8 @@ def compare_element(result, expected, typ, version=None):
         return
 
     if typ.startswith("sp_"):
-        comparator = getattr(tm, "assert_{typ}_equal".format(typ=typ))
-        comparator(result, expected, exact_indices=False)
+        comparator = tm.assert_equal
+        comparator(result, expected)
     elif typ == "timestamp":
         if expected is pd.NaT:
             assert result is pd.NaT
@@ -58,9 +60,7 @@ def compare_element(result, expected, typ, version=None):
             assert result == expected
             assert result.freq == expected.freq
     else:
-        comparator = getattr(
-            tm, "assert_{typ}_equal".format(typ=typ), tm.assert_almost_equal
-        )
+        comparator = getattr(tm, f"assert_{typ}_equal", tm.assert_almost_equal)
         comparator(result, expected)
 
 
@@ -75,17 +75,13 @@ def compare(data, vf, version):
 
             # use a specific comparator
             # if available
-            comparator = "compare_{typ}_{dt}".format(typ=typ, dt=dt)
+            comparator = f"compare_{typ}_{dt}"
 
             comparator = m.get(comparator, m["compare_element"])
             comparator(result, expected, typ, version)
     return data
 
 
-def compare_sp_series_ts(res, exp, typ, version):
-    tm.assert_sp_series_equal(res, exp)
-
-
 def compare_series_ts(result, expected, typ, version):
     # GH 7748
     tm.assert_series_equal(result, expected)
@@ -134,10 +130,6 @@ def compare_index_period(result, expected, typ, version):
     tm.assert_index_equal(result.shift(2), expected.shift(2))
 
 
-def compare_sp_frame_float(result, expected, typ, version):
-    tm.assert_sp_frame_equal(result, expected)
-
-
 files = glob.glob(
     os.path.join(os.path.dirname(__file__), "data", "legacy_pickle", "*", "*.pickle")
 )
@@ -151,7 +143,6 @@ def legacy_pickle(request, datapath):
 # ---------------------
 # tests
 # ---------------------
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 def test_pickles(current_pickle_data, legacy_pickle):
     if not is_platform_little_endian():
         pytest.skip("known failure on non-little endian")
@@ -162,7 +153,6 @@ def test_pickles(current_pickle_data, legacy_pickle):
         compare(current_pickle_data, legacy_pickle, version)
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 def test_round_trip_current(current_pickle_data):
     def python_pickler(obj, path):
         with open(path, "wb") as fh:
@@ -194,38 +184,6 @@ def python_unpickler(path):
                     compare_element(result, expected, typ)
 
 
-def test_pickle_v0_14_1(datapath):
-
-    cat = pd.Categorical(
-        values=["a", "b", "c"], ordered=False, categories=["a", "b", "c", "d"]
-    )
-    pickle_path = datapath("io", "data", "categorical_0_14_1.pickle")
-    # This code was executed once on v0.14.1 to generate the pickle:
-    #
-    # cat = Categorical(labels=np.arange(3), levels=['a', 'b', 'c', 'd'],
-    #                   name='foobar')
-    # with open(pickle_path, 'wb') as f: pickle.dump(cat, f)
-    #
-    tm.assert_categorical_equal(cat, pd.read_pickle(pickle_path))
-
-
-def test_pickle_v0_15_2(datapath):
-    # ordered -> _ordered
-    # GH 9347
-
-    cat = pd.Categorical(
-        values=["a", "b", "c"], ordered=False, categories=["a", "b", "c", "d"]
-    )
-    pickle_path = datapath("io", "data", "categorical_0_15_2.pickle")
-    # This code was executed once on v0.15.2 to generate the pickle:
-    #
-    # cat = Categorical(labels=np.arange(3), levels=['a', 'b', 'c', 'd'],
-    #                   name='foobar')
-    # with open(pickle_path, 'wb') as f: pickle.dump(cat, f)
-    #
-    tm.assert_categorical_equal(cat, pd.read_pickle(pickle_path))
-
-
 def test_pickle_path_pathlib():
     df = tm.makeDataFrame()
     result = tm.round_trip_pathlib(df.to_pickle, pd.read_pickle)
@@ -238,6 +196,35 @@ def test_pickle_path_localpath():
     tm.assert_frame_equal(df, result)
 
 
+@pytest.mark.xfail(reason="GitHub issue #31310", strict=False)
+def test_legacy_sparse_warning(datapath):
+    """
+
+    Generated with
+
+    >>> df = pd.DataFrame({"A": [1, 2, 3, 4], "B": [0, 0, 1, 1]}).to_sparse()
+    >>> df.to_pickle("pandas/tests/io/data/pickle/sparseframe-0.20.3.pickle.gz",
+    ...              compression="gzip")
+
+    >>> s = df['B']
+    >>> s.to_pickle("pandas/tests/io/data/pickle/sparseseries-0.20.3.pickle.gz",
+    ...             compression="gzip")
+    """
+    with tm.assert_produces_warning(FutureWarning):
+        simplefilter("ignore", DeprecationWarning)  # from boto
+        pd.read_pickle(
+            datapath("io", "data", "pickle", "sparseseries-0.20.3.pickle.gz"),
+            compression="gzip",
+        )
+
+    with tm.assert_produces_warning(FutureWarning):
+        simplefilter("ignore", DeprecationWarning)  # from boto
+        pd.read_pickle(
+            datapath("io", "data", "pickle", "sparseframe-0.20.3.pickle.gz"),
+            compression="gzip",
+        )
+
+
 # ---------------------
 # test pickle compression
 # ---------------------
@@ -245,7 +232,7 @@ def test_pickle_path_localpath():
 
 @pytest.fixture
 def get_random_path():
-    return "__{}__.pickle".format(tm.rands(10))
+    return f"__{tm.rands(10)}__.pickle"
 
 
 class TestCompression:
@@ -273,7 +260,7 @@ def compress_file(self, src_path, dest_path, compression):
         elif compression == "xz":
             f = _get_lzma_file(lzma)(dest_path, "w")
         else:
-            msg = "Unrecognized compression type: {}".format(compression)
+            msg = f"Unrecognized compression type: {compression}"
             raise ValueError(msg)
 
         if compression != "zip":
@@ -393,3 +380,124 @@ def test_read(self, protocol, get_random_path):
             df.to_pickle(path, protocol=protocol)
             df2 = pd.read_pickle(path)
             tm.assert_frame_equal(df, df2)
+
+
+def test_unicode_decode_error(datapath):
+    # pickle file written with py27, should be readable without raising
+    #  UnicodeDecodeError, see GH#28645
+    path = datapath("io", "data", "pickle", "test_py27.pkl")
+    df = pd.read_pickle(path)
+
+    # just test the columns are correct since the values are random
+    excols = pd.Index(["a", "b", "c"])
+    tm.assert_index_equal(df.columns, excols)
+
+
+# ---------------------
+# tests for buffer I/O
+# ---------------------
+
+
+def test_pickle_buffer_roundtrip():
+    with tm.ensure_clean() as path:
+        df = tm.makeDataFrame()
+        with open(path, "wb") as fh:
+            df.to_pickle(fh)
+        with open(path, "rb") as fh:
+            result = pd.read_pickle(fh)
+        tm.assert_frame_equal(df, result)
+
+
+# ---------------------
+# tests for URL I/O
+# ---------------------
+
+
+@pytest.mark.parametrize(
+    "mockurl", ["http://url.com", "ftp://test.com", "http://gzip.com"]
+)
+def test_pickle_generalurl_read(monkeypatch, mockurl):
+    def python_pickler(obj, path):
+        with open(path, "wb") as fh:
+            pickle.dump(obj, fh, protocol=-1)
+
+    class MockReadResponse:
+        def __init__(self, path):
+            self.file = open(path, "rb")
+            if "gzip" in path:
+                self.headers = {"Content-Encoding": "gzip"}
+            else:
+                self.headers = {"Content-Encoding": None}
+
+        def read(self):
+            return self.file.read()
+
+        def close(self):
+            return self.file.close()
+
+    with tm.ensure_clean() as path:
+
+        def mock_urlopen_read(*args, **kwargs):
+            return MockReadResponse(path)
+
+        df = tm.makeDataFrame()
+        python_pickler(df, path)
+        monkeypatch.setattr("urllib.request.urlopen", mock_urlopen_read)
+        result = pd.read_pickle(mockurl)
+        tm.assert_frame_equal(df, result)
+
+
+@td.skip_if_no("gcsfs")
+@pytest.mark.parametrize("mockurl", ["gs://gcs.com", "gcs://gcs.com"])
+def test_pickle_gcsurl_roundtrip(monkeypatch, mockurl):
+    with tm.ensure_clean() as path:
+
+        class MockGCSFileSystem:
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def open(self, *args):
+                mode = args[1] or None
+                f = open(path, mode)
+                return f
+
+        monkeypatch.setattr("gcsfs.GCSFileSystem", MockGCSFileSystem)
+        df = tm.makeDataFrame()
+        df.to_pickle(mockurl)
+        result = pd.read_pickle(mockurl)
+        tm.assert_frame_equal(df, result)
+
+
+@td.skip_if_no("s3fs")
+@pytest.mark.parametrize("mockurl", ["s3://s3.com", "s3n://s3.com", "s3a://s3.com"])
+def test_pickle_s3url_roundtrip(monkeypatch, mockurl):
+    with tm.ensure_clean() as path:
+
+        class MockS3FileSystem:
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def open(self, *args):
+                mode = args[1] or None
+                f = open(path, mode)
+                return f
+
+        monkeypatch.setattr("s3fs.S3FileSystem", MockS3FileSystem)
+        df = tm.makeDataFrame()
+        df.to_pickle(mockurl)
+        result = pd.read_pickle(mockurl)
+        tm.assert_frame_equal(df, result)
+
+
+class MyTz(datetime.tzinfo):
+    def __init__(self):
+        pass
+
+
+def test_read_pickle_with_subclass():
+    # GH 12163
+    expected = pd.Series(dtype=object), MyTz()
+    result = tm.round_trip_pickle(expected)
+
+    tm.assert_series_equal(result[0], expected[0])
+    assert isinstance(result[1], MyTz)
diff --git a/pandas/tests/io/test_spss.py b/pandas/tests/io/test_spss.py
index b7a62b7ba431b..013f56f83c5ec 100644
--- a/pandas/tests/io/test_spss.py
+++ b/pandas/tests/io/test_spss.py
@@ -2,14 +2,14 @@
 import pytest
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 pyreadstat = pytest.importorskip("pyreadstat")
 
 
 def test_spss_labelled_num(datapath):
     # test file from the Haven project (https://haven.tidyverse.org/)
-    fname = datapath("io", "data", "labelled-num.sav")
+    fname = datapath("io", "data", "spss", "labelled-num.sav")
 
     df = pd.read_spss(fname, convert_categoricals=True)
     expected = pd.DataFrame({"VAR00002": "This is one"}, index=[0])
@@ -23,7 +23,7 @@ def test_spss_labelled_num(datapath):
 
 def test_spss_labelled_num_na(datapath):
     # test file from the Haven project (https://haven.tidyverse.org/)
-    fname = datapath("io", "data", "labelled-num-na.sav")
+    fname = datapath("io", "data", "spss", "labelled-num-na.sav")
 
     df = pd.read_spss(fname, convert_categoricals=True)
     expected = pd.DataFrame({"VAR00002": ["This is one", None]})
@@ -37,7 +37,7 @@ def test_spss_labelled_num_na(datapath):
 
 def test_spss_labelled_str(datapath):
     # test file from the Haven project (https://haven.tidyverse.org/)
-    fname = datapath("io", "data", "labelled-str.sav")
+    fname = datapath("io", "data", "spss", "labelled-str.sav")
 
     df = pd.read_spss(fname, convert_categoricals=True)
     expected = pd.DataFrame({"gender": ["Male", "Female"]})
@@ -51,7 +51,7 @@ def test_spss_labelled_str(datapath):
 
 def test_spss_umlauts(datapath):
     # test file from the Haven project (https://haven.tidyverse.org/)
-    fname = datapath("io", "data", "umlauts.sav")
+    fname = datapath("io", "data", "spss", "umlauts.sav")
 
     df = pd.read_spss(fname, convert_categoricals=True)
     expected = pd.DataFrame(
@@ -67,7 +67,7 @@ def test_spss_umlauts(datapath):
 
 def test_spss_usecols(datapath):
     # usecols must be list-like
-    fname = datapath("io", "data", "labelled-num.sav")
+    fname = datapath("io", "data", "spss", "labelled-num.sav")
 
     with pytest.raises(TypeError, match="usecols must be list-like."):
         pd.read_spss(fname, usecols="VAR00002")
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 89bc98b5a1006..0ad9f2c1e941f 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -41,7 +41,7 @@
     to_datetime,
     to_timedelta,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 import pandas.io.sql as sql
 from pandas.io.sql import read_sql_query, read_sql_table
@@ -215,9 +215,7 @@ def teardown_method(self, method):
 class MySQLMixIn(MixInBase):
     def drop_table(self, table_name):
         cur = self.conn.cursor()
-        cur.execute(
-            "DROP TABLE IF EXISTS {}".format(sql._get_valid_mysql_name(table_name))
-        )
+        cur.execute(f"DROP TABLE IF EXISTS {sql._get_valid_mysql_name(table_name)}")
         self.conn.commit()
 
     def _get_all_tables(self):
@@ -237,7 +235,7 @@ def _close_conn(self):
 class SQLiteMixIn(MixInBase):
     def drop_table(self, table_name):
         self.conn.execute(
-            "DROP TABLE IF EXISTS {}".format(sql._get_valid_sqlite_name(table_name))
+            f"DROP TABLE IF EXISTS {sql._get_valid_sqlite_name(table_name)}"
         )
         self.conn.commit()
 
@@ -275,7 +273,7 @@ def _get_exec(self):
         else:
             return self.conn.cursor()
 
-    @pytest.fixture(params=[("io", "data", "iris.csv")])
+    @pytest.fixture(params=[("data", "iris.csv")])
     def load_iris_data(self, datapath, request):
         import io
 
@@ -405,11 +403,7 @@ def _load_raw_sql(self):
     def _count_rows(self, table_name):
         result = (
             self._get_exec()
-            .execute(
-                "SELECT count(*) AS count_1 FROM {table_name}".format(
-                    table_name=table_name
-                )
-            )
+            .execute(f"SELECT count(*) AS count_1 FROM {table_name}")
             .fetchone()
         )
         return result[0]
@@ -539,13 +533,16 @@ def _transaction_test(self):
         with self.pandasSQL.run_transaction() as trans:
             trans.execute("CREATE TABLE test_trans (A INT, B TEXT)")
 
+        class DummyException(Exception):
+            pass
+
         # Make sure when transaction is rolled back, no rows get inserted
         ins_sql = "INSERT INTO test_trans (A,B) VALUES (1, 'blah')"
         try:
             with self.pandasSQL.run_transaction() as trans:
                 trans.execute(ins_sql)
-                raise Exception("error")
-        except Exception:
+                raise DummyException("error")
+        except DummyException:
             # ignore raised exception
             pass
         res = self.pandasSQL.read_query("SELECT * FROM test_trans")
@@ -580,7 +577,7 @@ class _TestSQLApi(PandasSQLTest):
     """
 
     flavor = "sqlite"
-    mode = None
+    mode: str
 
     def setup_connect(self):
         self.conn = self.connect()
@@ -1204,7 +1201,7 @@ def _get_sqlite_column_type(self, schema, column):
         for col in schema.split("\n"):
             if col.split()[0].strip('""') == column:
                 return col.split()[1]
-        raise ValueError("Column {column} not found".format(column=column))
+        raise ValueError(f"Column {column} not found")
 
     def test_sqlite_type_mapping(self):
 
@@ -1231,7 +1228,7 @@ class _TestSQLAlchemy(SQLAlchemyMixIn, PandasSQLTest):
 
     """
 
-    flavor = None
+    flavor: str
 
     @pytest.fixture(autouse=True, scope="class")
     def setup_class(cls):
@@ -1269,7 +1266,7 @@ def setup_connect(self):
             # to test if connection can be made:
             self.conn.connect()
         except sqlalchemy.exc.OperationalError:
-            pytest.skip("Can't connect to {0} server".format(self.flavor))
+            pytest.skip(f"Can't connect to {self.flavor} server")
 
     def test_read_sql(self):
         self._read_sql_iris()
@@ -1411,7 +1408,7 @@ def check(col):
 
             else:
                 raise AssertionError(
-                    "DateCol loaded with incorrect type -> {0}".format(col.dtype)
+                    f"DateCol loaded with incorrect type -> {col.dtype}"
                 )
 
         # GH11216
@@ -2048,15 +2045,13 @@ def psql_insert_copy(table, conn, keys, data_iter):
                 writer.writerows(data_iter)
                 s_buf.seek(0)
 
-                columns = ", ".join('"{}"'.format(k) for k in keys)
+                columns = ", ".join(f'"{k}"' for k in keys)
                 if table.schema:
-                    table_name = "{}.{}".format(table.schema, table.name)
+                    table_name = f"{table.schema}.{table.name}"
                 else:
                     table_name = table.name
 
-                sql_query = "COPY {} ({}) FROM STDIN WITH CSV".format(
-                    table_name, columns
-                )
+                sql_query = f"COPY {table_name} ({columns}) FROM STDIN WITH CSV"
                 cur.copy_expert(sql=sql_query, file=s_buf)
 
         expected = DataFrame({"col1": [1, 2], "col2": [0.1, 0.2], "col3": ["a", "n"]})
@@ -2153,6 +2148,10 @@ def test_to_sql_replace(self):
     def test_to_sql_append(self):
         self._to_sql_append()
 
+    def test_to_sql_method_multi(self):
+        # GH 29921
+        self._to_sql(method="multi")
+
     def test_create_and_drop_table(self):
         temp_frame = DataFrame(
             {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
@@ -2196,14 +2195,12 @@ def test_datetime_time(self):
     def _get_index_columns(self, tbl_name):
         ixs = sql.read_sql_query(
             "SELECT * FROM sqlite_master WHERE type = 'index' "
-            + "AND tbl_name = '{tbl_name}'".format(tbl_name=tbl_name),
+            + f"AND tbl_name = '{tbl_name}'",
             self.conn,
         )
         ix_cols = []
         for ix_name in ixs.name:
-            ix_info = sql.read_sql_query(
-                "PRAGMA index_info({ix_name})".format(ix_name=ix_name), self.conn
-            )
+            ix_info = sql.read_sql_query(f"PRAGMA index_info({ix_name})", self.conn)
             ix_cols.append(ix_info.name.tolist())
         return ix_cols
 
@@ -2214,15 +2211,11 @@ def test_transactions(self):
         self._transaction_test()
 
     def _get_sqlite_column_type(self, table, column):
-        recs = self.conn.execute("PRAGMA table_info({table})".format(table=table))
+        recs = self.conn.execute(f"PRAGMA table_info({table})")
         for cid, name, ctype, not_null, default, pk in recs:
             if name == column:
                 return ctype
-        raise ValueError(
-            "Table {table}, column {column} not found".format(
-                table=table, column=column
-            )
-        )
+        raise ValueError(f"Table {table}, column {column} not found")
 
     def test_dtype(self):
         if self.flavor == "mysql":
@@ -2292,7 +2285,7 @@ def test_illegal_names(self):
             sql.table_exists(weird_name, self.conn)
 
             df2 = DataFrame([[1, 2], [3, 4]], columns=["a", weird_name])
-            c_tbl = "test_weird_col_name{ndx:d}".format(ndx=ndx)
+            c_tbl = f"test_weird_col_name{ndx:d}"
             df2.to_sql(c_tbl, self.conn)
             sql.table_exists(c_tbl, self.conn)
 
@@ -2497,7 +2490,7 @@ def test_if_exists(self):
         df_if_exists_1 = DataFrame({"col1": [1, 2], "col2": ["A", "B"]})
         df_if_exists_2 = DataFrame({"col1": [3, 4, 5], "col2": ["C", "D", "E"]})
         table_name = "table_if_exists"
-        sql_select = "SELECT * FROM {table_name}".format(table_name=table_name)
+        sql_select = f"SELECT * FROM {table_name}"
 
         def clean_up(test_table_to_drop):
             """
@@ -2785,7 +2778,7 @@ def test_if_exists(self):
         df_if_exists_1 = DataFrame({"col1": [1, 2], "col2": ["A", "B"]})
         df_if_exists_2 = DataFrame({"col1": [3, 4, 5], "col2": ["C", "D", "E"]})
         table_name = "table_if_exists"
-        sql_select = "SELECT * FROM {table_name}".format(table_name=table_name)
+        sql_select = f"SELECT * FROM {table_name}"
 
         def clean_up(test_table_to_drop):
             """
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 1e7d568602656..cb2112b481952 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1,4 +1,3 @@
-from collections import OrderedDict
 import datetime as dt
 from datetime import datetime
 import gzip
@@ -13,8 +12,8 @@
 from pandas.core.dtypes.common import is_categorical_dtype
 
 import pandas as pd
+import pandas._testing as tm
 from pandas.core.frame import DataFrame, Series
-import pandas.util.testing as tm
 
 from pandas.io.parsers import read_csv
 from pandas.io.stata import (
@@ -22,13 +21,25 @@
     PossiblePrecisionLoss,
     StataMissingValue,
     StataReader,
+    StataWriterUTF8,
     read_stata,
 )
 
 
+@pytest.fixture()
+def mixed_frame():
+    return pd.DataFrame(
+        {
+            "a": [1, 2, 3, 4],
+            "b": [1.0, 3.0, 27.0, 81.0],
+            "c": ["Atlanta", "Birmingham", "Cincinnati", "Detroit"],
+        }
+    )
+
+
 @pytest.fixture
 def dirpath(datapath):
-    return datapath("io", "data")
+    return datapath("io", "data", "stata")
 
 
 @pytest.fixture
@@ -42,7 +53,7 @@ def parsed_114(dirpath):
 class TestStata:
     @pytest.fixture(autouse=True)
     def setup_method(self, datapath):
-        self.dirpath = datapath("io", "data")
+        self.dirpath = datapath("io", "data", "stata")
         self.dta1_114 = os.path.join(self.dirpath, "stata1_114.dta")
         self.dta1_117 = os.path.join(self.dirpath, "stata1_117.dta")
 
@@ -101,6 +112,8 @@ def setup_method(self, datapath):
         self.dta24_111 = os.path.join(self.dirpath, "stata7_111.dta")
         self.dta25_118 = os.path.join(self.dirpath, "stata16_118.dta")
 
+        self.dta26_119 = os.path.join(self.dirpath, "stata1_119.dta.gz")
+
         self.stata_dates = os.path.join(self.dirpath, "stata13_dates.dta")
 
     def read_dta(self, file):
@@ -110,7 +123,7 @@ def read_dta(self, file):
     def read_csv(self, file):
         return read_csv(file, parse_dates=True)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_read_empty_dta(self, version):
         empty_ds = DataFrame(columns=["unit"])
         # GH 7369, make sure can read a 0-obs dta file
@@ -119,16 +132,6 @@ def test_read_empty_dta(self, version):
             empty_ds2 = read_stata(path)
             tm.assert_frame_equal(empty_ds, empty_ds2)
 
-    def test_data_method(self):
-        # Minimal testing of legacy data method
-        with StataReader(self.dta1_114) as rdr:
-            with tm.assert_produces_warning(UserWarning):
-                parsed_114_data = rdr.data()
-
-        with StataReader(self.dta1_114) as rdr:
-            parsed_114_read = rdr.read()
-        tm.assert_frame_equal(parsed_114_data, parsed_114_read)
-
     @pytest.mark.parametrize("file", ["dta1_114", "dta1_117"])
     def test_read_dta1(self, file):
 
@@ -340,7 +343,7 @@ def test_write_dta6(self):
                 check_index_type=False,
             )
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_read_write_dta10(self, version):
         original = DataFrame(
             data=[["string", "object", 1, 1.1, np.datetime64("2003-12-25")]],
@@ -376,13 +379,12 @@ def test_write_preserves_original(self):
             df.to_stata(path, write_index=False)
         tm.assert_frame_equal(df, df_copy)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_encoding(self, version):
 
         # GH 4626, proper encoding handling
         raw = read_stata(self.dta_encoding)
-        with tm.assert_produces_warning(FutureWarning):
-            encoded = read_stata(self.dta_encoding, encoding="latin-1")
+        encoded = read_stata(self.dta_encoding)
         result = encoded.kreis1849[0]
 
         expected = raw.kreis1849[0]
@@ -390,10 +392,7 @@ def test_encoding(self, version):
         assert isinstance(result, str)
 
         with tm.ensure_clean() as path:
-            with tm.assert_produces_warning(FutureWarning):
-                encoded.to_stata(
-                    path, write_index=False, version=version, encoding="latin-1"
-                )
+            encoded.to_stata(path, write_index=False, version=version)
             reread_encoded = read_stata(path)
             tm.assert_frame_equal(encoded, reread_encoded)
 
@@ -421,7 +420,7 @@ def test_read_write_dta11(self):
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), formatted)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_read_write_dta12(self, version):
         original = DataFrame(
             [(1, 2, 3, 4, 5, 6)],
@@ -473,7 +472,7 @@ def test_read_write_dta13(self):
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), formatted)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     @pytest.mark.parametrize(
         "file", ["dta14_113", "dta14_114", "dta14_115", "dta14_117"]
     )
@@ -516,7 +515,7 @@ def test_read_write_reread_dta15(self, file):
 
         tm.assert_frame_equal(expected, parsed)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_timestamp_and_label(self, version):
         original = DataFrame([(1,)], columns=["variable"])
         time_stamp = datetime(2000, 2, 29, 14, 21)
@@ -530,7 +529,7 @@ def test_timestamp_and_label(self, version):
                 assert reader.time_stamp == "29 Feb 2000 14:21"
                 assert reader.data_label == data_label
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_invalid_timestamp(self, version):
         original = DataFrame([(1,)], columns=["variable"])
         time_stamp = "01 Jan 2000, 00:00:00"
@@ -554,7 +553,7 @@ def test_numeric_column_names(self):
             written_and_read_again.columns = map(convert_col_name, columns)
             tm.assert_frame_equal(original, written_and_read_again)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_nan_to_missing_value(self, version):
         s1 = Series(np.arange(4.0), dtype=np.float32)
         s2 = Series(np.arange(4.0), dtype=np.float64)
@@ -674,7 +673,7 @@ def test_write_missing_strings(self):
             written_and_read_again = self.read_dta(path)
             tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     @pytest.mark.parametrize("byteorder", [">", "<"])
     def test_bool_uint(self, byteorder, version):
         s0 = Series([0, 1, True], dtype=np.bool)
@@ -749,10 +748,10 @@ def test_excessively_long_string(self):
             )
         original = DataFrame(s)
         msg = (
-            r"Fixed width strings in Stata \.dta files are limited to 244"
-            r" \(or fewer\)\ncharacters\.  Column 's500' does not satisfy"
-            r" this restriction\. Use the\n'version=117' parameter to write"
-            r" the newer \(Stata 13 and later\) format\."
+            r"Fixed width strings in Stata \.dta files are limited to 244 "
+            r"\(or fewer\)\ncharacters\.  Column 's500' does not satisfy "
+            r"this restriction\. Use the\n'version=117' parameter to write "
+            r"the newer \(Stata 13 and later\) format\."
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
@@ -920,7 +919,7 @@ def test_drop_column(self):
             columns = ["byte_", "int_", "long_", "not_found"]
             read_stata(self.dta15_117, convert_dates=True, columns=columns)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     @pytest.mark.filterwarnings(
         "ignore:\\nStata value:pandas.io.stata.ValueLabelTypeMismatch"
     )
@@ -980,8 +979,8 @@ def test_categorical_warnings_and_errors(self):
         )
         with tm.ensure_clean() as path:
             msg = (
-                "Stata value labels for a single variable must have"
-                r" a combined length less than 32,000 characters\."
+                "Stata value labels for a single variable must have "
+                r"a combined length less than 32,000 characters\."
             )
             with pytest.raises(ValueError, match=msg):
                 original.to_stata(path)
@@ -997,7 +996,7 @@ def test_categorical_warnings_and_errors(self):
             original.to_stata(path)
             # should get a warning for mixed content
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_categorical_with_stata_missing_values(self, version):
         values = [["a" + str(i)] for i in range(120)]
         values.append([np.nan])
@@ -1031,7 +1030,7 @@ def test_categorical_order(self, file):
                 cols.append((col, pd.Categorical.from_codes(codes, labels)))
             else:
                 cols.append((col, pd.Series(labels, dtype=np.float32)))
-        expected = DataFrame.from_dict(OrderedDict(cols))
+        expected = DataFrame.from_dict(dict(cols))
 
         # Read with and with out categoricals, ensure order is identical
         file = getattr(self, file)
@@ -1233,20 +1232,13 @@ def test_read_chunks_columns(self):
                 tm.assert_frame_equal(from_frame, chunk, check_dtype=False)
                 pos += chunksize
 
-    @pytest.mark.parametrize("version", [114, 117])
-    def test_write_variable_labels(self, version):
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_write_variable_labels(self, version, mixed_frame):
         # GH 13631, add support for writing variable labels
-        original = pd.DataFrame(
-            {
-                "a": [1, 2, 3, 4],
-                "b": [1.0, 3.0, 27.0, 81.0],
-                "c": ["Atlanta", "Birmingham", "Cincinnati", "Detroit"],
-            }
-        )
-        original.index.name = "index"
+        mixed_frame.index.name = "index"
         variable_labels = {"a": "City Rank", "b": "City Exponent", "c": "City"}
         with tm.ensure_clean() as path:
-            original.to_stata(path, variable_labels=variable_labels, version=version)
+            mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
             with StataReader(path) as sr:
                 read_labels = sr.variable_labels()
             expected_labels = {
@@ -1259,48 +1251,36 @@ def test_write_variable_labels(self, version):
 
         variable_labels["index"] = "The Index"
         with tm.ensure_clean() as path:
-            original.to_stata(path, variable_labels=variable_labels, version=version)
+            mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
             with StataReader(path) as sr:
                 read_labels = sr.variable_labels()
             assert read_labels == variable_labels
 
-    @pytest.mark.parametrize("version", [114, 117])
-    def test_invalid_variable_labels(self, version):
-        original = pd.DataFrame(
-            {
-                "a": [1, 2, 3, 4],
-                "b": [1.0, 3.0, 27.0, 81.0],
-                "c": ["Atlanta", "Birmingham", "Cincinnati", "Detroit"],
-            }
-        )
-        original.index.name = "index"
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_invalid_variable_labels(self, version, mixed_frame):
+        mixed_frame.index.name = "index"
         variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
         with tm.ensure_clean() as path:
             msg = "Variable labels must be 80 characters or fewer"
             with pytest.raises(ValueError, match=msg):
-                original.to_stata(
+                mixed_frame.to_stata(
                     path, variable_labels=variable_labels, version=version
                 )
 
+    @pytest.mark.parametrize("version", [114, 117])
+    def test_invalid_variable_label_encoding(self, version, mixed_frame):
+        mixed_frame.index.name = "index"
+        variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
         variable_labels["a"] = "invalid character Œ"
         with tm.ensure_clean() as path:
-            msg = (
-                "Variable labels must contain only characters that can be"
-                " encoded in Latin-1"
-            )
-            with pytest.raises(ValueError, match=msg):
-                original.to_stata(
+            with pytest.raises(
+                ValueError, match="Variable labels must contain only characters"
+            ):
+                mixed_frame.to_stata(
                     path, variable_labels=variable_labels, version=version
                 )
 
-    def test_write_variable_label_errors(self):
-        original = pd.DataFrame(
-            {
-                "a": [1, 2, 3, 4],
-                "b": [1.0, 3.0, 27.0, 81.0],
-                "c": ["Atlanta", "Birmingham", "Cincinnati", "Detroit"],
-            }
-        )
+    def test_write_variable_label_errors(self, mixed_frame):
         values = ["\u03A1", "\u0391", "\u039D", "\u0394", "\u0391", "\u03A3"]
 
         variable_labels_utf8 = {
@@ -1310,12 +1290,12 @@ def test_write_variable_label_errors(self):
         }
 
         msg = (
-            "Variable labels must contain only characters that can be"
-            " encoded in Latin-1"
+            "Variable labels must contain only characters that can be "
+            "encoded in Latin-1"
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
-                original.to_stata(path, variable_labels=variable_labels_utf8)
+                mixed_frame.to_stata(path, variable_labels=variable_labels_utf8)
 
         variable_labels_long = {
             "a": "City Rank",
@@ -1328,7 +1308,7 @@ def test_write_variable_label_errors(self):
         msg = "Variable labels must be 80 characters or fewer"
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
-                original.to_stata(path, variable_labels=variable_labels_long)
+                mixed_frame.to_stata(path, variable_labels=variable_labels_long)
 
     def test_default_date_conversion(self):
         # GH 12259
@@ -1394,7 +1374,7 @@ def test_unsupported_datetype(self):
                 "dates": dates,
             }
         )
-        with pytest.raises(NotImplementedError):
+        with pytest.raises(NotImplementedError, match="Data type datetime64"):
             with tm.ensure_clean() as path:
                 original.to_stata(path)
 
@@ -1438,8 +1418,8 @@ def test_out_of_range_double(self):
             }
         )
         msg = (
-            r"Column ColumnTooBig has a maximum value \(.+\)"
-            r" outside the range supported by Stata \(.+\)"
+            r"Column ColumnTooBig has a maximum value \(.+\) outside the range "
+            r"supported by Stata \(.+\)"
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
@@ -1447,8 +1427,8 @@ def test_out_of_range_double(self):
 
         df.loc[2, "ColumnTooBig"] = np.inf
         msg = (
-            "Column ColumnTooBig has a maximum value of infinity which"
-            " is outside the range supported by Stata"
+            "Column ColumnTooBig has a maximum value of infinity which is outside "
+            "the range supported by Stata"
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
@@ -1481,8 +1461,8 @@ def test_out_of_range_float(self):
 
         original.loc[2, "ColumnTooBig"] = np.inf
         msg = (
-            "Column ColumnTooBig has a maximum value of infinity which"
-            " is outside the range supported by Stata"
+            "Column ColumnTooBig has a maximum value of infinity which "
+            "is outside the range supported by Stata"
         )
         with pytest.raises(ValueError, match=msg):
             with tm.ensure_clean() as path:
@@ -1650,7 +1630,7 @@ def test_invalid_date_conversion(self):
             with pytest.raises(ValueError, match=msg):
                 original.to_stata(path, convert_dates={"wrong_name": "tc"})
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_nonfile_writing(self, version):
         # GH 21041
         bio = io.BytesIO()
@@ -1713,35 +1693,27 @@ def test_mixed_string_strl(self):
             expected = output.fillna("")
             tm.assert_frame_equal(reread, expected)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_all_none_exception(self, version):
         output = [{"none": "none", "number": 0}, {"none": None, "number": 1}]
         output = pd.DataFrame(output)
         output.loc[:, "none"] = None
         with tm.ensure_clean() as path:
-            msg = (
-                r"Column `none` cannot be exported\.\n\n"
-                "Only string-like object arrays containing all strings or a"
-                r" mix of strings and None can be exported\. Object arrays"
-                r" containing only null values are prohibited\. Other"
-                " object typescannot be exported and must first be"
-                r" converted to one of the supported types\."
-            )
-            with pytest.raises(ValueError, match=msg):
+            with pytest.raises(ValueError, match="Column `none` cannot be exported"):
                 output.to_stata(path, version=version)
 
-    @pytest.mark.parametrize("version", [114, 117])
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
     def test_invalid_file_not_written(self, version):
         content = "Here is one __�__ Another one __·__ Another one __½__"
         df = DataFrame([content], columns=["invalid"])
         with tm.ensure_clean() as path:
             msg1 = (
-                r"'latin-1' codec can't encode character '\\ufffd'"
-                r" in position 14: ordinal not in range\(256\)"
+                r"'latin-1' codec can't encode character '\\ufffd' "
+                r"in position 14: ordinal not in range\(256\)"
             )
             msg2 = (
-                "'ascii' codec can't decode byte 0xef in position 14:"
-                r" ordinal not in range\(128\)"
+                "'ascii' codec can't decode byte 0xef in position 14: "
+                r"ordinal not in range\(128\)"
             )
             with pytest.raises(UnicodeEncodeError, match=r"{}|{}".format(msg1, msg2)):
                 with tm.assert_produces_warning(ResourceWarning):
@@ -1780,3 +1752,67 @@ def test_encoding_latin1_118(self):
 
         expected = pd.DataFrame([["Düsseldorf"]] * 151, columns=["kreis1849"])
         tm.assert_frame_equal(encoded, expected)
+
+    @pytest.mark.slow
+    def test_stata_119(self):
+        # Gzipped since contains 32,999 variables and uncompressed is 20MiB
+        with gzip.open(self.dta26_119, "rb") as gz:
+            df = read_stata(gz)
+        assert df.shape == (1, 32999)
+        assert df.iloc[0, 6] == "A" * 3000
+        assert df.iloc[0, 7] == 3.14
+        assert df.iloc[0, -1] == 1
+        assert df.iloc[0, 0] == pd.Timestamp(datetime(2012, 12, 21, 21, 12, 21))
+
+    @pytest.mark.parametrize("version", [118, 119, None])
+    def test_utf8_writer(self, version):
+        cat = pd.Categorical(["a", "β", "ĉ"], ordered=True)
+        data = pd.DataFrame(
+            [
+                [1.0, 1, "ᴬ", "ᴀ relatively long ŝtring"],
+                [2.0, 2, "ᴮ", ""],
+                [3.0, 3, "ᴰ", None],
+            ],
+            columns=["a", "β", "ĉ", "strls"],
+        )
+        data["ᴐᴬᵀ"] = cat
+        variable_labels = {
+            "a": "apple",
+            "β": "ᵈᵉᵊ",
+            "ĉ": "ᴎტჄႲႳႴႶႺ",
+            "strls": "Long Strings",
+            "ᴐᴬᵀ": "",
+        }
+        data_label = "ᴅaᵀa-label"
+        data["β"] = data["β"].astype(np.int32)
+        with tm.ensure_clean() as path:
+            writer = StataWriterUTF8(
+                path,
+                data,
+                data_label=data_label,
+                convert_strl=["strls"],
+                variable_labels=variable_labels,
+                write_index=False,
+                version=version,
+            )
+            writer.write_file()
+            reread_encoded = read_stata(path)
+            # Missing is intentionally converted to empty strl
+            data["strls"] = data["strls"].fillna("")
+            tm.assert_frame_equal(data, reread_encoded)
+            reader = StataReader(path)
+            assert reader.data_label == data_label
+            assert reader.variable_labels() == variable_labels
+
+            data.to_stata(path, version=version, write_index=False)
+            reread_to_stata = read_stata(path)
+            tm.assert_frame_equal(data, reread_to_stata)
+
+    def test_writer_118_exceptions(self):
+        df = DataFrame(np.zeros((1, 33000), dtype=np.int8))
+        with tm.ensure_clean() as path:
+            with pytest.raises(ValueError, match="version must be either 118 or 119."):
+                StataWriterUTF8(path, df, version=117)
+        with tm.ensure_clean() as path:
+            with pytest.raises(ValueError, match="You must use version 119"):
+                StataWriterUTF8(path, df, version=118)
diff --git a/pandas/tests/plotting/common.py b/pandas/tests/plotting/common.py
index 5a591f72d7361..a604d90acc854 100644
--- a/pandas/tests/plotting/common.py
+++ b/pandas/tests/plotting/common.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # coding: utf-8
 
 import os
@@ -12,9 +12,9 @@
 
 from pandas.core.dtypes.api import is_list_like
 
+import pandas as pd
 from pandas import DataFrame, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_is_valid_plot_return_object, ensure_clean
+import pandas._testing as tm
 
 
 """
@@ -311,7 +311,7 @@ def _check_ax_scales(self, axes, xaxis="linear", yaxis="linear"):
         axes : matplotlib Axes object, or its list-like
         xaxis : {'linear', 'log'}
             expected xaxis scale
-        yaxis :  {'linear', 'log'}
+        yaxis : {'linear', 'log'}
             expected yaxis scale
         """
         axes = self._flatten_visible(axes)
@@ -329,7 +329,7 @@ def _check_axes_shape(self, axes, axes_num=None, layout=None, figsize=None):
         axes_num : number
             expected number of axes. Unnecessary axes should be set to
             invisible.
-        layout :  tuple
+        layout : tuple
             expected layout, (expected number of rows , columns)
         figsize : tuple
             expected figsize. default is matplotlib default
@@ -536,20 +536,20 @@ def _check_plot_works(f, filterwarnings="always", **kwargs):
 
             plt.clf()
 
-            ax = kwargs.get("ax", fig.add_subplot(211))  # noqa
+            kwargs.get("ax", fig.add_subplot(211))
             ret = f(**kwargs)
 
-            assert_is_valid_plot_return_object(ret)
+            tm.assert_is_valid_plot_return_object(ret)
 
-            try:
-                kwargs["ax"] = fig.add_subplot(212)
-                ret = f(**kwargs)
-            except Exception:
-                pass
+            if f is pd.plotting.bootstrap_plot:
+                assert "ax" not in kwargs
             else:
-                assert_is_valid_plot_return_object(ret)
+                kwargs["ax"] = fig.add_subplot(212)
+
+            ret = f(**kwargs)
+            tm.assert_is_valid_plot_return_object(ret)
 
-            with ensure_clean(return_filelike=True) as path:
+            with tm.ensure_clean(return_filelike=True) as path:
                 plt.savefig(path)
         finally:
             tm.close(fig)
diff --git a/pandas/tests/plotting/test_backend.py b/pandas/tests/plotting/test_backend.py
index 6511d94aa4c09..9025f8c361a82 100644
--- a/pandas/tests/plotting/test_backend.py
+++ b/pandas/tests/plotting/test_backend.py
@@ -9,7 +9,7 @@
 import pandas
 
 dummy_backend = types.ModuleType("pandas_dummy_backend")
-dummy_backend.plot = lambda *args, **kwargs: None
+setattr(dummy_backend, "plot", lambda *args, **kwargs: "used_dummy")
 
 
 @pytest.fixture
@@ -38,6 +38,14 @@ def test_backend_is_correct(monkeypatch, restore_backend):
     )
 
 
+def test_backend_can_be_set_in_plot_call(monkeypatch, restore_backend):
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+    df = pandas.DataFrame([1, 2, 3])
+
+    assert pandas.get_option("plotting.backend") == "matplotlib"
+    assert df.plot(backend="pandas_dummy_backend") == "used_dummy"
+
+
 @td.skip_if_no_mpl
 def test_register_entrypoint(restore_backend):
 
@@ -86,3 +94,11 @@ def test_setting_backend_without_plot_raises():
 def test_no_matplotlib_ok():
     with pytest.raises(ImportError):
         pandas.plotting._core._get_plot_backend("matplotlib")
+
+
+def test_extra_kinds_ok(monkeypatch, restore_backend):
+    # https://github.com/pandas-dev/pandas/pull/28647
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+    pandas.set_option("plotting.backend", "pandas_dummy_backend")
+    df = pandas.DataFrame({"A": [1, 2, 3]})
+    df.plot(kind="not a real kind")
diff --git a/pandas/tests/plotting/test_boxplot_method.py b/pandas/tests/plotting/test_boxplot_method.py
index 5bbaff580c356..b84fcffe26991 100644
--- a/pandas/tests/plotting/test_boxplot_method.py
+++ b/pandas/tests/plotting/test_boxplot_method.py
@@ -10,8 +10,8 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, MultiIndex, Series, date_range, timedelta_range
+import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
-import pandas.util.testing as tm
 
 import pandas.plotting as plotting
 
@@ -175,6 +175,51 @@ def test_boxplot_numeric_data(self):
         ax = df.plot(kind="box")
         assert [x.get_text() for x in ax.get_xticklabels()] == ["b", "c"]
 
+    @pytest.mark.parametrize(
+        "colors_kwd, expected",
+        [
+            (
+                dict(boxes="r", whiskers="b", medians="g", caps="c"),
+                dict(boxes="r", whiskers="b", medians="g", caps="c"),
+            ),
+            (dict(boxes="r"), dict(boxes="r")),
+            ("r", dict(boxes="r", whiskers="r", medians="r", caps="r")),
+        ],
+    )
+    def test_color_kwd(self, colors_kwd, expected):
+        # GH: 26214
+        df = DataFrame(random.rand(10, 2))
+        result = df.boxplot(color=colors_kwd, return_type="dict")
+        for k, v in expected.items():
+            assert result[k][0].get_color() == v
+
+    @pytest.mark.parametrize(
+        "dict_colors, msg",
+        [(dict(boxes="r", invalid_key="r"), "invalid key 'invalid_key'")],
+    )
+    def test_color_kwd_errors(self, dict_colors, msg):
+        # GH: 26214
+        df = DataFrame(random.rand(10, 2))
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(color=dict_colors, return_type="dict")
+
+    @pytest.mark.parametrize(
+        "props, expected",
+        [
+            ("boxprops", "boxes"),
+            ("whiskerprops", "whiskers"),
+            ("capprops", "caps"),
+            ("medianprops", "medians"),
+        ],
+    )
+    def test_specified_props_kwd(self, props, expected):
+        # GH 30346
+        df = DataFrame({k: np.random.random(100) for k in "ABC"})
+        kwd = {props: dict(color="C1")}
+        result = df.boxplot(return_type="dict", **kwd)
+
+        assert result[expected][0].get_color() == "C1"
+
 
 @td.skip_if_no_mpl
 class TestDataFrameGroupByPlots(TestPlotBase):
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index aabe16d5050f9..e54f4784e9c4f 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -8,9 +8,10 @@
 import pandas._config.config as cf
 
 from pandas.compat.numpy import np_datetime64_compat
+import pandas.util._test_decorators as td
 
 from pandas import Index, Period, Series, Timestamp, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.plotting import (
     deregister_matplotlib_converters,
@@ -22,24 +23,12 @@
     from pandas.plotting._matplotlib import converter
 except ImportError:
     # try / except, rather than skip, to avoid internal refactoring
-    # causing an improprer skip
+    # causing an improper skip
     pass
 
 pytest.importorskip("matplotlib.pyplot")
 
 
-def test_initial_warning():
-    code = (
-        "import pandas as pd; import matplotlib.pyplot as plt; "
-        "s = pd.Series(1, pd.date_range('2000', periods=12)); "
-        "fig, ax = plt.subplots(); "
-        "ax.plot(s.index, s.values)"
-    )
-    call = [sys.executable, "-c", code]
-    out = subprocess.check_output(call, stderr=subprocess.STDOUT).decode()
-    assert "Using an implicitly" in out
-
-
 def test_registry_mpl_resets():
     # Check that Matplotlib converters are properly reset (see issue #27481)
     code = (
@@ -71,38 +60,20 @@ def test_register_by_default(self):
         call = [sys.executable, "-c", code]
         assert subprocess.check_call(call) == 0
 
-    def test_warns(self):
-        plt = pytest.importorskip("matplotlib.pyplot")
-        s = Series(range(12), index=date_range("2017", periods=12))
-        _, ax = plt.subplots()
-
-        # Set to the "warning" state, in case this isn't the first test run
-        converter._WARN = True
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w:
-            ax.plot(s.index, s.values)
-            plt.close()
-
-        assert len(w) == 1
-        assert "Using an implicitly registered datetime converter" in str(w[0])
-
+    @td.skip_if_no("matplotlib", min_version="3.1.3")
     def test_registering_no_warning(self):
         plt = pytest.importorskip("matplotlib.pyplot")
         s = Series(range(12), index=date_range("2017", periods=12))
         _, ax = plt.subplots()
 
         # Set to the "warn" state, in case this isn't the first test run
-        converter._WARN = True
         register_matplotlib_converters()
-        with tm.assert_produces_warning(None) as w:
-            ax.plot(s.index, s.values)
-
-        assert len(w) == 0
+        ax.plot(s.index, s.values)
 
     def test_pandas_plots_register(self):
         pytest.importorskip("matplotlib.pyplot")
         s = Series(range(12), index=date_range("2017", periods=12))
         # Set to the "warn" state, in case this isn't the first test run
-        converter._WARN = True
         with tm.assert_produces_warning(None) as w:
             s.plot()
 
@@ -110,14 +81,17 @@ def test_pandas_plots_register(self):
 
     def test_matplotlib_formatters(self):
         units = pytest.importorskip("matplotlib.units")
-        assert Timestamp in units.registry
 
-        ctx = cf.option_context("plotting.matplotlib.register_converters", False)
-        with ctx:
-            assert Timestamp not in units.registry
+        # Can't make any assertion about the start state.
+        # We we check that toggling converters off removes it, and toggling it
+        # on restores it.
 
-        assert Timestamp in units.registry
+        with cf.option_context("plotting.matplotlib.register_converters", True):
+            with cf.option_context("plotting.matplotlib.register_converters", False):
+                assert Timestamp not in units.registry
+            assert Timestamp in units.registry
 
+    @td.skip_if_no("matplotlib", min_version="3.1.3")
     def test_option_no_warning(self):
         pytest.importorskip("matplotlib.pyplot")
         ctx = cf.option_context("plotting.matplotlib.register_converters", False)
@@ -125,22 +99,14 @@ def test_option_no_warning(self):
         s = Series(range(12), index=date_range("2017", periods=12))
         _, ax = plt.subplots()
 
-        converter._WARN = True
         # Test without registering first, no warning
         with ctx:
-            with tm.assert_produces_warning(None) as w:
-                ax.plot(s.index, s.values)
-
-        assert len(w) == 0
+            ax.plot(s.index, s.values)
 
         # Now test with registering
-        converter._WARN = True
         register_matplotlib_converters()
         with ctx:
-            with tm.assert_produces_warning(None) as w:
-                ax.plot(s.index, s.values)
-
-        assert len(w) == 0
+            ax.plot(s.index, s.values)
 
     def test_registry_resets(self):
         units = pytest.importorskip("matplotlib.units")
@@ -167,15 +133,6 @@ def test_registry_resets(self):
             for k, v in original.items():
                 units.registry[k] = v
 
-    def test_old_import_warns(self):
-        with tm.assert_produces_warning(FutureWarning) as w:
-            from pandas.tseries import converter
-
-            converter.register()
-
-        assert len(w)
-        assert "pandas.plotting.register_matplotlib_converters" in str(w[0].message)
-
 
 class TestDateTimeConverter:
     def setup_method(self, method):
@@ -305,7 +262,7 @@ def _assert_less(ts1, ts2):
             val1 = self.dtc.convert(ts1, None, None)
             val2 = self.dtc.convert(ts2, None, None)
             if not val1 < val2:
-                raise AssertionError("{0} is not less than {1}.".format(val1, val2))
+                raise AssertionError(f"{val1} is not less than {val2}.")
 
         # Matplotlib's time representation using floats cannot distinguish
         # intervals smaller than ~10 microsecond in the common range of years.
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index e2b7f2819f957..979b89a87d843 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -9,13 +9,12 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, Index, NaT, Series, isna
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import bdate_range, date_range
 from pandas.core.indexes.period import Period, PeriodIndex, period_range
 from pandas.core.indexes.timedeltas import timedelta_range
 from pandas.core.resample import DatetimeIndex
 from pandas.tests.plotting.common import TestPlotBase
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal, ensure_clean
 
 from pandas.tseries.offsets import DateOffset
 
@@ -46,11 +45,17 @@ def teardown_method(self, method):
 
     @pytest.mark.slow
     def test_ts_plot_with_tz(self, tz_aware_fixture):
-        # GH2877, GH17173
+        # GH2877, GH17173, GH31205, GH31580
         tz = tz_aware_fixture
         index = date_range("1/1/2011", periods=2, freq="H", tz=tz)
         ts = Series([188.5, 328.25], index=index)
-        _check_plot_works(ts.plot)
+        with tm.assert_produces_warning(None):
+            _check_plot_works(ts.plot)
+            ax = ts.plot()
+            xdata = list(ax.get_lines())[0].get_xdata()
+            # Check first and last points' labels are correct
+            assert (xdata[0].hour, xdata[0].minute) == (0, 0)
+            assert (xdata[-1].hour, xdata[-1].minute) == (1, 0)
 
     def test_fontsize_set_correctly(self):
         # For issue #8765
@@ -100,33 +105,12 @@ def test_nonnumeric_exclude(self):
         with pytest.raises(TypeError, match=msg):
             df["A"].plot()
 
-    def test_tsplot_deprecated(self):
-        from pandas.tseries.plotting import tsplot
-
-        _, ax = self.plt.subplots()
-        ts = tm.makeTimeSeries()
-
-        with tm.assert_produces_warning(FutureWarning):
-            tsplot(ts, self.plt.Axes.plot, ax=ax)
-
     @pytest.mark.slow
     def test_tsplot(self):
 
-        from pandas.tseries.plotting import tsplot
-
         _, ax = self.plt.subplots()
         ts = tm.makeTimeSeries()
 
-        def f(*args, **kwds):
-            with tm.assert_produces_warning(FutureWarning):
-                return tsplot(s, self.plt.Axes.plot, *args, **kwds)
-
-        for s in self.period_ser:
-            _check_plot_works(f, s.index.freq, ax=ax, series=s)
-
-        for s in self.datetime_ser:
-            _check_plot_works(f, s.index.freq.rule_code, ax=ax, series=s)
-
         for s in self.period_ser:
             _check_plot_works(s.plot, ax=ax)
 
@@ -143,8 +127,8 @@ def test_both_style_and_color(self):
         ts = tm.makeTimeSeries()
         msg = (
             "Cannot pass 'style' string with a color symbol and 'color' "
-            "keyword argument. Please use one or the other or pass 'style'"
-            " without a color symbol"
+            "keyword argument. Please use one or the other or pass 'style' "
+            "without a color symbol"
         )
         with pytest.raises(ValueError, match=msg):
             ts.plot(style="b-", color="#000099")
@@ -195,17 +179,6 @@ def check_format_of_first_point(ax, expected_string):
         check_format_of_first_point(ax, "t = 2014-01-01  y = 1.000000")
         tm.close()
 
-        # tsplot
-        from pandas.tseries.plotting import tsplot
-
-        _, ax = self.plt.subplots()
-        with tm.assert_produces_warning(FutureWarning):
-            tsplot(annual, self.plt.Axes.plot, ax=ax)
-        check_format_of_first_point(ax, "t = 2014  y = 1.000000")
-        with tm.assert_produces_warning(FutureWarning):
-            tsplot(daily, self.plt.Axes.plot, ax=ax)
-        check_format_of_first_point(ax, "t = 2014-01-01  y = 1.000000")
-
     @pytest.mark.slow
     def test_line_plot_period_series(self):
         for s in self.period_ser:
@@ -628,7 +601,7 @@ def test_secondary_y(self):
         axes = fig.get_axes()
         line = ax.get_lines()[0]
         xp = Series(line.get_ydata(), line.get_xdata())
-        assert_series_equal(ser, xp)
+        tm.assert_series_equal(ser, xp)
         assert ax.get_yaxis().get_ticks_position() == "right"
         assert not axes[0].get_yaxis().get_visible()
         self.plt.close(fig)
@@ -658,7 +631,7 @@ def test_secondary_y_ts(self):
         axes = fig.get_axes()
         line = ax.get_lines()[0]
         xp = Series(line.get_ydata(), line.get_xdata()).to_timestamp()
-        assert_series_equal(ser, xp)
+        tm.assert_series_equal(ser, xp)
         assert ax.get_yaxis().get_ticks_position() == "right"
         assert not axes[0].get_yaxis().get_visible()
         self.plt.close(fig)
@@ -893,16 +866,6 @@ def test_to_weekly_resampling(self):
         for l in ax.get_lines():
             assert PeriodIndex(data=l.get_xdata()).freq == idxh.freq
 
-        _, ax = self.plt.subplots()
-        from pandas.tseries.plotting import tsplot
-
-        with tm.assert_produces_warning(FutureWarning):
-            tsplot(high, self.plt.Axes.plot, ax=ax)
-        with tm.assert_produces_warning(FutureWarning):
-            lines = tsplot(low, self.plt.Axes.plot, ax=ax)
-        for l in lines:
-            assert PeriodIndex(data=l.get_xdata()).freq == idxh.freq
-
     @pytest.mark.slow
     def test_from_weekly_resampling(self):
         idxh = date_range("1/1/1999", periods=52, freq="W")
@@ -927,21 +890,6 @@ def test_from_weekly_resampling(self):
                 tm.assert_numpy_array_equal(xdata, expected_h)
         tm.close()
 
-        _, ax = self.plt.subplots()
-        from pandas.tseries.plotting import tsplot
-
-        with tm.assert_produces_warning(FutureWarning):
-            tsplot(low, self.plt.Axes.plot, ax=ax)
-        with tm.assert_produces_warning(FutureWarning):
-            lines = tsplot(high, self.plt.Axes.plot, ax=ax)
-        for l in lines:
-            assert PeriodIndex(data=l.get_xdata()).freq == idxh.freq
-            xdata = l.get_xdata(orig=False)
-            if len(xdata) == 12:  # idxl lines
-                tm.assert_numpy_array_equal(xdata, expected_l)
-            else:
-                tm.assert_numpy_array_equal(xdata, expected_h)
-
     @pytest.mark.slow
     def test_from_resampling_area_line_mixed(self):
         idxh = date_range("1/1/1999", periods=52, freq="W")
@@ -1410,7 +1358,7 @@ def test_plot_outofbounds_datetime(self):
 
     def test_format_timedelta_ticks_narrow(self):
 
-        expected_labels = ["00:00:00.0000000{:0>2d}".format(i) for i in np.arange(10)]
+        expected_labels = [f"00:00:00.0000000{i:0>2d}" for i in np.arange(10)]
 
         rng = timedelta_range("0", periods=10, freq="ns")
         df = DataFrame(np.random.randn(len(rng), 3), rng)
@@ -1553,14 +1501,11 @@ def _check_plot_works(f, freq=None, series=None, *args, **kwargs):
             assert ax.freq == freq
 
         ax = fig.add_subplot(212)
-        try:
-            kwargs["ax"] = ax
-            ret = f(*args, **kwargs)
-            assert ret is not None  # do something more intelligent
-        except Exception:
-            pass
-
-        with ensure_clean(return_filelike=True) as path:
+        kwargs["ax"] = ax
+        ret = f(*args, **kwargs)
+        assert ret is not None  # TODO: do something more intelligent
+
+        with tm.ensure_clean(return_filelike=True) as path:
             plt.savefig(path)
 
         # GH18439
@@ -1570,7 +1515,7 @@ def _check_plot_works(f, freq=None, series=None, *args, **kwargs):
         # https://github.com/pandas-dev/pandas/issues/24088
         # https://github.com/statsmodels/statsmodels/issues/4772
         if "statsmodels" not in sys.modules:
-            with ensure_clean(return_filelike=True) as path:
+            with tm.ensure_clean(return_filelike=True) as path:
                 pickle.dump(fig, path)
     finally:
         plt.close(fig)
diff --git a/pandas/tests/plotting/test_frame.py b/pandas/tests/plotting/test_frame.py
index 84badba271fce..ffbd135466709 100644
--- a/pandas/tests/plotting/test_frame.py
+++ b/pandas/tests/plotting/test_frame.py
@@ -3,6 +3,7 @@
 """ Test cases for DataFrame.plot """
 
 from datetime import date, datetime
+import itertools
 import string
 import warnings
 
@@ -16,9 +17,9 @@
 
 import pandas as pd
 from pandas import DataFrame, MultiIndex, PeriodIndex, Series, bdate_range, date_range
+import pandas._testing as tm
 from pandas.core.arrays import integer_array
 from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
-import pandas.util.testing as tm
 
 from pandas.io.formats.printing import pprint_thing
 import pandas.plotting as plotting
@@ -554,14 +555,14 @@ def test_subplots_timeseries_y_axis_not_supported(self):
             period:
                 since period isn't yet implemented in ``select_dtypes``
                 and because it will need a custom value converter +
-                tick formater (as was done for x-axis plots)
+                tick formatter (as was done for x-axis plots)
 
             categorical:
                  because it will need a custom value converter +
-                 tick formater (also doesn't work for x-axis, as of now)
+                 tick formatter (also doesn't work for x-axis, as of now)
 
             datetime_mixed_tz:
-                because of the way how pandas handels ``Series`` of
+                because of the way how pandas handles ``Series`` of
                 ``datetime`` objects with different timezone,
                 generally converting ``datetime`` objects in a tz-aware
                 form could help with this problem
@@ -1161,6 +1162,36 @@ def test_plot_scatter(self):
         axes = df.plot(x="x", y="y", kind="scatter", subplots=True)
         self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
 
+    def test_raise_error_on_datetime_time_data(self):
+        # GH 8113, datetime.time type is not supported by matplotlib in scatter
+        df = pd.DataFrame(np.random.randn(10), columns=["a"])
+        df["dtime"] = pd.date_range(start="2014-01-01", freq="h", periods=10).time
+        msg = "must be a string or a number, not 'datetime.time'"
+
+        with pytest.raises(TypeError, match=msg):
+            df.plot(kind="scatter", x="dtime", y="a")
+
+    def test_scatterplot_datetime_data(self):
+        # GH 30391
+        dates = pd.date_range(start=date(2019, 1, 1), periods=12, freq="W")
+        vals = np.random.normal(0, 1, len(dates))
+        df = pd.DataFrame({"dates": dates, "vals": vals})
+
+        _check_plot_works(df.plot.scatter, x="dates", y="vals")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
+    def test_scatterplot_object_data(self):
+        # GH 18755
+        df = pd.DataFrame(dict(a=["A", "B", "C"], b=[2, 3, 4]))
+
+        _check_plot_works(df.plot.scatter, x="a", y="b")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
+        df = pd.DataFrame(dict(a=["A", "B", "C"], b=["a", "b", "c"]))
+
+        _check_plot_works(df.plot.scatter, x="a", y="b")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
     @pytest.mark.slow
     def test_if_scatterplot_colorbar_affects_xaxis_visibility(self):
         # addressing issue #10611, to ensure colobar does not
@@ -1215,24 +1246,15 @@ def test_if_scatterplot_colorbars_are_next_to_parent_axes(self):
         colorbar_distance = axes_x_coords[3, :] - axes_x_coords[2, :]
         assert np.isclose(parent_distance, colorbar_distance, atol=1e-7).all()
 
+    @pytest.mark.parametrize("x, y", [("x", "y"), ("y", "x"), ("y", "y")])
     @pytest.mark.slow
-    def test_plot_scatter_with_categorical_data(self):
-        # GH 16199
+    def test_plot_scatter_with_categorical_data(self, x, y):
+        # after fixing GH 18755, should be able to plot categorical data
         df = pd.DataFrame(
             {"x": [1, 2, 3, 4], "y": pd.Categorical(["a", "b", "a", "c"])}
         )
 
-        with pytest.raises(ValueError) as ve:
-            df.plot(x="x", y="y", kind="scatter")
-        ve.match("requires y column to be numeric")
-
-        with pytest.raises(ValueError) as ve:
-            df.plot(x="y", y="x", kind="scatter")
-        ve.match("requires x column to be numeric")
-
-        with pytest.raises(ValueError) as ve:
-            df.plot(x="y", y="y", kind="scatter")
-        ve.match("requires x column to be numeric")
+        _check_plot_works(df.plot.scatter, x=x, y=y)
 
     @pytest.mark.slow
     def test_plot_scatter_with_c(self):
@@ -2330,6 +2352,23 @@ def _check_colors(bp, box_c, whiskers_c, medians_c, caps_c="k", fliers_c=None):
             # Color contains invalid key results in ValueError
             df.plot.box(color=dict(boxes="red", xxxx="blue"))
 
+    @pytest.mark.parametrize(
+        "props, expected",
+        [
+            ("boxprops", "boxes"),
+            ("whiskerprops", "whiskers"),
+            ("capprops", "caps"),
+            ("medianprops", "medians"),
+        ],
+    )
+    def test_specified_props_kwd_plot_box(self, props, expected):
+        # GH 30346
+        df = DataFrame({k: np.random.random(100) for k in "ABC"})
+        kwd = {props: dict(color="C1")}
+        result = df.plot.box(return_type="dict", **kwd)
+
+        assert result[expected][0].get_color() == "C1"
+
     def test_default_color_cycle(self):
         import matplotlib.pyplot as plt
         import cycler
@@ -2604,12 +2643,6 @@ def test_errorbar_plot(self):
             ax = _check_plot_works(df.plot, yerr=np.ones((2, 12)) * 0.4)
             self._check_has_errorbars(ax, xerr=0, yerr=2)
 
-            # yerr is iterator
-            import itertools
-
-            ax = _check_plot_works(df.plot, yerr=itertools.repeat(0.1, len(df)))
-            self._check_has_errorbars(ax, xerr=0, yerr=2)
-
             # yerr is column name
             for yerr in ["yerr", "誤差"]:
                 s_df = df.copy()
@@ -2626,6 +2659,17 @@ def test_errorbar_plot(self):
             with pytest.raises((ValueError, TypeError)):
                 df.plot(yerr=df_err)
 
+    @pytest.mark.xfail(reason="Iterator is consumed", raises=ValueError)
+    @pytest.mark.slow
+    def test_errorbar_plot_iterator(self):
+        with warnings.catch_warnings():
+            d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+            df = DataFrame(d)
+
+            # yerr is iterator
+            ax = _check_plot_works(df.plot, yerr=itertools.repeat(0.1, len(df)))
+            self._check_has_errorbars(ax, xerr=0, yerr=2)
+
     @pytest.mark.slow
     def test_errorbar_with_integer_column_names(self):
         # test with integer column names
@@ -3244,6 +3288,34 @@ def test_plot_no_numeric_data(self):
         with pytest.raises(TypeError):
             df.plot()
 
+    def test_missing_markers_legend(self):
+        # 14958
+        df = pd.DataFrame(np.random.randn(8, 3), columns=["A", "B", "C"])
+        ax = df.plot(y=["A"], marker="x", linestyle="solid")
+        df.plot(y=["B"], marker="o", linestyle="dotted", ax=ax)
+        df.plot(y=["C"], marker="<", linestyle="dotted", ax=ax)
+
+        self._check_legend_labels(ax, labels=["A", "B", "C"])
+        self._check_legend_marker(ax, expected_markers=["x", "o", "<"])
+
+    def test_missing_markers_legend_using_style(self):
+        # 14563
+        df = pd.DataFrame(
+            {
+                "A": [1, 2, 3, 4, 5, 6],
+                "B": [2, 4, 1, 3, 2, 4],
+                "C": [3, 3, 2, 6, 4, 2],
+                "X": [1, 2, 3, 4, 5, 6],
+            }
+        )
+
+        fig, ax = self.plt.subplots()
+        for kind in "ABC":
+            df.plot("X", kind, label=kind, ax=ax, style=".")
+
+        self._check_legend_labels(ax, labels=["A", "B", "C"])
+        self._check_legend_marker(ax, expected_markers=[".", ".", "."])
+
 
 def _generate_4_axes_via_gridspec():
     import matplotlib.pyplot as plt
diff --git a/pandas/tests/plotting/test_groupby.py b/pandas/tests/plotting/test_groupby.py
index bb1747710fe18..8fec4bb134cb4 100644
--- a/pandas/tests/plotting/test_groupby.py
+++ b/pandas/tests/plotting/test_groupby.py
@@ -8,8 +8,8 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase
-import pandas.util.testing as tm
 
 
 @td.skip_if_no_mpl
diff --git a/pandas/tests/plotting/test_hist_method.py b/pandas/tests/plotting/test_hist_method.py
index 14cb2bc9d7b62..50ebbc22f2739 100644
--- a/pandas/tests/plotting/test_hist_method.py
+++ b/pandas/tests/plotting/test_hist_method.py
@@ -9,8 +9,8 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
-import pandas.util.testing as tm
 
 
 @td.skip_if_no_mpl
@@ -253,6 +253,24 @@ def test_tight_layout(self):
 
         tm.close()
 
+    def test_hist_subplot_xrot(self):
+        # GH 30288
+        df = DataFrame(
+            {
+                "length": [1.5, 0.5, 1.2, 0.9, 3],
+                "animal": ["pig", "rabbit", "pig", "pig", "rabbit"],
+            }
+        )
+        axes = _check_plot_works(
+            df.hist,
+            filterwarnings="always",
+            column="length",
+            by="animal",
+            bins=5,
+            xrot=0,
+        )
+        self._check_ticks_props(axes, xrot=0)
+
 
 @td.skip_if_no_mpl
 class TestDataFrameGroupByPlots(TestPlotBase):
@@ -313,7 +331,8 @@ def test_grouped_hist_legacy(self):
         with pytest.raises(AttributeError):
             _grouped_hist(df.A, by=df.C, foo="bar")
 
-        with tm.assert_produces_warning(FutureWarning):
+        msg = "Specify figure size by tuple instead"
+        with pytest.raises(ValueError, match=msg):
             df.hist(by="C", figsize="default")
 
     @pytest.mark.slow
diff --git a/pandas/tests/plotting/test_misc.py b/pandas/tests/plotting/test_misc.py
index 940cfef4058e0..168e8c7de0b83 100644
--- a/pandas/tests/plotting/test_misc.py
+++ b/pandas/tests/plotting/test_misc.py
@@ -10,8 +10,8 @@
 import pandas.util._test_decorators as td
 
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
-import pandas.util.testing as tm
 
 import pandas.plotting as plotting
 
@@ -32,14 +32,9 @@ def test_get_accessor_args():
     with pytest.raises(TypeError, match=msg):
         func(backend_name="", data=[], args=[], kwargs={})
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        x, y, kind, kwargs = func(
-            backend_name="", data=Series(), args=["line", None], kwargs={}
-        )
-    assert x is None
-    assert y is None
-    assert kind == "line"
-    assert kwargs == {"ax": None}
+    msg = "should not be called with positional arguments"
+    with pytest.raises(TypeError, match=msg):
+        func(backend_name="", data=Series(dtype=object), args=["line", None], kwargs={})
 
     x, y, kind, kwargs = func(
         backend_name="",
@@ -53,7 +48,10 @@ def test_get_accessor_args():
     assert kwargs == {"grid": False}
 
     x, y, kind, kwargs = func(
-        backend_name="pandas.plotting._matplotlib", data=Series(), args=[], kwargs={}
+        backend_name="pandas.plotting._matplotlib",
+        data=Series(dtype=object),
+        args=[],
+        kwargs={},
     )
     assert x is None
     assert y is None
@@ -204,9 +202,6 @@ def test_andrews_curves(self, iris):
         handles, labels = ax.get_legend_handles_labels()
         self._check_colors(handles, linecolors=colors)
 
-        with tm.assert_produces_warning(FutureWarning):
-            andrews_curves(data=df, class_column="Name")
-
     @pytest.mark.slow
     def test_parallel_coordinates(self, iris):
         from pandas.plotting import parallel_coordinates
@@ -253,11 +248,6 @@ def test_parallel_coordinates(self, iris):
         handles, labels = ax.get_legend_handles_labels()
         self._check_colors(handles, linecolors=colors)
 
-        with tm.assert_produces_warning(FutureWarning):
-            parallel_coordinates(data=df, class_column="Name")
-        with tm.assert_produces_warning(FutureWarning):
-            parallel_coordinates(df, "Name", colors=colors)
-
     # not sure if this is indicative of a problem
     @pytest.mark.filterwarnings("ignore:Attempting to set:UserWarning")
     def test_parallel_coordinates_with_sorted_labels(self):
@@ -266,7 +256,7 @@ def test_parallel_coordinates_with_sorted_labels(self):
 
         df = DataFrame(
             {
-                "feat": [i for i in range(30)],
+                "feat": list(range(30)),
                 "class": [2 for _ in range(10)]
                 + [3 for _ in range(10)]
                 + [1 for _ in range(10)],
@@ -279,8 +269,7 @@ def test_parallel_coordinates_with_sorted_labels(self):
         )
         ordered_color_label_tuples = sorted(color_label_tuples, key=lambda x: x[1])
         prev_next_tupels = zip(
-            [i for i in ordered_color_label_tuples[0:-1]],
-            [i for i in ordered_color_label_tuples[1:]],
+            list(ordered_color_label_tuples[0:-1]), list(ordered_color_label_tuples[1:])
         )
         for prev, nxt in prev_next_tupels:
             # labels and colors are ordered strictly increasing
@@ -330,8 +319,8 @@ def test_subplot_titles(self, iris):
 
         # Case len(title) > len(df)
         msg = (
-            "The length of `title` must equal the number of columns if"
-            " using `title` of type `list` and `subplots=True`"
+            "The length of `title` must equal the number of columns if "
+            "using `title` of type `list` and `subplots=True`"
         )
         with pytest.raises(ValueError, match=msg):
             df.plot(subplots=True, title=title + ["kittens > puppies"])
@@ -342,8 +331,8 @@ def test_subplot_titles(self, iris):
 
         # Case subplots=False and title is of type list
         msg = (
-            "Using `title` of type `list` is not supported unless"
-            " `subplots=True` is passed"
+            "Using `title` of type `list` is not supported unless "
+            "`subplots=True` is passed"
         )
         with pytest.raises(ValueError, match=msg):
             df.plot(subplots=False, title=title)
@@ -417,3 +406,24 @@ def test_get_standard_colors_no_appending(self):
         color_list = cm.gnuplot(np.linspace(0, 1, 16))
         p = df.A.plot.bar(figsize=(16, 7), color=color_list)
         assert p.patches[1].get_facecolor() == p.patches[17].get_facecolor()
+
+    @pytest.mark.slow
+    def test_dictionary_color(self):
+        # issue-8193
+        # Test plot color dictionary format
+        data_files = ["a", "b"]
+
+        expected = [(0.5, 0.24, 0.6), (0.3, 0.7, 0.7)]
+
+        df1 = DataFrame(np.random.rand(2, 2), columns=data_files)
+        dic_color = {"b": (0.3, 0.7, 0.7), "a": (0.5, 0.24, 0.6)}
+
+        # Bar color test
+        ax = df1.plot(kind="bar", color=dic_color)
+        colors = [rect.get_facecolor()[0:-1] for rect in ax.get_children()[0:3:2]]
+        assert all(color == expected[index] for index, color in enumerate(colors))
+
+        # Line color test
+        ax = df1.plot(kind="line", color=dic_color)
+        colors = [rect.get_color() for rect in ax.get_lines()[0:2]]
+        assert all(color == expected[index] for index, color in enumerate(colors))
diff --git a/pandas/tests/plotting/test_series.py b/pandas/tests/plotting/test_series.py
index 84307ff6c250f..8463f30bee8f0 100644
--- a/pandas/tests/plotting/test_series.py
+++ b/pandas/tests/plotting/test_series.py
@@ -14,8 +14,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, date_range
+import pandas._testing as tm
 from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
-import pandas.util.testing as tm
 
 import pandas.plotting as plotting
 
@@ -330,7 +330,7 @@ def test_pie_series(self):
         ax = _check_plot_works(
             series.plot.pie, colors=color_args, autopct="%.2f", fontsize=7
         )
-        pcts = ["{0:.2f}".format(s * 100) for s in series.values / float(series.sum())]
+        pcts = [f"{s*100:.2f}" for s in series.values / float(series.sum())]
         expected_texts = list(chain.from_iterable(zip(series.index, pcts)))
         self._check_text_labels(ax.texts, expected_texts)
         for t in ax.texts:
@@ -865,12 +865,19 @@ def test_time_series_plot_color_with_empty_kwargs(self):
 
     def test_xticklabels(self):
         # GH11529
-        s = Series(np.arange(10), index=["P{i:02d}".format(i=i) for i in range(10)])
+        s = Series(np.arange(10), index=[f"P{i:02d}" for i in range(10)])
         _, ax = self.plt.subplots()
         ax = s.plot(xticks=[0, 3, 5, 9], ax=ax)
-        exp = ["P{i:02d}".format(i=i) for i in [0, 3, 5, 9]]
+        exp = [f"P{i:02d}" for i in [0, 3, 5, 9]]
         self._check_text_labels(ax.get_xticklabels(), exp)
 
+    def test_xtick_barPlot(self):
+        # GH28172
+        s = pd.Series(range(10), index=[f"P{i:02d}" for i in range(10)])
+        ax = s.plot.bar(xticks=range(0, 11, 2))
+        exp = np.array(list(range(0, 11, 2)))
+        tm.assert_numpy_array_equal(exp, ax.get_xticks())
+
     def test_custom_business_day_freq(self):
         # GH7222
         from pandas.tseries.offsets import CustomBusinessDay
@@ -924,3 +931,8 @@ def test_plot_no_numeric_data(self):
         df = pd.Series(["a", "b", "c"])
         with pytest.raises(TypeError):
             df.plot()
+
+    def test_style_single_ok(self):
+        s = pd.Series([1, 2])
+        ax = s.plot(style="s", color="C3")
+        assert ax.lines[0].get_color() == ["C3"]
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 05ebff4387908..0b312fe2f8990 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -21,8 +21,8 @@
     timedelta_range,
     to_timedelta,
 )
+import pandas._testing as tm
 from pandas.core import nanops
-import pandas.util.testing as tm
 
 
 def get_objs():
@@ -79,7 +79,7 @@ def test_nanops(self):
                 assert pd.isna(getattr(obj, opname)())
                 assert pd.isna(getattr(obj, opname)(skipna=False))
 
-                obj = klass([])
+                obj = klass([], dtype=object)
                 assert pd.isna(getattr(obj, opname)())
                 assert pd.isna(getattr(obj, opname)(skipna=False))
 
@@ -179,8 +179,8 @@ class TestIndexReductions:
         [
             (0, 400, 3),
             (500, 0, -6),
-            (-10 ** 6, 10 ** 6, 4),
-            (10 ** 6, -10 ** 6, -4),
+            (-(10 ** 6), 10 ** 6, 4),
+            (10 ** 6, -(10 ** 6), -4),
             (0, 10, 20),
         ],
     )
@@ -299,12 +299,6 @@ def test_timedelta_ops(self):
         result = td.to_frame().std()
         assert result[0] == expected
 
-        # invalid ops
-        for op in ["skew", "kurt", "sem", "prod"]:
-            msg = "reduction operation '{}' not allowed for this dtype"
-            with pytest.raises(TypeError, match=msg.format(op)):
-                getattr(td, op)()
-
         # GH#10040
         # make sure NaT is properly handled by median()
         s = Series([Timestamp("2015-02-03"), Timestamp("2015-02-07")])
@@ -315,6 +309,27 @@ def test_timedelta_ops(self):
         )
         assert s.diff().median() == timedelta(days=6)
 
+    @pytest.mark.parametrize("opname", ["skew", "kurt", "sem", "prod", "var"])
+    def test_invalid_td64_reductions(self, opname):
+        s = Series(
+            [Timestamp("20130101") + timedelta(seconds=i * i) for i in range(10)]
+        )
+        td = s.diff()
+
+        msg = "|".join(
+            [
+                "reduction operation '{op}' not allowed for this dtype",
+                r"cannot perform {op} with type timedelta64\[ns\]",
+            ]
+        )
+        msg = msg.format(op=opname)
+
+        with pytest.raises(TypeError, match=msg):
+            getattr(td, opname)()
+
+        with pytest.raises(TypeError, match=msg):
+            getattr(td.to_frame(), opname)(numeric_only=False)
+
     def test_minmax_tz(self, tz_naive_fixture):
         tz = tz_naive_fixture
         # monotonic
@@ -425,7 +440,8 @@ def test_minmax_period(self):
 
         # monotonic
         idx1 = pd.PeriodIndex([NaT, "2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
-        assert idx1.is_monotonic
+        assert not idx1.is_monotonic
+        assert idx1[1:].is_monotonic
 
         # non-monotonic
         idx2 = pd.PeriodIndex(
@@ -518,7 +534,7 @@ def test_empty(self, method, unit, use_bottleneck):
         with pd.option_context("use_bottleneck", use_bottleneck):
             # GH#9422 / GH#18921
             # Entirely empty
-            s = Series([])
+            s = Series([], dtype=object)
             # NA by default
             result = getattr(s, method)()
             assert result == unit
@@ -636,8 +652,19 @@ def test_ops_consistency_on_empty(self, method):
         assert pd.isna(result)
 
         # timedelta64[ns]
-        result = getattr(Series(dtype="m8[ns]"), method)()
-        assert result is pd.NaT
+        tdser = Series([], dtype="m8[ns]")
+        if method == "var":
+            msg = "|".join(
+                [
+                    "operation 'var' not allowed",
+                    r"cannot perform var with type timedelta64\[ns\]",
+                ]
+            )
+            with pytest.raises(TypeError, match=msg):
+                getattr(tdser, method)()
+        else:
+            result = getattr(tdser, method)()
+            assert result is pd.NaT
 
     def test_nansum_buglet(self):
         ser = Series([1.0, np.nan], index=[0, 1])
@@ -680,52 +707,40 @@ def test_empty_timeseries_reductions_return_nat(self):
             assert Series([], dtype=dtype).min(skipna=False) is pd.NaT
             assert Series([], dtype=dtype).max(skipna=False) is pd.NaT
 
-    def test_numpy_argmin_deprecated(self):
+    def test_numpy_argmin(self):
         # See GH#16830
         data = np.arange(1, 11)
 
         s = Series(data, index=data)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # The deprecation of Series.argmin also causes a deprecation
-            # warning when calling np.argmin. This behavior is temporary
-            # until the implementation of Series.argmin is corrected.
-            result = np.argmin(s)
+        result = np.argmin(s)
 
-        assert result == 1
+        expected = np.argmin(data)
+        assert result == expected
 
-        with tm.assert_produces_warning(FutureWarning):
-            # argmin is aliased to idxmin
-            result = s.argmin()
+        result = s.argmin()
 
-        assert result == 1
+        assert result == expected
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            msg = "the 'out' parameter is not supported"
-            with pytest.raises(ValueError, match=msg):
-                np.argmin(s, out=data)
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.argmin(s, out=data)
 
-    def test_numpy_argmax_deprecated(self):
+    def test_numpy_argmax(self):
         # See GH#16830
         data = np.arange(1, 11)
 
         s = Series(data, index=data)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            # The deprecation of Series.argmax also causes a deprecation
-            # warning when calling np.argmax. This behavior is temporary
-            # until the implementation of Series.argmax is corrected.
-            result = np.argmax(s)
-        assert result == 10
+        result = np.argmax(s)
+        expected = np.argmax(data)
+        assert result == expected
 
-        with tm.assert_produces_warning(FutureWarning):
-            # argmax is aliased to idxmax
-            result = s.argmax()
+        result = s.argmax()
 
-        assert result == 10
+        assert result == expected
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            msg = "the 'out' parameter is not supported"
-            with pytest.raises(ValueError, match=msg):
-                np.argmax(s, out=data)
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.argmax(s, out=data)
 
     def test_idxmin(self):
         # test idxmin
@@ -885,7 +900,7 @@ def test_timedelta64_analytics(self):
     @pytest.mark.parametrize(
         "test_input,error_type",
         [
-            (pd.Series([]), ValueError),
+            (pd.Series([], dtype="float64"), ValueError),
             # For strings, or any Series with dtype 'O'
             (pd.Series(["foo", "bar", "baz"]), TypeError),
             (pd.Series([(1,), (2,)]), TypeError),
@@ -1028,7 +1043,7 @@ def test_min_max(self):
         )
         _min = cat.min()
         _max = cat.max()
-        assert np.isnan(_min)
+        assert _min == "c"
         assert _max == "b"
 
         cat = Series(
@@ -1038,30 +1053,24 @@ def test_min_max(self):
         )
         _min = cat.min()
         _max = cat.max()
-        assert np.isnan(_min)
+        assert _min == 2
         assert _max == 1
 
-    def test_min_max_numeric_only(self):
-        # TODO deprecate numeric_only argument for Categorical and use
-        # skipna as well, see GH25303
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_min_max_skipna(self, skipna):
+        # GH 25303
         cat = Series(
             Categorical(["a", "b", np.nan, "a"], categories=["b", "a"], ordered=True)
         )
+        _min = cat.min(skipna=skipna)
+        _max = cat.max(skipna=skipna)
 
-        _min = cat.min()
-        _max = cat.max()
-        assert np.isnan(_min)
-        assert _max == "a"
-
-        _min = cat.min(numeric_only=True)
-        _max = cat.max(numeric_only=True)
-        assert _min == "b"
-        assert _max == "a"
-
-        _min = cat.min(numeric_only=False)
-        _max = cat.max(numeric_only=False)
-        assert np.isnan(_min)
-        assert _max == "a"
+        if skipna is True:
+            assert _min == "b"
+            assert _max == "a"
+        else:
+            assert np.isnan(_min)
+            assert np.isnan(_max)
 
 
 class TestSeriesMode:
diff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py
index 432811b5a8264..59dbcb9ab9fa0 100644
--- a/pandas/tests/reductions/test_stat_reductions.py
+++ b/pandas/tests/reductions/test_stat_reductions.py
@@ -10,8 +10,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
-import pandas.util.testing as tm
 
 
 class TestDatetimeLikeStatReductions:
diff --git a/pandas/tests/resample/conftest.py b/pandas/tests/resample/conftest.py
index bb4f7ced3350f..a4ac15d9f3b07 100644
--- a/pandas/tests/resample/conftest.py
+++ b/pandas/tests/resample/conftest.py
@@ -99,7 +99,8 @@ def _index_name():
 @pytest.fixture
 def index(_index_factory, _index_start, _index_end, _index_freq, _index_name):
     """Fixture for parametrization of date_range, period_range and
-    timedelta_range indexes"""
+    timedelta_range indexes
+    """
     return _index_factory(_index_start, _index_end, freq=_index_freq, name=_index_name)
 
 
@@ -107,35 +108,40 @@ def index(_index_factory, _index_start, _index_end, _index_freq, _index_name):
 def _static_values(index):
     """Fixture for parametrization of values used in parametrization of
     Series and DataFrames with date_range, period_range and
-    timedelta_range indexes"""
+    timedelta_range indexes
+    """
     return np.arange(len(index))
 
 
 @pytest.fixture
 def _series_name():
     """Fixture for parametrization of Series name for Series used with
-    date_range, period_range and timedelta_range indexes"""
+    date_range, period_range and timedelta_range indexes
+    """
     return None
 
 
 @pytest.fixture
 def series(index, _series_name, _static_values):
     """Fixture for parametrization of Series with date_range, period_range and
-    timedelta_range indexes"""
+    timedelta_range indexes
+    """
     return Series(_static_values, index=index, name=_series_name)
 
 
 @pytest.fixture
 def empty_series(series):
     """Fixture for parametrization of empty Series with date_range,
-    period_range and timedelta_range indexes"""
+    period_range and timedelta_range indexes
+    """
     return series[:0]
 
 
 @pytest.fixture
 def frame(index, _series_name, _static_values):
     """Fixture for parametrization of DataFrame with date_range, period_range
-    and timedelta_range indexes"""
+    and timedelta_range indexes
+    """
     # _series_name is intentionally unused
     return DataFrame({"value": _static_values}, index=index)
 
@@ -143,7 +149,8 @@ def frame(index, _series_name, _static_values):
 @pytest.fixture
 def empty_frame(series):
     """Fixture for parametrization of empty DataFrame with date_range,
-    period_range and timedelta_range indexes"""
+    period_range and timedelta_range indexes
+    """
     index = series.index[:0]
     return DataFrame(index=index)
 
@@ -151,7 +158,8 @@ def empty_frame(series):
 @pytest.fixture(params=[Series, DataFrame])
 def series_and_frame(request, series, frame):
     """Fixture for parametrization of Series and DataFrame with date_range,
-    period_range and timedelta_range indexes"""
+    period_range and timedelta_range indexes
+    """
     if request.param == Series:
         return series
     if request.param == DataFrame:
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index 51e309130e45d..c84a5bf653b0a 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -5,18 +5,13 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.groupby.groupby import DataError
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.indexes.datetimes import date_range
 from pandas.core.indexes.period import PeriodIndex, period_range
 from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-)
+from pandas.core.resample import _asfreq_compat
 
 # a fixture value can be overridden by the test parameter value. Note that the
 # value of the fixture can be overridden this way even if the test doesn't use
@@ -53,7 +48,7 @@ def test_asfreq(series_and_frame, freq, create_index):
     result = obj.resample(freq).asfreq()
     new_index = create_index(obj.index[0], obj.index[-1], freq=freq)
     expected = obj.reindex(new_index)
-    assert_almost_equal(result, expected)
+    tm.assert_almost_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -67,21 +62,21 @@ def test_asfreq_fill_value(series, create_index):
     result = s.resample("1H").asfreq()
     new_index = create_index(s.index[0], s.index[-1], freq="1H")
     expected = s.reindex(new_index)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     frame = s.to_frame("value")
     frame.iloc[1] = None
     result = frame.resample("1H").asfreq(fill_value=4.0)
     new_index = create_index(frame.index[0], frame.index[-1], freq="1H")
     expected = frame.reindex(new_index, fill_value=4.0)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @all_ts
 def test_resample_interpolate(frame):
     # # 12925
     df = frame
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample("1T").asfreq().interpolate(), df.resample("1T").interpolate()
     )
 
@@ -90,8 +85,8 @@ def test_raises_on_non_datetimelike_index():
     # this is a non datetimelike index
     xp = DataFrame()
     msg = (
-        "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex,"
-        " but got an instance of 'Index'"
+        "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, "
+        "but got an instance of 'Index'"
     )
     with pytest.raises(TypeError, match=msg):
         xp.resample("A").mean()
@@ -109,13 +104,25 @@ def test_resample_empty_series(freq, empty_series, resample_method):
     result = getattr(s.resample(freq), resample_method)()
 
     expected = s.copy()
-    if isinstance(s.index, PeriodIndex):
-        expected.index = s.index.asfreq(freq=freq)
-    else:
-        expected.index = s.index._shallow_copy(freq=freq)
-    assert_index_equal(result.index, expected.index)
+    expected.index = _asfreq_compat(s.index, freq)
+
+    tm.assert_index_equal(result.index, expected.index)
     assert result.index.freq == expected.index.freq
-    assert_series_equal(result, expected, check_dtype=False)
+    tm.assert_series_equal(result, expected, check_dtype=False)
+
+
+@all_ts
+@pytest.mark.parametrize("freq", ["M", "D", "H"])
+@pytest.mark.parametrize("resample_method", ["count", "size"])
+def test_resample_count_empty_series(freq, empty_series, resample_method):
+    # GH28427
+    result = getattr(empty_series.resample(freq), resample_method)()
+
+    index = _asfreq_compat(empty_series.index, freq)
+
+    expected = pd.Series([], dtype="int64", index=index, name=empty_series.name)
+
+    tm.assert_series_equal(result, expected)
 
 
 @all_ts
@@ -129,19 +136,51 @@ def test_resample_empty_dataframe(empty_frame, freq, resample_method):
         expected = df.copy()
     else:
         # GH14962
-        expected = Series([])
+        expected = Series([], dtype=object)
 
-    if isinstance(df.index, PeriodIndex):
-        expected.index = df.index.asfreq(freq=freq)
-    else:
-        expected.index = df.index._shallow_copy(freq=freq)
-    assert_index_equal(result.index, expected.index)
+    expected.index = _asfreq_compat(df.index, freq)
+
+    tm.assert_index_equal(result.index, expected.index)
     assert result.index.freq == expected.index.freq
-    assert_almost_equal(result, expected, check_dtype=False)
+    tm.assert_almost_equal(result, expected, check_dtype=False)
 
     # test size for GH13212 (currently stays as df)
 
 
+@all_ts
+@pytest.mark.parametrize("freq", ["M", "D", "H"])
+def test_resample_count_empty_dataframe(freq, empty_frame):
+    # GH28427
+
+    empty_frame = empty_frame.copy()
+    empty_frame["a"] = []
+
+    result = empty_frame.resample(freq).count()
+
+    index = _asfreq_compat(empty_frame.index, freq)
+
+    expected = pd.DataFrame({"a": []}, dtype="int64", index=index)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@all_ts
+@pytest.mark.parametrize("freq", ["M", "D", "H"])
+def test_resample_size_empty_dataframe(freq, empty_frame):
+    # GH28427
+
+    empty_frame = empty_frame.copy()
+    empty_frame["a"] = []
+
+    result = empty_frame.resample(freq).size()
+
+    index = _asfreq_compat(empty_frame.index, freq)
+
+    expected = pd.Series([], dtype="int64", index=index)
+
+    tm.assert_series_equal(result, expected)
+
+
 @pytest.mark.parametrize("index", tm.all_timeseries_index_generator(0))
 @pytest.mark.parametrize("dtype", [np.float, np.int, np.object, "datetime64[ns]"])
 def test_resample_empty_dtypes(index, dtype, resample_method):
@@ -159,7 +198,8 @@ def test_resample_empty_dtypes(index, dtype, resample_method):
 
 
 @all_ts
-def test_resample_loffset_arg_type(frame, create_index):
+@pytest.mark.parametrize("arg", ["mean", {"value": "mean"}, ["mean"]])
+def test_resample_loffset_arg_type(frame, create_index, arg):
     # GH 13218, 15002
     df = frame
     expected_means = [df.values[i : i + 2].mean() for i in range(0, len(df.values), 2)]
@@ -172,26 +212,18 @@ def test_resample_loffset_arg_type(frame, create_index):
     expected_index += timedelta(hours=2)
     expected = DataFrame({"value": expected_means}, index=expected_index)
 
-    for arg in ["mean", {"value": "mean"}, ["mean"]]:
-
-        result_agg = df.resample("2D", loffset="2H").agg(arg)
+    result_agg = df.resample("2D", loffset="2H").agg(arg)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result_how = df.resample("2D", how=arg, loffset="2H")
+    if isinstance(arg, list):
+        expected.columns = pd.MultiIndex.from_tuples([("value", "mean")])
 
-        if isinstance(arg, list):
-            expected.columns = pd.MultiIndex.from_tuples([("value", "mean")])
-
-        # GH 13022, 7687 - TODO: fix resample w/ TimedeltaIndex
-        if isinstance(expected.index, TimedeltaIndex):
-            msg = "DataFrame are different"
-            with pytest.raises(AssertionError, match=msg):
-                assert_frame_equal(result_agg, expected)
-            with pytest.raises(AssertionError, match=msg):
-                assert_frame_equal(result_how, expected)
-        else:
-            assert_frame_equal(result_agg, expected)
-            assert_frame_equal(result_how, expected)
+    # GH 13022, 7687 - TODO: fix resample w/ TimedeltaIndex
+    if isinstance(expected.index, TimedeltaIndex):
+        msg = "DataFrame are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(result_agg, expected)
+    else:
+        tm.assert_frame_equal(result_agg, expected)
 
 
 @all_ts
@@ -202,7 +234,7 @@ def test_apply_to_empty_series(empty_series):
         result = s.resample(freq).apply(lambda x: 1)
         expected = s.resample(freq).apply(np.sum)
 
-        assert_series_equal(result, expected, check_dtype=False)
+        tm.assert_series_equal(result, expected, check_dtype=False)
 
 
 @all_ts
@@ -214,7 +246,7 @@ def test_resampler_is_iterable(series):
     resampled = series.resample(freq)
     for (rk, rv), (gk, gv) in zip(resampled, grouped):
         assert rk == gk
-        assert_series_equal(rv, gv)
+        tm.assert_series_equal(rv, gv)
 
 
 @all_ts
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index fb3d428bcf4bf..3ad82b9e075a8 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -10,16 +10,11 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, Timedelta, Timestamp, isna, notna
+import pandas._testing as tm
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.indexes.datetimes import date_range
 from pandas.core.indexes.period import Period, period_range
 from pandas.core.resample import DatetimeIndex, _get_timestamp_range_edges
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
 
 import pandas.tseries.offsets as offsets
 from pandas.tseries.offsets import BDay, Minute
@@ -71,7 +66,7 @@ def test_custom_grouper(index):
 
     # GH2763 - return in put dtype if we can
     result = g.agg(np.sum)
-    assert_series_equal(result, expect)
+    tm.assert_series_equal(result, expect)
 
     df = DataFrame(np.random.rand(len(dti), 10), index=dti, dtype="float64")
     r = df.groupby(b).agg(np.sum)
@@ -109,7 +104,7 @@ def test_resample_basic(series, closed, expected):
     s = series
     expected = expected(s)
     result = s.resample("5min", closed=closed, label="right").mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_integerarray():
@@ -123,13 +118,15 @@ def test_resample_integerarray():
         index=pd.date_range("1/1/2000", periods=3, freq="3T"),
         dtype="Int64",
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.resample("3T").mean()
     expected = Series(
-        [1, 4, 7], index=pd.date_range("1/1/2000", periods=3, freq="3T"), dtype="Int64"
+        [1, 4, 7],
+        index=pd.date_range("1/1/2000", periods=3, freq="3T"),
+        dtype="float64",
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_basic_grouper(series):
@@ -137,7 +134,7 @@ def test_resample_basic_grouper(series):
     result = s.resample("5Min").last()
     grouper = Grouper(freq=Minute(5), closed="left", label="left")
     expected = s.groupby(grouper).agg(lambda x: x[-1])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -151,9 +148,7 @@ def test_resample_basic_grouper(series):
 def test_resample_string_kwargs(series, keyword, value):
     # see gh-19303
     # Check that wrong keyword argument strings raise an error
-    msg = "Unsupported value {value} for `{keyword}`".format(
-        value=value, keyword=keyword
-    )
+    msg = f"Unsupported value {value} for `{keyword}`"
     with pytest.raises(ValueError, match=msg):
         series.resample("5min", **({keyword: value}))
 
@@ -178,7 +173,7 @@ def test_resample_how(series, downsample_method):
     result = getattr(
         s.resample("5min", closed="right", label="right"), downsample_method
     )()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -205,7 +200,7 @@ def _ohlc(group):
     )
 
     result = s.resample("5min", closed="right", label="right").ohlc()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("func", ["min", "max", "sum", "prod", "mean", "var", "std"])
@@ -241,10 +236,10 @@ def __call__(self, x):
     df_partial2 = df.resample("M").apply(partial(fn, a=2))
     df_class = df.resample("M").apply(FnClass())
 
-    assert_frame_equal(df_standard, df_lambda)
-    assert_frame_equal(df_standard, df_partial)
-    assert_frame_equal(df_standard, df_partial2)
-    assert_frame_equal(df_standard, df_class)
+    tm.assert_frame_equal(df_standard, df_lambda)
+    tm.assert_frame_equal(df_standard, df_partial)
+    tm.assert_frame_equal(df_standard, df_partial2)
+    tm.assert_frame_equal(df_standard, df_class)
 
 
 def test_resample_rounding():
@@ -282,31 +277,31 @@ def test_resample_rounding():
     expected = DataFrame(
         {"value": [4, 9, 4, 2]}, index=date_range("2014-11-08", freq="6s", periods=4)
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.resample("7s").sum()
     expected = DataFrame(
         {"value": [4, 10, 4, 1]}, index=date_range("2014-11-08", freq="7s", periods=4)
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.resample("11s").sum()
     expected = DataFrame(
         {"value": [11, 8]}, index=date_range("2014-11-08", freq="11s", periods=2)
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.resample("13s").sum()
     expected = DataFrame(
         {"value": [13, 6]}, index=date_range("2014-11-08", freq="13s", periods=2)
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     result = df.resample("17s").sum()
     expected = DataFrame(
         {"value": [16, 3]}, index=date_range("2014-11-08", freq="17s", periods=2)
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_basic_from_daily():
@@ -388,12 +383,12 @@ def test_resample_upsampling_picked_but_not_correct():
     )
 
     result = s.resample("D").count()
-    assert_series_equal(result, Series(1, index=expected.index))
+    tm.assert_series_equal(result, Series(1, index=expected.index))
 
     result1 = s.resample("D").sum()
     result2 = s.resample("D").mean()
-    assert_series_equal(result1, expected)
-    assert_series_equal(result2, expected)
+    tm.assert_series_equal(result1, expected)
+    tm.assert_series_equal(result2, expected)
 
 
 def test_resample_frame_basic():
@@ -408,10 +403,10 @@ def test_resample_frame_basic():
         g._cython_agg_general(f)
 
     result = df.resample("A").mean()
-    assert_series_equal(result["A"], df["A"].resample("A").mean())
+    tm.assert_series_equal(result["A"], df["A"].resample("A").mean())
 
     result = df.resample("M").mean()
-    assert_series_equal(result["A"], df["A"].resample("M").mean())
+    tm.assert_series_equal(result["A"], df["A"].resample("M").mean())
 
     df.resample("M", kind="period").mean()
     df.resample("W-WED", kind="period").mean()
@@ -431,7 +426,7 @@ def test_resample_loffset(loffset):
         [s[0], s[1:6].mean(), s[6:11].mean(), s[11:].mean()],
         index=idx + timedelta(minutes=1),
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
     assert result.index.freq == Minute(5)
 
     # from daily
@@ -456,7 +451,7 @@ def test_resample_loffset_upsample():
     idx = date_range("1/1/2000", periods=4, freq="5min")
     expected = Series([s[0], s[5], s[10], s[-1]], index=idx + timedelta(minutes=1))
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_loffset_count():
@@ -472,13 +467,13 @@ def test_resample_loffset_count():
     )
     expected = Series(10, index=expected_index)
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # Same issue should apply to .size() since it goes through
     #   same code path
     result = ts.resample("10S", loffset="1s").size()
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_upsample():
@@ -519,7 +514,7 @@ def test_resample_how_method():
             Timestamp("2015-03-31 21:49:50"),
         ],
     )
-    assert_series_equal(s.resample("10S").mean(), expected)
+    tm.assert_series_equal(s.resample("10S").mean(), expected)
 
 
 def test_resample_extra_index_point():
@@ -530,7 +525,7 @@ def test_resample_extra_index_point():
     index = date_range(start="20150101", end="20150331", freq="B")
     df = DataFrame({"A": Series(range(len(index)), index=index)}, dtype="int64")
     result = df.resample("BM").last()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_upsample_with_limit():
@@ -539,7 +534,7 @@ def test_upsample_with_limit():
 
     result = ts.resample("t").ffill(limit=2)
     expected = ts.reindex(result.index, method="ffill", limit=2)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_nearest_upsample_with_limit():
@@ -548,7 +543,7 @@ def test_nearest_upsample_with_limit():
 
     result = ts.resample("t").nearest(limit=2)
     expected = ts.reindex(result.index, method="nearest", limit=2)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_ohlc(series):
@@ -601,7 +596,7 @@ def test_resample_ohlc_result():
     df = DataFrame(data=np.arange(len(index)), index=index)
     result = df.resample("B").mean()
     expected = df.reindex(index=date_range(rng[0], rng[-1], freq="B"))
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_ohlc_dataframe():
@@ -627,7 +622,7 @@ def test_resample_ohlc_dataframe():
         axis=1,
         keys=["VOLUME", "PRICE"],
     )
-    assert_frame_equal(exp, res)
+    tm.assert_frame_equal(exp, res)
 
     df.columns = [["a", "b"], ["c", "d"]]
     res = df.resample("H").ohlc()
@@ -643,7 +638,7 @@ def test_resample_ohlc_dataframe():
             ("b", "d", "close"),
         ]
     )
-    assert_frame_equal(exp, res)
+    tm.assert_frame_equal(exp, res)
 
     # dupe columns fail atm
     # df.columns = ['PRICE', 'PRICE']
@@ -662,7 +657,7 @@ def test_resample_dup_index():
     result = df.resample("Q", axis=1).mean()
     expected = df.groupby(lambda x: int((x.month - 1) / 3), axis=1).mean()
     expected.columns = [Period(year=2000, quarter=i + 1, freq="Q") for i in range(4)]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_reresample():
@@ -681,22 +676,22 @@ def test_resample_timestamp_to_period(simple_date_range_series):
     result = ts.resample("A-DEC", kind="period").mean()
     expected = ts.resample("A-DEC").mean()
     expected.index = period_range("1990", "2000", freq="a-dec")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.resample("A-JUN", kind="period").mean()
     expected = ts.resample("A-JUN").mean()
     expected.index = period_range("1990", "2000", freq="a-jun")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.resample("M", kind="period").mean()
     expected = ts.resample("M").mean()
     expected.index = period_range("1990-01", "2000-01", freq="M")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.resample("M", kind="period").mean()
     expected = ts.resample("M").mean()
     expected.index = period_range("1990-01", "2000-01", freq="M")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_ohlc_5min():
@@ -728,8 +723,8 @@ def test_downsample_non_unique():
 
     expected = ts.groupby(lambda x: x.month).mean()
     assert len(result) == 2
-    assert_almost_equal(result[0], expected[1])
-    assert_almost_equal(result[1], expected[2])
+    tm.assert_almost_equal(result[0], expected[1])
+    tm.assert_almost_equal(result[1], expected[2])
 
 
 def test_asfreq_non_unique():
@@ -766,7 +761,7 @@ def test_resample_anchored_ticks():
     for freq in freqs:
         result = ts[2:].resample(freq, closed="left", label="left").mean()
         expected = ts.resample(freq, closed="left", label="left").mean()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
 
 def test_resample_single_group():
@@ -774,11 +769,11 @@ def test_resample_single_group():
 
     rng = date_range("2000-1-1", "2000-2-10", freq="D")
     ts = Series(np.random.randn(len(rng)), index=rng)
-    assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
+    tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
 
     rng = date_range("2000-1-1", "2000-1-10", freq="D")
     ts = Series(np.random.randn(len(rng)), index=rng)
-    assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
+    tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
 
     # GH 3849
     s = Series(
@@ -787,7 +782,7 @@ def test_resample_single_group():
     )
     expected = Series([0.75], index=[Timestamp("20070915")])
     result = s.resample("D").apply(lambda x: np.std(x))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_base():
@@ -809,7 +804,7 @@ def test_resample_float_base():
     base = 17 + 43.51 / 60
     result = s.resample("3min", base=base).size()
     expected = Series(3, index=pd.DatetimeIndex(["2018-11-26 16:17:43.51"]))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_daily_anchored():
@@ -819,7 +814,7 @@ def test_resample_daily_anchored():
 
     result = ts[2:].resample("D", closed="left", label="left").mean()
     expected = ts.resample("D", closed="left", label="left").mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_to_period_monthly_buglet():
@@ -844,7 +839,7 @@ def test_period_with_agg():
 
     expected = s2.to_timestamp().resample("D").mean().to_period()
     result = s2.resample("D").agg(lambda x: x.mean())
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_segfault():
@@ -862,7 +857,7 @@ def test_resample_segfault():
     ).set_index("timestamp")
     result = df.groupby("ID").resample("5min").sum()
     expected = df.groupby("ID").apply(lambda x: x.resample("5min").sum())
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_dtype_preservation():
@@ -909,7 +904,7 @@ def test_weekly_resample_buglet():
 
     resampled = ts.resample("W").mean()
     expected = ts.resample("W-SUN").mean()
-    assert_series_equal(resampled, expected)
+    tm.assert_series_equal(resampled, expected)
 
 
 def test_monthly_resample_error():
@@ -933,7 +928,7 @@ def test_nanosecond_resample_error():
     exp_indx = pd.date_range(start=pd.to_datetime(exp_start), periods=10, freq="100n")
     exp = Series(range(len(exp_indx)), index=exp_indx)
 
-    assert_series_equal(result, exp)
+    tm.assert_series_equal(result, exp)
 
 
 def test_resample_anchored_intraday(simple_date_range_series):
@@ -1051,7 +1046,7 @@ def test_resample_not_monotonic():
 
     result = ts.resample("D").sum()
     exp = ts.sort_index().resample("D").sum()
-    assert_series_equal(result, exp)
+    tm.assert_series_equal(result, exp)
 
 
 def test_resample_median_bug_1688():
@@ -1130,9 +1125,9 @@ def test_resample_consistency():
     r10 = s.resample("10Min").bfill()
 
     # s10_2, r10, r10_2, rl should all be equal
-    assert_series_equal(s10_2, r10)
-    assert_series_equal(s10_2, r10_2)
-    assert_series_equal(s10_2, rl)
+    tm.assert_series_equal(s10_2, r10)
+    tm.assert_series_equal(s10_2, r10_2)
+    tm.assert_series_equal(s10_2, rl)
 
 
 def test_resample_timegrouper():
@@ -1158,10 +1153,10 @@ def test_resample_timegrouper():
             name="A",
         )
         expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.groupby(pd.Grouper(freq="M", key="A")).count()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df = DataFrame(dict(A=dates, B=np.arange(len(dates)), C=np.arange(len(dates))))
         result = df.set_index("A").resample("M").count()
@@ -1170,10 +1165,10 @@ def test_resample_timegrouper():
             index=exp_idx,
             columns=["B", "C"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.groupby(pd.Grouper(freq="M", key="A")).count()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
 
 def test_resample_nunique():
@@ -1198,13 +1193,13 @@ def test_resample_nunique():
 
     for t in [r, g]:
         result = r.ID.nunique()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     result = df.ID.resample("D").nunique()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = df.ID.groupby(pd.Grouper(freq="D")).nunique()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_nunique_preserves_column_level_names():
@@ -1228,9 +1223,9 @@ def test_resample_nunique_with_date_gap():
     # Since all elements are unique, these should all be the same
     results = [r.count(), r.nunique(), r.agg(Series.nunique), r.agg("nunique")]
 
-    assert_series_equal(results[0], results[1])
-    assert_series_equal(results[0], results[2])
-    assert_series_equal(results[0], results[3])
+    tm.assert_series_equal(results[0], results[1])
+    tm.assert_series_equal(results[0], results[2])
+    tm.assert_series_equal(results[0], results[3])
 
 
 @pytest.mark.parametrize("n", [10000, 100000])
@@ -1259,7 +1254,7 @@ def test_resample_group_info(n, k):
     arr = np.bincount(bins[mask] - 1, minlength=len(ix)).astype("int64", copy=False)
     right = Series(arr, index=ix)
 
-    assert_series_equal(left, right)
+    tm.assert_series_equal(left, right)
 
 
 def test_resample_size():
@@ -1274,7 +1269,7 @@ def test_resample_size():
     val = np.bincount(bins, minlength=len(ix) + 1)[1:].astype("int64", copy=False)
 
     right = Series(val, index=ix)
-    assert_series_equal(left, right)
+    tm.assert_series_equal(left, right)
 
 
 def test_resample_across_dst():
@@ -1305,7 +1300,7 @@ def test_resample_across_dst():
     result = df.resample(rule="H").sum()
     expected = DataFrame([5, 5], index=dti2)
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_with_dst_time_change():
@@ -1322,18 +1317,18 @@ def test_groupby_with_dst_time_change():
 
     index = pd.DatetimeIndex(expected_index_values)
     expected = pd.DataFrame([1.0] + ([np.nan] * 21) + [2.0], index=index)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_dst_anchor():
     # 5172
     dti = DatetimeIndex([datetime(2012, 11, 4, 23)], tz="US/Eastern")
     df = DataFrame([5], index=dti)
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample(rule="D").sum(), DataFrame([5], index=df.index.normalize())
     )
     df.resample(rule="MS").sum()
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample(rule="MS").sum(),
         DataFrame([5], index=DatetimeIndex([datetime(2012, 11, 1)], tz="US/Eastern")),
     )
@@ -1343,7 +1338,7 @@ def test_resample_dst_anchor():
     df = DataFrame({"a": values, "b": values, "c": values}, index=dti, dtype="int64")
     how = {"a": "min", "b": "max", "c": "count"}
 
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample("W-MON").agg(how)[["a", "b", "c"]],
         DataFrame(
             {
@@ -1356,7 +1351,7 @@ def test_resample_dst_anchor():
         "W-MON Frequency",
     )
 
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample("2W-MON").agg(how)[["a", "b", "c"]],
         DataFrame(
             {
@@ -1371,7 +1366,7 @@ def test_resample_dst_anchor():
         "2W-MON Frequency",
     )
 
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample("MS").agg(how)[["a", "b", "c"]],
         DataFrame(
             {"a": [0, 48, 1538], "b": [47, 1537, 1586], "c": [48, 1490, 49]},
@@ -1380,7 +1375,7 @@ def test_resample_dst_anchor():
         "MS Frequency",
     )
 
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df.resample("2MS").agg(how)[["a", "b", "c"]],
         DataFrame(
             {"a": [0, 1538], "b": [1537, 1586], "c": [1538, 49]},
@@ -1390,7 +1385,7 @@ def test_resample_dst_anchor():
     )
 
     df_daily = df["10/26/2013":"10/29/2013"]
-    assert_frame_equal(
+    tm.assert_frame_equal(
         df_daily.resample("D").agg({"a": "min", "b": "max", "c": "count"})[
             ["a", "b", "c"]
         ],
@@ -1436,10 +1431,11 @@ def test_downsample_across_dst_weekly():
     tm.assert_frame_equal(result, expected)
 
     idx = pd.date_range("2013-04-01", "2013-05-01", tz="Europe/London", freq="H")
-    s = Series(index=idx)
+    s = Series(index=idx, dtype=np.float64)
     result = s.resample("W").mean()
     expected = Series(
-        index=pd.date_range("2013-04-07", freq="W", periods=5, tz="Europe/London")
+        index=pd.date_range("2013-04-07", freq="W", periods=5, tz="Europe/London"),
+        dtype=np.float64,
     )
     tm.assert_series_equal(result, expected)
 
@@ -1461,17 +1457,17 @@ def test_resample_with_nat():
         ["1970-01-01 00:00:00", "1970-01-01 00:00:01", "1970-01-01 00:00:02"]
     )
     frame_1s = DataFrame([3, 7, 11], index=index_1s)
-    assert_frame_equal(frame.resample("1s").mean(), frame_1s)
+    tm.assert_frame_equal(frame.resample("1s").mean(), frame_1s)
 
     index_2s = DatetimeIndex(["1970-01-01 00:00:00", "1970-01-01 00:00:02"])
     frame_2s = DataFrame([5, 11], index=index_2s)
-    assert_frame_equal(frame.resample("2s").mean(), frame_2s)
+    tm.assert_frame_equal(frame.resample("2s").mean(), frame_2s)
 
     index_3s = DatetimeIndex(["1970-01-01 00:00:00"])
     frame_3s = DataFrame([7], index=index_3s)
-    assert_frame_equal(frame.resample("3s").mean(), frame_3s)
+    tm.assert_frame_equal(frame.resample("3s").mean(), frame_3s)
 
-    assert_frame_equal(frame.resample("60s").mean(), frame_3s)
+    tm.assert_frame_equal(frame.resample("60s").mean(), frame_3s)
 
 
 def test_resample_datetime_values():
@@ -1513,7 +1509,7 @@ def f(data, add_arg):
     df = pd.DataFrame({"A": 1, "B": 2}, index=pd.date_range("2017", periods=10))
     result = df.groupby("A").resample("D").agg(f, multiplier)
     expected = df.groupby("A").resample("D").mean().multiply(multiplier)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("k", [1, 2, 3])
@@ -1543,7 +1539,7 @@ def test_resample_equivalent_offsets(n1, freq1, n2, freq2, k):
 
     result1 = s.resample(str(n1_) + freq1).mean()
     result2 = s.resample(str(n2_) + freq2).mean()
-    assert_series_equal(result1, result2)
+    tm.assert_series_equal(result1, result2)
 
 
 @pytest.mark.parametrize(
@@ -1570,3 +1566,20 @@ def test_get_timestamp_range_edges(first, last, offset, exp_first, exp_last):
     result = _get_timestamp_range_edges(first, last, offset)
     expected = (exp_first, exp_last)
     assert result == expected
+
+
+def test_resample_apply_product():
+    # GH 5586
+    index = date_range(start="2012-01-31", freq="M", periods=12)
+
+    ts = Series(range(12), index=index)
+    df = DataFrame(dict(A=ts, B=ts + 2))
+    result = df.resample("Q").apply(np.product)
+    expected = DataFrame(
+        np.array([[0, 24], [60, 210], [336, 720], [990, 1716]], dtype=np.int64),
+        index=DatetimeIndex(
+            ["2012-03-31", "2012-06-30", "2012-09-30", "2012-12-31"], freq="Q-DEC"
+        ),
+        columns=["A", "B"],
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 30febe3d2cc83..ff303b808f6f5 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -10,16 +10,11 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp
+import pandas._testing as tm
 from pandas.core.indexes.base import InvalidIndexError
 from pandas.core.indexes.datetimes import date_range
 from pandas.core.indexes.period import Period, PeriodIndex, period_range
 from pandas.core.resample import _get_period_range_edges
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
 
 import pandas.tseries.offsets as offsets
 
@@ -50,7 +45,7 @@ def test_asfreq(self, series_and_frame, freq, kind):
             new_index = date_range(start=start, end=end, freq=freq, closed="left")
             expected = obj.to_timestamp().reindex(new_index).to_period(freq)
         result = obj.resample(freq, kind=kind).asfreq()
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
     def test_asfreq_fill_value(self, series):
         # test for fill value during resampling, issue 3715
@@ -63,7 +58,7 @@ def test_asfreq_fill_value(self, series):
         )
         expected = s.to_timestamp().reindex(new_index, fill_value=4.0)
         result = s.resample("1H", kind="timestamp").asfreq(fill_value=4.0)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         frame = s.to_frame("value")
         new_index = date_range(
@@ -73,7 +68,7 @@ def test_asfreq_fill_value(self, series):
         )
         expected = frame.to_timestamp().reindex(new_index, fill_value=3.0)
         result = frame.resample("1H", kind="timestamp").asfreq(fill_value=3.0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("freq", ["H", "12H", "2D", "W"])
     @pytest.mark.parametrize("kind", [None, "period", "timestamp"])
@@ -87,9 +82,9 @@ def test_selection(self, index, freq, kind, kwargs):
             index=pd.MultiIndex.from_arrays([rng, index], names=["v", "d"]),
         )
         msg = (
-            "Resampling from level= or on= selection with a PeriodIndex is"
-            r" not currently supported, use \.set_index\(\.\.\.\) to"
-            " explicitly set index"
+            "Resampling from level= or on= selection with a PeriodIndex is "
+            r"not currently supported, use \.set_index\(\.\.\.\) to "
+            "explicitly set index"
         )
         with pytest.raises(NotImplementedError, match=msg):
             df.resample(freq, kind=kind, **kwargs)
@@ -108,7 +103,7 @@ def test_annual_upsample_cases(
         result = getattr(ts.resample(targ, convention=conv), meth)()
         expected = result.to_timestamp(targ, how=conv)
         expected = expected.asfreq(targ, meth).to_period()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_basic_downsample(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
@@ -116,11 +111,11 @@ def test_basic_downsample(self, simple_period_range_series):
 
         expected = ts.groupby(ts.index.year).mean()
         expected.index = period_range("1/1/1990", "6/30/1995", freq="a-dec")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # this is ok
-        assert_series_equal(ts.resample("a-dec").mean(), result)
-        assert_series_equal(ts.resample("a").mean(), result)
+        tm.assert_series_equal(ts.resample("a-dec").mean(), result)
+        tm.assert_series_equal(ts.resample("a").mean(), result)
 
     @pytest.mark.parametrize(
         "rule,expected_error_msg",
@@ -135,8 +130,8 @@ def test_not_subperiod(self, simple_period_range_series, rule, expected_error_ms
         # These are incompatible period rules for resampling
         ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="w-wed")
         msg = (
-            "Frequency <Week: weekday=2> cannot be resampled to {}, as they"
-            " are not sub or super periods"
+            "Frequency <Week: weekday=2> cannot be resampled to {}, as they "
+            "are not sub or super periods"
         ).format(expected_error_msg)
         with pytest.raises(IncompatibleFrequency, match=msg):
             ts.resample(rule).mean()
@@ -149,7 +144,7 @@ def test_basic_upsample(self, freq, simple_period_range_series):
         resampled = result.resample(freq, convention="end").ffill()
         expected = result.to_timestamp(freq, how="end")
         expected = expected.asfreq(freq, "ffill").to_period(freq)
-        assert_series_equal(resampled, expected)
+        tm.assert_series_equal(resampled, expected)
 
     def test_upsample_with_limit(self):
         rng = period_range("1/1/2000", periods=5, freq="A")
@@ -157,14 +152,14 @@ def test_upsample_with_limit(self):
 
         result = ts.resample("M", convention="end").ffill(limit=2)
         expected = ts.asfreq("M").reindex(result.index, method="ffill", limit=2)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_annual_upsample(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="A-DEC")
         df = DataFrame({"a": ts})
         rdf = df.resample("D").ffill()
         exp = df["a"].resample("D").ffill()
-        assert_series_equal(rdf["a"], exp)
+        tm.assert_series_equal(rdf["a"], exp)
 
         rng = period_range("2000", "2003", freq="A-DEC")
         ts = Series([1, 2, 3, 4], index=rng)
@@ -173,7 +168,7 @@ def test_annual_upsample(self, simple_period_range_series):
         ex_index = period_range("2000-01", "2003-12", freq="M")
 
         expected = ts.asfreq("M", how="start").reindex(ex_index, method="ffill")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("month", MONTHS)
     @pytest.mark.parametrize("target", ["D", "B", "M"])
@@ -186,7 +181,7 @@ def test_quarterly_upsample(
         result = ts.resample(target, convention=convention).ffill()
         expected = result.to_timestamp(target, how=convention)
         expected = expected.asfreq(target, "ffill").to_period()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("target", ["D", "B"])
     @pytest.mark.parametrize("convention", ["start", "end"])
@@ -195,7 +190,7 @@ def test_monthly_upsample(self, target, convention, simple_period_range_series):
         result = ts.resample(target, convention=convention).ffill()
         expected = result.to_timestamp(target, how=convention)
         expected = expected.asfreq(target, "ffill").to_period()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_basic(self):
         # GH3609
@@ -211,9 +206,9 @@ def test_resample_basic(self):
         )
         expected = Series([34.5, 79.5], index=index)
         result = s.to_period().resample("T", kind="period").mean()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result2 = s.resample("T", kind="period").mean()
-        assert_series_equal(result2, expected)
+        tm.assert_series_equal(result2, expected)
 
     @pytest.mark.parametrize(
         "freq,expected_vals", [("M", [31, 29, 31, 9]), ("2M", [31 + 29, 31 + 9])]
@@ -226,7 +221,7 @@ def test_resample_count(self, freq, expected_vals):
             start="2000", freq=freq, periods=len(expected_vals)
         )
         expected = Series(expected_vals, index=expected_index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_same_freq(self, resample_method):
 
@@ -237,12 +232,12 @@ def test_resample_same_freq(self, resample_method):
         expected = series
 
         result = getattr(series.resample("M"), resample_method)()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_incompat_freq(self):
         msg = (
-            "Frequency <MonthEnd> cannot be resampled to <Week: weekday=6>,"
-            " as they are not sub or super periods"
+            "Frequency <MonthEnd> cannot be resampled to <Week: weekday=6>, "
+            "as they are not sub or super periods"
         )
         with pytest.raises(IncompatibleFrequency, match=msg):
             Series(
@@ -268,7 +263,7 @@ def test_with_local_timezone_pytz(self):
         # Pacific
         expected_index = pd.period_range(start=start, end=end, freq="D") - offsets.Day()
         expected = Series(1, index=expected_index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_with_pytz(self):
         # GH 13238
@@ -279,7 +274,7 @@ def test_resample_with_pytz(self):
         expected = Series(
             2, index=pd.DatetimeIndex(["2017-01-01", "2017-01-02"], tz="US/Eastern")
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         # Especially assert that the timezone is LMT for pytz
         assert result.index.tz == pytz.timezone("US/Eastern")
 
@@ -308,7 +303,7 @@ def test_with_local_timezone_dateutil(self):
             pd.period_range(start=start, end=end, freq="D", name="idx") - offsets.Day()
         )
         expected = Series(1, index=expected_index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_nonexistent_time_bin_edge(self):
         # GH 19375
@@ -350,7 +345,7 @@ def test_fill_method_and_how_upsample(self):
         )
         last = s.resample("M").ffill()
         both = s.resample("M").ffill().resample("M").last().astype("int64")
-        assert_series_equal(last, both)
+        tm.assert_series_equal(last, both)
 
     @pytest.mark.parametrize("day", DAYS)
     @pytest.mark.parametrize("target", ["D", "B"])
@@ -361,14 +356,14 @@ def test_weekly_upsample(self, day, target, convention, simple_period_range_seri
         result = ts.resample(target, convention=convention).ffill()
         expected = result.to_timestamp(target, how=convention)
         expected = expected.asfreq(target, "ffill").to_period()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_to_timestamps(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
 
         result = ts.resample("A-DEC", kind="timestamp").mean()
         expected = ts.to_timestamp(how="start").resample("A-DEC").mean()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_to_quarterly(self, simple_period_range_series):
         for month in MONTHS:
@@ -387,7 +382,7 @@ def test_resample_to_quarterly(self, simple_period_range_series):
             expected = stamps.reindex(qdates.to_timestamp("D", "s"), method="ffill")
             expected.index = qdates
 
-            assert_series_equal(quar_ts, expected)
+            tm.assert_series_equal(quar_ts, expected)
 
         # conforms, but different month
         ts = simple_period_range_series("1990", "1992", freq="A-JUN")
@@ -400,7 +395,7 @@ def test_resample_to_quarterly(self, simple_period_range_series):
             # .to_timestamp('D')
             # expected = expected.resample('Q-MAR').ffill()
 
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
     def test_resample_fill_missing(self):
         rng = PeriodIndex([2000, 2005, 2007, 2009], freq="A")
@@ -410,7 +405,7 @@ def test_resample_fill_missing(self):
         stamps = s.to_timestamp()
         filled = s.resample("A").ffill()
         expected = stamps.resample("A").ffill().to_period("A")
-        assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled, expected)
 
     def test_cant_fill_missing_dups(self):
         rng = PeriodIndex([2000, 2005, 2005, 2007, 2007], freq="A")
@@ -428,20 +423,20 @@ def test_resample_5minute(self, freq, kind):
         if kind != "timestamp":
             expected = expected.to_period(freq)
         result = ts.resample(freq, kind=kind).mean()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_upsample_daily_business_daily(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/2000", "2/1/2000", freq="B")
 
         result = ts.resample("D").asfreq()
         expected = ts.asfreq("D").reindex(period_range("1/3/2000", "2/1/2000"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         ts = simple_period_range_series("1/1/2000", "2/1/2000")
         result = ts.resample("H", convention="s").asfreq()
         exp_rng = period_range("1/1/2000", "2/1/2000 23:00", freq="H")
         expected = ts.asfreq("H", how="s").reindex(exp_rng)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_irregular_sparse(self):
         dr = date_range(start="1/1/2012", freq="5min", periods=1000)
@@ -451,7 +446,7 @@ def test_resample_irregular_sparse(self):
 
         result = subset.resample("10min").apply(len)
         expected = s.resample("10min").apply(len).loc[result.index]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_weekly_all_na(self):
         rng = date_range("1/1/2000", periods=10, freq="W-WED")
@@ -463,7 +458,7 @@ def test_resample_weekly_all_na(self):
 
         result = ts.resample("W-THU").asfreq().ffill()[:-1]
         expected = ts.asfreq("W-THU").ffill()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_resample_tz_localized(self):
         dr = date_range(start="2012-4-13", end="2012-5-1")
@@ -481,7 +476,7 @@ def test_resample_tz_localized(self):
 
         exp = ts_local_naive.resample("W").mean().tz_localize("America/Los_Angeles")
 
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
         # it works
         result = ts_local.resample("D").mean()
@@ -496,13 +491,13 @@ def test_resample_tz_localized(self):
         ex_index = date_range("2001-09-21", periods=1, freq="D", tz="Australia/Sydney")
         expected = Series([1.5], index=ex_index)
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # for good measure
         result = s.resample("D", kind="period").mean()
         ex_index = period_range("2001-09-20", periods=1, freq="D")
         expected = Series([1.5], index=ex_index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 6397
         # comparing an offset that doesn't propagate tz's
@@ -523,7 +518,7 @@ def test_resample_tz_localized(self):
             .agg({"first": np.sum, "second": np.mean})
             .reindex(columns=["first", "second"])
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_closed_left_corner(self):
         # #1465
@@ -535,7 +530,7 @@ def test_closed_left_corner(self):
 
         result = s.resample("10min", closed="left", label="right").mean()
         exp = s[1:].resample("10min", closed="left", label="right").mean()
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
         result = s.resample("10min", closed="left", label="left").mean()
         exp = s[1:].resample("10min", closed="left", label="left").mean()
@@ -543,7 +538,7 @@ def test_closed_left_corner(self):
         ex_index = date_range(start="1/1/2012 9:30", freq="10min", periods=3)
 
         tm.assert_index_equal(result.index, ex_index)
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_quarterly_resampling(self):
         rng = period_range("2000Q1", periods=10, freq="Q-DEC")
@@ -551,7 +546,7 @@ def test_quarterly_resampling(self):
 
         result = ts.resample("A").mean()
         exp = ts.to_timestamp().resample("A").mean().to_period()
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_resample_weekly_bug_1726(self):
         # 8/6/12 is a Monday
@@ -595,11 +590,11 @@ def test_resample_with_dst_time_change(self):
             [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0],
             index=index,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_resample_bms_2752(self):
         # GH2753
-        foo = Series(index=pd.bdate_range("20000101", "20000201"))
+        foo = Series(index=pd.bdate_range("20000101", "20000201"), dtype=np.float64)
         res1 = foo.resample("BMS").mean()
         res2 = foo.resample("BMS").mean().resample("B").mean()
         assert res1.index[0] == Timestamp("20000103")
@@ -616,7 +611,7 @@ def test_resample_bms_2752(self):
 
     #     result = ts.resample('D', convention='span').mean()
 
-    #     assert_series_equal(result, expected)
+    #     tm.assert_series_equal(result, expected)
 
     def test_default_right_closed_label(self):
         end_freq = ["D", "Q", "M", "D"]
@@ -627,7 +622,7 @@ def test_default_right_closed_label(self):
             df = DataFrame(np.random.randn(len(idx), 2), idx)
 
             resampled = df.resample(to_freq).mean()
-            assert_frame_equal(
+            tm.assert_frame_equal(
                 resampled, df.resample(to_freq, closed="right", label="right").mean()
             )
 
@@ -640,7 +635,7 @@ def test_default_left_closed_label(self):
             df = DataFrame(np.random.randn(len(idx), 2), idx)
 
             resampled = df.resample(to_freq).mean()
-            assert_frame_equal(
+            tm.assert_frame_equal(
                 resampled, df.resample(to_freq, closed="left", label="left").mean()
             )
 
@@ -660,7 +655,7 @@ def test_evenly_divisible_with_no_extra_bins(self):
         result = df.resample("5D").mean()
         expected = pd.concat([df.iloc[0:5].mean(), df.iloc[5:].mean()], axis=1).T
         expected.index = [Timestamp("2000-1-1"), Timestamp("2000-1-6")]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         index = date_range(start="2001-5-4", periods=28)
         df = DataFrame(
@@ -702,7 +697,7 @@ def test_evenly_divisible_with_no_extra_bins(self):
             index=index,
         )
         result = df.resample("7D").count()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
             [
@@ -718,7 +713,7 @@ def test_evenly_divisible_with_no_extra_bins(self):
             index=index,
         )
         result = df.resample("7D").sum()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("kind", ["period", None, "timestamp"])
     @pytest.mark.parametrize("agg_arg", ["mean", {"value": "mean"}, ["mean"]])
@@ -737,12 +732,9 @@ def test_loffset_returns_datetimeindex(self, frame, kind, agg_arg):
         expected = DataFrame({"value": expected_means}, index=expected_index)
 
         result_agg = df.resample("2D", loffset="2H", kind=kind).agg(agg_arg)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result_how = df.resample("2D", how=agg_arg, loffset="2H", kind=kind)
         if isinstance(agg_arg, list):
             expected.columns = pd.MultiIndex.from_tuples([("value", "mean")])
-        assert_frame_equal(result_agg, expected)
-        assert_frame_equal(result_how, expected)
+        tm.assert_frame_equal(result_agg, expected)
 
     @pytest.mark.parametrize("freq, period_mult", [("H", 24), ("12H", 2)])
     @pytest.mark.parametrize("kind", [None, "period"])
@@ -757,7 +749,7 @@ def test_upsampling_ohlc(self, freq, period_mult, kind):
         new_index = period_range(start="2000", freq=freq, periods=period_mult * len(pi))
         expected = expected.reindex(new_index)
         result = s.resample(freq, kind=kind).ohlc()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "periods, values",
@@ -807,7 +799,7 @@ def test_resample_with_nat(self, periods, values, freq, expected_values):
         )
         expected = DataFrame(expected_values, index=expected_index)
         result = frame.resample(freq).mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_resample_with_only_nat(self):
         # GH 13224
@@ -816,7 +808,7 @@ def test_resample_with_only_nat(self):
         expected_index = PeriodIndex(data=[], freq=pi.freq)
         expected = DataFrame(index=expected_index)
         result = frame.resample("1s").mean()
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "start,end,start_freq,end_freq,base",
@@ -848,7 +840,7 @@ def test_resample_with_non_zero_base(self, start, end, start_freq, end_freq, bas
         # to_timestamp casts 24H -> D
         result = result.asfreq(end_freq) if end_freq == "24H" else result
         expected = s.to_timestamp().resample(end_freq, base=base).mean()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "first,last,offset,exp_first,exp_last",
@@ -878,3 +870,15 @@ def test_get_period_range_edges(self, first, last, offset, exp_first, exp_last):
         result = _get_period_range_edges(first, last, offset)
         expected = (exp_first, exp_last)
         assert result == expected
+
+    def test_sum_min_count(self):
+        # GH 19974
+        index = pd.date_range(start="2018", freq="M", periods=6)
+        data = np.ones(6)
+        data[3:6] = np.nan
+        s = pd.Series(data, index).to_period()
+        result = s.resample("Q").sum(min_count=1)
+        expected = pd.Series(
+            [3.0, np.nan], index=PeriodIndex(["2018Q1", "2018Q2"], freq="Q-DEC")
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 94bc884d66835..d552241f9126f 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -6,9 +6,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 dti = date_range(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="Min")
 
@@ -64,7 +63,7 @@ def test_groupby_resample_api():
     index = pd.MultiIndex.from_arrays([[1] * 8 + [2] * 8, i], names=["group", "date"])
     expected = DataFrame({"val": [5] * 7 + [6] + [7] * 7 + [8]}, index=index)
     result = df.groupby("group").apply(lambda x: x.resample("1D").ffill())[["val"]]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_groupby_resample_on_api():
@@ -83,7 +82,7 @@ def test_groupby_resample_on_api():
     expected = df.set_index("dates").groupby("key").resample("D").mean()
 
     result = df.groupby("key").resample("D", on="dates").mean()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_pipe(test_frame):
@@ -158,11 +157,11 @@ def tests_skip_nuisance(test_frame):
     r = df.resample("H")
     result = r[["A", "B"]].sum()
     expected = pd.concat([r.A.sum(), r.B.sum()], axis=1)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     expected = r[["A", "B", "C"]].sum()
     result = r.sum()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_downsample_but_actually_upsampling():
@@ -175,12 +174,12 @@ def test_downsample_but_actually_upsampling():
         [0, 20, 40, 60, 80],
         index=pd.date_range("2012-01-01 00:00:00", freq="20s", periods=5),
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_combined_up_downsampling_of_irregular():
 
-    # since we are reallydoing an operation like this
+    # since we are really doing an operation like this
     # ts2.resample('2s').mean().ffill()
     # preserve these semantics
 
@@ -188,10 +187,50 @@ def test_combined_up_downsampling_of_irregular():
     ts = Series(np.arange(len(rng)), index=rng)
     ts2 = ts.iloc[[0, 1, 2, 3, 5, 7, 11, 15, 16, 25, 30]]
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = ts2.resample("2s", how="mean", fill_method="ffill")
-    expected = ts2.resample("2s").mean().ffill()
-    assert_series_equal(result, expected)
+    result = ts2.resample("2s").mean().ffill()
+    expected = Series(
+        [
+            0.5,
+            2.5,
+            5.0,
+            7.0,
+            7.0,
+            11.0,
+            11.0,
+            15.0,
+            16.0,
+            16.0,
+            16.0,
+            16.0,
+            25.0,
+            25.0,
+            25.0,
+            30.0,
+        ],
+        index=pd.DatetimeIndex(
+            [
+                "2012-01-01 00:00:00",
+                "2012-01-01 00:00:02",
+                "2012-01-01 00:00:04",
+                "2012-01-01 00:00:06",
+                "2012-01-01 00:00:08",
+                "2012-01-01 00:00:10",
+                "2012-01-01 00:00:12",
+                "2012-01-01 00:00:14",
+                "2012-01-01 00:00:16",
+                "2012-01-01 00:00:18",
+                "2012-01-01 00:00:20",
+                "2012-01-01 00:00:22",
+                "2012-01-01 00:00:24",
+                "2012-01-01 00:00:26",
+                "2012-01-01 00:00:28",
+                "2012-01-01 00:00:30",
+            ],
+            dtype="datetime64[ns]",
+            freq="2S",
+        ),
+    )
+    tm.assert_series_equal(result, expected)
 
 
 def test_transform():
@@ -199,7 +238,7 @@ def test_transform():
     r = test_series.resample("20min")
     expected = test_series.groupby(pd.Grouper(freq="20min")).transform("mean")
     result = r.transform("mean")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_fillna():
@@ -211,15 +250,15 @@ def test_fillna():
 
     expected = r.ffill()
     result = r.fillna(method="ffill")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     expected = r.bfill()
     result = r.fillna(method="bfill")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     msg = (
-        r"Invalid fill method\. Expecting pad \(ffill\), backfill"
-        r" \(bfill\) or nearest\. Got 0"
+        r"Invalid fill method\. Expecting pad \(ffill\), backfill "
+        r"\(bfill\) or nearest\. Got 0"
     )
     with pytest.raises(ValueError, match=msg):
         r.fillna(0)
@@ -233,7 +272,7 @@ def test_apply_without_aggregation():
 
     for t in [g, r]:
         result = t.apply(lambda x: x)
-        assert_series_equal(result, test_series)
+        tm.assert_series_equal(result, test_series)
 
 
 def test_agg_consistency():
@@ -248,10 +287,9 @@ def test_agg_consistency():
 
     r = df.resample("3T")
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        expected = r[["A", "B", "C"]].agg({"r1": "mean", "r2": "sum"})
-        result = r.agg({"r1": "mean", "r2": "sum"})
-    assert_frame_equal(result, expected, check_like=True)
+    msg = "nested renamer is not supported"
+    with pytest.raises(pd.core.base.SpecificationError, match=msg):
+        r.agg({"r1": "mean", "r2": "sum"})
 
 
 # TODO: once GH 14008 is fixed, move these tests into
@@ -289,45 +327,42 @@ def test_agg():
     expected.columns = pd.MultiIndex.from_product([["A", "B"], ["mean", "std"]])
     for t in cases:
         result = t.aggregate([np.mean, np.std])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     expected = pd.concat([a_mean, b_std], axis=1)
     for t in cases:
         result = t.aggregate({"A": np.mean, "B": np.std})
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     expected = pd.concat([a_mean, a_std], axis=1)
     expected.columns = pd.MultiIndex.from_tuples([("A", "mean"), ("A", "std")])
     for t in cases:
         result = t.aggregate({"A": ["mean", "std"]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     expected = pd.concat([a_mean, a_sum], axis=1)
     expected.columns = ["mean", "sum"]
     for t in cases:
         result = t["A"].aggregate(["mean", "sum"])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
-    expected = pd.concat([a_mean, a_sum], axis=1)
-    expected.columns = pd.MultiIndex.from_tuples([("A", "mean"), ("A", "sum")])
+    msg = "nested renamer is not supported"
     for t in cases:
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t.aggregate({"A": {"mean": "mean", "sum": "sum"}})
-        assert_frame_equal(result, expected, check_like=True)
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t.aggregate({"A": {"mean": "mean", "sum": "sum"}})
 
     expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
     expected.columns = pd.MultiIndex.from_tuples(
         [("A", "mean"), ("A", "sum"), ("B", "mean2"), ("B", "sum2")]
     )
     for t in cases:
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t.aggregate(
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t.aggregate(
                 {
                     "A": {"mean": "mean", "sum": "sum"},
                     "B": {"mean2": "mean", "sum2": "sum"},
                 }
             )
-        assert_frame_equal(result, expected, check_like=True)
 
     expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1)
     expected.columns = pd.MultiIndex.from_tuples(
@@ -335,7 +370,7 @@ def test_agg():
     )
     for t in cases:
         result = t.aggregate({"A": ["mean", "std"], "B": ["mean", "std"]})
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
     expected.columns = pd.MultiIndex.from_tuples(
@@ -374,7 +409,7 @@ def test_agg_misc():
         result = t.agg({"A": np.sum, "B": lambda x: np.std(x, ddof=1)})
         rcustom = t["B"].apply(lambda x: np.std(x, ddof=1))
         expected = pd.concat([r["A"].sum(), rcustom], axis=1)
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     # agg with renamers
     expected = pd.concat(
@@ -384,12 +419,10 @@ def test_agg_misc():
         [("result1", "A"), ("result1", "B"), ("result2", "A"), ("result2", "B")]
     )
 
+    msg = "nested renamer is not supported"
     for t in cases:
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t[["A", "B"]].agg(
-                OrderedDict([("result1", np.sum), ("result2", np.mean)])
-            )
-        assert_frame_equal(result, expected, check_like=True)
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t[["A", "B"]].agg(OrderedDict([("result1", np.sum), ("result2", np.mean)]))
 
     # agg with different hows
     expected = pd.concat(
@@ -400,30 +433,20 @@ def test_agg_misc():
     )
     for t in cases:
         result = t.agg(OrderedDict([("A", ["sum", "std"]), ("B", ["mean", "std"])]))
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     # equivalent of using a selection list / or not
     for t in cases:
         result = t[["A", "B"]].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
-        assert_frame_equal(result, expected, check_like=True)
+        tm.assert_frame_equal(result, expected, check_like=True)
 
     # series like aggs
     for t in cases:
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t["A"].agg({"A": ["sum", "std"]})
-        expected = pd.concat([t["A"].sum(), t["A"].std()], axis=1)
-        expected.columns = pd.MultiIndex.from_tuples([("A", "sum"), ("A", "std")])
-        assert_frame_equal(result, expected, check_like=True)
-
-        expected = pd.concat(
-            [t["A"].agg(["sum", "std"]), t["A"].agg(["mean", "std"])], axis=1
-        )
-        expected.columns = pd.MultiIndex.from_tuples(
-            [("A", "sum"), ("A", "std"), ("B", "mean"), ("B", "std")]
-        )
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t["A"].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
-        assert_frame_equal(result, expected, check_like=True)
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t["A"].agg({"A": ["sum", "std"]})
+
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t["A"].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
 
     # errors
     # invalid names in the agg specification
@@ -452,28 +475,20 @@ def test_agg_nested_dicts():
         df.groupby(pd.Grouper(freq="2D")),
     ]
 
-    msg = r"cannot perform renaming for r(1|2) with a nested dictionary"
+    msg = "nested renamer is not supported"
     for t in cases:
         with pytest.raises(pd.core.base.SpecificationError, match=msg):
             t.aggregate({"r1": {"A": ["mean", "sum"]}, "r2": {"B": ["mean", "sum"]}})
 
     for t in cases:
-        expected = pd.concat(
-            [t["A"].mean(), t["A"].std(), t["B"].mean(), t["B"].std()], axis=1
-        )
-        expected.columns = pd.MultiIndex.from_tuples(
-            [("ra", "mean"), ("ra", "std"), ("rb", "mean"), ("rb", "std")]
-        )
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t[["A", "B"]].agg(
+
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t[["A", "B"]].agg(
                 {"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}}
             )
-        assert_frame_equal(result, expected, check_like=True)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = t.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
-        assert_frame_equal(result, expected, check_like=True)
+        with pytest.raises(pd.core.base.SpecificationError, match=msg):
+            t.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
 
 
 def test_try_aggregate_non_existing_column():
@@ -504,8 +519,8 @@ def test_selection_api_validation():
 
     # non DatetimeIndex
     msg = (
-        "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex,"
-        " but got an instance of 'Int64Index'"
+        "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, "
+        "but got an instance of 'Int64Index'"
     )
     with pytest.raises(TypeError, match=msg):
         df.resample("2D", level="v")
@@ -524,8 +539,8 @@ def test_selection_api_validation():
 
     # upsampling not allowed
     msg = (
-        "Upsampling from level= or on= selection is not supported, use"
-        r" \.set_index\(\.\.\.\) to explicitly set index to datetime-like"
+        "Upsampling from level= or on= selection is not supported, use "
+        r"\.set_index\(\.\.\.\) to explicitly set index to datetime-like"
     )
     with pytest.raises(ValueError, match=msg):
         df.resample("2D", level="d").asfreq()
@@ -534,10 +549,10 @@ def test_selection_api_validation():
 
     exp = df_exp.resample("2D").sum()
     exp.index.name = "date"
-    assert_frame_equal(exp, df.resample("2D", on="date").sum())
+    tm.assert_frame_equal(exp, df.resample("2D", on="date").sum())
 
     exp.index.name = "d"
-    assert_frame_equal(exp, df.resample("2D", level="d").sum())
+    tm.assert_frame_equal(exp, df.resample("2D", level="d").sum())
 
 
 @pytest.mark.parametrize(
@@ -564,4 +579,4 @@ def test_agg_with_datetime_index_list_agg_func(col_name):
         ),
         columns=pd.MultiIndex(levels=[[col_name], ["mean"]], codes=[[0], [0]]),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index 9053a7ebfea2b..03c1445e099a0 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -2,11 +2,12 @@
 
 import numpy as np
 
+from pandas.util._test_decorators import async_mark
+
 import pandas as pd
 from pandas import DataFrame, Series, Timestamp
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 test_frame = DataFrame(
     {"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)},
@@ -14,17 +15,18 @@
 )
 
 
-def test_tab_complete_ipython6_warning(ip):
+@async_mark()
+async def test_tab_complete_ipython6_warning(ip):
     from IPython.core.completer import provisionalcompleter
 
     code = dedent(
         """\
-    import pandas.util.testing as tm
+    import pandas._testing as tm
     s = tm.makeTimeSeries()
     rs = s.resample("D")
     """
     )
-    ip.run_code(code)
+    await ip.run_code(code)
 
     with tm.assert_produces_warning(None):
         with provisionalcompleter("ignore"):
@@ -56,7 +58,7 @@ def f(x):
 
     expected = df.groupby("id").apply(f)
     result = df.set_index("date").groupby("id").resample("D").asfreq()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     df = DataFrame(
         {
@@ -71,7 +73,7 @@ def f(x):
 
     expected = df.groupby("group").apply(f)
     result = df.groupby("group").resample("1D").ffill()
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_getitem():
@@ -80,13 +82,13 @@ def test_getitem():
     expected = g.B.apply(lambda x: x.resample("2s").mean())
 
     result = g.resample("2s").B.mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = g.B.resample("2s").mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = g.resample("2s").mean().B
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_getitem_multiple():
@@ -105,10 +107,10 @@ def test_getitem_multiple():
         ),
         name="buyer",
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = r["buyer"].count()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_resample_on_api_with_getitem():
@@ -118,7 +120,7 @@ def test_groupby_resample_on_api_with_getitem():
     )
     exp = df.set_index("date").groupby("id").resample("2D")["data"].sum()
     result = df.groupby("id").resample("2D", on="date")["data"].sum()
-    assert_series_equal(result, exp)
+    tm.assert_series_equal(result, exp)
 
 
 def test_nearest():
@@ -144,7 +146,7 @@ def test_nearest():
             freq="20S",
         ),
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_methods():
@@ -154,37 +156,37 @@ def test_methods():
     for f in ["first", "last", "median", "sem", "sum", "mean", "min", "max"]:
         result = getattr(r, f)()
         expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     for f in ["size"]:
         result = getattr(r, f)()
         expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     for f in ["count"]:
         result = getattr(r, f)()
         expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     # series only
     for f in ["nunique"]:
         result = getattr(r.B, f)()
         expected = g.B.apply(lambda x: getattr(x.resample("2s"), f)())
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     for f in ["nearest", "backfill", "ffill", "asfreq"]:
         result = getattr(r, f)()
         expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     result = r.ohlc()
     expected = g.apply(lambda x: x.resample("2s").ohlc())
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     for f in ["std", "var"]:
         result = getattr(r, f)(ddof=1)
         expected = g.apply(lambda x: getattr(x.resample("2s"), f)(ddof=1))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
 
 def test_apply():
@@ -199,13 +201,13 @@ def f(x):
         return x.resample("2s").sum()
 
     result = r.apply(f)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     def f(x):
         return x.resample("2s").apply(lambda y: y.sum())
 
     result = g.apply(f)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_apply_with_mutated_index():
@@ -220,12 +222,29 @@ def f(x):
     expected = df.groupby(pd.Grouper(freq="M")).apply(f)
 
     result = df.resample("M").apply(f)
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # A case for series
     expected = df["col1"].groupby(pd.Grouper(freq="M")).apply(f)
     result = df["col1"].resample("M").apply(f)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_columns_multilevel():
+    # GH 16231
+    cols = pd.MultiIndex.from_tuples([("A", "a", "", "one"), ("B", "b", "i", "two")])
+    ind = date_range(start="2017-01-01", freq="15Min", periods=8)
+    df = DataFrame(np.array([0] * 16).reshape(8, 2), index=ind, columns=cols)
+    agg_dict = {col: (np.sum if col[3] == "one" else np.mean) for col in df.columns}
+    result = df.resample("H").apply(lambda x: agg_dict[x.name](x))
+    expected = DataFrame(
+        np.array([0] * 4).reshape(2, 2),
+        index=date_range(start="2017-01-01", freq="1H", periods=2),
+        columns=pd.MultiIndex.from_tuples(
+            [("A", "a", "", "one"), ("B", "b", "i", "two")]
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_groupby_with_label():
@@ -245,7 +264,7 @@ def test_resample_groupby_with_label():
         data={"col0": [0, 0, 2, 2], "col1": [1, 1, 2, 1]}, index=mindex
     )
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_consistency_with_window():
@@ -275,4 +294,4 @@ def test_median_duplicate_columns():
     expected = df2.resample("5s").median()
     result = df.resample("5s").median()
     expected.columns = result.columns
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 648d78d92e7d4..3aa7765954634 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -6,10 +6,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 test_series = Series(np.random.randn(1000), index=date_range("1/1/2000", periods=1000))
 
@@ -27,7 +26,7 @@ def f(x):
 
     applied.index = applied.index.droplevel(0)
     expected.index = expected.index.droplevel(0)
-    assert_series_equal(applied, expected)
+    tm.assert_series_equal(applied, expected)
 
 
 def test_count():
@@ -38,11 +37,11 @@ def test_count():
     grouper = Grouper(freq="A", label="right", closed="right")
     result = test_series.groupby(grouper).count()
     expected.index = result.index
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = test_series.resample("A").count()
     expected.index = result.index
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_numpy_reduction():
@@ -51,7 +50,7 @@ def test_numpy_reduction():
     expected = test_series.groupby(lambda x: x.year).agg(np.prod)
     expected.index = result.index
 
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_apply_iteration():
@@ -90,7 +89,7 @@ def test_fails_on_no_datetime_index(name, func):
 
     msg = (
         "Only valid with DatetimeIndex, TimedeltaIndex "
-        "or PeriodIndex, but got an instance of '{}'".format(name)
+        f"or PeriodIndex, but got an instance of '{name}'"
     )
     with pytest.raises(TypeError, match=msg):
         df.groupby(Grouper(freq="D"))
@@ -153,7 +152,7 @@ def test_aggregate_normal(resample_method):
         expected.index = date_range(start='2013-01-01',
                                     freq='D', periods=5, name='key')
         dt_result = getattr(dt_grouped, func)(3)
-        assert_frame_equal(expected, dt_result)
+        tm.assert_frame_equal(expected, dt_result)
     """
 
 
@@ -210,7 +209,7 @@ def test_aggregate_with_nat(func, fill_value):
     expected = normal_result.append(pad)
     expected = expected.sort_index()
     expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
-    assert_frame_equal(expected, dt_result)
+    tm.assert_frame_equal(expected, dt_result)
     assert dt_result.index.name == "key"
 
 
@@ -240,7 +239,7 @@ def test_aggregate_with_nat_size():
     expected = normal_result.append(pad)
     expected = expected.sort_index()
     expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
-    assert_series_equal(expected, dt_result)
+    tm.assert_series_equal(expected, dt_result)
     assert dt_result.index.name == "key"
 
 
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index 9ce419d5cd20a..a4d14f127b80e 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -4,9 +4,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.indexes.timedeltas import timedelta_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 def test_asfreq_bug():
@@ -16,7 +15,7 @@ def test_asfreq_bug():
         data=[1, np.nan, np.nan, 3],
         index=timedelta_range("0 day", periods=4, freq="1T"),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_with_nat():
@@ -27,7 +26,7 @@ def test_resample_with_nat():
         {"value": [2.5, np.nan, 5.0]},
         index=timedelta_range("0 day", periods=3, freq="1S"),
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_resample_as_freq_with_subperiod():
@@ -53,11 +52,11 @@ def test_resample_with_timedeltas():
     )
     result = df.resample("30T").sum()
 
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     s = df["A"]
     result = s.resample("30T").sum()
-    assert_series_equal(result, expected["A"])
+    tm.assert_series_equal(result, expected["A"])
 
 
 def test_resample_single_period_timedelta():
@@ -67,7 +66,7 @@ def test_resample_single_period_timedelta():
     expected = Series(
         [1, 5, 4], index=pd.timedelta_range("1 day", freq="2s", periods=3)
     )
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_timedelta_idempotency():
@@ -77,7 +76,7 @@ def test_resample_timedelta_idempotency():
     series = Series(range(9), index=index)
     result = series.resample("10L").mean()
     expected = series
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_resample_base_with_timedeltaindex():
@@ -106,7 +105,7 @@ def test_resample_categorical_data_with_timedeltaindex():
         index=pd.to_timedelta([0, 10], unit="s"),
     )
     expected = expected.reindex(["Group_obj", "Group"], axis=1)
-    expected["Group"] = expected["Group_obj"].astype("category")
+    expected["Group"] = expected["Group_obj"]
     tm.assert_frame_equal(result, expected)
 
 
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 305d7b9781634..7020d373caf82 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -6,9 +6,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, concat, merge
+import pandas._testing as tm
 from pandas.tests.reshape.merge.test_merge import NGROUPS, N, get_test_data
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
 
 a_ = np.array
 
@@ -194,7 +193,7 @@ def test_join_on(self):
         expected = DataFrame(
             {"key": ["a", "a", "b", "b", "c"], "value": [0, 0, 1, 1, 2]}
         )
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
         # Test when some are missing
         df_a = DataFrame([[1], [2], [3]], index=["a", "b", "c"], columns=["one"])
@@ -213,8 +212,8 @@ def test_join_on(self):
         source_copy = source.copy()
         source_copy["A"] = 0
         msg = (
-            "You are trying to merge on float64 and object columns. If"
-            " you wish to proceed you should use pd.concat"
+            "You are trying to merge on float64 and object columns. If "
+            "you wish to proceed you should use pd.concat"
         )
         with pytest.raises(ValueError, match=msg):
             target.join(source_copy, on="A")
@@ -227,9 +226,7 @@ def test_join_on_fails_with_different_right_index(self):
             {"a": np.random.choice(["m", "f"], size=10), "b": np.random.randn(10)},
             index=tm.makeCustomIndex(10, 2),
         )
-        msg = (
-            r"len\(left_on\) must equal the number of levels in the index" ' of "right"'
-        )
+        msg = r'len\(left_on\) must equal the number of levels in the index of "right"'
         with pytest.raises(ValueError, match=msg):
             merge(df, df2, left_on="a", right_index=True)
 
@@ -241,9 +238,7 @@ def test_join_on_fails_with_different_left_index(self):
         df2 = DataFrame(
             {"a": np.random.choice(["m", "f"], size=10), "b": np.random.randn(10)}
         )
-        msg = (
-            r"len\(right_on\) must equal the number of levels in the index" ' of "left"'
-        )
+        msg = r'len\(right_on\) must equal the number of levels in the index of "left"'
         with pytest.raises(ValueError, match=msg):
             merge(df, df2, right_on="b", left_index=True)
 
@@ -281,7 +276,7 @@ def test_join_on_pass_vector(self):
 
         join_col = self.target.pop("C")
         result = self.target.join(self.source, on=join_col)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_join_with_len0(self):
         # nothing to merge
@@ -314,12 +309,12 @@ def test_join_on_singlekey_list(self):
         joined = df.join(df2, on=["key"])
         expected = df.join(df2, on="key")
 
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
     def test_join_on_series(self):
         result = self.target.join(self.source["MergedA"], on="C")
         expected = self.target.join(self.source[["MergedA"]], on="C")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_join_on_series_buglet(self):
         # GH #638
@@ -341,11 +336,11 @@ def test_join_index_mixed(self, join_type):
 
         joined = df1.join(df2, how=join_type)
         expected = _join_by_hand(df1, df2, how=join_type)
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
         joined = df2.join(df1, how=join_type)
         expected = _join_by_hand(df2, df1, how=join_type)
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
     def test_join_index_mixed_overlap(self):
         df1 = DataFrame(
@@ -377,7 +372,7 @@ def test_join_index_mixed_overlap(self):
         df1.columns = expected_columns[:4]
         df2.columns = expected_columns[4:]
         expected = _join_by_hand(df1, df2)
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
     def test_join_empty_bug(self):
         # generated an exception in 0.4.3
@@ -416,7 +411,7 @@ def test_join_multiindex(self):
         ex_index = Index(index1.values).union(Index(index2.values))
         expected = df1.reindex(ex_index).join(df2.reindex(ex_index))
         expected.index.names = index1.names
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
         assert joined.index.names == index1.names
 
         df1 = df1.sort_index(level=1)
@@ -427,7 +422,7 @@ def test_join_multiindex(self):
         expected = df1.reindex(ex_index).join(df2.reindex(ex_index))
         expected.index.names = index1.names
 
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
         assert joined.index.names == index1.names
 
     def test_join_inner_multiindex(self):
@@ -475,7 +470,7 @@ def test_join_inner_multiindex(self):
             how="inner",
             sort=False,
         )
-        assert_frame_equal(joined, expected2.reindex_like(joined))
+        tm.assert_frame_equal(joined, expected2.reindex_like(joined))
 
         expected2 = merge(
             to_join,
@@ -490,7 +485,7 @@ def test_join_inner_multiindex(self):
         expected.index = joined.index
 
         assert joined.index.is_monotonic
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
         # _assert_same_contents(expected, expected2.loc[:, expected.columns])
 
@@ -528,7 +523,7 @@ def test_join_float64_float32(self):
         assert rs.dtypes["md"] == "float32"
 
         xp = xpdf.merge(s, left_on="a", right_index=True)
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
     def test_join_many_non_unique_index(self):
         df1 = DataFrame({"a": [1, 1], "b": [1, 1], "c": [10, 20]})
@@ -547,7 +542,7 @@ def test_join_many_non_unique_index(self):
         expected = expected[result.columns]
         expected["a"] = expected.a.astype("int64")
         expected["b"] = expected.b.astype("int64")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         df1 = DataFrame({"a": [1, 1, 1], "b": [1, 1, 1], "c": [10, 20, 30]})
         df2 = DataFrame({"a": [1, 1, 1], "b": [1, 1, 2], "d": [100, 200, 300]})
@@ -562,7 +557,7 @@ def test_join_many_non_unique_index(self):
 
         result = result.reset_index()
 
-        assert_frame_equal(result, expected.loc[:, result.columns])
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
         # GH 11519
         df = DataFrame(
@@ -580,9 +575,9 @@ def test_join_many_non_unique_index(self):
         outer = df.join(s, how="outer")
         left = df.join(s, how="left")
         right = df.join(s, how="right")
-        assert_frame_equal(inner, outer)
-        assert_frame_equal(inner, left)
-        assert_frame_equal(inner, right)
+        tm.assert_frame_equal(inner, outer)
+        tm.assert_frame_equal(inner, left)
+        tm.assert_frame_equal(inner, right)
 
     def test_join_sort(self):
         left = DataFrame({"key": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]})
@@ -597,7 +592,7 @@ def test_join_sort(self):
             },
             index=[1, 2, 0, 3],
         )
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
         # smoke test
         joined = left.join(right, on="key", sort=False)
@@ -625,7 +620,7 @@ def test_join_mixed_non_unique_index(self):
     def test_join_non_unique_period_index(self):
         # GH #16871
         index = pd.period_range("2016-01-01", periods=16, freq="M")
-        df = DataFrame([i for i in range(len(index))], index=index, columns=["pnum"])
+        df = DataFrame(list(range(len(index))), index=index, columns=["pnum"])
         df2 = concat([df, df])
         result = df.join(df2, how="inner", rsuffix="_df2")
         expected = DataFrame(
@@ -684,7 +679,7 @@ def test_join_many_mixed(self):
         df3 = df.loc[:, ["key"]]
 
         result = df1.join([df2, df3])
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_join_dups(self):
 
@@ -702,7 +697,7 @@ def test_join_dups(self):
         expected = concat([df, df], axis=1)
         result = df.join(df, rsuffix="_2")
         result.columns = expected.columns
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # GH 4975, invalid join on dups
         w = DataFrame(np.random.randn(4, 2), columns=["x", "y"])
@@ -716,7 +711,7 @@ def test_join_dups(self):
         dta = dta.merge(w, left_index=True, right_index=True)
         expected = concat([x, y, z, w], axis=1)
         expected.columns = ["x_x", "y_x", "x_y", "y_y", "x_x", "y_x", "x_y", "y_y"]
-        assert_frame_equal(dta, expected)
+        tm.assert_frame_equal(dta, expected)
 
     def test_join_multi_to_multi(self, join_type):
         # GH 20475
@@ -736,11 +731,9 @@ def test_join_multi_to_multi(self, join_type):
             .merge(right.reset_index(), on=["abc", "xy"], how=join_type)
             .set_index(["abc", "xy", "num"])
         )
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
-        msg = (
-            r"len\(left_on\) must equal the number of levels in the index" ' of "right"'
-        )
+        msg = r'len\(left_on\) must equal the number of levels in the index of "right"'
         with pytest.raises(ValueError, match=msg):
             left.join(right, on="xy", how=join_type)
 
@@ -769,7 +762,36 @@ def test_join_on_tz_aware_datetimeindex(self):
         result = df1.join(df2.set_index("date"), on="date")
         expected = df1.copy()
         expected["vals_2"] = pd.Series([np.nan] * 2 + list("tuv"), dtype=object)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_datetime_string(self):
+        # GH 5647
+        dfa = DataFrame(
+            [
+                ["2012-08-02", "L", 10],
+                ["2012-08-02", "J", 15],
+                ["2013-04-06", "L", 20],
+                ["2013-04-06", "J", 25],
+            ],
+            columns=["x", "y", "a"],
+        )
+        dfa["x"] = pd.to_datetime(dfa["x"])
+        dfb = DataFrame(
+            [["2012-08-02", "J", 1], ["2013-04-06", "L", 2]],
+            columns=["x", "y", "z"],
+            index=[2, 4],
+        )
+        dfb["x"] = pd.to_datetime(dfb["x"])
+        result = dfb.join(dfa.set_index(["x", "y"]), on=["x", "y"])
+        expected = DataFrame(
+            [
+                [pd.Timestamp("2012-08-02 00:00:00"), "J", 1, 15],
+                [pd.Timestamp("2013-04-06 00:00:00"), "L", 2, 20],
+            ],
+            index=[2, 4],
+            columns=["x", "y", "z", "a"],
+        )
+        tm.assert_frame_equal(result, expected)
 
 
 def _check_join(left, right, result, join_col, how="left", lsuffix="_x", rsuffix="_y"):
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index a04f093ee7818..fd189c7435b29 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -1,10 +1,9 @@
 from collections import OrderedDict
-from datetime import date, datetime
+from datetime import date, datetime, timedelta
 import random
 import re
 
 import numpy as np
-from numpy import nan
 import pytest
 
 from pandas.core.dtypes.common import is_categorical_dtype, is_object_dtype
@@ -26,11 +25,10 @@
     TimedeltaIndex,
     UInt64Index,
 )
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype as CDT
 from pandas.core.reshape.concat import concat
 from pandas.core.reshape.merge import MergeError, merge
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 N = 50
 NGROUPS = 8
@@ -129,13 +127,25 @@ def test_merge_inner_join_empty(self):
         df_a = pd.DataFrame({"a": [1, 2]}, index=[0, 1], dtype="int64")
         result = pd.merge(df_empty, df_a, left_index=True, right_index=True)
         expected = pd.DataFrame({"a": []}, index=[], dtype="int64")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_common(self):
         joined = merge(self.df, self.df2)
         exp = merge(self.df, self.df2, on=["key1", "key2"])
         tm.assert_frame_equal(joined, exp)
 
+    def test_merge_non_string_columns(self):
+        # https://github.com/pandas-dev/pandas/issues/17962
+        # Checks that method runs for non string column names
+        left = pd.DataFrame(
+            {0: [1, 0, 1, 0], 1: [0, 1, 0, 0], 2: [0, 0, 2, 0], 3: [1, 0, 0, 3]}
+        )
+
+        right = left.astype(float)
+        expected = left
+        result = pd.merge(left, right)
+        tm.assert_frame_equal(expected, result)
+
     def test_merge_index_as_on_arg(self):
         # GH14355
 
@@ -143,7 +153,7 @@ def test_merge_index_as_on_arg(self):
         right = self.df2.set_index("key1")
         result = merge(left, right, on="key1")
         expected = merge(self.df, self.df2, on="key1").set_index("key1")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_index_singlekey_right_vs_left(self):
         left = DataFrame(
@@ -157,7 +167,7 @@ def test_merge_index_singlekey_right_vs_left(self):
         merged2 = merge(
             right, left, right_on="key", left_index=True, how="right", sort=False
         )
-        assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
+        tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
 
         merged1 = merge(
             left, right, left_on="key", right_index=True, how="left", sort=True
@@ -165,7 +175,7 @@ def test_merge_index_singlekey_right_vs_left(self):
         merged2 = merge(
             right, left, right_on="key", left_index=True, how="right", sort=True
         )
-        assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
+        tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
 
     def test_merge_index_singlekey_inner(self):
         left = DataFrame(
@@ -176,11 +186,11 @@ def test_merge_index_singlekey_inner(self):
         # inner join
         result = merge(left, right, left_on="key", right_index=True, how="inner")
         expected = left.join(right, on="key").loc[result.index]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = merge(right, left, right_on="key", left_index=True, how="inner")
         expected = left.join(right, on="key").loc[result.index]
-        assert_frame_equal(result, expected.loc[:, result.columns])
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
     def test_merge_misspecified(self):
         msg = "Must pass right_on or right_index=True"
@@ -191,8 +201,8 @@ def test_merge_misspecified(self):
             merge(self.left, self.right, right_index=True)
 
         msg = (
-            'Can only pass argument "on" OR "left_on" and "right_on", not'
-            " a combination of both"
+            'Can only pass argument "on" OR "left_on" and "right_on", not '
+            "a combination of both"
         )
         with pytest.raises(pd.errors.MergeError, match=msg):
             merge(self.left, self.left, left_on="key", on="key")
@@ -297,7 +307,7 @@ def test_intelligently_handle_join_key(self):
             },
             columns=["value", "key", "rvalue"],
         )
-        assert_frame_equal(joined, expected)
+        tm.assert_frame_equal(joined, expected)
 
     def test_merge_join_key_dtype_cast(self):
         # #8596
@@ -332,7 +342,7 @@ def test_handle_join_key_pass_array(self):
         merged = merge(left, right, left_on="key", right_on=key, how="outer")
         merged2 = merge(right, left, left_on=key, right_on="key", how="outer")
 
-        assert_series_equal(merged["key"], merged2["key"])
+        tm.assert_series_equal(merged["key"], merged2["key"])
         assert merged["key"].notna().all()
         assert merged2["key"].notna().all()
 
@@ -361,10 +371,8 @@ def test_no_overlap_more_informative_error(self):
 
         msg = (
             "No common columns to perform merge on. "
-            "Merge options: left_on={lon}, right_on={ron}, "
-            "left_index={lidx}, right_index={ridx}".format(
-                lon=None, ron=None, lidx=False, ridx=False
-            )
+            f"Merge options: left_on={None}, right_on={None}, "
+            f"left_index={False}, right_index={False}"
         )
 
         with pytest.raises(MergeError, match=msg):
@@ -407,10 +415,10 @@ def test_left_merge_empty_dataframe(self):
         right = DataFrame({"key": []})
 
         result = merge(left, right, on="key", how="left")
-        assert_frame_equal(result, left)
+        tm.assert_frame_equal(result, left)
 
         result = merge(right, left, on="key", how="right")
-        assert_frame_equal(result, left)
+        tm.assert_frame_equal(result, left)
 
     @pytest.mark.parametrize(
         "kwarg",
@@ -541,7 +549,7 @@ def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
             columns=["value_x", "key", "value_y"],
         )
         actual = df_empty.merge(df, on="key")
-        assert_frame_equal(actual, expected)
+        tm.assert_frame_equal(actual, expected)
 
     def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
         # GH 25183
@@ -562,12 +570,10 @@ def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
             columns=["key", "value_x", "value_y"],
         )
         actual = df_left.merge(df_right, on="key")
-        assert_frame_equal(actual, expected)
+        tm.assert_frame_equal(actual, expected)
 
     def test_merge_nosort(self):
-        # #2098, anything to do?
-
-        from datetime import datetime
+        # GH#2098, TODO: anything to do?
 
         d = {
             "var1": np.random.randint(0, 10, size=10),
@@ -592,7 +598,7 @@ def test_merge_nosort(self):
 
         result = df.merge(new, on="var3", sort=False)
         exp = merge(df, new, on="var3", sort=False)
-        assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, exp)
 
         assert (df.var3.unique() == result.var3.unique()).all()
 
@@ -613,7 +619,7 @@ def test_merge_nan_right(self):
             .set_index(None)
             .reset_index()[["i1", "i2", "i1_", "i3"]]
         )
-        assert_frame_equal(result, expected, check_dtype=False)
+        tm.assert_frame_equal(result, expected, check_dtype=False)
 
         df1 = DataFrame({"i1": [0, 1], "i2": [0.5, 1.5]})
         df2 = DataFrame({"i1": [0], "i3": [0.7]})
@@ -621,12 +627,12 @@ def test_merge_nan_right(self):
         expected = DataFrame(
             {
                 "i1": {0: 0, 1: 1},
-                "i1_": {0: 0.0, 1: nan},
+                "i1_": {0: 0.0, 1: np.nan},
                 "i2": {0: 0.5, 1: 1.5},
-                "i3": {0: 0.69999999999999996, 1: nan},
+                "i3": {0: 0.69999999999999996, 1: np.nan},
             }
         )[["i1", "i2", "i1_", "i3"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_type(self):
         class NotADataFrame(DataFrame):
@@ -640,24 +646,20 @@ def _constructor(self):
         assert isinstance(result, NotADataFrame)
 
     def test_join_append_timedeltas(self):
-
-        import datetime as dt
-        from pandas import NaT
-
         # timedelta64 issues with join/merge
         # GH 5695
 
-        d = {"d": dt.datetime(2013, 11, 5, 5, 56), "t": dt.timedelta(0, 22500)}
+        d = {"d": datetime(2013, 11, 5, 5, 56), "t": timedelta(0, 22500)}
         df = DataFrame(columns=list("dt"))
         df = df.append(d, ignore_index=True)
         result = df.append(d, ignore_index=True)
         expected = DataFrame(
             {
-                "d": [dt.datetime(2013, 11, 5, 5, 56), dt.datetime(2013, 11, 5, 5, 56)],
-                "t": [dt.timedelta(0, 22500), dt.timedelta(0, 22500)],
+                "d": [datetime(2013, 11, 5, 5, 56), datetime(2013, 11, 5, 5, 56)],
+                "t": [timedelta(0, 22500), timedelta(0, 22500)],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         td = np.timedelta64(300000000)
         lhs = DataFrame(Series([td, td], index=["A", "B"]))
@@ -667,10 +669,10 @@ def test_join_append_timedeltas(self):
         expected = DataFrame(
             {
                 "0": Series([td, td], index=list("AB")),
-                "0r": Series([td, NaT], index=list("AB")),
+                "0r": Series([td, pd.NaT], index=list("AB")),
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_other_datetime_unit(self):
         # GH 13389
@@ -736,11 +738,11 @@ def test_overlapping_columns_error_message(self):
             }
         )
         expected.columns = ["key", "foo", "foo", "bar", "bar"]
-        assert_frame_equal(merge(df, df2), expected)
+        tm.assert_frame_equal(merge(df, df2), expected)
 
         # #2649, #10639
         df2.columns = ["key1", "foo", "foo"]
-        msg = r"Data columns not unique: Index\(\['foo', 'foo'\]," r" dtype='object'\)"
+        msg = r"Data columns not unique: Index\(\['foo', 'foo'\], dtype='object'\)"
         with pytest.raises(MergeError, match=msg):
             merge(df, df2)
 
@@ -768,7 +770,7 @@ def test_merge_on_datetime64tz(self):
             }
         )
         result = pd.merge(left, right, on="key", how="outer")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         left = pd.DataFrame(
             {
@@ -792,7 +794,7 @@ def test_merge_on_datetime64tz(self):
             }
         )
         result = pd.merge(left, right, on="key", how="outer")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         assert result["value_x"].dtype == "datetime64[ns, US/Eastern]"
         assert result["value_y"].dtype == "datetime64[ns, US/Eastern]"
 
@@ -851,12 +853,12 @@ def test_merge_datetime64tz_with_dst_transition(self):
                 "value_y": [np.nan] * 4 + [2] * 3,
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_non_unique_period_index(self):
         # GH #16871
         index = pd.period_range("2016-01-01", periods=16, freq="M")
-        df = DataFrame([i for i in range(len(index))], index=index, columns=["pnum"])
+        df = DataFrame(list(range(len(index))), index=index, columns=["pnum"])
         df2 = concat([df, df])
         result = df.merge(df2, left_index=True, right_index=True, how="inner")
         expected = DataFrame(
@@ -885,7 +887,7 @@ def test_merge_on_periods(self):
             }
         )
         result = pd.merge(left, right, on="key", how="outer")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         left = pd.DataFrame(
             {"key": [1, 2], "value": pd.period_range("20151010", periods=2, freq="D")}
@@ -904,7 +906,7 @@ def test_merge_on_periods(self):
             }
         )
         result = pd.merge(left, right, on="key", how="outer")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         assert result["value_x"].dtype == "Period[D]"
         assert result["value_y"].dtype == "Period[D]"
 
@@ -957,13 +959,13 @@ def test_indicator(self):
         ]
 
         test = merge(df1, df2, on="col1", how="outer", indicator=True)
-        assert_frame_equal(test, df_result)
+        tm.assert_frame_equal(test, df_result)
         test = df1.merge(df2, on="col1", how="outer", indicator=True)
-        assert_frame_equal(test, df_result)
+        tm.assert_frame_equal(test, df_result)
 
         # No side effects
-        assert_frame_equal(df1, df1_copy)
-        assert_frame_equal(df2, df2_copy)
+        tm.assert_frame_equal(df1, df1_copy)
+        tm.assert_frame_equal(df2, df2_copy)
 
         # Check with custom name
         df_result_custom_name = df_result
@@ -974,11 +976,11 @@ def test_indicator(self):
         test_custom_name = merge(
             df1, df2, on="col1", how="outer", indicator="custom_name"
         )
-        assert_frame_equal(test_custom_name, df_result_custom_name)
+        tm.assert_frame_equal(test_custom_name, df_result_custom_name)
         test_custom_name = df1.merge(
             df2, on="col1", how="outer", indicator="custom_name"
         )
-        assert_frame_equal(test_custom_name, df_result_custom_name)
+        tm.assert_frame_equal(test_custom_name, df_result_custom_name)
 
         # Check only accepts strings and booleans
         msg = "indicator option can only accept boolean or string arguments"
@@ -1009,10 +1011,9 @@ def test_indicator(self):
             df_badcolumn = DataFrame({"col1": [1, 2], i: [2, 2]})
 
             msg = (
-                "Cannot use `indicator=True` option when data contains a"
-                " column named {}|"
-                "Cannot use name of an existing column for indicator"
-                " column"
+                "Cannot use `indicator=True` option when data contains a "
+                "column named {}|"
+                "Cannot use name of an existing column for indicator column"
             ).format(i)
             with pytest.raises(ValueError, match=msg):
                 merge(df1, df_badcolumn, on="col1", how="outer", indicator=True)
@@ -1050,9 +1051,9 @@ def test_indicator(self):
         )
 
         test5 = merge(df3, df4, on=["col1", "col2"], how="outer", indicator=True)
-        assert_frame_equal(test5, hand_coded_result)
+        tm.assert_frame_equal(test5, hand_coded_result)
         test5 = df3.merge(df4, on=["col1", "col2"], how="outer", indicator=True)
-        assert_frame_equal(test5, hand_coded_result)
+        tm.assert_frame_equal(test5, hand_coded_result)
 
     def test_validation(self):
         left = DataFrame(
@@ -1073,8 +1074,8 @@ def test_validation(self):
         right_copy = right.copy()
 
         result = merge(left, right, left_index=True, right_index=True, validate="1:1")
-        assert_frame_equal(left, left_copy)
-        assert_frame_equal(right, right_copy)
+        tm.assert_frame_equal(left, left_copy)
+        tm.assert_frame_equal(right, right_copy)
 
         # make sure merge still correct
         expected = DataFrame(
@@ -1091,7 +1092,7 @@ def test_validation(self):
         result = merge(
             left, right, left_index=True, right_index=True, validate="one_to_one"
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected_2 = DataFrame(
             {
@@ -1103,12 +1104,12 @@ def test_validation(self):
         )
 
         result = merge(left, right, on="a", validate="1:1")
-        assert_frame_equal(left, left_copy)
-        assert_frame_equal(right, right_copy)
-        assert_frame_equal(result, expected_2)
+        tm.assert_frame_equal(left, left_copy)
+        tm.assert_frame_equal(right, right_copy)
+        tm.assert_frame_equal(result, expected_2)
 
         result = merge(left, right, on="a", validate="one_to_one")
-        assert_frame_equal(result, expected_2)
+        tm.assert_frame_equal(result, expected_2)
 
         # One index, one column
         expected_3 = DataFrame(
@@ -1129,7 +1130,7 @@ def test_validation(self):
             right_on="a",
             validate="one_to_one",
         )
-        assert_frame_equal(result, expected_3)
+        tm.assert_frame_equal(result, expected_3)
 
         # Dups on right
         right_w_dups = right.append(pd.DataFrame({"a": ["e"], "c": ["moo"]}, index=[4]))
@@ -1231,14 +1232,14 @@ def test_validation(self):
         )
 
         msg = (
-            "Merge keys are not unique in either left or right dataset;"
-            " not a one-to-one merge"
+            "Merge keys are not unique in either left or right dataset; "
+            "not a one-to-one merge"
         )
         with pytest.raises(MergeError, match=msg):
             merge(left, right, on="a", validate="1:1")
 
         result = merge(left, right, on=["a", "b"], validate="1:1")
-        assert_frame_equal(result, expected_multi)
+        tm.assert_frame_equal(result, expected_multi)
 
     def test_merge_two_empty_df_no_division_error(self):
         # GH17776, PR #17846
@@ -1300,7 +1301,7 @@ def test_merge_on_index_with_more_values(self, how, index, expected_index):
             columns=["a", "key", "b"],
         )
         expected.set_index(expected_index, inplace=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_right_index_right(self):
         # Note: the expected output here is probably incorrect.
@@ -1361,7 +1362,7 @@ def _check_merge(x, y):
         expected = expected.set_index("index")
 
         # TODO check_names on merge?
-        assert_frame_equal(result, expected, check_names=False)
+        tm.assert_frame_equal(result, expected, check_names=False)
 
 
 class TestMergeDtypes:
@@ -1439,10 +1440,21 @@ def test_merge_on_ints_floats(self, int_vals, float_vals, exp_vals):
         expected = DataFrame(exp_vals)
 
         result = A.merge(B, left_on="X", right_on="Y")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = B.merge(A, left_on="Y", right_on="X")
-        assert_frame_equal(result, expected[["Y", "X"]])
+        tm.assert_frame_equal(result, expected[["Y", "X"]])
+
+    def test_merge_key_dtype_cast(self):
+        # GH 17044
+        df1 = DataFrame({"key": [1.0, 2.0], "v1": [10, 20]}, columns=["key", "v1"])
+        df2 = DataFrame({"key": [2], "v2": [200]}, columns=["key", "v2"])
+        result = df1.merge(df2, on="key", how="left")
+        expected = DataFrame(
+            {"key": [1.0, 2.0], "v1": [10, 20], "v2": [np.nan, 200.0]},
+            columns=["key", "v1", "v2"],
+        )
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_on_ints_floats_warning(self):
         # GH 16572
@@ -1455,18 +1467,18 @@ def test_merge_on_ints_floats_warning(self):
 
         with tm.assert_produces_warning(UserWarning):
             result = A.merge(B, left_on="X", right_on="Y")
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
         with tm.assert_produces_warning(UserWarning):
             result = B.merge(A, left_on="Y", right_on="X")
-            assert_frame_equal(result, expected[["Y", "X"]])
+            tm.assert_frame_equal(result, expected[["Y", "X"]])
 
         # test no warning if float has NaNs
         B = DataFrame({"Y": [np.nan, np.nan, 3.0]})
 
         with tm.assert_produces_warning(None):
             result = B.merge(A, left_on="Y", right_on="X")
-            assert_frame_equal(result, expected[["Y", "X"]])
+            tm.assert_frame_equal(result, expected[["Y", "X"]])
 
     def test_merge_incompat_infer_boolean_object(self):
         # GH21119: bool + object bool merge OK
@@ -1475,9 +1487,9 @@ def test_merge_incompat_infer_boolean_object(self):
 
         expected = DataFrame({"key": [True, False]}, dtype=object)
         result = pd.merge(df1, df2, on="key")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         result = pd.merge(df2, df1, on="key")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # with missing value
         df1 = DataFrame({"key": Series([True, False, np.nan], dtype=object)})
@@ -1485,9 +1497,9 @@ def test_merge_incompat_infer_boolean_object(self):
 
         expected = DataFrame({"key": [True, False]}, dtype=object)
         result = pd.merge(df1, df2, on="key")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
         result = pd.merge(df2, df1, on="key")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "df1_vals, df2_vals",
@@ -1596,7 +1608,7 @@ def test_identical(self, left):
             [CategoricalDtype(), np.dtype("O"), np.dtype("O")],
             index=["X", "Y_x", "Y_y"],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_basic(self, left, right):
         # we have matching Categorical dtypes in X
@@ -1607,7 +1619,7 @@ def test_basic(self, left, right):
             [CategoricalDtype(), np.dtype("O"), np.dtype("int64")],
             index=["X", "Y", "Z"],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_merge_categorical(self):
         # GH 9426
@@ -1675,7 +1687,7 @@ def tests_merge_categorical_unordered_equal(self):
                 "Right": ["A1", "B1", "C1"],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_other_columns(self, left, right):
         # non-merge columns should preserve if possible
@@ -1687,7 +1699,7 @@ def test_other_columns(self, left, right):
             [CategoricalDtype(), np.dtype("O"), CategoricalDtype()],
             index=["X", "Y", "Z"],
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # categories are preserved
         assert left.X.values.is_dtype_equal(merged.X.values)
@@ -1716,7 +1728,7 @@ def test_dtype_on_merged_different(self, change, join_type, left, right):
         expected = Series(
             [np.dtype("O"), np.dtype("O"), np.dtype("int64")], index=["X", "Y", "Z"]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_self_join_multiple_categories(self):
         # GH 16767
@@ -1756,7 +1768,7 @@ def test_self_join_multiple_categories(self):
         # self-join should equal ourselves
         result = pd.merge(df, df, on=list(df.columns))
 
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_dtype_on_categorical_dates(self):
         # GH 16900
@@ -1781,13 +1793,13 @@ def test_dtype_on_categorical_dates(self):
             columns=["date", "num2", "num4"],
         )
         result_outer = pd.merge(df, df2, how="outer", on=["date"])
-        assert_frame_equal(result_outer, expected_outer)
+        tm.assert_frame_equal(result_outer, expected_outer)
 
         expected_inner = pd.DataFrame(
             [[pd.Timestamp("2001-01-01"), 1.1, 1.3]], columns=["date", "num2", "num4"]
         )
         result_inner = pd.merge(df, df2, how="inner", on=["date"])
-        assert_frame_equal(result_inner, expected_inner)
+        tm.assert_frame_equal(result_inner, expected_inner)
 
     @pytest.mark.parametrize("ordered", [True, False])
     @pytest.mark.parametrize(
@@ -1811,7 +1823,7 @@ def test_merging_with_bool_or_int_cateorical_column(
             {"id": [2, 4], "cat": expected_categories, "num": [1, 9]}
         )
         expected["cat"] = expected["cat"].astype(CDT(categories, ordered=ordered))
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
     def test_merge_on_int_array(self):
         # GH 23020
@@ -1820,7 +1832,7 @@ def test_merge_on_int_array(self):
         expected = pd.DataFrame(
             {"A": pd.Series([1, 2, np.nan], dtype="Int64"), "B_x": 1, "B_y": 1}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
 
 @pytest.fixture
@@ -1911,7 +1923,7 @@ def test_merge_index_types(index):
     expected = DataFrame(
         OrderedDict([("left_data", [1, 2]), ("right_data", [1.0, 2.0])]), index=index
     )
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize(
@@ -2094,3 +2106,64 @@ def test_merge_equal_cat_dtypes2():
 
     # Categorical is unordered, so don't check ordering.
     tm.assert_frame_equal(result, expected, check_categorical=False)
+
+
+def test_merge_on_cat_and_ext_array():
+    # GH 28668
+    right = DataFrame(
+        {"a": Series([pd.Interval(0, 1), pd.Interval(1, 2)], dtype="interval")}
+    )
+    left = right.copy()
+    left["a"] = left["a"].astype("category")
+
+    result = pd.merge(left, right, how="inner", on="a")
+    expected = right.copy()
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_multiindex_columns():
+    # Issue #28518
+    # Verify that merging two dataframes give the expected labels
+    # The original cause of this issue come from a bug lexsort_depth and is tested in
+    # test_lexsort_depth
+
+    letters = ["a", "b", "c", "d"]
+    numbers = ["1", "2", "3"]
+    index = pd.MultiIndex.from_product((letters, numbers), names=["outer", "inner"])
+
+    frame_x = pd.DataFrame(columns=index)
+    frame_x["id"] = ""
+    frame_y = pd.DataFrame(columns=index)
+    frame_y["id"] = ""
+
+    l_suf = "_x"
+    r_suf = "_y"
+    result = frame_x.merge(frame_y, on="id", suffixes=((l_suf, r_suf)))
+
+    # Constructing the expected results
+    expected_labels = [l + l_suf for l in letters] + [l + r_suf for l in letters]
+    expected_index = pd.MultiIndex.from_product(
+        [expected_labels, numbers], names=["outer", "inner"]
+    )
+    expected = pd.DataFrame(columns=expected_index)
+    expected["id"] = ""
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_datetime_upcast_dtype():
+    # https://github.com/pandas-dev/pandas/issues/31208
+    df1 = pd.DataFrame({"x": ["a", "b", "c"], "y": ["1", "2", "4"]})
+    df2 = pd.DataFrame(
+        {"y": ["1", "2", "3"], "z": pd.to_datetime(["2000", "2001", "2002"])}
+    )
+    result = pd.merge(df1, df2, how="left", on="y")
+    expected = pd.DataFrame(
+        {
+            "x": ["a", "b", "c"],
+            "y": ["1", "2", "4"],
+            "z": pd.to_datetime(["2000", "2001", "NaT"]),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index 7412b1de643a1..8037095aff0b9 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -6,8 +6,8 @@
 
 import pandas as pd
 from pandas import Timedelta, merge_asof, read_csv, to_datetime
+import pandas._testing as tm
 from pandas.core.reshape.merge import MergeError
-from pandas.util.testing import assert_frame_equal
 
 
 class TestAsOfMerge:
@@ -44,7 +44,7 @@ def test_examples1(self):
         )
 
         result = pd.merge_asof(left, right, on="a")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_examples2(self):
         """ doc-string examples """
@@ -131,7 +131,7 @@ def test_examples2(self):
             tolerance=pd.Timedelta("10ms"),
             allow_exact_matches=False,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_examples3(self):
         """ doc-string examples """
@@ -145,7 +145,7 @@ def test_examples3(self):
         )
 
         result = pd.merge_asof(left, right, on="a", direction="forward")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_examples4(self):
         """ doc-string examples """
@@ -159,7 +159,7 @@ def test_examples4(self):
         )
 
         result = pd.merge_asof(left, right, on="a", direction="nearest")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic(self):
 
@@ -168,7 +168,7 @@ def test_basic(self):
         quotes = self.quotes
 
         result = merge_asof(trades, quotes, on="time", by="ticker")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_categorical(self):
 
@@ -180,7 +180,7 @@ def test_basic_categorical(self):
         expected.ticker = expected.ticker.astype("category")
 
         result = merge_asof(trades, quotes, on="time", by="ticker")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_left_index(self):
 
@@ -196,7 +196,7 @@ def test_basic_left_index(self):
         expected.index = result.index
         # time column appears after left"s columns
         expected = expected[result.columns]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_right_index(self):
 
@@ -207,7 +207,7 @@ def test_basic_right_index(self):
         result = merge_asof(
             trades, quotes, left_on="time", right_index=True, by="ticker"
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_left_index_right_index(self):
 
@@ -218,7 +218,7 @@ def test_basic_left_index_right_index(self):
         result = merge_asof(
             trades, quotes, left_index=True, right_index=True, by="ticker"
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multi_index(self):
 
@@ -260,7 +260,7 @@ def test_basic_left_by_right_by(self):
         result = merge_asof(
             trades, quotes, on="time", left_by="ticker", right_by="ticker"
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_missing_right_by(self):
 
@@ -271,7 +271,7 @@ def test_missing_right_by(self):
         q = quotes[quotes.ticker != "MSFT"]
         result = merge_asof(trades, q, on="time", by="ticker")
         expected.loc[expected.ticker == "MSFT", ["bid", "ask"]] = np.nan
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multiby(self):
         # GH13936
@@ -336,7 +336,7 @@ def test_multiby(self):
         )
 
         result = pd.merge_asof(trades, quotes, on="time", by=["ticker", "exch"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multiby_heterogeneous_types(self):
         # GH13936
@@ -401,7 +401,7 @@ def test_multiby_heterogeneous_types(self):
         )
 
         result = pd.merge_asof(trades, quotes, on="time", by=["ticker", "exch"])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multiby_indexed(self):
         # GH15676
@@ -439,7 +439,7 @@ def test_multiby_indexed(self):
             left, right, left_index=True, right_index=True, by=["k1", "k2"]
         )
 
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
 
         with pytest.raises(MergeError):
             pd.merge_asof(
@@ -458,7 +458,7 @@ def test_basic2(self, datapath):
         quotes = self.read_data(datapath, "quotes2.csv", dedupe=True)
 
         result = merge_asof(trades, quotes, on="time", by="ticker")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_no_by(self):
         f = (
@@ -473,7 +473,7 @@ def test_basic_no_by(self):
         quotes = f(self.quotes)
 
         result = merge_asof(trades, quotes, on="time")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_valid_join_keys(self):
 
@@ -498,7 +498,7 @@ def test_with_duplicates(self, datapath):
         )
         result = merge_asof(self.trades, q, on="time", by="ticker")
         expected = self.read_data(datapath, "asof.csv")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_with_duplicates_no_on(self):
 
@@ -508,7 +508,7 @@ def test_with_duplicates_no_on(self):
         expected = pd.DataFrame(
             {"key": [1, 1, 3], "left_val": [1, 2, 3], "right_val": [1, 1, 3]}
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_valid_allow_exact_matches(self):
 
@@ -592,13 +592,7 @@ def test_non_sorted(self):
 
     @pytest.mark.parametrize(
         "tolerance",
-        [
-            Timedelta("1day"),
-            pytest.param(
-                datetime.timedelta(days=1),
-                marks=pytest.mark.xfail(reason="not implemented", strict=True),
-            ),
-        ],
+        [Timedelta("1day"), datetime.timedelta(days=1)],
         ids=["pd.Timedelta", "datetime.timedelta"],
     )
     def test_tolerance(self, tolerance):
@@ -608,7 +602,7 @@ def test_tolerance(self, tolerance):
 
         result = merge_asof(trades, quotes, on="time", by="ticker", tolerance=tolerance)
         expected = self.tolerance
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_tolerance_forward(self):
         # GH14887
@@ -621,7 +615,7 @@ def test_tolerance_forward(self):
         )
 
         result = pd.merge_asof(left, right, on="a", direction="forward", tolerance=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_tolerance_nearest(self):
         # GH14887
@@ -634,7 +628,7 @@ def test_tolerance_nearest(self):
         )
 
         result = pd.merge_asof(left, right, on="a", direction="nearest", tolerance=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_tolerance_tz(self):
         # GH 14844
@@ -674,7 +668,7 @@ def test_tolerance_tz(self):
                 "value2": list("BCDEE"),
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_tolerance_float(self):
         # GH22981
@@ -692,7 +686,7 @@ def test_tolerance_float(self):
         )
 
         result = pd.merge_asof(left, right, on="a", direction="nearest", tolerance=0.5)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_index_tolerance(self):
         # GH 15135
@@ -708,7 +702,7 @@ def test_index_tolerance(self):
             by="ticker",
             tolerance=pd.Timedelta("1day"),
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches(self):
 
@@ -716,7 +710,7 @@ def test_allow_exact_matches(self):
             self.trades, self.quotes, on="time", by="ticker", allow_exact_matches=False
         )
         expected = self.allow_exact_matches
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_forward(self):
         # GH14887
@@ -731,7 +725,7 @@ def test_allow_exact_matches_forward(self):
         result = pd.merge_asof(
             left, right, on="a", direction="forward", allow_exact_matches=False
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_nearest(self):
         # GH14887
@@ -746,7 +740,7 @@ def test_allow_exact_matches_nearest(self):
         result = pd.merge_asof(
             left, right, on="a", direction="nearest", allow_exact_matches=False
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance(self):
 
@@ -759,7 +753,7 @@ def test_allow_exact_matches_and_tolerance(self):
             allow_exact_matches=False,
         )
         expected = self.allow_exact_matches_and_tolerance
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance2(self):
         # GH 13695
@@ -783,7 +777,7 @@ def test_allow_exact_matches_and_tolerance2(self):
                 "version": [2],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = pd.merge_asof(df1, df2, on="time", allow_exact_matches=False)
         expected = pd.DataFrame(
@@ -793,7 +787,7 @@ def test_allow_exact_matches_and_tolerance2(self):
                 "version": [1],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = pd.merge_asof(
             df1,
@@ -809,7 +803,7 @@ def test_allow_exact_matches_and_tolerance2(self):
                 "version": [np.nan],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance3(self):
         # GH 13709
@@ -846,7 +840,7 @@ def test_allow_exact_matches_and_tolerance3(self):
                 "version": [np.nan, np.nan],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance_forward(self):
         # GH14887
@@ -866,7 +860,7 @@ def test_allow_exact_matches_and_tolerance_forward(self):
             allow_exact_matches=False,
             tolerance=1,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance_nearest(self):
         # GH14887
@@ -886,7 +880,7 @@ def test_allow_exact_matches_and_tolerance_nearest(self):
             allow_exact_matches=False,
             tolerance=1,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_forward_by(self):
         # GH14887
@@ -916,7 +910,7 @@ def test_forward_by(self):
         )
 
         result = pd.merge_asof(left, right, on="a", by="b", direction="forward")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_nearest_by(self):
         # GH14887
@@ -946,7 +940,7 @@ def test_nearest_by(self):
         )
 
         result = pd.merge_asof(left, right, on="a", by="b", direction="nearest")
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_by_int(self):
         # we specialize by type, so test that this is correct
@@ -1007,7 +1001,7 @@ def test_by_int(self):
             columns=["time", "key", "value1", "value2"],
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_on_float(self):
         # mimics how to determine the minimum-price variation
@@ -1037,7 +1031,7 @@ def test_on_float(self):
             columns=["symbol", "price", "mpv"],
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_on_specialized_type(self, any_real_dtype):
         # see gh-13936
@@ -1068,7 +1062,7 @@ def test_on_specialized_type(self, any_real_dtype):
         )
         expected.value = dtype(expected.value)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_on_specialized_type_by_int(self, any_real_dtype):
         # see gh-13936
@@ -1104,7 +1098,7 @@ def test_on_specialized_type_by_int(self, any_real_dtype):
         )
         expected.value = dtype(expected.value)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_on_float_by_int(self):
         # type specialize both "by" and "on" parameters
@@ -1161,7 +1155,7 @@ def test_on_float_by_int(self):
             columns=["symbol", "exch", "price", "mpv"],
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_merge_datatype_error_raises(self):
         msg = r"incompatible merge keys \[0\] .*, must be the same type"
@@ -1191,6 +1185,13 @@ def test_merge_datatype_categorical_error_raises(self):
         with pytest.raises(MergeError, match=msg):
             merge_asof(left, right, on="a")
 
+    def test_merge_groupby_multiple_column_with_categorical_column(self):
+        # GH 16454
+        df = pd.DataFrame({"x": [0], "y": [0], "z": pd.Categorical([0])})
+        result = merge_asof(df, df, on="x", by=["y", "z"])
+        expected = pd.DataFrame({"x": [0], "y": [0], "z": pd.Categorical([0])})
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize(
         "func", [lambda x: x, lambda x: to_datetime(x)], ids=["numeric", "datetime"]
     )
@@ -1230,7 +1231,7 @@ def test_merge_by_col_tz_aware(self):
             [[pd.Timestamp("2018-01-01", tz="UTC"), 2, "a", "b"]],
             columns=["by_col", "on_col", "values_x", "values_y"],
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_by_mixed_tz_aware(self):
         # GH 26649
@@ -1256,7 +1257,7 @@ def test_by_mixed_tz_aware(self):
             columns=["by_col1", "by_col2", "on_col", "value_x"],
         )
         expected["value_y"] = np.array([np.nan], dtype=object)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_timedelta_tolerance_nearest(self):
         # GH 27642
@@ -1292,4 +1293,51 @@ def test_timedelta_tolerance_nearest(self):
             left, right, on="time", tolerance=Timedelta("1ms"), direction="nearest"
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
+
+    def test_int_type_tolerance(self, any_int_dtype):
+        # GH #28870
+
+        left = pd.DataFrame({"a": [0, 10, 20], "left_val": [1, 2, 3]})
+        right = pd.DataFrame({"a": [5, 15, 25], "right_val": [1, 2, 3]})
+        left["a"] = left["a"].astype(any_int_dtype)
+        right["a"] = right["a"].astype(any_int_dtype)
+
+        expected = pd.DataFrame(
+            {"a": [0, 10, 20], "left_val": [1, 2, 3], "right_val": [np.nan, 1.0, 2.0]}
+        )
+        expected["a"] = expected["a"].astype(any_int_dtype)
+
+        result = pd.merge_asof(left, right, on="a", tolerance=10)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_index_column_tz(self):
+        # GH 29864
+        index = pd.date_range("2019-10-01", freq="30min", periods=5, tz="UTC")
+        left = pd.DataFrame([0.9, 0.8, 0.7, 0.6], columns=["xyz"], index=index[1:])
+        right = pd.DataFrame({"from_date": index, "abc": [2.46] * 4 + [2.19]})
+        result = pd.merge_asof(
+            left=left, right=right, left_index=True, right_on=["from_date"]
+        )
+        expected = pd.DataFrame(
+            {
+                "xyz": [0.9, 0.8, 0.7, 0.6],
+                "from_date": index[1:],
+                "abc": [2.46] * 3 + [2.19],
+            },
+            index=pd.Index([1, 2, 3, 4]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = pd.merge_asof(
+            left=right, right=left, right_index=True, left_on=["from_date"]
+        )
+        expected = pd.DataFrame(
+            {
+                "from_date": index,
+                "abc": [2.46] * 4 + [2.19],
+                "xyz": [np.nan, 0.9, 0.8, 0.7, 0.6],
+            },
+            index=pd.Index([0, 1, 2, 3, 4]),
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_merge_index_as_string.py b/pandas/tests/reshape/merge/test_merge_index_as_string.py
index 5e3bf03a0a4ec..9075a4e791583 100644
--- a/pandas/tests/reshape/merge/test_merge_index_as_string.py
+++ b/pandas/tests/reshape/merge/test_merge_index_as_string.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -30,7 +30,8 @@ def df2():
 @pytest.fixture(params=[[], ["outer"], ["outer", "inner"]])
 def left_df(request, df1):
     """ Construct left test DataFrame with specified levels
-    (any of 'outer', 'inner', and 'v1')"""
+    (any of 'outer', 'inner', and 'v1')
+    """
     levels = request.param
     if levels:
         df1 = df1.set_index(levels)
@@ -41,7 +42,8 @@ def left_df(request, df1):
 @pytest.fixture(params=[[], ["outer"], ["outer", "inner"]])
 def right_df(request, df2):
     """ Construct right test DataFrame with specified levels
-    (any of 'outer', 'inner', and 'v2')"""
+    (any of 'outer', 'inner', and 'v2')
+    """
     levels = request.param
 
     if levels:
@@ -136,7 +138,7 @@ def test_merge_indexes_and_columns_on(left_df, right_df, on, how):
 
     # Perform merge
     result = left_df.merge(right_df, on=on, how=how)
-    assert_frame_equal(result, expected, check_like=True)
+    tm.assert_frame_equal(result, expected, check_like=True)
 
 
 @pytest.mark.parametrize(
@@ -159,7 +161,7 @@ def test_merge_indexes_and_columns_lefton_righton(
 
     # Perform merge
     result = left_df.merge(right_df, left_on=left_on, right_on=right_on, how=how)
-    assert_frame_equal(result, expected, check_like=True)
+    tm.assert_frame_equal(result, expected, check_like=True)
 
 
 @pytest.mark.parametrize("left_index", ["inner", ["inner", "outer"]])
@@ -185,4 +187,4 @@ def test_join_indexes_and_columns_on(df1, df2, left_index, join_type):
         right_df, on=["outer", "inner"], how=join_type, lsuffix="_x", rsuffix="_y"
     )
 
-    assert_frame_equal(result, expected, check_like=True)
+    tm.assert_frame_equal(result, expected, check_like=True)
diff --git a/pandas/tests/reshape/merge/test_merge_ordered.py b/pandas/tests/reshape/merge/test_merge_ordered.py
index 2b79548be7b59..e0063925a03e1 100644
--- a/pandas/tests/reshape/merge/test_merge_ordered.py
+++ b/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -1,9 +1,9 @@
-from numpy import nan
+import numpy as np
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, merge_ordered
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 class TestMergeOrdered:
@@ -17,12 +17,12 @@ def test_basic(self):
         expected = DataFrame(
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
-                "lvalue": [1, nan, 2, nan, 3, nan],
-                "rvalue": [nan, 1, 2, 3, nan, 4],
+                "lvalue": [1, np.nan, 2, np.nan, 3, np.nan],
+                "rvalue": [np.nan, 1, 2, 3, np.nan, 4],
             }
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_ffill(self):
         result = merge_ordered(self.left, self.right, on="key", fill_method="ffill")
@@ -30,10 +30,10 @@ def test_ffill(self):
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
                 "lvalue": [1.0, 1, 2, 2, 3, 3.0],
-                "rvalue": [nan, 1, 2, 3, 3, 4],
+                "rvalue": [np.nan, 1, 2, 3, 3, 4],
             }
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_multigroup(self):
         left = pd.concat([self.left, self.left], ignore_index=True)
@@ -47,17 +47,17 @@ def test_multigroup(self):
             {
                 "key": ["a", "b", "c", "d", "e", "f"] * 2,
                 "lvalue": [1.0, 1, 2, 2, 3, 3.0] * 2,
-                "rvalue": [nan, 1, 2, 3, 3, 4] * 2,
+                "rvalue": [np.nan, 1, 2, 3, 3, 4] * 2,
             }
         )
         expected["group"] = ["a"] * 6 + ["b"] * 6
 
-        assert_frame_equal(result, expected.loc[:, result.columns])
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
         result2 = merge_ordered(
             self.right, left, on="key", right_by="group", fill_method="ffill"
         )
-        assert_frame_equal(result, result2.loc[:, result.columns])
+        tm.assert_frame_equal(result, result2.loc[:, result.columns])
 
         result = merge_ordered(left, self.right, on="key", left_by="group")
         assert result["group"].notna().all()
@@ -110,8 +110,8 @@ def test_doc_example(self):
                 "group": list("aaaaabbbbb"),
                 "key": ["a", "b", "c", "d", "e"] * 2,
                 "lvalue": [1, 1, 2, 2, 3] * 2,
-                "rvalue": [nan, 1, 2, 3, 3] * 2,
+                "rvalue": [np.nan, 1, 2, 3, 3] * 2,
             }
         )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py
index 7aea85153d908..1f78c1900d237 100644
--- a/pandas/tests/reshape/merge/test_multi.py
+++ b/pandas/tests/reshape/merge/test_multi.py
@@ -1,15 +1,12 @@
-from collections import OrderedDict
-
 import numpy as np
-from numpy import nan
 from numpy.random import randn
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
+import pandas._testing as tm
 from pandas.core.reshape.concat import concat
 from pandas.core.reshape.merge import merge
-import pandas.util.testing as tm
 
 
 @pytest.fixture
@@ -196,6 +193,27 @@ def test_merge_right_vs_left(self, left, right, sort):
 
         tm.assert_frame_equal(merged_left_right, merge_right_left)
 
+    def test_merge_multiple_cols_with_mixed_cols_index(self):
+        # GH29522
+        s = pd.Series(
+            range(6),
+            pd.MultiIndex.from_product([["A", "B"], [1, 2, 3]], names=["lev1", "lev2"]),
+            name="Amount",
+        )
+        df = pd.DataFrame(
+            {"lev1": list("AAABBB"), "lev2": [1, 2, 3, 1, 2, 3], "col": 0}
+        )
+        result = pd.merge(df, s.reset_index(), on=["lev1", "lev2"])
+        expected = pd.DataFrame(
+            {
+                "lev1": list("AAABBB"),
+                "lev2": [1, 2, 3, 1, 2, 3],
+                "col": [0] * 6,
+                "Amount": range(6),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_compress_group_combinations(self):
 
         # ~ 40000000 possible unique groups
@@ -311,11 +329,11 @@ def test_left_join_index_multi_match_multiindex(self):
             [
                 ["X", "Y", "C", "a", 6],
                 ["X", "Y", "C", "a", 9],
-                ["W", "Y", "C", "e", nan],
+                ["W", "Y", "C", "e", np.nan],
                 ["V", "Q", "A", "h", -3],
                 ["V", "R", "D", "i", 2],
                 ["V", "R", "D", "i", -1],
-                ["X", "Y", "D", "b", nan],
+                ["X", "Y", "D", "b", np.nan],
                 ["X", "Y", "A", "c", 1],
                 ["X", "Y", "A", "c", 4],
                 ["W", "Q", "B", "f", 3],
@@ -365,10 +383,10 @@ def test_left_join_index_multi_match(self):
                 ["c", 0, "x"],
                 ["c", 0, "r"],
                 ["c", 0, "s"],
-                ["b", 1, nan],
+                ["b", 1, np.nan],
                 ["a", 2, "v"],
                 ["a", 2, "z"],
-                ["b", 3, nan],
+                ["b", 3, np.nan],
             ],
             columns=["tag", "val", "char"],
             index=[2, 2, 2, 2, 0, 1, 1, 3],
@@ -454,17 +472,13 @@ def test_merge_datetime_index(self, klass):
         if klass is not None:
             on_vector = klass(on_vector)
 
-        expected = DataFrame(
-            OrderedDict([("a", [1, 2, 3]), ("key_1", [2016, 2017, 2018])])
-        )
+        expected = DataFrame({"a": [1, 2, 3], "key_1": [2016, 2017, 2018]})
 
         result = df.merge(df, on=["a", on_vector], how="inner")
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
-            OrderedDict(
-                [("key_0", [2016, 2017, 2018]), ("a_x", [1, 2, 3]), ("a_y", [1, 2, 3])]
-            )
+            {"key_0": [2016, 2017, 2018], "a_x": [1, 2, 3], "a_y": [1, 2, 3]}
         )
 
         result = df.merge(df, on=[df.index.year], how="inner")
@@ -768,17 +782,13 @@ def test_merge_datetime_index(self, box):
         if box is not None:
             on_vector = box(on_vector)
 
-        expected = DataFrame(
-            OrderedDict([("a", [1, 2, 3]), ("key_1", [2016, 2017, 2018])])
-        )
+        expected = DataFrame({"a": [1, 2, 3], "key_1": [2016, 2017, 2018]})
 
         result = df.merge(df, on=["a", on_vector], how="inner")
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
-            OrderedDict(
-                [("key_0", [2016, 2017, 2018]), ("a_x", [1, 2, 3]), ("a_y", [1, 2, 3])]
-            )
+            {"key_0": [2016, 2017, 2018], "a_x": [1, 2, 3], "a_y": [1, 2, 3]}
         )
 
         result = df.merge(df, on=[df.index.year], how="inner")
@@ -808,3 +818,22 @@ def test_single_common_level(self):
         ).set_index(["key", "X", "Y"])
 
         tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_wrong_order(self):
+        # GH 25760
+        # GH 28956
+
+        midx1 = pd.MultiIndex.from_product([[1, 2], [3, 4]], names=["a", "b"])
+        midx3 = pd.MultiIndex.from_tuples([(4, 1), (3, 2), (3, 1)], names=["b", "a"])
+
+        left = pd.DataFrame(index=midx1, data={"x": [10, 20, 30, 40]})
+        right = pd.DataFrame(index=midx3, data={"y": ["foo", "bar", "fing"]})
+
+        result = left.join(right)
+
+        expected = pd.DataFrame(
+            index=midx1,
+            data={"x": [10, 20, 30, 40], "y": ["fing", "foo", "bar", np.nan]},
+        )
+
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_pivot_old.py b/pandas/tests/reshape/merge/test_pivot_old.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 13f0f14014a31..5811f3bc196a1 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -27,10 +27,10 @@
     isna,
     read_csv,
 )
-import pandas.core.common as com
+import pandas._testing as tm
+from pandas.core.arrays import SparseArray
+from pandas.core.construction import create_series_with_explicit_dtype
 from pandas.tests.extension.decimal import to_decimal
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal, makeCustomDataframe as mkdf
 
 
 @pytest.fixture(params=[True, False])
@@ -39,16 +39,6 @@ def sort(request):
     return request.param
 
 
-@pytest.fixture(params=[True, False, None])
-def sort_with_none(request):
-    """Boolean sort keyword for concat and DataFrame.append.
-
-    Includes the default of None
-    """
-    # TODO: Replace with sort once keyword changes.
-    return request.param
-
-
 class TestConcatAppendCommon:
     """
     Test common dtype coercion rules between concat and append.
@@ -208,8 +198,8 @@ def test_concatlike_same_dtypes(self):
 
             # cannot append non-index
             msg = (
-                r"cannot concatenate object of type '.+';"
-                " only Series and DataFrame objs are valid"
+                r"cannot concatenate object of type '.+'; "
+                "only Series and DataFrame objs are valid"
             )
             with pytest.raises(TypeError, match=msg):
                 pd.Series(vals1).append(vals2)
@@ -769,25 +759,6 @@ def test_concat_categorical_empty(self):
         tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
         tm.assert_series_equal(s2.append(s1, ignore_index=True), exp)
 
-    def test_concat_join_axes_deprecated(self, axis):
-        # GH21951
-        one = pd.DataFrame([[0.0, 1.0], [2.0, 3.0]], columns=list("ab"))
-        two = pd.DataFrame(
-            [[10.0, 11.0], [12.0, 13.0]], index=[1, 2], columns=list("bc")
-        )
-
-        expected = pd.concat([one, two], axis=1, sort=False).reindex(index=two.index)
-        with tm.assert_produces_warning(expected_warning=FutureWarning):
-            result = pd.concat([one, two], axis=1, sort=False, join_axes=[two.index])
-        tm.assert_frame_equal(result, expected)
-
-        expected = pd.concat([one, two], axis=0, sort=False).reindex(
-            columns=two.columns
-        )
-        with tm.assert_produces_warning(expected_warning=FutureWarning):
-            result = pd.concat([one, two], axis=0, sort=False, join_axes=[two.columns])
-        tm.assert_frame_equal(result, expected)
-
 
 class TestAppend:
     def test_append(self, sort, float_frame):
@@ -860,7 +831,7 @@ def test_append_length0_frame(self, sort):
         df5 = df.append(df3, sort=sort)
 
         expected = DataFrame(index=[0, 1], columns=["A", "B", "C"])
-        assert_frame_equal(df5, expected)
+        tm.assert_frame_equal(df5, expected)
 
     def test_append_records(self):
         arr1 = np.zeros((2,), dtype=("i4,f4,a10"))
@@ -874,30 +845,22 @@ def test_append_records(self):
 
         result = df1.append(df2, ignore_index=True)
         expected = DataFrame(np.concatenate((arr1, arr2)))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     # rewrite sort fixture, since we also want to test default of None
-    def test_append_sorts(self, sort_with_none):
+    def test_append_sorts(self, sort):
         df1 = pd.DataFrame({"a": [1, 2], "b": [1, 2]}, columns=["b", "a"])
         df2 = pd.DataFrame({"a": [1, 2], "c": [3, 4]}, index=[2, 3])
 
-        if sort_with_none is None:
-            # only warn if not explicitly specified
-            # don't check stacklevel since its set for concat, and append
-            # has an extra stack.
-            ctx = tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
-        else:
-            ctx = tm.assert_produces_warning(None)
-
-        with ctx:
-            result = df1.append(df2, sort=sort_with_none)
+        with tm.assert_produces_warning(None):
+            result = df1.append(df2, sort=sort)
 
         # for None / True
         expected = pd.DataFrame(
             {"b": [1, 2, None, None], "a": [1, 2, 1, 2], "c": [None, None, 3, 4]},
             columns=["a", "b", "c"],
         )
-        if sort_with_none is False:
+        if sort is False:
             expected = expected[["b", "a", "c"]]
         tm.assert_frame_equal(result, expected)
 
@@ -969,7 +932,7 @@ def test_append_preserve_index_name(self):
 
     all_indexes = indexes_can_append + indexes_cannot_append_with_other
 
-    @pytest.mark.parametrize("index", all_indexes, ids=lambda x: x.__class__.__name__)
+    @pytest.mark.parametrize("index", all_indexes, ids=lambda x: type(x).__name__)
     def test_append_same_columns_type(self, index):
         # GH18359
 
@@ -981,7 +944,7 @@ def test_append_same_columns_type(self, index):
         expected = pd.DataFrame(
             [[1.0, 2.0, 3.0], [4, 5, 6], [7, 8, np.nan]], index=[0, 1, 2], columns=index
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # ser wider than df
         ser_index = index
@@ -994,12 +957,12 @@ def test_append_same_columns_type(self, index):
             index=[0, 1, 2],
             columns=ser_index,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "df_columns, series_index",
         combinations(indexes_can_append, r=2),
-        ids=lambda x: x.__class__.__name__,
+        ids=lambda x: type(x).__name__,
     )
     def test_append_different_columns_types(self, df_columns, series_index):
         # GH18359
@@ -1021,15 +984,15 @@ def test_append_different_columns_types(self, df_columns, series_index):
             index=[0, 1, 2],
             columns=combined_columns,
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "index_can_append", indexes_can_append, ids=lambda x: x.__class__.__name__
+        "index_can_append", indexes_can_append, ids=lambda x: type(x).__name__
     )
     @pytest.mark.parametrize(
         "index_cannot_append_with_other",
         indexes_cannot_append_with_other,
-        ids=lambda x: x.__class__.__name__,
+        ids=lambda x: type(x).__name__,
     )
     def test_append_different_columns_types_raises(
         self, index_can_append, index_cannot_append_with_other
@@ -1109,7 +1072,7 @@ def test_append_dtype_coerce(self, sort):
         else:
             expected = expected[["start_time", "end_time"]]
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_append_missing_column_proper_upcast(self, sort):
         df1 = DataFrame({"A": np.array([1, 2, 3, 4], dtype="i8")})
@@ -1138,7 +1101,7 @@ def test_append_empty_frame_to_series_with_dateutil_tz(self):
         # These columns get cast to object after append
         expected["a"] = expected["a"].astype(float)
         expected["b"] = expected["b"].astype(float)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
 
 class TestConcatenate:
@@ -1220,7 +1183,9 @@ def test_concat_keys_specific_levels(self):
         )
 
         tm.assert_index_equal(result.columns.levels[0], Index(level, name="group_key"))
-        assert result.columns.names[0] == "group_key"
+        tm.assert_index_equal(result.columns.levels[1], Index([0, 1, 2, 3]))
+
+        assert result.columns.names == ["group_key", None]
 
     def test_concat_dataframe_keys_bug(self, sort):
         t1 = DataFrame(
@@ -1263,7 +1228,7 @@ def test_concat_dict(self):
             "qux": DataFrame(np.random.randn(4, 3)),
         }
 
-        sorted_keys = com.dict_keys_to_ordered_list(frames)
+        sorted_keys = list(frames.keys())
 
         result = concat(frames)
         expected = concat([frames[k] for k in sorted_keys], keys=sorted_keys)
@@ -1362,7 +1327,7 @@ def test_concat_multiindex_with_none_in_index_names(self):
         expected = pd.DataFrame(
             {"col": list(range(5)) * 2}, index=index, dtype=np.int32
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = concat([df, df[:2]], keys=[1, 2], names=["level2"])
         level2 = [1] * 5 + [2] * 2
@@ -1371,7 +1336,7 @@ def test_concat_multiindex_with_none_in_index_names(self):
         tuples = list(zip(level2, level1, no_name))
         index = pd.MultiIndex.from_tuples(tuples, names=["level2", "level1", None])
         expected = pd.DataFrame({"col": no_name}, index=index, dtype=np.int32)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_keys_and_levels(self):
         df = DataFrame(np.random.randn(1, 3))
@@ -1409,7 +1374,7 @@ def test_concat_keys_and_levels(self):
             keys=[("foo", "one"), ("foo", "two"), ("baz", "one"), ("baz", "two")],
             names=["first", "second"],
         )
-        assert result.index.names == ("first", "second") + (None,)
+        assert result.index.names == ("first", "second", None)
         tm.assert_index_equal(
             result.index.levels[0], Index(["baz", "foo"], name="first")
         )
@@ -1492,12 +1457,12 @@ def test_dups_index(self):
         )
 
         result = concat([df, df], axis=1)
-        assert_frame_equal(result.iloc[:, :4], df)
-        assert_frame_equal(result.iloc[:, 4:], df)
+        tm.assert_frame_equal(result.iloc[:, :4], df)
+        tm.assert_frame_equal(result.iloc[:, 4:], df)
 
         result = concat([df, df], axis=0)
-        assert_frame_equal(result.iloc[:10], df)
-        assert_frame_equal(result.iloc[10:], df)
+        tm.assert_frame_equal(result.iloc[:10], df)
+        tm.assert_frame_equal(result.iloc[10:], df)
 
         # multi dtypes
         df = concat(
@@ -1511,23 +1476,23 @@ def test_dups_index(self):
         )
 
         result = concat([df, df], axis=1)
-        assert_frame_equal(result.iloc[:, :6], df)
-        assert_frame_equal(result.iloc[:, 6:], df)
+        tm.assert_frame_equal(result.iloc[:, :6], df)
+        tm.assert_frame_equal(result.iloc[:, 6:], df)
 
         result = concat([df, df], axis=0)
-        assert_frame_equal(result.iloc[:10], df)
-        assert_frame_equal(result.iloc[10:], df)
+        tm.assert_frame_equal(result.iloc[:10], df)
+        tm.assert_frame_equal(result.iloc[10:], df)
 
         # append
         result = df.iloc[0:8, :].append(df.iloc[8:])
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         result = df.iloc[0:8, :].append(df.iloc[8:9]).append(df.iloc[9:10])
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         expected = concat([df, df], axis=0)
         result = df.append(df)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_with_mixed_tuples(self, sort):
         # 10697
@@ -1561,14 +1526,14 @@ def test_handle_empty_objects(self, sort):
         )
         empty = DataFrame()
         result = concat([df, empty], axis=1)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
         result = concat([empty, df], axis=1)
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
         result = concat([df, empty])
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
         result = concat([empty, df])
-        assert_frame_equal(result, df)
+        tm.assert_frame_equal(result, df)
 
     def test_concat_mixed_objs(self):
 
@@ -1586,25 +1551,25 @@ def test_concat_mixed_objs(self):
             np.repeat(arr, 2).reshape(-1, 2), index=index, columns=[0, 0]
         )
         result = concat([df, df], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
             np.repeat(arr, 2).reshape(-1, 2), index=index, columns=[0, 1]
         )
         result = concat([s1, s2], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
             np.repeat(arr, 3).reshape(-1, 3), index=index, columns=[0, 1, 2]
         )
         result = concat([s1, s2, s1], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(
             np.repeat(arr, 5).reshape(-1, 5), index=index, columns=[0, 0, 1, 2, 3]
         )
         result = concat([s1, df, s2, s2, s1], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # with names
         s1.name = "foo"
@@ -1612,32 +1577,32 @@ def test_concat_mixed_objs(self):
             np.repeat(arr, 3).reshape(-1, 3), index=index, columns=["foo", 0, 0]
         )
         result = concat([s1, df, s2], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         s2.name = "bar"
         expected = DataFrame(
             np.repeat(arr, 3).reshape(-1, 3), index=index, columns=["foo", 0, "bar"]
         )
         result = concat([s1, df, s2], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # ignore index
         expected = DataFrame(
             np.repeat(arr, 3).reshape(-1, 3), index=index, columns=[0, 1, 2]
         )
         result = concat([s1, df, s2], axis=1, ignore_index=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # axis 0
         expected = DataFrame(
             np.tile(arr, 3).reshape(-1, 1), index=index.tolist() * 3, columns=[0]
         )
         result = concat([s1, df, s2])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(np.tile(arr, 3).reshape(-1, 1), columns=[0])
         result = concat([s1, df, s2], ignore_index=True)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_empty_dtype_coerce(self):
 
@@ -1703,11 +1668,11 @@ def test_concat_series_axis1(self, sort=sort):
 
         result = concat(pieces, axis=1)
         expected = DataFrame(pieces).T
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = concat(pieces, keys=["A", "B", "C"], axis=1)
         expected = DataFrame(pieces, index=["A", "B", "C"]).T
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         # preserve series names, #2489
         s = Series(randn(5), name="A")
@@ -1715,7 +1680,7 @@ def test_concat_series_axis1(self, sort=sort):
 
         result = concat([s, s2], axis=1)
         expected = DataFrame({"A": s, "B": s2})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         s2.name = None
         result = concat([s, s2], axis=1)
@@ -1726,7 +1691,7 @@ def test_concat_series_axis1(self, sort=sort):
         s2 = Series(randn(4), index=["d", "a", "b", "c"], name="B")
         result = concat([s, s2], axis=1, sort=sort)
         expected = DataFrame({"A": s, "B": s2})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_series_axis1_names_applied(self):
         # ensure names argument is not ignored on axis=1, #23490
@@ -1736,14 +1701,14 @@ def test_concat_series_axis1_names_applied(self):
         expected = DataFrame(
             [[1, 4], [2, 5], [3, 6]], columns=pd.Index(["a", "b"], name="A")
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = concat([s, s2], axis=1, keys=[("a", 1), ("b", 2)], names=["A", "B"])
         expected = DataFrame(
             [[1, 4], [2, 5], [3, 6]],
             columns=MultiIndex.from_tuples([("a", 1), ("b", 2)], names=["A", "B"]),
         )
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_single_with_key(self):
         df = DataFrame(np.random.randn(10, 4))
@@ -1816,7 +1781,7 @@ def test_concat_bug_2972(self):
 
         expected = DataFrame({0: ts0, 1: ts1})
         expected.columns = ["same name", "same name"]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_bug_3602(self):
 
@@ -1842,7 +1807,7 @@ def test_concat_bug_3602(self):
         expected.columns = ["firmNo", "prc", "stringvar", "C", "misc", "prc"]
 
         result = concat([df1, df2], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_inner_join_empty(self):
         # GH 15328
@@ -1852,7 +1817,7 @@ def test_concat_inner_join_empty(self):
 
         for how, expected in [("inner", df_expected), ("outer", df_a)]:
             result = pd.concat([df_a, df_empty], axis=1, join=how)
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
     def test_concat_series_axis1_same_names_ignore_index(self):
         dates = date_range("01-Jan-2013", "01-Jan-2014", freq="MS")[0:-1]
@@ -1870,15 +1835,15 @@ def test_concat_iterables(self):
         df1 = DataFrame([1, 2, 3])
         df2 = DataFrame([4, 5, 6])
         expected = DataFrame([1, 2, 3, 4, 5, 6])
-        assert_frame_equal(concat((df1, df2), ignore_index=True), expected)
-        assert_frame_equal(concat([df1, df2], ignore_index=True), expected)
-        assert_frame_equal(
+        tm.assert_frame_equal(concat((df1, df2), ignore_index=True), expected)
+        tm.assert_frame_equal(concat([df1, df2], ignore_index=True), expected)
+        tm.assert_frame_equal(
             concat((df for df in (df1, df2)), ignore_index=True), expected
         )
-        assert_frame_equal(concat(deque((df1, df2)), ignore_index=True), expected)
+        tm.assert_frame_equal(concat(deque((df1, df2)), ignore_index=True), expected)
 
         class CustomIterator1:
-            def __len__(self):
+            def __len__(self) -> int:
                 return 2
 
             def __getitem__(self, index):
@@ -1887,30 +1852,30 @@ def __getitem__(self, index):
                 except KeyError:
                     raise IndexError
 
-        assert_frame_equal(pd.concat(CustomIterator1(), ignore_index=True), expected)
+        tm.assert_frame_equal(pd.concat(CustomIterator1(), ignore_index=True), expected)
 
         class CustomIterator2(abc.Iterable):
             def __iter__(self):
                 yield df1
                 yield df2
 
-        assert_frame_equal(pd.concat(CustomIterator2(), ignore_index=True), expected)
+        tm.assert_frame_equal(pd.concat(CustomIterator2(), ignore_index=True), expected)
 
     def test_concat_invalid(self):
 
         # trying to concat a ndframe with a non-ndframe
-        df1 = mkdf(10, 2)
+        df1 = tm.makeCustomDataframe(10, 2)
         msg = (
-            "cannot concatenate object of type '{}';"
-            " only Series and DataFrame objs are valid"
+            "cannot concatenate object of type '{}'; "
+            "only Series and DataFrame objs are valid"
         )
         for obj in [1, dict(), [1, 2], (1, 2)]:
             with pytest.raises(TypeError, match=msg.format(type(obj))):
                 concat([df1, obj])
 
     def test_concat_invalid_first_argument(self):
-        df1 = mkdf(10, 2)
-        df2 = mkdf(10, 2)
+        df1 = tm.makeCustomDataframe(10, 2)
+        df2 = tm.makeCustomDataframe(10, 2)
         msg = (
             "first argument must be an iterable of pandas "
             'objects, you passed an object of type "DataFrame"'
@@ -1935,7 +1900,7 @@ def test_concat_invalid_first_argument(self):
         reader = read_csv(StringIO(data), chunksize=1)
         result = concat(reader, ignore_index=True)
         expected = read_csv(StringIO(data))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_NaT_series(self):
         # GH 11693
@@ -1979,7 +1944,7 @@ def test_concat_tz_frame(self):
 
         # concat
         df3 = pd.concat([df2.A.to_frame(), df2.B.to_frame()], axis=1)
-        assert_frame_equal(df2, df3)
+        tm.assert_frame_equal(df2, df3)
 
     def test_concat_tz_series(self):
         # gh-11755: tz and no tz
@@ -2085,7 +2050,7 @@ def test_concat_NaT_dataframes_all_NaT_axis_0(self, tz1, tz2, s):
         if tz1 != tz2:
             expected = expected.astype(object)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("tz1", [None, "UTC"])
     @pytest.mark.parametrize("tz2", [None, "UTC"])
@@ -2101,7 +2066,7 @@ def test_concat_NaT_dataframes_all_NaT_axis_1(self, tz1, tz2):
             }
         )
         result = pd.concat([first, second], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("tz1", [None, "UTC"])
     @pytest.mark.parametrize("tz2", [None, "UTC"])
@@ -2130,7 +2095,7 @@ def test_concat_NaT_series_dataframe_all_NaT(self, tz1, tz2):
             expected = expected.astype(object)
 
         result = pd.concat([first, second])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("tz", [None, "UTC"])
     def test_concat_NaT_dataframes(self, tz):
@@ -2152,7 +2117,7 @@ def test_concat_NaT_dataframes(self, tz):
         )
 
         result = pd.concat([first, second], axis=0)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_concat_period_series(self):
         x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
@@ -2195,7 +2160,7 @@ def test_concat_period_other_series(self):
     def test_concat_empty_series(self):
         # GH 11082
         s1 = pd.Series([1, 2, 3], name="x")
-        s2 = pd.Series(name="y")
+        s2 = pd.Series(name="y", dtype="float64")
         res = pd.concat([s1, s2], axis=1)
         exp = pd.DataFrame(
             {"x": [1, 2, 3], "y": [np.nan, np.nan, np.nan]},
@@ -2204,7 +2169,7 @@ def test_concat_empty_series(self):
         tm.assert_frame_equal(res, exp)
 
         s1 = pd.Series([1, 2, 3], name="x")
-        s2 = pd.Series(name="y")
+        s2 = pd.Series(name="y", dtype="float64")
         res = pd.concat([s1, s2], axis=0)
         # name will be reset
         exp = pd.Series([1, 2, 3])
@@ -2212,7 +2177,7 @@ def test_concat_empty_series(self):
 
         # empty Series with no name
         s1 = pd.Series([1, 2, 3], name="x")
-        s2 = pd.Series(name=None)
+        s2 = pd.Series(name=None, dtype="float64")
         res = pd.concat([s1, s2], axis=1)
         exp = pd.DataFrame(
             {"x": [1, 2, 3], 0: [np.nan, np.nan, np.nan]},
@@ -2227,7 +2192,9 @@ def test_concat_empty_series_timelike(self, tz, values):
         # GH 18447
 
         first = Series([], dtype="M8[ns]").dt.tz_localize(tz)
-        second = Series(values)
+        dtype = None if values else np.float64
+        second = Series(values, dtype=dtype)
+
         expected = DataFrame(
             {
                 0: pd.Series([pd.NaT] * len(values), dtype="M8[ns]").dt.tz_localize(tz),
@@ -2235,7 +2202,7 @@ def test_concat_empty_series_timelike(self, tz, values):
             }
         )
         result = concat([first, second], axis=1)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_default_index(self):
         # is_series and ignore_index
@@ -2587,7 +2554,8 @@ def test_concat_odered_dict(self):
 @pytest.mark.parametrize("dt", np.sctypes["float"])
 def test_concat_no_unnecessary_upcast(dt, pdt):
     # GH 13247
-    dims = pdt().ndim
+    dims = pdt(dtype=object).ndim
+
     dfs = [
         pdt(np.array([1], dtype=dt, ndmin=dims)),
         pdt(np.array([np.nan], dtype=dt, ndmin=dims)),
@@ -2597,7 +2565,7 @@ def test_concat_no_unnecessary_upcast(dt, pdt):
     assert x.values.dtype == dt
 
 
-@pytest.mark.parametrize("pdt", [pd.Series, pd.DataFrame])
+@pytest.mark.parametrize("pdt", [create_series_with_explicit_dtype, pd.DataFrame])
 @pytest.mark.parametrize("dt", np.sctypes["int"])
 def test_concat_will_upcast(dt, pdt):
     with catch_warnings(record=True):
@@ -2617,19 +2585,20 @@ def test_concat_empty_and_non_empty_frame_regression():
     df2 = pd.DataFrame({"foo": []})
     expected = pd.DataFrame({"foo": [1.0]})
     result = pd.concat([df1, df2])
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_concat_empty_and_non_empty_series_regression():
     # GH 18187 regression test
     s1 = pd.Series([1])
-    s2 = pd.Series([])
+    s2 = pd.Series([], dtype=object)
+
     expected = s1
     result = pd.concat([s1, s2])
     tm.assert_series_equal(result, expected)
 
 
-def test_concat_sorts_columns(sort_with_none):
+def test_concat_sorts_columns(sort):
     # GH-4588
     df1 = pd.DataFrame({"a": [1, 2], "b": [1, 2]}, columns=["b", "a"])
     df2 = pd.DataFrame({"a": [3, 4], "c": [5, 6]})
@@ -2640,22 +2609,16 @@ def test_concat_sorts_columns(sort_with_none):
         columns=["a", "b", "c"],
     )
 
-    if sort_with_none is False:
+    if sort is False:
         expected = expected[["b", "a", "c"]]
 
-    if sort_with_none is None:
-        # only warn if not explicitly specified
-        ctx = tm.assert_produces_warning(FutureWarning)
-    else:
-        ctx = tm.assert_produces_warning(None)
-
     # default
-    with ctx:
-        result = pd.concat([df1, df2], ignore_index=True, sort=sort_with_none)
+    with tm.assert_produces_warning(None):
+        result = pd.concat([df1, df2], ignore_index=True, sort=sort)
     tm.assert_frame_equal(result, expected)
 
 
-def test_concat_sorts_index(sort_with_none):
+def test_concat_sorts_index(sort):
     df1 = pd.DataFrame({"a": [1, 2, 3]}, index=["c", "a", "b"])
     df2 = pd.DataFrame({"b": [1, 2]}, index=["a", "b"])
 
@@ -2663,22 +2626,16 @@ def test_concat_sorts_index(sort_with_none):
     expected = pd.DataFrame(
         {"a": [2, 3, 1], "b": [1, 2, None]}, index=["a", "b", "c"], columns=["a", "b"]
     )
-    if sort_with_none is False:
+    if sort is False:
         expected = expected.loc[["c", "a", "b"]]
 
-    if sort_with_none is None:
-        # only warn if not explicitly specified
-        ctx = tm.assert_produces_warning(FutureWarning)
-    else:
-        ctx = tm.assert_produces_warning(None)
-
     # Warn and sort by default
-    with ctx:
-        result = pd.concat([df1, df2], axis=1, sort=sort_with_none)
+    with tm.assert_produces_warning(None):
+        result = pd.concat([df1, df2], axis=1, sort=sort)
     tm.assert_frame_equal(result, expected)
 
 
-def test_concat_inner_sort(sort_with_none):
+def test_concat_inner_sort(sort):
     # https://github.com/pandas-dev/pandas/pull/20613
     df1 = pd.DataFrame({"a": [1, 2], "b": [1, 2], "c": [1, 2]}, columns=["b", "a", "c"])
     df2 = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=[3, 4])
@@ -2686,12 +2643,10 @@ def test_concat_inner_sort(sort_with_none):
     with tm.assert_produces_warning(None):
         # unset sort should *not* warn for inner join
         # since that never sorted
-        result = pd.concat(
-            [df1, df2], sort=sort_with_none, join="inner", ignore_index=True
-        )
+        result = pd.concat([df1, df2], sort=sort, join="inner", ignore_index=True)
 
     expected = pd.DataFrame({"b": [1, 2, 3, 4], "a": [1, 2, 1, 2]}, columns=["b", "a"])
-    if sort_with_none is True:
+    if sort is True:
         expected = expected[["a", "b"]]
     tm.assert_frame_equal(result, expected)
 
@@ -2746,6 +2701,22 @@ def test_concat_categorical_tz():
     tm.assert_series_equal(result, expected)
 
 
+def test_concat_categorical_unchanged():
+    # GH-12007
+    # test fix for when concat on categorical and float
+    # coerces dtype categorical -> float
+    df = pd.DataFrame(pd.Series(["a", "b", "c"], dtype="category", name="A"))
+    ser = pd.Series([0, 1, 2], index=[0, 1, 3], name="B")
+    result = pd.concat([df, ser], axis=1)
+    expected = pd.DataFrame(
+        {
+            "A": pd.Series(["a", "b", "c", np.nan], dtype="category"),
+            "B": pd.Series([0, 1, np.nan, 2], dtype="float"),
+        }
+    )
+    tm.assert_equal(result, expected)
+
+
 def test_concat_datetimeindex_freq():
     # GH 3232
     # Monotonic index result
@@ -2758,5 +2729,38 @@ def test_concat_datetimeindex_freq():
     # Non-monotonic index result
     result = pd.concat([expected[50:], expected[:50]])
     expected = pd.DataFrame(data[50:] + data[:50], index=dr[50:].append(dr[:50]))
-    expected.index.freq = None
+    expected.index._data.freq = None
     tm.assert_frame_equal(result, expected)
+
+
+def test_concat_empty_df_object_dtype():
+    # GH 9149
+    df_1 = pd.DataFrame({"Row": [0, 1, 1], "EmptyCol": np.nan, "NumberCol": [1, 2, 3]})
+    df_2 = pd.DataFrame(columns=df_1.columns)
+    result = pd.concat([df_1, df_2], axis=0)
+    expected = df_1.astype(object)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_sparse():
+    # GH 23557
+    a = pd.Series(SparseArray([0, 1, 2]))
+    expected = pd.DataFrame(data=[[0, 0], [1, 1], [2, 2]]).astype(
+        pd.SparseDtype(np.int64, 0)
+    )
+    result = pd.concat([a, a], axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("test_series", [True, False])
+def test_concat_copy_index(test_series, axis):
+    # GH 29879
+    if test_series:
+        ser = Series([1, 2])
+        comb = concat([ser, ser], axis=axis, copy=True)
+        assert comb.index is not ser.index
+    else:
+        df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"])
+        comb = concat([df, df], axis=axis, copy=True)
+        assert comb.index is not df.index
+        assert comb.columns is not df.columns
diff --git a/pandas/tests/reshape/test_cut.py b/pandas/tests/reshape/test_cut.py
index a2ebf2359f55f..830e786fd1c6d 100644
--- a/pandas/tests/reshape/test_cut.py
+++ b/pandas/tests/reshape/test_cut.py
@@ -19,9 +19,9 @@
     timedelta_range,
     to_datetime,
 )
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype as CDT
 import pandas.core.reshape.tile as tmod
-import pandas.util.testing as tm
 
 
 def test_simple():
@@ -585,3 +585,43 @@ def test_timedelta_cut_roundtrip():
         ["0 days 23:57:07.200000", "2 days 00:00:00", "3 days 00:00:00"]
     )
     tm.assert_index_equal(result_bins, expected_bins)
+
+
+@pytest.mark.parametrize("bins", [6, 7])
+@pytest.mark.parametrize(
+    "box, compare",
+    [
+        (Series, tm.assert_series_equal),
+        (np.array, tm.assert_categorical_equal),
+        (list, tm.assert_equal),
+    ],
+)
+def test_cut_bool_coercion_to_int(bins, box, compare):
+    # issue 20303
+    data_expected = box([0, 1, 1, 0, 1] * 10)
+    data_result = box([False, True, True, False, True] * 10)
+    expected = cut(data_expected, bins, duplicates="drop")
+    result = cut(data_result, bins, duplicates="drop")
+    compare(result, expected)
+
+
+@pytest.mark.parametrize("labels", ["foo", 1, True])
+def test_cut_incorrect_labels(labels):
+    # GH 13318
+    values = range(5)
+    msg = "Bin labels must either be False, None or passed in as a list-like argument"
+    with pytest.raises(ValueError, match=msg):
+        cut(values, 4, labels=labels)
+
+
+@pytest.mark.parametrize("bins", [3, [0, 5, 15]])
+@pytest.mark.parametrize("right", [True, False])
+@pytest.mark.parametrize("include_lowest", [True, False])
+def test_cut_nullable_integer(bins, right, include_lowest):
+    a = np.random.randint(0, 10, size=50).astype(float)
+    a[::2] = np.nan
+    result = cut(
+        pd.array(a, dtype="Int64"), bins, right=right, include_lowest=include_lowest
+    )
+    expected = cut(a, bins, right=right, include_lowest=include_lowest)
+    tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index 5b1f151daf219..814325844cb4c 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -1,10 +1,9 @@
 import numpy as np
-from numpy import nan
 import pytest
 
 import pandas as pd
 from pandas import DataFrame, lreshape, melt, wide_to_long
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestMelt:
@@ -271,6 +270,16 @@ def test_pandas_dtypes(self, col):
         expected.columns = ["klass", "col", "attribute", "value"]
         tm.assert_frame_equal(result, expected)
 
+    def test_preserve_category(self):
+        # GH 15853
+        data = DataFrame({"A": [1, 2], "B": pd.Categorical(["X", "Y"])})
+        result = pd.melt(data, ["B"], ["A"])
+        expected = DataFrame(
+            {"B": pd.Categorical(["X", "Y"]), "variable": ["A", "A"], "value": [1, 2]}
+        )
+
+        tm.assert_frame_equal(result, expected)
+
     def test_melt_missing_columns_raises(self):
         # GH-23575
         # This test is to ensure that pandas raises an error if melting is
@@ -308,6 +317,22 @@ def test_melt_missing_columns_raises(self):
         ):
             multi.melt(["A"], ["F"], col_level=0)
 
+    def test_melt_mixed_int_str_id_vars(self):
+        # GH 29718
+        df = DataFrame({0: ["foo"], "a": ["bar"], "b": [1], "d": [2]})
+        result = melt(df, id_vars=[0, "a"], value_vars=["b", "d"])
+        expected = DataFrame(
+            {0: ["foo"] * 2, "a": ["bar"] * 2, "variable": list("bd"), "value": [1, 2]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_melt_mixed_int_str_value_vars(self):
+        # GH 29718
+        df = DataFrame({0: ["foo"], "a": ["bar"]})
+        result = melt(df, value_vars=[0, "a"])
+        expected = DataFrame({"variable": [0, "a"], "value": ["foo", "bar"]})
+        tm.assert_frame_equal(result, expected)
+
 
 class TestLreshape:
     def test_pairs(self):
@@ -329,11 +354,11 @@ def test_pairs(self):
                 "29dec2008",
                 "20jan2009",
             ],
-            "visitdt2": ["21jan2009", nan, "22jan2009", "31dec2008", "03feb2009"],
-            "visitdt3": ["05feb2009", nan, nan, "02jan2009", "15feb2009"],
+            "visitdt2": ["21jan2009", np.nan, "22jan2009", "31dec2008", "03feb2009"],
+            "visitdt3": ["05feb2009", np.nan, np.nan, "02jan2009", "15feb2009"],
             "wt1": [1823, 3338, 1549, 3298, 4306],
-            "wt2": [2011.0, nan, 1892.0, 3338.0, 4575.0],
-            "wt3": [2293.0, nan, nan, 3377.0, 4805.0],
+            "wt2": [2011.0, np.nan, 1892.0, 3338.0, 4575.0],
+            "wt3": [2293.0, np.nan, np.nan, 3377.0, 4805.0],
         }
 
         df = DataFrame(data)
@@ -497,13 +522,13 @@ def test_pairs(self):
                 "29dec2008",
                 "20jan2009",
                 "21jan2009",
-                nan,
+                np.nan,
                 "22jan2009",
                 "31dec2008",
                 "03feb2009",
                 "05feb2009",
-                nan,
-                nan,
+                np.nan,
+                np.nan,
                 "02jan2009",
                 "15feb2009",
             ],
@@ -514,13 +539,13 @@ def test_pairs(self):
                 3298.0,
                 4306.0,
                 2011.0,
-                nan,
+                np.nan,
                 1892.0,
                 3338.0,
                 4575.0,
                 2293.0,
-                nan,
-                nan,
+                np.nan,
+                np.nan,
                 3377.0,
                 4805.0,
             ],
@@ -528,6 +553,9 @@ def test_pairs(self):
         exp = DataFrame(exp_data, columns=result.columns)
         tm.assert_frame_equal(result, exp)
 
+        with tm.assert_produces_warning(FutureWarning):
+            result = lreshape(df, spec, dropna=False, label="foo")
+
         spec = {
             "visitdt": ["visitdt{i:d}".format(i=i) for i in range(1, 3)],
             "wt": ["wt{i:d}".format(i=i) for i in range(1, 4)],
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 582084e3bfb5a..fe75aef1ca3d7 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -1,4 +1,3 @@
-from collections import OrderedDict
 from datetime import date, datetime, timedelta
 from itertools import product
 
@@ -16,9 +15,9 @@
     concat,
     date_range,
 )
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype as CDT
 from pandas.core.reshape.pivot import crosstab, pivot_table
-import pandas.util.testing as tm
 
 
 @pytest.fixture(params=[True, False])
@@ -581,23 +580,23 @@ def test_pivot_tz_in_values(self):
         df = pd.DataFrame(
             [
                 {
-                    "uid": u"aa",
+                    "uid": "aa",
                     "ts": pd.Timestamp("2016-08-12 13:00:00-0700", tz="US/Pacific"),
                 },
                 {
-                    "uid": u"aa",
+                    "uid": "aa",
                     "ts": pd.Timestamp("2016-08-12 08:00:00-0700", tz="US/Pacific"),
                 },
                 {
-                    "uid": u"aa",
+                    "uid": "aa",
                     "ts": pd.Timestamp("2016-08-12 14:00:00-0700", tz="US/Pacific"),
                 },
                 {
-                    "uid": u"aa",
+                    "uid": "aa",
                     "ts": pd.Timestamp("2016-08-25 11:00:00-0700", tz="US/Pacific"),
                 },
                 {
-                    "uid": u"aa",
+                    "uid": "aa",
                     "ts": pd.Timestamp("2016-08-25 13:00:00-0700", tz="US/Pacific"),
                 },
             ]
@@ -782,6 +781,15 @@ def test_pivot_with_list_like_values_nans(self, values, method):
         expected = DataFrame(data=data, index=index, columns=columns, dtype="object")
         tm.assert_frame_equal(result, expected)
 
+    def test_pivot_columns_none_raise_error(self):
+        # GH 30924
+        df = pd.DataFrame(
+            {"col1": ["a", "b", "c"], "col2": [1, 2, 3], "col3": [1, 2, 3]}
+        )
+        msg = r"pivot\(\) missing 1 required argument: 'columns'"
+        with pytest.raises(TypeError, match=msg):
+            df.pivot(index="col1", values="col3")
+
     @pytest.mark.xfail(
         reason="MultiIndexed unstack with tuple names fails with KeyError GH#19966"
     )
@@ -897,17 +905,69 @@ def _check_output(
             totals = table.loc[("All", ""), value_col]
             assert totals == self.data[value_col].mean()
 
-        # no rows
-        rtable = self.data.pivot_table(
-            columns=["AA", "BB"], margins=True, aggfunc=np.mean
-        )
-        assert isinstance(rtable, Series)
-
         table = self.data.pivot_table(index=["AA", "BB"], margins=True, aggfunc="mean")
         for item in ["DD", "EE", "FF"]:
             totals = table.loc[("All", ""), item]
             assert totals == self.data[item].mean()
 
+    @pytest.mark.parametrize(
+        "columns, aggfunc, values, expected_columns",
+        [
+            (
+                "A",
+                np.mean,
+                [[5.5, 5.5, 2.2, 2.2], [8.0, 8.0, 4.4, 4.4]],
+                Index(["bar", "All", "foo", "All"], name="A"),
+            ),
+            (
+                ["A", "B"],
+                "sum",
+                [[9, 13, 22, 5, 6, 11], [14, 18, 32, 11, 11, 22]],
+                MultiIndex.from_tuples(
+                    [
+                        ("bar", "one"),
+                        ("bar", "two"),
+                        ("bar", "All"),
+                        ("foo", "one"),
+                        ("foo", "two"),
+                        ("foo", "All"),
+                    ],
+                    names=["A", "B"],
+                ),
+            ),
+        ],
+    )
+    def test_margin_with_only_columns_defined(
+        self, columns, aggfunc, values, expected_columns
+    ):
+        # GH 31016
+        df = pd.DataFrame(
+            {
+                "A": ["foo", "foo", "foo", "foo", "foo", "bar", "bar", "bar", "bar"],
+                "B": ["one", "one", "one", "two", "two", "one", "one", "two", "two"],
+                "C": [
+                    "small",
+                    "large",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                    "small",
+                    "small",
+                    "large",
+                ],
+                "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+                "E": [2, 4, 5, 5, 6, 6, 8, 9, 9],
+            }
+        )
+
+        result = df.pivot_table(columns=columns, margins=True, aggfunc=aggfunc)
+        expected = pd.DataFrame(
+            values, index=Index(["D", "E"]), columns=expected_columns
+        )
+
+        tm.assert_frame_equal(result, expected)
+
     def test_margins_dtype(self):
         # GH 17013
 
@@ -952,6 +1012,20 @@ def test_margins_dtype_len(self):
 
         tm.assert_frame_equal(expected, result)
 
+    @pytest.mark.parametrize("cols", [(1, 2), ("a", "b"), (1, "b"), ("a", 1)])
+    def test_pivot_table_multiindex_only(self, cols):
+        # GH 17038
+        df2 = DataFrame({cols[0]: [1, 2, 3], cols[1]: [1, 2, 3], "v": [4, 5, 6]})
+
+        result = df2.pivot_table(values="v", columns=cols)
+        expected = DataFrame(
+            [[4, 5, 6]],
+            columns=MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)], names=cols),
+            index=Index(["v"]),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
     def test_pivot_integer_columns(self):
         # caused by upstream bug in unstack
 
@@ -1044,7 +1118,7 @@ def test_pivot_columns_lexsorted(self):
         assert pivoted.columns.is_monotonic
 
     def test_pivot_complex_aggfunc(self):
-        f = OrderedDict([("D", ["std"]), ("E", ["sum"])])
+        f = {"D": ["std"], "E": ["sum"]}
         expected = self.data.groupby(["A", "B"]).agg(f).unstack("B")
         result = self.data.pivot_table(index="A", columns="B", aggfunc=f)
 
@@ -1656,6 +1730,69 @@ def test_categorical_margins_category(self, observed):
         table = df.pivot_table("x", "y", "z", dropna=observed, margins=True)
         tm.assert_frame_equal(table, expected)
 
+    def test_margins_casted_to_float(self, observed):
+        # GH 24893
+        df = pd.DataFrame(
+            {
+                "A": [2, 4, 6, 8],
+                "B": [1, 4, 5, 8],
+                "C": [1, 3, 4, 6],
+                "D": ["X", "X", "Y", "Y"],
+            }
+        )
+
+        result = pd.pivot_table(df, index="D", margins=True)
+        expected = pd.DataFrame(
+            {"A": [3, 7, 5], "B": [2.5, 6.5, 4.5], "C": [2, 5, 3.5]},
+            index=pd.Index(["X", "Y", "All"], name="D"),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_pivot_with_categorical(self, observed, ordered_fixture):
+        # gh-21370
+        idx = [np.nan, "low", "high", "low", np.nan]
+        col = [np.nan, "A", "B", np.nan, "A"]
+        df = pd.DataFrame(
+            {
+                "In": pd.Categorical(
+                    idx, categories=["low", "high"], ordered=ordered_fixture
+                ),
+                "Col": pd.Categorical(
+                    col, categories=["A", "B"], ordered=ordered_fixture
+                ),
+                "Val": range(1, 6),
+            }
+        )
+        # case with index/columns/value
+        result = df.pivot_table(
+            index="In", columns="Col", values="Val", observed=observed
+        )
+
+        expected_cols = pd.CategoricalIndex(
+            ["A", "B"], ordered=ordered_fixture, name="Col"
+        )
+
+        expected = pd.DataFrame(
+            data=[[2.0, np.nan], [np.nan, 3.0]], columns=expected_cols
+        )
+        expected.index = Index(
+            pd.Categorical(
+                ["low", "high"], categories=["low", "high"], ordered=ordered_fixture
+            ),
+            name="In",
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # case with columns/value
+        result = df.pivot_table(columns="Col", values="Val", observed=observed)
+
+        expected = pd.DataFrame(
+            data=[[3.5, 3.0]], columns=expected_cols, index=Index(["Val"])
+        )
+
+        tm.assert_frame_equal(result, expected)
+
     def test_categorical_aggfunc(self, observed):
         # GH 9534
         df = pd.DataFrame(
@@ -1903,6 +2040,31 @@ def test_pivot_table_aggfunc_scalar_dropna(self, dropna):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_pivot_table_empty_aggfunc(self):
+        # GH 9186
+        df = pd.DataFrame(
+            {
+                "A": [2, 2, 3, 3, 2],
+                "id": [5, 6, 7, 8, 9],
+                "C": ["p", "q", "q", "p", "q"],
+                "D": [None, None, None, None, None],
+            }
+        )
+        result = df.pivot_table(index="A", columns="D", values="id", aggfunc=np.size)
+        expected = pd.DataFrame()
+        tm.assert_frame_equal(result, expected)
+
+    def test_pivot_table_no_column_raises(self):
+        # GH 10326
+        def agg(l):
+            return np.mean(l)
+
+        foo = pd.DataFrame(
+            {"X": [0, 0, 1, 1], "Y": [0, 1, 0, 1], "Z": [10, 20, 30, 40]}
+        )
+        with pytest.raises(KeyError, match="notpresent"):
+            foo.pivot_table("notpresent", "X", "Y", aggfunc=agg)
+
 
 class TestCrosstab:
     def setup_method(self, method):
@@ -2462,6 +2624,19 @@ def test_crosstab_tuple_name(self, names):
         result = pd.crosstab(s1, s2)
         tm.assert_frame_equal(result, expected)
 
+    def test_crosstab_both_tuple_names(self):
+        # GH 18321
+        s1 = pd.Series(range(3), name=("a", "b"))
+        s2 = pd.Series(range(3), name=("c", "d"))
+
+        expected = pd.DataFrame(
+            np.eye(3, dtype="int64"),
+            index=pd.Index(range(3), name=("a", "b")),
+            columns=pd.Index(range(3), name=("c", "d")),
+        )
+        result = crosstab(s1, s2)
+        tm.assert_frame_equal(result, expected)
+
     def test_crosstab_unsorted_order(self):
         df = pd.DataFrame({"b": [3, 1, 2], "a": [5, 4, 6]}, index=["C", "A", "B"])
         result = pd.crosstab(df.index, [df.b, df.a])
@@ -2474,6 +2649,46 @@ def test_crosstab_unsorted_order(self):
         )
         tm.assert_frame_equal(result, expected)
 
+    def test_crosstab_normalize_multiple_columns(self):
+        # GH 15150
+        df = pd.DataFrame(
+            {
+                "A": ["one", "one", "two", "three"] * 6,
+                "B": ["A", "B", "C"] * 8,
+                "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 4,
+                "D": [0] * 24,
+                "E": [0] * 24,
+            }
+        )
+        result = pd.crosstab(
+            [df.A, df.B],
+            df.C,
+            values=df.D,
+            aggfunc=np.sum,
+            normalize=True,
+            margins=True,
+        )
+        expected = pd.DataFrame(
+            np.array([0] * 29 + [1], dtype=float).reshape(10, 3),
+            columns=Index(["bar", "foo", "All"], dtype="object", name="C"),
+            index=MultiIndex.from_tuples(
+                [
+                    ("one", "A"),
+                    ("one", "B"),
+                    ("one", "C"),
+                    ("three", "A"),
+                    ("three", "B"),
+                    ("three", "C"),
+                    ("two", "A"),
+                    ("two", "B"),
+                    ("two", "C"),
+                    ("All", ""),
+                ],
+                names=["A", "B"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_margin_normalize(self):
         # GH 27500
         df = pd.DataFrame(
diff --git a/pandas/tests/reshape/test_pivot_multilevel.py b/pandas/tests/reshape/test_pivot_multilevel.py
new file mode 100644
index 0000000000000..8374e829e6a28
--- /dev/null
+++ b/pandas/tests/reshape/test_pivot_multilevel.py
@@ -0,0 +1,192 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Index, MultiIndex
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "input_index, input_columns, input_values, "
+    "expected_values, expected_columns, expected_index",
+    [
+        (
+            ["lev4"],
+            "lev3",
+            "values",
+            [
+                [0.0, np.nan],
+                [np.nan, 1.0],
+                [2.0, np.nan],
+                [np.nan, 3.0],
+                [4.0, np.nan],
+                [np.nan, 5.0],
+                [6.0, np.nan],
+                [np.nan, 7.0],
+            ],
+            Index([1, 2], name="lev3"),
+            Index([1, 2, 3, 4, 5, 6, 7, 8], name="lev4"),
+        ),
+        (
+            ["lev4"],
+            "lev3",
+            None,
+            [
+                [1.0, np.nan, 1.0, np.nan, 0.0, np.nan],
+                [np.nan, 1.0, np.nan, 1.0, np.nan, 1.0],
+                [1.0, np.nan, 2.0, np.nan, 2.0, np.nan],
+                [np.nan, 1.0, np.nan, 2.0, np.nan, 3.0],
+                [2.0, np.nan, 1.0, np.nan, 4.0, np.nan],
+                [np.nan, 2.0, np.nan, 1.0, np.nan, 5.0],
+                [2.0, np.nan, 2.0, np.nan, 6.0, np.nan],
+                [np.nan, 2.0, np.nan, 2.0, np.nan, 7.0],
+            ],
+            MultiIndex.from_tuples(
+                [
+                    ("lev1", 1),
+                    ("lev1", 2),
+                    ("lev2", 1),
+                    ("lev2", 2),
+                    ("values", 1),
+                    ("values", 2),
+                ],
+                names=[None, "lev3"],
+            ),
+            Index([1, 2, 3, 4, 5, 6, 7, 8], name="lev4"),
+        ),
+        (
+            ["lev1", "lev2"],
+            "lev3",
+            "values",
+            [[0, 1], [2, 3], [4, 5], [6, 7]],
+            Index([1, 2], name="lev3"),
+            MultiIndex.from_tuples(
+                [(1, 1), (1, 2), (2, 1), (2, 2)], names=["lev1", "lev2"]
+            ),
+        ),
+        (
+            ["lev1", "lev2"],
+            "lev3",
+            None,
+            [[1, 2, 0, 1], [3, 4, 2, 3], [5, 6, 4, 5], [7, 8, 6, 7]],
+            MultiIndex.from_tuples(
+                [("lev4", 1), ("lev4", 2), ("values", 1), ("values", 2)],
+                names=[None, "lev3"],
+            ),
+            MultiIndex.from_tuples(
+                [(1, 1), (1, 2), (2, 1), (2, 2)], names=["lev1", "lev2"]
+            ),
+        ),
+    ],
+)
+def test_pivot_list_like_index(
+    input_index,
+    input_columns,
+    input_values,
+    expected_values,
+    expected_columns,
+    expected_index,
+):
+    # GH 21425, test when index is given a list
+    df = pd.DataFrame(
+        {
+            "lev1": [1, 1, 1, 1, 2, 2, 2, 2],
+            "lev2": [1, 1, 2, 2, 1, 1, 2, 2],
+            "lev3": [1, 2, 1, 2, 1, 2, 1, 2],
+            "lev4": [1, 2, 3, 4, 5, 6, 7, 8],
+            "values": [0, 1, 2, 3, 4, 5, 6, 7],
+        }
+    )
+
+    result = df.pivot(index=input_index, columns=input_columns, values=input_values)
+    expected = pd.DataFrame(
+        expected_values, columns=expected_columns, index=expected_index
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "input_index, input_columns, input_values, "
+    "expected_values, expected_columns, expected_index",
+    [
+        (
+            "lev4",
+            ["lev3"],
+            "values",
+            [
+                [0.0, np.nan],
+                [np.nan, 1.0],
+                [2.0, np.nan],
+                [np.nan, 3.0],
+                [4.0, np.nan],
+                [np.nan, 5.0],
+                [6.0, np.nan],
+                [np.nan, 7.0],
+            ],
+            Index([1, 2], name="lev3"),
+            Index([1, 2, 3, 4, 5, 6, 7, 8], name="lev4"),
+        ),
+        (
+            ["lev1", "lev2"],
+            ["lev3"],
+            "values",
+            [[0, 1], [2, 3], [4, 5], [6, 7]],
+            Index([1, 2], name="lev3"),
+            MultiIndex.from_tuples(
+                [(1, 1), (1, 2), (2, 1), (2, 2)], names=["lev1", "lev2"]
+            ),
+        ),
+        (
+            ["lev1"],
+            ["lev2", "lev3"],
+            "values",
+            [[0, 1, 2, 3], [4, 5, 6, 7]],
+            MultiIndex.from_tuples(
+                [(1, 1), (1, 2), (2, 1), (2, 2)], names=["lev2", "lev3"]
+            ),
+            Index([1, 2], name="lev1"),
+        ),
+        (
+            ["lev1", "lev2"],
+            ["lev3", "lev4"],
+            "values",
+            [
+                [0.0, 1.0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+                [np.nan, np.nan, 2.0, 3.0, np.nan, np.nan, np.nan, np.nan],
+                [np.nan, np.nan, np.nan, np.nan, 4.0, 5.0, np.nan, np.nan],
+                [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6.0, 7.0],
+            ],
+            MultiIndex.from_tuples(
+                [(1, 1), (2, 2), (1, 3), (2, 4), (1, 5), (2, 6), (1, 7), (2, 8)],
+                names=["lev3", "lev4"],
+            ),
+            MultiIndex.from_tuples(
+                [(1, 1), (1, 2), (2, 1), (2, 2)], names=["lev1", "lev2"]
+            ),
+        ),
+    ],
+)
+def test_pivot_list_like_columns(
+    input_index,
+    input_columns,
+    input_values,
+    expected_values,
+    expected_columns,
+    expected_index,
+):
+    # GH 21425, test when columns is given a list
+    df = pd.DataFrame(
+        {
+            "lev1": [1, 1, 1, 1, 2, 2, 2, 2],
+            "lev2": [1, 1, 2, 2, 1, 1, 2, 2],
+            "lev3": [1, 2, 1, 2, 1, 2, 1, 2],
+            "lev4": [1, 2, 3, 4, 5, 6, 7, 8],
+            "values": [0, 1, 2, 3, 4, 5, 6, 7],
+        }
+    )
+
+    result = df.pivot(index=input_index, columns=input_columns, values=input_values)
+    expected = pd.DataFrame(
+        expected_values, columns=expected_columns, index=expected_index
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_qcut.py b/pandas/tests/reshape/test_qcut.py
index cb46918157e89..c436ab5d90578 100644
--- a/pandas/tests/reshape/test_qcut.py
+++ b/pandas/tests/reshape/test_qcut.py
@@ -3,6 +3,7 @@
 import numpy as np
 import pytest
 
+import pandas as pd
 from pandas import (
     Categorical,
     DatetimeIndex,
@@ -18,9 +19,9 @@
     qcut,
     timedelta_range,
 )
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype as CDT
 from pandas.core.algorithms import quantile
-import pandas.util.testing as tm
 
 from pandas.tseries.offsets import Day, Nano
 
@@ -130,6 +131,38 @@ def test_qcut_return_intervals():
     tm.assert_series_equal(res, exp)
 
 
+@pytest.mark.parametrize("labels", ["foo", 1, True])
+def test_qcut_incorrect_labels(labels):
+    # GH 13318
+    values = range(5)
+    msg = "Bin labels must either be False, None or passed in as a list-like argument"
+    with pytest.raises(ValueError, match=msg):
+        qcut(values, 4, labels=labels)
+
+
+@pytest.mark.parametrize("labels", [["a", "b", "c"], list(range(3))])
+def test_qcut_wrong_length_labels(labels):
+    # GH 13318
+    values = range(10)
+    msg = "Bin labels must be one fewer than the number of bin edges"
+    with pytest.raises(ValueError, match=msg):
+        qcut(values, 4, labels=labels)
+
+
+@pytest.mark.parametrize(
+    "labels, expected",
+    [
+        (["a", "b", "c"], Categorical(["a", "b", "c"], ordered=True)),
+        (list(range(3)), Categorical([0, 1, 2], ordered=True)),
+    ],
+)
+def test_qcut_list_like_labels(labels, expected):
+    # GH 13318
+    values = range(3)
+    result = qcut(values, 3, labels=labels)
+    tm.assert_categorical_equal(result, expected)
+
+
 @pytest.mark.parametrize(
     "kwargs,msg",
     [
@@ -236,3 +269,32 @@ def test_date_like_qcut_bins(arg, expected_bins):
     ser = Series(arg)
     result, result_bins = qcut(ser, 2, retbins=True)
     tm.assert_index_equal(result_bins, expected_bins)
+
+
+@pytest.mark.parametrize("bins", [6, 7])
+@pytest.mark.parametrize(
+    "box, compare",
+    [
+        (Series, tm.assert_series_equal),
+        (np.array, tm.assert_categorical_equal),
+        (list, tm.assert_equal),
+    ],
+)
+def test_qcut_bool_coercion_to_int(bins, box, compare):
+    # issue 20303
+    data_expected = box([0, 1, 1, 0, 1] * 10)
+    data_result = box([False, True, True, False, True] * 10)
+    expected = qcut(data_expected, bins, duplicates="drop")
+    result = qcut(data_result, bins, duplicates="drop")
+    compare(result, expected)
+
+
+@pytest.mark.parametrize("q", [2, 5, 10])
+def test_qcut_nullable_integer(q, any_nullable_int_dtype):
+    arr = pd.array(np.arange(100), dtype=any_nullable_int_dtype)
+    arr[::2] = pd.NA
+
+    result = qcut(arr, q)
+    expected = qcut(arr.astype(float), q)
+
+    tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/reshape/test_reshape.py b/pandas/tests/reshape/test_reshape.py
index 149930059d868..6113cfec48df9 100644
--- a/pandas/tests/reshape/test_reshape.py
+++ b/pandas/tests/reshape/test_reshape.py
@@ -1,19 +1,16 @@
 from collections import OrderedDict
 
 import numpy as np
-from numpy import nan
 import pytest
 
 from pandas.core.dtypes.common import is_integer_dtype
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Index, Series, get_dummies
-from pandas.core.sparse.api import SparseArray, SparseDtype
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
 
 
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
 class TestGetDummies:
     @pytest.fixture
     def df(self):
@@ -48,16 +45,16 @@ def test_basic(self, sparse, dtype):
             dtype=self.effective_dtype(dtype),
         )
         if sparse:
-            expected = expected.apply(pd.SparseArray, fill_value=0.0)
+            expected = expected.apply(SparseArray, fill_value=0.0)
         result = get_dummies(s_list, sparse=sparse, dtype=dtype)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(s_series, sparse=sparse, dtype=dtype)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected.index = list("ABC")
         result = get_dummies(s_series_index, sparse=sparse, dtype=dtype)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_types(self, sparse, dtype):
         # GH 10531
@@ -89,9 +86,7 @@ def test_basic_types(self, sparse, dtype):
 
         result = get_dummies(s_df, columns=s_df.columns, sparse=sparse, dtype=dtype)
         if sparse:
-            dtype_name = "Sparse[{}, {}]".format(
-                self.effective_dtype(dtype).name, fill_value
-            )
+            dtype_name = f"Sparse[{self.effective_dtype(dtype).name}, {fill_value}]"
         else:
             dtype_name = self.effective_dtype(dtype).name
 
@@ -135,25 +130,25 @@ def test_include_na(self, sparse, dtype):
             {"a": [1, 0, 0], "b": [0, 1, 0]}, dtype=self.effective_dtype(dtype)
         )
         if sparse:
-            exp = exp.apply(pd.SparseArray, fill_value=0.0)
-        assert_frame_equal(res, exp)
+            exp = exp.apply(SparseArray, fill_value=0.0)
+        tm.assert_frame_equal(res, exp)
 
         # Sparse dataframes do not allow nan labelled columns, see #GH8822
         res_na = get_dummies(s, dummy_na=True, sparse=sparse, dtype=dtype)
         exp_na = DataFrame(
-            {nan: [0, 0, 1], "a": [1, 0, 0], "b": [0, 1, 0]},
+            {np.nan: [0, 0, 1], "a": [1, 0, 0], "b": [0, 1, 0]},
             dtype=self.effective_dtype(dtype),
         )
-        exp_na = exp_na.reindex(["a", "b", nan], axis=1)
+        exp_na = exp_na.reindex(["a", "b", np.nan], axis=1)
         # hack (NaN handling in assert_index_equal)
         exp_na.columns = res_na.columns
         if sparse:
-            exp_na = exp_na.apply(pd.SparseArray, fill_value=0.0)
-        assert_frame_equal(res_na, exp_na)
+            exp_na = exp_na.apply(SparseArray, fill_value=0.0)
+        tm.assert_frame_equal(res_na, exp_na)
 
-        res_just_na = get_dummies([nan], dummy_na=True, sparse=sparse, dtype=dtype)
+        res_just_na = get_dummies([np.nan], dummy_na=True, sparse=sparse, dtype=dtype)
         exp_just_na = DataFrame(
-            Series(1, index=[0]), columns=[nan], dtype=self.effective_dtype(dtype)
+            Series(1, index=[0]), columns=[np.nan], dtype=self.effective_dtype(dtype)
         )
         tm.assert_numpy_array_equal(res_just_na.values, exp_just_na.values)
 
@@ -166,12 +161,11 @@ def test_unicode(self, sparse):
         s = [e, eacute, eacute]
         res = get_dummies(s, prefix="letter", sparse=sparse)
         exp = DataFrame(
-            {"letter_e": [1, 0, 0], "letter_{eacute}".format(eacute=eacute): [0, 1, 1]},
-            dtype=np.uint8,
+            {"letter_e": [1, 0, 0], f"letter_{eacute}": [0, 1, 1]}, dtype=np.uint8,
         )
         if sparse:
-            exp = exp.apply(pd.SparseArray, fill_value=0)
-        assert_frame_equal(res, exp)
+            exp = exp.apply(SparseArray, fill_value=0)
+        tm.assert_frame_equal(res, exp)
 
     def test_dataframe_dummies_all_obj(self, df, sparse):
         df = df[["A", "B"]]
@@ -183,14 +177,14 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
         if sparse:
             expected = pd.DataFrame(
                 {
-                    "A_a": pd.SparseArray([1, 0, 1], dtype="uint8"),
-                    "A_b": pd.SparseArray([0, 1, 0], dtype="uint8"),
-                    "B_b": pd.SparseArray([1, 1, 0], dtype="uint8"),
-                    "B_c": pd.SparseArray([0, 0, 1], dtype="uint8"),
+                    "A_a": SparseArray([1, 0, 1], dtype="uint8"),
+                    "A_b": SparseArray([0, 1, 0], dtype="uint8"),
+                    "B_b": SparseArray([1, 1, 0], dtype="uint8"),
+                    "B_c": SparseArray([0, 0, 1], dtype="uint8"),
                 }
             )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_mix_default(self, df, sparse, dtype):
         result = get_dummies(df, sparse=sparse, dtype=dtype)
@@ -210,7 +204,7 @@ def test_dataframe_dummies_mix_default(self, df, sparse, dtype):
             }
         )
         expected = expected[["C", "A_a", "A_b", "B_b", "B_c"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_prefix_list(self, df, sparse):
         prefixes = ["from_A", "from_B"]
@@ -229,9 +223,9 @@ def test_dataframe_dummies_prefix_list(self, df, sparse):
         cols = ["from_A_a", "from_A_b", "from_B_b", "from_B_c"]
         expected = expected[["C"] + cols]
 
-        typ = pd.SparseArray if sparse else pd.Series
+        typ = SparseArray if sparse else pd.Series
         expected[cols] = expected[cols].apply(lambda x: typ(x))
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_prefix_str(self, df, sparse):
         # not that you should do this...
@@ -257,7 +251,7 @@ def test_dataframe_dummies_prefix_str(self, df, sparse):
                 axis=1,
             )
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_subset(self, df, sparse):
         result = get_dummies(df, prefix=["from_A"], columns=["A"], sparse=sparse)
@@ -273,8 +267,8 @@ def test_dataframe_dummies_subset(self, df, sparse):
         expected[["C"]] = df[["C"]]
         if sparse:
             cols = ["from_A_a", "from_A_b"]
-            expected[cols] = expected[cols].apply(lambda x: pd.SparseSeries(x))
-        assert_frame_equal(result, expected)
+            expected[cols] = expected[cols].astype(pd.SparseDtype("uint8", 0))
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_prefix_sep(self, df, sparse):
         result = get_dummies(df, prefix_sep="..", sparse=sparse)
@@ -292,16 +286,16 @@ def test_dataframe_dummies_prefix_sep(self, df, sparse):
         expected = expected[["C", "A..a", "A..b", "B..b", "B..c"]]
         if sparse:
             cols = ["A..a", "A..b", "B..b", "B..c"]
-            expected[cols] = expected[cols].apply(lambda x: pd.SparseSeries(x))
+            expected[cols] = expected[cols].astype(pd.SparseDtype("uint8", 0))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(df, prefix_sep=["..", "__"], sparse=sparse)
         expected = expected.rename(columns={"B..b": "B__b", "B..c": "B__c"})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(df, prefix_sep={"A": "..", "B": "__"}, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_prefix_bad_length(self, df, sparse):
         with pytest.raises(ValueError):
@@ -329,9 +323,9 @@ def test_dataframe_dummies_prefix_dict(self, sparse):
         columns = ["from_A_a", "from_A_b", "from_B_b", "from_B_c"]
         expected[columns] = expected[columns].astype(np.uint8)
         if sparse:
-            expected[columns] = expected[columns].apply(lambda x: pd.SparseSeries(x))
+            expected[columns] = expected[columns].astype(pd.SparseDtype("uint8", 0))
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_with_na(self, df, sparse, dtype):
         df.loc[3, :] = [np.nan, np.nan, np.nan]
@@ -358,11 +352,11 @@ def test_dataframe_dummies_with_na(self, df, sparse, dtype):
             }
         ).sort_index(axis=1)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(df, dummy_na=False, sparse=sparse, dtype=dtype)
         expected = expected[["C", "A_a", "A_b", "B_b", "B_c"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_with_categorical(self, df, sparse, dtype):
         df["cat"] = pd.Categorical(["x", "y", "y"])
@@ -386,7 +380,7 @@ def test_dataframe_dummies_with_categorical(self, df, sparse, dtype):
             }
         ).sort_index(axis=1)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "get_dummies_kwargs,expected",
@@ -413,7 +407,7 @@ def test_dataframe_dummies_unicode(self, get_dummies_kwargs, expected):
         # GH22084 pd.get_dummies incorrectly encodes unicode characters
         # in dataframe column names
         result = get_dummies(**get_dummies_kwargs)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_drop_first(self, sparse):
         # GH12402 Add a new parameter `drop_first` to avoid collinearity
@@ -426,15 +420,15 @@ def test_basic_drop_first(self, sparse):
 
         result = get_dummies(s_list, drop_first=True, sparse=sparse)
         if sparse:
-            expected = expected.apply(pd.SparseArray, fill_value=0)
-        assert_frame_equal(result, expected)
+            expected = expected.apply(SparseArray, fill_value=0)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(s_series, drop_first=True, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected.index = list("ABC")
         result = get_dummies(s_series_index, drop_first=True, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_drop_first_one_level(self, sparse):
         # Test the case that categorical variable only has one level.
@@ -445,14 +439,14 @@ def test_basic_drop_first_one_level(self, sparse):
         expected = DataFrame(index=np.arange(3))
 
         result = get_dummies(s_list, drop_first=True, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(s_series, drop_first=True, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         expected = DataFrame(index=list("ABC"))
         result = get_dummies(s_series_index, drop_first=True, sparse=sparse)
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_basic_drop_first_NA(self, sparse):
         # Test NA handling together with drop_first
@@ -460,29 +454,31 @@ def test_basic_drop_first_NA(self, sparse):
         res = get_dummies(s_NA, drop_first=True, sparse=sparse)
         exp = DataFrame({"b": [0, 1, 0]}, dtype=np.uint8)
         if sparse:
-            exp = exp.apply(pd.SparseArray, fill_value=0)
+            exp = exp.apply(SparseArray, fill_value=0)
 
-        assert_frame_equal(res, exp)
+        tm.assert_frame_equal(res, exp)
 
         res_na = get_dummies(s_NA, dummy_na=True, drop_first=True, sparse=sparse)
-        exp_na = DataFrame({"b": [0, 1, 0], nan: [0, 0, 1]}, dtype=np.uint8).reindex(
-            ["b", nan], axis=1
+        exp_na = DataFrame({"b": [0, 1, 0], np.nan: [0, 0, 1]}, dtype=np.uint8).reindex(
+            ["b", np.nan], axis=1
         )
         if sparse:
-            exp_na = exp_na.apply(pd.SparseArray, fill_value=0)
-        assert_frame_equal(res_na, exp_na)
+            exp_na = exp_na.apply(SparseArray, fill_value=0)
+        tm.assert_frame_equal(res_na, exp_na)
 
-        res_just_na = get_dummies([nan], dummy_na=True, drop_first=True, sparse=sparse)
+        res_just_na = get_dummies(
+            [np.nan], dummy_na=True, drop_first=True, sparse=sparse
+        )
         exp_just_na = DataFrame(index=np.arange(1))
-        assert_frame_equal(res_just_na, exp_just_na)
+        tm.assert_frame_equal(res_just_na, exp_just_na)
 
     def test_dataframe_dummies_drop_first(self, df, sparse):
         df = df[["A", "B"]]
         result = get_dummies(df, drop_first=True, sparse=sparse)
         expected = DataFrame({"A_b": [0, 1, 0], "B_c": [0, 0, 1]}, dtype=np.uint8)
         if sparse:
-            expected = expected.apply(pd.SparseArray, fill_value=0)
-        assert_frame_equal(result, expected)
+            expected = expected.apply(SparseArray, fill_value=0)
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_drop_first_with_categorical(self, df, sparse, dtype):
         df["cat"] = pd.Categorical(["x", "y", "y"])
@@ -495,8 +491,8 @@ def test_dataframe_dummies_drop_first_with_categorical(self, df, sparse, dtype):
         expected = expected[["C", "A_b", "B_c", "cat_y"]]
         if sparse:
             for col in cols:
-                expected[col] = pd.SparseSeries(expected[col])
-        assert_frame_equal(result, expected)
+                expected[col] = SparseArray(expected[col])
+        tm.assert_frame_equal(result, expected)
 
     def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
         df.loc[3, :] = [np.nan, np.nan, np.nan]
@@ -517,13 +513,13 @@ def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
         expected = expected.sort_index(axis=1)
         if sparse:
             for col in cols:
-                expected[col] = pd.SparseSeries(expected[col])
+                expected[col] = SparseArray(expected[col])
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = get_dummies(df, dummy_na=False, drop_first=True, sparse=sparse)
         expected = expected[["C", "A_b", "B_c"]]
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_int_int(self):
         data = Series([1, 2, 1])
@@ -608,6 +604,23 @@ def test_get_dummies_all_sparse(self):
         )
         tm.assert_frame_equal(result, expected)
 
+    @pytest.mark.parametrize("values", ["baz"])
+    def test_get_dummies_with_string_values(self, values):
+        # issue #28383
+        df = pd.DataFrame(
+            {
+                "bar": [1, 2, 3, 4, 5, 6],
+                "foo": ["one", "one", "one", "two", "two", "two"],
+                "baz": ["A", "B", "C", "A", "B", "C"],
+                "zoo": ["x", "y", "z", "q", "w", "t"],
+            }
+        )
+
+        msg = "Input must be a list-like for parameter `columns`"
+
+        with pytest.raises(TypeError, match=msg):
+            pd.get_dummies(df, columns=values)
+
 
 class TestCategoricalReshape:
     def test_reshaping_multi_index_categorical(self):
@@ -618,36 +631,14 @@ def test_reshaping_multi_index_categorical(self):
         df.index.names = ["major", "minor"]
         df["str"] = "foo"
 
-        dti = df.index.levels[0]
-
         df["category"] = df["str"].astype("category")
         result = df["category"].unstack()
 
+        dti = df.index.levels[0]
         c = Categorical(["foo"] * len(dti))
         expected = DataFrame(
             {"A": c.copy(), "B": c.copy(), "C": c.copy(), "D": c.copy()},
             columns=Index(list("ABCD"), name="minor"),
-            index=dti,
+            index=dti.rename("major"),
         )
         tm.assert_frame_equal(result, expected)
-
-
-class TestMakeAxisDummies:
-    def test_preserve_categorical_dtype(self):
-        # GH13854
-        for ordered in [False, True]:
-            cidx = pd.CategoricalIndex(list("xyz"), ordered=ordered)
-            midx = pd.MultiIndex(levels=[["a"], cidx], codes=[[0, 0], [0, 1]])
-            df = DataFrame([[10, 11]], index=midx)
-
-            expected = DataFrame(
-                [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], index=midx, columns=cidx
-            )
-
-            from pandas.core.reshape.reshape import make_axis_dummies
-
-            result = make_axis_dummies(df)
-            tm.assert_frame_equal(result, expected)
-
-            result = make_axis_dummies(df, transform=lambda x: x)
-            tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_union_categoricals.py b/pandas/tests/reshape/test_union_categoricals.py
index 188f08777668e..a503173bd74b1 100644
--- a/pandas/tests/reshape/test_union_categoricals.py
+++ b/pandas/tests/reshape/test_union_categoricals.py
@@ -5,7 +5,7 @@
 
 import pandas as pd
 from pandas import Categorical, CategoricalIndex, Series
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 class TestUnionCategoricals:
diff --git a/pandas/tests/reshape/test_util.py b/pandas/tests/reshape/test_util.py
index 60c6d7ec3017b..cd518dda4edbf 100644
--- a/pandas/tests/reshape/test_util.py
+++ b/pandas/tests/reshape/test_util.py
@@ -2,8 +2,8 @@
 import pytest
 
 from pandas import Index, date_range
+import pandas._testing as tm
 from pandas.core.reshape.util import cartesian_product
-import pandas.util.testing as tm
 
 
 class TestCartesianProduct:
diff --git a/pandas/tests/scalar/interval/test_ops.py b/pandas/tests/scalar/interval/test_ops.py
index f560c42617260..2d9f0954af5a8 100644
--- a/pandas/tests/scalar/interval/test_ops.py
+++ b/pandas/tests/scalar/interval/test_ops.py
@@ -59,8 +59,6 @@ def test_overlaps_endpoint(self, start_shift, closed, other_closed):
     )
     def test_overlaps_invalid_type(self, other):
         interval = Interval(0, 1)
-        msg = "`other` must be an Interval, got {other}".format(
-            other=type(other).__name__
-        )
+        msg = f"`other` must be an Interval, got {type(other).__name__}"
         with pytest.raises(TypeError, match=msg):
             interval.overlaps(other)
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 357274e724c68..436810042186a 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -3,7 +3,7 @@
 from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG, _period_code_map
 from pandas.errors import OutOfBoundsDatetime
 
-from pandas import Period, offsets
+from pandas import Period, Timestamp, offsets
 
 
 class TestFreqConversion:
@@ -656,6 +656,23 @@ def test_conv_secondly(self):
 
         assert ival_S.asfreq("S") == ival_S
 
+    def test_conv_microsecond(self):
+        # GH#31475 Avoid floating point errors dropping the start_time to
+        #  before the beginning of the Period
+        per = Period("2020-01-30 15:57:27.576166", freq="U")
+        assert per.ordinal == 1580399847576166
+
+        start = per.start_time
+        expected = Timestamp("2020-01-30 15:57:27.576166")
+        assert start == expected
+        assert start.value == per.ordinal * 1000
+
+        per2 = Period("2300-01-01", "us")
+        with pytest.raises(OutOfBoundsDatetime, match="2300-01-01"):
+            per2.start_time
+        with pytest.raises(OutOfBoundsDatetime, match="2300-01-01"):
+            per2.end_time
+
     def test_asfreq_mult(self):
         # normal freq to mult freq
         p = Period(freq="A", year=2007)
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index a1de205afc0e2..3846274dacd75 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -1,5 +1,7 @@
 from datetime import date, datetime, timedelta
+from distutils.version import StrictVersion
 
+import dateutil
 import numpy as np
 import pytest
 import pytz
@@ -10,13 +12,11 @@
 from pandas._libs.tslibs.parsing import DateParseError
 from pandas._libs.tslibs.period import IncompatibleFrequency
 from pandas._libs.tslibs.timezones import dateutil_gettz, maybe_get_tz
-from pandas.compat import PY35
 from pandas.compat.numpy import np_datetime64_compat
 
 import pandas as pd
 from pandas import NaT, Period, Timedelta, Timestamp, offsets
-import pandas.core.indexes.period as period
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestPeriodConstruction:
@@ -308,7 +308,7 @@ def test_multiples(self):
     @pytest.mark.parametrize("month", MONTHS)
     def test_period_cons_quarterly(self, month):
         # bugs in scikits.timeseries
-        freq = "Q-{month}".format(month=month)
+        freq = f"Q-{month}"
         exp = Period("1989Q3", freq=freq)
         assert "1989Q3" in str(exp)
         stamp = exp.to_timestamp("D", how="end")
@@ -322,7 +322,7 @@ def test_period_cons_quarterly(self, month):
     @pytest.mark.parametrize("month", MONTHS)
     def test_period_cons_annual(self, month):
         # bugs in scikits.timeseries
-        freq = "A-{month}".format(month=month)
+        freq = f"A-{month}"
         exp = Period("1989", freq=freq)
         stamp = exp.to_timestamp("D", how="end") + timedelta(days=30)
         p = Period(stamp, freq=freq)
@@ -333,8 +333,8 @@ def test_period_cons_annual(self, month):
     @pytest.mark.parametrize("day", DAYS)
     @pytest.mark.parametrize("num", range(10, 17))
     def test_period_cons_weekly(self, num, day):
-        daystr = "2011-02-{num}".format(num=num)
-        freq = "W-{day}".format(day=day)
+        daystr = f"2011-02-{num}"
+        freq = f"W-{day}"
 
         result = Period(daystr, freq=freq)
         expected = Period(daystr, freq="D").asfreq(freq)
@@ -650,7 +650,7 @@ def test_strftime(self):
 
 
 class TestPeriodProperties:
-    "Test properties such as year, month, weekday, etc...."
+    """Test properties such as year, month, weekday, etc...."""
 
     @pytest.mark.parametrize("freq", ["A", "M", "D", "H"])
     def test_is_leap_year(self, freq):
@@ -925,7 +925,7 @@ def test_properties_secondly(self):
 
 class TestPeriodField:
     def test_get_period_field_array_raises_on_out_of_range(self):
-        msg = "Buffer dtype mismatch, expected 'int64_t' but got 'double'"
+        msg = "Buffer dtype mismatch, expected 'const int64_t' but got 'double'"
         with pytest.raises(ValueError, match=msg):
             libperiod.get_period_field_arr(-1, np.empty(1), 0)
 
@@ -942,7 +942,7 @@ def test_equal(self):
         assert self.january1 == self.january2
 
     def test_equal_Raises_Value(self):
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             self.january1 == self.day
 
     def test_notEqual(self):
@@ -953,7 +953,7 @@ def test_greater(self):
         assert self.february > self.january1
 
     def test_greater_Raises_Value(self):
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             self.january1 > self.day
 
     def test_greater_Raises_Type(self):
@@ -964,7 +964,7 @@ def test_greaterEqual(self):
         assert self.january1 >= self.january2
 
     def test_greaterEqual_Raises_Value(self):
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             self.january1 >= self.day
 
         with pytest.raises(TypeError):
@@ -974,7 +974,7 @@ def test_smallerEqual(self):
         assert self.january1 <= self.january2
 
     def test_smallerEqual_Raises_Value(self):
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             self.january1 <= self.day
 
     def test_smallerEqual_Raises_Type(self):
@@ -985,7 +985,7 @@ def test_smaller(self):
         assert self.january1 < self.february
 
     def test_smaller_Raises_Value(self):
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             self.january1 < self.day
 
     def test_smaller_Raises_Type(self):
@@ -1026,7 +1026,7 @@ def test_sub_delta(self):
         result = left - right
         assert result == 4 * right.freq
 
-        with pytest.raises(period.IncompatibleFrequency):
+        with pytest.raises(IncompatibleFrequency):
             left - Period("2007-01", freq="M")
 
     def test_add_integer(self):
@@ -1044,6 +1044,7 @@ def test_add_sub_nat(self):
         assert NaT - p is NaT
 
         p = Period("NaT", freq="M")
+        assert p is NaT
         assert p + NaT is NaT
         assert NaT + p is NaT
         assert p - NaT is NaT
@@ -1097,16 +1098,16 @@ def test_sub(self):
         assert per2 - per1 == 14 * off
 
         msg = r"Input has different freq=M from Period\(freq=D\)"
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             per1 - Period("2011-02", freq="M")
 
     @pytest.mark.parametrize("n", [1, 2, 3, 4])
     def test_sub_n_gt_1_ticks(self, tick_classes, n):
         # GH 23878
-        p1 = pd.Period("19910905", freq=tick_classes(n))
-        p2 = pd.Period("19920406", freq=tick_classes(n))
+        p1 = Period("19910905", freq=tick_classes(n))
+        p2 = Period("19920406", freq=tick_classes(n))
 
-        expected = pd.Period(str(p2), freq=p2.freq.base) - pd.Period(
+        expected = Period(str(p2), freq=p2.freq.base) - Period(
             str(p1), freq=p1.freq.base
         )
 
@@ -1117,10 +1118,10 @@ def test_sub_n_gt_1_ticks(self, tick_classes, n):
     @pytest.mark.parametrize(
         "offset, kwd_name",
         [
-            (pd.offsets.YearEnd, "month"),
-            (pd.offsets.QuarterEnd, "startingMonth"),
-            (pd.offsets.MonthEnd, None),
-            (pd.offsets.Week, "weekday"),
+            (offsets.YearEnd, "month"),
+            (offsets.QuarterEnd, "startingMonth"),
+            (offsets.MonthEnd, None),
+            (offsets.Week, "weekday"),
         ],
     )
     def test_sub_n_gt_1_offsets(self, offset, kwd_name, n, normalize):
@@ -1128,12 +1129,10 @@ def test_sub_n_gt_1_offsets(self, offset, kwd_name, n, normalize):
         kwds = {kwd_name: 3} if kwd_name is not None else {}
         p1_d = "19910905"
         p2_d = "19920406"
-        p1 = pd.Period(p1_d, freq=offset(n, normalize, **kwds))
-        p2 = pd.Period(p2_d, freq=offset(n, normalize, **kwds))
+        p1 = Period(p1_d, freq=offset(n, normalize, **kwds))
+        p2 = Period(p2_d, freq=offset(n, normalize, **kwds))
 
-        expected = pd.Period(p2_d, freq=p2.freq.base) - pd.Period(
-            p1_d, freq=p1.freq.base
-        )
+        expected = Period(p2_d, freq=p2.freq.base) - Period(p1_d, freq=p1.freq.base)
 
         assert (p2 - p1) == expected
 
@@ -1152,14 +1151,14 @@ def test_add_offset(self):
                 np.timedelta64(365, "D"),
                 timedelta(365),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p + o
 
                 if isinstance(o, np.timedelta64):
                     with pytest.raises(TypeError):
                         o + p
                 else:
-                    with pytest.raises(period.IncompatibleFrequency):
+                    with pytest.raises(IncompatibleFrequency):
                         o + p
 
         for freq in ["M", "2M", "3M"]:
@@ -1179,14 +1178,14 @@ def test_add_offset(self):
                 np.timedelta64(365, "D"),
                 timedelta(365),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p + o
 
                 if isinstance(o, np.timedelta64):
                     with pytest.raises(TypeError):
                         o + p
                 else:
-                    with pytest.raises(period.IncompatibleFrequency):
+                    with pytest.raises(IncompatibleFrequency):
                         o + p
 
         # freq is Tick
@@ -1226,14 +1225,14 @@ def test_add_offset(self):
                 np.timedelta64(4, "h"),
                 timedelta(hours=23),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p + o
 
                 if isinstance(o, np.timedelta64):
                     with pytest.raises(TypeError):
                         o + p
                 else:
-                    with pytest.raises(period.IncompatibleFrequency):
+                    with pytest.raises(IncompatibleFrequency):
                         o + p
 
         for freq in ["H", "2H", "3H"]:
@@ -1272,20 +1271,21 @@ def test_add_offset(self):
                 np.timedelta64(3200, "s"),
                 timedelta(hours=23, minutes=30),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p + o
 
                 if isinstance(o, np.timedelta64):
                     with pytest.raises(TypeError):
                         o + p
                 else:
-                    with pytest.raises(period.IncompatibleFrequency):
+                    with pytest.raises(IncompatibleFrequency):
                         o + p
 
     def test_add_offset_nat(self):
         # freq is DateOffset
         for freq in ["A", "2A", "3A"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [offsets.YearEnd(2)]:
                 assert p + o is NaT
                 assert o + p is NaT
@@ -1302,6 +1302,7 @@ def test_add_offset_nat(self):
 
         for freq in ["M", "2M", "3M"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [offsets.MonthEnd(2), offsets.MonthEnd(12)]:
                 assert p + o is NaT
                 assert o + p is NaT
@@ -1319,6 +1320,7 @@ def test_add_offset_nat(self):
         # freq is Tick
         for freq in ["D", "2D", "3D"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [
                 offsets.Day(5),
                 offsets.Hour(24),
@@ -1342,6 +1344,7 @@ def test_add_offset_nat(self):
 
         for freq in ["H", "2H", "3H"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [
                 offsets.Day(2),
                 offsets.Hour(3),
@@ -1376,7 +1379,7 @@ def test_sub_offset(self):
                 np.timedelta64(365, "D"),
                 timedelta(365),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p - o
 
         for freq in ["M", "2M", "3M"]:
@@ -1391,7 +1394,7 @@ def test_sub_offset(self):
                 np.timedelta64(365, "D"),
                 timedelta(365),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p - o
 
         # freq is Tick
@@ -1411,7 +1414,7 @@ def test_sub_offset(self):
                 np.timedelta64(4, "h"),
                 timedelta(hours=23),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p - o
 
         for freq in ["H", "2H", "3H"]:
@@ -1434,13 +1437,14 @@ def test_sub_offset(self):
                 np.timedelta64(3200, "s"),
                 timedelta(hours=23, minutes=30),
             ]:
-                with pytest.raises(period.IncompatibleFrequency):
+                with pytest.raises(IncompatibleFrequency):
                     p - o
 
     def test_sub_offset_nat(self):
         # freq is DateOffset
         for freq in ["A", "2A", "3A"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [offsets.YearEnd(2)]:
                 assert p - o is NaT
 
@@ -1455,6 +1459,7 @@ def test_sub_offset_nat(self):
 
         for freq in ["M", "2M", "3M"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [offsets.MonthEnd(2), offsets.MonthEnd(12)]:
                 assert p - o is NaT
 
@@ -1470,6 +1475,7 @@ def test_sub_offset_nat(self):
         # freq is Tick
         for freq in ["D", "2D", "3D"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [
                 offsets.Day(5),
                 offsets.Hour(24),
@@ -1491,6 +1497,7 @@ def test_sub_offset_nat(self):
 
         for freq in ["H", "2H", "3H"]:
             p = Period("NaT", freq=freq)
+            assert p is NaT
             for o in [
                 offsets.Day(2),
                 offsets.Hour(3),
@@ -1513,6 +1520,7 @@ def test_sub_offset_nat(self):
     @pytest.mark.parametrize("freq", ["M", "2M", "3M"])
     def test_nat_ops(self, freq):
         p = Period("NaT", freq=freq)
+        assert p is NaT
         assert p + 1 is NaT
         assert 1 + p is NaT
         assert p - 1 is NaT
@@ -1530,10 +1538,10 @@ def test_period_ops_offset(self):
         assert result == exp
 
         msg = r"Input cannot be converted to Period\(freq=D\)"
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             p + offsets.Hour(2)
 
-        with pytest.raises(period.IncompatibleFrequency, match=msg):
+        with pytest.raises(IncompatibleFrequency, match=msg):
             p - offsets.Hour(2)
 
 
@@ -1549,13 +1557,29 @@ def test_period_immutable():
 
 
 @pytest.mark.xfail(
-    # xpassing on MacPython with strict=False
-    # https://travis-ci.org/MacPython/pandas-wheels/jobs/574706922
-    PY35,
-    reason="Parsing as Period('0007-01-01', 'D') for reasons unknown",
+    StrictVersion(dateutil.__version__.split(".dev")[0]) < StrictVersion("2.7.0"),
+    reason="Bug in dateutil < 2.7.0 when parsing old dates: Period('0001-01-07', 'D')",
     strict=False,
 )
 def test_small_year_parsing():
     per1 = Period("0001-01-07", "D")
     assert per1.year == 1
     assert per1.day == 7
+
+
+def test_negone_ordinals():
+    freqs = ["A", "M", "Q", "D", "H", "T", "S"]
+
+    period = Period(ordinal=-1, freq="D")
+    for freq in freqs:
+        repr(period.asfreq(freq))
+
+    for freq in freqs:
+        period = Period(ordinal=-1, freq=freq)
+        repr(period)
+        assert period.year == 1969
+
+    period = Period(ordinal=-1, freq="B")
+    repr(period)
+    period = Period(ordinal=-1, freq="W")
+    repr(period)
diff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py
new file mode 100644
index 0000000000000..dcb9d66708724
--- /dev/null
+++ b/pandas/tests/scalar/test_na_scalar.py
@@ -0,0 +1,269 @@
+import numpy as np
+import pytest
+
+from pandas._libs.missing import NA
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_singleton():
+    assert NA is NA
+    new_NA = type(NA)()
+    assert new_NA is NA
+
+
+def test_repr():
+    assert repr(NA) == "<NA>"
+    assert str(NA) == "<NA>"
+
+
+def test_truthiness():
+    with pytest.raises(TypeError):
+        bool(NA)
+
+    with pytest.raises(TypeError):
+        not NA
+
+
+def test_hashable():
+    assert hash(NA) == hash(NA)
+    d = {NA: "test"}
+    assert d[NA] == "test"
+
+
+def test_arithmetic_ops(all_arithmetic_functions):
+    op = all_arithmetic_functions
+
+    for other in [NA, 1, 1.0, "a", np.int64(1), np.nan]:
+        if op.__name__ in ("pow", "rpow", "rmod") and isinstance(other, str):
+            continue
+        if op.__name__ in ("divmod", "rdivmod"):
+            assert op(NA, other) is (NA, NA)
+        else:
+            if op.__name__ == "rpow":
+                # avoid special case
+                other += 1
+            assert op(NA, other) is NA
+
+
+def test_comparison_ops():
+
+    for other in [NA, 1, 1.0, "a", np.int64(1), np.nan, np.bool_(True)]:
+        assert (NA == other) is NA
+        assert (NA != other) is NA
+        assert (NA > other) is NA
+        assert (NA >= other) is NA
+        assert (NA < other) is NA
+        assert (NA <= other) is NA
+        assert (other == NA) is NA
+        assert (other != NA) is NA
+        assert (other > NA) is NA
+        assert (other >= NA) is NA
+        assert (other < NA) is NA
+        assert (other <= NA) is NA
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        0,
+        0.0,
+        -0,
+        -0.0,
+        False,
+        np.bool_(False),
+        np.int_(0),
+        np.float_(0),
+        np.int_(-0),
+        np.float_(-0),
+    ],
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_pow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = pd.NA ** value
+
+    if asarray:
+        result = result[0]
+    else:
+        # this assertion isn't possible for ndarray.
+        assert isinstance(result, type(value))
+    assert result == 1
+
+
+@pytest.mark.parametrize(
+    "value", [1, 1.0, True, np.bool_(True), np.int_(1), np.float_(1)],
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value ** pd.NA
+
+    if asarray:
+        result = result[0]
+    elif not isinstance(value, (np.float_, np.bool_, np.int_)):
+        # this assertion isn't possible with asarray=True
+        assert isinstance(result, type(value))
+
+    assert result == value
+
+
+@pytest.mark.parametrize(
+    "value", [-1, -1.0, np.int_(-1), np.float_(-1)],
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_minus_one(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value ** pd.NA
+
+    if asarray:
+        result = result[0]
+
+    assert pd.isna(result)
+
+
+def test_unary_ops():
+    assert +NA is NA
+    assert -NA is NA
+    assert abs(NA) is NA
+    assert ~NA is NA
+
+
+def test_logical_and():
+
+    assert NA & True is NA
+    assert True & NA is NA
+    assert NA & False is False
+    assert False & NA is False
+    assert NA & NA is NA
+
+    with pytest.raises(TypeError):
+        NA & 5
+
+
+def test_logical_or():
+
+    assert NA | True is True
+    assert True | NA is True
+    assert NA | False is NA
+    assert False | NA is NA
+    assert NA | NA is NA
+
+    with pytest.raises(TypeError):
+        NA | 5
+
+
+def test_logical_xor():
+
+    assert NA ^ True is NA
+    assert True ^ NA is NA
+    assert NA ^ False is NA
+    assert False ^ NA is NA
+    assert NA ^ NA is NA
+
+    with pytest.raises(TypeError):
+        NA ^ 5
+
+
+def test_logical_not():
+    assert ~NA is NA
+
+
+@pytest.mark.parametrize(
+    "shape", [(3,), (3, 3), (1, 2, 3)],
+)
+def test_arithmetic_ndarray(shape, all_arithmetic_functions):
+    op = all_arithmetic_functions
+    a = np.zeros(shape)
+    if op.__name__ == "pow":
+        a += 5
+    result = op(pd.NA, a)
+    expected = np.full(a.shape, pd.NA, dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_is_scalar():
+    assert is_scalar(NA) is True
+
+
+def test_isna():
+    assert pd.isna(NA) is True
+    assert pd.notna(NA) is False
+
+
+def test_series_isna():
+    s = pd.Series([1, NA], dtype=object)
+    expected = pd.Series([False, True])
+    tm.assert_series_equal(s.isna(), expected)
+
+
+def test_ufunc():
+    assert np.log(pd.NA) is pd.NA
+    assert np.add(pd.NA, 1) is pd.NA
+    result = np.divmod(pd.NA, 1)
+    assert result[0] is pd.NA and result[1] is pd.NA
+
+    result = np.frexp(pd.NA)
+    assert result[0] is pd.NA and result[1] is pd.NA
+
+
+def test_ufunc_raises():
+    with pytest.raises(ValueError, match="ufunc method 'at'"):
+        np.log.at(pd.NA, 0)
+
+
+def test_binary_input_not_dunder():
+    a = np.array([1, 2, 3])
+    expected = np.array([pd.NA, pd.NA, pd.NA], dtype=object)
+    result = np.logaddexp(a, pd.NA)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.logaddexp(pd.NA, a)
+    tm.assert_numpy_array_equal(result, expected)
+
+    # all NA, multiple inputs
+    assert np.logaddexp(pd.NA, pd.NA) is pd.NA
+
+    result = np.modf(pd.NA, pd.NA)
+    assert len(result) == 2
+    assert all(x is pd.NA for x in result)
+
+
+def test_divmod_ufunc():
+    # binary in, binary out.
+    a = np.array([1, 2, 3])
+    expected = np.array([pd.NA, pd.NA, pd.NA], dtype=object)
+
+    result = np.divmod(a, pd.NA)
+    assert isinstance(result, tuple)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+    result = np.divmod(pd.NA, a)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+
+def test_integer_hash_collision_dict():
+    # GH 30013
+    result = {NA: "foo", hash(NA): "bar"}
+
+    assert result[NA] == "foo"
+    assert result[hash(NA)] == "bar"
+
+
+def test_integer_hash_collision_set():
+    # GH 30013
+    result = {NA, hash(NA)}
+
+    assert len(result) == 2
+    assert NA in result
+    assert hash(NA) in result
diff --git a/pandas/tests/scalar/test_nat.py b/pandas/tests/scalar/test_nat.py
index 5eb69fb2952dc..a537f000959e3 100644
--- a/pandas/tests/scalar/test_nat.py
+++ b/pandas/tests/scalar/test_nat.py
@@ -21,9 +21,9 @@
     Timestamp,
     isna,
 )
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
 from pandas.core.ops import roperator
-from pandas.util import testing as tm
 
 
 @pytest.mark.parametrize(
@@ -123,6 +123,13 @@ def test_round_nat(klass, method, freq):
         "dst",
         "fromordinal",
         "fromtimestamp",
+        pytest.param(
+            "fromisocalendar",
+            marks=pytest.mark.skipif(
+                not compat.PY38,
+                reason="'fromisocalendar' was added in stdlib datetime in python 3.8",
+            ),
+        ),
         "isocalendar",
         "strftime",
         "strptime",
@@ -141,7 +148,7 @@ def test_round_nat(klass, method, freq):
 )
 def test_nat_methods_raise(method):
     # see gh-9513, gh-17329
-    msg = "NaTType does not support {method}".format(method=method)
+    msg = f"NaTType does not support {method}"
 
     with pytest.raises(ValueError, match=msg):
         getattr(NaT, method)()
@@ -297,6 +304,8 @@ def test_overlap_public_nat_methods(klass, expected):
     # "fromisoformat" was introduced in 3.7
     if klass is Timestamp and not compat.PY37:
         expected.remove("fromisoformat")
+
+    # "fromisocalendar" was introduced in 3.8
     if klass is Timestamp and not compat.PY38:
         expected.remove("fromisocalendar")
 
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 52f32d41a02ff..5fc991df49424 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -8,9 +8,9 @@
 import pytest
 
 import pandas as pd
-from pandas import NaT, Timedelta, Timestamp
+from pandas import NaT, Timedelta, Timestamp, offsets
+import pandas._testing as tm
 from pandas.core import ops
-import pandas.util.testing as tm
 
 
 class TestTimedeltaAdditionSubtraction:
@@ -28,7 +28,7 @@ class TestTimedeltaAdditionSubtraction:
             timedelta(seconds=10),
             np.timedelta64(10, "s"),
             np.timedelta64(10000000000, "ns"),
-            pd.offsets.Second(10),
+            offsets.Second(10),
         ],
     )
     def test_td_add_sub_ten_seconds(self, ten_seconds):
@@ -50,7 +50,7 @@ def test_td_add_sub_ten_seconds(self, ten_seconds):
             Timedelta("1 days, 00:00:10"),
             timedelta(days=1, seconds=10),
             np.timedelta64(1, "D") + np.timedelta64(10, "s"),
-            pd.offsets.Day() + pd.offsets.Second(10),
+            offsets.Day() + offsets.Second(10),
         ],
     )
     def test_td_add_sub_one_day_ten_seconds(self, one_day_ten_secs):
@@ -114,7 +114,7 @@ def test_td_add_timedelta64(self, op):
     def test_td_add_offset(self, op):
         td = Timedelta(10, unit="d")
 
-        result = op(td, pd.offsets.Hour(6))
+        result = op(td, offsets.Hour(6))
         assert isinstance(result, Timedelta)
         assert result == Timedelta(days=10, hours=6)
 
@@ -167,7 +167,7 @@ def test_td_sub_td64_nat(self):
 
     def test_td_sub_offset(self):
         td = Timedelta(10, unit="d")
-        result = td - pd.offsets.Hour(1)
+        result = td - offsets.Hour(1)
         assert isinstance(result, Timedelta)
         assert result == Timedelta(239, unit="h")
 
@@ -192,7 +192,7 @@ def test_td_rsub_nat(self):
         assert result is NaT
 
     def test_td_rsub_offset(self):
-        result = pd.offsets.Hour(1) - Timedelta(10, unit="d")
+        result = offsets.Hour(1) - Timedelta(10, unit="d")
         assert isinstance(result, Timedelta)
         assert result == Timedelta(-239, unit="h")
 
@@ -241,6 +241,57 @@ def test_td_add_mixed_timedeltalike_object_dtype_array(self, op):
         res = op(arr, Timedelta("1D"))
         tm.assert_numpy_array_equal(res, exp)
 
+    # TODO: moved from index tests following #24365, may need de-duplication
+    def test_ops_ndarray(self):
+        td = Timedelta("1 day")
+
+        # timedelta, timedelta
+        other = pd.to_timedelta(["1 day"]).values
+        expected = pd.to_timedelta(["2 days"]).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td + np.array([1])
+        msg = r"unsupported operand type\(s\) for \+: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.array([1]) + td
+
+        expected = pd.to_timedelta(["0 days"]).values
+        tm.assert_numpy_array_equal(td - other, expected)
+        tm.assert_numpy_array_equal(-other + td, expected)
+        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td - np.array([1])
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.array([1]) - td
+
+        expected = pd.to_timedelta(["2 days"]).values
+        tm.assert_numpy_array_equal(td * np.array([2]), expected)
+        tm.assert_numpy_array_equal(np.array([2]) * td, expected)
+        msg = (
+            "ufunc '?multiply'? cannot use operands with types "
+            r"dtype\('<m8\[ns\]'\) and dtype\('<m8\[ns\]'\)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            td * other
+        with pytest.raises(TypeError, match=msg):
+            other * td
+
+        tm.assert_numpy_array_equal(td / other, np.array([1], dtype=np.float64))
+        tm.assert_numpy_array_equal(other / td, np.array([1], dtype=np.float64))
+
+        # timedelta, datetime
+        other = pd.to_datetime(["2000-01-01"]).values
+        expected = pd.to_datetime(["2000-01-02"]).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+
+        expected = pd.to_datetime(["1999-12-31"]).values
+        tm.assert_numpy_array_equal(-td + other, expected)
+        tm.assert_numpy_array_equal(other - td, expected)
+
 
 class TestTimedeltaMultiplicationDivision:
     """
@@ -306,7 +357,7 @@ def test_td_div_timedeltalike_scalar(self):
         # GH#19738
         td = Timedelta(10, unit="d")
 
-        result = td / pd.offsets.Hour(1)
+        result = td / offsets.Hour(1)
         assert result == 240
 
         assert td / td == 1
@@ -342,7 +393,7 @@ def test_td_div_nan(self, nan):
     def test_td_rdiv_timedeltalike_scalar(self):
         # GH#19738
         td = Timedelta(10, unit="d")
-        result = pd.offsets.Hour(1) / td
+        result = offsets.Hour(1) / td
         assert result == 1 / 240.0
 
         assert np.timedelta64(60, "h") / td == 0.25
@@ -370,8 +421,8 @@ def test_td_floordiv_null_scalar(self):
     def test_td_floordiv_offsets(self):
         # GH#19738
         td = Timedelta(hours=3, minutes=4)
-        assert td // pd.offsets.Hour(1) == 3
-        assert td // pd.offsets.Minute(2) == 92
+        assert td // offsets.Hour(1) == 3
+        assert td // offsets.Minute(2) == 92
 
     def test_td_floordiv_invalid_scalar(self):
         # GH#18846
@@ -441,13 +492,13 @@ def test_td_rfloordiv_null_scalar(self):
 
     def test_td_rfloordiv_offsets(self):
         # GH#19738
-        assert pd.offsets.Hour(1) // Timedelta(minutes=25) == 2
+        assert offsets.Hour(1) // Timedelta(minutes=25) == 2
 
     def test_td_rfloordiv_invalid_scalar(self):
         # GH#18846
         td = Timedelta(hours=3, minutes=3)
 
-        dt64 = np.datetime64("2016-01-01", dtype="datetime64[us]")
+        dt64 = np.datetime64("2016-01-01", "us")
         with pytest.raises(TypeError):
             td.__rfloordiv__(dt64)
 
@@ -463,8 +514,8 @@ def test_td_rfloordiv_numeric_scalar(self):
             td.__rfloordiv__(np.float64(2.0))
         with pytest.raises(TypeError):
             td.__rfloordiv__(np.uint8(9))
-        with tm.assert_produces_warning(FutureWarning):
-            # GH-19761: Change to TypeError.
+        with pytest.raises(TypeError, match="Invalid dtype"):
+            # deprecated GH#19761, enforced GH#29797
             td.__rfloordiv__(np.int32(2.0))
 
     def test_td_rfloordiv_timedeltalike_array(self):
@@ -490,7 +541,9 @@ def test_td_rfloordiv_numeric_series(self):
         ser = pd.Series([1], dtype=np.int64)
         res = td.__rfloordiv__(ser)
         assert res is NotImplemented
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+
+        with pytest.raises(TypeError, match="Invalid dtype"):
+            # Deprecated GH#19761, enforced GH#29797
             # TODO: GH-19761. Change to TypeError.
             ser // td
 
@@ -532,7 +585,7 @@ def test_mod_offset(self):
         # GH#19365
         td = Timedelta(hours=37)
 
-        result = td % pd.offsets.Hour(5)
+        result = td % offsets.Hour(5)
         assert isinstance(result, Timedelta)
         assert result == Timedelta(hours=2)
 
@@ -633,7 +686,7 @@ def test_divmod_offset(self):
         # GH#19365
         td = Timedelta(days=2, hours=6)
 
-        result = divmod(td, pd.offsets.Hour(-4))
+        result = divmod(td, offsets.Hour(-4))
         assert result[0] == -14
         assert isinstance(result[1], Timedelta)
         assert result[1] == Timedelta(hours=-2)
@@ -653,7 +706,7 @@ def test_rdivmod_pytimedelta(self):
         assert result[1] == Timedelta(hours=6)
 
     def test_rdivmod_offset(self):
-        result = divmod(pd.offsets.Hour(54), Timedelta(hours=-4))
+        result = divmod(offsets.Hour(54), Timedelta(hours=-4))
         assert result[0] == -14
         assert isinstance(result[1], Timedelta)
         assert result[1] == Timedelta(hours=-2)
diff --git a/pandas/tests/scalar/timedelta/test_construction.py b/pandas/tests/scalar/timedelta/test_constructors.py
similarity index 98%
rename from pandas/tests/scalar/timedelta/test_construction.py
rename to pandas/tests/scalar/timedelta/test_constructors.py
index ae1e84576c092..25c9fc19981be 100644
--- a/pandas/tests/scalar/timedelta/test_construction.py
+++ b/pandas/tests/scalar/timedelta/test_constructors.py
@@ -274,3 +274,10 @@ def test_td_constructor_on_nanoseconds(constructed_td, conversion):
 def test_td_constructor_value_error():
     with pytest.raises(TypeError):
         Timedelta(nanoseconds="abc")
+
+
+def test_timedelta_constructor_identity():
+    # Test for #30543
+    expected = Timedelta(np.timedelta64(1, "s"))
+    result = Timedelta(expected)
+    assert result is expected
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index e4980be49d35f..9cdbeb6ab4845 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -1,37 +1,30 @@
 """ test the scalar Timedelta """
 from datetime import timedelta
-import re
 
 import numpy as np
 import pytest
 
-from pandas._libs.tslibs import NaT, iNaT
+from pandas._libs.tslibs import NaT, Timestamp, iNaT
 
 import pandas as pd
 from pandas import Series, Timedelta, TimedeltaIndex, timedelta_range, to_timedelta
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestTimedeltaArithmetic:
     def test_arithmetic_overflow(self):
         with pytest.raises(OverflowError):
-            pd.Timestamp("1700-01-01") + pd.Timedelta(13 * 19999, unit="D")
+            Timestamp("1700-01-01") + Timedelta(13 * 19999, unit="D")
 
         with pytest.raises(OverflowError):
-            pd.Timestamp("1700-01-01") + timedelta(days=13 * 19999)
+            Timestamp("1700-01-01") + timedelta(days=13 * 19999)
 
     def test_array_timedelta_floordiv(self):
-        # https://github.com/pandas-dev/pandas/issues/19761
+        # deprecated GH#19761, enforced GH#29797
         ints = pd.date_range("2012-10-08", periods=4, freq="D").view("i8")
-        msg = r"Use 'array // timedelta.value'"
-        with tm.assert_produces_warning(FutureWarning) as m:
-            result = ints // pd.Timedelta(1, unit="s")
 
-        assert msg in str(m[0].message)
-        expected = np.array(
-            [1349654400, 1349740800, 1349827200, 1349913600], dtype="i8"
-        )
-        tm.assert_numpy_array_equal(result, expected)
+        with pytest.raises(TypeError, match="Invalid dtype"):
+            ints // Timedelta(1, unit="s")
 
     def test_ops_error_str(self):
         # GH 13624
@@ -283,7 +276,7 @@ def check(value):
             rng.milliseconds
 
         # components
-        tup = pd.to_timedelta(-1, "us").components
+        tup = to_timedelta(-1, "us").components
         assert tup.days == -1
         assert tup.hours == 23
         assert tup.minutes == 59
@@ -324,12 +317,9 @@ def test_nat_converters(self):
         assert result.dtype.kind == "M"
         assert result.astype("int64") == iNaT
 
-    @pytest.mark.filterwarnings("ignore:M and Y units are deprecated")
     @pytest.mark.parametrize(
         "units, np_unit",
         [
-            (["Y", "y"], "Y"),
-            (["M"], "M"),
             (["W", "w"], "W"),
             (["D", "d", "days", "day", "Days", "Day"], "D"),
             (
@@ -409,7 +399,7 @@ def test_unit_parser(self, units, np_unit, wrapper):
                     [np.timedelta64(i, "m") for i in np.arange(5).tolist()]
                 )
 
-            str_repr = ["{}{}".format(x, unit) for x in np.arange(5)]
+            str_repr = [f"{x}{unit}" for x in np.arange(5)]
             result = to_timedelta(wrapper(str_repr))
             tm.assert_index_equal(result, expected)
             result = TimedeltaIndex(wrapper(str_repr))
@@ -426,25 +416,22 @@ def test_unit_parser(self, units, np_unit, wrapper):
             if unit == "M":
                 expected = Timedelta(np.timedelta64(2, "m").astype("timedelta64[ns]"))
 
-            result = to_timedelta("2{}".format(unit))
+            result = to_timedelta(f"2{unit}")
             assert result == expected
-            result = Timedelta("2{}".format(unit))
+            result = Timedelta(f"2{unit}")
             assert result == expected
 
     @pytest.mark.parametrize("unit", ["Y", "y", "M"])
-    def test_unit_m_y_deprecated(self, unit):
-        with tm.assert_produces_warning(FutureWarning) as w1:
+    def test_unit_m_y_raises(self, unit):
+        msg = "Units 'M' and 'Y' are no longer supported"
+        with pytest.raises(ValueError, match=msg):
             Timedelta(10, unit)
-        msg = r".* units are deprecated .*"
-        assert re.match(msg, str(w1[0].message))
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w2:
+
+        with pytest.raises(ValueError, match=msg):
             to_timedelta(10, unit)
-        msg = r".* units are deprecated .*"
-        assert re.match(msg, str(w2[0].message))
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False) as w3:
+
+        with pytest.raises(ValueError, match=msg):
             to_timedelta([1, 2], unit)
-        msg = r".* units are deprecated .*"
-        assert re.match(msg, str(w3[0].message))
 
     def test_numeric_conversions(self):
         assert Timedelta(0) == np.timedelta64(0, "ns")
@@ -512,7 +499,7 @@ def test_round(self):
         t1 = timedelta_range("1 days", periods=3, freq="1 min 2 s 3 us")
         t2 = -1 * t1
         t1a = timedelta_range("1 days", periods=3, freq="1 min 2 s")
-        t1c = pd.TimedeltaIndex([1, 1, 1], unit="D")
+        t1c = TimedeltaIndex([1, 1, 1], unit="D")
 
         # note that negative times round DOWN! so don't give whole numbers
         for (freq, s1, s2) in [
@@ -554,7 +541,7 @@ def test_round(self):
                     freq=None,
                 ),
             ),
-            ("d", t1c, pd.TimedeltaIndex([-1, -1, -1], unit="D")),
+            ("d", t1c, TimedeltaIndex([-1, -1, -1], unit="D")),
         ]:
 
             r1 = t1.round(freq)
@@ -575,11 +562,11 @@ def test_contains(self):
         # Checking for any NaT-like objects
         # GH 13603
         td = to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
-        for v in [pd.NaT, None, float("nan"), np.nan]:
+        for v in [NaT, None, float("nan"), np.nan]:
             assert not (v in td)
 
-        td = to_timedelta([pd.NaT])
-        for v in [pd.NaT, None, float("nan"), np.nan]:
+        td = to_timedelta([NaT])
+        for v in [NaT, None, float("nan"), np.nan]:
             assert v in td
 
     def test_identity(self):
@@ -668,11 +655,11 @@ def conv(v):
     def test_overflow(self):
         # GH 9442
         s = Series(pd.date_range("20130101", periods=100000, freq="H"))
-        s[0] += pd.Timedelta("1s 1ms")
+        s[0] += Timedelta("1s 1ms")
 
         # mean
         result = (s - s.min()).mean()
-        expected = pd.Timedelta((pd.TimedeltaIndex((s - s.min())).asi8 / len(s)).sum())
+        expected = Timedelta((TimedeltaIndex((s - s.min())).asi8 / len(s)).sum())
 
         # the computation is converted to float so
         # might be some loss of precision
@@ -748,41 +735,41 @@ def test_total_seconds_precision(self):
         assert (30.0 - Timedelta("30S").total_seconds()) < 1e-20
 
     def test_timedelta_arithmetic(self):
-        data = pd.Series(["nat", "32 days"], dtype="timedelta64[ns]")
+        data = Series(["nat", "32 days"], dtype="timedelta64[ns]")
         deltas = [timedelta(days=1), Timedelta(1, unit="D")]
         for delta in deltas:
             result_method = data.add(delta)
             result_operator = data + delta
-            expected = pd.Series(["nat", "33 days"], dtype="timedelta64[ns]")
+            expected = Series(["nat", "33 days"], dtype="timedelta64[ns]")
             tm.assert_series_equal(result_operator, expected)
             tm.assert_series_equal(result_method, expected)
 
             result_method = data.sub(delta)
             result_operator = data - delta
-            expected = pd.Series(["nat", "31 days"], dtype="timedelta64[ns]")
+            expected = Series(["nat", "31 days"], dtype="timedelta64[ns]")
             tm.assert_series_equal(result_operator, expected)
             tm.assert_series_equal(result_method, expected)
             # GH 9396
             result_method = data.div(delta)
             result_operator = data / delta
-            expected = pd.Series([np.nan, 32.0], dtype="float64")
+            expected = Series([np.nan, 32.0], dtype="float64")
             tm.assert_series_equal(result_operator, expected)
             tm.assert_series_equal(result_method, expected)
 
     def test_apply_to_timedelta(self):
-        timedelta_NaT = pd.to_timedelta("NaT")
+        timedelta_NaT = to_timedelta("NaT")
 
         list_of_valid_strings = ["00:00:01", "00:00:02"]
-        a = pd.to_timedelta(list_of_valid_strings)
-        b = Series(list_of_valid_strings).apply(pd.to_timedelta)
+        a = to_timedelta(list_of_valid_strings)
+        b = Series(list_of_valid_strings).apply(to_timedelta)
         # Can't compare until apply on a Series gives the correct dtype
         # assert_series_equal(a, b)
 
-        list_of_strings = ["00:00:01", np.nan, pd.NaT, timedelta_NaT]
+        list_of_strings = ["00:00:01", np.nan, NaT, timedelta_NaT]
 
         # TODO: unused?
-        a = pd.to_timedelta(list_of_strings)  # noqa
-        b = Series(list_of_strings).apply(pd.to_timedelta)  # noqa
+        a = to_timedelta(list_of_strings)  # noqa
+        b = Series(list_of_strings).apply(to_timedelta)  # noqa
         # Can't compare until apply on a Series gives the correct dtype
         # assert_series_equal(a, b)
 
@@ -810,9 +797,13 @@ def test_resolution_string(self):
     def test_resolution_deprecated(self):
         # GH#21344
         td = Timedelta(days=4, hours=3)
-        with tm.assert_produces_warning(FutureWarning) as w:
-            td.resolution
-        assert "Use Timedelta.resolution_string instead" in str(w[0].message)
+        result = td.resolution
+        assert result == Timedelta(nanoseconds=1)
+
+        # Check that the attribute is available on the class, mirroring
+        #  the stdlib timedelta behavior
+        result = Timedelta.resolution
+        assert result == Timedelta(nanoseconds=1)
 
 
 @pytest.mark.parametrize(
@@ -824,9 +815,22 @@ def test_resolution_deprecated(self):
         (Timedelta(0, unit="ns"), False),
         (Timedelta(-10, unit="ns"), True),
         (Timedelta(None), True),
-        (pd.NaT, True),
+        (NaT, True),
     ],
 )
 def test_truthiness(value, expected):
     # https://github.com/pandas-dev/pandas/issues/21484
     assert bool(value) is expected
+
+
+def test_timedelta_attribute_precision():
+    # GH 31354
+    td = Timedelta(1552211999999999872, unit="ns")
+    result = td.days * 86400
+    result += td.seconds
+    result *= 1000000
+    result += td.microseconds
+    result *= 1000
+    result += td.nanoseconds
+    expected = td.value
+    assert result == expected
diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py
index 9634c6d822236..1cab007c20a0e 100644
--- a/pandas/tests/scalar/timestamp/test_arithmetic.py
+++ b/pandas/tests/scalar/timestamp/test_arithmetic.py
@@ -3,10 +3,7 @@
 import numpy as np
 import pytest
 
-from pandas.errors import NullFrequencyError
-
 from pandas import Timedelta, Timestamp
-import pandas.util.testing as tm
 
 from pandas.tseries import offsets
 from pandas.tseries.frequencies import to_offset
@@ -97,10 +94,12 @@ def test_addition_subtraction_types(self):
         # addition/subtraction of integers
         ts = Timestamp(dt, freq="D")
 
-        with tm.assert_produces_warning(FutureWarning):
+        msg = "Addition/subtraction of integers"
+        with pytest.raises(TypeError, match=msg):
             # GH#22535 add/sub with integers is deprecated
-            assert type(ts + 1) == Timestamp
-            assert type(ts - 1) == Timestamp
+            ts + 1
+        with pytest.raises(TypeError, match=msg):
+            ts - 1
 
         # Timestamp + datetime not supported, though subtraction is supported
         # and yields timedelta more tests in tseries/base/tests/test_base.py
@@ -129,11 +128,6 @@ def test_addition_subtraction_preserve_frequency(self, freq, td, td64):
         ts = Timestamp("2014-03-05 00:00:00", freq=freq)
         original_freq = ts.freq
 
-        with tm.assert_produces_warning(FutureWarning):
-            # GH#22535 add/sub with integers is deprecated
-            assert (ts + 1).freq == original_freq
-            assert (ts - 1).freq == original_freq
-
         assert (ts + 1 * original_freq).freq == original_freq
         assert (ts - 1 * original_freq).freq == original_freq
 
@@ -179,12 +173,13 @@ def test_timestamp_add_timedelta64_unit(self, other, expected_difference):
         ],
     )
     def test_add_int_no_freq_raises(self, ts, other):
-        with pytest.raises(NullFrequencyError, match="without freq"):
+        msg = "Addition/subtraction of integers and integer-arrays"
+        with pytest.raises(TypeError, match=msg):
             ts + other
-        with pytest.raises(NullFrequencyError, match="without freq"):
+        with pytest.raises(TypeError, match=msg):
             other + ts
 
-        with pytest.raises(NullFrequencyError, match="without freq"):
+        with pytest.raises(TypeError, match=msg):
             ts - other
         with pytest.raises(TypeError):
             other - ts
@@ -206,17 +201,14 @@ def test_add_int_no_freq_raises(self, ts, other):
         ],
     )
     def test_add_int_with_freq(self, ts, other):
-        with tm.assert_produces_warning(FutureWarning):
-            result1 = ts + other
-        with tm.assert_produces_warning(FutureWarning):
-            result2 = other + ts
 
-        assert np.all(result1 == result2)
-
-        with tm.assert_produces_warning(FutureWarning):
-            result = result1 - other
+        with pytest.raises(TypeError):
+            ts + other
+        with pytest.raises(TypeError):
+            other + ts
 
-        assert np.all(result == ts)
+        with pytest.raises(TypeError):
+            ts - other
 
         with pytest.raises(TypeError):
             other - ts
diff --git a/pandas/tests/scalar/timestamp/test_comparisons.py b/pandas/tests/scalar/timestamp/test_comparisons.py
index 4ff0f84327854..fce4fa6eb1eaa 100644
--- a/pandas/tests/scalar/timestamp/test_comparisons.py
+++ b/pandas/tests/scalar/timestamp/test_comparisons.py
@@ -179,8 +179,8 @@ def __gt__(self, o):
         def __ge__(self, o):
             return True
 
-        def __eq__(self, o):
-            return isinstance(o, Inf)
+        def __eq__(self, other) -> bool:
+            return isinstance(other, Inf)
 
     inf = Inf()
     timestamp = Timestamp("2018-11-30")
diff --git a/pandas/tests/scalar/timestamp/test_constructors.py b/pandas/tests/scalar/timestamp/test_constructors.py
new file mode 100644
index 0000000000000..737a85faa4c9b
--- /dev/null
+++ b/pandas/tests/scalar/timestamp/test_constructors.py
@@ -0,0 +1,552 @@
+import calendar
+from datetime import datetime, timedelta
+
+import dateutil.tz
+from dateutil.tz import tzutc
+import numpy as np
+import pytest
+import pytz
+
+from pandas.errors import OutOfBoundsDatetime
+
+from pandas import Period, Timedelta, Timestamp, compat
+
+from pandas.tseries import offsets
+
+
+class TestTimestampConstructors:
+    def test_constructor(self):
+        base_str = "2014-07-01 09:00"
+        base_dt = datetime(2014, 7, 1, 9)
+        base_expected = 1_404_205_200_000_000_000
+
+        # confirm base representation is correct
+        assert calendar.timegm(base_dt.timetuple()) * 1_000_000_000 == base_expected
+
+        tests = [
+            (base_str, base_dt, base_expected),
+            (
+                "2014-07-01 10:00",
+                datetime(2014, 7, 1, 10),
+                base_expected + 3600 * 1_000_000_000,
+            ),
+            (
+                "2014-07-01 09:00:00.000008000",
+                datetime(2014, 7, 1, 9, 0, 0, 8),
+                base_expected + 8000,
+            ),
+            (
+                "2014-07-01 09:00:00.000000005",
+                Timestamp("2014-07-01 09:00:00.000000005"),
+                base_expected + 5,
+            ),
+        ]
+
+        timezones = [
+            (None, 0),
+            ("UTC", 0),
+            (pytz.utc, 0),
+            ("Asia/Tokyo", 9),
+            ("US/Eastern", -4),
+            ("dateutil/US/Pacific", -7),
+            (pytz.FixedOffset(-180), -3),
+            (dateutil.tz.tzoffset(None, 18000), 5),
+        ]
+
+        for date_str, date, expected in tests:
+            for result in [Timestamp(date_str), Timestamp(date)]:
+                # only with timestring
+                assert result.value == expected
+
+                # re-creation shouldn't affect to internal value
+                result = Timestamp(result)
+                assert result.value == expected
+
+            # with timezone
+            for tz, offset in timezones:
+                for result in [Timestamp(date_str, tz=tz), Timestamp(date, tz=tz)]:
+                    expected_tz = expected - offset * 3600 * 1_000_000_000
+                    assert result.value == expected_tz
+
+                    # should preserve tz
+                    result = Timestamp(result)
+                    assert result.value == expected_tz
+
+                    # should convert to UTC
+                    if tz is not None:
+                        result = Timestamp(result).tz_convert("UTC")
+                    else:
+                        result = Timestamp(result, tz="UTC")
+                    expected_utc = expected - offset * 3600 * 1_000_000_000
+                    assert result.value == expected_utc
+
+    def test_constructor_with_stringoffset(self):
+        # GH 7833
+        base_str = "2014-07-01 11:00:00+02:00"
+        base_dt = datetime(2014, 7, 1, 9)
+        base_expected = 1_404_205_200_000_000_000
+
+        # confirm base representation is correct
+        assert calendar.timegm(base_dt.timetuple()) * 1_000_000_000 == base_expected
+
+        tests = [
+            (base_str, base_expected),
+            ("2014-07-01 12:00:00+02:00", base_expected + 3600 * 1_000_000_000),
+            ("2014-07-01 11:00:00.000008000+02:00", base_expected + 8000),
+            ("2014-07-01 11:00:00.000000005+02:00", base_expected + 5),
+        ]
+
+        timezones = [
+            (None, 0),
+            ("UTC", 0),
+            (pytz.utc, 0),
+            ("Asia/Tokyo", 9),
+            ("US/Eastern", -4),
+            ("dateutil/US/Pacific", -7),
+            (pytz.FixedOffset(-180), -3),
+            (dateutil.tz.tzoffset(None, 18000), 5),
+        ]
+
+        for date_str, expected in tests:
+            for result in [Timestamp(date_str)]:
+                # only with timestring
+                assert result.value == expected
+
+                # re-creation shouldn't affect to internal value
+                result = Timestamp(result)
+                assert result.value == expected
+
+            # with timezone
+            for tz, offset in timezones:
+                result = Timestamp(date_str, tz=tz)
+                expected_tz = expected
+                assert result.value == expected_tz
+
+                # should preserve tz
+                result = Timestamp(result)
+                assert result.value == expected_tz
+
+                # should convert to UTC
+                result = Timestamp(result).tz_convert("UTC")
+                expected_utc = expected
+                assert result.value == expected_utc
+
+        # This should be 2013-11-01 05:00 in UTC
+        # converted to Chicago tz
+        result = Timestamp("2013-11-01 00:00:00-0500", tz="America/Chicago")
+        assert result.value == Timestamp("2013-11-01 05:00").value
+        expected = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')"  # noqa
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # This should be 2013-11-01 05:00 in UTC
+        # converted to Tokyo tz (+09:00)
+        result = Timestamp("2013-11-01 00:00:00-0500", tz="Asia/Tokyo")
+        assert result.value == Timestamp("2013-11-01 05:00").value
+        expected = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # GH11708
+        # This should be 2015-11-18 10:00 in UTC
+        # converted to Asia/Katmandu
+        result = Timestamp("2015-11-18 15:45:00+05:45", tz="Asia/Katmandu")
+        assert result.value == Timestamp("2015-11-18 10:00").value
+        expected = "Timestamp('2015-11-18 15:45:00+0545', tz='Asia/Katmandu')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # This should be 2015-11-18 10:00 in UTC
+        # converted to Asia/Kolkata
+        result = Timestamp("2015-11-18 15:30:00+05:30", tz="Asia/Kolkata")
+        assert result.value == Timestamp("2015-11-18 10:00").value
+        expected = "Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+    def test_constructor_invalid(self):
+        with pytest.raises(TypeError, match="Cannot convert input"):
+            Timestamp(slice(2))
+        with pytest.raises(ValueError, match="Cannot convert Period"):
+            Timestamp(Period("1000-01-01"))
+
+    def test_constructor_invalid_tz(self):
+        # GH#17690
+        with pytest.raises(TypeError, match="must be a datetime.tzinfo"):
+            Timestamp("2017-10-22", tzinfo="US/Eastern")
+
+        with pytest.raises(ValueError, match="at most one of"):
+            Timestamp("2017-10-22", tzinfo=pytz.utc, tz="UTC")
+
+        with pytest.raises(ValueError, match="Invalid frequency:"):
+            # GH#5168
+            # case where user tries to pass tz as an arg, not kwarg, gets
+            # interpreted as a `freq`
+            Timestamp("2012-01-01", "US/Pacific")
+
+    def test_constructor_strptime(self):
+        # GH25016
+        # Test support for Timestamp.strptime
+        fmt = "%Y%m%d-%H%M%S-%f%z"
+        ts = "20190129-235348-000001+0000"
+        with pytest.raises(NotImplementedError):
+            Timestamp.strptime(ts, fmt)
+
+    def test_constructor_tz_or_tzinfo(self):
+        # GH#17943, GH#17690, GH#5168
+        stamps = [
+            Timestamp(year=2017, month=10, day=22, tz="UTC"),
+            Timestamp(year=2017, month=10, day=22, tzinfo=pytz.utc),
+            Timestamp(year=2017, month=10, day=22, tz=pytz.utc),
+            Timestamp(datetime(2017, 10, 22), tzinfo=pytz.utc),
+            Timestamp(datetime(2017, 10, 22), tz="UTC"),
+            Timestamp(datetime(2017, 10, 22), tz=pytz.utc),
+        ]
+        assert all(ts == stamps[0] for ts in stamps)
+
+    def test_constructor_positional(self):
+        # see gh-10758
+        with pytest.raises(TypeError):
+            Timestamp(2000, 1)
+        with pytest.raises(ValueError):
+            Timestamp(2000, 0, 1)
+        with pytest.raises(ValueError):
+            Timestamp(2000, 13, 1)
+        with pytest.raises(ValueError):
+            Timestamp(2000, 1, 0)
+        with pytest.raises(ValueError):
+            Timestamp(2000, 1, 32)
+
+        # see gh-11630
+        assert repr(Timestamp(2015, 11, 12)) == repr(Timestamp("20151112"))
+        assert repr(Timestamp(2015, 11, 12, 1, 2, 3, 999999)) == repr(
+            Timestamp("2015-11-12 01:02:03.999999")
+        )
+
+    def test_constructor_keyword(self):
+        # GH 10758
+        with pytest.raises(TypeError):
+            Timestamp(year=2000, month=1)
+        with pytest.raises(ValueError):
+            Timestamp(year=2000, month=0, day=1)
+        with pytest.raises(ValueError):
+            Timestamp(year=2000, month=13, day=1)
+        with pytest.raises(ValueError):
+            Timestamp(year=2000, month=1, day=0)
+        with pytest.raises(ValueError):
+            Timestamp(year=2000, month=1, day=32)
+
+        assert repr(Timestamp(year=2015, month=11, day=12)) == repr(
+            Timestamp("20151112")
+        )
+
+        assert repr(
+            Timestamp(
+                year=2015,
+                month=11,
+                day=12,
+                hour=1,
+                minute=2,
+                second=3,
+                microsecond=999999,
+            )
+        ) == repr(Timestamp("2015-11-12 01:02:03.999999"))
+
+    def test_constructor_fromordinal(self):
+        base = datetime(2000, 1, 1)
+
+        ts = Timestamp.fromordinal(base.toordinal(), freq="D")
+        assert base == ts
+        assert ts.freq == "D"
+        assert base.toordinal() == ts.toordinal()
+
+        ts = Timestamp.fromordinal(base.toordinal(), tz="US/Eastern")
+        assert Timestamp("2000-01-01", tz="US/Eastern") == ts
+        assert base.toordinal() == ts.toordinal()
+
+        # GH#3042
+        dt = datetime(2011, 4, 16, 0, 0)
+        ts = Timestamp.fromordinal(dt.toordinal())
+        assert ts.to_pydatetime() == dt
+
+        # with a tzinfo
+        stamp = Timestamp("2011-4-16", tz="US/Eastern")
+        dt_tz = stamp.to_pydatetime()
+        ts = Timestamp.fromordinal(dt_tz.toordinal(), tz="US/Eastern")
+        assert ts.to_pydatetime() == dt_tz
+
+    @pytest.mark.parametrize(
+        "result",
+        [
+            Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), nanosecond=1),
+            Timestamp(
+                year=2000,
+                month=1,
+                day=2,
+                hour=3,
+                minute=4,
+                second=5,
+                microsecond=6,
+                nanosecond=1,
+            ),
+            Timestamp(
+                year=2000,
+                month=1,
+                day=2,
+                hour=3,
+                minute=4,
+                second=5,
+                microsecond=6,
+                nanosecond=1,
+                tz="UTC",
+            ),
+            Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, None),
+            Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, pytz.UTC),
+        ],
+    )
+    def test_constructor_nanosecond(self, result):
+        # GH 18898
+        expected = Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), tz=result.tz)
+        expected = expected + Timedelta(nanoseconds=1)
+        assert result == expected
+
+    @pytest.mark.parametrize("z", ["Z0", "Z00"])
+    def test_constructor_invalid_Z0_isostring(self, z):
+        # GH 8910
+        with pytest.raises(ValueError):
+            Timestamp("2014-11-02 01:00{}".format(z))
+
+    @pytest.mark.parametrize(
+        "arg",
+        [
+            "year",
+            "month",
+            "day",
+            "hour",
+            "minute",
+            "second",
+            "microsecond",
+            "nanosecond",
+        ],
+    )
+    def test_invalid_date_kwarg_with_string_input(self, arg):
+        kwarg = {arg: 1}
+        with pytest.raises(ValueError):
+            Timestamp("2010-10-10 12:59:59.999999999", **kwarg)
+
+    def test_out_of_bounds_integer_value(self):
+        # GH#26651 check that we raise OutOfBoundsDatetime, not OverflowError
+        with pytest.raises(OutOfBoundsDatetime):
+            Timestamp(Timestamp.max.value * 2)
+        with pytest.raises(OutOfBoundsDatetime):
+            Timestamp(Timestamp.min.value * 2)
+
+    def test_out_of_bounds_value(self):
+        one_us = np.timedelta64(1).astype("timedelta64[us]")
+
+        # By definition we can't go out of bounds in [ns], so we
+        # convert the datetime64s to [us] so we can go out of bounds
+        min_ts_us = np.datetime64(Timestamp.min).astype("M8[us]")
+        max_ts_us = np.datetime64(Timestamp.max).astype("M8[us]")
+
+        # No error for the min/max datetimes
+        Timestamp(min_ts_us)
+        Timestamp(max_ts_us)
+
+        # One us less than the minimum is an error
+        with pytest.raises(ValueError):
+            Timestamp(min_ts_us - one_us)
+
+        # One us more than the maximum is an error
+        with pytest.raises(ValueError):
+            Timestamp(max_ts_us + one_us)
+
+    def test_out_of_bounds_string(self):
+        with pytest.raises(ValueError):
+            Timestamp("1676-01-01")
+        with pytest.raises(ValueError):
+            Timestamp("2263-01-01")
+
+    def test_barely_out_of_bounds(self):
+        # GH#19529
+        # GH#19382 close enough to bounds that dropping nanos would result
+        # in an in-bounds datetime
+        with pytest.raises(OutOfBoundsDatetime):
+            Timestamp("2262-04-11 23:47:16.854775808")
+
+    def test_bounds_with_different_units(self):
+        out_of_bounds_dates = ("1677-09-21", "2262-04-12")
+
+        time_units = ("D", "h", "m", "s", "ms", "us")
+
+        for date_string in out_of_bounds_dates:
+            for unit in time_units:
+                dt64 = np.datetime64(date_string, unit)
+                with pytest.raises(ValueError):
+                    Timestamp(dt64)
+
+        in_bounds_dates = ("1677-09-23", "2262-04-11")
+
+        for date_string in in_bounds_dates:
+            for unit in time_units:
+                dt64 = np.datetime64(date_string, unit)
+                Timestamp(dt64)
+
+    def test_min_valid(self):
+        # Ensure that Timestamp.min is a valid Timestamp
+        Timestamp(Timestamp.min)
+
+    def test_max_valid(self):
+        # Ensure that Timestamp.max is a valid Timestamp
+        Timestamp(Timestamp.max)
+
+    def test_now(self):
+        # GH#9000
+        ts_from_string = Timestamp("now")
+        ts_from_method = Timestamp.now()
+        ts_datetime = datetime.now()
+
+        ts_from_string_tz = Timestamp("now", tz="US/Eastern")
+        ts_from_method_tz = Timestamp.now(tz="US/Eastern")
+
+        # Check that the delta between the times is less than 1s (arbitrarily
+        # small)
+        delta = Timedelta(seconds=1)
+        assert abs(ts_from_method - ts_from_string) < delta
+        assert abs(ts_datetime - ts_from_method) < delta
+        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
+        assert (
+            abs(
+                ts_from_string_tz.tz_localize(None)
+                - ts_from_method_tz.tz_localize(None)
+            )
+            < delta
+        )
+
+    def test_today(self):
+        ts_from_string = Timestamp("today")
+        ts_from_method = Timestamp.today()
+        ts_datetime = datetime.today()
+
+        ts_from_string_tz = Timestamp("today", tz="US/Eastern")
+        ts_from_method_tz = Timestamp.today(tz="US/Eastern")
+
+        # Check that the delta between the times is less than 1s (arbitrarily
+        # small)
+        delta = Timedelta(seconds=1)
+        assert abs(ts_from_method - ts_from_string) < delta
+        assert abs(ts_datetime - ts_from_method) < delta
+        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
+        assert (
+            abs(
+                ts_from_string_tz.tz_localize(None)
+                - ts_from_method_tz.tz_localize(None)
+            )
+            < delta
+        )
+
+    @pytest.mark.parametrize("tz", [None, pytz.timezone("US/Pacific")])
+    def test_disallow_setting_tz(self, tz):
+        # GH 3746
+        ts = Timestamp("2010")
+        with pytest.raises(AttributeError):
+            ts.tz = tz
+
+    @pytest.mark.parametrize("offset", ["+0300", "+0200"])
+    def test_construct_timestamp_near_dst(self, offset):
+        # GH 20854
+        expected = Timestamp(
+            "2016-10-30 03:00:00{}".format(offset), tz="Europe/Helsinki"
+        )
+        result = Timestamp(expected).tz_convert("Europe/Helsinki")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "arg", ["2013/01/01 00:00:00+09:00", "2013-01-01 00:00:00+09:00"]
+    )
+    def test_construct_with_different_string_format(self, arg):
+        # GH 12064
+        result = Timestamp(arg)
+        expected = Timestamp(datetime(2013, 1, 1), tz=pytz.FixedOffset(540))
+        assert result == expected
+
+    def test_construct_timestamp_preserve_original_frequency(self):
+        # GH 22311
+        result = Timestamp(Timestamp("2010-08-08", freq="D")).freq
+        expected = offsets.Day()
+        assert result == expected
+
+    def test_constructor_invalid_frequency(self):
+        # GH 22311
+        with pytest.raises(ValueError, match="Invalid frequency:"):
+            Timestamp("2012-01-01", freq=[])
+
+    @pytest.mark.parametrize("box", [datetime, Timestamp])
+    def test_raise_tz_and_tzinfo_in_datetime_input(self, box):
+        # GH 23579
+        kwargs = {"year": 2018, "month": 1, "day": 1, "tzinfo": pytz.utc}
+        with pytest.raises(ValueError, match="Cannot pass a datetime or Timestamp"):
+            Timestamp(box(**kwargs), tz="US/Pacific")
+        with pytest.raises(ValueError, match="Cannot pass a datetime or Timestamp"):
+            Timestamp(box(**kwargs), tzinfo=pytz.timezone("US/Pacific"))
+
+    def test_dont_convert_dateutil_utc_to_pytz_utc(self):
+        result = Timestamp(datetime(2018, 1, 1), tz=tzutc())
+        expected = Timestamp(datetime(2018, 1, 1)).tz_localize(tzutc())
+        assert result == expected
+
+    def test_constructor_subclassed_datetime(self):
+        # GH 25851
+        # ensure that subclassed datetime works for
+        # Timestamp creation
+        class SubDatetime(datetime):
+            pass
+
+        data = SubDatetime(2000, 1, 1)
+        result = Timestamp(data)
+        expected = Timestamp(2000, 1, 1)
+        assert result == expected
+
+    @pytest.mark.skipif(
+        not compat.PY38,
+        reason="datetime.fromisocalendar was added in Python version 3.8",
+    )
+    def test_constructor_fromisocalendar(self):
+        # GH 30395
+        expected_timestamp = Timestamp("2000-01-03 00:00:00")
+        expected_stdlib = datetime.fromisocalendar(2000, 1, 1)
+        result = Timestamp.fromisocalendar(2000, 1, 1)
+        assert result == expected_timestamp
+        assert result == expected_stdlib
+        assert isinstance(result, Timestamp)
+
+
+def test_constructor_ambigous_dst():
+    # GH 24329
+    # Make sure that calling Timestamp constructor
+    # on Timestamp created from ambiguous time
+    # doesn't change Timestamp.value
+    ts = Timestamp(1382835600000000000, tz="dateutil/Europe/London")
+    expected = ts.value
+    result = Timestamp(ts).value
+    assert result == expected
+
+
+@pytest.mark.parametrize("epoch", [1552211999999999872, 1552211999999999999])
+def test_constructor_before_dst_switch(epoch):
+    # GH 31043
+    # Make sure that calling Timestamp constructor
+    # on time just before DST switch doesn't lead to
+    # nonexistent time or value change
+    ts = Timestamp(epoch, tz="dateutil/America/Los_Angeles")
+    result = ts.tz.dst(ts)
+    expected = timedelta(seconds=0)
+    assert Timestamp(ts).value == epoch
+    assert result == expected
+
+
+def test_timestamp_constructor_identity():
+    # Test for #30543
+    expected = Timestamp("2017-01-01T12")
+    result = Timestamp(expected)
+    assert result is expected
diff --git a/pandas/tests/scalar/timestamp/test_rendering.py b/pandas/tests/scalar/timestamp/test_rendering.py
index 6b64b230a0bb9..cab6946bb8d02 100644
--- a/pandas/tests/scalar/timestamp/test_rendering.py
+++ b/pandas/tests/scalar/timestamp/test_rendering.py
@@ -85,3 +85,13 @@ def test_pprint(self):
          {'w': {'a': Timestamp('2011-01-01 00:00:00')}}],
  'foo': 1}"""
         assert result == expected
+
+    def test_to_timestamp_repr_is_code(self):
+        zs = [
+            Timestamp("99-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"),
+            Timestamp("2001-04-17 00:00:00", tz=None),
+        ]
+        for z in zs:
+            assert eval(repr(z)) == z
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index 652dd34ca7ce2..cee7ac450e411 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -5,21 +5,18 @@
 import locale
 import unicodedata
 
-import dateutil
 from dateutil.tz import tzutc
 import numpy as np
 import pytest
 import pytz
 from pytz import timezone, utc
 
-from pandas._libs.tslibs import conversion
 from pandas._libs.tslibs.timezones import dateutil_gettz as gettz, get_timezone
 from pandas.compat.numpy import np_datetime64_compat
-from pandas.errors import OutOfBoundsDatetime
 import pandas.util._test_decorators as td
 
-from pandas import NaT, Period, Timedelta, Timestamp
-import pandas.util.testing as tm
+from pandas import NaT, Timedelta, Timestamp
+import pandas._testing as tm
 
 from pandas.tseries import offsets
 
@@ -108,9 +105,7 @@ def check(value, equal):
     )
     def test_names(self, data, time_locale):
         # GH 17354
-        # Test .weekday_name, .day_name(), .month_name
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            assert data.weekday_name == "Monday"
+        # Test .day_name(), .month_name
         if time_locale is None:
             expected_day = "Monday"
             expected_month = "August"
@@ -194,511 +189,9 @@ def test_resolution(self):
         dt = Timestamp("2100-01-01 00:00:00")
         assert dt.resolution == Timedelta(nanoseconds=1)
 
-
-class TestTimestampConstructors:
-    def test_constructor(self):
-        base_str = "2014-07-01 09:00"
-        base_dt = datetime(2014, 7, 1, 9)
-        base_expected = 1404205200000000000
-
-        # confirm base representation is correct
-        import calendar
-
-        assert calendar.timegm(base_dt.timetuple()) * 1000000000 == base_expected
-
-        tests = [
-            (base_str, base_dt, base_expected),
-            (
-                "2014-07-01 10:00",
-                datetime(2014, 7, 1, 10),
-                base_expected + 3600 * 1000000000,
-            ),
-            (
-                "2014-07-01 09:00:00.000008000",
-                datetime(2014, 7, 1, 9, 0, 0, 8),
-                base_expected + 8000,
-            ),
-            (
-                "2014-07-01 09:00:00.000000005",
-                Timestamp("2014-07-01 09:00:00.000000005"),
-                base_expected + 5,
-            ),
-        ]
-
-        timezones = [
-            (None, 0),
-            ("UTC", 0),
-            (pytz.utc, 0),
-            ("Asia/Tokyo", 9),
-            ("US/Eastern", -4),
-            ("dateutil/US/Pacific", -7),
-            (pytz.FixedOffset(-180), -3),
-            (dateutil.tz.tzoffset(None, 18000), 5),
-        ]
-
-        for date_str, date, expected in tests:
-            for result in [Timestamp(date_str), Timestamp(date)]:
-                # only with timestring
-                assert result.value == expected
-                assert conversion.pydt_to_i8(result) == expected
-
-                # re-creation shouldn't affect to internal value
-                result = Timestamp(result)
-                assert result.value == expected
-                assert conversion.pydt_to_i8(result) == expected
-
-            # with timezone
-            for tz, offset in timezones:
-                for result in [Timestamp(date_str, tz=tz), Timestamp(date, tz=tz)]:
-                    expected_tz = expected - offset * 3600 * 1000000000
-                    assert result.value == expected_tz
-                    assert conversion.pydt_to_i8(result) == expected_tz
-
-                    # should preserve tz
-                    result = Timestamp(result)
-                    assert result.value == expected_tz
-                    assert conversion.pydt_to_i8(result) == expected_tz
-
-                    # should convert to UTC
-                    if tz is not None:
-                        result = Timestamp(result).tz_convert("UTC")
-                    else:
-                        result = Timestamp(result, tz="UTC")
-                    expected_utc = expected - offset * 3600 * 1000000000
-                    assert result.value == expected_utc
-                    assert conversion.pydt_to_i8(result) == expected_utc
-
-    def test_constructor_with_stringoffset(self):
-        # GH 7833
-        base_str = "2014-07-01 11:00:00+02:00"
-        base_dt = datetime(2014, 7, 1, 9)
-        base_expected = 1404205200000000000
-
-        # confirm base representation is correct
-        import calendar
-
-        assert calendar.timegm(base_dt.timetuple()) * 1000000000 == base_expected
-
-        tests = [
-            (base_str, base_expected),
-            ("2014-07-01 12:00:00+02:00", base_expected + 3600 * 1000000000),
-            ("2014-07-01 11:00:00.000008000+02:00", base_expected + 8000),
-            ("2014-07-01 11:00:00.000000005+02:00", base_expected + 5),
-        ]
-
-        timezones = [
-            (None, 0),
-            ("UTC", 0),
-            (pytz.utc, 0),
-            ("Asia/Tokyo", 9),
-            ("US/Eastern", -4),
-            ("dateutil/US/Pacific", -7),
-            (pytz.FixedOffset(-180), -3),
-            (dateutil.tz.tzoffset(None, 18000), 5),
-        ]
-
-        for date_str, expected in tests:
-            for result in [Timestamp(date_str)]:
-                # only with timestring
-                assert result.value == expected
-                assert conversion.pydt_to_i8(result) == expected
-
-                # re-creation shouldn't affect to internal value
-                result = Timestamp(result)
-                assert result.value == expected
-                assert conversion.pydt_to_i8(result) == expected
-
-            # with timezone
-            for tz, offset in timezones:
-                result = Timestamp(date_str, tz=tz)
-                expected_tz = expected
-                assert result.value == expected_tz
-                assert conversion.pydt_to_i8(result) == expected_tz
-
-                # should preserve tz
-                result = Timestamp(result)
-                assert result.value == expected_tz
-                assert conversion.pydt_to_i8(result) == expected_tz
-
-                # should convert to UTC
-                result = Timestamp(result).tz_convert("UTC")
-                expected_utc = expected
-                assert result.value == expected_utc
-                assert conversion.pydt_to_i8(result) == expected_utc
-
-        # This should be 2013-11-01 05:00 in UTC
-        # converted to Chicago tz
-        result = Timestamp("2013-11-01 00:00:00-0500", tz="America/Chicago")
-        assert result.value == Timestamp("2013-11-01 05:00").value
-        expected = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')"  # noqa
-        assert repr(result) == expected
-        assert result == eval(repr(result))
-
-        # This should be 2013-11-01 05:00 in UTC
-        # converted to Tokyo tz (+09:00)
-        result = Timestamp("2013-11-01 00:00:00-0500", tz="Asia/Tokyo")
-        assert result.value == Timestamp("2013-11-01 05:00").value
-        expected = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')"
-        assert repr(result) == expected
-        assert result == eval(repr(result))
-
-        # GH11708
-        # This should be 2015-11-18 10:00 in UTC
-        # converted to Asia/Katmandu
-        result = Timestamp("2015-11-18 15:45:00+05:45", tz="Asia/Katmandu")
-        assert result.value == Timestamp("2015-11-18 10:00").value
-        expected = "Timestamp('2015-11-18 15:45:00+0545', tz='Asia/Katmandu')"
-        assert repr(result) == expected
-        assert result == eval(repr(result))
-
-        # This should be 2015-11-18 10:00 in UTC
-        # converted to Asia/Kolkata
-        result = Timestamp("2015-11-18 15:30:00+05:30", tz="Asia/Kolkata")
-        assert result.value == Timestamp("2015-11-18 10:00").value
-        expected = "Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')"
-        assert repr(result) == expected
-        assert result == eval(repr(result))
-
-    def test_constructor_invalid(self):
-        with pytest.raises(TypeError, match="Cannot convert input"):
-            Timestamp(slice(2))
-        with pytest.raises(ValueError, match="Cannot convert Period"):
-            Timestamp(Period("1000-01-01"))
-
-    def test_constructor_invalid_tz(self):
-        # GH#17690
-        with pytest.raises(TypeError, match="must be a datetime.tzinfo"):
-            Timestamp("2017-10-22", tzinfo="US/Eastern")
-
-        with pytest.raises(ValueError, match="at most one of"):
-            Timestamp("2017-10-22", tzinfo=utc, tz="UTC")
-
-        with pytest.raises(ValueError, match="Invalid frequency:"):
-            # GH#5168
-            # case where user tries to pass tz as an arg, not kwarg, gets
-            # interpreted as a `freq`
-            Timestamp("2012-01-01", "US/Pacific")
-
-    def test_constructor_strptime(self):
-        # GH25016
-        # Test support for Timestamp.strptime
-        fmt = "%Y%m%d-%H%M%S-%f%z"
-        ts = "20190129-235348-000001+0000"
-        with pytest.raises(NotImplementedError):
-            Timestamp.strptime(ts, fmt)
-
-    def test_constructor_tz_or_tzinfo(self):
-        # GH#17943, GH#17690, GH#5168
-        stamps = [
-            Timestamp(year=2017, month=10, day=22, tz="UTC"),
-            Timestamp(year=2017, month=10, day=22, tzinfo=utc),
-            Timestamp(year=2017, month=10, day=22, tz=utc),
-            Timestamp(datetime(2017, 10, 22), tzinfo=utc),
-            Timestamp(datetime(2017, 10, 22), tz="UTC"),
-            Timestamp(datetime(2017, 10, 22), tz=utc),
-        ]
-        assert all(ts == stamps[0] for ts in stamps)
-
-    def test_constructor_positional(self):
-        # see gh-10758
-        with pytest.raises(TypeError):
-            Timestamp(2000, 1)
-        with pytest.raises(ValueError):
-            Timestamp(2000, 0, 1)
-        with pytest.raises(ValueError):
-            Timestamp(2000, 13, 1)
-        with pytest.raises(ValueError):
-            Timestamp(2000, 1, 0)
-        with pytest.raises(ValueError):
-            Timestamp(2000, 1, 32)
-
-        # see gh-11630
-        assert repr(Timestamp(2015, 11, 12)) == repr(Timestamp("20151112"))
-        assert repr(Timestamp(2015, 11, 12, 1, 2, 3, 999999)) == repr(
-            Timestamp("2015-11-12 01:02:03.999999")
-        )
-
-    def test_constructor_keyword(self):
-        # GH 10758
-        with pytest.raises(TypeError):
-            Timestamp(year=2000, month=1)
-        with pytest.raises(ValueError):
-            Timestamp(year=2000, month=0, day=1)
-        with pytest.raises(ValueError):
-            Timestamp(year=2000, month=13, day=1)
-        with pytest.raises(ValueError):
-            Timestamp(year=2000, month=1, day=0)
-        with pytest.raises(ValueError):
-            Timestamp(year=2000, month=1, day=32)
-
-        assert repr(Timestamp(year=2015, month=11, day=12)) == repr(
-            Timestamp("20151112")
-        )
-
-        assert repr(
-            Timestamp(
-                year=2015,
-                month=11,
-                day=12,
-                hour=1,
-                minute=2,
-                second=3,
-                microsecond=999999,
-            )
-        ) == repr(Timestamp("2015-11-12 01:02:03.999999"))
-
-    def test_constructor_fromordinal(self):
-        base = datetime(2000, 1, 1)
-
-        ts = Timestamp.fromordinal(base.toordinal(), freq="D")
-        assert base == ts
-        assert ts.freq == "D"
-        assert base.toordinal() == ts.toordinal()
-
-        ts = Timestamp.fromordinal(base.toordinal(), tz="US/Eastern")
-        assert Timestamp("2000-01-01", tz="US/Eastern") == ts
-        assert base.toordinal() == ts.toordinal()
-
-        # GH#3042
-        dt = datetime(2011, 4, 16, 0, 0)
-        ts = Timestamp.fromordinal(dt.toordinal())
-        assert ts.to_pydatetime() == dt
-
-        # with a tzinfo
-        stamp = Timestamp("2011-4-16", tz="US/Eastern")
-        dt_tz = stamp.to_pydatetime()
-        ts = Timestamp.fromordinal(dt_tz.toordinal(), tz="US/Eastern")
-        assert ts.to_pydatetime() == dt_tz
-
-    @pytest.mark.parametrize(
-        "result",
-        [
-            Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), nanosecond=1),
-            Timestamp(
-                year=2000,
-                month=1,
-                day=2,
-                hour=3,
-                minute=4,
-                second=5,
-                microsecond=6,
-                nanosecond=1,
-            ),
-            Timestamp(
-                year=2000,
-                month=1,
-                day=2,
-                hour=3,
-                minute=4,
-                second=5,
-                microsecond=6,
-                nanosecond=1,
-                tz="UTC",
-            ),
-            Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, None),
-            Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, pytz.UTC),
-        ],
-    )
-    def test_constructor_nanosecond(self, result):
-        # GH 18898
-        expected = Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), tz=result.tz)
-        expected = expected + Timedelta(nanoseconds=1)
-        assert result == expected
-
-    @pytest.mark.parametrize("z", ["Z0", "Z00"])
-    def test_constructor_invalid_Z0_isostring(self, z):
-        # GH 8910
-        with pytest.raises(ValueError):
-            Timestamp("2014-11-02 01:00{}".format(z))
-
-    @pytest.mark.parametrize(
-        "arg",
-        [
-            "year",
-            "month",
-            "day",
-            "hour",
-            "minute",
-            "second",
-            "microsecond",
-            "nanosecond",
-        ],
-    )
-    def test_invalid_date_kwarg_with_string_input(self, arg):
-        kwarg = {arg: 1}
-        with pytest.raises(ValueError):
-            Timestamp("2010-10-10 12:59:59.999999999", **kwarg)
-
-    def test_out_of_bounds_integer_value(self):
-        # GH#26651 check that we raise OutOfBoundsDatetime, not OverflowError
-        with pytest.raises(OutOfBoundsDatetime):
-            Timestamp(Timestamp.max.value * 2)
-        with pytest.raises(OutOfBoundsDatetime):
-            Timestamp(Timestamp.min.value * 2)
-
-    def test_out_of_bounds_value(self):
-        one_us = np.timedelta64(1).astype("timedelta64[us]")
-
-        # By definition we can't go out of bounds in [ns], so we
-        # convert the datetime64s to [us] so we can go out of bounds
-        min_ts_us = np.datetime64(Timestamp.min).astype("M8[us]")
-        max_ts_us = np.datetime64(Timestamp.max).astype("M8[us]")
-
-        # No error for the min/max datetimes
-        Timestamp(min_ts_us)
-        Timestamp(max_ts_us)
-
-        # One us less than the minimum is an error
-        with pytest.raises(ValueError):
-            Timestamp(min_ts_us - one_us)
-
-        # One us more than the maximum is an error
-        with pytest.raises(ValueError):
-            Timestamp(max_ts_us + one_us)
-
-    def test_out_of_bounds_string(self):
-        with pytest.raises(ValueError):
-            Timestamp("1676-01-01")
-        with pytest.raises(ValueError):
-            Timestamp("2263-01-01")
-
-    def test_barely_out_of_bounds(self):
-        # GH#19529
-        # GH#19382 close enough to bounds that dropping nanos would result
-        # in an in-bounds datetime
-        with pytest.raises(OutOfBoundsDatetime):
-            Timestamp("2262-04-11 23:47:16.854775808")
-
-    def test_bounds_with_different_units(self):
-        out_of_bounds_dates = ("1677-09-21", "2262-04-12")
-
-        time_units = ("D", "h", "m", "s", "ms", "us")
-
-        for date_string in out_of_bounds_dates:
-            for unit in time_units:
-                dt64 = np.datetime64(date_string, dtype="M8[{unit}]".format(unit=unit))
-                with pytest.raises(ValueError):
-                    Timestamp(dt64)
-
-        in_bounds_dates = ("1677-09-23", "2262-04-11")
-
-        for date_string in in_bounds_dates:
-            for unit in time_units:
-                dt64 = np.datetime64(date_string, dtype="M8[{unit}]".format(unit=unit))
-                Timestamp(dt64)
-
-    def test_min_valid(self):
-        # Ensure that Timestamp.min is a valid Timestamp
-        Timestamp(Timestamp.min)
-
-    def test_max_valid(self):
-        # Ensure that Timestamp.max is a valid Timestamp
-        Timestamp(Timestamp.max)
-
-    def test_now(self):
-        # GH#9000
-        ts_from_string = Timestamp("now")
-        ts_from_method = Timestamp.now()
-        ts_datetime = datetime.now()
-
-        ts_from_string_tz = Timestamp("now", tz="US/Eastern")
-        ts_from_method_tz = Timestamp.now(tz="US/Eastern")
-
-        # Check that the delta between the times is less than 1s (arbitrarily
-        # small)
-        delta = Timedelta(seconds=1)
-        assert abs(ts_from_method - ts_from_string) < delta
-        assert abs(ts_datetime - ts_from_method) < delta
-        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
-        assert (
-            abs(
-                ts_from_string_tz.tz_localize(None)
-                - ts_from_method_tz.tz_localize(None)
-            )
-            < delta
-        )
-
-    def test_today(self):
-        ts_from_string = Timestamp("today")
-        ts_from_method = Timestamp.today()
-        ts_datetime = datetime.today()
-
-        ts_from_string_tz = Timestamp("today", tz="US/Eastern")
-        ts_from_method_tz = Timestamp.today(tz="US/Eastern")
-
-        # Check that the delta between the times is less than 1s (arbitrarily
-        # small)
-        delta = Timedelta(seconds=1)
-        assert abs(ts_from_method - ts_from_string) < delta
-        assert abs(ts_datetime - ts_from_method) < delta
-        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
-        assert (
-            abs(
-                ts_from_string_tz.tz_localize(None)
-                - ts_from_method_tz.tz_localize(None)
-            )
-            < delta
-        )
-
-    @pytest.mark.parametrize("tz", [None, pytz.timezone("US/Pacific")])
-    def test_disallow_setting_tz(self, tz):
-        # GH 3746
-        ts = Timestamp("2010")
-        with pytest.raises(AttributeError):
-            ts.tz = tz
-
-    @pytest.mark.parametrize("offset", ["+0300", "+0200"])
-    def test_construct_timestamp_near_dst(self, offset):
-        # GH 20854
-        expected = Timestamp(
-            "2016-10-30 03:00:00{}".format(offset), tz="Europe/Helsinki"
-        )
-        result = Timestamp(expected).tz_convert("Europe/Helsinki")
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "arg", ["2013/01/01 00:00:00+09:00", "2013-01-01 00:00:00+09:00"]
-    )
-    def test_construct_with_different_string_format(self, arg):
-        # GH 12064
-        result = Timestamp(arg)
-        expected = Timestamp(datetime(2013, 1, 1), tz=pytz.FixedOffset(540))
-        assert result == expected
-
-    def test_construct_timestamp_preserve_original_frequency(self):
-        # GH 22311
-        result = Timestamp(Timestamp("2010-08-08", freq="D")).freq
-        expected = offsets.Day()
-        assert result == expected
-
-    def test_constructor_invalid_frequency(self):
-        # GH 22311
-        with pytest.raises(ValueError, match="Invalid frequency:"):
-            Timestamp("2012-01-01", freq=[])
-
-    @pytest.mark.parametrize("box", [datetime, Timestamp])
-    def test_depreciate_tz_and_tzinfo_in_datetime_input(self, box):
-        # GH 23579
-        kwargs = {"year": 2018, "month": 1, "day": 1, "tzinfo": utc}
-        with tm.assert_produces_warning(FutureWarning):
-            Timestamp(box(**kwargs), tz="US/Pacific")
-
-    def test_dont_convert_dateutil_utc_to_pytz_utc(self):
-        result = Timestamp(datetime(2018, 1, 1), tz=tzutc())
-        expected = Timestamp(datetime(2018, 1, 1)).tz_localize(tzutc())
-        assert result == expected
-
-    def test_constructor_subclassed_datetime(self):
-        # GH 25851
-        # ensure that subclassed datetime works for
-        # Timestamp creation
-        class SubDatetime(datetime):
-            pass
-
-        data = SubDatetime(2000, 1, 1)
-        result = Timestamp(data)
-        expected = Timestamp(2000, 1, 1)
-        assert result == expected
+        # Check that the attribute is available on the class, mirroring
+        #  the stdlib datetime behavior
+        assert Timestamp.resolution == Timedelta(nanoseconds=1)
 
 
 class TestTimestamp:
@@ -725,7 +218,7 @@ def test_utc_z_designator(self):
         assert get_timezone(Timestamp("2014-11-02 01:00Z").tzinfo) is utc
 
     def test_asm8(self):
-        np.random.seed(7960929)
+        np.random.seed(7_960_929)
         ns = [Timestamp.min.value, Timestamp.max.value, 1000]
 
         for n in ns:
@@ -737,7 +230,7 @@ def test_asm8(self):
 
     def test_class_ops_pytz(self):
         def compare(x, y):
-            assert int(Timestamp(x).value / 1e9) == int(Timestamp(y).value / 1e9)
+            assert int((Timestamp(x).value - Timestamp(y).value) / 1e9) == 0
 
         compare(Timestamp.now(), datetime.now())
         compare(Timestamp.now("UTC"), datetime.now(timezone("UTC")))
@@ -761,8 +254,12 @@ def compare(x, y):
 
     def test_class_ops_dateutil(self):
         def compare(x, y):
-            assert int(np.round(Timestamp(x).value / 1e9)) == int(
-                np.round(Timestamp(y).value / 1e9)
+            assert (
+                int(
+                    np.round(Timestamp(x).value / 1e9)
+                    - np.round(Timestamp(y).value / 1e9)
+                )
+                == 0
             )
 
         compare(Timestamp.now(), datetime.now())
@@ -786,7 +283,7 @@ def compare(x, y):
         )
 
     def test_basics_nanos(self):
-        val = np.int64(946684800000000000).view("M8[ns]")
+        val = np.int64(946_684_800_000_000_000).view("M8[ns]")
         stamp = Timestamp(val.view("i8") + 500)
         assert stamp.year == 2000
         assert stamp.month == 1
@@ -794,7 +291,7 @@ def test_basics_nanos(self):
         assert stamp.nanosecond == 500
 
         # GH 14415
-        val = np.iinfo(np.int64).min + 80000000000000
+        val = np.iinfo(np.int64).min + 80_000_000_000_000
         stamp = Timestamp(val)
         assert stamp.year == 1677
         assert stamp.month == 9
@@ -807,8 +304,8 @@ def test_basics_nanos(self):
         [
             [946688461000000000, {}],
             [946688461000000000 / 1000, dict(unit="us")],
-            [946688461000000000 / 1000000, dict(unit="ms")],
-            [946688461000000000 / 1000000000, dict(unit="s")],
+            [946688461000000000 / 1_000_000, dict(unit="ms")],
+            [946688461000000000 / 1_000_000_000, dict(unit="s")],
             [10957, dict(unit="D", h=0)],
             [
                 (946688461000000000 + 500000) / 1000000000,
@@ -852,24 +349,24 @@ def test_roundtrip(self):
         base = Timestamp("20140101 00:00:00")
 
         result = Timestamp(base.value + Timedelta("5ms").value)
-        assert result == Timestamp(str(base) + ".005000")
+        assert result == Timestamp(f"{base}.005000")
         assert result.microsecond == 5000
 
         result = Timestamp(base.value + Timedelta("5us").value)
-        assert result == Timestamp(str(base) + ".000005")
+        assert result == Timestamp(f"{base}.000005")
         assert result.microsecond == 5
 
         result = Timestamp(base.value + Timedelta("5ns").value)
-        assert result == Timestamp(str(base) + ".000000005")
+        assert result == Timestamp(f"{base}.000000005")
         assert result.nanosecond == 5
         assert result.microsecond == 0
 
         result = Timestamp(base.value + Timedelta("6ms 5us").value)
-        assert result == Timestamp(str(base) + ".006005")
+        assert result == Timestamp(f"{base}.006005")
         assert result.microsecond == 5 + 6 * 1000
 
         result = Timestamp(base.value + Timedelta("200ms 5us").value)
-        assert result == Timestamp(str(base) + ".200005")
+        assert result == Timestamp(f"{base}.200005")
         assert result.microsecond == 5 + 200 * 1000
 
     def test_hash_equivalent(self):
@@ -890,12 +387,12 @@ def test_nanosecond_string_parsing(self):
         ts = Timestamp("2013-05-01 07:15:45.123456789")
         # GH 7878
         expected_repr = "2013-05-01 07:15:45.123456789"
-        expected_value = 1367392545123456789
+        expected_value = 1_367_392_545_123_456_789
         assert ts.value == expected_value
         assert expected_repr in repr(ts)
 
         ts = Timestamp("2013-05-01 07:15:45.123456789+09:00", tz="Asia/Tokyo")
-        assert ts.value == expected_value - 9 * 3600 * 1000000000
+        assert ts.value == expected_value - 9 * 3600 * 1_000_000_000
         assert expected_repr in repr(ts)
 
         ts = Timestamp("2013-05-01 07:15:45.123456789", tz="UTC")
@@ -903,7 +400,7 @@ def test_nanosecond_string_parsing(self):
         assert expected_repr in repr(ts)
 
         ts = Timestamp("2013-05-01 07:15:45.123456789", tz="US/Eastern")
-        assert ts.value == expected_value + 4 * 3600 * 1000000000
+        assert ts.value == expected_value + 4 * 3600 * 1_000_000_000
         assert expected_repr in repr(ts)
 
         # GH 10041
@@ -913,7 +410,7 @@ def test_nanosecond_string_parsing(self):
 
     def test_nanosecond_timestamp(self):
         # GH 7610
-        expected = 1293840000000000005
+        expected = 1_293_840_000_000_000_005
         t = Timestamp("2011-01-01") + offsets.Nano(5)
         assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
         assert t.value == expected
@@ -929,7 +426,7 @@ def test_nanosecond_timestamp(self):
         assert t.value == expected
         assert t.nanosecond == 5
 
-        expected = 1293840000000000010
+        expected = 1_293_840_000_000_000_010
         t = t + offsets.Nano(5)
         assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
         assert t.value == expected
@@ -949,23 +446,23 @@ def test_nanosecond_timestamp(self):
 class TestTimestampToJulianDate:
     def test_compare_1700(self):
         r = Timestamp("1700-06-23").to_julian_date()
-        assert r == 2342145.5
+        assert r == 2_342_145.5
 
     def test_compare_2000(self):
         r = Timestamp("2000-04-12").to_julian_date()
-        assert r == 2451646.5
+        assert r == 2_451_646.5
 
     def test_compare_2100(self):
         r = Timestamp("2100-08-12").to_julian_date()
-        assert r == 2488292.5
+        assert r == 2_488_292.5
 
     def test_compare_hour01(self):
         r = Timestamp("2000-08-12T01:00:00").to_julian_date()
-        assert r == 2451768.5416666666666666
+        assert r == 2_451_768.5416666666666666
 
     def test_compare_hour13(self):
         r = Timestamp("2000-08-12T13:00:00").to_julian_date()
-        assert r == 2451769.0416666666666666
+        assert r == 2_451_769.0416666666666666
 
 
 class TestTimestampConversion:
diff --git a/pandas/tests/scalar/timestamp/test_timezones.py b/pandas/tests/scalar/timestamp/test_timezones.py
index 424b0c9abdef8..6537f6ccd8432 100644
--- a/pandas/tests/scalar/timestamp/test_timezones.py
+++ b/pandas/tests/scalar/timestamp/test_timezones.py
@@ -14,7 +14,6 @@
 import pandas.util._test_decorators as td
 
 from pandas import NaT, Timestamp
-import pandas.util.testing as tm
 
 
 class TestTimestampTZOperations:
@@ -80,7 +79,6 @@ def test_tz_localize_ambiguous(self):
             ("2015-03-29 02:30", "Europe/Belgrade"),
         ],
     )
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
     def test_tz_localize_nonexistent(self, stamp, tz):
         # GH#13057
         ts = Timestamp(stamp)
@@ -88,36 +86,21 @@ def test_tz_localize_nonexistent(self, stamp, tz):
             ts.tz_localize(tz)
         # GH 22644
         with pytest.raises(NonExistentTimeError):
-            with tm.assert_produces_warning(FutureWarning):
-                ts.tz_localize(tz, errors="raise")
-        with tm.assert_produces_warning(FutureWarning):
-            assert ts.tz_localize(tz, errors="coerce") is NaT
+            ts.tz_localize(tz, nonexistent="raise")
+        assert ts.tz_localize(tz, nonexistent="NaT") is NaT
 
-    def test_tz_localize_errors_ambiguous(self):
+    def test_tz_localize_ambiguous_raise(self):
         # GH#13057
         ts = Timestamp("2015-11-1 01:00")
         with pytest.raises(AmbiguousTimeError):
-            with tm.assert_produces_warning(FutureWarning):
-                ts.tz_localize("US/Pacific", errors="coerce")
+            ts.tz_localize("US/Pacific", ambiguous="raise")
 
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
-    def test_tz_localize_errors_invalid_arg(self):
+    def test_tz_localize_nonexistent_invalid_arg(self):
         # GH 22644
         tz = "Europe/Warsaw"
         ts = Timestamp("2015-03-29 02:00:00")
         with pytest.raises(ValueError):
-            with tm.assert_produces_warning(FutureWarning):
-                ts.tz_localize(tz, errors="foo")
-
-    def test_tz_localize_errors_coerce(self):
-        # GH 22644
-        # make sure errors='coerce' gets mapped correctly to nonexistent
-        tz = "Europe/Warsaw"
-        ts = Timestamp("2015-03-29 02:00:00")
-        with tm.assert_produces_warning(FutureWarning):
-            result = ts.tz_localize(tz, errors="coerce")
-        expected = ts.tz_localize(tz, nonexistent="NaT")
-        assert result is expected
+            ts.tz_localize(tz, nonexistent="foo")
 
     @pytest.mark.parametrize(
         "stamp",
@@ -306,15 +289,14 @@ def test_astimezone(self, tzstr):
 
     @td.skip_if_windows
     def test_tz_convert_utc_with_system_utc(self):
-        from pandas._libs.tslibs.timezones import maybe_get_tz
 
         # from system utc to real utc
-        ts = Timestamp("2001-01-05 11:56", tz=maybe_get_tz("dateutil/UTC"))
+        ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC"))
         # check that the time hasn't changed.
         assert ts == ts.tz_convert(dateutil.tz.tzutc())
 
         # from system utc to real utc
-        ts = Timestamp("2001-01-05 11:56", tz=maybe_get_tz("dateutil/UTC"))
+        ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC"))
         # check that the time hasn't changed.
         assert ts == ts.tz_convert(dateutil.tz.tzutc())
 
diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index dffb957b8f3b0..f968144286bd4 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -7,11 +7,10 @@
 
 from pandas._libs.tslibs import conversion
 from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
-from pandas.compat import PY36
 import pandas.util._test_decorators as td
 
 from pandas import NaT, Timestamp
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.frequencies import to_offset
 
@@ -226,9 +225,8 @@ def test_round_dst_border_nonexistent(self, method, ts_str, freq):
         ],
     )
     def test_round_int64(self, timestamp, freq):
-        """check that all rounding modes are accurate to int64 precision
-           see GH#22591
-        """
+        # check that all rounding modes are accurate to int64 precision
+        # see GH#22591
         dt = Timestamp(timestamp)
         unit = to_offset(freq).nanos
 
@@ -375,7 +373,6 @@ def test_replace_dst_border(self):
         expected = Timestamp("2013-11-3 03:00:00", tz="America/Chicago")
         assert result == expected
 
-    @pytest.mark.skipif(not PY36, reason="Fold not available until PY3.6")
     @pytest.mark.parametrize("fold", [0, 1])
     @pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"])
     def test_replace_dst_fold(self, fold, tz):
diff --git a/pandas/tests/series/common.py b/pandas/tests/series/common.py
deleted file mode 100644
index 38c62e89f1873..0000000000000
--- a/pandas/tests/series/common.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from pandas.util._decorators import cache_readonly
-
-import pandas as pd
-import pandas.util.testing as tm
-
-_ts = tm.makeTimeSeries()
-
-
-class TestData:
-    @cache_readonly
-    def ts(self):
-        ts = _ts.copy()
-        ts.name = "ts"
-        return ts
-
-    @cache_readonly
-    def series(self):
-        series = tm.makeStringSeries()
-        series.name = "series"
-        return series
-
-    @cache_readonly
-    def objSeries(self):
-        objSeries = tm.makeObjectSeries()
-        objSeries.name = "objects"
-        return objSeries
-
-    @cache_readonly
-    def empty(self):
-        return pd.Series([], index=[])
diff --git a/pandas/tests/series/conftest.py b/pandas/tests/series/conftest.py
index f5b401398d6d6..87aefec559311 100644
--- a/pandas/tests/series/conftest.py
+++ b/pandas/tests/series/conftest.py
@@ -1,16 +1,6 @@
 import pytest
 
-import pandas.util.testing as tm
-
-
-@pytest.fixture
-def datetime_series():
-    """
-    Fixture for Series of floats with DatetimeIndex
-    """
-    s = tm.makeTimeSeries()
-    s.name = "ts"
-    return s
+import pandas._testing as tm
 
 
 @pytest.fixture
@@ -26,7 +16,7 @@ def string_series():
 @pytest.fixture
 def object_series():
     """
-    Fixture for Series of dtype datetime64[ns] with Index of unique strings
+    Fixture for Series of dtype object with Index of unique strings
     """
     s = tm.makeObjectSeries()
     s.name = "objects"
diff --git a/pandas/tests/series/indexing/conftest.py b/pandas/tests/series/indexing/conftest.py
deleted file mode 100644
index 9c7103c196d60..0000000000000
--- a/pandas/tests/series/indexing/conftest.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import pytest
-
-from pandas.tests.series.common import TestData
-
-
-@pytest.fixture(scope="module")
-def test_data():
-    return TestData()
diff --git a/pandas/tests/series/indexing/test_alter_index.py b/pandas/tests/series/indexing/test_alter_index.py
index c93a000f5e7ce..05bd967903e9d 100644
--- a/pandas/tests/series/indexing/test_alter_index.py
+++ b/pandas/tests/series/indexing/test_alter_index.py
@@ -1,13 +1,11 @@
 from datetime import datetime
 
 import numpy as np
-from numpy import nan
 import pytest
 
 import pandas as pd
 from pandas import Categorical, Series, date_range, isna
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -20,9 +18,9 @@
     ],
 )
 @pytest.mark.parametrize("fill", [None, -1])
-def test_align(test_data, first_slice, second_slice, join_type, fill):
-    a = test_data.ts[slice(*first_slice)]
-    b = test_data.ts[slice(*second_slice)]
+def test_align(datetime_series, first_slice, second_slice, join_type, fill):
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
 
     aa, ab = a.align(b, join=join_type, fill_value=fill)
 
@@ -42,8 +40,8 @@ def test_align(test_data, first_slice, second_slice, join_type, fill):
         ea = ea.fillna(fill)
         eb = eb.fillna(fill)
 
-    assert_series_equal(aa, ea)
-    assert_series_equal(ab, eb)
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
     assert aa.name == "ts"
     assert ea.name == "ts"
     assert ab.name == "ts"
@@ -62,10 +60,10 @@ def test_align(test_data, first_slice, second_slice, join_type, fill):
 @pytest.mark.parametrize("method", ["pad", "bfill"])
 @pytest.mark.parametrize("limit", [None, 1])
 def test_align_fill_method(
-    test_data, first_slice, second_slice, join_type, method, limit
+    datetime_series, first_slice, second_slice, join_type, method, limit
 ):
-    a = test_data.ts[slice(*first_slice)]
-    b = test_data.ts[slice(*second_slice)]
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
 
     aa, ab = a.align(b, join=join_type, method=method, limit=limit)
 
@@ -76,48 +74,48 @@ def test_align_fill_method(
     ea = ea.fillna(method=method, limit=limit)
     eb = eb.fillna(method=method, limit=limit)
 
-    assert_series_equal(aa, ea)
-    assert_series_equal(ab, eb)
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
 
 
-def test_align_nocopy(test_data):
-    b = test_data.ts[:5].copy()
+def test_align_nocopy(datetime_series):
+    b = datetime_series[:5].copy()
 
     # do copy
-    a = test_data.ts.copy()
+    a = datetime_series.copy()
     ra, _ = a.align(b, join="left")
     ra[:5] = 5
     assert not (a[:5] == 5).any()
 
     # do not copy
-    a = test_data.ts.copy()
+    a = datetime_series.copy()
     ra, _ = a.align(b, join="left", copy=False)
     ra[:5] = 5
     assert (a[:5] == 5).all()
 
     # do copy
-    a = test_data.ts.copy()
-    b = test_data.ts[:5].copy()
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
     _, rb = a.align(b, join="right")
     rb[:3] = 5
     assert not (b[:3] == 5).any()
 
     # do not copy
-    a = test_data.ts.copy()
-    b = test_data.ts[:5].copy()
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
     _, rb = a.align(b, join="right", copy=False)
     rb[:2] = 5
     assert (b[:2] == 5).all()
 
 
-def test_align_same_index(test_data):
-    a, b = test_data.ts.align(test_data.ts, copy=False)
-    assert a.index is test_data.ts.index
-    assert b.index is test_data.ts.index
+def test_align_same_index(datetime_series):
+    a, b = datetime_series.align(datetime_series, copy=False)
+    assert a.index is datetime_series.index
+    assert b.index is datetime_series.index
 
-    a, b = test_data.ts.align(test_data.ts, copy=True)
-    assert a.index is not test_data.ts.index
-    assert b.index is not test_data.ts.index
+    a, b = datetime_series.align(datetime_series, copy=True)
+    assert a.index is not datetime_series.index
+    assert b.index is not datetime_series.index
 
 
 def test_align_multiindex():
@@ -155,55 +153,66 @@ def test_align_multiindex():
     tm.assert_series_equal(expr, res2l)
 
 
-def test_reindex(test_data):
-    identity = test_data.series.reindex(test_data.series.index)
+@pytest.mark.parametrize("method", ["backfill", "bfill", "pad", "ffill", None])
+def test_align_method(method):
+    # GH31788
+    ser = pd.Series(range(3), index=range(3))
+    df = pd.DataFrame(0.0, index=range(3), columns=range(3))
+
+    result_ser, result_df = ser.align(df, method=method)
+    tm.assert_series_equal(result_ser, ser)
+    tm.assert_frame_equal(result_df, df)
+
+
+def test_reindex(datetime_series, string_series):
+    identity = string_series.reindex(string_series.index)
 
     # __array_interface__ is not defined for older numpies
     # and on some pythons
     try:
-        assert np.may_share_memory(test_data.series.index, identity.index)
+        assert np.may_share_memory(string_series.index, identity.index)
     except AttributeError:
         pass
 
-    assert identity.index.is_(test_data.series.index)
-    assert identity.index.identical(test_data.series.index)
+    assert identity.index.is_(string_series.index)
+    assert identity.index.identical(string_series.index)
 
-    subIndex = test_data.series.index[10:20]
-    subSeries = test_data.series.reindex(subIndex)
+    subIndex = string_series.index[10:20]
+    subSeries = string_series.reindex(subIndex)
 
     for idx, val in subSeries.items():
-        assert val == test_data.series[idx]
+        assert val == string_series[idx]
 
-    subIndex2 = test_data.ts.index[10:20]
-    subTS = test_data.ts.reindex(subIndex2)
+    subIndex2 = datetime_series.index[10:20]
+    subTS = datetime_series.reindex(subIndex2)
 
     for idx, val in subTS.items():
-        assert val == test_data.ts[idx]
-    stuffSeries = test_data.ts.reindex(subIndex)
+        assert val == datetime_series[idx]
+    stuffSeries = datetime_series.reindex(subIndex)
 
     assert np.isnan(stuffSeries).all()
 
     # This is extremely important for the Cython code to not screw up
-    nonContigIndex = test_data.ts.index[::2]
-    subNonContig = test_data.ts.reindex(nonContigIndex)
+    nonContigIndex = datetime_series.index[::2]
+    subNonContig = datetime_series.reindex(nonContigIndex)
     for idx, val in subNonContig.items():
-        assert val == test_data.ts[idx]
+        assert val == datetime_series[idx]
 
     # return a copy the same index here
-    result = test_data.ts.reindex()
-    assert not (result is test_data.ts)
+    result = datetime_series.reindex()
+    assert not (result is datetime_series)
 
 
 def test_reindex_nan():
-    ts = Series([2, 3, 5, 7], index=[1, 4, nan, 8])
+    ts = Series([2, 3, 5, 7], index=[1, 4, np.nan, 8])
 
-    i, j = [nan, 1, nan, 8, 4, nan], [2, 0, 2, 3, 1, 2]
-    assert_series_equal(ts.reindex(i), ts.iloc[j])
+    i, j = [np.nan, 1, np.nan, 8, 4, np.nan], [2, 0, 2, 3, 1, 2]
+    tm.assert_series_equal(ts.reindex(i), ts.iloc[j])
 
     ts.index = ts.index.astype("object")
 
     # reindex coerces index.dtype to float, loc/iloc doesn't
-    assert_series_equal(ts.reindex(i), ts.iloc[j], check_index_type=False)
+    tm.assert_series_equal(ts.reindex(i), ts.iloc[j], check_index_type=False)
 
 
 def test_reindex_series_add_nat():
@@ -230,25 +239,26 @@ def test_reindex_with_datetimes():
     tm.assert_series_equal(result, expected)
 
 
-def test_reindex_corner(test_data):
+def test_reindex_corner(datetime_series):
     # (don't forget to fix this) I think it's fixed
-    test_data.empty.reindex(test_data.ts.index, method="pad")  # it works
+    empty = Series(dtype=object)
+    empty.reindex(datetime_series.index, method="pad")  # it works
 
     # corner case: pad empty series
-    reindexed = test_data.empty.reindex(test_data.ts.index, method="pad")
+    reindexed = empty.reindex(datetime_series.index, method="pad")
 
     # pass non-Index
-    reindexed = test_data.ts.reindex(list(test_data.ts.index))
-    assert_series_equal(test_data.ts, reindexed)
+    reindexed = datetime_series.reindex(list(datetime_series.index))
+    tm.assert_series_equal(datetime_series, reindexed)
 
     # bad fill method
-    ts = test_data.ts[::2]
+    ts = datetime_series[::2]
     msg = (
-        r"Invalid fill method\. Expecting pad \(ffill\), backfill"
-        r" \(bfill\) or nearest\. Got foo"
+        r"Invalid fill method\. Expecting pad \(ffill\), backfill "
+        r"\(bfill\) or nearest\. Got foo"
     )
     with pytest.raises(ValueError, match=msg):
-        ts.reindex(test_data.ts.index, method="foo")
+        ts.reindex(datetime_series.index, method="foo")
 
 
 def test_reindex_pad():
@@ -257,10 +267,10 @@ def test_reindex_pad():
 
     reindexed = s2.reindex(s.index, method="pad")
     reindexed2 = s2.reindex(s.index, method="ffill")
-    assert_series_equal(reindexed, reindexed2)
+    tm.assert_series_equal(reindexed, reindexed2)
 
     expected = Series([0, 0, 2, 2, 4, 4, 6, 6, 8, 8], index=np.arange(10))
-    assert_series_equal(reindexed, expected)
+    tm.assert_series_equal(reindexed, expected)
 
     # GH4604
     s = Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
@@ -269,27 +279,27 @@ def test_reindex_pad():
 
     # this changes dtype because the ffill happens after
     result = s.reindex(new_index).ffill()
-    assert_series_equal(result, expected.astype("float64"))
+    tm.assert_series_equal(result, expected.astype("float64"))
 
     result = s.reindex(new_index).ffill(downcast="infer")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     expected = Series([1, 5, 3, 5], index=new_index)
     result = s.reindex(new_index, method="ffill")
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # inference of new dtype
     s = Series([True, False, False, True], index=list("abcd"))
     new_index = "agc"
     result = s.reindex(list(new_index)).ffill()
     expected = Series([True, True, False], index=list(new_index))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # GH4618 shifted series downcasting
     s = Series(False, index=range(0, 5))
     result = s.shift(1).fillna(method="bfill")
     expected = Series(False, index=range(0, 5))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_reindex_nearest():
@@ -297,35 +307,35 @@ def test_reindex_nearest():
     target = [0.1, 0.9, 1.5, 2.0]
     actual = s.reindex(target, method="nearest")
     expected = Series(np.around(target).astype("int64"), target)
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
 
     actual = s.reindex_like(actual, method="nearest")
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
 
     actual = s.reindex_like(actual, method="nearest", tolerance=1)
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
     actual = s.reindex_like(actual, method="nearest", tolerance=[1, 2, 3, 4])
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
 
     actual = s.reindex(target, method="nearest", tolerance=0.2)
     expected = Series([0, 1, np.nan, 2], target)
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
 
     actual = s.reindex(target, method="nearest", tolerance=[0.3, 0.01, 0.4, 3])
     expected = Series([0, np.nan, np.nan, 2], target)
-    assert_series_equal(expected, actual)
+    tm.assert_series_equal(expected, actual)
 
 
 def test_reindex_backfill():
     pass
 
 
-def test_reindex_int(test_data):
-    ts = test_data.ts[::2]
+def test_reindex_int(datetime_series):
+    ts = datetime_series[::2]
     int_ts = Series(np.zeros(len(ts), dtype=int), index=ts.index)
 
     # this should work fine
-    reindexed_int = int_ts.reindex(test_data.ts.index)
+    reindexed_int = int_ts.reindex(datetime_series.index)
 
     # if NaNs introduced
     assert reindexed_int.dtype == np.float_
@@ -335,13 +345,13 @@ def test_reindex_int(test_data):
     assert reindexed_int.dtype == np.int_
 
 
-def test_reindex_bool(test_data):
+def test_reindex_bool(datetime_series):
     # A series other than float, int, string, or object
-    ts = test_data.ts[::2]
+    ts = datetime_series[::2]
     bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
 
     # this should work fine
-    reindexed_bool = bool_ts.reindex(test_data.ts.index)
+    reindexed_bool = bool_ts.reindex(datetime_series.index)
 
     # if NaNs introduced
     assert reindexed_bool.dtype == np.object_
@@ -351,11 +361,11 @@ def test_reindex_bool(test_data):
     assert reindexed_bool.dtype == np.bool_
 
 
-def test_reindex_bool_pad(test_data):
+def test_reindex_bool_pad(datetime_series):
     # fail
-    ts = test_data.ts[5:]
+    ts = datetime_series[5:]
     bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
-    filled_bool = bool_ts.reindex(test_data.ts.index, method="pad")
+    filled_bool = bool_ts.reindex(datetime_series.index, method="pad")
     assert isna(filled_bool[:5]).all()
 
 
@@ -383,10 +393,10 @@ def test_reindex_categorical():
     tm.assert_series_equal(result, expected)
 
 
-def test_reindex_like(test_data):
-    other = test_data.ts[::2]
-    assert_series_equal(
-        test_data.ts.reindex(other.index), test_data.ts.reindex_like(other)
+def test_reindex_like(datetime_series):
+    other = datetime_series[::2]
+    tm.assert_series_equal(
+        datetime_series.reindex(other.index), datetime_series.reindex_like(other)
     )
 
     # GH 7179
@@ -399,7 +409,7 @@ def test_reindex_like(test_data):
 
     result = series1.reindex_like(series2, method="pad")
     expected = Series([5, np.nan], index=[day1, day3])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_reindex_fill_value():
@@ -408,11 +418,11 @@ def test_reindex_fill_value():
     floats = Series([1.0, 2.0, 3.0])
     result = floats.reindex([1, 2, 3])
     expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = floats.reindex([1, 2, 3], fill_value=0)
     expected = Series([2.0, 3.0, 0], index=[1, 2, 3])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # -----------------------------------------------------------
     # ints
@@ -420,13 +430,13 @@ def test_reindex_fill_value():
 
     result = ints.reindex([1, 2, 3])
     expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # don't upcast
     result = ints.reindex([1, 2, 3], fill_value=0)
     expected = Series([2, 3, 0], index=[1, 2, 3])
     assert issubclass(result.dtype.type, np.integer)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # -----------------------------------------------------------
     # objects
@@ -434,11 +444,11 @@ def test_reindex_fill_value():
 
     result = objects.reindex([1, 2, 3])
     expected = Series([2, 3, np.nan], index=[1, 2, 3], dtype=object)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = objects.reindex([1, 2, 3], fill_value="foo")
     expected = Series([2, 3, "foo"], index=[1, 2, 3], dtype=object)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # ------------------------------------------------------------
     # bools
@@ -446,11 +456,11 @@ def test_reindex_fill_value():
 
     result = bools.reindex([1, 2, 3])
     expected = Series([False, True, np.nan], index=[1, 2, 3], dtype=object)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = bools.reindex([1, 2, 3], fill_value=False)
     expected = Series([False, True, False], index=[1, 2, 3])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_reindex_datetimeindexes_tz_naive_and_aware():
@@ -474,7 +484,7 @@ def test_rename():
     s = Series(range(1, 6), index=pd.Index(range(2, 7), name="IntIndex"))
     result = s.rename(str)
     expected = s.rename(lambda i: str(i))
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     assert result.name == expected.name
 
@@ -540,8 +550,9 @@ def test_drop_with_ignore_errors():
 def test_drop_empty_list(index, drop_labels):
     # GH 21494
     expected_index = [i for i in index if i not in drop_labels]
-    series = pd.Series(index=index).drop(drop_labels)
-    tm.assert_series_equal(series, pd.Series(index=expected_index))
+    series = pd.Series(index=index, dtype=object).drop(drop_labels)
+    expected = pd.Series(index=expected_index, dtype=object)
+    tm.assert_series_equal(series, expected)
 
 
 @pytest.mark.parametrize(
@@ -555,4 +566,5 @@ def test_drop_empty_list(index, drop_labels):
 def test_drop_non_empty_list(data, index, drop_labels):
     # GH 21494 and GH 16877
     with pytest.raises(KeyError, match="not found in axis"):
-        pd.Series(data=data, index=index).drop(drop_labels)
+        dtype = object if data is None else None
+        pd.Series(data=data, index=index, dtype=dtype).drop(drop_labels)
diff --git a/pandas/tests/series/indexing/test_boolean.py b/pandas/tests/series/indexing/test_boolean.py
index 01b4a3c84a565..28f3c0f7429f8 100644
--- a/pandas/tests/series/indexing/test_boolean.py
+++ b/pandas/tests/series/indexing/test_boolean.py
@@ -1,25 +1,21 @@
 import numpy as np
 import pytest
 
-from pandas.core.dtypes.common import is_integer
-
-import pandas as pd
-from pandas import Index, Series, Timestamp, date_range, isna
+from pandas import Index, Series
+import pandas._testing as tm
 from pandas.core.indexing import IndexingError
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
 
 from pandas.tseries.offsets import BDay
 
 
-def test_getitem_boolean(test_data):
-    s = test_data.series
+def test_getitem_boolean(string_series):
+    s = string_series
     mask = s > s.median()
 
     # passing list is OK
     result = s[list(mask)]
     expected = s[mask]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
     tm.assert_index_equal(result.index, s.index[mask])
 
 
@@ -35,18 +31,18 @@ def test_getitem_boolean_empty():
     s = Series(["A", "B"])
     expected = Series(np.nan, index=["C"], dtype=object)
     result = s[Series(["C"], dtype=object)]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     s = Series(["A", "B"])
     expected = Series(dtype=object, index=Index([], dtype="int64"))
     result = s[Series([], dtype=object)]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # invalid because of the boolean indexer
     # that's empty or not-aligned
     msg = (
-        r"Unalignable boolean Series provided as indexer \(index of"
-        r" the boolean Series and of the indexed object do not match"
+        r"Unalignable boolean Series provided as indexer \(index of "
+        r"the boolean Series and of the indexed object do not match"
     )
     with pytest.raises(IndexingError, match=msg):
         s[Series([], dtype=bool)]
@@ -55,43 +51,43 @@ def test_getitem_boolean_empty():
         s[Series([True], dtype=bool)]
 
 
-def test_getitem_boolean_object(test_data):
+def test_getitem_boolean_object(string_series):
     # using column from DataFrame
 
-    s = test_data.series
+    s = string_series
     mask = s > s.median()
     omask = mask.astype(object)
 
     # getitem
     result = s[omask]
     expected = s[mask]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # setitem
     s2 = s.copy()
     cop = s.copy()
     cop[omask] = 5
     s2[mask] = 5
-    assert_series_equal(cop, s2)
+    tm.assert_series_equal(cop, s2)
 
     # nans raise exception
     omask[5:10] = np.nan
-    msg = "cannot index with vector containing NA / NaN values"
+    msg = "cannot mask with array containing NA / NaN values"
     with pytest.raises(ValueError, match=msg):
         s[omask]
     with pytest.raises(ValueError, match=msg):
         s[omask] = 5
 
 
-def test_getitem_setitem_boolean_corner(test_data):
-    ts = test_data.ts
+def test_getitem_setitem_boolean_corner(datetime_series):
+    ts = datetime_series
     mask_shifted = ts.shift(1, freq=BDay()) > ts.median()
 
     # these used to raise...??
 
     msg = (
-        r"Unalignable boolean Series provided as indexer \(index of"
-        r" the boolean Series and of the indexed object do not match"
+        r"Unalignable boolean Series provided as indexer \(index of "
+        r"the boolean Series and of the indexed object do not match"
     )
     with pytest.raises(IndexingError, match=msg):
         ts[mask_shifted]
@@ -104,525 +100,36 @@ def test_getitem_setitem_boolean_corner(test_data):
         ts.loc[mask_shifted] = 1
 
 
-def test_setitem_boolean(test_data):
-    mask = test_data.series > test_data.series.median()
+def test_setitem_boolean(string_series):
+    mask = string_series > string_series.median()
 
     # similar indexed series
-    result = test_data.series.copy()
-    result[mask] = test_data.series * 2
-    expected = test_data.series * 2
-    assert_series_equal(result[mask], expected[mask])
+    result = string_series.copy()
+    result[mask] = string_series * 2
+    expected = string_series * 2
+    tm.assert_series_equal(result[mask], expected[mask])
 
     # needs alignment
-    result = test_data.series.copy()
-    result[mask] = (test_data.series * 2)[0:5]
-    expected = (test_data.series * 2)[0:5].reindex_like(test_data.series)
-    expected[-mask] = test_data.series[mask]
-    assert_series_equal(result[mask], expected[mask])
+    result = string_series.copy()
+    result[mask] = (string_series * 2)[0:5]
+    expected = (string_series * 2)[0:5].reindex_like(string_series)
+    expected[-mask] = string_series[mask]
+    tm.assert_series_equal(result[mask], expected[mask])
 
 
-def test_get_set_boolean_different_order(test_data):
-    ordered = test_data.series.sort_values()
+def test_get_set_boolean_different_order(string_series):
+    ordered = string_series.sort_values()
 
     # setting
-    copy = test_data.series.copy()
+    copy = string_series.copy()
     copy[ordered > 0] = 0
 
-    expected = test_data.series.copy()
+    expected = string_series.copy()
     expected[expected > 0] = 0
 
-    assert_series_equal(copy, expected)
+    tm.assert_series_equal(copy, expected)
 
     # getting
-    sel = test_data.series[ordered > 0]
-    exp = test_data.series[test_data.series > 0]
-    assert_series_equal(sel, exp)
-
-
-def test_where_unsafe_int(sint_dtype):
-    s = Series(np.arange(10), dtype=sint_dtype)
-    mask = s < 5
-
-    s[mask] = range(2, 7)
-    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype=sint_dtype)
-
-    assert_series_equal(s, expected)
-
-
-def test_where_unsafe_float(float_dtype):
-    s = Series(np.arange(10), dtype=float_dtype)
-    mask = s < 5
-
-    s[mask] = range(2, 7)
-    data = list(range(2, 7)) + list(range(5, 10))
-    expected = Series(data, dtype=float_dtype)
-
-    assert_series_equal(s, expected)
-
-
-@pytest.mark.parametrize(
-    "dtype,expected_dtype",
-    [
-        (np.int8, np.float64),
-        (np.int16, np.float64),
-        (np.int32, np.float64),
-        (np.int64, np.float64),
-        (np.float32, np.float32),
-        (np.float64, np.float64),
-    ],
-)
-def test_where_unsafe_upcast(dtype, expected_dtype):
-    # see gh-9743
-    s = Series(np.arange(10), dtype=dtype)
-    values = [2.5, 3.5, 4.5, 5.5, 6.5]
-    mask = s < 5
-    expected = Series(values + list(range(5, 10)), dtype=expected_dtype)
-    s[mask] = values
-    assert_series_equal(s, expected)
-
-
-def test_where_unsafe():
-    # see gh-9731
-    s = Series(np.arange(10), dtype="int64")
-    values = [2.5, 3.5, 4.5, 5.5]
-
-    mask = s > 5
-    expected = Series(list(range(6)) + values, dtype="float64")
-
-    s[mask] = values
-    assert_series_equal(s, expected)
-
-    # see gh-3235
-    s = Series(np.arange(10), dtype="int64")
-    mask = s < 5
-    s[mask] = range(2, 7)
-    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype="int64")
-    assert_series_equal(s, expected)
-    assert s.dtype == expected.dtype
-
-    s = Series(np.arange(10), dtype="int64")
-    mask = s > 5
-    s[mask] = [0] * 4
-    expected = Series([0, 1, 2, 3, 4, 5] + [0] * 4, dtype="int64")
-    assert_series_equal(s, expected)
-
-    s = Series(np.arange(10))
-    mask = s > 5
-
-    msg = "cannot assign mismatch length to masked array"
-    with pytest.raises(ValueError, match=msg):
-        s[mask] = [5, 4, 3, 2, 1]
-
-    with pytest.raises(ValueError, match=msg):
-        s[mask] = [0] * 5
-
-    # dtype changes
-    s = Series([1, 2, 3, 4])
-    result = s.where(s > 2, np.nan)
-    expected = Series([np.nan, np.nan, 3, 4])
-    assert_series_equal(result, expected)
-
-    # GH 4667
-    # setting with None changes dtype
-    s = Series(range(10)).astype(float)
-    s[8] = None
-    result = s[8]
-    assert isna(result)
-
-    s = Series(range(10)).astype(float)
-    s[s > 8] = None
-    result = s[isna(s)]
-    expected = Series(np.nan, index=[9])
-    assert_series_equal(result, expected)
-
-
-def test_where():
-    s = Series(np.random.randn(5))
-    cond = s > 0
-
-    rs = s.where(cond).dropna()
-    rs2 = s[cond]
-    assert_series_equal(rs, rs2)
-
-    rs = s.where(cond, -s)
-    assert_series_equal(rs, s.abs())
-
-    rs = s.where(cond)
-    assert s.shape == rs.shape
-    assert rs is not s
-
-    # test alignment
-    cond = Series([True, False, False, True, False], index=s.index)
-    s2 = -(s.abs())
-
-    expected = s2[cond].reindex(s2.index[:3]).reindex(s2.index)
-    rs = s2.where(cond[:3])
-    assert_series_equal(rs, expected)
-
-    expected = s2.abs()
-    expected.iloc[0] = s2[0]
-    rs = s2.where(cond[:3], -s2)
-    assert_series_equal(rs, expected)
-
-
-def test_where_error():
-    s = Series(np.random.randn(5))
-    cond = s > 0
-
-    msg = "Array conditional must be same shape as self"
-    with pytest.raises(ValueError, match=msg):
-        s.where(1)
-    with pytest.raises(ValueError, match=msg):
-        s.where(cond[:3].values, -s)
-
-    # GH 2745
-    s = Series([1, 2])
-    s[[True, False]] = [0, 1]
-    expected = Series([0, 2])
-    assert_series_equal(s, expected)
-
-    # failures
-    msg = "cannot assign mismatch length to masked array"
-    with pytest.raises(ValueError, match=msg):
-        s[[True, False]] = [0, 2, 3]
-    msg = (
-        "NumPy boolean array indexing assignment cannot assign 0 input"
-        " values to the 1 output values where the mask is true"
-    )
-    with pytest.raises(ValueError, match=msg):
-        s[[True, False]] = []
-
-
-@pytest.mark.parametrize("klass", [list, tuple, np.array, Series])
-def test_where_array_like(klass):
-    # see gh-15414
-    s = Series([1, 2, 3])
-    cond = [False, True, True]
-    expected = Series([np.nan, 2, 3])
-
-    result = s.where(klass(cond))
-    assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize(
-    "cond",
-    [
-        [1, 0, 1],
-        Series([2, 5, 7]),
-        ["True", "False", "True"],
-        [Timestamp("2017-01-01"), pd.NaT, Timestamp("2017-01-02")],
-    ],
-)
-def test_where_invalid_input(cond):
-    # see gh-15414: only boolean arrays accepted
-    s = Series([1, 2, 3])
-    msg = "Boolean array expected for the condition"
-
-    with pytest.raises(ValueError, match=msg):
-        s.where(cond)
-
-    msg = "Array conditional must be same shape as self"
-    with pytest.raises(ValueError, match=msg):
-        s.where([True])
-
-
-def test_where_ndframe_align():
-    msg = "Array conditional must be same shape as self"
-    s = Series([1, 2, 3])
-
-    cond = [True]
-    with pytest.raises(ValueError, match=msg):
-        s.where(cond)
-
-    expected = Series([1, np.nan, np.nan])
-
-    out = s.where(Series(cond))
-    tm.assert_series_equal(out, expected)
-
-    cond = np.array([False, True, False, True])
-    with pytest.raises(ValueError, match=msg):
-        s.where(cond)
-
-    expected = Series([np.nan, 2, np.nan])
-
-    out = s.where(Series(cond))
-    tm.assert_series_equal(out, expected)
-
-
-def test_where_setitem_invalid():
-    # GH 2702
-    # make sure correct exceptions are raised on invalid list assignment
-
-    msg = "cannot set using a {} indexer with a different length than the value"
-
-    # slice
-    s = Series(list("abc"))
-
-    with pytest.raises(ValueError, match=msg.format("slice")):
-        s[0:3] = list(range(27))
-
-    s[0:3] = list(range(3))
-    expected = Series([0, 1, 2])
-    assert_series_equal(s.astype(np.int64), expected)
-
-    # slice with step
-    s = Series(list("abcdef"))
-
-    with pytest.raises(ValueError, match=msg.format("slice")):
-        s[0:4:2] = list(range(27))
-
-    s = Series(list("abcdef"))
-    s[0:4:2] = list(range(2))
-    expected = Series([0, "b", 1, "d", "e", "f"])
-    assert_series_equal(s, expected)
-
-    # neg slices
-    s = Series(list("abcdef"))
-
-    with pytest.raises(ValueError, match=msg.format("slice")):
-        s[:-1] = list(range(27))
-
-    s[-3:-1] = list(range(2))
-    expected = Series(["a", "b", "c", 0, 1, "f"])
-    assert_series_equal(s, expected)
-
-    # list
-    s = Series(list("abc"))
-
-    with pytest.raises(ValueError, match=msg.format("list-like")):
-        s[[0, 1, 2]] = list(range(27))
-
-    s = Series(list("abc"))
-
-    with pytest.raises(ValueError, match=msg.format("list-like")):
-        s[[0, 1, 2]] = list(range(2))
-
-    # scalar
-    s = Series(list("abc"))
-    s[0] = list(range(10))
-    expected = Series([list(range(10)), "b", "c"])
-    assert_series_equal(s, expected)
-
-
-@pytest.mark.parametrize("size", range(2, 6))
-@pytest.mark.parametrize(
-    "mask", [[True, False, False, False, False], [True, False], [False]]
-)
-@pytest.mark.parametrize(
-    "item", [2.0, np.nan, np.finfo(np.float).max, np.finfo(np.float).min]
-)
-# Test numpy arrays, lists and tuples as the input to be
-# broadcast
-@pytest.mark.parametrize(
-    "box", [lambda x: np.array([x]), lambda x: [x], lambda x: (x,)]
-)
-def test_broadcast(size, mask, item, box):
-    selection = np.resize(mask, size)
-
-    data = np.arange(size, dtype=float)
-
-    # Construct the expected series by taking the source
-    # data or item based on the selection
-    expected = Series(
-        [item if use_item else data[i] for i, use_item in enumerate(selection)]
-    )
-
-    s = Series(data)
-    s[selection] = box(item)
-    assert_series_equal(s, expected)
-
-    s = Series(data)
-    result = s.where(~selection, box(item))
-    assert_series_equal(result, expected)
-
-    s = Series(data)
-    result = s.mask(selection, box(item))
-    assert_series_equal(result, expected)
-
-
-def test_where_inplace():
-    s = Series(np.random.randn(5))
-    cond = s > 0
-
-    rs = s.copy()
-
-    rs.where(cond, inplace=True)
-    assert_series_equal(rs.dropna(), s[cond])
-    assert_series_equal(rs, s.where(cond))
-
-    rs = s.copy()
-    rs.where(cond, -s, inplace=True)
-    assert_series_equal(rs, s.where(cond, -s))
-
-
-def test_where_dups():
-    # GH 4550
-    # where crashes with dups in index
-    s1 = Series(list(range(3)))
-    s2 = Series(list(range(3)))
-    comb = pd.concat([s1, s2])
-    result = comb.where(comb < 2)
-    expected = Series([0, 1, np.nan, 0, 1, np.nan], index=[0, 1, 2, 0, 1, 2])
-    assert_series_equal(result, expected)
-
-    # GH 4548
-    # inplace updating not working with dups
-    comb[comb < 1] = 5
-    expected = Series([5, 1, 2, 5, 1, 2], index=[0, 1, 2, 0, 1, 2])
-    assert_series_equal(comb, expected)
-
-    comb[comb < 2] += 10
-    expected = Series([5, 11, 2, 5, 11, 2], index=[0, 1, 2, 0, 1, 2])
-    assert_series_equal(comb, expected)
-
-
-def test_where_numeric_with_string():
-    # GH 9280
-    s = pd.Series([1, 2, 3])
-    w = s.where(s > 1, "X")
-
-    assert not is_integer(w[0])
-    assert is_integer(w[1])
-    assert is_integer(w[2])
-    assert isinstance(w[0], str)
-    assert w.dtype == "object"
-
-    w = s.where(s > 1, ["X", "Y", "Z"])
-    assert not is_integer(w[0])
-    assert is_integer(w[1])
-    assert is_integer(w[2])
-    assert isinstance(w[0], str)
-    assert w.dtype == "object"
-
-    w = s.where(s > 1, np.array(["X", "Y", "Z"]))
-    assert not is_integer(w[0])
-    assert is_integer(w[1])
-    assert is_integer(w[2])
-    assert isinstance(w[0], str)
-    assert w.dtype == "object"
-
-
-def test_where_timedelta_coerce():
-    s = Series([1, 2], dtype="timedelta64[ns]")
-    expected = Series([10, 10])
-    mask = np.array([False, False])
-
-    rs = s.where(mask, [10, 10])
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, 10)
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, 10.0)
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, [10.0, 10.0])
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, [10.0, np.nan])
-    expected = Series([10, None], dtype="object")
-    assert_series_equal(rs, expected)
-
-
-def test_where_datetime_conversion():
-    s = Series(date_range("20130102", periods=2))
-    expected = Series([10, 10])
-    mask = np.array([False, False])
-
-    rs = s.where(mask, [10, 10])
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, 10)
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, 10.0)
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, [10.0, 10.0])
-    assert_series_equal(rs, expected)
-
-    rs = s.where(mask, [10.0, np.nan])
-    expected = Series([10, None], dtype="object")
-    assert_series_equal(rs, expected)
-
-    # GH 15701
-    timestamps = ["2016-12-31 12:00:04+00:00", "2016-12-31 12:00:04.010000+00:00"]
-    s = Series([pd.Timestamp(t) for t in timestamps])
-    rs = s.where(Series([False, True]))
-    expected = Series([pd.NaT, s[1]])
-    assert_series_equal(rs, expected)
-
-
-def test_where_dt_tz_values(tz_naive_fixture):
-    ser1 = pd.Series(
-        pd.DatetimeIndex(["20150101", "20150102", "20150103"], tz=tz_naive_fixture)
-    )
-    ser2 = pd.Series(
-        pd.DatetimeIndex(["20160514", "20160515", "20160516"], tz=tz_naive_fixture)
-    )
-    mask = pd.Series([True, True, False])
-    result = ser1.where(mask, ser2)
-    exp = pd.Series(
-        pd.DatetimeIndex(["20150101", "20150102", "20160516"], tz=tz_naive_fixture)
-    )
-    assert_series_equal(exp, result)
-
-
-def test_mask():
-    # compare with tested results in test_where
-    s = Series(np.random.randn(5))
-    cond = s > 0
-
-    rs = s.where(~cond, np.nan)
-    assert_series_equal(rs, s.mask(cond))
-
-    rs = s.where(~cond)
-    rs2 = s.mask(cond)
-    assert_series_equal(rs, rs2)
-
-    rs = s.where(~cond, -s)
-    rs2 = s.mask(cond, -s)
-    assert_series_equal(rs, rs2)
-
-    cond = Series([True, False, False, True, False], index=s.index)
-    s2 = -(s.abs())
-    rs = s2.where(~cond[:3])
-    rs2 = s2.mask(cond[:3])
-    assert_series_equal(rs, rs2)
-
-    rs = s2.where(~cond[:3], -s2)
-    rs2 = s2.mask(cond[:3], -s2)
-    assert_series_equal(rs, rs2)
-
-    msg = "Array conditional must be same shape as self"
-    with pytest.raises(ValueError, match=msg):
-        s.mask(1)
-    with pytest.raises(ValueError, match=msg):
-        s.mask(cond[:3].values, -s)
-
-    # dtype changes
-    s = Series([1, 2, 3, 4])
-    result = s.mask(s > 2, np.nan)
-    expected = Series([1, 2, np.nan, np.nan])
-    assert_series_equal(result, expected)
-
-    # see gh-21891
-    s = Series([1, 2])
-    res = s.mask([True, False])
-
-    exp = Series([np.nan, 2])
-    tm.assert_series_equal(res, exp)
-
-
-def test_mask_inplace():
-    s = Series(np.random.randn(5))
-    cond = s > 0
-
-    rs = s.copy()
-    rs.mask(cond, inplace=True)
-    assert_series_equal(rs.dropna(), s[~cond])
-    assert_series_equal(rs, s.mask(cond))
-
-    rs = s.copy()
-    rs.mask(cond, -s, inplace=True)
-    assert_series_equal(rs, s.mask(cond, -s))
+    sel = string_series[ordered > 0]
+    exp = string_series[string_series > 0]
+    tm.assert_series_equal(sel, exp)
diff --git a/pandas/tests/series/indexing/test_callable.py b/pandas/tests/series/indexing/test_callable.py
index 2d879eed967e5..fe575cf146641 100644
--- a/pandas/tests/series/indexing/test_callable.py
+++ b/pandas/tests/series/indexing/test_callable.py
@@ -1,5 +1,5 @@
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_getitem_callable():
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index bf8d34cd62ff2..fc9d4ec5290a5 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta
+import re
 
 import numpy as np
 import pytest
@@ -8,12 +9,7 @@
 
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex, NaT, Series, Timestamp, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
+import pandas._testing as tm
 
 
 """
@@ -35,7 +31,7 @@ def test_fancy_getitem():
     assert s[Timestamp(datetime(2009, 1, 2))] == 48
     with pytest.raises(KeyError, match=r"^'2009-1-3'$"):
         s["2009-1-3"]
-    assert_series_equal(
+    tm.assert_series_equal(
         s["3/6/2009":"2009-06-05"], s[datetime(2009, 3, 6) : datetime(2009, 6, 5)]
     )
 
@@ -54,46 +50,13 @@ def test_fancy_setitem():
     assert (s[48:54] == -3).all()
 
 
-@pytest.mark.filterwarnings("ignore::DeprecationWarning")
-@pytest.mark.parametrize("tz", [None, "Asia/Shanghai", "Europe/Berlin"])
-@pytest.mark.parametrize("name", [None, "my_dti"])
-def test_dti_snap(name, tz):
-    dti = DatetimeIndex(
-        [
-            "1/1/2002",
-            "1/2/2002",
-            "1/3/2002",
-            "1/4/2002",
-            "1/5/2002",
-            "1/6/2002",
-            "1/7/2002",
-        ],
-        name=name,
-        tz=tz,
-        freq="D",
-    )
-
-    result = dti.snap(freq="W-MON")
-    expected = date_range("12/31/2001", "1/7/2002", name=name, tz=tz, freq="w-mon")
-    expected = expected.repeat([3, 4])
-    tm.assert_index_equal(result, expected)
-    assert result.tz == expected.tz
-
-    result = dti.snap(freq="B")
-
-    expected = date_range("1/1/2002", "1/7/2002", name=name, tz=tz, freq="b")
-    expected = expected.repeat([1, 1, 1, 2, 2])
-    tm.assert_index_equal(result, expected)
-    assert result.tz == expected.tz
-
-
 def test_dti_reset_index_round_trip():
     dti = date_range(start="1/1/2001", end="6/1/2001", freq="D")
     d1 = DataFrame({"v": np.random.rand(len(dti))}, index=dti)
     d2 = d1.reset_index()
     assert d2.dtypes[0] == np.dtype("M8[ns]")
     d3 = d2.set_index("index")
-    assert_frame_equal(d1, d3, check_names=False)
+    tm.assert_frame_equal(d1, d3, check_names=False)
 
     # #2329
     stamp = datetime(2012, 11, 22)
@@ -110,17 +73,13 @@ def test_series_set_value():
     dates = [datetime(2001, 1, 1), datetime(2001, 1, 2)]
     index = DatetimeIndex(dates)
 
-    s = Series()._set_value(dates[0], 1.0)
-    s2 = s._set_value(dates[1], np.nan)
+    s = Series(dtype=object)
+    s._set_value(dates[0], 1.0)
+    s._set_value(dates[1], np.nan)
 
     expected = Series([1.0, np.nan], index=index)
 
-    assert_series_equal(s2, expected)
-
-    # FIXME: dont leave commented-out
-    # s = Series(index[:1], index[:1])
-    # s2 = s._set_value(dates[1], index[1])
-    # assert s2.values.dtype == 'M8[ns]'
+    tm.assert_series_equal(s, expected)
 
 
 @pytest.mark.slow
@@ -139,17 +98,17 @@ def test_slicing_datetimes():
         index=[datetime(2001, 1, i, 10, 00) for i in [1, 2, 3, 4]],
     )
     result = df.loc[datetime(2001, 1, 1, 10) :]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
     result = df.loc[: datetime(2001, 1, 4, 10)]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
     result = df.loc[datetime(2001, 1, 1, 10) : datetime(2001, 1, 4, 10)]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
 
     result = df.loc[datetime(2001, 1, 1, 11) :]
     expected = df.iloc[1:]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
     result = df.loc["20010101 11":]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
     # duplicates
     df = pd.DataFrame(
@@ -158,17 +117,17 @@ def test_slicing_datetimes():
     )
 
     result = df.loc[datetime(2001, 1, 1, 10) :]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
     result = df.loc[: datetime(2001, 1, 4, 10)]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
     result = df.loc[datetime(2001, 1, 1, 10) : datetime(2001, 1, 4, 10)]
-    assert_frame_equal(result, df)
+    tm.assert_frame_equal(result, df)
 
     result = df.loc[datetime(2001, 1, 1, 11) :]
     expected = df.iloc[1:]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
     result = df.loc["20010101 11":]
-    assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected)
 
 
 def test_frame_datetime64_duplicated():
@@ -185,7 +144,6 @@ def test_frame_datetime64_duplicated():
 
 def test_getitem_setitem_datetime_tz_pytz():
     from pytz import timezone as tz
-    from pandas import date_range
 
     N = 50
     # testing with timezone, GH #2785
@@ -196,18 +154,18 @@ def test_getitem_setitem_datetime_tz_pytz():
     result = ts.copy()
     result["1990-01-01 09:00:00+00:00"] = 0
     result["1990-01-01 09:00:00+00:00"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts.copy()
     result["1990-01-01 03:00:00-06:00"] = 0
     result["1990-01-01 03:00:00-06:00"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     # repeat with datetimes
     result = ts.copy()
     result[datetime(1990, 1, 1, 9, tzinfo=tz("UTC"))] = 0
     result[datetime(1990, 1, 1, 9, tzinfo=tz("UTC"))] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts.copy()
 
@@ -215,7 +173,7 @@ def test_getitem_setitem_datetime_tz_pytz():
     date = tz("US/Central").localize(datetime(1990, 1, 1, 3))
     result[date] = 0
     result[date] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
 
 def test_getitem_setitem_datetime_tz_dateutil():
@@ -226,8 +184,6 @@ def test_getitem_setitem_datetime_tz_dateutil():
         lambda x: tzutc() if x == "UTC" else gettz(x)
     )  # handle special case for utc in dateutil
 
-    from pandas import date_range
-
     N = 50
 
     # testing with timezone, GH #2785
@@ -238,23 +194,23 @@ def test_getitem_setitem_datetime_tz_dateutil():
     result = ts.copy()
     result["1990-01-01 09:00:00+00:00"] = 0
     result["1990-01-01 09:00:00+00:00"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts.copy()
     result["1990-01-01 03:00:00-06:00"] = 0
     result["1990-01-01 03:00:00-06:00"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     # repeat with datetimes
     result = ts.copy()
     result[datetime(1990, 1, 1, 9, tzinfo=tz("UTC"))] = 0
     result[datetime(1990, 1, 1, 9, tzinfo=tz("UTC"))] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts.copy()
     result[datetime(1990, 1, 1, 3, tzinfo=tz("America/Chicago"))] = 0
     result[datetime(1990, 1, 1, 3, tzinfo=tz("America/Chicago"))] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
 
 def test_getitem_setitem_datetimeindex():
@@ -270,29 +226,29 @@ def test_getitem_setitem_datetimeindex():
     result = ts.copy()
     result["1990-01-01 04:00:00"] = 0
     result["1990-01-01 04:00:00"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts["1990-01-01 04:00:00":"1990-01-01 07:00:00"]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = 0
     result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = ts[4:8]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     lb = "1990-01-01 04:00:00"
     rb = "1990-01-01 07:00:00"
     # GH#18435 strings get a pass from tzawareness compat
     result = ts[(ts.index >= lb) & (ts.index <= rb)]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     lb = "1990-01-01 04:00:00-0500"
     rb = "1990-01-01 07:00:00-0500"
     result = ts[(ts.index >= lb) & (ts.index <= rb)]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # repeat all the above with naive datetimes
     result = ts[datetime(1990, 1, 1, 4)]
@@ -302,16 +258,16 @@ def test_getitem_setitem_datetimeindex():
     result = ts.copy()
     result[datetime(1990, 1, 1, 4)] = 0
     result[datetime(1990, 1, 1, 4)] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts[datetime(1990, 1, 1, 4) : datetime(1990, 1, 1, 7)]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result[datetime(1990, 1, 1, 4) : datetime(1990, 1, 1, 7)] = 0
     result[datetime(1990, 1, 1, 4) : datetime(1990, 1, 1, 7)] = ts[4:8]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     lb = datetime(1990, 1, 1, 4)
     rb = datetime(1990, 1, 1, 7)
@@ -325,7 +281,7 @@ def test_getitem_setitem_datetimeindex():
     rb = pd.Timestamp(datetime(1990, 1, 1, 7)).tz_localize(rng.tzinfo)
     result = ts[(ts.index >= lb) & (ts.index <= rb)]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts[ts.index[4]]
     expected = ts[4]
@@ -333,22 +289,22 @@ def test_getitem_setitem_datetimeindex():
 
     result = ts[ts.index[4:8]]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result[ts.index[4:8]] = 0
     result[4:8] = ts[4:8]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     # also test partial date slicing
     result = ts["1990-01-02"]
     expected = ts[24:48]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result["1990-01-02"] = 0
     result["1990-01-02"] = ts[24:48]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
 
 def test_getitem_setitem_periodindex():
@@ -365,22 +321,22 @@ def test_getitem_setitem_periodindex():
     result = ts.copy()
     result["1990-01-01 04"] = 0
     result["1990-01-01 04"] = ts[4]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     result = ts["1990-01-01 04":"1990-01-01 07"]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result["1990-01-01 04":"1990-01-01 07"] = 0
     result["1990-01-01 04":"1990-01-01 07"] = ts[4:8]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
     lb = "1990-01-01 04"
     rb = "1990-01-01 07"
     result = ts[(ts.index >= lb) & (ts.index <= rb)]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # GH 2782
     result = ts[ts.index[4]]
@@ -389,12 +345,12 @@ def test_getitem_setitem_periodindex():
 
     result = ts[ts.index[4:8]]
     expected = ts[4:8]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts.copy()
     result[ts.index[4:8]] = 0
     result[4:8] = ts[4:8]
-    assert_series_equal(result, ts)
+    tm.assert_series_equal(result, ts)
 
 
 # FutureWarning from NumPy.
@@ -404,13 +360,14 @@ def test_getitem_median_slice_bug():
     s = Series(np.random.randn(13), index=index)
 
     indexer = [slice(6, 7, None)]
-    result = s[indexer]
+    with tm.assert_produces_warning(FutureWarning):
+        # GH#31299
+        result = s[indexer]
     expected = s[indexer[0]]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_datetime_indexing():
-    from pandas import date_range
 
     index = date_range("1/1/2000", "1/7/2000")
     index = index.repeat(3)
@@ -418,7 +375,7 @@ def test_datetime_indexing():
     s = Series(len(index), index=index)
     stamp = Timestamp("1/8/2000")
 
-    with pytest.raises(KeyError, match=r"^947289600000000000$"):
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
         s[stamp]
     s[stamp] = 0
     assert s[stamp] == 0
@@ -427,7 +384,7 @@ def test_datetime_indexing():
     s = Series(len(index), index=index)
     s = s[::-1]
 
-    with pytest.raises(KeyError, match=r"^947289600000000000$"):
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
         s[stamp]
     s[stamp] = 0
     assert s[stamp] == 0
@@ -524,17 +481,18 @@ def test_duplicate_dates_indexing(dups):
         total = (ts.index == date).sum()
         expected = ts[mask]
         if total > 1:
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
         else:
-            assert_almost_equal(result, expected[0])
+            tm.assert_almost_equal(result, expected[0])
 
         cp = ts.copy()
         cp[date] = 0
         expected = Series(np.where(mask, 0, ts), index=ts.index)
-        assert_series_equal(cp, expected)
+        tm.assert_series_equal(cp, expected)
 
-    with pytest.raises(KeyError, match=r"^947116800000000000$"):
-        ts[datetime(2000, 1, 6)]
+    key = datetime(2000, 1, 6)
+    with pytest.raises(KeyError, match=re.escape(repr(key))):
+        ts[key]
 
     # new index
     ts[datetime(2000, 1, 6)] = 0
@@ -548,17 +506,17 @@ def test_range_slice():
 
     result = ts["1/2/2000":]
     expected = ts[1:]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = ts["1/2/2000":"1/3/2000"]
     expected = ts[1:4]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_groupby_average_dup_values(dups):
     result = dups.groupby(level=0).mean()
     expected = dups.groupby(dups.index).mean()
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_indexing_over_size_cutoff():
@@ -642,7 +600,7 @@ def compare(slobj):
         result = ts2[slobj].copy()
         result = result.sort_index()
         expected = ts[slobj]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     compare(slice("2011-01-01", "2011-01-15"))
     compare(slice("2010-12-30", "2011-01-15"))
@@ -656,7 +614,7 @@ def compare(slobj):
     # single values
     result = ts2["2011"].sort_index()
     expected = ts["2011"]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # diff freq
     rng = date_range(datetime(2005, 1, 1), periods=20, freq="M")
@@ -680,7 +638,7 @@ def test_indexing():
 
     df = DataFrame(dict(A=ts))
     result = df["2001"]["A"]
-    assert_series_equal(expected, result)
+    tm.assert_series_equal(expected, result)
 
     # setting
     ts["2001"] = 1
@@ -690,18 +648,18 @@ def test_indexing():
     df.loc["2001", "A"] = 1
 
     result = df["2001"]["A"]
-    assert_series_equal(expected, result)
+    tm.assert_series_equal(expected, result)
 
     # GH3546 (not including times on the last day)
     idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:00", freq="H")
     ts = Series(range(len(idx)), index=idx)
     expected = ts["2013-05"]
-    assert_series_equal(expected, ts)
+    tm.assert_series_equal(expected, ts)
 
     idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:59", freq="S")
     ts = Series(range(len(idx)), index=idx)
     expected = ts["2013-05"]
-    assert_series_equal(expected, ts)
+    tm.assert_series_equal(expected, ts)
 
     idx = [
         Timestamp("2013-05-31 00:00"),
@@ -709,7 +667,7 @@ def test_indexing():
     ]
     ts = Series(range(len(idx)), index=idx)
     expected = ts["2013"]
-    assert_series_equal(expected, ts)
+    tm.assert_series_equal(expected, ts)
 
     # GH14826, indexing with a seconds resolution string / datetime object
     df = DataFrame(
@@ -756,16 +714,6 @@ def test_nat_operations():
     assert s.max() == exp
 
 
-@pytest.mark.parametrize("method", ["round", "floor", "ceil"])
-@pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
-def test_round_nat(method, freq):
-    # GH14940
-    s = Series([pd.NaT])
-    expected = Series(pd.NaT)
-    round_method = getattr(s.dt, method)
-    assert_series_equal(round_method(freq), expected)
-
-
 def test_setitem_tuple_with_datetimetz():
     # GH 20441
     arr = date_range("2017", periods=4, tz="US/Eastern")
@@ -774,4 +722,4 @@ def test_setitem_tuple_with_datetimetz():
     expected = result.copy()
     result[(0, 1)] = np.nan
     expected.iloc[0] = np.nan
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/indexing/test_get.py b/pandas/tests/series/indexing/test_get.py
new file mode 100644
index 0000000000000..438b61ed203a3
--- /dev/null
+++ b/pandas/tests/series/indexing/test_get.py
@@ -0,0 +1,134 @@
+import numpy as np
+
+import pandas as pd
+from pandas import Series
+
+
+def test_get():
+    # GH 6383
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        )
+    )
+
+    result = s.get(25, 0)
+    expected = 0
+    assert result == expected
+
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        ),
+        index=pd.Float64Index(
+            [
+                25.0,
+                36.0,
+                49.0,
+                64.0,
+                81.0,
+                100.0,
+                121.0,
+                144.0,
+                169.0,
+                196.0,
+                1225.0,
+                1296.0,
+                1369.0,
+                1444.0,
+                1521.0,
+                1600.0,
+                1681.0,
+                1764.0,
+                1849.0,
+                1936.0,
+            ]
+        ),
+    )
+
+    result = s.get(25, 0)
+    expected = 43
+    assert result == expected
+
+    # GH 7407
+    # with a boolean accessor
+    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
+    vc = df.i.value_counts()
+    result = vc.get(99, default="Missing")
+    assert result == "Missing"
+
+    vc = df.b.value_counts()
+    result = vc.get(False, default="Missing")
+    assert result == 3
+
+    result = vc.get(True, default="Missing")
+    assert result == "Missing"
+
+
+def test_get_nan():
+    # GH 8569
+    s = pd.Float64Index(range(10)).to_series()
+    assert s.get(np.nan) is None
+    assert s.get(np.nan, default="Missing") == "Missing"
+
+
+def test_get_nan_multiple():
+    # GH 8569
+    # ensure that fixing "test_get_nan" above hasn't broken get
+    # with multiple elements
+    s = pd.Float64Index(range(10)).to_series()
+
+    idx = [2, 30]
+    assert s.get(idx) is None
+
+    idx = [2, np.nan]
+    assert s.get(idx) is None
+
+    # GH 17295 - all missing keys
+    idx = [20, 30]
+    assert s.get(idx) is None
+
+    idx = [np.nan, np.nan]
+    assert s.get(idx) is None
diff --git a/pandas/tests/series/indexing/test_iloc.py b/pandas/tests/series/indexing/test_iloc.py
index 199f57f6e0764..f276eb5b0b23d 100644
--- a/pandas/tests/series/indexing/test_iloc.py
+++ b/pandas/tests/series/indexing/test_iloc.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from pandas import Series
-from pandas.util.testing import assert_almost_equal, assert_series_equal
+import pandas._testing as tm
 
 
 def test_iloc():
@@ -10,12 +10,12 @@ def test_iloc():
     for i in range(len(s)):
         result = s.iloc[i]
         exp = s[s.index[i]]
-        assert_almost_equal(result, exp)
+        tm.assert_almost_equal(result, exp)
 
     # pass a slice
     result = s.iloc[slice(1, 3)]
     expected = s.loc[2:4]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # test slice is a view
     result[:] = 0
@@ -24,7 +24,7 @@ def test_iloc():
     # list of integers
     result = s.iloc[[0, 2, 3, 4, 5]]
     expected = s.reindex(s.index[[0, 2, 3, 4, 5]])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_iloc_nonunique():
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index f50b3ddbce7dc..18fcbea683dd3 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -9,8 +9,7 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, MultiIndex, Series, Timedelta, Timestamp
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 from pandas.tseries.offsets import BDay
 
@@ -18,10 +17,9 @@
 def test_basic_indexing():
     s = Series(np.random.randn(5), index=["a", "b", "a", "a", "b"])
 
-    msg = "index out of bounds"
+    msg = "index 5 is out of bounds for axis 0 with size 5"
     with pytest.raises(IndexError, match=msg):
         s[5]
-    msg = "index 5 is out of bounds for axis 0 with size 5"
     with pytest.raises(IndexError, match=msg):
         s[5] = 0
 
@@ -30,7 +28,6 @@ def test_basic_indexing():
 
     s = s.sort_index()
 
-    msg = r"index out of bounds|^5$"
     with pytest.raises(IndexError, match=msg):
         s[5]
     msg = r"index 5 is out of bounds for axis (0|1) with size 5|^5$"
@@ -38,30 +35,26 @@ def test_basic_indexing():
         s[5] = 0
 
 
-def test_basic_getitem_with_labels(test_data):
-    indices = test_data.ts.index[[5, 10, 15]]
+def test_basic_getitem_with_labels(datetime_series):
+    indices = datetime_series.index[[5, 10, 15]]
 
-    result = test_data.ts[indices]
-    expected = test_data.ts.reindex(indices)
-    assert_series_equal(result, expected)
+    result = datetime_series[indices]
+    expected = datetime_series.reindex(indices)
+    tm.assert_series_equal(result, expected)
 
-    result = test_data.ts[indices[0] : indices[2]]
-    expected = test_data.ts.loc[indices[0] : indices[2]]
-    assert_series_equal(result, expected)
+    result = datetime_series[indices[0] : indices[2]]
+    expected = datetime_series.loc[indices[0] : indices[2]]
+    tm.assert_series_equal(result, expected)
 
     # integer indexes, be careful
     s = Series(np.random.randn(10), index=list(range(0, 20, 2)))
     inds = [0, 2, 5, 7, 8]
     arr_inds = np.array([0, 2, 5, 7, 8])
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = s[inds]
-    expected = s.reindex(inds)
-    assert_series_equal(result, expected)
+    with pytest.raises(KeyError, match="with any missing labels"):
+        s[inds]
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = s[arr_inds]
-    expected = s.reindex(arr_inds)
-    assert_series_equal(result, expected)
+    with pytest.raises(KeyError, match="with any missing labels"):
+        s[arr_inds]
 
     # GH12089
     # with tz for values
@@ -83,67 +76,66 @@ def test_getitem_setitem_ellipsis():
     np.fix(s)
 
     result = s[...]
-    assert_series_equal(result, s)
+    tm.assert_series_equal(result, s)
 
     s[...] = 5
     assert (result == 5).all()
 
 
-def test_getitem_get(test_data):
-    test_series = test_data.series
-    test_obj_series = test_data.objSeries
-
-    idx1 = test_series.index[5]
-    idx2 = test_obj_series.index[5]
+def test_getitem_get(datetime_series, string_series, object_series):
+    idx1 = string_series.index[5]
+    idx2 = object_series.index[5]
 
-    assert test_series[idx1] == test_series.get(idx1)
-    assert test_obj_series[idx2] == test_obj_series.get(idx2)
+    assert string_series[idx1] == string_series.get(idx1)
+    assert object_series[idx2] == object_series.get(idx2)
 
-    assert test_series[idx1] == test_series[5]
-    assert test_obj_series[idx2] == test_obj_series[5]
+    assert string_series[idx1] == string_series[5]
+    assert object_series[idx2] == object_series[5]
 
-    assert test_series.get(-1) == test_series.get(test_series.index[-1])
-    assert test_series[5] == test_series.get(test_series.index[5])
+    assert string_series.get(-1) == string_series.get(string_series.index[-1])
+    assert string_series[5] == string_series.get(string_series.index[5])
 
     # missing
-    d = test_data.ts.index[0] - BDay()
+    d = datetime_series.index[0] - BDay()
     msg = r"Timestamp\('1999-12-31 00:00:00', freq='B'\)"
     with pytest.raises(KeyError, match=msg):
-        test_data.ts[d]
+        datetime_series[d]
 
     # None
     # GH 5652
-    for s in [Series(), Series(index=list("abc"))]:
+    s1 = Series(dtype=object)
+    s2 = Series(dtype=object, index=list("abc"))
+    for s in [s1, s2]:
         result = s.get(None)
         assert result is None
 
 
-def test_getitem_fancy(test_data):
-    slice1 = test_data.series[[1, 2, 3]]
-    slice2 = test_data.objSeries[[1, 2, 3]]
-    assert test_data.series.index[2] == slice1.index[1]
-    assert test_data.objSeries.index[2] == slice2.index[1]
-    assert test_data.series[2] == slice1[1]
-    assert test_data.objSeries[2] == slice2[1]
+def test_getitem_fancy(string_series, object_series):
+    slice1 = string_series[[1, 2, 3]]
+    slice2 = object_series[[1, 2, 3]]
+    assert string_series.index[2] == slice1.index[1]
+    assert object_series.index[2] == slice2.index[1]
+    assert string_series[2] == slice1[1]
+    assert object_series[2] == slice2[1]
 
 
-def test_getitem_generator(test_data):
-    gen = (x > 0 for x in test_data.series)
-    result = test_data.series[gen]
-    result2 = test_data.series[iter(test_data.series > 0)]
-    expected = test_data.series[test_data.series > 0]
-    assert_series_equal(result, expected)
-    assert_series_equal(result2, expected)
+def test_getitem_generator(string_series):
+    gen = (x > 0 for x in string_series)
+    result = string_series[gen]
+    result2 = string_series[iter(string_series > 0)]
+    expected = string_series[string_series > 0]
+    tm.assert_series_equal(result, expected)
+    tm.assert_series_equal(result2, expected)
 
 
 def test_type_promotion():
     # GH12599
-    s = pd.Series()
+    s = pd.Series(dtype=object)
     s["a"] = pd.Timestamp("2016-01-01")
     s["b"] = 3.0
     s["c"] = "foo"
     expected = Series([pd.Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
 
 @pytest.mark.parametrize(
@@ -165,18 +157,19 @@ def test_getitem_with_duplicates_indices(result_1, duplicate_item, expected_1):
     # GH 17610
     result = result_1.append(duplicate_item)
     expected = expected_1.append(duplicate_item)
-    assert_series_equal(result[1], expected)
+    tm.assert_series_equal(result[1], expected)
     assert result[2] == result_1[2]
 
 
-def test_getitem_out_of_bounds(test_data):
+def test_getitem_out_of_bounds(datetime_series):
     # don't segfault, GH #495
-    msg = "index out of bounds"
+    msg = r"index \d+ is out of bounds for axis 0 with size \d+"
     with pytest.raises(IndexError, match=msg):
-        test_data.ts[len(test_data.ts)]
+        datetime_series[len(datetime_series)]
 
     # GH #917
-    s = Series([])
+    msg = r"index -\d+ is out of bounds for axis 0 with size \d+"
+    s = Series([], dtype=object)
     with pytest.raises(IndexError, match=msg):
         s[-1]
 
@@ -190,8 +183,8 @@ def test_getitem_setitem_integers():
     tm.assert_almost_equal(s["a"], 5)
 
 
-def test_getitem_box_float64(test_data):
-    value = test_data.ts[5]
+def test_getitem_box_float64(datetime_series):
+    value = datetime_series[5]
     assert isinstance(value, np.float64)
 
 
@@ -248,6 +241,16 @@ def test_series_box_timestamp():
     assert isinstance(ser.iat[5], pd.Timestamp)
 
 
+def test_series_box_timedelta():
+    rng = pd.timedelta_range("1 day 1 s", periods=5, freq="h")
+    ser = pd.Series(rng)
+    assert isinstance(ser[0], Timedelta)
+    assert isinstance(ser.at[1], Timedelta)
+    assert isinstance(ser.iat[2], Timedelta)
+    assert isinstance(ser.loc[3], Timedelta)
+    assert isinstance(ser.iloc[4], Timedelta)
+
+
 def test_getitem_ambiguous_keyerror():
     s = Series(range(10), index=list(range(0, 20, 2)))
     with pytest.raises(KeyError, match=r"^1$"):
@@ -266,19 +269,18 @@ def test_getitem_dups_with_missing():
     # breaks reindex, so need to use .loc internally
     # GH 4246
     s = Series([1, 2, 3, 4], ["foo", "bar", "foo", "bah"])
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        expected = s.loc[["foo", "bar", "bah", "bam"]]
+    with pytest.raises(KeyError, match="with any missing labels"):
+        s.loc[["foo", "bar", "bah", "bam"]]
 
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = s[["foo", "bar", "bah", "bam"]]
-    assert_series_equal(result, expected)
+    with pytest.raises(KeyError, match="with any missing labels"):
+        s[["foo", "bar", "bah", "bam"]]
 
 
 def test_getitem_dups():
     s = Series(range(5), index=["A", "A", "B", "C", "C"], dtype=np.int64)
     expected = Series([3, 4], index=["C", "C"], dtype=np.int64)
     result = s["C"]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 def test_setitem_ambiguous_keyerror():
@@ -288,12 +290,12 @@ def test_setitem_ambiguous_keyerror():
     s2 = s.copy()
     s2[1] = 5
     expected = s.append(Series([5], index=[1]))
-    assert_series_equal(s2, expected)
+    tm.assert_series_equal(s2, expected)
 
     s2 = s.copy()
     s2.loc[1] = 5
     expected = s.append(Series([5], index=[1]))
-    assert_series_equal(s2, expected)
+    tm.assert_series_equal(s2, expected)
 
 
 def test_getitem_dataframe():
@@ -301,21 +303,21 @@ def test_getitem_dataframe():
     s = pd.Series(10, index=rng)
     df = pd.DataFrame(rng, index=rng)
     msg = (
-        "Indexing a Series with DataFrame is not supported,"
-        " use the appropriate DataFrame column"
+        "Indexing a Series with DataFrame is not supported, "
+        "use the appropriate DataFrame column"
     )
     with pytest.raises(TypeError, match=msg):
         s[df > 5]
 
 
-def test_setitem(test_data):
-    test_data.ts[test_data.ts.index[5]] = np.NaN
-    test_data.ts[[1, 2, 17]] = np.NaN
-    test_data.ts[6] = np.NaN
-    assert np.isnan(test_data.ts[6])
-    assert np.isnan(test_data.ts[2])
-    test_data.ts[np.isnan(test_data.ts)] = 5
-    assert not np.isnan(test_data.ts[2])
+def test_setitem(datetime_series, string_series):
+    datetime_series[datetime_series.index[5]] = np.NaN
+    datetime_series[[1, 2, 17]] = np.NaN
+    datetime_series[6] = np.NaN
+    assert np.isnan(datetime_series[6])
+    assert np.isnan(datetime_series[2])
+    datetime_series[np.isnan(datetime_series)] = 5
+    assert not np.isnan(datetime_series[2])
 
     # caught this bug when writing tests
     series = Series(tm.makeIntIndex(20).astype(float), index=tm.makeIntIndex(20))
@@ -324,24 +326,24 @@ def test_setitem(test_data):
     assert (series[::2] == 0).all()
 
     # set item that's not contained
-    s = test_data.series.copy()
+    s = string_series.copy()
     s["foobar"] = 1
 
     app = Series([1], index=["foobar"], name="series")
-    expected = test_data.series.append(app)
-    assert_series_equal(s, expected)
+    expected = string_series.append(app)
+    tm.assert_series_equal(s, expected)
 
     # Test for issue #10193
     key = pd.Timestamp("2012-01-01")
-    series = pd.Series()
+    series = pd.Series(dtype=object)
     series[key] = 47
     expected = pd.Series(47, [key])
-    assert_series_equal(series, expected)
+    tm.assert_series_equal(series, expected)
 
-    series = pd.Series([], pd.DatetimeIndex([], freq="D"))
+    series = pd.Series([], pd.DatetimeIndex([], freq="D"), dtype=object)
     series[key] = 47
     expected = pd.Series(47, pd.DatetimeIndex([key], freq="D"))
-    assert_series_equal(series, expected)
+    tm.assert_series_equal(series, expected)
 
 
 def test_setitem_dtypes():
@@ -351,77 +353,95 @@ def test_setitem_dtypes():
 
     s = Series([1, 2, 3])
     s.iloc[0] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     s = Series([1, 2, 3])
     s.loc[0] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     s = Series([1, 2, 3])
     s[0] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     s = Series([False])
     s.loc[0] = np.nan
-    assert_series_equal(s, Series([np.nan]))
+    tm.assert_series_equal(s, Series([np.nan]))
 
     s = Series([False, True])
     s.loc[0] = np.nan
-    assert_series_equal(s, Series([np.nan, 1.0]))
+    tm.assert_series_equal(s, Series([np.nan, 1.0]))
 
 
-def test_set_value(test_data):
-    idx = test_data.ts.index[10]
-    res = test_data.ts._set_value(idx, 0)
-    assert res is test_data.ts
-    assert test_data.ts[idx] == 0
+def test_set_value(datetime_series, string_series):
+    idx = datetime_series.index[10]
+    res = datetime_series._set_value(idx, 0)
+    assert res is None
+    assert datetime_series[idx] == 0
 
     # equiv
-    s = test_data.series.copy()
+    s = string_series.copy()
     res = s._set_value("foobar", 0)
-    assert res is s
-    assert res.index[-1] == "foobar"
-    assert res["foobar"] == 0
+    assert res is None
+    assert s.index[-1] == "foobar"
+    assert s["foobar"] == 0
 
-    s = test_data.series.copy()
+    s = string_series.copy()
     s.loc["foobar"] = 0
     assert s.index[-1] == "foobar"
     assert s["foobar"] == 0
 
 
-def test_setslice(test_data):
-    sl = test_data.ts[5:20]
+def test_setslice(datetime_series):
+    sl = datetime_series[5:20]
     assert len(sl) == len(sl.index)
     assert sl.index.is_unique is True
 
 
+def test_2d_to_1d_assignment_raises():
+    x = np.random.randn(2, 2)
+    y = pd.Series(range(2))
+
+    msg = (
+        r"shape mismatch: value array of shape \(2,2\) could not be "
+        r"broadcast to indexing result of shape \(2,\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        y.loc[range(2)] = x
+
+    msg = r"could not broadcast input array from shape \(2,2\) into shape \(2\)"
+    with pytest.raises(ValueError, match=msg):
+        y.loc[:] = x
+
+
 # FutureWarning from NumPy about [slice(None, 5).
 @pytest.mark.filterwarnings("ignore:Using a non-tuple:FutureWarning")
-def test_basic_getitem_setitem_corner(test_data):
+def test_basic_getitem_setitem_corner(datetime_series):
     # invalid tuples, e.g. td.ts[:, None] vs. td.ts[:, 2]
     msg = "Can only tuple-index with a MultiIndex"
     with pytest.raises(ValueError, match=msg):
-        test_data.ts[:, 2]
+        datetime_series[:, 2]
     with pytest.raises(ValueError, match=msg):
-        test_data.ts[:, 2] = 2
+        datetime_series[:, 2] = 2
 
     # weird lists. [slice(0, 5)] will work but not two slices
-    result = test_data.ts[[slice(None, 5)]]
-    expected = test_data.ts[:5]
-    assert_series_equal(result, expected)
+    with tm.assert_produces_warning(FutureWarning):
+        # GH#31299
+        result = datetime_series[[slice(None, 5)]]
+    expected = datetime_series[:5]
+    tm.assert_series_equal(result, expected)
 
     # OK
     msg = r"unhashable type(: 'slice')?"
     with pytest.raises(TypeError, match=msg):
-        test_data.ts[[5, slice(None, None)]]
+        datetime_series[[5, slice(None, None)]]
     with pytest.raises(TypeError, match=msg):
-        test_data.ts[[5, slice(None, None)]] = 2
+        datetime_series[[5, slice(None, None)]] = 2
 
 
 @pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Tokyo"])
 def test_setitem_with_tz(tz):
     orig = pd.Series(pd.date_range("2016-01-01", freq="H", periods=3, tz=tz))
-    assert orig.dtype == "datetime64[ns, {0}]".format(tz)
+    assert orig.dtype == f"datetime64[ns, {tz}]"
 
     # scalar
     s = orig.copy()
@@ -448,7 +468,7 @@ def test_setitem_with_tz(tz):
         [pd.Timestamp("2011-01-01", tz=tz), pd.Timestamp("2012-01-01", tz=tz)],
         index=[1, 2],
     )
-    assert vals.dtype == "datetime64[ns, {0}]".format(tz)
+    assert vals.dtype == f"datetime64[ns, {tz}]"
 
     s[[1, 2]] = vals
     exp = pd.Series(
@@ -473,7 +493,7 @@ def test_setitem_with_tz_dst():
     # GH XXX
     tz = "US/Eastern"
     orig = pd.Series(pd.date_range("2016-11-06", freq="H", periods=3, tz=tz))
-    assert orig.dtype == "datetime64[ns, {0}]".format(tz)
+    assert orig.dtype == f"datetime64[ns, {tz}]"
 
     # scalar
     s = orig.copy()
@@ -500,7 +520,7 @@ def test_setitem_with_tz_dst():
         [pd.Timestamp("2011-01-01", tz=tz), pd.Timestamp("2012-01-01", tz=tz)],
         index=[1, 2],
     )
-    assert vals.dtype == "datetime64[ns, {0}]".format(tz)
+    assert vals.dtype == f"datetime64[ns, {tz}]"
 
     s[[1, 2]] = vals
     exp = pd.Series(
@@ -556,25 +576,37 @@ def test_categorical_assigning_ops():
     tm.assert_series_equal(s, exp)
 
 
-def test_slice(test_data):
-    numSlice = test_data.series[10:20]
-    numSliceEnd = test_data.series[-10:]
-    objSlice = test_data.objSeries[10:20]
+def test_getitem_categorical_str():
+    # GH#31765
+    ser = pd.Series(range(5), index=pd.Categorical(["a", "b", "c", "a", "b"]))
+    result = ser["a"]
+    expected = ser.iloc[[0, 3]]
+    tm.assert_series_equal(result, expected)
+
+    # Check the intermediate steps work as expected
+    result = ser.index.get_value(ser, "a")
+    tm.assert_series_equal(result, expected)
+
+
+def test_slice(string_series, object_series):
+    numSlice = string_series[10:20]
+    numSliceEnd = string_series[-10:]
+    objSlice = object_series[10:20]
 
-    assert test_data.series.index[9] not in numSlice.index
-    assert test_data.objSeries.index[9] not in objSlice.index
+    assert string_series.index[9] not in numSlice.index
+    assert object_series.index[9] not in objSlice.index
 
     assert len(numSlice) == len(numSlice.index)
-    assert test_data.series[numSlice.index[0]] == numSlice[numSlice.index[0]]
+    assert string_series[numSlice.index[0]] == numSlice[numSlice.index[0]]
 
-    assert numSlice.index[1] == test_data.series.index[11]
-    assert tm.equalContents(numSliceEnd, np.array(test_data.series)[-10:])
+    assert numSlice.index[1] == string_series.index[11]
+    assert tm.equalContents(numSliceEnd, np.array(string_series)[-10:])
 
     # Test return view.
-    sl = test_data.series[10:20]
+    sl = string_series[10:20]
     sl[:] = 0
 
-    assert (test_data.series[10:20] == 0).all()
+    assert (string_series[10:20] == 0).all()
 
 
 def test_slice_can_reorder_not_uniquely_indexed():
@@ -582,31 +614,31 @@ def test_slice_can_reorder_not_uniquely_indexed():
     s[::-1]  # it works!
 
 
-def test_loc_setitem(test_data):
-    inds = test_data.series.index[[3, 4, 7]]
+def test_loc_setitem(string_series):
+    inds = string_series.index[[3, 4, 7]]
 
-    result = test_data.series.copy()
+    result = string_series.copy()
     result.loc[inds] = 5
 
-    expected = test_data.series.copy()
+    expected = string_series.copy()
     expected[[3, 4, 7]] = 5
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result.iloc[5:10] = 10
     expected[5:10] = 10
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # set slice with indices
-    d1, d2 = test_data.series.index[[5, 15]]
+    d1, d2 = string_series.index[[5, 15]]
     result.loc[d1:d2] = 6
     expected[5:16] = 6  # because it's inclusive
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     # set index value
-    test_data.series.loc[d1] = 4
-    test_data.series.loc[d2] = 6
-    assert test_data.series[d1] == 4
-    assert test_data.series[d2] == 6
+    string_series.loc[d1] = 4
+    string_series.loc[d2] = 6
+    assert string_series[d1] == 4
+    assert string_series[d2] == 6
 
 
 def test_setitem_na():
@@ -614,23 +646,23 @@ def test_setitem_na():
     expected = Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan])
     s = Series([2, 3, 4, 5, 6, 7, 8, 9, 10])
     s[::2] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     # gets coerced to float, right?
     expected = Series([np.nan, 1, np.nan, 0])
     s = Series([True, True, False, False])
     s[::2] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     expected = Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9])
     s = Series(np.arange(10))
     s[:5] = np.nan
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
 
 def test_timedelta_assignment():
     # GH 8209
-    s = Series([])
+    s = Series([], dtype=object)
     s.loc["B"] = timedelta(1)
     tm.assert_series_equal(s, Series(Timedelta("1 days"), index=["B"]))
 
@@ -776,10 +808,10 @@ def test_underlying_data_conversion():
     tm.assert_frame_equal(df, expected)
 
 
-def test_preserve_refs(test_data):
-    seq = test_data.ts[[5, 10, 15]]
+def test_preserve_refs(datetime_series):
+    seq = datetime_series[[5, 10, 15]]
     seq[1] = np.NaN
-    assert not np.isnan(test_data.ts[10])
+    assert not np.isnan(datetime_series[10])
 
 
 def test_cast_on_putmask():
@@ -790,7 +822,7 @@ def test_cast_on_putmask():
     s[[True, False]] = Series([0], index=[1], dtype="int64")
     expected = Series([0, 2], index=[1, 2], dtype="int64")
 
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
 
 def test_type_promote_putmask():
@@ -799,19 +831,19 @@ def test_type_promote_putmask():
     left, mask = ts.copy(), ts > 0
     right = ts[mask].copy().map(str)
     left[mask] = right
-    assert_series_equal(left, ts.map(lambda t: str(t) if t > 0 else t))
+    tm.assert_series_equal(left, ts.map(lambda t: str(t) if t > 0 else t))
 
     s = Series([0, 1, 2, 0])
     mask = s > 0
     s2 = s[mask].map(str)
     s[mask] = s2
-    assert_series_equal(s, Series([0, "1", "2", 0]))
+    tm.assert_series_equal(s, Series([0, "1", "2", 0]))
 
     s = Series([0, "foo", "bar", 0])
     mask = Series([False, True, True, False])
     s2 = s[mask]
     s[mask] = s2
-    assert_series_equal(s, Series([0, "foo", "bar", 0]))
+    tm.assert_series_equal(s, Series([0, "foo", "bar", 0]))
 
 
 def test_multilevel_preserve_name():
@@ -871,39 +903,23 @@ def test_pop():
     assert result == 4
 
     expected = Series([0, 0], index=["A", "C"], name=4)
-    assert_series_equal(k, expected)
-
-
-def test_take():
-    s = Series([-1, 5, 6, 2, 4])
-
-    actual = s.take([1, 3, 4])
-    expected = Series([5, 2, 4], index=[1, 3, 4])
-    tm.assert_series_equal(actual, expected)
-
-    actual = s.take([-1, 3, 4])
-    expected = Series([4, 2, 4], index=[4, 3, 4])
-    tm.assert_series_equal(actual, expected)
-
-    msg = "index {} is out of bounds for size 5"
-    with pytest.raises(IndexError, match=msg.format(10)):
-        s.take([1, 10])
-    with pytest.raises(IndexError, match=msg.format(5)):
-        s.take([2, 5])
-
-
-def test_take_categorical():
-    # https://github.com/pandas-dev/pandas/issues/20664
-    s = Series(pd.Categorical(["a", "b", "c"]))
-    result = s.take([-2, -2, 0])
-    expected = Series(
-        pd.Categorical(["b", "b", "a"], categories=["a", "b", "c"]), index=[1, 1, 0]
-    )
-    assert_series_equal(result, expected)
-
-
-def test_head_tail(test_data):
-    assert_series_equal(test_data.series.head(), test_data.series[:5])
-    assert_series_equal(test_data.series.head(0), test_data.series[0:0])
-    assert_series_equal(test_data.series.tail(), test_data.series[-5:])
-    assert_series_equal(test_data.series.tail(0), test_data.series[0:0])
+    tm.assert_series_equal(k, expected)
+
+
+def test_uint_drop(any_int_dtype):
+    # see GH18311
+    # assigning series.loc[0] = 4 changed series.dtype to int
+    series = pd.Series([1, 2, 3], dtype=any_int_dtype)
+    series.loc[0] = 4
+    expected = pd.Series([4, 2, 3], dtype=any_int_dtype)
+    tm.assert_series_equal(series, expected)
+
+
+def test_getitem_2d_no_warning():
+    # https://github.com/pandas-dev/pandas/issues/30867
+    # Don't want to support this long-term, but
+    # for now ensure that the warning from Index
+    # doesn't comes through via Series.__getitem__.
+    series = pd.Series([1, 2, 3], index=[1, 2, 3])
+    with tm.assert_produces_warning(None):
+        series[:, None]
diff --git a/pandas/tests/series/indexing/test_loc.py b/pandas/tests/series/indexing/test_loc.py
index 2f7807526a29d..7d6b6c78cc492 100644
--- a/pandas/tests/series/indexing/test_loc.py
+++ b/pandas/tests/series/indexing/test_loc.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 from pandas import Series, Timestamp
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize("val,expected", [(2 ** 63 - 1, 3), (2 ** 63, 4)])
@@ -13,30 +13,30 @@ def test_loc_uint64(val, expected):
     assert s.loc[val] == expected
 
 
-def test_loc_getitem(test_data):
-    inds = test_data.series.index[[3, 4, 7]]
-    assert_series_equal(test_data.series.loc[inds], test_data.series.reindex(inds))
-    assert_series_equal(test_data.series.iloc[5::2], test_data.series[5::2])
+def test_loc_getitem(string_series, datetime_series):
+    inds = string_series.index[[3, 4, 7]]
+    tm.assert_series_equal(string_series.loc[inds], string_series.reindex(inds))
+    tm.assert_series_equal(string_series.iloc[5::2], string_series[5::2])
 
     # slice with indices
-    d1, d2 = test_data.ts.index[[5, 15]]
-    result = test_data.ts.loc[d1:d2]
-    expected = test_data.ts.truncate(d1, d2)
-    assert_series_equal(result, expected)
+    d1, d2 = datetime_series.index[[5, 15]]
+    result = datetime_series.loc[d1:d2]
+    expected = datetime_series.truncate(d1, d2)
+    tm.assert_series_equal(result, expected)
 
     # boolean
-    mask = test_data.series > test_data.series.median()
-    assert_series_equal(test_data.series.loc[mask], test_data.series[mask])
+    mask = string_series > string_series.median()
+    tm.assert_series_equal(string_series.loc[mask], string_series[mask])
 
     # ask for index value
-    assert test_data.ts.loc[d1] == test_data.ts[d1]
-    assert test_data.ts.loc[d2] == test_data.ts[d2]
+    assert datetime_series.loc[d1] == datetime_series[d1]
+    assert datetime_series.loc[d2] == datetime_series[d2]
 
 
-def test_loc_getitem_not_monotonic(test_data):
-    d1, d2 = test_data.ts.index[[5, 15]]
+def test_loc_getitem_not_monotonic(datetime_series):
+    d1, d2 = datetime_series.index[[5, 15]]
 
-    ts2 = test_data.ts[::2][[1, 2, 0]]
+    ts2 = datetime_series[::2][[1, 2, 0]]
 
     msg = r"Timestamp\('2000-01-10 00:00:00'\)"
     with pytest.raises(KeyError, match=msg):
@@ -62,8 +62,8 @@ def test_loc_getitem_setitem_integer_slice_keyerrors():
     result2 = s.loc[3:11]
     expected = s.reindex([4, 6, 8, 10])
 
-    assert_series_equal(result, expected)
-    assert_series_equal(result2, expected)
+    tm.assert_series_equal(result, expected)
+    tm.assert_series_equal(result2, expected)
 
     # non-monotonic, raise KeyError
     s2 = s.iloc[list(range(5)) + list(range(9, 4, -1))]
@@ -73,44 +73,44 @@ def test_loc_getitem_setitem_integer_slice_keyerrors():
         s2.loc[3:11] = 0
 
 
-def test_loc_getitem_iterator(test_data):
-    idx = iter(test_data.series.index[:10])
-    result = test_data.series.loc[idx]
-    assert_series_equal(result, test_data.series[:10])
+def test_loc_getitem_iterator(string_series):
+    idx = iter(string_series.index[:10])
+    result = string_series.loc[idx]
+    tm.assert_series_equal(result, string_series[:10])
 
 
-def test_loc_setitem_boolean(test_data):
-    mask = test_data.series > test_data.series.median()
+def test_loc_setitem_boolean(string_series):
+    mask = string_series > string_series.median()
 
-    result = test_data.series.copy()
+    result = string_series.copy()
     result.loc[mask] = 0
-    expected = test_data.series
+    expected = string_series
     expected[mask] = 0
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
-def test_loc_setitem_corner(test_data):
-    inds = list(test_data.series.index[[5, 8, 12]])
-    test_data.series.loc[inds] = 5
+def test_loc_setitem_corner(string_series):
+    inds = list(string_series.index[[5, 8, 12]])
+    string_series.loc[inds] = 5
     msg = r"\['foo'\] not in index"
     with pytest.raises(KeyError, match=msg):
-        test_data.series.loc[inds + ["foo"]] = 5
+        string_series.loc[inds + ["foo"]] = 5
 
 
-def test_basic_setitem_with_labels(test_data):
-    indices = test_data.ts.index[[5, 10, 15]]
+def test_basic_setitem_with_labels(datetime_series):
+    indices = datetime_series.index[[5, 10, 15]]
 
-    cp = test_data.ts.copy()
-    exp = test_data.ts.copy()
+    cp = datetime_series.copy()
+    exp = datetime_series.copy()
     cp[indices] = 0
     exp.loc[indices] = 0
-    assert_series_equal(cp, exp)
+    tm.assert_series_equal(cp, exp)
 
-    cp = test_data.ts.copy()
-    exp = test_data.ts.copy()
+    cp = datetime_series.copy()
+    exp = datetime_series.copy()
     cp[indices[0] : indices[2]] = 0
     exp.loc[indices[0] : indices[2]] = 0
-    assert_series_equal(cp, exp)
+    tm.assert_series_equal(cp, exp)
 
     # integer indexes, be careful
     s = Series(np.random.randn(10), index=list(range(0, 20, 2)))
@@ -121,13 +121,13 @@ def test_basic_setitem_with_labels(test_data):
     exp = s.copy()
     s[inds] = 0
     s.loc[inds] = 0
-    assert_series_equal(cp, exp)
+    tm.assert_series_equal(cp, exp)
 
     cp = s.copy()
     exp = s.copy()
     s[arr_inds] = 0
     s.loc[arr_inds] = 0
-    assert_series_equal(cp, exp)
+    tm.assert_series_equal(cp, exp)
 
     inds_notfound = [0, 4, 5, 6]
     arr_inds_notfound = np.array([0, 4, 5, 6])
diff --git a/pandas/tests/series/indexing/test_mask.py b/pandas/tests/series/indexing/test_mask.py
new file mode 100644
index 0000000000000..dc4fb530dbb52
--- /dev/null
+++ b/pandas/tests/series/indexing/test_mask.py
@@ -0,0 +1,65 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_mask():
+    # compare with tested results in test_where
+    s = Series(np.random.randn(5))
+    cond = s > 0
+
+    rs = s.where(~cond, np.nan)
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.where(~cond)
+    rs2 = s.mask(cond)
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(~cond, -s)
+    rs2 = s.mask(cond, -s)
+    tm.assert_series_equal(rs, rs2)
+
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+    rs = s2.where(~cond[:3])
+    rs2 = s2.mask(cond[:3])
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s2.where(~cond[:3], -s2)
+    rs2 = s2.mask(cond[:3], -s2)
+    tm.assert_series_equal(rs, rs2)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.mask(1)
+    with pytest.raises(ValueError, match=msg):
+        s.mask(cond[:3].values, -s)
+
+    # dtype changes
+    s = Series([1, 2, 3, 4])
+    result = s.mask(s > 2, np.nan)
+    expected = Series([1, 2, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+    # see gh-21891
+    s = Series([1, 2])
+    res = s.mask([True, False])
+
+    exp = Series([np.nan, 2])
+    tm.assert_series_equal(res, exp)
+
+
+def test_mask_inplace():
+    s = Series(np.random.randn(5))
+    cond = s > 0
+
+    rs = s.copy()
+    rs.mask(cond, inplace=True)
+    tm.assert_series_equal(rs.dropna(), s[~cond])
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.copy()
+    rs.mask(cond, -s, inplace=True)
+    tm.assert_series_equal(rs, s.mask(cond, -s))
diff --git a/pandas/tests/series/indexing/test_numeric.py b/pandas/tests/series/indexing/test_numeric.py
index b4996575b0a05..7e73e6366438b 100644
--- a/pandas/tests/series/indexing/test_numeric.py
+++ b/pandas/tests/series/indexing/test_numeric.py
@@ -1,143 +1,8 @@
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import DataFrame, Index, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
-
-
-def test_get():
-    # GH 6383
-    s = Series(
-        np.array(
-            [
-                43,
-                48,
-                60,
-                48,
-                50,
-                51,
-                50,
-                45,
-                57,
-                48,
-                56,
-                45,
-                51,
-                39,
-                55,
-                43,
-                54,
-                52,
-                51,
-                54,
-            ]
-        )
-    )
-
-    result = s.get(25, 0)
-    expected = 0
-    assert result == expected
-
-    s = Series(
-        np.array(
-            [
-                43,
-                48,
-                60,
-                48,
-                50,
-                51,
-                50,
-                45,
-                57,
-                48,
-                56,
-                45,
-                51,
-                39,
-                55,
-                43,
-                54,
-                52,
-                51,
-                54,
-            ]
-        ),
-        index=pd.Float64Index(
-            [
-                25.0,
-                36.0,
-                49.0,
-                64.0,
-                81.0,
-                100.0,
-                121.0,
-                144.0,
-                169.0,
-                196.0,
-                1225.0,
-                1296.0,
-                1369.0,
-                1444.0,
-                1521.0,
-                1600.0,
-                1681.0,
-                1764.0,
-                1849.0,
-                1936.0,
-            ],
-            dtype="object",
-        ),
-    )
-
-    result = s.get(25, 0)
-    expected = 43
-    assert result == expected
-
-    # GH 7407
-    # with a boolean accessor
-    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
-    vc = df.i.value_counts()
-    result = vc.get(99, default="Missing")
-    assert result == "Missing"
-
-    vc = df.b.value_counts()
-    result = vc.get(False, default="Missing")
-    assert result == 3
-
-    result = vc.get(True, default="Missing")
-    assert result == "Missing"
-
-
-def test_get_nan():
-    # GH 8569
-    s = pd.Float64Index(range(10)).to_series()
-    assert s.get(np.nan) is None
-    assert s.get(np.nan, default="Missing") == "Missing"
-
-
-def test_get_nan_multiple():
-    # GH 8569
-    # ensure that fixing "test_get_nan" above hasn't broken get
-    # with multiple elements
-    s = pd.Float64Index(range(10)).to_series()
-
-    idx = [2, 30]
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        assert_series_equal(s.get(idx), Series([2, np.nan], index=idx))
-
-    idx = [2, np.nan]
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        assert_series_equal(s.get(idx), Series([2, np.nan], index=idx))
-
-    # GH 17295 - all missing keys
-    idx = [20, 30]
-    assert s.get(idx) is None
-
-    idx = [np.nan, np.nan]
-    assert s.get(idx) is None
+import pandas._testing as tm
 
 
 def test_delitem():
@@ -147,14 +12,14 @@ def test_delitem():
     del s[0]
 
     expected = Series(range(1, 5), index=range(1, 5))
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     del s[1]
     expected = Series(range(2, 5), index=range(2, 5))
-    assert_series_equal(s, expected)
+    tm.assert_series_equal(s, expected)
 
     # empty
-    s = Series()
+    s = Series(dtype=object)
 
     with pytest.raises(KeyError, match=r"^0$"):
         del s[0]
@@ -162,20 +27,20 @@ def test_delitem():
     # only 1 left, del, add, del
     s = Series(1)
     del s[0]
-    assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+    tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
     s[0] = 1
-    assert_series_equal(s, Series(1))
+    tm.assert_series_equal(s, Series(1))
     del s[0]
-    assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+    tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
 
     # Index(dtype=object)
     s = Series(1, index=["a"])
     del s["a"]
-    assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="object")))
+    tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="object")))
     s["a"] = 1
-    assert_series_equal(s, Series(1, index=["a"]))
+    tm.assert_series_equal(s, Series(1, index=["a"]))
     del s["a"]
-    assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="object")))
+    tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="object")))
 
 
 def test_slice_float64():
@@ -188,10 +53,10 @@ def test_slice_float64():
 
     result = s[start:end]
     expected = s.iloc[5:16]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     result = s.loc[start:end]
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     df = DataFrame(np.random.randn(20, 3), index=index)
 
@@ -206,10 +71,9 @@ def test_slice_float64():
 def test_getitem_negative_out_of_bounds():
     s = Series(tm.rands_array(5, 10), index=tm.rands_array(10, 10))
 
-    msg = "index out of bounds"
+    msg = "index -11 is out of bounds for axis 0 with size 10"
     with pytest.raises(IndexError, match=msg):
         s[-11]
-    msg = "index -11 is out of bounds for axis 0 with size 10"
     with pytest.raises(IndexError, match=msg):
         s[-11] = "foo"
 
@@ -217,19 +81,19 @@ def test_getitem_negative_out_of_bounds():
 def test_getitem_regression():
     s = Series(range(5), index=list(range(5)))
     result = s[list(range(5))]
-    assert_series_equal(result, s)
+    tm.assert_series_equal(result, s)
 
 
 def test_getitem_setitem_slice_bug():
     s = Series(range(10), index=list(range(10)))
     result = s[-12:]
-    assert_series_equal(result, s)
+    tm.assert_series_equal(result, s)
 
     result = s[-7:]
-    assert_series_equal(result, s[3:])
+    tm.assert_series_equal(result, s[3:])
 
     result = s[:-12]
-    assert_series_equal(result, s[:0])
+    tm.assert_series_equal(result, s[:0])
 
     s = Series(range(10), index=list(range(10)))
     s[-12:] = 0
@@ -244,7 +108,7 @@ def test_getitem_setitem_slice_integers():
 
     result = s[:4]
     expected = s.reindex([2, 4, 6, 8])
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
     s[:4] = 0
     assert (s[:4] == 0).all()
@@ -259,25 +123,24 @@ def test_setitem_float_labels():
     s.loc[1] = "zoo"
     tmp.iloc[2] = "zoo"
 
-    assert_series_equal(s, tmp)
+    tm.assert_series_equal(s, tmp)
 
 
-def test_slice_float_get_set(test_data):
+def test_slice_float_get_set(datetime_series):
     msg = (
-        r"cannot do slice indexing on <class 'pandas\.core\.indexes"
-        r"\.datetimes\.DatetimeIndex'> with these indexers \[{key}\]"
-        r" of <class 'float'>"
+        "cannot do slice indexing on DatetimeIndex with these indexers "
+        r"\[{key}\] of type float"
     )
     with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
-        test_data.ts[4.0:10.0]
+        datetime_series[4.0:10.0]
 
     with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
-        test_data.ts[4.0:10.0] = 0
+        datetime_series[4.0:10.0] = 0
 
     with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
-        test_data.ts[4.5:10.0]
+        datetime_series[4.5:10.0]
     with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
-        test_data.ts[4.5:10.0] = 0
+        datetime_series[4.5:10.0] = 0
 
 
 def test_slice_floats2():
@@ -312,6 +175,6 @@ def test_int_indexing():
         s["c"]
 
 
-def test_getitem_int64(test_data):
+def test_getitem_int64(datetime_series):
     idx = np.int64(5)
-    assert test_data.ts[idx] == test_data.ts[5]
+    assert datetime_series[idx] == datetime_series[5]
diff --git a/pandas/tests/series/indexing/test_take.py b/pandas/tests/series/indexing/test_take.py
new file mode 100644
index 0000000000000..9368d49e5ff2b
--- /dev/null
+++ b/pandas/tests/series/indexing/test_take.py
@@ -0,0 +1,33 @@
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_take():
+    ser = Series([-1, 5, 6, 2, 4])
+
+    actual = ser.take([1, 3, 4])
+    expected = Series([5, 2, 4], index=[1, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    actual = ser.take([-1, 3, 4])
+    expected = Series([4, 2, 4], index=[4, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    msg = "index {} is out of bounds for( axis 0 with)? size 5"
+    with pytest.raises(IndexError, match=msg.format(10)):
+        ser.take([1, 10])
+    with pytest.raises(IndexError, match=msg.format(5)):
+        ser.take([2, 5])
+
+
+def test_take_categorical():
+    # https://github.com/pandas-dev/pandas/issues/20664
+    ser = Series(pd.Categorical(["a", "b", "c"]))
+    result = ser.take([-2, -2, 0])
+    expected = Series(
+        pd.Categorical(["b", "b", "a"], categories=["a", "b", "c"]), index=[1, 1, 0]
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/indexing/test_where.py b/pandas/tests/series/indexing/test_where.py
new file mode 100644
index 0000000000000..9703f5afaf689
--- /dev/null
+++ b/pandas/tests/series/indexing/test_where.py
@@ -0,0 +1,437 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+import pandas as pd
+from pandas import Series, Timestamp, date_range, isna
+import pandas._testing as tm
+
+
+def test_where_unsafe_int(sint_dtype):
+    s = Series(np.arange(10), dtype=sint_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype=sint_dtype)
+
+    tm.assert_series_equal(s, expected)
+
+
+def test_where_unsafe_float(float_dtype):
+    s = Series(np.arange(10), dtype=float_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    data = list(range(2, 7)) + list(range(5, 10))
+    expected = Series(data, dtype=float_dtype)
+
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize(
+    "dtype,expected_dtype",
+    [
+        (np.int8, np.float64),
+        (np.int16, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+    ],
+)
+def test_where_unsafe_upcast(dtype, expected_dtype):
+    # see gh-9743
+    s = Series(np.arange(10), dtype=dtype)
+    values = [2.5, 3.5, 4.5, 5.5, 6.5]
+    mask = s < 5
+    expected = Series(values + list(range(5, 10)), dtype=expected_dtype)
+    s[mask] = values
+    tm.assert_series_equal(s, expected)
+
+
+def test_where_unsafe():
+    # see gh-9731
+    s = Series(np.arange(10), dtype="int64")
+    values = [2.5, 3.5, 4.5, 5.5]
+
+    mask = s > 5
+    expected = Series(list(range(6)) + values, dtype="float64")
+
+    s[mask] = values
+    tm.assert_series_equal(s, expected)
+
+    # see gh-3235
+    s = Series(np.arange(10), dtype="int64")
+    mask = s < 5
+    s[mask] = range(2, 7)
+    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype="int64")
+    tm.assert_series_equal(s, expected)
+    assert s.dtype == expected.dtype
+
+    s = Series(np.arange(10), dtype="int64")
+    mask = s > 5
+    s[mask] = [0] * 4
+    expected = Series([0, 1, 2, 3, 4, 5] + [0] * 4, dtype="int64")
+    tm.assert_series_equal(s, expected)
+
+    s = Series(np.arange(10))
+    mask = s > 5
+
+    msg = "cannot assign mismatch length to masked array"
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [5, 4, 3, 2, 1]
+
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [0] * 5
+
+    # dtype changes
+    s = Series([1, 2, 3, 4])
+    result = s.where(s > 2, np.nan)
+    expected = Series([np.nan, np.nan, 3, 4])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4667
+    # setting with None changes dtype
+    s = Series(range(10)).astype(float)
+    s[8] = None
+    result = s[8]
+    assert isna(result)
+
+    s = Series(range(10)).astype(float)
+    s[s > 8] = None
+    result = s[isna(s)]
+    expected = Series(np.nan, index=[9])
+    tm.assert_series_equal(result, expected)
+
+
+def test_where():
+    s = Series(np.random.randn(5))
+    cond = s > 0
+
+    rs = s.where(cond).dropna()
+    rs2 = s[cond]
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(cond, -s)
+    tm.assert_series_equal(rs, s.abs())
+
+    rs = s.where(cond)
+    assert s.shape == rs.shape
+    assert rs is not s
+
+    # test alignment
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+
+    expected = s2[cond].reindex(s2.index[:3]).reindex(s2.index)
+    rs = s2.where(cond[:3])
+    tm.assert_series_equal(rs, expected)
+
+    expected = s2.abs()
+    expected.iloc[0] = s2[0]
+    rs = s2.where(cond[:3], -s2)
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_error():
+    s = Series(np.random.randn(5))
+    cond = s > 0
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where(1)
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond[:3].values, -s)
+
+    # GH 2745
+    s = Series([1, 2])
+    s[[True, False]] = [0, 1]
+    expected = Series([0, 2])
+    tm.assert_series_equal(s, expected)
+
+    # failures
+    msg = "cannot assign mismatch length to masked array"
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = [0, 2, 3]
+    msg = (
+        "NumPy boolean array indexing assignment cannot assign 0 input "
+        "values to the 1 output values where the mask is true"
+    )
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = []
+
+
+@pytest.mark.parametrize("klass", [list, tuple, np.array, Series])
+def test_where_array_like(klass):
+    # see gh-15414
+    s = Series([1, 2, 3])
+    cond = [False, True, True]
+    expected = Series([np.nan, 2, 3])
+
+    result = s.where(klass(cond))
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "cond",
+    [
+        [1, 0, 1],
+        Series([2, 5, 7]),
+        ["True", "False", "True"],
+        [Timestamp("2017-01-01"), pd.NaT, Timestamp("2017-01-02")],
+    ],
+)
+def test_where_invalid_input(cond):
+    # see gh-15414: only boolean arrays accepted
+    s = Series([1, 2, 3])
+    msg = "Boolean array expected for the condition"
+
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where([True])
+
+
+def test_where_ndframe_align():
+    msg = "Array conditional must be same shape as self"
+    s = Series([1, 2, 3])
+
+    cond = [True]
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([1, np.nan, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+    cond = np.array([False, True, False, True])
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([np.nan, 2, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+
+def test_where_setitem_invalid():
+    # GH 2702
+    # make sure correct exceptions are raised on invalid list assignment
+
+    msg = "cannot set using a {} indexer with a different length than the value"
+
+    # slice
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg.format("slice")):
+        s[0:3] = list(range(27))
+
+    s[0:3] = list(range(3))
+    expected = Series([0, 1, 2])
+    tm.assert_series_equal(s.astype(np.int64), expected)
+
+    # slice with step
+    s = Series(list("abcdef"))
+
+    with pytest.raises(ValueError, match=msg.format("slice")):
+        s[0:4:2] = list(range(27))
+
+    s = Series(list("abcdef"))
+    s[0:4:2] = list(range(2))
+    expected = Series([0, "b", 1, "d", "e", "f"])
+    tm.assert_series_equal(s, expected)
+
+    # neg slices
+    s = Series(list("abcdef"))
+
+    with pytest.raises(ValueError, match=msg.format("slice")):
+        s[:-1] = list(range(27))
+
+    s[-3:-1] = list(range(2))
+    expected = Series(["a", "b", "c", 0, 1, "f"])
+    tm.assert_series_equal(s, expected)
+
+    # list
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg.format("list-like")):
+        s[[0, 1, 2]] = list(range(27))
+
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg.format("list-like")):
+        s[[0, 1, 2]] = list(range(2))
+
+    # scalar
+    s = Series(list("abc"))
+    s[0] = list(range(10))
+    expected = Series([list(range(10)), "b", "c"])
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize("size", range(2, 6))
+@pytest.mark.parametrize(
+    "mask", [[True, False, False, False, False], [True, False], [False]]
+)
+@pytest.mark.parametrize(
+    "item", [2.0, np.nan, np.finfo(np.float).max, np.finfo(np.float).min]
+)
+# Test numpy arrays, lists and tuples as the input to be
+# broadcast
+@pytest.mark.parametrize(
+    "box", [lambda x: np.array([x]), lambda x: [x], lambda x: (x,)]
+)
+def test_broadcast(size, mask, item, box):
+    selection = np.resize(mask, size)
+
+    data = np.arange(size, dtype=float)
+
+    # Construct the expected series by taking the source
+    # data or item based on the selection
+    expected = Series(
+        [item if use_item else data[i] for i, use_item in enumerate(selection)]
+    )
+
+    s = Series(data)
+    s[selection] = box(item)
+    tm.assert_series_equal(s, expected)
+
+    s = Series(data)
+    result = s.where(~selection, box(item))
+    tm.assert_series_equal(result, expected)
+
+    s = Series(data)
+    result = s.mask(selection, box(item))
+    tm.assert_series_equal(result, expected)
+
+
+def test_where_inplace():
+    s = Series(np.random.randn(5))
+    cond = s > 0
+
+    rs = s.copy()
+
+    rs.where(cond, inplace=True)
+    tm.assert_series_equal(rs.dropna(), s[cond])
+    tm.assert_series_equal(rs, s.where(cond))
+
+    rs = s.copy()
+    rs.where(cond, -s, inplace=True)
+    tm.assert_series_equal(rs, s.where(cond, -s))
+
+
+def test_where_dups():
+    # GH 4550
+    # where crashes with dups in index
+    s1 = Series(list(range(3)))
+    s2 = Series(list(range(3)))
+    comb = pd.concat([s1, s2])
+    result = comb.where(comb < 2)
+    expected = Series([0, 1, np.nan, 0, 1, np.nan], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4548
+    # inplace updating not working with dups
+    comb[comb < 1] = 5
+    expected = Series([5, 1, 2, 5, 1, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+    comb[comb < 2] += 10
+    expected = Series([5, 11, 2, 5, 11, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+
+def test_where_numeric_with_string():
+    # GH 9280
+    s = pd.Series([1, 2, 3])
+    w = s.where(s > 1, "X")
+
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, ["X", "Y", "Z"])
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, np.array(["X", "Y", "Z"]))
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+
+def test_where_timedelta_coerce():
+    s = Series([1, 2], dtype="timedelta64[ns]")
+    expected = Series([10, 10])
+    mask = np.array([False, False])
+
+    rs = s.where(mask, [10, 10])
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, 10)
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, 10.0)
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, [10.0, 10.0])
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, [10.0, np.nan])
+    expected = Series([10, None], dtype="object")
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_datetime_conversion():
+    s = Series(date_range("20130102", periods=2))
+    expected = Series([10, 10])
+    mask = np.array([False, False])
+
+    rs = s.where(mask, [10, 10])
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, 10)
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, 10.0)
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, [10.0, 10.0])
+    tm.assert_series_equal(rs, expected)
+
+    rs = s.where(mask, [10.0, np.nan])
+    expected = Series([10, None], dtype="object")
+    tm.assert_series_equal(rs, expected)
+
+    # GH 15701
+    timestamps = ["2016-12-31 12:00:04+00:00", "2016-12-31 12:00:04.010000+00:00"]
+    s = Series([pd.Timestamp(t) for t in timestamps])
+    rs = s.where(Series([False, True]))
+    expected = Series([pd.NaT, s[1]])
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_dt_tz_values(tz_naive_fixture):
+    ser1 = pd.Series(
+        pd.DatetimeIndex(["20150101", "20150102", "20150103"], tz=tz_naive_fixture)
+    )
+    ser2 = pd.Series(
+        pd.DatetimeIndex(["20160514", "20160515", "20160516"], tz=tz_naive_fixture)
+    )
+    mask = pd.Series([True, True, False])
+    result = ser1.where(mask, ser2)
+    exp = pd.Series(
+        pd.DatetimeIndex(["20150101", "20150102", "20160516"], tz=tz_naive_fixture)
+    )
+    tm.assert_series_equal(exp, result)
diff --git a/pandas/tests/series/indexing/test_xs.py b/pandas/tests/series/indexing/test_xs.py
new file mode 100644
index 0000000000000..43458ca2ebeb2
--- /dev/null
+++ b/pandas/tests/series/indexing/test_xs.py
@@ -0,0 +1,17 @@
+import numpy as np
+
+import pandas as pd
+
+
+def test_xs_datetimelike_wrapping():
+    # GH#31630 a case where we shouldn't wrap datetime64 in Timestamp
+    arr = pd.date_range("2016-01-01", periods=3)._data._data
+
+    ser = pd.Series(arr, dtype=object)
+    for i in range(len(ser)):
+        ser.iloc[i] = arr[i]
+    assert ser.dtype == object
+    assert isinstance(ser[0], np.datetime64)
+
+    result = ser.xs(0)
+    assert isinstance(result, np.datetime64)
diff --git a/pandas/tests/series/methods/__init__.py b/pandas/tests/series/methods/__init__.py
new file mode 100644
index 0000000000000..bcb0d30f405e2
--- /dev/null
+++ b/pandas/tests/series/methods/__init__.py
@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) Series methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.frame.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""
diff --git a/pandas/tests/series/methods/test_append.py b/pandas/tests/series/methods/test_append.py
new file mode 100644
index 0000000000000..4d64b5b397981
--- /dev/null
+++ b/pandas/tests/series/methods/test_append.py
@@ -0,0 +1,168 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, DatetimeIndex, Series, date_range
+import pandas._testing as tm
+
+
+class TestSeriesAppend:
+    def test_append(self, datetime_series, string_series, object_series):
+        appended_series = string_series.append(object_series)
+        for idx, value in appended_series.items():
+            if idx in string_series.index:
+                assert value == string_series[idx]
+            elif idx in object_series.index:
+                assert value == object_series[idx]
+            else:
+                raise AssertionError("orphaned index!")
+
+        msg = "Indexes have overlapping values:"
+        with pytest.raises(ValueError, match=msg):
+            datetime_series.append(datetime_series, verify_integrity=True)
+
+    def test_append_many(self, datetime_series):
+        pieces = [datetime_series[:5], datetime_series[5:10], datetime_series[10:]]
+
+        result = pieces[0].append(pieces[1:])
+        tm.assert_series_equal(result, datetime_series)
+
+    def test_append_duplicates(self):
+        # GH 13677
+        s1 = pd.Series([1, 2, 3])
+        s2 = pd.Series([4, 5, 6])
+        exp = pd.Series([1, 2, 3, 4, 5, 6], index=[0, 1, 2, 0, 1, 2])
+        tm.assert_series_equal(s1.append(s2), exp)
+        tm.assert_series_equal(pd.concat([s1, s2]), exp)
+
+        # the result must have RangeIndex
+        exp = pd.Series([1, 2, 3, 4, 5, 6])
+        tm.assert_series_equal(
+            s1.append(s2, ignore_index=True), exp, check_index_type=True
+        )
+        tm.assert_series_equal(
+            pd.concat([s1, s2], ignore_index=True), exp, check_index_type=True
+        )
+
+        msg = "Indexes have overlapping values:"
+        with pytest.raises(ValueError, match=msg):
+            s1.append(s2, verify_integrity=True)
+        with pytest.raises(ValueError, match=msg):
+            pd.concat([s1, s2], verify_integrity=True)
+
+    def test_append_tuples(self):
+        # GH 28410
+        s = pd.Series([1, 2, 3])
+        list_input = [s, s]
+        tuple_input = (s, s)
+
+        expected = s.append(list_input)
+        result = s.append(tuple_input)
+
+        tm.assert_series_equal(expected, result)
+
+    def test_append_dataframe_regression(self):
+        # GH 30975
+        df = pd.DataFrame({"A": [1, 2]})
+        result = df.A.append([df])
+        expected = pd.DataFrame(
+            {0: [1.0, 2.0, None, None], "A": [None, None, 1.0, 2.0]}, index=[0, 1, 0, 1]
+        )
+
+        tm.assert_frame_equal(expected, result)
+
+
+class TestSeriesAppendWithDatetimeIndex:
+    def test_append(self):
+        rng = date_range("5/8/2012 1:45", periods=10, freq="5T")
+        ts = Series(np.random.randn(len(rng)), rng)
+        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
+
+        result = ts.append(ts)
+        result_df = df.append(df)
+        ex_index = DatetimeIndex(np.tile(rng.values, 2))
+        tm.assert_index_equal(result.index, ex_index)
+        tm.assert_index_equal(result_df.index, ex_index)
+
+        appended = rng.append(rng)
+        tm.assert_index_equal(appended, ex_index)
+
+        appended = rng.append([rng, rng])
+        ex_index = DatetimeIndex(np.tile(rng.values, 3))
+        tm.assert_index_equal(appended, ex_index)
+
+        # different index names
+        rng1 = rng.copy()
+        rng2 = rng.copy()
+        rng1.name = "foo"
+        rng2.name = "bar"
+        assert rng1.append(rng1).name == "foo"
+        assert rng1.append(rng2).name is None
+
+    def test_append_tz(self):
+        # see gh-2938
+        rng = date_range("5/8/2012 1:45", periods=10, freq="5T", tz="US/Eastern")
+        rng2 = date_range("5/8/2012 2:35", periods=10, freq="5T", tz="US/Eastern")
+        rng3 = date_range("5/8/2012 1:45", periods=20, freq="5T", tz="US/Eastern")
+        ts = Series(np.random.randn(len(rng)), rng)
+        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
+        ts2 = Series(np.random.randn(len(rng2)), rng2)
+        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
+
+        result = ts.append(ts2)
+        result_df = df.append(df2)
+        tm.assert_index_equal(result.index, rng3)
+        tm.assert_index_equal(result_df.index, rng3)
+
+        appended = rng.append(rng2)
+        tm.assert_index_equal(appended, rng3)
+
+    def test_append_tz_explicit_pytz(self):
+        # see gh-2938
+        from pytz import timezone as timezone
+
+        rng = date_range(
+            "5/8/2012 1:45", periods=10, freq="5T", tz=timezone("US/Eastern")
+        )
+        rng2 = date_range(
+            "5/8/2012 2:35", periods=10, freq="5T", tz=timezone("US/Eastern")
+        )
+        rng3 = date_range(
+            "5/8/2012 1:45", periods=20, freq="5T", tz=timezone("US/Eastern")
+        )
+        ts = Series(np.random.randn(len(rng)), rng)
+        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
+        ts2 = Series(np.random.randn(len(rng2)), rng2)
+        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
+
+        result = ts.append(ts2)
+        result_df = df.append(df2)
+        tm.assert_index_equal(result.index, rng3)
+        tm.assert_index_equal(result_df.index, rng3)
+
+        appended = rng.append(rng2)
+        tm.assert_index_equal(appended, rng3)
+
+    def test_append_tz_dateutil(self):
+        # see gh-2938
+        rng = date_range(
+            "5/8/2012 1:45", periods=10, freq="5T", tz="dateutil/US/Eastern"
+        )
+        rng2 = date_range(
+            "5/8/2012 2:35", periods=10, freq="5T", tz="dateutil/US/Eastern"
+        )
+        rng3 = date_range(
+            "5/8/2012 1:45", periods=20, freq="5T", tz="dateutil/US/Eastern"
+        )
+        ts = Series(np.random.randn(len(rng)), rng)
+        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
+        ts2 = Series(np.random.randn(len(rng2)), rng2)
+        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
+
+        result = ts.append(ts2)
+        result_df = df.append(df2)
+        tm.assert_index_equal(result.index, rng3)
+        tm.assert_index_equal(result_df.index, rng3)
+
+        appended = rng.append(rng2)
+        tm.assert_index_equal(appended, rng3)
diff --git a/pandas/tests/series/methods/test_argsort.py b/pandas/tests/series/methods/test_argsort.py
new file mode 100644
index 0000000000000..c7fe6ed19a2eb
--- /dev/null
+++ b/pandas/tests/series/methods/test_argsort.py
@@ -0,0 +1,63 @@
+import numpy as np
+import pytest
+
+from pandas import Series, Timestamp, isna
+import pandas._testing as tm
+
+
+class TestSeriesArgsort:
+    def _check_accum_op(self, name, ser, check_dtype=True):
+        func = getattr(np, name)
+        tm.assert_numpy_array_equal(
+            func(ser).values, func(np.array(ser)), check_dtype=check_dtype,
+        )
+
+        # with missing values
+        ts = ser.copy()
+        ts[::2] = np.NaN
+
+        result = func(ts)[1::2]
+        expected = func(np.array(ts.dropna()))
+
+        tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)
+
+    def test_argsort(self, datetime_series):
+        self._check_accum_op("argsort", datetime_series, check_dtype=False)
+        argsorted = datetime_series.argsort()
+        assert issubclass(argsorted.dtype.type, np.integer)
+
+        # GH#2967 (introduced bug in 0.11-dev I think)
+        s = Series([Timestamp(f"201301{i:02d}") for i in range(1, 6)])
+        assert s.dtype == "datetime64[ns]"
+        shifted = s.shift(-1)
+        assert shifted.dtype == "datetime64[ns]"
+        assert isna(shifted[4])
+
+        result = s.argsort()
+        expected = Series(range(5), dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+        result = shifted.argsort()
+        expected = Series(list(range(4)) + [-1], dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_argsort_stable(self):
+        s = Series(np.random.randint(0, 100, size=10000))
+        mindexer = s.argsort(kind="mergesort")
+        qindexer = s.argsort()
+
+        mexpected = np.argsort(s.values, kind="mergesort")
+        qexpected = np.argsort(s.values, kind="quicksort")
+
+        tm.assert_series_equal(mindexer, Series(mexpected), check_dtype=False)
+        tm.assert_series_equal(qindexer, Series(qexpected), check_dtype=False)
+        msg = (
+            r"ndarray Expected type <class 'numpy\.ndarray'>, "
+            r"found <class 'pandas\.core\.series\.Series'> instead"
+        )
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_numpy_array_equal(qindexer, mindexer)
+
+    def test_argsort_preserve_name(self, datetime_series):
+        result = datetime_series.argsort()
+        assert result.name == datetime_series.name
diff --git a/pandas/tests/series/methods/test_asfreq.py b/pandas/tests/series/methods/test_asfreq.py
new file mode 100644
index 0000000000000..05ec56cf02182
--- /dev/null
+++ b/pandas/tests/series/methods/test_asfreq.py
@@ -0,0 +1,23 @@
+import numpy as np
+
+from pandas import DataFrame, Series, period_range
+import pandas._testing as tm
+
+
+class TestAsFreq:
+    # TODO: de-duplicate/parametrize or move DataFrame test
+    def test_asfreq_ts(self):
+        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
+        ts = Series(np.random.randn(len(index)), index=index)
+        df = DataFrame(np.random.randn(len(index), 3), index=index)
+
+        result = ts.asfreq("D", how="end")
+        df_result = df.asfreq("D", how="end")
+        exp_index = index.asfreq("D", how="end")
+        assert len(result) == len(ts)
+        tm.assert_index_equal(result.index, exp_index)
+        tm.assert_index_equal(df_result.index, exp_index)
+
+        result = ts.asfreq("D", how="start")
+        assert len(result) == len(ts)
+        tm.assert_index_equal(result.index, index.asfreq("D", how="start"))
diff --git a/pandas/tests/series/test_asof.py b/pandas/tests/series/methods/test_asof.py
similarity index 99%
rename from pandas/tests/series/test_asof.py
rename to pandas/tests/series/methods/test_asof.py
index 8bc9e9c38d83a..b121efd202744 100644
--- a/pandas/tests/series/test_asof.py
+++ b/pandas/tests/series/methods/test_asof.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import Series, Timestamp, date_range, isna, notna, offsets
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestSeriesAsof:
diff --git a/pandas/tests/series/methods/test_clip.py b/pandas/tests/series/methods/test_clip.py
new file mode 100644
index 0000000000000..37764d3b82c2d
--- /dev/null
+++ b/pandas/tests/series/methods/test_clip.py
@@ -0,0 +1,99 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series, Timestamp, isna, notna
+import pandas._testing as tm
+
+
+class TestSeriesClip:
+    def test_clip(self, datetime_series):
+        val = datetime_series.median()
+
+        assert datetime_series.clip(lower=val).min() == val
+        assert datetime_series.clip(upper=val).max() == val
+
+        result = datetime_series.clip(-0.5, 0.5)
+        expected = np.clip(datetime_series, -0.5, 0.5)
+        tm.assert_series_equal(result, expected)
+        assert isinstance(expected, Series)
+
+    def test_clip_types_and_nulls(self):
+
+        sers = [
+            Series([np.nan, 1.0, 2.0, 3.0]),
+            Series([None, "a", "b", "c"]),
+            Series(pd.to_datetime([np.nan, 1, 2, 3], unit="D")),
+        ]
+
+        for s in sers:
+            thresh = s[2]
+            lower = s.clip(lower=thresh)
+            upper = s.clip(upper=thresh)
+            assert lower[notna(lower)].min() == thresh
+            assert upper[notna(upper)].max() == thresh
+            assert list(isna(s)) == list(isna(lower))
+            assert list(isna(s)) == list(isna(upper))
+
+    def test_clip_with_na_args(self):
+        """Should process np.nan argument as None """
+        # GH#17276
+        s = Series([1, 2, 3])
+
+        tm.assert_series_equal(s.clip(np.nan), Series([1, 2, 3]))
+        tm.assert_series_equal(s.clip(upper=np.nan, lower=np.nan), Series([1, 2, 3]))
+
+        # GH#19992
+        tm.assert_series_equal(s.clip(lower=[0, 4, np.nan]), Series([1, 4, np.nan]))
+        tm.assert_series_equal(s.clip(upper=[1, np.nan, 1]), Series([1, np.nan, 1]))
+
+    def test_clip_against_series(self):
+        # GH#6966
+
+        s = Series([1.0, 1.0, 4.0])
+
+        lower = Series([1.0, 2.0, 3.0])
+        upper = Series([1.5, 2.5, 3.5])
+
+        tm.assert_series_equal(s.clip(lower, upper), Series([1.0, 2.0, 3.5]))
+        tm.assert_series_equal(s.clip(1.5, upper), Series([1.5, 1.5, 3.5]))
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("upper", [[1, 2, 3], np.asarray([1, 2, 3])])
+    def test_clip_against_list_like(self, inplace, upper):
+        # GH#15390
+        original = pd.Series([5, 6, 7])
+        result = original.clip(upper=upper, inplace=inplace)
+        expected = pd.Series([1, 2, 3])
+
+        if inplace:
+            result = original
+        tm.assert_series_equal(result, expected, check_exact=True)
+
+    def test_clip_with_datetimes(self):
+        # GH#11838
+        # naive and tz-aware datetimes
+
+        t = Timestamp("2015-12-01 09:30:30")
+        s = Series([Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:31:00")])
+        result = s.clip(upper=t)
+        expected = Series(
+            [Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:30:30")]
+        )
+        tm.assert_series_equal(result, expected)
+
+        t = Timestamp("2015-12-01 09:30:30", tz="US/Eastern")
+        s = Series(
+            [
+                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
+                Timestamp("2015-12-01 09:31:00", tz="US/Eastern"),
+            ]
+        )
+        result = s.clip(upper=t)
+        expected = Series(
+            [
+                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
+                Timestamp("2015-12-01 09:30:30", tz="US/Eastern"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_combine_first.py b/pandas/tests/series/methods/test_combine_first.py
new file mode 100644
index 0000000000000..aed6425e50117
--- /dev/null
+++ b/pandas/tests/series/methods/test_combine_first.py
@@ -0,0 +1,19 @@
+import numpy as np
+
+from pandas import Period, Series, date_range, period_range
+import pandas._testing as tm
+
+
+class TestCombineFirst:
+    def test_combine_first_period_datetime(self):
+        # GH#3367
+        didx = date_range(start="1950-01-31", end="1950-07-31", freq="M")
+        pidx = period_range(start=Period("1950-1"), end=Period("1950-7"), freq="M")
+        # check to be consistent with DatetimeIndex
+        for idx in [didx, pidx]:
+            a = Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
+            b = Series([9, 9, 9, 9, 9, 9, 9], index=idx)
+
+            result = a.combine_first(b)
+            expected = Series([1, 9, 9, 4, 5, 9, 7], index=idx, dtype=np.float64)
+            tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
new file mode 100644
index 0000000000000..923b5a94c5f41
--- /dev/null
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -0,0 +1,248 @@
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestSeriesConvertDtypes:
+    # The answerdict has keys that have 4 tuples, corresponding to the arguments
+    # infer_objects, convert_string, convert_integer, convert_boolean
+    # This allows all 16 possible combinations to be tested.  Since common
+    # combinations expect the same answer, this provides an easy way to list
+    # all the possibilities
+    @pytest.mark.parametrize(
+        "data, maindtype, answerdict",
+        [
+            (
+                [1, 2, 3],
+                np.dtype("int32"),
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "Int32",
+                    ((True, False), (True, False), (False,), (True, False)): np.dtype(
+                        "int32"
+                    ),
+                },
+            ),
+            (
+                [1, 2, 3],
+                np.dtype("int64"),
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "Int64",
+                    ((True, False), (True, False), (False,), (True, False)): np.dtype(
+                        "int64"
+                    ),
+                },
+            ),
+            (
+                ["x", "y", "z"],
+                np.dtype("O"),
+                {
+                    (
+                        (True, False),
+                        (True,),
+                        (True, False),
+                        (True, False),
+                    ): pd.StringDtype(),
+                    ((True, False), (False,), (True, False), (True, False)): np.dtype(
+                        "O"
+                    ),
+                },
+            ),
+            (
+                [True, False, np.nan],
+                np.dtype("O"),
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True,),
+                    ): pd.BooleanDtype(),
+                    ((True, False), (True, False), (True, False), (False,)): np.dtype(
+                        "O"
+                    ),
+                },
+            ),
+            (
+                ["h", "i", np.nan],
+                np.dtype("O"),
+                {
+                    (
+                        (True, False),
+                        (True,),
+                        (True, False),
+                        (True, False),
+                    ): pd.StringDtype(),
+                    ((True, False), (False,), (True, False), (True, False)): np.dtype(
+                        "O"
+                    ),
+                },
+            ),
+            (
+                [10, np.nan, 20],
+                np.dtype("float"),
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "Int64",
+                    ((True, False), (True, False), (False,), (True, False)): np.dtype(
+                        "float"
+                    ),
+                },
+            ),
+            (
+                [np.nan, 100.5, 200],
+                np.dtype("float"),
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): np.dtype("float"),
+                },
+            ),
+            (
+                [3, 4, 5],
+                "Int8",
+                {((True, False), (True, False), (True, False), (True, False)): "Int8"},
+            ),
+            (
+                [[1, 2], [3, 4], [5]],
+                None,
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): np.dtype("O"),
+                },
+            ),
+            (
+                [4, 5, 6],
+                np.dtype("uint32"),
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "UInt32",
+                    ((True, False), (True, False), (False,), (True, False)): np.dtype(
+                        "uint32"
+                    ),
+                },
+            ),
+            (
+                [-10, 12, 13],
+                np.dtype("i1"),
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "Int8",
+                    ((True, False), (True, False), (False,), (True, False)): np.dtype(
+                        "i1"
+                    ),
+                },
+            ),
+            (
+                [1, 2.0],
+                object,
+                {
+                    ((True, False), (True, False), (True,), (True, False)): "Int64",
+                    ((True,), (True, False), (False,), (True, False)): np.dtype(
+                        "float"
+                    ),
+                    ((False,), (True, False), (False,), (True, False)): np.dtype(
+                        "object"
+                    ),
+                },
+            ),
+            (
+                ["a", "b"],
+                pd.CategoricalDtype(),
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): pd.CategoricalDtype(),
+                },
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+                pd.DatetimeTZDtype(tz="UTC"),
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): pd.DatetimeTZDtype(tz="UTC"),
+                },
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+                "datetime64[ns]",
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): np.dtype("datetime64[ns]"),
+                },
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+                object,
+                {
+                    ((True,), (True, False), (True, False), (True, False),): np.dtype(
+                        "datetime64[ns]"
+                    ),
+                    ((False,), (True, False), (True, False), (True, False),): np.dtype(
+                        "O"
+                    ),
+                },
+            ),
+            (
+                pd.period_range("1/1/2011", freq="M", periods=3),
+                None,
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): pd.PeriodDtype("M"),
+                },
+            ),
+            (
+                pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+                None,
+                {
+                    (
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                        (True, False),
+                    ): pd.IntervalDtype("int64"),
+                },
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("params", product(*[(True, False)] * 4))
+    def test_convert_dtypes(self, data, maindtype, params, answerdict):
+        if maindtype is not None:
+            series = pd.Series(data, dtype=maindtype)
+        else:
+            series = pd.Series(data)
+        answers = {k: a for (kk, a) in answerdict.items() for k in product(*kk)}
+
+        ns = series.convert_dtypes(*params)
+        expected_dtype = answers[tuple(params)]
+        expected = pd.Series(series.values, dtype=expected_dtype)
+        tm.assert_series_equal(ns, expected)
+
+        # Test that it is a copy
+        copy = series.copy(deep=True)
+        ns[ns.notna()] = np.nan
+
+        # Make sure original not changed
+        tm.assert_series_equal(series, copy)
diff --git a/pandas/tests/series/methods/test_count.py b/pandas/tests/series/methods/test_count.py
new file mode 100644
index 0000000000000..1ca48eeb7c441
--- /dev/null
+++ b/pandas/tests/series/methods/test_count.py
@@ -0,0 +1,38 @@
+import numpy as np
+
+import pandas as pd
+from pandas import Categorical, MultiIndex, Series
+import pandas._testing as tm
+
+
+class TestSeriesCount:
+    def test_count(self, datetime_series):
+        assert datetime_series.count() == len(datetime_series)
+
+        datetime_series[::2] = np.NaN
+
+        assert datetime_series.count() == np.isfinite(datetime_series).sum()
+
+        mi = MultiIndex.from_arrays([list("aabbcc"), [1, 2, 2, np.nan, 1, 2]])
+        ts = Series(np.arange(len(mi)), index=mi)
+
+        left = ts.count(level=1)
+        right = Series([2, 3, 1], index=[1, 2, np.nan])
+        tm.assert_series_equal(left, right)
+
+        ts.iloc[[0, 3, 5]] = np.nan
+        tm.assert_series_equal(ts.count(level=1), right - 1)
+
+        # GH#29478
+        with pd.option_context("use_inf_as_na", True):
+            assert pd.Series([pd.Timestamp("1990/1/1")]).count() == 1
+
+    def test_count_categorical(self):
+
+        ser = Series(
+            Categorical(
+                [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
+            )
+        )
+        result = ser.count()
+        assert result == 2
diff --git a/pandas/tests/series/methods/test_cov_corr.py b/pandas/tests/series/methods/test_cov_corr.py
new file mode 100644
index 0000000000000..1f6033d435323
--- /dev/null
+++ b/pandas/tests/series/methods/test_cov_corr.py
@@ -0,0 +1,158 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import Series, isna
+import pandas._testing as tm
+
+
+class TestSeriesCov:
+    def test_cov(self, datetime_series):
+        # full overlap
+        tm.assert_almost_equal(
+            datetime_series.cov(datetime_series), datetime_series.std() ** 2
+        )
+
+        # partial overlap
+        tm.assert_almost_equal(
+            datetime_series[:15].cov(datetime_series[5:]),
+            datetime_series[5:15].std() ** 2,
+        )
+
+        # No overlap
+        assert np.isnan(datetime_series[::2].cov(datetime_series[1::2]))
+
+        # all NA
+        cp = datetime_series[:10].copy()
+        cp[:] = np.nan
+        assert isna(cp.cov(cp))
+
+        # min_periods
+        assert isna(datetime_series[:15].cov(datetime_series[5:], min_periods=12))
+
+        ts1 = datetime_series[:15].reindex(datetime_series.index)
+        ts2 = datetime_series[5:].reindex(datetime_series.index)
+        assert isna(ts1.cov(ts2, min_periods=12))
+
+
+class TestSeriesCorr:
+    @td.skip_if_no_scipy
+    def test_corr(self, datetime_series):
+        import scipy.stats as stats
+
+        # full overlap
+        tm.assert_almost_equal(datetime_series.corr(datetime_series), 1)
+
+        # partial overlap
+        tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), 1)
+
+        assert isna(datetime_series[:15].corr(datetime_series[5:], min_periods=12))
+
+        ts1 = datetime_series[:15].reindex(datetime_series.index)
+        ts2 = datetime_series[5:].reindex(datetime_series.index)
+        assert isna(ts1.corr(ts2, min_periods=12))
+
+        # No overlap
+        assert np.isnan(datetime_series[::2].corr(datetime_series[1::2]))
+
+        # all NA
+        cp = datetime_series[:10].copy()
+        cp[:] = np.nan
+        assert isna(cp.corr(cp))
+
+        A = tm.makeTimeSeries()
+        B = tm.makeTimeSeries()
+        result = A.corr(B)
+        expected, _ = stats.pearsonr(A, B)
+        tm.assert_almost_equal(result, expected)
+
+    @td.skip_if_no_scipy
+    def test_corr_rank(self):
+        import scipy.stats as stats
+
+        # kendall and spearman
+        A = tm.makeTimeSeries()
+        B = tm.makeTimeSeries()
+        A[-5:] = A[:5]
+        result = A.corr(B, method="kendall")
+        expected = stats.kendalltau(A, B)[0]
+        tm.assert_almost_equal(result, expected)
+
+        result = A.corr(B, method="spearman")
+        expected = stats.spearmanr(A, B)[0]
+        tm.assert_almost_equal(result, expected)
+
+        # results from R
+        A = Series(
+            [
+                -0.89926396,
+                0.94209606,
+                -1.03289164,
+                -0.95445587,
+                0.76910310,
+                -0.06430576,
+                -2.09704447,
+                0.40660407,
+                -0.89926396,
+                0.94209606,
+            ]
+        )
+        B = Series(
+            [
+                -1.01270225,
+                -0.62210117,
+                -1.56895827,
+                0.59592943,
+                -0.01680292,
+                1.17258718,
+                -1.06009347,
+                -0.10222060,
+                -0.89076239,
+                0.89372375,
+            ]
+        )
+        kexp = 0.4319297
+        sexp = 0.5853767
+        tm.assert_almost_equal(A.corr(B, method="kendall"), kexp)
+        tm.assert_almost_equal(A.corr(B, method="spearman"), sexp)
+
+    def test_corr_invalid_method(self):
+        # GH PR #22298
+        s1 = pd.Series(np.random.randn(10))
+        s2 = pd.Series(np.random.randn(10))
+        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
+        with pytest.raises(ValueError, match=msg):
+            s1.corr(s2, method="____")
+
+    def test_corr_callable_method(self, datetime_series):
+        # simple correlation example
+        # returns 1 if exact equality, 0 otherwise
+        my_corr = lambda a, b: 1.0 if (a == b).all() else 0.0
+
+        # simple example
+        s1 = Series([1, 2, 3, 4, 5])
+        s2 = Series([5, 4, 3, 2, 1])
+        expected = 0
+        tm.assert_almost_equal(s1.corr(s2, method=my_corr), expected)
+
+        # full overlap
+        tm.assert_almost_equal(
+            datetime_series.corr(datetime_series, method=my_corr), 1.0
+        )
+
+        # partial overlap
+        tm.assert_almost_equal(
+            datetime_series[:15].corr(datetime_series[5:], method=my_corr), 1.0
+        )
+
+        # No overlap
+        assert np.isnan(
+            datetime_series[::2].corr(datetime_series[1::2], method=my_corr)
+        )
+
+        # dataframe example
+        df = pd.DataFrame([s1, s2])
+        expected = pd.DataFrame([{0: 1.0, 1: 0}, {0: 0, 1: 1.0}])
+        tm.assert_almost_equal(df.transpose().corr(method=my_corr), expected)
diff --git a/pandas/tests/series/methods/test_describe.py b/pandas/tests/series/methods/test_describe.py
new file mode 100644
index 0000000000000..4e59c6995f4f2
--- /dev/null
+++ b/pandas/tests/series/methods/test_describe.py
@@ -0,0 +1,100 @@
+import numpy as np
+
+from pandas import Period, Series, Timedelta, Timestamp, date_range
+import pandas._testing as tm
+
+
+class TestSeriesDescribe:
+    def test_describe(self):
+        s = Series([0, 1, 2, 3, 4], name="int_data")
+        result = s.describe()
+        expected = Series(
+            [5, 2, s.std(), 0, 1, 2, 3, 4],
+            name="int_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        s = Series([True, True, False, False, False], name="bool_data")
+        result = s.describe()
+        expected = Series(
+            [5, 2, False, 3], name="bool_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        s = Series(["a", "a", "b", "c", "d"], name="str_data")
+        result = s.describe()
+        expected = Series(
+            [5, 4, "a", 2], name="str_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        s = Series(
+            [
+                Timedelta("1 days"),
+                Timedelta("2 days"),
+                Timedelta("3 days"),
+                Timedelta("4 days"),
+                Timedelta("5 days"),
+            ],
+            name="timedelta_data",
+        )
+        result = s.describe()
+        expected = Series(
+            [5, s[2], s.std(), s[0], s[1], s[2], s[3], s[4]],
+            name="timedelta_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        s = Series(
+            [Period("2020-01", "M"), Period("2020-01", "M"), Period("2019-12", "M")],
+            name="period_data",
+        )
+        result = s.describe()
+        expected = Series(
+            [3, 2, s[0], 2],
+            name="period_data",
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # https://github.com/pandas-dev/pandas/issues/27183
+        s = Series([None, None], dtype=object)
+        result = s.describe()
+        expected = Series(
+            [0, 0, np.nan, np.nan],
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = s[:0].describe()
+        tm.assert_series_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2])
+        assert np.isnan(result.iloc[3])
+
+    def test_describe_with_tz(self, tz_naive_fixture):
+        # GH 21332
+        tz = tz_naive_fixture
+        name = str(tz_naive_fixture)
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s = Series(date_range(start, end, tz=tz), name=name)
+        result = s.describe()
+        expected = Series(
+            [
+                5,
+                Timestamp(2018, 1, 3).tz_localize(tz),
+                start.tz_localize(tz),
+                s[1],
+                s[2],
+                s[3],
+                end.tz_localize(tz),
+            ],
+            name=name,
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_diff.py b/pandas/tests/series/methods/test_diff.py
new file mode 100644
index 0000000000000..033f75e95f11b
--- /dev/null
+++ b/pandas/tests/series/methods/test_diff.py
@@ -0,0 +1,77 @@
+import numpy as np
+import pytest
+
+from pandas import Series, TimedeltaIndex, date_range
+import pandas._testing as tm
+
+
+class TestSeriesDiff:
+    def test_diff_np(self):
+        pytest.skip("skipping due to Series no longer being an ndarray")
+
+        # no longer works as the return type of np.diff is now nd.array
+        s = Series(np.arange(5))
+
+        r = np.diff(s)
+        tm.assert_series_equal(Series([np.nan, 0, 0, 0, np.nan]), r)
+
+    def test_diff_int(self):
+        # int dtype
+        a = 10000000000000000
+        b = a + 1
+        s = Series([a, b])
+
+        result = s.diff()
+        assert result[1] == 1
+
+    def test_diff_tz(self):
+        # Combined datetime diff, normal diff and boolean diff test
+        ts = tm.makeTimeSeries(name="ts")
+        ts.diff()
+
+        # neg n
+        result = ts.diff(-1)
+        expected = ts - ts.shift(-1)
+        tm.assert_series_equal(result, expected)
+
+        # 0
+        result = ts.diff(0)
+        expected = ts - ts
+        tm.assert_series_equal(result, expected)
+
+        # datetime diff (GH#3100)
+        s = Series(date_range("20130102", periods=5))
+        result = s.diff()
+        expected = s - s.shift(1)
+        tm.assert_series_equal(result, expected)
+
+        # timedelta diff
+        result = result - result.shift(1)  # previous result
+        expected = expected.diff()  # previously expected
+        tm.assert_series_equal(result, expected)
+
+        # with tz
+        s = Series(
+            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
+        )
+        result = s.diff()
+        expected = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input,output,diff",
+        [([False, True, True, False, False], [np.nan, True, False, True, False], 1)],
+    )
+    def test_diff_bool(self, input, output, diff):
+        # boolean series (test for fixing #17294)
+        s = Series(input)
+        result = s.diff()
+        expected = Series(output)
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_object_dtype(self):
+        # object series
+        s = Series([False, True, 5.0, np.nan, True, False])
+        result = s.diff()
+        expected = s - s.shift(1)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_drop_duplicates.py b/pandas/tests/series/methods/test_drop_duplicates.py
new file mode 100644
index 0000000000000..2d052505d5ecc
--- /dev/null
+++ b/pandas/tests/series/methods/test_drop_duplicates.py
@@ -0,0 +1,141 @@
+import numpy as np
+import pytest
+
+from pandas import Categorical, Series
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, False, False, True, True, False])),
+        ("last", Series([False, True, True, False, False, False, False])),
+        (False, Series([False, True, True, False, True, True, False])),
+    ],
+)
+def test_drop_duplicates(any_numpy_dtype, keep, expected):
+    tc = Series([1, 0, 3, 5, 3, 0, 4], dtype=np.dtype(any_numpy_dtype))
+
+    if tc.dtype == "bool":
+        pytest.skip("tested separately in test_drop_duplicates_bool")
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    sc.drop_duplicates(keep=keep, inplace=True)
+    tm.assert_series_equal(sc, tc[~expected])
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, True])),
+        ("last", Series([True, True, False, False])),
+        (False, Series([True, True, True, True])),
+    ],
+)
+def test_drop_duplicates_bool(keep, expected):
+    tc = Series([True, False, True, False])
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    sc.drop_duplicates(keep=keep, inplace=True)
+    tm.assert_series_equal(sc, tc[~expected])
+
+
+class TestSeriesDropDuplicates:
+    @pytest.mark.parametrize(
+        "dtype",
+        ["int_", "uint", "float_", "unicode_", "timedelta64[h]", "datetime64[D]"],
+    )
+    def test_drop_duplicates_categorical_non_bool(self, dtype, ordered_fixture):
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
+        # Test case 1
+        input1 = np.array([1, 2, 3, 3], dtype=np.dtype(dtype))
+        tc1 = Series(Categorical(input1, categories=cat_array, ordered=ordered_fixture))
+        if dtype == "datetime64[D]":
+            # pre-empty flaky xfail, tc1 values are seemingly-random
+            if not (np.array(tc1) == input1).all():
+                pytest.xfail(reason="GH#7996")
+
+        expected = Series([False, False, False, True])
+        tm.assert_series_equal(tc1.duplicated(), expected)
+        tm.assert_series_equal(tc1.drop_duplicates(), tc1[~expected])
+        sc = tc1.copy()
+        sc.drop_duplicates(inplace=True)
+        tm.assert_series_equal(sc, tc1[~expected])
+
+        expected = Series([False, False, True, False])
+        tm.assert_series_equal(tc1.duplicated(keep="last"), expected)
+        tm.assert_series_equal(tc1.drop_duplicates(keep="last"), tc1[~expected])
+        sc = tc1.copy()
+        sc.drop_duplicates(keep="last", inplace=True)
+        tm.assert_series_equal(sc, tc1[~expected])
+
+        expected = Series([False, False, True, True])
+        tm.assert_series_equal(tc1.duplicated(keep=False), expected)
+        tm.assert_series_equal(tc1.drop_duplicates(keep=False), tc1[~expected])
+        sc = tc1.copy()
+        sc.drop_duplicates(keep=False, inplace=True)
+        tm.assert_series_equal(sc, tc1[~expected])
+
+        # Test case 2
+        input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
+        tc2 = Series(Categorical(input2, categories=cat_array, ordered=ordered_fixture))
+        if dtype == "datetime64[D]":
+            # pre-empty flaky xfail, tc2 values are seemingly-random
+            if not (np.array(tc2) == input2).all():
+                pytest.xfail(reason="GH#7996")
+
+        expected = Series([False, False, False, False, True, True, False])
+        tm.assert_series_equal(tc2.duplicated(), expected)
+        tm.assert_series_equal(tc2.drop_duplicates(), tc2[~expected])
+        sc = tc2.copy()
+        sc.drop_duplicates(inplace=True)
+        tm.assert_series_equal(sc, tc2[~expected])
+
+        expected = Series([False, True, True, False, False, False, False])
+        tm.assert_series_equal(tc2.duplicated(keep="last"), expected)
+        tm.assert_series_equal(tc2.drop_duplicates(keep="last"), tc2[~expected])
+        sc = tc2.copy()
+        sc.drop_duplicates(keep="last", inplace=True)
+        tm.assert_series_equal(sc, tc2[~expected])
+
+        expected = Series([False, True, True, False, True, True, False])
+        tm.assert_series_equal(tc2.duplicated(keep=False), expected)
+        tm.assert_series_equal(tc2.drop_duplicates(keep=False), tc2[~expected])
+        sc = tc2.copy()
+        sc.drop_duplicates(keep=False, inplace=True)
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_bool(self, ordered_fixture):
+        tc = Series(
+            Categorical(
+                [True, False, True, False],
+                categories=[True, False],
+                ordered=ordered_fixture,
+            )
+        )
+
+        expected = Series([False, False, True, True])
+        tm.assert_series_equal(tc.duplicated(), expected)
+        tm.assert_series_equal(tc.drop_duplicates(), tc[~expected])
+        sc = tc.copy()
+        sc.drop_duplicates(inplace=True)
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, False, False])
+        tm.assert_series_equal(tc.duplicated(keep="last"), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep="last"), tc[~expected])
+        sc = tc.copy()
+        sc.drop_duplicates(keep="last", inplace=True)
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, True, True])
+        tm.assert_series_equal(tc.duplicated(keep=False), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep=False), tc[~expected])
+        sc = tc.copy()
+        sc.drop_duplicates(keep=False, inplace=True)
+        tm.assert_series_equal(sc, tc[~expected])
diff --git a/pandas/tests/series/methods/test_duplicated.py b/pandas/tests/series/methods/test_duplicated.py
new file mode 100644
index 0000000000000..5cc297913e851
--- /dev/null
+++ b/pandas/tests/series/methods/test_duplicated.py
@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True], name="name")),
+        ("last", Series([True, True, False, False, False], name="name")),
+        (False, Series([True, True, True, False, True], name="name")),
+    ],
+)
+def test_duplicated_keep(keep, expected):
+    ser = Series(["a", "b", "b", "c", "a"], name="name")
+
+    result = ser.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_nan_none(keep, expected):
+    ser = Series([np.nan, 3, 3, None, np.nan], dtype=object)
+
+    result = ser.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_explode.py b/pandas/tests/series/methods/test_explode.py
similarity index 90%
rename from pandas/tests/series/test_explode.py
rename to pandas/tests/series/methods/test_explode.py
index 331546f7dc73d..979199e1efc62 100644
--- a/pandas/tests/series/test_explode.py
+++ b/pandas/tests/series/methods/test_explode.py
@@ -2,7 +2,7 @@
 import pytest
 
 import pandas as pd
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 def test_basic():
@@ -29,7 +29,7 @@ def test_mixed_type():
 
 
 def test_empty():
-    s = pd.Series()
+    s = pd.Series(dtype=object)
     result = s.explode()
     expected = s.copy()
     tm.assert_series_equal(result, expected)
@@ -111,3 +111,11 @@ def test_nested_EA():
         pd.date_range("20170101", periods=6, tz="UTC"), index=[0, 0, 0, 1, 1, 1]
     )
     tm.assert_series_equal(result, expected)
+
+
+def test_duplicate_index():
+    # GH 28005
+    s = pd.Series([[1, 2], [3, 4]], index=[0, 0])
+    result = s.explode()
+    expected = pd.Series([1, 2, 3, 4], index=[0, 0, 0, 0], dtype=object)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_head_tail.py b/pandas/tests/series/methods/test_head_tail.py
new file mode 100644
index 0000000000000..d9f8d85eda350
--- /dev/null
+++ b/pandas/tests/series/methods/test_head_tail.py
@@ -0,0 +1,8 @@
+import pandas._testing as tm
+
+
+def test_head_tail(string_series):
+    tm.assert_series_equal(string_series.head(), string_series[:5])
+    tm.assert_series_equal(string_series.head(0), string_series[0:0])
+    tm.assert_series_equal(string_series.tail(), string_series[-5:])
+    tm.assert_series_equal(string_series.tail(0), string_series[0:0])
diff --git a/pandas/tests/series/methods/test_isin.py b/pandas/tests/series/methods/test_isin.py
new file mode 100644
index 0000000000000..3836c1d56bf87
--- /dev/null
+++ b/pandas/tests/series/methods/test_isin.py
@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series, date_range
+import pandas._testing as tm
+
+
+class TestSeriesIsIn:
+    def test_isin(self):
+        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
+
+        result = s.isin(["A", "C"])
+        expected = Series([True, False, True, False, False, False, True, True])
+        tm.assert_series_equal(result, expected)
+
+        # GH#16012
+        # This specific issue has to have a series over 1e6 in len, but the
+        # comparison array (in_list) must be large enough so that numpy doesn't
+        # do a manual masking trick that will avoid this issue altogether
+        s = Series(list("abcdefghijk" * 10 ** 5))
+        # If numpy doesn't do the manual comparison/mask, these
+        # unorderable mixed types are what cause the exception in numpy
+        in_list = [-1, "a", "b", "G", "Y", "Z", "E", "K", "E", "S", "I", "R", "R"] * 6
+
+        assert s.isin(in_list).sum() == 200000
+
+    def test_isin_with_string_scalar(self):
+        # GH#4763
+        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
+        msg = (
+            r"only list-like objects are allowed to be passed to isin\(\), "
+            r"you passed a \[str\]"
+        )
+        with pytest.raises(TypeError, match=msg):
+            s.isin("a")
+
+        s = Series(["aaa", "b", "c"])
+        with pytest.raises(TypeError, match=msg):
+            s.isin("aaa")
+
+    def test_isin_with_i8(self):
+        # GH#5021
+
+        expected = Series([True, True, False, False, False])
+        expected2 = Series([False, True, False, False, False])
+
+        # datetime64[ns]
+        s = Series(date_range("jan-01-2013", "jan-05-2013"))
+
+        result = s.isin(s[0:2])
+        tm.assert_series_equal(result, expected)
+
+        result = s.isin(s[0:2].values)
+        tm.assert_series_equal(result, expected)
+
+        # fails on dtype conversion in the first place
+        result = s.isin(s[0:2].values.astype("datetime64[D]"))
+        tm.assert_series_equal(result, expected)
+
+        result = s.isin([s[1]])
+        tm.assert_series_equal(result, expected2)
+
+        result = s.isin([np.datetime64(s[1])])
+        tm.assert_series_equal(result, expected2)
+
+        result = s.isin(set(s[0:2]))
+        tm.assert_series_equal(result, expected)
+
+        # timedelta64[ns]
+        s = Series(pd.to_timedelta(range(5), unit="d"))
+        result = s.isin(s[0:2])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_isin_empty(self, empty):
+        # see GH#16991
+        s = Series(["a", "b"])
+        expected = Series([False, False])
+
+        result = s.isin(empty)
+        tm.assert_series_equal(expected, result)
diff --git a/pandas/tests/series/methods/test_nlargest.py b/pandas/tests/series/methods/test_nlargest.py
new file mode 100644
index 0000000000000..a029965c7394f
--- /dev/null
+++ b/pandas/tests/series/methods/test_nlargest.py
@@ -0,0 +1,213 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+main_dtypes = [
+    "datetime",
+    "datetimetz",
+    "timedelta",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "float32",
+    "float64",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+]
+
+
+@pytest.fixture
+def s_main_dtypes():
+    """
+    A DataFrame with many dtypes
+
+    * datetime
+    * datetimetz
+    * timedelta
+    * [u]int{8,16,32,64}
+    * float{32,64}
+
+    The columns are the name of the dtype.
+    """
+    df = pd.DataFrame(
+        {
+            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+            "datetimetz": pd.to_datetime(
+                ["2003", "2002", "2001", "2002", "2005"]
+            ).tz_localize("US/Eastern"),
+            "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
+        }
+    )
+
+    for dtype in [
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+    ]:
+        df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
+
+    return df
+
+
+@pytest.fixture(params=main_dtypes)
+def s_main_dtypes_split(request, s_main_dtypes):
+    """Each series in s_main_dtypes."""
+    return s_main_dtypes[request.param]
+
+
+def assert_check_nselect_boundary(vals, dtype, method):
+    # helper function for 'test_boundary_{dtype}' tests
+    ser = Series(vals, dtype=dtype)
+    result = getattr(ser, method)(3)
+    expected_idxr = [0, 1, 2] if method == "nsmallest" else [3, 2, 1]
+    expected = ser.loc[expected_idxr]
+    tm.assert_series_equal(result, expected)
+
+
+class TestSeriesNLargestNSmallest:
+    @pytest.mark.parametrize(
+        "r",
+        [
+            Series([3.0, 2, 1, 2, "5"], dtype="object"),
+            Series([3.0, 2, 1, 2, 5], dtype="object"),
+            # not supported on some archs
+            # Series([3., 2, 1, 2, 5], dtype='complex256'),
+            Series([3.0, 2, 1, 2, 5], dtype="complex128"),
+            Series(list("abcde")),
+            Series(list("abcde"), dtype="category"),
+        ],
+    )
+    def test_nlargest_error(self, r):
+        dt = r.dtype
+        msg = "Cannot use method 'n(larg|small)est' with dtype {dt}".format(dt=dt)
+        args = 2, len(r), 0, -1
+        methods = r.nlargest, r.nsmallest
+        for method, arg in product(methods, args):
+            with pytest.raises(TypeError, match=msg):
+                method(arg)
+
+    def test_nsmallest_nlargest(self, s_main_dtypes_split):
+        # float, int, datetime64 (use i8), timedelts64 (same),
+        # object that are numbers, object that are strings
+        ser = s_main_dtypes_split
+
+        tm.assert_series_equal(ser.nsmallest(2), ser.iloc[[2, 1]])
+        tm.assert_series_equal(ser.nsmallest(2, keep="last"), ser.iloc[[2, 3]])
+
+        empty = ser.iloc[0:0]
+        tm.assert_series_equal(ser.nsmallest(0), empty)
+        tm.assert_series_equal(ser.nsmallest(-1), empty)
+        tm.assert_series_equal(ser.nlargest(0), empty)
+        tm.assert_series_equal(ser.nlargest(-1), empty)
+
+        tm.assert_series_equal(ser.nsmallest(len(ser)), ser.sort_values())
+        tm.assert_series_equal(ser.nsmallest(len(ser) + 1), ser.sort_values())
+        tm.assert_series_equal(ser.nlargest(len(ser)), ser.iloc[[4, 0, 1, 3, 2]])
+        tm.assert_series_equal(ser.nlargest(len(ser) + 1), ser.iloc[[4, 0, 1, 3, 2]])
+
+    def test_nlargest_misc(self):
+
+        ser = Series([3.0, np.nan, 1, 2, 5])
+        tm.assert_series_equal(ser.nlargest(), ser.iloc[[4, 0, 3, 2]])
+        tm.assert_series_equal(ser.nsmallest(), ser.iloc[[2, 3, 0, 4]])
+
+        msg = 'keep must be either "first", "last"'
+        with pytest.raises(ValueError, match=msg):
+            ser.nsmallest(keep="invalid")
+        with pytest.raises(ValueError, match=msg):
+            ser.nlargest(keep="invalid")
+
+        # GH#15297
+        ser = Series([1] * 5, index=[1, 2, 3, 4, 5])
+        expected_first = Series([1] * 3, index=[1, 2, 3])
+        expected_last = Series([1] * 3, index=[5, 4, 3])
+
+        result = ser.nsmallest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nsmallest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+        result = ser.nlargest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nlargest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+    @pytest.mark.parametrize("n", range(1, 5))
+    def test_nlargest_n(self, n):
+
+        # GH 13412
+        ser = Series([1, 4, 3, 2], index=[0, 0, 1, 1])
+        result = ser.nlargest(n)
+        expected = ser.sort_values(ascending=False).head(n)
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(n)
+        expected = ser.sort_values().head(n)
+        tm.assert_series_equal(result, expected)
+
+    def test_nlargest_boundary_integer(self, nselect_method, any_int_dtype):
+        # GH#21426
+        dtype_info = np.iinfo(any_int_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val, min_val + 1, max_val - 1, max_val]
+        assert_check_nselect_boundary(vals, any_int_dtype, nselect_method)
+
+    def test_nlargest_boundary_float(self, nselect_method, float_dtype):
+        # GH#21426
+        dtype_info = np.finfo(float_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        min_2nd, max_2nd = np.nextafter([min_val, max_val], 0, dtype=float_dtype)
+        vals = [min_val, min_2nd, max_2nd, max_val]
+        assert_check_nselect_boundary(vals, float_dtype, nselect_method)
+
+    @pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+    def test_nlargest_boundary_datetimelike(self, nselect_method, dtype):
+        # GH#21426
+        # use int64 bounds and +1 to min_val since true minimum is NaT
+        # (include min_val/NaT at end to maintain same expected_idxr)
+        dtype_info = np.iinfo("int64")
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val + 1, min_val + 2, max_val - 1, max_val, min_val]
+        assert_check_nselect_boundary(vals, dtype, nselect_method)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # see GH#16818
+        ser = Series([10, 9, 8, 7, 7, 7, 7, 6])
+        result = ser.nlargest(4, keep="all")
+        expected = Series([10, 9, 8, 7, 7, 7, 7])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(2, keep="all")
+        expected = Series([6, 7, 7, 7, 7], index=[7, 3, 4, 5, 6])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data,expected", [([True, False], [True]), ([True, False, True, True], [True])]
+    )
+    def test_nlargest_boolean(self, data, expected):
+        # GH#26154 : ensure True > False
+        ser = Series(data)
+        result = ser.nlargest(1)
+        expected = Series(expected)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_pct_change.py b/pandas/tests/series/methods/test_pct_change.py
new file mode 100644
index 0000000000000..1efb57894f986
--- /dev/null
+++ b/pandas/tests/series/methods/test_pct_change.py
@@ -0,0 +1,79 @@
+import numpy as np
+import pytest
+
+from pandas import Series, date_range
+import pandas._testing as tm
+
+
+class TestSeriesPctChange:
+    def test_pct_change(self, datetime_series):
+        rs = datetime_series.pct_change(fill_method=None)
+        tm.assert_series_equal(rs, datetime_series / datetime_series.shift(1) - 1)
+
+        rs = datetime_series.pct_change(2)
+        filled = datetime_series.fillna(method="pad")
+        tm.assert_series_equal(rs, filled / filled.shift(2) - 1)
+
+        rs = datetime_series.pct_change(fill_method="bfill", limit=1)
+        filled = datetime_series.fillna(method="bfill", limit=1)
+        tm.assert_series_equal(rs, filled / filled.shift(1) - 1)
+
+        rs = datetime_series.pct_change(freq="5D")
+        filled = datetime_series.fillna(method="pad")
+        tm.assert_series_equal(
+            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
+        )
+
+    def test_pct_change_with_duplicate_axis(self):
+        # GH#28664
+        common_idx = date_range("2019-11-14", periods=5, freq="D")
+        result = Series(range(5), common_idx).pct_change(freq="B")
+
+        # the reason that the expected should be like this is documented at PR 28681
+        expected = Series([np.NaN, np.inf, np.NaN, np.NaN, 3.0], common_idx)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_pct_change_shift_over_nas(self):
+        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
+
+        chg = s.pct_change()
+        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
+        tm.assert_series_equal(chg, expected)
+
+    @pytest.mark.parametrize(
+        "freq, periods, fill_method, limit",
+        [
+            ("5B", 5, None, None),
+            ("3B", 3, None, None),
+            ("3B", 3, "bfill", None),
+            ("7B", 7, "pad", 1),
+            ("7B", 7, "bfill", 3),
+            ("14B", 14, None, None),
+        ],
+    )
+    def test_pct_change_periods_freq(
+        self, freq, periods, fill_method, limit, datetime_series
+    ):
+        # GH#7292
+        rs_freq = datetime_series.pct_change(
+            freq=freq, fill_method=fill_method, limit=limit
+        )
+        rs_periods = datetime_series.pct_change(
+            periods, fill_method=fill_method, limit=limit
+        )
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+        empty_ts = Series(index=datetime_series.index, dtype=object)
+        rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
+        rs_periods = empty_ts.pct_change(periods, fill_method=fill_method, limit=limit)
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+
+@pytest.mark.parametrize("fill_method", ["pad", "ffill", None])
+def test_pct_change_with_duplicated_indices(fill_method):
+    # GH30463
+    s = Series([np.nan, 1, 2, 3, 9, 18], index=["a", "b"] * 3)
+    result = s.pct_change(fill_method=fill_method)
+    expected = Series([np.nan, np.nan, 1.0, 0.5, 2.0, 1.0], index=["a", "b"] * 3)
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_quantile.py b/pandas/tests/series/methods/test_quantile.py
similarity index 78%
rename from pandas/tests/series/test_quantile.py
rename to pandas/tests/series/methods/test_quantile.py
index b001312fa37f3..79f50afca658f 100644
--- a/pandas/tests/series/test_quantile.py
+++ b/pandas/tests/series/methods/test_quantile.py
@@ -5,27 +5,25 @@
 
 import pandas as pd
 from pandas import Index, Series
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import Timestamp
-import pandas.util.testing as tm
 
-from .common import TestData
 
+class TestSeriesQuantile:
+    def test_quantile(self, datetime_series):
 
-class TestSeriesQuantile(TestData):
-    def test_quantile(self):
+        q = datetime_series.quantile(0.1)
+        assert q == np.percentile(datetime_series.dropna(), 10)
 
-        q = self.ts.quantile(0.1)
-        assert q == np.percentile(self.ts.dropna(), 10)
-
-        q = self.ts.quantile(0.9)
-        assert q == np.percentile(self.ts.dropna(), 90)
+        q = datetime_series.quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
 
         # object dtype
-        q = Series(self.ts, dtype=object).quantile(0.9)
-        assert q == np.percentile(self.ts.dropna(), 90)
+        q = Series(datetime_series, dtype=object).quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
 
         # datetime64[ns] dtype
-        dts = self.ts.index.to_series()
+        dts = datetime_series.index.to_series()
         q = dts.quantile(0.2)
         assert q == Timestamp("2000-01-10 19:12:00")
 
@@ -41,20 +39,23 @@ def test_quantile(self):
         msg = "percentiles should all be in the interval \\[0, 1\\]"
         for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
             with pytest.raises(ValueError, match=msg):
-                self.ts.quantile(invalid)
+                datetime_series.quantile(invalid)
 
-    def test_quantile_multi(self):
+    def test_quantile_multi(self, datetime_series):
 
         qs = [0.1, 0.9]
-        result = self.ts.quantile(qs)
+        result = datetime_series.quantile(qs)
         expected = pd.Series(
-            [np.percentile(self.ts.dropna(), 10), np.percentile(self.ts.dropna(), 90)],
+            [
+                np.percentile(datetime_series.dropna(), 10),
+                np.percentile(datetime_series.dropna(), 90),
+            ],
             index=qs,
-            name=self.ts.name,
+            name=datetime_series.name,
         )
         tm.assert_series_equal(result, expected)
 
-        dts = self.ts.index.to_series()
+        dts = datetime_series.index.to_series()
         dts.name = "xxx"
         result = dts.quantile((0.2, 0.2))
         expected = Series(
@@ -64,18 +65,20 @@ def test_quantile_multi(self):
         )
         tm.assert_series_equal(result, expected)
 
-        result = self.ts.quantile([])
-        expected = pd.Series([], name=self.ts.name, index=Index([], dtype=float))
+        result = datetime_series.quantile([])
+        expected = pd.Series(
+            [], name=datetime_series.name, index=Index([], dtype=float), dtype="float64"
+        )
         tm.assert_series_equal(result, expected)
 
-    def test_quantile_interpolation(self):
+    def test_quantile_interpolation(self, datetime_series):
         # see gh-10174
 
         # interpolation = linear (default case)
-        q = self.ts.quantile(0.1, interpolation="linear")
-        assert q == np.percentile(self.ts.dropna(), 10)
-        q1 = self.ts.quantile(0.1)
-        assert q1 == np.percentile(self.ts.dropna(), 10)
+        q = datetime_series.quantile(0.1, interpolation="linear")
+        assert q == np.percentile(datetime_series.dropna(), 10)
+        q1 = datetime_series.quantile(0.1)
+        assert q1 == np.percentile(datetime_series.dropna(), 10)
 
         # test with and without interpolation keyword
         assert q == q1
@@ -101,7 +104,8 @@ def test_quantile_nan(self):
         assert result == expected
 
         # all nan/empty
-        cases = [Series([]), Series([np.nan, np.nan])]
+        s1 = Series([], dtype=object)
+        cases = [s1, Series([np.nan, np.nan])]
 
         for s in cases:
             res = s.quantile(0.5)
diff --git a/pandas/tests/series/test_rank.py b/pandas/tests/series/methods/test_rank.py
similarity index 85%
rename from pandas/tests/series/test_rank.py
rename to pandas/tests/series/methods/test_rank.py
index f93e1651c8b10..3d4688c8274f9 100644
--- a/pandas/tests/series/test_rank.py
+++ b/pandas/tests/series/methods/test_rank.py
@@ -1,7 +1,6 @@
 from itertools import chain, product
 
 import numpy as np
-from numpy import nan
 import pytest
 
 from pandas._libs.algos import Infinity, NegInfinity
@@ -9,37 +8,35 @@
 import pandas.util._test_decorators as td
 
 from pandas import NaT, Series, Timestamp, date_range
+import pandas._testing as tm
 from pandas.api.types import CategoricalDtype
-from pandas.tests.series.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
 
 
-class TestSeriesRank(TestData):
-    s = Series([1, 3, 4, 2, nan, 2, 1, 5, nan, 3])
+class TestSeriesRank:
+    s = Series([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])
 
     results = {
-        "average": np.array([1.5, 5.5, 7.0, 3.5, nan, 3.5, 1.5, 8.0, nan, 5.5]),
-        "min": np.array([1, 5, 7, 3, nan, 3, 1, 8, nan, 5]),
-        "max": np.array([2, 6, 7, 4, nan, 4, 2, 8, nan, 6]),
-        "first": np.array([1, 5, 7, 3, nan, 4, 2, 8, nan, 6]),
-        "dense": np.array([1, 3, 4, 2, nan, 2, 1, 5, nan, 3]),
+        "average": np.array([1.5, 5.5, 7.0, 3.5, np.nan, 3.5, 1.5, 8.0, np.nan, 5.5]),
+        "min": np.array([1, 5, 7, 3, np.nan, 3, 1, 8, np.nan, 5]),
+        "max": np.array([2, 6, 7, 4, np.nan, 4, 2, 8, np.nan, 6]),
+        "first": np.array([1, 5, 7, 3, np.nan, 4, 2, 8, np.nan, 6]),
+        "dense": np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3]),
     }
 
-    def test_rank(self):
+    def test_rank(self, datetime_series):
         pytest.importorskip("scipy.stats.special")
         rankdata = pytest.importorskip("scipy.stats.rankdata")
 
-        self.ts[::2] = np.nan
-        self.ts[:10][::3] = 4.0
+        datetime_series[::2] = np.nan
+        datetime_series[:10][::3] = 4.0
 
-        ranks = self.ts.rank()
-        oranks = self.ts.astype("O").rank()
+        ranks = datetime_series.rank()
+        oranks = datetime_series.astype("O").rank()
 
-        assert_series_equal(ranks, oranks)
+        tm.assert_series_equal(ranks, oranks)
 
-        mask = np.isnan(self.ts)
-        filled = self.ts.fillna(np.inf)
+        mask = np.isnan(datetime_series)
+        filled = datetime_series.fillna(np.inf)
 
         # rankdata returns a ndarray
         exp = Series(rankdata(filled), index=filled.index, name="ts")
@@ -51,58 +48,58 @@ def test_rank(self):
 
         iranks = iseries.rank()
         exp = iseries.astype(float).rank()
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
         iseries = Series(np.arange(5)) + 1.0
         exp = iseries / 5.0
         iranks = iseries.rank(pct=True)
 
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries = Series(np.repeat(1, 100))
         exp = Series(np.repeat(0.505, 100))
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries[1] = np.nan
         exp = Series(np.repeat(50.0 / 99.0, 100))
         exp[1] = np.nan
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries = Series(np.arange(5)) + 1.0
         iseries[4] = np.nan
         exp = iseries / 4.0
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries = Series(np.repeat(np.nan, 100))
         exp = iseries.copy()
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries = Series(np.arange(5)) + 1
         iseries[4] = np.nan
         exp = iseries / 4.0
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         rng = date_range("1/1/1990", periods=5)
         iseries = Series(np.arange(5), rng) + 1
         iseries.iloc[4] = np.nan
         exp = iseries / 4.0
         iranks = iseries.rank(pct=True)
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         iseries = Series([1e-50, 1e-100, 1e-20, 1e-2, 1e-20 + 1e-30, 1e-1])
         exp = Series([2, 1, 3, 5, 4, 6.0])
         iranks = iseries.rank()
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         # GH 5968
         iseries = Series(["3 day", "1 day 10m", "-2 day", NaT], dtype="m8[ns]")
         exp = Series([3, 2, 1, np.nan])
         iranks = iseries.rank()
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
         values = np.array(
             [-50, -1, -1e-20, -1e-25, -1e-50, 0, 1e-40, 1e-20, 1e-10, 2, 40],
@@ -112,7 +109,7 @@ def test_rank(self):
         iseries = Series(values[random_order])
         exp = Series(random_order + 1.0, dtype="float64")
         iranks = iseries.rank()
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
     def test_rank_categorical(self):
         # GH issue #15420 rank incorrectly orders ordered categories
@@ -128,8 +125,8 @@ def test_rank_categorical(self):
                 ordered=True,
             )
         )
-        assert_series_equal(ordered.rank(), exp)
-        assert_series_equal(ordered.rank(ascending=False), exp_desc)
+        tm.assert_series_equal(ordered.rank(), exp)
+        tm.assert_series_equal(ordered.rank(ascending=False), exp_desc)
 
         # Unordered categoricals should be ranked as objects
         unordered = Series(
@@ -142,14 +139,14 @@ def test_rank_categorical(self):
         )
         exp_unordered = Series([2.0, 4.0, 6.0, 3.0, 1.0, 5.0])
         res = unordered.rank()
-        assert_series_equal(res, exp_unordered)
+        tm.assert_series_equal(res, exp_unordered)
 
         unordered1 = Series([1, 2, 3, 4, 5, 6]).astype(
             CategoricalDtype([1, 2, 3, 4, 5, 6], False)
         )
         exp_unordered1 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
         res1 = unordered1.rank()
-        assert_series_equal(res1, exp_unordered1)
+        tm.assert_series_equal(res1, exp_unordered1)
 
         # Test na_option for rank data
         na_ser = Series(
@@ -165,18 +162,20 @@ def test_rank_categorical(self):
         exp_bot = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
         exp_keep = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, np.NaN])
 
-        assert_series_equal(na_ser.rank(na_option="top"), exp_top)
-        assert_series_equal(na_ser.rank(na_option="bottom"), exp_bot)
-        assert_series_equal(na_ser.rank(na_option="keep"), exp_keep)
+        tm.assert_series_equal(na_ser.rank(na_option="top"), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom"), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep"), exp_keep)
 
         # Test na_option for rank data with ascending False
         exp_top = Series([7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
         exp_bot = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 7.0])
         exp_keep = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, np.NaN])
 
-        assert_series_equal(na_ser.rank(na_option="top", ascending=False), exp_top)
-        assert_series_equal(na_ser.rank(na_option="bottom", ascending=False), exp_bot)
-        assert_series_equal(na_ser.rank(na_option="keep", ascending=False), exp_keep)
+        tm.assert_series_equal(na_ser.rank(na_option="top", ascending=False), exp_top)
+        tm.assert_series_equal(
+            na_ser.rank(na_option="bottom", ascending=False), exp_bot
+        )
+        tm.assert_series_equal(na_ser.rank(na_option="keep", ascending=False), exp_keep)
 
         # Test invalid values for na_option
         msg = "na_option must be one of 'keep', 'top', or 'bottom'"
@@ -196,16 +195,15 @@ def test_rank_categorical(self):
         exp_bot = Series([0.2, 0.4, 0.6, 0.8, 1.0])
         exp_keep = Series([0.25, 0.5, 0.75, 1.0, np.NaN])
 
-        assert_series_equal(na_ser.rank(na_option="top", pct=True), exp_top)
-        assert_series_equal(na_ser.rank(na_option="bottom", pct=True), exp_bot)
-        assert_series_equal(na_ser.rank(na_option="keep", pct=True), exp_keep)
+        tm.assert_series_equal(na_ser.rank(na_option="top", pct=True), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom", pct=True), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep", pct=True), exp_keep)
 
     def test_rank_signature(self):
         s = Series([0, 1])
         s.rank(method="average")
         msg = (
-            "No axis named average for object type"
-            " <class 'pandas.core.series.Series'>"
+            "No axis named average for object type <class 'pandas.core.series.Series'>"
         )
         with pytest.raises(ValueError, match=msg):
             s.rank("average")
@@ -293,7 +291,7 @@ def test_rank_inf(self, contents, dtype):
         iseries = Series(values[random_order])
         exp = Series(exp_order[random_order], dtype="float64")
         iranks = iseries.rank()
-        assert_series_equal(iranks, exp)
+        tm.assert_series_equal(iranks, exp)
 
     def test_rank_tie_methods(self):
         s = self.s
@@ -396,7 +394,7 @@ def test_rank_dense_method(self):
                 s = Series(ser).astype(dtype)
                 result = s.rank(method="dense")
                 expected = Series(exp).astype(result.dtype)
-                assert_series_equal(result, expected)
+                tm.assert_series_equal(result, expected)
 
     def test_rank_descending(self):
         dtypes = ["O", "f8", "i8"]
@@ -409,14 +407,14 @@ def test_rank_descending(self):
 
             res = s.rank(ascending=False)
             expected = (s.max() - s).rank()
-            assert_series_equal(res, expected)
+            tm.assert_series_equal(res, expected)
 
             if method == "first" and dtype == "O":
                 continue
 
             expected = (s.max() - s).rank(method=method)
             res2 = s.rank(method=method, ascending=False)
-            assert_series_equal(res2, expected)
+            tm.assert_series_equal(res2, expected)
 
     def test_rank_int(self):
         s = self.s.dropna().astype("i8")
@@ -425,7 +423,7 @@ def test_rank_int(self):
             result = s.rank(method=method)
             expected = Series(res).dropna()
             expected.index = result.index
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
     def test_rank_object_bug(self):
         # GH 13445
@@ -442,7 +440,7 @@ def test_rank_modify_inplace(self):
 
         s.rank()
         result = s
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
 
 # GH15630, pct should be on 100% basis when method='dense'
@@ -467,7 +465,7 @@ def test_rank_dense_pct(dtype, ser, exp):
     s = Series(ser).astype(dtype)
     result = s.rank(method="dense", pct=True)
     expected = Series(exp).astype(result.dtype)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("dtype", ["O", "f8", "i8"])
@@ -489,7 +487,7 @@ def test_rank_min_pct(dtype, ser, exp):
     s = Series(ser).astype(dtype)
     result = s.rank(method="min", pct=True)
     expected = Series(exp).astype(result.dtype)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("dtype", ["O", "f8", "i8"])
@@ -511,7 +509,7 @@ def test_rank_max_pct(dtype, ser, exp):
     s = Series(ser).astype(dtype)
     result = s.rank(method="max", pct=True)
     expected = Series(exp).astype(result.dtype)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("dtype", ["O", "f8", "i8"])
@@ -533,7 +531,7 @@ def test_rank_average_pct(dtype, ser, exp):
     s = Series(ser).astype(dtype)
     result = s.rank(method="average", pct=True)
     expected = Series(exp).astype(result.dtype)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("dtype", ["f8", "i8"])
@@ -555,7 +553,7 @@ def test_rank_first_pct(dtype, ser, exp):
     s = Series(ser).astype(dtype)
     result = s.rank(method="first", pct=True)
     expected = Series(exp).astype(result.dtype)
-    assert_series_equal(result, expected)
+    tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.single
diff --git a/pandas/tests/series/test_replace.py b/pandas/tests/series/methods/test_replace.py
similarity index 83%
rename from pandas/tests/series/test_replace.py
rename to pandas/tests/series/methods/test_replace.py
index 06a859963cf93..770ad38b0215e 100644
--- a/pandas/tests/series/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -2,13 +2,11 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
-from .common import TestData
 
-
-class TestSeriesReplace(TestData):
-    def test_replace(self):
+class TestSeriesReplace:
+    def test_replace(self, datetime_series):
         N = 100
         ser = pd.Series(np.random.randn(N))
         ser[0:4] = np.nan
@@ -65,7 +63,7 @@ def test_replace(self):
         filled[4] = 0
         tm.assert_series_equal(ser.replace(np.inf, 0), filled)
 
-        ser = pd.Series(self.ts.index)
+        ser = pd.Series(datetime_series.index)
         tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
 
         # malformed
@@ -122,8 +120,8 @@ def test_replace_with_single_list(self):
         # make sure things don't get corrupted when fillna call fails
         s = ser.copy()
         msg = (
-            r"Invalid fill method\. Expecting pad \(ffill\) or backfill"
-            r" \(bfill\)\. Got crash_cymbal"
+            r"Invalid fill method\. Expecting pad \(ffill\) or backfill "
+            r"\(bfill\)\. Got crash_cymbal"
         )
         with pytest.raises(ValueError, match=msg):
             s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
@@ -247,7 +245,10 @@ def test_replace_with_empty_dictlike(self):
         # GH 15289
         s = pd.Series(list("abcd"))
         tm.assert_series_equal(s, s.replace(dict()))
-        tm.assert_series_equal(s, s.replace(pd.Series([])))
+
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            empty_series = pd.Series([])
+        tm.assert_series_equal(s, s.replace(empty_series))
 
     def test_replace_string_with_number(self):
         # GH 15743
@@ -295,6 +296,29 @@ def test_replace_categorical(self, categorical, numeric):
         expected = pd.Series(numeric)
         tm.assert_series_equal(expected, result, check_dtype=False)
 
+    def test_replace_categorical_single(self):
+        # GH 26988
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+        s = pd.Series(dti)
+        c = s.astype("category")
+
+        expected = c.copy()
+        expected = expected.cat.add_categories("foo")
+        expected[2] = "foo"
+        expected = expected.cat.remove_unused_categories()
+        assert c[2] != "foo"
+
+        result = c.replace(c[2], "foo")
+        tm.assert_series_equal(expected, result)
+        assert c[2] != "foo"  # ensure non-inplace call does not alter original
+
+        c.replace(c[2], "foo", inplace=True)
+        tm.assert_series_equal(expected, c)
+
+        first_value = c[0]
+        c.replace(c[1], c[0], inplace=True)
+        assert c[0] == c[1] == first_value  # test replacing with existing value
+
     def test_replace_with_no_overflowerror(self):
         # GH 25616
         # casts to object without Exception from OverflowError
@@ -307,3 +331,34 @@ def test_replace_with_no_overflowerror(self):
         result = s.replace(["100000000000000000000"], [1])
         expected = pd.Series([0, 1, "100000000000000000001"])
         tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, to_replace, exp",
+        [
+            ([1, 2, 3], {1: 2, 2: 3, 3: 4}, [2, 3, 4]),
+            (["1", "2", "3"], {"1": "2", "2": "3", "3": "4"}, ["2", "3", "4"]),
+        ],
+    )
+    def test_replace_commutative(self, ser, to_replace, exp):
+        # GH 16051
+        # DataFrame.replace() overwrites when values are non-numeric
+
+        series = pd.Series(ser)
+
+        expected = pd.Series(exp)
+        result = series.replace(to_replace)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, exp", [([1, 2, 3], [1, True, 3]), (["x", 2, 3], ["x", True, 3])]
+    )
+    def test_replace_no_cast(self, ser, exp):
+        # GH 9113
+        # BUG: replace int64 dtype with bool coerces to int64
+
+        series = pd.Series(ser)
+        result = series.replace(2, True)
+        expected = pd.Series(exp)
+
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_round.py b/pandas/tests/series/methods/test_round.py
new file mode 100644
index 0000000000000..88d5c428712dc
--- /dev/null
+++ b/pandas/tests/series/methods/test_round.py
@@ -0,0 +1,56 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesRound:
+    def test_round(self, datetime_series):
+        datetime_series.index.name = "index_name"
+        result = datetime_series.round(2)
+        expected = Series(
+            np.round(datetime_series.values, 2), index=datetime_series.index, name="ts"
+        )
+        tm.assert_series_equal(result, expected)
+        assert result.name == datetime_series.name
+
+    def test_round_numpy(self):
+        # See GH#12600
+        ser = Series([1.53, 1.36, 0.06])
+        out = np.round(ser, decimals=0)
+        expected = Series([2.0, 1.0, 0.0])
+        tm.assert_series_equal(out, expected)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.round(ser, decimals=0, out=ser)
+
+    def test_round_numpy_with_nan(self):
+        # See GH#14197
+        ser = Series([1.53, np.nan, 0.06])
+        with tm.assert_produces_warning(None):
+            result = ser.round()
+        expected = Series([2.0, np.nan, 0.0])
+        tm.assert_series_equal(result, expected)
+
+    def test_round_builtin(self):
+        ser = Series([1.123, 2.123, 3.123], index=range(3))
+        result = round(ser)
+        expected_rounded0 = Series([1.0, 2.0, 3.0], index=range(3))
+        tm.assert_series_equal(result, expected_rounded0)
+
+        decimals = 2
+        expected_rounded = Series([1.12, 2.12, 3.12], index=range(3))
+        result = round(ser, decimals)
+        tm.assert_series_equal(result, expected_rounded)
+
+    @pytest.mark.parametrize("method", ["round", "floor", "ceil"])
+    @pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
+    def test_round_nat(self, method, freq):
+        # GH14940
+        ser = Series([pd.NaT])
+        expected = Series(pd.NaT)
+        round_method = getattr(ser.dt, method)
+        tm.assert_series_equal(round_method(freq), expected)
diff --git a/pandas/tests/series/methods/test_searchsorted.py b/pandas/tests/series/methods/test_searchsorted.py
new file mode 100644
index 0000000000000..fd6c6f74a9136
--- /dev/null
+++ b/pandas/tests/series/methods/test_searchsorted.py
@@ -0,0 +1,55 @@
+import numpy as np
+
+from pandas import Series, Timestamp, date_range
+import pandas._testing as tm
+from pandas.api.types import is_scalar
+
+
+class TestSeriesSearchSorted:
+    def test_searchsorted(self):
+        ser = Series([1, 2, 3])
+
+        result = ser.searchsorted(1, side="left")
+        assert is_scalar(result)
+        assert result == 0
+
+        result = ser.searchsorted(1, side="right")
+        assert is_scalar(result)
+        assert result == 1
+
+    def test_searchsorted_numeric_dtypes_scalar(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted(30)
+        assert is_scalar(res)
+        assert res == 2
+
+        res = ser.searchsorted([30])
+        exp = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_numeric_dtypes_vector(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted([91, 2e6])
+        exp = np.array([3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_datetime64_scalar(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        val = Timestamp("20120102")
+        res = ser.searchsorted(val)
+        assert is_scalar(res)
+        assert res == 1
+
+    def test_searchsorted_datetime64_list(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        vals = [Timestamp("20120102"), Timestamp("20120104")]
+        res = ser.searchsorted(vals)
+        exp = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_sorter(self):
+        # GH8490
+        ser = Series([3, 1, 2])
+        res = ser.searchsorted([0, 3], sorter=np.argsort(ser))
+        exp = np.array([0, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
diff --git a/pandas/tests/series/methods/test_shift.py b/pandas/tests/series/methods/test_shift.py
new file mode 100644
index 0000000000000..8256e2f33b936
--- /dev/null
+++ b/pandas/tests/series/methods/test_shift.py
@@ -0,0 +1,265 @@
+import numpy as np
+import pytest
+
+from pandas.errors import NullFrequencyError
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+    NaT,
+    Series,
+    TimedeltaIndex,
+    date_range,
+    offsets,
+)
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay
+
+
+class TestShift:
+    def test_shift(self, datetime_series):
+        shifted = datetime_series.shift(1)
+        unshifted = shifted.shift(-1)
+
+        tm.assert_index_equal(shifted.index, datetime_series.index)
+        tm.assert_index_equal(unshifted.index, datetime_series.index)
+        tm.assert_numpy_array_equal(
+            unshifted.dropna().values, datetime_series.values[:-1]
+        )
+
+        offset = BDay()
+        shifted = datetime_series.shift(1, freq=offset)
+        unshifted = shifted.shift(-1, freq=offset)
+
+        tm.assert_series_equal(unshifted, datetime_series)
+
+        unshifted = datetime_series.shift(0, freq=offset)
+        tm.assert_series_equal(unshifted, datetime_series)
+
+        shifted = datetime_series.shift(1, freq="B")
+        unshifted = shifted.shift(-1, freq="B")
+
+        tm.assert_series_equal(unshifted, datetime_series)
+
+        # corner case
+        unshifted = datetime_series.shift(0)
+        tm.assert_series_equal(unshifted, datetime_series)
+
+        # Shifting with PeriodIndex
+        ps = tm.makePeriodSeries()
+        shifted = ps.shift(1)
+        unshifted = shifted.shift(-1)
+        tm.assert_index_equal(shifted.index, ps.index)
+        tm.assert_index_equal(unshifted.index, ps.index)
+        tm.assert_numpy_array_equal(unshifted.dropna().values, ps.values[:-1])
+
+        shifted2 = ps.shift(1, "B")
+        shifted3 = ps.shift(1, BDay())
+        tm.assert_series_equal(shifted2, shifted3)
+        tm.assert_series_equal(ps, shifted2.shift(-1, "B"))
+
+        msg = "Given freq D does not match PeriodIndex freq B"
+        with pytest.raises(ValueError, match=msg):
+            ps.shift(freq="D")
+
+        # legacy support
+        shifted4 = ps.shift(1, freq="B")
+        tm.assert_series_equal(shifted2, shifted4)
+
+        shifted5 = ps.shift(1, freq=BDay())
+        tm.assert_series_equal(shifted5, shifted4)
+
+        # 32-bit taking
+        # GH#8129
+        index = date_range("2000-01-01", periods=5)
+        for dtype in ["int32", "int64"]:
+            s1 = Series(np.arange(5, dtype=dtype), index=index)
+            p = s1.iloc[1]
+            result = s1.shift(periods=p)
+            expected = Series([np.nan, 0, 1, 2, 3], index=index)
+            tm.assert_series_equal(result, expected)
+
+        # GH#8260
+        # with tz
+        s = Series(
+            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
+        )
+        result = s - s.shift()
+
+        exp = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
+        tm.assert_series_equal(result, exp)
+
+        # incompat tz
+        s2 = Series(date_range("2000-01-01 09:00:00", periods=5, tz="CET"), name="foo")
+        msg = "DatetimeArray subtraction must have the same timezones or no timezones"
+        with pytest.raises(TypeError, match=msg):
+            s - s2
+
+    def test_shift2(self):
+        ts = Series(
+            np.random.randn(5), index=date_range("1/1/2000", periods=5, freq="H")
+        )
+
+        result = ts.shift(1, freq="5T")
+        exp_index = ts.index.shift(1, freq="5T")
+        tm.assert_index_equal(result.index, exp_index)
+
+        # GH#1063, multiple of same base
+        result = ts.shift(1, freq="4H")
+        exp_index = ts.index + offsets.Hour(4)
+        tm.assert_index_equal(result.index, exp_index)
+
+        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
+        msg = "Cannot shift with no freq"
+        with pytest.raises(NullFrequencyError, match=msg):
+            idx.shift(1)
+
+    def test_shift_fill_value(self):
+        # GH#24128
+        ts = Series(
+            [1.0, 2.0, 3.0, 4.0, 5.0], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+
+        exp = Series(
+            [0.0, 1.0, 2.0, 3.0, 4.0], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        # check that fill value works
+        result = ts.shift(1, fill_value=0.0)
+        tm.assert_series_equal(result, exp)
+
+        exp = Series(
+            [0.0, 0.0, 1.0, 2.0, 3.0], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        result = ts.shift(2, fill_value=0.0)
+        tm.assert_series_equal(result, exp)
+
+        ts = pd.Series([1, 2, 3])
+        res = ts.shift(2, fill_value=0)
+        assert res.dtype == ts.dtype
+
+    def test_shift_categorical_fill_value(self):
+        ts = pd.Series(["a", "b", "c", "d"], dtype="category")
+        res = ts.shift(1, fill_value="a")
+        expected = pd.Series(
+            pd.Categorical(
+                ["a", "a", "b", "c"], categories=["a", "b", "c", "d"], ordered=False
+            )
+        )
+        tm.assert_equal(res, expected)
+
+        # check for incorrect fill_value
+        msg = "'fill_value=f' is not present in this Categorical's categories"
+        with pytest.raises(ValueError, match=msg):
+            ts.shift(1, fill_value="f")
+
+    def test_shift_dst(self):
+        # GH#13926
+        dates = date_range("2016-11-06", freq="H", periods=10, tz="US/Eastern")
+        s = Series(dates)
+
+        res = s.shift(0)
+        tm.assert_series_equal(res, s)
+        assert res.dtype == "datetime64[ns, US/Eastern]"
+
+        res = s.shift(1)
+        exp_vals = [NaT] + dates.astype(object).values.tolist()[:9]
+        exp = Series(exp_vals)
+        tm.assert_series_equal(res, exp)
+        assert res.dtype == "datetime64[ns, US/Eastern]"
+
+        res = s.shift(-2)
+        exp_vals = dates.astype(object).values.tolist()[2:] + [NaT, NaT]
+        exp = Series(exp_vals)
+        tm.assert_series_equal(res, exp)
+        assert res.dtype == "datetime64[ns, US/Eastern]"
+
+        for ex in [10, -10, 20, -20]:
+            res = s.shift(ex)
+            exp = Series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
+            tm.assert_series_equal(res, exp)
+            assert res.dtype == "datetime64[ns, US/Eastern]"
+
+    def test_tshift(self, datetime_series):
+        # PeriodIndex
+        ps = tm.makePeriodSeries()
+        shifted = ps.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_series_equal(unshifted, ps)
+
+        shifted2 = ps.tshift(freq="B")
+        tm.assert_series_equal(shifted, shifted2)
+
+        shifted3 = ps.tshift(freq=BDay())
+        tm.assert_series_equal(shifted, shifted3)
+
+        msg = "Given freq M does not match PeriodIndex freq B"
+        with pytest.raises(ValueError, match=msg):
+            ps.tshift(freq="M")
+
+        # DatetimeIndex
+        shifted = datetime_series.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_series_equal(datetime_series, unshifted)
+
+        shifted2 = datetime_series.tshift(freq=datetime_series.index.freq)
+        tm.assert_series_equal(shifted, shifted2)
+
+        inferred_ts = Series(
+            datetime_series.values, Index(np.asarray(datetime_series.index)), name="ts"
+        )
+        shifted = inferred_ts.tshift(1)
+        unshifted = shifted.tshift(-1)
+        tm.assert_series_equal(shifted, datetime_series.tshift(1))
+        tm.assert_series_equal(unshifted, inferred_ts)
+
+        no_freq = datetime_series[[0, 5, 7]]
+        msg = "Freq was not given and was not set in the index"
+        with pytest.raises(ValueError, match=msg):
+            no_freq.tshift()
+
+    def test_shift_int(self, datetime_series):
+        ts = datetime_series.astype(int)
+        shifted = ts.shift(1)
+        expected = ts.astype(float).shift(1)
+        tm.assert_series_equal(shifted, expected)
+
+    def test_shift_object_non_scalar_fill(self):
+        # shift requires scalar fill_value except for object dtype
+        ser = Series(range(3))
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            ser.shift(1, fill_value=[])
+
+        df = ser.to_frame()
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            df.shift(1, fill_value=np.arange(3))
+
+        obj_ser = ser.astype(object)
+        result = obj_ser.shift(1, fill_value={})
+        assert result[0] == {}
+
+        obj_df = obj_ser.to_frame()
+        result = obj_df.shift(1, fill_value={})
+        assert result.iloc[0, 0] == {}
+
+    def test_shift_categorical(self):
+        # GH#9416
+        s = pd.Series(["a", "b", "c", "d"], dtype="category")
+
+        tm.assert_series_equal(s.iloc[:-1], s.shift(1).shift(-1).dropna())
+
+        sp1 = s.shift(1)
+        tm.assert_index_equal(s.index, sp1.index)
+        assert np.all(sp1.values.codes[:1] == -1)
+        assert np.all(s.values.codes[:-1] == sp1.values.codes[1:])
+
+        sn2 = s.shift(-2)
+        tm.assert_index_equal(s.index, sn2.index)
+        assert np.all(sn2.values.codes[-2:] == -1)
+        assert np.all(s.values.codes[2:] == sn2.values.codes[:-2])
+
+        tm.assert_index_equal(s.values.categories, sp1.values.categories)
+        tm.assert_index_equal(s.values.categories, sn2.values.categories)
diff --git a/pandas/tests/series/methods/test_sort_index.py b/pandas/tests/series/methods/test_sort_index.py
new file mode 100644
index 0000000000000..6fa4eeaee34c0
--- /dev/null
+++ b/pandas/tests/series/methods/test_sort_index.py
@@ -0,0 +1,168 @@
+import random
+
+import numpy as np
+import pytest
+
+from pandas import IntervalIndex, MultiIndex, Series
+import pandas._testing as tm
+
+
+class TestSeriesSortIndex:
+    def test_sort_index(self, datetime_series):
+        rindex = list(datetime_series.index)
+        random.shuffle(rindex)
+
+        random_order = datetime_series.reindex(rindex)
+        sorted_series = random_order.sort_index()
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        # descending
+        sorted_series = random_order.sort_index(ascending=False)
+        tm.assert_series_equal(
+            sorted_series, datetime_series.reindex(datetime_series.index[::-1])
+        )
+
+        # compat on level
+        sorted_series = random_order.sort_index(level=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        # compat on axis
+        sorted_series = random_order.sort_index(axis=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        msg = "No axis named 1 for object type <class 'pandas.core.series.Series'>"
+        with pytest.raises(ValueError, match=msg):
+            random_order.sort_values(axis=1)
+
+        sorted_series = random_order.sort_index(level=0, axis=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        with pytest.raises(ValueError, match=msg):
+            random_order.sort_index(level=0, axis=1)
+
+    def test_sort_index_inplace(self, datetime_series):
+
+        # For GH#11402
+        rindex = list(datetime_series.index)
+        random.shuffle(rindex)
+
+        # descending
+        random_order = datetime_series.reindex(rindex)
+        result = random_order.sort_index(ascending=False, inplace=True)
+
+        assert result is None
+        tm.assert_series_equal(
+            random_order, datetime_series.reindex(datetime_series.index[::-1])
+        )
+
+        # ascending
+        random_order = datetime_series.reindex(rindex)
+        result = random_order.sort_index(ascending=True, inplace=True)
+
+        assert result is None
+        tm.assert_series_equal(random_order, datetime_series)
+
+    def test_sort_index_level(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        res = s.sort_index(level="A")
+        tm.assert_series_equal(backwards, res)
+
+        res = s.sort_index(level=["A", "B"])
+        tm.assert_series_equal(backwards, res)
+
+        res = s.sort_index(level="A", sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+        res = s.sort_index(level=["A", "B"], sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+    @pytest.mark.parametrize("level", ["A", 0])  # GH#21052
+    def test_sort_index_multiindex(self, level):
+
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        # implicit sort_remaining=True
+        res = s.sort_index(level=level)
+        tm.assert_series_equal(backwards, res)
+
+        # GH#13496
+        # sort has no effect without remaining lvls
+        res = s.sort_index(level=level, sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+    def test_sort_index_kind(self):
+        # GH#14444 & GH#13589:  Add support for sort algo choosing
+        series = Series(index=[3, 2, 1, 4, 3], dtype=object)
+        expected_series = Series(index=[1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(kind="mergesort")
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+        index_sorted_series = series.sort_index(kind="quicksort")
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+        index_sorted_series = series.sort_index(kind="heapsort")
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+    def test_sort_index_na_position(self):
+        series = Series(index=[3, 2, 1, 4, 3, np.nan], dtype=object)
+        expected_series_first = Series(index=[np.nan, 1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="first")
+        tm.assert_series_equal(expected_series_first, index_sorted_series)
+
+        expected_series_last = Series(index=[1, 2, 3, 3, 4, np.nan], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="last")
+        tm.assert_series_equal(expected_series_last, index_sorted_series)
+
+    def test_sort_index_intervals(self):
+        s = Series(
+            [np.nan, 1, 2, 3], IntervalIndex.from_arrays([0, 1, 2, 3], [1, 2, 3, 4])
+        )
+
+        result = s.sort_index()
+        expected = s
+        tm.assert_series_equal(result, expected)
+
+        result = s.sort_index(ascending=False)
+        expected = Series(
+            [3, 2, 1, np.nan], IntervalIndex.from_arrays([3, 2, 1, 0], [4, 3, 2, 1])
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_list, sorted_list, ascending, ignore_index, output_index",
+        [
+            ([2, 3, 6, 1], [2, 3, 6, 1], True, True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [2, 3, 6, 1], True, False, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [1, 6, 3, 2], False, True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [1, 6, 3, 2], False, False, [3, 2, 1, 0]),
+        ],
+    )
+    def test_sort_index_ignore_index(
+        self, inplace, original_list, sorted_list, ascending, ignore_index, output_index
+    ):
+        # GH 30114
+        ser = Series(original_list)
+        expected = Series(sorted_list, index=output_index)
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_ser = ser.copy()
+            result_ser.sort_index(**kwargs)
+        else:
+            result_ser = ser.sort_index(**kwargs)
+
+        tm.assert_series_equal(result_ser, expected)
+        tm.assert_series_equal(ser, Series(original_list))
diff --git a/pandas/tests/series/test_sorting.py b/pandas/tests/series/methods/test_sort_values.py
similarity index 53%
rename from pandas/tests/series/test_sorting.py
rename to pandas/tests/series/methods/test_sort_values.py
index 125f516ab6b09..caa2abd61af6a 100644
--- a/pandas/tests/series/test_sorting.py
+++ b/pandas/tests/series/methods/test_sort_values.py
@@ -1,17 +1,12 @@
-import random
-
 import numpy as np
 import pytest
 
-from pandas import Categorical, DataFrame, IntervalIndex, MultiIndex, Series
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal, assert_series_equal
-
-from .common import TestData
+from pandas import Categorical, DataFrame, Series
+import pandas._testing as tm
 
 
-class TestSeriesSorting(TestData):
-    def test_sort_values(self):
+class TestSeriesSortValues:
+    def test_sort_values(self, datetime_series):
 
         # check indexes are reordered corresponding with the values
         ser = Series([3, 2, 4, 1], ["A", "B", "C", "D"])
@@ -19,7 +14,7 @@ def test_sort_values(self):
         result = ser.sort_values()
         tm.assert_series_equal(expected, result)
 
-        ts = self.ts.copy()
+        ts = datetime_series.copy()
         ts[:5] = np.NaN
         vals = ts.values
 
@@ -40,17 +35,17 @@ def test_sort_values(self):
         # ascending=False
         ordered = ts.sort_values(ascending=False)
         expected = np.sort(ts.dropna().values)[::-1]
-        assert_almost_equal(expected, ordered.dropna().values)
+        tm.assert_almost_equal(expected, ordered.dropna().values)
         ordered = ts.sort_values(ascending=False, na_position="first")
-        assert_almost_equal(expected, ordered.dropna().values)
+        tm.assert_almost_equal(expected, ordered.dropna().values)
 
         # ascending=[False] should behave the same as ascending=False
         ordered = ts.sort_values(ascending=[False])
         expected = ts.sort_values(ascending=False)
-        assert_series_equal(expected, ordered)
+        tm.assert_series_equal(expected, ordered)
         ordered = ts.sort_values(ascending=[False], na_position="first")
         expected = ts.sort_values(ascending=False, na_position="first")
-        assert_series_equal(expected, ordered)
+        tm.assert_series_equal(expected, ordered)
 
         msg = "ascending must be boolean"
         with pytest.raises(ValueError, match=msg):
@@ -69,129 +64,25 @@ def test_sort_values(self):
             ts.sort_values(ascending="foobar")
 
         # inplace=True
-        ts = self.ts.copy()
+        ts = datetime_series.copy()
         ts.sort_values(ascending=False, inplace=True)
-        tm.assert_series_equal(ts, self.ts.sort_values(ascending=False))
-        tm.assert_index_equal(ts.index, self.ts.sort_values(ascending=False).index)
+        tm.assert_series_equal(ts, datetime_series.sort_values(ascending=False))
+        tm.assert_index_equal(
+            ts.index, datetime_series.sort_values(ascending=False).index
+        )
 
-        # GH 5856/5853
+        # GH#5856/5853
         # Series.sort_values operating on a view
         df = DataFrame(np.random.randn(10, 4))
         s = df.iloc[:, 0]
 
         msg = (
-            "This Series is a view of some other array, to sort in-place"
-            " you must create a copy"
+            "This Series is a view of some other array, to sort in-place "
+            "you must create a copy"
         )
         with pytest.raises(ValueError, match=msg):
             s.sort_values(inplace=True)
 
-    def test_sort_index(self):
-        rindex = list(self.ts.index)
-        random.shuffle(rindex)
-
-        random_order = self.ts.reindex(rindex)
-        sorted_series = random_order.sort_index()
-        assert_series_equal(sorted_series, self.ts)
-
-        # descending
-        sorted_series = random_order.sort_index(ascending=False)
-        assert_series_equal(sorted_series, self.ts.reindex(self.ts.index[::-1]))
-
-        # compat on level
-        sorted_series = random_order.sort_index(level=0)
-        assert_series_equal(sorted_series, self.ts)
-
-        # compat on axis
-        sorted_series = random_order.sort_index(axis=0)
-        assert_series_equal(sorted_series, self.ts)
-
-        msg = "No axis named 1 for object type <class 'pandas.core.series.Series'>"
-        with pytest.raises(ValueError, match=msg):
-            random_order.sort_values(axis=1)
-
-        sorted_series = random_order.sort_index(level=0, axis=0)
-        assert_series_equal(sorted_series, self.ts)
-
-        with pytest.raises(ValueError, match=msg):
-            random_order.sort_index(level=0, axis=1)
-
-    def test_sort_index_inplace(self):
-
-        # For #11402
-        rindex = list(self.ts.index)
-        random.shuffle(rindex)
-
-        # descending
-        random_order = self.ts.reindex(rindex)
-        result = random_order.sort_index(ascending=False, inplace=True)
-
-        assert result is None
-        tm.assert_series_equal(random_order, self.ts.reindex(self.ts.index[::-1]))
-
-        # ascending
-        random_order = self.ts.reindex(rindex)
-        result = random_order.sort_index(ascending=True, inplace=True)
-
-        assert result is None
-        tm.assert_series_equal(random_order, self.ts)
-
-    @pytest.mark.parametrize("level", ["A", 0])  # GH 21052
-    def test_sort_index_multiindex(self, level):
-
-        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
-        s = Series([1, 2], mi)
-        backwards = s.iloc[[1, 0]]
-
-        # implicit sort_remaining=True
-        res = s.sort_index(level=level)
-        assert_series_equal(backwards, res)
-
-        # GH13496
-        # sort has no effect without remaining lvls
-        res = s.sort_index(level=level, sort_remaining=False)
-        assert_series_equal(s, res)
-
-    def test_sort_index_kind(self):
-        # GH #14444 & #13589:  Add support for sort algo choosing
-        series = Series(index=[3, 2, 1, 4, 3])
-        expected_series = Series(index=[1, 2, 3, 3, 4])
-
-        index_sorted_series = series.sort_index(kind="mergesort")
-        assert_series_equal(expected_series, index_sorted_series)
-
-        index_sorted_series = series.sort_index(kind="quicksort")
-        assert_series_equal(expected_series, index_sorted_series)
-
-        index_sorted_series = series.sort_index(kind="heapsort")
-        assert_series_equal(expected_series, index_sorted_series)
-
-    def test_sort_index_na_position(self):
-        series = Series(index=[3, 2, 1, 4, 3, np.nan])
-
-        expected_series_first = Series(index=[np.nan, 1, 2, 3, 3, 4])
-        index_sorted_series = series.sort_index(na_position="first")
-        assert_series_equal(expected_series_first, index_sorted_series)
-
-        expected_series_last = Series(index=[1, 2, 3, 3, 4, np.nan])
-        index_sorted_series = series.sort_index(na_position="last")
-        assert_series_equal(expected_series_last, index_sorted_series)
-
-    def test_sort_index_intervals(self):
-        s = Series(
-            [np.nan, 1, 2, 3], IntervalIndex.from_arrays([0, 1, 2, 3], [1, 2, 3, 4])
-        )
-
-        result = s.sort_index()
-        expected = s
-        assert_series_equal(result, expected)
-
-        result = s.sort_index(ascending=False)
-        expected = Series(
-            [3, 2, 1, np.nan], IntervalIndex.from_arrays([3, 2, 1, 0], [4, 3, 2, 1])
-        )
-        assert_series_equal(result, expected)
-
     def test_sort_values_categorical(self):
 
         c = Categorical(["a", "b", "b", "a"], ordered=False)
@@ -249,7 +140,7 @@ def test_sort_values_categorical(self):
         df.sort_values(by=["unsort"], ascending=False)
 
         # multi-columns sort
-        # GH 7848
+        # GH#7848
         df = DataFrame(
             {"id": [6, 5, 4, 3, 2, 1], "raw_grade": ["a", "b", "b", "a", "a", "e"]}
         )
@@ -265,3 +156,28 @@ def test_sort_values_categorical(self):
         result = df.sort_values(by=["grade", "id"])
         expected = df.iloc[[2, 1, 5, 4, 3, 0]]
         tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_list, sorted_list, ignore_index, output_index",
+        [
+            ([2, 3, 6, 1], [6, 3, 2, 1], True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [6, 3, 2, 1], False, [2, 1, 0, 3]),
+        ],
+    )
+    def test_sort_values_ignore_index(
+        self, inplace, original_list, sorted_list, ignore_index, output_index
+    ):
+        # GH 30114
+        ser = Series(original_list)
+        expected = Series(sorted_list, index=output_index)
+        kwargs = {"ignore_index": ignore_index, "inplace": inplace}
+
+        if inplace:
+            result_ser = ser.copy()
+            result_ser.sort_values(ascending=False, **kwargs)
+        else:
+            result_ser = ser.sort_values(ascending=False, **kwargs)
+
+        tm.assert_series_equal(result_ser, expected)
+        tm.assert_series_equal(ser, Series(original_list))
diff --git a/pandas/tests/series/methods/test_to_dict.py b/pandas/tests/series/methods/test_to_dict.py
new file mode 100644
index 0000000000000..2fbf3e8d39cf3
--- /dev/null
+++ b/pandas/tests/series/methods/test_to_dict.py
@@ -0,0 +1,20 @@
+import collections
+
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesToDict:
+    @pytest.mark.parametrize(
+        "mapping", (dict, collections.defaultdict(list), collections.OrderedDict)
+    )
+    def test_to_dict(self, mapping, datetime_series):
+        # GH#16122
+        tm.assert_series_equal(
+            Series(datetime_series.to_dict(mapping), name="ts"), datetime_series
+        )
+        from_method = Series(datetime_series.to_dict(collections.Counter))
+        from_constructor = Series(collections.Counter(datetime_series.items()))
+        tm.assert_series_equal(from_method, from_constructor)
diff --git a/pandas/tests/series/methods/test_to_timestamp.py b/pandas/tests/series/methods/test_to_timestamp.py
new file mode 100644
index 0000000000000..44caf1f082a4f
--- /dev/null
+++ b/pandas/tests/series/methods/test_to_timestamp.py
@@ -0,0 +1,54 @@
+from datetime import timedelta
+
+from pandas import Series, Timedelta, date_range, period_range, to_datetime
+import pandas._testing as tm
+
+
+class TestToTimestamp:
+    def test_to_timestamp(self):
+        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        series = Series(1, index=index, name="foo")
+
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        result = series.to_timestamp(how="end")
+        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+        assert result.name == "foo"
+
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        result = series.to_timestamp(how="start")
+        tm.assert_index_equal(result.index, exp_index)
+
+        def _get_with_delta(delta, freq="A-DEC"):
+            return date_range(
+                to_datetime("1/1/2001") + delta,
+                to_datetime("12/31/2009") + delta,
+                freq=freq,
+            )
+
+        delta = timedelta(hours=23)
+        result = series.to_timestamp("H", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        delta = timedelta(hours=23, minutes=59)
+        result = series.to_timestamp("T", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        result = series.to_timestamp("S", "end")
+        delta = timedelta(hours=23, minutes=59, seconds=59)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        index = period_range(freq="H", start="1/1/2001", end="1/2/2001")
+        series = Series(1, index=index, name="foo")
+
+        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="H")
+        result = series.to_timestamp(how="end")
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+        assert result.name == "foo"
diff --git a/pandas/tests/series/methods/test_truncate.py b/pandas/tests/series/methods/test_truncate.py
new file mode 100644
index 0000000000000..d4e2890ed8bf0
--- /dev/null
+++ b/pandas/tests/series/methods/test_truncate.py
@@ -0,0 +1,78 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay
+
+
+class TestTruncate:
+    def test_truncate(self, datetime_series):
+        offset = BDay()
+
+        ts = datetime_series[::3]
+
+        start, end = datetime_series.index[3], datetime_series.index[6]
+        start_missing, end_missing = datetime_series.index[2], datetime_series.index[7]
+
+        # neither specified
+        truncated = ts.truncate()
+        tm.assert_series_equal(truncated, ts)
+
+        # both specified
+        expected = ts[1:3]
+
+        truncated = ts.truncate(start, end)
+        tm.assert_series_equal(truncated, expected)
+
+        truncated = ts.truncate(start_missing, end_missing)
+        tm.assert_series_equal(truncated, expected)
+
+        # start specified
+        expected = ts[1:]
+
+        truncated = ts.truncate(before=start)
+        tm.assert_series_equal(truncated, expected)
+
+        truncated = ts.truncate(before=start_missing)
+        tm.assert_series_equal(truncated, expected)
+
+        # end specified
+        expected = ts[:3]
+
+        truncated = ts.truncate(after=end)
+        tm.assert_series_equal(truncated, expected)
+
+        truncated = ts.truncate(after=end_missing)
+        tm.assert_series_equal(truncated, expected)
+
+        # corner case, empty series returned
+        truncated = ts.truncate(after=datetime_series.index[0] - offset)
+        assert len(truncated) == 0
+
+        truncated = ts.truncate(before=datetime_series.index[-1] + offset)
+        assert len(truncated) == 0
+
+        msg = "Truncate: 1999-12-31 00:00:00 must be after 2000-02-14 00:00:00"
+        with pytest.raises(ValueError, match=msg):
+            ts.truncate(
+                before=datetime_series.index[-1] + offset,
+                after=datetime_series.index[0] - offset,
+            )
+
+    def test_truncate_nonsortedindex(self):
+        # GH#17935
+
+        s = pd.Series(["a", "b", "c", "d", "e"], index=[5, 3, 2, 9, 0])
+        msg = "truncate requires a sorted index"
+
+        with pytest.raises(ValueError, match=msg):
+            s.truncate(before=3, after=9)
+
+        rng = pd.date_range("2011-01-01", "2012-01-01", freq="W")
+        ts = pd.Series(np.random.randn(len(rng)), index=rng)
+        msg = "truncate requires a sorted index"
+
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending=False).truncate(before="2011-11", after="2011-12")
diff --git a/pandas/tests/series/methods/test_unstack.py b/pandas/tests/series/methods/test_unstack.py
new file mode 100644
index 0000000000000..7645fb8759a54
--- /dev/null
+++ b/pandas/tests/series/methods/test_unstack.py
@@ -0,0 +1,120 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, MultiIndex, Series
+import pandas._testing as tm
+
+
+def test_unstack():
+    index = MultiIndex(
+        levels=[["bar", "foo"], ["one", "three", "two"]],
+        codes=[[1, 1, 0, 0], [0, 1, 0, 2]],
+    )
+
+    s = Series(np.arange(4.0), index=index)
+    unstacked = s.unstack()
+
+    expected = DataFrame(
+        [[2.0, np.nan, 3.0], [0.0, 1.0, np.nan]],
+        index=["bar", "foo"],
+        columns=["one", "three", "two"],
+    )
+
+    tm.assert_frame_equal(unstacked, expected)
+
+    unstacked = s.unstack(level=0)
+    tm.assert_frame_equal(unstacked, expected.T)
+
+    index = MultiIndex(
+        levels=[["bar"], ["one", "two", "three"], [0, 1]],
+        codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+    )
+    s = Series(np.random.randn(6), index=index)
+    exp_index = MultiIndex(
+        levels=[["one", "two", "three"], [0, 1]],
+        codes=[[0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+    )
+    expected = DataFrame({"bar": s.values}, index=exp_index).sort_index(level=0)
+    unstacked = s.unstack(0).sort_index()
+    tm.assert_frame_equal(unstacked, expected)
+
+    # GH5873
+    idx = pd.MultiIndex.from_arrays([[101, 102], [3.5, np.nan]])
+    ts = pd.Series([1, 2], index=idx)
+    left = ts.unstack()
+    right = DataFrame(
+        [[np.nan, 1], [2, np.nan]], index=[101, 102], columns=[np.nan, 3.5]
+    )
+    tm.assert_frame_equal(left, right)
+
+    idx = pd.MultiIndex.from_arrays(
+        [
+            ["cat", "cat", "cat", "dog", "dog"],
+            ["a", "a", "b", "a", "b"],
+            [1, 2, 1, 1, np.nan],
+        ]
+    )
+    ts = pd.Series([1.0, 1.1, 1.2, 1.3, 1.4], index=idx)
+    right = DataFrame(
+        [[1.0, 1.3], [1.1, np.nan], [np.nan, 1.4], [1.2, np.nan]],
+        columns=["cat", "dog"],
+    )
+    tpls = [("a", 1), ("a", 2), ("b", np.nan), ("b", 1)]
+    right.index = pd.MultiIndex.from_tuples(tpls)
+    tm.assert_frame_equal(ts.unstack(level=0), right)
+
+
+def test_unstack_tuplename_in_multiindex():
+    # GH 19966
+    idx = pd.MultiIndex.from_product(
+        [["a", "b", "c"], [1, 2, 3]], names=[("A", "a"), ("B", "b")]
+    )
+    ser = pd.Series(1, index=idx)
+    result = ser.unstack(("A", "a"))
+
+    expected = pd.DataFrame(
+        [[1, 1, 1], [1, 1, 1], [1, 1, 1]],
+        columns=pd.MultiIndex.from_tuples(
+            [("a",), ("b",), ("c",)], names=[("A", "a")],
+        ),
+        index=pd.Index([1, 2, 3], name=("B", "b")),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "unstack_idx, expected_values, expected_index, expected_columns",
+    [
+        (
+            ("A", "a"),
+            [[1, 1], [1, 1], [1, 1], [1, 1]],
+            pd.MultiIndex.from_tuples(
+                [(1, 3), (1, 4), (2, 3), (2, 4)], names=["B", "C"]
+            ),
+            pd.MultiIndex.from_tuples([("a",), ("b",)], names=[("A", "a")]),
+        ),
+        (
+            (("A", "a"), "B"),
+            [[1, 1, 1, 1], [1, 1, 1, 1]],
+            pd.Index([3, 4], name="C"),
+            pd.MultiIndex.from_tuples(
+                [("a", 1), ("a", 2), ("b", 1), ("b", 2)], names=[("A", "a"), "B"]
+            ),
+        ),
+    ],
+)
+def test_unstack_mixed_type_name_in_multiindex(
+    unstack_idx, expected_values, expected_index, expected_columns
+):
+    # GH 19966
+    idx = pd.MultiIndex.from_product(
+        [["a", "b"], [1, 2], [3, 4]], names=[("A", "a"), "B", "C"]
+    )
+    ser = pd.Series(1, index=idx)
+    result = ser.unstack(unstack_idx)
+
+    expected = pd.DataFrame(
+        expected_values, columns=expected_columns, index=expected_index,
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_value_counts.py b/pandas/tests/series/methods/test_value_counts.py
new file mode 100644
index 0000000000000..fdb35befeb0c2
--- /dev/null
+++ b/pandas/tests/series/methods/test_value_counts.py
@@ -0,0 +1,179 @@
+import numpy as np
+
+import pandas as pd
+from pandas import Categorical, CategoricalIndex, Series
+import pandas._testing as tm
+
+
+class TestSeriesValueCounts:
+    def test_value_counts_datetime(self):
+        # most dtypes are tested in tests/base
+        values = [
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 10:00"),
+            pd.Timestamp("2011-01-01 11:00"),
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 11:00"),
+        ]
+
+        exp_idx = pd.DatetimeIndex(
+            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"]
+        )
+        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
+
+        ser = pd.Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check DatetimeIndex outputs the same result
+        idx = pd.DatetimeIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_datetime_tz(self):
+        values = [
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
+        ]
+
+        exp_idx = pd.DatetimeIndex(
+            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
+            tz="US/Eastern",
+        )
+        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
+
+        ser = pd.Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        idx = pd.DatetimeIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_period(self):
+        values = [
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-02", freq="M"),
+            pd.Period("2011-03", freq="M"),
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-03", freq="M"),
+        ]
+
+        exp_idx = pd.PeriodIndex(["2011-01", "2011-03", "2011-02"], freq="M")
+        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
+
+        ser = pd.Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check DatetimeIndex outputs the same result
+        idx = pd.PeriodIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical_ordered(self):
+        # most dtypes are tested in tests/base
+        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=True)
+
+        exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=True)
+        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
+
+        ser = pd.Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check CategoricalIndex outputs the same result
+        idx = pd.CategoricalIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical_not_ordered(self):
+        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=False)
+
+        exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=False)
+        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
+
+        ser = pd.Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check CategoricalIndex outputs the same result
+        idx = pd.CategoricalIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical(self):
+        # GH#12835
+        cats = Categorical(list("abcccb"), categories=list("cabd"))
+        ser = Series(cats, name="xxx")
+        res = ser.value_counts(sort=False)
+
+        exp_index = CategoricalIndex(list("cabd"), categories=cats.categories)
+        exp = Series([3, 1, 2, 0], name="xxx", index=exp_index)
+        tm.assert_series_equal(res, exp)
+
+        res = ser.value_counts(sort=True)
+
+        exp_index = CategoricalIndex(list("cbad"), categories=cats.categories)
+        exp = Series([3, 2, 1, 0], name="xxx", index=exp_index)
+        tm.assert_series_equal(res, exp)
+
+        # check object dtype handles the Series.name as the same
+        # (tested in tests/base)
+        ser = Series(["a", "b", "c", "c", "c", "b"], name="xxx")
+        res = ser.value_counts()
+        exp = Series([3, 2, 1], name="xxx", index=["c", "b", "a"])
+        tm.assert_series_equal(res, exp)
+
+    def test_value_counts_categorical_with_nan(self):
+        # see GH#9443
+
+        # sanity check
+        ser = Series(["a", "b", "a"], dtype="category")
+        exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))
+
+        res = ser.value_counts(dropna=True)
+        tm.assert_series_equal(res, exp)
+
+        res = ser.value_counts(dropna=True)
+        tm.assert_series_equal(res, exp)
+
+        # same Series via two different constructions --> same behaviour
+        series = [
+            Series(["a", "b", None, "a", None, None], dtype="category"),
+            Series(
+                Categorical(["a", "b", None, "a", None, None], categories=["a", "b"])
+            ),
+        ]
+
+        for ser in series:
+            # None is a NaN value, so we exclude its count here
+            exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))
+            res = ser.value_counts(dropna=True)
+            tm.assert_series_equal(res, exp)
+
+            # we don't exclude the count of None and sort by counts
+            exp = Series([3, 2, 1], index=CategoricalIndex([np.nan, "a", "b"]))
+            res = ser.value_counts(dropna=False)
+            tm.assert_series_equal(res, exp)
+
+            # When we aren't sorting by counts, and np.nan isn't a
+            # category, it should be last.
+            exp = Series([2, 1, 3], index=CategoricalIndex(["a", "b", np.nan]))
+            res = ser.value_counts(dropna=False, sort=False)
+            tm.assert_series_equal(res, exp)
diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index 5d74ad95be90d..71f6681e8c955 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -4,23 +4,23 @@
 import pytest
 
 from pandas import DataFrame, Index, MultiIndex, RangeIndex, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestSeriesAlterAxes:
     def test_setindex(self, string_series):
         # wrong type
         msg = (
-            r"Index\(\.\.\.\) must be called with a collection of some"
-            r" kind, None was passed"
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            r"kind, None was passed"
         )
         with pytest.raises(TypeError, match=msg):
             string_series.index = None
 
         # wrong length
         msg = (
-            "Length mismatch: Expected axis has 30 elements, new"
-            " values have 29 elements"
+            "Length mismatch: Expected axis has 30 elements, "
+            "new values have 29 elements"
         )
         with pytest.raises(ValueError, match=msg):
             string_series.index = np.arange(len(string_series) - 1)
@@ -83,8 +83,9 @@ def test_rename_axis_supported(self):
         s = Series(range(5))
         s.rename({}, axis=0)
         s.rename({}, axis="index")
-        with pytest.raises(ValueError, match="No axis named 5"):
-            s.rename({}, axis=5)
+        # TODO: clean up shared index validation
+        # with pytest.raises(ValueError, match="No axis named 5"):
+        #     s.rename({}, axis=5)
 
     def test_set_name_attribute(self):
         s = Series([1, 2, 3])
@@ -233,7 +234,7 @@ def test_reorder_levels(self):
     def test_rename_axis_mapper(self):
         # GH 19978
         mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
-        s = Series([i for i in range(len(mi))], index=mi)
+        s = Series(list(range(len(mi))), index=mi)
 
         result = s.rename_axis(index={"ll": "foo"})
         assert result.index.names == ["foo", "nn"]
@@ -322,17 +323,6 @@ def test_set_axis_inplace(self):
             with pytest.raises(ValueError, match="No axis named"):
                 s.set_axis(list("abcd"), axis=axis, inplace=False)
 
-    def test_set_axis_prior_to_deprecation_signature(self):
-        s = Series(np.arange(4), index=[1, 3, 5, 7], dtype="int64")
-
-        expected = s.copy()
-        expected.index = list("abcd")
-
-        for axis in [0, "index"]:
-            with tm.assert_produces_warning(FutureWarning):
-                result = s.set_axis(0, list("abcd"), inplace=False)
-            tm.assert_series_equal(result, expected)
-
     def test_reset_index_drop_errors(self):
         #  GH 20925
 
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index 1ddaa4692d741..e6e91b5d4f5f4 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -1,491 +1,22 @@
-from itertools import product
 import operator
 
 import numpy as np
-from numpy import nan
 import pytest
 
 import pandas.util._test_decorators as td
 
 import pandas as pd
-from pandas import (
-    Categorical,
-    CategoricalIndex,
-    DataFrame,
-    Series,
-    date_range,
-    isna,
-    notna,
-)
-from pandas.api.types import is_scalar
-from pandas.core.index import MultiIndex
-from pandas.core.indexes.datetimes import Timestamp
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-)
+from pandas import DataFrame, Series
+import pandas._testing as tm
 
 
 class TestSeriesAnalytics:
-    def test_describe(self):
-        s = Series([0, 1, 2, 3, 4], name="int_data")
-        result = s.describe()
-        expected = Series(
-            [5, 2, s.std(), 0, 1, 2, 3, 4],
-            name="int_data",
-            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
-        )
-        tm.assert_series_equal(result, expected)
-
-        s = Series([True, True, False, False, False], name="bool_data")
-        result = s.describe()
-        expected = Series(
-            [5, 2, False, 3], name="bool_data", index=["count", "unique", "top", "freq"]
-        )
-        tm.assert_series_equal(result, expected)
-
-        s = Series(["a", "a", "b", "c", "d"], name="str_data")
-        result = s.describe()
-        expected = Series(
-            [5, 4, "a", 2], name="str_data", index=["count", "unique", "top", "freq"]
-        )
-        tm.assert_series_equal(result, expected)
-
-    def test_describe_empty_object(self):
-        # https://github.com/pandas-dev/pandas/issues/27183
-        s = pd.Series([None, None], dtype=object)
-        result = s.describe()
-        expected = pd.Series(
-            [0, 0, np.nan, np.nan],
-            dtype=object,
-            index=["count", "unique", "top", "freq"],
-        )
-        tm.assert_series_equal(result, expected)
-
-        result = s[:0].describe()
-        tm.assert_series_equal(result, expected)
-        # ensure NaN, not None
-        assert np.isnan(result.iloc[2])
-        assert np.isnan(result.iloc[3])
-
-    def test_describe_with_tz(self, tz_naive_fixture):
-        # GH 21332
-        tz = tz_naive_fixture
-        name = str(tz_naive_fixture)
-        start = Timestamp(2018, 1, 1)
-        end = Timestamp(2018, 1, 5)
-        s = Series(date_range(start, end, tz=tz), name=name)
-        result = s.describe()
-        expected = Series(
-            [
-                5,
-                5,
-                s.value_counts().index[0],
-                1,
-                start.tz_localize(tz),
-                end.tz_localize(tz),
-            ],
-            name=name,
-            index=["count", "unique", "top", "freq", "first", "last"],
-        )
-        tm.assert_series_equal(result, expected)
-
-    def test_argsort(self, datetime_series):
-        self._check_accum_op("argsort", datetime_series, check_dtype=False)
-        argsorted = datetime_series.argsort()
-        assert issubclass(argsorted.dtype.type, np.integer)
-
-        # GH 2967 (introduced bug in 0.11-dev I think)
-        s = Series([Timestamp("201301{i:02d}".format(i=i)) for i in range(1, 6)])
-        assert s.dtype == "datetime64[ns]"
-        shifted = s.shift(-1)
-        assert shifted.dtype == "datetime64[ns]"
-        assert isna(shifted[4])
-
-        result = s.argsort()
-        expected = Series(range(5), dtype="int64")
-        assert_series_equal(result, expected)
-
-        result = shifted.argsort()
-        expected = Series(list(range(4)) + [-1], dtype="int64")
-        assert_series_equal(result, expected)
-
-    def test_argsort_stable(self):
-        s = Series(np.random.randint(0, 100, size=10000))
-        mindexer = s.argsort(kind="mergesort")
-        qindexer = s.argsort()
-
-        mexpected = np.argsort(s.values, kind="mergesort")
-        qexpected = np.argsort(s.values, kind="quicksort")
-
-        tm.assert_series_equal(mindexer, Series(mexpected), check_dtype=False)
-        tm.assert_series_equal(qindexer, Series(qexpected), check_dtype=False)
-        msg = (
-            r"ndarray Expected type <class 'numpy\.ndarray'>,"
-            r" found <class 'pandas\.core\.series\.Series'> instead"
-        )
-        with pytest.raises(AssertionError, match=msg):
-            tm.assert_numpy_array_equal(qindexer, mindexer)
-
-    def test_cumsum(self, datetime_series):
-        self._check_accum_op("cumsum", datetime_series)
-
-    def test_cumprod(self, datetime_series):
-        self._check_accum_op("cumprod", datetime_series)
-
-    def test_cummin(self, datetime_series):
-        tm.assert_numpy_array_equal(
-            datetime_series.cummin().values,
-            np.minimum.accumulate(np.array(datetime_series)),
-        )
-        ts = datetime_series.copy()
-        ts[::2] = np.NaN
-        result = ts.cummin()[1::2]
-        expected = np.minimum.accumulate(ts.dropna())
-
-        tm.assert_series_equal(result, expected)
-
-    def test_cummax(self, datetime_series):
-        tm.assert_numpy_array_equal(
-            datetime_series.cummax().values,
-            np.maximum.accumulate(np.array(datetime_series)),
-        )
-        ts = datetime_series.copy()
-        ts[::2] = np.NaN
-        result = ts.cummax()[1::2]
-        expected = np.maximum.accumulate(ts.dropna())
-
-        tm.assert_series_equal(result, expected)
-
-    def test_cummin_datetime64(self):
-        s = pd.Series(
-            pd.to_datetime(["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-3"])
-        )
-
-        expected = pd.Series(
-            pd.to_datetime(["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-1"])
-        )
-        result = s.cummin(skipna=True)
-        tm.assert_series_equal(expected, result)
-
-        expected = pd.Series(
-            pd.to_datetime(
-                ["NaT", "2000-1-2", "2000-1-2", "2000-1-1", "2000-1-1", "2000-1-1"]
-            )
-        )
-        result = s.cummin(skipna=False)
-        tm.assert_series_equal(expected, result)
-
-    def test_cummax_datetime64(self):
-        s = pd.Series(
-            pd.to_datetime(["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-3"])
-        )
-
-        expected = pd.Series(
-            pd.to_datetime(["NaT", "2000-1-2", "NaT", "2000-1-2", "NaT", "2000-1-3"])
-        )
-        result = s.cummax(skipna=True)
-        tm.assert_series_equal(expected, result)
-
-        expected = pd.Series(
-            pd.to_datetime(
-                ["NaT", "2000-1-2", "2000-1-2", "2000-1-2", "2000-1-2", "2000-1-3"]
-            )
-        )
-        result = s.cummax(skipna=False)
-        tm.assert_series_equal(expected, result)
-
-    def test_cummin_timedelta64(self):
-        s = pd.Series(pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "3 min"]))
-
-        expected = pd.Series(
-            pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "1 min"])
-        )
-        result = s.cummin(skipna=True)
-        tm.assert_series_equal(expected, result)
-
-        expected = pd.Series(
-            pd.to_timedelta(["NaT", "2 min", "2 min", "1 min", "1 min", "1 min"])
-        )
-        result = s.cummin(skipna=False)
-        tm.assert_series_equal(expected, result)
-
-    def test_cummax_timedelta64(self):
-        s = pd.Series(pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "3 min"]))
-
-        expected = pd.Series(
-            pd.to_timedelta(["NaT", "2 min", "NaT", "2 min", "NaT", "3 min"])
-        )
-        result = s.cummax(skipna=True)
-        tm.assert_series_equal(expected, result)
-
-        expected = pd.Series(
-            pd.to_timedelta(["NaT", "2 min", "2 min", "2 min", "2 min", "3 min"])
-        )
-        result = s.cummax(skipna=False)
-        tm.assert_series_equal(expected, result)
-
-    def test_npdiff(self):
-        pytest.skip("skipping due to Series no longer being an ndarray")
-
-        # no longer works as the return type of np.diff is now nd.array
-        s = Series(np.arange(5))
-
-        r = np.diff(s)
-        assert_series_equal(Series([nan, 0, 0, 0, nan]), r)
-
-    def _check_accum_op(self, name, datetime_series_, check_dtype=True):
-        func = getattr(np, name)
-        tm.assert_numpy_array_equal(
-            func(datetime_series_).values,
-            func(np.array(datetime_series_)),
-            check_dtype=check_dtype,
-        )
-
-        # with missing values
-        ts = datetime_series_.copy()
-        ts[::2] = np.NaN
-
-        result = func(ts)[1::2]
-        expected = func(np.array(ts.dropna()))
-
-        tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)
-
-    def test_compress(self):
-        cond = [True, False, True, False, False]
-        s = Series([1, -1, 5, 8, 7], index=list("abcde"), name="foo")
-        expected = Series(s.values.compress(cond), index=list("ac"), name="foo")
-        with tm.assert_produces_warning(FutureWarning):
-            result = s.compress(cond)
-        tm.assert_series_equal(result, expected)
-
-    def test_numpy_compress(self):
-        cond = [True, False, True, False, False]
-        s = Series([1, -1, 5, 8, 7], index=list("abcde"), name="foo")
-        expected = Series(s.values.compress(cond), index=list("ac"), name="foo")
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            tm.assert_series_equal(np.compress(cond, s), expected)
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            msg = "the 'axis' parameter is not supported"
-            with pytest.raises(ValueError, match=msg):
-                np.compress(cond, s, axis=1)
-
-            msg = "the 'out' parameter is not supported"
-            with pytest.raises(ValueError, match=msg):
-                np.compress(cond, s, out=s)
-
-    def test_round(self, datetime_series):
-        datetime_series.index.name = "index_name"
-        result = datetime_series.round(2)
-        expected = Series(
-            np.round(datetime_series.values, 2), index=datetime_series.index, name="ts"
-        )
-        assert_series_equal(result, expected)
-        assert result.name == datetime_series.name
-
-    def test_numpy_round(self):
-        # See gh-12600
-        s = Series([1.53, 1.36, 0.06])
-        out = np.round(s, decimals=0)
-        expected = Series([2.0, 1.0, 0.0])
-        assert_series_equal(out, expected)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.round(s, decimals=0, out=s)
-
-    def test_numpy_round_nan(self):
-        # See gh-14197
-        s = Series([1.53, np.nan, 0.06])
-        with tm.assert_produces_warning(None):
-            result = s.round()
-        expected = Series([2.0, np.nan, 0.0])
-        assert_series_equal(result, expected)
-
-    def test_built_in_round(self):
-        s = Series([1.123, 2.123, 3.123], index=range(3))
-        result = round(s)
-        expected_rounded0 = Series([1.0, 2.0, 3.0], index=range(3))
-        tm.assert_series_equal(result, expected_rounded0)
-
-        decimals = 2
-        expected_rounded = Series([1.12, 2.12, 3.12], index=range(3))
-        result = round(s, decimals)
-        tm.assert_series_equal(result, expected_rounded)
-
     def test_prod_numpy16_bug(self):
         s = Series([1.0, 1.0, 1.0], index=range(3))
         result = s.prod()
 
         assert not isinstance(result, Series)
 
-    @td.skip_if_no_scipy
-    def test_corr(self, datetime_series):
-        import scipy.stats as stats
-
-        # full overlap
-        tm.assert_almost_equal(datetime_series.corr(datetime_series), 1)
-
-        # partial overlap
-        tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), 1)
-
-        assert isna(datetime_series[:15].corr(datetime_series[5:], min_periods=12))
-
-        ts1 = datetime_series[:15].reindex(datetime_series.index)
-        ts2 = datetime_series[5:].reindex(datetime_series.index)
-        assert isna(ts1.corr(ts2, min_periods=12))
-
-        # No overlap
-        assert np.isnan(datetime_series[::2].corr(datetime_series[1::2]))
-
-        # all NA
-        cp = datetime_series[:10].copy()
-        cp[:] = np.nan
-        assert isna(cp.corr(cp))
-
-        A = tm.makeTimeSeries()
-        B = tm.makeTimeSeries()
-        result = A.corr(B)
-        expected, _ = stats.pearsonr(A, B)
-        tm.assert_almost_equal(result, expected)
-
-    @td.skip_if_no_scipy
-    def test_corr_rank(self):
-        import scipy.stats as stats
-
-        # kendall and spearman
-        A = tm.makeTimeSeries()
-        B = tm.makeTimeSeries()
-        A[-5:] = A[:5]
-        result = A.corr(B, method="kendall")
-        expected = stats.kendalltau(A, B)[0]
-        tm.assert_almost_equal(result, expected)
-
-        result = A.corr(B, method="spearman")
-        expected = stats.spearmanr(A, B)[0]
-        tm.assert_almost_equal(result, expected)
-
-        # results from R
-        A = Series(
-            [
-                -0.89926396,
-                0.94209606,
-                -1.03289164,
-                -0.95445587,
-                0.76910310,
-                -0.06430576,
-                -2.09704447,
-                0.40660407,
-                -0.89926396,
-                0.94209606,
-            ]
-        )
-        B = Series(
-            [
-                -1.01270225,
-                -0.62210117,
-                -1.56895827,
-                0.59592943,
-                -0.01680292,
-                1.17258718,
-                -1.06009347,
-                -0.10222060,
-                -0.89076239,
-                0.89372375,
-            ]
-        )
-        kexp = 0.4319297
-        sexp = 0.5853767
-        tm.assert_almost_equal(A.corr(B, method="kendall"), kexp)
-        tm.assert_almost_equal(A.corr(B, method="spearman"), sexp)
-
-    def test_corr_invalid_method(self):
-        # GH PR #22298
-        s1 = pd.Series(np.random.randn(10))
-        s2 = pd.Series(np.random.randn(10))
-        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
-        with pytest.raises(ValueError, match=msg):
-            s1.corr(s2, method="____")
-
-    def test_corr_callable_method(self, datetime_series):
-        # simple correlation example
-        # returns 1 if exact equality, 0 otherwise
-        my_corr = lambda a, b: 1.0 if (a == b).all() else 0.0
-
-        # simple example
-        s1 = Series([1, 2, 3, 4, 5])
-        s2 = Series([5, 4, 3, 2, 1])
-        expected = 0
-        tm.assert_almost_equal(s1.corr(s2, method=my_corr), expected)
-
-        # full overlap
-        tm.assert_almost_equal(
-            datetime_series.corr(datetime_series, method=my_corr), 1.0
-        )
-
-        # partial overlap
-        tm.assert_almost_equal(
-            datetime_series[:15].corr(datetime_series[5:], method=my_corr), 1.0
-        )
-
-        # No overlap
-        assert np.isnan(
-            datetime_series[::2].corr(datetime_series[1::2], method=my_corr)
-        )
-
-        # dataframe example
-        df = pd.DataFrame([s1, s2])
-        expected = pd.DataFrame([{0: 1.0, 1: 0}, {0: 0, 1: 1.0}])
-        tm.assert_almost_equal(df.transpose().corr(method=my_corr), expected)
-
-    def test_cov(self, datetime_series):
-        # full overlap
-        tm.assert_almost_equal(
-            datetime_series.cov(datetime_series), datetime_series.std() ** 2
-        )
-
-        # partial overlap
-        tm.assert_almost_equal(
-            datetime_series[:15].cov(datetime_series[5:]),
-            datetime_series[5:15].std() ** 2,
-        )
-
-        # No overlap
-        assert np.isnan(datetime_series[::2].cov(datetime_series[1::2]))
-
-        # all NA
-        cp = datetime_series[:10].copy()
-        cp[:] = np.nan
-        assert isna(cp.cov(cp))
-
-        # min_periods
-        assert isna(datetime_series[:15].cov(datetime_series[5:], min_periods=12))
-
-        ts1 = datetime_series[:15].reindex(datetime_series.index)
-        ts2 = datetime_series[5:].reindex(datetime_series.index)
-        assert isna(ts1.cov(ts2, min_periods=12))
-
-    def test_count(self, datetime_series):
-        assert datetime_series.count() == len(datetime_series)
-
-        datetime_series[::2] = np.NaN
-
-        assert datetime_series.count() == np.isfinite(datetime_series).sum()
-
-        mi = MultiIndex.from_arrays([list("aabbcc"), [1, 2, 2, nan, 1, 2]])
-        ts = Series(np.arange(len(mi)), index=mi)
-
-        left = ts.count(level=1)
-        right = Series([2, 3, 1], index=[1, 2, nan])
-        assert_series_equal(left, right)
-
-        ts.iloc[[0, 3, 5]] = nan
-        assert_series_equal(ts.count(level=1), right - 1)
-
     def test_dot(self):
         a = Series(np.random.randn(4), index=["p", "q", "r", "s"])
         b = DataFrame(
@@ -494,21 +25,21 @@ def test_dot(self):
 
         result = a.dot(b)
         expected = Series(np.dot(a.values, b.values), index=["1", "2", "3"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Check index alignment
         b2 = b.reindex(index=reversed(b.index))
         result = a.dot(b)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Check ndarray argument
         result = a.dot(b.values)
         assert np.all(result == expected.values)
-        assert_almost_equal(a.dot(b["2"].values), expected["2"])
+        tm.assert_almost_equal(a.dot(b["2"].values), expected["2"])
 
         # Check series argument
-        assert_almost_equal(a.dot(b["1"]), expected["1"])
-        assert_almost_equal(a.dot(b2["1"]), expected["1"])
+        tm.assert_almost_equal(a.dot(b["1"]), expected["1"])
+        tm.assert_almost_equal(a.dot(b2["1"]), expected["1"])
 
         msg = r"Dot product shape mismatch, \(4,\) vs \(3,\)"
         # exception raised is of type Exception
@@ -528,53 +59,53 @@ def test_matmul(self):
         # Series @ DataFrame -> Series
         result = operator.matmul(a, b)
         expected = Series(np.dot(a.values, b.values), index=["1", "2", "3"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # DataFrame @ Series -> Series
         result = operator.matmul(b.T, a)
         expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Series @ Series -> scalar
         result = operator.matmul(a, a)
         expected = np.dot(a.values, a.values)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         # GH 21530
         # vector (1D np.array) @ Series (__rmatmul__)
         result = operator.matmul(a.values, a)
         expected = np.dot(a.values, a.values)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         # GH 21530
         # vector (1D list) @ Series (__rmatmul__)
         result = operator.matmul(a.values.tolist(), a)
         expected = np.dot(a.values, a.values)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         # GH 21530
         # matrix (2D np.array) @ Series (__rmatmul__)
         result = operator.matmul(b.T.values, a)
         expected = np.dot(b.T.values, a.values)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         # GH 21530
         # matrix (2D nested lists) @ Series (__rmatmul__)
         result = operator.matmul(b.T.values.tolist(), a)
         expected = np.dot(b.T.values, a.values)
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         # mixed dtype DataFrame @ Series
         a["p"] = int(a.p)
         result = operator.matmul(b.T, a)
         expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # different dtypes DataFrame @ Series
         a = a.astype(int)
         result = operator.matmul(b.T, a)
         expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         msg = r"Dot product shape mismatch, \(4,\) vs \(3,\)"
         # exception raised is of type Exception
@@ -584,325 +115,34 @@ def test_matmul(self):
         with pytest.raises(ValueError, match=msg):
             a.dot(b.T)
 
-    def test_clip(self, datetime_series):
-        val = datetime_series.median()
-
-        with tm.assert_produces_warning(FutureWarning):
-            assert datetime_series.clip_lower(val).min() == val
-        with tm.assert_produces_warning(FutureWarning):
-            assert datetime_series.clip_upper(val).max() == val
-
-        assert datetime_series.clip(lower=val).min() == val
-        assert datetime_series.clip(upper=val).max() == val
-
-        result = datetime_series.clip(-0.5, 0.5)
-        expected = np.clip(datetime_series, -0.5, 0.5)
-        assert_series_equal(result, expected)
-        assert isinstance(expected, Series)
-
-    def test_clip_types_and_nulls(self):
-
-        sers = [
-            Series([np.nan, 1.0, 2.0, 3.0]),
-            Series([None, "a", "b", "c"]),
-            Series(pd.to_datetime([np.nan, 1, 2, 3], unit="D")),
-        ]
-
-        for s in sers:
-            thresh = s[2]
-            with tm.assert_produces_warning(FutureWarning):
-                lower = s.clip_lower(thresh)
-            with tm.assert_produces_warning(FutureWarning):
-                upper = s.clip_upper(thresh)
-            assert lower[notna(lower)].min() == thresh
-            assert upper[notna(upper)].max() == thresh
-            assert list(isna(s)) == list(isna(lower))
-            assert list(isna(s)) == list(isna(upper))
-
-    def test_clip_with_na_args(self):
-        """Should process np.nan argument as None """
-        # GH # 17276
-        s = Series([1, 2, 3])
-
-        assert_series_equal(s.clip(np.nan), Series([1, 2, 3]))
-        assert_series_equal(s.clip(upper=np.nan, lower=np.nan), Series([1, 2, 3]))
-
-        # GH #19992
-        assert_series_equal(s.clip(lower=[0, 4, np.nan]), Series([1, 4, np.nan]))
-        assert_series_equal(s.clip(upper=[1, np.nan, 1]), Series([1, np.nan, 1]))
-
-    def test_clip_against_series(self):
-        # GH #6966
-
-        s = Series([1.0, 1.0, 4.0])
-        threshold = Series([1.0, 2.0, 3.0])
-
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(s.clip_lower(threshold), Series([1.0, 2.0, 4.0]))
-        with tm.assert_produces_warning(FutureWarning):
-            assert_series_equal(s.clip_upper(threshold), Series([1.0, 1.0, 3.0]))
-
-        lower = Series([1.0, 2.0, 3.0])
-        upper = Series([1.5, 2.5, 3.5])
-
-        assert_series_equal(s.clip(lower, upper), Series([1.0, 2.0, 3.5]))
-        assert_series_equal(s.clip(1.5, upper), Series([1.5, 1.5, 3.5]))
-
-    @pytest.mark.parametrize("inplace", [True, False])
-    @pytest.mark.parametrize("upper", [[1, 2, 3], np.asarray([1, 2, 3])])
-    def test_clip_against_list_like(self, inplace, upper):
-        # GH #15390
-        original = pd.Series([5, 6, 7])
-        result = original.clip(upper=upper, inplace=inplace)
-        expected = pd.Series([1, 2, 3])
-
-        if inplace:
-            result = original
-        tm.assert_series_equal(result, expected, check_exact=True)
-
-    def test_clip_with_datetimes(self):
-
-        # GH 11838
-        # naive and tz-aware datetimes
-
-        t = Timestamp("2015-12-01 09:30:30")
-        s = Series([Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:31:00")])
-        result = s.clip(upper=t)
-        expected = Series(
-            [Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:30:30")]
-        )
-        assert_series_equal(result, expected)
-
-        t = Timestamp("2015-12-01 09:30:30", tz="US/Eastern")
-        s = Series(
-            [
-                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
-                Timestamp("2015-12-01 09:31:00", tz="US/Eastern"),
-            ]
-        )
-        result = s.clip(upper=t)
-        expected = Series(
-            [
-                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
-                Timestamp("2015-12-01 09:30:30", tz="US/Eastern"),
-            ]
-        )
-        assert_series_equal(result, expected)
-
-    def test_cummethods_bool(self):
-        # GH 6270
-
-        a = pd.Series([False, False, False, True, True, False, False])
-        b = ~a
-        c = pd.Series([False] * len(b))
-        d = ~c
-        methods = {
-            "cumsum": np.cumsum,
-            "cumprod": np.cumprod,
-            "cummin": np.minimum.accumulate,
-            "cummax": np.maximum.accumulate,
-        }
-        args = product((a, b, c, d), methods)
-        for s, method in args:
-            expected = Series(methods[method](s.values))
-            result = getattr(s, method)()
-            assert_series_equal(result, expected)
-
-        e = pd.Series([False, True, nan, False])
-        cse = pd.Series([0, 1, nan, 1], dtype=object)
-        cpe = pd.Series([False, 0, nan, 0])
-        cmin = pd.Series([False, False, nan, False])
-        cmax = pd.Series([False, True, nan, True])
-        expecteds = {"cumsum": cse, "cumprod": cpe, "cummin": cmin, "cummax": cmax}
-
-        for method in methods:
-            res = getattr(e, method)()
-            assert_series_equal(res, expecteds[method])
-
-    def test_isin(self):
-        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
-
-        result = s.isin(["A", "C"])
-        expected = Series([True, False, True, False, False, False, True, True])
-        assert_series_equal(result, expected)
-
-        # GH: 16012
-        # This specific issue has to have a series over 1e6 in len, but the
-        # comparison array (in_list) must be large enough so that numpy doesn't
-        # do a manual masking trick that will avoid this issue altogether
-        s = Series(list("abcdefghijk" * 10 ** 5))
-        # If numpy doesn't do the manual comparison/mask, these
-        # unorderable mixed types are what cause the exception in numpy
-        in_list = [-1, "a", "b", "G", "Y", "Z", "E", "K", "E", "S", "I", "R", "R"] * 6
-
-        assert s.isin(in_list).sum() == 200000
-
-    def test_isin_with_string_scalar(self):
-        # GH4763
-        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
-        msg = (
-            r"only list-like objects are allowed to be passed to isin\(\),"
-            r" you passed a \[str\]"
-        )
-        with pytest.raises(TypeError, match=msg):
-            s.isin("a")
-
-        s = Series(["aaa", "b", "c"])
-        with pytest.raises(TypeError, match=msg):
-            s.isin("aaa")
-
-    def test_isin_with_i8(self):
-        # GH 5021
-
-        expected = Series([True, True, False, False, False])
-        expected2 = Series([False, True, False, False, False])
-
-        # datetime64[ns]
-        s = Series(date_range("jan-01-2013", "jan-05-2013"))
-
-        result = s.isin(s[0:2])
-        assert_series_equal(result, expected)
-
-        result = s.isin(s[0:2].values)
-        assert_series_equal(result, expected)
-
-        # fails on dtype conversion in the first place
-        result = s.isin(s[0:2].values.astype("datetime64[D]"))
-        assert_series_equal(result, expected)
-
-        result = s.isin([s[1]])
-        assert_series_equal(result, expected2)
-
-        result = s.isin([np.datetime64(s[1])])
-        assert_series_equal(result, expected2)
-
-        result = s.isin(set(s[0:2]))
-        assert_series_equal(result, expected)
-
-        # timedelta64[ns]
-        s = Series(pd.to_timedelta(range(5), unit="d"))
-        result = s.isin(s[0:2])
-        assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("empty", [[], Series(), np.array([])])
-    def test_isin_empty(self, empty):
-        # see gh-16991
-        s = Series(["a", "b"])
-        expected = Series([False, False])
-
-        result = s.isin(empty)
-        tm.assert_series_equal(expected, result)
-
     def test_ptp(self):
         # GH21614
         N = 1000
         arr = np.random.randn(N)
         ser = Series(arr)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            assert np.ptp(ser) == np.ptp(arr)
-
-        # GH11163
-        s = Series([3, 5, np.nan, -3, 10])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            assert s.ptp() == 13
-            assert pd.isna(s.ptp(skipna=False))
-
-        mi = pd.MultiIndex.from_product([["a", "b"], [1, 2, 3]])
-        s = pd.Series([1, np.nan, 7, 3, 5, np.nan], index=mi)
-
-        expected = pd.Series([6, 2], index=["a", "b"], dtype=np.float64)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            tm.assert_series_equal(s.ptp(level=0), expected)
-
-        expected = pd.Series([np.nan, np.nan], index=["a", "b"])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            tm.assert_series_equal(s.ptp(level=0, skipna=False), expected)
-
-        msg = "No axis named 1 for object type <class 'pandas.core.series.Series'>"
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                s.ptp(axis=1)
-
-        s = pd.Series(["a", "b", "c", "d", "e"])
-        msg = r"unsupported operand type\(s\) for -: 'str' and 'str'"
-        with pytest.raises(TypeError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                s.ptp()
-
-        msg = r"Series\.ptp does not implement numeric_only\."
-        with pytest.raises(NotImplementedError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-                s.ptp(numeric_only=True)
+        assert np.ptp(ser) == np.ptp(arr)
 
     def test_repeat(self):
         s = Series(np.random.randn(3), index=["a", "b", "c"])
 
         reps = s.repeat(5)
         exp = Series(s.values.repeat(5), index=s.index.values.repeat(5))
-        assert_series_equal(reps, exp)
+        tm.assert_series_equal(reps, exp)
 
         to_rep = [2, 3, 4]
         reps = s.repeat(to_rep)
         exp = Series(s.values.repeat(to_rep), index=s.index.values.repeat(to_rep))
-        assert_series_equal(reps, exp)
+        tm.assert_series_equal(reps, exp)
 
     def test_numpy_repeat(self):
         s = Series(np.arange(3), name="x")
         expected = Series(s.values.repeat(2), name="x", index=s.index.values.repeat(2))
-        assert_series_equal(np.repeat(s, 2), expected)
+        tm.assert_series_equal(np.repeat(s, 2), expected)
 
         msg = "the 'axis' parameter is not supported"
         with pytest.raises(ValueError, match=msg):
             np.repeat(s, 2, axis=0)
 
-    def test_searchsorted(self):
-        s = Series([1, 2, 3])
-
-        result = s.searchsorted(1, side="left")
-        assert is_scalar(result)
-        assert result == 0
-
-        result = s.searchsorted(1, side="right")
-        assert is_scalar(result)
-        assert result == 1
-
-    def test_searchsorted_numeric_dtypes_scalar(self):
-        s = Series([1, 2, 90, 1000, 3e9])
-        r = s.searchsorted(30)
-        assert is_scalar(r)
-        assert r == 2
-
-        r = s.searchsorted([30])
-        e = np.array([2], dtype=np.intp)
-        tm.assert_numpy_array_equal(r, e)
-
-    def test_searchsorted_numeric_dtypes_vector(self):
-        s = Series([1, 2, 90, 1000, 3e9])
-        r = s.searchsorted([91, 2e6])
-        e = np.array([3, 4], dtype=np.intp)
-        tm.assert_numpy_array_equal(r, e)
-
-    def test_search_sorted_datetime64_scalar(self):
-        s = Series(pd.date_range("20120101", periods=10, freq="2D"))
-        v = pd.Timestamp("20120102")
-        r = s.searchsorted(v)
-        assert is_scalar(r)
-        assert r == 1
-
-    def test_search_sorted_datetime64_list(self):
-        s = Series(pd.date_range("20120101", periods=10, freq="2D"))
-        v = [pd.Timestamp("20120102"), pd.Timestamp("20120104")]
-        r = s.searchsorted(v)
-        e = np.array([1, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(r, e)
-
-    def test_searchsorted_sorter(self):
-        # GH8490
-        s = Series([3, 1, 2])
-        r = s.searchsorted([0, 3], sorter=np.argsort(s))
-        e = np.array([0, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(r, e)
-
     def test_is_monotonic(self):
 
         s = Series(np.random.randint(0, 10, size=1000))
@@ -920,233 +160,6 @@ def test_is_monotonic(self):
         assert s.is_monotonic is False
         assert s.is_monotonic_decreasing is True
 
-    def test_sort_index_level(self):
-        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
-        s = Series([1, 2], mi)
-        backwards = s.iloc[[1, 0]]
-
-        res = s.sort_index(level="A")
-        assert_series_equal(backwards, res)
-
-        res = s.sort_index(level=["A", "B"])
-        assert_series_equal(backwards, res)
-
-        res = s.sort_index(level="A", sort_remaining=False)
-        assert_series_equal(s, res)
-
-        res = s.sort_index(level=["A", "B"], sort_remaining=False)
-        assert_series_equal(s, res)
-
-    def test_apply_categorical(self):
-        values = pd.Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
-        s = pd.Series(values, name="XX", index=list("abcdefg"))
-        result = s.apply(lambda x: x.lower())
-
-        # should be categorical dtype when the number of categories are
-        # the same
-        values = pd.Categorical(list("abbabcd"), categories=list("dcba"), ordered=True)
-        exp = pd.Series(values, name="XX", index=list("abcdefg"))
-        tm.assert_series_equal(result, exp)
-        tm.assert_categorical_equal(result.values, exp.values)
-
-        result = s.apply(lambda x: "A")
-        exp = pd.Series(["A"] * 7, name="XX", index=list("abcdefg"))
-        tm.assert_series_equal(result, exp)
-        assert result.dtype == np.object
-
-    def test_shift_int(self, datetime_series):
-        ts = datetime_series.astype(int)
-        shifted = ts.shift(1)
-        expected = ts.astype(float).shift(1)
-        assert_series_equal(shifted, expected)
-
-    def test_shift_categorical(self):
-        # GH 9416
-        s = pd.Series(["a", "b", "c", "d"], dtype="category")
-
-        assert_series_equal(s.iloc[:-1], s.shift(1).shift(-1).dropna())
-
-        sp1 = s.shift(1)
-        assert_index_equal(s.index, sp1.index)
-        assert np.all(sp1.values.codes[:1] == -1)
-        assert np.all(s.values.codes[:-1] == sp1.values.codes[1:])
-
-        sn2 = s.shift(-2)
-        assert_index_equal(s.index, sn2.index)
-        assert np.all(sn2.values.codes[-2:] == -1)
-        assert np.all(s.values.codes[2:] == sn2.values.codes[:-2])
-
-        assert_index_equal(s.values.categories, sp1.values.categories)
-        assert_index_equal(s.values.categories, sn2.values.categories)
-
-    def test_unstack(self):
-        from numpy import nan
-
-        index = MultiIndex(
-            levels=[["bar", "foo"], ["one", "three", "two"]],
-            codes=[[1, 1, 0, 0], [0, 1, 0, 2]],
-        )
-
-        s = Series(np.arange(4.0), index=index)
-        unstacked = s.unstack()
-
-        expected = DataFrame(
-            [[2.0, nan, 3.0], [0.0, 1.0, nan]],
-            index=["bar", "foo"],
-            columns=["one", "three", "two"],
-        )
-
-        assert_frame_equal(unstacked, expected)
-
-        unstacked = s.unstack(level=0)
-        assert_frame_equal(unstacked, expected.T)
-
-        index = MultiIndex(
-            levels=[["bar"], ["one", "two", "three"], [0, 1]],
-            codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
-        )
-        s = Series(np.random.randn(6), index=index)
-        exp_index = MultiIndex(
-            levels=[["one", "two", "three"], [0, 1]],
-            codes=[[0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
-        )
-        expected = DataFrame({"bar": s.values}, index=exp_index).sort_index(level=0)
-        unstacked = s.unstack(0).sort_index()
-        assert_frame_equal(unstacked, expected)
-
-        # GH5873
-        idx = pd.MultiIndex.from_arrays([[101, 102], [3.5, np.nan]])
-        ts = pd.Series([1, 2], index=idx)
-        left = ts.unstack()
-        right = DataFrame([[nan, 1], [2, nan]], index=[101, 102], columns=[nan, 3.5])
-        assert_frame_equal(left, right)
-
-        idx = pd.MultiIndex.from_arrays(
-            [
-                ["cat", "cat", "cat", "dog", "dog"],
-                ["a", "a", "b", "a", "b"],
-                [1, 2, 1, 1, np.nan],
-            ]
-        )
-        ts = pd.Series([1.0, 1.1, 1.2, 1.3, 1.4], index=idx)
-        right = DataFrame(
-            [[1.0, 1.3], [1.1, nan], [nan, 1.4], [1.2, nan]], columns=["cat", "dog"]
-        )
-        tpls = [("a", 1), ("a", 2), ("b", nan), ("b", 1)]
-        right.index = pd.MultiIndex.from_tuples(tpls)
-        assert_frame_equal(ts.unstack(level=0), right)
-
-    def test_value_counts_datetime(self):
-        # most dtypes are tested in test_base.py
-        values = [
-            pd.Timestamp("2011-01-01 09:00"),
-            pd.Timestamp("2011-01-01 10:00"),
-            pd.Timestamp("2011-01-01 11:00"),
-            pd.Timestamp("2011-01-01 09:00"),
-            pd.Timestamp("2011-01-01 09:00"),
-            pd.Timestamp("2011-01-01 11:00"),
-        ]
-
-        exp_idx = pd.DatetimeIndex(
-            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"]
-        )
-        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
-
-        s = pd.Series(values, name="xxx")
-        tm.assert_series_equal(s.value_counts(), exp)
-        # check DatetimeIndex outputs the same result
-        idx = pd.DatetimeIndex(values, name="xxx")
-        tm.assert_series_equal(idx.value_counts(), exp)
-
-        # normalize
-        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
-        tm.assert_series_equal(s.value_counts(normalize=True), exp)
-        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
-
-    def test_value_counts_datetime_tz(self):
-        values = [
-            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
-            pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"),
-            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
-            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
-            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
-            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
-        ]
-
-        exp_idx = pd.DatetimeIndex(
-            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
-            tz="US/Eastern",
-        )
-        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
-
-        s = pd.Series(values, name="xxx")
-        tm.assert_series_equal(s.value_counts(), exp)
-        idx = pd.DatetimeIndex(values, name="xxx")
-        tm.assert_series_equal(idx.value_counts(), exp)
-
-        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
-        tm.assert_series_equal(s.value_counts(normalize=True), exp)
-        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
-
-    def test_value_counts_period(self):
-        values = [
-            pd.Period("2011-01", freq="M"),
-            pd.Period("2011-02", freq="M"),
-            pd.Period("2011-03", freq="M"),
-            pd.Period("2011-01", freq="M"),
-            pd.Period("2011-01", freq="M"),
-            pd.Period("2011-03", freq="M"),
-        ]
-
-        exp_idx = pd.PeriodIndex(["2011-01", "2011-03", "2011-02"], freq="M")
-        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
-
-        s = pd.Series(values, name="xxx")
-        tm.assert_series_equal(s.value_counts(), exp)
-        # check DatetimeIndex outputs the same result
-        idx = pd.PeriodIndex(values, name="xxx")
-        tm.assert_series_equal(idx.value_counts(), exp)
-
-        # normalize
-        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
-        tm.assert_series_equal(s.value_counts(normalize=True), exp)
-        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
-
-    def test_value_counts_categorical_ordered(self):
-        # most dtypes are tested in test_base.py
-        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=True)
-
-        exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=True)
-        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
-
-        s = pd.Series(values, name="xxx")
-        tm.assert_series_equal(s.value_counts(), exp)
-        # check CategoricalIndex outputs the same result
-        idx = pd.CategoricalIndex(values, name="xxx")
-        tm.assert_series_equal(idx.value_counts(), exp)
-
-        # normalize
-        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
-        tm.assert_series_equal(s.value_counts(normalize=True), exp)
-        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
-
-    def test_value_counts_categorical_not_ordered(self):
-        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=False)
-
-        exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=False)
-        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")
-
-        s = pd.Series(values, name="xxx")
-        tm.assert_series_equal(s.value_counts(), exp)
-        # check CategoricalIndex outputs the same result
-        idx = pd.CategoricalIndex(values, name="xxx")
-        tm.assert_series_equal(idx.value_counts(), exp)
-
-        # normalize
-        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
-        tm.assert_series_equal(s.value_counts(normalize=True), exp)
-        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
-
     @pytest.mark.parametrize("func", [np.any, np.all])
     @pytest.mark.parametrize("kwargs", [dict(keepdims=True), dict(out=object())])
     @td.skip_if_np_lt("1.15")
@@ -1196,381 +209,3 @@ def test_validate_stat_keepdims(self):
         )
         with pytest.raises(ValueError, match=msg):
             np.sum(s, keepdims=True)
-
-    def test_compound_deprecated(self):
-        s = Series([0.1, 0.2, 0.3, 0.4])
-        with tm.assert_produces_warning(FutureWarning):
-            s.compound()
-
-        df = pd.DataFrame({"s": s})
-        with tm.assert_produces_warning(FutureWarning):
-            df.compound()
-
-
-main_dtypes = [
-    "datetime",
-    "datetimetz",
-    "timedelta",
-    "int8",
-    "int16",
-    "int32",
-    "int64",
-    "float32",
-    "float64",
-    "uint8",
-    "uint16",
-    "uint32",
-    "uint64",
-]
-
-
-@pytest.fixture
-def s_main_dtypes():
-    """A DataFrame with many dtypes
-
-    * datetime
-    * datetimetz
-    * timedelta
-    * [u]int{8,16,32,64}
-    * float{32,64}
-
-    The columns are the name of the dtype.
-    """
-    df = pd.DataFrame(
-        {
-            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
-            "datetimetz": pd.to_datetime(
-                ["2003", "2002", "2001", "2002", "2005"]
-            ).tz_localize("US/Eastern"),
-            "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
-        }
-    )
-
-    for dtype in [
-        "int8",
-        "int16",
-        "int32",
-        "int64",
-        "float32",
-        "float64",
-        "uint8",
-        "uint16",
-        "uint32",
-        "uint64",
-    ]:
-        df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
-
-    return df
-
-
-@pytest.fixture(params=main_dtypes)
-def s_main_dtypes_split(request, s_main_dtypes):
-    """Each series in s_main_dtypes."""
-    return s_main_dtypes[request.param]
-
-
-def assert_check_nselect_boundary(vals, dtype, method):
-    # helper function for 'test_boundary_{dtype}' tests
-    s = Series(vals, dtype=dtype)
-    result = getattr(s, method)(3)
-    expected_idxr = [0, 1, 2] if method == "nsmallest" else [3, 2, 1]
-    expected = s.loc[expected_idxr]
-    tm.assert_series_equal(result, expected)
-
-
-class TestNLargestNSmallest:
-    @pytest.mark.parametrize(
-        "r",
-        [
-            Series([3.0, 2, 1, 2, "5"], dtype="object"),
-            Series([3.0, 2, 1, 2, 5], dtype="object"),
-            # not supported on some archs
-            # Series([3., 2, 1, 2, 5], dtype='complex256'),
-            Series([3.0, 2, 1, 2, 5], dtype="complex128"),
-            Series(list("abcde")),
-            Series(list("abcde"), dtype="category"),
-        ],
-    )
-    def test_error(self, r):
-        dt = r.dtype
-        msg = "Cannot use method 'n(larg|small)est' with dtype {dt}".format(dt=dt)
-        args = 2, len(r), 0, -1
-        methods = r.nlargest, r.nsmallest
-        for method, arg in product(methods, args):
-            with pytest.raises(TypeError, match=msg):
-                method(arg)
-
-    def test_nsmallest_nlargest(self, s_main_dtypes_split):
-        # float, int, datetime64 (use i8), timedelts64 (same),
-        # object that are numbers, object that are strings
-        s = s_main_dtypes_split
-
-        assert_series_equal(s.nsmallest(2), s.iloc[[2, 1]])
-        assert_series_equal(s.nsmallest(2, keep="last"), s.iloc[[2, 3]])
-
-        empty = s.iloc[0:0]
-        assert_series_equal(s.nsmallest(0), empty)
-        assert_series_equal(s.nsmallest(-1), empty)
-        assert_series_equal(s.nlargest(0), empty)
-        assert_series_equal(s.nlargest(-1), empty)
-
-        assert_series_equal(s.nsmallest(len(s)), s.sort_values())
-        assert_series_equal(s.nsmallest(len(s) + 1), s.sort_values())
-        assert_series_equal(s.nlargest(len(s)), s.iloc[[4, 0, 1, 3, 2]])
-        assert_series_equal(s.nlargest(len(s) + 1), s.iloc[[4, 0, 1, 3, 2]])
-
-    def test_misc(self):
-
-        s = Series([3.0, np.nan, 1, 2, 5])
-        assert_series_equal(s.nlargest(), s.iloc[[4, 0, 3, 2]])
-        assert_series_equal(s.nsmallest(), s.iloc[[2, 3, 0, 4]])
-
-        msg = 'keep must be either "first", "last"'
-        with pytest.raises(ValueError, match=msg):
-            s.nsmallest(keep="invalid")
-        with pytest.raises(ValueError, match=msg):
-            s.nlargest(keep="invalid")
-
-        # GH 15297
-        s = Series([1] * 5, index=[1, 2, 3, 4, 5])
-        expected_first = Series([1] * 3, index=[1, 2, 3])
-        expected_last = Series([1] * 3, index=[5, 4, 3])
-
-        result = s.nsmallest(3)
-        assert_series_equal(result, expected_first)
-
-        result = s.nsmallest(3, keep="last")
-        assert_series_equal(result, expected_last)
-
-        result = s.nlargest(3)
-        assert_series_equal(result, expected_first)
-
-        result = s.nlargest(3, keep="last")
-        assert_series_equal(result, expected_last)
-
-    @pytest.mark.parametrize("n", range(1, 5))
-    def test_n(self, n):
-
-        # GH 13412
-        s = Series([1, 4, 3, 2], index=[0, 0, 1, 1])
-        result = s.nlargest(n)
-        expected = s.sort_values(ascending=False).head(n)
-        assert_series_equal(result, expected)
-
-        result = s.nsmallest(n)
-        expected = s.sort_values().head(n)
-        assert_series_equal(result, expected)
-
-    def test_boundary_integer(self, nselect_method, any_int_dtype):
-        # GH 21426
-        dtype_info = np.iinfo(any_int_dtype)
-        min_val, max_val = dtype_info.min, dtype_info.max
-        vals = [min_val, min_val + 1, max_val - 1, max_val]
-        assert_check_nselect_boundary(vals, any_int_dtype, nselect_method)
-
-    def test_boundary_float(self, nselect_method, float_dtype):
-        # GH 21426
-        dtype_info = np.finfo(float_dtype)
-        min_val, max_val = dtype_info.min, dtype_info.max
-        min_2nd, max_2nd = np.nextafter([min_val, max_val], 0, dtype=float_dtype)
-        vals = [min_val, min_2nd, max_2nd, max_val]
-        assert_check_nselect_boundary(vals, float_dtype, nselect_method)
-
-    @pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
-    def test_boundary_datetimelike(self, nselect_method, dtype):
-        # GH 21426
-        # use int64 bounds and +1 to min_val since true minimum is NaT
-        # (include min_val/NaT at end to maintain same expected_idxr)
-        dtype_info = np.iinfo("int64")
-        min_val, max_val = dtype_info.min, dtype_info.max
-        vals = [min_val + 1, min_val + 2, max_val - 1, max_val, min_val]
-        assert_check_nselect_boundary(vals, dtype, nselect_method)
-
-    def test_duplicate_keep_all_ties(self):
-        # see gh-16818
-        s = Series([10, 9, 8, 7, 7, 7, 7, 6])
-        result = s.nlargest(4, keep="all")
-        expected = Series([10, 9, 8, 7, 7, 7, 7])
-        assert_series_equal(result, expected)
-
-        result = s.nsmallest(2, keep="all")
-        expected = Series([6, 7, 7, 7, 7], index=[7, 3, 4, 5, 6])
-        assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "data,expected", [([True, False], [True]), ([True, False, True, True], [True])]
-    )
-    def test_boolean(self, data, expected):
-        # GH 26154 : ensure True > False
-        s = Series(data)
-        result = s.nlargest(1)
-        expected = Series(expected)
-        assert_series_equal(result, expected)
-
-
-class TestCategoricalSeriesAnalytics:
-    def test_count(self):
-
-        s = Series(
-            Categorical(
-                [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
-            )
-        )
-        result = s.count()
-        assert result == 2
-
-    def test_value_counts(self):
-        # GH 12835
-        cats = Categorical(list("abcccb"), categories=list("cabd"))
-        s = Series(cats, name="xxx")
-        res = s.value_counts(sort=False)
-
-        exp_index = CategoricalIndex(list("cabd"), categories=cats.categories)
-        exp = Series([3, 1, 2, 0], name="xxx", index=exp_index)
-        tm.assert_series_equal(res, exp)
-
-        res = s.value_counts(sort=True)
-
-        exp_index = CategoricalIndex(list("cbad"), categories=cats.categories)
-        exp = Series([3, 2, 1, 0], name="xxx", index=exp_index)
-        tm.assert_series_equal(res, exp)
-
-        # check object dtype handles the Series.name as the same
-        # (tested in test_base.py)
-        s = Series(["a", "b", "c", "c", "c", "b"], name="xxx")
-        res = s.value_counts()
-        exp = Series([3, 2, 1], name="xxx", index=["c", "b", "a"])
-        tm.assert_series_equal(res, exp)
-
-    def test_value_counts_with_nan(self):
-        # see gh-9443
-
-        # sanity check
-        s = Series(["a", "b", "a"], dtype="category")
-        exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))
-
-        res = s.value_counts(dropna=True)
-        tm.assert_series_equal(res, exp)
-
-        res = s.value_counts(dropna=True)
-        tm.assert_series_equal(res, exp)
-
-        # same Series via two different constructions --> same behaviour
-        series = [
-            Series(["a", "b", None, "a", None, None], dtype="category"),
-            Series(
-                Categorical(["a", "b", None, "a", None, None], categories=["a", "b"])
-            ),
-        ]
-
-        for s in series:
-            # None is a NaN value, so we exclude its count here
-            exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))
-            res = s.value_counts(dropna=True)
-            tm.assert_series_equal(res, exp)
-
-            # we don't exclude the count of None and sort by counts
-            exp = Series([3, 2, 1], index=CategoricalIndex([np.nan, "a", "b"]))
-            res = s.value_counts(dropna=False)
-            tm.assert_series_equal(res, exp)
-
-            # When we aren't sorting by counts, and np.nan isn't a
-            # category, it should be last.
-            exp = Series([2, 1, 3], index=CategoricalIndex(["a", "b", np.nan]))
-            res = s.value_counts(dropna=False, sort=False)
-            tm.assert_series_equal(res, exp)
-
-    @pytest.mark.parametrize(
-        "dtype",
-        ["int_", "uint", "float_", "unicode_", "timedelta64[h]", "datetime64[D]"],
-    )
-    def test_drop_duplicates_categorical_non_bool(self, dtype, ordered_fixture):
-        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
-
-        # Test case 1
-        input1 = np.array([1, 2, 3, 3], dtype=np.dtype(dtype))
-        tc1 = Series(Categorical(input1, categories=cat_array, ordered=ordered_fixture))
-        if dtype == "datetime64[D]":
-            # pre-empty flaky xfail, tc1 values are seemingly-random
-            if not (np.array(tc1) == input1).all():
-                pytest.xfail(reason="GH#7996")
-
-        expected = Series([False, False, False, True])
-        tm.assert_series_equal(tc1.duplicated(), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(), tc1[~expected])
-        sc = tc1.copy()
-        sc.drop_duplicates(inplace=True)
-        tm.assert_series_equal(sc, tc1[~expected])
-
-        expected = Series([False, False, True, False])
-        tm.assert_series_equal(tc1.duplicated(keep="last"), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(keep="last"), tc1[~expected])
-        sc = tc1.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
-        tm.assert_series_equal(sc, tc1[~expected])
-
-        expected = Series([False, False, True, True])
-        tm.assert_series_equal(tc1.duplicated(keep=False), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(keep=False), tc1[~expected])
-        sc = tc1.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
-        tm.assert_series_equal(sc, tc1[~expected])
-
-        # Test case 2
-        input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
-        tc2 = Series(Categorical(input2, categories=cat_array, ordered=ordered_fixture))
-        if dtype == "datetime64[D]":
-            # pre-empty flaky xfail, tc2 values are seemingly-random
-            if not (np.array(tc2) == input2).all():
-                pytest.xfail(reason="GH#7996")
-
-        expected = Series([False, False, False, False, True, True, False])
-        tm.assert_series_equal(tc2.duplicated(), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(), tc2[~expected])
-        sc = tc2.copy()
-        sc.drop_duplicates(inplace=True)
-        tm.assert_series_equal(sc, tc2[~expected])
-
-        expected = Series([False, True, True, False, False, False, False])
-        tm.assert_series_equal(tc2.duplicated(keep="last"), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(keep="last"), tc2[~expected])
-        sc = tc2.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
-        tm.assert_series_equal(sc, tc2[~expected])
-
-        expected = Series([False, True, True, False, True, True, False])
-        tm.assert_series_equal(tc2.duplicated(keep=False), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(keep=False), tc2[~expected])
-        sc = tc2.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
-        tm.assert_series_equal(sc, tc2[~expected])
-
-    def test_drop_duplicates_categorical_bool(self, ordered_fixture):
-        tc = Series(
-            Categorical(
-                [True, False, True, False],
-                categories=[True, False],
-                ordered=ordered_fixture,
-            )
-        )
-
-        expected = Series([False, False, True, True])
-        tm.assert_series_equal(tc.duplicated(), expected)
-        tm.assert_series_equal(tc.drop_duplicates(), tc[~expected])
-        sc = tc.copy()
-        sc.drop_duplicates(inplace=True)
-        tm.assert_series_equal(sc, tc[~expected])
-
-        expected = Series([True, True, False, False])
-        tm.assert_series_equal(tc.duplicated(keep="last"), expected)
-        tm.assert_series_equal(tc.drop_duplicates(keep="last"), tc[~expected])
-        sc = tc.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
-        tm.assert_series_equal(sc, tc[~expected])
-
-        expected = Series([True, True, True, True])
-        tm.assert_series_equal(tc.duplicated(keep=False), expected)
-        tm.assert_series_equal(tc.drop_duplicates(keep=False), tc[~expected])
-        sc = tc.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
-        tm.assert_series_equal(sc, tc[~expected])
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index d204d7d2a1d7c..f96d6ddfc357e 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -5,6 +5,8 @@
 import numpy as np
 import pytest
 
+from pandas.util._test_decorators import async_mark
+
 import pandas as pd
 from pandas import (
     Categorical,
@@ -12,146 +14,125 @@
     DatetimeIndex,
     Index,
     Series,
+    Timedelta,
     TimedeltaIndex,
+    Timestamp,
     date_range,
     period_range,
     timedelta_range,
 )
+import pandas._testing as tm
 from pandas.core.arrays import PeriodArray
-from pandas.core.indexes.datetimes import Timestamp
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal, ensure_clean
 
 import pandas.io.formats.printing as printing
 
-from .common import TestData
-
-
-class SharedWithSparse:
-    """
-    A collection of tests Series and SparseSeries can share.
-
-    In generic tests on this class, use ``self._assert_series_equal()``
-    which is implemented in sub-classes.
-    """
 
-    def _assert_series_equal(self, left, right):
-        """Dispatch to series class dependent assertion"""
-        raise NotImplementedError
+class TestSeriesMisc:
+    def test_scalarop_preserve_name(self, datetime_series):
+        result = datetime_series * 2
+        assert result.name == datetime_series.name
 
-    def test_scalarop_preserve_name(self):
-        result = self.ts * 2
-        assert result.name == self.ts.name
+    def test_copy_name(self, datetime_series):
+        result = datetime_series.copy()
+        assert result.name == datetime_series.name
 
-    def test_copy_name(self):
-        result = self.ts.copy()
-        assert result.name == self.ts.name
-
-    def test_copy_index_name_checking(self):
+    def test_copy_index_name_checking(self, datetime_series):
         # don't want to be able to modify the index stored elsewhere after
         # making a copy
 
-        self.ts.index.name = None
-        assert self.ts.index.name is None
-        assert self.ts is self.ts
+        datetime_series.index.name = None
+        assert datetime_series.index.name is None
+        assert datetime_series is datetime_series
 
-        cp = self.ts.copy()
+        cp = datetime_series.copy()
         cp.index.name = "foo"
-        printing.pprint_thing(self.ts.index.name)
-        assert self.ts.index.name is None
+        printing.pprint_thing(datetime_series.index.name)
+        assert datetime_series.index.name is None
 
-    def test_append_preserve_name(self):
-        result = self.ts[:5].append(self.ts[5:])
-        assert result.name == self.ts.name
+    def test_append_preserve_name(self, datetime_series):
+        result = datetime_series[:5].append(datetime_series[5:])
+        assert result.name == datetime_series.name
 
-    def test_binop_maybe_preserve_name(self):
+    def test_binop_maybe_preserve_name(self, datetime_series):
         # names match, preserve
-        result = self.ts * self.ts
-        assert result.name == self.ts.name
-        result = self.ts.mul(self.ts)
-        assert result.name == self.ts.name
+        result = datetime_series * datetime_series
+        assert result.name == datetime_series.name
+        result = datetime_series.mul(datetime_series)
+        assert result.name == datetime_series.name
 
-        result = self.ts * self.ts[:-2]
-        assert result.name == self.ts.name
+        result = datetime_series * datetime_series[:-2]
+        assert result.name == datetime_series.name
 
         # names don't match, don't preserve
-        cp = self.ts.copy()
+        cp = datetime_series.copy()
         cp.name = "something else"
-        result = self.ts + cp
+        result = datetime_series + cp
         assert result.name is None
-        result = self.ts.add(cp)
+        result = datetime_series.add(cp)
         assert result.name is None
 
         ops = ["add", "sub", "mul", "div", "truediv", "floordiv", "mod", "pow"]
         ops = ops + ["r" + op for op in ops]
         for op in ops:
             # names match, preserve
-            s = self.ts.copy()
+            s = datetime_series.copy()
             result = getattr(s, op)(s)
-            assert result.name == self.ts.name
+            assert result.name == datetime_series.name
 
             # names don't match, don't preserve
-            cp = self.ts.copy()
+            cp = datetime_series.copy()
             cp.name = "changed"
             result = getattr(s, op)(cp)
             assert result.name is None
 
-    def test_combine_first_name(self):
-        result = self.ts.combine_first(self.ts[:5])
-        assert result.name == self.ts.name
+    def test_combine_first_name(self, datetime_series):
+        result = datetime_series.combine_first(datetime_series[:5])
+        assert result.name == datetime_series.name
+
+    def test_getitem_preserve_name(self, datetime_series):
+        result = datetime_series[datetime_series > 0]
+        assert result.name == datetime_series.name
 
-    def test_getitem_preserve_name(self):
-        result = self.ts[self.ts > 0]
-        assert result.name == self.ts.name
+        result = datetime_series[[0, 2, 4]]
+        assert result.name == datetime_series.name
 
-        result = self.ts[[0, 2, 4]]
-        assert result.name == self.ts.name
+        result = datetime_series[5:10]
+        assert result.name == datetime_series.name
 
-        result = self.ts[5:10]
-        assert result.name == self.ts.name
+    def test_pickle_datetimes(self, datetime_series):
+        unp_ts = self._pickle_roundtrip(datetime_series)
+        tm.assert_series_equal(unp_ts, datetime_series)
 
-    def test_pickle(self):
-        unp_series = self._pickle_roundtrip(self.series)
-        unp_ts = self._pickle_roundtrip(self.ts)
-        assert_series_equal(unp_series, self.series)
-        assert_series_equal(unp_ts, self.ts)
+    def test_pickle_strings(self, string_series):
+        unp_series = self._pickle_roundtrip(string_series)
+        tm.assert_series_equal(unp_series, string_series)
 
     def _pickle_roundtrip(self, obj):
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             obj.to_pickle(path)
             unpickled = pd.read_pickle(path)
             return unpickled
 
-    def test_argsort_preserve_name(self):
-        result = self.ts.argsort()
-        assert result.name == self.ts.name
-
-    def test_sort_index_name(self):
-        result = self.ts.sort_index(ascending=False)
-        assert result.name == self.ts.name
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-    def test_to_sparse_pass_name(self):
-        result = self.ts.to_sparse()
-        assert result.name == self.ts.name
+    def test_sort_index_name(self, datetime_series):
+        result = datetime_series.sort_index(ascending=False)
+        assert result.name == datetime_series.name
 
     def test_constructor_dict(self):
         d = {"a": 0.0, "b": 1.0, "c": 2.0}
-        result = self.series_klass(d)
-        expected = self.series_klass(d, index=sorted(d.keys()))
-        self._assert_series_equal(result, expected)
+        result = Series(d)
+        expected = Series(d, index=sorted(d.keys()))
+        tm.assert_series_equal(result, expected)
 
-        result = self.series_klass(d, index=["b", "c", "d", "a"])
-        expected = self.series_klass([1, 2, np.nan, 0], index=["b", "c", "d", "a"])
-        self._assert_series_equal(result, expected)
+        result = Series(d, index=["b", "c", "d", "a"])
+        expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"])
+        tm.assert_series_equal(result, expected)
 
-    def test_constructor_subclass_dict(self):
-        data = tm.TestSubDict((x, 10.0 * x) for x in range(10))
-        series = self.series_klass(data)
-        expected = self.series_klass(dict(data.items()))
-        self._assert_series_equal(series, expected)
+    def test_constructor_subclass_dict(self, dict_subclass):
+        data = dict_subclass((x, 10.0 * x) for x in range(10))
+        series = Series(data)
+        expected = Series(dict(data.items()))
+        tm.assert_series_equal(series, expected)
 
     def test_constructor_ordereddict(self):
         # GH3283
@@ -159,44 +140,44 @@ def test_constructor_ordereddict(self):
             ("col{i}".format(i=i), np.random.random()) for i in range(12)
         )
 
-        series = self.series_klass(data)
-        expected = self.series_klass(list(data.values()), list(data.keys()))
-        self._assert_series_equal(series, expected)
+        series = Series(data)
+        expected = Series(list(data.values()), list(data.keys()))
+        tm.assert_series_equal(series, expected)
 
         # Test with subclass
         class A(OrderedDict):
             pass
 
-        series = self.series_klass(A(data))
-        self._assert_series_equal(series, expected)
+        series = Series(A(data))
+        tm.assert_series_equal(series, expected)
 
     def test_constructor_dict_multiindex(self):
         d = {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0}
         _d = sorted(d.items())
-        result = self.series_klass(d)
-        expected = self.series_klass(
+        result = Series(d)
+        expected = Series(
             [x[1] for x in _d], index=pd.MultiIndex.from_tuples([x[0] for x in _d])
         )
-        self._assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         d["z"] = 111.0
         _d.insert(0, ("z", d["z"]))
-        result = self.series_klass(d)
-        expected = self.series_klass(
+        result = Series(d)
+        expected = Series(
             [x[1] for x in _d], index=pd.Index([x[0] for x in _d], tupleize_cols=False)
         )
         result = result.reindex(index=expected.index)
-        self._assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_dict_timedelta_index(self):
         # GH #12169 : Resample category data with timedelta index
         # construct Series from dict as data and TimedeltaIndex as index
         # will result NaN in result Series data
-        expected = self.series_klass(
+        expected = Series(
             data=["A", "B", "C"], index=pd.to_timedelta([0, 10, 20], unit="s")
         )
 
-        result = self.series_klass(
+        result = Series(
             data={
                 pd.to_timedelta(0, unit="s"): "A",
                 pd.to_timedelta(10, unit="s"): "B",
@@ -204,27 +185,13 @@ def test_constructor_dict_timedelta_index(self):
             },
             index=pd.to_timedelta([0, 10, 20], unit="s"),
         )
-        self._assert_series_equal(result, expected)
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    def test_from_array_deprecated(self):
-
-        # multiple FutureWarnings, so can't assert stacklevel
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            self.series_klass.from_array([1, 2, 3])
+        tm.assert_series_equal(result, expected)
 
     def test_sparse_accessor_updates_on_inplace(self):
         s = pd.Series([1, 1, 2, 3], dtype="Sparse[int]")
         s.drop([0, 1], inplace=True)
         assert s.sparse.density == 1.0
 
-
-class TestSeriesMisc(TestData, SharedWithSparse):
-
-    series_klass = Series
-    # SharedWithSparse tests use generic, series_klass-agnostic assertion
-    _assert_series_equal = staticmethod(tm.assert_series_equal)
-
     def test_tab_completion(self):
         # GH 9910
         s = Series(list("abcd"))
@@ -255,9 +222,6 @@ def test_tab_completion(self):
     def test_tab_completion_with_categorical(self):
         # test the tab completion display
         ok_for_cat = [
-            "name",
-            "index",
-            "categorical",
             "categories",
             "codes",
             "ordered",
@@ -273,11 +237,11 @@ def test_tab_completion_with_categorical(self):
 
         def get_dir(s):
             results = [r for r in s.cat.__dir__() if not r.startswith("_")]
-            return list(sorted(set(results)))
+            return sorted(set(results))
 
         s = Series(list("aabbcde")).astype("category")
         results = get_dir(s)
-        tm.assert_almost_equal(results, list(sorted(set(ok_for_cat))))
+        tm.assert_almost_equal(results, sorted(set(ok_for_cat)))
 
     @pytest.mark.parametrize(
         "index",
@@ -301,7 +265,7 @@ def get_dir(s):
     )
     def test_index_tab_completion(self, index):
         # dir contains string-like values of the Index.
-        s = pd.Series(index=index)
+        s = pd.Series(index=index, dtype=object)
         dir_s = dir(s)
         for i, x in enumerate(s.index.unique(level=0)):
             if i < 100:
@@ -310,7 +274,7 @@ def test_index_tab_completion(self, index):
                 assert x not in dir_s
 
     def test_not_hashable(self):
-        s_empty = Series()
+        s_empty = Series(dtype=object)
         s = Series([1])
         msg = "'Series' objects are mutable, thus they cannot be hashed"
         with pytest.raises(TypeError, match=msg):
@@ -318,44 +282,49 @@ def test_not_hashable(self):
         with pytest.raises(TypeError, match=msg):
             hash(s)
 
-    def test_contains(self):
-        tm.assert_contains_all(self.ts.index, self.ts)
+    def test_contains(self, datetime_series):
+        tm.assert_contains_all(datetime_series.index, datetime_series)
 
-    def test_iter(self):
-        for i, val in enumerate(self.series):
-            assert val == self.series[i]
+    def test_iter_datetimes(self, datetime_series):
+        for i, val in enumerate(datetime_series):
+            assert val == datetime_series[i]
 
-        for i, val in enumerate(self.ts):
-            assert val == self.ts[i]
+    def test_iter_strings(self, string_series):
+        for i, val in enumerate(string_series):
+            assert val == string_series[i]
 
-    def test_keys(self):
+    def test_keys(self, datetime_series):
         # HACK: By doing this in two stages, we avoid 2to3 wrapping the call
         # to .keys() in a list()
-        getkeys = self.ts.keys
-        assert getkeys() is self.ts.index
+        getkeys = datetime_series.keys
+        assert getkeys() is datetime_series.index
 
-    def test_values(self):
-        tm.assert_almost_equal(self.ts.values, self.ts, check_dtype=False)
+    def test_values(self, datetime_series):
+        tm.assert_almost_equal(
+            datetime_series.values, datetime_series, check_dtype=False
+        )
 
-    def test_iteritems(self):
-        for idx, val in self.series.iteritems():
-            assert val == self.series[idx]
+    def test_iteritems_datetimes(self, datetime_series):
+        for idx, val in datetime_series.iteritems():
+            assert val == datetime_series[idx]
 
-        for idx, val in self.ts.iteritems():
-            assert val == self.ts[idx]
+    def test_iteritems_strings(self, string_series):
+        for idx, val in string_series.iteritems():
+            assert val == string_series[idx]
 
-        # assert is lazy (genrators don't define reverse, lists do)
-        assert not hasattr(self.series.iteritems(), "reverse")
+        # assert is lazy (generators don't define reverse, lists do)
+        assert not hasattr(string_series.iteritems(), "reverse")
 
-    def test_items(self):
-        for idx, val in self.series.items():
-            assert val == self.series[idx]
+    def test_items_datetimes(self, datetime_series):
+        for idx, val in datetime_series.items():
+            assert val == datetime_series[idx]
 
-        for idx, val in self.ts.items():
-            assert val == self.ts[idx]
+    def test_items_strings(self, string_series):
+        for idx, val in string_series.items():
+            assert val == string_series[idx]
 
-        # assert is lazy (genrators don't define reverse, lists do)
-        assert not hasattr(self.series.items(), "reverse")
+        # assert is lazy (generators don't define reverse, lists do)
+        assert not hasattr(string_series.items(), "reverse")
 
     def test_raise_on_info(self):
         s = Series(np.random.randn(10))
@@ -405,16 +374,16 @@ def test_copy_tzaware(self):
             # default deep is True
             if deep is None or deep is True:
                 # Did not modify original Series
-                assert_series_equal(s2, expected2)
-                assert_series_equal(s, expected)
+                tm.assert_series_equal(s2, expected2)
+                tm.assert_series_equal(s, expected)
             else:
                 # we DID modify the original Series
-                assert_series_equal(s2, expected2)
-                assert_series_equal(s, expected2)
+                tm.assert_series_equal(s2, expected2)
+                tm.assert_series_equal(s, expected2)
 
     def test_axis_alias(self):
         s = Series([1, 2, np.nan])
-        assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
+        tm.assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
         assert s.dropna().sum("rows") == 3
         assert s._get_axis_number("rows") == 0
         assert s._get_axis_name("rows") == "index"
@@ -424,9 +393,53 @@ def test_class_axis(self):
         # no exception and no empty docstring
         assert pydoc.getdoc(Series.index)
 
-    def test_numpy_unique(self):
+    def test_numpy_unique(self, datetime_series):
         # it works!
-        np.unique(self.ts)
+        np.unique(datetime_series)
+
+    def test_item(self):
+        s = Series([1])
+        result = s.item()
+        assert result == 1
+        assert result == s.iloc[0]
+        assert isinstance(result, int)  # i.e. not np.int64
+
+        ser = Series([0.5], index=[3])
+        result = ser.item()
+        assert isinstance(result, float)
+        assert result == 0.5
+
+        ser = Series([1, 2])
+        msg = "can only convert an array of size 1"
+        with pytest.raises(ValueError, match=msg):
+            ser.item()
+
+        dti = pd.date_range("2016-01-01", periods=2)
+        with pytest.raises(ValueError, match=msg):
+            dti.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(dti).item()
+
+        val = dti[:1].item()
+        assert isinstance(val, Timestamp)
+        val = Series(dti)[:1].item()
+        assert isinstance(val, Timestamp)
+
+        tdi = dti - dti
+        with pytest.raises(ValueError, match=msg):
+            tdi.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(tdi).item()
+
+        val = tdi[:1].item()
+        assert isinstance(val, Timedelta)
+        val = Series(tdi)[:1].item()
+        assert isinstance(val, Timedelta)
+
+        # Case where ser[0] would not work
+        ser = Series(dti, index=[5, 6])
+        val = ser[:1].item()
+        assert val == dti[0]
 
     def test_ndarray_compat(self):
 
@@ -444,13 +457,6 @@ def f(x):
         expected = tsdf.max()
         tm.assert_series_equal(result, expected)
 
-        # .item()
-        with tm.assert_produces_warning(FutureWarning):
-            s = Series([1])
-            result = s.item()
-            assert result == 1
-            assert s.item() == s.iloc[0]
-
         # using an ndarray like function
         s = Series(np.random.randn(10))
         result = Series(np.ones_like(s))
@@ -461,30 +467,6 @@ def f(x):
         s = Series(np.random.randn(10))
         tm.assert_almost_equal(s.ravel(order="F"), s.values.ravel(order="F"))
 
-        # compress
-        # GH 6658
-        s = Series([0, 1.0, -1], index=list("abc"))
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = np.compress(s > 0, s)
-        tm.assert_series_equal(result, Series([1.0], index=["b"]))
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = np.compress(s < -1, s)
-        # result empty Index(dtype=object) as the same as original
-        exp = Series([], dtype="float64", index=Index([], dtype="object"))
-        tm.assert_series_equal(result, exp)
-
-        s = Series([0, 1.0, -1], index=[0.1, 0.2, 0.3])
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = np.compress(s > 0, s)
-        tm.assert_series_equal(result, Series([1.0], index=[0.2]))
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = np.compress(s < -1, s)
-        # result empty Float64Index as the same as original
-        exp = Series([], dtype="float64", index=Index([], dtype="float64"))
-        tm.assert_series_equal(result, exp)
-
     def test_str_accessor_updates_on_inplace(self):
         s = pd.Series(list("abc"))
         s.drop([0], inplace=True)
@@ -496,7 +478,7 @@ def test_str_attribute(self):
         s = Series([" jack", "jill ", " jesse ", "frank"])
         for method in methods:
             expected = Series([getattr(str, method)(x) for x in s.values])
-            assert_series_equal(getattr(Series.str, method)(s.str), expected)
+            tm.assert_series_equal(getattr(Series.str, method)(s.str), expected)
 
         # str accessor only valid with string values
         s = Series(range(5))
@@ -504,19 +486,21 @@ def test_str_attribute(self):
             s.str.repeat(2)
 
     def test_empty_method(self):
-        s_empty = pd.Series()
+        s_empty = pd.Series(dtype=object)
         assert s_empty.empty
 
-        for full_series in [pd.Series([1]), pd.Series(index=[1])]:
+        s2 = pd.Series(index=[1], dtype=object)
+        for full_series in [pd.Series([1]), s2]:
             assert not full_series.empty
 
-    def test_tab_complete_warning(self, ip):
+    @async_mark()
+    async def test_tab_complete_warning(self, ip):
         # https://github.com/pandas-dev/pandas/issues/16409
         pytest.importorskip("IPython", minversion="6.0.0")
         from IPython.core.completer import provisionalcompleter
 
         code = "import pandas as pd; s = pd.Series()"
-        ip.run_code(code)
+        await ip.run_code(code)
         with tm.assert_produces_warning(None):
             with provisionalcompleter("ignore"):
                 list(ip.Completer.completions("s.", 1))
@@ -528,11 +512,12 @@ def test_integer_series_size(self):
         s = Series(range(9), dtype="Int64")
         assert s.size == 9
 
-    def test_get_values_deprecation(self):
-        s = Series(range(9))
-        with tm.assert_produces_warning(FutureWarning):
-            res = s.get_values()
-        tm.assert_numpy_array_equal(res, s.values)
+    def test_attrs(self):
+        s = pd.Series([0, 1], name="abc")
+        assert s.attrs == {}
+        s.attrs["version"] = 1
+        result = s + 1
+        assert result.attrs == {"version": 1}
 
 
 class TestCategoricalSeries:
@@ -697,6 +682,7 @@ def test_dt_accessor_api_for_categorical(self):
             ("floor", ("D",), {}),
             ("ceil", ("D",), {}),
             ("asfreq", ("D",), {}),
+            # FIXME: don't leave commented-out
             # ('tz_localize', ("UTC",), {}),
         ]
         _special_func_names = [f[0] for f in special_func_defs]
@@ -729,20 +715,11 @@ def test_dt_accessor_api_for_categorical(self):
                     res = getattr(c.dt, func)(*args, **kwargs)
                     exp = getattr(s.dt, func)(*args, **kwargs)
 
-                if isinstance(res, DataFrame):
-                    tm.assert_frame_equal(res, exp)
-                elif isinstance(res, Series):
-                    tm.assert_series_equal(res, exp)
-                else:
-                    tm.assert_almost_equal(res, exp)
+                tm.assert_equal(res, exp)
 
             for attr in attr_names:
-                try:
-                    res = getattr(c.dt, attr)
-                    exp = getattr(s.dt, attr)
-                except Exception as e:
-                    print(name, attr)
-                    raise e
+                res = getattr(c.dt, attr)
+                exp = getattr(s.dt, attr)
 
             if isinstance(res, DataFrame):
                 tm.assert_frame_equal(res, exp)
diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py
index 65a0822bbc55f..a4c55a80a9f0f 100644
--- a/pandas/tests/series/test_apply.py
+++ b/pandas/tests/series/test_apply.py
@@ -1,4 +1,4 @@
-from collections import Counter, OrderedDict, defaultdict
+from collections import Counter, defaultdict
 from itertools import chain
 
 import numpy as np
@@ -6,9 +6,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, isna
+import pandas._testing as tm
 from pandas.conftest import _get_cython_table_params
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+from pandas.core.base import SpecificationError
 
 
 class TestSeriesApply:
@@ -37,7 +37,7 @@ def test_apply(self, datetime_series):
         assert s.name == rs.name
 
         # index but no data
-        s = Series(index=[1, 2, 3])
+        s = Series(index=[1, 2, 3], dtype=np.float64)
         rs = s.apply(lambda x: x)
         tm.assert_series_equal(s, rs)
 
@@ -47,12 +47,12 @@ def test_apply_same_length_inference_bug(self):
 
         result = s.apply(f)
         expected = s.map(f)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([1, 2, 3])
         result = s.apply(f)
         expected = s.map(f)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_dont_convert_dtype(self):
         s = Series(np.random.randn(10))
@@ -92,7 +92,7 @@ def test_apply_box(self):
         s = pd.Series(vals)
         assert s.dtype == "datetime64[ns]"
         # boxed value must be Timestamp instance
-        res = s.apply(lambda x: "{0}_{1}_{2}".format(x.__class__.__name__, x.day, x.tz))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
         exp = pd.Series(["Timestamp_1_None", "Timestamp_2_None"])
         tm.assert_series_equal(res, exp)
 
@@ -102,7 +102,7 @@ def test_apply_box(self):
         ]
         s = pd.Series(vals)
         assert s.dtype == "datetime64[ns, US/Eastern]"
-        res = s.apply(lambda x: "{0}_{1}_{2}".format(x.__class__.__name__, x.day, x.tz))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
         exp = pd.Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"])
         tm.assert_series_equal(res, exp)
 
@@ -110,7 +110,7 @@ def test_apply_box(self):
         vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")]
         s = pd.Series(vals)
         assert s.dtype == "timedelta64[ns]"
-        res = s.apply(lambda x: "{0}_{1}".format(x.__class__.__name__, x.days))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.days}")
         exp = pd.Series(["Timedelta_1", "Timedelta_2"])
         tm.assert_series_equal(res, exp)
 
@@ -118,7 +118,7 @@ def test_apply_box(self):
         vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
         s = pd.Series(vals)
         assert s.dtype == "Period[M]"
-        res = s.apply(lambda x: "{0}_{1}".format(x.__class__.__name__, x.freqstr))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.freqstr}")
         exp = pd.Series(["Period_M", "Period_M"])
         tm.assert_series_equal(res, exp)
 
@@ -158,9 +158,27 @@ def test_apply_dict_depr(self):
             columns=["A", "B", "C"],
             index=pd.date_range("1/1/2000", periods=10),
         )
-        with tm.assert_produces_warning(FutureWarning):
+        msg = "nested renamer is not supported"
+        with pytest.raises(SpecificationError, match=msg):
             tsdf.A.agg({"foo": ["sum", "mean"]})
 
+    def test_apply_categorical(self):
+        values = pd.Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
+        ser = pd.Series(values, name="XX", index=list("abcdefg"))
+        result = ser.apply(lambda x: x.lower())
+
+        # should be categorical dtype when the number of categories are
+        # the same
+        values = pd.Categorical(list("abbabcd"), categories=list("dcba"), ordered=True)
+        exp = pd.Series(values, name="XX", index=list("abcdefg"))
+        tm.assert_series_equal(result, exp)
+        tm.assert_categorical_equal(result.values, exp.values)
+
+        result = ser.apply(lambda x: "A")
+        exp = pd.Series(["A"] * 7, name="XX", index=list("abcdefg"))
+        tm.assert_series_equal(result, exp)
+        assert result.dtype == np.object
+
     @pytest.mark.parametrize("series", [["1-1", "1-1", np.NaN], ["1-1", "1-2", np.NaN]])
     def test_apply_categorical_with_nan_values(self, series):
         # GH 20714 bug fixed in: GH 24275
@@ -171,6 +189,12 @@ def test_apply_categorical_with_nan_values(self, series):
         expected = expected.astype(object)
         tm.assert_series_equal(result, expected)
 
+    def test_apply_empty_integer_series_with_datetime_index(self):
+        # GH 21245
+        s = pd.Series([], index=pd.date_range(start="2018-01-01", periods=0), dtype=int)
+        result = s.apply(lambda x: x)
+        tm.assert_series_equal(result, s)
+
 
 class TestSeriesAggregate:
     def test_transform(self, string_series):
@@ -184,22 +208,22 @@ def test_transform(self, string_series):
             # ufunc
             result = string_series.transform(np.sqrt)
             expected = f_sqrt.copy()
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
             result = string_series.apply(np.sqrt)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
             # list-like
             result = string_series.transform([np.sqrt])
             expected = f_sqrt.to_frame().copy()
             expected.columns = ["sqrt"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform([np.sqrt])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform(["sqrt"])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # multiple items in list
             # these are in the order as if we are applying both functions per
@@ -207,11 +231,11 @@ def test_transform(self, string_series):
             expected = pd.concat([f_sqrt, f_abs], axis=1)
             expected.columns = ["sqrt", "absolute"]
             result = string_series.apply([np.sqrt, np.abs])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform(["sqrt", "abs"])
             expected.columns = ["sqrt", "abs"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # dict, provide renaming
             expected = pd.concat([f_sqrt, f_abs], axis=1)
@@ -219,7 +243,7 @@ def test_transform(self, string_series):
             expected = expected.unstack().rename("series")
 
             result = string_series.apply({"foo": np.sqrt, "bar": np.abs})
-            assert_series_equal(result.reindex_like(expected), expected)
+            tm.assert_series_equal(result.reindex_like(expected), expected)
 
     def test_transform_and_agg_error(self, string_series):
         # we are trying to transform with an aggregator
@@ -251,31 +275,17 @@ def test_demo(self):
         tm.assert_series_equal(result, expected)
 
         # nested renaming
-        with tm.assert_produces_warning(FutureWarning):
-            result = s.agg({"foo": ["min", "max"]})
-
-        expected = (
-            DataFrame({"foo": [0, 5]}, index=["min", "max"]).unstack().rename("series")
-        )
-        tm.assert_series_equal(result, expected)
+        msg = "nested renamer is not supported"
+        with pytest.raises(SpecificationError, match=msg):
+            s.agg({"foo": ["min", "max"]})
 
     def test_multiple_aggregators_with_dict_api(self):
 
         s = Series(range(6), dtype="int64", name="series")
         # nested renaming
-        with tm.assert_produces_warning(FutureWarning):
-            result = s.agg({"foo": ["min", "max"], "bar": ["sum", "mean"]})
-
-        expected = (
-            DataFrame(
-                {"foo": [5.0, np.nan, 0.0, np.nan], "bar": [np.nan, 2.5, np.nan, 15.0]},
-                columns=["foo", "bar"],
-                index=["max", "mean", "min", "sum"],
-            )
-            .unstack()
-            .rename("series")
-        )
-        tm.assert_series_equal(result.reindex_like(expected), expected)
+        msg = "nested renamer is not supported"
+        with pytest.raises(SpecificationError, match=msg):
+            s.agg({"foo": ["min", "max"], "bar": ["sum", "mean"]})
 
     def test_agg_apply_evaluate_lambdas_the_same(self, string_series):
         # test that we are evaluating row-by-row first
@@ -304,20 +314,18 @@ def test_replicate_describe(self, string_series):
         # this also tests a result set that is all scalars
         expected = string_series.describe()
         result = string_series.apply(
-            OrderedDict(
-                [
-                    ("count", "count"),
-                    ("mean", "mean"),
-                    ("std", "std"),
-                    ("min", "min"),
-                    ("25%", lambda x: x.quantile(0.25)),
-                    ("50%", "median"),
-                    ("75%", lambda x: x.quantile(0.75)),
-                    ("max", "max"),
-                ]
-            )
+            {
+                "count": "count",
+                "mean": "mean",
+                "std": "std",
+                "min": "min",
+                "25%": lambda x: x.quantile(0.25),
+                "50%": "median",
+                "75%": lambda x: x.quantile(0.75),
+                "max": "max",
+            }
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_reduce(self, string_series):
         # reductions with named functions
@@ -327,7 +335,7 @@ def test_reduce(self, string_series):
             ["sum", "mean"],
             name=string_series.name,
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_non_callable_aggregates(self):
         # test agg using non-callable series attributes
@@ -340,14 +348,14 @@ def test_non_callable_aggregates(self):
 
         # test when mixed w/ callable reducers
         result = s.agg(["size", "count", "mean"])
-        expected = Series(OrderedDict([("size", 3.0), ("count", 2.0), ("mean", 1.5)]))
-        assert_series_equal(result[expected.index], expected)
+        expected = Series({"size": 3.0, "count": 2.0, "mean": 1.5})
+        tm.assert_series_equal(result[expected.index], expected)
 
     @pytest.mark.parametrize(
         "series, func, expected",
         chain(
             _get_cython_table_params(
-                Series(),
+                Series(dtype=np.float64),
                 [
                     ("sum", 0),
                     ("max", np.nan),
@@ -402,8 +410,11 @@ def test_agg_cython_table(self, series, func, expected):
         "series, func, expected",
         chain(
             _get_cython_table_params(
-                Series(),
-                [("cumprod", Series([], Index([]))), ("cumsum", Series([], Index([])))],
+                Series(dtype=np.float64),
+                [
+                    ("cumprod", Series([], Index([]), dtype=np.float64)),
+                    ("cumsum", Series([], Index([]), dtype=np.float64)),
+                ],
             ),
             _get_cython_table_params(
                 Series([np.nan, 1, 2, 3]),
@@ -516,7 +527,7 @@ def test_map_compat(self):
         s = Series([True, True, False], index=[1, 2, 3])
         result = s.map({True: "foo", False: "bar"})
         expected = Series(["foo", "foo", "bar"], index=[1, 2, 3])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_int(self):
         left = Series({"a": 1.0, "b": 2.0, "c": 3.0, "d": 4})
@@ -547,7 +558,7 @@ def test_map_na_exclusion(self):
 
         result = s.map(lambda x: x * 2, na_action="ignore")
         exp = s * 2
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_map_dict_with_tuple_keys(self):
         """
@@ -572,7 +583,7 @@ def test_map_counter(self):
         counter["c"] += 1
         result = s.map(counter)
         expected = Series([0, 5, 1], index=[1, 2, 3])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_defaultdict(self):
         s = Series([1, 2, 3], index=["a", "b", "c"])
@@ -580,7 +591,15 @@ def test_map_defaultdict(self):
         default_dict[1] = "stuff"
         result = s.map(default_dict)
         expected = Series(["stuff", "blank", "blank"], index=["a", "b", "c"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_map_dict_na_key(self):
+        # https://github.com/pandas-dev/pandas/issues/17648
+        # Checks that np.nan key is appropriately mapped
+        s = Series([1, 2, np.nan])
+        expected = Series(["a", "b", "c"])
+        result = s.map({1: "a", 2: "b", np.nan: "c"})
+        tm.assert_series_equal(result, expected)
 
     def test_map_dict_subclass_with_missing(self):
         """
@@ -596,7 +615,7 @@ def __missing__(self, key):
         dictionary = DictWithMissing({3: "three"})
         result = s.map(dictionary)
         expected = Series(["missing", "missing", "three"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_dict_subclass_without_missing(self):
         class DictWithoutMissing(dict):
@@ -606,14 +625,38 @@ class DictWithoutMissing(dict):
         dictionary = DictWithoutMissing({3: "three"})
         result = s.map(dictionary)
         expected = Series([np.nan, np.nan, "three"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_map_abc_mapping(self, non_mapping_dict_subclass):
+        # https://github.com/pandas-dev/pandas/issues/29733
+        # Check collections.abc.Mapping support as mapper for Series.map
+        s = Series([1, 2, 3])
+        not_a_dictionary = non_mapping_dict_subclass({3: "three"})
+        result = s.map(not_a_dictionary)
+        expected = Series([np.nan, np.nan, "three"])
+        tm.assert_series_equal(result, expected)
+
+    def test_map_abc_mapping_with_missing(self, non_mapping_dict_subclass):
+        # https://github.com/pandas-dev/pandas/issues/29733
+        # Check collections.abc.Mapping support as mapper for Series.map
+        class NonDictMappingWithMissing(non_mapping_dict_subclass):
+            def __missing__(self, key):
+                return "missing"
+
+        s = Series([1, 2, 3])
+        not_a_dictionary = NonDictMappingWithMissing({3: "three"})
+        result = s.map(not_a_dictionary)
+        # __missing__ is a dict concept, not a Mapping concept,
+        # so it should not change the result!
+        expected = Series([np.nan, np.nan, "three"])
+        tm.assert_series_equal(result, expected)
 
     def test_map_box(self):
         vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
         s = pd.Series(vals)
         assert s.dtype == "datetime64[ns]"
         # boxed value must be Timestamp instance
-        res = s.map(lambda x: "{0}_{1}_{2}".format(x.__class__.__name__, x.day, x.tz))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
         exp = pd.Series(["Timestamp_1_None", "Timestamp_2_None"])
         tm.assert_series_equal(res, exp)
 
@@ -623,7 +666,7 @@ def test_map_box(self):
         ]
         s = pd.Series(vals)
         assert s.dtype == "datetime64[ns, US/Eastern]"
-        res = s.map(lambda x: "{0}_{1}_{2}".format(x.__class__.__name__, x.day, x.tz))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
         exp = pd.Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"])
         tm.assert_series_equal(res, exp)
 
@@ -631,7 +674,7 @@ def test_map_box(self):
         vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")]
         s = pd.Series(vals)
         assert s.dtype == "timedelta64[ns]"
-        res = s.map(lambda x: "{0}_{1}".format(x.__class__.__name__, x.days))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.days}")
         exp = pd.Series(["Timedelta_1", "Timedelta_2"])
         tm.assert_series_equal(res, exp)
 
@@ -639,7 +682,7 @@ def test_map_box(self):
         vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
         s = pd.Series(vals)
         assert s.dtype == "Period[M]"
-        res = s.map(lambda x: "{0}_{1}".format(x.__class__.__name__, x.freqstr))
+        res = s.apply(lambda x: f"{type(x).__name__}_{x.freqstr}")
         exp = pd.Series(["Period_M", "Period_M"])
         tm.assert_series_equal(res, exp)
 
@@ -729,11 +772,18 @@ def test_apply_series_on_date_time_index_aware_series(self, dti, exp):
         # Calling apply on a localized time series should not cause an error
         index = dti.tz_localize("UTC").index
         result = pd.Series(index).apply(lambda x: pd.Series([1, 2]))
-        assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, exp)
 
     def test_apply_scaler_on_date_time_index_aware_series(self):
         # GH 25959
         # Calling apply on a localized time series should not cause an error
         series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
         result = pd.Series(series.index).apply(lambda x: 1)
-        assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))
+        tm.assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))
+
+    def test_map_float_to_string_precision(self):
+        # GH 13228
+        ser = pd.Series(1 / 3)
+        result = ser.map(lambda val: str(val)).to_dict()
+        expected = {0: "0.3333333333333333"}
+        assert result == expected
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 89557445cafb4..f3ffdc373e178 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -3,10 +3,11 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs import IncompatibleFrequency
+
 import pandas as pd
 from pandas import Series
-from pandas.core.indexes.period import IncompatibleFrequency
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _permute(obj):
@@ -46,6 +47,22 @@ def test_flex_method_equivalence(self, opname, ts):
             expected = alt(other, series)
             tm.assert_almost_equal(result, expected)
 
+    def test_flex_method_subclass_metadata_preservation(self, all_arithmetic_operators):
+        # GH 13208
+        class MySeries(Series):
+            _metadata = ["x"]
+
+            @property
+            def _constructor(self):
+                return MySeries
+
+        opname = all_arithmetic_operators
+        op = getattr(Series, opname)
+        m = MySeries([1, 2, 3], name="test")
+        m.x = 42
+        result = op(m, 1)
+        assert result.x == 42
+
 
 class TestSeriesArithmetic:
     # Some of these may end up in tests/arithmetic, but are not yet sorted
@@ -66,6 +83,21 @@ def test_add_series_with_period_index(self):
         with pytest.raises(IncompatibleFrequency, match=msg):
             ts + ts.asfreq("D", how="end")
 
+    @pytest.mark.parametrize(
+        "target_add,input_value,expected_value",
+        [
+            ("!", ["hello", "world"], ["hello!", "world!"]),
+            ("m", ["hello", "world"], ["hellom", "worldm"]),
+        ],
+    )
+    def test_string_addition(self, target_add, input_value, expected_value):
+        # GH28658 - ensure adding 'm' does not raise an error
+        a = Series(input_value)
+
+        result = a + target_add
+        expected = Series(expected_value)
+        tm.assert_series_equal(result, expected)
+
 
 # ------------------------------------------------------------------
 # Comparisons
@@ -156,6 +188,14 @@ def test_ser_cmp_result_names(self, names, op):
         result = op(ser, tdi)
         assert result.name == names[2]
 
+        # interval dtype
+        if op in [operator.eq, operator.ne]:
+            # interval dtype comparisons not yet implemented
+            ii = pd.interval_range(start=0, periods=5, name=names[0])
+            ser = Series(ii).rename(names[1])
+            result = op(ser, ii)
+            assert result.name == names[2]
+
         # categorical
         if op in [operator.eq, operator.ne]:
             # categorical dtype comparisons raise for inequalities
diff --git a/pandas/tests/series/test_combine_concat.py b/pandas/tests/series/test_combine_concat.py
index 5b77ef58b2ef8..4cb471597b67a 100644
--- a/pandas/tests/series/test_combine_concat.py
+++ b/pandas/tests/series/test_combine_concat.py
@@ -1,70 +1,14 @@
 from datetime import datetime
 
 import numpy as np
-from numpy import nan
 import pytest
 
 import pandas as pd
-from pandas import DataFrame, DatetimeIndex, Series, date_range
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
+from pandas import DataFrame, Series, to_datetime
+import pandas._testing as tm
 
 
 class TestSeriesCombine:
-    def test_append(self, datetime_series, string_series, object_series):
-        appendedSeries = string_series.append(object_series)
-        for idx, value in appendedSeries.items():
-            if idx in string_series.index:
-                assert value == string_series[idx]
-            elif idx in object_series.index:
-                assert value == object_series[idx]
-            else:
-                raise AssertionError("orphaned index!")
-
-        msg = "Indexes have overlapping values:"
-        with pytest.raises(ValueError, match=msg):
-            datetime_series.append(datetime_series, verify_integrity=True)
-
-    def test_append_many(self, datetime_series):
-        pieces = [datetime_series[:5], datetime_series[5:10], datetime_series[10:]]
-
-        result = pieces[0].append(pieces[1:])
-        assert_series_equal(result, datetime_series)
-
-    def test_append_duplicates(self):
-        # GH 13677
-        s1 = pd.Series([1, 2, 3])
-        s2 = pd.Series([4, 5, 6])
-        exp = pd.Series([1, 2, 3, 4, 5, 6], index=[0, 1, 2, 0, 1, 2])
-        tm.assert_series_equal(s1.append(s2), exp)
-        tm.assert_series_equal(pd.concat([s1, s2]), exp)
-
-        # the result must have RangeIndex
-        exp = pd.Series([1, 2, 3, 4, 5, 6])
-        tm.assert_series_equal(
-            s1.append(s2, ignore_index=True), exp, check_index_type=True
-        )
-        tm.assert_series_equal(
-            pd.concat([s1, s2], ignore_index=True), exp, check_index_type=True
-        )
-
-        msg = "Indexes have overlapping values:"
-        with pytest.raises(ValueError, match=msg):
-            s1.append(s2, verify_integrity=True)
-        with pytest.raises(ValueError, match=msg):
-            pd.concat([s1, s2], verify_integrity=True)
-
-    def test_append_tuples(self):
-        # GH 28410
-        s = pd.Series([1, 2, 3])
-        list_input = [s, s]
-        tuple_input = (s, s)
-
-        expected = s.append(list_input)
-        result = s.append(tuple_input)
-
-        tm.assert_series_equal(expected, result)
-
     def test_combine_scalar(self):
         # GH 21248
         # Note - combine() with another Series is tested elsewhere because
@@ -109,17 +53,18 @@ def test_combine_first(self):
 
         # corner case
         s = Series([1.0, 2, 3], index=[0, 1, 2])
-        result = s.combine_first(Series([], index=[]))
+        empty = Series([], index=[], dtype=object)
+        result = s.combine_first(empty)
         s.index = s.index.astype("O")
-        assert_series_equal(s, result)
+        tm.assert_series_equal(s, result)
 
     def test_update(self):
-        s = Series([1.5, nan, 3.0, 4.0, nan])
-        s2 = Series([nan, 3.5, nan, 5.0])
+        s = Series([1.5, np.nan, 3.0, 4.0, np.nan])
+        s2 = Series([np.nan, 3.5, np.nan, 5.0])
         s.update(s2)
 
         expected = Series([1.5, 3.5, 3.0, 5.0, np.nan])
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
         # GH 3217
         df = DataFrame([{"a": 1}, {"a": 3, "b": 2}])
@@ -129,7 +74,7 @@ def test_update(self):
         expected = DataFrame(
             [[1, np.nan, "foo"], [3, 2.0, np.nan]], columns=["a", "b", "c"]
         )
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize(
         "other, dtype, expected",
@@ -162,7 +107,7 @@ def test_update_dtypes(self, other, dtype, expected):
         other = Series(other, index=[1, 3])
         s.update(other)
 
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     def test_concat_empty_series_dtypes_roundtrips(self):
 
@@ -227,10 +172,8 @@ def test_combine_first_dt_tz_values(self, tz_naive_fixture):
             tz=tz_naive_fixture,
         )
         exp = pd.Series(exp_vals, name="ser1")
-        assert_series_equal(exp, result)
+        tm.assert_series_equal(exp, result)
 
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
     def test_concat_empty_series_dtypes(self):
 
         # booleans
@@ -287,143 +230,37 @@ def test_concat_empty_series_dtypes(self):
         # sparse
         # TODO: move?
         result = pd.concat(
-            [Series(dtype="float64").to_sparse(), Series(dtype="float64").to_sparse()]
+            [
+                Series(dtype="float64").astype("Sparse"),
+                Series(dtype="float64").astype("Sparse"),
+            ]
         )
         assert result.dtype == "Sparse[float64]"
 
-        # GH 26705 - Assert .ftype is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert result.ftype == "float64:sparse"
-
         result = pd.concat(
-            [Series(dtype="float64").to_sparse(), Series(dtype="float64")]
+            [Series(dtype="float64").astype("Sparse"), Series(dtype="float64")]
         )
         # TODO: release-note: concat sparse dtype
-        expected = pd.core.sparse.api.SparseDtype(np.float64)
+        expected = pd.SparseDtype(np.float64)
         assert result.dtype == expected
 
-        # GH 26705 - Assert .ftype is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert result.ftype == "float64:sparse"
-
         result = pd.concat(
-            [Series(dtype="float64").to_sparse(), Series(dtype="object")]
+            [Series(dtype="float64").astype("Sparse"), Series(dtype="object")]
         )
         # TODO: release-note: concat sparse dtype
-        expected = pd.core.sparse.api.SparseDtype("object")
+        expected = pd.SparseDtype("object")
         assert result.dtype == expected
 
-        # GH 26705 - Assert .ftype is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert result.ftype == "object:sparse"
-
     def test_combine_first_dt64(self):
-        from pandas.core.tools.datetimes import to_datetime
 
         s0 = to_datetime(Series(["2010", np.NaN]))
         s1 = to_datetime(Series([np.NaN, "2011"]))
         rs = s0.combine_first(s1)
         xp = to_datetime(Series(["2010", "2011"]))
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         s0 = to_datetime(Series(["2010", np.NaN]))
         s1 = Series([np.NaN, "2011"])
         rs = s0.combine_first(s1)
         xp = Series([datetime(2010, 1, 1), "2011"])
-        assert_series_equal(rs, xp)
-
-
-class TestTimeseries:
-    def test_append_concat(self):
-        rng = date_range("5/8/2012 1:45", periods=10, freq="5T")
-        ts = Series(np.random.randn(len(rng)), rng)
-        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
-
-        result = ts.append(ts)
-        result_df = df.append(df)
-        ex_index = DatetimeIndex(np.tile(rng.values, 2))
-        tm.assert_index_equal(result.index, ex_index)
-        tm.assert_index_equal(result_df.index, ex_index)
-
-        appended = rng.append(rng)
-        tm.assert_index_equal(appended, ex_index)
-
-        appended = rng.append([rng, rng])
-        ex_index = DatetimeIndex(np.tile(rng.values, 3))
-        tm.assert_index_equal(appended, ex_index)
-
-        # different index names
-        rng1 = rng.copy()
-        rng2 = rng.copy()
-        rng1.name = "foo"
-        rng2.name = "bar"
-        assert rng1.append(rng1).name == "foo"
-        assert rng1.append(rng2).name is None
-
-    def test_append_concat_tz(self):
-        # see gh-2938
-        rng = date_range("5/8/2012 1:45", periods=10, freq="5T", tz="US/Eastern")
-        rng2 = date_range("5/8/2012 2:35", periods=10, freq="5T", tz="US/Eastern")
-        rng3 = date_range("5/8/2012 1:45", periods=20, freq="5T", tz="US/Eastern")
-        ts = Series(np.random.randn(len(rng)), rng)
-        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
-        ts2 = Series(np.random.randn(len(rng2)), rng2)
-        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
-
-        result = ts.append(ts2)
-        result_df = df.append(df2)
-        tm.assert_index_equal(result.index, rng3)
-        tm.assert_index_equal(result_df.index, rng3)
-
-        appended = rng.append(rng2)
-        tm.assert_index_equal(appended, rng3)
-
-    def test_append_concat_tz_explicit_pytz(self):
-        # see gh-2938
-        from pytz import timezone as timezone
-
-        rng = date_range(
-            "5/8/2012 1:45", periods=10, freq="5T", tz=timezone("US/Eastern")
-        )
-        rng2 = date_range(
-            "5/8/2012 2:35", periods=10, freq="5T", tz=timezone("US/Eastern")
-        )
-        rng3 = date_range(
-            "5/8/2012 1:45", periods=20, freq="5T", tz=timezone("US/Eastern")
-        )
-        ts = Series(np.random.randn(len(rng)), rng)
-        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
-        ts2 = Series(np.random.randn(len(rng2)), rng2)
-        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
-
-        result = ts.append(ts2)
-        result_df = df.append(df2)
-        tm.assert_index_equal(result.index, rng3)
-        tm.assert_index_equal(result_df.index, rng3)
-
-        appended = rng.append(rng2)
-        tm.assert_index_equal(appended, rng3)
-
-    def test_append_concat_tz_dateutil(self):
-        # see gh-2938
-        rng = date_range(
-            "5/8/2012 1:45", periods=10, freq="5T", tz="dateutil/US/Eastern"
-        )
-        rng2 = date_range(
-            "5/8/2012 2:35", periods=10, freq="5T", tz="dateutil/US/Eastern"
-        )
-        rng3 = date_range(
-            "5/8/2012 1:45", periods=20, freq="5T", tz="dateutil/US/Eastern"
-        )
-        ts = Series(np.random.randn(len(rng)), rng)
-        df = DataFrame(np.random.randn(len(rng), 4), index=rng)
-        ts2 = Series(np.random.randn(len(rng2)), rng2)
-        df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)
-
-        result = ts.append(ts2)
-        result_df = df.append(df2)
-        tm.assert_index_equal(result.index, rng3)
-        tm.assert_index_equal(result_df.index, rng3)
-
-        appended = rng.append(rng2)
-        tm.assert_index_equal(appended, rng3)
+        tm.assert_series_equal(rs, xp)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 2f09d777e719c..b0d06793dbe13 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2,16 +2,14 @@
 from datetime import datetime, timedelta
 
 import numpy as np
-from numpy import nan
 import numpy.ma as ma
 import pytest
 
 from pandas._libs import lib
 from pandas._libs.tslib import iNaT
-from pandas.compat import PY36
 
 from pandas.core.dtypes.common import is_categorical_dtype, is_datetime64tz_dtype
-from pandas.core.dtypes.dtypes import CategoricalDtype, ordered_sentinel
+from pandas.core.dtypes.dtypes import CategoricalDtype
 
 import pandas as pd
 from pandas import (
@@ -28,9 +26,8 @@
     period_range,
     timedelta_range,
 )
-from pandas.core.arrays import period_array
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray, period_array
 
 
 class TestSeriesConstructors:
@@ -46,17 +43,19 @@ class TestSeriesConstructors:
             (lambda: Series({}), True),
             (lambda: Series(()), False),  # creates a RangeIndex
             (lambda: Series([]), False),  # creates a RangeIndex
-            (lambda: Series((x for x in [])), False),  # creates a RangeIndex
+            (lambda: Series((_ for _ in [])), False),  # creates a RangeIndex
             (lambda: Series(data=None), True),
             (lambda: Series(data={}), True),
             (lambda: Series(data=()), False),  # creates a RangeIndex
             (lambda: Series(data=[]), False),  # creates a RangeIndex
-            (lambda: Series(data=(x for x in [])), False),  # creates a RangeIndex
+            (lambda: Series(data=(_ for _ in [])), False),  # creates a RangeIndex
         ],
     )
     def test_empty_constructor(self, constructor, check_index_type):
-        expected = Series()
-        result = constructor()
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            expected = Series()
+            result = constructor()
+
         assert len(result.index) == 0
         tm.assert_series_equal(result, expected, check_index_type=check_index_type)
 
@@ -68,6 +67,14 @@ def test_invalid_dtype(self):
             with pytest.raises(TypeError, match=msg):
                 Series([], name="time", dtype=dtype)
 
+    def test_invalid_compound_dtype(self):
+        # GH#13296
+        c_dtype = np.dtype([("a", "i8"), ("b", "f4")])
+        cdt_arr = np.array([(1, 0.4), (256, -13)], dtype=c_dtype)
+
+        with pytest.raises(ValueError, match="Use DataFrame instead"):
+            Series(cdt_arr, index=["A", "B"])
+
     def test_scalar_conversion(self):
 
         # Pass in scalar is disabled
@@ -79,8 +86,8 @@ def test_scalar_conversion(self):
         assert int(Series([1.0])) == 1
 
     def test_constructor(self, datetime_series):
-        empty_series = Series()
-
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            empty_series = Series()
         assert datetime_series.index.is_all_dates
 
         # Pass in Series
@@ -97,7 +104,8 @@ def test_constructor(self, datetime_series):
         assert mixed[1] is np.NaN
 
         assert not empty_series.index.is_all_dates
-        assert not Series().index.is_all_dates
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            assert not Series().index.is_all_dates
 
         # exception raised is of type Exception
         with pytest.raises(Exception, match="Data must be 1-dimensional"):
@@ -116,45 +124,47 @@ def test_constructor(self, datetime_series):
 
     @pytest.mark.parametrize("input_class", [list, dict, OrderedDict])
     def test_constructor_empty(self, input_class):
-        empty = Series()
-        empty2 = Series(input_class())
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            empty = Series()
+            empty2 = Series(input_class())
 
         # these are Index() and RangeIndex() which don't compare type equal
         # but are just .equals
-        assert_series_equal(empty, empty2, check_index_type=False)
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
 
         # With explicit dtype:
         empty = Series(dtype="float64")
         empty2 = Series(input_class(), dtype="float64")
-        assert_series_equal(empty, empty2, check_index_type=False)
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
 
         # GH 18515 : with dtype=category:
         empty = Series(dtype="category")
         empty2 = Series(input_class(), dtype="category")
-        assert_series_equal(empty, empty2, check_index_type=False)
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
 
         if input_class is not list:
             # With index:
-            empty = Series(index=range(10))
-            empty2 = Series(input_class(), index=range(10))
-            assert_series_equal(empty, empty2)
+            with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+                empty = Series(index=range(10))
+                empty2 = Series(input_class(), index=range(10))
+            tm.assert_series_equal(empty, empty2)
 
             # With index and dtype float64:
             empty = Series(np.nan, index=range(10))
             empty2 = Series(input_class(), index=range(10), dtype="float64")
-            assert_series_equal(empty, empty2)
+            tm.assert_series_equal(empty, empty2)
 
             # GH 19853 : with empty string, index and dtype str
             empty = Series("", dtype=str, index=range(3))
             empty2 = Series("", index=range(3))
-            assert_series_equal(empty, empty2)
+            tm.assert_series_equal(empty, empty2)
 
     @pytest.mark.parametrize("input_arg", [np.nan, float("nan")])
     def test_constructor_nan(self, input_arg):
         empty = Series(dtype="float64", index=range(10))
         empty2 = Series(input_arg, index=range(10))
 
-        assert_series_equal(empty, empty2, check_index_type=False)
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
 
     @pytest.mark.parametrize(
         "dtype",
@@ -168,7 +178,8 @@ def test_constructor_dtype_only(self, dtype, index):
         assert len(result) == 0
 
     def test_constructor_no_data_index_order(self):
-        result = pd.Series(index=["b", "a", "c"])
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            result = pd.Series(index=["b", "a", "c"])
         assert result.index.tolist() == ["b", "a", "c"]
 
     def test_constructor_no_data_string_type(self):
@@ -199,7 +210,7 @@ def test_constructor_series(self):
         s1 = Series([4, 7, -5, 3], index=index1)
         s2 = Series(s1, index=index2)
 
-        assert_series_equal(s2, s1.sort_index())
+        tm.assert_series_equal(s2, s1.sort_index())
 
     def test_constructor_iterable(self):
         # GH 21987
@@ -210,19 +221,19 @@ def __iter__(self):
 
         expected = Series(list(range(10)), dtype="int64")
         result = Series(Iter(), dtype="int64")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_sequence(self):
         # GH 21987
         expected = Series(list(range(10)), dtype="int64")
         result = Series(range(10), dtype="int64")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_single_str(self):
         # GH 21987
         expected = Series(["abc"])
         result = Series("abc")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_list_like(self):
 
@@ -232,7 +243,7 @@ def test_constructor_list_like(self):
         expected = Series([1, 2, 3], dtype="int64")
         for obj in [[1, 2, 3], (1, 2, 3), np.array([1, 2, 3], dtype="int64")]:
             result = Series(obj, index=[0, 1, 2])
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("dtype", ["bool", "int32", "int64", "float64"])
     def test_constructor_index_dtype(self, dtype):
@@ -257,12 +268,12 @@ def test_constructor_list_str(self, input_vals, string_dtype):
         # when dtype is str, 'str', or 'U'
         result = Series(input_vals, dtype=string_dtype)
         expected = Series(input_vals).astype(string_dtype)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_list_str_na(self, string_dtype):
         result = Series([1.0, 2.0, np.nan], dtype=string_dtype)
         expected = Series(["1.0", "2.0", np.nan], dtype=object)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         assert np.isnan(result[2])
 
     def test_constructor_generator(self):
@@ -270,12 +281,12 @@ def test_constructor_generator(self):
 
         result = Series(gen)
         exp = Series(range(10))
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
         gen = (i for i in range(10))
         result = Series(gen, index=range(10, 20))
         exp.index = range(10, 20)
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_constructor_map(self):
         # GH8909
@@ -283,12 +294,12 @@ def test_constructor_map(self):
 
         result = Series(m)
         exp = Series(range(10))
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
         m = map(lambda x: x, range(10))
         result = Series(m, index=range(10, 20))
         exp.index = range(10, 20)
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_constructor_categorical(self):
         cat = pd.Categorical([0, 1, 2, 0, 1, 2], ["a", "b", "c"], fastpath=True)
@@ -398,22 +409,6 @@ def test_constructor_categorical_string(self):
         result = Series(result, dtype="category")
         tm.assert_series_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "none, warning", [(None, None), (ordered_sentinel, FutureWarning)]
-    )
-    def test_categorical_ordered_none_deprecated(self, none, warning):
-        # GH 26336: only warn if None is not explicitly passed
-        cdt1 = CategoricalDtype(categories=list("cdab"), ordered=True)
-        cdt2 = CategoricalDtype(categories=list("cedafb"), ordered=none)
-
-        cat = Categorical(list("abcdaba"), dtype=cdt1)
-        with tm.assert_produces_warning(warning, check_stacklevel=False):
-            Series(cat, dtype=cdt2)
-
-        s = Series(cat)
-        with tm.assert_produces_warning(warning, check_stacklevel=False):
-            Series(s, dtype=cdt2)
-
     def test_categorical_sideeffects_free(self):
         # Passing a categorical to a Series and then changing values in either
         # the series or the categorical should not change the values in the
@@ -456,59 +451,59 @@ def test_unordered_compare_equal(self):
     def test_constructor_maskedarray(self):
         data = ma.masked_all((3,), dtype=float)
         result = Series(data)
-        expected = Series([nan, nan, nan])
-        assert_series_equal(result, expected)
+        expected = Series([np.nan, np.nan, np.nan])
+        tm.assert_series_equal(result, expected)
 
         data[0] = 0.0
         data[2] = 2.0
         index = ["a", "b", "c"]
         result = Series(data, index=index)
-        expected = Series([0.0, nan, 2.0], index=index)
-        assert_series_equal(result, expected)
+        expected = Series([0.0, np.nan, 2.0], index=index)
+        tm.assert_series_equal(result, expected)
 
         data[1] = 1.0
         result = Series(data, index=index)
         expected = Series([0.0, 1.0, 2.0], index=index)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         data = ma.masked_all((3,), dtype=int)
         result = Series(data)
-        expected = Series([nan, nan, nan], dtype=float)
-        assert_series_equal(result, expected)
+        expected = Series([np.nan, np.nan, np.nan], dtype=float)
+        tm.assert_series_equal(result, expected)
 
         data[0] = 0
         data[2] = 2
         index = ["a", "b", "c"]
         result = Series(data, index=index)
-        expected = Series([0, nan, 2], index=index, dtype=float)
-        assert_series_equal(result, expected)
+        expected = Series([0, np.nan, 2], index=index, dtype=float)
+        tm.assert_series_equal(result, expected)
 
         data[1] = 1
         result = Series(data, index=index)
         expected = Series([0, 1, 2], index=index, dtype=int)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         data = ma.masked_all((3,), dtype=bool)
         result = Series(data)
-        expected = Series([nan, nan, nan], dtype=object)
-        assert_series_equal(result, expected)
+        expected = Series([np.nan, np.nan, np.nan], dtype=object)
+        tm.assert_series_equal(result, expected)
 
         data[0] = True
         data[2] = False
         index = ["a", "b", "c"]
         result = Series(data, index=index)
-        expected = Series([True, nan, False], index=index, dtype=object)
-        assert_series_equal(result, expected)
+        expected = Series([True, np.nan, False], index=index, dtype=object)
+        tm.assert_series_equal(result, expected)
 
         data[1] = True
         result = Series(data, index=index)
         expected = Series([True, True, False], index=index, dtype=bool)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         data = ma.masked_all((3,), dtype="M8[ns]")
         result = Series(data)
         expected = Series([iNaT, iNaT, iNaT], dtype="M8[ns]")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         data[0] = datetime(2001, 1, 1)
         data[2] = datetime(2001, 1, 3)
@@ -519,7 +514,7 @@ def test_constructor_maskedarray(self):
             index=index,
             dtype="M8[ns]",
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         data[1] = datetime(2001, 1, 2)
         result = Series(data, index=index)
@@ -528,13 +523,13 @@ def test_constructor_maskedarray(self):
             index=index,
             dtype="M8[ns]",
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_maskedarray_hardened(self):
         # Check numpy masked arrays with hard masks -- from GH24574
         data = ma.masked_all((3,), dtype=float).harden_mask()
         result = pd.Series(data)
-        expected = pd.Series([nan, nan, nan])
+        expected = pd.Series([np.nan, np.nan, np.nan])
         tm.assert_series_equal(result, expected)
 
     def test_series_ctor_plus_datetimeindex(self):
@@ -634,7 +629,8 @@ def test_constructor_limit_copies(self, index):
         assert s._data.blocks[0].values is not index
 
     def test_constructor_pass_none(self):
-        s = Series(None, index=range(5))
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            s = Series(None, index=range(5))
         assert s.dtype == np.float64
 
         s = Series(None, index=range(5), dtype=object)
@@ -642,9 +638,10 @@ def test_constructor_pass_none(self):
 
         # GH 7431
         # inference on the index
-        s = Series(index=np.array([None]))
-        expected = Series(index=Index([None]))
-        assert_series_equal(s, expected)
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            s = Series(index=np.array([None]))
+            expected = Series(index=Index([None]))
+        tm.assert_series_equal(s, expected)
 
     def test_constructor_pass_nan_nat(self):
         # GH 13467
@@ -684,7 +681,7 @@ def test_constructor_coerce_float_fail(self, any_int_dtype):
     def test_constructor_coerce_float_valid(self, float_dtype):
         s = Series([1, 2, 3.5], dtype=float_dtype)
         expected = Series([1, 2, 3.5]).astype(float_dtype)
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     def test_constructor_dtype_no_cast(self):
         # see gh-1572
@@ -736,14 +733,14 @@ def test_constructor_dtype_datetime64(self):
         s = Series(iNaT, index=range(5))
         assert not isna(s).all()
 
-        s = Series(nan, dtype="M8[ns]", index=range(5))
+        s = Series(np.nan, dtype="M8[ns]", index=range(5))
         assert isna(s).all()
 
         s = Series([datetime(2001, 1, 2, 0, 0), iNaT], dtype="M8[ns]")
         assert isna(s[1])
         assert s.dtype == "M8[ns]"
 
-        s = Series([datetime(2001, 1, 2, 0, 0), nan], dtype="M8[ns]")
+        s = Series([datetime(2001, 1, 2, 0, 0), np.nan], dtype="M8[ns]")
         assert isna(s[1])
         assert s.dtype == "M8[ns]"
 
@@ -784,7 +781,7 @@ def test_constructor_dtype_datetime64(self):
         dts.astype("int64")
 
         # invalid casting
-        msg = r"cannot astype a datetimelike from \[datetime64\[ns\]\] to" r" \[int32\]"
+        msg = r"cannot astype a datetimelike from \[datetime64\[ns\]\] to \[int32\]"
         with pytest.raises(TypeError, match=msg):
             dts.astype("int32")
 
@@ -814,17 +811,17 @@ def test_constructor_dtype_datetime64(self):
         expected = Series(values2, index=dates)
 
         for dtype in ["s", "D", "ms", "us", "ns"]:
-            values1 = dates.view(np.ndarray).astype("M8[{0}]".format(dtype))
+            values1 = dates.view(np.ndarray).astype(f"M8[{dtype}]")
             result = Series(values1, dates)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         # GH 13876
         # coerce to non-ns to object properly
         expected = Series(values2, index=dates, dtype=object)
         for dtype in ["s", "D", "ms", "us", "ns"]:
-            values1 = dates.view(np.ndarray).astype("M8[{0}]".format(dtype))
+            values1 = dates.view(np.ndarray).astype(f"M8[{dtype}]")
             result = Series(values1, index=dates, dtype=object)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         # leave datetime.date alone
         dates2 = np.array([d.date() for d in dates.to_pydatetime()], dtype=object)
@@ -901,14 +898,14 @@ def test_constructor_with_datetime_tz(self):
         )
 
         result = s[Series([True, True, False], index=s.index)]
-        assert_series_equal(result, s[0:2])
+        tm.assert_series_equal(result, s[0:2])
 
         result = s.iloc[0:1]
-        assert_series_equal(result, Series(dr[0:1]))
+        tm.assert_series_equal(result, Series(dr[0:1]))
 
         # concat
         result = pd.concat([s.iloc[0:1], s.iloc[1:]])
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         # short str
         assert "datetime64[ns, US/Eastern]" in str(s)
@@ -947,7 +944,7 @@ def test_constructor_with_datetime_tz(self):
         # with all NaT
         s = Series(pd.NaT, index=[0, 1], dtype="datetime64[ns, US/Eastern]")
         expected = Series(pd.DatetimeIndex(["NaT", "NaT"], tz="US/Eastern"))
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     @pytest.mark.parametrize("arr_dtype", [np.int64, np.float64])
     @pytest.mark.parametrize("dtype", ["M8", "m8"])
@@ -955,7 +952,7 @@ def test_constructor_with_datetime_tz(self):
     def test_construction_to_datetimelike_unit(self, arr_dtype, dtype, unit):
         # tests all units
         # gh-19223
-        dtype = "{}[{}]".format(dtype, unit)
+        dtype = f"{dtype}[{unit}]"
         arr = np.array([1, 2, 3], dtype=arr_dtype)
         s = Series(arr)
         result = s.astype(dtype)
@@ -968,18 +965,45 @@ def test_constructor_with_naive_string_and_datetimetz_dtype(self, arg):
         # GH 17415: With naive string
         result = Series([arg], dtype="datetime64[ns, CET]")
         expected = Series(pd.Timestamp(arg)).dt.tz_localize("CET")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_datetime64_bigendian(self):
+        # GH#30976
+        ms = np.datetime64(1, "ms")
+        arr = np.array([np.datetime64(1, "ms")], dtype=">M8[ms]")
+
+        result = Series(arr)
+        expected = Series([Timestamp(ms)])
+        tm.assert_series_equal(result, expected)
 
-    def test_construction_interval(self):
+    @pytest.mark.parametrize("interval_constructor", [IntervalIndex, IntervalArray])
+    def test_construction_interval(self, interval_constructor):
         # construction from interval & array of intervals
-        index = IntervalIndex.from_breaks(np.arange(3), closed="right")
-        result = Series(index)
-        repr(result)
-        str(result)
-        tm.assert_index_equal(Index(result.values), index)
+        intervals = interval_constructor.from_breaks(np.arange(3), closed="right")
+        result = Series(intervals)
+        assert result.dtype == "interval[int64]"
+        tm.assert_index_equal(Index(result.values), Index(intervals))
 
-        result = Series(index.values)
-        tm.assert_index_equal(Index(result.values), index)
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_infer_interval(self, data_constructor):
+        # GH 23563: consistent closed results in interval dtype
+        data = [pd.Interval(0, 1), pd.Interval(0, 2), None]
+        result = pd.Series(data_constructor(data))
+        expected = pd.Series(IntervalArray(data))
+        assert result.dtype == "interval[float64]"
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_interval_mixed_closed(self, data_constructor):
+        # GH 23563: mixed closed results in object dtype (not interval dtype)
+        data = [pd.Interval(0, 1, closed="both"), pd.Interval(0, 2, closed="neither")]
+        result = Series(data_constructor(data))
+        assert result.dtype == object
+        assert result.tolist() == data
 
     def test_construction_consistency(self):
 
@@ -996,17 +1020,16 @@ def test_construction_consistency(self):
         result = Series(s.values, dtype=s.dtype)
         tm.assert_series_equal(result, s)
 
-    def test_constructor_infer_period(self):
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_infer_period(self, data_constructor):
         data = [pd.Period("2000", "D"), pd.Period("2001", "D"), None]
-        result = pd.Series(data)
+        result = pd.Series(data_constructor(data))
         expected = pd.Series(period_array(data))
         tm.assert_series_equal(result, expected)
         assert result.dtype == "Period[D]"
 
-        data = np.asarray(data, dtype=object)
-        tm.assert_series_equal(result, expected)
-        assert result.dtype == "Period[D]"
-
     def test_constructor_period_incompatible_frequency(self):
         data = [pd.Period("2000", "D"), pd.Period("2001", "A")]
         result = pd.Series(data)
@@ -1021,21 +1044,28 @@ def test_constructor_periodindex(self):
         s = Series(pi)
         assert s.dtype == "Period[D]"
         expected = Series(pi.astype(object))
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     def test_constructor_dict(self):
         d = {"a": 0.0, "b": 1.0, "c": 2.0}
         result = Series(d, index=["b", "c", "d", "a"])
-        expected = Series([1, 2, nan, 0], index=["b", "c", "d", "a"])
-        assert_series_equal(result, expected)
+        expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"])
+        tm.assert_series_equal(result, expected)
 
         pidx = tm.makePeriodIndex(100)
         d = {pidx[0]: 0, pidx[1]: 1}
         result = Series(d, index=pidx)
-        expected = Series(np.nan, pidx)
+        expected = Series(np.nan, pidx, dtype=np.float64)
         expected.iloc[0] = 0
         expected.iloc[1] = 1
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_list_value_explicit_dtype(self):
+        # GH 18625
+        d = {"a": [[2], [3], [4]]}
+        result = Series(d, index=["a"], dtype="object")
+        expected = Series(d, index=["a"])
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_dict_order(self):
         # GH19018
@@ -1043,10 +1073,7 @@ def test_constructor_dict_order(self):
         # order by value
         d = {"b": 1, "a": 0, "c": 2}
         result = Series(d)
-        if PY36:
-            expected = Series([1, 0, 2], index=list("bac"))
-        else:
-            expected = Series([0, 1, 2], index=list("abc"))
+        expected = Series([1, 0, 2], index=list("bac"))
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("value", [2, np.nan, None, float("nan")])
@@ -1055,7 +1082,7 @@ def test_constructor_dict_nan_key(self, value):
         d = {1: "a", value: "b", float("nan"): "c", 4: "d"}
         result = Series(d).sort_values()
         expected = Series(["a", "b", "c", "d"], index=[1, value, np.nan, 4])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # MultiIndex:
         d = {(1, 1): "a", (2, np.nan): "b", (3, value): "c"}
@@ -1063,7 +1090,7 @@ def test_constructor_dict_nan_key(self, value):
         expected = Series(
             ["a", "b", "c"], index=Index([(1, 1), (2, np.nan), (3, value)])
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_dict_datetime64_index(self):
         # GH 9456
@@ -1084,9 +1111,26 @@ def create_data(constructor):
         result_datetime = Series(data_datetime)
         result_Timestamp = Series(data_Timestamp)
 
-        assert_series_equal(result_datetime64, expected)
-        assert_series_equal(result_datetime, expected)
-        assert_series_equal(result_Timestamp, expected)
+        tm.assert_series_equal(result_datetime64, expected)
+        tm.assert_series_equal(result_datetime, expected)
+        tm.assert_series_equal(result_Timestamp, expected)
+
+    def test_contructor_dict_tuple_indexer(self):
+        # GH 12948
+        data = {(1, 1, None): -1.0}
+        result = Series(data)
+        expected = Series(
+            -1.0, index=MultiIndex(levels=[[1], [1], [np.nan]], codes=[[0], [0], [-1]])
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_mapping(self, non_mapping_dict_subclass):
+        # GH 29788
+        ndm = non_mapping_dict_subclass({3: "three"})
+        result = Series(ndm)
+        expected = Series(["three"], index=[3])
+
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_list_of_tuples(self):
         data = [(1, 1), (2, 2), (2, 3)]
@@ -1134,7 +1178,7 @@ def test_fromDict(self):
 
     def test_fromValue(self, datetime_series):
 
-        nans = Series(np.NaN, index=datetime_series.index)
+        nans = Series(np.NaN, index=datetime_series.index, dtype=np.float64)
         assert nans.dtype == np.float_
         assert len(nans) == len(datetime_series)
 
@@ -1205,7 +1249,7 @@ def test_constructor_dtype_timedelta64(self):
         td.astype("int64")
 
         # invalid casting
-        msg = r"cannot astype a timedelta from \[timedelta64\[ns\]\] to" r" \[int32\]"
+        msg = r"cannot astype a timedelta from \[timedelta64\[ns\]\] to \[int32\]"
         with pytest.raises(TypeError, match=msg):
             td.astype("int32")
 
@@ -1235,7 +1279,7 @@ def test_constructor_mixed_tz(self):
             [Timestamp("20130101"), Timestamp("20130101", tz="US/Eastern")],
             dtype="object",
         )
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     def test_NaT_scalar(self):
         series = Series([0, 1000, 2000, iNaT], dtype="M8[ns]")
@@ -1250,7 +1294,7 @@ def test_NaT_cast(self):
         # GH10747
         result = Series([np.nan]).astype("M8[ns]")
         expected = Series([NaT])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_constructor_name_hashable(self):
         for n in [777, 777.0, "name", datetime(2001, 11, 11), (1,), "\u05D0"]:
@@ -1274,7 +1318,7 @@ def test_convert_non_ns(self):
         arr = np.array([1, 2, 3], dtype="timedelta64[s]")
         s = Series(arr)
         expected = Series(pd.timedelta_range("00:00:01", periods=3, freq="s"))
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
         # convert from a numpy array of non-ns datetime64
         # note that creating a numpy datetime64 is in LOCAL time!!!!
@@ -1283,12 +1327,12 @@ def test_convert_non_ns(self):
         s = Series(
             np.array(["2013-01-01", "2013-01-02", "2013-01-03"], dtype="datetime64[D]")
         )
-        assert_series_equal(s, Series(date_range("20130101", periods=3, freq="D")))
+        tm.assert_series_equal(s, Series(date_range("20130101", periods=3, freq="D")))
 
         # s = Series(np.array(['2013-01-01 00:00:01','2013-01-01
         # 00:00:02','2013-01-01 00:00:03'],dtype='datetime64[s]'))
 
-        # assert_series_equal(s,date_range('20130101
+        # tm.assert_series_equal(s,date_range('20130101
         # 00:00:01',period=3,freq='s'))
 
     @pytest.mark.parametrize(
@@ -1303,12 +1347,11 @@ def test_convert_non_ns(self):
     def test_constructor_cant_cast_datetimelike(self, index):
 
         # floats are not ok
-        msg = "Cannot cast {}.*? to ".format(
-            # strip Index to convert PeriodIndex -> Period
-            # We don't care whether the error message says
-            # PeriodIndex or PeriodArray
-            type(index).__name__.rstrip("Index")
-        )
+        # strip Index to convert PeriodIndex -> Period
+        # We don't care whether the error message says
+        # PeriodIndex or PeriodArray
+        msg = f"Cannot cast {type(index).__name__.rstrip('Index')}.*? to "
+
         with pytest.raises(TypeError, match=msg):
             Series(index, dtype=float)
 
diff --git a/pandas/tests/series/test_cumulative.py b/pandas/tests/series/test_cumulative.py
new file mode 100644
index 0000000000000..885b5bf0476f2
--- /dev/null
+++ b/pandas/tests/series/test_cumulative.py
@@ -0,0 +1,170 @@
+"""
+Tests for Series cumulative operations.
+
+See also
+--------
+tests.frame.test_cumulative
+"""
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def _check_accum_op(name, series, check_dtype=True):
+    func = getattr(np, name)
+    tm.assert_numpy_array_equal(
+        func(series).values, func(np.array(series)), check_dtype=check_dtype,
+    )
+
+    # with missing values
+    ts = series.copy()
+    ts[::2] = np.NaN
+
+    result = func(ts)[1::2]
+    expected = func(np.array(ts.dropna()))
+
+    tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)
+
+
+class TestSeriesCumulativeOps:
+    def test_cumsum(self, datetime_series):
+        _check_accum_op("cumsum", datetime_series)
+
+    def test_cumprod(self, datetime_series):
+        _check_accum_op("cumprod", datetime_series)
+
+    def test_cummin(self, datetime_series):
+        tm.assert_numpy_array_equal(
+            datetime_series.cummin().values,
+            np.minimum.accumulate(np.array(datetime_series)),
+        )
+        ts = datetime_series.copy()
+        ts[::2] = np.NaN
+        result = ts.cummin()[1::2]
+        expected = np.minimum.accumulate(ts.dropna())
+
+        tm.assert_series_equal(result, expected)
+
+    def test_cummax(self, datetime_series):
+        tm.assert_numpy_array_equal(
+            datetime_series.cummax().values,
+            np.maximum.accumulate(np.array(datetime_series)),
+        )
+        ts = datetime_series.copy()
+        ts[::2] = np.NaN
+        result = ts.cummax()[1::2]
+        expected = np.maximum.accumulate(ts.dropna())
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "US/Pacific"])
+    def test_cummin_datetime64(self, tz):
+        s = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-3"]
+            ).tz_localize(tz)
+        )
+
+        expected = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-1"]
+            ).tz_localize(tz)
+        )
+        result = s.cummin(skipna=True)
+        tm.assert_series_equal(expected, result)
+
+        expected = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "2000-1-2", "2000-1-1", "2000-1-1", "2000-1-1"]
+            ).tz_localize(tz)
+        )
+        result = s.cummin(skipna=False)
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.parametrize("tz", [None, "US/Pacific"])
+    def test_cummax_datetime64(self, tz):
+        s = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "NaT", "2000-1-1", "NaT", "2000-1-3"]
+            ).tz_localize(tz)
+        )
+
+        expected = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "NaT", "2000-1-2", "NaT", "2000-1-3"]
+            ).tz_localize(tz)
+        )
+        result = s.cummax(skipna=True)
+        tm.assert_series_equal(expected, result)
+
+        expected = pd.Series(
+            pd.to_datetime(
+                ["NaT", "2000-1-2", "2000-1-2", "2000-1-2", "2000-1-2", "2000-1-3"]
+            ).tz_localize(tz)
+        )
+        result = s.cummax(skipna=False)
+        tm.assert_series_equal(expected, result)
+
+    def test_cummin_timedelta64(self):
+        s = pd.Series(pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "3 min"]))
+
+        expected = pd.Series(
+            pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "1 min"])
+        )
+        result = s.cummin(skipna=True)
+        tm.assert_series_equal(expected, result)
+
+        expected = pd.Series(
+            pd.to_timedelta(["NaT", "2 min", "2 min", "1 min", "1 min", "1 min"])
+        )
+        result = s.cummin(skipna=False)
+        tm.assert_series_equal(expected, result)
+
+    def test_cummax_timedelta64(self):
+        s = pd.Series(pd.to_timedelta(["NaT", "2 min", "NaT", "1 min", "NaT", "3 min"]))
+
+        expected = pd.Series(
+            pd.to_timedelta(["NaT", "2 min", "NaT", "2 min", "NaT", "3 min"])
+        )
+        result = s.cummax(skipna=True)
+        tm.assert_series_equal(expected, result)
+
+        expected = pd.Series(
+            pd.to_timedelta(["NaT", "2 min", "2 min", "2 min", "2 min", "3 min"])
+        )
+        result = s.cummax(skipna=False)
+        tm.assert_series_equal(expected, result)
+
+    def test_cummethods_bool(self):
+        # GH#6270
+
+        a = pd.Series([False, False, False, True, True, False, False])
+        b = ~a
+        c = pd.Series([False] * len(b))
+        d = ~c
+        methods = {
+            "cumsum": np.cumsum,
+            "cumprod": np.cumprod,
+            "cummin": np.minimum.accumulate,
+            "cummax": np.maximum.accumulate,
+        }
+        args = product((a, b, c, d), methods)
+        for s, method in args:
+            expected = pd.Series(methods[method](s.values))
+            result = getattr(s, method)()
+            tm.assert_series_equal(result, expected)
+
+        e = pd.Series([False, True, np.nan, False])
+        cse = pd.Series([0, 1, np.nan, 1], dtype=object)
+        cpe = pd.Series([False, 0, np.nan, 0])
+        cmin = pd.Series([False, False, np.nan, False])
+        cmax = pd.Series([False, True, np.nan, True])
+        expecteds = {"cumsum": cse, "cumprod": cpe, "cummin": cmin, "cummax": cmax}
+
+        for method in methods:
+            res = getattr(e, method)()
+            tm.assert_series_equal(res, expecteds[method])
diff --git a/pandas/tests/series/test_datetime_values.py b/pandas/tests/series/test_datetime_values.py
index c9092917cb0c6..b8be4ea137e3d 100644
--- a/pandas/tests/series/test_datetime_values.py
+++ b/pandas/tests/series/test_datetime_values.py
@@ -24,10 +24,9 @@
     period_range,
     timedelta_range,
 )
+import pandas._testing as tm
 from pandas.core.arrays import PeriodArray
 import pandas.core.common as com
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
 
 
 class TestSeriesDatetimeValues:
@@ -209,20 +208,18 @@ def compare(s, name):
         # test limited display api
         def get_dir(s):
             results = [r for r in s.dt.__dir__() if not r.startswith("_")]
-            return list(sorted(set(results)))
+            return sorted(set(results))
 
         s = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
         results = get_dir(s)
-        tm.assert_almost_equal(
-            results, list(sorted(set(ok_for_dt + ok_for_dt_methods)))
-        )
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
 
         s = Series(
             period_range("20130101", periods=5, freq="D", name="xxx").astype(object)
         )
         results = get_dir(s)
         tm.assert_almost_equal(
-            results, list(sorted(set(ok_for_period + ok_for_period_methods)))
+            results, sorted(set(ok_for_period + ok_for_period_methods))
         )
 
         # 11295
@@ -230,9 +227,7 @@ def get_dir(s):
         s = Series(pd.date_range("2015-01-01", "2016-01-01", freq="T"), name="xxx")
         s = s.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
         results = get_dir(s)
-        tm.assert_almost_equal(
-            results, list(sorted(set(ok_for_dt + ok_for_dt_methods)))
-        )
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
         exp_values = pd.date_range(
             "2015-01-01", "2016-01-01", freq="T", tz="UTC"
         ).tz_convert("America/Chicago")
@@ -345,6 +340,39 @@ def test_dt_namespace_accessor_categorical(self):
         expected = Series([2017, 2017, 2018, 2018], name="foo")
         tm.assert_series_equal(result, expected)
 
+    def test_dt_tz_localize_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = pd.Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_localize(tz)
+        expected = datetimes.dt.tz_localize(tz)
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_tz_convert_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = pd.Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns, MET]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_convert(tz)
+        expected = datetimes.dt.tz_convert(tz)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("accessor", ["year", "month", "day"])
+    def test_dt_other_accessors_categorical(self, accessor):
+        # GH 27952
+        datetimes = pd.Series(
+            ["2018-01-01", "2018-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = getattr(categorical.dt, accessor)
+        expected = getattr(datetimes.dt, accessor)
+        tm.assert_series_equal(result, expected)
+
     def test_dt_accessor_no_new_attributes(self):
         # https://github.com/pandas-dev/pandas/issues/10673
         s = Series(date_range("20130101", periods=5, freq="D"))
@@ -399,7 +427,6 @@ def test_dt_accessor_datetime_name_accessors(self, time_locale):
         ]
         for day, name, eng_name in zip(range(4, 11), expected_days, english_days):
             name = name.capitalize()
-            assert s.dt.weekday_name[day] == eng_name
             assert s.dt.day_name(locale=time_locale)[day] == name
         s = s.append(Series([pd.NaT]))
         assert np.isnan(s.dt.day_name(locale=time_locale).iloc[-1])
@@ -472,7 +499,7 @@ def test_strftime(self):
         s.iloc[0] = pd.NaT
         result = s.dt.strftime("%Y/%m/%d")
         expected = Series(
-            ["NaT", "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+            [np.nan, "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
         )
         tm.assert_series_equal(result, expected)
 
@@ -522,6 +549,20 @@ def test_strftime(self):
         )
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "data",
+        [
+            DatetimeIndex(["2019-01-01", pd.NaT]),
+            PeriodIndex(["2019-01-01", pd.NaT], dtype="period[D]"),
+        ],
+    )
+    def test_strftime_nat(self, data):
+        # GH 29578
+        s = Series(data)
+        result = s.dt.strftime("%Y-%m-%d")
+        expected = Series(["2019-01-01", np.nan])
+        tm.assert_series_equal(result, expected)
+
     def test_valid_dt_with_missing_values(self):
 
         from datetime import date, time
@@ -587,11 +628,11 @@ def test_between(self):
 
         result = s[s.between(s[3], s[17])]
         expected = s[3:18].dropna()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s[s.between(s[3], s[17], inclusive=False)]
         expected = s[5:16].dropna()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_date_tz(self):
         # GH11757
@@ -601,8 +642,8 @@ def test_date_tz(self):
         )
         s = Series(rng)
         expected = Series([date(2014, 4, 4), date(2014, 7, 18), date(2015, 11, 22)])
-        assert_series_equal(s.dt.date, expected)
-        assert_series_equal(s.apply(lambda x: x.date()), expected)
+        tm.assert_series_equal(s.dt.date, expected)
+        tm.assert_series_equal(s.apply(lambda x: x.date()), expected)
 
     def test_datetime_understood(self):
         # Ensures it doesn't fail to create the right series
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 9be79bf93ece7..1fc582156a884 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -8,7 +8,7 @@
 
 from pandas._libs.tslibs import iNaT
 
-from pandas.core.dtypes.dtypes import CategoricalDtype, ordered_sentinel
+from pandas.core.dtypes.dtypes import CategoricalDtype
 
 import pandas as pd
 from pandas import (
@@ -20,7 +20,7 @@
     Timestamp,
     date_range,
 )
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestSeriesDtypes:
@@ -44,30 +44,11 @@ def test_astype(self, dtype):
         assert as_typed.dtype == dtype
         assert as_typed.name == s.name
 
-    def test_asobject_deprecated(self):
-        s = Series(np.random.randn(5), name="foo")
-        with tm.assert_produces_warning(FutureWarning):
-            o = s.asobject
-        assert isinstance(o, np.ndarray)
-
     def test_dtype(self, datetime_series):
 
         assert datetime_series.dtype == np.dtype("float64")
         assert datetime_series.dtypes == np.dtype("float64")
 
-        # GH 26705 - Assert .ftype is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert datetime_series.ftype == "float64:dense"
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            assert datetime_series.ftypes == "float64:dense"
-        # GH18243 - Assert .get_ftype_counts is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            tm.assert_series_equal(
-                datetime_series.get_ftype_counts(), Series(1, ["float64:dense"])
-            )
-
     @pytest.mark.parametrize("value", [np.nan, np.inf])
     @pytest.mark.parametrize("dtype", [np.int32, np.int64])
     def test_astype_cast_nan_inf_int(self, dtype, value):
@@ -212,8 +193,8 @@ def test_astype_dict_like(self, dtype_class):
 
         dt3 = dtype_class({"abc": str, "def": str})
         msg = (
-            "Only the Series name can be used for the key in Series dtype"
-            r" mappings\."
+            "Only the Series name can be used for the key in Series dtype "
+            r"mappings\."
         )
         with pytest.raises(KeyError, match=msg):
             s.astype(dt3)
@@ -224,28 +205,20 @@ def test_astype_dict_like(self, dtype_class):
 
         # GH16717
         # if dtypes provided is empty, it should error
-        dt5 = dtype_class({})
+        if dtype_class is Series:
+            dt5 = dtype_class({}, dtype=object)
+        else:
+            dt5 = dtype_class({})
+
         with pytest.raises(KeyError, match=msg):
             s.astype(dt5)
 
-    def test_astype_categories_deprecation_raises(self):
-
-        # deprecated 17636
+    def test_astype_categories_raises(self):
+        # deprecated 17636, removed in GH-27141
         s = Series(["a", "b", "a"])
-        with pytest.raises(ValueError, match="Got an unexpected"):
+        with pytest.raises(TypeError, match="got an unexpected"):
             s.astype("category", categories=["a", "b"], ordered=True)
 
-    @pytest.mark.parametrize(
-        "none, warning", [(None, None), (ordered_sentinel, FutureWarning)]
-    )
-    def test_astype_category_ordered_none_deprecated(self, none, warning):
-        # GH 26336: only warn if None is not explicitly passed
-        cdt1 = CategoricalDtype(categories=list("cdab"), ordered=True)
-        cdt2 = CategoricalDtype(categories=list("cedafb"), ordered=none)
-        s = Series(list("abcdaba"), dtype=cdt1)
-        with tm.assert_produces_warning(warning, check_stacklevel=False):
-            s.astype(cdt2)
-
     def test_astype_from_categorical(self):
         items = ["a", "b", "c", "a"]
         s = Series(items)
@@ -300,7 +273,7 @@ def test_astype_categorical_to_other(self):
         expected = s
         tm.assert_series_equal(s.astype("category"), expected)
         tm.assert_series_equal(s.astype(CategoricalDtype()), expected)
-        msg = r"could not convert string to float|" r"invalid literal for float\(\)"
+        msg = r"could not convert string to float|invalid literal for float\(\)"
         with pytest.raises(ValueError, match=msg):
             s.astype("float64")
 
@@ -378,6 +351,15 @@ def test_astype_categorical_to_categorical(
             result = s.astype("category")
             tm.assert_series_equal(result, expected)
 
+    def test_astype_bool_missing_to_categorical(self):
+        # GH-19182
+        s = Series([True, False, np.nan])
+        assert s.dtypes == np.object_
+
+        result = s.astype(CategoricalDtype(categories=[True, False]))
+        expected = Series(Categorical([True, False, np.nan], categories=[True, False]))
+        tm.assert_series_equal(result, expected)
+
     def test_astype_categoricaldtype(self):
         s = Series(["a", "b", "a"])
         result = s.astype(CategoricalDtype(["a", "b"], ordered=True))
@@ -419,36 +401,17 @@ def test_astype_empty_constructor_equality(self, dtype):
             "m",  # Generic timestamps raise a ValueError. Already tested.
         ):
             init_empty = Series([], dtype=dtype)
-            as_type_empty = Series([]).astype(dtype)
+            with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+                as_type_empty = Series([]).astype(dtype)
             tm.assert_series_equal(init_empty, as_type_empty)
 
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
-    def test_complex(self):
-        # see gh-4819: complex access for ndarray compat
-        a = np.arange(5, dtype=np.float64)
-        b = Series(a + 4j * a)
-
-        tm.assert_numpy_array_equal(a, np.real(b))
-        tm.assert_numpy_array_equal(4 * a, np.imag(b))
-
-        b.real = np.arange(5) + 5
-        tm.assert_numpy_array_equal(a + 5, np.real(b))
-        tm.assert_numpy_array_equal(4 * a, np.imag(b))
-
-    def test_real_imag_deprecated(self):
-        # GH 18262
-        s = pd.Series([1])
-        with tm.assert_produces_warning(FutureWarning):
-            s.imag
-            s.real
-
     def test_arg_for_errors_in_astype(self):
         # see gh-14878
         s = Series([1, 2, 3])
 
         msg = (
-            r"Expected value of kwarg 'errors' to be one of \['raise',"
-            r" 'ignore'\]\. Supplied value is 'False'"
+            r"Expected value of kwarg 'errors' to be one of \['raise', "
+            r"'ignore'\]\. Supplied value is 'False'"
         )
         with pytest.raises(ValueError, match=msg):
             s.astype(np.float64, errors=False)
@@ -502,11 +465,6 @@ def test_infer_objects_series(self):
         assert actual.dtype == "object"
         tm.assert_series_equal(actual, expected)
 
-    def test_is_homogeneous_type(self):
-        assert Series()._is_homogeneous_type
-        assert Series([1, 2])._is_homogeneous_type
-        assert Series(pd.Categorical([1, 2]))._is_homogeneous_type
-
     @pytest.mark.parametrize(
         "data",
         [
@@ -519,3 +477,13 @@ def test_values_compatibility(self, data):
         result = pd.Series(data).values
         expected = np.array(data.astype(object))
         tm.assert_numpy_array_equal(result, expected)
+
+    def test_reindex_astype_order_consistency(self):
+        # GH 17444
+        s = Series([1, 2, 3], index=[2, 0, 1])
+        new_index = [0, 1, 2]
+        temp_dtype = "category"
+        new_dtype = str
+        s1 = s.reindex(new_index).astype(temp_dtype).astype(new_dtype)
+        s2 = s.astype(temp_dtype).reindex(new_index).astype(new_dtype)
+        tm.assert_series_equal(s1, s2)
diff --git a/pandas/tests/series/test_duplicates.py b/pandas/tests/series/test_duplicates.py
index 4a914e4fb0f2c..3513db6177951 100644
--- a/pandas/tests/series/test_duplicates.py
+++ b/pandas/tests/series/test_duplicates.py
@@ -2,10 +2,11 @@
 import pytest
 
 from pandas import Categorical, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.construction import create_series_with_explicit_dtype
 
 
-def test_value_counts_nunique():
+def test_nunique():
     # basics.rst doc example
     series = Series(np.random.randn(500))
     series[20:500] = np.nan
@@ -70,7 +71,7 @@ def test_unique_data_ownership():
 )
 def test_is_unique(data, expected):
     # GH11946 / GH25180
-    s = Series(data)
+    s = create_series_with_explicit_dtype(data, dtype_if_empty=object)
     assert s.is_unique is expected
 
 
@@ -85,76 +86,7 @@ def __ne__(self, other):
 
     with capsys.disabled():
         li = [Foo(i) for i in range(5)]
-        s = Series(li, index=[i for i in range(5)])
+        s = Series(li, index=list(range(5)))
     s.is_unique
     captured = capsys.readouterr()
     assert len(captured.err) == 0
-
-
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, False, False, True, True, False])),
-        ("last", Series([False, True, True, False, False, False, False])),
-        (False, Series([False, True, True, False, True, True, False])),
-    ],
-)
-def test_drop_duplicates(any_numpy_dtype, keep, expected):
-    tc = Series([1, 0, 3, 5, 3, 0, 4], dtype=np.dtype(any_numpy_dtype))
-
-    if tc.dtype == "bool":
-        pytest.skip("tested separately in test_drop_duplicates_bool")
-
-    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
-    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
-    sc = tc.copy()
-    sc.drop_duplicates(keep=keep, inplace=True)
-    tm.assert_series_equal(sc, tc[~expected])
-
-
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, True, True])),
-        ("last", Series([True, True, False, False])),
-        (False, Series([True, True, True, True])),
-    ],
-)
-def test_drop_duplicates_bool(keep, expected):
-    tc = Series([True, False, True, False])
-
-    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
-    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
-    sc = tc.copy()
-    sc.drop_duplicates(keep=keep, inplace=True)
-    tm.assert_series_equal(sc, tc[~expected])
-
-
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, True, False, True], name="name")),
-        ("last", Series([True, True, False, False, False], name="name")),
-        (False, Series([True, True, True, False, True], name="name")),
-    ],
-)
-def test_duplicated_keep(keep, expected):
-    s = Series(["a", "b", "b", "c", "a"], name="name")
-
-    result = s.duplicated(keep=keep)
-    tm.assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize(
-    "keep, expected",
-    [
-        ("first", Series([False, False, True, False, True])),
-        ("last", Series([True, True, False, False, False])),
-        (False, Series([True, True, True, False, True])),
-    ],
-)
-def test_duplicated_nan_none(keep, expected):
-    s = Series([np.nan, 3, 3, None, np.nan], dtype=object)
-
-    result = s.duplicated(keep=keep)
-    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_internals.py b/pandas/tests/series/test_internals.py
index d35198ca70f37..4c817ed2e2d59 100644
--- a/pandas/tests/series/test_internals.py
+++ b/pandas/tests/series/test_internals.py
@@ -5,9 +5,8 @@
 
 import pandas as pd
 from pandas import NaT, Series, Timestamp
+import pandas._testing as tm
 from pandas.core.internals.blocks import IntBlock
-import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal
 
 
 class TestSeriesInternals:
@@ -19,15 +18,15 @@ def test_convert(self):
         s = Series(["a", "b", "c"])
         results = s._convert(datetime=True, coerce=True)
         expected = Series([NaT] * 3)
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         results = s._convert(numeric=True, coerce=True)
         expected = Series([np.nan] * 3)
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         expected = Series([NaT] * 3, dtype=np.dtype("m8[ns]"))
         results = s._convert(timedelta=True, coerce=True)
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         dt = datetime(2001, 1, 1, 0, 0)
         td = dt - datetime(2000, 1, 1, 0, 0)
@@ -36,79 +35,79 @@ def test_convert(self):
         s = Series(["a", "3.1415", dt, td])
         results = s._convert(datetime=True, coerce=True)
         expected = Series([NaT, NaT, dt, NaT])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         results = s._convert(numeric=True, coerce=True)
         expected = Series([np.nan, 3.1415, np.nan, np.nan])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         results = s._convert(timedelta=True, coerce=True)
         expected = Series([NaT, NaT, NaT, td], dtype=np.dtype("m8[ns]"))
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
 
         # Test standard conversion returns original
         results = s._convert(datetime=True)
-        assert_series_equal(results, s)
+        tm.assert_series_equal(results, s)
         results = s._convert(numeric=True)
         expected = Series([np.nan, 3.1415, np.nan, np.nan])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
         results = s._convert(timedelta=True)
-        assert_series_equal(results, s)
+        tm.assert_series_equal(results, s)
 
         # test pass-through and non-conversion when other types selected
         s = Series(["1.0", "2.0", "3.0"])
         results = s._convert(datetime=True, numeric=True, timedelta=True)
         expected = Series([1.0, 2.0, 3.0])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
         results = s._convert(True, False, True)
-        assert_series_equal(results, s)
+        tm.assert_series_equal(results, s)
 
         s = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)], dtype="O")
         results = s._convert(datetime=True, numeric=True, timedelta=True)
         expected = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
         results = s._convert(datetime=False, numeric=True, timedelta=True)
-        assert_series_equal(results, s)
+        tm.assert_series_equal(results, s)
 
         td = datetime(2001, 1, 1, 0, 0) - datetime(2000, 1, 1, 0, 0)
         s = Series([td, td], dtype="O")
         results = s._convert(datetime=True, numeric=True, timedelta=True)
         expected = Series([td, td])
-        assert_series_equal(results, expected)
+        tm.assert_series_equal(results, expected)
         results = s._convert(True, True, False)
-        assert_series_equal(results, s)
+        tm.assert_series_equal(results, s)
 
         s = Series([1.0, 2, 3], index=["a", "b", "c"])
         result = s._convert(numeric=True)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         # force numeric conversion
         r = s.copy().astype("O")
         r["a"] = "1"
         result = r._convert(numeric=True)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         r = s.copy().astype("O")
         r["a"] = "1."
         result = r._convert(numeric=True)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         r = s.copy().astype("O")
         r["a"] = "garbled"
         result = r._convert(numeric=True)
         expected = s.copy()
         expected["a"] = np.nan
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 4119, not converting a mixed type (e.g.floats and object)
         s = Series([1, "na", 3, 4])
         result = s._convert(datetime=True, numeric=True)
         expected = Series([1, np.nan, 3, 4])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([1, "", 3, 4])
         result = s._convert(datetime=True, numeric=True)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # dates
         s = Series(
@@ -137,10 +136,10 @@ def test_convert(self):
             [Timestamp("20010101"), Timestamp("20010102"), Timestamp("20010103")],
             dtype="M8[ns]",
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s._convert(datetime=True, coerce=True)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series(
             [
@@ -156,19 +155,19 @@ def test_convert(self):
             dtype="M8[ns]",
         )
         result = s2._convert(datetime=True, numeric=False, timedelta=False, coerce=True)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result = s2._convert(datetime=True, coerce=True)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series(["foo", "bar", 1, 1.0], dtype="O")
         result = s._convert(datetime=True, coerce=True)
         expected = Series([NaT] * 2 + [Timestamp(1)] * 2)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # preserver if non-object
         s = Series([1], dtype="float32")
         result = s._convert(datetime=True, coerce=True)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         # r = s.copy()
         # r[0] = np.nan
@@ -180,10 +179,10 @@ def test_convert(self):
         for x in "abcdefghijklmnopqrstuvwxyz":
             s = Series([x])
             result = s._convert(datetime=True, coerce=True)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
             s = Series([x.upper()])
             result = s._convert(datetime=True, coerce=True)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
     def test_convert_no_arg_error(self):
         s = Series(["1.0", "2"])
@@ -243,10 +242,3 @@ def test_hasnans_unchached_for_series():
     ser.iloc[-1] = np.nan
     assert ser.hasnans is True
     assert Series.hasnans.__doc__ == pd.Index.hasnans.__doc__
-
-
-def test_put_deprecated():
-    # GH 18262
-    s = pd.Series([1])
-    with tm.assert_produces_warning(FutureWarning):
-        s.put(0, 0)
diff --git a/pandas/tests/series/test_io.py b/pandas/tests/series/test_io.py
index 0ddf1dfcabb59..510c11a51ca38 100644
--- a/pandas/tests/series/test_io.py
+++ b/pandas/tests/series/test_io.py
@@ -1,4 +1,3 @@
-import collections
 from datetime import datetime
 from io import StringIO
 
@@ -7,15 +6,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-    ensure_clean,
-)
+import pandas._testing as tm
 
-from pandas.io.common import _get_handle
+from pandas.io.common import get_handle
 
 
 class TestSeriesToCSV:
@@ -31,30 +24,12 @@ def read_csv(self, path, **kwargs):
 
         return out
 
-    @pytest.mark.parametrize("arg", ["path", "header", "both"])
-    def test_to_csv_deprecation(self, arg, datetime_series):
-        # see gh-19715
-        with ensure_clean() as path:
-            if arg == "path":
-                kwargs = dict(path=path, header=False)
-            elif arg == "header":
-                kwargs = dict(path_or_buf=path)
-            else:  # Both discrepancies match.
-                kwargs = dict(path=path)
-
-            with tm.assert_produces_warning(FutureWarning):
-                datetime_series.to_csv(**kwargs)
-
-                # Make sure roundtrip still works.
-                ts = self.read_csv(path)
-                assert_series_equal(datetime_series, ts, check_names=False)
-
     def test_from_csv(self, datetime_series, string_series):
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             datetime_series.to_csv(path, header=False)
             ts = self.read_csv(path)
-            assert_series_equal(datetime_series, ts, check_names=False)
+            tm.assert_series_equal(datetime_series, ts, check_names=False)
 
             assert ts.name is None
             assert ts.index.name is None
@@ -66,7 +41,7 @@ def test_from_csv(self, datetime_series, string_series):
 
             string_series.to_csv(path, header=False)
             series = self.read_csv(path)
-            assert_series_equal(string_series, series, check_names=False)
+            tm.assert_series_equal(string_series, series, check_names=False)
 
             assert series.name is None
             assert series.index.name is None
@@ -82,16 +57,16 @@ def test_from_csv(self, datetime_series, string_series):
             check_series = Series(
                 {datetime(1998, 1, 1): 1.0, datetime(1999, 1, 1): 2.0}
             )
-            assert_series_equal(check_series, series)
+            tm.assert_series_equal(check_series, series)
 
             series = self.read_csv(path, sep="|", parse_dates=False)
             check_series = Series({"1998-01-01": 1.0, "1999-01-01": 2.0})
-            assert_series_equal(check_series, series)
+            tm.assert_series_equal(check_series, series)
 
     def test_to_csv(self, datetime_series):
         import io
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             datetime_series.to_csv(path, header=False)
 
             with io.open(path, newline=None) as f:
@@ -100,7 +75,7 @@ def test_to_csv(self, datetime_series):
 
             datetime_series.to_csv(path, index=False, header=False)
             arr = np.loadtxt(path)
-            assert_almost_equal(arr, datetime_series.values)
+            tm.assert_almost_equal(arr, datetime_series.values)
 
     def test_to_csv_unicode_index(self):
         buf = StringIO()
@@ -110,17 +85,17 @@ def test_to_csv_unicode_index(self):
         buf.seek(0)
 
         s2 = self.read_csv(buf, index_col=0, encoding="UTF-8")
-        assert_series_equal(s, s2)
+        tm.assert_series_equal(s, s2)
 
     def test_to_csv_float_format(self):
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
             ser = Series([0.123456, 0.234567, 0.567567])
             ser.to_csv(filename, float_format="%.2f", header=False)
 
             rs = self.read_csv(filename)
             xp = Series([0.12, 0.23, 0.57])
-            assert_series_equal(rs, xp)
+            tm.assert_series_equal(rs, xp)
 
     def test_to_csv_list_entries(self):
         s = Series(["jack and jill", "jesse and frank"])
@@ -153,7 +128,7 @@ def test_to_csv_path_is_none(self):
     )
     def test_to_csv_compression(self, s, encoding, compression):
 
-        with ensure_clean() as filename:
+        with tm.ensure_clean() as filename:
 
             s.to_csv(filename, compression=compression, encoding=encoding, header=True)
             # test the round trip - to_csv -> read_csv
@@ -164,10 +139,10 @@ def test_to_csv_compression(self, s, encoding, compression):
                 index_col=0,
                 squeeze=True,
             )
-            assert_series_equal(s, result)
+            tm.assert_series_equal(s, result)
 
             # test the round trip using file handle - to_csv -> read_csv
-            f, _handles = _get_handle(
+            f, _handles = get_handle(
                 filename, "w", compression=compression, encoding=encoding
             )
             with f:
@@ -179,7 +154,7 @@ def test_to_csv_compression(self, s, encoding, compression):
                 index_col=0,
                 squeeze=True,
             )
-            assert_series_equal(s, result)
+            tm.assert_series_equal(s, result)
 
             # explicitly ensure file was compressed
             with tm.decompress_file(filename, compression) as fh:
@@ -187,7 +162,7 @@ def test_to_csv_compression(self, s, encoding, compression):
                 assert s.name in text
 
             with tm.decompress_file(filename, compression) as fh:
-                assert_series_equal(
+                tm.assert_series_equal(
                     s, pd.read_csv(fh, index_col=0, squeeze=True, encoding=encoding)
                 )
 
@@ -195,7 +170,7 @@ def test_to_csv_interval_index(self):
         # GH 28210
         s = Series(["foo", "bar", "baz"], index=pd.interval_range(0, 3))
 
-        with ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
+        with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
             s.to_csv(path, header=False)
             result = self.read_csv(path, index_col=0, squeeze=True)
 
@@ -203,7 +178,7 @@ def test_to_csv_interval_index(self):
             expected = s.copy()
             expected.index = expected.index.astype(str)
 
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
 
 class TestSeriesIO:
@@ -211,20 +186,20 @@ def test_to_frame(self, datetime_series):
         datetime_series.name = None
         rs = datetime_series.to_frame()
         xp = pd.DataFrame(datetime_series.values, index=datetime_series.index)
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
         datetime_series.name = "testname"
         rs = datetime_series.to_frame()
         xp = pd.DataFrame(
             dict(testname=datetime_series.values), index=datetime_series.index
         )
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
         rs = datetime_series.to_frame(name="testdifferent")
         xp = pd.DataFrame(
             dict(testdifferent=datetime_series.values), index=datetime_series.index
         )
-        assert_frame_equal(rs, xp)
+        tm.assert_frame_equal(rs, xp)
 
     def test_timeseries_periodindex(self):
         # GH2891
@@ -240,18 +215,9 @@ def test_pickle_preserve_name(self):
             unpickled = self._pickle_roundtrip_name(tm.makeTimeSeries(name=n))
             assert unpickled.name == n
 
-    def test_pickle_categorical_ordered_from_sentinel(self):
-        # GH 27295: can remove test when _ordered_from_sentinel is removed (GH 26403)
-        s = Series(["a", "b", "c", "a"], dtype="category")
-        result = tm.round_trip_pickle(s)
-        result = result.astype("category")
-
-        tm.assert_series_equal(result, s)
-        assert result.dtype._ordered_from_sentinel is False
-
     def _pickle_roundtrip_name(self, obj):
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             obj.to_pickle(path)
             unpickled = pd.read_pickle(path)
             return unpickled
@@ -271,16 +237,4 @@ class SubclassedFrame(DataFrame):
         result = s.to_frame()
         assert isinstance(result, SubclassedFrame)
         expected = SubclassedFrame({"X": [1, 2, 3]})
-        assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "mapping", (dict, collections.defaultdict(list), collections.OrderedDict)
-    )
-    def test_to_dict(self, mapping, datetime_series):
-        # GH16122
-        tm.assert_series_equal(
-            Series(datetime_series.to_dict(mapping), name="ts"), datetime_series
-        )
-        from_method = Series(datetime_series.to_dict(collections.Counter))
-        from_constructor = Series(collections.Counter(datetime_series.items()))
-        tm.assert_series_equal(from_method, from_constructor)
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py
index ddd2c566f4cda..6b7d9e00a5228 100644
--- a/pandas/tests/series/test_missing.py
+++ b/pandas/tests/series/test_missing.py
@@ -1,12 +1,10 @@
 from datetime import datetime, timedelta
 
 import numpy as np
-from numpy import nan
 import pytest
 import pytz
 
 from pandas._libs.tslib import iNaT
-from pandas.errors import PerformanceWarning
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -18,31 +16,12 @@
     MultiIndex,
     NaT,
     Series,
+    Timedelta,
     Timestamp,
     date_range,
     isna,
 )
-from pandas.core.series import remove_na
-import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
-
-
-def _skip_if_no_pchip():
-    try:
-        from scipy.interpolate import pchip_interpolate  # noqa
-    except ImportError:
-        import pytest
-
-        pytest.skip("scipy.interpolate.pchip missing")
-
-
-def _skip_if_no_akima():
-    try:
-        from scipy.interpolate import Akima1DInterpolator  # noqa
-    except ImportError:
-        import pytest
-
-        pytest.skip("scipy.interpolate.Akima1DInterpolator missing")
+import pandas._testing as tm
 
 
 def _simple_ts(start, end, freq="D"):
@@ -51,11 +30,6 @@ def _simple_ts(start, end, freq="D"):
 
 
 class TestSeriesMissingData:
-    def test_remove_na_deprecation(self):
-        # see gh-16971
-        with tm.assert_produces_warning(FutureWarning):
-            remove_na(Series([]))
-
     def test_timedelta_fillna(self):
         # GH 3371
         s = Series(
@@ -69,8 +43,7 @@ def test_timedelta_fillna(self):
         td = s.diff()
 
         # reg fillna
-        with tm.assert_produces_warning(FutureWarning):
-            result = td.fillna(0)
+        result = td.fillna(Timedelta(seconds=0))
         expected = Series(
             [
                 timedelta(0),
@@ -79,11 +52,13 @@ def test_timedelta_fillna(self):
                 timedelta(days=1, seconds=9 * 3600 + 60 + 1),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # interpreted as seconds, deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            result = td.fillna(1)
+        with pytest.raises(TypeError, match="Passing integers to fillna"):
+            td.fillna(1)
+
+        result = td.fillna(Timedelta(seconds=1))
         expected = Series(
             [
                 timedelta(seconds=1),
@@ -92,7 +67,7 @@ def test_timedelta_fillna(self):
                 timedelta(days=1, seconds=9 * 3600 + 60 + 1),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td.fillna(timedelta(days=1, seconds=1))
         expected = Series(
@@ -103,7 +78,7 @@ def test_timedelta_fillna(self):
                 timedelta(days=1, seconds=9 * 3600 + 60 + 1),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td.fillna(np.timedelta64(int(1e9)))
         expected = Series(
@@ -114,7 +89,7 @@ def test_timedelta_fillna(self):
                 timedelta(days=1, seconds=9 * 3600 + 60 + 1),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = td.fillna(NaT)
         expected = Series(
@@ -126,23 +101,21 @@ def test_timedelta_fillna(self):
             ],
             dtype="m8[ns]",
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # ffill
         td[2] = np.nan
         result = td.ffill()
-        with tm.assert_produces_warning(FutureWarning):
-            expected = td.fillna(0)
+        expected = td.fillna(Timedelta(seconds=0))
         expected[0] = np.nan
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # bfill
         td[2] = np.nan
         result = td.bfill()
-        with tm.assert_produces_warning(FutureWarning):
-            expected = td.fillna(0)
+        expected = td.fillna(Timedelta(seconds=0))
         expected[2] = timedelta(days=1, seconds=9 * 3600 + 60 + 1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_datetime64_fillna(self):
 
@@ -166,11 +139,11 @@ def test_datetime64_fillna(self):
                 Timestamp("20130103 9:01:01"),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.fillna(NaT)
         expected = s
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # ffill
         result = s.ffill()
@@ -182,7 +155,7 @@ def test_datetime64_fillna(self):
                 Timestamp("20130103 9:01:01"),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # bfill
         result = s.bfill()
@@ -194,7 +167,7 @@ def test_datetime64_fillna(self):
                 Timestamp("20130103 9:01:01"),
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 6587
         # make sure that we are treating as integer when filling
@@ -209,7 +182,7 @@ def test_datetime64_fillna(self):
             dtype="M8[ns]",
         )
         result = s.fillna(method="backfill")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_datetime64_tz_fillna(self):
 
@@ -302,7 +275,7 @@ def test_datetime64_tz_fillna(self):
                 ["2011-01-01 10:00", pd.NaT, "2011-01-03 10:00", pd.NaT], tz=tz
             )
             s = pd.Series(idx)
-            assert s.dtype == "datetime64[ns, {0}]".format(tz)
+            assert s.dtype == f"datetime64[ns, {tz}]"
             tm.assert_series_equal(pd.isna(s), null_loc)
 
             result = s.fillna(pd.Timestamp("2011-01-02 10:00"))
@@ -426,7 +399,7 @@ def test_datetime64_tz_fillna(self):
                 pd.Timestamp("2012-11-11 00:00:00+01:00"),
             ]
         )
-        assert_series_equal(df.fillna(method="pad"), exp)
+        tm.assert_series_equal(df.fillna(method="pad"), exp)
 
         df = pd.Series([pd.NaT, pd.Timestamp("2012-11-11 00:00:00+01:00")])
         exp = pd.Series(
@@ -435,7 +408,7 @@ def test_datetime64_tz_fillna(self):
                 pd.Timestamp("2012-11-11 00:00:00+01:00"),
             ]
         )
-        assert_series_equal(df.fillna(method="bfill"), exp)
+        tm.assert_series_equal(df.fillna(method="bfill"), exp)
 
     def test_datetime64_non_nano_fillna(self):
         # GH#27419
@@ -459,28 +432,35 @@ def test_fillna_consistency(self):
             [Timestamp("20130101"), Timestamp("2013-01-01", tz="US/Eastern")],
             dtype="object",
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # where (we ignore the errors=)
         result = s.where(
             [True, False], Timestamp("20130101", tz="US/Eastern"), errors="ignore"
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.where(
             [True, False], Timestamp("20130101", tz="US/Eastern"), errors="ignore"
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # with a non-datetime
         result = s.fillna("foo")
         expected = Series([Timestamp("20130101"), "foo"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # assignment
         s2 = s.copy()
         s2[1] = "foo"
-        assert_series_equal(s2, expected)
+        tm.assert_series_equal(s2, expected)
+
+    def test_where_sparse(self):
+        # GH#17198 make sure we dont get an AttributeError for sp_index
+        ser = pd.Series(pd.arrays.SparseArray([1, 2]))
+        result = ser.where(ser >= 2, 0)
+        expected = pd.Series(pd.arrays.SparseArray([0, 2]))
+        tm.assert_series_equal(result, expected)
 
     def test_datetime64tz_fillna_round_issue(self):
         # GH 14872
@@ -499,7 +479,7 @@ def test_datetime64tz_fillna_round_issue(self):
             ]
         )
 
-        assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled, expected)
 
     def test_fillna_downcast(self):
         # GH 15277
@@ -507,26 +487,26 @@ def test_fillna_downcast(self):
         s = pd.Series([1.0, np.nan])
         result = s.fillna(0, downcast="infer")
         expected = pd.Series([1, 0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # infer int64 from float64 when fillna value is a dict
         s = pd.Series([1.0, np.nan])
         result = s.fillna({1: 0}, downcast="infer")
         expected = pd.Series([1, 0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_fillna_int(self):
         s = Series(np.random.randint(-100, 100, 50))
         s.fillna(method="ffill", inplace=True)
-        assert_series_equal(s.fillna(method="ffill", inplace=False), s)
+        tm.assert_series_equal(s.fillna(method="ffill", inplace=False), s)
 
     def test_fillna_raise(self):
         s = Series(np.random.randint(-100, 100, 50))
-        msg = '"value" parameter must be a scalar or dict, but you passed a' ' "list"'
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
         with pytest.raises(TypeError, match=msg):
             s.fillna([1, 2])
 
-        msg = '"value" parameter must be a scalar or dict, but you passed a' ' "tuple"'
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
         with pytest.raises(TypeError, match=msg):
             s.fillna((1, 2))
 
@@ -613,11 +593,11 @@ def test_fillna_categorical_raise(self):
         with pytest.raises(ValueError, match="fill value must be in categories"):
             s.fillna({1: "d", 3: "a"})
 
-        msg = '"value" parameter must be a scalar or ' 'dict, but you passed a "list"'
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
         with pytest.raises(TypeError, match=msg):
             s.fillna(["a", "b"])
 
-        msg = '"value" parameter must be a scalar or ' 'dict, but you passed a "tuple"'
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
         with pytest.raises(TypeError, match=msg):
             s.fillna(("a", "b"))
 
@@ -637,15 +617,15 @@ def test_fillna_nat(self):
         expected = series.copy()
         expected.values[3] = expected.values[2]
 
-        assert_series_equal(filled, expected)
-        assert_series_equal(filled2, expected)
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
 
         df = DataFrame({"A": series})
         filled = df.fillna(method="pad")
         filled2 = df.fillna(value=series.values[2])
         expected = DataFrame({"A": expected})
-        assert_frame_equal(filled, expected)
-        assert_frame_equal(filled2, expected)
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
 
         series = Series([iNaT, 0, 1, 2], dtype="M8[ns]")
 
@@ -655,15 +635,15 @@ def test_fillna_nat(self):
         expected = series.copy()
         expected[0] = expected[1]
 
-        assert_series_equal(filled, expected)
-        assert_series_equal(filled2, expected)
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
 
         df = DataFrame({"A": series})
         filled = df.fillna(method="bfill")
         filled2 = df.fillna(value=series[1])
         expected = DataFrame({"A": expected})
-        assert_frame_equal(filled, expected)
-        assert_frame_equal(filled2, expected)
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
 
     def test_isna_for_inf(self):
         s = Series(["a", np.inf, np.nan, 1.0])
@@ -716,39 +696,39 @@ def test_fillna(self, datetime_series):
         s2 = Series([1])
         result = s1.fillna(s2)
         expected = Series([1.0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result = s1.fillna({})
-        assert_series_equal(result, s1)
-        result = s1.fillna(Series(()))
-        assert_series_equal(result, s1)
+        tm.assert_series_equal(result, s1)
+        result = s1.fillna(Series((), dtype=object))
+        tm.assert_series_equal(result, s1)
         result = s2.fillna(s1)
-        assert_series_equal(result, s2)
+        tm.assert_series_equal(result, s2)
         result = s1.fillna({0: 1})
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result = s1.fillna({1: 1})
-        assert_series_equal(result, Series([np.nan]))
+        tm.assert_series_equal(result, Series([np.nan]))
         result = s1.fillna({0: 1, 1: 1})
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result = s1.fillna(Series({0: 1, 1: 1}))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         result = s1.fillna(Series({0: 1, 1: 1}, index=[4, 5]))
-        assert_series_equal(result, s1)
+        tm.assert_series_equal(result, s1)
 
         s1 = Series([0, 1, 2], list("abc"))
         s2 = Series([0, np.nan, 2], list("bac"))
         result = s2.fillna(s1)
         expected = Series([0, 0, 2.0], list("bac"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # limit
         s = Series(np.nan, index=[0, 1, 2])
         result = s.fillna(999, limit=1)
         expected = Series([999, np.nan, np.nan], index=[0, 1, 2])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.fillna(999, limit=2)
         expected = Series([999, 999, np.nan], index=[0, 1, 2])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH 9043
         # make sure a string representation of int/float values can be filled
@@ -758,26 +738,26 @@ def test_fillna(self, datetime_series):
             s = Series([0, 1, np.nan, np.nan, 4], dtype="float64")
             result = s.fillna(val)
             expected = Series([0, 1, val, val, 4], dtype="object")
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
     def test_fillna_bug(self):
-        x = Series([nan, 1.0, nan, 3.0, nan], ["z", "a", "b", "c", "d"])
+        x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
         filled = x.fillna(method="ffill")
-        expected = Series([nan, 1.0, 1.0, 3.0, 3.0], x.index)
-        assert_series_equal(filled, expected)
+        expected = Series([np.nan, 1.0, 1.0, 3.0, 3.0], x.index)
+        tm.assert_series_equal(filled, expected)
 
         filled = x.fillna(method="bfill")
-        expected = Series([1.0, 1.0, 3.0, 3.0, nan], x.index)
-        assert_series_equal(filled, expected)
+        expected = Series([1.0, 1.0, 3.0, 3.0, np.nan], x.index)
+        tm.assert_series_equal(filled, expected)
 
     def test_fillna_inplace(self):
-        x = Series([nan, 1.0, nan, 3.0, nan], ["z", "a", "b", "c", "d"])
+        x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
         y = x.copy()
 
         y.fillna(value=0, inplace=True)
 
         expected = x.fillna(value=0)
-        assert_series_equal(y, expected)
+        tm.assert_series_equal(y, expected)
 
     def test_fillna_invalid_method(self, datetime_series):
         try:
@@ -788,18 +768,18 @@ def test_fillna_invalid_method(self, datetime_series):
     def test_ffill(self):
         ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5))
         ts[2] = np.NaN
-        assert_series_equal(ts.ffill(), ts.fillna(method="ffill"))
+        tm.assert_series_equal(ts.ffill(), ts.fillna(method="ffill"))
 
     def test_ffill_mixed_dtypes_without_missing_data(self):
         # GH14956
         series = pd.Series([datetime(2015, 1, 1, tzinfo=pytz.utc), 1])
         result = series.ffill()
-        assert_series_equal(series, result)
+        tm.assert_series_equal(series, result)
 
     def test_bfill(self):
         ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5))
         ts[2] = np.NaN
-        assert_series_equal(ts.bfill(), ts.fillna(method="bfill"))
+        tm.assert_series_equal(ts.bfill(), ts.fillna(method="bfill"))
 
     def test_timedelta64_nan(self):
 
@@ -840,10 +820,11 @@ def test_timedelta64_nan(self):
         #     np.random.seed(12345)
         #     selector = -0.5 <= datetime_series <= 0.5
         #     expected = (datetime_series >= -0.5) & (datetime_series <= 0.5)
-        #     assert_series_equal(selector, expected)
+        #     tm.assert_series_equal(selector, expected)
 
     def test_dropna_empty(self):
-        s = Series([])
+        s = Series([], dtype=object)
+
         assert len(s.dropna()) == 0
         s.dropna(inplace=True)
         assert len(s) == 0
@@ -905,7 +886,7 @@ def test_dropna_intervals(self):
 
         result = s.dropna()
         expected = s.iloc[1:]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_valid(self, datetime_series):
         ts = datetime_series.copy()
@@ -917,20 +898,20 @@ def test_valid(self, datetime_series):
         tm.assert_series_equal(result, ts[pd.notna(ts)])
 
     def test_isna(self):
-        ser = Series([0, 5.4, 3, nan, -0.001])
+        ser = Series([0, 5.4, 3, np.nan, -0.001])
         expected = Series([False, False, False, True, False])
         tm.assert_series_equal(ser.isna(), expected)
 
-        ser = Series(["hi", "", nan])
+        ser = Series(["hi", "", np.nan])
         expected = Series([False, False, True])
         tm.assert_series_equal(ser.isna(), expected)
 
     def test_notna(self):
-        ser = Series([0, 5.4, 3, nan, -0.001])
+        ser = Series([0, 5.4, 3, np.nan, -0.001])
         expected = Series([True, True, True, False, True])
         tm.assert_series_equal(ser.notna(), expected)
 
-        ser = Series(["hi", "", nan])
+        ser = Series(["hi", "", np.nan])
         expected = Series([True, True, False])
         tm.assert_series_equal(ser.notna(), expected)
 
@@ -944,7 +925,7 @@ def test_pad_nan(self):
         expected = Series(
             [np.nan, 1.0, 1.0, 3.0, 3.0], ["z", "a", "b", "c", "d"], dtype=float
         )
-        assert_series_equal(x[1:], expected[1:])
+        tm.assert_series_equal(x[1:], expected[1:])
         assert np.isnan(x[0]), np.isnan(expected[0])
 
     def test_pad_require_monotonicity(self):
@@ -972,7 +953,7 @@ def test_fill_value_when_combine_const(self):
 
         exp = s.fillna(0).add(2)
         res = s.add(2, fill_value=0)
-        assert_series_equal(res, exp)
+        tm.assert_series_equal(res, exp)
 
     def test_series_fillna_limit(self):
         index = np.arange(10)
@@ -983,74 +964,15 @@ def test_series_fillna_limit(self):
 
         expected = s[:2].reindex(index).fillna(method="pad")
         expected[-3:] = np.nan
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s[-2:].reindex(index)
         result = result.fillna(method="bfill", limit=5)
 
         expected = s[-2:].reindex(index).fillna(method="backfill")
         expected[:3] = np.nan
-        assert_series_equal(result, expected)
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-    def test_sparse_series_fillna_limit(self):
-        index = np.arange(10)
-        s = Series(np.random.randn(10), index=index)
-
-        ss = s[:2].reindex(index).to_sparse()
-        # TODO: what is this test doing? why are result an expected
-        # the same call to fillna?
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            # TODO: release-note fillna performance warning
-            result = ss.fillna(method="pad", limit=5)
-            expected = ss.fillna(method="pad", limit=5)
-        expected = expected.to_dense()
-        expected[-3:] = np.nan
-        expected = expected.to_sparse()
-        assert_series_equal(result, expected)
-
-        ss = s[-2:].reindex(index).to_sparse()
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            result = ss.fillna(method="backfill", limit=5)
-            expected = ss.fillna(method="backfill")
-        expected = expected.to_dense()
-        expected[:3] = np.nan
-        expected = expected.to_sparse()
-        assert_series_equal(result, expected)
-
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-    @pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-    def test_sparse_series_pad_backfill_limit(self):
-        index = np.arange(10)
-        s = Series(np.random.randn(10), index=index)
-        s = s.to_sparse()
-
-        result = s[:2].reindex(index, method="pad", limit=5)
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = s[:2].reindex(index).fillna(method="pad")
-        expected = expected.to_dense()
-        expected[-3:] = np.nan
-        expected = expected.to_sparse()
-        assert_series_equal(result, expected)
-
-        result = s[-2:].reindex(index, method="backfill", limit=5)
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = s[-2:].reindex(index).fillna(method="backfill")
-        expected = expected.to_dense()
-        expected[:3] = np.nan
-        expected = expected.to_sparse()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-    @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
     def test_series_pad_backfill_limit(self):
         index = np.arange(10)
         s = Series(np.random.randn(10), index=index)
@@ -1059,13 +981,13 @@ def test_series_pad_backfill_limit(self):
 
         expected = s[:2].reindex(index).fillna(method="pad")
         expected[-3:] = np.nan
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s[-2:].reindex(index, method="backfill", limit=5)
 
         expected = s[-2:].reindex(index).fillna(method="backfill")
         expected[:3] = np.nan
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
 
 @pytest.fixture(
@@ -1159,7 +1081,6 @@ def test_interpolate_time_raises_for_non_timeseries(self):
 
     @td.skip_if_no_scipy
     def test_interpolate_pchip(self):
-        _skip_if_no_pchip()
 
         ser = Series(np.sort(np.random.uniform(size=100)))
 
@@ -1173,7 +1094,6 @@ def test_interpolate_pchip(self):
 
     @td.skip_if_no_scipy
     def test_interpolate_akima(self):
-        _skip_if_no_akima()
 
         ser = Series([10, 11, 12, 13])
 
@@ -1186,7 +1106,7 @@ def test_interpolate_akima(self):
             float
         )
         interp_s = ser.reindex(new_index).interpolate(method="akima")
-        assert_series_equal(interp_s[1:3], expected)
+        tm.assert_series_equal(interp_s[1:3], expected)
 
     @td.skip_if_no_scipy
     def test_interpolate_piecewise_polynomial(self):
@@ -1201,7 +1121,7 @@ def test_interpolate_piecewise_polynomial(self):
             float
         )
         interp_s = ser.reindex(new_index).interpolate(method="piecewise_polynomial")
-        assert_series_equal(interp_s[1:3], expected)
+        tm.assert_series_equal(interp_s[1:3], expected)
 
     @td.skip_if_no_scipy
     def test_interpolate_from_derivatives(self):
@@ -1216,7 +1136,7 @@ def test_interpolate_from_derivatives(self):
             float
         )
         interp_s = ser.reindex(new_index).interpolate(method="from_derivatives")
-        assert_series_equal(interp_s[1:3], expected)
+        tm.assert_series_equal(interp_s[1:3], expected)
 
     @pytest.mark.parametrize(
         "kwargs",
@@ -1229,10 +1149,10 @@ def test_interpolate_from_derivatives(self):
     )
     def test_interpolate_corners(self, kwargs):
         s = Series([np.nan, np.nan])
-        assert_series_equal(s.interpolate(**kwargs), s)
+        tm.assert_series_equal(s.interpolate(**kwargs), s)
 
-        s = Series([]).interpolate()
-        assert_series_equal(s.interpolate(**kwargs), s)
+        s = Series([], dtype=object).interpolate()
+        tm.assert_series_equal(s.interpolate(**kwargs), s)
 
     def test_interpolate_index_values(self):
         s = Series(np.nan, index=np.sort(np.random.rand(30)))
@@ -1249,19 +1169,19 @@ def test_interpolate_index_values(self):
             np.interp(vals[bad], vals[good], s.values[good]), index=s.index[bad]
         )
 
-        assert_series_equal(result[bad], expected)
+        tm.assert_series_equal(result[bad], expected)
 
         # 'values' is synonymous with 'index' for the method kwarg
         other_result = s.interpolate(method="values")
 
-        assert_series_equal(other_result, result)
-        assert_series_equal(other_result[bad], expected)
+        tm.assert_series_equal(other_result, result)
+        tm.assert_series_equal(other_result[bad], expected)
 
     def test_interpolate_non_ts(self):
         s = Series([1, 3, np.nan, np.nan, np.nan, 11])
         msg = (
-            "time-weighted interpolation only works on Series or DataFrames"
-            " with a DatetimeIndex"
+            "time-weighted interpolation only works on Series or DataFrames "
+            "with a DatetimeIndex"
         )
         with pytest.raises(ValueError, match=msg):
             s.interpolate(method="time")
@@ -1279,26 +1199,26 @@ def test_nan_interpolate(self, kwargs):
         s = Series([0, 1, np.nan, 3])
         result = s.interpolate(**kwargs)
         expected = Series([0.0, 1.0, 2.0, 3.0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_nan_irregular_index(self):
         s = Series([1, 2, np.nan, 4], index=[1, 3, 5, 9])
         result = s.interpolate()
         expected = Series([1.0, 2.0, 3.0, 4.0], index=[1, 3, 5, 9])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_nan_str_index(self):
         s = Series([0, 1, 2, np.nan], index=list("abcd"))
         result = s.interpolate()
         expected = Series([0.0, 1.0, 2.0, 2.0], index=list("abcd"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @td.skip_if_no_scipy
     def test_interp_quad(self):
         sq = Series([1, 4, np.nan, 16], index=[1, 2, 3, 4])
         result = sq.interpolate(method="quadratic")
         expected = Series([1.0, 4.0, 9.0, 16.0], index=[1, 2, 3, 4])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @td.skip_if_no_scipy
     def test_interp_scipy_basic(self):
@@ -1306,43 +1226,43 @@ def test_interp_scipy_basic(self):
         # slinear
         expected = Series([1.0, 3.0, 7.5, 12.0, 18.5, 25.0])
         result = s.interpolate(method="slinear")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.interpolate(method="slinear", downcast="infer")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         # nearest
         expected = Series([1, 3, 3, 12, 12, 25])
         result = s.interpolate(method="nearest")
-        assert_series_equal(result, expected.astype("float"))
+        tm.assert_series_equal(result, expected.astype("float"))
 
         result = s.interpolate(method="nearest", downcast="infer")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         # zero
         expected = Series([1, 3, 3, 12, 12, 25])
         result = s.interpolate(method="zero")
-        assert_series_equal(result, expected.astype("float"))
+        tm.assert_series_equal(result, expected.astype("float"))
 
         result = s.interpolate(method="zero", downcast="infer")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         # quadratic
         # GH #15662.
         expected = Series([1, 3.0, 6.823529, 12.0, 18.058824, 25.0])
         result = s.interpolate(method="quadratic")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.interpolate(method="quadratic", downcast="infer")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         # cubic
         expected = Series([1.0, 3.0, 6.8, 12.0, 18.2, 25.0])
         result = s.interpolate(method="cubic")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_limit(self):
         s = Series([1, 3, np.nan, np.nan, np.nan, 11])
 
         expected = Series([1.0, 3.0, 5.0, 7.0, np.nan, 11.0])
         result = s.interpolate(method="linear", limit=2)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("limit", [-1, 0])
     def test_interpolate_invalid_nonpositive_limit(self, nontemporal_method, limit):
@@ -1364,7 +1284,7 @@ def test_interpolate_invalid_float_limit(self, nontemporal_method):
     def test_interp_invalid_method(self, invalid_method):
         s = Series([1, 3, np.nan, 12, np.nan, 25])
 
-        msg = "method must be one of.* Got '{}' instead".format(invalid_method)
+        msg = f"method must be one of.* Got '{invalid_method}' instead"
         with pytest.raises(ValueError, match=msg):
             s.interpolate(method=invalid_method)
 
@@ -1380,32 +1300,32 @@ def test_interp_limit_forward(self):
         expected = Series([1.0, 3.0, 5.0, 7.0, np.nan, 11.0])
 
         result = s.interpolate(method="linear", limit=2, limit_direction="forward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.interpolate(method="linear", limit=2, limit_direction="FORWARD")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_unlimited(self):
         # these test are for issue #16282 default Limit=None is unlimited
         s = Series([np.nan, 1.0, 3.0, np.nan, np.nan, np.nan, 11.0, np.nan])
         expected = Series([1.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 11.0])
         result = s.interpolate(method="linear", limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([np.nan, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 11.0])
         result = s.interpolate(method="linear", limit_direction="forward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([1.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, np.nan])
         result = s.interpolate(method="linear", limit_direction="backward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_limit_bad_direction(self):
         s = Series([1, 3, np.nan, np.nan, np.nan, 11])
 
         msg = (
-            r"Invalid limit_direction: expecting one of \['forward',"
-            r" 'backward', 'both'\], got 'abc'"
+            r"Invalid limit_direction: expecting one of \['forward', "
+            r"'backward', 'both'\], got 'abc'"
         )
         with pytest.raises(ValueError, match=msg):
             s.interpolate(method="linear", limit=2, limit_direction="abc")
@@ -1417,38 +1337,45 @@ def test_interp_limit_bad_direction(self):
     # limit_area introduced GH #16284
     def test_interp_limit_area(self):
         # These tests are for issue #9218 -- fill NaNs in both directions.
-        s = Series([nan, nan, 3, nan, nan, nan, 7, nan, nan])
+        s = Series([np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan])
 
-        expected = Series([nan, nan, 3.0, 4.0, 5.0, 6.0, 7.0, nan, nan])
+        expected = Series([np.nan, np.nan, 3.0, 4.0, 5.0, 6.0, 7.0, np.nan, np.nan])
         result = s.interpolate(method="linear", limit_area="inside")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([nan, nan, 3.0, 4.0, nan, nan, 7.0, nan, nan])
+        expected = Series(
+            [np.nan, np.nan, 3.0, 4.0, np.nan, np.nan, 7.0, np.nan, np.nan]
+        )
         result = s.interpolate(method="linear", limit_area="inside", limit=1)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([nan, nan, 3.0, 4.0, nan, 6.0, 7.0, nan, nan])
+        expected = Series([np.nan, np.nan, 3.0, 4.0, np.nan, 6.0, 7.0, np.nan, np.nan])
         result = s.interpolate(
             method="linear", limit_area="inside", limit_direction="both", limit=1
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([nan, nan, 3.0, nan, nan, nan, 7.0, 7.0, 7.0])
+        expected = Series([np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0])
         result = s.interpolate(method="linear", limit_area="outside")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([nan, nan, 3.0, nan, nan, nan, 7.0, 7.0, nan])
+        expected = Series(
+            [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan]
+        )
         result = s.interpolate(method="linear", limit_area="outside", limit=1)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([nan, 3.0, 3.0, nan, nan, nan, 7.0, 7.0, nan])
+        expected = Series([np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan])
         result = s.interpolate(
             method="linear", limit_area="outside", limit_direction="both", limit=1
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-        expected = Series([3.0, 3.0, 3.0, nan, nan, nan, 7.0, nan, nan])
+        expected = Series([3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan])
         result = s.interpolate(
-            method="linear", limit_area="outside", direction="backward"
+            method="linear", limit_area="outside", limit_direction="backward"
         )
+        tm.assert_series_equal(result, expected)
 
         # raises an error even if limit type is wrong.
         msg = r"Invalid limit_area: expecting one of \['inside', 'outside'\], got abc"
@@ -1461,24 +1388,24 @@ def test_interp_limit_direction(self):
 
         expected = Series([1.0, 3.0, np.nan, 7.0, 9.0, 11.0])
         result = s.interpolate(method="linear", limit=2, limit_direction="backward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([1.0, 3.0, 5.0, np.nan, 9.0, 11.0])
         result = s.interpolate(method="linear", limit=1, limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # Check that this works on a longer series of nans.
         s = Series([1, 3, np.nan, np.nan, np.nan, 7, 9, np.nan, np.nan, 12, np.nan])
 
         expected = Series([1.0, 3.0, 4.0, 5.0, 6.0, 7.0, 9.0, 10.0, 11.0, 12.0, 12.0])
         result = s.interpolate(method="linear", limit=2, limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series(
             [1.0, 3.0, 4.0, np.nan, 6.0, 7.0, 9.0, 10.0, 11.0, 12.0, 12.0]
         )
         result = s.interpolate(method="linear", limit=1, limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_limit_to_ends(self):
         # These test are for issue #10420 -- flow back to beginning.
@@ -1486,11 +1413,11 @@ def test_interp_limit_to_ends(self):
 
         expected = Series([5.0, 5.0, 5.0, 7.0, 9.0, np.nan])
         result = s.interpolate(method="linear", limit=2, limit_direction="backward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([5.0, 5.0, 5.0, 7.0, 9.0, 9.0])
         result = s.interpolate(method="linear", limit=2, limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_limit_before_ends(self):
         # These test are for issue #11115 -- limit ends properly.
@@ -1498,25 +1425,25 @@ def test_interp_limit_before_ends(self):
 
         expected = Series([np.nan, np.nan, 5.0, 7.0, 7.0, np.nan])
         result = s.interpolate(method="linear", limit=1, limit_direction="forward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([np.nan, 5.0, 5.0, 7.0, np.nan, np.nan])
         result = s.interpolate(method="linear", limit=1, limit_direction="backward")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([np.nan, 5.0, 5.0, 7.0, 7.0, np.nan])
         result = s.interpolate(method="linear", limit=1, limit_direction="both")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @td.skip_if_no_scipy
     def test_interp_all_good(self):
         s = Series([1, 2, 3])
         result = s.interpolate(method="polynomial", order=1)
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
         # non-scipy
         result = s.interpolate()
-        assert_series_equal(result, s)
+        tm.assert_series_equal(result, s)
 
     @pytest.mark.parametrize(
         "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
@@ -1528,7 +1455,7 @@ def test_interp_multiIndex(self, check_scipy):
         expected = s.copy()
         expected.loc[2] = 2
         result = s.interpolate()
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         msg = "Only `method=linear` interpolation is supported on MultiIndexes"
         if check_scipy:
@@ -1553,7 +1480,7 @@ def test_interp_datetime64(self, method, tz_naive_fixture):
             [1.0, 1.0, 3.0],
             index=date_range("1/1/2000", periods=3, tz=tz_naive_fixture),
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_interp_pad_datetime64tz_values(self):
         # GH#27628 missing.interpolate_2d should handle datetimetz values
@@ -1571,7 +1498,7 @@ def test_interp_limit_no_nans(self):
         s = pd.Series([1.0, 2.0, 3.0])
         result = s.interpolate(limit=1)
         expected = s
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @td.skip_if_no_scipy
     @pytest.mark.parametrize("method", ["polynomial", "spline"])
@@ -1595,18 +1522,18 @@ def test_spline(self):
         s = Series([1, 2, np.nan, 4, 5, np.nan, 7])
         result = s.interpolate(method="spline", order=1)
         expected = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @td.skip_if_no_scipy
     def test_spline_extrapolate(self):
         s = Series([1, 2, 3, 4, np.nan, 6, np.nan])
         result3 = s.interpolate(method="spline", order=1, ext=3)
         expected3 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 6.0])
-        assert_series_equal(result3, expected3)
+        tm.assert_series_equal(result3, expected3)
 
         result1 = s.interpolate(method="spline", order=1, ext=0)
         expected1 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
-        assert_series_equal(result1, expected1)
+        tm.assert_series_equal(result1, expected1)
 
     @td.skip_if_no_scipy
     def test_spline_smooth(self):
@@ -1622,20 +1549,20 @@ def test_spline_interpolation(self):
         s[np.random.randint(0, 9, 3)] = np.nan
         result1 = s.interpolate(method="spline", order=1)
         expected1 = s.interpolate(method="spline", order=1)
-        assert_series_equal(result1, expected1)
+        tm.assert_series_equal(result1, expected1)
 
     def test_interp_timedelta64(self):
         # GH 6424
         df = Series([1, np.nan, 3], index=pd.to_timedelta([1, 2, 3]))
         result = df.interpolate(method="time")
         expected = Series([1.0, 2.0, 3.0], index=pd.to_timedelta([1, 2, 3]))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # test for non uniform spacing
         df = Series([1, np.nan, 3], index=pd.to_timedelta([1, 2, 4]))
         result = df.interpolate(method="time")
         expected = Series([1.0, 1.666667, 3.0], index=pd.to_timedelta([1, 2, 4]))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_series_interpolate_method_values(self):
         # #1646
@@ -1644,7 +1571,7 @@ def test_series_interpolate_method_values(self):
 
         result = ts.interpolate(method="values")
         exp = ts.interpolate()
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_series_interpolate_intraday(self):
         # #1698
@@ -1661,12 +1588,6 @@ def test_series_interpolate_intraday(self):
 
         tm.assert_numpy_array_equal(result.values, exp.values)
 
-    def test_nonzero_warning(self):
-        # GH 24048
-        ser = pd.Series([1, 0, 3, 4])
-        with tm.assert_produces_warning(FutureWarning):
-            ser.nonzero()
-
     @pytest.mark.parametrize(
         "ind",
         [
@@ -1681,18 +1602,18 @@ def test_interp_non_timedelta_index(self, interp_methods_ind, ind):
 
         method, kwargs = interp_methods_ind
         if method == "pchip":
-            _skip_if_no_pchip()
+            pytest.importorskip("scipy")
 
         if method == "linear":
             result = df[0].interpolate(**kwargs)
             expected = pd.Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
         else:
             expected_error = (
                 "Index column must be numeric or datetime type when "
-                "using {method} method other than linear. "
+                f"using {method} method other than linear. "
                 "Try setting a numeric or datetime index column before "
-                "interpolating.".format(method=method)
+                "interpolating."
             )
             with pytest.raises(ValueError, match=expected_error):
                 df[0].interpolate(method=method, **kwargs)
@@ -1709,13 +1630,24 @@ def test_interpolate_timedelta_index(self, interp_methods_ind):
 
         method, kwargs = interp_methods_ind
         if method == "pchip":
-            _skip_if_no_pchip()
+            pytest.importorskip("scipy")
 
         if method in {"linear", "pchip"}:
             result = df[0].interpolate(method=method, **kwargs)
             expected = pd.Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
         else:
             pytest.skip(
                 "This interpolation method is not supported for Timedelta Index yet."
             )
+
+    @pytest.mark.parametrize(
+        "ascending, expected_values",
+        [(True, [1, 2, 3, 9, 10]), (False, [10, 9, 3, 2, 1])],
+    )
+    def test_interpolate_unsorted_index(self, ascending, expected_values):
+        # GH 21037
+        ts = pd.Series(data=[10, 9, np.nan, 2, 1], index=[10, 9, 3, 2, 1])
+        result = ts.sort_index(ascending=ascending).interpolate(method="index")
+        expected = pd.Series(data=expected_values, index=expected_values, dtype=float)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index c2cf91e582c47..bdd9f92d92d3f 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -6,18 +6,9 @@
 
 import pandas as pd
 from pandas import Categorical, DataFrame, Index, Series, bdate_range, date_range, isna
+import pandas._testing as tm
 from pandas.core import ops
-from pandas.core.indexes.base import InvalidIndexError
 import pandas.core.nanops as nanops
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_index_equal,
-    assert_series_equal,
-)
-
-from .common import TestData
 
 
 class TestSeriesLogicalOps:
@@ -34,7 +25,7 @@ def test_bool_operators_with_nas(self, bool_op):
 
         expected = bool_op(filled < filled[9], filled > filled[3])
         expected[mask] = False
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_logical_operators_bool_dtype_with_empty(self):
         # GH#9016: support bitwise op for integer types
@@ -42,15 +33,51 @@ def test_logical_operators_bool_dtype_with_empty(self):
 
         s_tft = Series([True, False, True], index=index)
         s_fff = Series([False, False, False], index=index)
-        s_empty = Series([])
+        s_empty = Series([], dtype=object)
 
         res = s_tft & s_empty
         expected = s_fff
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_tft | s_empty
         expected = s_tft
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
+
+    @pytest.mark.parametrize(
+        "left, right, op, expected",
+        [
+            (
+                [True, False, np.nan],
+                [True, False, True],
+                operator.and_,
+                [True, False, False],
+            ),
+            (
+                [True, False, True],
+                [True, False, np.nan],
+                operator.and_,
+                [True, False, False],
+            ),
+            (
+                [True, False, np.nan],
+                [True, False, True],
+                operator.or_,
+                [True, False, False],
+            ),
+            (
+                [True, False, True],
+                [True, False, np.nan],
+                operator.or_,
+                [True, False, True],
+            ),
+        ],
+    )
+    def test_logical_operators_nans(self, left, right, op, expected):
+        # GH 13896
+        result = op(Series(left), Series(right))
+        expected = Series(expected)
+
+        tm.assert_series_equal(result, expected)
 
     def test_logical_operators_int_dtype_with_int_dtype(self):
         # GH#9016: support bitwise op for integer types
@@ -64,20 +91,20 @@ def test_logical_operators_int_dtype_with_int_dtype(self):
 
         res = s_0123 & s_3333
         expected = Series(range(4), dtype="int64")
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_0123 | s_4444
         expected = Series(range(4, 8), dtype="int64")
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         s_1111 = Series([1] * 4, dtype="int8")
         res = s_0123 & s_1111
         expected = Series([0, 1, 0, 1], dtype="int64")
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_0123.astype(np.int16) | s_1111.astype(np.int32)
         expected = Series([1, 1, 3, 3], dtype="int32")
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
     def test_logical_operators_int_dtype_with_int_scalar(self):
         # GH#9016: support bitwise op for integer types
@@ -85,11 +112,11 @@ def test_logical_operators_int_dtype_with_int_scalar(self):
 
         res = s_0123 & 0
         expected = Series([0] * 4)
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_0123 & 1
         expected = Series([0, 1, 0, 1])
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
     def test_logical_operators_int_dtype_with_float(self):
         # GH#9016: support bitwise op for integer types
@@ -121,17 +148,17 @@ def test_logical_operators_int_dtype_with_bool(self):
         expected = Series([False] * 4)
 
         result = s_0123 & False
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s_0123 & [False]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s_0123 & (False,)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s_0123 ^ False
         expected = Series([False, True, True, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_logical_operators_int_dtype_with_object(self):
         # GH#9016: support bitwise op for integer types
@@ -139,7 +166,7 @@ def test_logical_operators_int_dtype_with_object(self):
 
         result = s_0123 & Series([False, np.NaN, False, False])
         expected = Series([False] * 4)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s_abNd = Series(["a", "b", np.NaN, "d"])
         with pytest.raises(TypeError, match="unsupported.* 'int' and 'str'"):
@@ -153,11 +180,11 @@ def test_logical_operators_bool_dtype_with_int(self):
 
         res = s_tft & 0
         expected = s_fff
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_tft & 1
         expected = s_tft
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
     def test_logical_ops_bool_dtype_with_ndarray(self):
         # make sure we operate on ndarray the same as Series
@@ -210,21 +237,21 @@ def test_logical_operators_int_dtype_with_bool_dtype_and_reindex(self):
         # s_0123 will be all false now because of reindexing like s_tft
         expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
         result = s_tft & s_0123
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
         result = s_0123 & s_tft
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s_a0b1c0 = Series([1], list("b"))
 
         res = s_tft & s_a0b1c0
         expected = s_tff.reindex(list("abc"))
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
         res = s_tft | s_a0b1c0
         expected = s_tft.reindex(list("abc"))
-        assert_series_equal(res, expected)
+        tm.assert_series_equal(res, expected)
 
     def test_scalar_na_logical_ops_corners(self):
         s = Series([2, 3, 4, 5, 6, 7, 8, 9, 10])
@@ -238,7 +265,7 @@ def test_scalar_na_logical_ops_corners(self):
         expected = Series(True, index=s.index)
         expected[::2] = False
         result = s & list(s)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         d = DataFrame({"A": s})
         # TODO: Fix this exception - needs to be fixed! (see GH5035)
@@ -250,12 +277,20 @@ def test_scalar_na_logical_ops_corners(self):
 
         with pytest.raises(TypeError):
             d.__and__(s, axis="columns")
+        with pytest.raises(TypeError):
+            d.__and__(s, axis=1)
 
         with pytest.raises(TypeError):
             s & d
+        with pytest.raises(TypeError):
+            d & s
 
-        # this is wrong as its not a boolean result
-        # result = d.__and__(s,axis='index')
+        expected = (s & s).to_frame("A")
+        result = d.__and__(s, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        result = d.__and__(s, axis=0)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("op", [operator.and_, operator.or_, operator.xor])
     def test_logical_ops_with_index(self, op):
@@ -267,12 +302,26 @@ def test_logical_ops_with_index(self, op):
         expected = Series([op(ser[n], idx1[n]) for n in range(len(ser))])
 
         result = op(ser, idx1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([op(ser[n], idx2[n]) for n in range(len(ser))], dtype=bool)
 
         result = op(ser, idx2)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_reversed_xor_with_index_returns_index(self):
+        # GH#22092, GH#19792
+        ser = Series([True, True, False, False])
+        idx1 = Index([True, False, True, False])
+        idx2 = Index([1, 0, 1, 0])
+
+        expected = Index.symmetric_difference(idx1, ser)
+        result = idx1 ^ ser
+        tm.assert_index_equal(result, expected)
+
+        expected = Index.symmetric_difference(idx2, ser)
+        result = idx2 ^ ser
+        tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
         "op",
@@ -280,7 +329,7 @@ def test_logical_ops_with_index(self, op):
             pytest.param(
                 ops.rand_,
                 marks=pytest.mark.xfail(
-                    reason="GH#22092 Index implementation returns Index",
+                    reason="GH#22092 Index __and__ returns Index intersection",
                     raises=AssertionError,
                     strict=True,
                 ),
@@ -288,30 +337,26 @@ def test_logical_ops_with_index(self, op):
             pytest.param(
                 ops.ror_,
                 marks=pytest.mark.xfail(
-                    reason="Index.get_indexer with non unique index",
-                    raises=InvalidIndexError,
+                    reason="GH#22092 Index __or__ returns Index union",
+                    raises=AssertionError,
                     strict=True,
                 ),
             ),
-            ops.rxor,
         ],
     )
-    def test_reversed_logical_ops_with_index(self, op):
+    def test_reversed_logical_op_with_index_returns_series(self, op):
         # GH#22092, GH#19792
         ser = Series([True, True, False, False])
         idx1 = Index([True, False, True, False])
         idx2 = Index([1, 0, 1, 0])
 
-        # symmetric_difference is only for rxor, but other 2 should fail
-        expected = idx1.symmetric_difference(ser)
-
+        expected = pd.Series(op(idx1.values, ser.values))
         result = op(ser, idx1)
-        assert_index_equal(result, expected)
-
-        expected = idx2.symmetric_difference(ser)
+        tm.assert_series_equal(result, expected)
 
+        expected = pd.Series(op(idx2.values, ser.values))
         result = op(ser, idx2)
-        assert_index_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
         "op, expected",
@@ -338,15 +383,15 @@ def test_logical_ops_label_based(self):
 
         expected = Series([False, True, False], list("abc"))
         result = a & b
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([True, True, False], list("abc"))
         result = a | b
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([True, False, False], list("abc"))
         result = a ^ b
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # rhs is bigger
         a = Series([True, False, True], list("bca"))
@@ -354,46 +399,48 @@ def test_logical_ops_label_based(self):
 
         expected = Series([False, True, False, False], list("abcd"))
         result = a & b
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series([True, True, False, False], list("abcd"))
         result = a | b
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # filling
 
         # vs empty
-        result = a & Series([])
+        empty = Series([], dtype=object)
+
+        result = a & empty.copy()
         expected = Series([False, False, False], list("bca"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
-        result = a | Series([])
+        result = a | empty.copy()
         expected = Series([True, False, True], list("bca"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # vs non-matching
         result = a & Series([1], ["z"])
         expected = Series([False, False, False, False], list("abcz"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = a | Series([1], ["z"])
         expected = Series([True, True, False, False], list("abcz"))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # identity
         # we would like s[s|e] == s to hold for any e, whether empty or not
         for e in [
-            Series([]),
+            empty.copy(),
             Series([1], ["z"]),
             Series(np.nan, b.index),
             Series(np.nan, a.index),
         ]:
             result = a[a | e]
-            assert_series_equal(result, a[a])
+            tm.assert_series_equal(result, a[a])
 
         for e in [Series(["z"])]:
             result = a[a | e]
-            assert_series_equal(result, a[a])
+            tm.assert_series_equal(result, a[a])
 
         # vs scalars
         index = list("bca")
@@ -402,7 +449,7 @@ def test_logical_ops_label_based(self):
         for v in [True, 1, 2]:
             result = Series([True, False, True], index=index) | v
             expected = Series([True, True, True], index=index)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         for v in [np.nan, "foo"]:
             with pytest.raises(TypeError):
@@ -411,17 +458,17 @@ def test_logical_ops_label_based(self):
         for v in [False, 0]:
             result = Series([True, False, True], index=index) | v
             expected = Series([True, False, True], index=index)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         for v in [True, 1]:
             result = Series([True, False, True], index=index) & v
             expected = Series([True, False, True], index=index)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         for v in [False, 0]:
             result = Series([True, False, True], index=index) & v
             expected = Series([False, False, False], index=index)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
         for v in [np.nan]:
             with pytest.raises(TypeError):
                 t & v
@@ -432,47 +479,44 @@ def test_logical_ops_df_compat(self):
         s2 = pd.Series([True, True, False], index=list("ABD"), name="x")
 
         exp = pd.Series([True, False, False, False], index=list("ABCD"), name="x")
-        assert_series_equal(s1 & s2, exp)
-        assert_series_equal(s2 & s1, exp)
+        tm.assert_series_equal(s1 & s2, exp)
+        tm.assert_series_equal(s2 & s1, exp)
 
         # True | np.nan => True
-        exp = pd.Series([True, True, True, False], index=list("ABCD"), name="x")
-        assert_series_equal(s1 | s2, exp)
+        exp_or1 = pd.Series([True, True, True, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s1 | s2, exp_or1)
         # np.nan | True => np.nan, filled with False
-        exp = pd.Series([True, True, False, False], index=list("ABCD"), name="x")
-        assert_series_equal(s2 | s1, exp)
+        exp_or = pd.Series([True, True, False, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s2 | s1, exp_or)
 
         # DataFrame doesn't fill nan with False
-        exp = pd.DataFrame({"x": [True, False, np.nan, np.nan]}, index=list("ABCD"))
-        assert_frame_equal(s1.to_frame() & s2.to_frame(), exp)
-        assert_frame_equal(s2.to_frame() & s1.to_frame(), exp)
+        tm.assert_frame_equal(s1.to_frame() & s2.to_frame(), exp.to_frame())
+        tm.assert_frame_equal(s2.to_frame() & s1.to_frame(), exp.to_frame())
 
         exp = pd.DataFrame({"x": [True, True, np.nan, np.nan]}, index=list("ABCD"))
-        assert_frame_equal(s1.to_frame() | s2.to_frame(), exp)
-        assert_frame_equal(s2.to_frame() | s1.to_frame(), exp)
+        tm.assert_frame_equal(s1.to_frame() | s2.to_frame(), exp_or1.to_frame())
+        tm.assert_frame_equal(s2.to_frame() | s1.to_frame(), exp_or.to_frame())
 
         # different length
         s3 = pd.Series([True, False, True], index=list("ABC"), name="x")
         s4 = pd.Series([True, True, True, True], index=list("ABCD"), name="x")
 
         exp = pd.Series([True, False, True, False], index=list("ABCD"), name="x")
-        assert_series_equal(s3 & s4, exp)
-        assert_series_equal(s4 & s3, exp)
+        tm.assert_series_equal(s3 & s4, exp)
+        tm.assert_series_equal(s4 & s3, exp)
 
         # np.nan | True => np.nan, filled with False
-        exp = pd.Series([True, True, True, False], index=list("ABCD"), name="x")
-        assert_series_equal(s3 | s4, exp)
+        exp_or1 = pd.Series([True, True, True, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s3 | s4, exp_or1)
         # True | np.nan => True
-        exp = pd.Series([True, True, True, True], index=list("ABCD"), name="x")
-        assert_series_equal(s4 | s3, exp)
+        exp_or = pd.Series([True, True, True, True], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s4 | s3, exp_or)
 
-        exp = pd.DataFrame({"x": [True, False, True, np.nan]}, index=list("ABCD"))
-        assert_frame_equal(s3.to_frame() & s4.to_frame(), exp)
-        assert_frame_equal(s4.to_frame() & s3.to_frame(), exp)
+        tm.assert_frame_equal(s3.to_frame() & s4.to_frame(), exp.to_frame())
+        tm.assert_frame_equal(s4.to_frame() & s3.to_frame(), exp.to_frame())
 
-        exp = pd.DataFrame({"x": [True, True, True, np.nan]}, index=list("ABCD"))
-        assert_frame_equal(s3.to_frame() | s4.to_frame(), exp)
-        assert_frame_equal(s4.to_frame() | s3.to_frame(), exp)
+        tm.assert_frame_equal(s3.to_frame() | s4.to_frame(), exp_or1.to_frame())
+        tm.assert_frame_equal(s4.to_frame() | s3.to_frame(), exp_or.to_frame())
 
 
 class TestSeriesComparisons:
@@ -486,15 +530,15 @@ def test_comparisons(self):
             expected = (left > right).astype("O")
         expected[:3] = np.nan
 
-        assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected)
 
         s = Series(["a", "b", "c"])
         s2 = Series([False, True, False])
 
         # it works!
         exp = Series([False, False, False])
-        assert_series_equal(s == s2, exp)
-        assert_series_equal(s2 == s, exp)
+        tm.assert_series_equal(s == s2, exp)
+        tm.assert_series_equal(s2 == s, exp)
 
     def test_categorical_comparisons(self):
         # GH 8938
@@ -558,35 +602,35 @@ def test_comparison_tuples(self):
 
         result = s == (1, 2)
         expected = Series([False, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s != (1, 2)
         expected = Series([True, False])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s == (0, 0)
         expected = Series([False, False])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s != (0, 0)
         expected = Series([True, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([(1, 1), (1, 1)])
 
         result = s == (1, 1)
         expected = Series([True, True])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s != (1, 1)
         expected = Series([False, False])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([frozenset([1]), frozenset([1, 2])])
 
         result = s == frozenset([1])
         expected = Series([True, False])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_comparison_operators_with_nas(self):
         ser = Series(bdate_range("1/1/2000", periods=10), dtype=object)
@@ -607,13 +651,13 @@ def test_comparison_operators_with_nas(self):
             else:
                 expected = expected.fillna(False).astype(bool)
 
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
             # FIXME: dont leave commented-out
             # fffffffuuuuuuuuuuuu
             # result = f(val, s)
             # expected = f(val, s.dropna()).reindex(s.index)
-            # assert_series_equal(result, expected)
+            # tm.assert_series_equal(result, expected)
 
     def test_unequal_categorical_comparison_raises_type_error(self):
         # unequal comparison should raise for unordered cats
@@ -683,7 +727,7 @@ def test_compare_series_interval_keyword(self):
         s = Series(["IntervalA", "IntervalB", "IntervalC"])
         result = s == "IntervalA"
         expected = Series([True, False, False])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
 
 class TestSeriesFlexComparisonOps:
@@ -692,51 +736,51 @@ def test_comparison_flex_alignment(self):
         right = Series([2, 2, 2], index=list("bcd"))
 
         exp = pd.Series([False, False, True, False], index=list("abcd"))
-        assert_series_equal(left.eq(right), exp)
+        tm.assert_series_equal(left.eq(right), exp)
 
         exp = pd.Series([True, True, False, True], index=list("abcd"))
-        assert_series_equal(left.ne(right), exp)
+        tm.assert_series_equal(left.ne(right), exp)
 
         exp = pd.Series([False, False, True, False], index=list("abcd"))
-        assert_series_equal(left.le(right), exp)
+        tm.assert_series_equal(left.le(right), exp)
 
         exp = pd.Series([False, False, False, False], index=list("abcd"))
-        assert_series_equal(left.lt(right), exp)
+        tm.assert_series_equal(left.lt(right), exp)
 
         exp = pd.Series([False, True, True, False], index=list("abcd"))
-        assert_series_equal(left.ge(right), exp)
+        tm.assert_series_equal(left.ge(right), exp)
 
         exp = pd.Series([False, True, False, False], index=list("abcd"))
-        assert_series_equal(left.gt(right), exp)
+        tm.assert_series_equal(left.gt(right), exp)
 
     def test_comparison_flex_alignment_fill(self):
         left = Series([1, 3, 2], index=list("abc"))
         right = Series([2, 2, 2], index=list("bcd"))
 
         exp = pd.Series([False, False, True, True], index=list("abcd"))
-        assert_series_equal(left.eq(right, fill_value=2), exp)
+        tm.assert_series_equal(left.eq(right, fill_value=2), exp)
 
         exp = pd.Series([True, True, False, False], index=list("abcd"))
-        assert_series_equal(left.ne(right, fill_value=2), exp)
+        tm.assert_series_equal(left.ne(right, fill_value=2), exp)
 
         exp = pd.Series([False, False, True, True], index=list("abcd"))
-        assert_series_equal(left.le(right, fill_value=0), exp)
+        tm.assert_series_equal(left.le(right, fill_value=0), exp)
 
         exp = pd.Series([False, False, False, True], index=list("abcd"))
-        assert_series_equal(left.lt(right, fill_value=0), exp)
+        tm.assert_series_equal(left.lt(right, fill_value=0), exp)
 
         exp = pd.Series([True, True, True, False], index=list("abcd"))
-        assert_series_equal(left.ge(right, fill_value=0), exp)
+        tm.assert_series_equal(left.ge(right, fill_value=0), exp)
 
         exp = pd.Series([True, True, False, False], index=list("abcd"))
-        assert_series_equal(left.gt(right, fill_value=0), exp)
+        tm.assert_series_equal(left.gt(right, fill_value=0), exp)
 
 
-class TestSeriesOperators(TestData):
+class TestSeriesOperators:
     def test_operators_empty_int_corner(self):
         s1 = Series([], [], dtype=np.int32)
         s2 = Series({"x": 0.0})
-        assert_series_equal(s1 * s2, Series([np.nan], index=["x"]))
+        tm.assert_series_equal(s1 * s2, Series([np.nan], index=["x"]))
 
     def test_ops_datetimelike_align(self):
         # GH 7500
@@ -748,21 +792,19 @@ def test_ops_datetimelike_align(self):
         expected = Series([timedelta(0), timedelta(0), pd.NaT])
         # name is reset
         result = dt2 - dt
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         expected = Series(expected, name=0)
         result = (dt2.to_frame() - dt.to_frame())[0]
-        assert_series_equal(result, expected)
-
-    def test_operators_corner(self):
-        series = self.ts
+        tm.assert_series_equal(result, expected)
 
-        empty = Series([], index=Index([]))
+    def test_operators_corner(self, datetime_series):
+        empty = Series([], index=Index([]), dtype=np.float64)
 
-        result = series + empty
+        result = datetime_series + empty
         assert np.isnan(result).all()
 
-        result = empty + Series([], index=Index([]))
+        result = empty + empty.copy()
         assert len(result) == 0
 
         # TODO: this returned NotImplemented earlier, what to do?
@@ -772,10 +814,12 @@ def test_operators_corner(self):
         # deltas = deltas + sub_deltas
 
         # float + int
-        int_ts = self.ts.astype(int)[:-5]
-        added = self.ts + int_ts
+        int_ts = datetime_series.astype(int)[:-5]
+        added = datetime_series + int_ts
         expected = Series(
-            self.ts.values[:-5] + int_ts.values, index=self.ts.index[:-5], name="ts"
+            datetime_series.values[:-5] + int_ts.values,
+            index=datetime_series.index[:-5],
+            name="ts",
         )
         tm.assert_series_equal(added[:-5], expected)
 
@@ -818,14 +862,14 @@ def _check_fill(meth, op, a, b, fill_value=0):
 
             result = meth(a, b, fill_value=fill_value)
             expected = Series(exp_values, exp_index)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
         a = Series([np.nan, 1.0, 2.0, 3.0, np.nan], index=np.arange(5))
         b = Series([np.nan, 1, np.nan, 3, np.nan, 4.0], index=np.arange(6))
 
         result = op(a, b)
         exp = equiv_op(a, b)
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
         _check_fill(op, equiv_op, a, b, fill_value=fv)
         # should accept axis=0 or axis='rows'
         op(a, b, axis=0)
@@ -849,7 +893,7 @@ def test_op_duplicate_index(self):
         s2 = Series([10, 10], index=[1, 2])
         result = s1 + s2
         expected = pd.Series([11, 12, np.nan], index=[1, 1, 2])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_divmod(self):
         # GH25557
@@ -858,13 +902,24 @@ def test_divmod(self):
 
         result = a.divmod(b)
         expected = divmod(a, b)
-        assert_series_equal(result[0], expected[0])
-        assert_series_equal(result[1], expected[1])
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
 
         result = a.rdivmod(b)
         expected = divmod(b, a)
-        assert_series_equal(result[0], expected[0])
-        assert_series_equal(result[1], expected[1])
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+    @pytest.mark.parametrize("index", [None, range(9)])
+    def test_series_integer_mod(self, index):
+        # see gh-24396
+        s1 = Series(range(1, 10))
+        s2 = Series("foo", index=index)
+
+        msg = "not all arguments converted during string formatting"
+
+        with pytest.raises(TypeError, match=msg):
+            s2 % s1
 
 
 class TestSeriesUnaryOps:
@@ -873,9 +928,9 @@ class TestSeriesUnaryOps:
     def test_neg(self):
         ser = tm.makeStringSeries()
         ser.name = "series"
-        assert_series_equal(-ser, -1 * ser)
+        tm.assert_series_equal(-ser, -1 * ser)
 
     def test_invert(self):
         ser = tm.makeStringSeries()
         ser.name = "series"
-        assert_series_equal(-(ser < 0), ~(ser < 0))
+        tm.assert_series_equal(-(ser < 0), ~(ser < 0))
diff --git a/pandas/tests/series/test_period.py b/pandas/tests/series/test_period.py
index 4aeb211170d8f..03fee389542e3 100644
--- a/pandas/tests/series/test_period.py
+++ b/pandas/tests/series/test_period.py
@@ -3,8 +3,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Period, Series, period_range
+import pandas._testing as tm
 from pandas.core.arrays import PeriodArray
-import pandas.util.testing as tm
 
 
 class TestSeriesPeriod:
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index 3c6da304dd68d..64a8c4569406e 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -8,19 +8,17 @@
     Categorical,
     DataFrame,
     Index,
+    MultiIndex,
     Series,
     date_range,
     option_context,
     period_range,
     timedelta_range,
 )
-from pandas.core.index import MultiIndex
-import pandas.util.testing as tm
+import pandas._testing as tm
 
-from .common import TestData
 
-
-class TestSeriesRepr(TestData):
+class TestSeriesRepr:
     def test_multilevel_name_print(self):
         index = MultiIndex(
             levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
@@ -64,27 +62,27 @@ def test_name_printing(self):
         s.name = None
         assert "Name:" not in repr(s)
 
-        s = Series(index=date_range("20010101", "20020101"), name="test")
+        s = Series(index=date_range("20010101", "20020101"), name="test", dtype=object)
         assert "Name: test" in repr(s)
 
-    def test_repr(self):
-        str(self.ts)
-        str(self.series)
-        str(self.series.astype(int))
-        str(self.objSeries)
+    def test_repr(self, datetime_series, string_series, object_series):
+        str(datetime_series)
+        str(string_series)
+        str(string_series.astype(int))
+        str(object_series)
 
         str(Series(tm.randn(1000), index=np.arange(1000)))
         str(Series(tm.randn(1000), index=np.arange(1000, 0, step=-1)))
 
         # empty
-        str(self.empty)
+        str(Series(dtype=object))
 
         # with NaNs
-        self.series[5:7] = np.NaN
-        str(self.series)
+        string_series[5:7] = np.NaN
+        str(string_series)
 
         # with Nones
-        ots = self.ts.astype("O")
+        ots = datetime_series.astype("O")
         ots[::2] = None
         repr(ots)
 
@@ -102,8 +100,8 @@ def test_repr(self):
             ("\u03B1", "\u03B2", "\u03B3"),
             ("\u03B1", "bar"),
         ]:
-            self.series.name = name
-            repr(self.series)
+            string_series.name = name
+            repr(string_series)
 
         biggie = Series(
             tm.randn(1000), index=np.arange(1000), name=("foo", "bar", "baz")
@@ -229,7 +227,7 @@ class County:
             name = "San Sebastián"
             state = "PR"
 
-            def __repr__(self):
+            def __repr__(self) -> str:
                 return self.name + ", " + self.state
 
         cat = pd.Categorical([County() for _ in range(61)])
diff --git a/pandas/tests/series/test_subclass.py b/pandas/tests/series/test_subclass.py
index 450fdc3f4dd6f..73247bbf8b3d6 100644
--- a/pandas/tests/series/test_subclass.py
+++ b/pandas/tests/series/test_subclass.py
@@ -1,9 +1,4 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-from pandas import SparseDtype
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestSeriesSubclassing:
@@ -37,68 +32,6 @@ def test_subclass_unstack(self):
         tm.assert_frame_equal(res, exp)
 
     def test_subclass_empty_repr(self):
-        assert "SubclassedSeries" in repr(tm.SubclassedSeries())
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-class TestSparseSeriesSubclassing:
-    def test_subclass_sparse_slice(self):
-        # int64
-        s = tm.SubclassedSparseSeries([1, 2, 3, 4, 5])
-        exp = tm.SubclassedSparseSeries([2, 3, 4], index=[1, 2, 3])
-        tm.assert_sp_series_equal(s.loc[1:3], exp)
-        assert s.loc[1:3].dtype == SparseDtype(np.int64)
-
-        exp = tm.SubclassedSparseSeries([2, 3], index=[1, 2])
-        tm.assert_sp_series_equal(s.iloc[1:3], exp)
-        assert s.iloc[1:3].dtype == SparseDtype(np.int64)
-
-        exp = tm.SubclassedSparseSeries([2, 3], index=[1, 2])
-        tm.assert_sp_series_equal(s[1:3], exp)
-        assert s[1:3].dtype == SparseDtype(np.int64)
-
-        # float64
-        s = tm.SubclassedSparseSeries([1.0, 2.0, 3.0, 4.0, 5.0])
-        exp = tm.SubclassedSparseSeries([2.0, 3.0, 4.0], index=[1, 2, 3])
-        tm.assert_sp_series_equal(s.loc[1:3], exp)
-        assert s.loc[1:3].dtype == SparseDtype(np.float64)
-
-        exp = tm.SubclassedSparseSeries([2.0, 3.0], index=[1, 2])
-        tm.assert_sp_series_equal(s.iloc[1:3], exp)
-        assert s.iloc[1:3].dtype == SparseDtype(np.float64)
-
-        exp = tm.SubclassedSparseSeries([2.0, 3.0], index=[1, 2])
-        tm.assert_sp_series_equal(s[1:3], exp)
-        assert s[1:3].dtype == SparseDtype(np.float64)
-
-    def test_subclass_sparse_addition(self):
-        s1 = tm.SubclassedSparseSeries([1, 3, 5])
-        s2 = tm.SubclassedSparseSeries([-2, 5, 12])
-        exp = tm.SubclassedSparseSeries([-1, 8, 17])
-        tm.assert_sp_series_equal(s1 + s2, exp)
-
-        s1 = tm.SubclassedSparseSeries([4.0, 5.0, 6.0])
-        s2 = tm.SubclassedSparseSeries([1.0, 2.0, 3.0])
-        exp = tm.SubclassedSparseSeries([5.0, 7.0, 9.0])
-        tm.assert_sp_series_equal(s1 + s2, exp)
-
-    def test_subclass_sparse_to_frame(self):
-        s = tm.SubclassedSparseSeries([1, 2], index=list("ab"), name="xxx")
-        res = s.to_frame()
-
-        exp_arr = pd.SparseArray([1, 2], dtype=np.int64, kind="block", fill_value=0)
-        exp = tm.SubclassedSparseDataFrame(
-            {"xxx": exp_arr}, index=list("ab"), default_fill_value=0
-        )
-        tm.assert_sp_frame_equal(res, exp)
-
-        # create from int dict
-        res = tm.SubclassedSparseDataFrame(
-            {"xxx": [1, 2]}, index=list("ab"), default_fill_value=0
-        )
-        tm.assert_sp_frame_equal(res, exp)
-
-        s = tm.SubclassedSparseSeries([1.1, 2.1], index=list("ab"), name="xxx")
-        res = s.to_frame()
-        exp = tm.SubclassedSparseDataFrame({"xxx": [1.1, 2.1]}, index=list("ab"))
-        tm.assert_sp_frame_equal(res, exp)
+        with tm.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
+            sub_series = tm.SubclassedSeries()
+        assert "SubclassedSeries" in repr(sub_series)
diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py
index d0ca5d82c6b33..459377fb18f29 100644
--- a/pandas/tests/series/test_timeseries.py
+++ b/pandas/tests/series/test_timeseries.py
@@ -7,31 +7,21 @@
 
 from pandas._libs.tslib import iNaT
 from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
-from pandas.errors import NullFrequencyError
 import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
     DataFrame,
-    Index,
+    DatetimeIndex,
     NaT,
     Series,
     Timestamp,
     concat,
     date_range,
-    offsets,
     timedelta_range,
     to_datetime,
 )
-from pandas.core.indexes.datetimes import DatetimeIndex
-from pandas.core.indexes.timedeltas import TimedeltaIndex
-from pandas.tests.series.common import TestData
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
+import pandas._testing as tm
 
 from pandas.tseries.offsets import BDay, BMonthEnd
 
@@ -47,275 +37,7 @@ def assert_range_equal(left, right):
     assert left.tz == right.tz
 
 
-class TestTimeSeries(TestData):
-    def test_shift(self):
-        shifted = self.ts.shift(1)
-        unshifted = shifted.shift(-1)
-
-        tm.assert_index_equal(shifted.index, self.ts.index)
-        tm.assert_index_equal(unshifted.index, self.ts.index)
-        tm.assert_numpy_array_equal(unshifted.dropna().values, self.ts.values[:-1])
-
-        offset = BDay()
-        shifted = self.ts.shift(1, freq=offset)
-        unshifted = shifted.shift(-1, freq=offset)
-
-        assert_series_equal(unshifted, self.ts)
-
-        unshifted = self.ts.shift(0, freq=offset)
-        assert_series_equal(unshifted, self.ts)
-
-        shifted = self.ts.shift(1, freq="B")
-        unshifted = shifted.shift(-1, freq="B")
-
-        assert_series_equal(unshifted, self.ts)
-
-        # corner case
-        unshifted = self.ts.shift(0)
-        assert_series_equal(unshifted, self.ts)
-
-        # Shifting with PeriodIndex
-        ps = tm.makePeriodSeries()
-        shifted = ps.shift(1)
-        unshifted = shifted.shift(-1)
-        tm.assert_index_equal(shifted.index, ps.index)
-        tm.assert_index_equal(unshifted.index, ps.index)
-        tm.assert_numpy_array_equal(unshifted.dropna().values, ps.values[:-1])
-
-        shifted2 = ps.shift(1, "B")
-        shifted3 = ps.shift(1, BDay())
-        assert_series_equal(shifted2, shifted3)
-        assert_series_equal(ps, shifted2.shift(-1, "B"))
-
-        msg = "Given freq D does not match PeriodIndex freq B"
-        with pytest.raises(ValueError, match=msg):
-            ps.shift(freq="D")
-
-        # legacy support
-        shifted4 = ps.shift(1, freq="B")
-        assert_series_equal(shifted2, shifted4)
-
-        shifted5 = ps.shift(1, freq=BDay())
-        assert_series_equal(shifted5, shifted4)
-
-        # 32-bit taking
-        # GH 8129
-        index = date_range("2000-01-01", periods=5)
-        for dtype in ["int32", "int64"]:
-            s1 = Series(np.arange(5, dtype=dtype), index=index)
-            p = s1.iloc[1]
-            result = s1.shift(periods=p)
-            expected = Series([np.nan, 0, 1, 2, 3], index=index)
-            assert_series_equal(result, expected)
-
-        # xref 8260
-        # with tz
-        s = Series(
-            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
-        )
-        result = s - s.shift()
-
-        exp = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
-        assert_series_equal(result, exp)
-
-        # incompat tz
-        s2 = Series(date_range("2000-01-01 09:00:00", periods=5, tz="CET"), name="foo")
-        msg = "DatetimeArray subtraction must have the same timezones or no timezones"
-        with pytest.raises(TypeError, match=msg):
-            s - s2
-
-    def test_shift2(self):
-        ts = Series(
-            np.random.randn(5), index=date_range("1/1/2000", periods=5, freq="H")
-        )
-
-        result = ts.shift(1, freq="5T")
-        exp_index = ts.index.shift(1, freq="5T")
-        tm.assert_index_equal(result.index, exp_index)
-
-        # GH #1063, multiple of same base
-        result = ts.shift(1, freq="4H")
-        exp_index = ts.index + offsets.Hour(4)
-        tm.assert_index_equal(result.index, exp_index)
-
-        idx = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"])
-        msg = "Cannot shift with no freq"
-        with pytest.raises(NullFrequencyError, match=msg):
-            idx.shift(1)
-
-    def test_shift_fill_value(self):
-        # GH #24128
-        ts = Series(
-            [1.0, 2.0, 3.0, 4.0, 5.0], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-
-        exp = Series(
-            [0.0, 1.0, 2.0, 3.0, 4.0], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-        # check that fill value works
-        result = ts.shift(1, fill_value=0.0)
-        tm.assert_series_equal(result, exp)
-
-        exp = Series(
-            [0.0, 0.0, 1.0, 2.0, 3.0], index=date_range("1/1/2000", periods=5, freq="H")
-        )
-        result = ts.shift(2, fill_value=0.0)
-        tm.assert_series_equal(result, exp)
-
-        ts = pd.Series([1, 2, 3])
-        res = ts.shift(2, fill_value=0)
-        assert res.dtype == ts.dtype
-
-    def test_categorical_shift_fill_value(self):
-        ts = pd.Series(["a", "b", "c", "d"], dtype="category")
-        res = ts.shift(1, fill_value="a")
-        expected = pd.Series(
-            pd.Categorical(
-                ["a", "a", "b", "c"], categories=["a", "b", "c", "d"], ordered=False
-            )
-        )
-        tm.assert_equal(res, expected)
-
-        # check for incorrect fill_value
-        msg = "'fill_value=f' is not present in this Categorical's categories"
-        with pytest.raises(ValueError, match=msg):
-            ts.shift(1, fill_value="f")
-
-    def test_shift_dst(self):
-        # GH 13926
-        dates = date_range("2016-11-06", freq="H", periods=10, tz="US/Eastern")
-        s = Series(dates)
-
-        res = s.shift(0)
-        tm.assert_series_equal(res, s)
-        assert res.dtype == "datetime64[ns, US/Eastern]"
-
-        res = s.shift(1)
-        exp_vals = [NaT] + dates.astype(object).values.tolist()[:9]
-        exp = Series(exp_vals)
-        tm.assert_series_equal(res, exp)
-        assert res.dtype == "datetime64[ns, US/Eastern]"
-
-        res = s.shift(-2)
-        exp_vals = dates.astype(object).values.tolist()[2:] + [NaT, NaT]
-        exp = Series(exp_vals)
-        tm.assert_series_equal(res, exp)
-        assert res.dtype == "datetime64[ns, US/Eastern]"
-
-        for ex in [10, -10, 20, -20]:
-            res = s.shift(ex)
-            exp = Series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
-            tm.assert_series_equal(res, exp)
-            assert res.dtype == "datetime64[ns, US/Eastern]"
-
-    def test_tshift(self):
-        # PeriodIndex
-        ps = tm.makePeriodSeries()
-        shifted = ps.tshift(1)
-        unshifted = shifted.tshift(-1)
-
-        assert_series_equal(unshifted, ps)
-
-        shifted2 = ps.tshift(freq="B")
-        assert_series_equal(shifted, shifted2)
-
-        shifted3 = ps.tshift(freq=BDay())
-        assert_series_equal(shifted, shifted3)
-
-        msg = "Given freq M does not match PeriodIndex freq B"
-        with pytest.raises(ValueError, match=msg):
-            ps.tshift(freq="M")
-
-        # DatetimeIndex
-        shifted = self.ts.tshift(1)
-        unshifted = shifted.tshift(-1)
-
-        assert_series_equal(self.ts, unshifted)
-
-        shifted2 = self.ts.tshift(freq=self.ts.index.freq)
-        assert_series_equal(shifted, shifted2)
-
-        inferred_ts = Series(
-            self.ts.values, Index(np.asarray(self.ts.index)), name="ts"
-        )
-        shifted = inferred_ts.tshift(1)
-        unshifted = shifted.tshift(-1)
-        assert_series_equal(shifted, self.ts.tshift(1))
-        assert_series_equal(unshifted, inferred_ts)
-
-        no_freq = self.ts[[0, 5, 7]]
-        msg = "Freq was not given and was not set in the index"
-        with pytest.raises(ValueError, match=msg):
-            no_freq.tshift()
-
-    def test_truncate(self):
-        offset = BDay()
-
-        ts = self.ts[::3]
-
-        start, end = self.ts.index[3], self.ts.index[6]
-        start_missing, end_missing = self.ts.index[2], self.ts.index[7]
-
-        # neither specified
-        truncated = ts.truncate()
-        assert_series_equal(truncated, ts)
-
-        # both specified
-        expected = ts[1:3]
-
-        truncated = ts.truncate(start, end)
-        assert_series_equal(truncated, expected)
-
-        truncated = ts.truncate(start_missing, end_missing)
-        assert_series_equal(truncated, expected)
-
-        # start specified
-        expected = ts[1:]
-
-        truncated = ts.truncate(before=start)
-        assert_series_equal(truncated, expected)
-
-        truncated = ts.truncate(before=start_missing)
-        assert_series_equal(truncated, expected)
-
-        # end specified
-        expected = ts[:3]
-
-        truncated = ts.truncate(after=end)
-        assert_series_equal(truncated, expected)
-
-        truncated = ts.truncate(after=end_missing)
-        assert_series_equal(truncated, expected)
-
-        # corner case, empty series returned
-        truncated = ts.truncate(after=self.ts.index[0] - offset)
-        assert len(truncated) == 0
-
-        truncated = ts.truncate(before=self.ts.index[-1] + offset)
-        assert len(truncated) == 0
-
-        msg = "Truncate: 1999-12-31 00:00:00 must be after 2000-02-14 00:00:00"
-        with pytest.raises(ValueError, match=msg):
-            ts.truncate(
-                before=self.ts.index[-1] + offset, after=self.ts.index[0] - offset
-            )
-
-    def test_truncate_nonsortedindex(self):
-        # GH 17935
-
-        s = pd.Series(["a", "b", "c", "d", "e"], index=[5, 3, 2, 9, 0])
-        msg = "truncate requires a sorted index"
-
-        with pytest.raises(ValueError, match=msg):
-            s.truncate(before=3, after=9)
-
-        rng = pd.date_range("2011-01-01", "2012-01-01", freq="W")
-        ts = pd.Series(np.random.randn(len(rng)), index=rng)
-        msg = "truncate requires a sorted index"
-
-        with pytest.raises(ValueError, match=msg):
-            ts.sort_values(ascending=False).truncate(before="2011-11", after="2011-12")
-
+class TestTimeSeries:
     def test_asfreq(self):
         ts = Series(
             [0.0, 1.0, 2.0],
@@ -349,110 +71,20 @@ def test_asfreq(self):
 
     def test_asfreq_datetimeindex_empty_series(self):
         # GH 14320
-        expected = Series(index=pd.DatetimeIndex(["2016-09-29 11:00"])).asfreq("H")
-        result = Series(index=pd.DatetimeIndex(["2016-09-29 11:00"]), data=[3]).asfreq(
-            "H"
-        )
+        index = pd.DatetimeIndex(["2016-09-29 11:00"])
+        expected = Series(index=index, dtype=object).asfreq("H")
+        result = Series([3], index=index.copy()).asfreq("H")
         tm.assert_index_equal(expected.index, result.index)
 
-    def test_diff(self):
+    def test_autocorr(self, datetime_series):
         # Just run the function
-        self.ts.diff()
-
-        # int dtype
-        a = 10000000000000000
-        b = a + 1
-        s = Series([a, b])
-
-        rs = s.diff()
-        assert rs[1] == 1
-
-        # neg n
-        rs = self.ts.diff(-1)
-        xp = self.ts - self.ts.shift(-1)
-        assert_series_equal(rs, xp)
-
-        # 0
-        rs = self.ts.diff(0)
-        xp = self.ts - self.ts
-        assert_series_equal(rs, xp)
-
-        # datetime diff (GH3100)
-        s = Series(date_range("20130102", periods=5))
-        rs = s - s.shift(1)
-        xp = s.diff()
-        assert_series_equal(rs, xp)
-
-        # timedelta diff
-        nrs = rs - rs.shift(1)
-        nxp = xp.diff()
-        assert_series_equal(nrs, nxp)
-
-        # with tz
-        s = Series(
-            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
-        )
-        result = s.diff()
-        assert_series_equal(
-            result, Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
-        )
-
-    def test_pct_change(self):
-        rs = self.ts.pct_change(fill_method=None)
-        assert_series_equal(rs, self.ts / self.ts.shift(1) - 1)
-
-        rs = self.ts.pct_change(2)
-        filled = self.ts.fillna(method="pad")
-        assert_series_equal(rs, filled / filled.shift(2) - 1)
-
-        rs = self.ts.pct_change(fill_method="bfill", limit=1)
-        filled = self.ts.fillna(method="bfill", limit=1)
-        assert_series_equal(rs, filled / filled.shift(1) - 1)
-
-        rs = self.ts.pct_change(freq="5D")
-        filled = self.ts.fillna(method="pad")
-        assert_series_equal(
-            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
-        )
-
-    def test_pct_change_shift_over_nas(self):
-        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
-
-        chg = s.pct_change()
-        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
-        assert_series_equal(chg, expected)
-
-    @pytest.mark.parametrize(
-        "freq, periods, fill_method, limit",
-        [
-            ("5B", 5, None, None),
-            ("3B", 3, None, None),
-            ("3B", 3, "bfill", None),
-            ("7B", 7, "pad", 1),
-            ("7B", 7, "bfill", 3),
-            ("14B", 14, None, None),
-        ],
-    )
-    def test_pct_change_periods_freq(self, freq, periods, fill_method, limit):
-        # GH 7292
-        rs_freq = self.ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
-        rs_periods = self.ts.pct_change(periods, fill_method=fill_method, limit=limit)
-        assert_series_equal(rs_freq, rs_periods)
-
-        empty_ts = Series(index=self.ts.index)
-        rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
-        rs_periods = empty_ts.pct_change(periods, fill_method=fill_method, limit=limit)
-        assert_series_equal(rs_freq, rs_periods)
-
-    def test_autocorr(self):
-        # Just run the function
-        corr1 = self.ts.autocorr()
+        corr1 = datetime_series.autocorr()
 
         # Now run it with the lag parameter
-        corr2 = self.ts.autocorr(lag=1)
+        corr2 = datetime_series.autocorr(lag=1)
 
         # corr() with lag needs Series of at least length 2
-        if len(self.ts) <= 2:
+        if len(datetime_series) <= 2:
             assert np.isnan(corr1)
             assert np.isnan(corr2)
         else:
@@ -460,19 +92,19 @@ def test_autocorr(self):
 
         # Choose a random lag between 1 and length of Series - 2
         # and compare the result with the Series corr() function
-        n = 1 + np.random.randint(max(1, len(self.ts) - 2))
-        corr1 = self.ts.corr(self.ts.shift(n))
-        corr2 = self.ts.autocorr(lag=n)
+        n = 1 + np.random.randint(max(1, len(datetime_series) - 2))
+        corr1 = datetime_series.corr(datetime_series.shift(n))
+        corr2 = datetime_series.autocorr(lag=n)
 
         # corr() with lag needs Series of at least length 2
-        if len(self.ts) <= 2:
+        if len(datetime_series) <= 2:
             assert np.isnan(corr1)
             assert np.isnan(corr2)
         else:
             assert corr1 == corr2
 
-    def test_first_last_valid(self):
-        ts = self.ts.copy()
+    def test_first_last_valid(self, datetime_series):
+        ts = datetime_series.copy()
         ts[:5] = np.NaN
 
         index = ts.first_valid_index()
@@ -486,12 +118,12 @@ def test_first_last_valid(self):
         assert ts.last_valid_index() is None
         assert ts.first_valid_index() is None
 
-        ser = Series([], index=[])
+        ser = Series([], index=[], dtype=object)
         assert ser.last_valid_index() is None
         assert ser.first_valid_index() is None
 
         # GH12800
-        empty = Series()
+        empty = Series(dtype=object)
         assert empty.last_valid_index() is None
         assert empty.first_valid_index() is None
 
@@ -504,10 +136,17 @@ def test_first_last_valid(self):
         assert ts.first_valid_index().freq == ts.index.freq
         assert ts.last_valid_index().freq == ts.index.freq
 
-    def test_mpl_compat_hack(self):
-        result = self.ts[:, np.newaxis]
-        expected = self.ts.values[:, np.newaxis]
-        assert_almost_equal(result, expected)
+    def test_mpl_compat_hack(self, datetime_series):
+
+        # This is currently failing because the test was relying on
+        # the DeprecationWarning coming through Index.__getitem__.
+        # We want to implement a warning specifically for Series.__getitem__
+        # at which point this will become a Deprecation/FutureWarning
+        with tm.assert_produces_warning(None):
+            # GH#30588 multi-dimensional indexing deprecated
+            result = datetime_series[:, np.newaxis]
+        expected = datetime_series.values[:, np.newaxis]
+        tm.assert_almost_equal(result, expected)
 
     def test_timeseries_coercion(self):
         idx = tm.makeDateIndex(10000)
@@ -538,14 +177,14 @@ def test_to_datetime_unit(self):
         expected = Series(
             [Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([epoch + t for t in range(20)]).astype(float)
         result = to_datetime(s, unit="s")
         expected = Series(
             [Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([epoch + t for t in range(20)] + [iNaT])
         result = to_datetime(s, unit="s")
@@ -553,7 +192,7 @@ def test_to_datetime_unit(self):
             [Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)]
             + [NaT]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([epoch + t for t in range(20)] + [iNaT]).astype(float)
         result = to_datetime(s, unit="s")
@@ -561,7 +200,7 @@ def test_to_datetime_unit(self):
             [Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)]
             + [NaT]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # GH13834
         s = Series([epoch + t for t in np.arange(0, 2, 0.25)] + [iNaT]).astype(float)
@@ -573,7 +212,7 @@ def test_to_datetime_unit(self):
             ]
             + [NaT]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = concat(
             [Series([epoch + t for t in range(20)]).astype(float), Series([np.nan])],
@@ -584,7 +223,7 @@ def test_to_datetime_unit(self):
             [Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)]
             + [NaT]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = to_datetime([1, 2, "NaT", pd.NaT, np.nan], unit="D")
         expected = DatetimeIndex(
@@ -633,7 +272,7 @@ def test_asfreq_keep_index_name(self):
         # GH #9854
         index_name = "bar"
         index = pd.date_range("20130101", periods=20, name=index_name)
-        df = pd.DataFrame([x for x in range(20)], columns=["foo"], index=index)
+        df = pd.DataFrame(list(range(20)), columns=["foo"], index=index)
 
         assert index_name == df.index.name
         assert index_name == df.asfreq("10D").index.name
@@ -649,13 +288,13 @@ def test_promote_datetime_date(self):
         result = ts + ts2
         result2 = ts2 + ts
         expected = ts + ts[5:]
-        assert_series_equal(result, expected)
-        assert_series_equal(result2, expected)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result2, expected)
 
         # test asfreq
         result = ts2.asfreq("4H", method="ffill")
         expected = ts[5:].asfreq("4H", method="ffill")
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = rng.get_indexer(ts2.index)
         expected = rng.get_indexer(ts_slice.index)
@@ -671,7 +310,7 @@ def test_asfreq_normalize(self):
         norm = date_range("1/1/2000", periods=20)
         expected = Series(vals, index=norm)
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         vals = np.random.randn(20, 3)
         ts = DataFrame(vals, index=rng)
@@ -679,7 +318,7 @@ def test_asfreq_normalize(self):
         result = ts.asfreq("D", normalize=True)
         expected = DataFrame(vals, index=norm)
 
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_first_subset(self):
         ts = _simple_ts("1/1/2000", "1/1/2010", freq="12h")
@@ -692,14 +331,14 @@ def test_first_subset(self):
 
         result = ts.first("3M")
         expected = ts[:"3/31/2000"]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = ts.first("21D")
         expected = ts[:21]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = ts[:0].first("3M")
-        assert_series_equal(result, ts[:0])
+        tm.assert_series_equal(result, ts[:0])
 
     def test_first_raises(self):
         # GH20725
@@ -719,14 +358,14 @@ def test_last_subset(self):
 
         result = ts.last("21D")
         expected = ts["12/12/2009":]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = ts.last("21D")
         expected = ts[-21:]
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = ts[:0].last("3M")
-        assert_series_equal(result, ts[:0])
+        tm.assert_series_equal(result, ts[:0])
 
     def test_last_raises(self):
         # GH20725
@@ -751,7 +390,7 @@ def test_at_time(self):
 
         result = ts.at_time("9:30")
         expected = ts.at_time(time(9, 30))
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         df = DataFrame(np.random.randn(len(rng), 3), index=rng)
 
@@ -760,9 +399,10 @@ def test_at_time(self):
         expected = ts[(rng.hour == 9) & (rng.minute == 30)]
         exp_df = df[(rng.hour == 9) & (rng.minute == 30)]
 
+        # FIXME: dont leave commented-out
         # expected.index = date_range('1/1/2000', '1/4/2000')
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
         tm.assert_frame_equal(result_df, exp_df)
 
         chunk = df.loc["1/4/2000":]
@@ -775,7 +415,7 @@ def test_at_time(self):
         ts = Series(np.random.randn(len(rng)), index=rng)
 
         result = ts.at_time(time(0, 0))
-        assert_series_equal(result, ts)
+        tm.assert_series_equal(result, ts)
 
         # time doesn't exist
         rng = date_range("1/1/2012", freq="23Min", periods=384)
@@ -796,7 +436,7 @@ def test_between(self):
 
         result = series.between(left, right)
         expected = (series >= left) & (series <= right)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_between_time(self):
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
@@ -828,7 +468,7 @@ def test_between_time(self):
 
         result = ts.between_time("00:00", "01:00")
         expected = ts.between_time(stime, etime)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         # across midnight
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
@@ -868,10 +508,7 @@ def test_between_time_raises(self):
     def test_between_time_types(self):
         # GH11818
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")
-        msg = (
-            r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\]"
-            " to a time"
-        )
+        msg = r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\] to a time"
         with pytest.raises(ValueError, match=msg):
             rng.indexer_between_time(datetime(2010, 1, 2, 1), datetime(2010, 1, 2, 5))
 
@@ -925,12 +562,12 @@ def test_to_period(self):
         pts = ts.to_period()
         exp = ts.copy()
         exp.index = period_range("1/1/2000", "1/1/2001")
-        assert_series_equal(pts, exp)
+        tm.assert_series_equal(pts, exp)
 
         pts = ts.to_period("M")
         exp.index = exp.index.asfreq("M")
         tm.assert_index_equal(pts.index, exp.index.asfreq("M"))
-        assert_series_equal(pts, exp)
+        tm.assert_series_equal(pts, exp)
 
         # GH 7606 without freq
         idx = DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"])
@@ -941,16 +578,16 @@ def test_to_period(self):
         s = Series(np.random.randn(4), index=idx)
         expected = s.copy()
         expected.index = exp_idx
-        assert_series_equal(s.to_period(), expected)
+        tm.assert_series_equal(s.to_period(), expected)
 
         df = DataFrame(np.random.randn(4, 4), index=idx, columns=idx)
         expected = df.copy()
         expected.index = exp_idx
-        assert_frame_equal(df.to_period(), expected)
+        tm.assert_frame_equal(df.to_period(), expected)
 
         expected = df.copy()
         expected.columns = exp_idx
-        assert_frame_equal(df.to_period(axis=1), expected)
+        tm.assert_frame_equal(df.to_period(axis=1), expected)
 
     def test_groupby_count_dateparseerror(self):
         dr = date_range(start="1/1/2012", freq="5min", periods=10)
@@ -964,7 +601,7 @@ def test_groupby_count_dateparseerror(self):
         grouped = s.groupby(lambda x: x[0] % 2 == 0)
         expected = grouped.count()
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_to_csv_numpy_16_bug(self):
         frame = DataFrame({"a": date_range("1/1/2000", periods=10)})
@@ -1069,10 +706,6 @@ def test_from_M8_structured(self):
         assert isinstance(s[0], Timestamp)
         assert s[0] == dates[0][0]
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            s = Series.from_array(arr["Date"], Index([0]))
-            assert s[0] == dates[0][0]
-
     def test_get_level_values_box(self):
         from pandas import MultiIndex
 
@@ -1102,14 +735,12 @@ def test_asarray_tz_naive(self):
         # This shouldn't produce a warning.
         ser = pd.Series(pd.date_range("2000", periods=2))
         expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
-        with tm.assert_produces_warning(None):
-            result = np.asarray(ser)
+        result = np.asarray(ser)
 
         tm.assert_numpy_array_equal(result, expected)
 
         # optionally, object
-        with tm.assert_produces_warning(None):
-            result = np.asarray(ser, dtype=object)
+        result = np.asarray(ser, dtype=object)
 
         expected = np.array([pd.Timestamp("2000-01-01"), pd.Timestamp("2000-01-02")])
         tm.assert_numpy_array_equal(result, expected)
@@ -1118,15 +749,12 @@ def test_asarray_tz_aware(self):
         tz = "US/Central"
         ser = pd.Series(pd.date_range("2000", periods=2, tz=tz))
         expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]")
-        # We warn by default and return an ndarray[M8[ns]]
-        with tm.assert_produces_warning(FutureWarning):
-            result = np.asarray(ser)
+        result = np.asarray(ser, dtype="datetime64[ns]")
 
         tm.assert_numpy_array_equal(result, expected)
 
         # Old behavior with no warning
-        with tm.assert_produces_warning(None):
-            result = np.asarray(ser, dtype="M8[ns]")
+        result = np.asarray(ser, dtype="M8[ns]")
 
         tm.assert_numpy_array_equal(result, expected)
 
@@ -1134,7 +762,6 @@ def test_asarray_tz_aware(self):
         expected = np.array(
             [pd.Timestamp("2000-01-01", tz=tz), pd.Timestamp("2000-01-02", tz=tz)]
         )
-        with tm.assert_produces_warning(None):
-            result = np.asarray(ser, dtype=object)
+        result = np.asarray(ser, dtype=object)
 
         tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/series/test_timezones.py b/pandas/tests/series/test_timezones.py
index c16e2864b131f..a363f927d10a9 100644
--- a/pandas/tests/series/test_timezones.py
+++ b/pandas/tests/series/test_timezones.py
@@ -11,8 +11,8 @@
 from pandas._libs.tslibs import conversion, timezones
 
 from pandas import DatetimeIndex, Index, NaT, Series, Timestamp
+import pandas._testing as tm
 from pandas.core.indexes.datetimes import date_range
-import pandas.util.testing as tm
 
 
 class TestSeriesTimezones:
@@ -33,21 +33,6 @@ def test_series_tz_localize(self):
         with pytest.raises(TypeError, match="Already tz-aware"):
             ts.tz_localize("US/Eastern")
 
-    @pytest.mark.filterwarnings("ignore::FutureWarning")
-    def test_tz_localize_errors_deprecation(self):
-        # GH 22644
-        tz = "Europe/Warsaw"
-        n = 60
-        rng = date_range(start="2015-03-29 02:00:00", periods=n, freq="min")
-        ts = Series(rng)
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            with pytest.raises(ValueError):
-                ts.dt.tz_localize(tz, errors="foo")
-            # make sure errors='coerce' gets mapped correctly to nonexistent
-            result = ts.dt.tz_localize(tz, errors="coerce")
-            expected = ts.dt.tz_localize(tz, nonexistent="NaT")
-            tm.assert_series_equal(result, expected)
-
     def test_series_tz_localize_ambiguous_bool(self):
         # make sure that we are correctly accepting bool values as ambiguous
 
@@ -104,7 +89,7 @@ def test_series_tz_localize_nonexistent(self, tz, method, exp):
     @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
     def test_series_tz_localize_empty(self, tzstr):
         # GH#2248
-        ser = Series()
+        ser = Series(dtype=object)
 
         ser2 = ser.tz_localize("utc")
         assert ser2.index.tz == pytz.utc
diff --git a/pandas/tests/series/test_ufunc.py b/pandas/tests/series/test_ufunc.py
index 8144a3931b9b8..ece7f1f21ab23 100644
--- a/pandas/tests/series/test_ufunc.py
+++ b/pandas/tests/series/test_ufunc.py
@@ -5,7 +5,8 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.arrays import SparseArray
 
 UNARY_UFUNCS = [np.positive, np.floor, np.exp]
 BINARY_UFUNCS = [np.add, np.logaddexp]  # dunder op
@@ -33,7 +34,7 @@ def test_unary_ufunc(ufunc, sparse):
     array = np.random.randint(0, 10, 10, dtype="int64")
     array[::2] = 0
     if sparse:
-        array = pd.SparseArray(array, dtype=pd.SparseDtype("int64", 0))
+        array = SparseArray(array, dtype=pd.SparseDtype("int64", 0))
 
     index = list(string.ascii_letters[:10])
     name = "name"
@@ -51,8 +52,8 @@ def test_binary_ufunc_with_array(flip, sparse, ufunc, arrays_for_binary_ufunc):
     # Test that ufunc(Series(a), array) == Series(ufunc(a, b))
     a1, a2 = arrays_for_binary_ufunc
     if sparse:
-        a1 = pd.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
-        a2 = pd.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
 
     name = "name"  # op(Series, array) preserves the name.
     series = pd.Series(a1, name=name)
@@ -79,8 +80,8 @@ def test_binary_ufunc_with_index(flip, sparse, ufunc, arrays_for_binary_ufunc):
     #   * ufunc(Index, Series) dispatches to Series (returns a Series)
     a1, a2 = arrays_for_binary_ufunc
     if sparse:
-        a1 = pd.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
-        a2 = pd.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
 
     name = "name"  # op(Series, array) preserves the name.
     series = pd.Series(a1, name=name)
@@ -110,8 +111,8 @@ def test_binary_ufunc_with_series(
     #   with alignment between the indices
     a1, a2 = arrays_for_binary_ufunc
     if sparse:
-        a1 = pd.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
-        a2 = pd.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
 
     name = "name"  # op(Series, array) preserves the name.
     series = pd.Series(a1, name=name)
@@ -149,7 +150,7 @@ def test_binary_ufunc_scalar(ufunc, sparse, flip, arrays_for_binary_ufunc):
     #   * ufunc(Series, scalar) == ufunc(scalar, Series)
     array, _ = arrays_for_binary_ufunc
     if sparse:
-        array = pd.SparseArray(array)
+        array = SparseArray(array)
     other = 2
     series = pd.Series(array, name="name")
 
@@ -183,8 +184,8 @@ def test_multiple_ouput_binary_ufuncs(ufunc, sparse, shuffle, arrays_for_binary_
     a2[a2 == 0] = 1
 
     if sparse:
-        a1 = pd.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
-        a2 = pd.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
 
     s1 = pd.Series(a1)
     s2 = pd.Series(a2)
@@ -209,7 +210,7 @@ def test_multiple_ouput_ufunc(sparse, arrays_for_binary_ufunc):
     array, _ = arrays_for_binary_ufunc
 
     if sparse:
-        array = pd.SparseArray(array)
+        array = SparseArray(array)
 
     series = pd.Series(array, name="name")
     result = np.modf(series)
@@ -251,7 +252,7 @@ def __add__(self, other):
 @pytest.mark.parametrize(
     "values",
     [
-        pd.array([1, 3, 2]),
+        pd.array([1, 3, 2], dtype="int64"),
         pd.array([1, 10, 0], dtype="Sparse[int]"),
         pd.to_datetime(["2000", "2010", "2001"]),
         pd.to_datetime(["2000", "2010", "2001"]).tz_localize("CET"),
@@ -282,10 +283,10 @@ def __add__(self, other):
             other = getattr(other, "value", other)
             return type(self)(self.value + other)
 
-        def __eq__(self, other):
+        def __eq__(self, other) -> bool:
             return type(other) is Thing and self.value == other.value
 
-        def __repr__(self):
+        def __repr__(self) -> str:
             return "Thing({})".format(self.value)
 
     s = pd.Series([Thing(1), Thing(2)])
@@ -299,7 +300,5 @@ def test_outer():
     s = pd.Series([1, 2, 3])
     o = np.array([1, 2, 3])
 
-    with tm.assert_produces_warning(FutureWarning):
-        result = np.subtract.outer(s, o)
-    expected = np.array([[0, -1, -2], [1, 0, -1], [2, 1, 0]], dtype=np.dtype("int64"))
-    tm.assert_numpy_array_equal(result, expected)
+    with pytest.raises(NotImplementedError):
+        np.subtract.outer(s, o)
diff --git a/pandas/tests/sparse/frame/conftest.py b/pandas/tests/sparse/frame/conftest.py
deleted file mode 100644
index 989b58419c2cd..0000000000000
--- a/pandas/tests/sparse/frame/conftest.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import DataFrame, SparseArray, SparseDataFrame, bdate_range
-
-data = {
-    "A": [np.nan, np.nan, np.nan, 0, 1, 2, 3, 4, 5, 6],
-    "B": [0, 1, 2, np.nan, np.nan, np.nan, 3, 4, 5, 6],
-    "C": np.arange(10, dtype=np.float64),
-    "D": [0, 1, 2, 3, 4, 5, np.nan, np.nan, np.nan, np.nan],
-}
-dates = bdate_range("1/1/2011", periods=10)
-
-
-# fixture names must be compatible with the tests in
-# tests/frame/test_api.SharedWithSparse
-
-
-@pytest.fixture
-def float_frame_dense():
-    """
-    Fixture for dense DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; some entries are missing
-    """
-    return DataFrame(data, index=dates)
-
-
-@pytest.fixture
-def float_frame():
-    """
-    Fixture for sparse DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; some entries are missing
-    """
-    # default_kind='block' is the default
-    return SparseDataFrame(data, index=dates, default_kind="block")
-
-
-@pytest.fixture
-def float_frame_int_kind():
-    """
-    Fixture for sparse DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D'] and default_kind='integer'.
-    Some entries are missing.
-    """
-    return SparseDataFrame(data, index=dates, default_kind="integer")
-
-
-@pytest.fixture
-def float_string_frame():
-    """
-    Fixture for sparse DataFrame of floats and strings with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D', 'foo']; some entries are missing
-    """
-    sdf = SparseDataFrame(data, index=dates)
-    sdf["foo"] = SparseArray(["bar"] * len(dates))
-    return sdf
-
-
-@pytest.fixture
-def float_frame_fill0_dense():
-    """
-    Fixture for dense DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; missing entries have been filled with 0
-    """
-    values = SparseDataFrame(data).values
-    values[np.isnan(values)] = 0
-    return DataFrame(values, columns=["A", "B", "C", "D"], index=dates)
-
-
-@pytest.fixture
-def float_frame_fill0():
-    """
-    Fixture for sparse DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; missing entries have been filled with 0
-    """
-    values = SparseDataFrame(data).values
-    values[np.isnan(values)] = 0
-    return SparseDataFrame(
-        values, columns=["A", "B", "C", "D"], default_fill_value=0, index=dates
-    )
-
-
-@pytest.fixture
-def float_frame_fill2_dense():
-    """
-    Fixture for dense DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; missing entries have been filled with 2
-    """
-    values = SparseDataFrame(data).values
-    values[np.isnan(values)] = 2
-    return DataFrame(values, columns=["A", "B", "C", "D"], index=dates)
-
-
-@pytest.fixture
-def float_frame_fill2():
-    """
-    Fixture for sparse DataFrame of floats with DatetimeIndex
-
-    Columns are ['A', 'B', 'C', 'D']; missing entries have been filled with 2
-    """
-    values = SparseDataFrame(data).values
-    values[np.isnan(values)] = 2
-    return SparseDataFrame(
-        values, columns=["A", "B", "C", "D"], default_fill_value=2, index=dates
-    )
-
-
-@pytest.fixture
-def empty_frame():
-    """
-    Fixture for empty SparseDataFrame
-    """
-    return SparseDataFrame()
diff --git a/pandas/tests/sparse/frame/test_analytics.py b/pandas/tests/sparse/frame/test_analytics.py
deleted file mode 100644
index fae879b3d33b5..0000000000000
--- a/pandas/tests/sparse/frame/test_analytics.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import DataFrame, SparseDataFrame, SparseSeries
-from pandas.util import testing as tm
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_quantile():
-    # GH 17386
-    data = [[1, 1], [2, 10], [3, 100], [np.nan, np.nan]]
-    q = 0.1
-
-    sparse_df = SparseDataFrame(data)
-    result = sparse_df.quantile(q)
-
-    dense_df = DataFrame(data)
-    dense_expected = dense_df.quantile(q)
-    sparse_expected = SparseSeries(dense_expected)
-
-    tm.assert_series_equal(result, dense_expected)
-    tm.assert_sp_series_equal(result, sparse_expected)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_quantile_multi():
-    # GH 17386
-    data = [[1, 1], [2, 10], [3, 100], [np.nan, np.nan]]
-    q = [0.1, 0.5]
-
-    sparse_df = SparseDataFrame(data)
-    result = sparse_df.quantile(q)
-
-    dense_df = DataFrame(data)
-    dense_expected = dense_df.quantile(q)
-    sparse_expected = SparseDataFrame(dense_expected)
-
-    tm.assert_frame_equal(result, dense_expected)
-    tm.assert_sp_frame_equal(result, sparse_expected)
diff --git a/pandas/tests/sparse/frame/test_apply.py b/pandas/tests/sparse/frame/test_apply.py
deleted file mode 100644
index d8158db32d8f0..0000000000000
--- a/pandas/tests/sparse/frame/test_apply.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import DataFrame, Series, SparseDataFrame, bdate_range
-from pandas.core import nanops
-from pandas.core.sparse.api import SparseDtype
-from pandas.util import testing as tm
-
-
-@pytest.fixture
-def dates():
-    return bdate_range("1/1/2011", periods=10)
-
-
-@pytest.fixture
-def empty():
-    return SparseDataFrame()
-
-
-@pytest.fixture
-def frame(dates):
-    data = {
-        "A": [np.nan, np.nan, np.nan, 0, 1, 2, 3, 4, 5, 6],
-        "B": [0, 1, 2, np.nan, np.nan, np.nan, 3, 4, 5, 6],
-        "C": np.arange(10, dtype=np.float64),
-        "D": [0, 1, 2, 3, 4, 5, np.nan, np.nan, np.nan, np.nan],
-    }
-
-    return SparseDataFrame(data, index=dates)
-
-
-@pytest.fixture
-def fill_frame(frame):
-    values = frame.values.copy()
-    values[np.isnan(values)] = 2
-
-    return SparseDataFrame(
-        values, columns=["A", "B", "C", "D"], default_fill_value=2, index=frame.index
-    )
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-def test_apply(frame):
-    applied = frame.apply(np.sqrt)
-    assert isinstance(applied, SparseDataFrame)
-    tm.assert_almost_equal(applied.values, np.sqrt(frame.values))
-
-    # agg / broadcast
-    # two FutureWarnings, so we can't check stacklevel properly.
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        broadcasted = frame.apply(np.sum, broadcast=True)
-    assert isinstance(broadcasted, SparseDataFrame)
-
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        exp = frame.to_dense().apply(np.sum, broadcast=True)
-    tm.assert_frame_equal(broadcasted.to_dense(), exp)
-
-    applied = frame.apply(np.sum)
-    tm.assert_series_equal(applied, frame.to_dense().apply(nanops.nansum).to_sparse())
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_apply_fill(fill_frame):
-    applied = fill_frame.apply(np.sqrt)
-    assert applied["A"].fill_value == np.sqrt(2)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_apply_empty(empty):
-    assert empty.apply(np.sqrt) is empty
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-def test_apply_nonuq():
-    orig = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=["a", "a", "c"])
-    sparse = orig.to_sparse()
-    res = sparse.apply(lambda s: s[0], axis=1)
-    exp = orig.apply(lambda s: s[0], axis=1)
-
-    # dtype must be kept
-    assert res.dtype == SparseDtype(np.int64)
-
-    # ToDo: apply must return subclassed dtype
-    assert isinstance(res, Series)
-    tm.assert_series_equal(res.to_dense(), exp)
-
-    # df.T breaks
-    sparse = orig.T.to_sparse()
-    res = sparse.apply(lambda s: s[0], axis=0)  # noqa
-    exp = orig.T.apply(lambda s: s[0], axis=0)
-
-    # TODO: no non-unique columns supported in sparse yet
-    # tm.assert_series_equal(res.to_dense(), exp)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_applymap(frame):
-    # just test that it works
-    result = frame.applymap(lambda x: x * 2)
-    assert isinstance(result, SparseDataFrame)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_apply_keep_sparse_dtype():
-    # GH 23744
-    sdf = SparseDataFrame(
-        np.array([[0, 1, 0], [0, 0, 0], [0, 0, 1]]),
-        columns=["b", "a", "c"],
-        default_fill_value=1,
-    )
-    df = DataFrame(sdf)
-
-    expected = sdf.apply(np.exp)
-    result = df.apply(np.exp)
-    tm.assert_frame_equal(expected, result)
diff --git a/pandas/tests/sparse/frame/test_frame.py b/pandas/tests/sparse/frame/test_frame.py
deleted file mode 100644
index e372e2563e682..0000000000000
--- a/pandas/tests/sparse/frame/test_frame.py
+++ /dev/null
@@ -1,1596 +0,0 @@
-import operator
-from types import LambdaType
-
-import numpy as np
-from numpy import nan
-import pytest
-
-from pandas._libs.sparse import BlockIndex, IntIndex
-from pandas.errors import PerformanceWarning
-
-import pandas as pd
-from pandas import DataFrame, Series, bdate_range, compat
-from pandas.core import ops
-from pandas.core.indexes.datetimes import DatetimeIndex
-from pandas.core.sparse import frame as spf
-from pandas.core.sparse.api import (
-    SparseArray,
-    SparseDataFrame,
-    SparseDtype,
-    SparseSeries,
-)
-from pandas.tests.frame.test_api import SharedWithSparse
-from pandas.util import testing as tm
-
-from pandas.tseries.offsets import BDay
-
-
-def test_deprecated():
-    with tm.assert_produces_warning(FutureWarning):
-        pd.SparseDataFrame({"A": [1, 2]})
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrame(SharedWithSparse):
-    klass = SparseDataFrame
-
-    # SharedWithSparse tests use generic, klass-agnostic assertion
-    _assert_frame_equal = staticmethod(tm.assert_sp_frame_equal)
-    _assert_series_equal = staticmethod(tm.assert_sp_series_equal)
-
-    def test_iterrows(self, float_frame, float_string_frame):
-        # Same as parent, but we don't ensure the sparse kind is the same.
-        for k, v in float_frame.iterrows():
-            exp = float_frame.loc[k]
-            tm.assert_sp_series_equal(v, exp, check_kind=False)
-
-        for k, v in float_string_frame.iterrows():
-            exp = float_string_frame.loc[k]
-            tm.assert_sp_series_equal(v, exp, check_kind=False)
-
-    def test_itertuples(self, float_frame):
-        for i, tup in enumerate(float_frame.itertuples()):
-            s = self.klass._constructor_sliced(tup[1:])
-            s.name = tup[0]
-            expected = float_frame.iloc[i, :].reset_index(drop=True)
-            tm.assert_sp_series_equal(s, expected, check_kind=False)
-
-    def test_fill_value_when_combine_const(self):
-        # GH12723
-        dat = np.array([0, 1, np.nan, 3, 4, 5], dtype="float")
-        df = SparseDataFrame({"foo": dat}, index=range(6))
-
-        exp = df.fillna(0).add(2)
-        res = df.add(2, fill_value=0)
-        tm.assert_sp_frame_equal(res, exp)
-
-    def test_values(self, empty_frame, float_frame):
-        empty = empty_frame.values
-        assert empty.shape == (0, 0)
-
-        no_cols = SparseDataFrame(index=np.arange(10))
-        mat = no_cols.values
-        assert mat.shape == (10, 0)
-
-        no_index = SparseDataFrame(columns=np.arange(10))
-        mat = no_index.values
-        assert mat.shape == (0, 10)
-
-    def test_copy(self, float_frame):
-        cp = float_frame.copy()
-        assert isinstance(cp, SparseDataFrame)
-        tm.assert_sp_frame_equal(cp, float_frame)
-
-        # as of v0.15.0
-        # this is now identical (but not is_a )
-        assert cp.index.identical(float_frame.index)
-
-    def test_constructor(self, float_frame, float_frame_int_kind, float_frame_fill0):
-        for col, series in float_frame.items():
-            assert isinstance(series, SparseSeries)
-
-        assert isinstance(float_frame_int_kind["A"].sp_index, IntIndex)
-
-        # constructed zframe from matrix above
-        assert float_frame_fill0["A"].fill_value == 0
-        # XXX: changed asarray
-        expected = pd.SparseArray(
-            [0, 0, 0, 0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], fill_value=0, kind="block"
-        )
-        tm.assert_sp_array_equal(expected, float_frame_fill0["A"].values)
-        tm.assert_numpy_array_equal(
-            np.array([0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0]),
-            float_frame_fill0["A"].to_dense().values,
-        )
-
-        # construct no data
-        sdf = SparseDataFrame(columns=np.arange(10), index=np.arange(10))
-        for col, series in sdf.items():
-            assert isinstance(series, SparseSeries)
-
-        # construct from nested dict
-        data = {c: s.to_dict() for c, s in float_frame.items()}
-
-        sdf = SparseDataFrame(data)
-        tm.assert_sp_frame_equal(sdf, float_frame)
-
-        # TODO: test data is copied from inputs
-
-        # init dict with different index
-        idx = float_frame.index[:5]
-        cons = SparseDataFrame(
-            float_frame,
-            index=idx,
-            columns=float_frame.columns,
-            default_fill_value=float_frame.default_fill_value,
-            default_kind=float_frame.default_kind,
-            copy=True,
-        )
-        reindexed = float_frame.reindex(idx)
-
-        tm.assert_sp_frame_equal(cons, reindexed, exact_indices=False)
-
-        # assert level parameter breaks reindex
-        with pytest.raises(TypeError):
-            float_frame.reindex(idx, level=0)
-
-        repr(float_frame)
-
-    def test_constructor_fill_value_not_scalar_raises(self):
-        d = {"b": [2, 3], "a": [0, 1]}
-        fill_value = np.array(np.nan)
-        with pytest.raises(ValueError, match="must be a scalar"):
-            SparseDataFrame(data=d, default_fill_value=fill_value)
-
-    def test_constructor_dict_order(self):
-        # GH19018
-        # initialization ordering: by insertion order if python>= 3.6, else
-        # order by value
-        d = {"b": [2, 3], "a": [0, 1]}
-        frame = SparseDataFrame(data=d)
-        if compat.PY36:
-            expected = SparseDataFrame(data=d, columns=list("ba"))
-        else:
-            expected = SparseDataFrame(data=d, columns=list("ab"))
-        tm.assert_sp_frame_equal(frame, expected)
-
-    def test_constructor_ndarray(self, float_frame):
-        # no index or columns
-        sp = SparseDataFrame(float_frame.values)
-
-        # 1d
-        sp = SparseDataFrame(
-            float_frame["A"].values, index=float_frame.index, columns=["A"]
-        )
-        tm.assert_sp_frame_equal(sp, float_frame.reindex(columns=["A"]))
-
-        # raise on level argument
-        msg = "Reindex by level not supported for sparse"
-        with pytest.raises(TypeError, match=msg):
-            float_frame.reindex(columns=["A"], level=1)
-
-        # wrong length index / columns
-        with pytest.raises(ValueError, match="^Index length"):
-            SparseDataFrame(float_frame.values, index=float_frame.index[:-1])
-
-        with pytest.raises(ValueError, match="^Column length"):
-            SparseDataFrame(float_frame.values, columns=float_frame.columns[:-1])
-
-    # GH 9272
-    def test_constructor_empty(self):
-        sp = SparseDataFrame()
-        assert len(sp.index) == 0
-        assert len(sp.columns) == 0
-
-    def test_constructor_dataframe(self, float_frame):
-        dense = float_frame.to_dense()
-        sp = SparseDataFrame(dense)
-        tm.assert_sp_frame_equal(sp, float_frame)
-
-    def test_constructor_convert_index_once(self):
-        arr = np.array([1.5, 2.5, 3.5])
-        sdf = SparseDataFrame(columns=range(4), index=arr)
-        assert sdf[0].index is sdf[1].index
-
-    def test_constructor_from_series(self):
-
-        # GH 2873
-        x = Series(np.random.randn(10000), name="a")
-        x = x.to_sparse(fill_value=0)
-        assert isinstance(x, SparseSeries)
-        df = SparseDataFrame(x)
-        assert isinstance(df, SparseDataFrame)
-
-        x = Series(np.random.randn(10000), name="a")
-        y = Series(np.random.randn(10000), name="b")
-        x2 = x.astype(float)
-        x2.loc[:9998] = np.NaN
-        # TODO: x_sparse is unused...fix
-        x_sparse = x2.to_sparse(fill_value=np.NaN)  # noqa
-
-        # Currently fails too with weird ufunc error
-        # df1 = SparseDataFrame([x_sparse, y])
-
-        y.loc[:9998] = 0
-        # TODO: y_sparse is unsused...fix
-        y_sparse = y.to_sparse(fill_value=0)  # noqa
-        # without sparse value raises error
-        # df2 = SparseDataFrame([x2_sparse, y])
-
-    def test_constructor_from_dense_series(self):
-        # GH 19393
-        # series with name
-        x = Series(np.random.randn(10000), name="a")
-        result = SparseDataFrame(x)
-        expected = x.to_frame().to_sparse()
-        tm.assert_sp_frame_equal(result, expected)
-
-        # series with no name
-        x = Series(np.random.randn(10000))
-        result = SparseDataFrame(x)
-        expected = x.to_frame().to_sparse()
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_constructor_from_unknown_type(self):
-        # GH 19393
-        class Unknown:
-            pass
-
-        with pytest.raises(
-            TypeError,
-            match=(
-                "SparseDataFrame called with unknown type "
-                '"Unknown" for data argument'
-            ),
-        ):
-            SparseDataFrame(Unknown())
-
-    def test_constructor_preserve_attr(self):
-        # GH 13866
-        arr = pd.SparseArray([1, 0, 3, 0], dtype=np.int64, fill_value=0)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        df = pd.SparseDataFrame({"x": arr})
-        assert df["x"].dtype == SparseDtype(np.int64)
-        assert df["x"].fill_value == 0
-
-        s = pd.SparseSeries(arr, name="x")
-        assert s.dtype == SparseDtype(np.int64)
-        assert s.fill_value == 0
-
-        df = pd.SparseDataFrame(s)
-        assert df["x"].dtype == SparseDtype(np.int64)
-        assert df["x"].fill_value == 0
-
-        df = pd.SparseDataFrame({"x": s})
-        assert df["x"].dtype == SparseDtype(np.int64)
-        assert df["x"].fill_value == 0
-
-    def test_constructor_nan_dataframe(self):
-        # GH 10079
-        trains = np.arange(100)
-        thresholds = [10, 20, 30, 40, 50, 60]
-        tuples = [(i, j) for i in trains for j in thresholds]
-        index = pd.MultiIndex.from_tuples(tuples, names=["trains", "thresholds"])
-        matrix = np.empty((len(index), len(trains)))
-        matrix.fill(np.nan)
-        df = pd.DataFrame(matrix, index=index, columns=trains, dtype=float)
-        result = df.to_sparse()
-        expected = pd.SparseDataFrame(matrix, index=index, columns=trains, dtype=float)
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_type_coercion_at_construction(self):
-        # GH 15682
-        result = pd.SparseDataFrame(
-            {"a": [1, 0, 0], "b": [0, 1, 0], "c": [0, 0, 1]},
-            dtype="uint8",
-            default_fill_value=0,
-        )
-        expected = pd.SparseDataFrame(
-            {
-                "a": pd.SparseSeries([1, 0, 0], dtype="uint8"),
-                "b": pd.SparseSeries([0, 1, 0], dtype="uint8"),
-                "c": pd.SparseSeries([0, 0, 1], dtype="uint8"),
-            },
-            default_fill_value=0,
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_default_dtype(self):
-        result = pd.SparseDataFrame(columns=list("ab"), index=range(2))
-        expected = pd.SparseDataFrame(
-            [[np.nan, np.nan], [np.nan, np.nan]], columns=list("ab"), index=range(2)
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_nan_data_with_int_dtype_raises_error(self):
-        sdf = pd.SparseDataFrame(
-            [[np.nan, np.nan], [np.nan, np.nan]], columns=list("ab"), index=range(2)
-        )
-        msg = "Cannot convert non-finite values"
-        with pytest.raises(ValueError, match=msg):
-            pd.SparseDataFrame(sdf, dtype=np.int64)
-
-    def test_dtypes(self):
-        df = DataFrame(np.random.randn(10000, 4))
-        df.loc[:9998] = np.nan
-        sdf = df.to_sparse()
-        result = sdf.dtypes
-        expected = Series(["Sparse[float64, nan]"] * 4)
-        tm.assert_series_equal(result, expected)
-
-    def test_shape(
-        self, float_frame, float_frame_int_kind, float_frame_fill0, float_frame_fill2
-    ):
-        # see gh-10452
-        assert float_frame.shape == (10, 4)
-        assert float_frame_int_kind.shape == (10, 4)
-        assert float_frame_fill0.shape == (10, 4)
-        assert float_frame_fill2.shape == (10, 4)
-
-    def test_str(self):
-        df = DataFrame(np.random.randn(10000, 4))
-        df.loc[:9998] = np.nan
-
-        sdf = df.to_sparse()
-        str(sdf)
-
-    def test_array_interface(self, float_frame):
-        res = np.sqrt(float_frame)
-        dres = np.sqrt(float_frame.to_dense())
-        tm.assert_frame_equal(res.to_dense(), dres)
-
-    def test_pickle(
-        self,
-        float_frame,
-        float_frame_int_kind,
-        float_frame_dense,
-        float_frame_fill0,
-        float_frame_fill0_dense,
-        float_frame_fill2,
-        float_frame_fill2_dense,
-    ):
-        def _test_roundtrip(frame, orig):
-            result = tm.round_trip_pickle(frame)
-            tm.assert_sp_frame_equal(frame, result)
-            tm.assert_frame_equal(result.to_dense(), orig, check_dtype=False)
-
-        _test_roundtrip(SparseDataFrame(), DataFrame())
-        _test_roundtrip(float_frame, float_frame_dense)
-        _test_roundtrip(float_frame_int_kind, float_frame_dense)
-        _test_roundtrip(float_frame_fill0, float_frame_fill0_dense)
-        _test_roundtrip(float_frame_fill2, float_frame_fill2_dense)
-
-    def test_dense_to_sparse(self):
-        df = DataFrame({"A": [nan, nan, nan, 1, 2], "B": [1, 2, nan, nan, nan]})
-        sdf = df.to_sparse()
-        assert isinstance(sdf, SparseDataFrame)
-        assert np.isnan(sdf.default_fill_value)
-        assert isinstance(sdf["A"].sp_index, BlockIndex)
-        tm.assert_frame_equal(sdf.to_dense(), df)
-
-        sdf = df.to_sparse(kind="integer")
-        assert isinstance(sdf["A"].sp_index, IntIndex)
-
-        df = DataFrame({"A": [0, 0, 0, 1, 2], "B": [1, 2, 0, 0, 0]}, dtype=float)
-        sdf = df.to_sparse(fill_value=0)
-        assert sdf.default_fill_value == 0
-        tm.assert_frame_equal(sdf.to_dense(), df)
-
-    def test_deprecated_dense_to_sparse(self):
-        # GH 26557
-        # Deprecated 0.25.0
-
-        df = pd.DataFrame({"A": [1, np.nan, 3]})
-        sparse_df = pd.SparseDataFrame({"A": [1, np.nan, 3]})
-
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            result = df.to_sparse()
-        tm.assert_frame_equal(result, sparse_df)
-
-    def test_density(self):
-        df = SparseSeries([nan, nan, nan, 0, 1, 2, 3, 4, 5, 6])
-        assert df.density == 0.7
-
-        df = SparseDataFrame(
-            {
-                "A": [nan, nan, nan, 0, 1, 2, 3, 4, 5, 6],
-                "B": [0, 1, 2, nan, nan, nan, 3, 4, 5, 6],
-                "C": np.arange(10),
-                "D": [0, 1, 2, 3, 4, 5, nan, nan, nan, nan],
-            }
-        )
-
-        assert df.density == 0.75
-
-    def test_sparse_to_dense(self):
-        pass
-
-    def test_sparse_series_ops(self, float_frame):
-        self._check_frame_ops(float_frame)
-
-    def test_sparse_series_ops_i(self, float_frame_int_kind):
-        self._check_frame_ops(float_frame_int_kind)
-
-    def test_sparse_series_ops_z(self, float_frame_fill0):
-        self._check_frame_ops(float_frame_fill0)
-
-    def test_sparse_series_ops_fill(self, float_frame_fill2):
-        self._check_frame_ops(float_frame_fill2)
-
-    def _check_frame_ops(self, frame):
-        def _compare_to_dense(a, b, da, db, op):
-            sparse_result = op(a, b)
-            dense_result = op(da, db)
-
-            # catch lambdas but not non-lambdas e.g. operator.add
-            if op in [operator.floordiv, ops.rfloordiv] or isinstance(op, LambdaType):
-                # GH#27231 Series sets 1//0 to np.inf, which SparseArray
-                #  does not do (yet)
-                mask = np.isinf(dense_result) & ~np.isinf(sparse_result.to_dense())
-                dense_result[mask] = np.nan
-
-            fill = sparse_result.default_fill_value
-            dense_result = dense_result.to_sparse(fill_value=fill)
-            tm.assert_sp_frame_equal(sparse_result, dense_result, exact_indices=False)
-
-            if isinstance(a, DataFrame) and isinstance(db, DataFrame):
-                mixed_result = op(a, db)
-                assert isinstance(mixed_result, SparseDataFrame)
-                tm.assert_sp_frame_equal(
-                    mixed_result, sparse_result, exact_indices=False
-                )
-
-        opnames = ["add", "sub", "mul", "truediv", "floordiv"]
-
-        fidx = frame.index
-
-        # time series operations
-
-        series = [
-            frame["A"],
-            frame["B"],
-            frame["C"],
-            frame["D"],
-            frame["A"].reindex(fidx[:7]),
-            frame["A"].reindex(fidx[::2]),
-            SparseSeries([], index=[]),
-        ]
-
-        for op in opnames:
-            _compare_to_dense(
-                frame,
-                frame[::2],
-                frame.to_dense(),
-                frame[::2].to_dense(),
-                getattr(operator, op),
-            )
-
-            # 2304, no auto-broadcasting
-            for i, s in enumerate(series):
-                f = lambda a, b: getattr(a, op)(b, axis="index")
-                _compare_to_dense(frame, s, frame.to_dense(), s.to_dense(), f)
-
-                # FIXME: dont leave commented-out
-                # rops are not implemented
-                # _compare_to_dense(s, frame, s.to_dense(),
-                #                   frame.to_dense(), f)
-
-                # cross-sectional operations
-        series = [
-            frame.xs(fidx[0]),
-            frame.xs(fidx[3]),
-            frame.xs(fidx[5]),
-            frame.xs(fidx[7]),
-            frame.xs(fidx[5])[:2],
-        ]
-
-        for name in opnames:
-            op = getattr(operator, name)
-            for s in series:
-                _compare_to_dense(frame, s, frame.to_dense(), s, op)
-                _compare_to_dense(s, frame, s, frame.to_dense(), op)
-
-        # it works!
-        frame + frame.loc[:, ["A", "B"]]
-
-    def test_op_corners(self, float_frame, empty_frame):
-        empty = empty_frame + empty_frame
-        assert empty.empty
-
-        foo = float_frame + empty_frame
-        assert isinstance(foo.index, DatetimeIndex)
-        tm.assert_frame_equal(foo, float_frame * np.nan)
-
-        foo = empty_frame + float_frame
-        tm.assert_frame_equal(foo, float_frame * np.nan)
-
-    def test_scalar_ops(self):
-        pass
-
-    def test_getitem(self):
-        # 1585 select multiple columns
-        sdf = SparseDataFrame(index=[0, 1, 2], columns=["a", "b", "c"])
-
-        result = sdf[["a", "b"]]
-        exp = sdf.reindex(columns=["a", "b"])
-        tm.assert_sp_frame_equal(result, exp)
-
-        with pytest.raises(KeyError, match=r"\['d'\] not in index"):
-            sdf[["a", "d"]]
-
-    def test_iloc(self, float_frame):
-
-        # GH 2227
-        result = float_frame.iloc[:, 0]
-        assert isinstance(result, SparseSeries)
-        tm.assert_sp_series_equal(result, float_frame["A"])
-
-        # preserve sparse index type. #2251
-        data = {"A": [0, 1]}
-        iframe = SparseDataFrame(data, default_kind="integer")
-        tm.assert_class_equal(iframe["A"].sp_index, iframe.iloc[:, 0].sp_index)
-
-    def test_set_value(self, float_frame):
-
-        # ok, as the index gets converted to object
-        frame = float_frame.copy()
-        res = frame._set_value("foobar", "B", 1.5)
-        assert res.index.dtype == "object"
-
-        res = float_frame
-        res.index = res.index.astype(object)
-
-        res = float_frame._set_value("foobar", "B", 1.5)
-        assert res is not float_frame
-        assert res.index[-1] == "foobar"
-        assert res._get_value("foobar", "B") == 1.5
-
-        res2 = res._set_value("foobar", "qux", 1.5)
-        assert res2 is not res
-        tm.assert_index_equal(
-            res2.columns, pd.Index(list(float_frame.columns) + ["qux"])
-        )
-        assert res2._get_value("foobar", "qux") == 1.5
-
-    def test_fancy_index_misc(self, float_frame):
-        # axis = 0
-        sliced = float_frame.iloc[-2:, :]
-        expected = float_frame.reindex(index=float_frame.index[-2:])
-        tm.assert_sp_frame_equal(sliced, expected)
-
-        # axis = 1
-        sliced = float_frame.iloc[:, -2:]
-        expected = float_frame.reindex(columns=float_frame.columns[-2:])
-        tm.assert_sp_frame_equal(sliced, expected)
-
-    def test_getitem_overload(self, float_frame):
-        # slicing
-        sl = float_frame[:20]
-        tm.assert_sp_frame_equal(sl, float_frame.reindex(float_frame.index[:20]))
-
-        # boolean indexing
-        d = float_frame.index[5]
-        indexer = float_frame.index > d
-
-        subindex = float_frame.index[indexer]
-        subframe = float_frame[indexer]
-
-        tm.assert_index_equal(subindex, subframe.index)
-        msg = "Item wrong length 9 instead of 10"
-        with pytest.raises(ValueError, match=msg):
-            float_frame[indexer[:-1]]
-
-    def test_setitem(
-        self,
-        float_frame,
-        float_frame_int_kind,
-        float_frame_dense,
-        float_frame_fill0,
-        float_frame_fill0_dense,
-        float_frame_fill2,
-        float_frame_fill2_dense,
-    ):
-        def _check_frame(frame, orig):
-            N = len(frame)
-
-            # insert SparseSeries
-            frame["E"] = frame["A"]
-            assert isinstance(frame["E"], SparseSeries)
-            tm.assert_sp_series_equal(frame["E"], frame["A"], check_names=False)
-
-            # insert SparseSeries differently-indexed
-            to_insert = frame["A"][::2]
-            frame["E"] = to_insert
-            expected = to_insert.to_dense().reindex(frame.index)
-            result = frame["E"].to_dense()
-            tm.assert_series_equal(result, expected, check_names=False)
-            assert result.name == "E"
-
-            # insert Series
-            frame["F"] = frame["A"].to_dense()
-            assert isinstance(frame["F"], SparseSeries)
-            tm.assert_sp_series_equal(frame["F"], frame["A"], check_names=False)
-
-            # insert Series differently-indexed
-            to_insert = frame["A"].to_dense()[::2]
-            frame["G"] = to_insert
-            expected = to_insert.reindex(frame.index)
-            expected.name = "G"
-            tm.assert_series_equal(frame["G"].to_dense(), expected)
-
-            # insert ndarray
-            frame["H"] = np.random.randn(N)
-            assert isinstance(frame["H"], SparseSeries)
-
-            to_sparsify = np.random.randn(N)
-            to_sparsify[N // 2 :] = frame.default_fill_value
-            frame["I"] = to_sparsify
-            assert len(frame["I"].sp_values) == N // 2
-
-            # insert ndarray wrong size
-            # GH 25484
-            msg = "Length of values does not match length of index"
-            with pytest.raises(ValueError, match=msg):
-                frame["foo"] = np.random.randn(N - 1)
-
-            # scalar value
-            frame["J"] = 5
-            assert len(frame["J"].sp_values) == N
-            assert (frame["J"].sp_values == 5).all()
-
-            frame["K"] = frame.default_fill_value
-            assert len(frame["K"].sp_values) == 0
-
-        _check_frame(float_frame, float_frame_dense)
-        _check_frame(float_frame_int_kind, float_frame_dense)
-        _check_frame(float_frame_fill0, float_frame_fill0_dense)
-        _check_frame(float_frame_fill2, float_frame_fill2_dense)
-
-    @pytest.mark.parametrize(
-        "values",
-        [
-            [True, False],
-            [0, 1],
-            [1, None],
-            ["a", "b"],
-            [pd.Timestamp("2017"), pd.NaT],
-            [pd.Timedelta("10s"), pd.NaT],
-        ],
-    )
-    def test_setitem_more(self, values):
-        df = pd.DataFrame({"A": values})
-        df["A"] = pd.SparseArray(values)
-        expected = pd.DataFrame({"A": pd.SparseArray(values)})
-        tm.assert_frame_equal(df, expected)
-
-    def test_setitem_corner(self, float_frame):
-        float_frame["a"] = float_frame["B"]
-        tm.assert_sp_series_equal(float_frame["a"], float_frame["B"], check_names=False)
-
-    def test_setitem_array(self, float_frame):
-        arr = float_frame["B"]
-
-        float_frame["E"] = arr
-        tm.assert_sp_series_equal(float_frame["E"], float_frame["B"], check_names=False)
-
-        float_frame["F"] = arr[:-1]
-        index = float_frame.index[:-1]
-        tm.assert_sp_series_equal(
-            float_frame["E"].reindex(index),
-            float_frame["F"].reindex(index),
-            check_names=False,
-        )
-
-    def test_setitem_chained_no_consolidate(self):
-        # https://github.com/pandas-dev/pandas/pull/19268
-        # issuecomment-361696418
-        # chained setitem used to cause consolidation
-        sdf = pd.SparseDataFrame([[np.nan, 1], [2, np.nan]])
-        with pd.option_context("mode.chained_assignment", None):
-            sdf[0][1] = 2
-        assert len(sdf._data.blocks) == 2
-
-    def test_delitem(self, float_frame):
-        A = float_frame["A"]
-        C = float_frame["C"]
-
-        del float_frame["B"]
-        assert "B" not in float_frame
-        tm.assert_sp_series_equal(float_frame["A"], A)
-        tm.assert_sp_series_equal(float_frame["C"], C)
-
-        del float_frame["D"]
-        assert "D" not in float_frame
-
-        del float_frame["A"]
-        assert "A" not in float_frame
-
-    def test_set_columns(self, float_frame):
-        float_frame.columns = float_frame.columns
-        msg = (
-            "Length mismatch: Expected axis has 4 elements, new values have"
-            " 3 elements"
-        )
-        with pytest.raises(ValueError, match=msg):
-            float_frame.columns = float_frame.columns[:-1]
-
-    def test_set_index(self, float_frame):
-        float_frame.index = float_frame.index
-        msg = (
-            "Length mismatch: Expected axis has 10 elements, new values"
-            " have 9 elements"
-        )
-        with pytest.raises(ValueError, match=msg):
-            float_frame.index = float_frame.index[:-1]
-
-    def test_ctor_reindex(self):
-        idx = pd.Index([0, 1, 2, 3])
-        msg = "Length of passed values is 2, index implies 4"
-        with pytest.raises(ValueError, match=msg):
-            pd.SparseDataFrame({"A": [1, 2]}, index=idx)
-
-    def test_append(self, float_frame):
-        a = float_frame[:5]
-        b = float_frame[5:]
-
-        appended = a.append(b)
-        tm.assert_sp_frame_equal(appended, float_frame, exact_indices=False)
-
-        a = float_frame.iloc[:5, :3]
-        b = float_frame.iloc[5:]
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
-            # Stacklevel is set for pd.concat, not append
-            appended = a.append(b)
-        tm.assert_sp_frame_equal(
-            appended.iloc[:, :3], float_frame.iloc[:, :3], exact_indices=False
-        )
-
-        a = a[["B", "C", "A"]].head(2)
-        b = b.head(2)
-
-        expected = pd.SparseDataFrame(
-            {
-                "B": [0.0, 1, None, 3],
-                "C": [0.0, 1, 5, 6],
-                "A": [None, None, 2, 3],
-                "D": [None, None, 5, None],
-            },
-            index=a.index | b.index,
-            columns=["B", "C", "A", "D"],
-        )
-        with tm.assert_produces_warning(None, raise_on_extra_warnings=False):
-            appended = a.append(b, sort=False)
-
-        tm.assert_frame_equal(appended, expected)
-
-        with tm.assert_produces_warning(None, raise_on_extra_warnings=False):
-            appended = a.append(b, sort=True)
-
-        tm.assert_sp_frame_equal(
-            appended,
-            expected[["A", "B", "C", "D"]],
-            consolidate_block_indices=True,
-            check_kind=False,
-        )
-
-    def test_astype(self):
-        sparse = pd.SparseDataFrame(
-            {
-                "A": SparseArray([1, 2, 3, 4], dtype=np.int64),
-                "B": SparseArray([4, 5, 6, 7], dtype=np.int64),
-            }
-        )
-        assert sparse["A"].dtype == SparseDtype(np.int64)
-        assert sparse["B"].dtype == SparseDtype(np.int64)
-
-        # retain fill_value
-        res = sparse.astype(np.float64)
-        exp = pd.SparseDataFrame(
-            {
-                "A": SparseArray([1.0, 2.0, 3.0, 4.0], fill_value=0, kind="integer"),
-                "B": SparseArray([4.0, 5.0, 6.0, 7.0], fill_value=0, kind="integer"),
-            },
-            default_fill_value=np.nan,
-        )
-        tm.assert_sp_frame_equal(res, exp)
-        assert res["A"].dtype == SparseDtype(np.float64, 0)
-        assert res["B"].dtype == SparseDtype(np.float64, 0)
-
-        # update fill_value
-        res = sparse.astype(SparseDtype(np.float64, np.nan))
-        exp = pd.SparseDataFrame(
-            {
-                "A": SparseArray(
-                    [1.0, 2.0, 3.0, 4.0], fill_value=np.nan, kind="integer"
-                ),
-                "B": SparseArray(
-                    [4.0, 5.0, 6.0, 7.0], fill_value=np.nan, kind="integer"
-                ),
-            },
-            default_fill_value=np.nan,
-        )
-        tm.assert_sp_frame_equal(res, exp)
-        assert res["A"].dtype == SparseDtype(np.float64, np.nan)
-        assert res["B"].dtype == SparseDtype(np.float64, np.nan)
-
-    def test_astype_bool(self):
-        sparse = pd.SparseDataFrame(
-            {
-                "A": SparseArray([0, 2, 0, 4], fill_value=0, dtype=np.int64),
-                "B": SparseArray([0, 5, 0, 7], fill_value=0, dtype=np.int64),
-            },
-            default_fill_value=0,
-        )
-        assert sparse["A"].dtype == SparseDtype(np.int64)
-        assert sparse["B"].dtype == SparseDtype(np.int64)
-
-        res = sparse.astype(SparseDtype(bool, False))
-        exp = pd.SparseDataFrame(
-            {
-                "A": SparseArray(
-                    [False, True, False, True],
-                    dtype=np.bool,
-                    fill_value=False,
-                    kind="integer",
-                ),
-                "B": SparseArray(
-                    [False, True, False, True],
-                    dtype=np.bool,
-                    fill_value=False,
-                    kind="integer",
-                ),
-            },
-            default_fill_value=False,
-        )
-        tm.assert_sp_frame_equal(res, exp)
-        assert res["A"].dtype == SparseDtype(np.bool)
-        assert res["B"].dtype == SparseDtype(np.bool)
-
-    def test_astype_object(self):
-        # This may change in GH-23125
-        df = pd.DataFrame({"A": SparseArray([0, 1]), "B": SparseArray([0, 1])})
-        result = df.astype(object)
-        dtype = SparseDtype(object, 0)
-        expected = pd.DataFrame(
-            {
-                "A": SparseArray([0, 1], dtype=dtype),
-                "B": SparseArray([0, 1], dtype=dtype),
-            }
-        )
-        tm.assert_frame_equal(result, expected)
-
-    def test_fillna(self, float_frame_fill0, float_frame_fill0_dense):
-        df = float_frame_fill0.reindex(list(range(5)))
-        dense = float_frame_fill0_dense.reindex(list(range(5)))
-
-        result = df.fillna(0)
-        expected = dense.fillna(0)
-        tm.assert_sp_frame_equal(
-            result, expected.to_sparse(fill_value=0), exact_indices=False
-        )
-        tm.assert_frame_equal(result.to_dense(), expected)
-
-        result = df.copy()
-        result.fillna(0, inplace=True)
-        expected = dense.fillna(0)
-
-        tm.assert_sp_frame_equal(
-            result, expected.to_sparse(fill_value=0), exact_indices=False
-        )
-        tm.assert_frame_equal(result.to_dense(), expected)
-
-        result = df.copy()
-        result = df["A"]
-        result.fillna(0, inplace=True)
-
-        expected = dense["A"].fillna(0)
-        # this changes internal SparseArray repr
-        # tm.assert_sp_series_equal(result, expected.to_sparse(fill_value=0))
-        tm.assert_series_equal(result.to_dense(), expected)
-
-    def test_fillna_fill_value(self):
-        df = pd.DataFrame({"A": [1, 0, 0], "B": [np.nan, np.nan, 4]})
-
-        sparse = pd.SparseDataFrame(df)
-        tm.assert_frame_equal(
-            sparse.fillna(-1).to_dense(), df.fillna(-1), check_dtype=False
-        )
-
-        sparse = pd.SparseDataFrame(df, default_fill_value=0)
-        tm.assert_frame_equal(
-            sparse.fillna(-1).to_dense(), df.fillna(-1), check_dtype=False
-        )
-
-    def test_sparse_frame_pad_backfill_limit(self):
-        index = np.arange(10)
-        df = DataFrame(np.random.randn(10, 4), index=index)
-        sdf = df.to_sparse()
-
-        result = sdf[:2].reindex(index, method="pad", limit=5)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = sdf[:2].reindex(index).fillna(method="pad")
-        expected = expected.to_dense()
-        expected.values[-3:] = np.nan
-        expected = expected.to_sparse()
-        tm.assert_frame_equal(result, expected)
-
-        result = sdf[-2:].reindex(index, method="backfill", limit=5)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = sdf[-2:].reindex(index).fillna(method="backfill")
-        expected = expected.to_dense()
-        expected.values[:3] = np.nan
-        expected = expected.to_sparse()
-        tm.assert_frame_equal(result, expected)
-
-    def test_sparse_frame_fillna_limit(self):
-        index = np.arange(10)
-        df = DataFrame(np.random.randn(10, 4), index=index)
-        sdf = df.to_sparse()
-
-        result = sdf[:2].reindex(index)
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            result = result.fillna(method="pad", limit=5)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = sdf[:2].reindex(index).fillna(method="pad")
-        expected = expected.to_dense()
-        expected.values[-3:] = np.nan
-        expected = expected.to_sparse()
-        tm.assert_frame_equal(result, expected)
-
-        result = sdf[-2:].reindex(index)
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            result = result.fillna(method="backfill", limit=5)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            expected = sdf[-2:].reindex(index).fillna(method="backfill")
-        expected = expected.to_dense()
-        expected.values[:3] = np.nan
-        expected = expected.to_sparse()
-        tm.assert_frame_equal(result, expected)
-
-    def test_rename(self, float_frame):
-        result = float_frame.rename(index=str)
-        expected = SparseDataFrame(
-            float_frame.values,
-            index=float_frame.index.strftime("%Y-%m-%d %H:%M:%S"),
-            columns=list("ABCD"),
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-        result = float_frame.rename(columns="{}1".format)
-        data = {
-            "A1": [nan, nan, nan, 0, 1, 2, 3, 4, 5, 6],
-            "B1": [0, 1, 2, nan, nan, nan, 3, 4, 5, 6],
-            "C1": np.arange(10, dtype=np.float64),
-            "D1": [0, 1, 2, 3, 4, 5, nan, nan, nan, nan],
-        }
-        expected = SparseDataFrame(data, index=float_frame.index)
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_corr(self, float_frame):
-        res = float_frame.corr()
-        # XXX: this stays sparse
-        tm.assert_frame_equal(res, float_frame.to_dense().corr().to_sparse())
-
-    def test_describe(self, float_frame):
-        float_frame["foo"] = np.nan
-        float_frame.dtypes.value_counts()
-        str(float_frame)
-        desc = float_frame.describe()  # noqa
-
-    def test_join(self, float_frame):
-        left = float_frame.loc[:, ["A", "B"]]
-        right = float_frame.loc[:, ["C", "D"]]
-        joined = left.join(right)
-        tm.assert_sp_frame_equal(joined, float_frame, exact_indices=False)
-
-        right = float_frame.loc[:, ["B", "D"]]
-        msg = (
-            r"columns overlap but no suffix specified: Index\(\['B'\],"
-            r" dtype='object'\)"
-        )
-        with pytest.raises(ValueError, match=msg):
-            left.join(right)
-
-        with pytest.raises(ValueError, match="Other Series must have a name"):
-            float_frame.join(
-                Series(np.random.randn(len(float_frame)), index=float_frame.index)
-            )
-
-    def test_reindex(
-        self, float_frame, float_frame_int_kind, float_frame_fill0, float_frame_fill2
-    ):
-        def _check_frame(frame):
-            index = frame.index
-            sidx = index[::2]
-            sidx2 = index[:5]  # noqa
-
-            sparse_result = frame.reindex(sidx)
-            dense_result = frame.to_dense().reindex(sidx)
-            tm.assert_frame_equal(sparse_result.to_dense(), dense_result)
-
-            tm.assert_frame_equal(frame.reindex(list(sidx)).to_dense(), dense_result)
-
-            sparse_result2 = sparse_result.reindex(index)
-            dense_result2 = dense_result.reindex(index)
-            tm.assert_frame_equal(sparse_result2.to_dense(), dense_result2)
-
-            # propagate CORRECT fill value
-            tm.assert_almost_equal(
-                sparse_result.default_fill_value, frame.default_fill_value
-            )
-            tm.assert_almost_equal(sparse_result["A"].fill_value, frame["A"].fill_value)
-
-            # length zero
-            length_zero = frame.reindex([])
-            assert len(length_zero) == 0
-            assert len(length_zero.columns) == len(frame.columns)
-            assert len(length_zero["A"]) == 0
-
-            # frame being reindexed has length zero
-            length_n = length_zero.reindex(index)
-            assert len(length_n) == len(frame)
-            assert len(length_n.columns) == len(frame.columns)
-            assert len(length_n["A"]) == len(frame)
-
-            # reindex columns
-            reindexed = frame.reindex(columns=["A", "B", "Z"])
-            assert len(reindexed.columns) == 3
-            tm.assert_almost_equal(reindexed["Z"].fill_value, frame.default_fill_value)
-            assert np.isnan(reindexed["Z"].sp_values).all()
-
-        _check_frame(float_frame)
-        _check_frame(float_frame_int_kind)
-        _check_frame(float_frame_fill0)
-        _check_frame(float_frame_fill2)
-
-        # with copy=False
-        reindexed = float_frame.reindex(float_frame.index, copy=False)
-        reindexed["F"] = reindexed["A"]
-        assert "F" in float_frame
-
-        reindexed = float_frame.reindex(float_frame.index)
-        reindexed["G"] = reindexed["A"]
-        assert "G" not in float_frame
-
-    def test_reindex_fill_value(self, float_frame_fill0, float_frame_fill0_dense):
-        rng = bdate_range("20110110", periods=20)
-
-        result = float_frame_fill0.reindex(rng, fill_value=0)
-        exp = float_frame_fill0_dense.reindex(rng, fill_value=0)
-        exp = exp.to_sparse(float_frame_fill0.default_fill_value)
-        tm.assert_sp_frame_equal(result, exp)
-
-    def test_reindex_method(self):
-
-        sparse = SparseDataFrame(
-            data=[[11.0, 12.0, 14.0], [21.0, 22.0, 24.0], [41.0, 42.0, 44.0]],
-            index=[1, 2, 4],
-            columns=[1, 2, 4],
-            dtype=float,
-        )
-
-        # Over indices
-
-        # default method
-        result = sparse.reindex(index=range(6))
-        expected = SparseDataFrame(
-            data=[
-                [nan, nan, nan],
-                [11.0, 12.0, 14.0],
-                [21.0, 22.0, 24.0],
-                [nan, nan, nan],
-                [41.0, 42.0, 44.0],
-                [nan, nan, nan],
-            ],
-            index=range(6),
-            columns=[1, 2, 4],
-            dtype=float,
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-        # method='bfill'
-        result = sparse.reindex(index=range(6), method="bfill")
-        expected = SparseDataFrame(
-            data=[
-                [11.0, 12.0, 14.0],
-                [11.0, 12.0, 14.0],
-                [21.0, 22.0, 24.0],
-                [41.0, 42.0, 44.0],
-                [41.0, 42.0, 44.0],
-                [nan, nan, nan],
-            ],
-            index=range(6),
-            columns=[1, 2, 4],
-            dtype=float,
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-        # method='ffill'
-        result = sparse.reindex(index=range(6), method="ffill")
-        expected = SparseDataFrame(
-            data=[
-                [nan, nan, nan],
-                [11.0, 12.0, 14.0],
-                [21.0, 22.0, 24.0],
-                [21.0, 22.0, 24.0],
-                [41.0, 42.0, 44.0],
-                [41.0, 42.0, 44.0],
-            ],
-            index=range(6),
-            columns=[1, 2, 4],
-            dtype=float,
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-        # Over columns
-
-        # default method
-        result = sparse.reindex(columns=range(6))
-        expected = SparseDataFrame(
-            data=[
-                [nan, 11.0, 12.0, nan, 14.0, nan],
-                [nan, 21.0, 22.0, nan, 24.0, nan],
-                [nan, 41.0, 42.0, nan, 44.0, nan],
-            ],
-            index=[1, 2, 4],
-            columns=range(6),
-            dtype=float,
-        )
-        tm.assert_sp_frame_equal(result, expected)
-
-        # method='bfill'
-        with pytest.raises(NotImplementedError):
-            sparse.reindex(columns=range(6), method="bfill")
-
-        # method='ffill'
-        with pytest.raises(NotImplementedError):
-            sparse.reindex(columns=range(6), method="ffill")
-
-    def test_take(self, float_frame):
-        result = float_frame.take([1, 0, 2], axis=1)
-        expected = float_frame.reindex(columns=["B", "A", "C"])
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_to_dense(
-        self,
-        float_frame,
-        float_frame_int_kind,
-        float_frame_dense,
-        float_frame_fill0,
-        float_frame_fill0_dense,
-        float_frame_fill2,
-        float_frame_fill2_dense,
-    ):
-        def _check(frame, orig):
-            dense_dm = frame.to_dense()
-            # Sparse[float] != float
-            tm.assert_frame_equal(frame, dense_dm, check_dtype=False)
-            tm.assert_frame_equal(dense_dm, orig, check_dtype=False)
-
-        _check(float_frame, float_frame_dense)
-        _check(float_frame_int_kind, float_frame_dense)
-        _check(float_frame_fill0, float_frame_fill0_dense)
-        _check(float_frame_fill2, float_frame_fill2_dense)
-
-    def test_stack_sparse_frame(
-        self, float_frame, float_frame_int_kind, float_frame_fill0, float_frame_fill2
-    ):
-        def _check(frame):
-            dense_frame = frame.to_dense()  # noqa
-
-            from_dense_lp = frame.stack().to_frame()
-
-            from_sparse_lp = spf.stack_sparse_frame(frame)
-
-            tm.assert_numpy_array_equal(from_dense_lp.values, from_sparse_lp.values)
-
-        _check(float_frame)
-        _check(float_frame_int_kind)
-
-        # for now
-        msg = "This routine assumes NaN fill value"
-        with pytest.raises(TypeError, match=msg):
-            _check(float_frame_fill0)
-        with pytest.raises(TypeError, match=msg):
-            _check(float_frame_fill2)
-
-    def test_transpose(
-        self,
-        float_frame,
-        float_frame_int_kind,
-        float_frame_dense,
-        float_frame_fill0,
-        float_frame_fill0_dense,
-        float_frame_fill2,
-        float_frame_fill2_dense,
-    ):
-        def _check(frame, orig):
-            transposed = frame.T
-            untransposed = transposed.T
-            tm.assert_sp_frame_equal(frame, untransposed)
-
-            tm.assert_frame_equal(frame.T.to_dense(), orig.T)
-            tm.assert_frame_equal(frame.T.T.to_dense(), orig.T.T)
-            tm.assert_sp_frame_equal(frame, frame.T.T, exact_indices=False)
-
-        _check(float_frame, float_frame_dense)
-        _check(float_frame_int_kind, float_frame_dense)
-        _check(float_frame_fill0, float_frame_fill0_dense)
-        _check(float_frame_fill2, float_frame_fill2_dense)
-
-    def test_shift(
-        self,
-        float_frame,
-        float_frame_int_kind,
-        float_frame_dense,
-        float_frame_fill0,
-        float_frame_fill0_dense,
-        float_frame_fill2,
-        float_frame_fill2_dense,
-    ):
-        def _check(frame, orig):
-            shifted = frame.shift(0)
-            exp = orig.shift(0)
-            tm.assert_frame_equal(shifted.to_dense(), exp)
-
-            shifted = frame.shift(1)
-            exp = orig.shift(1)
-            tm.assert_frame_equal(shifted.to_dense(), exp)
-
-            shifted = frame.shift(-2)
-            exp = orig.shift(-2)
-            tm.assert_frame_equal(shifted.to_dense(), exp)
-
-            shifted = frame.shift(2, freq="B")
-            exp = orig.shift(2, freq="B")
-            exp = exp.to_sparse(frame.default_fill_value, kind=frame.default_kind)
-            tm.assert_frame_equal(shifted, exp)
-
-            shifted = frame.shift(2, freq=BDay())
-            exp = orig.shift(2, freq=BDay())
-            exp = exp.to_sparse(frame.default_fill_value, kind=frame.default_kind)
-            tm.assert_frame_equal(shifted, exp)
-
-        _check(float_frame, float_frame_dense)
-        _check(float_frame_int_kind, float_frame_dense)
-        _check(float_frame_fill0, float_frame_fill0_dense)
-        _check(float_frame_fill2, float_frame_fill2_dense)
-
-    def test_count(self, float_frame):
-        dense_result = float_frame.to_dense().count()
-
-        result = float_frame.count()
-        tm.assert_series_equal(result.to_dense(), dense_result)
-
-        result = float_frame.count(axis=None)
-        tm.assert_series_equal(result.to_dense(), dense_result)
-
-        result = float_frame.count(axis=0)
-        tm.assert_series_equal(result.to_dense(), dense_result)
-
-        result = float_frame.count(axis=1)
-        dense_result = float_frame.to_dense().count(axis=1)
-
-        # win32 don't check dtype
-        tm.assert_series_equal(result, dense_result, check_dtype=False)
-
-    def test_numpy_transpose(self):
-        sdf = SparseDataFrame([1, 2, 3], index=[1, 2, 3], columns=["a"])
-        result = np.transpose(np.transpose(sdf))
-        tm.assert_sp_frame_equal(result, sdf)
-
-        msg = "the 'axes' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.transpose(sdf, axes=1)
-
-    def test_combine_first(self, float_frame):
-        df = float_frame
-
-        result = df[::2].combine_first(df)
-
-        expected = df[::2].to_dense().combine_first(df.to_dense())
-        expected = expected.to_sparse(fill_value=df.default_fill_value)
-
-        tm.assert_sp_frame_equal(result, expected)
-
-    @pytest.mark.xfail(reason="No longer supported.")
-    def test_combine_first_with_dense(self):
-        # We could support this if we allow
-        # pd.core.dtypes.cast.find_common_type to special case SparseDtype
-        # but I don't think that's worth it.
-        df = self.frame
-
-        result = df[::2].combine_first(df.to_dense())
-        expected = df[::2].to_dense().combine_first(df.to_dense())
-        expected = expected.to_sparse(fill_value=df.default_fill_value)
-
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_combine_add(self, float_frame):
-        df = float_frame.to_dense()
-        df2 = df.copy()
-        df2["C"][:3] = np.nan
-        df["A"][:3] = 5.7
-
-        result = df.to_sparse().add(df2.to_sparse(), fill_value=0)
-        expected = df.add(df2, fill_value=0).to_sparse()
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_isin(self):
-        sparse_df = DataFrame({"flag": [1.0, 0.0, 1.0]}).to_sparse(fill_value=0.0)
-        xp = sparse_df[sparse_df.flag == 1.0]
-        rs = sparse_df[sparse_df.flag.isin([1.0])]
-        tm.assert_frame_equal(xp, rs)
-
-    def test_sparse_pow_issue(self):
-        # 2220
-        df = SparseDataFrame({"A": [1.1, 3.3], "B": [2.5, -3.9]})
-
-        # note : no error without nan
-        df = SparseDataFrame({"A": [nan, 0, 1]})
-
-        # note that 2 ** df works fine, also df ** 1
-        result = 1 ** df
-
-        r1 = result.take([0], 1)["A"]
-        r2 = result["A"]
-
-        assert len(r2.sp_values) == len(r1.sp_values)
-
-    def test_as_blocks(self):
-        df = SparseDataFrame({"A": [1.1, 3.3], "B": [nan, -3.9]}, dtype="float64")
-
-        # deprecated 0.21.0
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            df_blocks = df.blocks
-        assert list(df_blocks.keys()) == ["Sparse[float64, nan]"]
-        tm.assert_frame_equal(df_blocks["Sparse[float64, nan]"], df)
-
-    @pytest.mark.xfail(reason="nan column names in _init_dict problematic (GH#16894)")
-    def test_nan_columnname(self):
-        # GH 8822
-        nan_colname = DataFrame(Series(1.0, index=[0]), columns=[nan])
-        nan_colname_sparse = nan_colname.to_sparse()
-        assert np.isnan(nan_colname_sparse.columns[0])
-
-    def test_isna(self):
-        # GH 8276
-        df = pd.SparseDataFrame(
-            {"A": [np.nan, np.nan, 1, 2, np.nan], "B": [0, np.nan, np.nan, 2, np.nan]}
-        )
-
-        res = df.isna()
-        exp = pd.SparseDataFrame(
-            {
-                "A": [True, True, False, False, True],
-                "B": [False, True, True, False, True],
-            },
-            default_fill_value=True,
-        )
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp)
-
-        # if fill_value is not nan, True can be included in sp_values
-        df = pd.SparseDataFrame(
-            {"A": [0, 0, 1, 2, np.nan], "B": [0, np.nan, 0, 2, np.nan]},
-            default_fill_value=0.0,
-        )
-        res = df.isna()
-        assert isinstance(res, pd.SparseDataFrame)
-        exp = pd.DataFrame(
-            {
-                "A": [False, False, False, False, True],
-                "B": [False, True, False, False, True],
-            }
-        )
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    def test_notna(self):
-        # GH 8276
-        df = pd.SparseDataFrame(
-            {"A": [np.nan, np.nan, 1, 2, np.nan], "B": [0, np.nan, np.nan, 2, np.nan]}
-        )
-
-        res = df.notna()
-        exp = pd.SparseDataFrame(
-            {
-                "A": [False, False, True, True, False],
-                "B": [True, False, False, True, False],
-            },
-            default_fill_value=False,
-        )
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp)
-
-        # if fill_value is not nan, True can be included in sp_values
-        df = pd.SparseDataFrame(
-            {"A": [0, 0, 1, 2, np.nan], "B": [0, np.nan, 0, 2, np.nan]},
-            default_fill_value=0.0,
-        )
-        res = df.notna()
-        assert isinstance(res, pd.SparseDataFrame)
-        exp = pd.DataFrame(
-            {
-                "A": [True, True, True, True, False],
-                "B": [True, False, True, True, False],
-            }
-        )
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    def test_default_fill_value_with_no_data(self):
-        # GH 16807
-        expected = pd.SparseDataFrame(
-            [[1.0, 1.0], [1.0, 1.0]], columns=list("ab"), index=range(2)
-        )
-        result = pd.SparseDataFrame(
-            columns=list("ab"), index=range(2), default_fill_value=1.0
-        )
-        tm.assert_frame_equal(expected, result)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrameArithmetic:
-    def test_numeric_op_scalar(self):
-        df = pd.DataFrame(
-            {
-                "A": [nan, nan, 0, 1],
-                "B": [0, 1, 2, nan],
-                "C": [1.0, 2.0, 3.0, 4.0],
-                "D": [nan, nan, nan, nan],
-            }
-        )
-        sparse = df.to_sparse()
-
-        tm.assert_sp_frame_equal(sparse + 1, (df + 1).to_sparse())
-
-    def test_comparison_op_scalar(self):
-        # GH 13001
-        df = pd.DataFrame(
-            {
-                "A": [nan, nan, 0, 1],
-                "B": [0, 1, 2, nan],
-                "C": [1.0, 2.0, 3.0, 4.0],
-                "D": [nan, nan, nan, nan],
-            }
-        )
-        sparse = df.to_sparse()
-
-        # comparison changes internal repr, compare with dense
-        res = sparse > 1
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), df > 1)
-
-        res = sparse != 0
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), df != 0)
-
-    def test_add_series_retains_dtype(self):
-        # SparseDataFrame._combine_match_columns used to incorrectly cast
-        #  to float
-        d = {0: [2j, 3j], 1: [0, 1]}
-        sdf = SparseDataFrame(data=d, default_fill_value=1)
-        result = sdf + sdf[0]
-
-        df = sdf.to_dense()
-        expected = df + df[0]
-        tm.assert_frame_equal(result.to_dense(), expected)
-
-        # Make it explicit to be on the safe side
-        edata = {0: [4j, 5j], 1: [3j, 1 + 3j]}
-        expected = DataFrame(edata)
-        tm.assert_frame_equal(result.to_dense(), expected)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrameAnalytics:
-    def test_cumsum(self, float_frame):
-        expected = SparseDataFrame(float_frame.to_dense().cumsum())
-
-        result = float_frame.cumsum()
-        tm.assert_sp_frame_equal(result, expected)
-
-        result = float_frame.cumsum(axis=None)
-        tm.assert_sp_frame_equal(result, expected)
-
-        result = float_frame.cumsum(axis=0)
-        tm.assert_sp_frame_equal(result, expected)
-
-    def test_numpy_cumsum(self, float_frame):
-        result = np.cumsum(float_frame)
-        expected = SparseDataFrame(float_frame.to_dense().cumsum())
-        tm.assert_sp_frame_equal(result, expected)
-
-        msg = "the 'dtype' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.cumsum(float_frame, dtype=np.int64)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.cumsum(float_frame, out=result)
-
-    def test_numpy_func_call(self, float_frame):
-        # no exception should be raised even though
-        # numpy passes in 'axis=None' or `axis=-1'
-        funcs = ["sum", "cumsum", "var", "mean", "prod", "cumprod", "std", "min", "max"]
-        for func in funcs:
-            getattr(np, func)(float_frame)
-
-    @pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH 17386)")
-    def test_quantile(self):
-        # GH 17386
-        data = [[1, 1], [2, 10], [3, 100], [nan, nan]]
-        q = 0.1
-
-        sparse_df = SparseDataFrame(data)
-        result = sparse_df.quantile(q)
-
-        dense_df = DataFrame(data)
-        dense_expected = dense_df.quantile(q)
-        sparse_expected = SparseSeries(dense_expected)
-
-        tm.assert_series_equal(result, dense_expected)
-        tm.assert_sp_series_equal(result, sparse_expected)
-
-    @pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH 17386)")
-    def test_quantile_multi(self):
-        # GH 17386
-        data = [[1, 1], [2, 10], [3, 100], [nan, nan]]
-        q = [0.1, 0.5]
-
-        sparse_df = SparseDataFrame(data)
-        result = sparse_df.quantile(q)
-
-        dense_df = DataFrame(data)
-        dense_expected = dense_df.quantile(q)
-        sparse_expected = SparseDataFrame(dense_expected)
-
-        tm.assert_frame_equal(result, dense_expected)
-        tm.assert_sp_frame_equal(result, sparse_expected)
-
-    def test_assign_with_sparse_frame(self):
-        # GH 19163
-        df = pd.DataFrame({"a": [1, 2, 3]})
-        res = df.to_sparse(fill_value=False).assign(newcol=False)
-        exp = df.assign(newcol=False).to_sparse(fill_value=False)
-
-        tm.assert_sp_frame_equal(res, exp)
-
-        for column in res.columns:
-            assert type(res[column]) is SparseSeries
-
-    @pytest.mark.parametrize("inplace", [True, False])
-    @pytest.mark.parametrize("how", ["all", "any"])
-    def test_dropna(self, inplace, how):
-        # Tests regression #21172.
-        expected = pd.SparseDataFrame({"F2": [0, 1]})
-        input_df = pd.SparseDataFrame(
-            {"F1": [float("nan"), float("nan")], "F2": [0, 1]}
-        )
-        result_df = input_df.dropna(axis=1, inplace=inplace, how=how)
-        if inplace:
-            result_df = input_df
-        tm.assert_sp_frame_equal(expected, result_df)
diff --git a/pandas/tests/sparse/frame/test_indexing.py b/pandas/tests/sparse/frame/test_indexing.py
deleted file mode 100644
index c93e9d1e0e8d1..0000000000000
--- a/pandas/tests/sparse/frame/test_indexing.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import DataFrame, SparseDataFrame
-from pandas.util import testing as tm
-
-pytestmark = pytest.mark.skip("Wrong SparseBlock initialization (GH 17386)")
-
-
-@pytest.mark.parametrize(
-    "data",
-    [
-        [[1, 1], [2, 2], [3, 3], [4, 4], [0, 0]],
-        [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0], [np.nan, np.nan]],
-        [
-            [1.0, 1.0 + 1.0j],
-            [2.0 + 2.0j, 2.0],
-            [3.0, 3.0 + 3.0j],
-            [4.0 + 4.0j, 4.0],
-            [np.nan, np.nan],
-        ],
-    ],
-)
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_numeric_data(data):
-    # GH 17386
-    lower_bound = 1.5
-
-    sparse = SparseDataFrame(data)
-    result = sparse.where(sparse > lower_bound)
-
-    dense = DataFrame(data)
-    dense_expected = dense.where(dense > lower_bound)
-    sparse_expected = SparseDataFrame(dense_expected)
-
-    tm.assert_frame_equal(result, dense_expected)
-    tm.assert_sp_frame_equal(result, sparse_expected)
-
-
-@pytest.mark.parametrize(
-    "data",
-    [
-        [[1, 1], [2, 2], [3, 3], [4, 4], [0, 0]],
-        [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0], [np.nan, np.nan]],
-        [
-            [1.0, 1.0 + 1.0j],
-            [2.0 + 2.0j, 2.0],
-            [3.0, 3.0 + 3.0j],
-            [4.0 + 4.0j, 4.0],
-            [np.nan, np.nan],
-        ],
-    ],
-)
-@pytest.mark.parametrize("other", [True, -100, 0.1, 100.0 + 100.0j])
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_numeric_data_and_other(data, other):
-    # GH 17386
-    lower_bound = 1.5
-
-    sparse = SparseDataFrame(data)
-    result = sparse.where(sparse > lower_bound, other)
-
-    dense = DataFrame(data)
-    dense_expected = dense.where(dense > lower_bound, other)
-    sparse_expected = SparseDataFrame(dense_expected, default_fill_value=other)
-
-    tm.assert_frame_equal(result, dense_expected)
-    tm.assert_sp_frame_equal(result, sparse_expected)
-
-
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_bool_data():
-    # GH 17386
-    data = [[False, False], [True, True], [False, False]]
-    cond = True
-
-    sparse = SparseDataFrame(data)
-    result = sparse.where(sparse == cond)
-
-    dense = DataFrame(data)
-    dense_expected = dense.where(dense == cond)
-    sparse_expected = SparseDataFrame(dense_expected)
-
-    tm.assert_frame_equal(result, dense_expected)
-    tm.assert_sp_frame_equal(result, sparse_expected)
-
-
-@pytest.mark.parametrize("other", [True, 0, 0.1, 100.0 + 100.0j])
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_bool_data_and_other(other):
-    # GH 17386
-    data = [[False, False], [True, True], [False, False]]
-    cond = True
-
-    sparse = SparseDataFrame(data)
-    result = sparse.where(sparse == cond, other)
-
-    dense = DataFrame(data)
-    dense_expected = dense.where(dense == cond, other)
-    sparse_expected = SparseDataFrame(dense_expected, default_fill_value=other)
-
-    tm.assert_frame_equal(result, dense_expected)
-    tm.assert_sp_frame_equal(result, sparse_expected)
diff --git a/pandas/tests/sparse/frame/test_to_csv.py b/pandas/tests/sparse/frame/test_to_csv.py
deleted file mode 100644
index 4ba4fba7391d4..0000000000000
--- a/pandas/tests/sparse/frame/test_to_csv.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import SparseDataFrame, read_csv
-from pandas.util import testing as tm
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrameToCsv:
-    fill_values = [np.nan, 0, None, 1]
-
-    @pytest.mark.parametrize("fill_value", fill_values)
-    def test_to_csv_sparse_dataframe(self, fill_value):
-        # GH19384
-        sdf = SparseDataFrame(
-            {"a": type(self).fill_values}, default_fill_value=fill_value
-        )
-
-        with tm.ensure_clean("sparse_df.csv") as path:
-            sdf.to_csv(path, index=False)
-            df = read_csv(path, skip_blank_lines=False)
-
-            tm.assert_sp_frame_equal(df.to_sparse(fill_value=fill_value), sdf)
diff --git a/pandas/tests/sparse/frame/test_to_from_scipy.py b/pandas/tests/sparse/frame/test_to_from_scipy.py
deleted file mode 100644
index 9d1ccc62146ab..0000000000000
--- a/pandas/tests/sparse/frame/test_to_from_scipy.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas.core.dtypes.common import is_bool_dtype
-
-import pandas as pd
-from pandas import SparseDataFrame, SparseSeries
-from pandas.core.sparse.api import SparseDtype
-from pandas.util import testing as tm
-
-scipy = pytest.importorskip("scipy")
-ignore_matrix_warning = pytest.mark.filterwarnings(
-    "ignore:the matrix subclass:PendingDeprecationWarning"
-)
-
-
-@pytest.mark.parametrize("index", [None, list("abc")])  # noqa: F811
-@pytest.mark.parametrize("columns", [None, list("def")])
-@pytest.mark.parametrize("fill_value", [None, 0, np.nan])
-@pytest.mark.parametrize("dtype", [bool, int, float, np.uint16])
-@ignore_matrix_warning
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_from_to_scipy(spmatrix, index, columns, fill_value, dtype):
-    # GH 4343
-    # Make one ndarray and from it one sparse matrix, both to be used for
-    # constructing frames and comparing results
-    arr = np.eye(3, dtype=dtype)
-    # GH 16179
-    arr[0, 1] = dtype(2)
-    try:
-        spm = spmatrix(arr)
-        assert spm.dtype == arr.dtype
-    except (TypeError, AssertionError):
-        # If conversion to sparse fails for this spmatrix type and arr.dtype,
-        # then the combination is not currently supported in NumPy, so we
-        # can just skip testing it thoroughly
-        return
-
-    sdf = SparseDataFrame(
-        spm, index=index, columns=columns, default_fill_value=fill_value
-    )
-
-    # Expected result construction is kind of tricky for all
-    # dtype-fill_value combinations; easiest to cast to something generic
-    # and except later on
-    rarr = arr.astype(object)
-    rarr[arr == 0] = np.nan
-    expected = SparseDataFrame(rarr, index=index, columns=columns).fillna(
-        fill_value if fill_value is not None else np.nan
-    )
-
-    # Assert frame is as expected
-    sdf_obj = sdf.astype(object)
-    tm.assert_sp_frame_equal(sdf_obj, expected)
-    tm.assert_frame_equal(sdf_obj.to_dense(), expected.to_dense())
-
-    # Assert spmatrices equal
-    assert dict(sdf.to_coo().todok()) == dict(spm.todok())
-
-    # Ensure dtype is preserved if possible
-    # XXX: verify this
-    res_dtype = bool if is_bool_dtype(dtype) else dtype
-    tm.assert_contains_all(
-        sdf.dtypes.apply(lambda dtype: dtype.subtype), {np.dtype(res_dtype)}
-    )
-    assert sdf.to_coo().dtype == res_dtype
-
-    # However, adding a str column results in an upcast to object
-    sdf["strings"] = np.arange(len(sdf)).astype(str)
-    assert sdf.to_coo().dtype == np.object_
-
-
-@pytest.mark.parametrize("fill_value", [None, 0, np.nan])  # noqa: F811
-@ignore_matrix_warning
-@pytest.mark.filterwarnings("ignore:object dtype is not supp:UserWarning")
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_from_to_scipy_object(spmatrix, fill_value):
-    # GH 4343
-    dtype = object
-    columns = list("cd")
-    index = list("ab")
-
-    if spmatrix is scipy.sparse.dok_matrix:
-        pytest.skip("dok_matrix from object does not work in SciPy")
-
-    # Make one ndarray and from it one sparse matrix, both to be used for
-    # constructing frames and comparing results
-    arr = np.eye(2, dtype=dtype)
-    try:
-        spm = spmatrix(arr)
-        assert spm.dtype == arr.dtype
-    except (TypeError, AssertionError):
-        # If conversion to sparse fails for this spmatrix type and arr.dtype,
-        # then the combination is not currently supported in NumPy, so we
-        # can just skip testing it thoroughly
-        return
-
-    sdf = SparseDataFrame(
-        spm, index=index, columns=columns, default_fill_value=fill_value
-    )
-
-    # Expected result construction is kind of tricky for all
-    # dtype-fill_value combinations; easiest to cast to something generic
-    # and except later on
-    rarr = arr.astype(object)
-    rarr[arr == 0] = np.nan
-    expected = SparseDataFrame(rarr, index=index, columns=columns).fillna(
-        fill_value if fill_value is not None else np.nan
-    )
-
-    # Assert frame is as expected
-    sdf_obj = sdf.astype(SparseDtype(object, fill_value))
-    tm.assert_sp_frame_equal(sdf_obj, expected)
-    tm.assert_frame_equal(sdf_obj.to_dense(), expected.to_dense())
-
-    # Assert spmatrices equal
-    assert dict(sdf.to_coo().todok()) == dict(spm.todok())
-
-    # Ensure dtype is preserved if possible
-    res_dtype = object
-    tm.assert_contains_all(
-        sdf.dtypes.apply(lambda dtype: dtype.subtype), {np.dtype(res_dtype)}
-    )
-    assert sdf.to_coo().dtype == res_dtype
-
-
-@ignore_matrix_warning
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_from_scipy_correct_ordering(spmatrix):
-    # GH 16179
-    arr = np.arange(1, 5).reshape(2, 2)
-    try:
-        spm = spmatrix(arr)
-        assert spm.dtype == arr.dtype
-    except (TypeError, AssertionError):
-        # If conversion to sparse fails for this spmatrix type and arr.dtype,
-        # then the combination is not currently supported in NumPy, so we
-        # can just skip testing it thoroughly
-        return
-
-    sdf = SparseDataFrame(spm)
-    expected = SparseDataFrame(arr)
-    tm.assert_sp_frame_equal(sdf, expected)
-    tm.assert_frame_equal(sdf.to_dense(), expected.to_dense())
-
-
-@ignore_matrix_warning
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_from_scipy_fillna(spmatrix):
-    # GH 16112
-    arr = np.eye(3)
-    arr[1:, 0] = np.nan
-
-    try:
-        spm = spmatrix(arr)
-        assert spm.dtype == arr.dtype
-    except (TypeError, AssertionError):
-        # If conversion to sparse fails for this spmatrix type and arr.dtype,
-        # then the combination is not currently supported in NumPy, so we
-        # can just skip testing it thoroughly
-        return
-
-    sdf = SparseDataFrame(spm).fillna(-1.0)
-
-    # Returning frame should fill all nan values with -1.0
-    expected = SparseDataFrame(
-        {
-            0: SparseSeries([1.0, -1, -1]),
-            1: SparseSeries([np.nan, 1, np.nan]),
-            2: SparseSeries([np.nan, np.nan, 1]),
-        },
-        default_fill_value=-1,
-    )
-
-    # fill_value is expected to be what .fillna() above was called with
-    # We don't use -1 as initial fill_value in expected SparseSeries
-    # construction because this way we obtain "compressed" SparseArrays,
-    # avoiding having to construct them ourselves
-    for col in expected:
-        expected[col].fill_value = -1
-
-    tm.assert_sp_frame_equal(sdf, expected)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-def test_index_names_multiple_nones():
-    # https://github.com/pandas-dev/pandas/pull/24092
-    sparse = pytest.importorskip("scipy.sparse")
-
-    s = pd.Series(1, index=pd.MultiIndex.from_product([["A", "B"], [0, 1]])).to_sparse()
-    result, _, _ = s.to_coo()
-    assert isinstance(result, sparse.coo_matrix)
-    result = result.toarray()
-    expected = np.ones((2, 2), dtype="int64")
-    tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/sparse/series/test_indexing.py b/pandas/tests/sparse/series/test_indexing.py
deleted file mode 100644
index c75f3b2134f91..0000000000000
--- a/pandas/tests/sparse/series/test_indexing.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import Series, SparseSeries
-from pandas.util import testing as tm
-
-pytestmark = pytest.mark.skip("Wrong SparseBlock initialization (GH 17386)")
-
-
-@pytest.mark.parametrize(
-    "data",
-    [
-        [1, 1, 2, 2, 3, 3, 4, 4, 0, 0],
-        [1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, np.nan, np.nan],
-        [
-            1.0,
-            1.0 + 1.0j,
-            2.0 + 2.0j,
-            2.0,
-            3.0,
-            3.0 + 3.0j,
-            4.0 + 4.0j,
-            4.0,
-            np.nan,
-            np.nan,
-        ],
-    ],
-)
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_numeric_data(data):
-    # GH 17386
-    lower_bound = 1.5
-
-    sparse = SparseSeries(data)
-    result = sparse.where(sparse > lower_bound)
-
-    dense = Series(data)
-    dense_expected = dense.where(dense > lower_bound)
-    sparse_expected = SparseSeries(dense_expected)
-
-    tm.assert_series_equal(result, dense_expected)
-    tm.assert_sp_series_equal(result, sparse_expected)
-
-
-@pytest.mark.parametrize(
-    "data",
-    [
-        [1, 1, 2, 2, 3, 3, 4, 4, 0, 0],
-        [1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, np.nan, np.nan],
-        [
-            1.0,
-            1.0 + 1.0j,
-            2.0 + 2.0j,
-            2.0,
-            3.0,
-            3.0 + 3.0j,
-            4.0 + 4.0j,
-            4.0,
-            np.nan,
-            np.nan,
-        ],
-    ],
-)
-@pytest.mark.parametrize("other", [True, -100, 0.1, 100.0 + 100.0j])
-@pytest.mark.skip(reason="Wrong SparseBlock initialization (Segfault) (GH 17386)")
-def test_where_with_numeric_data_and_other(data, other):
-    # GH 17386
-    lower_bound = 1.5
-
-    sparse = SparseSeries(data)
-    result = sparse.where(sparse > lower_bound, other)
-
-    dense = Series(data)
-    dense_expected = dense.where(dense > lower_bound, other)
-    sparse_expected = SparseSeries(dense_expected, fill_value=other)
-
-    tm.assert_series_equal(result, dense_expected)
-    tm.assert_sp_series_equal(result, sparse_expected)
-
-
-@pytest.mark.xfail(reason="Wrong SparseBlock initialization (GH#17386)")
-def test_where_with_bool_data():
-    # GH 17386
-    data = [False, False, True, True, False, False]
-    cond = True
-
-    sparse = SparseSeries(data)
-    result = sparse.where(sparse == cond)
-
-    dense = Series(data)
-    dense_expected = dense.where(dense == cond)
-    sparse_expected = SparseSeries(dense_expected)
-
-    tm.assert_series_equal(result, dense_expected)
-    tm.assert_sp_series_equal(result, sparse_expected)
-
-
-@pytest.mark.parametrize("other", [True, 0, 0.1, 100.0 + 100.0j])
-@pytest.mark.skip(reason="Wrong SparseBlock initialization (Segfault) (GH 17386)")
-def test_where_with_bool_data_and_other(other):
-    # GH 17386
-    data = [False, False, True, True, False, False]
-    cond = True
-
-    sparse = SparseSeries(data)
-    result = sparse.where(sparse == cond, other)
-
-    dense = Series(data)
-    dense_expected = dense.where(dense == cond, other)
-    sparse_expected = SparseSeries(dense_expected, fill_value=other)
-
-    tm.assert_series_equal(result, dense_expected)
-    tm.assert_sp_series_equal(result, sparse_expected)
diff --git a/pandas/tests/sparse/series/test_series.py b/pandas/tests/sparse/series/test_series.py
deleted file mode 100644
index 046e7745fd4ec..0000000000000
--- a/pandas/tests/sparse/series/test_series.py
+++ /dev/null
@@ -1,1596 +0,0 @@
-from datetime import datetime
-import operator
-
-import numpy as np
-from numpy import nan
-import pytest
-
-from pandas._libs.sparse import BlockIndex, IntIndex
-from pandas.compat import PY36
-from pandas.errors import PerformanceWarning
-import pandas.util._test_decorators as td
-
-import pandas as pd
-from pandas import DataFrame, Series, SparseDtype, SparseSeries, bdate_range, isna
-from pandas.core import ops
-from pandas.core.reshape.util import cartesian_product
-import pandas.core.sparse.frame as spf
-from pandas.tests.series.test_api import SharedWithSparse
-import pandas.util.testing as tm
-
-from pandas.tseries.offsets import BDay
-
-
-def test_deprecated():
-    with tm.assert_produces_warning(FutureWarning):
-        pd.SparseSeries([0, 1])
-
-
-def _test_data1():
-    # nan-based
-    arr = np.arange(20, dtype=float)
-    index = np.arange(20)
-    arr[:2] = nan
-    arr[5:10] = nan
-    arr[-3:] = nan
-
-    return arr, index
-
-
-def _test_data2():
-    # nan-based
-    arr = np.arange(15, dtype=float)
-    index = np.arange(15)
-    arr[7:12] = nan
-    arr[-1:] = nan
-    return arr, index
-
-
-def _test_data1_zero():
-    # zero-based
-    arr, index = _test_data1()
-    arr[np.isnan(arr)] = 0
-    return arr, index
-
-
-def _test_data2_zero():
-    # zero-based
-    arr, index = _test_data2()
-    arr[np.isnan(arr)] = 0
-    return arr, index
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseSeries(SharedWithSparse):
-
-    series_klass = SparseSeries
-    # SharedWithSparse tests use generic, series_klass-agnostic assertion
-    _assert_series_equal = staticmethod(tm.assert_sp_series_equal)
-
-    def setup_method(self, method):
-        arr, index = _test_data1()
-
-        date_index = bdate_range("1/1/2011", periods=len(index))
-
-        self.bseries = SparseSeries(arr, index=index, kind="block", name="bseries")
-        self.ts = self.bseries
-
-        self.btseries = SparseSeries(arr, index=date_index, kind="block")
-
-        self.iseries = SparseSeries(arr, index=index, kind="integer", name="iseries")
-
-        arr, index = _test_data2()
-        self.bseries2 = SparseSeries(arr, index=index, kind="block")
-        self.iseries2 = SparseSeries(arr, index=index, kind="integer")
-
-        arr, index = _test_data1_zero()
-        self.zbseries = SparseSeries(
-            arr, index=index, kind="block", fill_value=0, name="zbseries"
-        )
-        self.ziseries = SparseSeries(arr, index=index, kind="integer", fill_value=0)
-
-        arr, index = _test_data2_zero()
-        self.zbseries2 = SparseSeries(arr, index=index, kind="block", fill_value=0)
-        self.ziseries2 = SparseSeries(arr, index=index, kind="integer", fill_value=0)
-
-    def test_constructor_dict_input(self):
-        # gh-16905
-        constructor_dict = {1: 1.0}
-        index = [0, 1, 2]
-
-        # Series with index passed in
-        series = pd.Series(constructor_dict)
-        expected = SparseSeries(series, index=index)
-
-        result = SparseSeries(constructor_dict, index=index)
-        tm.assert_sp_series_equal(result, expected)
-
-        # Series with index and dictionary with no index
-        expected = SparseSeries(series)
-
-        result = SparseSeries(constructor_dict)
-        tm.assert_sp_series_equal(result, expected)
-
-    def test_constructor_dict_order(self):
-        # GH19018
-        # initialization ordering: by insertion order if python>= 3.6, else
-        # order by value
-        d = {"b": 1, "a": 0, "c": 2}
-        result = SparseSeries(d)
-        if PY36:
-            expected = SparseSeries([1, 0, 2], index=list("bac"))
-        else:
-            expected = SparseSeries([0, 1, 2], index=list("abc"))
-        tm.assert_sp_series_equal(result, expected)
-
-    def test_constructor_dtype(self):
-        arr = SparseSeries([np.nan, 1, 2, np.nan])
-        assert arr.dtype == SparseDtype(np.float64)
-        assert np.isnan(arr.fill_value)
-
-        arr = SparseSeries([np.nan, 1, 2, np.nan], fill_value=0)
-        assert arr.dtype == SparseDtype(np.float64, 0)
-        assert arr.fill_value == 0
-
-        arr = SparseSeries([0, 1, 2, 4], dtype=np.int64, fill_value=np.nan)
-        assert arr.dtype == SparseDtype(np.int64, np.nan)
-        assert np.isnan(arr.fill_value)
-
-        arr = SparseSeries([0, 1, 2, 4], dtype=np.int64)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-        arr = SparseSeries([0, 1, 2, 4], fill_value=0, dtype=np.int64)
-        assert arr.dtype == SparseDtype(np.int64, 0)
-        assert arr.fill_value == 0
-
-    def test_iteration_and_str(self):
-        [x for x in self.bseries]
-        str(self.bseries)
-
-    def test_construct_DataFrame_with_sp_series(self):
-        # it works!
-        df = DataFrame({"col": self.bseries})
-
-        # printing & access
-        df.iloc[:1]
-        df["col"]
-        df.dtypes
-        str(df)
-
-        # blocking
-        expected = Series({"col": "float64:sparse"})
-
-        # GH 26705 - Assert .ftypes is deprecated
-        with tm.assert_produces_warning(FutureWarning):
-            result = df.ftypes
-        tm.assert_series_equal(expected, result)
-
-    def test_constructor_preserve_attr(self):
-        arr = pd.SparseArray([1, 0, 3, 0], dtype=np.int64, fill_value=0)
-        assert arr.dtype == SparseDtype(np.int64)
-        assert arr.fill_value == 0
-
-        s = pd.SparseSeries(arr, name="x")
-        assert s.dtype == SparseDtype(np.int64)
-        assert s.fill_value == 0
-
-    def test_series_density(self):
-        # GH2803
-        ts = Series(np.random.randn(10))
-        ts[2:-2] = nan
-        sts = ts.to_sparse()
-        density = sts.density  # don't die
-        assert density == 4 / 10.0
-
-    def test_sparse_to_dense(self):
-        arr, index = _test_data1()
-        series = self.bseries.to_dense()
-        tm.assert_series_equal(series, Series(arr, name="bseries"))
-
-        series = self.iseries.to_dense()
-        tm.assert_series_equal(series, Series(arr, name="iseries"))
-
-        arr, index = _test_data1_zero()
-        series = self.zbseries.to_dense()
-        tm.assert_series_equal(series, Series(arr, name="zbseries"))
-
-        series = self.ziseries.to_dense()
-        tm.assert_series_equal(series, Series(arr))
-
-    def test_to_dense_fill_value(self):
-        s = pd.Series([1, np.nan, np.nan, 3, np.nan])
-        res = SparseSeries(s).to_dense()
-        tm.assert_series_equal(res, s)
-
-        res = SparseSeries(s, fill_value=0).to_dense()
-        tm.assert_series_equal(res, s)
-
-        s = pd.Series([1, np.nan, 0, 3, 0])
-        res = SparseSeries(s, fill_value=0).to_dense()
-        tm.assert_series_equal(res, s)
-
-        res = SparseSeries(s, fill_value=0).to_dense()
-        tm.assert_series_equal(res, s)
-
-        s = pd.Series([np.nan, np.nan, np.nan, np.nan, np.nan])
-        res = SparseSeries(s).to_dense()
-        tm.assert_series_equal(res, s)
-
-        s = pd.Series([np.nan, np.nan, np.nan, np.nan, np.nan])
-        res = SparseSeries(s, fill_value=0).to_dense()
-        tm.assert_series_equal(res, s)
-
-    def test_dense_to_sparse(self):
-        series = self.bseries.to_dense()
-        bseries = series.to_sparse(kind="block")
-        iseries = series.to_sparse(kind="integer")
-        tm.assert_sp_series_equal(bseries, self.bseries)
-        tm.assert_sp_series_equal(iseries, self.iseries, check_names=False)
-        assert iseries.name == self.bseries.name
-
-        assert len(series) == len(bseries)
-        assert len(series) == len(iseries)
-        assert series.shape == bseries.shape
-        assert series.shape == iseries.shape
-
-        # non-NaN fill value
-        series = self.zbseries.to_dense()
-        zbseries = series.to_sparse(kind="block", fill_value=0)
-        ziseries = series.to_sparse(kind="integer", fill_value=0)
-        tm.assert_sp_series_equal(zbseries, self.zbseries)
-        tm.assert_sp_series_equal(ziseries, self.ziseries, check_names=False)
-        assert ziseries.name == self.zbseries.name
-
-        assert len(series) == len(zbseries)
-        assert len(series) == len(ziseries)
-        assert series.shape == zbseries.shape
-        assert series.shape == ziseries.shape
-
-    def test_to_dense_preserve_name(self):
-        assert self.bseries.name is not None
-        result = self.bseries.to_dense()
-        assert result.name == self.bseries.name
-
-    def test_constructor(self):
-        # test setup guys
-        assert np.isnan(self.bseries.fill_value)
-        assert isinstance(self.bseries.sp_index, BlockIndex)
-        assert np.isnan(self.iseries.fill_value)
-        assert isinstance(self.iseries.sp_index, IntIndex)
-
-        assert self.zbseries.fill_value == 0
-        tm.assert_numpy_array_equal(
-            self.zbseries.values.to_dense(), self.bseries.to_dense().fillna(0).values
-        )
-
-        # pass SparseSeries
-        def _check_const(sparse, name):
-            # use passed series name
-            result = SparseSeries(sparse)
-            tm.assert_sp_series_equal(result, sparse)
-            assert sparse.name == name
-            assert result.name == name
-
-            # use passed name
-            result = SparseSeries(sparse, name="x")
-            tm.assert_sp_series_equal(result, sparse, check_names=False)
-            assert result.name == "x"
-
-        _check_const(self.bseries, "bseries")
-        _check_const(self.iseries, "iseries")
-        _check_const(self.zbseries, "zbseries")
-
-        # Sparse time series works
-        date_index = bdate_range("1/1/2000", periods=len(self.bseries))
-        s5 = SparseSeries(self.bseries, index=date_index)
-        assert isinstance(s5, SparseSeries)
-
-        # pass Series
-        bseries2 = SparseSeries(self.bseries.to_dense())
-        tm.assert_numpy_array_equal(self.bseries.sp_values, bseries2.sp_values)
-
-        # pass dict?
-
-        # don't copy the data by default
-        values = np.ones(self.bseries.npoints)
-        sp = SparseSeries(values, sparse_index=self.bseries.sp_index)
-        sp.sp_values[:5] = 97
-        assert values[0] == 97
-
-        assert len(sp) == 20
-        assert sp.shape == (20,)
-
-        # but can make it copy!
-        sp = SparseSeries(values, sparse_index=self.bseries.sp_index, copy=True)
-        sp.sp_values[:5] = 100
-        assert values[0] == 97
-
-        assert len(sp) == 20
-        assert sp.shape == (20,)
-
-    def test_constructor_scalar(self):
-        data = 5
-        sp = SparseSeries(data, np.arange(100))
-        sp = sp.reindex(np.arange(200))
-        assert (sp.loc[:99] == data).all()
-        assert isna(sp.loc[100:]).all()
-
-        data = np.nan
-        sp = SparseSeries(data, np.arange(100))
-        assert len(sp) == 100
-        assert sp.shape == (100,)
-
-    def test_constructor_ndarray(self):
-        pass
-
-    def test_constructor_nonnan(self):
-        arr = [0, 0, 0, nan, nan]
-        sp_series = SparseSeries(arr, fill_value=0)
-        tm.assert_numpy_array_equal(sp_series.values.to_dense(), np.array(arr))
-        assert len(sp_series) == 5
-        assert sp_series.shape == (5,)
-
-    def test_constructor_empty(self):
-        # see gh-9272
-        sp = SparseSeries()
-        assert len(sp.index) == 0
-        assert sp.shape == (0,)
-
-    def test_copy_astype(self):
-        cop = self.bseries.astype(np.float64)
-        assert cop is not self.bseries
-        assert cop.sp_index is self.bseries.sp_index
-        assert cop.dtype == SparseDtype(np.float64)
-
-        cop2 = self.iseries.copy()
-
-        tm.assert_sp_series_equal(cop, self.bseries)
-        tm.assert_sp_series_equal(cop2, self.iseries)
-
-        # test that data is copied
-        cop[:5] = 97
-        assert cop.sp_values[0] == 97
-        assert self.bseries.sp_values[0] != 97
-
-        # correct fill value
-        zbcop = self.zbseries.copy()
-        zicop = self.ziseries.copy()
-
-        tm.assert_sp_series_equal(zbcop, self.zbseries)
-        tm.assert_sp_series_equal(zicop, self.ziseries)
-
-        # no deep copy
-        view = self.bseries.copy(deep=False)
-        view.sp_values[:5] = 5
-        assert (self.bseries.sp_values[:5] == 5).all()
-
-    def test_shape(self):
-        # see gh-10452
-        assert self.bseries.shape == (20,)
-        assert self.btseries.shape == (20,)
-        assert self.iseries.shape == (20,)
-
-        assert self.bseries2.shape == (15,)
-        assert self.iseries2.shape == (15,)
-
-        assert self.zbseries2.shape == (15,)
-        assert self.ziseries2.shape == (15,)
-
-    def test_astype(self):
-        result = self.bseries.astype(SparseDtype(np.int64, 0))
-        expected = (
-            self.bseries.to_dense().fillna(0).astype(np.int64).to_sparse(fill_value=0)
-        )
-        tm.assert_sp_series_equal(result, expected)
-
-    def test_astype_all(self):
-        orig = pd.Series(np.array([1, 2, 3]))
-        s = SparseSeries(orig)
-
-        types = [np.float64, np.float32, np.int64, np.int32, np.int16, np.int8]
-        for typ in types:
-            dtype = SparseDtype(typ)
-            res = s.astype(dtype)
-            assert res.dtype == dtype
-            tm.assert_series_equal(res.to_dense(), orig.astype(typ))
-
-    def test_kind(self):
-        assert self.bseries.kind == "block"
-        assert self.iseries.kind == "integer"
-
-    def test_to_frame(self):
-        # GH 9850
-        s = pd.SparseSeries([1, 2, 0, nan, 4, nan, 0], name="x")
-        exp = pd.SparseDataFrame({"x": [1, 2, 0, nan, 4, nan, 0]})
-        tm.assert_sp_frame_equal(s.to_frame(), exp)
-
-        exp = pd.SparseDataFrame({"y": [1, 2, 0, nan, 4, nan, 0]})
-        tm.assert_sp_frame_equal(s.to_frame(name="y"), exp)
-
-        s = pd.SparseSeries([1, 2, 0, nan, 4, nan, 0], name="x", fill_value=0)
-        exp = pd.SparseDataFrame({"x": [1, 2, 0, nan, 4, nan, 0]}, default_fill_value=0)
-
-        tm.assert_sp_frame_equal(s.to_frame(), exp)
-        exp = pd.DataFrame({"y": [1, 2, 0, nan, 4, nan, 0]})
-        tm.assert_frame_equal(s.to_frame(name="y").to_dense(), exp)
-
-    def test_pickle(self):
-        def _test_roundtrip(series):
-            unpickled = tm.round_trip_pickle(series)
-            tm.assert_sp_series_equal(series, unpickled)
-            tm.assert_series_equal(series.to_dense(), unpickled.to_dense())
-
-        self._check_all(_test_roundtrip)
-
-    def _check_all(self, check_func):
-        check_func(self.bseries)
-        check_func(self.iseries)
-        check_func(self.zbseries)
-        check_func(self.ziseries)
-
-    def test_getitem(self):
-        def _check_getitem(sp, dense):
-            for idx, val in dense.items():
-                tm.assert_almost_equal(val, sp[idx])
-
-            for i in range(len(dense)):
-                tm.assert_almost_equal(sp[i], dense[i])
-                # j = np.float64(i)
-                # assert_almost_equal(sp[j], dense[j])
-
-                # API change 1/6/2012
-                # negative getitem works
-                # for i in xrange(len(dense)):
-                #     assert_almost_equal(sp[-i], dense[-i])
-
-        _check_getitem(self.bseries, self.bseries.to_dense())
-        _check_getitem(self.btseries, self.btseries.to_dense())
-
-        _check_getitem(self.zbseries, self.zbseries.to_dense())
-        _check_getitem(self.iseries, self.iseries.to_dense())
-        _check_getitem(self.ziseries, self.ziseries.to_dense())
-
-        # exception handling
-        with pytest.raises(IndexError, match="Out of bounds access"):
-            self.bseries[len(self.bseries) + 1]
-
-        # index not contained
-        msg = r"Timestamp\('2011-01-31 00:00:00', freq='B'\)"
-        with pytest.raises(KeyError, match=msg):
-            self.btseries[self.btseries.index[-1] + BDay()]
-
-    def test_get_get_value(self):
-        tm.assert_almost_equal(self.bseries.get(10), self.bseries[10])
-        assert self.bseries.get(len(self.bseries) + 1) is None
-
-        dt = self.btseries.index[10]
-        result = self.btseries.get(dt)
-        expected = self.btseries.to_dense()[dt]
-        tm.assert_almost_equal(result, expected)
-
-        tm.assert_almost_equal(self.bseries._get_value(10), self.bseries[10])
-
-    def test_set_value(self):
-
-        idx = self.btseries.index[7]
-        self.btseries._set_value(idx, 0)
-        assert self.btseries[idx] == 0
-
-        self.iseries._set_value("foobar", 0)
-        assert self.iseries.index[-1] == "foobar"
-        assert self.iseries["foobar"] == 0
-
-    def test_getitem_slice(self):
-        idx = self.bseries.index
-        res = self.bseries[::2]
-        assert isinstance(res, SparseSeries)
-
-        expected = self.bseries.reindex(idx[::2])
-        tm.assert_sp_series_equal(res, expected)
-
-        res = self.bseries[:5]
-        assert isinstance(res, SparseSeries)
-        tm.assert_sp_series_equal(res, self.bseries.reindex(idx[:5]))
-
-        res = self.bseries[5:]
-        tm.assert_sp_series_equal(res, self.bseries.reindex(idx[5:]))
-
-        # negative indices
-        res = self.bseries[:-3]
-        tm.assert_sp_series_equal(res, self.bseries.reindex(idx[:-3]))
-
-    def test_take(self):
-        def _compare_with_dense(sp):
-            dense = sp.to_dense()
-
-            def _compare(idx):
-                dense_result = dense.take(idx).values
-                sparse_result = sp.take(idx)
-                assert isinstance(sparse_result, SparseSeries)
-                tm.assert_almost_equal(dense_result, sparse_result.values.to_dense())
-
-            _compare([1.0, 2.0, 3.0, 4.0, 5.0, 0.0])
-            _compare([7, 2, 9, 0, 4])
-            _compare([3, 6, 3, 4, 7])
-
-        self._check_all(_compare_with_dense)
-
-        msg = "index 21 is out of bounds for size 20"
-        with pytest.raises(IndexError, match=msg):
-            self.bseries.take([0, len(self.bseries) + 1])
-
-        # Corner case
-        # XXX: changed test. Why wsa this considered a corner case?
-        sp = SparseSeries(np.ones(10) * nan)
-        exp = pd.Series(np.repeat(nan, 5))
-        tm.assert_series_equal(sp.take([0, 1, 2, 3, 4]), exp.to_sparse())
-
-    def test_numpy_take(self):
-        sp = SparseSeries([1.0, 2.0, 3.0])
-        indices = [1, 2]
-
-        tm.assert_series_equal(
-            np.take(sp, indices, axis=0).to_dense(),
-            np.take(sp.to_dense(), indices, axis=0),
-        )
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.take(sp, indices, out=np.empty(sp.shape))
-
-        msg = "the 'mode' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.take(sp, indices, out=None, mode="clip")
-
-    def test_setitem(self):
-        self.bseries[5] = 7.0
-        assert self.bseries[5] == 7.0
-
-    def test_setslice(self):
-        self.bseries[5:10] = 7.0
-        tm.assert_series_equal(
-            self.bseries[5:10].to_dense(),
-            Series(7.0, index=range(5, 10), name=self.bseries.name),
-        )
-
-    def test_operators(self):
-        def _check_op(a, b, op):
-            sp_result = op(a, b)
-            adense = a.to_dense() if isinstance(a, SparseSeries) else a
-            bdense = b.to_dense() if isinstance(b, SparseSeries) else b
-            dense_result = op(adense, bdense)
-            if "floordiv" in op.__name__:
-                # Series sets 1//0 to np.inf, which SparseSeries does not do (yet)
-                mask = np.isinf(dense_result)
-                dense_result[mask] = np.nan
-            tm.assert_almost_equal(sp_result.to_dense(), dense_result)
-
-        def check(a, b):
-            _check_op(a, b, operator.add)
-            _check_op(a, b, operator.sub)
-            _check_op(a, b, operator.truediv)
-            _check_op(a, b, operator.floordiv)
-            _check_op(a, b, operator.mul)
-
-            _check_op(a, b, ops.radd)
-            _check_op(a, b, ops.rsub)
-            _check_op(a, b, ops.rtruediv)
-            _check_op(a, b, ops.rfloordiv)
-            _check_op(a, b, ops.rmul)
-
-            # FIXME: don't leave commented-out
-            # NaN ** 0 = 1 in C?
-            # _check_op(a, b, operator.pow)
-            # _check_op(a, b, ops.rpow)
-
-        check(self.bseries, self.bseries)
-        check(self.iseries, self.iseries)
-        check(self.bseries, self.iseries)
-
-        check(self.bseries, self.bseries2)
-        check(self.bseries, self.iseries2)
-        check(self.iseries, self.iseries2)
-
-        # scalar value
-        check(self.bseries, 5)
-
-        # zero-based
-        check(self.zbseries, self.zbseries * 2)
-        check(self.zbseries, self.zbseries2)
-        check(self.ziseries, self.ziseries2)
-
-        # with dense
-        result = self.bseries + self.bseries.to_dense()
-        tm.assert_sp_series_equal(result, self.bseries + self.bseries)
-
-    def test_binary_operators(self):
-
-        # skipping for now #####
-        import pytest
-
-        pytest.skip("skipping sparse binary operators test")
-
-        def _check_inplace_op(iop, op):
-            tmp = self.bseries.copy()
-
-            expected = op(tmp, self.bseries)
-            iop(tmp, self.bseries)
-            tm.assert_sp_series_equal(tmp, expected)
-
-        inplace_ops = ["add", "sub", "mul", "truediv", "floordiv", "pow"]
-        for op in inplace_ops:
-            _check_inplace_op(
-                getattr(operator, "i{op}".format(op=op)), getattr(operator, op)
-            )
-
-    @pytest.mark.parametrize(
-        "values, op, fill_value",
-        [
-            ([True, False, False, True], operator.invert, True),
-            ([True, False, False, True], operator.invert, False),
-            ([0, 1, 2, 3], operator.pos, 0),
-            ([0, 1, 2, 3], operator.neg, 0),
-            ([0, np.nan, 2, 3], operator.pos, np.nan),
-            ([0, np.nan, 2, 3], operator.neg, np.nan),
-        ],
-    )
-    def test_unary_operators(self, values, op, fill_value):
-        # https://github.com/pandas-dev/pandas/issues/22835
-        values = np.asarray(values)
-        if op is operator.invert:
-            new_fill_value = not fill_value
-        else:
-            new_fill_value = op(fill_value)
-        s = SparseSeries(
-            values, fill_value=fill_value, index=["a", "b", "c", "d"], name="name"
-        )
-        result = op(s)
-        expected = SparseSeries(
-            op(values),
-            fill_value=new_fill_value,
-            index=["a", "b", "c", "d"],
-            name="name",
-        )
-        tm.assert_sp_series_equal(result, expected)
-
-    def test_abs(self):
-        s = SparseSeries([1, 2, -3], name="x")
-        expected = SparseSeries([1, 2, 3], name="x")
-        result = s.abs()
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-        result = abs(s)
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-        result = np.abs(s)
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-        s = SparseSeries([1, -2, 2, -3], fill_value=-2, name="x")
-        expected = SparseSeries(
-            [1, 2, 3], sparse_index=s.sp_index, fill_value=2, name="x"
-        )
-        result = s.abs()
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-        result = abs(s)
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-        result = np.abs(s)
-        tm.assert_sp_series_equal(result, expected)
-        assert result.name == "x"
-
-    def test_reindex(self):
-        def _compare_with_series(sps, new_index):
-            spsre = sps.reindex(new_index)
-
-            series = sps.to_dense()
-            seriesre = series.reindex(new_index)
-            seriesre = seriesre.to_sparse(fill_value=sps.fill_value)
-
-            tm.assert_sp_series_equal(spsre, seriesre)
-            tm.assert_series_equal(spsre.to_dense(), seriesre.to_dense())
-
-        _compare_with_series(self.bseries, self.bseries.index[::2])
-        _compare_with_series(self.bseries, list(self.bseries.index[::2]))
-        _compare_with_series(self.bseries, self.bseries.index[:10])
-        _compare_with_series(self.bseries, self.bseries.index[5:])
-
-        _compare_with_series(self.zbseries, self.zbseries.index[::2])
-        _compare_with_series(self.zbseries, self.zbseries.index[:10])
-        _compare_with_series(self.zbseries, self.zbseries.index[5:])
-
-        # special cases
-        same_index = self.bseries.reindex(self.bseries.index)
-        tm.assert_sp_series_equal(self.bseries, same_index)
-        assert same_index is not self.bseries
-
-        # corner cases
-        sp = SparseSeries([], index=[])
-        # TODO: sp_zero is not used anywhere...remove?
-        sp_zero = SparseSeries([], index=[], fill_value=0)  # noqa
-        _compare_with_series(sp, np.arange(10))
-
-        # with copy=False
-        reindexed = self.bseries.reindex(self.bseries.index, copy=True)
-        reindexed.sp_values[:] = 1.0
-        assert (self.bseries.sp_values != 1.0).all()
-
-        reindexed = self.bseries.reindex(self.bseries.index, copy=False)
-        reindexed.sp_values[:] = 1.0
-        tm.assert_numpy_array_equal(self.bseries.sp_values, np.repeat(1.0, 10))
-
-    def test_sparse_reindex(self):
-        length = 10
-
-        def _check(values, index1, index2, fill_value):
-            first_series = SparseSeries(
-                values, sparse_index=index1, fill_value=fill_value
-            )
-            reindexed = first_series.sparse_reindex(index2)
-            assert reindexed.sp_index is index2
-
-            int_indices1 = index1.to_int_index().indices
-            int_indices2 = index2.to_int_index().indices
-
-            expected = Series(values, index=int_indices1)
-            expected = expected.reindex(int_indices2).fillna(fill_value)
-            tm.assert_almost_equal(expected.values, reindexed.sp_values)
-
-            # make sure level argument asserts
-            # TODO: expected is not used anywhere...remove?
-            expected = expected.reindex(int_indices2).fillna(fill_value)  # noqa
-
-        def _check_with_fill_value(values, first, second, fill_value=nan):
-            i_index1 = IntIndex(length, first)
-            i_index2 = IntIndex(length, second)
-
-            b_index1 = i_index1.to_block_index()
-            b_index2 = i_index2.to_block_index()
-
-            _check(values, i_index1, i_index2, fill_value)
-            _check(values, b_index1, b_index2, fill_value)
-
-        def _check_all(values, first, second):
-            _check_with_fill_value(values, first, second, fill_value=nan)
-            _check_with_fill_value(values, first, second, fill_value=0)
-
-        index1 = [2, 4, 5, 6, 8, 9]
-        values1 = np.arange(6.0)
-
-        _check_all(values1, index1, [2, 4, 5])
-        _check_all(values1, index1, [2, 3, 4, 5, 6, 7, 8, 9])
-        _check_all(values1, index1, [0, 1])
-        _check_all(values1, index1, [0, 1, 7, 8, 9])
-        _check_all(values1, index1, [])
-
-        first_series = SparseSeries(
-            values1, sparse_index=IntIndex(length, index1), fill_value=nan
-        )
-        with pytest.raises(TypeError, match="new index must be a SparseIndex"):
-            first_series.sparse_reindex(0)
-
-    def test_repr(self):
-        # TODO: These aren't used
-        bsrepr = repr(self.bseries)  # noqa
-        isrepr = repr(self.iseries)  # noqa
-
-    def test_iter(self):
-        pass
-
-    def test_truncate(self):
-        pass
-
-    def test_fillna(self):
-        pass
-
-    def test_groupby(self):
-        pass
-
-    def test_reductions(self):
-        def _compare_with_dense(obj, op):
-            sparse_result = getattr(obj, op)()
-            series = obj.to_dense()
-            dense_result = getattr(series, op)()
-            assert sparse_result == dense_result
-
-        to_compare = ["count", "sum", "mean", "std", "var", "skew"]
-
-        def _compare_all(obj):
-            for op in to_compare:
-                _compare_with_dense(obj, op)
-
-        _compare_all(self.bseries)
-
-        self.bseries.sp_values[5:10] = np.NaN
-        _compare_all(self.bseries)
-
-        _compare_all(self.zbseries)
-        self.zbseries.sp_values[5:10] = np.NaN
-        _compare_all(self.zbseries)
-
-        series = self.zbseries.copy()
-        series.fill_value = 2
-        _compare_all(series)
-
-        nonna = Series(np.random.randn(20)).to_sparse()
-        _compare_all(nonna)
-
-        nonna2 = Series(np.random.randn(20)).to_sparse(fill_value=0)
-        _compare_all(nonna2)
-
-    def test_dropna(self):
-        sp = SparseSeries([0, 0, 0, nan, nan, 5, 6], fill_value=0)
-
-        sp_valid = sp.dropna()
-
-        expected = sp.to_dense().dropna()
-        expected = expected[expected != 0]
-        exp_arr = pd.SparseArray(expected.values, fill_value=0, kind="block")
-        tm.assert_sp_array_equal(sp_valid.values, exp_arr)
-        tm.assert_index_equal(sp_valid.index, expected.index)
-        assert len(sp_valid.sp_values) == 2
-
-        result = self.bseries.dropna()
-        expected = self.bseries.to_dense().dropna()
-        assert not isinstance(result, SparseSeries)
-        tm.assert_series_equal(result, expected)
-
-    def test_homogenize(self):
-        def _check_matches(indices, expected):
-            data = {
-                i: SparseSeries(
-                    idx.to_int_index().indices, sparse_index=idx, fill_value=np.nan
-                )
-                for i, idx in enumerate(indices)
-            }
-
-            # homogenized is only valid with NaN fill values
-            homogenized = spf.homogenize(data)
-
-            for k, v in homogenized.items():
-                assert v.sp_index.equals(expected)
-
-        indices1 = [
-            BlockIndex(10, [2], [7]),
-            BlockIndex(10, [1, 6], [3, 4]),
-            BlockIndex(10, [0], [10]),
-        ]
-        expected1 = BlockIndex(10, [2, 6], [2, 3])
-        _check_matches(indices1, expected1)
-
-        indices2 = [BlockIndex(10, [2], [7]), BlockIndex(10, [2], [7])]
-        expected2 = indices2[0]
-        _check_matches(indices2, expected2)
-
-        # must have NaN fill value
-        data = {"a": SparseSeries(np.arange(7), sparse_index=expected2, fill_value=0)}
-        with pytest.raises(TypeError, match="NaN fill value"):
-            spf.homogenize(data)
-
-    def test_fill_value_corner(self):
-        cop = self.zbseries.copy()
-        cop.fill_value = 0
-        result = self.bseries / cop
-
-        assert np.isnan(result.fill_value)
-
-        cop2 = self.zbseries.copy()
-        cop2.fill_value = 1
-        result = cop2 / cop
-        # 1 / 0 is inf
-        assert np.isinf(result.fill_value)
-
-    def test_fill_value_when_combine_const(self):
-        # GH12723
-        s = SparseSeries([0, 1, np.nan, 3, 4, 5], index=np.arange(6))
-
-        exp = s.fillna(0).add(2)
-        res = s.add(2, fill_value=0)
-        tm.assert_series_equal(res, exp)
-
-    def test_shift(self):
-        series = SparseSeries([nan, 1.0, 2.0, 3.0, nan, nan], index=np.arange(6))
-
-        shifted = series.shift(0)
-        # assert shifted is not series
-        tm.assert_sp_series_equal(shifted, series)
-
-        f = lambda s: s.shift(1)
-        _dense_series_compare(series, f)
-
-        f = lambda s: s.shift(-2)
-        _dense_series_compare(series, f)
-
-        series = SparseSeries(
-            [nan, 1.0, 2.0, 3.0, nan, nan], index=bdate_range("1/1/2000", periods=6)
-        )
-        f = lambda s: s.shift(2, freq="B")
-        _dense_series_compare(series, f)
-
-        f = lambda s: s.shift(2, freq=BDay())
-        _dense_series_compare(series, f)
-
-    def test_shift_nan(self):
-        # GH 12908
-        orig = pd.Series([np.nan, 2, np.nan, 4, 0, np.nan, 0])
-        sparse = orig.to_sparse()
-
-        tm.assert_sp_series_equal(
-            sparse.shift(0), orig.shift(0).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(1), orig.shift(1).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(2), orig.shift(2).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(3), orig.shift(3).to_sparse(), check_kind=False
-        )
-
-        tm.assert_sp_series_equal(sparse.shift(-1), orig.shift(-1).to_sparse())
-        tm.assert_sp_series_equal(sparse.shift(-2), orig.shift(-2).to_sparse())
-        tm.assert_sp_series_equal(sparse.shift(-3), orig.shift(-3).to_sparse())
-        tm.assert_sp_series_equal(sparse.shift(-4), orig.shift(-4).to_sparse())
-
-        sparse = orig.to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(
-            sparse.shift(0), orig.shift(0).to_sparse(fill_value=sparse.fill_value)
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(1), orig.shift(1).to_sparse(fill_value=0), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(2), orig.shift(2).to_sparse(fill_value=0), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(3), orig.shift(3).to_sparse(fill_value=0), check_kind=False
-        )
-
-        tm.assert_sp_series_equal(
-            sparse.shift(-1), orig.shift(-1).to_sparse(fill_value=0), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-2), orig.shift(-2).to_sparse(fill_value=0), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-3), orig.shift(-3).to_sparse(fill_value=0), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-4), orig.shift(-4).to_sparse(fill_value=0), check_kind=False
-        )
-
-    def test_shift_dtype(self):
-        # GH 12908
-        orig = pd.Series([1, 2, 3, 4], dtype=np.int64)
-
-        sparse = orig.to_sparse()
-        tm.assert_sp_series_equal(sparse.shift(0), orig.shift(0).to_sparse())
-
-        sparse = orig.to_sparse(fill_value=np.nan)
-        tm.assert_sp_series_equal(
-            sparse.shift(0), orig.shift(0).to_sparse(fill_value=np.nan)
-        )
-        # shift(1) or more span changes dtype to float64
-        # XXX: SparseSeries doesn't need to shift dtype here.
-        # Do we want to astype in shift, for backwards compat?
-        # If not, document it.
-        tm.assert_sp_series_equal(
-            sparse.shift(1).astype("f8"), orig.shift(1).to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(2).astype("f8"), orig.shift(2).to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(3).astype("f8"), orig.shift(3).to_sparse(kind="integer")
-        )
-
-        tm.assert_sp_series_equal(
-            sparse.shift(-1).astype("f8"), orig.shift(-1).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-2).astype("f8"), orig.shift(-2).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-3).astype("f8"), orig.shift(-3).to_sparse(), check_kind=False
-        )
-        tm.assert_sp_series_equal(
-            sparse.shift(-4).astype("f8"), orig.shift(-4).to_sparse(), check_kind=False
-        )
-
-    @pytest.mark.parametrize("fill_value", [0, 1, np.nan])
-    @pytest.mark.parametrize("periods", [0, 1, 2, 3, -1, -2, -3, -4])
-    def test_shift_dtype_fill_value(self, fill_value, periods):
-        # GH 12908
-        orig = pd.Series([1, 0, 0, 4], dtype=np.dtype("int64"))
-
-        sparse = orig.to_sparse(fill_value=fill_value)
-
-        result = sparse.shift(periods)
-        expected = orig.shift(periods).to_sparse(fill_value=fill_value)
-
-        tm.assert_sp_series_equal(
-            result, expected, check_kind=False, consolidate_block_indices=True
-        )
-
-    def test_combine_first(self):
-        s = self.bseries
-
-        result = s[::2].combine_first(s)
-        result2 = s[::2].combine_first(s.to_dense())
-
-        expected = s[::2].to_dense().combine_first(s.to_dense())
-        expected = expected.to_sparse(fill_value=s.fill_value)
-
-        tm.assert_sp_series_equal(result, result2)
-        tm.assert_sp_series_equal(result, expected)
-
-    @pytest.mark.parametrize("deep", [True, False])
-    @pytest.mark.parametrize("fill_value", [0, 1, np.nan, None])
-    def test_memory_usage_deep(self, deep, fill_value):
-        values = [1.0] + [fill_value] * 20
-        sparse_series = SparseSeries(values, fill_value=fill_value)
-        dense_series = Series(values)
-        sparse_usage = sparse_series.memory_usage(deep=deep)
-        dense_usage = dense_series.memory_usage(deep=deep)
-
-        assert sparse_usage < dense_usage
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseHandlingMultiIndexes:
-    def setup_method(self, method):
-        miindex = pd.MultiIndex.from_product(
-            [["x", "y"], ["10", "20"]], names=["row-foo", "row-bar"]
-        )
-        micol = pd.MultiIndex.from_product(
-            [["a", "b", "c"], ["1", "2"]], names=["col-foo", "col-bar"]
-        )
-        dense_multiindex_frame = (
-            pd.DataFrame(index=miindex, columns=micol).sort_index().sort_index(axis=1)
-        )
-        self.dense_multiindex_frame = dense_multiindex_frame.fillna(value=3.14)
-
-    def test_to_sparse_preserve_multiindex_names_columns(self):
-        sparse_multiindex_frame = self.dense_multiindex_frame.to_sparse()
-        sparse_multiindex_frame = sparse_multiindex_frame.copy()
-        tm.assert_index_equal(
-            sparse_multiindex_frame.columns, self.dense_multiindex_frame.columns
-        )
-
-    def test_round_trip_preserve_multiindex_names(self):
-        sparse_multiindex_frame = self.dense_multiindex_frame.to_sparse()
-        round_trip_multiindex_frame = sparse_multiindex_frame.to_dense()
-        tm.assert_frame_equal(
-            self.dense_multiindex_frame,
-            round_trip_multiindex_frame,
-            check_column_type=True,
-            check_names=True,
-        )
-
-
-@td.skip_if_no_scipy
-@pytest.mark.filterwarnings("ignore:the matrix subclass:PendingDeprecationWarning")
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseSeriesScipyInteraction:
-    # Issue 8048: add SparseSeries coo methods
-
-    def setup_method(self, method):
-        import scipy.sparse
-
-        # SparseSeries inputs used in tests, the tests rely on the order
-        self.sparse_series = []
-        s = pd.Series([3.0, nan, 1.0, 2.0, nan, nan])
-        s.index = pd.MultiIndex.from_tuples(
-            [
-                (1, 2, "a", 0),
-                (1, 2, "a", 1),
-                (1, 1, "b", 0),
-                (1, 1, "b", 1),
-                (2, 1, "b", 0),
-                (2, 1, "b", 1),
-            ],
-            names=["A", "B", "C", "D"],
-        )
-        self.sparse_series.append(s.to_sparse())
-
-        ss = self.sparse_series[0].copy()
-        ss.index.names = [3, 0, 1, 2]
-        self.sparse_series.append(ss)
-
-        ss = pd.Series(
-            [nan] * 12, index=cartesian_product((range(3), range(4)))
-        ).to_sparse()
-        for k, v in zip([(0, 0), (1, 2), (1, 3)], [3.0, 1.0, 2.0]):
-            ss[k] = v
-        self.sparse_series.append(ss)
-
-        # results used in tests
-        self.coo_matrices = []
-        self.coo_matrices.append(
-            scipy.sparse.coo_matrix(
-                ([3.0, 1.0, 2.0], ([0, 1, 1], [0, 2, 3])), shape=(3, 4)
-            )
-        )
-        self.coo_matrices.append(
-            scipy.sparse.coo_matrix(
-                ([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])), shape=(3, 4)
-            )
-        )
-        self.coo_matrices.append(
-            scipy.sparse.coo_matrix(
-                ([3.0, 1.0, 2.0], ([0, 1, 1], [0, 0, 1])), shape=(3, 2)
-            )
-        )
-        self.ils = [
-            [(1, 2), (1, 1), (2, 1)],
-            [(1, 1), (1, 2), (2, 1)],
-            [(1, 2, "a"), (1, 1, "b"), (2, 1, "b")],
-        ]
-        self.jls = [[("a", 0), ("a", 1), ("b", 0), ("b", 1)], [0, 1]]
-
-    def test_to_coo_text_names_integer_row_levels_nosort(self):
-        ss = self.sparse_series[0]
-        kwargs = {"row_levels": [0, 1], "column_levels": [2, 3]}
-        result = (self.coo_matrices[0], self.ils[0], self.jls[0])
-        self._run_test(ss, kwargs, result)
-
-    def test_to_coo_text_names_integer_row_levels_sort(self):
-        ss = self.sparse_series[0]
-        kwargs = {"row_levels": [0, 1], "column_levels": [2, 3], "sort_labels": True}
-        result = (self.coo_matrices[1], self.ils[1], self.jls[0])
-        self._run_test(ss, kwargs, result)
-
-    def test_to_coo_text_names_text_row_levels_nosort_col_level_single(self):
-        ss = self.sparse_series[0]
-        kwargs = {
-            "row_levels": ["A", "B", "C"],
-            "column_levels": ["D"],
-            "sort_labels": False,
-        }
-        result = (self.coo_matrices[2], self.ils[2], self.jls[1])
-        self._run_test(ss, kwargs, result)
-
-    def test_to_coo_integer_names_integer_row_levels_nosort(self):
-        ss = self.sparse_series[1]
-        kwargs = {"row_levels": [3, 0], "column_levels": [1, 2]}
-        result = (self.coo_matrices[0], self.ils[0], self.jls[0])
-        self._run_test(ss, kwargs, result)
-
-    def test_to_coo_text_names_text_row_levels_nosort(self):
-        ss = self.sparse_series[0]
-        kwargs = {"row_levels": ["A", "B"], "column_levels": ["C", "D"]}
-        result = (self.coo_matrices[0], self.ils[0], self.jls[0])
-        self._run_test(ss, kwargs, result)
-
-    def test_to_coo_bad_partition_nonnull_intersection(self):
-        ss = self.sparse_series[0]
-        msg = "Is not a partition because intersection is not null"
-        with pytest.raises(ValueError, match=msg):
-            ss.to_coo(["A", "B", "C"], ["C", "D"])
-
-    def test_to_coo_bad_partition_small_union(self):
-        ss = self.sparse_series[0]
-        msg = "Is not a partition because union is not the whole"
-        with pytest.raises(ValueError, match=msg):
-            ss.to_coo(["A"], ["C", "D"])
-
-    def test_to_coo_nlevels_less_than_two(self):
-        ss = self.sparse_series[0]
-        ss.index = np.arange(len(ss.index))
-        msg = "to_coo requires MultiIndex with nlevels > 2"
-        with pytest.raises(ValueError, match=msg):
-            ss.to_coo()
-
-    def test_to_coo_bad_ilevel(self):
-        ss = self.sparse_series[0]
-        with pytest.raises(KeyError, match="Level E not found"):
-            ss.to_coo(["A", "B"], ["C", "D", "E"])
-
-    def test_to_coo_duplicate_index_entries(self):
-        ss = pd.concat([self.sparse_series[0], self.sparse_series[0]]).to_sparse()
-        msg = "Duplicate index entries are not allowed in to_coo transformation"
-        with pytest.raises(ValueError, match=msg):
-            ss.to_coo(["A", "B"], ["C", "D"])
-
-    def test_from_coo_dense_index(self):
-        ss = SparseSeries.from_coo(self.coo_matrices[0], dense_index=True)
-        check = self.sparse_series[2]
-        tm.assert_sp_series_equal(ss, check)
-
-    def test_from_coo_nodense_index(self):
-        ss = SparseSeries.from_coo(self.coo_matrices[0], dense_index=False)
-        check = self.sparse_series[2]
-        check = check.dropna().to_sparse()
-        tm.assert_sp_series_equal(ss, check)
-
-    def test_from_coo_long_repr(self):
-        # GH 13114
-        # test it doesn't raise error. Formatting is tested in test_format
-        import scipy.sparse
-
-        sparse = SparseSeries.from_coo(scipy.sparse.rand(350, 18))
-        repr(sparse)
-
-    def _run_test(self, ss, kwargs, check):
-        results = ss.to_coo(**kwargs)
-        self._check_results_to_coo(results, check)
-        # for every test, also test symmetry property (transpose), switch
-        # row_levels and column_levels
-        d = kwargs.copy()
-        d["row_levels"] = kwargs["column_levels"]
-        d["column_levels"] = kwargs["row_levels"]
-        results = ss.to_coo(**d)
-        results = (results[0].T, results[2], results[1])
-        self._check_results_to_coo(results, check)
-
-    def _check_results_to_coo(self, results, check):
-        (A, il, jl) = results
-        (A_result, il_result, jl_result) = check
-        # convert to dense and compare
-        tm.assert_numpy_array_equal(A.todense(), A_result.todense())
-        # or compare directly as difference of sparse
-        # assert(abs(A - A_result).max() < 1e-12) # max is failing in python
-        # 2.6
-        assert il == il_result
-        assert jl == jl_result
-
-    def test_concat(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        for kind in ["integer", "block"]:
-            sparse1 = pd.SparseSeries(val1, name="x", kind=kind)
-            sparse2 = pd.SparseSeries(val2, name="y", kind=kind)
-
-            res = pd.concat([sparse1, sparse2])
-            exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-            exp = pd.SparseSeries(exp, kind=kind)
-            tm.assert_sp_series_equal(res, exp)
-
-            sparse1 = pd.SparseSeries(val1, fill_value=0, name="x", kind=kind)
-            sparse2 = pd.SparseSeries(val2, fill_value=0, name="y", kind=kind)
-
-            res = pd.concat([sparse1, sparse2])
-            exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-            exp = pd.SparseSeries(exp, fill_value=0, kind=kind)
-            tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
-
-    def test_concat_axis1(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x")
-        sparse2 = pd.SparseSeries(val2, name="y")
-
-        res = pd.concat([sparse1, sparse2], axis=1)
-        exp = pd.concat([pd.Series(val1, name="x"), pd.Series(val2, name="y")], axis=1)
-        exp = pd.SparseDataFrame(exp)
-        tm.assert_sp_frame_equal(res, exp)
-
-    def test_concat_different_fill(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        for kind in ["integer", "block"]:
-            sparse1 = pd.SparseSeries(val1, name="x", kind=kind)
-            sparse2 = pd.SparseSeries(val2, name="y", kind=kind, fill_value=0)
-
-            with tm.assert_produces_warning(
-                PerformanceWarning, raise_on_extra_warnings=False
-            ):
-                res = pd.concat([sparse1, sparse2])
-            exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-            exp = pd.SparseSeries(exp, kind=kind)
-            tm.assert_sp_series_equal(res, exp)
-
-            with tm.assert_produces_warning(
-                PerformanceWarning, raise_on_extra_warnings=False
-            ):
-                res = pd.concat([sparse2, sparse1])
-            exp = pd.concat([pd.Series(val2), pd.Series(val1)])
-            exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
-            tm.assert_sp_series_equal(res, exp)
-
-    def test_concat_axis1_different_fill(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x")
-        sparse2 = pd.SparseSeries(val2, name="y", fill_value=0)
-
-        res = pd.concat([sparse1, sparse2], axis=1)
-        exp = pd.concat([pd.Series(val1, name="x"), pd.Series(val2, name="y")], axis=1)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    def test_concat_different_kind(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x", kind="integer")
-        sparse2 = pd.SparseSeries(val2, name="y", kind="block", fill_value=0)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            res = pd.concat([sparse1, sparse2])
-        exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-        exp = pd.SparseSeries(exp, kind="integer")
-        tm.assert_sp_series_equal(res, exp)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            res = pd.concat([sparse2, sparse1])
-        exp = pd.concat([pd.Series(val2), pd.Series(val1)])
-        exp = pd.SparseSeries(exp, kind="block", fill_value=0)
-        tm.assert_sp_series_equal(res, exp)
-
-    def test_concat_sparse_dense(self):
-        # use first input's fill_value
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        for kind in ["integer", "block"]:
-            sparse = pd.SparseSeries(val1, name="x", kind=kind)
-            dense = pd.Series(val2, name="y")
-
-            res = pd.concat([sparse, dense])
-            exp = pd.concat([pd.Series(val1), dense])
-            exp = pd.SparseSeries(exp, kind=kind)
-            tm.assert_sp_series_equal(res, exp)
-
-            res = pd.concat([dense, sparse, dense])
-            exp = pd.concat([dense, pd.Series(val1), dense])
-            exp = exp.astype("Sparse")
-            tm.assert_series_equal(res, exp)
-
-            sparse = pd.SparseSeries(val1, name="x", kind=kind, fill_value=0)
-            dense = pd.Series(val2, name="y")
-
-            res = pd.concat([sparse, dense])
-            exp = pd.concat([pd.Series(val1), dense])
-            exp = exp.astype(SparseDtype(exp.dtype, 0))
-            tm.assert_series_equal(res, exp)
-
-            res = pd.concat([dense, sparse, dense])
-            exp = pd.concat([dense, pd.Series(val1), dense])
-            exp = exp.astype(SparseDtype(exp.dtype, 0))
-            tm.assert_series_equal(res, exp)
-
-    def test_value_counts(self):
-        vals = [1, 2, nan, 0, nan, 1, 2, nan, nan, 1, 2, 0, 1, 1]
-        dense = pd.Series(vals, name="xx")
-
-        sparse = pd.SparseSeries(vals, name="xx")
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-        sparse = pd.SparseSeries(vals, name="xx", fill_value=0)
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-    def test_value_counts_dup(self):
-        vals = [1, 2, nan, 0, nan, 1, 2, nan, nan, 1, 2, 0, 1, 1]
-
-        # numeric op may cause sp_values to include the same value as
-        # fill_value
-        dense = pd.Series(vals, name="xx") / 0.0
-        sparse = pd.SparseSeries(vals, name="xx") / 0.0
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-        vals = [1, 2, 0, 0, 0, 1, 2, 0, 0, 1, 2, 0, 1, 1]
-
-        dense = pd.Series(vals, name="xx") * 0.0
-        sparse = pd.SparseSeries(vals, name="xx") * 0.0
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-    def test_value_counts_int(self):
-        vals = [1, 2, 0, 1, 2, 1, 2, 0, 1, 1]
-        dense = pd.Series(vals, name="xx")
-
-        # fill_value is np.nan, but should not be included in the result
-        sparse = pd.SparseSeries(vals, name="xx")
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-        sparse = pd.SparseSeries(vals, name="xx", fill_value=0)
-        tm.assert_series_equal(sparse.value_counts(), dense.value_counts())
-        tm.assert_series_equal(
-            sparse.value_counts(dropna=False), dense.value_counts(dropna=False)
-        )
-
-    def test_isna(self):
-        # GH 8276
-        s = pd.SparseSeries([np.nan, np.nan, 1, 2, np.nan], name="xxx")
-
-        res = s.isna()
-        exp = pd.SparseSeries(
-            [True, True, False, False, True], name="xxx", fill_value=True
-        )
-        tm.assert_sp_series_equal(res, exp)
-
-        # if fill_value is not nan, True can be included in sp_values
-        s = pd.SparseSeries([np.nan, 0.0, 1.0, 2.0, 0.0], name="xxx", fill_value=0.0)
-        res = s.isna()
-        assert isinstance(res, pd.SparseSeries)
-        exp = pd.Series([True, False, False, False, False], name="xxx")
-        tm.assert_series_equal(res.to_dense(), exp)
-
-    def test_notna(self):
-        # GH 8276
-        s = pd.SparseSeries([np.nan, np.nan, 1, 2, np.nan], name="xxx")
-
-        res = s.notna()
-        exp = pd.SparseSeries(
-            [False, False, True, True, False], name="xxx", fill_value=False
-        )
-        tm.assert_sp_series_equal(res, exp)
-
-        # if fill_value is not nan, True can be included in sp_values
-        s = pd.SparseSeries([np.nan, 0.0, 1.0, 2.0, 0.0], name="xxx", fill_value=0.0)
-        res = s.notna()
-        assert isinstance(res, pd.SparseSeries)
-        exp = pd.Series([False, True, True, True, True], name="xxx")
-        tm.assert_series_equal(res.to_dense(), exp)
-
-
-def _dense_series_compare(s, f):
-    result = f(s)
-    assert isinstance(result, SparseSeries)
-    dense_result = f(s.to_dense())
-    tm.assert_series_equal(result.to_dense(), dense_result)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseSeriesAnalytics:
-    def setup_method(self, method):
-        arr, index = _test_data1()
-        self.bseries = SparseSeries(arr, index=index, kind="block", name="bseries")
-
-        arr, index = _test_data1_zero()
-        self.zbseries = SparseSeries(
-            arr, index=index, kind="block", fill_value=0, name="zbseries"
-        )
-
-    def test_cumsum(self):
-        result = self.bseries.cumsum()
-        expected = SparseSeries(self.bseries.to_dense().cumsum())
-        tm.assert_sp_series_equal(result, expected)
-
-        result = self.zbseries.cumsum()
-        expected = self.zbseries.to_dense().cumsum().to_sparse()
-        tm.assert_series_equal(result, expected)
-
-        axis = 1  # Series is 1-D, so only axis = 0 is valid.
-        msg = "No axis named {axis}".format(axis=axis)
-        with pytest.raises(ValueError, match=msg):
-            self.bseries.cumsum(axis=axis)
-
-    def test_numpy_cumsum(self):
-        result = np.cumsum(self.bseries)
-        expected = SparseSeries(self.bseries.to_dense().cumsum())
-        tm.assert_sp_series_equal(result, expected)
-
-        result = np.cumsum(self.zbseries)
-        expected = self.zbseries.to_dense().cumsum().to_sparse()
-        tm.assert_series_equal(result, expected)
-
-        msg = "the 'dtype' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.cumsum(self.bseries, dtype=np.int64)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.cumsum(self.zbseries, out=result)
-
-    def test_numpy_func_call(self):
-        # no exception should be raised even though
-        # numpy passes in 'axis=None' or `axis=-1'
-        funcs = [
-            "sum",
-            "cumsum",
-            "var",
-            "mean",
-            "prod",
-            "cumprod",
-            "std",
-            "argsort",
-            "min",
-            "max",
-        ]
-        for func in funcs:
-            for series in ("bseries", "zbseries"):
-                getattr(np, func)(getattr(self, series))
-
-    def test_deprecated_numpy_func_call(self):
-        # NOTE: These should be add to the 'test_numpy_func_call' test above
-        # once the behavior of argmin/argmax is corrected.
-        funcs = ["argmin", "argmax"]
-        for func in funcs:
-            for series in ("bseries", "zbseries"):
-                with tm.assert_produces_warning(
-                    FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-                ):
-                    getattr(np, func)(getattr(self, series))
-
-                with tm.assert_produces_warning(
-                    FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-                ):
-                    getattr(getattr(self, series), func)()
-
-
-@pytest.mark.parametrize(
-    "datetime_type",
-    (np.datetime64, pd.Timestamp, lambda x: datetime.strptime(x, "%Y-%m-%d")),
-)
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_constructor_dict_datetime64_index(datetime_type):
-    # GH 9456
-    dates = ["1984-02-19", "1988-11-06", "1989-12-03", "1990-03-15"]
-    values = [42544017.198965244, 1234565, 40512335.181958228, -1]
-
-    result = SparseSeries(dict(zip(map(datetime_type, dates), values)))
-    expected = SparseSeries(values, map(pd.Timestamp, dates))
-
-    tm.assert_sp_series_equal(result, expected)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-def test_to_sparse():
-    # https://github.com/pandas-dev/pandas/issues/22389
-    arr = pd.SparseArray([1, 2, None, 3])
-    result = pd.Series(arr).to_sparse()
-    assert len(result) == 4
-    tm.assert_sp_array_equal(result.values, arr, check_kind=False)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_deprecated_to_sparse():
-    # GH 26557
-    # Deprecated 0.25.0
-
-    ser = Series([1, np.nan, 3])
-    sparse_ser = pd.SparseSeries([1, np.nan, 3])
-
-    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-        result = ser.to_sparse()
-    tm.assert_series_equal(result, sparse_ser)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_constructor_mismatched_raises():
-    msg = "Length of passed values is 2, index implies 3"
-    with pytest.raises(ValueError, match=msg):
-        SparseSeries([1, 2], index=[1, 2, 3])
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_block_deprecated():
-    s = SparseSeries([1])
-    with tm.assert_produces_warning(FutureWarning):
-        s.block
diff --git a/pandas/tests/sparse/test_combine_concat.py b/pandas/tests/sparse/test_combine_concat.py
deleted file mode 100644
index c553cd3fd1a7a..0000000000000
--- a/pandas/tests/sparse/test_combine_concat.py
+++ /dev/null
@@ -1,474 +0,0 @@
-import itertools
-
-import numpy as np
-import pytest
-
-from pandas.errors import PerformanceWarning
-
-import pandas as pd
-import pandas.util.testing as tm
-
-
-class TestSparseArrayConcat:
-    @pytest.mark.parametrize("kind", ["integer", "block"])
-    def test_basic(self, kind):
-        a = pd.SparseArray([1, 0, 0, 2], kind=kind)
-        b = pd.SparseArray([1, 0, 2, 2], kind=kind)
-
-        result = pd.SparseArray._concat_same_type([a, b])
-        # Can't make any assertions about the sparse index itself
-        # since we aren't don't merge sparse blocs across arrays
-        # in to_concat
-        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
-        tm.assert_numpy_array_equal(result.sp_values, expected)
-        assert result.kind == kind
-
-    @pytest.mark.parametrize("kind", ["integer", "block"])
-    def test_uses_first_kind(self, kind):
-        other = "integer" if kind == "block" else "block"
-        a = pd.SparseArray([1, 0, 0, 2], kind=kind)
-        b = pd.SparseArray([1, 0, 2, 2], kind=other)
-
-        result = pd.SparseArray._concat_same_type([a, b])
-        expected = np.array([1, 2, 1, 2, 2], dtype="int64")
-        tm.assert_numpy_array_equal(result.sp_values, expected)
-        assert result.kind == kind
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-class TestSparseSeriesConcat:
-    @pytest.mark.parametrize("kind", ["integer", "block"])
-    def test_concat(self, kind):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x", kind=kind)
-        sparse2 = pd.SparseSeries(val2, name="y", kind=kind)
-
-        res = pd.concat([sparse1, sparse2])
-        exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-        exp = pd.SparseSeries(exp, kind=kind)
-        tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
-
-        sparse1 = pd.SparseSeries(val1, fill_value=0, name="x", kind=kind)
-        sparse2 = pd.SparseSeries(val2, fill_value=0, name="y", kind=kind)
-
-        res = pd.concat([sparse1, sparse2])
-        exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-        exp = pd.SparseSeries(exp, fill_value=0, kind=kind)
-        tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
-
-    def test_concat_axis1(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x")
-        sparse2 = pd.SparseSeries(val2, name="y")
-
-        res = pd.concat([sparse1, sparse2], axis=1)
-        exp = pd.concat([pd.Series(val1, name="x"), pd.Series(val2, name="y")], axis=1)
-        exp = pd.SparseDataFrame(exp)
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-    def test_concat_different_fill(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        for kind in ["integer", "block"]:
-            sparse1 = pd.SparseSeries(val1, name="x", kind=kind)
-            sparse2 = pd.SparseSeries(val2, name="y", kind=kind, fill_value=0)
-
-            with tm.assert_produces_warning(
-                PerformanceWarning, raise_on_extra_warnings=False
-            ):
-                res = pd.concat([sparse1, sparse2])
-
-            exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-            exp = pd.SparseSeries(exp, kind=kind)
-            tm.assert_sp_series_equal(res, exp)
-
-            with tm.assert_produces_warning(
-                PerformanceWarning, raise_on_extra_warnings=False
-            ):
-                res = pd.concat([sparse2, sparse1])
-
-            exp = pd.concat([pd.Series(val2), pd.Series(val1)])
-            exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
-            tm.assert_sp_series_equal(res, exp)
-
-    def test_concat_axis1_different_fill(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x")
-        sparse2 = pd.SparseSeries(val2, name="y", fill_value=0)
-
-        res = pd.concat([sparse1, sparse2], axis=1)
-        exp = pd.concat([pd.Series(val1, name="x"), pd.Series(val2, name="y")], axis=1)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    def test_concat_different_kind(self):
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse1 = pd.SparseSeries(val1, name="x", kind="integer")
-        sparse2 = pd.SparseSeries(val2, name="y", kind="block")
-
-        res = pd.concat([sparse1, sparse2])
-        exp = pd.concat([pd.Series(val1), pd.Series(val2)])
-        exp = pd.SparseSeries(exp, kind=sparse1.kind)
-        tm.assert_sp_series_equal(res, exp)
-
-        res = pd.concat([sparse2, sparse1])
-        exp = pd.concat([pd.Series(val2), pd.Series(val1)])
-        exp = pd.SparseSeries(exp, kind=sparse2.kind)
-        tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
-
-    @pytest.mark.parametrize("kind", ["integer", "block"])
-    def test_concat_sparse_dense(self, kind):
-        # use first input's fill_value
-        val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
-        val2 = np.array([3, np.nan, 4, 0, 0])
-
-        sparse = pd.SparseSeries(val1, name="x", kind=kind)
-        dense = pd.Series(val2, name="y")
-
-        res = pd.concat([sparse, dense])
-        exp = pd.SparseSeries(pd.concat([pd.Series(val1), dense]), kind=kind)
-        tm.assert_sp_series_equal(res, exp)
-
-        res = pd.concat([dense, sparse, dense])
-        exp = pd.concat([dense, pd.Series(val1), dense])
-        # XXX: changed from SparseSeries to Series[sparse]
-        exp = pd.Series(pd.SparseArray(exp, kind=kind), index=exp.index, name=exp.name)
-        tm.assert_series_equal(res, exp)
-
-        sparse = pd.SparseSeries(val1, name="x", kind=kind, fill_value=0)
-        dense = pd.Series(val2, name="y")
-
-        res = pd.concat([sparse, dense])
-        # XXX: changed from SparseSeries to Series[sparse]
-        exp = pd.concat([pd.Series(val1), dense])
-        exp = pd.Series(
-            pd.SparseArray(exp, kind=kind, fill_value=0), index=exp.index, name=exp.name
-        )
-        tm.assert_series_equal(res, exp)
-
-        res = pd.concat([dense, sparse, dense])
-        exp = pd.concat([dense, pd.Series(val1), dense])
-        # XXX: changed from SparseSeries to Series[sparse]
-        exp = pd.Series(
-            pd.SparseArray(exp, kind=kind, fill_value=0), index=exp.index, name=exp.name
-        )
-        tm.assert_series_equal(res, exp)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrameConcat:
-    def setup_method(self, method):
-
-        self.dense1 = pd.DataFrame(
-            {
-                "A": [0.0, 1.0, 2.0, np.nan],
-                "B": [0.0, 0.0, 0.0, 0.0],
-                "C": [np.nan, np.nan, np.nan, np.nan],
-                "D": [1.0, 2.0, 3.0, 4.0],
-            }
-        )
-
-        self.dense2 = pd.DataFrame(
-            {
-                "A": [5.0, 6.0, 7.0, 8.0],
-                "B": [np.nan, 0.0, 7.0, 8.0],
-                "C": [5.0, 6.0, np.nan, np.nan],
-                "D": [np.nan, np.nan, np.nan, np.nan],
-            }
-        )
-
-        self.dense3 = pd.DataFrame(
-            {
-                "E": [5.0, 6.0, 7.0, 8.0],
-                "F": [np.nan, 0.0, 7.0, 8.0],
-                "G": [5.0, 6.0, np.nan, np.nan],
-                "H": [np.nan, np.nan, np.nan, np.nan],
-            }
-        )
-
-    def test_concat(self):
-        # fill_value = np.nan
-        sparse = self.dense1.to_sparse()
-        sparse2 = self.dense2.to_sparse()
-
-        res = pd.concat([sparse, sparse])
-        exp = pd.concat([self.dense1, self.dense1]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse2, sparse2])
-        exp = pd.concat([self.dense2, self.dense2]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse, sparse2])
-        exp = pd.concat([self.dense1, self.dense2]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse2, sparse])
-        exp = pd.concat([self.dense2, self.dense1]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        # fill_value = 0
-        sparse = self.dense1.to_sparse(fill_value=0)
-        sparse2 = self.dense2.to_sparse(fill_value=0)
-
-        res = pd.concat([sparse, sparse])
-        exp = pd.concat([self.dense1, self.dense1]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse2, sparse2])
-        exp = pd.concat([self.dense2, self.dense2]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse, sparse2])
-        exp = pd.concat([self.dense1, self.dense2]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        res = pd.concat([sparse2, sparse])
-        exp = pd.concat([self.dense2, self.dense1]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-    def test_concat_different_fill_value(self):
-        # 1st fill_value will be used
-        sparse = self.dense1.to_sparse()
-        sparse2 = self.dense2.to_sparse(fill_value=0)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            res = pd.concat([sparse, sparse2])
-        exp = pd.concat([self.dense1, self.dense2]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-        with tm.assert_produces_warning(
-            PerformanceWarning, raise_on_extra_warnings=False
-        ):
-            res = pd.concat([sparse2, sparse])
-        exp = pd.concat([self.dense2, self.dense1]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
-
-    def test_concat_different_columns_sort_warns(self):
-        sparse = self.dense1.to_sparse()
-        sparse3 = self.dense3.to_sparse()
-
-        # stacklevel is wrong since we have two FutureWarnings,
-        # one for depr, one for sorting.
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
-            res = pd.concat([sparse, sparse3])
-        with tm.assert_produces_warning(
-            FutureWarning, check_stacklevel=False, raise_on_extra_warnings=False
-        ):
-            exp = pd.concat([self.dense1, self.dense3])
-
-        exp = exp.to_sparse()
-        tm.assert_sp_frame_equal(res, exp, check_kind=False)
-
-    def test_concat_different_columns(self):
-        # fill_value = np.nan
-        sparse = self.dense1.to_sparse()
-        sparse3 = self.dense3.to_sparse()
-
-        res = pd.concat([sparse, sparse3], sort=True)
-        exp = pd.concat([self.dense1, self.dense3], sort=True).to_sparse()
-        tm.assert_sp_frame_equal(res, exp, check_kind=False)
-
-        res = pd.concat([sparse3, sparse], sort=True)
-        exp = pd.concat([self.dense3, self.dense1], sort=True).to_sparse()
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp, check_kind=False)
-
-    def test_concat_bug(self):
-        from pandas.core.sparse.api import SparseDtype
-
-        x = pd.SparseDataFrame({"A": pd.SparseArray([np.nan, np.nan], fill_value=0)})
-        y = pd.SparseDataFrame({"B": []})
-        res = pd.concat([x, y], sort=False)[["A"]]
-        exp = pd.DataFrame(
-            {"A": pd.SparseArray([np.nan, np.nan], dtype=SparseDtype(float, 0))}
-        )
-        tm.assert_frame_equal(res, exp)
-
-    def test_concat_different_columns_buggy(self):
-        sparse = self.dense1.to_sparse(fill_value=0)
-        sparse3 = self.dense3.to_sparse(fill_value=0)
-
-        res = pd.concat([sparse, sparse3], sort=True)
-        exp = pd.concat([self.dense1, self.dense3], sort=True).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-
-        tm.assert_sp_frame_equal(
-            res, exp, check_kind=False, consolidate_block_indices=True
-        )
-
-        res = pd.concat([sparse3, sparse], sort=True)
-        exp = pd.concat([self.dense3, self.dense1], sort=True).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(
-            res, exp, check_kind=False, consolidate_block_indices=True
-        )
-
-        # different fill values
-        sparse = self.dense1.to_sparse()
-        sparse3 = self.dense3.to_sparse(fill_value=0)
-        # each columns keeps its fill_value, thus compare in dense
-        res = pd.concat([sparse, sparse3], sort=True)
-        exp = pd.concat([self.dense1, self.dense3], sort=True)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-        res = pd.concat([sparse3, sparse], sort=True)
-        exp = pd.concat([self.dense3, self.dense1], sort=True)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    def test_concat_series(self):
-        # fill_value = np.nan
-        sparse = self.dense1.to_sparse()
-        sparse2 = self.dense2.to_sparse()
-
-        for col in ["A", "D"]:
-            res = pd.concat([sparse, sparse2[col]])
-            exp = pd.concat([self.dense1, self.dense2[col]]).to_sparse()
-            tm.assert_sp_frame_equal(res, exp, check_kind=False)
-
-            res = pd.concat([sparse2[col], sparse])
-            exp = pd.concat([self.dense2[col], self.dense1]).to_sparse()
-            tm.assert_sp_frame_equal(res, exp, check_kind=False)
-
-        # fill_value = 0
-        sparse = self.dense1.to_sparse(fill_value=0)
-        sparse2 = self.dense2.to_sparse(fill_value=0)
-
-        for col in ["C", "D"]:
-            res = pd.concat([sparse, sparse2[col]])
-            exp = pd.concat([self.dense1, self.dense2[col]]).to_sparse(fill_value=0)
-            exp._default_fill_value = np.nan
-            tm.assert_sp_frame_equal(
-                res, exp, check_kind=False, consolidate_block_indices=True
-            )
-
-            res = pd.concat([sparse2[col], sparse])
-            exp = pd.concat([self.dense2[col], self.dense1]).to_sparse(fill_value=0)
-            exp["C"] = res["C"]
-            exp._default_fill_value = np.nan
-            tm.assert_sp_frame_equal(
-                res, exp, consolidate_block_indices=True, check_kind=False
-            )
-
-    def test_concat_axis1(self):
-        # fill_value = np.nan
-        sparse = self.dense1.to_sparse()
-        sparse3 = self.dense3.to_sparse()
-
-        res = pd.concat([sparse, sparse3], axis=1)
-        exp = pd.concat([self.dense1, self.dense3], axis=1).to_sparse()
-        tm.assert_sp_frame_equal(res, exp)
-
-        res = pd.concat([sparse3, sparse], axis=1)
-        exp = pd.concat([self.dense3, self.dense1], axis=1).to_sparse()
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp)
-
-        # fill_value = 0
-        sparse = self.dense1.to_sparse(fill_value=0)
-        sparse3 = self.dense3.to_sparse(fill_value=0)
-
-        res = pd.concat([sparse, sparse3], axis=1)
-        exp = pd.concat([self.dense1, self.dense3], axis=1).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp)
-
-        res = pd.concat([sparse3, sparse], axis=1)
-        exp = pd.concat([self.dense3, self.dense1], axis=1).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(res, exp)
-
-        # different fill values
-        sparse = self.dense1.to_sparse()
-        sparse3 = self.dense3.to_sparse(fill_value=0)
-        # each columns keeps its fill_value, thus compare in dense
-        res = pd.concat([sparse, sparse3], axis=1)
-        exp = pd.concat([self.dense1, self.dense3], axis=1)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-        res = pd.concat([sparse3, sparse], axis=1)
-        exp = pd.concat([self.dense3, self.dense1], axis=1)
-        assert isinstance(res, pd.SparseDataFrame)
-        tm.assert_frame_equal(res.to_dense(), exp)
-
-    @pytest.mark.parametrize(
-        "fill_value,sparse_idx,dense_idx",
-        itertools.product([None, 0, 1, np.nan], [0, 1], [1, 0]),
-    )
-    def test_concat_sparse_dense_rows(self, fill_value, sparse_idx, dense_idx):
-        frames = [self.dense1, self.dense2]
-        sparse_frame = [
-            frames[dense_idx],
-            frames[sparse_idx].to_sparse(fill_value=fill_value),
-        ]
-        dense_frame = [frames[dense_idx], frames[sparse_idx]]
-
-        # This will try both directions sparse + dense and dense + sparse
-        for _ in range(2):
-            res = pd.concat(sparse_frame)
-            exp = pd.concat(dense_frame)
-
-            assert isinstance(res, pd.SparseDataFrame)
-            tm.assert_frame_equal(res.to_dense(), exp)
-
-            sparse_frame = sparse_frame[::-1]
-            dense_frame = dense_frame[::-1]
-
-    @pytest.mark.parametrize(
-        "fill_value,sparse_idx,dense_idx",
-        itertools.product([None, 0, 1, np.nan], [0, 1], [1, 0]),
-    )
-    @pytest.mark.xfail(reason="The iloc fails and I can't make expected", strict=True)
-    def test_concat_sparse_dense_cols(self, fill_value, sparse_idx, dense_idx):
-        # See GH16874, GH18914 and #18686 for why this should be a DataFrame
-        from pandas.core.dtypes.common import is_sparse
-
-        frames = [self.dense1, self.dense3]
-
-        sparse_frame = [
-            frames[dense_idx],
-            frames[sparse_idx].to_sparse(fill_value=fill_value),
-        ]
-        dense_frame = [frames[dense_idx], frames[sparse_idx]]
-
-        # This will try both directions sparse + dense and dense + sparse
-        for _ in range(2):
-            res = pd.concat(sparse_frame, axis=1)
-            exp = pd.concat(dense_frame, axis=1)
-            cols = [i for (i, x) in enumerate(res.dtypes) if is_sparse(x)]
-
-            for col in cols:
-                exp.iloc[:, col] = exp.iloc[:, col].astype("Sparse")
-
-            for column in frames[dense_idx].columns:
-                if dense_idx == sparse_idx:
-                    tm.assert_frame_equal(res[column], exp[column])
-                else:
-                    tm.assert_series_equal(res[column], exp[column])
-
-            tm.assert_frame_equal(res, exp)
-
-            sparse_frame = sparse_frame[::-1]
-            dense_frame = dense_frame[::-1]
diff --git a/pandas/tests/sparse/test_format.py b/pandas/tests/sparse/test_format.py
deleted file mode 100644
index cf8734910cd19..0000000000000
--- a/pandas/tests/sparse/test_format.py
+++ /dev/null
@@ -1,165 +0,0 @@
-import warnings
-
-import numpy as np
-import pytest
-
-from pandas.compat import is_platform_32bit, is_platform_windows
-
-import pandas as pd
-from pandas import option_context
-import pandas.util.testing as tm
-
-use_32bit_repr = is_platform_windows() or is_platform_32bit()
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseSeriesFormatting:
-    @property
-    def dtype_format_for_platform(self):
-        return "" if use_32bit_repr else ", dtype=int32"
-
-    def test_sparse_max_row(self):
-        s = pd.Series([1, np.nan, np.nan, 3, np.nan]).to_sparse()
-        result = repr(s)
-        dfm = self.dtype_format_for_platform
-        exp = (
-            "0    1.0\n1    NaN\n2    NaN\n3    3.0\n"
-            "4    NaN\ndtype: Sparse[float64, nan]\nBlockIndex\n"
-            "Block locations: array([0, 3]{0})\n"
-            "Block lengths: array([1, 1]{0})".format(dfm)
-        )
-        assert result == exp
-
-    def test_sparsea_max_row_truncated(self):
-        s = pd.Series([1, np.nan, np.nan, 3, np.nan]).to_sparse()
-        dfm = self.dtype_format_for_platform
-
-        with option_context("display.max_rows", 3):
-            # GH 10560
-            result = repr(s)
-            exp = (
-                "0    1.0\n    ... \n4    NaN\n"
-                "Length: 5, dtype: Sparse[float64, nan]\nBlockIndex\n"
-                "Block locations: array([0, 3]{0})\n"
-                "Block lengths: array([1, 1]{0})".format(dfm)
-            )
-            assert result == exp
-
-    def test_sparse_mi_max_row(self):
-        idx = pd.MultiIndex.from_tuples(
-            [("A", 0), ("A", 1), ("B", 0), ("C", 0), ("C", 1), ("C", 2)]
-        )
-        s = pd.Series([1, np.nan, np.nan, 3, np.nan, np.nan], index=idx).to_sparse()
-        result = repr(s)
-        dfm = self.dtype_format_for_platform
-        exp = (
-            "A  0    1.0\n   1    NaN\nB  0    NaN\n"
-            "C  0    3.0\n   1    NaN\n   2    NaN\n"
-            "dtype: Sparse[float64, nan]\nBlockIndex\n"
-            "Block locations: array([0, 3]{0})\n"
-            "Block lengths: array([1, 1]{0})".format(dfm)
-        )
-        assert result == exp
-
-        with option_context("display.max_rows", 3, "display.show_dimensions", False):
-            # GH 13144
-            result = repr(s)
-            exp = (
-                "A  0    1.0\n       ... \nC  2    NaN\n"
-                "dtype: Sparse[float64, nan]\nBlockIndex\n"
-                "Block locations: array([0, 3]{0})\n"
-                "Block lengths: array([1, 1]{0})".format(dfm)
-            )
-            assert result == exp
-
-    def test_sparse_bool(self):
-        # GH 13110
-        s = pd.SparseSeries([True, False, False, True, False, False], fill_value=False)
-        result = repr(s)
-        dtype = "" if use_32bit_repr else ", dtype=int32"
-        exp = (
-            "0     True\n1    False\n2    False\n"
-            "3     True\n4    False\n5    False\n"
-            "dtype: Sparse[bool, False]\nBlockIndex\n"
-            "Block locations: array([0, 3]{0})\n"
-            "Block lengths: array([1, 1]{0})".format(dtype)
-        )
-        assert result == exp
-
-        with option_context("display.max_rows", 3):
-            result = repr(s)
-            exp = (
-                "0     True\n     ...  \n5    False\n"
-                "Length: 6, dtype: Sparse[bool, False]\nBlockIndex\n"
-                "Block locations: array([0, 3]{0})\n"
-                "Block lengths: array([1, 1]{0})".format(dtype)
-            )
-            assert result == exp
-
-    def test_sparse_int(self):
-        # GH 13110
-        s = pd.SparseSeries([0, 1, 0, 0, 1, 0], fill_value=False)
-
-        result = repr(s)
-        dtype = "" if use_32bit_repr else ", dtype=int32"
-        exp = (
-            "0    0\n1    1\n2    0\n3    0\n4    1\n"
-            "5    0\ndtype: Sparse[int64, False]\nBlockIndex\n"
-            "Block locations: array([1, 4]{0})\n"
-            "Block lengths: array([1, 1]{0})".format(dtype)
-        )
-        assert result == exp
-
-        with option_context("display.max_rows", 3, "display.show_dimensions", False):
-            result = repr(s)
-            exp = (
-                "0    0\n    ..\n5    0\n"
-                "dtype: Sparse[int64, False]\nBlockIndex\n"
-                "Block locations: array([1, 4]{0})\n"
-                "Block lengths: array([1, 1]{0})".format(dtype)
-            )
-            assert result == exp
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseDataFrameFormatting:
-    def test_sparse_frame(self):
-        # GH 13110
-        df = pd.DataFrame(
-            {
-                "A": [True, False, True, False, True],
-                "B": [True, False, True, False, True],
-                "C": [0, 0, 3, 0, 5],
-                "D": [np.nan, np.nan, np.nan, 1, 2],
-            }
-        )
-        sparse = df.to_sparse()
-        assert repr(sparse) == repr(df)
-
-        with option_context("display.max_rows", 3):
-            assert repr(sparse) == repr(df)
-
-    def test_sparse_repr_after_set(self):
-        # GH 15488
-        sdf = pd.SparseDataFrame([[np.nan, 1], [2, np.nan]])
-        res = sdf.copy()
-
-        # Ignore the warning
-        with pd.option_context("mode.chained_assignment", None):
-            sdf[0][1] = 2  # This line triggers the bug
-
-        repr(sdf)
-        tm.assert_sp_frame_equal(sdf, res)
-
-
-def test_repr_no_warning():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", FutureWarning)
-        df = pd.SparseDataFrame({"A": [1, 2]})
-        s = df["A"]
-
-    with tm.assert_produces_warning(None):
-        repr(df)
-        repr(s)
diff --git a/pandas/tests/sparse/test_groupby.py b/pandas/tests/sparse/test_groupby.py
deleted file mode 100644
index 04e49a272a77a..0000000000000
--- a/pandas/tests/sparse/test_groupby.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-import pandas.util.testing as tm
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestSparseGroupBy:
-    def setup_method(self, method):
-        self.dense = pd.DataFrame(
-            {
-                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
-                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
-                "C": np.random.randn(8),
-                "D": np.random.randn(8),
-                "E": [np.nan, np.nan, 1, 2, np.nan, 1, np.nan, np.nan],
-            }
-        )
-        self.sparse = self.dense.to_sparse()
-
-    def test_first_last_nth(self):
-        # tests for first / last / nth
-        sparse_grouped = self.sparse.groupby("A")
-        dense_grouped = self.dense.groupby("A")
-
-        sparse_grouped_first = sparse_grouped.first()
-        sparse_grouped_last = sparse_grouped.last()
-        sparse_grouped_nth = sparse_grouped.nth(1)
-
-        dense_grouped_first = pd.DataFrame(dense_grouped.first().to_sparse())
-        dense_grouped_last = pd.DataFrame(dense_grouped.last().to_sparse())
-        dense_grouped_nth = pd.DataFrame(dense_grouped.nth(1).to_sparse())
-
-        tm.assert_frame_equal(sparse_grouped_first, dense_grouped_first)
-        tm.assert_frame_equal(sparse_grouped_last, dense_grouped_last)
-        tm.assert_frame_equal(sparse_grouped_nth, dense_grouped_nth)
-
-    def test_aggfuncs(self):
-        sparse_grouped = self.sparse.groupby("A")
-        dense_grouped = self.dense.groupby("A")
-
-        result = sparse_grouped.mean().to_sparse()
-        expected = dense_grouped.mean().to_sparse()
-
-        tm.assert_frame_equal(result, expected)
-
-        # ToDo: sparse sum includes str column
-        # tm.assert_frame_equal(sparse_grouped.sum(),
-        #                       dense_grouped.sum())
-
-        result = sparse_grouped.count().to_sparse()
-        expected = dense_grouped.count().to_sparse()
-
-        tm.assert_frame_equal(result, expected)
-
-
-@pytest.mark.parametrize("fill_value", [0, np.nan])
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-def test_groupby_includes_fill_value(fill_value):
-    # https://github.com/pandas-dev/pandas/issues/5078
-    df = pd.DataFrame(
-        {
-            "a": [fill_value, 1, fill_value, fill_value],
-            "b": [fill_value, 1, fill_value, fill_value],
-        }
-    )
-    sdf = df.to_sparse(fill_value=fill_value)
-    result = sdf.groupby("a").sum()
-    expected = pd.DataFrame(df.groupby("a").sum().to_sparse(fill_value=fill_value))
-    tm.assert_frame_equal(result, expected, check_index_type=False)
diff --git a/pandas/tests/sparse/test_indexing.py b/pandas/tests/sparse/test_indexing.py
deleted file mode 100644
index ea5e939b57566..0000000000000
--- a/pandas/tests/sparse/test_indexing.py
+++ /dev/null
@@ -1,1058 +0,0 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-from pandas.core.sparse.api import SparseDtype
-import pandas.util.testing as tm
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseSeriesIndexing:
-    def setup_method(self, method):
-        self.orig = pd.Series([1, np.nan, np.nan, 3, np.nan])
-        self.sparse = self.orig.to_sparse()
-
-    def test_getitem(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse[0] == 1
-        assert np.isnan(sparse[1])
-        assert sparse[3] == 3
-
-        result = sparse[[1, 3, 4]]
-        exp = orig[[1, 3, 4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse[orig % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse[sparse % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_getitem_slice(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        tm.assert_sp_series_equal(sparse[:2], orig[:2].to_sparse())
-        tm.assert_sp_series_equal(sparse[4:2], orig[4:2].to_sparse())
-        tm.assert_sp_series_equal(sparse[::2], orig[::2].to_sparse())
-        tm.assert_sp_series_equal(sparse[-5:], orig[-5:].to_sparse())
-
-    def test_getitem_int_dtype(self):
-        # GH 8292
-        s = pd.SparseSeries([0, 1, 2, 3, 4, 5, 6], name="xxx")
-        res = s[::2]
-        exp = pd.SparseSeries([0, 2, 4, 6], index=[0, 2, 4, 6], name="xxx")
-        tm.assert_sp_series_equal(res, exp)
-        assert res.dtype == SparseDtype(np.int64)
-
-        s = pd.SparseSeries([0, 1, 2, 3, 4, 5, 6], fill_value=0, name="xxx")
-        res = s[::2]
-        exp = pd.SparseSeries(
-            [0, 2, 4, 6], index=[0, 2, 4, 6], fill_value=0, name="xxx"
-        )
-        tm.assert_sp_series_equal(res, exp)
-        assert res.dtype == SparseDtype(np.int64)
-
-    def test_getitem_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse(fill_value=0)
-
-        assert sparse[0] == 1
-        assert np.isnan(sparse[1])
-        assert sparse[2] == 0
-        assert sparse[3] == 3
-
-        result = sparse[[1, 3, 4]]
-        exp = orig[[1, 3, 4]].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse[orig % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse[sparse % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_getitem_ellipsis(self):
-        # GH 9467
-        s = pd.SparseSeries([1, np.nan, 2, 0, np.nan])
-        tm.assert_sp_series_equal(s[...], s)
-
-        s = pd.SparseSeries([1, np.nan, 2, 0, np.nan], fill_value=0)
-        tm.assert_sp_series_equal(s[...], s)
-
-    def test_getitem_slice_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(sparse[:2], orig[:2].to_sparse(fill_value=0))
-        tm.assert_sp_series_equal(sparse[4:2], orig[4:2].to_sparse(fill_value=0))
-        tm.assert_sp_series_equal(sparse[::2], orig[::2].to_sparse(fill_value=0))
-        tm.assert_sp_series_equal(sparse[-5:], orig[-5:].to_sparse(fill_value=0))
-
-    def test_loc(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse.loc[0] == 1
-        assert np.isnan(sparse.loc[1])
-
-        result = sparse.loc[[1, 3, 4]]
-        exp = orig.loc[[1, 3, 4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # exceeds the bounds
-        result = sparse.reindex([1, 3, 4, 5])
-        exp = orig.reindex([1, 3, 4, 5]).to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-        # padded with NaN
-        assert np.isnan(result[-1])
-
-        # dense array
-        result = sparse.loc[orig % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse.loc[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_loc_index(self):
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan], index=list("ABCDE"))
-        sparse = orig.to_sparse()
-
-        assert sparse.loc["A"] == 1
-        assert np.isnan(sparse.loc["B"])
-
-        result = sparse.loc[["A", "C", "D"]]
-        exp = orig.loc[["A", "C", "D"]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse.loc[orig % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_loc_index_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        assert sparse.loc["A"] == 1
-        assert np.isnan(sparse.loc["B"])
-
-        result = sparse.loc[["A", "C", "D"]]
-        exp = orig.loc[["A", "C", "D"]].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse.loc[orig % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_loc_slice(self):
-        orig = self.orig
-        sparse = self.sparse
-        tm.assert_sp_series_equal(sparse.loc[2:], orig.loc[2:].to_sparse())
-
-    def test_loc_slice_index_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        tm.assert_sp_series_equal(
-            sparse.loc["C":], orig.loc["C":].to_sparse(fill_value=0)
-        )
-
-    def test_loc_slice_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(sparse.loc[2:], orig.loc[2:].to_sparse(fill_value=0))
-
-    def test_iloc(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse.iloc[3] == 3
-        assert np.isnan(sparse.iloc[2])
-
-        result = sparse.iloc[[1, 3, 4]]
-        exp = orig.iloc[[1, 3, 4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        result = sparse.iloc[[1, -2, -4]]
-        exp = orig.iloc[[1, -2, -4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        with pytest.raises(IndexError):
-            sparse.iloc[[1, 3, 5]]
-
-    def test_iloc_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse(fill_value=0)
-
-        assert sparse.iloc[3] == 3
-        assert np.isnan(sparse.iloc[1])
-        assert sparse.iloc[4] == 0
-
-        result = sparse.iloc[[1, 3, 4]]
-        exp = orig.iloc[[1, 3, 4]].to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_iloc_slice(self):
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan])
-        sparse = orig.to_sparse()
-        tm.assert_sp_series_equal(sparse.iloc[2:], orig.iloc[2:].to_sparse())
-
-    def test_iloc_slice_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(
-            sparse.iloc[2:], orig.iloc[2:].to_sparse(fill_value=0)
-        )
-
-    def test_at(self):
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan])
-        sparse = orig.to_sparse()
-        assert sparse.at[0] == orig.at[0]
-        assert np.isnan(sparse.at[1])
-        assert np.isnan(sparse.at[2])
-        assert sparse.at[3] == orig.at[3]
-        assert np.isnan(sparse.at[4])
-
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan], index=list("abcde"))
-        sparse = orig.to_sparse()
-        assert sparse.at["a"] == orig.at["a"]
-        assert np.isnan(sparse.at["b"])
-        assert np.isnan(sparse.at["c"])
-        assert sparse.at["d"] == orig.at["d"]
-        assert np.isnan(sparse.at["e"])
-
-    def test_at_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("abcde"))
-        sparse = orig.to_sparse(fill_value=0)
-        assert sparse.at["a"] == orig.at["a"]
-        assert np.isnan(sparse.at["b"])
-        assert sparse.at["c"] == orig.at["c"]
-        assert sparse.at["d"] == orig.at["d"]
-        assert sparse.at["e"] == orig.at["e"]
-
-    def test_iat(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse.iat[0] == orig.iat[0]
-        assert np.isnan(sparse.iat[1])
-        assert np.isnan(sparse.iat[2])
-        assert sparse.iat[3] == orig.iat[3]
-        assert np.isnan(sparse.iat[4])
-
-        assert np.isnan(sparse.iat[-1])
-        assert sparse.iat[-5] == orig.iat[-5]
-
-    def test_iat_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0])
-        sparse = orig.to_sparse()
-        assert sparse.iat[0] == orig.iat[0]
-        assert np.isnan(sparse.iat[1])
-        assert sparse.iat[2] == orig.iat[2]
-        assert sparse.iat[3] == orig.iat[3]
-        assert sparse.iat[4] == orig.iat[4]
-
-        assert sparse.iat[-1] == orig.iat[-1]
-        assert sparse.iat[-5] == orig.iat[-5]
-
-    def test_get(self):
-        s = pd.SparseSeries([1, np.nan, np.nan, 3, np.nan])
-        assert s.get(0) == 1
-        assert np.isnan(s.get(1))
-        assert s.get(5) is None
-
-        s = pd.SparseSeries([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        assert s.get("A") == 1
-        assert np.isnan(s.get("B"))
-        assert s.get("C") == 0
-        assert s.get("XX") is None
-
-        s = pd.SparseSeries([1, np.nan, 0, 3, 0], index=list("ABCDE"), fill_value=0)
-        assert s.get("A") == 1
-        assert np.isnan(s.get("B"))
-        assert s.get("C") == 0
-        assert s.get("XX") is None
-
-    def test_take(self):
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan], index=list("ABCDE"))
-        sparse = orig.to_sparse()
-
-        tm.assert_sp_series_equal(sparse.take([0]), orig.take([0]).to_sparse())
-        tm.assert_sp_series_equal(
-            sparse.take([0, 1, 3]), orig.take([0, 1, 3]).to_sparse()
-        )
-        tm.assert_sp_series_equal(
-            sparse.take([-1, -2]), orig.take([-1, -2]).to_sparse()
-        )
-
-    def test_take_fill_value(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        tm.assert_sp_series_equal(
-            sparse.take([0]), orig.take([0]).to_sparse(fill_value=0)
-        )
-
-        exp = orig.take([0, 1, 3]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(sparse.take([0, 1, 3]), exp)
-
-        exp = orig.take([-1, -2]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(sparse.take([-1, -2]), exp)
-
-    def test_reindex(self):
-        orig = pd.Series([1, np.nan, np.nan, 3, np.nan], index=list("ABCDE"))
-        sparse = orig.to_sparse()
-
-        res = sparse.reindex(["A", "E", "C", "D"])
-        exp = orig.reindex(["A", "E", "C", "D"]).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-        # all missing & fill_value
-        res = sparse.reindex(["B", "E", "C"])
-        exp = orig.reindex(["B", "E", "C"]).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-        orig = pd.Series([np.nan, np.nan, np.nan, np.nan, np.nan], index=list("ABCDE"))
-        sparse = orig.to_sparse()
-
-        res = sparse.reindex(["A", "E", "C", "D"])
-        exp = orig.reindex(["A", "E", "C", "D"]).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-    def test_fill_value_reindex(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "E", "C", "D"])
-        exp = orig.reindex(["A", "E", "C", "D"]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(res, exp)
-
-        # includes missing and fill_value
-        res = sparse.reindex(["A", "B", "C"])
-        exp = orig.reindex(["A", "B", "C"]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(res, exp)
-
-        # all missing
-        orig = pd.Series([np.nan, np.nan, np.nan, np.nan, np.nan], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "E", "C", "D"])
-        exp = orig.reindex(["A", "E", "C", "D"]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(res, exp)
-
-        # all fill_value
-        orig = pd.Series([0.0, 0.0, 0.0, 0.0, 0.0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-    def test_fill_value_reindex_coerces_float_int(self):
-        orig = pd.Series([1, np.nan, 0, 3, 0], index=list("ABCDE"))
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "E", "C", "D"])
-        exp = orig.reindex(["A", "E", "C", "D"]).to_sparse(fill_value=0)
-        tm.assert_sp_series_equal(res, exp)
-
-    def test_reindex_fill_value(self):
-        floats = pd.Series([1.0, 2.0, 3.0]).to_sparse()
-        result = floats.reindex([1, 2, 3], fill_value=0)
-        expected = pd.Series([2.0, 3.0, 0], index=[1, 2, 3]).to_sparse()
-        tm.assert_sp_series_equal(result, expected)
-
-    def test_reindex_nearest(self):
-        s = pd.Series(np.arange(10, dtype="float64")).to_sparse()
-        target = [0.1, 0.9, 1.5, 2.0]
-        actual = s.reindex(target, method="nearest")
-        expected = pd.Series(np.around(target), target).to_sparse()
-        tm.assert_sp_series_equal(expected, actual)
-
-        actual = s.reindex(target, method="nearest", tolerance=0.2)
-        expected = pd.Series([0, 1, np.nan, 2], target).to_sparse()
-        tm.assert_sp_series_equal(expected, actual)
-
-        actual = s.reindex(target, method="nearest", tolerance=[0.3, 0.01, 0.4, 3])
-        expected = pd.Series([0, np.nan, np.nan, 2], target).to_sparse()
-        tm.assert_sp_series_equal(expected, actual)
-
-    @pytest.mark.parametrize("kind", ["integer", "block"])
-    @pytest.mark.parametrize("fill", [True, False, np.nan])
-    def tests_indexing_with_sparse(self, kind, fill):
-        # see gh-13985
-        arr = pd.SparseArray([1, 2, 3], kind=kind)
-        indexer = pd.SparseArray([True, False, True], fill_value=fill, dtype=bool)
-
-        expected = arr[indexer]
-        result = pd.SparseArray([1, 3], kind=kind)
-        tm.assert_sp_array_equal(result, expected)
-
-        s = pd.SparseSeries(arr, index=["a", "b", "c"], dtype=np.float64)
-        expected = pd.SparseSeries(
-            [1, 3],
-            index=["a", "c"],
-            kind=kind,
-            dtype=SparseDtype(np.float64, s.fill_value),
-        )
-
-        tm.assert_sp_series_equal(s[indexer], expected)
-        tm.assert_sp_series_equal(s.loc[indexer], expected)
-        tm.assert_sp_series_equal(s.iloc[indexer], expected)
-
-        indexer = pd.SparseSeries(indexer, index=["a", "b", "c"])
-        tm.assert_sp_series_equal(s[indexer], expected)
-        tm.assert_sp_series_equal(s.loc[indexer], expected)
-
-        msg = "iLocation based boolean indexing cannot use an indexable as a mask"
-        with pytest.raises(ValueError, match=msg):
-            s.iloc[indexer]
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-class TestSparseSeriesMultiIndexing(TestSparseSeriesIndexing):
-    def setup_method(self, method):
-        # Mi with duplicated values
-        idx = pd.MultiIndex.from_tuples(
-            [("A", 0), ("A", 1), ("B", 0), ("C", 0), ("C", 1)]
-        )
-        self.orig = pd.Series([1, np.nan, np.nan, 3, np.nan], index=idx)
-        self.sparse = self.orig.to_sparse()
-
-    def test_getitem_multi(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse[0] == orig[0]
-        assert np.isnan(sparse[1])
-        assert sparse[3] == orig[3]
-
-        tm.assert_sp_series_equal(sparse["A"], orig["A"].to_sparse())
-        tm.assert_sp_series_equal(sparse["B"], orig["B"].to_sparse())
-
-        result = sparse[[1, 3, 4]]
-        exp = orig[[1, 3, 4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse[orig % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse[sparse % 2 == 1]
-        exp = orig[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_getitem_multi_tuple(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse["C", 0] == orig["C", 0]
-        assert np.isnan(sparse["A", 1])
-        assert np.isnan(sparse["B", 0])
-
-    def test_getitems_slice_multi(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        tm.assert_sp_series_equal(sparse[2:], orig[2:].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc["B":], orig.loc["B":].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc["C":], orig.loc["C":].to_sparse())
-
-        tm.assert_sp_series_equal(sparse.loc["A":"B"], orig.loc["A":"B"].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc[:"B"], orig.loc[:"B"].to_sparse())
-
-    def test_loc(self):
-        # need to be override to use different label
-        orig = self.orig
-        sparse = self.sparse
-
-        tm.assert_sp_series_equal(sparse.loc["A"], orig.loc["A"].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc["B"], orig.loc["B"].to_sparse())
-
-        result = sparse.loc[[1, 3, 4]]
-        exp = orig.loc[[1, 3, 4]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # exceeds the bounds
-        result = sparse.loc[[1, 3, 4, 5]]
-        exp = orig.loc[[1, 3, 4, 5]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # single element list (GH 15447)
-        result = sparse.loc[["A"]]
-        exp = orig.loc[["A"]].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # dense array
-        result = sparse.loc[orig % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse % 2 == 1]
-        exp = orig.loc[orig % 2 == 1].to_sparse()
-        tm.assert_sp_series_equal(result, exp)
-
-        # sparse array
-        result = sparse.loc[pd.SparseArray(sparse % 2 == 1, dtype=bool)]
-        tm.assert_sp_series_equal(result, exp)
-
-    def test_loc_multi_tuple(self):
-        orig = self.orig
-        sparse = self.sparse
-
-        assert sparse.loc["C", 0] == orig.loc["C", 0]
-        assert np.isnan(sparse.loc["A", 1])
-        assert np.isnan(sparse.loc["B", 0])
-
-    def test_loc_slice(self):
-        orig = self.orig
-        sparse = self.sparse
-        tm.assert_sp_series_equal(sparse.loc["A":], orig.loc["A":].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc["B":], orig.loc["B":].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc["C":], orig.loc["C":].to_sparse())
-
-        tm.assert_sp_series_equal(sparse.loc["A":"B"], orig.loc["A":"B"].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc[:"B"], orig.loc[:"B"].to_sparse())
-
-    def test_reindex(self):
-        # GH 15447
-        orig = self.orig
-        sparse = self.sparse
-
-        res = sparse.reindex([("A", 0), ("C", 1)])
-        exp = orig.reindex([("A", 0), ("C", 1)]).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-        # On specific level:
-        res = sparse.reindex(["A", "C", "B"], level=0)
-        exp = orig.reindex(["A", "C", "B"], level=0).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-        # single element list (GH 15447)
-        res = sparse.reindex(["A"], level=0)
-        exp = orig.reindex(["A"], level=0).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-
-        with pytest.raises(TypeError):
-            # Incomplete keys are not accepted for reindexing:
-            sparse.reindex(["A", "C"])
-
-        # "copy" argument:
-        res = sparse.reindex(sparse.index, copy=True)
-        exp = orig.reindex(orig.index, copy=True).to_sparse()
-        tm.assert_sp_series_equal(res, exp)
-        assert sparse is not res
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-class TestSparseDataFrameIndexing:
-    def test_getitem(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4], [0, np.nan, 5]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        tm.assert_sp_series_equal(sparse["x"], orig["x"].to_sparse())
-        tm.assert_sp_frame_equal(sparse[["x"]], orig[["x"]].to_sparse())
-        tm.assert_sp_frame_equal(sparse[["z", "x"]], orig[["z", "x"]].to_sparse())
-
-        tm.assert_sp_frame_equal(
-            sparse[[True, False, True, True]],
-            orig[[True, False, True, True]].to_sparse(),
-        )
-
-        tm.assert_sp_frame_equal(sparse.iloc[[1, 2]], orig.iloc[[1, 2]].to_sparse())
-
-    def test_getitem_fill_value(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-
-        result = sparse[["z"]]
-        expected = orig[["z"]].to_sparse(fill_value=0)
-        tm.assert_sp_frame_equal(result, expected, check_fill_value=False)
-
-        tm.assert_sp_series_equal(sparse["y"], orig["y"].to_sparse(fill_value=0))
-
-        exp = orig[["x"]].to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse[["x"]], exp)
-
-        exp = orig[["z", "x"]].to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse[["z", "x"]], exp)
-
-        indexer = [True, False, True, True]
-        exp = orig[indexer].to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse[indexer], exp)
-
-        exp = orig.iloc[[1, 2]].to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse.iloc[[1, 2]], exp)
-
-    def test_loc(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        assert sparse.loc[0, "x"] == 1
-        assert np.isnan(sparse.loc[1, "z"])
-        assert sparse.loc[2, "z"] == 4
-
-        # have to specify `kind='integer'`, since we construct a
-        # new SparseArray here, and the default sparse type is
-        # integer there, but block in SparseSeries
-        tm.assert_sp_series_equal(sparse.loc[0], orig.loc[0].to_sparse(kind="integer"))
-        tm.assert_sp_series_equal(sparse.loc[1], orig.loc[1].to_sparse(kind="integer"))
-        tm.assert_sp_series_equal(
-            sparse.loc[2, :], orig.loc[2, :].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.loc[2, :], orig.loc[2, :].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(sparse.loc[:, "y"], orig.loc[:, "y"].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc[:, "y"], orig.loc[:, "y"].to_sparse())
-
-        result = sparse.loc[[1, 2]]
-        exp = orig.loc[[1, 2]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[[1, 2], :]
-        exp = orig.loc[[1, 2], :].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[:, ["x", "z"]]
-        exp = orig.loc[:, ["x", "z"]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[[0, 2], ["x", "z"]]
-        exp = orig.loc[[0, 2], ["x", "z"]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # exceeds the bounds
-        result = sparse.reindex([1, 3, 4, 5])
-        exp = orig.reindex([1, 3, 4, 5]).to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # dense array
-        result = sparse.loc[orig.x % 2 == 1]
-        exp = orig.loc[orig.x % 2 == 1].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse.x % 2 == 1]
-        exp = orig.loc[orig.x % 2 == 1].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # sparse array
-        result = sparse.loc[pd.SparseArray(sparse.x % 2 == 1, dtype=bool)]
-        tm.assert_sp_frame_equal(result, exp)
-
-    def test_loc_index(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4]],
-            index=list("abc"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        assert sparse.loc["a", "x"] == 1
-        assert np.isnan(sparse.loc["b", "z"])
-        assert sparse.loc["c", "z"] == 4
-
-        tm.assert_sp_series_equal(
-            sparse.loc["a"], orig.loc["a"].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.loc["b"], orig.loc["b"].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.loc["b", :], orig.loc["b", :].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.loc["b", :], orig.loc["b", :].to_sparse(kind="integer")
-        )
-
-        tm.assert_sp_series_equal(sparse.loc[:, "z"], orig.loc[:, "z"].to_sparse())
-        tm.assert_sp_series_equal(sparse.loc[:, "z"], orig.loc[:, "z"].to_sparse())
-
-        result = sparse.loc[["a", "b"]]
-        exp = orig.loc[["a", "b"]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[["a", "b"], :]
-        exp = orig.loc[["a", "b"], :].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[:, ["x", "z"]]
-        exp = orig.loc[:, ["x", "z"]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.loc[["c", "a"], ["x", "z"]]
-        exp = orig.loc[["c", "a"], ["x", "z"]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # dense array
-        result = sparse.loc[orig.x % 2 == 1]
-        exp = orig.loc[orig.x % 2 == 1].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # sparse array (actuary it coerces to normal Series)
-        result = sparse.loc[sparse.x % 2 == 1]
-        exp = orig.loc[orig.x % 2 == 1].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        # sparse array
-        result = sparse.loc[pd.SparseArray(sparse.x % 2 == 1, dtype=bool)]
-        tm.assert_sp_frame_equal(result, exp)
-
-    def test_loc_slice(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-        tm.assert_sp_frame_equal(sparse.loc[2:], orig.loc[2:].to_sparse())
-
-    def test_iloc(self):
-        orig = pd.DataFrame([[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4]])
-        sparse = orig.to_sparse()
-
-        assert sparse.iloc[1, 1] == 3
-        assert np.isnan(sparse.iloc[2, 0])
-
-        tm.assert_sp_series_equal(sparse.iloc[0], orig.loc[0].to_sparse(kind="integer"))
-        tm.assert_sp_series_equal(sparse.iloc[1], orig.loc[1].to_sparse(kind="integer"))
-        tm.assert_sp_series_equal(
-            sparse.iloc[2, :], orig.iloc[2, :].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(
-            sparse.iloc[2, :], orig.iloc[2, :].to_sparse(kind="integer")
-        )
-        tm.assert_sp_series_equal(sparse.iloc[:, 1], orig.iloc[:, 1].to_sparse())
-        tm.assert_sp_series_equal(sparse.iloc[:, 1], orig.iloc[:, 1].to_sparse())
-
-        result = sparse.iloc[[1, 2]]
-        exp = orig.iloc[[1, 2]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.iloc[[1, 2], :]
-        exp = orig.iloc[[1, 2], :].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.iloc[:, [1, 0]]
-        exp = orig.iloc[:, [1, 0]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        result = sparse.iloc[[2], [1, 0]]
-        exp = orig.iloc[[2], [1, 0]].to_sparse()
-        tm.assert_sp_frame_equal(result, exp)
-
-        with pytest.raises(IndexError):
-            sparse.iloc[[1, 3, 5]]
-
-    def test_iloc_slice(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, 4]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-        tm.assert_sp_frame_equal(sparse.iloc[2:], orig.iloc[2:].to_sparse())
-
-    def test_at(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-        assert sparse.at["A", "x"] == orig.at["A", "x"]
-        assert np.isnan(sparse.at["B", "z"])
-        assert np.isnan(sparse.at["C", "y"])
-        assert sparse.at["D", "x"] == orig.at["D", "x"]
-
-    def test_at_fill_value(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-        assert sparse.at["A", "x"] == orig.at["A", "x"]
-        assert np.isnan(sparse.at["B", "z"])
-        assert np.isnan(sparse.at["C", "y"])
-        assert sparse.at["D", "x"] == orig.at["D", "x"]
-
-    def test_iat(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-        assert sparse.iat[0, 0] == orig.iat[0, 0]
-        assert np.isnan(sparse.iat[1, 2])
-        assert np.isnan(sparse.iat[2, 1])
-        assert sparse.iat[2, 0] == orig.iat[2, 0]
-
-        assert np.isnan(sparse.iat[-1, -2])
-        assert sparse.iat[-1, -1] == orig.iat[-1, -1]
-
-    def test_iat_fill_value(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-        assert sparse.iat[0, 0] == orig.iat[0, 0]
-        assert np.isnan(sparse.iat[1, 2])
-        assert np.isnan(sparse.iat[2, 1])
-        assert sparse.iat[2, 0] == orig.iat[2, 0]
-
-        assert np.isnan(sparse.iat[-1, -2])
-        assert sparse.iat[-1, -1] == orig.iat[-1, -1]
-
-    def test_take(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        tm.assert_sp_frame_equal(sparse.take([0]), orig.take([0]).to_sparse())
-        tm.assert_sp_frame_equal(sparse.take([0, 1]), orig.take([0, 1]).to_sparse())
-        tm.assert_sp_frame_equal(sparse.take([-1, -2]), orig.take([-1, -2]).to_sparse())
-
-    def test_take_fill_value(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-
-        exp = orig.take([0]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse.take([0]), exp)
-
-        exp = orig.take([0, 1]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse.take([0, 1]), exp)
-
-        exp = orig.take([-1, -2]).to_sparse(fill_value=0)
-        exp._default_fill_value = np.nan
-        tm.assert_sp_frame_equal(sparse.take([-1, -2]), exp)
-
-    def test_reindex(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        res = sparse.reindex(["A", "C", "B"])
-        exp = orig.reindex(["A", "C", "B"]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp)
-
-        orig = pd.DataFrame(
-            [
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-            ],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse()
-
-        res = sparse.reindex(["A", "C", "B"])
-        exp = orig.reindex(["A", "C", "B"]).to_sparse()
-        tm.assert_sp_frame_equal(res, exp)
-
-    def test_reindex_fill_value(self):
-        orig = pd.DataFrame(
-            [[1, np.nan, 0], [2, 3, np.nan], [0, np.nan, 4], [0, np.nan, 5]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "C", "B"])
-        exp = orig.reindex(["A", "C", "B"]).to_sparse(fill_value=0)
-        tm.assert_sp_frame_equal(res, exp)
-
-        # all missing
-        orig = pd.DataFrame(
-            [
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-                [np.nan, np.nan, np.nan],
-            ],
-            index=list("ABCD"),
-            columns=list("xyz"),
-        )
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "C", "B"])
-        exp = orig.reindex(["A", "C", "B"]).to_sparse(fill_value=0)
-        tm.assert_sp_frame_equal(res, exp)
-
-        # all fill_value
-        orig = pd.DataFrame(
-            [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],
-            index=list("ABCD"),
-            columns=list("xyz"),
-            dtype=np.int,
-        )
-        sparse = orig.to_sparse(fill_value=0)
-
-        res = sparse.reindex(["A", "C", "B"])
-        exp = orig.reindex(["A", "C", "B"]).to_sparse(fill_value=0)
-        tm.assert_sp_frame_equal(res, exp)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-class TestMultitype:
-    def setup_method(self, method):
-        self.cols = ["string", "int", "float", "object"]
-
-        self.string_series = pd.SparseSeries(["a", "b", "c"])
-        self.int_series = pd.SparseSeries([1, 2, 3])
-        self.float_series = pd.SparseSeries([1.1, 1.2, 1.3])
-        self.object_series = pd.SparseSeries([[], {}, set()])
-        self.sdf = pd.SparseDataFrame(
-            {
-                "string": self.string_series,
-                "int": self.int_series,
-                "float": self.float_series,
-                "object": self.object_series,
-            }
-        )
-        self.sdf = self.sdf[self.cols]
-        self.ss = pd.SparseSeries(["a", 1, 1.1, []], index=self.cols)
-
-    def test_frame_basic_dtypes(self):
-        for _, row in self.sdf.iterrows():
-            assert row.dtype == SparseDtype(object)
-        tm.assert_sp_series_equal(
-            self.sdf["string"], self.string_series, check_names=False
-        )
-        tm.assert_sp_series_equal(self.sdf["int"], self.int_series, check_names=False)
-        tm.assert_sp_series_equal(
-            self.sdf["float"], self.float_series, check_names=False
-        )
-        tm.assert_sp_series_equal(
-            self.sdf["object"], self.object_series, check_names=False
-        )
-
-    def test_frame_indexing_single(self):
-        tm.assert_sp_series_equal(
-            self.sdf.iloc[0],
-            pd.SparseSeries(["a", 1, 1.1, []], index=self.cols),
-            check_names=False,
-        )
-        tm.assert_sp_series_equal(
-            self.sdf.iloc[1],
-            pd.SparseSeries(["b", 2, 1.2, {}], index=self.cols),
-            check_names=False,
-        )
-        tm.assert_sp_series_equal(
-            self.sdf.iloc[2],
-            pd.SparseSeries(["c", 3, 1.3, set()], index=self.cols),
-            check_names=False,
-        )
-
-    def test_frame_indexing_multiple(self):
-        tm.assert_sp_frame_equal(self.sdf, self.sdf[:])
-        tm.assert_sp_frame_equal(self.sdf, self.sdf.loc[:])
-        tm.assert_sp_frame_equal(
-            self.sdf.iloc[[1, 2]],
-            pd.SparseDataFrame(
-                {
-                    "string": self.string_series.iloc[[1, 2]],
-                    "int": self.int_series.iloc[[1, 2]],
-                    "float": self.float_series.iloc[[1, 2]],
-                    "object": self.object_series.iloc[[1, 2]],
-                },
-                index=[1, 2],
-            )[self.cols],
-        )
-        tm.assert_sp_frame_equal(
-            self.sdf[["int", "string"]],
-            pd.SparseDataFrame({"int": self.int_series, "string": self.string_series}),
-        )
-
-    def test_series_indexing_single(self):
-        for i, idx in enumerate(self.cols):
-            assert self.ss.iloc[i] == self.ss[idx]
-            tm.assert_class_equal(self.ss.iloc[i], self.ss[idx], obj="series index")
-
-        assert self.ss["string"] == "a"
-        assert self.ss["int"] == 1
-        assert self.ss["float"] == 1.1
-        assert self.ss["object"] == []
-
-    def test_series_indexing_multiple(self):
-        tm.assert_sp_series_equal(
-            self.ss.loc[["string", "int"]],
-            pd.SparseSeries(["a", 1], index=["string", "int"]),
-        )
-        tm.assert_sp_series_equal(
-            self.ss.loc[["string", "object"]],
-            pd.SparseSeries(["a", []], index=["string", "object"]),
-        )
diff --git a/pandas/tests/sparse/test_pivot.py b/pandas/tests/sparse/test_pivot.py
deleted file mode 100644
index 880c1c55f9f79..0000000000000
--- a/pandas/tests/sparse/test_pivot.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-import pandas.util.testing as tm
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
-@pytest.mark.filterwarnings("ignore:DataFrame.to_sparse:FutureWarning")
-class TestPivotTable:
-    def setup_method(self, method):
-        rs = np.random.RandomState(0)
-        self.dense = pd.DataFrame(
-            {
-                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
-                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
-                "C": rs.randn(8),
-                "D": rs.randn(8),
-                "E": [np.nan, np.nan, 1, 2, np.nan, 1, np.nan, np.nan],
-            }
-        )
-        self.sparse = self.dense.to_sparse()
-
-    def test_pivot_table(self):
-        res_sparse = pd.pivot_table(self.sparse, index="A", columns="B", values="C")
-        res_dense = pd.pivot_table(self.dense, index="A", columns="B", values="C")
-        tm.assert_frame_equal(res_sparse, res_dense)
-
-        res_sparse = pd.pivot_table(self.sparse, index="A", columns="B", values="E")
-        res_dense = pd.pivot_table(self.dense, index="A", columns="B", values="E")
-        tm.assert_frame_equal(res_sparse, res_dense)
-
-        res_sparse = pd.pivot_table(
-            self.sparse, index="A", columns="B", values="E", aggfunc="mean"
-        )
-        res_dense = pd.pivot_table(
-            self.dense, index="A", columns="B", values="E", aggfunc="mean"
-        )
-        tm.assert_frame_equal(res_sparse, res_dense)
-
-    def test_pivot_table_with_nans(self):
-        res_sparse = pd.pivot_table(
-            self.sparse, index="A", columns="B", values="E", aggfunc="sum"
-        )
-        res_dense = pd.pivot_table(
-            self.dense, index="A", columns="B", values="E", aggfunc="sum"
-        )
-        tm.assert_frame_equal(res_sparse, res_dense)
-
-    def test_pivot_table_multi(self):
-        res_sparse = pd.pivot_table(
-            self.sparse, index="A", columns="B", values=["D", "E"]
-        )
-        res_dense = pd.pivot_table(
-            self.dense, index="A", columns="B", values=["D", "E"]
-        )
-        res_dense = res_dense.apply(lambda x: x.astype("Sparse[float64]"))
-        tm.assert_frame_equal(res_sparse, res_dense)
diff --git a/pandas/tests/sparse/test_reshape.py b/pandas/tests/sparse/test_reshape.py
deleted file mode 100644
index bb5232f065a04..0000000000000
--- a/pandas/tests/sparse/test_reshape.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-import pandas.util.testing as tm
-
-
-@pytest.fixture
-def sparse_df():
-    return pd.SparseDataFrame({0: {0: 1}, 1: {1: 1}, 2: {2: 1}})  # eye
-
-
-@pytest.fixture
-def multi_index3():
-    return pd.MultiIndex.from_tuples([(0, 0), (1, 1), (2, 2)])
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_sparse_frame_stack(sparse_df, multi_index3):
-    ss = sparse_df.stack()
-    expected = pd.SparseSeries(np.ones(3), index=multi_index3)
-    tm.assert_sp_series_equal(ss, expected)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_sparse_frame_unstack(sparse_df):
-    mi = pd.MultiIndex.from_tuples([(0, 0), (1, 0), (1, 2)])
-    sparse_df.index = mi
-    arr = np.array([[1, np.nan, np.nan], [np.nan, 1, np.nan], [np.nan, np.nan, 1]])
-    unstacked_df = pd.DataFrame(arr, index=mi).unstack()
-    unstacked_sdf = sparse_df.unstack()
-
-    tm.assert_numpy_array_equal(unstacked_df.values, unstacked_sdf.values)
-
-
-@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
-def test_sparse_series_unstack(sparse_df, multi_index3):
-    frame = pd.SparseSeries(np.ones(3), index=multi_index3).unstack()
-
-    arr = np.array([1, np.nan, np.nan])
-    arrays = {i: pd.SparseArray(np.roll(arr, i)) for i in range(3)}
-    expected = pd.DataFrame(arrays)
-    tm.assert_frame_equal(frame, expected)
diff --git a/pandas/tests/test_aggregation.py b/pandas/tests/test_aggregation.py
new file mode 100644
index 0000000000000..74ccebc8e2275
--- /dev/null
+++ b/pandas/tests/test_aggregation.py
@@ -0,0 +1,90 @@
+import numpy as np
+import pytest
+
+from pandas.core.aggregation import _make_unique_kwarg_list, maybe_mangle_lambdas
+
+
+def test_maybe_mangle_lambdas_passthrough():
+    assert maybe_mangle_lambdas("mean") == "mean"
+    assert maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
+    # don't mangel single lambda.
+    assert maybe_mangle_lambdas([lambda x: x])[0].__name__ == "<lambda>"
+
+
+def test_maybe_mangle_lambdas_listlike():
+    aggfuncs = [lambda x: 1, lambda x: 2]
+    result = maybe_mangle_lambdas(aggfuncs)
+    assert result[0].__name__ == "<lambda_0>"
+    assert result[1].__name__ == "<lambda_1>"
+    assert aggfuncs[0](None) == result[0](None)
+    assert aggfuncs[1](None) == result[1](None)
+
+
+def test_maybe_mangle_lambdas():
+    func = {"A": [lambda x: 0, lambda x: 1]}
+    result = maybe_mangle_lambdas(func)
+    assert result["A"][0].__name__ == "<lambda_0>"
+    assert result["A"][1].__name__ == "<lambda_1>"
+
+
+def test_maybe_mangle_lambdas_args():
+    func = {"A": [lambda x, a, b=1: (0, a, b), lambda x: 1]}
+    result = maybe_mangle_lambdas(func)
+    assert result["A"][0].__name__ == "<lambda_0>"
+    assert result["A"][1].__name__ == "<lambda_1>"
+
+    assert func["A"][0](0, 1) == (0, 1, 1)
+    assert func["A"][0](0, 1, 2) == (0, 1, 2)
+    assert func["A"][0](0, 2, b=3) == (0, 2, 3)
+
+
+def test_maybe_mangle_lambdas_named():
+    func = {"C": np.mean, "D": {"foo": np.mean, "bar": np.mean}}
+    result = maybe_mangle_lambdas(func)
+    assert result == func
+
+
+@pytest.mark.parametrize(
+    "order, expected_reorder",
+    [
+        (
+            [
+                ("height", "<lambda>"),
+                ("height", "max"),
+                ("weight", "max"),
+                ("height", "<lambda>"),
+                ("weight", "<lambda>"),
+            ],
+            [
+                ("height", "<lambda>_0"),
+                ("height", "max"),
+                ("weight", "max"),
+                ("height", "<lambda>_1"),
+                ("weight", "<lambda>"),
+            ],
+        ),
+        (
+            [
+                ("col2", "min"),
+                ("col1", "<lambda>"),
+                ("col1", "<lambda>"),
+                ("col1", "<lambda>"),
+            ],
+            [
+                ("col2", "min"),
+                ("col1", "<lambda>_0"),
+                ("col1", "<lambda>_1"),
+                ("col1", "<lambda>_2"),
+            ],
+        ),
+        (
+            [("col", "<lambda>"), ("col", "<lambda>"), ("col", "<lambda>")],
+            [("col", "<lambda>_0"), ("col", "<lambda>_1"), ("col", "<lambda>_2")],
+        ),
+    ],
+)
+def test_make_unique(order, expected_reorder):
+    # GH 27519, test if make_unique function reorders correctly
+    result = _make_unique_kwarg_list(order)
+
+    assert result == expected_reorder
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index d81ee79418e9c..a1de9c435c9ba 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -3,7 +3,6 @@
 import struct
 
 import numpy as np
-from numpy import nan
 from numpy.random import RandomState
 import pytest
 
@@ -11,6 +10,13 @@
 from pandas.compat.numpy import np_array_datetime64_compat
 import pandas.util._test_decorators as td
 
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_complex_dtype,
+    is_float_dtype,
+    is_integer_dtype,
+    is_object_dtype,
+)
 from pandas.core.dtypes.dtypes import CategoricalDtype as CDT
 
 import pandas as pd
@@ -24,85 +30,49 @@
     Timestamp,
     compat,
 )
+import pandas._testing as tm
+from pandas.conftest import BYTES_DTYPES, STRING_DTYPES
 import pandas.core.algorithms as algos
 from pandas.core.arrays import DatetimeArray
 import pandas.core.common as com
-from pandas.core.sorting import safe_sort
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal
-
-
-class TestMatch:
-    def test_ints(self):
-        values = np.array([0, 2, 1])
-        to_match = np.array([0, 1, 2, 2, 0, 1, 3, 0])
-
-        result = algos.match(to_match, values)
-        expected = np.array([0, 2, 1, 1, 0, 2, -1, 0], dtype=np.int64)
-        tm.assert_numpy_array_equal(result, expected)
-
-        result = Series(algos.match(to_match, values, np.nan))
-        expected = Series(np.array([0, 2, 1, 1, 0, 2, np.nan, 0]))
-        tm.assert_series_equal(result, expected)
-
-        s = Series(np.arange(5), dtype=np.float32)
-        result = algos.match(s, [2, 4])
-        expected = np.array([-1, -1, 0, -1, 1], dtype=np.int64)
-        tm.assert_numpy_array_equal(result, expected)
-
-        result = Series(algos.match(s, [2, 4], np.nan))
-        expected = Series(np.array([np.nan, np.nan, 0, np.nan, 1]))
-        tm.assert_series_equal(result, expected)
-
-    def test_strings(self):
-        values = ["foo", "bar", "baz"]
-        to_match = ["bar", "foo", "qux", "foo", "bar", "baz", "qux"]
-
-        result = algos.match(to_match, values)
-        expected = np.array([1, 0, -1, 0, 1, 2, -1], dtype=np.int64)
-        tm.assert_numpy_array_equal(result, expected)
-
-        result = Series(algos.match(to_match, values, np.nan))
-        expected = Series(np.array([1, 0, np.nan, 0, 1, 2, np.nan]))
-        tm.assert_series_equal(result, expected)
 
 
 class TestFactorize:
     def test_basic(self):
 
-        labels, uniques = algos.factorize(["a", "b", "b", "a", "a", "c", "c", "c"])
+        codes, uniques = algos.factorize(["a", "b", "b", "a", "a", "c", "c", "c"])
         tm.assert_numpy_array_equal(uniques, np.array(["a", "b", "c"], dtype=object))
 
-        labels, uniques = algos.factorize(
+        codes, uniques = algos.factorize(
             ["a", "b", "b", "a", "a", "c", "c", "c"], sort=True
         )
         exp = np.array([0, 1, 1, 0, 0, 2, 2, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = np.array(["a", "b", "c"], dtype=object)
         tm.assert_numpy_array_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(list(reversed(range(5))))
+        codes, uniques = algos.factorize(list(reversed(range(5))))
         exp = np.array([0, 1, 2, 3, 4], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = np.array([4, 3, 2, 1, 0], dtype=np.int64)
         tm.assert_numpy_array_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(list(reversed(range(5))), sort=True)
+        codes, uniques = algos.factorize(list(reversed(range(5))), sort=True)
 
         exp = np.array([4, 3, 2, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = np.array([0, 1, 2, 3, 4], dtype=np.int64)
         tm.assert_numpy_array_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(list(reversed(np.arange(5.0))))
+        codes, uniques = algos.factorize(list(reversed(np.arange(5.0))))
         exp = np.array([0, 1, 2, 3, 4], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = np.array([4.0, 3.0, 2.0, 1.0, 0.0], dtype=np.float64)
         tm.assert_numpy_array_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(list(reversed(np.arange(5.0))), sort=True)
+        codes, uniques = algos.factorize(list(reversed(np.arange(5.0))), sort=True)
         exp = np.array([4, 3, 2, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = np.array([0.0, 1.0, 2.0, 3.0, 4.0], dtype=np.float64)
         tm.assert_numpy_array_equal(uniques, exp)
 
@@ -110,16 +80,16 @@ def test_mixed(self):
 
         # doc example reshaping.rst
         x = Series(["A", "A", np.nan, "B", 3.14, np.inf])
-        labels, uniques = algos.factorize(x)
+        codes, uniques = algos.factorize(x)
 
         exp = np.array([0, 0, -1, 1, 2, 3], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = Index(["A", "B", 3.14, np.inf])
         tm.assert_index_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(x, sort=True)
+        codes, uniques = algos.factorize(x, sort=True)
         exp = np.array([2, 2, -1, 3, 0, 1], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = Index([3.14, np.inf, "A", "B"])
         tm.assert_index_equal(uniques, exp)
 
@@ -129,16 +99,16 @@ def test_datelike(self):
         v1 = Timestamp("20130101 09:00:00.00004")
         v2 = Timestamp("20130101")
         x = Series([v1, v1, v1, v2, v2, v1])
-        labels, uniques = algos.factorize(x)
+        codes, uniques = algos.factorize(x)
 
         exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = DatetimeIndex([v1, v2])
         tm.assert_index_equal(uniques, exp)
 
-        labels, uniques = algos.factorize(x, sort=True)
+        codes, uniques = algos.factorize(x, sort=True)
         exp = np.array([1, 1, 1, 0, 0, 1], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         exp = DatetimeIndex([v2, v1])
         tm.assert_index_equal(uniques, exp)
 
@@ -148,28 +118,28 @@ def test_datelike(self):
         x = Series([v1, v1, v1, v2, v2, v1])
 
         # periods are not 'sorted' as they are converted back into an index
-        labels, uniques = algos.factorize(x)
+        codes, uniques = algos.factorize(x)
         exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         tm.assert_index_equal(uniques, pd.PeriodIndex([v1, v2]))
 
-        labels, uniques = algos.factorize(x, sort=True)
+        codes, uniques = algos.factorize(x, sort=True)
         exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         tm.assert_index_equal(uniques, pd.PeriodIndex([v1, v2]))
 
         # GH 5986
         v1 = pd.to_timedelta("1 day 1 min")
         v2 = pd.to_timedelta("1 day")
         x = Series([v1, v2, v1, v1, v2, v2, v1])
-        labels, uniques = algos.factorize(x)
+        codes, uniques = algos.factorize(x)
         exp = np.array([0, 1, 0, 0, 1, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         tm.assert_index_equal(uniques, pd.to_timedelta([v1, v2]))
 
-        labels, uniques = algos.factorize(x, sort=True)
+        codes, uniques = algos.factorize(x, sort=True)
         exp = np.array([1, 0, 1, 1, 0, 0, 1], dtype=np.intp)
-        tm.assert_numpy_array_equal(labels, exp)
+        tm.assert_numpy_array_equal(codes, exp)
         tm.assert_index_equal(uniques, pd.to_timedelta([v2, v1]))
 
     def test_factorize_nan(self):
@@ -196,7 +166,7 @@ def test_factorize_nan(self):
         tm.assert_numpy_array_equal(pd.isna(key), expected == na_sentinel)
 
     @pytest.mark.parametrize(
-        "data,expected_label,expected_level",
+        "data, expected_codes, expected_uniques",
         [
             (
                 [(1, 1), (1, 2), (0, 0), (1, 2), "nonsense"],
@@ -211,14 +181,14 @@ def test_factorize_nan(self):
             ([(1, 1), (1, 2), (0, 0), (1, 2)], [0, 1, 2, 1], [(1, 1), (1, 2), (0, 0)]),
         ],
     )
-    def test_factorize_tuple_list(self, data, expected_label, expected_level):
+    def test_factorize_tuple_list(self, data, expected_codes, expected_uniques):
         # GH9454
-        result = pd.factorize(data)
+        codes, uniques = pd.factorize(data)
 
-        tm.assert_numpy_array_equal(result[0], np.array(expected_label, dtype=np.intp))
+        tm.assert_numpy_array_equal(codes, np.array(expected_codes, dtype=np.intp))
 
-        expected_level_array = com.asarray_tuplesafe(expected_level, dtype=object)
-        tm.assert_numpy_array_equal(result[1], expected_level_array)
+        expected_uniques_array = com.asarray_tuplesafe(expected_uniques, dtype=object)
+        tm.assert_numpy_array_equal(uniques, expected_uniques_array)
 
     def test_complex_sorting(self):
         # gh 12666 - check no segfault
@@ -235,58 +205,58 @@ def test_complex_sorting(self):
     def test_float64_factorize(self, writable):
         data = np.array([1.0, 1e8, 1.0, 1e-8, 1e8, 1.0], dtype=np.float64)
         data.setflags(write=writable)
-        exp_labels = np.array([0, 1, 0, 2, 1, 0], dtype=np.intp)
-        exp_uniques = np.array([1.0, 1e8, 1e-8], dtype=np.float64)
+        expected_codes = np.array([0, 1, 0, 2, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([1.0, 1e8, 1e-8], dtype=np.float64)
 
-        labels, uniques = algos.factorize(data)
-        tm.assert_numpy_array_equal(labels, exp_labels)
-        tm.assert_numpy_array_equal(uniques, exp_uniques)
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_uint64_factorize(self, writable):
         data = np.array([2 ** 64 - 1, 1, 2 ** 64 - 1], dtype=np.uint64)
         data.setflags(write=writable)
-        exp_labels = np.array([0, 1, 0], dtype=np.intp)
-        exp_uniques = np.array([2 ** 64 - 1, 1], dtype=np.uint64)
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([2 ** 64 - 1, 1], dtype=np.uint64)
 
-        labels, uniques = algos.factorize(data)
-        tm.assert_numpy_array_equal(labels, exp_labels)
-        tm.assert_numpy_array_equal(uniques, exp_uniques)
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_int64_factorize(self, writable):
-        data = np.array([2 ** 63 - 1, -2 ** 63, 2 ** 63 - 1], dtype=np.int64)
+        data = np.array([2 ** 63 - 1, -(2 ** 63), 2 ** 63 - 1], dtype=np.int64)
         data.setflags(write=writable)
-        exp_labels = np.array([0, 1, 0], dtype=np.intp)
-        exp_uniques = np.array([2 ** 63 - 1, -2 ** 63], dtype=np.int64)
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([2 ** 63 - 1, -(2 ** 63)], dtype=np.int64)
 
-        labels, uniques = algos.factorize(data)
-        tm.assert_numpy_array_equal(labels, exp_labels)
-        tm.assert_numpy_array_equal(uniques, exp_uniques)
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_string_factorize(self, writable):
         data = np.array(["a", "c", "a", "b", "c"], dtype=object)
         data.setflags(write=writable)
-        exp_labels = np.array([0, 1, 0, 2, 1], dtype=np.intp)
-        exp_uniques = np.array(["a", "c", "b"], dtype=object)
+        expected_codes = np.array([0, 1, 0, 2, 1], dtype=np.intp)
+        expected_uniques = np.array(["a", "c", "b"], dtype=object)
 
-        labels, uniques = algos.factorize(data)
-        tm.assert_numpy_array_equal(labels, exp_labels)
-        tm.assert_numpy_array_equal(uniques, exp_uniques)
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_object_factorize(self, writable):
         data = np.array(["a", "c", None, np.nan, "a", "b", pd.NaT, "c"], dtype=object)
         data.setflags(write=writable)
-        exp_labels = np.array([0, 1, -1, -1, 0, 2, -1, 1], dtype=np.intp)
-        exp_uniques = np.array(["a", "c", "b"], dtype=object)
+        expected_codes = np.array([0, 1, -1, -1, 0, 2, -1, 1], dtype=np.intp)
+        expected_uniques = np.array(["a", "c", "b"], dtype=object)
 
-        labels, uniques = algos.factorize(data)
-        tm.assert_numpy_array_equal(labels, exp_labels)
-        tm.assert_numpy_array_equal(uniques, exp_uniques)
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     def test_deprecate_order(self):
         # gh 19727 - check warning is raised for deprecated keyword, order.
         # Test not valid once order keyword is removed.
         data = np.array([2 ** 63, 1, 2 ** 63], dtype=np.uint64)
-        with tm.assert_produces_warning(expected_warning=FutureWarning):
+        with pytest.raises(TypeError, match="got an unexpected keyword"):
             algos.factorize(data, order=True)
         with tm.assert_produces_warning(False):
             algos.factorize(data)
@@ -295,36 +265,36 @@ def test_deprecate_order(self):
         "data",
         [
             np.array([0, 1, 0], dtype="u8"),
-            np.array([-2 ** 63, 1, -2 ** 63], dtype="i8"),
+            np.array([-(2 ** 63), 1, -(2 ** 63)], dtype="i8"),
             np.array(["__nan__", "foo", "__nan__"], dtype="object"),
         ],
     )
     def test_parametrized_factorize_na_value_default(self, data):
         # arrays that include the NA default for that type, but isn't used.
-        l, u = algos.factorize(data)
+        codes, uniques = algos.factorize(data)
         expected_uniques = data[[0, 1]]
-        expected_labels = np.array([0, 1, 0], dtype=np.intp)
-        tm.assert_numpy_array_equal(l, expected_labels)
-        tm.assert_numpy_array_equal(u, expected_uniques)
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     @pytest.mark.parametrize(
         "data, na_value",
         [
             (np.array([0, 1, 0, 2], dtype="u8"), 0),
             (np.array([1, 0, 1, 2], dtype="u8"), 1),
-            (np.array([-2 ** 63, 1, -2 ** 63, 0], dtype="i8"), -2 ** 63),
-            (np.array([1, -2 ** 63, 1, 0], dtype="i8"), 1),
+            (np.array([-(2 ** 63), 1, -(2 ** 63), 0], dtype="i8"), -(2 ** 63)),
+            (np.array([1, -(2 ** 63), 1, 0], dtype="i8"), 1),
             (np.array(["a", "", "a", "b"], dtype=object), "a"),
             (np.array([(), ("a", 1), (), ("a", 2)], dtype=object), ()),
             (np.array([("a", 1), (), ("a", 1), ("a", 2)], dtype=object), ("a", 1)),
         ],
     )
     def test_parametrized_factorize_na_value(self, data, na_value):
-        l, u = algos._factorize_array(data, na_value=na_value)
+        codes, uniques = algos._factorize_array(data, na_value=na_value)
         expected_uniques = data[[1, 3]]
-        expected_labels = np.array([-1, 0, -1, 1], dtype=np.intp)
-        tm.assert_numpy_array_equal(l, expected_labels)
-        tm.assert_numpy_array_equal(u, expected_uniques)
+        expected_codes = np.array([-1, 0, -1, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
 
     @pytest.mark.parametrize("sort", [True, False])
     @pytest.mark.parametrize("na_sentinel", [-1, -10, 100])
@@ -343,14 +313,14 @@ def test_parametrized_factorize_na_value(self, data, na_value):
         ids=["numpy_array", "extension_array"],
     )
     def test_factorize_na_sentinel(self, sort, na_sentinel, data, uniques):
-        labels, uniques = algos.factorize(data, sort=sort, na_sentinel=na_sentinel)
+        codes, uniques = algos.factorize(data, sort=sort, na_sentinel=na_sentinel)
         if sort:
-            expected_labels = np.array([1, 0, na_sentinel, 1], dtype=np.intp)
-            expected_uniques = safe_sort(uniques)
+            expected_codes = np.array([1, 0, na_sentinel, 1], dtype=np.intp)
+            expected_uniques = algos.safe_sort(uniques)
         else:
-            expected_labels = np.array([0, 1, na_sentinel, 0], dtype=np.intp)
+            expected_codes = np.array([0, 1, na_sentinel, 0], dtype=np.intp)
             expected_uniques = uniques
-        tm.assert_numpy_array_equal(labels, expected_labels)
+        tm.assert_numpy_array_equal(codes, expected_codes)
         if isinstance(data, np.ndarray):
             tm.assert_numpy_array_equal(uniques, expected_uniques)
         else:
@@ -390,6 +360,35 @@ def test_on_index_object(self):
 
         tm.assert_almost_equal(result, expected)
 
+    def test_dtype_preservation(self, any_numpy_dtype):
+        # GH 15442
+        if any_numpy_dtype in (BYTES_DTYPES + STRING_DTYPES):
+            pytest.skip("skip string dtype")
+        elif is_integer_dtype(any_numpy_dtype):
+            data = [1, 2, 2]
+            uniques = [1, 2]
+        elif is_float_dtype(any_numpy_dtype):
+            data = [1, 2, 2]
+            uniques = [1.0, 2.0]
+        elif is_complex_dtype(any_numpy_dtype):
+            data = [complex(1, 0), complex(2, 0), complex(2, 0)]
+            uniques = [complex(1, 0), complex(2, 0)]
+        elif is_bool_dtype(any_numpy_dtype):
+            data = [True, True, False]
+            uniques = [True, False]
+        elif is_object_dtype(any_numpy_dtype):
+            data = ["A", "B", "B"]
+            uniques = ["A", "B"]
+        else:
+            # datetime64[ns]/M8[ns]/timedelta64[ns]/m8[ns] tested elsewhere
+            data = [1, 2, 2]
+            uniques = [1, 2]
+
+        result = Series(data, dtype=any_numpy_dtype).unique()
+        expected = np.array(uniques, dtype=any_numpy_dtype)
+
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_datetime64_dtype_array_returned(self):
         # GH 9431
         expected = np_array_datetime64_compat(
@@ -421,6 +420,18 @@ def test_datetime64_dtype_array_returned(self):
         tm.assert_numpy_array_equal(result, expected)
         assert result.dtype == expected.dtype
 
+    def test_datetime_non_ns(self):
+        a = np.array(["2000", "2000", "2001"], dtype="datetime64[s]")
+        result = pd.unique(a)
+        expected = np.array(["2000", "2001"], dtype="datetime64[ns]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_timedelta_non_ns(self):
+        a = np.array(["2000", "2000", "2001"], dtype="timedelta64[s]")
+        result = pd.unique(a)
+        expected = np.array([2000000000000, 2001000000000], dtype="timedelta64[ns]")
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_timedelta64_dtype_array_returned(self):
         # GH 9431
         expected = np.array([31200, 45678, 10000], dtype="m8[ns]")
@@ -654,8 +665,8 @@ class TestIsin:
     def test_invalid(self):
 
         msg = (
-            r"only list-like objects are allowed to be passed to isin\(\),"
-            r" you passed a \[int\]"
+            r"only list-like objects are allowed to be passed to isin\(\), "
+            r"you passed a \[int\]"
         )
         with pytest.raises(TypeError, match=msg):
             algos.isin(1, 1)
@@ -768,7 +779,7 @@ def test_same_object_is_in(self):
         # with similar behavior, then we at least should
         # fall back to usual python's behavior: "a in [a] == True"
         class LikeNan:
-            def __eq__(self):
+            def __eq__(self, other) -> bool:
                 return False
 
             def __hash__(self):
@@ -813,7 +824,7 @@ def test_no_cast(self):
         result = algos.isin(comps, values)
         tm.assert_numpy_array_equal(expected, result)
 
-    @pytest.mark.parametrize("empty", [[], Series(), np.array([])])
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
     def test_empty(self, empty):
         # see gh-16991
         vals = Index(["a", "b"])
@@ -1403,6 +1414,19 @@ class TestGroupVarFloat32(GroupVarTestMixin):
 
 
 class TestHashTable:
+    def test_string_hashtable_set_item_signature(self):
+        # GH#30419 fix typing in StringHashTable.set_item to prevent segfault
+        tbl = ht.StringHashTable()
+
+        tbl.set_item("key", 1)
+        assert tbl.get_item("key") == 1
+
+        with pytest.raises(TypeError, match="'key' has incorrect type"):
+            # key arg typed as string, not object
+            tbl.set_item(4, 6)
+        with pytest.raises(TypeError, match="'val' has incorrect type"):
+            tbl.get_item(4)
+
     def test_lookup_nan(self, writable):
         xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3])
         # GH 21688 ensure we can deal with readonly memory views
@@ -1620,14 +1644,14 @@ def test_scipy_compat(self):
         def _check(arr):
             mask = ~np.isfinite(arr)
             arr = arr.copy()
-            result = libalgos.rank_1d_float64(arr)
+            result = libalgos.rank_1d(arr)
             arr[mask] = np.inf
             exp = rankdata(arr)
-            exp[mask] = nan
-            assert_almost_equal(result, exp)
+            exp[mask] = np.nan
+            tm.assert_almost_equal(result, exp)
 
-        _check(np.array([nan, nan, 5.0, 5.0, 5.0, nan, 1, 2, 3, nan]))
-        _check(np.array([4.0, nan, 5.0, 5.0, 5.0, nan, 1, 2, 4.0, nan]))
+        _check(np.array([np.nan, np.nan, 5.0, 5.0, 5.0, np.nan, 1, 2, 3, np.nan]))
+        _check(np.array([4.0, np.nan, 5.0, 5.0, 5.0, np.nan, 1, 2, 4.0, np.nan]))
 
     def test_basic(self):
         exp = np.array([1, 2], dtype=np.float64)
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 65b2dab1b02a8..186c735a0bff9 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -8,7 +8,8 @@
 
 import pandas as pd
 from pandas import Series, Timestamp
-from pandas.core import common as com, ops
+from pandas.core import ops
+import pandas.core.common as com
 
 
 def test_get_callable_name():
@@ -59,10 +60,11 @@ def test_random_state():
     assert com.random_state() is np.random
 
     # Error for floats or strings
-    with pytest.raises(ValueError):
+    msg = "random_state must be an integer, a numpy RandomState, or None"
+    with pytest.raises(ValueError, match=msg):
         com.random_state("test")
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match=msg):
         com.random_state(5.5)
 
 
@@ -92,15 +94,17 @@ def test_dict_compat():
 
 def test_standardize_mapping():
     # No uninitialized defaultdicts
-    with pytest.raises(TypeError):
+    msg = r"to_dict\(\) only accepts initialized defaultdicts"
+    with pytest.raises(TypeError, match=msg):
         com.standardize_mapping(collections.defaultdict)
 
     # No non-mapping subtypes, instance
-    with pytest.raises(TypeError):
+    msg = "unsupported type: <class 'list'>"
+    with pytest.raises(TypeError, match=msg):
         com.standardize_mapping([])
 
     # No non-mapping subtypes, class
-    with pytest.raises(TypeError):
+    with pytest.raises(TypeError, match=msg):
         com.standardize_mapping(list)
 
     fill = {"bad": "data"}
diff --git a/pandas/tests/test_compat.py b/pandas/tests/test_compat.py
deleted file mode 100644
index 4ff8b0b31e85e..0000000000000
--- a/pandas/tests/test_compat.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-Testing that functions from compat work as expected
-"""
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 3a24736c57c01..02898988ca8aa 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -8,29 +8,18 @@
 import numpy as np  # noqa
 import pytest
 
-from pandas.compat import PY36
-
-from pandas import DataFrame, Series
-from pandas.util import testing as tm
+from pandas import DataFrame
+import pandas._testing as tm
 
 
 def import_module(name):
     # we *only* want to skip if the module is truly not available
     # and NOT just an actual import error because of pandas changes
 
-    if PY36:
-        try:
-            return importlib.import_module(name)
-        except ModuleNotFoundError:  # noqa
-            pytest.skip("skipping as {} not available".format(name))
-
-    else:
-        try:
-            return importlib.import_module(name)
-        except ImportError as e:
-            if "No module named" in str(e) and name in str(e):
-                pytest.skip("skipping as {} not available".format(name))
-            raise
+    try:
+        return importlib.import_module(name)
+    except ModuleNotFoundError:  # noqa
+        pytest.skip("skipping as {} not available".format(name))
 
 
 @pytest.fixture
@@ -50,6 +39,7 @@ def test_dask(df):
     assert ddf.compute() is not None
 
 
+@pytest.mark.filterwarnings("ignore:Panel class is removed")
 def test_xarray(df):
 
     xarray = import_module("xarray")  # noqa
@@ -65,6 +55,10 @@ def test_oo_optimizable():
 @tm.network
 # Cython import warning
 @pytest.mark.filterwarnings("ignore:can't:ImportWarning")
+@pytest.mark.filterwarnings(
+    # patsy needs to update their imports
+    "ignore:Using or importing the ABCs from 'collections:DeprecationWarning"
+)
 def test_statsmodels():
 
     statsmodels = import_module("statsmodels")  # noqa
@@ -112,10 +106,7 @@ def test_pandas_datareader():
 
 
 # importing from pandas, Cython import warning
-@pytest.mark.filterwarnings("ignore:The 'warn':DeprecationWarning")
-@pytest.mark.filterwarnings("ignore:pandas.util:DeprecationWarning")
 @pytest.mark.filterwarnings("ignore:can't resolve:ImportWarning")
-@pytest.mark.skip(reason="gh-25778: geopandas stack issue")
 def test_geopandas():
 
     geopandas = import_module("geopandas")  # noqa
@@ -123,26 +114,6 @@ def test_geopandas():
     assert geopandas.read_file(fp) is not None
 
 
-def test_geopandas_coordinate_indexer():
-    # this test is included to have coverage of one case in the indexing.py
-    # code that is only kept for compatibility with geopandas, see
-    # https://github.com/pandas-dev/pandas/issues/27258
-    # We should be able to remove this after some time when its usage is
-    # removed in geopandas
-    from pandas.core.indexing import _NDFrameIndexer
-
-    class _CoordinateIndexer(_NDFrameIndexer):
-        def _getitem_tuple(self, tup):
-            obj = self.obj
-            xs, ys = tup
-            return obj[xs][ys]
-
-    Series._create_indexer("cx", _CoordinateIndexer)
-    s = Series(range(5))
-    res = s.cx[:, :]
-    tm.assert_series_equal(s, res)
-
-
 # Cython import warning
 @pytest.mark.filterwarnings("ignore:can't resolve:ImportWarning")
 @pytest.mark.filterwarnings("ignore:RangeIndex.* is deprecated:DeprecationWarning")
@@ -165,7 +136,12 @@ def test_missing_required_dependency():
     # https://github.com/MacPython/pandas-wheels/pull/50
     call = ["python", "-sSE", "-c", "import pandas"]
 
-    with pytest.raises(subprocess.CalledProcessError) as exc:
+    msg = (
+        r"Command '\['python', '-sSE', '-c', 'import pandas'\]' "
+        "returned non-zero exit status 1."
+    )
+
+    with pytest.raises(subprocess.CalledProcessError, match=msg) as exc:
         subprocess.check_output(call, stderr=subprocess.STDOUT)
 
     output = exc.value.stdout.decode()
diff --git a/pandas/tests/test_errors.py b/pandas/tests/test_errors.py
index 531c511e8c02d..d72c00ceb0045 100644
--- a/pandas/tests/test_errors.py
+++ b/pandas/tests/test_errors.py
@@ -22,37 +22,23 @@
 def test_exception_importable(exc):
     from pandas import errors
 
-    e = getattr(errors, exc)
-    assert e is not None
+    err = getattr(errors, exc)
+    assert err is not None
 
     # check that we can raise on them
-    with pytest.raises(e):
-        raise e()
+
+    msg = "^$"
+
+    with pytest.raises(err, match=msg):
+        raise err()
 
 
 def test_catch_oob():
     from pandas import errors
 
-    try:
+    msg = "Out of bounds nanosecond timestamp: 1500-01-01 00:00:00"
+    with pytest.raises(errors.OutOfBoundsDatetime, match=msg):
         pd.Timestamp("15000101")
-    except errors.OutOfBoundsDatetime:
-        pass
-
-
-def test_error_rename():
-    # see gh-12665
-    from pandas.errors import ParserError
-    from pandas.io.common import CParserError
-
-    try:
-        raise CParserError()
-    except ParserError:
-        pass
-
-    try:
-        raise ParserError()
-    except CParserError:
-        pass
 
 
 class Foo:
diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py
index ca514f62f451d..fadab5d821470 100644
--- a/pandas/tests/test_expressions.py
+++ b/pandas/tests/test_expressions.py
@@ -5,16 +5,9 @@
 from numpy.random import randn
 import pytest
 
+import pandas._testing as tm
 from pandas.core.api import DataFrame
 from pandas.core.computation import expressions as expr
-import pandas.util.testing as tm
-from pandas.util.testing import (
-    assert_almost_equal,
-    assert_frame_equal,
-    assert_series_equal,
-)
-
-from pandas.io.formats.printing import pprint_thing
 
 _frame = DataFrame(randn(10000, 4), columns=list("ABCD"), dtype="float64")
 _frame2 = DataFrame(randn(100, 4), columns=list("ABCD"), dtype="float64")
@@ -50,57 +43,35 @@ def setup_method(self, method):
         self.frame2 = _frame2.copy()
         self.mixed = _mixed.copy()
         self.mixed2 = _mixed2.copy()
-        self.integer = _integer.copy()
         self._MIN_ELEMENTS = expr._MIN_ELEMENTS
 
     def teardown_method(self, method):
         expr._MIN_ELEMENTS = self._MIN_ELEMENTS
 
-    def run_arithmetic(self, df, other, assert_func, check_dtype=False, test_flex=True):
+    def run_arithmetic(self, df, other):
         expr._MIN_ELEMENTS = 0
         operations = ["add", "sub", "mul", "mod", "truediv", "floordiv"]
-        for arith in operations:
-
-            operator_name = arith
-            if arith == "div":
-                operator_name = "truediv"
-
-            if test_flex:
-                op = lambda x, y: getattr(x, arith)(y)
-                op.__name__ = arith
-            else:
-                op = getattr(operator, operator_name)
-            expr.set_use_numexpr(False)
-            expected = op(df, other)
-            expr.set_use_numexpr(True)
+        for test_flex in [True, False]:
+            for arith in operations:
+                # TODO: share with run_binary
+                if test_flex:
+                    op = lambda x, y: getattr(x, arith)(y)
+                    op.__name__ = arith
+                else:
+                    op = getattr(operator, arith)
+                expr.set_use_numexpr(False)
+                expected = op(df, other)
+                expr.set_use_numexpr(True)
 
-            result = op(df, other)
-            try:
-                if check_dtype:
-                    if arith == "truediv":
+                result = op(df, other)
+                if arith == "truediv":
+                    if expected.ndim == 1:
                         assert expected.dtype.kind == "f"
-                assert_func(expected, result)
-            except Exception:
-                pprint_thing("Failed test with operator {op.__name__!r}".format(op=op))
-                raise
-
-    def test_integer_arithmetic(self):
-        self.run_arithmetic(self.integer, self.integer, assert_frame_equal)
-        self.run_arithmetic(
-            self.integer.iloc[:, 0],
-            self.integer.iloc[:, 0],
-            assert_series_equal,
-            check_dtype=True,
-        )
+                    else:
+                        assert all(x.kind == "f" for x in expected.dtypes.values)
+                tm.assert_equal(expected, result)
 
-    def run_binary(
-        self,
-        df,
-        other,
-        assert_func,
-        test_flex=False,
-        numexpr_ops={"gt", "lt", "ge", "le", "eq", "ne"},
-    ):
+    def run_binary(self, df, other):
         """
         tests solely that the result is the same whether or not numexpr is
         enabled.  Need to test whether the function does the correct thing
@@ -110,97 +81,59 @@ def run_binary(
         expr.set_test_mode(True)
         operations = ["gt", "lt", "ge", "le", "eq", "ne"]
 
-        for arith in operations:
-            if test_flex:
-                op = lambda x, y: getattr(df, arith)(y)
-                op.__name__ = arith
-            else:
-                op = getattr(operator, arith)
-            expr.set_use_numexpr(False)
-            expected = op(df, other)
-            expr.set_use_numexpr(True)
-            expr.get_test_result()
-            result = op(df, other)
-            used_numexpr = expr.get_test_result()
-            try:
-                if arith in numexpr_ops:
-                    assert used_numexpr, "Did not use numexpr as expected."
+        for test_flex in [True, False]:
+            for arith in operations:
+                if test_flex:
+                    op = lambda x, y: getattr(x, arith)(y)
+                    op.__name__ = arith
                 else:
-                    assert not used_numexpr, "Used numexpr unexpectedly."
-                assert_func(expected, result)
-            except Exception:
-                pprint_thing("Failed test with operation {arith!r}".format(arith=arith))
-                pprint_thing("test_flex was {test_flex!r}".format(test_flex=test_flex))
-                raise
-
-    def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs):
-        self.run_arithmetic(df, other, assert_frame_equal, test_flex=False, **kwargs)
-        self.run_arithmetic(df, other, assert_frame_equal, test_flex=True, **kwargs)
-        if run_binary:
-            if binary_comp is None:
+                    op = getattr(operator, arith)
                 expr.set_use_numexpr(False)
-                binary_comp = other + 1
+                expected = op(df, other)
                 expr.set_use_numexpr(True)
-            self.run_binary(
-                df, binary_comp, assert_frame_equal, test_flex=False, **kwargs
-            )
-            self.run_binary(
-                df, binary_comp, assert_frame_equal, test_flex=True, **kwargs
-            )
-
-    def run_series(self, ser, other, binary_comp=None, **kwargs):
-        self.run_arithmetic(ser, other, assert_series_equal, test_flex=False, **kwargs)
-        self.run_arithmetic(ser, other, assert_almost_equal, test_flex=True, **kwargs)
-        # series doesn't uses vec_compare instead of numexpr...
-        # if binary_comp is None:
-        #     binary_comp = other + 1
-        # self.run_binary(ser, binary_comp, assert_frame_equal,
-        # test_flex=False, **kwargs)
-        # self.run_binary(ser, binary_comp, assert_frame_equal,
-        # test_flex=True, **kwargs)
-
-    def test_integer_arithmetic_frame(self):
-        self.run_frame(self.integer, self.integer)
-
-    def test_integer_arithmetic_series(self):
-        self.run_series(self.integer.iloc[:, 0], self.integer.iloc[:, 0])
-
-    def test_float_arithemtic_frame(self):
-        self.run_frame(self.frame2, self.frame2)
-
-    def test_float_arithmetic_series(self):
-        self.run_series(self.frame2.iloc[:, 0], self.frame2.iloc[:, 0])
-
-    def test_mixed_arithmetic_frame(self):
-        # TODO: FIGURE OUT HOW TO GET IT TO WORK...
+
+                expr.get_test_result()
+                result = op(df, other)
+                used_numexpr = expr.get_test_result()
+                assert used_numexpr, "Did not use numexpr as expected."
+                tm.assert_equal(expected, result)
+
+    def run_frame(self, df, other, run_binary=True):
+        self.run_arithmetic(df, other)
+        if run_binary:
+            expr.set_use_numexpr(False)
+            binary_comp = other + 1
+            expr.set_use_numexpr(True)
+            self.run_binary(df, binary_comp)
+
+        for i in range(len(df.columns)):
+            self.run_arithmetic(df.iloc[:, i], other.iloc[:, i])
+            # FIXME: dont leave commented-out
+            # series doesn't uses vec_compare instead of numexpr...
+            # binary_comp = other.iloc[:, i] + 1
+            # self.run_binary(df.iloc[:, i], binary_comp)
+
+    @pytest.mark.parametrize(
+        "df",
+        [
+            _integer,
+            _integer2,
+            # randint to get a case with zeros
+            _integer * np.random.randint(0, 2, size=np.shape(_integer)),
+            _frame,
+            _frame2,
+            _mixed,
+            _mixed2,
+        ],
+    )
+    def test_arithmetic(self, df):
+        # TODO: FIGURE OUT HOW TO GET RUN_BINARY TO WORK WITH MIXED=...
         # can't do arithmetic because comparison methods try to do *entire*
         # frame instead of by-column
-        self.run_frame(self.mixed2, self.mixed2, run_binary=False)
-
-    def test_mixed_arithmetic_series(self):
-        for col in self.mixed2.columns:
-            self.run_series(self.mixed2[col], self.mixed2[col], binary_comp=4)
-
-    def test_float_arithemtic(self):
-        self.run_arithmetic(self.frame, self.frame, assert_frame_equal)
-        self.run_arithmetic(
-            self.frame.iloc[:, 0],
-            self.frame.iloc[:, 0],
-            assert_series_equal,
-            check_dtype=True,
-        )
-
-    def test_mixed_arithmetic(self):
-        self.run_arithmetic(self.mixed, self.mixed, assert_frame_equal)
-        for col in self.mixed.columns:
-            self.run_arithmetic(self.mixed[col], self.mixed[col], assert_series_equal)
+        kinds = {x.kind for x in df.dtypes.values}
+        should = len(kinds) == 1
 
-    def test_integer_with_zeros(self):
-        self.integer *= np.random.randint(0, 2, size=np.shape(self.integer))
-        self.run_arithmetic(self.integer, self.integer, assert_frame_equal)
-        self.run_arithmetic(
-            self.integer.iloc[:, 0], self.integer.iloc[:, 0], assert_series_equal
-        )
+        self.run_frame(df, df, run_binary=should)
 
     def test_invalid(self):
 
@@ -228,40 +161,33 @@ def test_invalid(self):
         )
         assert result
 
-    def test_binary_ops(self):
+    @pytest.mark.parametrize(
+        "opname,op_str",
+        [("add", "+"), ("sub", "-"), ("mul", "*"), ("truediv", "/"), ("pow", "**")],
+    )
+    @pytest.mark.parametrize("left,right", [(_frame, _frame2), (_mixed, _mixed2)])
+    def test_binary_ops(self, opname, op_str, left, right):
         def testit():
 
-            for f, f2 in [(self.frame, self.frame2), (self.mixed, self.mixed2)]:
+            if opname == "pow":
+                # TODO: get this working
+                return
 
-                for op, op_str in [
-                    ("add", "+"),
-                    ("sub", "-"),
-                    ("mul", "*"),
-                    ("div", "/"),
-                    ("pow", "**"),
-                ]:
+            op = getattr(operator, opname)
 
-                    if op == "pow":
-                        continue
-
-                    if op == "div":
-                        op = getattr(operator, "truediv", None)
-                    else:
-                        op = getattr(operator, op, None)
-                    if op is not None:
-                        result = expr._can_use_numexpr(op, op_str, f, f, "evaluate")
-                        assert result != f._is_mixed_type
+            result = expr._can_use_numexpr(op, op_str, left, left, "evaluate")
+            assert result != left._is_mixed_type
 
-                        result = expr.evaluate(op, op_str, f, f, use_numexpr=True)
-                        expected = expr.evaluate(op, op_str, f, f, use_numexpr=False)
+            result = expr.evaluate(op, op_str, left, left, use_numexpr=True)
+            expected = expr.evaluate(op, op_str, left, left, use_numexpr=False)
 
-                        if isinstance(result, DataFrame):
-                            tm.assert_frame_equal(result, expected)
-                        else:
-                            tm.assert_numpy_array_equal(result, expected.values)
+            if isinstance(result, DataFrame):
+                tm.assert_frame_equal(result, expected)
+            else:
+                tm.assert_numpy_array_equal(result, expected.values)
 
-                        result = expr._can_use_numexpr(op, op_str, f2, f2, "evaluate")
-                        assert not result
+            result = expr._can_use_numexpr(op, op_str, right, right, "evaluate")
+            assert not result
 
         expr.set_use_numexpr(False)
         testit()
@@ -271,39 +197,37 @@ def testit():
         expr.set_numexpr_threads()
         testit()
 
-    def test_boolean_ops(self):
+    @pytest.mark.parametrize(
+        "opname,op_str",
+        [
+            ("gt", ">"),
+            ("lt", "<"),
+            ("ge", ">="),
+            ("le", "<="),
+            ("eq", "=="),
+            ("ne", "!="),
+        ],
+    )
+    @pytest.mark.parametrize("left,right", [(_frame, _frame2), (_mixed, _mixed2)])
+    def test_comparison_ops(self, opname, op_str, left, right):
         def testit():
-            for f, f2 in [(self.frame, self.frame2), (self.mixed, self.mixed2)]:
-
-                f11 = f
-                f12 = f + 1
-
-                f21 = f2
-                f22 = f2 + 1
-
-                for op, op_str in [
-                    ("gt", ">"),
-                    ("lt", "<"),
-                    ("ge", ">="),
-                    ("le", "<="),
-                    ("eq", "=="),
-                    ("ne", "!="),
-                ]:
+            f12 = left + 1
+            f22 = right + 1
 
-                    op = getattr(operator, op)
+            op = getattr(operator, opname)
 
-                    result = expr._can_use_numexpr(op, op_str, f11, f12, "evaluate")
-                    assert result != f11._is_mixed_type
+            result = expr._can_use_numexpr(op, op_str, left, f12, "evaluate")
+            assert result != left._is_mixed_type
 
-                    result = expr.evaluate(op, op_str, f11, f12, use_numexpr=True)
-                    expected = expr.evaluate(op, op_str, f11, f12, use_numexpr=False)
-                    if isinstance(result, DataFrame):
-                        tm.assert_frame_equal(result, expected)
-                    else:
-                        tm.assert_numpy_array_equal(result, expected.values)
+            result = expr.evaluate(op, op_str, left, f12, use_numexpr=True)
+            expected = expr.evaluate(op, op_str, left, f12, use_numexpr=False)
+            if isinstance(result, DataFrame):
+                tm.assert_frame_equal(result, expected)
+            else:
+                tm.assert_numpy_array_equal(result, expected.values)
 
-                    result = expr._can_use_numexpr(op, op_str, f21, f22, "evaluate")
-                    assert not result
+            result = expr._can_use_numexpr(op, op_str, right, f22, "evaluate")
+            assert not result
 
         expr.set_use_numexpr(False)
         testit()
@@ -313,16 +237,15 @@ def testit():
         expr.set_numexpr_threads()
         testit()
 
-    def test_where(self):
+    @pytest.mark.parametrize("cond", [True, False])
+    @pytest.mark.parametrize("df", [_frame, _frame2, _mixed, _mixed2])
+    def test_where(self, cond, df):
         def testit():
-            for f in [self.frame, self.frame2, self.mixed, self.mixed2]:
-
-                for cond in [True, False]:
-                    c = np.empty(f.shape, dtype=np.bool_)
-                    c.fill(cond)
-                    result = expr.where(c, f.values, f.values + 1)
-                    expected = np.where(c, f.values, f.values + 1)
-                    tm.assert_numpy_array_equal(result, expected)
+            c = np.empty(df.shape, dtype=np.bool_)
+            c.fill(cond)
+            result = expr.where(c, df.values, df.values + 1)
+            expected = np.where(c, df.values, df.values + 1)
+            tm.assert_numpy_array_equal(result, expected)
 
         expr.set_use_numexpr(False)
         testit()
@@ -332,78 +255,81 @@ def testit():
         expr.set_numexpr_threads()
         testit()
 
-    def test_bool_ops_raise_on_arithmetic(self):
+    @pytest.mark.parametrize(
+        "op_str,opname", [("/", "truediv"), ("//", "floordiv"), ("**", "pow")]
+    )
+    def test_bool_ops_raise_on_arithmetic(self, op_str, opname):
         df = DataFrame({"a": np.random.rand(10) > 0.5, "b": np.random.rand(10) > 0.5})
-        names = "truediv", "floordiv", "pow"
-        ops = "/", "//", "**"
-        msg = "operator %r not implemented for bool dtypes"
-        for op, name in zip(ops, names):
-            f = getattr(operator, name)
-            err_msg = re.escape(msg % op)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(df, df)
+        msg = f"operator {repr(op_str)} not implemented for bool dtypes"
+        f = getattr(operator, opname)
+        err_msg = re.escape(msg)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(df.a, df.b)
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df, df)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(df.a, True)
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df.a, df.b)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(False, df.a)
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df.a, True)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(False, df)
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(False, df.a)
 
-            with pytest.raises(NotImplementedError, match=err_msg):
-                f(df, True)
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(False, df)
 
-    def test_bool_ops_warn_on_arithmetic(self):
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df, True)
+
+    @pytest.mark.parametrize(
+        "op_str,opname", [("+", "add"), ("*", "mul"), ("-", "sub")]
+    )
+    def test_bool_ops_warn_on_arithmetic(self, op_str, opname):
         n = 10
         df = DataFrame({"a": np.random.rand(n) > 0.5, "b": np.random.rand(n) > 0.5})
-        names = "add", "mul", "sub"
-        ops = "+", "*", "-"
+
         subs = {"+": "|", "*": "&", "-": "^"}
         sub_funcs = {"|": "or_", "&": "and_", "^": "xor"}
-        for op, name in zip(ops, names):
-            f = getattr(operator, name)
-            fe = getattr(operator, sub_funcs[subs[op]])
-
-            if op == "-":
-                # raises TypeError
-                continue
-
-            with tm.use_numexpr(True, min_elements=5):
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(df, df)
-                    e = fe(df, df)
-                    tm.assert_frame_equal(r, e)
-
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(df.a, df.b)
-                    e = fe(df.a, df.b)
-                    tm.assert_series_equal(r, e)
-
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(df.a, True)
-                    e = fe(df.a, True)
-                    tm.assert_series_equal(r, e)
-
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(False, df.a)
-                    e = fe(False, df.a)
-                    tm.assert_series_equal(r, e)
-
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(False, df)
-                    e = fe(False, df)
-                    tm.assert_frame_equal(r, e)
-
-                with tm.assert_produces_warning(check_stacklevel=False):
-                    r = f(df, True)
-                    e = fe(df, True)
-                    tm.assert_frame_equal(r, e)
+
+        f = getattr(operator, opname)
+        fe = getattr(operator, sub_funcs[subs[op_str]])
+
+        if op_str == "-":
+            # raises TypeError
+            return
+
+        with tm.use_numexpr(True, min_elements=5):
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(df, df)
+                e = fe(df, df)
+                tm.assert_frame_equal(r, e)
+
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(df.a, df.b)
+                e = fe(df.a, df.b)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(df.a, True)
+                e = fe(df.a, True)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(False, df.a)
+                e = fe(False, df.a)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(False, df)
+                e = fe(False, df)
+                tm.assert_frame_equal(r, e)
+
+            with tm.assert_produces_warning(check_stacklevel=False):
+                r = f(df, True)
+                e = fe(df, True)
+                tm.assert_frame_equal(r, e)
 
     @pytest.mark.parametrize(
         "test_input,expected",
@@ -429,7 +355,7 @@ def test_bool_ops_warn_on_arithmetic(self):
     def test_bool_ops_column_name_dtype(self, test_input, expected):
         # GH 22383 - .ne fails if columns containing column name 'dtype'
         result = test_input.loc[:, ["a", "dtype"]].ne(test_input.loc[:, ["a", "dtype"]])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "arith", ("add", "sub", "mul", "mod", "truediv", "floordiv")
@@ -455,4 +381,4 @@ def test_frame_series_axis(self, axis, arith):
         expr.set_use_numexpr(True)
 
         result = op_func(other, axis=axis)
-        assert_frame_equal(expected, result)
+        tm.assert_frame_equal(expected, result)
diff --git a/pandas/tests/test_join.py b/pandas/tests/test_join.py
index e750193abb71a..129dc275c4d5a 100644
--- a/pandas/tests/test_join.py
+++ b/pandas/tests/test_join.py
@@ -1,57 +1,53 @@
 import numpy as np
+import pytest
 
 from pandas._libs import join as _join
 
 from pandas import Categorical, DataFrame, Index, merge
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal, assert_frame_equal
+import pandas._testing as tm
 
 
 class TestIndexer:
-    def test_outer_join_indexer(self):
-        typemap = [
-            ("int32", _join.outer_join_indexer_int32),
-            ("int64", _join.outer_join_indexer_int64),
-            ("float32", _join.outer_join_indexer_float32),
-            ("float64", _join.outer_join_indexer_float64),
-            ("object", _join.outer_join_indexer_object),
-        ]
-
-        for dtype, indexer in typemap:
-            left = np.arange(3, dtype=dtype)
-            right = np.arange(2, 5, dtype=dtype)
-            empty = np.array([], dtype=dtype)
-
-            result, lindexer, rindexer = indexer(left, right)
-            assert isinstance(result, np.ndarray)
-            assert isinstance(lindexer, np.ndarray)
-            assert isinstance(rindexer, np.ndarray)
-            tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
-            exp = np.array([0, 1, 2, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
-
-            result, lindexer, rindexer = indexer(empty, right)
-            tm.assert_numpy_array_equal(result, right)
-            exp = np.array([-1, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
-
-            result, lindexer, rindexer = indexer(left, empty)
-            tm.assert_numpy_array_equal(result, left)
-            exp = np.array([0, 1, 2], dtype=np.int64)
-            tm.assert_numpy_array_equal(lindexer, exp)
-            exp = np.array([-1, -1, -1], dtype=np.int64)
-            tm.assert_numpy_array_equal(rindexer, exp)
+    @pytest.mark.parametrize(
+        "dtype", ["int32", "int64", "float32", "float64", "object"]
+    )
+    def test_outer_join_indexer(self, dtype):
+        indexer = _join.outer_join_indexer
+
+        left = np.arange(3, dtype=dtype)
+        right = np.arange(2, 5, dtype=dtype)
+        empty = np.array([], dtype=dtype)
+
+        result, lindexer, rindexer = indexer(left, right)
+        assert isinstance(result, np.ndarray)
+        assert isinstance(lindexer, np.ndarray)
+        assert isinstance(rindexer, np.ndarray)
+        tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
+        exp = np.array([0, 1, 2, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(empty, right)
+        tm.assert_numpy_array_equal(result, right)
+        exp = np.array([-1, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(left, empty)
+        tm.assert_numpy_array_equal(result, left)
+        exp = np.array([0, 1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(rindexer, exp)
 
 
 def test_left_join_indexer_unique():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([2, 2, 3, 4, 4], dtype=np.int64)
 
-    result = _join.left_join_indexer_unique_int64(b, a)
+    result = _join.left_join_indexer_unique(b, a)
     expected = np.array([1, 1, 2, 3, 3], dtype=np.int64)
     tm.assert_numpy_array_equal(result, expected)
 
@@ -182,20 +178,20 @@ def test_inner_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.inner_join_indexer_int64(a, b)
+    index, ares, bres = _join.inner_join_indexer(a, b)
 
     index_exp = np.array([3, 5], dtype=np.int64)
-    assert_almost_equal(index, index_exp)
+    tm.assert_almost_equal(index, index_exp)
 
     aexp = np.array([2, 4], dtype=np.int64)
     bexp = np.array([1, 2], dtype=np.int64)
-    assert_almost_equal(ares, aexp)
-    assert_almost_equal(bres, bexp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
 
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.inner_join_indexer_int64(a, b)
+    index, ares, bres = _join.inner_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -205,20 +201,20 @@ def test_outer_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.outer_join_indexer_int64(a, b)
+    index, ares, bres = _join.outer_join_indexer(a, b)
 
     index_exp = np.array([0, 1, 2, 3, 4, 5, 7, 9], dtype=np.int64)
-    assert_almost_equal(index, index_exp)
+    tm.assert_almost_equal(index, index_exp)
 
     aexp = np.array([-1, 0, 1, 2, 3, 4, -1, -1], dtype=np.int64)
     bexp = np.array([0, -1, -1, 1, -1, 2, 3, 4], dtype=np.int64)
-    assert_almost_equal(ares, aexp)
-    assert_almost_equal(bres, bexp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
 
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.outer_join_indexer_int64(a, b)
+    index, ares, bres = _join.outer_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -228,19 +224,19 @@ def test_left_join_indexer():
     a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
     b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
 
-    index, ares, bres = _join.left_join_indexer_int64(a, b)
+    index, ares, bres = _join.left_join_indexer(a, b)
 
-    assert_almost_equal(index, a)
+    tm.assert_almost_equal(index, a)
 
     aexp = np.array([0, 1, 2, 3, 4], dtype=np.int64)
     bexp = np.array([-1, -1, 1, -1, 2], dtype=np.int64)
-    assert_almost_equal(ares, aexp)
-    assert_almost_equal(bres, bexp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
 
     a = np.array([5], dtype=np.int64)
     b = np.array([5], dtype=np.int64)
 
-    index, ares, bres = _join.left_join_indexer_int64(a, b)
+    index, ares, bres = _join.left_join_indexer(a, b)
     tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
     tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.int64))
     tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.int64))
@@ -250,48 +246,48 @@ def test_left_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.left_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.left_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
-    assert_almost_equal(res, exp_res)
+    tm.assert_almost_equal(res, exp_res)
 
     exp_lidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.int64)
-    assert_almost_equal(lidx, exp_lidx)
+    tm.assert_almost_equal(lidx, exp_lidx)
 
     exp_ridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.int64)
-    assert_almost_equal(ridx, exp_ridx)
+    tm.assert_almost_equal(ridx, exp_ridx)
 
 
 def test_outer_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.outer_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.outer_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
-    assert_almost_equal(res, exp_res)
+    tm.assert_almost_equal(res, exp_res)
 
     exp_lidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.int64)
-    assert_almost_equal(lidx, exp_lidx)
+    tm.assert_almost_equal(lidx, exp_lidx)
 
     exp_ridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.int64)
-    assert_almost_equal(ridx, exp_ridx)
+    tm.assert_almost_equal(ridx, exp_ridx)
 
 
 def test_inner_join_indexer2():
     idx = Index([1, 1, 2, 5])
     idx2 = Index([1, 2, 5, 7, 9])
 
-    res, lidx, ridx = _join.inner_join_indexer_int64(idx2.values, idx.values)
+    res, lidx, ridx = _join.inner_join_indexer(idx2.values, idx.values)
 
     exp_res = np.array([1, 1, 2, 5], dtype=np.int64)
-    assert_almost_equal(res, exp_res)
+    tm.assert_almost_equal(res, exp_res)
 
     exp_lidx = np.array([0, 0, 1, 2], dtype=np.int64)
-    assert_almost_equal(lidx, exp_lidx)
+    tm.assert_almost_equal(lidx, exp_lidx)
 
     exp_ridx = np.array([0, 1, 2, 3], dtype=np.int64)
-    assert_almost_equal(ridx, exp_ridx)
+    tm.assert_almost_equal(ridx, exp_ridx)
 
 
 def test_merge_join_categorical_multiindex():
@@ -318,7 +314,7 @@ def test_merge_join_categorical_multiindex():
     )
     result = a.join(b, on=["Cat1", "Int1"])
     expected = expected.drop(["Cat", "Int"], axis=1)
-    assert_frame_equal(expected, result)
+    tm.assert_frame_equal(expected, result)
 
     # Same test, but with ordered categorical
     a = {
@@ -347,4 +343,4 @@ def test_merge_join_categorical_multiindex():
     )
     result = a.join(b, on=["Cat1", "Int1"])
     expected = expected.drop(["Cat", "Int"], axis=1)
-    assert_frame_equal(expected, result)
+    tm.assert_frame_equal(expected, result)
diff --git a/pandas/tests/test_lib.py b/pandas/tests/test_lib.py
index 77841f0bb9f0d..d914cf873de24 100644
--- a/pandas/tests/test_lib.py
+++ b/pandas/tests/test_lib.py
@@ -4,7 +4,7 @@
 from pandas._libs import lib, writers as libwriters
 
 from pandas import Index
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 class TestMisc:
@@ -22,7 +22,8 @@ def test_max_len_string_array(self):
         assert libwriters.max_len_string_array(arr) == 3
 
         # raises
-        with pytest.raises(TypeError):
+        msg = "No matching signature found"
+        with pytest.raises(TypeError, match=msg):
             libwriters.max_len_string_array(arr.astype("U"))
 
     def test_fast_unique_multiple_list_gen_sort(self):
@@ -100,9 +101,11 @@ def test_maybe_indices_to_slice_right_edge(self):
         assert not isinstance(maybe_slice, slice)
         tm.assert_numpy_array_equal(maybe_slice, indices)
 
-        with pytest.raises(IndexError):
+        msg = "index 100 is out of bounds for axis (0|1) with size 100"
+
+        with pytest.raises(IndexError, match=msg):
             target[indices]
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             target[maybe_slice]
 
         indices = np.array([100, 99, 98, 97], dtype=np.int64)
@@ -111,9 +114,9 @@ def test_maybe_indices_to_slice_right_edge(self):
         assert not isinstance(maybe_slice, slice)
         tm.assert_numpy_array_equal(maybe_slice, indices)
 
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             target[indices]
-        with pytest.raises(IndexError):
+        with pytest.raises(IndexError, match=msg):
             target[maybe_slice]
 
         for case in [[99, 97, 99, 96], [99, 99, 98, 97], [98, 98, 97, 96]]:
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index dc4db6e7902a8..b377ca2869bd3 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -2,7 +2,6 @@
 from io import StringIO
 import itertools
 from itertools import product
-from warnings import catch_warnings, simplefilter
 
 import numpy as np
 from numpy.random import randn
@@ -12,9 +11,8 @@
 from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype
 
 import pandas as pd
-from pandas import DataFrame, Series, Timestamp, isna
-from pandas.core.index import Index, MultiIndex
-import pandas.util.testing as tm
+from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, isna
+import pandas._testing as tm
 
 AGG_FUNCTIONS = [
     "sum",
@@ -121,7 +119,8 @@ def test_append_index(self):
                     (1.2, tz.localize(datetime.datetime(2011, 1, 2)), "B"),
                     (1.3, tz.localize(datetime.datetime(2011, 1, 3)), "C"),
                 ]
-                + expected_tuples
+                + expected_tuples,
+                dtype=object,
             ),
             None,
         )
@@ -209,11 +208,6 @@ def test_reindex(self):
         reindexed = self.frame.loc[[("foo", "one"), ("bar", "one")]]
         tm.assert_frame_equal(reindexed, expected)
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            reindexed = self.frame.ix[[("foo", "one"), ("bar", "one")]]
-        tm.assert_frame_equal(reindexed, expected)
-
     def test_reindex_preserve_levels(self):
         new_index = self.ymd.index[::10]
         chunk = self.ymd.reindex(new_index)
@@ -222,11 +216,6 @@ def test_reindex_preserve_levels(self):
         chunk = self.ymd.loc[new_index]
         assert chunk.index is new_index
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            chunk = self.ymd.ix[new_index]
-        assert chunk.index is new_index
-
         ymdT = self.ymd.T
         chunk = ymdT.reindex(columns=new_index)
         assert chunk.columns is new_index
@@ -257,7 +246,7 @@ def test_repr_name_coincide(self):
         assert lines[2].startswith("a 0 foo")
 
     def test_delevel_infer_dtype(self):
-        tuples = [tuple for tuple in product(["foo", "bar"], [10, 20], [1.0, 1.1])]
+        tuples = list(product(["foo", "bar"], [10, 20], [1.0, 1.1]))
         index = MultiIndex.from_tuples(tuples, names=["prm0", "prm1", "prm2"])
         df = DataFrame(np.random.randn(8, 3), columns=["A", "B", "C"], index=index)
         deleveled = df.reset_index()
@@ -335,7 +324,7 @@ def test_count_level_corner(self):
         df = self.frame[:0]
         result = df.count(level=0)
         expected = (
-            DataFrame(index=s.index.levels[0], columns=df.columns)
+            DataFrame(index=s.index.levels[0].set_names(["first"]), columns=df.columns)
             .fillna(0)
             .astype(np.int64)
         )
@@ -358,6 +347,49 @@ def test_unstack(self):
         # test that int32 work
         self.ymd.astype(np.int32).unstack()
 
+    @pytest.mark.parametrize(
+        "result_rows,result_columns,index_product,expected_row",
+        [
+            (
+                [[1, 1, None, None, 30.0, None], [2, 2, None, None, 30.0, None]],
+                ["ix1", "ix2", "col1", "col2", "col3", "col4"],
+                2,
+                [None, None, 30.0, None],
+            ),
+            (
+                [[1, 1, None, None, 30.0], [2, 2, None, None, 30.0]],
+                ["ix1", "ix2", "col1", "col2", "col3"],
+                2,
+                [None, None, 30.0],
+            ),
+            (
+                [[1, 1, None, None, 30.0], [2, None, None, None, 30.0]],
+                ["ix1", "ix2", "col1", "col2", "col3"],
+                None,
+                [None, None, 30.0],
+            ),
+        ],
+    )
+    def test_unstack_partial(
+        self, result_rows, result_columns, index_product, expected_row
+    ):
+        # check for regressions on this issue:
+        # https://github.com/pandas-dev/pandas/issues/19351
+        # make sure DataFrame.unstack() works when its run on a subset of the DataFrame
+        # and the Index levels contain values that are not present in the subset
+        result = pd.DataFrame(result_rows, columns=result_columns).set_index(
+            ["ix1", "ix2"]
+        )
+        result = result.iloc[1:2].unstack("ix2")
+        expected = pd.DataFrame(
+            [expected_row],
+            columns=pd.MultiIndex.from_product(
+                [result_columns[2:], [index_product]], names=[None, "ix2"]
+            ),
+            index=pd.Index([2], name="ix1"),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_unstack_multiple_no_empty_columns(self):
         index = MultiIndex.from_tuples(
             [(0, "foo", 0), (0, "bar", 0), (1, "baz", 1), (1, "qux", 1)]
@@ -540,6 +572,17 @@ def test_stack_unstack_wrong_level_name(self, method):
             with pytest.raises(KeyError, match="does not match index name"):
                 getattr(s, method)("mistake")
 
+    def test_unused_level_raises(self):
+        # GH 20410
+        mi = MultiIndex(
+            levels=[["a_lot", "onlyone", "notevenone"], [1970, ""]],
+            codes=[[1, 0], [1, 0]],
+        )
+        df = DataFrame(-1, index=range(3), columns=mi)
+
+        with pytest.raises(KeyError, match="notevenone"):
+            df["notevenone"]
+
     def test_unstack_level_name(self):
         result = self.frame.unstack("second")
         expected = self.frame.unstack(level=1)
@@ -848,6 +891,31 @@ def manual_compare_stacked(df, df_stacked, lev0, lev1):
         )
         manual_compare_stacked(df, df.stack(0), 0, 1)
 
+    def test_stack_unstack_unordered_multiindex(self):
+        # GH 18265
+        values = np.arange(5)
+        data = np.vstack(
+            [
+                ["b{}".format(x) for x in values],  # b0, b1, ..
+                ["a{}".format(x) for x in values],
+            ]
+        )  # a0, a1, ..
+        df = pd.DataFrame(data.T, columns=["b", "a"])
+        df.columns.name = "first"
+        second_level_dict = {"x": df}
+        multi_level_df = pd.concat(second_level_dict, axis=1)
+        multi_level_df.columns.names = ["second", "first"]
+        df = multi_level_df.reindex(sorted(multi_level_df.columns), axis=1)
+        result = df.stack(["first", "second"]).unstack(["first", "second"])
+        expected = DataFrame(
+            [["a0", "b0"], ["a1", "b1"], ["a2", "b2"], ["a3", "b3"], ["a4", "b4"]],
+            index=[0, 1, 2, 3, 4],
+            columns=MultiIndex.from_tuples(
+                [("a", "x"), ("b", "x")], names=["first", "second"]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_groupby_corner(self):
         midx = MultiIndex(
             levels=[["foo"], ["bar"], ["baz"]],
@@ -914,6 +982,10 @@ def test_swaplevel(self):
         exp = self.frame.swaplevel("first", "second").T
         tm.assert_frame_equal(swapped, exp)
 
+        msg = "Can only swap levels on a hierarchical axis."
+        with pytest.raises(TypeError, match=msg):
+            DataFrame(range(3)).swaplevel()
+
     def test_reorder_levels(self):
         result = self.ymd.reorder_levels(["month", "day", "year"])
         expected = self.ymd.swaplevel(0, 1).swaplevel(1, 2)
@@ -975,14 +1047,12 @@ def test_count(self):
         series.index.names = ["a", "b"]
 
         result = series.count(level="b")
-        expect = self.series.count(level=1)
-        tm.assert_series_equal(result, expect, check_names=False)
-        assert result.index.name == "b"
+        expect = self.series.count(level=1).rename_axis("b")
+        tm.assert_series_equal(result, expect)
 
         result = series.count(level="a")
-        expect = self.series.count(level=0)
-        tm.assert_series_equal(result, expect, check_names=False)
-        assert result.index.name == "a"
+        expect = self.series.count(level=0).rename_axis("a")
+        tm.assert_series_equal(result, expect)
 
         msg = "Level x not found"
         with pytest.raises(KeyError, match=msg):
@@ -1014,6 +1084,8 @@ def test_frame_group_ops(self, op, level, axis, skipna, sort):
         self.frame.iloc[1, [1, 2]] = np.nan
         self.frame.iloc[7, [0, 1]] = np.nan
 
+        level_name = self.frame.index.names[level]
+
         if axis == 0:
             frame = self.frame
         else:
@@ -1034,7 +1106,7 @@ def aggf(x):
             frame = frame.sort_index(level=level, axis=axis)
 
         # for good measure, groupby detail
-        level_index = frame._get_axis(axis).levels[level]
+        level_index = frame._get_axis(axis).levels[level].rename(level_name)
 
         tm.assert_index_equal(leftside._get_axis(axis), level_index)
         tm.assert_index_equal(rightside._get_axis(axis), level_index)
@@ -1065,6 +1137,23 @@ def test_frame_any_all_group(self):
         ex = DataFrame({"data": [False, False]}, index=["one", "two"])
         tm.assert_frame_equal(result, ex)
 
+    def test_series_any_timedelta(self):
+        # GH 17667
+        df = DataFrame(
+            {
+                "a": Series([0, 0]),
+                "t": Series([pd.to_timedelta(0, "s"), pd.to_timedelta(1, "ms")]),
+            }
+        )
+
+        result = df.any(axis=0)
+        expected = Series(data=[False, True], index=["a", "t"])
+        tm.assert_series_equal(result, expected)
+
+        result = df.any(axis=1)
+        expected = Series(data=[False, True])
+        tm.assert_series_equal(result, expected)
+
     def test_std_var_pass_ddof(self):
         index = MultiIndex.from_arrays(
             [np.arange(5).repeat(10), np.tile(np.arange(10), 5)]
@@ -1299,6 +1388,30 @@ def test_mixed_depth_drop(self):
         )
         tm.assert_frame_equal(expected, result)
 
+    def test_drop_multiindex_other_level_nan(self):
+        # GH 12754
+        df = (
+            DataFrame(
+                {
+                    "A": ["one", "one", "two", "two"],
+                    "B": [np.nan, 0.0, 1.0, 2.0],
+                    "C": ["a", "b", "c", "c"],
+                    "D": [1, 2, 3, 4],
+                }
+            )
+            .set_index(["A", "B", "C"])
+            .sort_index()
+        )
+        result = df.drop("c", level="C")
+        expected = DataFrame(
+            [2, 1],
+            columns=["D"],
+            index=pd.MultiIndex.from_tuples(
+                [("one", 0.0, "b"), ("one", np.nan, "a")], names=["A", "B", "C"]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_drop_nonunique(self):
         df = DataFrame(
             [
@@ -1467,25 +1580,36 @@ def test_frame_dict_constructor_empty_series(self):
         s2 = Series(
             [1, 2, 3, 4], index=MultiIndex.from_tuples([(1, 2), (1, 3), (3, 2), (3, 4)])
         )
-        s3 = Series()
+        s3 = Series(dtype=object)
 
         # it works!
         DataFrame({"foo": s1, "bar": s2, "baz": s3})
         DataFrame.from_dict({"foo": s1, "baz": s3, "bar": s2})
 
-    def test_multiindex_na_repr(self):
-        # only an issue with long columns
+    @pytest.mark.parametrize("d", [4, "d"])
+    def test_empty_frame_groupby_dtypes_consistency(self, d):
+        # GH 20888
+        group_keys = ["a", "b", "c"]
+        df = DataFrame({"a": [1], "b": [2], "c": [3], "d": [d]})
 
-        from numpy import nan
+        g = df[df.a == 2].groupby(group_keys)
+        result = g.first().index
+        expected = MultiIndex(
+            levels=[[1], [2], [3]], codes=[[], [], []], names=["a", "b", "c"]
+        )
+
+        tm.assert_index_equal(result, expected)
 
+    def test_multiindex_na_repr(self):
+        # only an issue with long columns
         df3 = DataFrame(
             {
                 "A" * 30: {("A", "A0006000", "nuit"): "A0006000"},
-                "B" * 30: {("A", "A0006000", "nuit"): nan},
-                "C" * 30: {("A", "A0006000", "nuit"): nan},
-                "D" * 30: {("A", "A0006000", "nuit"): nan},
+                "B" * 30: {("A", "A0006000", "nuit"): np.nan},
+                "C" * 30: {("A", "A0006000", "nuit"): np.nan},
+                "D" * 30: {("A", "A0006000", "nuit"): np.nan},
                 "E" * 30: {("A", "A0006000", "nuit"): "A"},
-                "F" * 30: {("A", "A0006000", "nuit"): nan},
+                "F" * 30: {("A", "A0006000", "nuit"): np.nan},
             }
         )
 
@@ -1625,10 +1749,14 @@ def test_constructor_with_tz(self):
         )
 
         result = MultiIndex.from_arrays([index, columns])
+
+        assert result.names == ["dt1", "dt2"]
         tm.assert_index_equal(result.levels[0], index)
         tm.assert_index_equal(result.levels[1], columns)
 
         result = MultiIndex.from_arrays([Series(index), Series(columns)])
+
+        assert result.names == ["dt1", "dt2"]
         tm.assert_index_equal(result.levels[0], index)
         tm.assert_index_equal(result.levels[1], columns)
 
@@ -1660,10 +1788,12 @@ def test_set_index_datetime(self):
         df = df.set_index("label", append=True)
         tm.assert_index_equal(df.index.levels[0], expected)
         tm.assert_index_equal(df.index.levels[1], Index(["a", "b"], name="label"))
+        assert df.index.names == ["datetime", "label"]
 
         df = df.swaplevel(0, 1)
         tm.assert_index_equal(df.index.levels[0], Index(["a", "b"], name="label"))
         tm.assert_index_equal(df.index.levels[1], expected)
+        assert df.index.names == ["label", "datetime"]
 
         df = DataFrame(np.random.random(6))
         idx1 = pd.DatetimeIndex(
@@ -1912,6 +2042,15 @@ def test_repeat(self):
         m_df = Series(data, index=m_idx)
         assert m_df.repeat(3).shape == (3 * len(data),)
 
+    def test_subsets_multiindex_dtype(self):
+        # GH 20757
+        data = [["x", 1]]
+        columns = [("a", "b", np.nan), ("a", "c", 0.0)]
+        df = DataFrame(data, columns=pd.MultiIndex.from_tuples(columns))
+        expected = df.dtypes.a.b
+        result = df.a.b.dtypes
+        tm.assert_series_equal(result, expected)
+
 
 class TestSorted(Base):
     """ everything you wanted to test about sorting """
@@ -2037,6 +2176,40 @@ def test_sort_index_level_mixed(self):
             sorted_after.drop([("foo", "three")], axis=1),
         )
 
+    def test_sort_index_categorical_multiindex(self):
+        # GH 15058
+        df = DataFrame(
+            {
+                "a": range(6),
+                "l1": pd.Categorical(
+                    ["a", "a", "b", "b", "c", "c"],
+                    categories=["c", "a", "b"],
+                    ordered=True,
+                ),
+                "l2": [0, 1, 0, 1, 0, 1],
+            }
+        )
+        result = df.set_index(["l1", "l2"]).sort_index()
+        expected = DataFrame(
+            [4, 5, 0, 1, 2, 3],
+            columns=["a"],
+            index=MultiIndex(
+                levels=[
+                    pd.CategoricalIndex(
+                        ["c", "a", "b"],
+                        categories=["c", "a", "b"],
+                        ordered=True,
+                        name="l1",
+                        dtype="category",
+                    ),
+                    [0, 1],
+                ],
+                codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+                names=["l1", "l2"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
     def test_is_lexsorted(self):
         levels = [[0, 1], [0, 1, 2]]
 
@@ -2056,6 +2229,53 @@ def test_is_lexsorted(self):
         assert not index.is_lexsorted()
         assert index.lexsort_depth == 0
 
+    def test_raise_invalid_sortorder(self):
+        # Test that the MultiIndex constructor raise when a incorrect sortorder is given
+        # Issue #28518
+
+        levels = [[0, 1], [0, 1, 2]]
+
+        # Correct sortorder
+        MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], sortorder=2
+        )
+
+        with pytest.raises(ValueError, match=r".* sortorder 2 with lexsort_depth 1.*"):
+            MultiIndex(
+                levels=levels,
+                codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
+                sortorder=2,
+            )
+
+        with pytest.raises(ValueError, match=r".* sortorder 1 with lexsort_depth 0.*"):
+            MultiIndex(
+                levels=levels,
+                codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
+                sortorder=1,
+            )
+
+    def test_lexsort_depth(self):
+        # Test that lexsort_depth return the  correct sortorder
+        # when it was given to the MultiIndex const.
+        # Issue #28518
+
+        levels = [[0, 1], [0, 1, 2]]
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], sortorder=2
+        )
+        assert index.lexsort_depth == 2
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=1
+        )
+        assert index.lexsort_depth == 1
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=0
+        )
+        assert index.lexsort_depth == 0
+
     def test_sort_index_and_reconstruction(self):
 
         # 15622
@@ -2153,6 +2373,14 @@ def test_sort_index_and_reconstruction_doc_example(self):
 
         tm.assert_frame_equal(result, expected)
 
+    def test_sort_index_non_existent_label_multiindex(self):
+        # GH 12261
+        df = DataFrame(0, columns=[], index=pd.MultiIndex.from_product([[], []]))
+        df.loc["b", "2"] = 1
+        df.loc["a", "3"] = 1
+        result = df.sort_index().index.is_monotonic
+        assert result is True
+
     def test_sort_index_reorder_on_ops(self):
         # 15687
         df = DataFrame(
@@ -2306,3 +2534,29 @@ def test_sort_ascending_list(self):
         result = s.sort_index(level=["third", "first"], ascending=[False, True])
         expected = s.iloc[[0, 4, 1, 5, 2, 6, 3, 7]]
         tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "keys, expected",
+        [
+            (["b", "a"], [["b", "b", "a", "a"], [1, 2, 1, 2]]),
+            (["a", "b"], [["a", "a", "b", "b"], [1, 2, 1, 2]]),
+            ((["a", "b"], [1, 2]), [["a", "a", "b", "b"], [1, 2, 1, 2]]),
+            ((["a", "b"], [2, 1]), [["a", "a", "b", "b"], [2, 1, 2, 1]]),
+            ((["b", "a"], [2, 1]), [["b", "b", "a", "a"], [2, 1, 2, 1]]),
+            ((["b", "a"], [1, 2]), [["b", "b", "a", "a"], [1, 2, 1, 2]]),
+            ((["c", "a"], [2, 1]), [["c", "a", "a"], [1, 2, 1]]),
+        ],
+    )
+    @pytest.mark.parametrize("dim", ["index", "columns"])
+    def test_multilevel_index_loc_order(self, dim, keys, expected):
+        # GH 22797
+        # Try to respect order of keys given for MultiIndex.loc
+        kwargs = {dim: [["c", "a", "a", "b", "b"], [1, 1, 2, 1, 2]]}
+        df = pd.DataFrame(np.arange(25).reshape(5, 5), **kwargs,)
+        exp_index = MultiIndex.from_arrays(expected)
+        if dim == "index":
+            res = df.loc[keys, :]
+            tm.assert_index_equal(res.index, exp_index)
+        elif dim == "columns":
+            res = df.loc[:, keys]
+            tm.assert_index_equal(res.columns, exp_index)
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index 21ab28c94c978..2c5d028ebe42e 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -1,4 +1,5 @@
 from functools import partial
+import operator
 import warnings
 
 import numpy as np
@@ -10,11 +11,12 @@
 
 import pandas as pd
 from pandas import Series, isna
+import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray
 import pandas.core.nanops as nanops
-import pandas.util.testing as tm
 
 use_bn = nanops._USE_BOTTLENECK
+has_c16 = hasattr(np, "complex128")
 
 
 class TestnanopsDataFrame:
@@ -22,7 +24,7 @@ def setup_method(self, method):
         np.random.seed(11235)
         nanops._USE_BOTTLENECK = False
 
-        arr_shape = (11, 7, 5)
+        arr_shape = (11, 7)
 
         self.arr_float = np.random.randn(*arr_shape)
         self.arr_float1 = np.random.randn(*arr_shape)
@@ -66,21 +68,21 @@ def setup_method(self, method):
             self.arr_nan_infj = self.arr_inf * 1j
             self.arr_complex_nan_infj = np.vstack([self.arr_complex, self.arr_nan_infj])
 
-        self.arr_float_2d = self.arr_float[:, :, 0]
-        self.arr_float1_2d = self.arr_float1[:, :, 0]
+        self.arr_float_2d = self.arr_float
+        self.arr_float1_2d = self.arr_float1
 
-        self.arr_nan_2d = self.arr_nan[:, :, 0]
-        self.arr_float_nan_2d = self.arr_float_nan[:, :, 0]
-        self.arr_float1_nan_2d = self.arr_float1_nan[:, :, 0]
-        self.arr_nan_float1_2d = self.arr_nan_float1[:, :, 0]
+        self.arr_nan_2d = self.arr_nan
+        self.arr_float_nan_2d = self.arr_float_nan
+        self.arr_float1_nan_2d = self.arr_float1_nan
+        self.arr_nan_float1_2d = self.arr_nan_float1
 
-        self.arr_float_1d = self.arr_float[:, 0, 0]
-        self.arr_float1_1d = self.arr_float1[:, 0, 0]
+        self.arr_float_1d = self.arr_float[:, 0]
+        self.arr_float1_1d = self.arr_float1[:, 0]
 
-        self.arr_nan_1d = self.arr_nan[:, 0, 0]
-        self.arr_float_nan_1d = self.arr_float_nan[:, 0, 0]
-        self.arr_float1_nan_1d = self.arr_float1_nan[:, 0, 0]
-        self.arr_nan_float1_1d = self.arr_nan_float1[:, 0, 0]
+        self.arr_nan_1d = self.arr_nan[:, 0]
+        self.arr_float_nan_1d = self.arr_float_nan[:, 0]
+        self.arr_float1_nan_1d = self.arr_float1_nan[:, 0]
+        self.arr_nan_float1_1d = self.arr_nan_float1[:, 0]
 
     def teardown_method(self, method):
         nanops._USE_BOTTLENECK = use_bn
@@ -131,14 +133,9 @@ def _coerce_tds(targ, res):
                 if targ.dtype.kind != "O":
                     res = res.astype(targ.dtype)
                 else:
-                    try:
-                        res = res.astype("c16")
-                    except RuntimeError:
-                        res = res.astype("f8")
-                    try:
-                        targ = targ.astype("c16")
-                    except RuntimeError:
-                        targ = targ.astype("f8")
+                    cast_dtype = "c16" if has_c16 else "f8"
+                    res = res.astype(cast_dtype)
+                    targ = targ.astype(cast_dtype)
             # there should never be a case where numpy returns an object
             # but nanops doesn't, so make that an exception
             elif targ.dtype.kind == "O":
@@ -152,93 +149,62 @@ def check_fun_data(
         targfunc,
         testarval,
         targarval,
-        targarnanval,
         check_dtype=True,
         empty_targfunc=None,
-        **kwargs
+        **kwargs,
     ):
         for axis in list(range(targarval.ndim)) + [None]:
             for skipna in [False, True]:
-                targartempval = targarval if skipna else targarnanval
+                targartempval = targarval if skipna else testarval
                 if skipna and empty_targfunc and isna(targartempval).all():
                     targ = empty_targfunc(targartempval, axis=axis, **kwargs)
                 else:
                     targ = targfunc(targartempval, axis=axis, **kwargs)
 
-                try:
-                    res = testfunc(testarval, axis=axis, skipna=skipna, **kwargs)
+                res = testfunc(testarval, axis=axis, skipna=skipna, **kwargs)
+                self.check_results(targ, res, axis, check_dtype=check_dtype)
+                if skipna:
+                    res = testfunc(testarval, axis=axis, **kwargs)
+                    self.check_results(targ, res, axis, check_dtype=check_dtype)
+                if axis is None:
+                    res = testfunc(testarval, skipna=skipna, **kwargs)
+                    self.check_results(targ, res, axis, check_dtype=check_dtype)
+                if skipna and axis is None:
+                    res = testfunc(testarval, **kwargs)
                     self.check_results(targ, res, axis, check_dtype=check_dtype)
-                    if skipna:
-                        res = testfunc(testarval, axis=axis, **kwargs)
-                        self.check_results(targ, res, axis, check_dtype=check_dtype)
-                    if axis is None:
-                        res = testfunc(testarval, skipna=skipna, **kwargs)
-                        self.check_results(targ, res, axis, check_dtype=check_dtype)
-                    if skipna and axis is None:
-                        res = testfunc(testarval, **kwargs)
-                        self.check_results(targ, res, axis, check_dtype=check_dtype)
-                except BaseException as exc:
-                    exc.args += (
-                        "axis: {axis} of {of}".format(axis=axis, of=testarval.ndim - 1),
-                        "skipna: {skipna}".format(skipna=skipna),
-                        "kwargs: {kwargs}".format(kwargs=kwargs),
-                    )
-                    raise
 
         if testarval.ndim <= 1:
             return
 
-        try:
-            testarval2 = np.take(testarval, 0, axis=-1)
-            targarval2 = np.take(targarval, 0, axis=-1)
-            targarnanval2 = np.take(targarnanval, 0, axis=-1)
-        except ValueError:
-            return
+        # Recurse on lower-dimension
+        testarval2 = np.take(testarval, 0, axis=-1)
+        targarval2 = np.take(targarval, 0, axis=-1)
         self.check_fun_data(
             testfunc,
             targfunc,
             testarval2,
             targarval2,
-            targarnanval2,
             check_dtype=check_dtype,
             empty_targfunc=empty_targfunc,
-            **kwargs
+            **kwargs,
         )
 
-    def check_fun(
-        self,
-        testfunc,
-        targfunc,
-        testar,
-        targar=None,
-        targarnan=None,
-        empty_targfunc=None,
-        **kwargs
-    ):
-        if targar is None:
-            targar = testar
-        if targarnan is None:
-            targarnan = testar
+    def check_fun(self, testfunc, targfunc, testar, empty_targfunc=None, **kwargs):
+
+        targar = testar
+        if testar.endswith("_nan") and hasattr(self, testar[:-4]):
+            targar = testar[:-4]
+
         testarval = getattr(self, testar)
         targarval = getattr(self, targar)
-        targarnanval = getattr(self, targarnan)
-        try:
-            self.check_fun_data(
-                testfunc,
-                targfunc,
-                testarval,
-                targarval,
-                targarnanval,
-                empty_targfunc=empty_targfunc,
-                **kwargs
-            )
-        except BaseException as exc:
-            exc.args += (
-                "testar: {testar}".format(testar=testar),
-                "targar: {targar}".format(targar=targar),
-                "targarnan: {targarnan}".format(targarnan=targarnan),
-            )
-            raise
+        self.check_fun_data(
+            testfunc,
+            targfunc,
+            testarval,
+            targarval,
+            empty_targfunc=empty_targfunc,
+            **kwargs,
+        )
 
     def check_funs(
         self,
@@ -246,14 +212,13 @@ def check_funs(
         targfunc,
         allow_complex=True,
         allow_all_nan=True,
-        allow_str=True,
         allow_date=True,
         allow_tdelta=True,
         allow_obj=True,
-        **kwargs
+        **kwargs,
     ):
         self.check_fun(testfunc, targfunc, "arr_float", **kwargs)
-        self.check_fun(testfunc, targfunc, "arr_float_nan", "arr_float", **kwargs)
+        self.check_fun(testfunc, targfunc, "arr_float_nan", **kwargs)
         self.check_fun(testfunc, targfunc, "arr_int", **kwargs)
         self.check_fun(testfunc, targfunc, "arr_bool", **kwargs)
         objs = [
@@ -267,26 +232,15 @@ def check_funs(
 
         if allow_complex:
             self.check_fun(testfunc, targfunc, "arr_complex", **kwargs)
-            self.check_fun(
-                testfunc, targfunc, "arr_complex_nan", "arr_complex", **kwargs
-            )
+            self.check_fun(testfunc, targfunc, "arr_complex_nan", **kwargs)
             if allow_all_nan:
                 self.check_fun(testfunc, targfunc, "arr_nan_nanj", **kwargs)
             objs += [self.arr_complex.astype("O")]
 
-        if allow_str:
-            self.check_fun(testfunc, targfunc, "arr_str", **kwargs)
-            self.check_fun(testfunc, targfunc, "arr_utf", **kwargs)
-            objs += [self.arr_str.astype("O"), self.arr_utf.astype("O")]
-
         if allow_date:
-            try:
-                targfunc(self.arr_date)
-            except TypeError:
-                pass
-            else:
-                self.check_fun(testfunc, targfunc, "arr_date", **kwargs)
-                objs += [self.arr_date.astype("O")]
+            targfunc(self.arr_date)
+            self.check_fun(testfunc, targfunc, "arr_date", **kwargs)
+            objs += [self.arr_date.astype("O")]
 
         if allow_tdelta:
             try:
@@ -316,33 +270,20 @@ def _badobj_wrap(self, value, func, allow_complex=True, **kwargs):
                 value = value.astype("f8")
         return func(value, **kwargs)
 
-    def test_nanany(self):
+    @pytest.mark.parametrize(
+        "nan_op,np_op", [(nanops.nanany, np.any), (nanops.nanall, np.all)]
+    )
+    def test_nan_funcs(self, nan_op, np_op):
+        # TODO: allow tdelta, doesn't break tests
         self.check_funs(
-            nanops.nanany,
-            np.any,
-            allow_all_nan=False,
-            allow_str=False,
-            allow_date=False,
-            allow_tdelta=False,
-        )
-
-    def test_nanall(self):
-        self.check_funs(
-            nanops.nanall,
-            np.all,
-            allow_all_nan=False,
-            allow_str=False,
-            allow_date=False,
-            allow_tdelta=False,
+            nan_op, np_op, allow_all_nan=False, allow_date=False, allow_tdelta=False
         )
 
     def test_nansum(self):
         self.check_funs(
             nanops.nansum,
             np.sum,
-            allow_str=False,
             allow_date=False,
-            allow_tdelta=True,
             check_dtype=False,
             empty_targfunc=np.nansum,
         )
@@ -351,11 +292,9 @@ def test_nanmean(self):
         self.check_funs(
             nanops.nanmean,
             np.mean,
-            allow_complex=False,
+            allow_complex=False,  # TODO: allow this, doesn't break test
             allow_obj=False,
-            allow_str=False,
             allow_date=False,
-            allow_tdelta=True,
         )
 
     def test_nanmean_overflow(self):
@@ -363,7 +302,7 @@ def test_nanmean_overflow(self):
         # In the previous implementation mean can overflow for int dtypes, it
         # is now consistent with numpy
 
-        for a in [2 ** 55, -2 ** 55, 20150515061816532]:
+        for a in [2 ** 55, -(2 ** 55), 20150515061816532]:
             s = Series(a, index=range(500), dtype=np.int64)
             result = s.mean()
             np_result = s.values.mean()
@@ -371,22 +310,31 @@ def test_nanmean_overflow(self):
             assert result == np_result
             assert result.dtype == np.float64
 
-    def test_returned_dtype(self):
-
-        dtypes = [np.int16, np.int32, np.int64, np.float32, np.float64]
-        if hasattr(np, "float128"):
-            dtypes.append(np.float128)
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            np.int16,
+            np.int32,
+            np.int64,
+            np.float32,
+            np.float64,
+            getattr(np, "float128", None),
+        ],
+    )
+    def test_returned_dtype(self, dtype):
+        if dtype is None:
+            # no float128 available
+            return
 
-        for dtype in dtypes:
-            s = Series(range(10), dtype=dtype)
-            group_a = ["mean", "std", "var", "skew", "kurt"]
-            group_b = ["min", "max"]
-            for method in group_a + group_b:
-                result = getattr(s, method)()
-                if is_integer_dtype(dtype) and method in group_a:
-                    assert result.dtype == np.float64
-                else:
-                    assert result.dtype == dtype
+        s = Series(range(10), dtype=dtype)
+        group_a = ["mean", "std", "var", "skew", "kurt"]
+        group_b = ["min", "max"]
+        for method in group_a + group_b:
+            result = getattr(s, method)()
+            if is_integer_dtype(dtype) and method in group_a:
+                assert result.dtype == np.float64
+            else:
+                assert result.dtype == dtype
 
     def test_nanmedian(self):
         with warnings.catch_warnings(record=True):
@@ -395,9 +343,7 @@ def test_nanmedian(self):
                 nanops.nanmedian,
                 np.median,
                 allow_complex=False,
-                allow_str=False,
                 allow_date=False,
-                allow_tdelta=True,
                 allow_obj="convert",
             )
 
@@ -407,9 +353,7 @@ def test_nanvar(self, ddof):
             nanops.nanvar,
             np.var,
             allow_complex=False,
-            allow_str=False,
             allow_date=False,
-            allow_tdelta=True,
             allow_obj="convert",
             ddof=ddof,
         )
@@ -420,9 +364,7 @@ def test_nanstd(self, ddof):
             nanops.nanstd,
             np.std,
             allow_complex=False,
-            allow_str=False,
             allow_date=False,
-            allow_tdelta=True,
             allow_obj="convert",
             ddof=ddof,
         )
@@ -437,32 +379,19 @@ def test_nansem(self, ddof):
                 nanops.nansem,
                 sem,
                 allow_complex=False,
-                allow_str=False,
                 allow_date=False,
                 allow_tdelta=False,
                 allow_obj="convert",
                 ddof=ddof,
             )
 
-    def _minmax_wrap(self, value, axis=None, func=None):
-
-        # numpy warns if all nan
-        res = func(value, axis)
-        if res.dtype.kind == "m":
-            res = np.atleast_1d(res)
-        return res
-
-    def test_nanmin(self):
+    @pytest.mark.parametrize(
+        "nan_op,np_op", [(nanops.nanmin, np.min), (nanops.nanmax, np.max)]
+    )
+    def test_nanops_with_warnings(self, nan_op, np_op):
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("ignore", RuntimeWarning)
-            func = partial(self._minmax_wrap, func=np.min)
-            self.check_funs(nanops.nanmin, func, allow_str=False, allow_obj=False)
-
-    def test_nanmax(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", RuntimeWarning)
-            func = partial(self._minmax_wrap, func=np.max)
-            self.check_funs(nanops.nanmax, func, allow_str=False, allow_obj=False)
+            self.check_funs(nan_op, np_op, allow_obj=False)
 
     def _argminmax_wrap(self, value, axis=None, func=None):
         res = func(value, axis)
@@ -483,20 +412,13 @@ def test_nanargmax(self):
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("ignore", RuntimeWarning)
             func = partial(self._argminmax_wrap, func=np.argmax)
-            self.check_funs(
-                nanops.nanargmax,
-                func,
-                allow_str=False,
-                allow_obj=False,
-                allow_date=True,
-                allow_tdelta=True,
-            )
+            self.check_funs(nanops.nanargmax, func, allow_obj=False)
 
     def test_nanargmin(self):
         with warnings.catch_warnings(record=True):
             warnings.simplefilter("ignore", RuntimeWarning)
             func = partial(self._argminmax_wrap, func=np.argmin)
-            self.check_funs(nanops.nanargmin, func, allow_str=False, allow_obj=False)
+            self.check_funs(nanops.nanargmin, func, allow_obj=False)
 
     def _skew_kurt_wrap(self, values, axis=None, func=None):
         if not isinstance(values.dtype.type, np.floating):
@@ -520,7 +442,6 @@ def test_nanskew(self):
                 nanops.nanskew,
                 func,
                 allow_complex=False,
-                allow_str=False,
                 allow_date=False,
                 allow_tdelta=False,
             )
@@ -536,7 +457,6 @@ def test_nankurt(self):
                 nanops.nankurt,
                 func,
                 allow_complex=False,
-                allow_str=False,
                 allow_date=False,
                 allow_tdelta=False,
             )
@@ -545,7 +465,6 @@ def test_nanprod(self):
         self.check_funs(
             nanops.nanprod,
             np.prod,
-            allow_str=False,
             allow_date=False,
             allow_tdelta=False,
             empty_targfunc=np.nanprod,
@@ -557,7 +476,7 @@ def check_nancorr_nancov_2d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_2d,
             self.arr_float1_2d,
             min_periods=len(self.arr_float_2d) - 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ0, res00)
         tm.assert_almost_equal(targ0, res01)
@@ -567,7 +486,7 @@ def check_nancorr_nancov_2d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_nan_2d,
             self.arr_float1_nan_2d,
             min_periods=len(self.arr_float_2d) - 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ1, res10)
         tm.assert_almost_equal(targ1, res11)
@@ -581,13 +500,13 @@ def check_nancorr_nancov_2d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_nan_2d,
             self.arr_nan_float1_2d,
             min_periods=len(self.arr_float_2d) - 1,
-            **kwargs
+            **kwargs,
         )
         res25 = checkfun(
             self.arr_float_2d,
             self.arr_float1_2d,
             min_periods=len(self.arr_float_2d) + 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ2, res20)
         tm.assert_almost_equal(targ2, res21)
@@ -602,7 +521,7 @@ def check_nancorr_nancov_1d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_1d,
             self.arr_float1_1d,
             min_periods=len(self.arr_float_1d) - 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ0, res00)
         tm.assert_almost_equal(targ0, res01)
@@ -612,7 +531,7 @@ def check_nancorr_nancov_1d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_nan_1d,
             self.arr_float1_nan_1d,
             min_periods=len(self.arr_float_1d) - 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ1, res10)
         tm.assert_almost_equal(targ1, res11)
@@ -626,13 +545,13 @@ def check_nancorr_nancov_1d(self, checkfun, targ0, targ1, **kwargs):
             self.arr_float_nan_1d,
             self.arr_nan_float1_1d,
             min_periods=len(self.arr_float_1d) - 1,
-            **kwargs
+            **kwargs,
         )
         res25 = checkfun(
             self.arr_float_1d,
             self.arr_float1_1d,
             min_periods=len(self.arr_float_1d) + 1,
-            **kwargs
+            **kwargs,
         )
         tm.assert_almost_equal(targ2, res20)
         tm.assert_almost_equal(targ2, res21)
@@ -679,6 +598,14 @@ def test_nancorr_spearman(self):
         targ1 = spearmanr(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0]
         self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="spearman")
 
+    @td.skip_if_no_scipy
+    def test_invalid_method(self):
+        targ0 = np.corrcoef(self.arr_float_2d, self.arr_float1_2d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
+        msg = "Unkown method 'foo', expected one of 'kendall', 'spearman'"
+        with pytest.raises(ValueError, match=msg):
+            self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="foo")
+
     def test_nancov(self):
         targ0 = np.cov(self.arr_float_2d, self.arr_float1_2d)[0, 1]
         targ1 = np.cov(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
@@ -697,77 +624,58 @@ def check_nancomp(self, checkfun, targ0):
         arr_nan_float1 = self.arr_nan_float1
 
         while targ0.ndim:
-            try:
-                res0 = checkfun(arr_float, arr_float1)
-                tm.assert_almost_equal(targ0, res0)
-
-                if targ0.ndim > 1:
-                    targ1 = np.vstack([targ0, arr_nan])
-                else:
-                    targ1 = np.hstack([targ0, arr_nan])
-                res1 = checkfun(arr_float_nan, arr_float1_nan)
-                tm.assert_numpy_array_equal(targ1, res1, check_dtype=False)
-
-                targ2 = arr_nan_nan
-                res2 = checkfun(arr_float_nan, arr_nan_float1)
-                tm.assert_numpy_array_equal(targ2, res2, check_dtype=False)
-            except Exception as exc:
-                exc.args += ("ndim: {arr_float.ndim}".format(arr_float=arr_float),)
-                raise
+            res0 = checkfun(arr_float, arr_float1)
+            tm.assert_almost_equal(targ0, res0)
 
-            try:
-                arr_float = np.take(arr_float, 0, axis=-1)
-                arr_float1 = np.take(arr_float1, 0, axis=-1)
-                arr_nan = np.take(arr_nan, 0, axis=-1)
-                arr_nan_nan = np.take(arr_nan_nan, 0, axis=-1)
-                arr_float_nan = np.take(arr_float_nan, 0, axis=-1)
-                arr_float1_nan = np.take(arr_float1_nan, 0, axis=-1)
-                arr_nan_float1 = np.take(arr_nan_float1, 0, axis=-1)
-                targ0 = np.take(targ0, 0, axis=-1)
-            except ValueError:
-                break
-
-    def test_nangt(self):
-        targ0 = self.arr_float > self.arr_float1
-        self.check_nancomp(nanops.nangt, targ0)
-
-    def test_nange(self):
-        targ0 = self.arr_float >= self.arr_float1
-        self.check_nancomp(nanops.nange, targ0)
-
-    def test_nanlt(self):
-        targ0 = self.arr_float < self.arr_float1
-        self.check_nancomp(nanops.nanlt, targ0)
-
-    def test_nanle(self):
-        targ0 = self.arr_float <= self.arr_float1
-        self.check_nancomp(nanops.nanle, targ0)
-
-    def test_naneq(self):
-        targ0 = self.arr_float == self.arr_float1
-        self.check_nancomp(nanops.naneq, targ0)
-
-    def test_nanne(self):
-        targ0 = self.arr_float != self.arr_float1
-        self.check_nancomp(nanops.nanne, targ0)
-
-    def check_bool(self, func, value, correct, *args, **kwargs):
+            if targ0.ndim > 1:
+                targ1 = np.vstack([targ0, arr_nan])
+            else:
+                targ1 = np.hstack([targ0, arr_nan])
+            res1 = checkfun(arr_float_nan, arr_float1_nan)
+            tm.assert_numpy_array_equal(targ1, res1, check_dtype=False)
+
+            targ2 = arr_nan_nan
+            res2 = checkfun(arr_float_nan, arr_nan_float1)
+            tm.assert_numpy_array_equal(targ2, res2, check_dtype=False)
+
+            # Lower dimension for next step in the loop
+            arr_float = np.take(arr_float, 0, axis=-1)
+            arr_float1 = np.take(arr_float1, 0, axis=-1)
+            arr_nan = np.take(arr_nan, 0, axis=-1)
+            arr_nan_nan = np.take(arr_nan_nan, 0, axis=-1)
+            arr_float_nan = np.take(arr_float_nan, 0, axis=-1)
+            arr_float1_nan = np.take(arr_float1_nan, 0, axis=-1)
+            arr_nan_float1 = np.take(arr_nan_float1, 0, axis=-1)
+            targ0 = np.take(targ0, 0, axis=-1)
+
+    @pytest.mark.parametrize(
+        "op,nanop",
+        [
+            (operator.eq, nanops.naneq),
+            (operator.ne, nanops.nanne),
+            (operator.gt, nanops.nangt),
+            (operator.ge, nanops.nange),
+            (operator.lt, nanops.nanlt),
+            (operator.le, nanops.nanle),
+        ],
+    )
+    def test_nan_comparison(self, op, nanop):
+        targ0 = op(self.arr_float, self.arr_float1)
+        self.check_nancomp(nanop, targ0)
+
+    def check_bool(self, func, value, correct):
         while getattr(value, "ndim", True):
-            try:
-                res0 = func(value, *args, **kwargs)
-                if correct:
-                    assert res0
-                else:
-                    assert not res0
-            except BaseException as exc:
-                exc.args += ("dim: {}".format(getattr(value, "ndim", value)),)
-                raise
+            res0 = func(value)
+            if correct:
+                assert res0
+            else:
+                assert not res0
+
             if not hasattr(value, "ndim"):
                 break
-            try:
-                value = np.take(value, 0, axis=-1)
-            except ValueError:
-                break
+
+            # Reduce dimension for next step in the loop
+            value = np.take(value, 0, axis=-1)
 
     def test__has_infs(self):
         pairs = [
@@ -796,69 +704,13 @@ def test__has_infs(self):
 
         for arr, correct in pairs:
             val = getattr(self, arr)
-            try:
-                self.check_bool(nanops._has_infs, val, correct)
-            except BaseException as exc:
-                exc.args += (arr,)
-                raise
-
-        for arr, correct in pairs_float:
-            val = getattr(self, arr)
-            try:
-                self.check_bool(nanops._has_infs, val, correct)
-                self.check_bool(nanops._has_infs, val.astype("f4"), correct)
-                self.check_bool(nanops._has_infs, val.astype("f2"), correct)
-            except BaseException as exc:
-                exc.args += (arr,)
-                raise
-
-    def test__isfinite(self):
-        pairs = [
-            ("arr_complex", False),
-            ("arr_int", False),
-            ("arr_bool", False),
-            ("arr_str", False),
-            ("arr_utf", False),
-            ("arr_complex", False),
-            ("arr_complex_nan", True),
-            ("arr_nan_nanj", True),
-            ("arr_nan_infj", True),
-            ("arr_complex_nan_infj", True),
-        ]
-        pairs_float = [
-            ("arr_float", False),
-            ("arr_nan", True),
-            ("arr_float_nan", True),
-            ("arr_nan_nan", True),
-            ("arr_float_inf", True),
-            ("arr_inf", True),
-            ("arr_nan_inf", True),
-            ("arr_float_nan_inf", True),
-            ("arr_nan_nan_inf", True),
-        ]
-
-        func1 = lambda x: np.any(nanops._isfinite(x).ravel())
-
-        # TODO: unused?
-        # func2 = lambda x: np.any(nanops._isfinite(x).values.ravel())
-
-        for arr, correct in pairs:
-            val = getattr(self, arr)
-            try:
-                self.check_bool(func1, val, correct)
-            except BaseException as exc:
-                exc.args += (arr,)
-                raise
+            self.check_bool(nanops._has_infs, val, correct)
 
         for arr, correct in pairs_float:
             val = getattr(self, arr)
-            try:
-                self.check_bool(func1, val, correct)
-                self.check_bool(func1, val.astype("f4"), correct)
-                self.check_bool(func1, val.astype("f2"), correct)
-            except BaseException as exc:
-                exc.args += (arr,)
-                raise
+            self.check_bool(nanops._has_infs, val, correct)
+            self.check_bool(nanops._has_infs, val.astype("f4"), correct)
+            self.check_bool(nanops._has_infs, val.astype("f2"), correct)
 
     def test__bn_ok_dtype(self):
         assert nanops._bn_ok_dtype(self.arr_float.dtype, "test")
@@ -911,10 +763,11 @@ def test_non_convertable_values(self):
         msg = "Could not convert foo to numeric"
         with pytest.raises(TypeError, match=msg):
             nanops._ensure_numeric("foo")
-        msg = "Could not convert {} to numeric"
+
+        # with the wrong type, python raises TypeError for us
+        msg = "argument must be a string or a number"
         with pytest.raises(TypeError, match=msg):
             nanops._ensure_numeric({})
-        msg = r"Could not convert \[\] to numeric"
         with pytest.raises(TypeError, match=msg):
             nanops._ensure_numeric([])
 
diff --git a/pandas/tests/test_optional_dependency.py b/pandas/tests/test_optional_dependency.py
index cd154ed5fe570..ce527214e55e7 100644
--- a/pandas/tests/test_optional_dependency.py
+++ b/pandas/tests/test_optional_dependency.py
@@ -5,7 +5,7 @@
 
 from pandas.compat._optional import VERSIONS, import_optional_dependency
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_import_optional():
diff --git a/pandas/tests/test_register_accessor.py b/pandas/tests/test_register_accessor.py
index 97086f8ab1e85..d839936f731a3 100644
--- a/pandas/tests/test_register_accessor.py
+++ b/pandas/tests/test_register_accessor.py
@@ -3,13 +3,14 @@
 import pytest
 
 import pandas as pd
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @contextlib.contextmanager
 def ensure_removed(obj, attr):
     """Ensure that an attribute added to 'obj' during the test is
-    removed when we're done"""
+    removed when we're done
+    """
     try:
         yield
     finally:
@@ -45,7 +46,8 @@ def test_register(obj, registrar):
     with ensure_removed(obj, "mine"):
         before = set(dir(obj))
         registrar("mine")(MyAccessor)
-        assert obj([]).mine.prop == "item"
+        o = obj([]) if obj is not pd.Series else obj([], dtype=object)
+        assert o.mine.prop == "item"
         after = set(dir(obj))
         assert (before ^ after) == {"mine"}
         assert "mine" in obj._accessors
@@ -88,4 +90,4 @@ def __init__(self, data):
                 raise AttributeError("whoops")
 
         with pytest.raises(AttributeError, match="whoops"):
-            pd.Series([]).bad
+            pd.Series([], dtype=object).bad
diff --git a/pandas/tests/test_sorting.py b/pandas/tests/test_sorting.py
index f64ad8edafbd7..98297474243e4 100644
--- a/pandas/tests/test_sorting.py
+++ b/pandas/tests/test_sorting.py
@@ -3,21 +3,19 @@
 from itertools import product
 
 import numpy as np
-from numpy import nan
 import pytest
 
 from pandas import DataFrame, MultiIndex, Series, array, concat, merge
-from pandas.core import common as com
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
+import pandas.core.common as com
 from pandas.core.sorting import (
     decons_group_index,
     get_group_index,
     is_int64_overflow_possible,
     lexsort_indexer,
     nargsort,
-    safe_sort,
 )
-from pandas.util import testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 class TestSorting:
@@ -99,11 +97,11 @@ def aggr(func):
             res = DataFrame(arr, columns=["jim", "joe"], index=mi)
             return res.sort_index()
 
-        assert_frame_equal(gr.mean(), aggr(np.mean))
-        assert_frame_equal(gr.median(), aggr(np.median))
+        tm.assert_frame_equal(gr.mean(), aggr(np.mean))
+        tm.assert_frame_equal(gr.median(), aggr(np.median))
 
     def test_lexsort_indexer(self):
-        keys = [[nan] * 5 + list(range(100)) + [nan] * 5]
+        keys = [[np.nan] * 5 + list(range(100)) + [np.nan] * 5]
         # orders=True, na_position='last'
         result = lexsort_indexer(keys, orders=True, na_position="last")
         exp = list(range(5, 105)) + list(range(5)) + list(range(105, 110))
@@ -126,7 +124,7 @@ def test_lexsort_indexer(self):
 
     def test_nargsort(self):
         # np.argsort(items) places NaNs last
-        items = [nan] * 5 + list(range(100)) + [nan] * 5
+        items = [np.nan] * 5 + list(range(100)) + [np.nan] * 5
         # np.argsort(items2) may not place NaNs first
         items2 = np.array(items, dtype="O")
 
@@ -206,22 +204,22 @@ def test_int64_overflow_issues(self):
 
         out = merge(left, right, how="outer")
         assert len(out) == len(left)
-        assert_series_equal(out["left"], -out["right"], check_names=False)
+        tm.assert_series_equal(out["left"], -out["right"], check_names=False)
         result = out.iloc[:, :-2].sum(axis=1)
-        assert_series_equal(out["left"], result, check_names=False)
+        tm.assert_series_equal(out["left"], result, check_names=False)
         assert result.name is None
 
         out.sort_values(out.columns.tolist(), inplace=True)
         out.index = np.arange(len(out))
         for how in ["left", "right", "outer", "inner"]:
-            assert_frame_equal(out, merge(left, right, how=how, sort=True))
+            tm.assert_frame_equal(out, merge(left, right, how=how, sort=True))
 
         # check that left merge w/ sort=False maintains left frame order
         out = merge(left, right, how="left", sort=False)
-        assert_frame_equal(left, out[left.columns.tolist()])
+        tm.assert_frame_equal(left, out[left.columns.tolist()])
 
         out = merge(right, left, how="left", sort=False)
-        assert_frame_equal(right, out[right.columns.tolist()])
+        tm.assert_frame_equal(right, out[right.columns.tolist()])
 
         # one-2-many/none match
         n = 1 << 11
@@ -285,7 +283,7 @@ def align(df):
 
         def verify_order(df):
             kcols = list("ABCDEFG")
-            assert_frame_equal(
+            tm.assert_frame_equal(
                 df[kcols].copy(), df[kcols].sort_values(kcols, kind="mergesort")
             )
 
@@ -310,33 +308,33 @@ def verify_order(df):
                     verify_order(res)
 
                 # as in GH9092 dtypes break with outer/right join
-                assert_frame_equal(
+                tm.assert_frame_equal(
                     frame, align(res), check_dtype=how not in ("right", "outer")
                 )
 
 
 def test_decons():
-    def testit(label_list, shape):
-        group_index = get_group_index(label_list, shape, sort=True, xnull=True)
-        label_list2 = decons_group_index(group_index, shape)
+    def testit(codes_list, shape):
+        group_index = get_group_index(codes_list, shape, sort=True, xnull=True)
+        codes_list2 = decons_group_index(group_index, shape)
 
-        for a, b in zip(label_list, label_list2):
+        for a, b in zip(codes_list, codes_list2):
             tm.assert_numpy_array_equal(a, b)
 
     shape = (4, 5, 6)
-    label_list = [
+    codes_list = [
         np.tile([0, 1, 2, 3, 0, 1, 2, 3], 100).astype(np.int64),
         np.tile([0, 2, 4, 3, 0, 1, 2, 3], 100).astype(np.int64),
         np.tile([5, 1, 0, 2, 3, 0, 5, 4], 100).astype(np.int64),
     ]
-    testit(label_list, shape)
+    testit(codes_list, shape)
 
     shape = (10000, 10000)
-    label_list = [
+    codes_list = [
         np.tile(np.arange(10000, dtype=np.int64), 5),
         np.tile(np.arange(10000, dtype=np.int64), 5),
     ]
-    testit(label_list, shape)
+    testit(codes_list, shape)
 
 
 class TestSafeSort:
@@ -357,42 +355,42 @@ def test_basic_sort(self):
         tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize("verify", [True, False])
-    def test_labels(self, verify):
+    def test_codes(self, verify):
         values = [3, 1, 2, 0, 4]
         expected = np.array([0, 1, 2, 3, 4])
 
-        labels = [0, 1, 1, 2, 3, 0, -1, 4]
-        result, result_labels = safe_sort(values, labels, verify=verify)
-        expected_labels = np.array([3, 1, 1, 2, 0, 3, -1, 4], dtype=np.intp)
+        codes = [0, 1, 1, 2, 3, 0, -1, 4]
+        result, result_codes = safe_sort(values, codes, verify=verify)
+        expected_codes = np.array([3, 1, 1, 2, 0, 3, -1, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
-        tm.assert_numpy_array_equal(result_labels, expected_labels)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
 
         # na_sentinel
-        labels = [0, 1, 1, 2, 3, 0, 99, 4]
-        result, result_labels = safe_sort(values, labels, na_sentinel=99, verify=verify)
-        expected_labels = np.array([3, 1, 1, 2, 0, 3, 99, 4], dtype=np.intp)
+        codes = [0, 1, 1, 2, 3, 0, 99, 4]
+        result, result_codes = safe_sort(values, codes, na_sentinel=99, verify=verify)
+        expected_codes = np.array([3, 1, 1, 2, 0, 3, 99, 4], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
-        tm.assert_numpy_array_equal(result_labels, expected_labels)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
 
-        labels = []
-        result, result_labels = safe_sort(values, labels, verify=verify)
-        expected_labels = np.array([], dtype=np.intp)
+        codes = []
+        result, result_codes = safe_sort(values, codes, verify=verify)
+        expected_codes = np.array([], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
-        tm.assert_numpy_array_equal(result_labels, expected_labels)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
 
     @pytest.mark.parametrize("na_sentinel", [-1, 99])
-    def test_labels_out_of_bound(self, na_sentinel):
+    def test_codes_out_of_bound(self, na_sentinel):
         values = [3, 1, 2, 0, 4]
         expected = np.array([0, 1, 2, 3, 4])
 
         # out of bound indices
-        labels = [0, 101, 102, 2, 3, 0, 99, 4]
-        result, result_labels = safe_sort(values, labels, na_sentinel=na_sentinel)
-        expected_labels = np.array(
+        codes = [0, 101, 102, 2, 3, 0, 99, 4]
+        result, result_codes = safe_sort(values, codes, na_sentinel=na_sentinel)
+        expected_codes = np.array(
             [3, na_sentinel, na_sentinel, 2, 0, 3, na_sentinel, 4], dtype=np.intp
         )
         tm.assert_numpy_array_equal(result, expected)
-        tm.assert_numpy_array_equal(result_labels, expected_labels)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
 
     def test_mixed_integer(self):
         values = np.array(["b", 1, 0, "a", 0, "b"], dtype=object)
@@ -401,12 +399,12 @@ def test_mixed_integer(self):
         tm.assert_numpy_array_equal(result, expected)
 
         values = np.array(["b", 1, 0, "a"], dtype=object)
-        labels = [0, 1, 2, 3, 0, -1, 1]
-        result, result_labels = safe_sort(values, labels)
+        codes = [0, 1, 2, 3, 0, -1, 1]
+        result, result_codes = safe_sort(values, codes)
         expected = np.array([0, 1, "a", "b"], dtype=object)
-        expected_labels = np.array([3, 1, 0, 2, 3, -1, 1], dtype=np.intp)
+        expected_codes = np.array([3, 1, 0, 2, 3, -1, 1], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
-        tm.assert_numpy_array_equal(result_labels, expected_labels)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
 
     def test_mixed_integer_from_list(self):
         values = ["b", 1, 0, "a", 0, "b"]
@@ -430,10 +428,10 @@ def test_exceptions(self):
             safe_sort(values=1)
 
         with pytest.raises(TypeError, match="Only list-like objects or None"):
-            safe_sort(values=[0, 1, 2], labels=1)
+            safe_sort(values=[0, 1, 2], codes=1)
 
         with pytest.raises(ValueError, match="values should be unique"):
-            safe_sort(values=[0, 1, 2, 1], labels=[0, 1])
+            safe_sort(values=[0, 1, 2, 1], codes=[0, 1])
 
     def test_extension_array(self):
         # a = array([1, 3, np.nan, 2], dtype='Int64')
@@ -445,12 +443,12 @@ def test_extension_array(self):
 
     @pytest.mark.parametrize("verify", [True, False])
     @pytest.mark.parametrize("na_sentinel", [-1, 99])
-    def test_extension_array_labels(self, verify, na_sentinel):
+    def test_extension_array_codes(self, verify, na_sentinel):
         a = array([1, 3, 2], dtype="Int64")
-        result, labels = safe_sort(
+        result, codes = safe_sort(
             a, [0, 1, na_sentinel, 2], na_sentinel=na_sentinel, verify=verify
         )
         expected_values = array([1, 2, 3], dtype="Int64")
-        expected_labels = np.array([0, 2, na_sentinel, 1], dtype=np.intp)
+        expected_codes = np.array([0, 2, na_sentinel, 1], dtype=np.intp)
         tm.assert_extension_array_equal(result, expected_values)
-        tm.assert_numpy_array_equal(labels, expected_labels)
+        tm.assert_numpy_array_equal(codes, expected_codes)
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index bc8dc7272a83a..62d26dacde67b 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -2,64 +2,64 @@
 import re
 
 import numpy as np
-from numpy import nan as NA
 from numpy.random import randint
 import pytest
 
+from pandas._libs import lib
+
 from pandas import DataFrame, Index, MultiIndex, Series, concat, isna, notna
+import pandas._testing as tm
 import pandas.core.strings as strings
-import pandas.util.testing as tm
-from pandas.util.testing import assert_index_equal, assert_series_equal
 
 
 def assert_series_or_index_equal(left, right):
     if isinstance(left, Series):
-        assert_series_equal(left, right)
+        tm.assert_series_equal(left, right)
     else:  # Index
-        assert_index_equal(left, right)
+        tm.assert_index_equal(left, right)
 
 
 _any_string_method = [
-    ("cat", (), {"sep": ","}),  # noqa: E241
-    ("cat", (Series(list("zyx")),), {"sep": ",", "join": "left"}),  # noqa: E241
-    ("center", (10,), {}),  # noqa: E241
-    ("contains", ("a",), {}),  # noqa: E241
-    ("count", ("a",), {}),  # noqa: E241
-    ("decode", ("UTF-8",), {}),  # noqa: E241
-    ("encode", ("UTF-8",), {}),  # noqa: E241
-    ("endswith", ("a",), {}),  # noqa: E241
-    ("extract", ("([a-z]*)",), {"expand": False}),  # noqa: E241
-    ("extract", ("([a-z]*)",), {"expand": True}),  # noqa: E241
-    ("extractall", ("([a-z]*)",), {}),  # noqa: E241
-    ("find", ("a",), {}),  # noqa: E241
-    ("findall", ("a",), {}),  # noqa: E241
-    ("get", (0,), {}),  # noqa: E241
+    ("cat", (), {"sep": ","}),
+    ("cat", (Series(list("zyx")),), {"sep": ",", "join": "left"}),
+    ("center", (10,), {}),
+    ("contains", ("a",), {}),
+    ("count", ("a",), {}),
+    ("decode", ("UTF-8",), {}),
+    ("encode", ("UTF-8",), {}),
+    ("endswith", ("a",), {}),
+    ("extract", ("([a-z]*)",), {"expand": False}),
+    ("extract", ("([a-z]*)",), {"expand": True}),
+    ("extractall", ("([a-z]*)",), {}),
+    ("find", ("a",), {}),
+    ("findall", ("a",), {}),
+    ("get", (0,), {}),
     # because "index" (and "rindex") fail intentionally
     # if the string is not found, search only for empty string
-    ("index", ("",), {}),  # noqa: E241
-    ("join", (",",), {}),  # noqa: E241
-    ("ljust", (10,), {}),  # noqa: E241
-    ("match", ("a",), {}),  # noqa: E241
-    ("normalize", ("NFC",), {}),  # noqa: E241
-    ("pad", (10,), {}),  # noqa: E241
-    ("partition", (" ",), {"expand": False}),  # noqa: E241
-    ("partition", (" ",), {"expand": True}),  # noqa: E241
-    ("repeat", (3,), {}),  # noqa: E241
-    ("replace", ("a", "z"), {}),  # noqa: E241
-    ("rfind", ("a",), {}),  # noqa: E241
-    ("rindex", ("",), {}),  # noqa: E241
-    ("rjust", (10,), {}),  # noqa: E241
-    ("rpartition", (" ",), {"expand": False}),  # noqa: E241
-    ("rpartition", (" ",), {"expand": True}),  # noqa: E241
-    ("slice", (0, 1), {}),  # noqa: E241
-    ("slice_replace", (0, 1, "z"), {}),  # noqa: E241
-    ("split", (" ",), {"expand": False}),  # noqa: E241
-    ("split", (" ",), {"expand": True}),  # noqa: E241
-    ("startswith", ("a",), {}),  # noqa: E241
+    ("index", ("",), {}),
+    ("join", (",",), {}),
+    ("ljust", (10,), {}),
+    ("match", ("a",), {}),
+    ("normalize", ("NFC",), {}),
+    ("pad", (10,), {}),
+    ("partition", (" ",), {"expand": False}),
+    ("partition", (" ",), {"expand": True}),
+    ("repeat", (3,), {}),
+    ("replace", ("a", "z"), {}),
+    ("rfind", ("a",), {}),
+    ("rindex", ("",), {}),
+    ("rjust", (10,), {}),
+    ("rpartition", (" ",), {"expand": False}),
+    ("rpartition", (" ",), {"expand": True}),
+    ("slice", (0, 1), {}),
+    ("slice_replace", (0, 1, "z"), {}),
+    ("split", (" ",), {"expand": False}),
+    ("split", (" ",), {"expand": True}),
+    ("startswith", ("a",), {}),
     # translating unicode points of "a" to "d"
-    ("translate", ({97: 100},), {}),  # noqa: E241
-    ("wrap", (2,), {}),  # noqa: E241
-    ("zfill", (10,), {}),  # noqa: E241
+    ("translate", ({97: 100},), {}),
+    ("wrap", (2,), {}),
+    ("zfill", (10,), {}),
 ] + list(
     zip(
         [
@@ -202,9 +202,9 @@ def test_api_mi_raises(self):
         assert not hasattr(mi, "str")
 
     @pytest.mark.parametrize("dtype", [object, "category"])
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_api_per_dtype(self, box, dtype, any_skipna_inferred_dtype):
+    def test_api_per_dtype(self, index_or_series, dtype, any_skipna_inferred_dtype):
         # one instance of parametrized fixture
+        box = index_or_series
         inferred_dtype, values = any_skipna_inferred_dtype
 
         t = box(values, dtype=dtype)  # explicit dtype to avoid casting
@@ -236,13 +236,17 @@ def test_api_per_dtype(self, box, dtype, any_skipna_inferred_dtype):
             assert not hasattr(t, "str")
 
     @pytest.mark.parametrize("dtype", [object, "category"])
-    @pytest.mark.parametrize("box", [Series, Index])
     def test_api_per_method(
-        self, box, dtype, any_allowed_skipna_inferred_dtype, any_string_method
+        self,
+        index_or_series,
+        dtype,
+        any_allowed_skipna_inferred_dtype,
+        any_string_method,
     ):
         # this test does not check correctness of the different methods,
         # just that the methods work on the specified (inferred) dtypes,
         # and raise on all others
+        box = index_or_series
 
         # one instance of each parametrized fixture
         inferred_dtype, values = any_allowed_skipna_inferred_dtype
@@ -292,10 +296,8 @@ def test_api_per_method(
         else:
             # GH 23011, GH 23163
             msg = (
-                "Cannot use .str.{name} with values of inferred dtype "
-                "{inferred_dtype!r}.".format(
-                    name=method_name, inferred_dtype=inferred_dtype
-                )
+                f"Cannot use .str.{method_name} with values of "
+                f"inferred dtype {repr(inferred_dtype)}."
             )
             with pytest.raises(TypeError, match=msg):
                 method(*args, **kwargs)
@@ -325,17 +327,18 @@ def test_iter(self):
         strs = "google", "wikimedia", "wikipedia", "wikitravel"
         ds = Series(strs)
 
-        for s in ds.str:
-            # iter must yield a Series
-            assert isinstance(s, Series)
+        with tm.assert_produces_warning(FutureWarning):
+            for s in ds.str:
+                # iter must yield a Series
+                assert isinstance(s, Series)
 
-            # indices of each yielded Series should be equal to the index of
-            # the original Series
-            tm.assert_index_equal(s.index, ds.index)
+                # indices of each yielded Series should be equal to the index of
+                # the original Series
+                tm.assert_index_equal(s.index, ds.index)
 
-            for el in s:
-                # each element of the series is either a basestring/str or nan
-                assert isinstance(el, str) or isna(el)
+                for el in s:
+                    # each element of the series is either a basestring/str or nan
+                    assert isinstance(el, str) or isna(el)
 
         # desired behavior is to iterate until everything would be nan on the
         # next iter so make sure the last element of the iterator was 'l' in
@@ -347,8 +350,9 @@ def test_iter_empty(self):
 
         i, s = 100, 1
 
-        for i, s in enumerate(ds.str):
-            pass
+        with tm.assert_produces_warning(FutureWarning):
+            for i, s in enumerate(ds.str):
+                pass
 
         # nothing to iterate over so nothing defined values should remain
         # unchanged
@@ -358,27 +362,29 @@ def test_iter_empty(self):
     def test_iter_single_element(self):
         ds = Series(["a"])
 
-        for i, s in enumerate(ds.str):
-            pass
+        with tm.assert_produces_warning(FutureWarning):
+            for i, s in enumerate(ds.str):
+                pass
 
         assert not i
-        assert_series_equal(ds, s)
+        tm.assert_series_equal(ds, s)
 
     def test_iter_object_try_string(self):
         ds = Series([slice(None, randint(10), randint(10, 20)) for _ in range(4)])
 
         i, s = 100, "h"
 
-        for i, s in enumerate(ds.str):
-            pass
+        with tm.assert_produces_warning(FutureWarning):
+            for i, s in enumerate(ds.str):
+                pass
 
         assert i == 100
         assert s == "h"
 
-    @pytest.mark.parametrize("box", [Series, Index])
     @pytest.mark.parametrize("other", [None, Series, Index])
-    def test_str_cat_name(self, box, other):
+    def test_str_cat_name(self, index_or_series, other):
         # GH 21053
+        box = index_or_series
         values = ["a", "b"]
         if other:
             other = other(values)
@@ -387,8 +393,8 @@ def test_str_cat_name(self, box, other):
         result = box(values, name="name").str.cat(other, sep=",")
         assert result.name == "name"
 
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_str_cat(self, box):
+    def test_str_cat(self, index_or_series):
+        box = index_or_series
         # test_cat above tests "str_cat" from ndarray;
         # here testing "str.cat" from Series/Indext to ndarray/list
         s = box(["a", "a", "b", "b", "c", np.nan])
@@ -427,9 +433,9 @@ def test_str_cat(self, box):
         with pytest.raises(ValueError, match=rgx):
             s.str.cat(list(z))
 
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_str_cat_raises_intuitive_error(self, box):
+    def test_str_cat_raises_intuitive_error(self, index_or_series):
         # GH 11334
+        box = index_or_series
         s = box(["a", "b", "c", "d"])
         message = "Did you mean to supply a `sep` keyword?"
         with pytest.raises(ValueError, match=message):
@@ -440,8 +446,11 @@ def test_str_cat_raises_intuitive_error(self, box):
     @pytest.mark.parametrize("sep", ["", None])
     @pytest.mark.parametrize("dtype_target", ["object", "category"])
     @pytest.mark.parametrize("dtype_caller", ["object", "category"])
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_str_cat_categorical(self, box, dtype_caller, dtype_target, sep):
+    def test_str_cat_categorical(
+        self, index_or_series, dtype_caller, dtype_target, sep
+    ):
+        box = index_or_series
+
         s = Index(["a", "a", "b", "a"], dtype=dtype_caller)
         s = s if box == Index else Series(s, index=s)
         t = Index(["b", "a", "b", "c"], dtype=dtype_target)
@@ -494,8 +503,8 @@ def test_str_cat_wrong_dtype_raises(self, box, data):
             # need to use outer and na_rep, as otherwise Index would not raise
             s.str.cat(t, join="outer", na_rep="-")
 
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_str_cat_mixed_inputs(self, box):
+    def test_str_cat_mixed_inputs(self, index_or_series):
+        box = index_or_series
         s = Index(["a", "b", "c", "d"])
         s = s if box == Index else Series(s, index=s)
 
@@ -596,9 +605,10 @@ def test_str_cat_mixed_inputs(self, box):
             s.str.cat(iter([t.values, list(s)]))
 
     @pytest.mark.parametrize("join", ["left", "outer", "inner", "right"])
-    @pytest.mark.parametrize("box", [Series, Index])
-    def test_str_cat_align_indexed(self, box, join):
+    def test_str_cat_align_indexed(self, index_or_series, join):
         # https://github.com/pandas-dev/pandas/issues/18657
+        box = index_or_series
+
         s = Series(["a", "b", "c", "d"], index=["a", "b", "c", "d"])
         t = Series(["D", "A", "E", "B"], index=["d", "a", "e", "b"])
         sa, ta = s.align(t, join=join)
@@ -656,10 +666,14 @@ def test_str_cat_align_mixed_inputs(self, join):
         with pytest.raises(ValueError, match=rgx):
             s.str.cat([t, z], join=join)
 
-    @pytest.mark.parametrize("box", [Series, Index])
-    @pytest.mark.parametrize("other", [Series, Index])
-    def test_str_cat_all_na(self, box, other):
+    index_or_series2 = [Series, Index]  # type: ignore
+    # List item 0 has incompatible type "Type[Series]"; expected "Type[PandasObject]"
+    # See GH#29725
+
+    @pytest.mark.parametrize("other", index_or_series2)
+    def test_str_cat_all_na(self, index_or_series, other):
         # GH 24044
+        box = index_or_series
 
         # check that all NaNs in caller / target work
         s = Index(["a", "b", "c", "d"])
@@ -717,50 +731,55 @@ def test_cat_on_filtered_index(self):
         assert str_multiple.loc[1] == "2011 2 2"
 
     def test_count(self):
-        values = np.array(["foo", "foofoo", NA, "foooofooofommmfoo"], dtype=np.object_)
+        values = np.array(
+            ["foo", "foofoo", np.nan, "foooofooofommmfoo"], dtype=np.object_
+        )
 
         result = strings.str_count(values, "f[o]+")
-        exp = np.array([1, 2, NA, 4])
+        exp = np.array([1, 2, np.nan, 4])
         tm.assert_numpy_array_equal(result, exp)
 
         result = Series(values).str.count("f[o]+")
-        exp = Series([1, 2, NA, 4])
+        exp = Series([1, 2, np.nan, 4])
         assert isinstance(result, Series)
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = ["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0]
+        mixed = np.array(
+            ["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0],
+            dtype=object,
+        )
         rs = strings.str_count(mixed, "a")
-        xp = np.array([1, NA, 0, NA, NA, 0, NA, NA, NA])
+        xp = np.array([1, np.nan, 0, np.nan, np.nan, 0, np.nan, np.nan, np.nan])
         tm.assert_numpy_array_equal(rs, xp)
 
         rs = Series(mixed).str.count("a")
-        xp = Series([1, NA, 0, NA, NA, 0, NA, NA, NA])
+        xp = Series([1, np.nan, 0, np.nan, np.nan, 0, np.nan, np.nan, np.nan])
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
     def test_contains(self):
         values = np.array(
-            ["foo", NA, "fooommm__foo", "mmm_", "foommm[_]+bar"], dtype=np.object_
+            ["foo", np.nan, "fooommm__foo", "mmm_", "foommm[_]+bar"], dtype=np.object_
         )
         pat = "mmm[_]+"
 
         result = strings.str_contains(values, pat)
-        expected = np.array([False, NA, True, True, False], dtype=np.object_)
+        expected = np.array([False, np.nan, True, True, False], dtype=np.object_)
         tm.assert_numpy_array_equal(result, expected)
 
         result = strings.str_contains(values, pat, regex=False)
-        expected = np.array([False, NA, False, False, True], dtype=np.object_)
+        expected = np.array([False, np.nan, False, False, True], dtype=np.object_)
         tm.assert_numpy_array_equal(result, expected)
 
-        values = ["foo", "xyz", "fooommm__foo", "mmm_"]
+        values = np.array(["foo", "xyz", "fooommm__foo", "mmm_"], dtype=object)
         result = strings.str_contains(values, pat)
         expected = np.array([False, False, True, True])
         assert result.dtype == np.bool_
         tm.assert_numpy_array_equal(result, expected)
 
         # case insensitive using regex
-        values = ["Foo", "xYz", "fOOomMm__fOo", "MMM_"]
+        values = np.array(["Foo", "xYz", "fOOomMm__fOo", "MMM_"], dtype=object)
         result = strings.str_contains(values, "FOO|mmm", case=False)
         expected = np.array([True, False, True, True])
         tm.assert_numpy_array_equal(result, expected)
@@ -771,18 +790,26 @@ def test_contains(self):
         tm.assert_numpy_array_equal(result, expected)
 
         # mixed
-        mixed = ["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0]
+        mixed = np.array(
+            ["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0],
+            dtype=object,
+        )
         rs = strings.str_contains(mixed, "o")
-        xp = np.array([False, NA, False, NA, NA, True, NA, NA, NA], dtype=np.object_)
+        xp = np.array(
+            [False, np.nan, False, np.nan, np.nan, True, np.nan, np.nan, np.nan],
+            dtype=np.object_,
+        )
         tm.assert_numpy_array_equal(rs, xp)
 
         rs = Series(mixed).str.contains("o")
-        xp = Series([False, NA, False, NA, NA, True, NA, NA, NA])
+        xp = Series(
+            [False, np.nan, False, np.nan, np.nan, True, np.nan, np.nan, np.nan]
+        )
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
         # unicode
-        values = np.array(["foo", NA, "fooommm__foo", "mmm_"], dtype=np.object_)
+        values = np.array(["foo", np.nan, "fooommm__foo", "mmm_"], dtype=np.object_)
         pat = "mmm[_]+"
 
         result = strings.str_contains(values, pat)
@@ -823,10 +850,10 @@ def test_contains_for_object_category(self):
         tm.assert_series_equal(result, expected)
 
     def test_startswith(self):
-        values = Series(["om", NA, "foo_nom", "nom", "bar_foo", NA, "foo"])
+        values = Series(["om", np.nan, "foo_nom", "nom", "bar_foo", np.nan, "foo"])
 
         result = values.str.startswith("foo")
-        exp = Series([False, NA, True, False, False, NA, True])
+        exp = Series([False, np.nan, True, False, False, np.nan, True])
         tm.assert_series_equal(result, exp)
 
         result = values.str.startswith("foo", na=True)
@@ -834,92 +861,117 @@ def test_startswith(self):
 
         # mixed
         mixed = np.array(
-            ["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0],
+            ["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0],
             dtype=np.object_,
         )
         rs = strings.str_startswith(mixed, "f")
-        xp = np.array([False, NA, False, NA, NA, True, NA, NA, NA], dtype=np.object_)
+        xp = np.array(
+            [False, np.nan, False, np.nan, np.nan, True, np.nan, np.nan, np.nan],
+            dtype=np.object_,
+        )
         tm.assert_numpy_array_equal(rs, xp)
 
         rs = Series(mixed).str.startswith("f")
         assert isinstance(rs, Series)
-        xp = Series([False, NA, False, NA, NA, True, NA, NA, NA])
+        xp = Series(
+            [False, np.nan, False, np.nan, np.nan, True, np.nan, np.nan, np.nan]
+        )
         tm.assert_series_equal(rs, xp)
 
     def test_endswith(self):
-        values = Series(["om", NA, "foo_nom", "nom", "bar_foo", NA, "foo"])
+        values = Series(["om", np.nan, "foo_nom", "nom", "bar_foo", np.nan, "foo"])
 
         result = values.str.endswith("foo")
-        exp = Series([False, NA, False, False, True, NA, True])
+        exp = Series([False, np.nan, False, False, True, np.nan, True])
         tm.assert_series_equal(result, exp)
 
         result = values.str.endswith("foo", na=False)
         tm.assert_series_equal(result, exp.fillna(False).astype(bool))
 
         # mixed
-        mixed = ["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0]
+        mixed = np.array(
+            ["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0],
+            dtype=object,
+        )
         rs = strings.str_endswith(mixed, "f")
-        xp = np.array([False, NA, False, NA, NA, False, NA, NA, NA], dtype=np.object_)
+        xp = np.array(
+            [False, np.nan, False, np.nan, np.nan, False, np.nan, np.nan, np.nan],
+            dtype=np.object_,
+        )
         tm.assert_numpy_array_equal(rs, xp)
 
         rs = Series(mixed).str.endswith("f")
-        xp = Series([False, NA, False, NA, NA, False, NA, NA, NA])
+        xp = Series(
+            [False, np.nan, False, np.nan, np.nan, False, np.nan, np.nan, np.nan]
+        )
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
     def test_title(self):
-        values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
+        values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"])
 
         result = values.str.title()
-        exp = Series(["Foo", "Bar", NA, "Blah", "Blurg"])
+        exp = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"])
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["FOO", NA, "bar", True, datetime.today(), "blah", None, 1, 2.0])
+        mixed = Series(
+            ["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]
+        )
         mixed = mixed.str.title()
-        exp = Series(["Foo", NA, "Bar", NA, NA, "Blah", NA, NA, NA])
+        exp = Series(
+            ["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan]
+        )
         tm.assert_almost_equal(mixed, exp)
 
     def test_lower_upper(self):
-        values = Series(["om", NA, "nom", "nom"])
+        values = Series(["om", np.nan, "nom", "nom"])
 
         result = values.str.upper()
-        exp = Series(["OM", NA, "NOM", "NOM"])
+        exp = Series(["OM", np.nan, "NOM", "NOM"])
         tm.assert_series_equal(result, exp)
 
         result = result.str.lower()
         tm.assert_series_equal(result, values)
 
         # mixed
-        mixed = Series(["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0])
+        mixed = Series(["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0])
         mixed = mixed.str.upper()
         rs = Series(mixed).str.lower()
-        xp = Series(["a", NA, "b", NA, NA, "foo", NA, NA, NA])
+        xp = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan])
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
     def test_capitalize(self):
-        values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
+        values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"])
         result = values.str.capitalize()
-        exp = Series(["Foo", "Bar", NA, "Blah", "Blurg"])
+        exp = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"])
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["FOO", NA, "bar", True, datetime.today(), "blah", None, 1, 2.0])
+        mixed = Series(
+            ["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]
+        )
         mixed = mixed.str.capitalize()
-        exp = Series(["Foo", NA, "Bar", NA, NA, "Blah", NA, NA, NA])
+        exp = Series(
+            ["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan]
+        )
         tm.assert_almost_equal(mixed, exp)
 
     def test_swapcase(self):
-        values = Series(["FOO", "BAR", NA, "Blah", "blurg"])
+        values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"])
         result = values.str.swapcase()
-        exp = Series(["foo", "bar", NA, "bLAH", "BLURG"])
+        exp = Series(["foo", "bar", np.nan, "bLAH", "BLURG"])
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["FOO", NA, "bar", True, datetime.today(), "Blah", None, 1, 2.0])
+        mixed = Series(
+            ["FOO", np.nan, "bar", True, datetime.today(), "Blah", None, 1, 2.0]
+        )
         mixed = mixed.str.swapcase()
-        exp = Series(["foo", NA, "BAR", NA, NA, "bLAH", NA, NA, NA])
+        exp = Series(
+            ["foo", np.nan, "BAR", np.nan, np.nan, "bLAH", np.nan, np.nan, np.nan]
+        )
         tm.assert_almost_equal(mixed, exp)
 
     def test_casemethods(self):
@@ -932,23 +984,23 @@ def test_casemethods(self):
         assert s.str.swapcase().tolist() == [v.swapcase() for v in values]
 
     def test_replace(self):
-        values = Series(["fooBAD__barBAD", NA])
+        values = Series(["fooBAD__barBAD", np.nan])
 
         result = values.str.replace("BAD[_]*", "")
-        exp = Series(["foobar", NA])
+        exp = Series(["foobar", np.nan])
         tm.assert_series_equal(result, exp)
 
         result = values.str.replace("BAD[_]*", "", n=1)
-        exp = Series(["foobarBAD", NA])
+        exp = Series(["foobarBAD", np.nan])
         tm.assert_series_equal(result, exp)
 
         # mixed
         mixed = Series(
-            ["aBAD", NA, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0]
+            ["aBAD", np.nan, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0]
         )
 
         rs = Series(mixed).str.replace("BAD[_]*", "")
-        xp = Series(["a", NA, "b", NA, NA, "foo", NA, NA, NA])
+        xp = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan])
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
@@ -969,12 +1021,12 @@ def test_replace(self):
 
     def test_replace_callable(self):
         # GH 15055
-        values = Series(["fooBAD__barBAD", NA])
+        values = Series(["fooBAD__barBAD", np.nan])
 
         # test with callable
         repl = lambda m: m.group(0).swapcase()
         result = values.str.replace("[a-z][A-Z]{2}", repl, n=2)
-        exp = Series(["foObaD__baRbaD", NA])
+        exp = Series(["foObaD__baRbaD", np.nan])
         tm.assert_series_equal(result, exp)
 
         # test with wrong number of arguments, raising an error
@@ -996,34 +1048,34 @@ def test_replace_callable(self):
             values.str.replace("a", repl)
 
         # test regex named groups
-        values = Series(["Foo Bar Baz", NA])
+        values = Series(["Foo Bar Baz", np.nan])
         pat = r"(?P<first>\w+) (?P<middle>\w+) (?P<last>\w+)"
         repl = lambda m: m.group("middle").swapcase()
         result = values.str.replace(pat, repl)
-        exp = Series(["bAR", NA])
+        exp = Series(["bAR", np.nan])
         tm.assert_series_equal(result, exp)
 
     def test_replace_compiled_regex(self):
         # GH 15446
-        values = Series(["fooBAD__barBAD", NA])
+        values = Series(["fooBAD__barBAD", np.nan])
 
         # test with compiled regex
         pat = re.compile(r"BAD[_]*")
         result = values.str.replace(pat, "")
-        exp = Series(["foobar", NA])
+        exp = Series(["foobar", np.nan])
         tm.assert_series_equal(result, exp)
 
         result = values.str.replace(pat, "", n=1)
-        exp = Series(["foobarBAD", NA])
+        exp = Series(["foobarBAD", np.nan])
         tm.assert_series_equal(result, exp)
 
         # mixed
         mixed = Series(
-            ["aBAD", NA, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0]
+            ["aBAD", np.nan, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0]
         )
 
         rs = Series(mixed).str.replace(pat, "")
-        xp = Series(["a", NA, "b", NA, NA, "foo", NA, NA, NA])
+        xp = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan])
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
@@ -1036,7 +1088,7 @@ def test_replace_compiled_regex(self):
 
         # case and flags provided to str.replace will have no effect
         # and will produce warnings
-        values = Series(["fooBAD__barBAD__bad", NA])
+        values = Series(["fooBAD__barBAD__bad", np.nan])
         pat = re.compile(r"BAD[_]*")
 
         with pytest.raises(ValueError, match="case and flags cannot be"):
@@ -1049,21 +1101,21 @@ def test_replace_compiled_regex(self):
             result = values.str.replace(pat, "", case=True)
 
         # test with callable
-        values = Series(["fooBAD__barBAD", NA])
+        values = Series(["fooBAD__barBAD", np.nan])
         repl = lambda m: m.group(0).swapcase()
         pat = re.compile("[a-z][A-Z]{2}")
         result = values.str.replace(pat, repl, n=2)
-        exp = Series(["foObaD__baRbaD", NA])
+        exp = Series(["foObaD__baRbaD", np.nan])
         tm.assert_series_equal(result, exp)
 
     def test_replace_literal(self):
         # GH16808 literal replace (regex=False vs regex=True)
-        values = Series(["f.o", "foo", NA])
-        exp = Series(["bao", "bao", NA])
+        values = Series(["f.o", "foo", np.nan])
+        exp = Series(["bao", "bao", np.nan])
         result = values.str.replace("f.", "ba")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["bao", "foo", NA])
+        exp = Series(["bao", "foo", np.nan])
         result = values.str.replace("f.", "ba", regex=False)
         tm.assert_series_equal(result, exp)
 
@@ -1081,60 +1133,72 @@ def test_replace_literal(self):
             values.str.replace(compiled_pat, "", regex=False)
 
     def test_repeat(self):
-        values = Series(["a", "b", NA, "c", NA, "d"])
+        values = Series(["a", "b", np.nan, "c", np.nan, "d"])
 
         result = values.str.repeat(3)
-        exp = Series(["aaa", "bbb", NA, "ccc", NA, "ddd"])
+        exp = Series(["aaa", "bbb", np.nan, "ccc", np.nan, "ddd"])
         tm.assert_series_equal(result, exp)
 
         result = values.str.repeat([1, 2, 3, 4, 5, 6])
-        exp = Series(["a", "bb", NA, "cccc", NA, "dddddd"])
+        exp = Series(["a", "bb", np.nan, "cccc", np.nan, "dddddd"])
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["a", NA, "b", True, datetime.today(), "foo", None, 1, 2.0])
+        mixed = Series(["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0])
 
         rs = Series(mixed).str.repeat(3)
-        xp = Series(["aaa", NA, "bbb", NA, NA, "foofoofoo", NA, NA, NA])
+        xp = Series(
+            ["aaa", np.nan, "bbb", np.nan, np.nan, "foofoofoo", np.nan, np.nan, np.nan]
+        )
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
     def test_match(self):
         # New match behavior introduced in 0.13
-        values = Series(["fooBAD__barBAD", NA, "foo"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
         result = values.str.match(".*(BAD[_]+).*(BAD)")
-        exp = Series([True, NA, False])
+        exp = Series([True, np.nan, False])
         tm.assert_series_equal(result, exp)
 
-        values = Series(["fooBAD__barBAD", NA, "foo"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
         result = values.str.match(".*BAD[_]+.*BAD")
-        exp = Series([True, NA, False])
+        exp = Series([True, np.nan, False])
         tm.assert_series_equal(result, exp)
 
         # mixed
         mixed = Series(
-            ["aBAD_BAD", NA, "BAD_b_BAD", True, datetime.today(), "foo", None, 1, 2.0]
+            [
+                "aBAD_BAD",
+                np.nan,
+                "BAD_b_BAD",
+                True,
+                datetime.today(),
+                "foo",
+                None,
+                1,
+                2.0,
+            ]
         )
         rs = Series(mixed).str.match(".*(BAD[_]+).*(BAD)")
-        xp = Series([True, NA, True, NA, NA, False, NA, NA, NA])
+        xp = Series([True, np.nan, True, np.nan, np.nan, False, np.nan, np.nan, np.nan])
         assert isinstance(rs, Series)
         tm.assert_series_equal(rs, xp)
 
         # na GH #6609
         res = Series(["a", 0, np.nan]).str.match("a", na=False)
         exp = Series([True, False, False])
-        assert_series_equal(exp, res)
+        tm.assert_series_equal(exp, res)
         res = Series(["a", 0, np.nan]).str.match("a")
         exp = Series([True, np.nan, np.nan])
-        assert_series_equal(exp, res)
+        tm.assert_series_equal(exp, res)
 
     def test_extract_expand_None(self):
-        values = Series(["fooBAD__barBAD", NA, "foo"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
         with pytest.raises(ValueError, match="expand must be True or False"):
             values.str.extract(".*(BAD[_]+).*(BAD)", expand=None)
 
     def test_extract_expand_unspecified(self):
-        values = Series(["fooBAD__barBAD", NA, "foo"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
         result_unspecified = values.str.extract(".*(BAD[_]+).*")
         assert isinstance(result_unspecified, DataFrame)
         result_true = values.str.extract(".*(BAD[_]+).*", expand=True)
@@ -1142,8 +1206,8 @@ def test_extract_expand_unspecified(self):
 
     def test_extract_expand_False(self):
         # Contains tests like those in test_match and some others.
-        values = Series(["fooBAD__barBAD", NA, "foo"])
-        er = [NA, NA]  # empty row
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
+        er = [np.nan, np.nan]  # empty row
 
         result = values.str.extract(".*(BAD[_]+).*(BAD)", expand=False)
         exp = DataFrame([["BAD__", "BAD"], er, er])
@@ -1151,7 +1215,17 @@ def test_extract_expand_False(self):
 
         # mixed
         mixed = Series(
-            ["aBAD_BAD", NA, "BAD_b_BAD", True, datetime.today(), "foo", None, 1, 2.0]
+            [
+                "aBAD_BAD",
+                np.nan,
+                "BAD_b_BAD",
+                True,
+                datetime.today(),
+                "foo",
+                None,
+                1,
+                2.0,
+            ]
         )
 
         rs = Series(mixed).str.extract(".*(BAD[_]+).*(BAD)", expand=False)
@@ -1159,7 +1233,7 @@ def test_extract_expand_False(self):
         tm.assert_frame_equal(rs, exp)
 
         # unicode
-        values = Series(["fooBAD__barBAD", NA, "foo"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
 
         result = values.str.extract(".*(BAD[_]+).*(BAD)", expand=False)
         exp = DataFrame([["BAD__", "BAD"], er, er])
@@ -1198,51 +1272,55 @@ def test_extract_expand_False(self):
         s = Series(["A1", "B2", "C3"])
         # one group, no matches
         result = s.str.extract("(_)", expand=False)
-        exp = Series([NA, NA, NA], dtype=object)
+        exp = Series([np.nan, np.nan, np.nan], dtype=object)
         tm.assert_series_equal(result, exp)
 
         # two groups, no matches
         result = s.str.extract("(_)(_)", expand=False)
-        exp = DataFrame([[NA, NA], [NA, NA], [NA, NA]], dtype=object)
+        exp = DataFrame(
+            [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=object
+        )
         tm.assert_frame_equal(result, exp)
 
         # one group, some matches
         result = s.str.extract("([AB])[123]", expand=False)
-        exp = Series(["A", "B", NA])
+        exp = Series(["A", "B", np.nan])
         tm.assert_series_equal(result, exp)
 
         # two groups, some matches
         result = s.str.extract("([AB])([123])", expand=False)
-        exp = DataFrame([["A", "1"], ["B", "2"], [NA, NA]])
+        exp = DataFrame([["A", "1"], ["B", "2"], [np.nan, np.nan]])
         tm.assert_frame_equal(result, exp)
 
         # one named group
         result = s.str.extract("(?P<letter>[AB])", expand=False)
-        exp = Series(["A", "B", NA], name="letter")
+        exp = Series(["A", "B", np.nan], name="letter")
         tm.assert_series_equal(result, exp)
 
         # two named groups
         result = s.str.extract("(?P<letter>[AB])(?P<number>[123])", expand=False)
         exp = DataFrame(
-            [["A", "1"], ["B", "2"], [NA, NA]], columns=["letter", "number"]
+            [["A", "1"], ["B", "2"], [np.nan, np.nan]], columns=["letter", "number"]
         )
         tm.assert_frame_equal(result, exp)
 
         # mix named and unnamed groups
         result = s.str.extract("([AB])(?P<number>[123])", expand=False)
-        exp = DataFrame([["A", "1"], ["B", "2"], [NA, NA]], columns=[0, "number"])
+        exp = DataFrame(
+            [["A", "1"], ["B", "2"], [np.nan, np.nan]], columns=[0, "number"]
+        )
         tm.assert_frame_equal(result, exp)
 
         # one normal group, one non-capturing group
         result = s.str.extract("([AB])(?:[123])", expand=False)
-        exp = Series(["A", "B", NA])
+        exp = Series(["A", "B", np.nan])
         tm.assert_series_equal(result, exp)
 
         # two normal groups, one non-capturing group
         result = Series(["A11", "B22", "C33"]).str.extract(
             "([AB])([123])(?:[123])", expand=False
         )
-        exp = DataFrame([["A", "1"], ["B", "2"], [NA, NA]])
+        exp = DataFrame([["A", "1"], ["B", "2"], [np.nan, np.nan]])
         tm.assert_frame_equal(result, exp)
 
         # one optional group followed by one normal group
@@ -1250,7 +1328,7 @@ def test_extract_expand_False(self):
             "(?P<letter>[AB])?(?P<number>[123])", expand=False
         )
         exp = DataFrame(
-            [["A", "1"], ["B", "2"], [NA, "3"]], columns=["letter", "number"]
+            [["A", "1"], ["B", "2"], [np.nan, "3"]], columns=["letter", "number"]
         )
         tm.assert_frame_equal(result, exp)
 
@@ -1259,7 +1337,7 @@ def test_extract_expand_False(self):
             "(?P<letter>[ABC])(?P<number>[123])?", expand=False
         )
         exp = DataFrame(
-            [["A", "1"], ["B", "2"], ["C", NA]], columns=["letter", "number"]
+            [["A", "1"], ["B", "2"], ["C", np.nan]], columns=["letter", "number"]
         )
         tm.assert_frame_equal(result, exp)
 
@@ -1270,13 +1348,13 @@ def check_index(index):
             index = index[: len(data)]
             s = Series(data, index=index)
             result = s.str.extract(r"(\d)", expand=False)
-            exp = Series(["1", "2", NA], index=index)
+            exp = Series(["1", "2", np.nan], index=index)
             tm.assert_series_equal(result, exp)
 
             result = Series(data, index=index).str.extract(
                 r"(?P<letter>\D)(?P<number>\d)?", expand=False
             )
-            e_list = [["A", "1"], ["B", "2"], ["C", NA]]
+            e_list = [["A", "1"], ["B", "2"], ["C", np.nan]]
             exp = DataFrame(e_list, columns=["letter", "number"], index=index)
             tm.assert_frame_equal(result, exp)
 
@@ -1300,8 +1378,8 @@ def check_index(index):
 
     def test_extract_expand_True(self):
         # Contains tests like those in test_match and some others.
-        values = Series(["fooBAD__barBAD", NA, "foo"])
-        er = [NA, NA]  # empty row
+        values = Series(["fooBAD__barBAD", np.nan, "foo"])
+        er = [np.nan, np.nan]  # empty row
 
         result = values.str.extract(".*(BAD[_]+).*(BAD)", expand=True)
         exp = DataFrame([["BAD__", "BAD"], er, er])
@@ -1309,7 +1387,17 @@ def test_extract_expand_True(self):
 
         # mixed
         mixed = Series(
-            ["aBAD_BAD", NA, "BAD_b_BAD", True, datetime.today(), "foo", None, 1, 2.0]
+            [
+                "aBAD_BAD",
+                np.nan,
+                "BAD_b_BAD",
+                True,
+                datetime.today(),
+                "foo",
+                None,
+                1,
+                2.0,
+            ]
         )
 
         rs = Series(mixed).str.extract(".*(BAD[_]+).*(BAD)", expand=True)
@@ -1333,7 +1421,7 @@ def test_extract_expand_True(self):
             result_df = s_or_idx.str.extract(r"(?P<uno>A)\d", expand=True)
             assert isinstance(result_df, DataFrame)
             result_series = result_df["uno"]
-            assert_series_equal(result_series, Series(["A", "A"], name="uno"))
+            tm.assert_series_equal(result_series, Series(["A", "A"], name="uno"))
 
     def test_extract_series(self):
         # extract should give the same result whether or not the
@@ -1342,32 +1430,34 @@ def test_extract_series(self):
             s = Series(["A1", "B2", "C3"], name=series_name)
             # one group, no matches
             result = s.str.extract("(_)", expand=True)
-            exp = DataFrame([NA, NA, NA], dtype=object)
+            exp = DataFrame([np.nan, np.nan, np.nan], dtype=object)
             tm.assert_frame_equal(result, exp)
 
             # two groups, no matches
             result = s.str.extract("(_)(_)", expand=True)
-            exp = DataFrame([[NA, NA], [NA, NA], [NA, NA]], dtype=object)
+            exp = DataFrame(
+                [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=object
+            )
             tm.assert_frame_equal(result, exp)
 
             # one group, some matches
             result = s.str.extract("([AB])[123]", expand=True)
-            exp = DataFrame(["A", "B", NA])
+            exp = DataFrame(["A", "B", np.nan])
             tm.assert_frame_equal(result, exp)
 
             # two groups, some matches
             result = s.str.extract("([AB])([123])", expand=True)
-            exp = DataFrame([["A", "1"], ["B", "2"], [NA, NA]])
+            exp = DataFrame([["A", "1"], ["B", "2"], [np.nan, np.nan]])
             tm.assert_frame_equal(result, exp)
 
             # one named group
             result = s.str.extract("(?P<letter>[AB])", expand=True)
-            exp = DataFrame({"letter": ["A", "B", NA]})
+            exp = DataFrame({"letter": ["A", "B", np.nan]})
             tm.assert_frame_equal(result, exp)
 
             # two named groups
             result = s.str.extract("(?P<letter>[AB])(?P<number>[123])", expand=True)
-            e_list = [["A", "1"], ["B", "2"], [NA, NA]]
+            e_list = [["A", "1"], ["B", "2"], [np.nan, np.nan]]
             exp = DataFrame(e_list, columns=["letter", "number"])
             tm.assert_frame_equal(result, exp)
 
@@ -1378,7 +1468,7 @@ def test_extract_series(self):
 
             # one normal group, one non-capturing group
             result = s.str.extract("([AB])(?:[123])", expand=True)
-            exp = DataFrame(["A", "B", NA])
+            exp = DataFrame(["A", "B", np.nan])
             tm.assert_frame_equal(result, exp)
 
     def test_extract_optional_groups(self):
@@ -1387,14 +1477,14 @@ def test_extract_optional_groups(self):
         result = Series(["A11", "B22", "C33"]).str.extract(
             "([AB])([123])(?:[123])", expand=True
         )
-        exp = DataFrame([["A", "1"], ["B", "2"], [NA, NA]])
+        exp = DataFrame([["A", "1"], ["B", "2"], [np.nan, np.nan]])
         tm.assert_frame_equal(result, exp)
 
         # one optional group followed by one normal group
         result = Series(["A1", "B2", "3"]).str.extract(
             "(?P<letter>[AB])?(?P<number>[123])", expand=True
         )
-        e_list = [["A", "1"], ["B", "2"], [NA, "3"]]
+        e_list = [["A", "1"], ["B", "2"], [np.nan, "3"]]
         exp = DataFrame(e_list, columns=["letter", "number"])
         tm.assert_frame_equal(result, exp)
 
@@ -1402,7 +1492,7 @@ def test_extract_optional_groups(self):
         result = Series(["A1", "B2", "C"]).str.extract(
             "(?P<letter>[ABC])(?P<number>[123])?", expand=True
         )
-        e_list = [["A", "1"], ["B", "2"], ["C", NA]]
+        e_list = [["A", "1"], ["B", "2"], ["C", np.nan]]
         exp = DataFrame(e_list, columns=["letter", "number"])
         tm.assert_frame_equal(result, exp)
 
@@ -1412,13 +1502,13 @@ def check_index(index):
             data = ["A1", "B2", "C"]
             index = index[: len(data)]
             result = Series(data, index=index).str.extract(r"(\d)", expand=True)
-            exp = DataFrame(["1", "2", NA], index=index)
+            exp = DataFrame(["1", "2", np.nan], index=index)
             tm.assert_frame_equal(result, exp)
 
             result = Series(data, index=index).str.extract(
                 r"(?P<letter>\D)(?P<number>\d)?", expand=True
             )
-            e_list = [["A", "1"], ["B", "2"], ["C", NA]]
+            e_list = [["A", "1"], ["B", "2"], ["C", np.nan]]
             exp = DataFrame(e_list, columns=["letter", "number"], index=index)
             tm.assert_frame_equal(result, exp)
 
@@ -1528,7 +1618,7 @@ def test_extractall(self):
             [(1, 0), (2, 0), (2, 1)], names=(None, "match")
         )
         expected_df = DataFrame(
-            [("A", "1"), (NA, "3"), (NA, "2")],
+            [("A", "1"), (np.nan, "3"), (np.nan, "2")],
             expected_index,
             columns=["letter", "number"],
         )
@@ -1538,7 +1628,9 @@ def test_extractall(self):
         pattern = "([AB])?(?P<number>[123])"
         computed_df = Series(subject_list).str.extractall(pattern)
         expected_df = DataFrame(
-            [("A", "1"), (NA, "3"), (NA, "2")], expected_index, columns=[0, "number"]
+            [("A", "1"), (np.nan, "3"), (np.nan, "2")],
+            expected_index,
+            columns=[0, "number"],
         )
         tm.assert_frame_equal(computed_df, expected_df)
 
@@ -1733,7 +1825,7 @@ def test_extractall_same_as_extract_subject_index(self):
 
     def test_empty_str_methods(self):
         empty_str = empty = Series(dtype=object)
-        empty_int = Series(dtype=int)
+        empty_int = Series(dtype="int64")
         empty_bool = Series(dtype=bool)
         empty_bytes = Series(dtype=object)
 
@@ -1784,15 +1876,16 @@ def test_empty_str_methods(self):
         tm.assert_series_equal(empty_str, empty.str.get(0))
         tm.assert_series_equal(empty_str, empty_bytes.str.decode("ascii"))
         tm.assert_series_equal(empty_bytes, empty.str.encode("ascii"))
-        tm.assert_series_equal(empty_str, empty.str.isalnum())
-        tm.assert_series_equal(empty_str, empty.str.isalpha())
-        tm.assert_series_equal(empty_str, empty.str.isdigit())
-        tm.assert_series_equal(empty_str, empty.str.isspace())
-        tm.assert_series_equal(empty_str, empty.str.islower())
-        tm.assert_series_equal(empty_str, empty.str.isupper())
-        tm.assert_series_equal(empty_str, empty.str.istitle())
-        tm.assert_series_equal(empty_str, empty.str.isnumeric())
-        tm.assert_series_equal(empty_str, empty.str.isdecimal())
+        # ismethods should always return boolean (GH 29624)
+        tm.assert_series_equal(empty_bool, empty.str.isalnum())
+        tm.assert_series_equal(empty_bool, empty.str.isalpha())
+        tm.assert_series_equal(empty_bool, empty.str.isdigit())
+        tm.assert_series_equal(empty_bool, empty.str.isspace())
+        tm.assert_series_equal(empty_bool, empty.str.islower())
+        tm.assert_series_equal(empty_bool, empty.str.isupper())
+        tm.assert_series_equal(empty_bool, empty.str.istitle())
+        tm.assert_series_equal(empty_bool, empty.str.isnumeric())
+        tm.assert_series_equal(empty_bool, empty.str.isdecimal())
         tm.assert_series_equal(empty_str, empty.str.capitalize())
         tm.assert_series_equal(empty_str, empty.str.swapcase())
         tm.assert_series_equal(empty_str, empty.str.normalize("NFC"))
@@ -1916,11 +2009,33 @@ def test_join(self):
 
         # mixed
         mixed = Series(
-            ["a_b", NA, "asdf_cas_asdf", True, datetime.today(), "foo", None, 1, 2.0]
+            [
+                "a_b",
+                np.nan,
+                "asdf_cas_asdf",
+                True,
+                datetime.today(),
+                "foo",
+                None,
+                1,
+                2.0,
+            ]
         )
 
         rs = Series(mixed).str.split("_").str.join("_")
-        xp = Series(["a_b", NA, "asdf_cas_asdf", NA, NA, "foo", NA, NA, NA])
+        xp = Series(
+            [
+                "a_b",
+                np.nan,
+                "asdf_cas_asdf",
+                np.nan,
+                np.nan,
+                "foo",
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
@@ -1929,34 +2044,66 @@ def test_len(self):
         values = Series(["foo", "fooo", "fooooo", np.nan, "fooooooo"])
 
         result = values.str.len()
-        exp = values.map(lambda x: len(x) if notna(x) else NA)
+        exp = values.map(lambda x: len(x) if notna(x) else np.nan)
         tm.assert_series_equal(result, exp)
 
         # mixed
         mixed = Series(
-            ["a_b", NA, "asdf_cas_asdf", True, datetime.today(), "foo", None, 1, 2.0]
+            [
+                "a_b",
+                np.nan,
+                "asdf_cas_asdf",
+                True,
+                datetime.today(),
+                "foo",
+                None,
+                1,
+                2.0,
+            ]
         )
 
         rs = Series(mixed).str.len()
-        xp = Series([3, NA, 13, NA, NA, 3, NA, NA, NA])
+        xp = Series([3, np.nan, 13, np.nan, np.nan, 3, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
     def test_findall(self):
-        values = Series(["fooBAD__barBAD", NA, "foo", "BAD"])
+        values = Series(["fooBAD__barBAD", np.nan, "foo", "BAD"])
 
         result = values.str.findall("BAD[_]*")
-        exp = Series([["BAD__", "BAD"], NA, [], ["BAD"]])
+        exp = Series([["BAD__", "BAD"], np.nan, [], ["BAD"]])
         tm.assert_almost_equal(result, exp)
 
         # mixed
         mixed = Series(
-            ["fooBAD__barBAD", NA, "foo", True, datetime.today(), "BAD", None, 1, 2.0]
+            [
+                "fooBAD__barBAD",
+                np.nan,
+                "foo",
+                True,
+                datetime.today(),
+                "BAD",
+                None,
+                1,
+                2.0,
+            ]
         )
 
         rs = Series(mixed).str.findall("BAD[_]*")
-        xp = Series([["BAD__", "BAD"], NA, [], NA, NA, ["BAD"], NA, NA, NA])
+        xp = Series(
+            [
+                ["BAD__", "BAD"],
+                np.nan,
+                [],
+                np.nan,
+                np.nan,
+                ["BAD"],
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
@@ -2076,59 +2223,65 @@ def _check(result, expected):
         tm.assert_series_equal(result, Series([3, 1, 2, np.nan]))
 
     def test_pad(self):
-        values = Series(["a", "b", NA, "c", NA, "eeeeee"])
+        values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"])
 
         result = values.str.pad(5, side="left")
-        exp = Series(["    a", "    b", NA, "    c", NA, "eeeeee"])
+        exp = Series(["    a", "    b", np.nan, "    c", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.pad(5, side="right")
-        exp = Series(["a    ", "b    ", NA, "c    ", NA, "eeeeee"])
+        exp = Series(["a    ", "b    ", np.nan, "c    ", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.pad(5, side="both")
-        exp = Series(["  a  ", "  b  ", NA, "  c  ", NA, "eeeeee"])
+        exp = Series(["  a  ", "  b  ", np.nan, "  c  ", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         # mixed
-        mixed = Series(["a", NA, "b", True, datetime.today(), "ee", None, 1, 2.0])
+        mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0])
 
         rs = Series(mixed).str.pad(5, side="left")
-        xp = Series(["    a", NA, "    b", NA, NA, "   ee", NA, NA, NA])
+        xp = Series(
+            ["    a", np.nan, "    b", np.nan, np.nan, "   ee", np.nan, np.nan, np.nan]
+        )
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
-        mixed = Series(["a", NA, "b", True, datetime.today(), "ee", None, 1, 2.0])
+        mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0])
 
         rs = Series(mixed).str.pad(5, side="right")
-        xp = Series(["a    ", NA, "b    ", NA, NA, "ee   ", NA, NA, NA])
+        xp = Series(
+            ["a    ", np.nan, "b    ", np.nan, np.nan, "ee   ", np.nan, np.nan, np.nan]
+        )
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
-        mixed = Series(["a", NA, "b", True, datetime.today(), "ee", None, 1, 2.0])
+        mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0])
 
         rs = Series(mixed).str.pad(5, side="both")
-        xp = Series(["  a  ", NA, "  b  ", NA, NA, "  ee ", NA, NA, NA])
+        xp = Series(
+            ["  a  ", np.nan, "  b  ", np.nan, np.nan, "  ee ", np.nan, np.nan, np.nan]
+        )
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
     def test_pad_fillchar(self):
 
-        values = Series(["a", "b", NA, "c", NA, "eeeeee"])
+        values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"])
 
         result = values.str.pad(5, side="left", fillchar="X")
-        exp = Series(["XXXXa", "XXXXb", NA, "XXXXc", NA, "eeeeee"])
+        exp = Series(["XXXXa", "XXXXb", np.nan, "XXXXc", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.pad(5, side="right", fillchar="X")
-        exp = Series(["aXXXX", "bXXXX", NA, "cXXXX", NA, "eeeeee"])
+        exp = Series(["aXXXX", "bXXXX", np.nan, "cXXXX", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.pad(5, side="both", fillchar="X")
-        exp = Series(["XXaXX", "XXbXX", NA, "XXcXX", NA, "eeeeee"])
+        exp = Series(["XXaXX", "XXbXX", np.nan, "XXcXX", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         msg = "fillchar must be a character, not str"
@@ -2169,35 +2322,76 @@ def _check(result, expected):
         tm.assert_series_equal(result, expected)
 
     def test_center_ljust_rjust(self):
-        values = Series(["a", "b", NA, "c", NA, "eeeeee"])
+        values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"])
 
         result = values.str.center(5)
-        exp = Series(["  a  ", "  b  ", NA, "  c  ", NA, "eeeeee"])
+        exp = Series(["  a  ", "  b  ", np.nan, "  c  ", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.ljust(5)
-        exp = Series(["a    ", "b    ", NA, "c    ", NA, "eeeeee"])
+        exp = Series(["a    ", "b    ", np.nan, "c    ", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         result = values.str.rjust(5)
-        exp = Series(["    a", "    b", NA, "    c", NA, "eeeeee"])
+        exp = Series(["    a", "    b", np.nan, "    c", np.nan, "eeeeee"])
         tm.assert_almost_equal(result, exp)
 
         # mixed
-        mixed = Series(["a", NA, "b", True, datetime.today(), "c", "eee", None, 1, 2.0])
+        mixed = Series(
+            ["a", np.nan, "b", True, datetime.today(), "c", "eee", None, 1, 2.0]
+        )
 
         rs = Series(mixed).str.center(5)
-        xp = Series(["  a  ", NA, "  b  ", NA, NA, "  c  ", " eee ", NA, NA, NA])
+        xp = Series(
+            [
+                "  a  ",
+                np.nan,
+                "  b  ",
+                np.nan,
+                np.nan,
+                "  c  ",
+                " eee ",
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
         rs = Series(mixed).str.ljust(5)
-        xp = Series(["a    ", NA, "b    ", NA, NA, "c    ", "eee  ", NA, NA, NA])
+        xp = Series(
+            [
+                "a    ",
+                np.nan,
+                "b    ",
+                np.nan,
+                np.nan,
+                "c    ",
+                "eee  ",
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
         rs = Series(mixed).str.rjust(5)
-        xp = Series(["    a", NA, "    b", NA, NA, "    c", "  eee", NA, NA, NA])
+        xp = Series(
+            [
+                "    a",
+                np.nan,
+                "    b",
+                np.nan,
+                np.nan,
+                "    c",
+                "  eee",
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
@@ -2266,14 +2460,14 @@ def test_zfill(self):
         tm.assert_series_equal(result, expected)
 
     def test_split(self):
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h"])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
 
         result = values.str.split("_")
-        exp = Series([["a", "b", "c"], ["c", "d", "e"], NA, ["f", "g", "h"]])
+        exp = Series([["a", "b", "c"], ["c", "d", "e"], np.nan, ["f", "g", "h"]])
         tm.assert_series_equal(result, exp)
 
         # more than one char
-        values = Series(["a__b__c", "c__d__e", NA, "f__g__h"])
+        values = Series(["a__b__c", "c__d__e", np.nan, "f__g__h"])
         result = values.str.split("__")
         tm.assert_series_equal(result, exp)
 
@@ -2281,9 +2475,20 @@ def test_split(self):
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["a_b_c", NA, "d_e_f", True, datetime.today(), None, 1, 2.0])
+        mixed = Series(["a_b_c", np.nan, "d_e_f", True, datetime.today(), None, 1, 2.0])
         result = mixed.str.split("_")
-        exp = Series([["a", "b", "c"], NA, ["d", "e", "f"], NA, NA, NA, NA, NA])
+        exp = Series(
+            [
+                ["a", "b", "c"],
+                np.nan,
+                ["d", "e", "f"],
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
         assert isinstance(result, Series)
         tm.assert_almost_equal(result, exp)
 
@@ -2292,19 +2497,19 @@ def test_split(self):
         tm.assert_almost_equal(result, exp)
 
         # regex split
-        values = Series(["a,b_c", "c_d,e", NA, "f,g,h"])
+        values = Series(["a,b_c", "c_d,e", np.nan, "f,g,h"])
         result = values.str.split("[,_]")
-        exp = Series([["a", "b", "c"], ["c", "d", "e"], NA, ["f", "g", "h"]])
+        exp = Series([["a", "b", "c"], ["c", "d", "e"], np.nan, ["f", "g", "h"]])
         tm.assert_series_equal(result, exp)
 
     def test_rsplit(self):
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h"])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
         result = values.str.rsplit("_")
-        exp = Series([["a", "b", "c"], ["c", "d", "e"], NA, ["f", "g", "h"]])
+        exp = Series([["a", "b", "c"], ["c", "d", "e"], np.nan, ["f", "g", "h"]])
         tm.assert_series_equal(result, exp)
 
         # more than one char
-        values = Series(["a__b__c", "c__d__e", NA, "f__g__h"])
+        values = Series(["a__b__c", "c__d__e", np.nan, "f__g__h"])
         result = values.str.rsplit("__")
         tm.assert_series_equal(result, exp)
 
@@ -2312,9 +2517,20 @@ def test_rsplit(self):
         tm.assert_series_equal(result, exp)
 
         # mixed
-        mixed = Series(["a_b_c", NA, "d_e_f", True, datetime.today(), None, 1, 2.0])
+        mixed = Series(["a_b_c", np.nan, "d_e_f", True, datetime.today(), None, 1, 2.0])
         result = mixed.str.rsplit("_")
-        exp = Series([["a", "b", "c"], NA, ["d", "e", "f"], NA, NA, NA, NA, NA])
+        exp = Series(
+            [
+                ["a", "b", "c"],
+                np.nan,
+                ["d", "e", "f"],
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+            ]
+        )
         assert isinstance(result, Series)
         tm.assert_almost_equal(result, exp)
 
@@ -2323,15 +2539,15 @@ def test_rsplit(self):
         tm.assert_almost_equal(result, exp)
 
         # regex split is not supported by rsplit
-        values = Series(["a,b_c", "c_d,e", NA, "f,g,h"])
+        values = Series(["a,b_c", "c_d,e", np.nan, "f,g,h"])
         result = values.str.rsplit("[,_]")
-        exp = Series([["a,b_c"], ["c_d,e"], NA, ["f,g,h"]])
+        exp = Series([["a,b_c"], ["c_d,e"], np.nan, ["f,g,h"]])
         tm.assert_series_equal(result, exp)
 
         # setting max number of splits, make sure it's from reverse
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h"])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
         result = values.str.rsplit("_", n=1)
-        exp = Series([["a_b", "c"], ["c_d", "e"], NA, ["f_g", "h"]])
+        exp = Series([["a_b", "c"], ["c_d", "e"], np.nan, ["f_g", "h"]])
         tm.assert_series_equal(result, exp)
 
     def test_split_blank_string(self):
@@ -2406,9 +2622,9 @@ def test_split_to_dataframe(self):
                 0: ["some", "one"],
                 1: ["unequal", "of"],
                 2: ["splits", "these"],
-                3: [NA, "things"],
-                4: [NA, "is"],
-                5: [NA, "not"],
+                3: [np.nan, "things"],
+                4: [np.nan, "is"],
+                5: [np.nan, "not"],
             }
         )
         tm.assert_frame_equal(result, exp)
@@ -2449,7 +2665,7 @@ def test_split_to_multiindex_expand(self):
         result = idx.str.split("_", expand=True)
         exp = MultiIndex.from_tuples(
             [
-                ("some", "unequal", "splits", NA, NA, NA),
+                ("some", "unequal", "splits", np.nan, np.nan, np.nan),
                 ("one", "of", "these", "things", "is", "not"),
                 (np.nan, np.nan, np.nan, np.nan, np.nan, np.nan),
                 (None, None, None, None, None, None),
@@ -2514,9 +2730,9 @@ def test_rsplit_to_multiindex_expand(self):
 
     def test_split_nan_expand(self):
         # gh-18450
-        s = Series(["foo,bar,baz", NA])
+        s = Series(["foo,bar,baz", np.nan])
         result = s.str.split(",", expand=True)
-        exp = DataFrame([["foo", "bar", "baz"], [NA, NA, NA]])
+        exp = DataFrame([["foo", "bar", "baz"], [np.nan, np.nan, np.nan]])
         tm.assert_frame_equal(result, exp)
 
         # check that these are actually np.nan and not None
@@ -2551,67 +2767,79 @@ def test_split_with_name(self):
     def test_partition_series(self):
         # https://github.com/pandas-dev/pandas/issues/23558
 
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h", None])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h", None])
 
         result = values.str.partition("_", expand=False)
         exp = Series(
-            [("a", "_", "b_c"), ("c", "_", "d_e"), NA, ("f", "_", "g_h"), None]
+            [("a", "_", "b_c"), ("c", "_", "d_e"), np.nan, ("f", "_", "g_h"), None]
         )
         tm.assert_series_equal(result, exp)
 
         result = values.str.rpartition("_", expand=False)
         exp = Series(
-            [("a_b", "_", "c"), ("c_d", "_", "e"), NA, ("f_g", "_", "h"), None]
+            [("a_b", "_", "c"), ("c_d", "_", "e"), np.nan, ("f_g", "_", "h"), None]
         )
         tm.assert_series_equal(result, exp)
 
         # more than one char
-        values = Series(["a__b__c", "c__d__e", NA, "f__g__h", None])
+        values = Series(["a__b__c", "c__d__e", np.nan, "f__g__h", None])
         result = values.str.partition("__", expand=False)
         exp = Series(
-            [("a", "__", "b__c"), ("c", "__", "d__e"), NA, ("f", "__", "g__h"), None]
+            [
+                ("a", "__", "b__c"),
+                ("c", "__", "d__e"),
+                np.nan,
+                ("f", "__", "g__h"),
+                None,
+            ]
         )
         tm.assert_series_equal(result, exp)
 
         result = values.str.rpartition("__", expand=False)
         exp = Series(
-            [("a__b", "__", "c"), ("c__d", "__", "e"), NA, ("f__g", "__", "h"), None]
+            [
+                ("a__b", "__", "c"),
+                ("c__d", "__", "e"),
+                np.nan,
+                ("f__g", "__", "h"),
+                None,
+            ]
         )
         tm.assert_series_equal(result, exp)
 
         # None
-        values = Series(["a b c", "c d e", NA, "f g h", None])
+        values = Series(["a b c", "c d e", np.nan, "f g h", None])
         result = values.str.partition(expand=False)
         exp = Series(
-            [("a", " ", "b c"), ("c", " ", "d e"), NA, ("f", " ", "g h"), None]
+            [("a", " ", "b c"), ("c", " ", "d e"), np.nan, ("f", " ", "g h"), None]
         )
         tm.assert_series_equal(result, exp)
 
         result = values.str.rpartition(expand=False)
         exp = Series(
-            [("a b", " ", "c"), ("c d", " ", "e"), NA, ("f g", " ", "h"), None]
+            [("a b", " ", "c"), ("c d", " ", "e"), np.nan, ("f g", " ", "h"), None]
         )
         tm.assert_series_equal(result, exp)
 
         # Not split
-        values = Series(["abc", "cde", NA, "fgh", None])
+        values = Series(["abc", "cde", np.nan, "fgh", None])
         result = values.str.partition("_", expand=False)
-        exp = Series([("abc", "", ""), ("cde", "", ""), NA, ("fgh", "", ""), None])
+        exp = Series([("abc", "", ""), ("cde", "", ""), np.nan, ("fgh", "", ""), None])
         tm.assert_series_equal(result, exp)
 
         result = values.str.rpartition("_", expand=False)
-        exp = Series([("", "", "abc"), ("", "", "cde"), NA, ("", "", "fgh"), None])
+        exp = Series([("", "", "abc"), ("", "", "cde"), np.nan, ("", "", "fgh"), None])
         tm.assert_series_equal(result, exp)
 
         # unicode
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h"])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
 
         result = values.str.partition("_", expand=False)
-        exp = Series([("a", "_", "b_c"), ("c", "_", "d_e"), NA, ("f", "_", "g_h")])
+        exp = Series([("a", "_", "b_c"), ("c", "_", "d_e"), np.nan, ("f", "_", "g_h")])
         tm.assert_series_equal(result, exp)
 
         result = values.str.rpartition("_", expand=False)
-        exp = Series([("a_b", "_", "c"), ("c_d", "_", "e"), NA, ("f_g", "_", "h")])
+        exp = Series([("a_b", "_", "c"), ("c_d", "_", "e"), np.nan, ("f_g", "_", "h")])
         tm.assert_series_equal(result, exp)
 
         # compare to standard lib
@@ -2629,7 +2857,8 @@ def test_partition_index(self):
         result = values.str.partition("_", expand=False)
         exp = Index(
             np.array(
-                [("a", "_", "b_c"), ("c", "_", "d_e"), ("f", "_", "g_h"), np.nan, None]
+                [("a", "_", "b_c"), ("c", "_", "d_e"), ("f", "_", "g_h"), np.nan, None],
+                dtype=object,
             )
         )
         tm.assert_index_equal(result, exp)
@@ -2638,7 +2867,8 @@ def test_partition_index(self):
         result = values.str.rpartition("_", expand=False)
         exp = Index(
             np.array(
-                [("a_b", "_", "c"), ("c_d", "_", "e"), ("f_g", "_", "h"), np.nan, None]
+                [("a_b", "_", "c"), ("c_d", "_", "e"), ("f_g", "_", "h"), np.nan, None],
+                dtype=object,
             )
         )
         tm.assert_index_equal(result, exp)
@@ -2675,7 +2905,7 @@ def test_partition_index(self):
     def test_partition_to_dataframe(self):
         # https://github.com/pandas-dev/pandas/issues/23558
 
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h", None])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h", None])
         result = values.str.partition("_")
         exp = DataFrame(
             {
@@ -2696,7 +2926,7 @@ def test_partition_to_dataframe(self):
         )
         tm.assert_frame_equal(result, exp)
 
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h", None])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h", None])
         result = values.str.partition("_", expand=True)
         exp = DataFrame(
             {
@@ -2742,23 +2972,17 @@ def test_partition_with_name(self):
         assert res.nlevels == 1
         tm.assert_index_equal(res, exp)
 
-    def test_partition_deprecation(self):
+    def test_partition_sep_kwarg(self):
         # GH 22676; depr kwarg "pat" in favor of "sep"
-        values = Series(["a_b_c", "c_d_e", NA, "f_g_h"])
+        values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
 
-        # str.partition
-        # using sep -> no warning
         expected = values.str.partition(sep="_")
-        with tm.assert_produces_warning(FutureWarning):
-            result = values.str.partition(pat="_")
-            tm.assert_frame_equal(result, expected)
+        result = values.str.partition("_")
+        tm.assert_frame_equal(result, expected)
 
-        # str.rpartition
-        # using sep -> no warning
         expected = values.str.rpartition(sep="_")
-        with tm.assert_produces_warning(FutureWarning):
-            result = values.str.rpartition(pat="_")
-            tm.assert_frame_equal(result, expected)
+        result = values.str.rpartition("_")
+        tm.assert_frame_equal(result, expected)
 
     def test_pipe_failures(self):
         # #2119
@@ -2777,100 +3001,102 @@ def test_pipe_failures(self):
     @pytest.mark.parametrize(
         "start, stop, step, expected",
         [
-            (2, 5, None, Series(["foo", "bar", NA, "baz"])),
-            (0, 3, -1, Series(["", "", NA, ""])),
-            (None, None, -1, Series(["owtoofaa", "owtrabaa", NA, "xuqzabaa"])),
-            (3, 10, 2, Series(["oto", "ato", NA, "aqx"])),
-            (3, 0, -1, Series(["ofa", "aba", NA, "aba"])),
+            (2, 5, None, Series(["foo", "bar", np.nan, "baz"])),
+            (0, 3, -1, Series(["", "", np.nan, ""])),
+            (None, None, -1, Series(["owtoofaa", "owtrabaa", np.nan, "xuqzabaa"])),
+            (3, 10, 2, Series(["oto", "ato", np.nan, "aqx"])),
+            (3, 0, -1, Series(["ofa", "aba", np.nan, "aba"])),
         ],
     )
     def test_slice(self, start, stop, step, expected):
-        values = Series(["aafootwo", "aabartwo", NA, "aabazqux"])
+        values = Series(["aafootwo", "aabartwo", np.nan, "aabazqux"])
         result = values.str.slice(start, stop, step)
         tm.assert_series_equal(result, expected)
 
         # mixed
         mixed = Series(
-            ["aafootwo", NA, "aabartwo", True, datetime.today(), None, 1, 2.0]
+            ["aafootwo", np.nan, "aabartwo", True, datetime.today(), None, 1, 2.0]
         )
 
         rs = Series(mixed).str.slice(2, 5)
-        xp = Series(["foo", NA, "bar", NA, NA, NA, NA, NA])
+        xp = Series(["foo", np.nan, "bar", np.nan, np.nan, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
         rs = Series(mixed).str.slice(2, 5, -1)
-        xp = Series(["oof", NA, "rab", NA, NA, NA, NA, NA])
+        xp = Series(["oof", np.nan, "rab", np.nan, np.nan, np.nan, np.nan, np.nan])
 
     def test_slice_replace(self):
-        values = Series(["short", "a bit longer", "evenlongerthanthat", "", NA])
+        values = Series(["short", "a bit longer", "evenlongerthanthat", "", np.nan])
 
-        exp = Series(["shrt", "a it longer", "evnlongerthanthat", "", NA])
+        exp = Series(["shrt", "a it longer", "evnlongerthanthat", "", np.nan])
         result = values.str.slice_replace(2, 3)
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["shzrt", "a zit longer", "evznlongerthanthat", "z", NA])
+        exp = Series(["shzrt", "a zit longer", "evznlongerthanthat", "z", np.nan])
         result = values.str.slice_replace(2, 3, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["shzort", "a zbit longer", "evzenlongerthanthat", "z", NA])
+        exp = Series(["shzort", "a zbit longer", "evzenlongerthanthat", "z", np.nan])
         result = values.str.slice_replace(2, 2, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["shzort", "a zbit longer", "evzenlongerthanthat", "z", NA])
+        exp = Series(["shzort", "a zbit longer", "evzenlongerthanthat", "z", np.nan])
         result = values.str.slice_replace(2, 1, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["shorz", "a bit longez", "evenlongerthanthaz", "z", NA])
+        exp = Series(["shorz", "a bit longez", "evenlongerthanthaz", "z", np.nan])
         result = values.str.slice_replace(-1, None, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["zrt", "zer", "zat", "z", NA])
+        exp = Series(["zrt", "zer", "zat", "z", np.nan])
         result = values.str.slice_replace(None, -2, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["shortz", "a bit znger", "evenlozerthanthat", "z", NA])
+        exp = Series(["shortz", "a bit znger", "evenlozerthanthat", "z", np.nan])
         result = values.str.slice_replace(6, 8, "z")
         tm.assert_series_equal(result, exp)
 
-        exp = Series(["zrt", "a zit longer", "evenlongzerthanthat", "z", NA])
+        exp = Series(["zrt", "a zit longer", "evenlongzerthanthat", "z", np.nan])
         result = values.str.slice_replace(-10, 3, "z")
         tm.assert_series_equal(result, exp)
 
     def test_strip_lstrip_rstrip(self):
-        values = Series(["  aa   ", " bb \n", NA, "cc  "])
+        values = Series(["  aa   ", " bb \n", np.nan, "cc  "])
 
         result = values.str.strip()
-        exp = Series(["aa", "bb", NA, "cc"])
+        exp = Series(["aa", "bb", np.nan, "cc"])
         tm.assert_series_equal(result, exp)
 
         result = values.str.lstrip()
-        exp = Series(["aa   ", "bb \n", NA, "cc  "])
+        exp = Series(["aa   ", "bb \n", np.nan, "cc  "])
         tm.assert_series_equal(result, exp)
 
         result = values.str.rstrip()
-        exp = Series(["  aa", " bb", NA, "cc"])
+        exp = Series(["  aa", " bb", np.nan, "cc"])
         tm.assert_series_equal(result, exp)
 
     def test_strip_lstrip_rstrip_mixed(self):
         # mixed
-        mixed = Series(["  aa  ", NA, " bb \t\n", True, datetime.today(), None, 1, 2.0])
+        mixed = Series(
+            ["  aa  ", np.nan, " bb \t\n", True, datetime.today(), None, 1, 2.0]
+        )
 
         rs = Series(mixed).str.strip()
-        xp = Series(["aa", NA, "bb", NA, NA, NA, NA, NA])
+        xp = Series(["aa", np.nan, "bb", np.nan, np.nan, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
         rs = Series(mixed).str.lstrip()
-        xp = Series(["aa  ", NA, "bb \t\n", NA, NA, NA, NA, NA])
+        xp = Series(["aa  ", np.nan, "bb \t\n", np.nan, np.nan, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
 
         rs = Series(mixed).str.rstrip()
-        xp = Series(["  aa", NA, " bb", NA, NA, NA, NA, NA])
+        xp = Series(["  aa", np.nan, " bb", np.nan, np.nan, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
@@ -2880,15 +3106,15 @@ def test_strip_lstrip_rstrip_args(self):
 
         rs = values.str.strip("x")
         xp = Series(["ABC", " BNSD", "LDFJH "])
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         rs = values.str.lstrip("x")
         xp = Series(["ABCxx", " BNSD", "LDFJH xx"])
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         rs = values.str.rstrip("x")
         xp = Series(["xxABC", "xx BNSD", "LDFJH "])
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
     def test_wrap(self):
         # test values are: two words less than width, two words equal to width,
@@ -2925,14 +3151,14 @@ def test_wrap(self):
         )
 
         rs = values.str.wrap(12, break_long_words=True)
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         # test with pre and post whitespace (non-unicode), NaN, and non-ascii
         # Unicode
         values = Series(["  pre  ", np.nan, "\xac\u20ac\U00008000 abadcafe"])
-        xp = Series(["  pre", NA, "\xac\u20ac\U00008000 ab\nadcafe"])
+        xp = Series(["  pre", np.nan, "\xac\u20ac\U00008000 ab\nadcafe"])
         rs = values.str.wrap(6)
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
     def test_get(self):
         values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"])
@@ -2942,10 +3168,10 @@ def test_get(self):
         tm.assert_series_equal(result, expected)
 
         # mixed
-        mixed = Series(["a_b_c", NA, "c_d_e", True, datetime.today(), None, 1, 2.0])
+        mixed = Series(["a_b_c", np.nan, "c_d_e", True, datetime.today(), None, 1, 2.0])
 
         rs = Series(mixed).str.split("_").str.get(1)
-        xp = Series(["b", NA, "d", NA, NA, NA, NA, NA])
+        xp = Series(["b", np.nan, "d", np.nan, np.nan, np.nan, np.nan, np.nan])
 
         assert isinstance(rs, Series)
         tm.assert_almost_equal(rs, xp)
@@ -2989,37 +3215,37 @@ def test_get_complex_nested(self, to_type):
 
     def test_contains_moar(self):
         # PR #1179
-        s = Series(["A", "B", "C", "Aaba", "Baca", "", NA, "CABA", "dog", "cat"])
+        s = Series(["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"])
 
         result = s.str.contains("a")
         expected = Series(
             [False, False, False, True, True, False, np.nan, False, False, True]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("a", case=False)
         expected = Series(
             [True, False, False, True, True, False, np.nan, True, False, True]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("Aa")
         expected = Series(
             [False, False, False, True, False, False, np.nan, False, False, False]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("ba")
         expected = Series(
             [False, False, False, True, False, False, np.nan, False, False, False]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("ba", case=False)
         expected = Series(
             [False, False, False, True, True, False, np.nan, True, False, False]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_contains_nan(self):
         # PR #14171
@@ -3027,29 +3253,29 @@ def test_contains_nan(self):
 
         result = s.str.contains("foo", na=False)
         expected = Series([False, False, False], dtype=np.bool_)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("foo", na=True)
         expected = Series([True, True, True], dtype=np.bool_)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("foo", na="foo")
         expected = Series(["foo", "foo", "foo"], dtype=np.object_)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.contains("foo")
         expected = Series([np.nan, np.nan, np.nan], dtype=np.object_)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_replace_moar(self):
         # PR #1179
-        s = Series(["A", "B", "C", "Aaba", "Baca", "", NA, "CABA", "dog", "cat"])
+        s = Series(["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"])
 
         result = s.str.replace("A", "YYY")
         expected = Series(
-            ["YYY", "B", "C", "YYYaba", "Baca", "", NA, "CYYYBYYY", "dog", "cat"]
+            ["YYY", "B", "C", "YYYaba", "Baca", "", np.nan, "CYYYBYYY", "dog", "cat"]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.replace("A", "YYY", case=False)
         expected = Series(
@@ -3060,13 +3286,13 @@ def test_replace_moar(self):
                 "YYYYYYbYYY",
                 "BYYYcYYY",
                 "",
-                NA,
+                np.nan,
                 "CYYYBYYY",
                 "dog",
                 "cYYYt",
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str.replace("^.a|dog", "XX-XX ", case=False)
         expected = Series(
@@ -3077,30 +3303,40 @@ def test_replace_moar(self):
                 "XX-XX ba",
                 "XX-XX ca",
                 "",
-                NA,
+                np.nan,
                 "XX-XX BA",
                 "XX-XX ",
                 "XX-XX t",
             ]
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_string_slice_get_syntax(self):
         s = Series(
-            ["YYY", "B", "C", "YYYYYYbYYY", "BYYYcYYY", NA, "CYYYBYYY", "dog", "cYYYt"]
+            [
+                "YYY",
+                "B",
+                "C",
+                "YYYYYYbYYY",
+                "BYYYcYYY",
+                np.nan,
+                "CYYYBYYY",
+                "dog",
+                "cYYYt",
+            ]
         )
 
         result = s.str[0]
         expected = s.str.get(0)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str[:3]
         expected = s.str.slice(stop=3)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         result = s.str[2::-1]
         expected = s.str.slice(start=2, step=-1)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_string_slice_out_of_bounds(self):
         s = Series([(1, 2), (1,), (3, 4, 5)])
@@ -3108,12 +3344,12 @@ def test_string_slice_out_of_bounds(self):
         result = s.str[1]
         expected = Series([2, np.nan, 4])
 
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series(["foo", "b", "ba"])
         result = s.str[1]
         expected = Series(["o", np.nan, "a"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_match_findall_flags(self):
         data = {
@@ -3156,8 +3392,8 @@ def test_encode_decode_errors(self):
         encodeBase = Series(["a", "b", "a\x9d"])
 
         msg = (
-            r"'charmap' codec can't encode character '\\x9d' in position 1:"
-            " character maps to <undefined>"
+            r"'charmap' codec can't encode character '\\x9d' in position 1: "
+            "character maps to <undefined>"
         )
         with pytest.raises(UnicodeEncodeError, match=msg):
             encodeBase.str.encode("cp1252")
@@ -3170,8 +3406,8 @@ def test_encode_decode_errors(self):
         decodeBase = Series([b"a", b"b", b"a\x9d"])
 
         msg = (
-            "'charmap' codec can't decode byte 0x9d in position 1:"
-            " character maps to <undefined>"
+            "'charmap' codec can't decode byte 0x9d in position 1: "
+            "character maps to <undefined>"
         )
         with pytest.raises(UnicodeDecodeError, match=msg):
             decodeBase.str.decode("cp1252")
@@ -3264,8 +3500,91 @@ def test_method_on_bytes(self):
 
     def test_casefold(self):
         # GH25405
-        expected = Series(["ss", NA, "case", "ssd"])
-        s = Series(["ß", NA, "case", "ßd"])
+        expected = Series(["ss", np.nan, "case", "ssd"])
+        s = Series(["ß", np.nan, "case", "ßd"])
         result = s.str.casefold()
 
         tm.assert_series_equal(result, expected)
+
+
+def test_string_array(any_string_method):
+    method_name, args, kwargs = any_string_method
+    if method_name == "decode":
+        pytest.skip("decode requires bytes.")
+
+    data = ["a", "bb", np.nan, "ccc"]
+    a = Series(data, dtype=object)
+    b = Series(data, dtype="string")
+
+    expected = getattr(a.str, method_name)(*args, **kwargs)
+    result = getattr(b.str, method_name)(*args, **kwargs)
+
+    if isinstance(expected, Series):
+        if expected.dtype == "object" and lib.is_string_array(
+            expected.dropna().values,
+        ):
+            assert result.dtype == "string"
+            result = result.astype(object)
+
+        elif expected.dtype == "object" and lib.is_bool_array(
+            expected.values, skipna=True
+        ):
+            assert result.dtype == "boolean"
+            result = result.astype(object)
+
+        elif expected.dtype == "float" and expected.isna().any():
+            assert result.dtype == "Int64"
+            result = result.astype("float")
+
+    elif isinstance(expected, DataFrame):
+        columns = expected.select_dtypes(include="object").columns
+        assert all(result[columns].dtypes == "string")
+        result[columns] = result[columns].astype(object)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method,expected",
+    [
+        ("count", [2, None]),
+        ("find", [0, None]),
+        ("index", [0, None]),
+        ("rindex", [2, None]),
+    ],
+)
+def test_string_array_numeric_integer_array(method, expected):
+    s = Series(["aba", None], dtype="string")
+    result = getattr(s.str, method)("a")
+    expected = Series(expected, dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "method,expected",
+    [
+        ("isdigit", [False, None, True]),
+        ("isalpha", [True, None, False]),
+        ("isalnum", [True, None, True]),
+        ("isdigit", [False, None, True]),
+    ],
+)
+def test_string_array_boolean_array(method, expected):
+    s = Series(["a", None, "1"], dtype="string")
+    result = getattr(s.str, method)()
+    expected = Series(expected, dtype="boolean")
+    tm.assert_series_equal(result, expected)
+
+
+def test_string_array_extract():
+    # https://github.com/pandas-dev/pandas/issues/30969
+    # Only expand=False & multiple groups was failing
+    a = Series(["a1", "b2", "cc"], dtype="string")
+    b = Series(["a1", "b2", "cc"], dtype="object")
+    pat = r"(\w)(\d)"
+
+    result = a.str.extract(pat, expand=False)
+    expected = b.str.extract(pat, expand=False)
+    assert all(result.dtypes == "string")
+
+    result = result.astype(object)
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/test_take.py b/pandas/tests/test_take.py
index d2a9e1dc94bb5..2534f1849cf61 100644
--- a/pandas/tests/test_take.py
+++ b/pandas/tests/test_take.py
@@ -6,8 +6,8 @@
 
 from pandas._libs.tslib import iNaT
 
+import pandas._testing as tm
 import pandas.core.algorithms as algos
-import pandas.util.testing as tm
 
 
 @pytest.fixture(params=[True, False])
@@ -345,7 +345,7 @@ def test_2d_float32(self):
 
     def test_2d_datetime64(self):
         # 2005/01/01 - 2006/01/01
-        arr = np.random.randint(11045376, 11360736, (5, 3)) * 100000000000
+        arr = np.random.randint(11_045_376, 11_360_736, (5, 3)) * 100_000_000_000
         arr = arr.view(dtype="datetime64[ns]")
         indexer = [0, 2, -1, 1, -1]
 
@@ -423,16 +423,21 @@ class TestExtensionTake:
 
     def test_bounds_check_large(self):
         arr = np.array([1, 2])
-        with pytest.raises(IndexError):
+
+        msg = "indices are out-of-bounds"
+        with pytest.raises(IndexError, match=msg):
             algos.take(arr, [2, 3], allow_fill=True)
 
-        with pytest.raises(IndexError):
+        msg = "index 2 is out of bounds for( axis 0 with)? size 2"
+        with pytest.raises(IndexError, match=msg):
             algos.take(arr, [2, 3], allow_fill=False)
 
     def test_bounds_check_small(self):
         arr = np.array([1, 2, 3], dtype=np.int64)
         indexer = [0, -1, -2]
-        with pytest.raises(ValueError):
+
+        msg = r"'indices' contains values less than allowed \(-2 < -1\)"
+        with pytest.raises(ValueError, match=msg):
             algos.take(arr, indexer, allow_fill=True)
 
         result = algos.take(arr, indexer)
@@ -446,7 +451,11 @@ def test_take_empty(self, allow_fill):
         result = algos.take(arr, [], allow_fill=allow_fill)
         tm.assert_numpy_array_equal(arr, result)
 
-        with pytest.raises(IndexError):
+        msg = (
+            "cannot do a non-empty take from an empty axes.|"
+            "indices are out-of-bounds"
+        )
+        with pytest.raises(IndexError, match=msg):
             algos.take(arr, [0], allow_fill=allow_fill)
 
     def test_take_na_empty(self):
diff --git a/pandas/tests/tools/test_numeric.py b/pandas/tests/tools/test_numeric.py
index bc1eee2a0aaf2..2fd39d5a7b703 100644
--- a/pandas/tests/tools/test_numeric.py
+++ b/pandas/tests/tools/test_numeric.py
@@ -6,7 +6,7 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, to_numeric
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 @pytest.fixture(params=[None, "ignore", "raise", "coerce"])
@@ -567,6 +567,24 @@ def test_downcast_limits(dtype, downcast, min_max):
     assert series.dtype == dtype
 
 
+@pytest.mark.parametrize(
+    "ser,expected",
+    [
+        (
+            pd.Series([0, 9223372036854775808]),
+            pd.Series([0, 9223372036854775808], dtype=np.uint64),
+        )
+    ],
+)
+def test_downcast_uint64(ser, expected):
+    # see gh-14422:
+    # BUG: to_numeric doesn't work uint64 numbers
+
+    result = pd.to_numeric(ser, downcast="unsigned")
+
+    tm.assert_series_equal(result, expected)
+
+
 @pytest.mark.parametrize(
     "data,exp_data",
     [
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 50844aabb2c88..c32ad5087ab9e 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -8,8 +8,8 @@
 from pandas.compat import is_platform_windows
 
 from pandas import DatetimeIndex, Index, Series, Timestamp, date_range, period_range
+import pandas._testing as tm
 from pandas.core.tools.datetimes import to_datetime
-import pandas.util.testing as tm
 
 import pandas.tseries.frequencies as frequencies
 import pandas.tseries.offsets as offsets
@@ -178,7 +178,7 @@ def test_infer_freq_delta(base_delta_code_pair, count):
     inc = base_delta * count
     index = DatetimeIndex([b + inc * j for j in range(3)])
 
-    exp_freq = "{count:d}{code}".format(count=count, code=code) if count > 1 else code
+    exp_freq = f"{count:d}{code}" if count > 1 else code
     assert frequencies.infer_freq(index) == exp_freq
 
 
@@ -202,13 +202,11 @@ def test_infer_freq_custom(base_delta_code_pair, constructor):
 
 
 def test_weekly_infer(periods, day):
-    _check_generated_range("1/1/2000", periods, "W-{day}".format(day=day))
+    _check_generated_range("1/1/2000", periods, f"W-{day}")
 
 
 def test_week_of_month_infer(periods, day, count):
-    _check_generated_range(
-        "1/1/2000", periods, "WOM-{count}{day}".format(count=count, day=day)
-    )
+    _check_generated_range("1/1/2000", periods, f"WOM-{count}{day}")
 
 
 @pytest.mark.parametrize("freq", ["M", "BM", "BMS"])
@@ -217,14 +215,12 @@ def test_monthly_infer(periods, freq):
 
 
 def test_quarterly_infer(month, periods):
-    _check_generated_range("1/1/2000", periods, "Q-{month}".format(month=month))
+    _check_generated_range("1/1/2000", periods, f"Q-{month}")
 
 
 @pytest.mark.parametrize("annual", ["A", "BA"])
 def test_annually_infer(month, periods, annual):
-    _check_generated_range(
-        "1/1/2000", periods, "{annual}-{month}".format(annual=annual, month=month)
-    )
+    _check_generated_range("1/1/2000", periods, f"{annual}-{month}")
 
 
 @pytest.mark.parametrize(
@@ -468,7 +464,7 @@ def test_series_datetime_index(freq):
 @pytest.mark.parametrize(
     "offset_func",
     [
-        frequencies.get_offset,
+        frequencies._get_offset,
         lambda freq: date_range("2011-01-01", periods=5, freq=freq),
     ],
 )
@@ -528,8 +524,8 @@ def test_legacy_offset_warnings(offset_func, freq):
 
 
 def test_ms_vs_capital_ms():
-    left = frequencies.get_offset("ms")
-    right = frequencies.get_offset("MS")
+    left = frequencies._get_offset("ms")
+    right = frequencies._get_offset("MS")
 
     assert left == offsets.Milli()
     assert right == offsets.MonthBegin()
diff --git a/pandas/tests/tseries/frequencies/test_to_offset.py b/pandas/tests/tseries/frequencies/test_to_offset.py
index b6069c446160d..beaefe9109e91 100644
--- a/pandas/tests/tseries/frequencies/test_to_offset.py
+++ b/pandas/tests/tseries/frequencies/test_to_offset.py
@@ -86,7 +86,7 @@ def test_to_offset_invalid(freqstr):
 
     # We escape string because some of our
     # inputs contain regex special characters.
-    msg = re.escape("Invalid frequency: {freqstr}".format(freqstr=freqstr))
+    msg = re.escape(f"Invalid frequency: {freqstr}")
     with pytest.raises(ValueError, match=msg):
         frequencies.to_offset(freqstr)
 
diff --git a/pandas/tests/tseries/holiday/test_calendar.py b/pandas/tests/tseries/holiday/test_calendar.py
index 79c28942769f0..cd3b1aab33a2a 100644
--- a/pandas/tests/tseries/holiday/test_calendar.py
+++ b/pandas/tests/tseries/holiday/test_calendar.py
@@ -2,14 +2,15 @@
 
 import pytest
 
-from pandas import DatetimeIndex
-import pandas.util.testing as tm
+from pandas import DatetimeIndex, offsets, to_datetime
+import pandas._testing as tm
 
 from pandas.tseries.holiday import (
     AbstractHolidayCalendar,
     Holiday,
     Timestamp,
     USFederalHolidayCalendar,
+    USLaborDay,
     USThanksgivingDay,
     get_calendar,
 )
@@ -81,3 +82,31 @@ def test_calendar_observance_dates():
 def test_rule_from_name():
     us_fed_cal = get_calendar("USFederalHolidayCalendar")
     assert us_fed_cal.rule_from_name("Thanksgiving") == USThanksgivingDay
+
+
+def test_calendar_2031():
+    # See gh-27790
+    #
+    # Labor Day 2031 is on September 1. Saturday before is August 30.
+    # Next working day after August 30 ought to be Tuesday, September 2.
+
+    class testCalendar(AbstractHolidayCalendar):
+        rules = [USLaborDay]
+
+    cal = testCalendar()
+    workDay = offsets.CustomBusinessDay(calendar=cal)
+    Sat_before_Labor_Day_2031 = to_datetime("2031-08-30")
+    next_working_day = Sat_before_Labor_Day_2031 + 0 * workDay
+    assert next_working_day == to_datetime("2031-09-02")
+
+
+def test_no_holidays_calendar():
+    # Test for issue #31415
+
+    class NoHolidaysCalendar(AbstractHolidayCalendar):
+        pass
+
+    cal = NoHolidaysCalendar()
+    holidays = cal.holidays(Timestamp("01-Jan-2020"), Timestamp("01-Jan-2021"))
+    empty_index = DatetimeIndex([])  # Type is DatetimeIndex since return_name=False
+    tm.assert_index_equal(holidays, empty_index)
diff --git a/pandas/tests/tseries/holiday/test_holiday.py b/pandas/tests/tseries/holiday/test_holiday.py
index 06869fcd7a4f8..a2c146dbd65e8 100644
--- a/pandas/tests/tseries/holiday/test_holiday.py
+++ b/pandas/tests/tseries/holiday/test_holiday.py
@@ -3,7 +3,7 @@
 import pytest
 from pytz import utc
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries.holiday import (
     MO,
@@ -238,7 +238,7 @@ class TestCalendar(AbstractHolidayCalendar):
         rules = []
 
     calendar = get_calendar("TestCalendar")
-    assert TestCalendar == calendar.__class__
+    assert TestCalendar == type(calendar)
 
 
 def test_factory():
diff --git a/pandas/tests/tseries/offsets/common.py b/pandas/tests/tseries/offsets/common.py
index fbf4454109ec0..71953fd095882 100644
--- a/pandas/tests/tseries/offsets/common.py
+++ b/pandas/tests/tseries/offsets/common.py
@@ -13,18 +13,14 @@ def assert_offset_equal(offset, base, expected):
         assert actual_apply == expected
     except AssertionError:
         raise AssertionError(
-            "\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
-            "\nAt Date: {base}".format(
-                expected=expected, actual=actual, offset=offset, base=base
-            )
+            f"\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
+            f"\nAt Date: {base}"
         )
 
 
-def assert_onOffset(offset, date, expected):
-    actual = offset.onOffset(date)
+def assert_is_on_offset(offset, date, expected):
+    actual = offset.is_on_offset(date)
     assert actual == expected, (
-        "\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
-        "\nAt Date: {date}".format(
-            expected=expected, actual=actual, offset=offset, date=date
-        )
+        f"\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
+        f"\nAt Date: {date}"
     )
diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py
index 8b1aaafb94e0b..f0ce104a68e29 100644
--- a/pandas/tests/tseries/offsets/test_fiscal.py
+++ b/pandas/tests/tseries/offsets/test_fiscal.py
@@ -9,11 +9,12 @@
 from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
 
 from pandas import Timestamp
+import pandas._testing as tm
 
 from pandas.tseries.frequencies import get_offset
 from pandas.tseries.offsets import FY5253, FY5253Quarter
 
-from .common import assert_offset_equal, assert_onOffset
+from .common import assert_is_on_offset, assert_offset_equal
 from .test_offsets import Base, WeekDay
 
 
@@ -50,9 +51,11 @@ def test_get_offset_name():
 
 def test_get_offset():
     with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-        get_offset("gibberish")
+        with tm.assert_produces_warning(FutureWarning):
+            get_offset("gibberish")
     with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-        get_offset("QS-JAN-B")
+        with tm.assert_produces_warning(FutureWarning):
+            get_offset("QS-JAN-B")
 
     pairs = [
         ("RE-N-DEC-MON", makeFY5253NearestEndMonth(weekday=0, startingMonth=12)),
@@ -78,11 +81,11 @@ def test_get_offset():
     ]
 
     for name, expected in pairs:
-        offset = get_offset(name)
-        assert (
-            offset == expected
-        ), "Expected {name!r} to yield {expected!r} (actual: {offset!r})".format(
-            name=name, expected=expected, offset=offset
+        with tm.assert_produces_warning(FutureWarning):
+            offset = get_offset(name)
+        assert offset == expected, (
+            f"Expected {repr(name)} to yield {repr(expected)} "
+            f"(actual: {repr(offset)})"
         )
 
 
@@ -92,7 +95,7 @@ class TestFY5253LastOfMonth(Base):
 
     on_offset_cases = [
         # From Wikipedia (see:
-        # http://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar#Last_Saturday_of_the_month_at_fiscal_year_end)
+        # https://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar#Last_Saturday_of_the_month_at_fiscal_year_end)
         (offset_lom_sat_aug, datetime(2006, 8, 26), True),
         (offset_lom_sat_aug, datetime(2007, 8, 25), True),
         (offset_lom_sat_aug, datetime(2008, 8, 30), True),
@@ -129,9 +132,9 @@ class TestFY5253LastOfMonth(Base):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
     def test_apply(self):
         offset_lom_aug_sat = makeFY5253LastOfMonth(startingMonth=8, weekday=WeekDay.SAT)
@@ -205,7 +208,7 @@ def test_get_year_end(self):
 
     on_offset_cases = [
         #    From Wikipedia (see:
-        #    http://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar
+        #    https://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar
         #    #Saturday_nearest_the_end_of_month)
         #    2006-09-02   2006 September 2
         #    2007-09-01   2007 September 1
@@ -254,9 +257,9 @@ def test_get_year_end(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
     def test_apply(self):
         date_seq_nem_8_sat = [
@@ -330,16 +333,16 @@ def test_apply(self):
 
 
 class TestFY5253LastOfMonthQuarter(Base):
-    def test_isAnchored(self):
+    def test_is_anchored(self):
         assert makeFY5253LastOfMonthQuarter(
             startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
-        ).isAnchored()
+        ).is_anchored()
         assert makeFY5253LastOfMonthQuarter(
             weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
-        ).isAnchored()
+        ).is_anchored()
         assert not makeFY5253LastOfMonthQuarter(
             2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
-        ).isAnchored()
+        ).is_anchored()
 
     def test_equality(self):
         assert makeFY5253LastOfMonthQuarter(
@@ -492,9 +495,9 @@ def test_offset(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
     def test_year_has_extra_week(self):
         # End of long Q1
@@ -597,9 +600,9 @@ class TestFY5253NearestEndMonthQuarter(Base):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
     def test_offset(self):
         offset = makeFY5253NearestEndMonthQuarter(
@@ -653,7 +656,7 @@ def test_fy5253_last_onoffset():
     # GH#18877 dates on the year-end but not normalized to midnight
     offset = FY5253(n=-5, startingMonth=5, variation="last", weekday=0)
     ts = Timestamp("1984-05-28 06:29:43.955911354+0200", tz="Europe/San_Marino")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
@@ -662,7 +665,7 @@ def test_fy5253_nearest_onoffset():
     # GH#18877 dates on the year-end but not normalized to midnight
     offset = FY5253(n=3, startingMonth=7, variation="nearest", weekday=2)
     ts = Timestamp("2032-07-28 00:12:59.035729419+0000", tz="Africa/Dakar")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
@@ -673,7 +676,7 @@ def test_fy5253qtr_onoffset_nearest():
     offset = FY5253Quarter(
         n=3, qtr_with_extra_week=1, startingMonth=2, variation="nearest", weekday=0
     )
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
@@ -685,5 +688,5 @@ def test_fy5253qtr_onoffset_last():
     )
     ts = Timestamp("2011-01-26 19:03:40.331096129+0200", tz="Africa/Windhoek")
     slow = (ts + offset) - offset == ts
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     assert fast == slow
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 1abc8aece5ec9..2f00a58fe80be 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -1,4 +1,5 @@
 from datetime import date, datetime, time as dt_time, timedelta
+from typing import Dict, List, Optional, Tuple, Type
 
 import numpy as np
 import pytest
@@ -19,17 +20,19 @@
 from pandas._libs.tslibs.offsets import ApplyTypeError
 import pandas.compat as compat
 from pandas.compat.numpy import np_datetime64_compat
+from pandas.errors import PerformanceWarning
 
-from pandas.core.indexes.datetimes import DatetimeIndex, _to_M8, date_range
+import pandas._testing as tm
+from pandas.core.indexes.datetimes import DatetimeIndex, date_range
 from pandas.core.series import Series
-import pandas.util.testing as tm
 
 from pandas.io.pickle import read_pickle
-from pandas.tseries.frequencies import _offset_map, get_offset
+from pandas.tseries.frequencies import _get_offset, _offset_map
 from pandas.tseries.holiday import USFederalHolidayCalendar
 import pandas.tseries.offsets as offsets
 from pandas.tseries.offsets import (
     FY5253,
+    BaseOffset,
     BDay,
     BMonthBegin,
     BMonthEnd,
@@ -41,7 +44,10 @@
     CBMonthBegin,
     CBMonthEnd,
     CDay,
+    CustomBusinessDay,
     CustomBusinessHour,
+    CustomBusinessMonthBegin,
+    CustomBusinessMonthEnd,
     DateOffset,
     Day,
     Easter,
@@ -61,7 +67,7 @@
     YearEnd,
 )
 
-from .common import assert_offset_equal, assert_onOffset
+from .common import assert_is_on_offset, assert_offset_equal
 
 
 class WeekDay:
@@ -75,24 +81,14 @@ class WeekDay:
     SUN = 6
 
 
-####
-# Misc function tests
-####
-
-
-def test_to_M8():
-    valb = datetime(2007, 10, 1)
-    valu = _to_M8(valb)
-    assert isinstance(valu, np.datetime64)
-
-
 #####
 # DateOffset Tests
 #####
+_ApplyCases = List[Tuple[BaseOffset, Dict[datetime, datetime]]]
 
 
 class Base:
-    _offset = None
+    _offset: Optional[Type[DateOffset]] = None
     d = Timestamp(datetime(2008, 1, 2))
 
     timezones = [
@@ -132,10 +128,7 @@ def _get_offset(self, klass, value=1, normalize=False):
         elif klass is DateOffset:
             klass = klass(days=value, normalize=normalize)
         else:
-            try:
-                klass = klass(value, normalize=normalize)
-            except Exception:
-                klass = klass(normalize=normalize)
+            klass = klass(value, normalize=normalize)
         return klass
 
     def test_apply_out_of_range(self, tz_naive_fixture):
@@ -333,7 +326,7 @@ def test_offset_freqstr(self, offset_types):
 
         freqstr = offset.freqstr
         if freqstr not in ("<Easter>", "<DateOffset: days=1>", "LWOM-SAT"):
-            code = get_offset(freqstr)
+            code = _get_offset(freqstr)
             assert offset.rule_code == code
 
     def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=False):
@@ -358,7 +351,7 @@ def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=Fals
         ts = Timestamp(dt) + Nano(5)
 
         if (
-            offset_s.__class__.__name__ == "DateOffset"
+            type(offset_s).__name__ == "DateOffset"
             and (funcname == "apply" or normalize)
             and ts.nanosecond > 0
         ):
@@ -395,7 +388,7 @@ def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=Fals
             ts = Timestamp(dt, tz=tz) + Nano(5)
 
             if (
-                offset_s.__class__.__name__ == "DateOffset"
+                type(offset_s).__name__ == "DateOffset"
                 and (funcname == "apply" or normalize)
                 and ts.nanosecond > 0
             ):
@@ -553,24 +546,24 @@ def test_rollback(self, offset_types):
                 offset_types, "rollback", dt, expected, normalize=True
             )
 
-    def test_onOffset(self, offset_types):
+    def test_is_on_offset(self, offset_types):
         dt = self.expecteds[offset_types.__name__]
         offset_s = self._get_offset(offset_types)
-        assert offset_s.onOffset(dt)
+        assert offset_s.is_on_offset(dt)
 
-        # when normalize=True, onOffset checks time is 00:00:00
+        # when normalize=True, is_on_offset checks time is 00:00:00
         if issubclass(offset_types, Tick):
             # normalize=True disallowed for Tick subclasses GH#21427
             return
         offset_n = self._get_offset(offset_types, normalize=True)
-        assert not offset_n.onOffset(dt)
+        assert not offset_n.is_on_offset(dt)
 
         if offset_types in (BusinessHour, CustomBusinessHour):
             # In default BusinessHour (9:00-17:00), normalized time
             # cannot be in business hour range
             return
         date = datetime(dt.year, dt.month, dt.day)
-        assert offset_n.onOffset(date)
+        assert offset_n.is_on_offset(date)
 
     def test_add(self, offset_types, tz_naive_fixture):
         tz = tz_naive_fixture
@@ -607,6 +600,46 @@ def test_add(self, offset_types, tz_naive_fixture):
         assert isinstance(result, Timestamp)
         assert result == expected_localize
 
+    def test_add_empty_datetimeindex(self, offset_types, tz_naive_fixture):
+        # GH#12724, GH#30336
+        offset_s = self._get_offset(offset_types)
+
+        dti = DatetimeIndex([], tz=tz_naive_fixture)
+
+        warn = None
+        if isinstance(
+            offset_s,
+            (
+                Easter,
+                WeekOfMonth,
+                LastWeekOfMonth,
+                CustomBusinessDay,
+                BusinessHour,
+                CustomBusinessHour,
+                CustomBusinessMonthBegin,
+                CustomBusinessMonthEnd,
+                FY5253,
+                FY5253Quarter,
+            ),
+        ):
+            # We don't have an optimized apply_index
+            warn = PerformanceWarning
+
+        with tm.assert_produces_warning(warn):
+            result = dti + offset_s
+        tm.assert_index_equal(result, dti)
+        with tm.assert_produces_warning(warn):
+            result = offset_s + dti
+        tm.assert_index_equal(result, dti)
+
+        dta = dti._data
+        with tm.assert_produces_warning(warn):
+            result = dta + offset_s
+        tm.assert_equal(result, dta)
+        with tm.assert_produces_warning(warn):
+            result = offset_s + dta
+        tm.assert_equal(result, dta)
+
     def test_pickle_v0_15_2(self, datapath):
         offsets = {
             "DateOffset": DateOffset(years=1),
@@ -622,6 +655,27 @@ def test_pickle_v0_15_2(self, datapath):
         #
         tm.assert_dict_equal(offsets, read_pickle(pickle_path))
 
+    def test_onOffset_deprecated(self, offset_types):
+        # GH#30340 use idiomatic naming
+        off = self._get_offset(offset_types)
+
+        ts = Timestamp.now()
+        with tm.assert_produces_warning(FutureWarning):
+            result = off.onOffset(ts)
+
+        expected = off.is_on_offset(ts)
+        assert result == expected
+
+    def test_isAnchored_deprecated(self, offset_types):
+        # GH#30340 use idiomatic naming
+        off = self._get_offset(offset_types)
+
+        with tm.assert_produces_warning(FutureWarning):
+            result = off.isAnchored()
+
+        expected = off.is_anchored()
+        assert result == expected
+
 
 class TestDateOffset(Base):
     def setup_method(self, method):
@@ -645,8 +699,8 @@ def test_constructor(self):
 
         assert (self.d + DateOffset(2)) == datetime(2008, 1, 4)
 
-        assert not DateOffset(2).isAnchored()
-        assert DateOffset(1).isAnchored()
+        assert not DateOffset(2).is_anchored()
+        assert DateOffset(1).is_anchored()
 
         d = datetime(2008, 1, 31)
         assert (d + DateOffset(months=1)) == datetime(2008, 2, 29)
@@ -672,7 +726,7 @@ def setup_method(self, method):
         self.offset2 = BDay(2)
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -734,16 +788,16 @@ def test_roll_date_object(self):
         result = offset.rollforward(dt)
         assert result == datetime(2012, 9, 15)
 
-    def test_onOffset(self):
+    def test_is_on_offset(self):
         tests = [
             (BDay(), datetime(2008, 1, 1), True),
             (BDay(), datetime(2008, 1, 5), False),
         ]
 
         for offset, d, expected in tests:
-            assert_onOffset(offset, d, expected)
+            assert_is_on_offset(offset, d, expected)
 
-    apply_cases = []
+    apply_cases: _ApplyCases = []
     apply_cases.append(
         (
             BDay(),
@@ -914,7 +968,7 @@ def test_constructor_errors(self, start, end, match):
             BusinessHour(start=start, end=end)
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -1229,10 +1283,10 @@ def test_normalize(self, case):
     )
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, cases = case
         for dt, expected in cases.items():
-            assert offset.onOffset(dt) == expected
+            assert offset.is_on_offset(dt) == expected
 
     opening_time_cases = []
     # opening time should be affected by sign of n, not by n's value and
@@ -2280,7 +2334,7 @@ def test_constructor_errors(self):
             CustomBusinessHour(start="14:00:05")
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -2428,7 +2482,7 @@ def test_normalize(self, norm_cases):
         for dt, expected in cases.items():
             assert offset.apply(dt) == expected
 
-    def test_onOffset(self):
+    def test_is_on_offset(self):
         tests = []
 
         tests.append(
@@ -2447,7 +2501,7 @@ def test_onOffset(self):
 
         for offset, cases in tests:
             for dt, expected in cases.items():
-                assert offset.onOffset(dt) == expected
+                assert offset.is_on_offset(dt) == expected
 
     apply_cases = []
     apply_cases.append(
@@ -2558,7 +2612,7 @@ def setup_method(self, method):
         self.offset2 = CDay(2)
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -2627,11 +2681,11 @@ def test_roll_date_object(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, d, expected = case
-        assert_onOffset(offset, d, expected)
+        assert_is_on_offset(offset, d, expected)
 
-    apply_cases = []
+    apply_cases: _ApplyCases = []
     apply_cases.append(
         (
             CDay(),
@@ -2727,8 +2781,8 @@ def test_apply_large_n(self):
 
     def test_apply_corner(self):
         msg = (
-            "Only know how to combine trading day with datetime, datetime64"
-            " or timedelta"
+            "Only know how to combine trading day "
+            "with datetime, datetime64 or timedelta"
         )
         with pytest.raises(ApplyTypeError, match=msg):
             CDay().apply(BMonthEnd())
@@ -2829,7 +2883,7 @@ class TestCustomBusinessMonthEnd(CustomBusinessMonthBase, Base):
     _offset = CBMonthEnd
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -2874,11 +2928,11 @@ def test_roll_date_object(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, d, expected = case
-        assert_onOffset(offset, d, expected)
+        assert_is_on_offset(offset, d, expected)
 
-    apply_cases = []
+    apply_cases: _ApplyCases = []
     apply_cases.append(
         (
             CBMonthEnd(),
@@ -2978,7 +3032,7 @@ class TestCustomBusinessMonthBegin(CustomBusinessMonthBase, Base):
     _offset = CBMonthBegin
 
     def test_different_normalize_equals(self):
-        # GH#21404 changed __eq__ to return False when `normalize` doesnt match
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
         offset = self._offset()
         offset2 = self._offset(normalize=True)
         assert offset != offset2
@@ -3023,11 +3077,11 @@ def test_roll_date_object(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
-    apply_cases = []
+    apply_cases: _ApplyCases = []
     apply_cases.append(
         (
             CBMonthBegin(),
@@ -3140,11 +3194,11 @@ def test_corner(self):
         with pytest.raises(ValueError, match="Day must be"):
             Week(weekday=-1)
 
-    def test_isAnchored(self):
-        assert Week(weekday=0).isAnchored()
-        assert not Week().isAnchored()
-        assert not Week(2, weekday=2).isAnchored()
-        assert not Week(2).isAnchored()
+    def test_is_anchored(self):
+        assert Week(weekday=0).is_anchored()
+        assert not Week().is_anchored()
+        assert not Week(2, weekday=2).is_anchored()
+        assert not Week(2).is_anchored()
 
     offset_cases = []
     # not business week
@@ -3208,7 +3262,7 @@ def test_offset(self, case):
             assert_offset_equal(offset, base, expected)
 
     @pytest.mark.parametrize("weekday", range(7))
-    def test_onOffset(self, weekday):
+    def test_is_on_offset(self, weekday):
         offset = Week(weekday=weekday)
 
         for day in range(1, 8):
@@ -3218,7 +3272,7 @@ def test_onOffset(self, weekday):
                 expected = True
             else:
                 expected = False
-        assert_onOffset(offset, date, expected)
+        assert_is_on_offset(offset, date, expected)
 
 
 class TestWeekOfMonth(Base):
@@ -3315,10 +3369,10 @@ def test_offset(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         week, weekday, dt, expected = case
         offset = WeekOfMonth(week=week, weekday=weekday)
-        assert offset.onOffset(dt) == expected
+        assert offset.is_on_offset(dt) == expected
 
 
 class TestLastWeekOfMonth(Base):
@@ -3392,10 +3446,10 @@ def test_offset(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         weekday, dt, expected = case
         offset = LastWeekOfMonth(weekday=weekday)
-        assert offset.onOffset(dt) == expected
+        assert offset.is_on_offset(dt) == expected
 
 
 class TestSemiMonthEnd(Base):
@@ -3602,9 +3656,9 @@ def test_apply_index(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         dt, expected = case
-        assert_onOffset(SemiMonthEnd(), dt, expected)
+        assert_is_on_offset(SemiMonthEnd(), dt, expected)
 
     @pytest.mark.parametrize("klass", [Series, DatetimeIndex])
     def test_vectorized_offset_addition(self, klass):
@@ -3866,9 +3920,9 @@ def test_apply_index(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         dt, expected = case
-        assert_onOffset(SemiMonthBegin(), dt, expected)
+        assert_is_on_offset(SemiMonthBegin(), dt, expected)
 
     @pytest.mark.parametrize("klass", [Series, DatetimeIndex])
     def test_vectorized_offset_addition(self, klass):
@@ -3951,9 +4005,9 @@ def test_get_offset_name(self):
 
 def test_get_offset():
     with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-        get_offset("gibberish")
+        _get_offset("gibberish")
     with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-        get_offset("QS-JAN-B")
+        _get_offset("QS-JAN-B")
 
     pairs = [
         ("B", BDay()),
@@ -3968,11 +4022,10 @@ def test_get_offset():
     ]
 
     for name, expected in pairs:
-        offset = get_offset(name)
-        assert (
-            offset == expected
-        ), "Expected {name!r} to yield {expected!r} (actual: {offset!r})".format(
-            name=name, expected=expected, offset=offset
+        offset = _get_offset(name)
+        assert offset == expected, (
+            f"Expected {repr(name)} to yield {repr(expected)} "
+            f"(actual: {repr(offset)})"
         )
 
 
@@ -3980,7 +4033,7 @@ def test_get_offset_legacy():
     pairs = [("w@Sat", Week(weekday=5))]
     for name, expected in pairs:
         with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-            get_offset(name)
+            _get_offset(name)
 
 
 class TestOffsetAliases:
@@ -3996,17 +4049,17 @@ def test_alias_equality(self):
     def test_rule_code(self):
         lst = ["M", "MS", "BM", "BMS", "D", "B", "H", "T", "S", "L", "U"]
         for k in lst:
-            assert k == get_offset(k).rule_code
+            assert k == _get_offset(k).rule_code
             # should be cached - this is kind of an internals test...
             assert k in _offset_map
-            assert k == (get_offset(k) * 3).rule_code
+            assert k == (_get_offset(k) * 3).rule_code
 
         suffix_lst = ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"]
         base = "W"
         for v in suffix_lst:
             alias = "-".join([base, v])
-            assert alias == get_offset(alias).rule_code
-            assert alias == (get_offset(alias) * 5).rule_code
+            assert alias == _get_offset(alias).rule_code
+            assert alias == (_get_offset(alias) * 5).rule_code
 
         suffix_lst = [
             "JAN",
@@ -4026,8 +4079,8 @@ def test_rule_code(self):
         for base in base_lst:
             for v in suffix_lst:
                 alias = "-".join([base, v])
-                assert alias == get_offset(alias).rule_code
-                assert alias == (get_offset(alias) * 5).rule_code
+                assert alias == _get_offset(alias).rule_code
+                assert alias == (_get_offset(alias) * 5).rule_code
 
         lst = ["M", "D", "B", "H", "T", "S", "L", "U"]
         for k in lst:
@@ -4080,7 +4133,7 @@ def test_str_for_named_is_name(self):
         names += ["WOM-" + week + day for week in ("1", "2", "3", "4") for day in days]
         _offset_map.clear()
         for name in names:
-            offset = get_offset(name)
+            offset = _get_offset(name)
             assert offset.freqstr == name
 
 
@@ -4170,9 +4223,9 @@ def _test_offset(self, offset_name, offset_n, tstart, expected_utc_offset):
 
     def _make_timestamp(self, string, hrs_offset, tz):
         if hrs_offset >= 0:
-            offset_string = "{hrs:02d}00".format(hrs=hrs_offset)
+            offset_string = f"{hrs_offset:02d}00"
         else:
-            offset_string = "-{hrs:02d}00".format(hrs=-1 * hrs_offset)
+            offset_string = f"-{(hrs_offset * -1):02}00"
         return Timestamp(string + offset_string).tz_convert(tz)
 
     def test_springforward_plural(self):
@@ -4253,7 +4306,7 @@ def test_valid_default_arguments(offset_types):
     cls()
 
 
-@pytest.mark.parametrize("kwd", sorted(list(liboffsets.relativedelta_kwds)))
+@pytest.mark.parametrize("kwd", sorted(liboffsets.relativedelta_kwds))
 def test_valid_month_attributes(kwd, month_classes):
     # GH#18226
     cls = month_classes
@@ -4262,14 +4315,14 @@ def test_valid_month_attributes(kwd, month_classes):
         cls(**{kwd: 3})
 
 
-@pytest.mark.parametrize("kwd", sorted(list(liboffsets.relativedelta_kwds)))
+@pytest.mark.parametrize("kwd", sorted(liboffsets.relativedelta_kwds))
 def test_valid_relativedelta_kwargs(kwd):
     # Check that all the arguments specified in liboffsets.relativedelta_kwds
     # are in fact valid relativedelta keyword args
     DateOffset(**{kwd: 1})
 
 
-@pytest.mark.parametrize("kwd", sorted(list(liboffsets.relativedelta_kwds)))
+@pytest.mark.parametrize("kwd", sorted(liboffsets.relativedelta_kwds))
 def test_valid_tick_attributes(kwd, tick_classes):
     # GH#18226
     cls = tick_classes
@@ -4305,34 +4358,34 @@ def test_tick_normalize_raises(tick_classes):
 
 def test_weeks_onoffset():
     # GH#18510 Week with weekday = None, normalize = False should always
-    # be onOffset
+    # be is_on_offset
     offset = Week(n=2, weekday=None)
     ts = Timestamp("1862-01-13 09:03:34.873477378+0210", tz="Africa/Lusaka")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
     # negative n
     offset = Week(n=2, weekday=None)
     ts = Timestamp("1856-10-24 16:18:36.556360110-0717", tz="Pacific/Easter")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
 
 def test_weekofmonth_onoffset():
     # GH#18864
-    # Make sure that nanoseconds don't trip up onOffset (and with it apply)
+    # Make sure that nanoseconds don't trip up is_on_offset (and with it apply)
     offset = WeekOfMonth(n=2, week=2, weekday=0)
     ts = Timestamp("1916-05-15 01:14:49.583410462+0422", tz="Asia/Qyzylorda")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
     # negative n
     offset = WeekOfMonth(n=-3, week=1, weekday=0)
     ts = Timestamp("1980-12-08 03:38:52.878321185+0500", tz="Asia/Oral")
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     slow = (ts + offset) - offset == ts
     assert fast == slow
 
@@ -4342,12 +4395,21 @@ def test_last_week_of_month_on_offset():
     offset = LastWeekOfMonth(n=4, weekday=6)
     ts = Timestamp("1917-05-27 20:55:27.084284178+0200", tz="Europe/Warsaw")
     slow = (ts + offset) - offset == ts
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     assert fast == slow
 
     # negative n
     offset = LastWeekOfMonth(n=-4, weekday=5)
     ts = Timestamp("2005-08-27 05:01:42.799392561-0500", tz="America/Rainy_River")
     slow = (ts + offset) - offset == ts
-    fast = offset.onOffset(ts)
+    fast = offset.is_on_offset(ts)
     assert fast == slow
+
+
+def test_week_add_invalid():
+    # Week with weekday should raise TypeError and _not_ AttributeError
+    #  when adding invalid offset
+    offset = Week(weekday=1)
+    other = Day()
+    with pytest.raises(TypeError, match="Cannot add"):
+        offset + other
diff --git a/pandas/tests/tseries/offsets/test_offsets_properties.py b/pandas/tests/tseries/offsets/test_offsets_properties.py
index 880ff1f137520..716d3ff3faf1c 100644
--- a/pandas/tests/tseries/offsets/test_offsets_properties.py
+++ b/pandas/tests/tseries/offsets/test_offsets_properties.py
@@ -15,6 +15,7 @@
 import pytest
 
 import pandas as pd
+from pandas import Timestamp
 
 from pandas.tseries.offsets import (
     BMonthBegin,
@@ -36,15 +37,15 @@
 
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
-    min_dt = (pd.Timestamp(1900, 1, 1).to_pydatetime(),)
-    max_dt = (pd.Timestamp(1900, 1, 1).to_pydatetime(),)
+    min_dt = Timestamp(1900, 1, 1).to_pydatetime()
+    max_dt = Timestamp(1900, 1, 1).to_pydatetime()
 
 gen_date_range = st.builds(
     pd.date_range,
     start=st.datetimes(
         # TODO: Choose the min/max values more systematically
-        min_value=pd.Timestamp(1900, 1, 1).to_pydatetime(),
-        max_value=pd.Timestamp(2100, 1, 1).to_pydatetime(),
+        min_value=Timestamp(1900, 1, 1).to_pydatetime(),
+        max_value=Timestamp(2100, 1, 1).to_pydatetime(),
     ),
     periods=st.integers(min_value=2, max_value=100),
     freq=st.sampled_from("Y Q M D H T s ms us ns".split()),
@@ -89,11 +90,11 @@
 @given(gen_random_datetime, gen_yqm_offset)
 def test_on_offset_implementations(dt, offset):
     assume(not offset.normalize)
-    # check that the class-specific implementations of onOffset match
+    # check that the class-specific implementations of is_on_offset match
     # the general case definition:
     #   (dt + offset) - offset == dt
     compare = (dt + offset) - offset
-    assert offset.onOffset(dt) == (compare == dt)
+    assert offset.is_on_offset(dt) == (compare == dt)
 
 
 @pytest.mark.xfail(
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index 98a3631c8e63a..297e5c3178379 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -8,7 +8,7 @@
 import pytest
 
 from pandas import Timedelta, Timestamp
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 from pandas.tseries import offsets
 from pandas.tseries.offsets import Hour, Micro, Milli, Minute, Nano, Second
@@ -284,7 +284,7 @@ def test_tick_equalities(cls):
 
 @pytest.mark.parametrize("cls", tick_classes)
 def test_tick_offset(cls):
-    assert not cls().isAnchored()
+    assert not cls().is_anchored()
 
 
 @pytest.mark.parametrize("cls", tick_classes)
diff --git a/pandas/tests/tseries/offsets/test_yqm_offsets.py b/pandas/tests/tseries/offsets/test_yqm_offsets.py
index 12a524d82fcf5..79a0e0f2c25eb 100644
--- a/pandas/tests/tseries/offsets/test_yqm_offsets.py
+++ b/pandas/tests/tseries/offsets/test_yqm_offsets.py
@@ -23,7 +23,7 @@
     YearEnd,
 )
 
-from .common import assert_offset_equal, assert_onOffset
+from .common import assert_is_on_offset, assert_offset_equal
 from .test_offsets import Base
 
 # --------------------------------------------------------------------
@@ -85,7 +85,7 @@ def test_on_offset(offset):
         if not (m == 11 and d == 31)
     ]
     for date in dates:
-        res = offset.onOffset(date)
+        res = offset.is_on_offset(date)
         slow_version = date == (date + offset) - offset
         assert res == slow_version
 
@@ -247,9 +247,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestBMonthBegin(Base):
@@ -335,9 +335,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestBMonthEnd(Base):
@@ -424,9 +424,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 # --------------------------------------------------------------------
@@ -442,10 +442,10 @@ def test_repr(self):
         expected = "<QuarterBegin: startingMonth=1>"
         assert repr(QuarterBegin(startingMonth=1)) == expected
 
-    def test_isAnchored(self):
-        assert QuarterBegin(startingMonth=1).isAnchored()
-        assert QuarterBegin().isAnchored()
-        assert not QuarterBegin(2, startingMonth=1).isAnchored()
+    def test_is_anchored(self):
+        assert QuarterBegin(startingMonth=1).is_anchored()
+        assert QuarterBegin().is_anchored()
+        assert not QuarterBegin(2, startingMonth=1).is_anchored()
 
     def test_offset_corner_case(self):
         # corner
@@ -552,10 +552,10 @@ def test_repr(self):
         expected = "<QuarterEnd: startingMonth=1>"
         assert repr(QuarterEnd(startingMonth=1)) == expected
 
-    def test_isAnchored(self):
-        assert QuarterEnd(startingMonth=1).isAnchored()
-        assert QuarterEnd().isAnchored()
-        assert not QuarterEnd(2, startingMonth=1).isAnchored()
+    def test_is_anchored(self):
+        assert QuarterEnd(startingMonth=1).is_anchored()
+        assert QuarterEnd().is_anchored()
+        assert not QuarterEnd(2, startingMonth=1).is_anchored()
 
     def test_offset_corner_case(self):
         # corner
@@ -683,9 +683,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestBQuarterBegin(Base):
@@ -699,10 +699,10 @@ def test_repr(self):
         expected = "<BusinessQuarterBegin: startingMonth=1>"
         assert repr(BQuarterBegin(startingMonth=1)) == expected
 
-    def test_isAnchored(self):
-        assert BQuarterBegin(startingMonth=1).isAnchored()
-        assert BQuarterBegin().isAnchored()
-        assert not BQuarterBegin(2, startingMonth=1).isAnchored()
+    def test_is_anchored(self):
+        assert BQuarterBegin(startingMonth=1).is_anchored()
+        assert BQuarterBegin().is_anchored()
+        assert not BQuarterBegin(2, startingMonth=1).is_anchored()
 
     def test_offset_corner_case(self):
         # corner
@@ -824,10 +824,10 @@ def test_repr(self):
         expected = "<BusinessQuarterEnd: startingMonth=1>"
         assert repr(BQuarterEnd(startingMonth=1)) == expected
 
-    def test_isAnchored(self):
-        assert BQuarterEnd(startingMonth=1).isAnchored()
-        assert BQuarterEnd().isAnchored()
-        assert not BQuarterEnd(2, startingMonth=1).isAnchored()
+    def test_is_anchored(self):
+        assert BQuarterEnd(startingMonth=1).is_anchored()
+        assert BQuarterEnd().is_anchored()
+        assert not BQuarterEnd(2, startingMonth=1).is_anchored()
 
     def test_offset_corner_case(self):
         # corner
@@ -951,9 +951,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 # --------------------------------------------------------------------
@@ -1109,9 +1109,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestYearEnd(Base):
@@ -1186,9 +1186,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestYearEndDiffMonth(Base):
@@ -1258,9 +1258,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestBYearBegin(Base):
@@ -1404,9 +1404,9 @@ def test_offset(self, case):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
 
 
 class TestBYearEndLagged(Base):
@@ -1459,6 +1459,6 @@ def test_roll(self):
     ]
 
     @pytest.mark.parametrize("case", on_offset_cases)
-    def test_onOffset(self, case):
+    def test_is_on_offset(self, case):
         offset, dt, expected = case
-        assert_onOffset(offset, dt, expected)
+        assert_is_on_offset(offset, dt, expected)
diff --git a/pandas/tests/tslibs/test_array_to_datetime.py b/pandas/tests/tslibs/test_array_to_datetime.py
index 5cf2165993cd7..a40fcd725d604 100644
--- a/pandas/tests/tslibs/test_array_to_datetime.py
+++ b/pandas/tests/tslibs/test_array_to_datetime.py
@@ -9,7 +9,7 @@
 from pandas.compat.numpy import np_array_datetime64_compat
 
 from pandas import Timestamp
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
index 6c30e2b6c7a1c..96c2d6bbd8106 100644
--- a/pandas/tests/tslibs/test_conversion.py
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -8,7 +8,7 @@
 from pandas._libs.tslibs import conversion, timezones, tzconversion
 
 from pandas import Timestamp, date_range
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def _compare_utc_to_local(tz_didx):
@@ -72,6 +72,15 @@ def test_length_zero_copy(dtype, copy):
     assert result.base is (None if copy else arr)
 
 
+def test_ensure_datetime64ns_bigendian():
+    # GH#29684
+    arr = np.array([np.datetime64(1, "ms")], dtype=">M8[ms]")
+    result = conversion.ensure_datetime64ns(arr)
+
+    expected = np.array([np.datetime64(1, "ms")], dtype="M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
 class SubDatetime(datetime):
     pass
 
diff --git a/pandas/tests/tslibs/test_fields.py b/pandas/tests/tslibs/test_fields.py
index cd729956a027c..943f4207df543 100644
--- a/pandas/tests/tslibs/test_fields.py
+++ b/pandas/tests/tslibs/test_fields.py
@@ -2,7 +2,7 @@
 
 from pandas._libs.tslibs import fields
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_fields_readonly():
diff --git a/pandas/tests/tslibs/test_parse_iso8601.py b/pandas/tests/tslibs/test_parse_iso8601.py
index a6e7aee46b485..a58f227c20c7f 100644
--- a/pandas/tests/tslibs/test_parse_iso8601.py
+++ b/pandas/tests/tslibs/test_parse_iso8601.py
@@ -59,9 +59,7 @@ def test_parsers_iso8601_invalid(date_str):
 
 def test_parsers_iso8601_invalid_offset_invalid():
     date_str = "2001-01-01 12-34-56"
-    msg = "Timezone hours offset out of range " 'in datetime string "{s}"'.format(
-        s=date_str
-    )
+    msg = f'Timezone hours offset out of range in datetime string "{date_str}"'
 
     with pytest.raises(ValueError, match=msg):
         tslib._test_parse_iso8601(date_str)
diff --git a/pandas/tests/tslibs/test_parsing.py b/pandas/tests/tslibs/test_parsing.py
index 126a1bd12ad59..c452d5b12ce01 100644
--- a/pandas/tests/tslibs/test_parsing.py
+++ b/pandas/tests/tslibs/test_parsing.py
@@ -11,27 +11,31 @@
 from pandas._libs.tslibs.parsing import parse_time_string
 import pandas.util._test_decorators as td
 
-from pandas.util import testing as tm
+import pandas._testing as tm
 
 
 def test_parse_time_string():
-    (date, parsed, reso) = parse_time_string("4Q1984")
-    (date_lower, parsed_lower, reso_lower) = parse_time_string("4q1984")
+    (parsed, reso) = parse_time_string("4Q1984")
+    (parsed_lower, reso_lower) = parse_time_string("4q1984")
 
-    assert date == date_lower
     assert reso == reso_lower
     assert parsed == parsed_lower
 
 
+def test_parse_time_string_invalid_type():
+    # Raise on invalid input, don't just return it
+    with pytest.raises(TypeError):
+        parse_time_string((4, 5))
+
+
 @pytest.mark.parametrize(
     "dashed,normal", [("1988-Q2", "1988Q2"), ("2Q-1988", "2Q1988")]
 )
 def test_parse_time_quarter_with_dash(dashed, normal):
     # see gh-9688
-    (date_dash, parsed_dash, reso_dash) = parse_time_string(dashed)
-    (date, parsed, reso) = parse_time_string(normal)
+    (parsed_dash, reso_dash) = parse_time_string(dashed)
+    (parsed, reso) = parse_time_string(normal)
 
-    assert date_dash == date
     assert parsed_dash == parsed
     assert reso_dash == reso
 
@@ -100,7 +104,7 @@ def test_parsers_quarterly_with_freq_error(date_str, kwargs, msg):
     ],
 )
 def test_parsers_quarterly_with_freq(date_str, freq, expected):
-    result, _, _ = parsing.parse_time_string(date_str, freq=freq)
+    result, _ = parsing.parse_time_string(date_str, freq=freq)
     assert result == expected
 
 
@@ -125,7 +129,7 @@ def test_parsers_quarter_invalid(date_str):
     [("201101", datetime(2011, 1, 1, 0, 0)), ("200005", datetime(2000, 5, 1, 0, 0))],
 )
 def test_parsers_month_freq(date_str, expected):
-    result, _, _ = parsing.parse_time_string(date_str, freq="M")
+    result, _ = parsing.parse_time_string(date_str, freq="M")
     assert result == expected
 
 
@@ -209,3 +213,13 @@ def test_try_parse_dates():
 
     expected = np.array([parse(d, dayfirst=True) for d in arr])
     tm.assert_numpy_array_equal(result, expected)
+
+
+def test_parse_time_string_check_instance_type_raise_exception():
+    # issue 20684
+    with pytest.raises(TypeError):
+        parse_time_string((1, 2, 3))
+
+    result = parse_time_string("2019")
+    expected = (datetime(2019, 1, 1), "year")
+    assert result == expected
diff --git a/pandas/tests/tslibs/test_timedeltas.py b/pandas/tests/tslibs/test_timedeltas.py
index d4bd7c2d5486c..86d5cc749b5e1 100644
--- a/pandas/tests/tslibs/test_timedeltas.py
+++ b/pandas/tests/tslibs/test_timedeltas.py
@@ -3,8 +3,7 @@
 
 from pandas._libs.tslibs.timedeltas import delta_to_nanoseconds
 
-import pandas as pd
-from pandas import Timedelta
+from pandas import Timedelta, offsets
 
 
 @pytest.mark.parametrize(
@@ -13,7 +12,7 @@
         (np.timedelta64(14, "D"), 14 * 24 * 3600 * 1e9),
         (Timedelta(minutes=-7), -7 * 60 * 1e9),
         (Timedelta(minutes=-7).to_pytimedelta(), -7 * 60 * 1e9),
-        (pd.offsets.Nano(125), 125),
+        (offsets.Nano(125), 125),
         (1, 1),
         (np.int64(2), 2),
         (np.int32(3), 3),
diff --git a/pandas/tests/util/test_assert_almost_equal.py b/pandas/tests/util/test_assert_almost_equal.py
index 5a677d629e72d..b8048891e4876 100644
--- a/pandas/tests/util/test_assert_almost_equal.py
+++ b/pandas/tests/util/test_assert_almost_equal.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import DataFrame, Index, Series, Timestamp
-from pandas.util.testing import assert_almost_equal
+import pandas._testing as tm
 
 
 def _assert_almost_equal_both(a, b, **kwargs):
@@ -18,10 +18,10 @@ def _assert_almost_equal_both(a, b, **kwargs):
     b : object
         The second object to compare.
     kwargs : dict
-        The arguments passed to `assert_almost_equal`.
+        The arguments passed to `tm.assert_almost_equal`.
     """
-    assert_almost_equal(a, b, **kwargs)
-    assert_almost_equal(b, a, **kwargs)
+    tm.assert_almost_equal(a, b, **kwargs)
+    tm.assert_almost_equal(b, a, **kwargs)
 
 
 def _assert_not_almost_equal(a, b, **kwargs):
@@ -35,13 +35,11 @@ def _assert_not_almost_equal(a, b, **kwargs):
     b : object
         The second object to compare.
     kwargs : dict
-        The arguments passed to `assert_almost_equal`.
+        The arguments passed to `tm.assert_almost_equal`.
     """
     try:
-        assert_almost_equal(a, b, **kwargs)
-        msg = (
-            "{a} and {b} were approximately equal when they shouldn't have been"
-        ).format(a=a, b=b)
+        tm.assert_almost_equal(a, b, **kwargs)
+        msg = f"{a} and {b} were approximately equal when they shouldn't have been"
         pytest.fail(msg=msg)
     except AssertionError:
         pass
@@ -240,7 +238,7 @@ def test_assert_almost_equal_value_mismatch():
     msg = "expected 2\\.00000 but got 1\\.00000, with decimal 5"
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(1, 2)
+        tm.assert_almost_equal(1, 2)
 
 
 @pytest.mark.parametrize(
@@ -248,16 +246,15 @@ def test_assert_almost_equal_value_mismatch():
     [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
 )
 def test_assert_almost_equal_class_mismatch(a, b, klass1, klass2):
-    msg = """numpy array are different
+
+    msg = f"""numpy array are different
 
 numpy array classes are different
 \\[left\\]:  {klass1}
-\\[right\\]: {klass2}""".format(
-        klass1=klass1, klass2=klass2
-    )
+\\[right\\]: {klass2}"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(a, b)
+        tm.assert_almost_equal(a, b)
 
 
 def test_assert_almost_equal_value_mismatch1():
@@ -268,7 +265,7 @@ def test_assert_almost_equal_value_mismatch1():
 \\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+        tm.assert_almost_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
 
 
 def test_assert_almost_equal_value_mismatch2():
@@ -279,7 +276,7 @@ def test_assert_almost_equal_value_mismatch2():
 \\[right\\]: \\[1, 3\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(np.array([1, 2]), np.array([1, 3]))
+        tm.assert_almost_equal(np.array([1, 2]), np.array([1, 3]))
 
 
 def test_assert_almost_equal_value_mismatch3():
@@ -290,7 +287,7 @@ def test_assert_almost_equal_value_mismatch3():
 \\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(
+        tm.assert_almost_equal(
             np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
         )
 
@@ -303,7 +300,7 @@ def test_assert_almost_equal_value_mismatch4():
 \\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
+        tm.assert_almost_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
 
 
 def test_assert_almost_equal_shape_mismatch_override():
@@ -313,7 +310,7 @@ def test_assert_almost_equal_shape_mismatch_override():
 \\[left\\]:  \\(2L*,\\)
 \\[right\\]: \\(3L*,\\)"""
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+        tm.assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
 
 
 def test_assert_almost_equal_unicode():
@@ -325,7 +322,7 @@ def test_assert_almost_equal_unicode():
 \\[right\\]: \\[á, à, å\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
+        tm.assert_almost_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
 
 
 def test_assert_almost_equal_timestamp():
@@ -339,7 +336,7 @@ def test_assert_almost_equal_timestamp():
 \\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal(a, b)
+        tm.assert_almost_equal(a, b)
 
 
 def test_assert_almost_equal_iterable_length_mismatch():
@@ -350,7 +347,7 @@ def test_assert_almost_equal_iterable_length_mismatch():
 \\[right\\]: 3"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal([1, 2], [3, 4, 5])
+        tm.assert_almost_equal([1, 2], [3, 4, 5])
 
 
 def test_assert_almost_equal_iterable_values_mismatch():
@@ -361,4 +358,4 @@ def test_assert_almost_equal_iterable_values_mismatch():
 \\[right\\]: \\[1, 3\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_almost_equal([1, 2], [1, 3])
+        tm.assert_almost_equal([1, 2], [1, 3])
diff --git a/pandas/tests/util/test_assert_categorical_equal.py b/pandas/tests/util/test_assert_categorical_equal.py
index d51dd8b36751a..8957e7a172666 100644
--- a/pandas/tests/util/test_assert_categorical_equal.py
+++ b/pandas/tests/util/test_assert_categorical_equal.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import Categorical
-from pandas.util.testing import assert_categorical_equal
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -9,7 +9,7 @@
     [Categorical([1, 2, 3, 4]), Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4, 5])],
 )
 def test_categorical_equal(c):
-    assert_categorical_equal(c, c)
+    tm.assert_categorical_equal(c, c)
 
 
 @pytest.mark.parametrize("check_category_order", [True, False])
@@ -25,9 +25,9 @@ def test_categorical_equal_order_mismatch(check_category_order):
 \\[left\\]:  Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)
 \\[right\\]: Int64Index\\(\\[4, 3, 2, 1\\], dtype='int64'\\)"""
         with pytest.raises(AssertionError, match=msg):
-            assert_categorical_equal(c1, c2, **kwargs)
+            tm.assert_categorical_equal(c1, c2, **kwargs)
     else:
-        assert_categorical_equal(c1, c2, **kwargs)
+        tm.assert_categorical_equal(c1, c2, **kwargs)
 
 
 def test_categorical_equal_categories_mismatch():
@@ -41,7 +41,7 @@ def test_categorical_equal_categories_mismatch():
     c2 = Categorical([1, 2, 3, 5])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_categorical_equal(c1, c2)
+        tm.assert_categorical_equal(c1, c2)
 
 
 def test_categorical_equal_codes_mismatch():
@@ -56,7 +56,7 @@ def test_categorical_equal_codes_mismatch():
     c2 = Categorical([1, 2, 3, 4], categories=categories)
 
     with pytest.raises(AssertionError, match=msg):
-        assert_categorical_equal(c1, c2)
+        tm.assert_categorical_equal(c1, c2)
 
 
 def test_categorical_equal_ordered_mismatch():
@@ -71,22 +71,20 @@ def test_categorical_equal_ordered_mismatch():
     c2 = Categorical(data, ordered=True)
 
     with pytest.raises(AssertionError, match=msg):
-        assert_categorical_equal(c1, c2)
+        tm.assert_categorical_equal(c1, c2)
 
 
 @pytest.mark.parametrize("obj", ["index", "foo", "pandas"])
 def test_categorical_equal_object_override(obj):
     data = [1, 2, 3, 4]
-    msg = """{obj} are different
+    msg = f"""{obj} are different
 
 Attribute "ordered" are different
 \\[left\\]:  False
-\\[right\\]: True""".format(
-        obj=obj
-    )
+\\[right\\]: True"""
 
     c1 = Categorical(data, ordered=False)
     c2 = Categorical(data, ordered=True)
 
     with pytest.raises(AssertionError, match=msg):
-        assert_categorical_equal(c1, c2, obj=obj)
+        tm.assert_categorical_equal(c1, c2, obj=obj)
diff --git a/pandas/tests/util/test_assert_extension_array_equal.py b/pandas/tests/util/test_assert_extension_array_equal.py
index 43a474da2bbda..0547323b882f6 100644
--- a/pandas/tests/util/test_assert_extension_array_equal.py
+++ b/pandas/tests/util/test_assert_extension_array_equal.py
@@ -1,8 +1,8 @@
 import numpy as np
 import pytest
 
+import pandas._testing as tm
 from pandas.core.arrays.sparse import SparseArray
-from pandas.util.testing import assert_extension_array_equal
 
 
 @pytest.mark.parametrize(
@@ -27,9 +27,9 @@ def test_assert_extension_array_equal_not_exact(kwargs):
 \\[right\\]: \\[-0\\.17387645482.*, 0\\.341414801642.*\\]"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_extension_array_equal(arr1, arr2, **kwargs)
+            tm.assert_extension_array_equal(arr1, arr2, **kwargs)
     else:
-        assert_extension_array_equal(arr1, arr2, **kwargs)
+        tm.assert_extension_array_equal(arr1, arr2, **kwargs)
 
 
 @pytest.mark.parametrize(
@@ -50,9 +50,9 @@ def test_assert_extension_array_equal_less_precise(check_less_precise):
 \\[right\\]: \\[0\\.5, 0\\.123457\\]"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_extension_array_equal(arr1, arr2, **kwargs)
+            tm.assert_extension_array_equal(arr1, arr2, **kwargs)
     else:
-        assert_extension_array_equal(arr1, arr2, **kwargs)
+        tm.assert_extension_array_equal(arr1, arr2, **kwargs)
 
 
 def test_assert_extension_array_equal_dtype_mismatch(check_dtype):
@@ -71,9 +71,9 @@ def test_assert_extension_array_equal_dtype_mismatch(check_dtype):
 \\[right\\]: Sparse\\[int32, 0\\]"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_extension_array_equal(arr1, arr2, **kwargs)
+            tm.assert_extension_array_equal(arr1, arr2, **kwargs)
     else:
-        assert_extension_array_equal(arr1, arr2, **kwargs)
+        tm.assert_extension_array_equal(arr1, arr2, **kwargs)
 
 
 def test_assert_extension_array_equal_missing_values():
@@ -88,7 +88,7 @@ def test_assert_extension_array_equal_missing_values():
 \\[right\\]: \\[True, False, False, False\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_extension_array_equal(arr1, arr2)
+        tm.assert_extension_array_equal(arr1, arr2)
 
 
 @pytest.mark.parametrize("side", ["left", "right"])
@@ -96,7 +96,7 @@ def test_assert_extension_array_equal_non_extension_array(side):
     numpy_array = np.arange(5)
     extension_array = SparseArray(numpy_array)
 
-    msg = "{side} is not an ExtensionArray".format(side=side)
+    msg = f"{side} is not an ExtensionArray"
     args = (
         (numpy_array, extension_array)
         if side == "left"
@@ -104,4 +104,4 @@ def test_assert_extension_array_equal_non_extension_array(side):
     )
 
     with pytest.raises(AssertionError, match=msg):
-        assert_extension_array_equal(*args)
+        tm.assert_extension_array_equal(*args)
diff --git a/pandas/tests/util/test_assert_frame_equal.py b/pandas/tests/util/test_assert_frame_equal.py
index 9571e8027ccf7..3090343ba2fd9 100644
--- a/pandas/tests/util/test_assert_frame_equal.py
+++ b/pandas/tests/util/test_assert_frame_equal.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import DataFrame
-from pandas.util.testing import assert_frame_equal
+import pandas._testing as tm
 
 
 @pytest.fixture(params=[True, False])
@@ -27,10 +27,10 @@ def _assert_frame_equal_both(a, b, **kwargs):
     b : DataFrame
         The second DataFrame to compare.
     kwargs : dict
-        The arguments passed to `assert_frame_equal`.
+        The arguments passed to `tm.assert_frame_equal`.
     """
-    assert_frame_equal(a, b, **kwargs)
-    assert_frame_equal(b, a, **kwargs)
+    tm.assert_frame_equal(a, b, **kwargs)
+    tm.assert_frame_equal(b, a, **kwargs)
 
 
 def _assert_not_frame_equal(a, b, **kwargs):
@@ -44,15 +44,11 @@ def _assert_not_frame_equal(a, b, **kwargs):
     b : DataFrame
         The second DataFrame to compare.
     kwargs : dict
-        The arguments passed to `assert_frame_equal`.
+        The arguments passed to `tm.assert_frame_equal`.
     """
-    try:
-        assert_frame_equal(a, b, **kwargs)
-        msg = "The two DataFrames were equal when they shouldn't have been"
-
-        pytest.fail(msg=msg)
-    except AssertionError:
-        pass
+    msg = "The two DataFrames were equal when they shouldn't have been"
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(a, b, **kwargs)
 
 
 def _assert_not_frame_equal_both(a, b, **kwargs):
@@ -68,7 +64,7 @@ def _assert_not_frame_equal_both(a, b, **kwargs):
     b : DataFrame
         The second DataFrame to compare.
     kwargs : dict
-        The arguments passed to `assert_frame_equal`.
+        The arguments passed to `tm.assert_frame_equal`.
     """
     _assert_not_frame_equal(a, b, **kwargs)
     _assert_not_frame_equal(b, a, **kwargs)
@@ -80,9 +76,9 @@ def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
     df2 = DataFrame({"A": [3, 2, 1], "B": [6, 5, 4]}, index=["c", "b", "a"])
 
     if not check_like:  # Do not ignore row-column orderings.
-        msg = "{obj}.index are different".format(obj=obj_fixture)
+        msg = f"{obj_fixture}.index are different"
         with pytest.raises(AssertionError, match=msg):
-            assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+            tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
     else:
         _assert_frame_equal_both(df1, df2, check_like=check_like, obj=obj_fixture)
 
@@ -95,10 +91,10 @@ def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
     ],
 )
 def test_frame_equal_shape_mismatch(df1, df2, obj_fixture):
-    msg = "{obj} are different".format(obj=obj_fixture)
+    msg = f"{obj_fixture} are different"
 
     with pytest.raises(AssertionError, match=msg):
-        assert_frame_equal(df1, df2, obj=obj_fixture)
+        tm.assert_frame_equal(df1, df2, obj=obj_fixture)
 
 
 @pytest.mark.parametrize(
@@ -127,9 +123,9 @@ def test_frame_equal_index_dtype_mismatch(df1, df2, msg, check_index_type):
 
     if check_index_type:
         with pytest.raises(AssertionError, match=msg):
-            assert_frame_equal(df1, df2, **kwargs)
+            tm.assert_frame_equal(df1, df2, **kwargs)
     else:
-        assert_frame_equal(df1, df2, **kwargs)
+        tm.assert_frame_equal(df1, df2, **kwargs)
 
 
 def test_empty_dtypes(check_dtype):
@@ -141,59 +137,54 @@ def test_empty_dtypes(check_dtype):
     df1["col1"] = df1["col1"].astype("int64")
 
     if check_dtype:
-        msg = "Attributes are different"
+        msg = r"Attributes of DataFrame\..* are different"
         with pytest.raises(AssertionError, match=msg):
-            assert_frame_equal(df1, df2, **kwargs)
+            tm.assert_frame_equal(df1, df2, **kwargs)
     else:
-        assert_frame_equal(df1, df2, **kwargs)
+        tm.assert_frame_equal(df1, df2, **kwargs)
 
 
 def test_frame_equal_index_mismatch(obj_fixture):
-    msg = """{obj}\\.index are different
+    msg = f"""{obj_fixture}\\.index are different
 
-{obj}\\.index values are different \\(33\\.33333 %\\)
+{obj_fixture}\\.index values are different \\(33\\.33333 %\\)
 \\[left\\]:  Index\\(\\['a', 'b', 'c'\\], dtype='object'\\)
-\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)""".format(
-        obj=obj_fixture
-    )
+\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)"""
 
     df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
     df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "d"])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_frame_equal(df1, df2, obj=obj_fixture)
+        tm.assert_frame_equal(df1, df2, obj=obj_fixture)
 
 
 def test_frame_equal_columns_mismatch(obj_fixture):
-    msg = """{obj}\\.columns are different
+    msg = f"""{obj_fixture}\\.columns are different
 
-{obj}\\.columns values are different \\(50\\.0 %\\)
+{obj_fixture}\\.columns values are different \\(50\\.0 %\\)
 \\[left\\]:  Index\\(\\['A', 'B'\\], dtype='object'\\)
-\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)""".format(
-        obj=obj_fixture
-    )
+\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)"""
 
     df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
     df2 = DataFrame({"A": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_frame_equal(df1, df2, obj=obj_fixture)
+        tm.assert_frame_equal(df1, df2, obj=obj_fixture)
 
 
 def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
-    msg = """{obj}\\.iloc\\[:, 1\\] are different
+    obj = obj_fixture
+    msg = f"""{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
 
-{obj}\\.iloc\\[:, 1\\] values are different \\(33\\.33333 %\\)
+{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) values are different \\(33\\.33333 %\\)
 \\[left\\]:  \\[4, 5, 6\\]
-\\[right\\]: \\[4, 5, 7\\]""".format(
-        obj=obj_fixture
-    )
+\\[right\\]: \\[4, 5, 7\\]"""
 
     df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
     df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 7]})
 
     with pytest.raises(AssertionError, match=msg):
-        assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
 
 
 @pytest.mark.parametrize(
@@ -202,18 +193,18 @@ def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
         (
             DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
             DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "e̊"]}),
-            """{obj}\\.iloc\\[:, 1\\] are different
+            """{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) are different
 
-{obj}\\.iloc\\[:, 1\\] values are different \\(33\\.33333 %\\)
+{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) values are different \\(33\\.33333 %\\)
 \\[left\\]:  \\[é, è, ë\\]
 \\[right\\]: \\[é, è, e̊\\]""",
         ),
         (
             DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
             DataFrame({"A": ["a", "a", "a"], "E": ["e", "e", "e"]}),
-            """{obj}\\.iloc\\[:, 0\\] are different
+            """{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) are different
 
-{obj}\\.iloc\\[:, 0\\] values are different \\(100\\.0 %\\)
+{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) values are different \\(100\\.0 %\\)
 \\[left\\]:  \\[á, à, ä\\]
 \\[right\\]: \\[a, a, a\\]""",
         ),
@@ -222,8 +213,8 @@ def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
 def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
     # see gh-20503
     #
-    # Test ensures that `assert_frame_equals` raises the right exception
+    # Test ensures that `tm.assert_frame_equals` raises the right exception
     # when comparing DataFrames containing differing unicode objects.
     msg = msg.format(obj=obj_fixture)
     with pytest.raises(AssertionError, match=msg):
-        assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
diff --git a/pandas/tests/util/test_assert_index_equal.py b/pandas/tests/util/test_assert_index_equal.py
index 270f765caebd0..bbbeebcec2569 100644
--- a/pandas/tests/util/test_assert_index_equal.py
+++ b/pandas/tests/util/test_assert_index_equal.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import Categorical, Index, MultiIndex, NaT
-from pandas.util.testing import assert_index_equal
+import pandas._testing as tm
 
 
 def test_index_equal_levels_mismatch():
@@ -20,7 +20,7 @@ def test_index_equal_levels_mismatch():
     idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, exact=False)
+        tm.assert_index_equal(idx1, idx2, exact=False)
 
 
 def test_index_equal_values_mismatch(check_exact):
@@ -34,7 +34,7 @@ def test_index_equal_values_mismatch(check_exact):
     idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, check_exact=check_exact)
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
 
 
 def test_index_equal_length_mismatch(check_exact):
@@ -48,7 +48,7 @@ def test_index_equal_length_mismatch(check_exact):
     idx2 = Index([1, 2, 3, 4])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, check_exact=check_exact)
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
 
 
 def test_index_equal_class_mismatch(check_exact):
@@ -62,7 +62,7 @@ def test_index_equal_class_mismatch(check_exact):
     idx2 = Index([1, 2, 3.0])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, exact=True, check_exact=check_exact)
+        tm.assert_index_equal(idx1, idx2, exact=True, check_exact=check_exact)
 
 
 def test_index_equal_values_close(check_exact):
@@ -77,9 +77,9 @@ def test_index_equal_values_close(check_exact):
 \\[right\\]: Float64Index\\(\\[1.0, 2.0, 3.0000000001\\], dtype='float64'\\)"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_index_equal(idx1, idx2, check_exact=check_exact)
+            tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
     else:
-        assert_index_equal(idx1, idx2, check_exact=check_exact)
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
 
 
 def test_index_equal_values_less_close(check_exact, check_less_precise):
@@ -95,9 +95,9 @@ def test_index_equal_values_less_close(check_exact, check_less_precise):
 \\[right\\]: Float64Index\\(\\[1.0, 2.0, 3.0001\\], dtype='float64'\\)"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_index_equal(idx1, idx2, **kwargs)
+            tm.assert_index_equal(idx1, idx2, **kwargs)
     else:
-        assert_index_equal(idx1, idx2, **kwargs)
+        tm.assert_index_equal(idx1, idx2, **kwargs)
 
 
 def test_index_equal_values_too_far(check_exact, check_less_precise):
@@ -112,7 +112,7 @@ def test_index_equal_values_too_far(check_exact, check_less_precise):
 \\[right\\]: Int64Index\\(\\[1, 2, 4\\], dtype='int64'\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, **kwargs)
+        tm.assert_index_equal(idx1, idx2, **kwargs)
 
 
 def test_index_equal_level_values_mismatch(check_exact, check_less_precise):
@@ -127,7 +127,7 @@ def test_index_equal_level_values_mismatch(check_exact, check_less_precise):
 \\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_index_equal(idx1, idx2, **kwargs)
+        tm.assert_index_equal(idx1, idx2, **kwargs)
 
 
 @pytest.mark.parametrize(
@@ -135,24 +135,23 @@ def test_index_equal_level_values_mismatch(check_exact, check_less_precise):
     [(None, "x"), ("x", "x"), (np.nan, np.nan), (NaT, NaT), (np.nan, NaT)],
 )
 def test_index_equal_names(name1, name2):
-    msg = """Index are different
-
-Attribute "names" are different
-\\[left\\]:  \\[{name1}\\]
-\\[right\\]: \\[{name2}\\]"""
 
     idx1 = Index([1, 2, 3], name=name1)
     idx2 = Index([1, 2, 3], name=name2)
 
     if name1 == name2 or name1 is name2:
-        assert_index_equal(idx1, idx2)
+        tm.assert_index_equal(idx1, idx2)
     else:
         name1 = "'x'" if name1 == "x" else name1
         name2 = "'x'" if name2 == "x" else name2
-        msg = msg.format(name1=name1, name2=name2)
+        msg = f"""Index are different
+
+Attribute "names" are different
+\\[left\\]:  \\[{name1}\\]
+\\[right\\]: \\[{name2}\\]"""
 
         with pytest.raises(AssertionError, match=msg):
-            assert_index_equal(idx1, idx2)
+            tm.assert_index_equal(idx1, idx2)
 
 
 def test_index_equal_category_mismatch(check_categorical):
@@ -168,6 +167,6 @@ def test_index_equal_category_mismatch(check_categorical):
 
     if check_categorical:
         with pytest.raises(AssertionError, match=msg):
-            assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+            tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
     else:
-        assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+        tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
diff --git a/pandas/tests/util/test_assert_interval_array_equal.py b/pandas/tests/util/test_assert_interval_array_equal.py
index e4435b5f008e8..96f2973a1528c 100644
--- a/pandas/tests/util/test_assert_interval_array_equal.py
+++ b/pandas/tests/util/test_assert_interval_array_equal.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import interval_range
-from pandas.util.testing import assert_interval_array_equal
+import pandas._testing as tm
 
 
 @pytest.mark.parametrize(
@@ -14,7 +14,7 @@
 )
 def test_interval_array_equal(kwargs):
     arr = interval_range(**kwargs).values
-    assert_interval_array_equal(arr, arr)
+    tm.assert_interval_array_equal(arr, arr)
 
 
 def test_interval_array_equal_closed_mismatch():
@@ -30,7 +30,7 @@ def test_interval_array_equal_closed_mismatch():
 \\[right\\]: right"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_interval_array_equal(arr1, arr2)
+        tm.assert_interval_array_equal(arr1, arr2)
 
 
 def test_interval_array_equal_periods_mismatch():
@@ -46,7 +46,7 @@ def test_interval_array_equal_periods_mismatch():
 \\[right\\]: 6, Int64Index\\(\\[0, 1, 2, 3, 4, 5\\], dtype='int64'\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_interval_array_equal(arr1, arr2)
+        tm.assert_interval_array_equal(arr1, arr2)
 
 
 def test_interval_array_equal_end_mismatch():
@@ -62,7 +62,7 @@ def test_interval_array_equal_end_mismatch():
 \\[right\\]: Int64Index\\(\\[0, 4, 8, 12, 16\\], dtype='int64'\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_interval_array_equal(arr1, arr2)
+        tm.assert_interval_array_equal(arr1, arr2)
 
 
 def test_interval_array_equal_start_mismatch():
@@ -78,4 +78,4 @@ def test_interval_array_equal_start_mismatch():
 \\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_interval_array_equal(arr1, arr2)
+        tm.assert_interval_array_equal(arr1, arr2)
diff --git a/pandas/tests/util/test_assert_numpy_array_equal.py b/pandas/tests/util/test_assert_numpy_array_equal.py
index 59f77d18a8929..c8ae9ebdd8651 100644
--- a/pandas/tests/util/test_assert_numpy_array_equal.py
+++ b/pandas/tests/util/test_assert_numpy_array_equal.py
@@ -2,7 +2,7 @@
 import pytest
 
 from pandas import Timestamp
-from pandas.util.testing import assert_numpy_array_equal
+import pandas._testing as tm
 
 
 def test_assert_numpy_array_equal_shape_mismatch():
@@ -13,14 +13,14 @@ def test_assert_numpy_array_equal_shape_mismatch():
 \\[right\\]: \\(3L*,\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]))
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]))
 
 
 def test_assert_numpy_array_equal_bad_type():
     expected = "Expected type"
 
     with pytest.raises(AssertionError, match=expected):
-        assert_numpy_array_equal(1, 2)
+        tm.assert_numpy_array_equal(1, 2)
 
 
 @pytest.mark.parametrize(
@@ -28,16 +28,14 @@ def test_assert_numpy_array_equal_bad_type():
     [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
 )
 def test_assert_numpy_array_equal_class_mismatch(a, b, klass1, klass2):
-    msg = """numpy array are different
+    msg = f"""numpy array are different
 
 numpy array classes are different
 \\[left\\]:  {klass1}
-\\[right\\]: {klass2}""".format(
-        klass1=klass1, klass2=klass2
-    )
+\\[right\\]: {klass2}"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(a, b)
+        tm.assert_numpy_array_equal(a, b)
 
 
 def test_assert_numpy_array_equal_value_mismatch1():
@@ -48,7 +46,7 @@ def test_assert_numpy_array_equal_value_mismatch1():
 \\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+        tm.assert_numpy_array_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
 
 
 def test_assert_numpy_array_equal_value_mismatch2():
@@ -59,7 +57,7 @@ def test_assert_numpy_array_equal_value_mismatch2():
 \\[right\\]: \\[1, 3\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([1, 2]), np.array([1, 3]))
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([1, 3]))
 
 
 def test_assert_numpy_array_equal_value_mismatch3():
@@ -70,7 +68,7 @@ def test_assert_numpy_array_equal_value_mismatch3():
 \\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(
+        tm.assert_numpy_array_equal(
             np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
         )
 
@@ -83,7 +81,7 @@ def test_assert_numpy_array_equal_value_mismatch4():
 \\[right\\]: \\[1\\.1, 2.0\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([1.1, 2.000001]), np.array([1.1, 2.0]))
+        tm.assert_numpy_array_equal(np.array([1.1, 2.000001]), np.array([1.1, 2.0]))
 
 
 def test_assert_numpy_array_equal_value_mismatch5():
@@ -94,7 +92,7 @@ def test_assert_numpy_array_equal_value_mismatch5():
 \\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(
+        tm.assert_numpy_array_equal(
             np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
         )
 
@@ -107,7 +105,9 @@ def test_assert_numpy_array_equal_value_mismatch6():
 \\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
+        tm.assert_numpy_array_equal(
+            np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]])
+        )
 
 
 def test_assert_numpy_array_equal_shape_mismatch_override():
@@ -118,13 +118,13 @@ def test_assert_numpy_array_equal_shape_mismatch_override():
 \\[right\\]: \\(3L*,\\)"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
 
 
 def test_numpy_array_equal_unicode():
     # see gh-20503
     #
-    # Test ensures that `assert_numpy_array_equals` raises the right
+    # Test ensures that `tm.assert_numpy_array_equals` raises the right
     # exception when comparing np.arrays containing differing unicode objects.
     msg = """numpy array are different
 
@@ -133,7 +133,9 @@ def test_numpy_array_equal_unicode():
 \\[right\\]: \\[á, à, å\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
+        tm.assert_numpy_array_equal(
+            np.array(["á", "à", "ä"]), np.array(["á", "à", "å"])
+        )
 
 
 def test_numpy_array_equal_object():
@@ -147,7 +149,7 @@ def test_numpy_array_equal_object():
 \\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
 
     with pytest.raises(AssertionError, match=msg):
-        assert_numpy_array_equal(a, b)
+        tm.assert_numpy_array_equal(a, b)
 
 
 @pytest.mark.parametrize("other_type", ["same", "copy"])
@@ -170,6 +172,6 @@ def test_numpy_array_equal_copy_flag(other_type, check_same):
 
     if msg is not None:
         with pytest.raises(AssertionError, match=msg):
-            assert_numpy_array_equal(a, other, check_same=check_same)
+            tm.assert_numpy_array_equal(a, other, check_same=check_same)
     else:
-        assert_numpy_array_equal(a, other, check_same=check_same)
+        tm.assert_numpy_array_equal(a, other, check_same=check_same)
diff --git a/pandas/tests/util/test_assert_produces_warning.py b/pandas/tests/util/test_assert_produces_warning.py
index c681817896903..87765c909938d 100644
--- a/pandas/tests/util/test_assert_produces_warning.py
+++ b/pandas/tests/util/test_assert_produces_warning.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def f():
diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index a12d9386eb159..eaf0824f52927 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -1,7 +1,7 @@
 import pytest
 
 from pandas import Categorical, DataFrame, Series
-from pandas.util.testing import assert_series_equal
+import pandas._testing as tm
 
 
 def _assert_series_equal_both(a, b, **kwargs):
@@ -17,10 +17,10 @@ def _assert_series_equal_both(a, b, **kwargs):
     b : Series
         The second Series to compare.
     kwargs : dict
-        The arguments passed to `assert_series_equal`.
+        The arguments passed to `tm.assert_series_equal`.
     """
-    assert_series_equal(a, b, **kwargs)
-    assert_series_equal(b, a, **kwargs)
+    tm.assert_series_equal(a, b, **kwargs)
+    tm.assert_series_equal(b, a, **kwargs)
 
 
 def _assert_not_series_equal(a, b, **kwargs):
@@ -34,10 +34,10 @@ def _assert_not_series_equal(a, b, **kwargs):
     b : Series
         The second Series to compare.
     kwargs : dict
-        The arguments passed to `assert_series_equal`.
+        The arguments passed to `tm.assert_series_equal`.
     """
     try:
-        assert_series_equal(a, b, **kwargs)
+        tm.assert_series_equal(a, b, **kwargs)
         msg = "The two Series were equal when they shouldn't have been"
 
         pytest.fail(msg=msg)
@@ -58,7 +58,7 @@ def _assert_not_series_equal_both(a, b, **kwargs):
     b : Series
         The second Series to compare.
     kwargs : dict
-        The arguments passed to `assert_series_equal`.
+        The arguments passed to `tm.assert_series_equal`.
     """
     _assert_not_series_equal(a, b, **kwargs)
     _assert_not_series_equal(b, a, **kwargs)
@@ -114,7 +114,7 @@ def test_less_precise(data1, data2, dtype, check_less_precise):
     ):
         msg = "Series values are different"
         with pytest.raises(AssertionError, match=msg):
-            assert_series_equal(s1, s2, **kwargs)
+            tm.assert_series_equal(s1, s2, **kwargs)
     else:
         _assert_series_equal_both(s1, s2, **kwargs)
 
@@ -145,9 +145,9 @@ def test_series_equal_index_dtype(s1, s2, msg, check_index_type):
 
     if check_index_type:
         with pytest.raises(AssertionError, match=msg):
-            assert_series_equal(s1, s2, **kwargs)
+            tm.assert_series_equal(s1, s2, **kwargs)
     else:
-        assert_series_equal(s1, s2, **kwargs)
+        tm.assert_series_equal(s1, s2, **kwargs)
 
 
 def test_series_equal_length_mismatch(check_less_precise):
@@ -161,7 +161,7 @@ def test_series_equal_length_mismatch(check_less_precise):
     s2 = Series([1, 2, 3, 4])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_series_equal(s1, s2, check_less_precise=check_less_precise)
+        tm.assert_series_equal(s1, s2, check_less_precise=check_less_precise)
 
 
 def test_series_equal_values_mismatch(check_less_precise):
@@ -175,11 +175,11 @@ def test_series_equal_values_mismatch(check_less_precise):
     s2 = Series([1, 2, 4])
 
     with pytest.raises(AssertionError, match=msg):
-        assert_series_equal(s1, s2, check_less_precise=check_less_precise)
+        tm.assert_series_equal(s1, s2, check_less_precise=check_less_precise)
 
 
 def test_series_equal_categorical_mismatch(check_categorical):
-    msg = """Attributes are different
+    msg = """Attributes of Series are different
 
 Attribute "dtype" are different
 \\[left\\]:  CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False\\)
@@ -191,6 +191,6 @@ def test_series_equal_categorical_mismatch(check_categorical):
 
     if check_categorical:
         with pytest.raises(AssertionError, match=msg):
-            assert_series_equal(s1, s2, check_categorical=check_categorical)
+            tm.assert_series_equal(s1, s2, check_categorical=check_categorical)
     else:
         _assert_series_equal_both(s1, s2, check_categorical=check_categorical)
diff --git a/pandas/tests/util/test_deprecate.py b/pandas/tests/util/test_deprecate.py
index 8fbc8037ed7c5..ee4f7e3f34f2e 100644
--- a/pandas/tests/util/test_deprecate.py
+++ b/pandas/tests/util/test_deprecate.py
@@ -4,7 +4,7 @@
 
 from pandas.util._decorators import deprecate
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def new_func():
diff --git a/pandas/tests/util/test_deprecate_kwarg.py b/pandas/tests/util/test_deprecate_kwarg.py
index c17c48197ccf7..b165e9fba0e4f 100644
--- a/pandas/tests/util/test_deprecate_kwarg.py
+++ b/pandas/tests/util/test_deprecate_kwarg.py
@@ -2,7 +2,7 @@
 
 from pandas.util._decorators import deprecate_kwarg
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 @deprecate_kwarg("old", "new")
diff --git a/pandas/tests/util/test_hashing.py b/pandas/tests/util/test_hashing.py
index df3c7fe9c9936..c856585f20138 100644
--- a/pandas/tests/util/test_hashing.py
+++ b/pandas/tests/util/test_hashing.py
@@ -5,9 +5,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series
+import pandas._testing as tm
 from pandas.core.util.hashing import _hash_scalar, hash_tuple, hash_tuples
 from pandas.util import hash_array, hash_pandas_object
-import pandas.util.testing as tm
 
 
 @pytest.fixture(
@@ -207,7 +207,7 @@ def test_multiindex_objects():
         Series(["a", np.nan, "c"]),
         Series(["a", None, "c"]),
         Series([True, False, True]),
-        Series(),
+        Series(dtype=object),
         Index([1, 2, 3]),
         Index([True, False, True]),
         DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
@@ -353,3 +353,31 @@ def test_hash_collisions():
 
     result = hash_array(np.asarray(hashes, dtype=object), "utf8")
     tm.assert_numpy_array_equal(result, np.concatenate([expected1, expected2], axis=0))
+
+
+def test_hash_with_tuple():
+    # GH#28969 array containing a tuple raises on call to arr.astype(str)
+    #  apparently a numpy bug github.com/numpy/numpy/issues/9441
+
+    df = pd.DataFrame({"data": [tuple("1"), tuple("2")]})
+    result = hash_pandas_object(df)
+    expected = pd.Series([10345501319357378243, 8331063931016360761], dtype=np.uint64)
+    tm.assert_series_equal(result, expected)
+
+    df2 = pd.DataFrame({"data": [tuple([1]), tuple([2])]})
+    result = hash_pandas_object(df2)
+    expected = pd.Series([9408946347443669104, 3278256261030523334], dtype=np.uint64)
+    tm.assert_series_equal(result, expected)
+
+    # require that the elements of such tuples are themselves hashable
+
+    df3 = pd.DataFrame({"data": [tuple([1, []]), tuple([2, {}])]})
+    with pytest.raises(TypeError, match="unhashable type: 'list'"):
+        hash_pandas_object(df3)
+
+
+def test_hash_object_none_key():
+    # https://github.com/pandas-dev/pandas/issues/30887
+    result = pd.util.hash_pandas_object(pd.Series(["a", "b"]), hash_key=None)
+    expected = pd.Series([4578374827886788867, 17338122309987883691], dtype="uint64")
+    tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/util/test_move.py b/pandas/tests/util/test_move.py
deleted file mode 100644
index 0e28dd2dd9d71..0000000000000
--- a/pandas/tests/util/test_move.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import pytest
-
-from pandas.util._move import BadMove, move_into_mutable_buffer, stolenbuf
-
-
-def test_cannot_create_instance_of_stolen_buffer():
-    # Stolen buffers need to be created through the smart constructor
-    # "move_into_mutable_buffer," which has a bunch of checks in it.
-
-    msg = "cannot create 'pandas.util._move.stolenbuf' instances"
-    with pytest.raises(TypeError, match=msg):
-        stolenbuf()
-
-
-def test_more_than_one_ref():
-    # Test case for when we try to use "move_into_mutable_buffer"
-    # when the object being moved has other references.
-
-    b = b"testing"
-
-    with pytest.raises(BadMove, match="testing") as e:
-
-        def handle_success(type_, value, tb):
-            assert value.args[0] is b
-            return type(e).handle_success(e, type_, value, tb)  # super
-
-        e.handle_success = handle_success
-        move_into_mutable_buffer(b)
-
-
-def test_exactly_one_ref():
-    # Test case for when the object being moved has exactly one reference.
-
-    b = b"testing"
-
-    # We need to pass an expression on the stack to ensure that there are
-    # not extra references hanging around. We cannot rewrite this test as
-    #   buf = b[:-3]
-    #   as_stolen_buf = move_into_mutable_buffer(buf)
-    # because then we would have more than one reference to buf.
-    as_stolen_buf = move_into_mutable_buffer(b[:-3])
-
-    # Materialize as byte-array to show that it is mutable.
-    assert bytearray(as_stolen_buf) == b"test"
diff --git a/pandas/tests/util/test_util.py b/pandas/tests/util/test_util.py
index 83d9be1ad235f..8860e6fe272ce 100644
--- a/pandas/tests/util/test_util.py
+++ b/pandas/tests/util/test_util.py
@@ -1,12 +1,10 @@
 import os
-import sys
 
 import pytest
 
 import pandas.compat as compat
-from pandas.compat import raise_with_traceback
 
-import pandas.util.testing as tm
+import pandas._testing as tm
 
 
 def test_rands():
@@ -34,23 +32,6 @@ def test_numpy_err_state_is_default():
     assert np.geterr() == expected
 
 
-def test_raise_with_traceback():
-    with pytest.raises(LookupError, match="error_text"):
-        try:
-            raise ValueError("THIS IS AN ERROR")
-        except ValueError:
-            e = LookupError("error_text")
-            raise_with_traceback(e)
-
-    with pytest.raises(LookupError, match="error_text"):
-        try:
-            raise ValueError("This is another error")
-        except ValueError:
-            e = LookupError("error_text")
-            _, _, traceback = sys.exc_info()
-            raise_with_traceback(e, traceback)
-
-
 def test_convert_rows_list_to_csv_str():
     rows_list = ["aaa", "bbb", "ccc"]
     ret = tm.convert_rows_list_to_csv_str(rows_list)
@@ -70,16 +51,6 @@ def test_create_temp_directory():
     assert not os.path.exists(path)
 
 
-def test_assert_raises_regex_deprecated():
-    # see gh-23592
-
-    with tm.assert_produces_warning(FutureWarning):
-        msg = "Not equal!"
-
-        with tm.assert_raises_regex(AssertionError, msg):
-            assert 1 == 2, msg
-
-
 @pytest.mark.parametrize("strict_data_files", [True, False])
 def test_datapath_missing(datapath):
     with pytest.raises(ValueError, match="Could not find file"):
@@ -105,3 +76,8 @@ def test_rng_context():
         with tm.RNGContext(1):
             assert np.random.randn() == expected1
         assert np.random.randn() == expected0
+
+
+def test_external_error_raised():
+    with tm.external_error_raised(TypeError):
+        raise TypeError("Should not check this error message, so it will pass")
diff --git a/pandas/tests/util/test_validate_args.py b/pandas/tests/util/test_validate_args.py
index 1f1365d62c64e..746d859b3322e 100644
--- a/pandas/tests/util/test_validate_args.py
+++ b/pandas/tests/util/test_validate_args.py
@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 import pytest
 
 from pandas.util._validators import validate_args
@@ -22,10 +20,8 @@ def test_bad_arg_length_max_value_single():
     max_length = len(compat_args) + min_fname_arg_count
     actual_length = len(args) + min_fname_arg_count
     msg = (
-        r"{fname}\(\) takes at most {max_length} "
-        r"argument \({actual_length} given\)".format(
-            fname=_fname, max_length=max_length, actual_length=actual_length
-        )
+        fr"{_fname}\(\) takes at most {max_length} "
+        fr"argument \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -40,10 +36,8 @@ def test_bad_arg_length_max_value_multiple():
     max_length = len(compat_args) + min_fname_arg_count
     actual_length = len(args) + min_fname_arg_count
     msg = (
-        r"{fname}\(\) takes at most {max_length} "
-        r"arguments \({actual_length} given\)".format(
-            fname=_fname, max_length=max_length, actual_length=actual_length
-        )
+        fr"{_fname}\(\) takes at most {max_length} "
+        fr"arguments \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -54,15 +48,11 @@ def test_bad_arg_length_max_value_multiple():
 def test_not_all_defaults(i):
     bad_arg = "foo"
     msg = (
-        "the '{arg}' parameter is not supported "
-        r"in the pandas implementation of {func}\(\)".format(arg=bad_arg, func=_fname)
+        f"the '{bad_arg}' parameter is not supported "
+        fr"in the pandas implementation of {_fname}\(\)"
     )
 
-    compat_args = OrderedDict()
-    compat_args["foo"] = 2
-    compat_args["bar"] = -1
-    compat_args["baz"] = 3
-
+    compat_args = {"foo": 2, "bar": -1, "baz": 3}
     arg_vals = (1, -1, 3)
 
     with pytest.raises(ValueError, match=msg):
@@ -73,8 +63,5 @@ def test_validation():
     # No exceptions should be raised.
     validate_args(_fname, (None,), 2, dict(out=None))
 
-    compat_args = OrderedDict()
-    compat_args["axis"] = 1
-    compat_args["out"] = None
-
+    compat_args = {"axis": 1, "out": None}
     validate_args(_fname, (1, None), 2, compat_args)
diff --git a/pandas/tests/util/test_validate_args_and_kwargs.py b/pandas/tests/util/test_validate_args_and_kwargs.py
index 396056466bb81..941ba86c61319 100644
--- a/pandas/tests/util/test_validate_args_and_kwargs.py
+++ b/pandas/tests/util/test_validate_args_and_kwargs.py
@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 import pytest
 
 from pandas.util._validators import validate_args_and_kwargs
@@ -17,10 +15,8 @@ def test_invalid_total_length_max_length_one():
     actual_length = len(kwargs) + len(args) + min_fname_arg_count
 
     msg = (
-        r"{fname}\(\) takes at most {max_length} "
-        r"argument \({actual_length} given\)".format(
-            fname=_fname, max_length=max_length, actual_length=actual_length
-        )
+        fr"{_fname}\(\) takes at most {max_length} "
+        fr"argument \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -37,10 +33,8 @@ def test_invalid_total_length_max_length_multiple():
     actual_length = len(kwargs) + len(args) + min_fname_arg_count
 
     msg = (
-        r"{fname}\(\) takes at most {max_length} "
-        r"arguments \({actual_length} given\)".format(
-            fname=_fname, max_length=max_length, actual_length=actual_length
-        )
+        fr"{_fname}\(\) takes at most {max_length} "
+        fr"arguments \({actual_length} given\)"
     )
 
     with pytest.raises(TypeError, match=msg):
@@ -52,13 +46,11 @@ def test_missing_args_or_kwargs(args, kwargs):
     bad_arg = "bar"
     min_fname_arg_count = 2
 
-    compat_args = OrderedDict()
-    compat_args["foo"] = -5
-    compat_args[bad_arg] = 1
+    compat_args = {"foo": -5, bad_arg: 1}
 
     msg = (
-        r"the '{arg}' parameter is not supported "
-        r"in the pandas implementation of {func}\(\)".format(arg=bad_arg, func=_fname)
+        fr"the '{bad_arg}' parameter is not supported "
+        fr"in the pandas implementation of {_fname}\(\)"
     )
 
     with pytest.raises(ValueError, match=msg):
@@ -68,17 +60,11 @@ def test_missing_args_or_kwargs(args, kwargs):
 def test_duplicate_argument():
     min_fname_arg_count = 2
 
-    compat_args = OrderedDict()
-    compat_args["foo"] = None
-    compat_args["bar"] = None
-    compat_args["baz"] = None
-
+    compat_args = {"foo": None, "bar": None, "baz": None}
     kwargs = {"foo": None, "bar": None}
     args = (None,)  # duplicate value for "foo"
 
-    msg = r"{fname}\(\) got multiple values for keyword " r"argument '{arg}'".format(
-        fname=_fname, arg="foo"
-    )
+    msg = fr"{_fname}\(\) got multiple values for keyword argument 'foo'"
 
     with pytest.raises(TypeError, match=msg):
         validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
@@ -86,10 +72,7 @@ def test_duplicate_argument():
 
 def test_validation():
     # No exceptions should be raised.
-    compat_args = OrderedDict()
-    compat_args["foo"] = 1
-    compat_args["bar"] = None
-    compat_args["baz"] = -2
+    compat_args = {"foo": 1, "bar": None, "baz": -2}
     kwargs = {"baz": -2}
 
     args = (1, None)
diff --git a/pandas/tests/util/test_validate_kwargs.py b/pandas/tests/util/test_validate_kwargs.py
index ec9f3948403de..8fe2a3712bf49 100644
--- a/pandas/tests/util/test_validate_kwargs.py
+++ b/pandas/tests/util/test_validate_kwargs.py
@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 import pytest
 
 from pandas.util._validators import validate_bool_kwarg, validate_kwargs
@@ -11,14 +9,10 @@ def test_bad_kwarg():
     good_arg = "f"
     bad_arg = good_arg + "o"
 
-    compat_args = OrderedDict()
-    compat_args[good_arg] = "foo"
-    compat_args[bad_arg + "o"] = "bar"
+    compat_args = {good_arg: "foo", bad_arg + "o": "bar"}
     kwargs = {good_arg: "foo", bad_arg: "bar"}
 
-    msg = r"{fname}\(\) got an unexpected " r"keyword argument '{arg}'".format(
-        fname=_fname, arg=bad_arg
-    )
+    msg = fr"{_fname}\(\) got an unexpected keyword argument '{bad_arg}'"
 
     with pytest.raises(TypeError, match=msg):
         validate_kwargs(_fname, kwargs, compat_args)
@@ -28,14 +22,11 @@ def test_bad_kwarg():
 def test_not_all_none(i):
     bad_arg = "foo"
     msg = (
-        r"the '{arg}' parameter is not supported "
-        r"in the pandas implementation of {func}\(\)".format(arg=bad_arg, func=_fname)
+        fr"the '{bad_arg}' parameter is not supported "
+        fr"in the pandas implementation of {_fname}\(\)"
     )
 
-    compat_args = OrderedDict()
-    compat_args["foo"] = 1
-    compat_args["bar"] = "s"
-    compat_args["baz"] = None
+    compat_args = {"foo": 1, "bar": "s", "baz": None}
 
     kwarg_keys = ("foo", "bar", "baz")
     kwarg_vals = (2, "s", None)
@@ -48,10 +39,7 @@ def test_not_all_none(i):
 
 def test_validation():
     # No exceptions should be raised.
-    compat_args = OrderedDict()
-    compat_args["f"] = None
-    compat_args["b"] = 1
-    compat_args["ba"] = "s"
+    compat_args = {"f": None, "b": 1, "ba": "s"}
 
     kwargs = dict(f=None, b=1)
     validate_kwargs(_fname, kwargs, compat_args)
@@ -60,9 +48,9 @@ def test_validation():
 @pytest.mark.parametrize("name", ["inplace", "copy"])
 @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
 def test_validate_bool_kwarg_fail(name, value):
-    msg = 'For argument "%s" expected type bool, received type %s' % (
-        name,
-        type(value).__name__,
+    msg = (
+        f'For argument "{name}" expected type bool, '
+        f"received type {type(value).__name__}"
     )
 
     with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/window/common.py b/pandas/tests/window/common.py
index 1dfc0f34b2b8d..6aeada3152dbb 100644
--- a/pandas/tests/window/common.py
+++ b/pandas/tests/window/common.py
@@ -3,7 +3,8 @@
 import numpy as np
 from numpy.random import randn
 
-from pandas import DataFrame, Series, bdate_range
+from pandas import DataFrame, Series, bdate_range, notna
+import pandas._testing as tm
 
 N, K = 100, 10
 
@@ -21,3 +22,365 @@ def _create_data(self):
         self.rng = bdate_range(datetime(2009, 1, 1), periods=N)
         self.series = Series(arr.copy(), index=self.rng)
         self.frame = DataFrame(randn(N, K), index=self.rng, columns=np.arange(K))
+
+
+# create the data only once as we are not setting it
+def _create_consistency_data():
+    def create_series():
+        return [
+            Series(dtype=object),
+            Series([np.nan]),
+            Series([np.nan, np.nan]),
+            Series([3.0]),
+            Series([np.nan, 3.0]),
+            Series([3.0, np.nan]),
+            Series([1.0, 3.0]),
+            Series([2.0, 2.0]),
+            Series([3.0, 1.0]),
+            Series(
+                [5.0, 5.0, 5.0, 5.0, np.nan, np.nan, np.nan, 5.0, 5.0, np.nan, np.nan]
+            ),
+            Series(
+                [
+                    np.nan,
+                    5.0,
+                    5.0,
+                    5.0,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    5.0,
+                    5.0,
+                    np.nan,
+                    np.nan,
+                ]
+            ),
+            Series(
+                [
+                    np.nan,
+                    np.nan,
+                    5.0,
+                    5.0,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    5.0,
+                    5.0,
+                    np.nan,
+                    np.nan,
+                ]
+            ),
+            Series(
+                [
+                    np.nan,
+                    3.0,
+                    np.nan,
+                    3.0,
+                    4.0,
+                    5.0,
+                    6.0,
+                    np.nan,
+                    np.nan,
+                    7.0,
+                    12.0,
+                    13.0,
+                    14.0,
+                    15.0,
+                ]
+            ),
+            Series(
+                [
+                    np.nan,
+                    5.0,
+                    np.nan,
+                    2.0,
+                    4.0,
+                    0.0,
+                    9.0,
+                    np.nan,
+                    np.nan,
+                    3.0,
+                    12.0,
+                    13.0,
+                    14.0,
+                    15.0,
+                ]
+            ),
+            Series(
+                [
+                    2.0,
+                    3.0,
+                    np.nan,
+                    3.0,
+                    4.0,
+                    5.0,
+                    6.0,
+                    np.nan,
+                    np.nan,
+                    7.0,
+                    12.0,
+                    13.0,
+                    14.0,
+                    15.0,
+                ]
+            ),
+            Series(
+                [
+                    2.0,
+                    5.0,
+                    np.nan,
+                    2.0,
+                    4.0,
+                    0.0,
+                    9.0,
+                    np.nan,
+                    np.nan,
+                    3.0,
+                    12.0,
+                    13.0,
+                    14.0,
+                    15.0,
+                ]
+            ),
+            Series(range(10)),
+            Series(range(20, 0, -2)),
+        ]
+
+    def create_dataframes():
+        return [
+            DataFrame(),
+            DataFrame(columns=["a"]),
+            DataFrame(columns=["a", "a"]),
+            DataFrame(columns=["a", "b"]),
+            DataFrame(np.arange(10).reshape((5, 2))),
+            DataFrame(np.arange(25).reshape((5, 5))),
+            DataFrame(np.arange(25).reshape((5, 5)), columns=["a", "b", 99, "d", "d"]),
+        ] + [DataFrame(s) for s in create_series()]
+
+    def is_constant(x):
+        values = x.values.ravel()
+        return len(set(values[notna(values)])) == 1
+
+    def no_nans(x):
+        return x.notna().all().all()
+
+    # data is a tuple(object, is_constant, no_nans)
+    data = create_series() + create_dataframes()
+
+    return [(x, is_constant(x), no_nans(x)) for x in data]
+
+
+_consistency_data = _create_consistency_data()
+
+
+class ConsistencyBase(Base):
+    base_functions = [
+        (lambda v: Series(v).count(), None, "count"),
+        (lambda v: Series(v).max(), None, "max"),
+        (lambda v: Series(v).min(), None, "min"),
+        (lambda v: Series(v).sum(), None, "sum"),
+        (lambda v: Series(v).mean(), None, "mean"),
+        (lambda v: Series(v).std(), 1, "std"),
+        (lambda v: Series(v).cov(Series(v)), None, "cov"),
+        (lambda v: Series(v).corr(Series(v)), None, "corr"),
+        (lambda v: Series(v).var(), 1, "var"),
+        # restore once GH 8086 is fixed
+        # lambda v: Series(v).skew(), 3, 'skew'),
+        # (lambda v: Series(v).kurt(), 4, 'kurt'),
+        # restore once GH 8084 is fixed
+        # lambda v: Series(v).quantile(0.3), None, 'quantile'),
+        (lambda v: Series(v).median(), None, "median"),
+        (np.nanmax, 1, "max"),
+        (np.nanmin, 1, "min"),
+        (np.nansum, 1, "sum"),
+        (np.nanmean, 1, "mean"),
+        (lambda v: np.nanstd(v, ddof=1), 1, "std"),
+        (lambda v: np.nanvar(v, ddof=1), 1, "var"),
+        (np.nanmedian, 1, "median"),
+    ]
+    no_nan_functions = [
+        (np.max, None, "max"),
+        (np.min, None, "min"),
+        (np.sum, None, "sum"),
+        (np.mean, None, "mean"),
+        (lambda v: np.std(v, ddof=1), 1, "std"),
+        (lambda v: np.var(v, ddof=1), 1, "var"),
+        (np.median, None, "median"),
+    ]
+
+    def _create_data(self):
+        super()._create_data()
+        self.data = _consistency_data
+
+    def _test_moments_consistency_mock_mean(self, mean, mock_mean):
+        for (x, is_constant, no_nans) in self.data:
+            mean_x = mean(x)
+            # check that correlation of a series with itself is either 1 or NaN
+
+            if mock_mean:
+                # check that mean equals mock_mean
+                expected = mock_mean(x)
+                tm.assert_equal(mean_x, expected.astype("float64"))
+
+    def _test_moments_consistency_is_constant(self, min_periods, count, mean, corr):
+        for (x, is_constant, no_nans) in self.data:
+            count_x = count(x)
+            mean_x = mean(x)
+            # check that correlation of a series with itself is either 1 or NaN
+            corr_x_x = corr(x, x)
+
+            if is_constant:
+                exp = x.max() if isinstance(x, Series) else x.max().max()
+
+                # check mean of constant series
+                expected = x * np.nan
+                expected[count_x >= max(min_periods, 1)] = exp
+                tm.assert_equal(mean_x, expected)
+
+                # check correlation of constant series with itself is NaN
+                expected[:] = np.nan
+                tm.assert_equal(corr_x_x, expected)
+
+    def _test_moments_consistency_var_debiasing_factors(
+        self, var_biased=None, var_unbiased=None, var_debiasing_factors=None
+    ):
+        for (x, is_constant, no_nans) in self.data:
+            if var_unbiased and var_biased and var_debiasing_factors:
+                # check variance debiasing factors
+                var_unbiased_x = var_unbiased(x)
+                var_biased_x = var_biased(x)
+                var_debiasing_factors_x = var_debiasing_factors(x)
+                tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
+
+    def _test_moments_consistency(
+        self,
+        min_periods,
+        count,
+        mean,
+        corr,
+        var_unbiased=None,
+        std_unbiased=None,
+        cov_unbiased=None,
+        var_biased=None,
+        std_biased=None,
+        cov_biased=None,
+    ):
+
+        for (x, is_constant, no_nans) in self.data:
+            count_x = count(x)
+            mean_x = mean(x)
+
+            for (std, var, cov) in [
+                (std_biased, var_biased, cov_biased),
+                (std_unbiased, var_unbiased, cov_unbiased),
+            ]:
+
+                # check that var(x), std(x), and cov(x) are all >= 0
+                var_x = var(x)
+                std_x = std(x)
+                assert not (var_x < 0).any().any()
+                assert not (std_x < 0).any().any()
+                if cov:
+                    cov_x_x = cov(x, x)
+                    assert not (cov_x_x < 0).any().any()
+
+                    # check that var(x) == cov(x, x)
+                    tm.assert_equal(var_x, cov_x_x)
+
+                # check that var(x) == std(x)^2
+                tm.assert_equal(var_x, std_x * std_x)
+
+                if var is var_biased:
+                    # check that biased var(x) == mean(x^2) - mean(x)^2
+                    mean_x2 = mean(x * x)
+                    tm.assert_equal(var_x, mean_x2 - (mean_x * mean_x))
+
+                if is_constant:
+                    # check that variance of constant series is identically 0
+                    assert not (var_x > 0).any().any()
+                    expected = x * np.nan
+                    expected[count_x >= max(min_periods, 1)] = 0.0
+                    if var is var_unbiased:
+                        expected[count_x < 2] = np.nan
+                    tm.assert_equal(var_x, expected)
+
+                if isinstance(x, Series):
+                    for (y, is_constant, no_nans) in self.data:
+                        if not x.isna().equals(y.isna()):
+                            # can only easily test two Series with similar
+                            # structure
+                            continue
+
+                        # check that cor(x, y) is symmetric
+                        corr_x_y = corr(x, y)
+                        corr_y_x = corr(y, x)
+                        tm.assert_equal(corr_x_y, corr_y_x)
+
+                        if cov:
+                            # check that cov(x, y) is symmetric
+                            cov_x_y = cov(x, y)
+                            cov_y_x = cov(y, x)
+                            tm.assert_equal(cov_x_y, cov_y_x)
+
+                            # check that cov(x, y) == (var(x+y) - var(x) -
+                            # var(y)) / 2
+                            var_x_plus_y = var(x + y)
+                            var_y = var(y)
+                            tm.assert_equal(
+                                cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y)
+                            )
+
+                            # check that corr(x, y) == cov(x, y) / (std(x) *
+                            # std(y))
+                            std_y = std(y)
+                            tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
+
+                            if cov is cov_biased:
+                                # check that biased cov(x, y) == mean(x*y) -
+                                # mean(x)*mean(y)
+                                mean_y = mean(y)
+                                mean_x_times_y = mean(x * y)
+                                tm.assert_equal(
+                                    cov_x_y, mean_x_times_y - (mean_x * mean_y)
+                                )
+
+    def _check_pairwise_moment(self, dispatch, name, **kwargs):
+        def get_result(obj, obj2=None):
+            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
+
+        result = get_result(self.frame)
+        result = result.loc[(slice(None), 1), 5]
+        result.index = result.index.droplevel(1)
+        expected = get_result(self.frame[1], self.frame[5])
+        tm.assert_series_equal(result, expected, check_names=False)
+
+
+def ew_func(A, B, com, name, **kwargs):
+    return getattr(A.ewm(com, **kwargs), name)(B)
+
+
+def check_binary_ew(name, A, B):
+
+    result = ew_func(A=A, B=B, com=20, name=name, min_periods=5)
+    assert np.isnan(result.values[:14]).all()
+    assert not np.isnan(result.values[14:]).any()
+
+
+def check_binary_ew_min_periods(name, min_periods, A, B):
+    # GH 7898
+    result = ew_func(A, B, 20, name=name, min_periods=min_periods)
+    # binary functions (ewmcov, ewmcorr) with bias=False require at
+    # least two values
+    assert np.isnan(result.values[:11]).all()
+    assert not np.isnan(result.values[11:]).any()
+
+    # check series of length 0
+    empty = Series([], dtype=np.float64)
+    result = ew_func(empty, empty, 50, name=name, min_periods=min_periods)
+    tm.assert_series_equal(result, empty)
+
+    # check series of length 1
+    result = ew_func(
+        Series([1.0]), Series([1.0]), 50, name=name, min_periods=min_periods
+    )
+    tm.assert_series_equal(result, Series([np.NaN]))
diff --git a/pandas/tests/window/conftest.py b/pandas/tests/window/conftest.py
index 7ea4be25ca2a6..fb46ca51ace58 100644
--- a/pandas/tests/window/conftest.py
+++ b/pandas/tests/window/conftest.py
@@ -1,5 +1,7 @@
 import pytest
 
+import pandas.util._test_decorators as td
+
 
 @pytest.fixture(params=[True, False])
 def raw(request):
@@ -47,3 +49,41 @@ def center(request):
 @pytest.fixture(params=[None, 1])
 def min_periods(request):
     return request.param
+
+
+@pytest.fixture(params=[True, False])
+def parallel(request):
+    """parallel keyword argument for numba.jit"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def nogil(request):
+    """nogil keyword argument for numba.jit"""
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def nopython(request):
+    """nopython keyword argument for numba.jit"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[pytest.param("numba", marks=td.skip_if_no("numba", "0.46.0")), "cython"]
+)
+def engine(request):
+    """engine keyword argument for rolling.apply"""
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(("numba", True), marks=td.skip_if_no("numba", "0.46.0")),
+        ("cython", True),
+        ("cython", False),
+    ]
+)
+def engine_and_raw(request):
+    """engine and raw keyword arguments for rolling.apply"""
+    return request.param
diff --git a/pandas/tests/window/moments/conftest.py b/pandas/tests/window/moments/conftest.py
new file mode 100644
index 0000000000000..2002f4d0bff43
--- /dev/null
+++ b/pandas/tests/window/moments/conftest.py
@@ -0,0 +1,20 @@
+import numpy as np
+from numpy.random import randn
+import pytest
+
+from pandas import Series
+
+
+@pytest.fixture
+def binary_ew_data():
+    A = Series(randn(50), index=np.arange(50))
+    B = A[2:] + randn(48)
+
+    A[:10] = np.NaN
+    B[-10:] = np.NaN
+    return A, B
+
+
+@pytest.fixture(params=[0, 1, 2])
+def min_periods(request):
+    return request.param
diff --git a/pandas/tests/window/moments/test_moments_ewm.py b/pandas/tests/window/moments/test_moments_ewm.py
new file mode 100644
index 0000000000000..599761259e041
--- /dev/null
+++ b/pandas/tests/window/moments/test_moments_ewm.py
@@ -0,0 +1,439 @@
+import numpy as np
+from numpy.random import randn
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, concat
+import pandas._testing as tm
+from pandas.tests.window.common import (
+    Base,
+    ConsistencyBase,
+    check_binary_ew,
+    check_binary_ew_min_periods,
+    ew_func,
+)
+
+
+@pytest.mark.filterwarnings("ignore:can't resolve package:ImportWarning")
+class TestMoments(Base):
+    def setup_method(self, method):
+        self._create_data()
+
+    def test_ewma(self):
+        self._check_ew(name="mean")
+
+        vals = pd.Series(np.zeros(1000))
+        vals[5] = 1
+        result = vals.ewm(span=100, adjust=False).mean().sum()
+        assert np.abs(result - 1) < 1e-2
+
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewma_cases(self, adjust, ignore_na):
+        # try adjust/ignore_na args matrix
+
+        s = Series([1.0, 2.0, 4.0, 8.0])
+
+        if adjust:
+            expected = Series([1.0, 1.6, 2.736842, 4.923077])
+        else:
+            expected = Series([1.0, 1.333333, 2.222222, 4.148148])
+
+        result = s.ewm(com=2.0, adjust=adjust, ignore_na=ignore_na).mean()
+        tm.assert_series_equal(result, expected)
+
+    def test_ewma_nan_handling(self):
+        s = Series([1.0] + [np.nan] * 5 + [1.0])
+        result = s.ewm(com=5).mean()
+        tm.assert_series_equal(result, Series([1.0] * len(s)))
+
+        s = Series([np.nan] * 2 + [1.0] + [np.nan] * 2 + [1.0])
+        result = s.ewm(com=5).mean()
+        tm.assert_series_equal(result, Series([np.nan] * 2 + [1.0] * 4))
+
+        # GH 7603
+        s0 = Series([np.nan, 1.0, 101.0])
+        s1 = Series([1.0, np.nan, 101.0])
+        s2 = Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan])
+        s3 = Series([1.0, np.nan, 101.0, 50.0])
+        com = 2.0
+        alpha = 1.0 / (1.0 + com)
+
+        def simple_wma(s, w):
+            return (s.multiply(w).cumsum() / w.cumsum()).fillna(method="ffill")
+
+        for (s, adjust, ignore_na, w) in [
+            (s0, True, False, [np.nan, (1.0 - alpha), 1.0]),
+            (s0, True, True, [np.nan, (1.0 - alpha), 1.0]),
+            (s0, False, False, [np.nan, (1.0 - alpha), alpha]),
+            (s0, False, True, [np.nan, (1.0 - alpha), alpha]),
+            (s1, True, False, [(1.0 - alpha) ** 2, np.nan, 1.0]),
+            (s1, True, True, [(1.0 - alpha), np.nan, 1.0]),
+            (s1, False, False, [(1.0 - alpha) ** 2, np.nan, alpha]),
+            (s1, False, True, [(1.0 - alpha), np.nan, alpha]),
+            (
+                s2,
+                True,
+                False,
+                [np.nan, (1.0 - alpha) ** 3, np.nan, np.nan, 1.0, np.nan],
+            ),
+            (s2, True, True, [np.nan, (1.0 - alpha), np.nan, np.nan, 1.0, np.nan]),
+            (
+                s2,
+                False,
+                False,
+                [np.nan, (1.0 - alpha) ** 3, np.nan, np.nan, alpha, np.nan],
+            ),
+            (s2, False, True, [np.nan, (1.0 - alpha), np.nan, np.nan, alpha, np.nan]),
+            (s3, True, False, [(1.0 - alpha) ** 3, np.nan, (1.0 - alpha), 1.0]),
+            (s3, True, True, [(1.0 - alpha) ** 2, np.nan, (1.0 - alpha), 1.0]),
+            (
+                s3,
+                False,
+                False,
+                [
+                    (1.0 - alpha) ** 3,
+                    np.nan,
+                    (1.0 - alpha) * alpha,
+                    alpha * ((1.0 - alpha) ** 2 + alpha),
+                ],
+            ),
+            (
+                s3,
+                False,
+                True,
+                [(1.0 - alpha) ** 2, np.nan, (1.0 - alpha) * alpha, alpha],
+            ),
+        ]:
+            expected = simple_wma(s, Series(w))
+            result = s.ewm(com=com, adjust=adjust, ignore_na=ignore_na).mean()
+
+            tm.assert_series_equal(result, expected)
+            if ignore_na is False:
+                # check that ignore_na defaults to False
+                result = s.ewm(com=com, adjust=adjust).mean()
+                tm.assert_series_equal(result, expected)
+
+    def test_ewmvar(self):
+        self._check_ew(name="var")
+
+    def test_ewmvol(self):
+        self._check_ew(name="vol")
+
+    def test_ewma_span_com_args(self):
+        A = self.series.ewm(com=9.5).mean()
+        B = self.series.ewm(span=20).mean()
+        tm.assert_almost_equal(A, B)
+
+        with pytest.raises(ValueError):
+            self.series.ewm(com=9.5, span=20)
+        with pytest.raises(ValueError):
+            self.series.ewm().mean()
+
+    def test_ewma_halflife_arg(self):
+        A = self.series.ewm(com=13.932726172912965).mean()
+        B = self.series.ewm(halflife=10.0).mean()
+        tm.assert_almost_equal(A, B)
+
+        with pytest.raises(ValueError):
+            self.series.ewm(span=20, halflife=50)
+        with pytest.raises(ValueError):
+            self.series.ewm(com=9.5, halflife=50)
+        with pytest.raises(ValueError):
+            self.series.ewm(com=9.5, span=20, halflife=50)
+        with pytest.raises(ValueError):
+            self.series.ewm()
+
+    def test_ewm_alpha(self):
+        # GH 10789
+        s = Series(self.arr)
+        a = s.ewm(alpha=0.61722699889169674).mean()
+        b = s.ewm(com=0.62014947789973052).mean()
+        c = s.ewm(span=2.240298955799461).mean()
+        d = s.ewm(halflife=0.721792864318).mean()
+        tm.assert_series_equal(a, b)
+        tm.assert_series_equal(a, c)
+        tm.assert_series_equal(a, d)
+
+    def test_ewm_alpha_arg(self):
+        # GH 10789
+        s = self.series
+        with pytest.raises(ValueError):
+            s.ewm()
+        with pytest.raises(ValueError):
+            s.ewm(com=10.0, alpha=0.5)
+        with pytest.raises(ValueError):
+            s.ewm(span=10.0, alpha=0.5)
+        with pytest.raises(ValueError):
+            s.ewm(halflife=10.0, alpha=0.5)
+
+    def test_ewm_domain_checks(self):
+        # GH 12492
+        s = Series(self.arr)
+        msg = "comass must satisfy: comass >= 0"
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(com=-0.1)
+        s.ewm(com=0.0)
+        s.ewm(com=0.1)
+
+        msg = "span must satisfy: span >= 1"
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(span=-0.1)
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(span=0.0)
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(span=0.9)
+        s.ewm(span=1.0)
+        s.ewm(span=1.1)
+
+        msg = "halflife must satisfy: halflife > 0"
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(halflife=-0.1)
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(halflife=0.0)
+        s.ewm(halflife=0.1)
+
+        msg = "alpha must satisfy: 0 < alpha <= 1"
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(alpha=-0.1)
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(alpha=0.0)
+        s.ewm(alpha=0.1)
+        s.ewm(alpha=1.0)
+        with pytest.raises(ValueError, match=msg):
+            s.ewm(alpha=1.1)
+
+    @pytest.mark.parametrize("method", ["mean", "vol", "var"])
+    def test_ew_empty_series(self, method):
+        vals = pd.Series([], dtype=np.float64)
+
+        ewm = vals.ewm(3)
+        result = getattr(ewm, method)()
+        tm.assert_almost_equal(result, vals)
+
+    def _check_ew(self, name=None, preserve_nan=False):
+        series_result = getattr(self.series.ewm(com=10), name)()
+        assert isinstance(series_result, Series)
+
+        frame_result = getattr(self.frame.ewm(com=10), name)()
+        assert type(frame_result) == DataFrame
+
+        result = getattr(self.series.ewm(com=10), name)()
+        if preserve_nan:
+            assert result[self._nan_locs].isna().all()
+
+    @pytest.mark.parametrize("min_periods", [0, 1])
+    @pytest.mark.parametrize("name", ["mean", "var", "vol"])
+    def test_ew_min_periods(self, min_periods, name):
+        # excluding NaNs correctly
+        arr = randn(50)
+        arr[:10] = np.NaN
+        arr[-10:] = np.NaN
+        s = Series(arr)
+
+        # check min_periods
+        # GH 7898
+        result = getattr(s.ewm(com=50, min_periods=2), name)()
+        assert result[:11].isna().all()
+        assert not result[11:].isna().any()
+
+        result = getattr(s.ewm(com=50, min_periods=min_periods), name)()
+        if name == "mean":
+            assert result[:10].isna().all()
+            assert not result[10:].isna().any()
+        else:
+            # ewm.std, ewm.vol, ewm.var (with bias=False) require at least
+            # two values
+            assert result[:11].isna().all()
+            assert not result[11:].isna().any()
+
+        # check series of length 0
+        result = getattr(
+            Series(dtype=object).ewm(com=50, min_periods=min_periods), name
+        )()
+        tm.assert_series_equal(result, Series(dtype="float64"))
+
+        # check series of length 1
+        result = getattr(Series([1.0]).ewm(50, min_periods=min_periods), name)()
+        if name == "mean":
+            tm.assert_series_equal(result, Series([1.0]))
+        else:
+            # ewm.std, ewm.vol, ewm.var with bias=False require at least
+            # two values
+            tm.assert_series_equal(result, Series([np.NaN]))
+
+        # pass in ints
+        result2 = getattr(Series(np.arange(50)).ewm(span=10), name)()
+        assert result2.dtype == np.float_
+
+
+class TestEwmMomentsConsistency(ConsistencyBase):
+    def setup_method(self, method):
+        self._create_data()
+
+    def test_ewmcov_pairwise(self):
+        self._check_pairwise_moment("ewm", "cov", span=10, min_periods=5)
+
+    @pytest.mark.parametrize("name", ["cov", "corr"])
+    def test_ewm_corr_cov(self, name, min_periods, binary_ew_data):
+        A, B = binary_ew_data
+
+        check_binary_ew(name="corr", A=A, B=B)
+        check_binary_ew_min_periods("corr", min_periods, A, B)
+
+    def test_ewmcorr_pairwise(self):
+        self._check_pairwise_moment("ewm", "corr", span=10, min_periods=5)
+
+    @pytest.mark.parametrize("name", ["cov", "corr"])
+    def test_different_input_array_raise_exception(self, name, binary_ew_data):
+
+        A, _ = binary_ew_data
+        msg = "Input arrays must be of the same type!"
+        # exception raised is Exception
+        with pytest.raises(Exception, match=msg):
+            ew_func(A, randn(50), 20, name=name, min_periods=5)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewm_consistency(self, min_periods, adjust, ignore_na):
+        def _weights(s, com, adjust, ignore_na):
+            if isinstance(s, DataFrame):
+                if not len(s.columns):
+                    return DataFrame(index=s.index, columns=s.columns)
+                w = concat(
+                    [
+                        _weights(
+                            s.iloc[:, i], com=com, adjust=adjust, ignore_na=ignore_na
+                        )
+                        for i, _ in enumerate(s.columns)
+                    ],
+                    axis=1,
+                )
+                w.index = s.index
+                w.columns = s.columns
+                return w
+
+            w = Series(np.nan, index=s.index)
+            alpha = 1.0 / (1.0 + com)
+            if ignore_na:
+                w[s.notna()] = _weights(
+                    s[s.notna()], com=com, adjust=adjust, ignore_na=False
+                )
+            elif adjust:
+                for i in range(len(s)):
+                    if s.iat[i] == s.iat[i]:
+                        w.iat[i] = pow(1.0 / (1.0 - alpha), i)
+            else:
+                sum_wts = 0.0
+                prev_i = -1
+                for i in range(len(s)):
+                    if s.iat[i] == s.iat[i]:
+                        if prev_i == -1:
+                            w.iat[i] = 1.0
+                        else:
+                            w.iat[i] = alpha * sum_wts / pow(1.0 - alpha, i - prev_i)
+                        sum_wts += w.iat[i]
+                        prev_i = i
+            return w
+
+        def _variance_debiasing_factors(s, com, adjust, ignore_na):
+            weights = _weights(s, com=com, adjust=adjust, ignore_na=ignore_na)
+            cum_sum = weights.cumsum().fillna(method="ffill")
+            cum_sum_sq = (weights * weights).cumsum().fillna(method="ffill")
+            numerator = cum_sum * cum_sum
+            denominator = numerator - cum_sum_sq
+            denominator[denominator <= 0.0] = np.nan
+            return numerator / denominator
+
+        def _ewma(s, com, min_periods, adjust, ignore_na):
+            weights = _weights(s, com=com, adjust=adjust, ignore_na=ignore_na)
+            result = (
+                s.multiply(weights)
+                .cumsum()
+                .divide(weights.cumsum())
+                .fillna(method="ffill")
+            )
+            result[
+                s.expanding().count() < (max(min_periods, 1) if min_periods else 1)
+            ] = np.nan
+            return result
+
+        com = 3.0
+        self._test_moments_consistency_mock_mean(
+            mean=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).mean(),
+            mock_mean=lambda x: _ewma(
+                x, com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ),
+        )
+
+        self._test_moments_consistency_is_constant(
+            min_periods=min_periods,
+            count=lambda x: x.expanding().count(),
+            mean=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).mean(),
+            corr=lambda x, y: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).corr(y),
+        )
+
+        self._test_moments_consistency_var_debiasing_factors(
+            var_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=False)
+            ),
+            var_biased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=True)
+            ),
+            var_debiasing_factors=lambda x: (
+                _variance_debiasing_factors(
+                    x, com=com, adjust=adjust, ignore_na=ignore_na
+                )
+            ),
+        )
+        # test consistency between different ewm* moments
+        self._test_moments_consistency(
+            min_periods=min_periods,
+            count=lambda x: x.expanding().count(),
+            mean=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).mean(),
+            corr=lambda x, y: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).corr(y),
+            var_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=False)
+            ),
+            std_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).std(bias=False)
+            ),
+            cov_unbiased=lambda x, y: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).cov(y, bias=False)
+            ),
+            var_biased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=True)
+            ),
+            std_biased=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).std(bias=True),
+            cov_biased=lambda x, y: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).cov(y, bias=True)
+            ),
+        )
diff --git a/pandas/tests/window/moments/test_moments_expanding.py b/pandas/tests/window/moments/test_moments_expanding.py
new file mode 100644
index 0000000000000..9dfaecee9caeb
--- /dev/null
+++ b/pandas/tests/window/moments/test_moments_expanding.py
@@ -0,0 +1,420 @@
+import warnings
+
+import numpy as np
+from numpy.random import randn
+import pytest
+
+from pandas import DataFrame, Index, MultiIndex, Series, isna, notna
+import pandas._testing as tm
+from pandas.tests.window.common import ConsistencyBase
+
+
+class TestExpandingMomentsConsistency(ConsistencyBase):
+    def setup_method(self, method):
+        self._create_data()
+
+    def test_expanding_apply_args_kwargs(self, engine_and_raw):
+        def mean_w_arg(x, const):
+            return np.mean(x) + const
+
+        engine, raw = engine_and_raw
+
+        df = DataFrame(np.random.rand(20, 3))
+
+        expected = df.expanding().apply(np.mean, engine=engine, raw=raw) + 20.0
+
+        result = df.expanding().apply(mean_w_arg, engine=engine, raw=raw, args=(20,))
+        tm.assert_frame_equal(result, expected)
+
+        result = df.expanding().apply(mean_w_arg, raw=raw, kwargs={"const": 20})
+        tm.assert_frame_equal(result, expected)
+
+    def test_expanding_corr(self):
+        A = self.series.dropna()
+        B = (A + randn(len(A)))[:-5]
+
+        result = A.expanding().corr(B)
+
+        rolling_result = A.rolling(window=len(A), min_periods=1).corr(B)
+
+        tm.assert_almost_equal(rolling_result, result)
+
+    def test_expanding_count(self):
+        result = self.series.expanding(min_periods=0).count()
+        tm.assert_almost_equal(
+            result, self.series.rolling(window=len(self.series), min_periods=0).count()
+        )
+
+    def test_expanding_quantile(self):
+        result = self.series.expanding().quantile(0.5)
+
+        rolling_result = self.series.rolling(
+            window=len(self.series), min_periods=1
+        ).quantile(0.5)
+
+        tm.assert_almost_equal(result, rolling_result)
+
+    def test_expanding_cov(self):
+        A = self.series
+        B = (A + randn(len(A)))[:-5]
+
+        result = A.expanding().cov(B)
+
+        rolling_result = A.rolling(window=len(A), min_periods=1).cov(B)
+
+        tm.assert_almost_equal(rolling_result, result)
+
+    def test_expanding_cov_pairwise(self):
+        result = self.frame.expanding().corr()
+
+        rolling_result = self.frame.rolling(
+            window=len(self.frame), min_periods=1
+        ).corr()
+
+        tm.assert_frame_equal(result, rolling_result)
+
+    def test_expanding_corr_pairwise(self):
+        result = self.frame.expanding().corr()
+
+        rolling_result = self.frame.rolling(
+            window=len(self.frame), min_periods=1
+        ).corr()
+        tm.assert_frame_equal(result, rolling_result)
+
+    def test_expanding_cov_diff_index(self):
+        # GH 7512
+        s1 = Series([1, 2, 3], index=[0, 1, 2])
+        s2 = Series([1, 3], index=[0, 2])
+        result = s1.expanding().cov(s2)
+        expected = Series([None, None, 2.0])
+        tm.assert_series_equal(result, expected)
+
+        s2a = Series([1, None, 3], index=[0, 1, 2])
+        result = s1.expanding().cov(s2a)
+        tm.assert_series_equal(result, expected)
+
+        s1 = Series([7, 8, 10], index=[0, 1, 3])
+        s2 = Series([7, 9, 10], index=[0, 2, 3])
+        result = s1.expanding().cov(s2)
+        expected = Series([None, None, None, 4.5])
+        tm.assert_series_equal(result, expected)
+
+    def test_expanding_corr_diff_index(self):
+        # GH 7512
+        s1 = Series([1, 2, 3], index=[0, 1, 2])
+        s2 = Series([1, 3], index=[0, 2])
+        result = s1.expanding().corr(s2)
+        expected = Series([None, None, 1.0])
+        tm.assert_series_equal(result, expected)
+
+        s2a = Series([1, None, 3], index=[0, 1, 2])
+        result = s1.expanding().corr(s2a)
+        tm.assert_series_equal(result, expected)
+
+        s1 = Series([7, 8, 10], index=[0, 1, 3])
+        s2 = Series([7, 9, 10], index=[0, 2, 3])
+        result = s1.expanding().corr(s2)
+        expected = Series([None, None, None, 1.0])
+        tm.assert_series_equal(result, expected)
+
+    def test_expanding_cov_pairwise_diff_length(self):
+        # GH 7512
+        df1 = DataFrame([[1, 5], [3, 2], [3, 9]], columns=Index(["A", "B"], name="foo"))
+        df1a = DataFrame(
+            [[1, 5], [3, 9]], index=[0, 2], columns=Index(["A", "B"], name="foo")
+        )
+        df2 = DataFrame(
+            [[5, 6], [None, None], [2, 1]], columns=Index(["X", "Y"], name="foo")
+        )
+        df2a = DataFrame(
+            [[5, 6], [2, 1]], index=[0, 2], columns=Index(["X", "Y"], name="foo")
+        )
+        # TODO: xref gh-15826
+        # .loc is not preserving the names
+        result1 = df1.expanding().cov(df2, pairwise=True).loc[2]
+        result2 = df1.expanding().cov(df2a, pairwise=True).loc[2]
+        result3 = df1a.expanding().cov(df2, pairwise=True).loc[2]
+        result4 = df1a.expanding().cov(df2a, pairwise=True).loc[2]
+        expected = DataFrame(
+            [[-3.0, -6.0], [-5.0, -10.0]],
+            columns=Index(["A", "B"], name="foo"),
+            index=Index(["X", "Y"], name="foo"),
+        )
+        tm.assert_frame_equal(result1, expected)
+        tm.assert_frame_equal(result2, expected)
+        tm.assert_frame_equal(result3, expected)
+        tm.assert_frame_equal(result4, expected)
+
+    def test_expanding_corr_pairwise_diff_length(self):
+        # GH 7512
+        df1 = DataFrame(
+            [[1, 2], [3, 2], [3, 4]],
+            columns=["A", "B"],
+            index=Index(range(3), name="bar"),
+        )
+        df1a = DataFrame(
+            [[1, 2], [3, 4]], index=Index([0, 2], name="bar"), columns=["A", "B"]
+        )
+        df2 = DataFrame(
+            [[5, 6], [None, None], [2, 1]],
+            columns=["X", "Y"],
+            index=Index(range(3), name="bar"),
+        )
+        df2a = DataFrame(
+            [[5, 6], [2, 1]], index=Index([0, 2], name="bar"), columns=["X", "Y"]
+        )
+        result1 = df1.expanding().corr(df2, pairwise=True).loc[2]
+        result2 = df1.expanding().corr(df2a, pairwise=True).loc[2]
+        result3 = df1a.expanding().corr(df2, pairwise=True).loc[2]
+        result4 = df1a.expanding().corr(df2a, pairwise=True).loc[2]
+        expected = DataFrame(
+            [[-1.0, -1.0], [-1.0, -1.0]], columns=["A", "B"], index=Index(["X", "Y"])
+        )
+        tm.assert_frame_equal(result1, expected)
+        tm.assert_frame_equal(result2, expected)
+        tm.assert_frame_equal(result3, expected)
+        tm.assert_frame_equal(result4, expected)
+
+    @pytest.mark.parametrize("has_min_periods", [True, False])
+    @pytest.mark.parametrize(
+        "func,static_comp",
+        [("sum", np.sum), ("mean", np.mean), ("max", np.max), ("min", np.min)],
+        ids=["sum", "mean", "max", "min"],
+    )
+    def test_expanding_func(self, func, static_comp, has_min_periods):
+        def expanding_func(x, min_periods=1, center=False, axis=0):
+            exp = x.expanding(min_periods=min_periods, center=center, axis=axis)
+            return getattr(exp, func)()
+
+        self._check_expanding(expanding_func, static_comp, preserve_nan=False)
+        self._check_expanding_has_min_periods(
+            expanding_func, static_comp, has_min_periods
+        )
+
+    @pytest.mark.parametrize("has_min_periods", [True, False])
+    def test_expanding_apply(self, engine_and_raw, has_min_periods):
+
+        engine, raw = engine_and_raw
+
+        def expanding_mean(x, min_periods=1):
+
+            exp = x.expanding(min_periods=min_periods)
+            result = exp.apply(lambda x: x.mean(), raw=raw, engine=engine)
+            return result
+
+        # TODO(jreback), needed to add preserve_nan=False
+        # here to make this pass
+        self._check_expanding(expanding_mean, np.mean, preserve_nan=False)
+        self._check_expanding_has_min_periods(expanding_mean, np.mean, has_min_periods)
+
+    def test_expanding_apply_empty_series(self, engine_and_raw):
+        engine, raw = engine_and_raw
+        ser = Series([], dtype=np.float64)
+        tm.assert_series_equal(
+            ser, ser.expanding().apply(lambda x: x.mean(), raw=raw, engine=engine)
+        )
+
+    def test_expanding_apply_min_periods_0(self, engine_and_raw):
+        # GH 8080
+        engine, raw = engine_and_raw
+        s = Series([None, None, None])
+        result = s.expanding(min_periods=0).apply(
+            lambda x: len(x), raw=raw, engine=engine
+        )
+        expected = Series([1.0, 2.0, 3.0])
+        tm.assert_series_equal(result, expected)
+
+    def _check_expanding(self, func, static_comp, preserve_nan=True):
+
+        series_result = func(self.series)
+        assert isinstance(series_result, Series)
+        frame_result = func(self.frame)
+        assert isinstance(frame_result, DataFrame)
+
+        result = func(self.series)
+        tm.assert_almost_equal(result[10], static_comp(self.series[:11]))
+
+        if preserve_nan:
+            assert result.iloc[self._nan_locs].isna().all()
+
+    def _check_expanding_has_min_periods(self, func, static_comp, has_min_periods):
+        ser = Series(randn(50))
+
+        if has_min_periods:
+            result = func(ser, min_periods=30)
+            assert result[:29].isna().all()
+            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+
+            # min_periods is working correctly
+            result = func(ser, min_periods=15)
+            assert isna(result.iloc[13])
+            assert notna(result.iloc[14])
+
+            ser2 = Series(randn(20))
+            result = func(ser2, min_periods=5)
+            assert isna(result[3])
+            assert notna(result[4])
+
+            # min_periods=0
+            result0 = func(ser, min_periods=0)
+            result1 = func(ser, min_periods=1)
+            tm.assert_almost_equal(result0, result1)
+        else:
+            result = func(ser)
+            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x: x.expanding().count(),
+            lambda x: x.expanding(min_periods=5).cov(x, pairwise=False),
+            lambda x: x.expanding(min_periods=5).corr(x, pairwise=False),
+            lambda x: x.expanding(min_periods=5).max(),
+            lambda x: x.expanding(min_periods=5).min(),
+            lambda x: x.expanding(min_periods=5).sum(),
+            lambda x: x.expanding(min_periods=5).mean(),
+            lambda x: x.expanding(min_periods=5).std(),
+            lambda x: x.expanding(min_periods=5).var(),
+            lambda x: x.expanding(min_periods=5).skew(),
+            lambda x: x.expanding(min_periods=5).kurt(),
+            lambda x: x.expanding(min_periods=5).quantile(0.5),
+            lambda x: x.expanding(min_periods=5).median(),
+            lambda x: x.expanding(min_periods=5).apply(sum, raw=False),
+            lambda x: x.expanding(min_periods=5).apply(sum, raw=True),
+        ],
+    )
+    def test_moment_functions_zero_length(self, f):
+        # GH 8056
+        s = Series(dtype=np.float64)
+        s_expected = s
+        df1 = DataFrame()
+        df1_expected = df1
+        df2 = DataFrame(columns=["a"])
+        df2["a"] = df2["a"].astype("float64")
+        df2_expected = df2
+
+        s_result = f(s)
+        tm.assert_series_equal(s_result, s_expected)
+
+        df1_result = f(df1)
+        tm.assert_frame_equal(df1_result, df1_expected)
+
+        df2_result = f(df2)
+        tm.assert_frame_equal(df2_result, df2_expected)
+
+    @pytest.mark.parametrize(
+        "f",
+        [
+            lambda x: (x.expanding(min_periods=5).cov(x, pairwise=True)),
+            lambda x: (x.expanding(min_periods=5).corr(x, pairwise=True)),
+        ],
+    )
+    def test_moment_functions_zero_length_pairwise(self, f):
+
+        df1 = DataFrame()
+        df2 = DataFrame(columns=Index(["a"], name="foo"), index=Index([], name="bar"))
+        df2["a"] = df2["a"].astype("float64")
+
+        df1_expected = DataFrame(
+            index=MultiIndex.from_product([df1.index, df1.columns]), columns=Index([])
+        )
+        df2_expected = DataFrame(
+            index=MultiIndex.from_product(
+                [df2.index, df2.columns], names=["bar", "foo"]
+            ),
+            columns=Index(["a"], name="foo"),
+            dtype="float64",
+        )
+
+        df1_result = f(df1)
+        tm.assert_frame_equal(df1_result, df1_expected)
+
+        df2_result = f(df2)
+        tm.assert_frame_equal(df2_result, df2_expected)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    def test_expanding_consistency(self, min_periods):
+
+        # suppress warnings about empty slices, as we are deliberately testing
+        # with empty/0-length Series/DataFrames
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=".*(empty slice|0 for slice).*",
+                category=RuntimeWarning,
+            )
+
+            # test consistency between different expanding_* moments
+            self._test_moments_consistency_mock_mean(
+                mean=lambda x: x.expanding(min_periods=min_periods).mean(),
+                mock_mean=lambda x: x.expanding(min_periods=min_periods).sum()
+                / x.expanding().count(),
+            )
+
+            self._test_moments_consistency_is_constant(
+                min_periods=min_periods,
+                count=lambda x: x.expanding().count(),
+                mean=lambda x: x.expanding(min_periods=min_periods).mean(),
+                corr=lambda x, y: x.expanding(min_periods=min_periods).corr(y),
+            )
+
+            self._test_moments_consistency_var_debiasing_factors(
+                var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+                var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+                var_debiasing_factors=lambda x: (
+                    x.expanding().count()
+                    / (x.expanding().count() - 1.0).replace(0.0, np.nan)
+                ),
+            )
+            self._test_moments_consistency(
+                min_periods=min_periods,
+                count=lambda x: x.expanding(min_periods=min_periods).count(),
+                mean=lambda x: x.expanding(min_periods=min_periods).mean(),
+                corr=lambda x, y: x.expanding(min_periods=min_periods).corr(y),
+                var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+                std_unbiased=lambda x: x.expanding(min_periods=min_periods).std(),
+                cov_unbiased=lambda x, y: x.expanding(min_periods=min_periods).cov(y),
+                var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+                std_biased=lambda x: x.expanding(min_periods=min_periods).std(ddof=0),
+                cov_biased=lambda x, y: x.expanding(min_periods=min_periods).cov(
+                    y, ddof=0
+                ),
+            )
+
+            # test consistency between expanding_xyz() and either (a)
+            # expanding_apply of Series.xyz(), or (b) expanding_apply of
+            # np.nanxyz()
+            for (x, is_constant, no_nans) in self.data:
+                functions = self.base_functions
+
+                # GH 8269
+                if no_nans:
+                    functions = self.base_functions + self.no_nan_functions
+                for (f, require_min_periods, name) in functions:
+                    expanding_f = getattr(x.expanding(min_periods=min_periods), name)
+
+                    if (
+                        require_min_periods
+                        and (min_periods is not None)
+                        and (min_periods < require_min_periods)
+                    ):
+                        continue
+
+                    if name == "count":
+                        expanding_f_result = expanding_f()
+                        expanding_apply_f_result = x.expanding(min_periods=0).apply(
+                            func=f, raw=True
+                        )
+                    else:
+                        if name in ["cov", "corr"]:
+                            expanding_f_result = expanding_f(pairwise=False)
+                        else:
+                            expanding_f_result = expanding_f()
+                        expanding_apply_f_result = x.expanding(
+                            min_periods=min_periods
+                        ).apply(func=f, raw=True)
+
+                    # GH 9422
+                    if name in ["sum", "prod"]:
+                        tm.assert_equal(expanding_f_result, expanding_apply_f_result)
diff --git a/pandas/tests/window/test_moments.py b/pandas/tests/window/moments/test_moments_rolling.py
similarity index 51%
rename from pandas/tests/window/test_moments.py
rename to pandas/tests/window/moments/test_moments_rolling.py
index 3d6cd7d10bd10..83e4ee25558b5 100644
--- a/pandas/tests/window/test_moments.py
+++ b/pandas/tests/window/moments/test_moments_rolling.py
@@ -9,10 +9,10 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-from pandas import DataFrame, Index, Series, concat, isna, notna
+from pandas import DataFrame, Index, Series, isna, notna
+import pandas._testing as tm
 from pandas.core.window.common import _flex_binary_moment
-from pandas.tests.window.common import Base
-import pandas.util.testing as tm
+from pandas.tests.window.common import Base, ConsistencyBase
 
 import pandas.tseries.offsets as offsets
 
@@ -108,7 +108,7 @@ def test_cmov_window_corner(self):
         assert np.isnan(result).all()
 
         # empty
-        vals = pd.Series([])
+        vals = pd.Series([], dtype=object)
         result = vals.rolling(5, center=True, win_type="boxcar").mean()
         assert len(result) == 0
 
@@ -119,64 +119,95 @@ def test_cmov_window_corner(self):
         assert len(result) == 5
 
     @td.skip_if_no_scipy
-    def test_cmov_window_frame(self):
+    @pytest.mark.parametrize(
+        "f,xp",
+        [
+            (
+                "mean",
+                [
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                    [9.252, 9.392],
+                    [8.644, 9.906],
+                    [8.87, 10.208],
+                    [6.81, 8.588],
+                    [7.792, 8.644],
+                    [9.05, 7.824],
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                ],
+            ),
+            (
+                "std",
+                [
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                    [3.789706, 4.068313],
+                    [3.429232, 3.237411],
+                    [3.589269, 3.220810],
+                    [3.405195, 2.380655],
+                    [3.281839, 2.369869],
+                    [3.676846, 1.801799],
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                ],
+            ),
+            (
+                "var",
+                [
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                    [14.36187, 16.55117],
+                    [11.75963, 10.48083],
+                    [12.88285, 10.37362],
+                    [11.59535, 5.66752],
+                    [10.77047, 5.61628],
+                    [13.51920, 3.24648],
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                ],
+            ),
+            (
+                "sum",
+                [
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                    [46.26, 46.96],
+                    [43.22, 49.53],
+                    [44.35, 51.04],
+                    [34.05, 42.94],
+                    [38.96, 43.22],
+                    [45.25, 39.12],
+                    [np.nan, np.nan],
+                    [np.nan, np.nan],
+                ],
+            ),
+        ],
+    )
+    def test_cmov_window_frame(self, f, xp):
         # Gh 8238
-        vals = np.array(
-            [
-                [12.18, 3.64],
-                [10.18, 9.16],
-                [13.24, 14.61],
-                [4.51, 8.11],
-                [6.15, 11.44],
-                [9.14, 6.21],
-                [11.31, 10.67],
-                [2.94, 6.51],
-                [9.42, 8.39],
-                [12.44, 7.34],
-            ]
-        )
-
-        xp = np.array(
-            [
-                [np.nan, np.nan],
-                [np.nan, np.nan],
-                [9.252, 9.392],
-                [8.644, 9.906],
-                [8.87, 10.208],
-                [6.81, 8.588],
-                [7.792, 8.644],
-                [9.05, 7.824],
-                [np.nan, np.nan],
-                [np.nan, np.nan],
-            ]
+        df = DataFrame(
+            np.array(
+                [
+                    [12.18, 3.64],
+                    [10.18, 9.16],
+                    [13.24, 14.61],
+                    [4.51, 8.11],
+                    [6.15, 11.44],
+                    [9.14, 6.21],
+                    [11.31, 10.67],
+                    [2.94, 6.51],
+                    [9.42, 8.39],
+                    [12.44, 7.34],
+                ]
+            )
         )
+        xp = DataFrame(np.array(xp))
 
-        # DataFrame
-        rs = DataFrame(vals).rolling(5, win_type="boxcar", center=True).mean()
-        tm.assert_frame_equal(DataFrame(xp), rs)
+        roll = df.rolling(5, win_type="boxcar", center=True)
+        rs = getattr(roll, f)()
 
-        # invalid method
-        with pytest.raises(AttributeError):
-            (DataFrame(vals).rolling(5, win_type="boxcar", center=True).std())
-
-        # sum
-        xp = np.array(
-            [
-                [np.nan, np.nan],
-                [np.nan, np.nan],
-                [46.26, 46.96],
-                [43.22, 49.53],
-                [44.35, 51.04],
-                [34.05, 42.94],
-                [38.96, 43.22],
-                [45.25, 39.12],
-                [np.nan, np.nan],
-                [np.nan, np.nan],
-            ]
-        )
-
-        rs = DataFrame(vals).rolling(5, win_type="boxcar", center=True).sum()
-        tm.assert_frame_equal(DataFrame(xp), rs)
+        tm.assert_frame_equal(xp, rs)
 
     @td.skip_if_no_scipy
     def test_cmov_window_na_min_periods(self):
@@ -643,64 +674,6 @@ def f(x):
 
         self._check_moment_func(np.mean, name="apply", func=f, raw=raw)
 
-        expected = Series([])
-        result = expected.rolling(10).apply(lambda x: x.mean(), raw=raw)
-        tm.assert_series_equal(result, expected)
-
-        # gh-8080
-        s = Series([None, None, None])
-        result = s.rolling(2, min_periods=0).apply(lambda x: len(x), raw=raw)
-        expected = Series([1.0, 2.0, 2.0])
-        tm.assert_series_equal(result, expected)
-
-        result = s.rolling(2, min_periods=0).apply(len, raw=raw)
-        tm.assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("klass", [Series, DataFrame])
-    @pytest.mark.parametrize(
-        "method", [lambda x: x.rolling(window=2), lambda x: x.expanding()]
-    )
-    def test_apply_future_warning(self, klass, method):
-
-        # gh-5071
-        s = klass(np.arange(3))
-
-        with tm.assert_produces_warning(FutureWarning):
-            method(s).apply(lambda x: len(x))
-
-    def test_rolling_apply_out_of_bounds(self, raw):
-        # gh-1850
-        vals = pd.Series([1, 2, 3, 4])
-
-        result = vals.rolling(10).apply(np.sum, raw=raw)
-        assert result.isna().all()
-
-        result = vals.rolling(10, min_periods=1).apply(np.sum, raw=raw)
-        expected = pd.Series([1, 3, 6, 10], dtype=float)
-        tm.assert_almost_equal(result, expected)
-
-    @pytest.mark.parametrize("window", [2, "2s"])
-    def test_rolling_apply_with_pandas_objects(self, window):
-        # 5071
-        df = pd.DataFrame(
-            {"A": np.random.randn(5), "B": np.random.randint(0, 10, size=5)},
-            index=pd.date_range("20130101", periods=5, freq="s"),
-        )
-
-        # we have an equal spaced timeseries index
-        # so simulate removing the first period
-        def f(x):
-            if x.index[0] == df.index[0]:
-                return np.nan
-            return x.iloc[-1]
-
-        result = df.rolling(window).apply(f, raw=False)
-        expected = df.iloc[2:].reindex_like(df)
-        tm.assert_frame_equal(result, expected)
-
-        with pytest.raises(AttributeError):
-            df.rolling(window).apply(f, raw=True)
-
     def test_rolling_std(self, raw):
         self._check_moment_func(lambda x: np.std(x, ddof=1), name="std", raw=raw)
         self._check_moment_func(
@@ -769,7 +742,7 @@ def _check_moment_func(
         has_time_rule=True,
         fill_value=None,
         zero_min_periods_equal=True,
-        **kwargs
+        **kwargs,
     ):
 
         # inject raw
@@ -804,8 +777,8 @@ def get_result(obj, window, min_periods=None, center=False):
                 series_result = get_result(series, window=win, min_periods=minp)
                 frame_result = get_result(frame, window=win, min_periods=minp)
             else:
-                series_result = get_result(series, window=win)
-                frame_result = get_result(frame, window=win)
+                series_result = get_result(series, window=win, min_periods=0)
+                frame_result = get_result(frame, window=win, min_periods=0)
 
             last_date = series_result.index[-1]
             prev_date = last_date - 24 * offsets.BDay()
@@ -862,8 +835,8 @@ def get_result(obj, window, min_periods=None, center=False):
                 nan_mask = ~nan_mask
                 tm.assert_almost_equal(result[nan_mask], expected[nan_mask])
         else:
-            result = get_result(self.series, len(self.series) + 1)
-            expected = get_result(self.series, len(self.series))
+            result = get_result(self.series, len(self.series) + 1, min_periods=0)
+            expected = get_result(self.series, len(self.series), min_periods=0)
             nan_mask = isna(result)
             tm.assert_series_equal(nan_mask, isna(expected))
 
@@ -878,10 +851,11 @@ def get_result(obj, window, min_periods=None, center=False):
                     pd.concat([obj, Series([np.NaN] * 9)]), 20, min_periods=15
                 )[9:].reset_index(drop=True)
             else:
-                result = get_result(obj, 20, center=True)
-                expected = get_result(pd.concat([obj, Series([np.NaN] * 9)]), 20)[
-                    9:
-                ].reset_index(drop=True)
+                result = get_result(obj, 20, min_periods=0, center=True)
+                print(result)
+                expected = get_result(
+                    pd.concat([obj, Series([np.NaN] * 9)]), 20, min_periods=0
+                )[9:].reset_index(drop=True)
 
             tm.assert_series_equal(result, expected)
 
@@ -920,21 +894,27 @@ def get_result(obj, window, min_periods=None, center=False):
             else:
                 series_xp = (
                     get_result(
-                        self.series.reindex(list(self.series.index) + s), window=25
+                        self.series.reindex(list(self.series.index) + s),
+                        window=25,
+                        min_periods=0,
                     )
                     .shift(-12)
                     .reindex(self.series.index)
                 )
                 frame_xp = (
                     get_result(
-                        self.frame.reindex(list(self.frame.index) + s), window=25
+                        self.frame.reindex(list(self.frame.index) + s),
+                        window=25,
+                        min_periods=0,
                     )
                     .shift(-12)
                     .reindex(self.frame.index)
                 )
 
-                series_rs = get_result(self.series, window=25, center=True)
-                frame_rs = get_result(self.frame, window=25, center=True)
+                series_rs = get_result(
+                    self.series, window=25, min_periods=0, center=True
+                )
+                frame_rs = get_result(self.frame, window=25, min_periods=0, center=True)
 
             if fill_value is not None:
                 series_xp = series_xp.fillna(fill_value)
@@ -942,398 +922,6 @@ def get_result(obj, window, min_periods=None, center=False):
             tm.assert_series_equal(series_xp, series_rs)
             tm.assert_frame_equal(frame_xp, frame_rs)
 
-    def test_ewma(self):
-        self._check_ew(name="mean")
-
-        vals = pd.Series(np.zeros(1000))
-        vals[5] = 1
-        result = vals.ewm(span=100, adjust=False).mean().sum()
-        assert np.abs(result - 1) < 1e-2
-
-    @pytest.mark.parametrize("adjust", [True, False])
-    @pytest.mark.parametrize("ignore_na", [True, False])
-    def test_ewma_cases(self, adjust, ignore_na):
-        # try adjust/ignore_na args matrix
-
-        s = Series([1.0, 2.0, 4.0, 8.0])
-
-        if adjust:
-            expected = Series([1.0, 1.6, 2.736842, 4.923077])
-        else:
-            expected = Series([1.0, 1.333333, 2.222222, 4.148148])
-
-        result = s.ewm(com=2.0, adjust=adjust, ignore_na=ignore_na).mean()
-        tm.assert_series_equal(result, expected)
-
-    def test_ewma_nan_handling(self):
-        s = Series([1.0] + [np.nan] * 5 + [1.0])
-        result = s.ewm(com=5).mean()
-        tm.assert_series_equal(result, Series([1.0] * len(s)))
-
-        s = Series([np.nan] * 2 + [1.0] + [np.nan] * 2 + [1.0])
-        result = s.ewm(com=5).mean()
-        tm.assert_series_equal(result, Series([np.nan] * 2 + [1.0] * 4))
-
-        # GH 7603
-        s0 = Series([np.nan, 1.0, 101.0])
-        s1 = Series([1.0, np.nan, 101.0])
-        s2 = Series([np.nan, 1.0, np.nan, np.nan, 101.0, np.nan])
-        s3 = Series([1.0, np.nan, 101.0, 50.0])
-        com = 2.0
-        alpha = 1.0 / (1.0 + com)
-
-        def simple_wma(s, w):
-            return (s.multiply(w).cumsum() / w.cumsum()).fillna(method="ffill")
-
-        for (s, adjust, ignore_na, w) in [
-            (s0, True, False, [np.nan, (1.0 - alpha), 1.0]),
-            (s0, True, True, [np.nan, (1.0 - alpha), 1.0]),
-            (s0, False, False, [np.nan, (1.0 - alpha), alpha]),
-            (s0, False, True, [np.nan, (1.0 - alpha), alpha]),
-            (s1, True, False, [(1.0 - alpha) ** 2, np.nan, 1.0]),
-            (s1, True, True, [(1.0 - alpha), np.nan, 1.0]),
-            (s1, False, False, [(1.0 - alpha) ** 2, np.nan, alpha]),
-            (s1, False, True, [(1.0 - alpha), np.nan, alpha]),
-            (
-                s2,
-                True,
-                False,
-                [np.nan, (1.0 - alpha) ** 3, np.nan, np.nan, 1.0, np.nan],
-            ),
-            (s2, True, True, [np.nan, (1.0 - alpha), np.nan, np.nan, 1.0, np.nan]),
-            (
-                s2,
-                False,
-                False,
-                [np.nan, (1.0 - alpha) ** 3, np.nan, np.nan, alpha, np.nan],
-            ),
-            (s2, False, True, [np.nan, (1.0 - alpha), np.nan, np.nan, alpha, np.nan]),
-            (s3, True, False, [(1.0 - alpha) ** 3, np.nan, (1.0 - alpha), 1.0]),
-            (s3, True, True, [(1.0 - alpha) ** 2, np.nan, (1.0 - alpha), 1.0]),
-            (
-                s3,
-                False,
-                False,
-                [
-                    (1.0 - alpha) ** 3,
-                    np.nan,
-                    (1.0 - alpha) * alpha,
-                    alpha * ((1.0 - alpha) ** 2 + alpha),
-                ],
-            ),
-            (
-                s3,
-                False,
-                True,
-                [(1.0 - alpha) ** 2, np.nan, (1.0 - alpha) * alpha, alpha],
-            ),
-        ]:
-            expected = simple_wma(s, Series(w))
-            result = s.ewm(com=com, adjust=adjust, ignore_na=ignore_na).mean()
-
-            tm.assert_series_equal(result, expected)
-            if ignore_na is False:
-                # check that ignore_na defaults to False
-                result = s.ewm(com=com, adjust=adjust).mean()
-                tm.assert_series_equal(result, expected)
-
-    def test_ewmvar(self):
-        self._check_ew(name="var")
-
-    def test_ewmvol(self):
-        self._check_ew(name="vol")
-
-    def test_ewma_span_com_args(self):
-        A = self.series.ewm(com=9.5).mean()
-        B = self.series.ewm(span=20).mean()
-        tm.assert_almost_equal(A, B)
-
-        with pytest.raises(ValueError):
-            self.series.ewm(com=9.5, span=20)
-        with pytest.raises(ValueError):
-            self.series.ewm().mean()
-
-    def test_ewma_halflife_arg(self):
-        A = self.series.ewm(com=13.932726172912965).mean()
-        B = self.series.ewm(halflife=10.0).mean()
-        tm.assert_almost_equal(A, B)
-
-        with pytest.raises(ValueError):
-            self.series.ewm(span=20, halflife=50)
-        with pytest.raises(ValueError):
-            self.series.ewm(com=9.5, halflife=50)
-        with pytest.raises(ValueError):
-            self.series.ewm(com=9.5, span=20, halflife=50)
-        with pytest.raises(ValueError):
-            self.series.ewm()
-
-    def test_ewm_alpha(self):
-        # GH 10789
-        s = Series(self.arr)
-        a = s.ewm(alpha=0.61722699889169674).mean()
-        b = s.ewm(com=0.62014947789973052).mean()
-        c = s.ewm(span=2.240298955799461).mean()
-        d = s.ewm(halflife=0.721792864318).mean()
-        tm.assert_series_equal(a, b)
-        tm.assert_series_equal(a, c)
-        tm.assert_series_equal(a, d)
-
-    def test_ewm_alpha_arg(self):
-        # GH 10789
-        s = self.series
-        with pytest.raises(ValueError):
-            s.ewm()
-        with pytest.raises(ValueError):
-            s.ewm(com=10.0, alpha=0.5)
-        with pytest.raises(ValueError):
-            s.ewm(span=10.0, alpha=0.5)
-        with pytest.raises(ValueError):
-            s.ewm(halflife=10.0, alpha=0.5)
-
-    def test_ewm_domain_checks(self):
-        # GH 12492
-        s = Series(self.arr)
-        msg = "comass must satisfy: comass >= 0"
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(com=-0.1)
-        s.ewm(com=0.0)
-        s.ewm(com=0.1)
-
-        msg = "span must satisfy: span >= 1"
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(span=-0.1)
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(span=0.0)
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(span=0.9)
-        s.ewm(span=1.0)
-        s.ewm(span=1.1)
-
-        msg = "halflife must satisfy: halflife > 0"
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(halflife=-0.1)
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(halflife=0.0)
-        s.ewm(halflife=0.1)
-
-        msg = "alpha must satisfy: 0 < alpha <= 1"
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(alpha=-0.1)
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(alpha=0.0)
-        s.ewm(alpha=0.1)
-        s.ewm(alpha=1.0)
-        with pytest.raises(ValueError, match=msg):
-            s.ewm(alpha=1.1)
-
-    @pytest.mark.parametrize("method", ["mean", "vol", "var"])
-    def test_ew_empty_series(self, method):
-        vals = pd.Series([], dtype=np.float64)
-
-        ewm = vals.ewm(3)
-        result = getattr(ewm, method)()
-        tm.assert_almost_equal(result, vals)
-
-    def _check_ew(self, name=None, preserve_nan=False):
-        series_result = getattr(self.series.ewm(com=10), name)()
-        assert isinstance(series_result, Series)
-
-        frame_result = getattr(self.frame.ewm(com=10), name)()
-        assert type(frame_result) == DataFrame
-
-        result = getattr(self.series.ewm(com=10), name)()
-        if preserve_nan:
-            assert result[self._nan_locs].isna().all()
-
-        # excluding NaNs correctly
-        arr = randn(50)
-        arr[:10] = np.NaN
-        arr[-10:] = np.NaN
-        s = Series(arr)
-
-        # check min_periods
-        # GH 7898
-        result = getattr(s.ewm(com=50, min_periods=2), name)()
-        assert result[:11].isna().all()
-        assert not result[11:].isna().any()
-
-        for min_periods in (0, 1):
-            result = getattr(s.ewm(com=50, min_periods=min_periods), name)()
-            if name == "mean":
-                assert result[:10].isna().all()
-                assert not result[10:].isna().any()
-            else:
-                # ewm.std, ewm.vol, ewm.var (with bias=False) require at least
-                # two values
-                assert result[:11].isna().all()
-                assert not result[11:].isna().any()
-
-            # check series of length 0
-            result = getattr(Series().ewm(com=50, min_periods=min_periods), name)()
-            tm.assert_series_equal(result, Series())
-
-            # check series of length 1
-            result = getattr(Series([1.0]).ewm(50, min_periods=min_periods), name)()
-            if name == "mean":
-                tm.assert_series_equal(result, Series([1.0]))
-            else:
-                # ewm.std, ewm.vol, ewm.var with bias=False require at least
-                # two values
-                tm.assert_series_equal(result, Series([np.NaN]))
-
-        # pass in ints
-        result2 = getattr(Series(np.arange(50)).ewm(span=10), name)()
-        assert result2.dtype == np.float_
-
-
-# create the data only once as we are not setting it
-def _create_consistency_data():
-    def create_series():
-        return [
-            Series(),
-            Series([np.nan]),
-            Series([np.nan, np.nan]),
-            Series([3.0]),
-            Series([np.nan, 3.0]),
-            Series([3.0, np.nan]),
-            Series([1.0, 3.0]),
-            Series([2.0, 2.0]),
-            Series([3.0, 1.0]),
-            Series(
-                [5.0, 5.0, 5.0, 5.0, np.nan, np.nan, np.nan, 5.0, 5.0, np.nan, np.nan]
-            ),
-            Series(
-                [
-                    np.nan,
-                    5.0,
-                    5.0,
-                    5.0,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    5.0,
-                    5.0,
-                    np.nan,
-                    np.nan,
-                ]
-            ),
-            Series(
-                [
-                    np.nan,
-                    np.nan,
-                    5.0,
-                    5.0,
-                    np.nan,
-                    np.nan,
-                    np.nan,
-                    5.0,
-                    5.0,
-                    np.nan,
-                    np.nan,
-                ]
-            ),
-            Series(
-                [
-                    np.nan,
-                    3.0,
-                    np.nan,
-                    3.0,
-                    4.0,
-                    5.0,
-                    6.0,
-                    np.nan,
-                    np.nan,
-                    7.0,
-                    12.0,
-                    13.0,
-                    14.0,
-                    15.0,
-                ]
-            ),
-            Series(
-                [
-                    np.nan,
-                    5.0,
-                    np.nan,
-                    2.0,
-                    4.0,
-                    0.0,
-                    9.0,
-                    np.nan,
-                    np.nan,
-                    3.0,
-                    12.0,
-                    13.0,
-                    14.0,
-                    15.0,
-                ]
-            ),
-            Series(
-                [
-                    2.0,
-                    3.0,
-                    np.nan,
-                    3.0,
-                    4.0,
-                    5.0,
-                    6.0,
-                    np.nan,
-                    np.nan,
-                    7.0,
-                    12.0,
-                    13.0,
-                    14.0,
-                    15.0,
-                ]
-            ),
-            Series(
-                [
-                    2.0,
-                    5.0,
-                    np.nan,
-                    2.0,
-                    4.0,
-                    0.0,
-                    9.0,
-                    np.nan,
-                    np.nan,
-                    3.0,
-                    12.0,
-                    13.0,
-                    14.0,
-                    15.0,
-                ]
-            ),
-            Series(range(10)),
-            Series(range(20, 0, -2)),
-        ]
-
-    def create_dataframes():
-        return [
-            DataFrame(),
-            DataFrame(columns=["a"]),
-            DataFrame(columns=["a", "a"]),
-            DataFrame(columns=["a", "b"]),
-            DataFrame(np.arange(10).reshape((5, 2))),
-            DataFrame(np.arange(25).reshape((5, 5))),
-            DataFrame(np.arange(25).reshape((5, 5)), columns=["a", "b", 99, "d", "d"]),
-        ] + [DataFrame(s) for s in create_series()]
-
-    def is_constant(x):
-        values = x.values.ravel()
-        return len(set(values[notna(values)])) == 1
-
-    def no_nans(x):
-        return x.notna().all().all()
-
-    # data is a tuple(object, is_constant, no_nans)
-    data = create_series() + create_dataframes()
-
-    return [(x, is_constant(x), no_nans(x)) for x in data]
-
-
-_consistency_data = _create_consistency_data()
-
 
 def _rolling_consistency_cases():
     for window in [1, 2, 3, 10, 20]:
@@ -1344,363 +932,10 @@ def _rolling_consistency_cases():
                 yield window, min_periods, center
 
 
-class TestMomentsConsistency(Base):
-    base_functions = [
-        (lambda v: Series(v).count(), None, "count"),
-        (lambda v: Series(v).max(), None, "max"),
-        (lambda v: Series(v).min(), None, "min"),
-        (lambda v: Series(v).sum(), None, "sum"),
-        (lambda v: Series(v).mean(), None, "mean"),
-        (lambda v: Series(v).std(), 1, "std"),
-        (lambda v: Series(v).cov(Series(v)), None, "cov"),
-        (lambda v: Series(v).corr(Series(v)), None, "corr"),
-        (lambda v: Series(v).var(), 1, "var"),
-        # restore once GH 8086 is fixed
-        # lambda v: Series(v).skew(), 3, 'skew'),
-        # (lambda v: Series(v).kurt(), 4, 'kurt'),
-        # restore once GH 8084 is fixed
-        # lambda v: Series(v).quantile(0.3), None, 'quantile'),
-        (lambda v: Series(v).median(), None, "median"),
-        (np.nanmax, 1, "max"),
-        (np.nanmin, 1, "min"),
-        (np.nansum, 1, "sum"),
-        (np.nanmean, 1, "mean"),
-        (lambda v: np.nanstd(v, ddof=1), 1, "std"),
-        (lambda v: np.nanvar(v, ddof=1), 1, "var"),
-        (np.nanmedian, 1, "median"),
-    ]
-    no_nan_functions = [
-        (np.max, None, "max"),
-        (np.min, None, "min"),
-        (np.sum, None, "sum"),
-        (np.mean, None, "mean"),
-        (lambda v: np.std(v, ddof=1), 1, "std"),
-        (lambda v: np.var(v, ddof=1), 1, "var"),
-        (np.median, None, "median"),
-    ]
-
-    def _create_data(self):
-        super()._create_data()
-        self.data = _consistency_data
-
+class TestRollingMomentsConsistency(ConsistencyBase):
     def setup_method(self, method):
         self._create_data()
 
-    def _test_moments_consistency(
-        self,
-        min_periods,
-        count,
-        mean,
-        mock_mean,
-        corr,
-        var_unbiased=None,
-        std_unbiased=None,
-        cov_unbiased=None,
-        var_biased=None,
-        std_biased=None,
-        cov_biased=None,
-        var_debiasing_factors=None,
-    ):
-        def _non_null_values(x):
-            values = x.values.ravel()
-            return set(values[notna(values)].tolist())
-
-        for (x, is_constant, no_nans) in self.data:
-            count_x = count(x)
-            mean_x = mean(x)
-
-            if mock_mean:
-                # check that mean equals mock_mean
-                expected = mock_mean(x)
-                tm.assert_equal(mean_x, expected.astype("float64"))
-
-            # check that correlation of a series with itself is either 1 or NaN
-            corr_x_x = corr(x, x)
-
-            # assert _non_null_values(corr_x_x).issubset(set([1.]))
-            # restore once rolling_cov(x, x) is identically equal to var(x)
-
-            if is_constant:
-                exp = x.max() if isinstance(x, Series) else x.max().max()
-
-                # check mean of constant series
-                expected = x * np.nan
-                expected[count_x >= max(min_periods, 1)] = exp
-                tm.assert_equal(mean_x, expected)
-
-                # check correlation of constant series with itself is NaN
-                expected[:] = np.nan
-                tm.assert_equal(corr_x_x, expected)
-
-            if var_unbiased and var_biased and var_debiasing_factors:
-                # check variance debiasing factors
-                var_unbiased_x = var_unbiased(x)
-                var_biased_x = var_biased(x)
-                var_debiasing_factors_x = var_debiasing_factors(x)
-                tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
-
-            for (std, var, cov) in [
-                (std_biased, var_biased, cov_biased),
-                (std_unbiased, var_unbiased, cov_unbiased),
-            ]:
-
-                # check that var(x), std(x), and cov(x) are all >= 0
-                var_x = var(x)
-                std_x = std(x)
-                assert not (var_x < 0).any().any()
-                assert not (std_x < 0).any().any()
-                if cov:
-                    cov_x_x = cov(x, x)
-                    assert not (cov_x_x < 0).any().any()
-
-                    # check that var(x) == cov(x, x)
-                    tm.assert_equal(var_x, cov_x_x)
-
-                # check that var(x) == std(x)^2
-                tm.assert_equal(var_x, std_x * std_x)
-
-                if var is var_biased:
-                    # check that biased var(x) == mean(x^2) - mean(x)^2
-                    mean_x2 = mean(x * x)
-                    tm.assert_equal(var_x, mean_x2 - (mean_x * mean_x))
-
-                if is_constant:
-                    # check that variance of constant series is identically 0
-                    assert not (var_x > 0).any().any()
-                    expected = x * np.nan
-                    expected[count_x >= max(min_periods, 1)] = 0.0
-                    if var is var_unbiased:
-                        expected[count_x < 2] = np.nan
-                    tm.assert_equal(var_x, expected)
-
-                if isinstance(x, Series):
-                    for (y, is_constant, no_nans) in self.data:
-                        if not x.isna().equals(y.isna()):
-                            # can only easily test two Series with similar
-                            # structure
-                            continue
-
-                        # check that cor(x, y) is symmetric
-                        corr_x_y = corr(x, y)
-                        corr_y_x = corr(y, x)
-                        tm.assert_equal(corr_x_y, corr_y_x)
-
-                        if cov:
-                            # check that cov(x, y) is symmetric
-                            cov_x_y = cov(x, y)
-                            cov_y_x = cov(y, x)
-                            tm.assert_equal(cov_x_y, cov_y_x)
-
-                            # check that cov(x, y) == (var(x+y) - var(x) -
-                            # var(y)) / 2
-                            var_x_plus_y = var(x + y)
-                            var_y = var(y)
-                            tm.assert_equal(
-                                cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y)
-                            )
-
-                            # check that corr(x, y) == cov(x, y) / (std(x) *
-                            # std(y))
-                            std_y = std(y)
-                            tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
-
-                            if cov is cov_biased:
-                                # check that biased cov(x, y) == mean(x*y) -
-                                # mean(x)*mean(y)
-                                mean_y = mean(y)
-                                mean_x_times_y = mean(x * y)
-                                tm.assert_equal(
-                                    cov_x_y, mean_x_times_y - (mean_x * mean_y)
-                                )
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
-    @pytest.mark.parametrize("adjust", [True, False])
-    @pytest.mark.parametrize("ignore_na", [True, False])
-    def test_ewm_consistency(self, min_periods, adjust, ignore_na):
-        def _weights(s, com, adjust, ignore_na):
-            if isinstance(s, DataFrame):
-                if not len(s.columns):
-                    return DataFrame(index=s.index, columns=s.columns)
-                w = concat(
-                    [
-                        _weights(
-                            s.iloc[:, i], com=com, adjust=adjust, ignore_na=ignore_na
-                        )
-                        for i, _ in enumerate(s.columns)
-                    ],
-                    axis=1,
-                )
-                w.index = s.index
-                w.columns = s.columns
-                return w
-
-            w = Series(np.nan, index=s.index)
-            alpha = 1.0 / (1.0 + com)
-            if ignore_na:
-                w[s.notna()] = _weights(
-                    s[s.notna()], com=com, adjust=adjust, ignore_na=False
-                )
-            elif adjust:
-                for i in range(len(s)):
-                    if s.iat[i] == s.iat[i]:
-                        w.iat[i] = pow(1.0 / (1.0 - alpha), i)
-            else:
-                sum_wts = 0.0
-                prev_i = -1
-                for i in range(len(s)):
-                    if s.iat[i] == s.iat[i]:
-                        if prev_i == -1:
-                            w.iat[i] = 1.0
-                        else:
-                            w.iat[i] = alpha * sum_wts / pow(1.0 - alpha, i - prev_i)
-                        sum_wts += w.iat[i]
-                        prev_i = i
-            return w
-
-        def _variance_debiasing_factors(s, com, adjust, ignore_na):
-            weights = _weights(s, com=com, adjust=adjust, ignore_na=ignore_na)
-            cum_sum = weights.cumsum().fillna(method="ffill")
-            cum_sum_sq = (weights * weights).cumsum().fillna(method="ffill")
-            numerator = cum_sum * cum_sum
-            denominator = numerator - cum_sum_sq
-            denominator[denominator <= 0.0] = np.nan
-            return numerator / denominator
-
-        def _ewma(s, com, min_periods, adjust, ignore_na):
-            weights = _weights(s, com=com, adjust=adjust, ignore_na=ignore_na)
-            result = (
-                s.multiply(weights)
-                .cumsum()
-                .divide(weights.cumsum())
-                .fillna(method="ffill")
-            )
-            result[
-                s.expanding().count() < (max(min_periods, 1) if min_periods else 1)
-            ] = np.nan
-            return result
-
-        com = 3.0
-        # test consistency between different ewm* moments
-        self._test_moments_consistency(
-            min_periods=min_periods,
-            count=lambda x: x.expanding().count(),
-            mean=lambda x: x.ewm(
-                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-            ).mean(),
-            mock_mean=lambda x: _ewma(
-                x, com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-            ),
-            corr=lambda x, y: x.ewm(
-                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-            ).corr(y),
-            var_unbiased=lambda x: (
-                x.ewm(
-                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-                ).var(bias=False)
-            ),
-            std_unbiased=lambda x: (
-                x.ewm(
-                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-                ).std(bias=False)
-            ),
-            cov_unbiased=lambda x, y: (
-                x.ewm(
-                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-                ).cov(y, bias=False)
-            ),
-            var_biased=lambda x: (
-                x.ewm(
-                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-                ).var(bias=True)
-            ),
-            std_biased=lambda x: x.ewm(
-                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-            ).std(bias=True),
-            cov_biased=lambda x, y: (
-                x.ewm(
-                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
-                ).cov(y, bias=True)
-            ),
-            var_debiasing_factors=lambda x: (
-                _variance_debiasing_factors(
-                    x, com=com, adjust=adjust, ignore_na=ignore_na
-                )
-            ),
-        )
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
-    def test_expanding_consistency(self, min_periods):
-
-        # suppress warnings about empty slices, as we are deliberately testing
-        # with empty/0-length Series/DataFrames
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                message=".*(empty slice|0 for slice).*",
-                category=RuntimeWarning,
-            )
-
-            # test consistency between different expanding_* moments
-            self._test_moments_consistency(
-                min_periods=min_periods,
-                count=lambda x: x.expanding().count(),
-                mean=lambda x: x.expanding(min_periods=min_periods).mean(),
-                mock_mean=lambda x: x.expanding(min_periods=min_periods).sum()
-                / x.expanding().count(),
-                corr=lambda x, y: x.expanding(min_periods=min_periods).corr(y),
-                var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
-                std_unbiased=lambda x: x.expanding(min_periods=min_periods).std(),
-                cov_unbiased=lambda x, y: x.expanding(min_periods=min_periods).cov(y),
-                var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
-                std_biased=lambda x: x.expanding(min_periods=min_periods).std(ddof=0),
-                cov_biased=lambda x, y: x.expanding(min_periods=min_periods).cov(
-                    y, ddof=0
-                ),
-                var_debiasing_factors=lambda x: (
-                    x.expanding().count()
-                    / (x.expanding().count() - 1.0).replace(0.0, np.nan)
-                ),
-            )
-
-            # test consistency between expanding_xyz() and either (a)
-            # expanding_apply of Series.xyz(), or (b) expanding_apply of
-            # np.nanxyz()
-            for (x, is_constant, no_nans) in self.data:
-                functions = self.base_functions
-
-                # GH 8269
-                if no_nans:
-                    functions = self.base_functions + self.no_nan_functions
-                for (f, require_min_periods, name) in functions:
-                    expanding_f = getattr(x.expanding(min_periods=min_periods), name)
-
-                    if (
-                        require_min_periods
-                        and (min_periods is not None)
-                        and (min_periods < require_min_periods)
-                    ):
-                        continue
-
-                    if name == "count":
-                        expanding_f_result = expanding_f()
-                        expanding_apply_f_result = x.expanding(min_periods=0).apply(
-                            func=f, raw=True
-                        )
-                    else:
-                        if name in ["cov", "corr"]:
-                            expanding_f_result = expanding_f(pairwise=False)
-                        else:
-                            expanding_f_result = expanding_f()
-                        expanding_apply_f_result = x.expanding(
-                            min_periods=min_periods
-                        ).apply(func=f, raw=True)
-
-                    # GH 9422
-                    if name in ["sum", "prod"]:
-                        tm.assert_equal(expanding_f_result, expanding_apply_f_result)
-
     @pytest.mark.slow
     @pytest.mark.parametrize(
         "window,min_periods,center", list(_rolling_consistency_cases())
@@ -1717,9 +952,7 @@ def test_rolling_consistency(self, window, min_periods, center):
             )
 
             # test consistency between different rolling_* moments
-            self._test_moments_consistency(
-                min_periods=min_periods,
-                count=lambda x: (x.rolling(window=window, center=center).count()),
+            self._test_moments_consistency_mock_mean(
                 mean=lambda x: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
@@ -1734,61 +967,110 @@ def test_rolling_consistency(self, window, min_periods, center):
                         ).count()
                     )
                 ),
-                corr=lambda x, y: (
+            )
+
+            self._test_moments_consistency_is_constant(
+                min_periods=min_periods,
+                count=lambda x: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
-                    ).corr(y)
+                    ).count()
                 ),
-                var_unbiased=lambda x: (
+                mean=lambda x: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
-                    ).var()
+                    ).mean()
                 ),
-                std_unbiased=lambda x: (
+                corr=lambda x, y: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
-                    ).std()
+                    ).corr(y)
                 ),
-                cov_unbiased=lambda x, y: (
+            )
+
+            self._test_moments_consistency_var_debiasing_factors(
+                var_unbiased=lambda x: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
-                    ).cov(y)
+                    ).var()
                 ),
                 var_biased=lambda x: (
                     x.rolling(
                         window=window, min_periods=min_periods, center=center
                     ).var(ddof=0)
                 ),
-                std_biased=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).std(ddof=0)
-                ),
-                cov_biased=lambda x, y: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).cov(y, ddof=0)
-                ),
                 var_debiasing_factors=lambda x: (
-                    x.rolling(window=window, center=center)
+                    x.rolling(window=window, min_periods=min_periods, center=center)
                     .count()
                     .divide(
-                        (x.rolling(window=window, center=center).count() - 1.0).replace(
-                            0.0, np.nan
-                        )
+                        (
+                            x.rolling(
+                                window=window, min_periods=min_periods, center=center
+                            ).count()
+                            - 1.0
+                        ).replace(0.0, np.nan)
                     )
                 ),
             )
 
-            # test consistency between rolling_xyz() and either (a)
-            # rolling_apply of Series.xyz(), or (b) rolling_apply of
-            # np.nanxyz()
-            for (x, is_constant, no_nans) in self.data:
-                functions = self.base_functions
-
-                # GH 8269
-                if no_nans:
-                    functions = self.base_functions + self.no_nan_functions
+            self._test_moments_consistency(
+                min_periods=min_periods,
+                count=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).count()
+                ),
+                mean=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).mean()
+                ),
+                corr=lambda x, y: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).corr(y)
+                ),
+                var_unbiased=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).var()
+                ),
+                std_unbiased=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).std()
+                ),
+                cov_unbiased=lambda x, y: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).cov(y)
+                ),
+                var_biased=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).var(ddof=0)
+                ),
+                std_biased=lambda x: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).std(ddof=0)
+                ),
+                cov_biased=lambda x, y: (
+                    x.rolling(
+                        window=window, min_periods=min_periods, center=center
+                    ).cov(y, ddof=0)
+                ),
+            )
+
+            # test consistency between rolling_xyz() and either (a)
+            # rolling_apply of Series.xyz(), or (b) rolling_apply of
+            # np.nanxyz()
+            for (x, is_constant, no_nans) in self.data:
+                functions = self.base_functions
+
+                # GH 8269
+                if no_nans:
+                    functions = self.base_functions + self.no_nan_functions
                 for (f, require_min_periods, name) in functions:
                     rolling_f = getattr(
                         x.rolling(
@@ -1807,7 +1089,7 @@ def test_rolling_consistency(self, window, min_periods, center):
                     if name == "count":
                         rolling_f_result = rolling_f()
                         rolling_apply_f_result = x.rolling(
-                            window=window, min_periods=0, center=center
+                            window=window, min_periods=min_periods, center=center
                         ).apply(func=f, raw=True)
                     else:
                         if name in ["cov", "corr"]:
@@ -1860,22 +1142,12 @@ def test_rolling_corr_with_zero_variance(self, window):
 
         assert s.rolling(window=window).corr(other=other).isna().all()
 
-    def _check_pairwise_moment(self, dispatch, name, **kwargs):
-        def get_result(obj, obj2=None):
-            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
-
-        result = get_result(self.frame)
-        result = result.loc[(slice(None), 1), 5]
-        result.index = result.index.droplevel(1)
-        expected = get_result(self.frame[1], self.frame[5])
-        tm.assert_series_equal(result, expected, check_names=False)
-
     def test_flex_binary_moment(self):
         # GH3155
         # don't blow the stack
         msg = (
-            "arguments to moment function must be of type"
-            " np.ndarray/Series/DataFrame"
+            "arguments to moment function must be of type "
+            "np.ndarray/Series/DataFrame"
         )
         with pytest.raises(TypeError, match=msg):
             _flex_binary_moment(5, 6, None)
@@ -1930,155 +1202,6 @@ def test_flex_binary_frame(self, method):
         )
         tm.assert_frame_equal(res3, exp)
 
-    def test_ewmcov(self):
-        self._check_binary_ew("cov")
-
-    def test_ewmcov_pairwise(self):
-        self._check_pairwise_moment("ewm", "cov", span=10, min_periods=5)
-
-    def test_ewmcorr(self):
-        self._check_binary_ew("corr")
-
-    def test_ewmcorr_pairwise(self):
-        self._check_pairwise_moment("ewm", "corr", span=10, min_periods=5)
-
-    def _check_binary_ew(self, name):
-        def func(A, B, com, **kwargs):
-            return getattr(A.ewm(com, **kwargs), name)(B)
-
-        A = Series(randn(50), index=np.arange(50))
-        B = A[2:] + randn(48)
-
-        A[:10] = np.NaN
-        B[-10:] = np.NaN
-
-        result = func(A, B, 20, min_periods=5)
-        assert np.isnan(result.values[:14]).all()
-        assert not np.isnan(result.values[14:]).any()
-
-        # GH 7898
-        for min_periods in (0, 1, 2):
-            result = func(A, B, 20, min_periods=min_periods)
-            # binary functions (ewmcov, ewmcorr) with bias=False require at
-            # least two values
-            assert np.isnan(result.values[:11]).all()
-            assert not np.isnan(result.values[11:]).any()
-
-            # check series of length 0
-            result = func(Series([]), Series([]), 50, min_periods=min_periods)
-            tm.assert_series_equal(result, Series([]))
-
-            # check series of length 1
-            result = func(Series([1.0]), Series([1.0]), 50, min_periods=min_periods)
-            tm.assert_series_equal(result, Series([np.NaN]))
-
-        msg = "Input arrays must be of the same type!"
-        # exception raised is Exception
-        with pytest.raises(Exception, match=msg):
-            func(A, randn(50), 20, min_periods=5)
-
-    def test_expanding_apply_args_kwargs(self, raw):
-        def mean_w_arg(x, const):
-            return np.mean(x) + const
-
-        df = DataFrame(np.random.rand(20, 3))
-
-        expected = df.expanding().apply(np.mean, raw=raw) + 20.0
-
-        result = df.expanding().apply(mean_w_arg, raw=raw, args=(20,))
-        tm.assert_frame_equal(result, expected)
-
-        result = df.expanding().apply(mean_w_arg, raw=raw, kwargs={"const": 20})
-        tm.assert_frame_equal(result, expected)
-
-    def test_expanding_corr(self):
-        A = self.series.dropna()
-        B = (A + randn(len(A)))[:-5]
-
-        result = A.expanding().corr(B)
-
-        rolling_result = A.rolling(window=len(A), min_periods=1).corr(B)
-
-        tm.assert_almost_equal(rolling_result, result)
-
-    def test_expanding_count(self):
-        result = self.series.expanding().count()
-        tm.assert_almost_equal(
-            result, self.series.rolling(window=len(self.series)).count()
-        )
-
-    def test_expanding_quantile(self):
-        result = self.series.expanding().quantile(0.5)
-
-        rolling_result = self.series.rolling(
-            window=len(self.series), min_periods=1
-        ).quantile(0.5)
-
-        tm.assert_almost_equal(result, rolling_result)
-
-    def test_expanding_cov(self):
-        A = self.series
-        B = (A + randn(len(A)))[:-5]
-
-        result = A.expanding().cov(B)
-
-        rolling_result = A.rolling(window=len(A), min_periods=1).cov(B)
-
-        tm.assert_almost_equal(rolling_result, result)
-
-    def test_expanding_cov_pairwise(self):
-        result = self.frame.expanding().corr()
-
-        rolling_result = self.frame.rolling(
-            window=len(self.frame), min_periods=1
-        ).corr()
-
-        tm.assert_frame_equal(result, rolling_result)
-
-    def test_expanding_corr_pairwise(self):
-        result = self.frame.expanding().corr()
-
-        rolling_result = self.frame.rolling(
-            window=len(self.frame), min_periods=1
-        ).corr()
-        tm.assert_frame_equal(result, rolling_result)
-
-    def test_expanding_cov_diff_index(self):
-        # GH 7512
-        s1 = Series([1, 2, 3], index=[0, 1, 2])
-        s2 = Series([1, 3], index=[0, 2])
-        result = s1.expanding().cov(s2)
-        expected = Series([None, None, 2.0])
-        tm.assert_series_equal(result, expected)
-
-        s2a = Series([1, None, 3], index=[0, 1, 2])
-        result = s1.expanding().cov(s2a)
-        tm.assert_series_equal(result, expected)
-
-        s1 = Series([7, 8, 10], index=[0, 1, 3])
-        s2 = Series([7, 9, 10], index=[0, 2, 3])
-        result = s1.expanding().cov(s2)
-        expected = Series([None, None, None, 4.5])
-        tm.assert_series_equal(result, expected)
-
-    def test_expanding_corr_diff_index(self):
-        # GH 7512
-        s1 = Series([1, 2, 3], index=[0, 1, 2])
-        s2 = Series([1, 3], index=[0, 2])
-        result = s1.expanding().corr(s2)
-        expected = Series([None, None, 1.0])
-        tm.assert_series_equal(result, expected)
-
-        s2a = Series([1, None, 3], index=[0, 1, 2])
-        result = s1.expanding().corr(s2a)
-        tm.assert_series_equal(result, expected)
-
-        s1 = Series([7, 8, 10], index=[0, 1, 3])
-        s2 = Series([7, 9, 10], index=[0, 2, 3])
-        result = s1.expanding().corr(s2)
-        expected = Series([None, None, None, 1.0])
-        tm.assert_series_equal(result, expected)
-
     def test_rolling_cov_diff_length(self):
         # GH 7512
         s1 = Series([1, 2, 3], index=[0, 1, 2])
@@ -2106,8 +1229,8 @@ def test_rolling_corr_diff_length(self):
     @pytest.mark.parametrize(
         "f",
         [
-            lambda x: (x.rolling(window=10, min_periods=5).cov(x, pairwise=False)),
-            lambda x: (x.rolling(window=10, min_periods=5).corr(x, pairwise=False)),
+            lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False),
+            lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False),
             lambda x: x.rolling(window=10, min_periods=5).max(),
             lambda x: x.rolling(window=10, min_periods=5).min(),
             lambda x: x.rolling(window=10, min_periods=5).sum(),
@@ -2123,6 +1246,7 @@ def test_rolling_corr_diff_length(self):
             lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(),
         ],
     )
+    @td.skip_if_no_scipy
     def test_rolling_functions_window_non_shrinkage(self, f):
         # GH 7764
         s = Series(range(4))
@@ -2130,16 +1254,11 @@ def test_rolling_functions_window_non_shrinkage(self, f):
         df = DataFrame([[1, 5], [3, 2], [3, 9], [-1, 0]], columns=["A", "B"])
         df_expected = DataFrame(np.nan, index=df.index, columns=df.columns)
 
-        try:
-            s_result = f(s)
-            tm.assert_series_equal(s_result, s_expected)
-
-            df_result = f(df)
-            tm.assert_frame_equal(df_result, df_expected)
-        except (ImportError):
+        s_result = f(s)
+        tm.assert_series_equal(s_result, s_expected)
 
-            # scipy needed for rolling_window
-            pytest.skip("scipy not available")
+        df_result = f(df)
+        tm.assert_frame_equal(df_result, df_expected)
 
     def test_rolling_functions_window_non_shrinkage_binary(self):
 
@@ -2164,154 +1283,6 @@ def test_rolling_functions_window_non_shrinkage_binary(self):
             df_result = f(df)
             tm.assert_frame_equal(df_result, df_expected)
 
-    def test_moment_functions_zero_length(self):
-        # GH 8056
-        s = Series()
-        s_expected = s
-        df1 = DataFrame()
-        df1_expected = df1
-        df2 = DataFrame(columns=["a"])
-        df2["a"] = df2["a"].astype("float64")
-        df2_expected = df2
-
-        functions = [
-            lambda x: x.expanding().count(),
-            lambda x: x.expanding(min_periods=5).cov(x, pairwise=False),
-            lambda x: x.expanding(min_periods=5).corr(x, pairwise=False),
-            lambda x: x.expanding(min_periods=5).max(),
-            lambda x: x.expanding(min_periods=5).min(),
-            lambda x: x.expanding(min_periods=5).sum(),
-            lambda x: x.expanding(min_periods=5).mean(),
-            lambda x: x.expanding(min_periods=5).std(),
-            lambda x: x.expanding(min_periods=5).var(),
-            lambda x: x.expanding(min_periods=5).skew(),
-            lambda x: x.expanding(min_periods=5).kurt(),
-            lambda x: x.expanding(min_periods=5).quantile(0.5),
-            lambda x: x.expanding(min_periods=5).median(),
-            lambda x: x.expanding(min_periods=5).apply(sum, raw=False),
-            lambda x: x.expanding(min_periods=5).apply(sum, raw=True),
-            lambda x: x.rolling(window=10).count(),
-            lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False),
-            lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False),
-            lambda x: x.rolling(window=10, min_periods=5).max(),
-            lambda x: x.rolling(window=10, min_periods=5).min(),
-            lambda x: x.rolling(window=10, min_periods=5).sum(),
-            lambda x: x.rolling(window=10, min_periods=5).mean(),
-            lambda x: x.rolling(window=10, min_periods=5).std(),
-            lambda x: x.rolling(window=10, min_periods=5).var(),
-            lambda x: x.rolling(window=10, min_periods=5).skew(),
-            lambda x: x.rolling(window=10, min_periods=5).kurt(),
-            lambda x: x.rolling(window=10, min_periods=5).quantile(0.5),
-            lambda x: x.rolling(window=10, min_periods=5).median(),
-            lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=False),
-            lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=True),
-            lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(),
-        ]
-        for f in functions:
-            try:
-                s_result = f(s)
-                tm.assert_series_equal(s_result, s_expected)
-
-                df1_result = f(df1)
-                tm.assert_frame_equal(df1_result, df1_expected)
-
-                df2_result = f(df2)
-                tm.assert_frame_equal(df2_result, df2_expected)
-            except (ImportError):
-
-                # scipy needed for rolling_window
-                continue
-
-    def test_moment_functions_zero_length_pairwise(self):
-
-        df1 = DataFrame()
-        df1_expected = df1
-        df2 = DataFrame(columns=Index(["a"], name="foo"), index=Index([], name="bar"))
-        df2["a"] = df2["a"].astype("float64")
-
-        df1_expected = DataFrame(
-            index=pd.MultiIndex.from_product([df1.index, df1.columns]),
-            columns=Index([]),
-        )
-        df2_expected = DataFrame(
-            index=pd.MultiIndex.from_product(
-                [df2.index, df2.columns], names=["bar", "foo"]
-            ),
-            columns=Index(["a"], name="foo"),
-            dtype="float64",
-        )
-
-        functions = [
-            lambda x: (x.expanding(min_periods=5).cov(x, pairwise=True)),
-            lambda x: (x.expanding(min_periods=5).corr(x, pairwise=True)),
-            lambda x: (x.rolling(window=10, min_periods=5).cov(x, pairwise=True)),
-            lambda x: (x.rolling(window=10, min_periods=5).corr(x, pairwise=True)),
-        ]
-        for f in functions:
-            df1_result = f(df1)
-            tm.assert_frame_equal(df1_result, df1_expected)
-
-            df2_result = f(df2)
-            tm.assert_frame_equal(df2_result, df2_expected)
-
-    def test_expanding_cov_pairwise_diff_length(self):
-        # GH 7512
-        df1 = DataFrame([[1, 5], [3, 2], [3, 9]], columns=Index(["A", "B"], name="foo"))
-        df1a = DataFrame(
-            [[1, 5], [3, 9]], index=[0, 2], columns=Index(["A", "B"], name="foo")
-        )
-        df2 = DataFrame(
-            [[5, 6], [None, None], [2, 1]], columns=Index(["X", "Y"], name="foo")
-        )
-        df2a = DataFrame(
-            [[5, 6], [2, 1]], index=[0, 2], columns=Index(["X", "Y"], name="foo")
-        )
-        # TODO: xref gh-15826
-        # .loc is not preserving the names
-        result1 = df1.expanding().cov(df2a, pairwise=True).loc[2]
-        result2 = df1.expanding().cov(df2a, pairwise=True).loc[2]
-        result3 = df1a.expanding().cov(df2, pairwise=True).loc[2]
-        result4 = df1a.expanding().cov(df2a, pairwise=True).loc[2]
-        expected = DataFrame(
-            [[-3.0, -6.0], [-5.0, -10.0]],
-            columns=Index(["A", "B"], name="foo"),
-            index=Index(["X", "Y"], name="foo"),
-        )
-        tm.assert_frame_equal(result1, expected)
-        tm.assert_frame_equal(result2, expected)
-        tm.assert_frame_equal(result3, expected)
-        tm.assert_frame_equal(result4, expected)
-
-    def test_expanding_corr_pairwise_diff_length(self):
-        # GH 7512
-        df1 = DataFrame(
-            [[1, 2], [3, 2], [3, 4]],
-            columns=["A", "B"],
-            index=Index(range(3), name="bar"),
-        )
-        df1a = DataFrame(
-            [[1, 2], [3, 4]], index=Index([0, 2], name="bar"), columns=["A", "B"]
-        )
-        df2 = DataFrame(
-            [[5, 6], [None, None], [2, 1]],
-            columns=["X", "Y"],
-            index=Index(range(3), name="bar"),
-        )
-        df2a = DataFrame(
-            [[5, 6], [2, 1]], index=Index([0, 2], name="bar"), columns=["X", "Y"]
-        )
-        result1 = df1.expanding().corr(df2, pairwise=True).loc[2]
-        result2 = df1.expanding().corr(df2a, pairwise=True).loc[2]
-        result3 = df1a.expanding().corr(df2, pairwise=True).loc[2]
-        result4 = df1a.expanding().corr(df2a, pairwise=True).loc[2]
-        expected = DataFrame(
-            [[-1.0, -1.0], [-1.0, -1.0]], columns=["A", "B"], index=Index(["X", "Y"])
-        )
-        tm.assert_frame_equal(result1, expected)
-        tm.assert_frame_equal(result2, expected)
-        tm.assert_frame_equal(result3, expected)
-        tm.assert_frame_equal(result4, expected)
-
     def test_rolling_skew_edge_cases(self):
 
         all_nan = Series([np.NaN] * 5)
@@ -2362,83 +1333,6 @@ def test_rolling_kurt_eq_value_fperr(self):
         a = Series([1.1] * 15).rolling(window=10).kurt()
         assert np.isnan(a).all()
 
-    @pytest.mark.parametrize(
-        "func,static_comp",
-        [("sum", np.sum), ("mean", np.mean), ("max", np.max), ("min", np.min)],
-        ids=["sum", "mean", "max", "min"],
-    )
-    def test_expanding_func(self, func, static_comp):
-        def expanding_func(x, min_periods=1, center=False, axis=0):
-            exp = x.expanding(min_periods=min_periods, center=center, axis=axis)
-            return getattr(exp, func)()
-
-        self._check_expanding(expanding_func, static_comp, preserve_nan=False)
-
-    def test_expanding_apply(self, raw):
-        def expanding_mean(x, min_periods=1):
-
-            exp = x.expanding(min_periods=min_periods)
-            result = exp.apply(lambda x: x.mean(), raw=raw)
-            return result
-
-        # TODO(jreback), needed to add preserve_nan=False
-        # here to make this pass
-        self._check_expanding(expanding_mean, np.mean, preserve_nan=False)
-
-        ser = Series([])
-        tm.assert_series_equal(ser, ser.expanding().apply(lambda x: x.mean(), raw=raw))
-
-        # GH 8080
-        s = Series([None, None, None])
-        result = s.expanding(min_periods=0).apply(lambda x: len(x), raw=raw)
-        expected = Series([1.0, 2.0, 3.0])
-        tm.assert_series_equal(result, expected)
-
-    def _check_expanding(
-        self,
-        func,
-        static_comp,
-        has_min_periods=True,
-        has_time_rule=True,
-        preserve_nan=True,
-    ):
-
-        series_result = func(self.series)
-        assert isinstance(series_result, Series)
-        frame_result = func(self.frame)
-        assert isinstance(frame_result, DataFrame)
-
-        result = func(self.series)
-        tm.assert_almost_equal(result[10], static_comp(self.series[:11]))
-
-        if preserve_nan:
-            assert result.iloc[self._nan_locs].isna().all()
-
-        ser = Series(randn(50))
-
-        if has_min_periods:
-            result = func(ser, min_periods=30)
-            assert result[:29].isna().all()
-            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
-
-            # min_periods is working correctly
-            result = func(ser, min_periods=15)
-            assert isna(result.iloc[13])
-            assert notna(result.iloc[14])
-
-            ser2 = Series(randn(20))
-            result = func(ser2, min_periods=5)
-            assert isna(result[3])
-            assert notna(result[4])
-
-            # min_periods=0
-            result0 = func(ser, min_periods=0)
-            result1 = func(ser, min_periods=1)
-            tm.assert_almost_equal(result0, result1)
-        else:
-            result = func(ser)
-            tm.assert_almost_equal(result.iloc[-1], static_comp(ser[:50]))
-
     def test_rolling_max_gh6297(self):
         """Replicate result expected in GH #6297"""
 
@@ -2560,3 +1454,76 @@ def test_rolling_min_max_numeric_types(self):
             assert result.dtypes[0] == np.dtype("f8")
             result = DataFrame(np.arange(20, dtype=data_type)).rolling(window=5).min()
             assert result.dtypes[0] == np.dtype("f8")
+
+    def test_moment_functions_zero_length(self):
+        # GH 8056
+        s = Series(dtype=np.float64)
+        s_expected = s
+        df1 = DataFrame()
+        df1_expected = df1
+        df2 = DataFrame(columns=["a"])
+        df2["a"] = df2["a"].astype("float64")
+        df2_expected = df2
+
+        functions = [
+            lambda x: x.rolling(window=10).count(),
+            lambda x: x.rolling(window=10, min_periods=5).cov(x, pairwise=False),
+            lambda x: x.rolling(window=10, min_periods=5).corr(x, pairwise=False),
+            lambda x: x.rolling(window=10, min_periods=5).max(),
+            lambda x: x.rolling(window=10, min_periods=5).min(),
+            lambda x: x.rolling(window=10, min_periods=5).sum(),
+            lambda x: x.rolling(window=10, min_periods=5).mean(),
+            lambda x: x.rolling(window=10, min_periods=5).std(),
+            lambda x: x.rolling(window=10, min_periods=5).var(),
+            lambda x: x.rolling(window=10, min_periods=5).skew(),
+            lambda x: x.rolling(window=10, min_periods=5).kurt(),
+            lambda x: x.rolling(window=10, min_periods=5).quantile(0.5),
+            lambda x: x.rolling(window=10, min_periods=5).median(),
+            lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=False),
+            lambda x: x.rolling(window=10, min_periods=5).apply(sum, raw=True),
+            lambda x: x.rolling(win_type="boxcar", window=10, min_periods=5).mean(),
+        ]
+        for f in functions:
+            try:
+                s_result = f(s)
+                tm.assert_series_equal(s_result, s_expected)
+
+                df1_result = f(df1)
+                tm.assert_frame_equal(df1_result, df1_expected)
+
+                df2_result = f(df2)
+                tm.assert_frame_equal(df2_result, df2_expected)
+            except (ImportError):
+
+                # scipy needed for rolling_window
+                continue
+
+    def test_moment_functions_zero_length_pairwise(self):
+
+        df1 = DataFrame()
+        df2 = DataFrame(columns=Index(["a"], name="foo"), index=Index([], name="bar"))
+        df2["a"] = df2["a"].astype("float64")
+
+        df1_expected = DataFrame(
+            index=pd.MultiIndex.from_product([df1.index, df1.columns]),
+            columns=Index([]),
+        )
+        df2_expected = DataFrame(
+            index=pd.MultiIndex.from_product(
+                [df2.index, df2.columns], names=["bar", "foo"]
+            ),
+            columns=Index(["a"], name="foo"),
+            dtype="float64",
+        )
+
+        functions = [
+            lambda x: (x.rolling(window=10, min_periods=5).cov(x, pairwise=True)),
+            lambda x: (x.rolling(window=10, min_periods=5).corr(x, pairwise=True)),
+        ]
+
+        for f in functions:
+            df1_result = f(df1)
+            tm.assert_frame_equal(df1_result, df1_expected)
+
+            df2_result = f(df2)
+            tm.assert_frame_equal(df2_result, df2_expected)
diff --git a/pandas/tests/window/test_api.py b/pandas/tests/window/test_api.py
index 11527efa4c39f..680237db0535b 100644
--- a/pandas/tests/window/test_api.py
+++ b/pandas/tests/window/test_api.py
@@ -1,6 +1,4 @@
 from collections import OrderedDict
-import warnings
-from warnings import catch_warnings
 
 import numpy as np
 import pytest
@@ -9,9 +7,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, concat
+import pandas._testing as tm
 from pandas.core.base import SpecificationError
 from pandas.tests.window.common import Base
-import pandas.util.testing as tm
 
 
 class TestApi(Base):
@@ -82,7 +80,6 @@ def test_agg(self):
         a_sum = r["A"].sum()
         b_mean = r["B"].mean()
         b_std = r["B"].std()
-        b_sum = r["B"].sum()
 
         result = r.aggregate([np.mean, np.std])
         expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
@@ -104,26 +101,18 @@ def test_agg(self):
         expected.columns = ["mean", "sum"]
         tm.assert_frame_equal(result, expected)
 
-        with catch_warnings(record=True):
+        msg = "nested renamer is not supported"
+        with pytest.raises(SpecificationError, match=msg):
             # using a dict with renaming
-            warnings.simplefilter("ignore", FutureWarning)
-            result = r.aggregate({"A": {"mean": "mean", "sum": "sum"}})
-        expected = concat([a_mean, a_sum], axis=1)
-        expected.columns = pd.MultiIndex.from_tuples([("A", "mean"), ("A", "sum")])
-        tm.assert_frame_equal(result, expected, check_like=True)
+            r.aggregate({"A": {"mean": "mean", "sum": "sum"}})
 
-        with catch_warnings(record=True):
-            warnings.simplefilter("ignore", FutureWarning)
-            result = r.aggregate(
+        with pytest.raises(SpecificationError, match=msg):
+            r.aggregate(
                 {
                     "A": {"mean": "mean", "sum": "sum"},
                     "B": {"mean2": "mean", "sum2": "sum"},
                 }
             )
-        expected = concat([a_mean, a_sum, b_mean, b_sum], axis=1)
-        exp_cols = [("A", "mean"), ("A", "sum"), ("B", "mean2"), ("B", "sum2")]
-        expected.columns = pd.MultiIndex.from_tuples(exp_cols)
-        tm.assert_frame_equal(result, expected, check_like=True)
 
         result = r.aggregate({"A": ["mean", "std"], "B": ["mean", "std"]})
         expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
@@ -168,7 +157,7 @@ def test_agg_nested_dicts(self):
         df = DataFrame({"A": range(5), "B": range(0, 10, 2)})
         r = df.rolling(window=3)
 
-        msg = r"cannot perform renaming for (r1|r2) with a nested dictionary"
+        msg = "nested renamer is not supported"
         with pytest.raises(SpecificationError, match=msg):
             r.aggregate({"r1": {"A": ["mean", "sum"]}, "r2": {"B": ["mean", "sum"]}})
 
@@ -178,25 +167,13 @@ def test_agg_nested_dicts(self):
         expected.columns = pd.MultiIndex.from_tuples(
             [("ra", "mean"), ("ra", "std"), ("rb", "mean"), ("rb", "std")]
         )
-        with catch_warnings(record=True):
-            warnings.simplefilter("ignore", FutureWarning)
-            result = r[["A", "B"]].agg(
+        with pytest.raises(SpecificationError, match=msg):
+            r[["A", "B"]].agg(
                 {"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}}
             )
-        tm.assert_frame_equal(result, expected, check_like=True)
 
-        with catch_warnings(record=True):
-            warnings.simplefilter("ignore", FutureWarning)
-            result = r.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
-        expected.columns = pd.MultiIndex.from_tuples(
-            [
-                ("A", "ra", "mean"),
-                ("A", "ra", "std"),
-                ("B", "rb", "mean"),
-                ("B", "rb", "std"),
-            ]
-        )
-        tm.assert_frame_equal(result, expected, check_like=True)
+        with pytest.raises(SpecificationError, match=msg):
+            r.agg({"A": {"ra": ["mean", "std"]}, "B": {"rb": ["mean", "std"]}})
 
     def test_count_nonnumeric_types(self):
         # GH12541
@@ -260,10 +237,10 @@ def test_count_nonnumeric_types(self):
             columns=cols,
         )
 
-        result = df.rolling(window=2).count()
+        result = df.rolling(window=2, min_periods=0).count()
         tm.assert_frame_equal(result, expected)
 
-        result = df.rolling(1).count()
+        result = df.rolling(1, min_periods=0).count()
         expected = df.notna().astype(float)
         tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/window/test_apply.py b/pandas/tests/window/test_apply.py
new file mode 100644
index 0000000000000..7132e64c1191c
--- /dev/null
+++ b/pandas/tests/window/test_apply.py
@@ -0,0 +1,140 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import DataFrame, Series, Timestamp, date_range
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("bad_raw", [None, 1, 0])
+def test_rolling_apply_invalid_raw(bad_raw):
+    with pytest.raises(ValueError, match="raw parameter must be `True` or `False`"):
+        Series(range(3)).rolling(1).apply(len, raw=bad_raw)
+
+
+def test_rolling_apply_out_of_bounds(engine_and_raw):
+    # gh-1850
+    engine, raw = engine_and_raw
+
+    vals = Series([1, 2, 3, 4])
+
+    result = vals.rolling(10).apply(np.sum, engine=engine, raw=raw)
+    assert result.isna().all()
+
+    result = vals.rolling(10, min_periods=1).apply(np.sum, engine=engine, raw=raw)
+    expected = Series([1, 3, 6, 10], dtype=float)
+    tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize("window", [2, "2s"])
+def test_rolling_apply_with_pandas_objects(window):
+    # 5071
+    df = DataFrame(
+        {"A": np.random.randn(5), "B": np.random.randint(0, 10, size=5)},
+        index=date_range("20130101", periods=5, freq="s"),
+    )
+
+    # we have an equal spaced timeseries index
+    # so simulate removing the first period
+    def f(x):
+        if x.index[0] == df.index[0]:
+            return np.nan
+        return x.iloc[-1]
+
+    result = df.rolling(window).apply(f, raw=False)
+    expected = df.iloc[2:].reindex_like(df)
+    tm.assert_frame_equal(result, expected)
+
+    with pytest.raises(AttributeError):
+        df.rolling(window).apply(f, raw=True)
+
+
+def test_rolling_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+
+    expected = Series([], dtype="float64")
+    result = expected.rolling(10).apply(lambda x: x.mean(), engine=engine, raw=raw)
+    tm.assert_series_equal(result, expected)
+
+    # gh-8080
+    s = Series([None, None, None])
+    result = s.rolling(2, min_periods=0).apply(lambda x: len(x), engine=engine, raw=raw)
+    expected = Series([1.0, 2.0, 2.0])
+    tm.assert_series_equal(result, expected)
+
+    result = s.rolling(2, min_periods=0).apply(len, engine=engine, raw=raw)
+    tm.assert_series_equal(result, expected)
+
+
+def test_all_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+
+    df = (
+        DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+        ).set_index("A")
+        * 2
+    )
+    er = df.rolling(window=1)
+    r = df.rolling(window="1s")
+
+    result = r.apply(lambda x: 1, engine=engine, raw=raw)
+    expected = er.apply(lambda x: 1, engine=engine, raw=raw)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ragged_apply(engine_and_raw):
+    engine, raw = engine_and_raw
+
+    df = DataFrame({"B": range(5)})
+    df.index = [
+        Timestamp("20130101 09:00:00"),
+        Timestamp("20130101 09:00:02"),
+        Timestamp("20130101 09:00:03"),
+        Timestamp("20130101 09:00:05"),
+        Timestamp("20130101 09:00:06"),
+    ]
+
+    f = lambda x: 1
+    result = df.rolling(window="1s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+    result = df.rolling(window="2s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+    result = df.rolling(window="5s", min_periods=1).apply(f, engine=engine, raw=raw)
+    expected = df.copy()
+    expected["B"] = 1.0
+    tm.assert_frame_equal(result, expected)
+
+
+def test_invalid_engine():
+    with pytest.raises(ValueError, match="engine must be either 'numba' or 'cython'"):
+        Series(range(1)).rolling(1).apply(lambda x: x, engine="foo")
+
+
+def test_invalid_engine_kwargs_cython():
+    with pytest.raises(ValueError, match="cython engine does not accept engine_kwargs"):
+        Series(range(1)).rolling(1).apply(
+            lambda x: x, engine="cython", engine_kwargs={"nopython": False}
+        )
+
+
+def test_invalid_raw_numba():
+    with pytest.raises(
+        ValueError, match="raw must be `True` when using the numba engine"
+    ):
+        Series(range(1)).rolling(1).apply(lambda x: x, raw=False, engine="numba")
+
+
+@td.skip_if_no("numba")
+def test_invalid_kwargs_nopython():
+    with pytest.raises(ValueError, match="numba does not support kwargs with"):
+        Series(range(1)).rolling(1).apply(
+            lambda x: x, kwargs={"a": 1}, engine="numba", raw=True
+        )
diff --git a/pandas/tests/window/test_base_indexer.py b/pandas/tests/window/test_base_indexer.py
new file mode 100644
index 0000000000000..606520c6d68ca
--- /dev/null
+++ b/pandas/tests/window/test_base_indexer.py
@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
+from pandas.core.window.indexers import ExpandingIndexer
+
+
+def test_bad_get_window_bounds_signature():
+    class BadIndexer(BaseIndexer):
+        def get_window_bounds(self):
+            return None
+
+    indexer = BadIndexer()
+    with pytest.raises(ValueError, match="BadIndexer does not implement"):
+        Series(range(5)).rolling(indexer)
+
+
+def test_expanding_indexer():
+    s = Series(range(10))
+    indexer = ExpandingIndexer()
+    result = s.rolling(indexer).mean()
+    expected = s.expanding().mean()
+    tm.assert_series_equal(result, expected)
+
+
+def test_indexer_constructor_arg():
+    # Example found in computation.rst
+    use_expanding = [True, False, True, False, True]
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = i + 1
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+    result = df.rolling(indexer).sum()
+    expected = DataFrame({"values": [0.0, 1.0, 3.0, 3.0, 10.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_indexer_accepts_rolling_args():
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if center and min_periods == 1 and closed == "both" and i == 2:
+                    start[i] = 0
+                    end[i] = num_values
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1)
+    result = df.rolling(indexer, center=True, min_periods=1, closed="both").sum()
+    expected = DataFrame({"values": [0.0, 1.0, 10.0, 3.0, 4.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_win_type_not_implemented():
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed):
+            return np.array([0, 1]), np.array([1, 2])
+
+    df = DataFrame({"values": range(2)})
+    indexer = CustomIndexer()
+    with pytest.raises(NotImplementedError, match="BaseIndexer subclasses not"):
+        df.rolling(indexer, win_type="boxcar")
diff --git a/pandas/tests/window/test_dtypes.py b/pandas/tests/window/test_dtypes.py
index 9d023034c570a..b1c9b66ab09d3 100644
--- a/pandas/tests/window/test_dtypes.py
+++ b/pandas/tests/window/test_dtypes.py
@@ -4,8 +4,8 @@
 import pytest
 
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.base import DataError
-import pandas.util.testing as tm
 
 # gh-12373 : rolling functions error on float32 data
 # make sure rolling functions works for different dtypes
diff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py
index 098acdff93ac6..6b6367fd80b26 100644
--- a/pandas/tests/window/test_expanding.py
+++ b/pandas/tests/window/test_expanding.py
@@ -5,9 +5,9 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
+import pandas._testing as tm
 from pandas.core.window import Expanding
 from pandas.tests.window.common import Base
-import pandas.util.testing as tm
 
 
 class TestExpanding(Base):
@@ -113,3 +113,22 @@ def test_expanding_axis(self, axis_frame):
 
         result = df.expanding(3, axis=axis_frame).sum()
         tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("constructor", [Series, DataFrame])
+def test_expanding_count_with_min_periods(constructor):
+    # GH 26996
+    result = constructor(range(5)).expanding(min_periods=3).count()
+    expected = constructor([np.nan, np.nan, 3.0, 4.0, 5.0])
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("constructor", [Series, DataFrame])
+def test_expanding_count_default_min_periods_with_null_values(constructor):
+    # GH 26996
+    values = [1, 2, 3, np.nan, 4, 5, 6]
+    expected_counts = [1.0, 2.0, 3.0, 3.0, 4.0, 5.0, 6.0]
+
+    result = constructor(values).expanding().count()
+    expected = constructor(expected_counts)
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index b726bd3e3c8a7..5b2687271f9d6 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -3,7 +3,8 @@
 
 import pandas as pd
 from pandas import DataFrame, Series
-import pandas.util.testing as tm
+import pandas._testing as tm
+from pandas.core.groupby.groupby import get_groupby
 
 
 class TestGrouperGrouping:
@@ -13,18 +14,18 @@ def setup_method(self, method):
 
     def test_mutated(self):
 
-        msg = r"group\(\) got an unexpected keyword argument 'foo'"
+        msg = r"groupby\(\) got an unexpected keyword argument 'foo'"
         with pytest.raises(TypeError, match=msg):
             self.frame.groupby("A", foo=1)
 
         g = self.frame.groupby("A")
         assert not g.mutated
-        g = self.frame.groupby("A", mutated=True)
+        g = get_groupby(self.frame, by="A", mutated=True)
         assert g.mutated
 
     def test_getitem(self):
         g = self.frame.groupby("A")
-        g_mutated = self.frame.groupby("A", mutated=True)
+        g_mutated = get_groupby(self.frame, by="A", mutated=True)
 
         expected = g_mutated.B.apply(lambda x: x.rolling(2).mean())
 
@@ -45,7 +46,7 @@ def test_getitem_multiple(self):
         # GH 13174
         g = self.frame.groupby("A")
         r = g.rolling(2)
-        g_mutated = self.frame.groupby("A", mutated=True)
+        g_mutated = get_groupby(self.frame, by="A", mutated=True)
         expected = g_mutated.B.apply(lambda x: x.rolling(2).count())
 
         result = r.B.count()
@@ -59,7 +60,6 @@ def test_rolling(self):
         r = g.rolling(window=4)
 
         for f in ["sum", "mean", "min", "max", "count", "kurt", "skew"]:
-
             result = getattr(r, f)()
             expected = g.apply(lambda x: getattr(x.rolling(4), f)())
             tm.assert_frame_equal(result, expected)
@@ -69,8 +69,16 @@ def test_rolling(self):
             expected = g.apply(lambda x: getattr(x.rolling(4), f)(ddof=1))
             tm.assert_frame_equal(result, expected)
 
-        result = r.quantile(0.5)
-        expected = g.apply(lambda x: x.rolling(4).quantile(0.5))
+    @pytest.mark.parametrize(
+        "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
+    )
+    def test_rolling_quantile(self, interpolation):
+        g = self.frame.groupby("A")
+        r = g.rolling(window=4)
+        result = r.quantile(0.4, interpolation=interpolation)
+        expected = g.apply(
+            lambda x: x.rolling(4).quantile(0.4, interpolation=interpolation)
+        )
         tm.assert_frame_equal(result, expected)
 
     def test_rolling_corr_cov(self):
@@ -141,8 +149,16 @@ def test_expanding(self):
             expected = g.apply(lambda x: getattr(x.expanding(), f)(ddof=0))
             tm.assert_frame_equal(result, expected)
 
-        result = r.quantile(0.5)
-        expected = g.apply(lambda x: x.expanding().quantile(0.5))
+    @pytest.mark.parametrize(
+        "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
+    )
+    def test_expanding_quantile(self, interpolation):
+        g = self.frame.groupby("A")
+        r = g.expanding()
+        result = r.quantile(0.4, interpolation=interpolation)
+        expected = g.apply(
+            lambda x: x.expanding().quantile(0.4, interpolation=interpolation)
+        )
         tm.assert_frame_equal(result, expected)
 
     def test_expanding_corr_cov(self):
@@ -174,3 +190,21 @@ def test_expanding_apply(self, raw):
         result = r.apply(lambda x: x.sum(), raw=raw)
         expected = g.apply(lambda x: x.expanding().apply(lambda y: y.sum(), raw=raw))
         tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("expected_value,raw_value", [[1.0, True], [0.0, False]])
+    def test_groupby_rolling(self, expected_value, raw_value):
+        # GH 31754
+
+        def foo(x):
+            return int(isinstance(x, np.ndarray))
+
+        df = pd.DataFrame({"id": [1, 1, 1], "value": [1, 2, 3]})
+        result = df.groupby("id").value.rolling(1).apply(foo, raw=raw_value)
+        expected = Series(
+            [expected_value] * 3,
+            index=pd.MultiIndex.from_tuples(
+                ((1, 0), (1, 1), (1, 2)), names=["id", None]
+            ),
+            name="value",
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_numba.py b/pandas/tests/window/test_numba.py
new file mode 100644
index 0000000000000..cc8aef1779b46
--- /dev/null
+++ b/pandas/tests/window/test_numba.py
@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import Series
+import pandas._testing as tm
+
+
+@td.skip_if_no("numba", "0.46.0")
+@pytest.mark.filterwarnings("ignore:\\nThe keyword argument")
+# Filter warnings when parallel=True and the function can't be parallelized by Numba
+class TestApply:
+    @pytest.mark.parametrize("jit", [True, False])
+    def test_numba_vs_cython(self, jit, nogil, parallel, nopython):
+        def f(x, *args):
+            arg_sum = 0
+            for arg in args:
+                arg_sum += arg
+            return np.mean(x) + arg_sum
+
+        if jit:
+            import numba
+
+            f = numba.jit(f)
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+        args = (2,)
+
+        s = Series(range(10))
+        result = s.rolling(2).apply(
+            f, args=args, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = s.rolling(2).apply(f, engine="cython", args=args, raw=True)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("jit", [True, False])
+    def test_cache(self, jit, nogil, parallel, nopython):
+        # Test that the functions are cached correctly if we switch functions
+        def func_1(x):
+            return np.mean(x) + 4
+
+        def func_2(x):
+            return np.std(x) * 5
+
+        if jit:
+            import numba
+
+            func_1 = numba.jit(func_1)
+            func_2 = numba.jit(func_2)
+
+        engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
+
+        roll = Series(range(10)).rolling(2)
+        result = roll.apply(
+            func_1, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_1, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
+
+        # func_1 should be in the cache now
+        assert func_1 in roll._numba_func_cache
+
+        result = roll.apply(
+            func_2, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_2, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
+        # This run should use the cached func_1
+        result = roll.apply(
+            func_1, engine="numba", engine_kwargs=engine_kwargs, raw=True
+        )
+        expected = roll.apply(func_1, engine="cython", raw=True)
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_pairwise.py b/pandas/tests/window/test_pairwise.py
index 56d89e15c418c..bb305e93a3cf1 100644
--- a/pandas/tests/window/test_pairwise.py
+++ b/pandas/tests/window/test_pairwise.py
@@ -1,10 +1,11 @@
 import warnings
 
+import numpy as np
 import pytest
 
-from pandas import DataFrame, Series
-from pandas.core.sorting import safe_sort
-import pandas.util.testing as tm
+from pandas import DataFrame, Series, date_range
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
 
 
 class TestPairwise:
@@ -181,3 +182,10 @@ def test_pairwise_with_series(self, f):
         for i, result in enumerate(results):
             if i > 0:
                 self.compare(result, results[0])
+
+    def test_corr_freq_memory_error(self):
+        # GH 31789
+        s = Series(range(5), index=date_range("2020", periods=5))
+        result = s.rolling("12H").corr(s)
+        expected = Series([np.nan] * 5, index=date_range("2020", periods=5))
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 70ba85120af3c..ab2c7fcb7a0dc 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -1,4 +1,4 @@
-from datetime import timedelta
+from datetime import datetime, timedelta
 
 import numpy as np
 import pytest
@@ -7,10 +7,10 @@
 import pandas.util._test_decorators as td
 
 import pandas as pd
-from pandas import DataFrame, Series
+from pandas import DataFrame, Index, Series
+import pandas._testing as tm
 from pandas.core.window import Rolling
 from pandas.tests.window.common import Base
-import pandas.util.testing as tm
 
 
 class TestRolling(Base):
@@ -32,23 +32,34 @@ def test_constructor(self, which):
         c = o.rolling
 
         # valid
+        c(0)
         c(window=2)
         c(window=2, min_periods=1)
         c(window=2, min_periods=1, center=True)
         c(window=2, min_periods=1, center=False)
 
         # GH 13383
-        with pytest.raises(ValueError):
-            c(0)
+
+        msg = "window must be non-negative"
+
+        with pytest.raises(ValueError, match=msg):
             c(-1)
 
         # not valid
         for w in [2.0, "foo", np.array([2])]:
-            with pytest.raises(ValueError):
+            msg = (
+                "window must be an integer|"
+                "passed window foo is not compatible with a datetimelike index"
+            )
+            with pytest.raises(ValueError, match=msg):
                 c(window=w)
-            with pytest.raises(ValueError):
+
+            msg = "min_periods must be an integer"
+            with pytest.raises(ValueError, match=msg):
                 c(window=2, min_periods=w)
-            with pytest.raises(ValueError):
+
+            msg = "center must be a boolean"
+            with pytest.raises(ValueError, match=msg):
                 c(window=2, min_periods=1, center=w)
 
     @td.skip_if_no_scipy
@@ -57,7 +68,10 @@ def test_constructor_with_win_type(self, which):
         # GH 13383
         o = getattr(self, which)
         c = o.rolling
-        with pytest.raises(ValueError):
+
+        msg = "window must be > 0"
+
+        with pytest.raises(ValueError, match=msg):
             c(-1, win_type="boxcar")
 
     @pytest.mark.parametrize("window", [timedelta(days=3), pd.Timedelta(days=3)])
@@ -113,7 +127,10 @@ def test_numpy_compat(self, method):
     def test_closed(self):
         df = DataFrame({"A": [0, 1, 2, 3, 4]})
         # closed only allowed for datetimelike
-        with pytest.raises(ValueError):
+
+        msg = "closed only implemented for datetimelike and offset based windows"
+
+        with pytest.raises(ValueError, match=msg):
             df.rolling(window=3, closed="neither")
 
     @pytest.mark.parametrize("closed", ["neither", "left"])
@@ -296,7 +313,10 @@ def test_iter_raises(self, klass):
         # https://github.com/pandas-dev/pandas/issues/11704
         # Iteration over a Window
         obj = klass([1, 2, 3, 4])
-        with pytest.raises(NotImplementedError):
+
+        msg = "See issue #11704 https://github.com/pandas-dev/pandas/issues/11704"
+
+        with pytest.raises(NotImplementedError, match=msg):
             iter(obj.rolling(2))
 
     def test_rolling_axis_sum(self, axis_frame):
@@ -324,7 +344,7 @@ def test_rolling_axis_count(self, axis_frame):
         else:
             expected = DataFrame({"x": [1.0, 1.0, 1.0], "y": [2.0, 2.0, 2.0]})
 
-        result = df.rolling(2, axis=axis_frame).count()
+        result = df.rolling(2, axis=axis_frame, min_periods=0).count()
         tm.assert_frame_equal(result, expected)
 
     def test_readonly_array(self):
@@ -361,3 +381,87 @@ def test_rolling_datetime(self, axis_frame, tz_naive_fixture):
             }
         )
         tm.assert_frame_equal(result, expected)
+
+
+def test_rolling_window_as_string():
+    # see gh-22590
+    date_today = datetime.now()
+    days = pd.date_range(date_today, date_today + timedelta(365), freq="D")
+
+    npr = np.random.RandomState(seed=421)
+
+    data = npr.randint(1, high=100, size=len(days))
+    df = DataFrame({"DateCol": days, "metric": data})
+
+    df.set_index("DateCol", inplace=True)
+    result = df.rolling(window="21D", min_periods=2, closed="left")["metric"].agg("max")
+
+    expData = (
+        [np.nan] * 2
+        + [88.0] * 16
+        + [97.0] * 9
+        + [98.0]
+        + [99.0] * 21
+        + [95.0] * 16
+        + [93.0] * 5
+        + [89.0] * 5
+        + [96.0] * 21
+        + [94.0] * 14
+        + [90.0] * 13
+        + [88.0] * 2
+        + [90.0] * 9
+        + [96.0] * 21
+        + [95.0] * 6
+        + [91.0]
+        + [87.0] * 6
+        + [92.0] * 21
+        + [83.0] * 2
+        + [86.0] * 10
+        + [87.0] * 5
+        + [98.0] * 21
+        + [97.0] * 14
+        + [93.0] * 7
+        + [87.0] * 4
+        + [86.0] * 4
+        + [95.0] * 21
+        + [85.0] * 14
+        + [83.0] * 2
+        + [76.0] * 5
+        + [81.0] * 2
+        + [98.0] * 21
+        + [95.0] * 14
+        + [91.0] * 7
+        + [86.0]
+        + [93.0] * 3
+        + [95.0] * 20
+    )
+
+    expected = Series(expData, index=Index(days, name="DateCol"), name="metric")
+    tm.assert_series_equal(result, expected)
+
+
+def test_min_periods1():
+    # GH#6795
+    df = pd.DataFrame([0, 1, 2, 1, 0], columns=["a"])
+    result = df["a"].rolling(3, center=True, min_periods=1).max()
+    expected = pd.Series([1.0, 2.0, 2.0, 2.0, 1.0], name="a")
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("constructor", [Series, DataFrame])
+def test_rolling_count_with_min_periods(constructor):
+    # GH 26996
+    result = constructor(range(5)).rolling(3, min_periods=3).count()
+    expected = constructor([np.nan, np.nan, 3.0, 3.0, 3.0])
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("constructor", [Series, DataFrame])
+def test_rolling_count_default_min_periods_with_null_values(constructor):
+    # GH 26996
+    values = [1, 2, 3, np.nan, 4, 5, 6]
+    expected_counts = [1.0, 2.0, 3.0, 2.0, 2.0, 2.0, 3.0]
+
+    result = constructor(values).rolling(3).count()
+    expected = constructor(expected_counts)
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index e057eadae9da8..5f5e10b5dd497 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -1,8 +1,16 @@
 import numpy as np
 import pytest
 
-from pandas import DataFrame, Index, Series, Timestamp, date_range, to_datetime
-import pandas.util.testing as tm
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+    to_datetime,
+)
+import pandas._testing as tm
 
 import pandas.tseries.offsets as offsets
 
@@ -105,8 +113,16 @@ def test_monotonic_on(self):
         assert df.index.is_monotonic
         df.rolling("2s").sum()
 
-        # non-monotonic
-        df.index = reversed(df.index.tolist())
+    def test_non_monotonic_on(self):
+        # GH 19248
+        df = DataFrame(
+            {"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
+        )
+        df = df.set_index("A")
+        non_monotonic_index = df.index.to_list()
+        non_monotonic_index[0] = non_monotonic_index[3]
+        df.index = non_monotonic_index
+
         assert not df.index.is_monotonic
 
         with pytest.raises(ValueError):
@@ -519,25 +535,36 @@ def test_ragged_max(self):
         expected["B"] = [0.0, 1, 2, 3, 4]
         tm.assert_frame_equal(result, expected)
 
-    def test_ragged_apply(self, raw):
+    @pytest.mark.parametrize(
+        "freq, op, result_data",
+        [
+            ("ms", "min", [0.0] * 10),
+            ("ms", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("ms", "max", [0.0] * 9 + [2.0]),
+            ("s", "min", [0.0] * 10),
+            ("s", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("s", "max", [0.0] * 9 + [2.0]),
+            ("min", "min", [0.0] * 10),
+            ("min", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("min", "max", [0.0] * 9 + [2.0]),
+            ("h", "min", [0.0] * 10),
+            ("h", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("h", "max", [0.0] * 9 + [2.0]),
+            ("D", "min", [0.0] * 10),
+            ("D", "mean", [0.0] * 9 + [2.0 / 9]),
+            ("D", "max", [0.0] * 9 + [2.0]),
+        ],
+    )
+    def test_freqs_ops(self, freq, op, result_data):
+        # GH 21096
+        index = date_range(start="2018-1-1 01:00:00", freq=f"1{freq}", periods=10)
+        s = Series(data=0, index=index)
+        s.iloc[1] = np.nan
+        s.iloc[-1] = 2
+        result = getattr(s.rolling(window=f"10{freq}"), op)()
+        expected = Series(data=result_data, index=index)
 
-        df = self.ragged
-
-        f = lambda x: 1
-        result = df.rolling(window="1s", min_periods=1).apply(f, raw=raw)
-        expected = df.copy()
-        expected["B"] = 1.0
-        tm.assert_frame_equal(result, expected)
-
-        result = df.rolling(window="2s", min_periods=1).apply(f, raw=raw)
-        expected = df.copy()
-        expected["B"] = 1.0
-        tm.assert_frame_equal(result, expected)
-
-        result = df.rolling(window="5s", min_periods=1).apply(f, raw=raw)
-        expected = df.copy()
-        expected["B"] = 1.0
-        tm.assert_frame_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_all(self):
 
@@ -567,16 +594,6 @@ def test_all(self):
         expected = er.quantile(0.5)
         tm.assert_frame_equal(result, expected)
 
-    def test_all_apply(self, raw):
-
-        df = self.regular * 2
-        er = df.rolling(window=1)
-        r = df.rolling(window="1s")
-
-        result = r.apply(lambda x: 1, raw=raw)
-        expected = er.apply(lambda x: 1, raw=raw)
-        tm.assert_frame_equal(result, expected)
-
     def test_all2(self):
 
         # more sophisticated comparison of integer vs.
@@ -690,3 +707,34 @@ def test_rolling_cov_offset(self):
 
         expected2 = ss.rolling(3, min_periods=1).cov()
         tm.assert_series_equal(result, expected2)
+
+    def test_rolling_on_decreasing_index(self):
+        # GH-19248
+        index = [
+            Timestamp("20190101 09:00:00"),
+            Timestamp("20190101 09:00:02"),
+            Timestamp("20190101 09:00:03"),
+            Timestamp("20190101 09:00:05"),
+            Timestamp("20190101 09:00:06"),
+        ]
+
+        df = DataFrame({"column": [3, 4, 4, 2, 1]}, index=reversed(index))
+        result = df.rolling("2s").min()
+        expected = DataFrame(
+            {"column": [3.0, 3.0, 3.0, 2.0, 1.0]}, index=reversed(index)
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_rolling_on_multi_index_level(self):
+        # GH-15584
+        df = DataFrame(
+            {"column": range(6)},
+            index=MultiIndex.from_product(
+                [date_range("20190101", periods=3), range(2)], names=["date", "seq"]
+            ),
+        )
+        result = df.rolling("10d", on=df.index.get_level_values("date")).sum()
+        expected = DataFrame(
+            {"column": [0.0, 1.0, 3.0, 6.0, 10.0, 15.0]}, index=df.index
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/window/test_window.py b/pandas/tests/window/test_window.py
index 5692404205012..cc29ab4f2cd62 100644
--- a/pandas/tests/window/test_window.py
+++ b/pandas/tests/window/test_window.py
@@ -60,12 +60,12 @@ def test_numpy_compat(self, method):
             getattr(w, method)(dtype=np.float64)
 
     @td.skip_if_no_scipy
-    @pytest.mark.parametrize("arg", ["median", "var", "std", "kurt", "skew"])
+    @pytest.mark.parametrize("arg", ["median", "kurt", "skew"])
     def test_agg_function_support(self, arg):
         df = pd.DataFrame({"A": np.arange(5)})
         roll = df.rolling(2, win_type="triang")
 
-        msg = "'{arg}' is not a valid function for " "'Window' object".format(arg=arg)
+        msg = f"'{arg}' is not a valid function for 'Window' object"
         with pytest.raises(AttributeError, match=msg):
             roll.agg(arg)
 
diff --git a/pandas/tseries/converter.py b/pandas/tseries/converter.py
deleted file mode 100644
index c2b76188ad36b..0000000000000
--- a/pandas/tseries/converter.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# flake8: noqa
-import warnings
-
-# TODO `_matplotlib` module should be private, so the plotting backend
-# can be change. Decide whether all these should be public and exponsed
-# in `pandas.plotting`, or remove from here (I guess they are here for
-# legacy reasons
-from pandas.plotting._matplotlib.converter import (
-    DatetimeConverter,
-    MilliSecondLocator,
-    PandasAutoDateFormatter,
-    PandasAutoDateLocator,
-    PeriodConverter,
-    TimeConverter,
-    TimeFormatter,
-    TimeSeries_DateFormatter,
-    TimeSeries_DateLocator,
-    get_datevalue,
-    get_finder,
-    time2num,
-)
-
-
-def register():
-    from pandas.plotting import register_matplotlib_converters
-
-    msg = (
-        "'pandas.tseries.converter.register' has been moved and renamed to "
-        "'pandas.plotting.register_matplotlib_converters'. "
-    )
-    warnings.warn(msg, FutureWarning, stacklevel=2)
-    register_matplotlib_converters()
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index dfe91b514bbe1..af34180fb3170 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -1,6 +1,7 @@
 from datetime import timedelta
 import re
-from typing import Dict
+from typing import Dict, Optional
+import warnings
 
 import numpy as np
 from pytz import AmbiguousTimeError
@@ -49,11 +50,13 @@
 # Offset names ("time rules") and related functions
 
 #: cache of previously seen offsets
-_offset_map = {}  # type: Dict[str, DateOffset]
+_offset_map: Dict[str, DateOffset] = {}
 
 
-def get_period_alias(offset_str):
-    """ alias to closest period strings BQ->Q etc"""
+def get_period_alias(offset_str: str) -> Optional[str]:
+    """
+    Alias to closest period strings BQ->Q etc.
+    """
     return _offset_to_period_map.get(offset_str, None)
 
 
@@ -68,10 +71,10 @@ def get_period_alias(offset_str):
 }
 
 
-def to_offset(freq):
+def to_offset(freq) -> Optional[DateOffset]:
     """
     Return DateOffset object from string or tuple representation
-    or datetime.timedelta object
+    or datetime.timedelta object.
 
     Parameters
     ----------
@@ -123,7 +126,7 @@ def to_offset(freq):
         if isinstance(stride, str):
             name, stride = stride, name
         name, _ = libfreqs._base_and_stride(name)
-        delta = get_offset(name) * stride
+        delta = _get_offset(name) * stride
 
     elif isinstance(freq, timedelta):
         delta = None
@@ -138,7 +141,7 @@ def to_offset(freq):
                         delta = offset
                     else:
                         delta = delta + offset
-        except Exception:
+        except ValueError:
             raise ValueError(libfreqs.INVALID_FREQ_ERR_MSG.format(freq))
 
     else:
@@ -164,13 +167,13 @@ def to_offset(freq):
                         float(stride), prefix
                     )
                 stride = int(stride)
-                offset = get_offset(name)
+                offset = _get_offset(name)
                 offset = offset * int(np.fabs(stride) * stride_sign)
                 if delta is None:
                     delta = offset
                 else:
                     delta = delta + offset
-        except Exception:
+        except (ValueError, TypeError):
             raise ValueError(libfreqs.INVALID_FREQ_ERR_MSG.format(freq))
 
     if delta is None:
@@ -179,14 +182,33 @@ def to_offset(freq):
     return delta
 
 
-def get_offset(name):
+def get_offset(name: str) -> DateOffset:
     """
-    Return DateOffset object associated with rule name
+    Return DateOffset object associated with rule name.
+
+    .. deprecated:: 1.0.0
 
     Examples
     --------
     get_offset('EOM') --> BMonthEnd(1)
     """
+    warnings.warn(
+        "get_offset is deprecated and will be removed in a future version, "
+        "use to_offset instead",
+        FutureWarning,
+        stacklevel=2,
+    )
+    return _get_offset(name)
+
+
+def _get_offset(name: str) -> DateOffset:
+    """
+    Return DateOffset object associated with rule name.
+
+    Examples
+    --------
+    _get_offset('EOM') --> BMonthEnd(1)
+    """
     if name not in libfreqs._dont_uppercase:
         name = name.upper()
         name = libfreqs._lite_rule_alias.get(name, name)
@@ -214,7 +236,7 @@ def get_offset(name):
 # Period codes
 
 
-def infer_freq(index, warn=True):
+def infer_freq(index, warn: bool = True) -> Optional[str]:
     """
     Infer the most likely frequency given the input index. If the frequency is
     uncertain, a warning will be printed.
@@ -222,8 +244,8 @@ def infer_freq(index, warn=True):
     Parameters
     ----------
     index : DatetimeIndex or TimedeltaIndex
-      if passed a Series will use the values of the series (NOT THE INDEX)
-    warn : boolean, default True
+      If passed a Series will use the values of the series (NOT THE INDEX).
+    warn : bool, default True
 
     Returns
     -------
@@ -243,10 +265,11 @@ def infer_freq(index, warn=True):
         ):
             raise TypeError(
                 "cannot infer freq from a non-convertible dtype "
-                "on a Series of {dtype}".format(dtype=index.dtype)
+                f"on a Series of {index.dtype}"
             )
         index = values
 
+    inferer: _FrequencyInferer
     if is_period_arraylike(index):
         raise TypeError(
             "PeriodIndex given. Check the `freq` attribute "
@@ -260,8 +283,7 @@ def infer_freq(index, warn=True):
     if isinstance(index, pd.Index) and not isinstance(index, pd.DatetimeIndex):
         if isinstance(index, (pd.Int64Index, pd.Float64Index)):
             raise TypeError(
-                "cannot infer freq from a non-convertible index "
-                "type {type}".format(type=type(index))
+                f"cannot infer freq from a non-convertible index type {type(index)}"
             )
         index = index.values
 
@@ -280,7 +302,7 @@ class _FrequencyInferer:
     Not sure if I can avoid the state machine here
     """
 
-    def __init__(self, index, warn=True):
+    def __init__(self, index, warn: bool = True):
         self.index = index
         self.values = index.asi8
 
@@ -308,14 +330,14 @@ def deltas_asi8(self):
         return unique_deltas(self.index.asi8)
 
     @cache_readonly
-    def is_unique(self):
+    def is_unique(self) -> bool:
         return len(self.deltas) == 1
 
     @cache_readonly
-    def is_unique_asi8(self):
+    def is_unique_asi8(self) -> bool:
         return len(self.deltas_asi8) == 1
 
-    def get_freq(self):
+    def get_freq(self) -> Optional[str]:
         """
         Find the appropriate frequency string to describe the inferred
         frequency of self.values
@@ -388,12 +410,12 @@ def mdiffs(self):
     def ydiffs(self):
         return unique_deltas(self.fields["Y"].astype("i8"))
 
-    def _infer_daily_rule(self):
+    def _infer_daily_rule(self) -> Optional[str]:
         annual_rule = self._get_annual_rule()
         if annual_rule:
             nyears = self.ydiffs[0]
             month = MONTH_ALIASES[self.rep_stamp.month]
-            alias = "{prefix}-{month}".format(prefix=annual_rule, month=month)
+            alias = f"{annual_rule}-{month}"
             return _maybe_add_count(alias, nyears)
 
         quarterly_rule = self._get_quarterly_rule()
@@ -401,7 +423,7 @@ def _infer_daily_rule(self):
             nquarters = self.mdiffs[0] / 3
             mod_dict = {0: 12, 2: 11, 1: 10}
             month = MONTH_ALIASES[mod_dict[self.rep_stamp.month % 3]]
-            alias = "{prefix}-{month}".format(prefix=quarterly_rule, month=month)
+            alias = f"{quarterly_rule}-{month}"
             return _maybe_add_count(alias, nquarters)
 
         monthly_rule = self._get_monthly_rule()
@@ -413,7 +435,7 @@ def _infer_daily_rule(self):
             if days % 7 == 0:
                 # Weekly
                 day = int_to_weekday[self.rep_stamp.weekday()]
-                return _maybe_add_count("W-{day}".format(day=day), days / 7)
+                return _maybe_add_count(f"W-{day}", days / 7)
             else:
                 return _maybe_add_count("D", days)
 
@@ -424,7 +446,9 @@ def _infer_daily_rule(self):
         if wom_rule:
             return wom_rule
 
-    def _get_annual_rule(self):
+        return None
+
+    def _get_annual_rule(self) -> Optional[str]:
         if len(self.ydiffs) > 1:
             return None
 
@@ -434,7 +458,7 @@ def _get_annual_rule(self):
         pos_check = self.month_position_check()
         return {"cs": "AS", "bs": "BAS", "ce": "A", "be": "BA"}.get(pos_check)
 
-    def _get_quarterly_rule(self):
+    def _get_quarterly_rule(self) -> Optional[str]:
         if len(self.mdiffs) > 1:
             return None
 
@@ -444,13 +468,13 @@ def _get_quarterly_rule(self):
         pos_check = self.month_position_check()
         return {"cs": "QS", "bs": "BQS", "ce": "Q", "be": "BQ"}.get(pos_check)
 
-    def _get_monthly_rule(self):
+    def _get_monthly_rule(self) -> Optional[str]:
         if len(self.mdiffs) > 1:
             return None
         pos_check = self.month_position_check()
         return {"cs": "MS", "bs": "BMS", "ce": "M", "be": "BM"}.get(pos_check)
 
-    def _is_business_daily(self):
+    def _is_business_daily(self) -> bool:
         # quick check: cannot be business daily
         if self.day_deltas != [1, 3]:
             return False
@@ -465,7 +489,7 @@ def _is_business_daily(self):
             | ((weekdays > 0) & (weekdays <= 4) & (shifts == 1))
         )
 
-    def _get_wom_rule(self):
+    def _get_wom_rule(self) -> Optional[str]:
         #         wdiffs = unique(np.diff(self.index.week))
         # We also need -47, -49, -48 to catch index spanning year boundary
         #     if not lib.ismember(wdiffs, set([4, 5, -47, -49, -48])).all():
@@ -485,7 +509,7 @@ def _get_wom_rule(self):
         week = week_of_months[0] + 1
         wd = int_to_weekday[weekdays[0]]
 
-        return "WOM-{week}{weekday}".format(week=week, weekday=wd)
+        return f"WOM-{week}{wd}"
 
 
 class _TimedeltaFrequencyInferer(_FrequencyInferer):
@@ -495,20 +519,20 @@ def _infer_daily_rule(self):
             if days % 7 == 0:
                 # Weekly
                 wd = int_to_weekday[self.rep_stamp.weekday()]
-                alias = "W-{weekday}".format(weekday=wd)
+                alias = f"W-{wd}"
                 return _maybe_add_count(alias, days / 7)
             else:
                 return _maybe_add_count("D", days)
 
 
-def _is_multiple(us, mult):
+def _is_multiple(us, mult: int) -> bool:
     return us % mult == 0
 
 
-def _maybe_add_count(base, count):
+def _maybe_add_count(base: str, count: float) -> str:
     if count != 1:
         assert count == int(count)
         count = int(count)
-        return "{count}{base}".format(count=count, base=base)
+        return f"{count}{base}"
     else:
         return base
diff --git a/pandas/tseries/holiday.py b/pandas/tseries/holiday.py
index 1654163d2a9e0..fe30130e87c01 100644
--- a/pandas/tseries/holiday.py
+++ b/pandas/tseries/holiday.py
@@ -7,7 +7,7 @@
 
 from pandas.errors import PerformanceWarning
 
-from pandas import DateOffset, Series, Timestamp, date_range
+from pandas import DateOffset, DatetimeIndex, Series, Timestamp, concat, date_range
 
 from pandas.tseries.offsets import Day, Easter
 
@@ -183,19 +183,19 @@ class from pandas.tseries.offsets
         assert days_of_week is None or type(days_of_week) == tuple
         self.days_of_week = days_of_week
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         info = ""
         if self.year is not None:
-            info += "year={year}, ".format(year=self.year)
-        info += "month={mon}, day={day}, ".format(mon=self.month, day=self.day)
+            info += f"year={self.year}, "
+        info += f"month={self.month}, day={self.day}, "
 
         if self.offset is not None:
-            info += "offset={offset}".format(offset=self.offset)
+            info += f"offset={self.offset}"
 
         if self.observance is not None:
-            info += "observance={obs}".format(obs=self.observance)
+            info += f"observance={self.observance}"
 
-        repr = "Holiday: {name} ({info})".format(name=self.name, info=info)
+        repr = f"Holiday: {self.name} ({info})"
         return repr
 
     def dates(self, start_date, end_date, return_name=False):
@@ -344,9 +344,9 @@ class AbstractHolidayCalendar(metaclass=HolidayCalendarMetaClass):
     Abstract interface to create holidays following certain rules.
     """
 
-    rules = []  # type: List[Holiday]
+    rules: List[Holiday] = []
     start_date = Timestamp(datetime(1970, 1, 1))
-    end_date = Timestamp(datetime(2030, 12, 31))
+    end_date = Timestamp(datetime(2200, 12, 31))
     _cache = None
 
     def __init__(self, name=None, rules=None):
@@ -363,7 +363,7 @@ def __init__(self, name=None, rules=None):
         """
         super().__init__()
         if name is None:
-            name = self.__class__.__name__
+            name = type(self).__name__
         self.name = name
 
         if rules is not None:
@@ -394,8 +394,7 @@ def holidays(self, start=None, end=None, return_name=False):
         """
         if self.rules is None:
             raise Exception(
-                "Holiday Calendar {name} does not have any "
-                "rules specified".format(name=self.name)
+                f"Holiday Calendar {self.name} does not have any rules specified"
             )
 
         if start is None:
@@ -407,17 +406,14 @@ def holidays(self, start=None, end=None, return_name=False):
         start = Timestamp(start)
         end = Timestamp(end)
 
-        holidays = None
         # If we don't have a cache or the dates are outside the prior cache, we
         # get them again
         if self._cache is None or start < self._cache[0] or end > self._cache[1]:
-            for rule in self.rules:
-                rule_holidays = rule.dates(start, end, return_name=True)
-
-                if holidays is None:
-                    holidays = rule_holidays
-                else:
-                    holidays = holidays.append(rule_holidays)
+            holidays = [rule.dates(start, end, return_name=True) for rule in self.rules]
+            if holidays:
+                holidays = concat(holidays)
+            else:
+                holidays = Series(index=DatetimeIndex([]), dtype=object)
 
             self._cache = (start, end, holidays.sort_index())
 
diff --git a/pandas/tseries/offsets.py b/pandas/tseries/offsets.py
index edf58ba3850a1..e05cce9c49f4b 100644
--- a/pandas/tseries/offsets.py
+++ b/pandas/tseries/offsets.py
@@ -1,7 +1,8 @@
 from datetime import date, datetime, timedelta
 import functools
 import operator
-from typing import Optional
+from typing import Any, Optional
+import warnings
 
 from dateutil.easter import easter
 import numpy as np
@@ -25,7 +26,7 @@
     BaseOffset,
     _get_calendar,
     _is_normalized,
-    _to_dt64,
+    _to_dt64D,
     apply_index_wraps,
     as_datetime,
     roll_yearday,
@@ -36,8 +37,6 @@
 
 from pandas.core.dtypes.inference import is_list_like
 
-from pandas.core.tools.datetimes import to_datetime
-
 __all__ = [
     "Day",
     "BusinessDay",
@@ -167,7 +166,7 @@ class DateOffset(BaseOffset):
     that conform to the DateOffset.  For example, Bday defines this
     set to be the set of dates that are weekdays (M-F).  To test if a
     date is in the set of a DateOffset dateOffset we can use the
-    onOffset method: dateOffset.onOffset(date).
+    is_on_offset method: dateOffset.is_on_offset(date).
 
     If a date is not on a valid date, the rollback and rollforward
     methods can be used to roll the date to the nearest valid date
@@ -204,7 +203,8 @@ def __add__(date):
     normalize : bool, default False
         Whether to round the result of a DateOffset addition down to the
         previous midnight.
-    **kwds : Temporal parameter that add to or replace the offset value.
+    **kwds
+        Temporal parameter that add to or replace the offset value.
 
         Parameters that **add** to the offset (like Timedelta):
 
@@ -228,7 +228,7 @@ def __add__(date):
         - minute
         - second
         - microsecond
-        - nanosecond
+        - nanosecond.
 
     See Also
     --------
@@ -252,6 +252,7 @@ def __add__(date):
     _use_relativedelta = False
     _adjust_dst = False
     _attributes = frozenset(["n", "normalize"] + list(liboffsets.relativedelta_kwds))
+    _deprecations = frozenset(["isAnchored", "onOffset"])
 
     # default for prior pickles
     normalize = False
@@ -310,9 +311,8 @@ def apply_index(self, i):
 
         if type(self) is not DateOffset:
             raise NotImplementedError(
-                "DateOffset subclass {name} "
-                "does not have a vectorized "
-                "implementation".format(name=self.__class__.__name__)
+                f"DateOffset subclass {type(self).__name__} "
+                "does not have a vectorized implementation"
             )
         kwds = self.kwds
         relativedelta_fast = {
@@ -361,19 +361,35 @@ def apply_index(self, i):
             kwd = set(kwds) - relativedelta_fast
             raise NotImplementedError(
                 "DateOffset with relativedelta "
-                "keyword(s) {kwd} not able to be "
-                "applied vectorized".format(kwd=kwd)
+                f"keyword(s) {kwd} not able to be "
+                "applied vectorized"
             )
 
-    def isAnchored(self):
+    def is_anchored(self) -> bool:
         # TODO: Does this make sense for the general case?  It would help
-        # if there were a canonical docstring for what isAnchored means.
+        # if there were a canonical docstring for what is_anchored means.
         return self.n == 1
 
+    def onOffset(self, dt):
+        warnings.warn(
+            "onOffset is a deprecated, use is_on_offset instead",
+            FutureWarning,
+            stacklevel=2,
+        )
+        return self.is_on_offset(dt)
+
+    def isAnchored(self) -> bool:
+        warnings.warn(
+            "isAnchored is a deprecated, use is_anchored instead",
+            FutureWarning,
+            stacklevel=2,
+        )
+        return self.is_anchored()
+
     # TODO: Combine this with BusinessMixin version by defining a whitelisted
     # set of attributes on each object rather than the existing behavior of
     # iterating over internal ``__dict__``
-    def _repr_attrs(self):
+    def _repr_attrs(self) -> str:
         exclude = {"n", "inc", "normalize"}
         attrs = []
         for attr in sorted(self.__dict__):
@@ -381,7 +397,7 @@ def _repr_attrs(self):
                 continue
             elif attr not in exclude:
                 value = getattr(self, attr)
-                attrs.append("{attr}={value}".format(attr=attr, value=value))
+                attrs.append(f"{attr}={value}")
 
         out = ""
         if attrs:
@@ -389,7 +405,7 @@ def _repr_attrs(self):
         return out
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self.rule_code
 
     def rollback(self, dt):
@@ -402,8 +418,8 @@ def rollback(self, dt):
             Rolled timestamp if not on offset, otherwise unchanged timestamp.
         """
         dt = as_timestamp(dt)
-        if not self.onOffset(dt):
-            dt = dt - self.__class__(1, normalize=self.normalize, **self.kwds)
+        if not self.is_on_offset(dt):
+            dt = dt - type(self)(1, normalize=self.normalize, **self.kwds)
         return dt
 
     def rollforward(self, dt):
@@ -416,11 +432,11 @@ def rollforward(self, dt):
             Rolled timestamp if not on offset, otherwise unchanged timestamp.
         """
         dt = as_timestamp(dt)
-        if not self.onOffset(dt):
-            dt = dt + self.__class__(1, normalize=self.normalize, **self.kwds)
+        if not self.is_on_offset(dt):
+            dt = dt + type(self)(1, normalize=self.normalize, **self.kwds)
         return dt
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt):
         if self.normalize and not _is_normalized(dt):
             return False
         # XXX, see #1395
@@ -436,22 +452,22 @@ def onOffset(self, dt):
 
     # way to get around weirdness with rule_code
     @property
-    def _prefix(self):
+    def _prefix(self) -> str:
         raise NotImplementedError("Prefix not defined")
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         return self._prefix
 
     @cache_readonly
-    def freqstr(self):
+    def freqstr(self) -> str:
         try:
             code = self.rule_code
         except NotImplementedError:
             return repr(self)
 
         if self.n != 1:
-            fstr = "{n}{code}".format(n=self.n, code=code)
+            fstr = f"{self.n}{code}"
         else:
             fstr = code
 
@@ -464,12 +480,12 @@ def freqstr(self):
 
         return fstr
 
-    def _offset_str(self):
+    def _offset_str(self) -> str:
         return ""
 
     @property
     def nanos(self):
-        raise ValueError("{name} is a non-fixed frequency".format(name=self))
+        raise ValueError(f"{self} is a non-fixed frequency")
 
 
 class SingleConstructorOffset(DateOffset):
@@ -477,7 +493,7 @@ class SingleConstructorOffset(DateOffset):
     def _from_name(cls, suffix=None):
         # default _from_name calls cls with no args
         if suffix:
-            raise ValueError("Bad freq suffix {suffix}".format(suffix=suffix))
+            raise ValueError(f"Bad freq suffix {suffix}")
         return cls()
 
 
@@ -513,11 +529,11 @@ def offset(self):
         # Alias for backward compat
         return self._offset
 
-    def _repr_attrs(self):
+    def _repr_attrs(self) -> str:
         if self.offset:
-            attrs = ["offset={offset!r}".format(offset=self.offset)]
+            attrs = [f"offset={repr(self.offset)}"]
         else:
-            attrs = None
+            attrs = []
         out = ""
         if attrs:
             out += ": " + ", ".join(attrs)
@@ -537,7 +553,7 @@ def __init__(self, n=1, normalize=False, offset=timedelta(0)):
         BaseOffset.__init__(self, n, normalize)
         object.__setattr__(self, "_offset", offset)
 
-    def _offset_str(self):
+    def _offset_str(self) -> str:
         def get_str(td):
             off_str = ""
             if td.days > 0:
@@ -605,7 +621,7 @@ def apply(self, other):
             return BDay(self.n, offset=self.offset + other, normalize=self.normalize)
         else:
             raise ApplyTypeError(
-                "Only know how to combine business day with " "datetime or timedelta."
+                "Only know how to combine business day with datetime or timedelta."
             )
 
     @apply_index_wraps
@@ -633,7 +649,7 @@ def apply_index(self, i):
         result = shifted.to_timestamp() + time
         return result
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         return dt.weekday() < 5
@@ -657,9 +673,7 @@ def __init__(self, start="09:00", end="17:00", offset=timedelta(0)):
 
         # Validation of input
         if len(start) != len(end):
-            raise ValueError(
-                "number of starting time and ending time " "must be the same"
-            )
+            raise ValueError("number of starting time and ending time must be the same")
         num_openings = len(start)
 
         # sort starting and ending time by starting time
@@ -732,7 +746,7 @@ def _next_opening_time(self, other, sign=1):
         earliest_start = self.start[0]
         latest_start = self.start[-1]
 
-        if not self.next_bday.onOffset(other):
+        if not self.next_bday.is_on_offset(other):
             # today is not business day
             other = other + sign * self.next_bday
             if self.n * sign >= 0:
@@ -799,7 +813,7 @@ def rollback(self, dt):
         """
         Roll provided date backward to next offset only if not on offset.
         """
-        if not self.onOffset(dt):
+        if not self.is_on_offset(dt):
             if self.n >= 0:
                 dt = self._prev_opening_time(dt)
             else:
@@ -812,7 +826,7 @@ def rollforward(self, dt):
         """
         Roll provided date forward to next offset only if not on offset.
         """
-        if not self.onOffset(dt):
+        if not self.is_on_offset(dt):
             if self.n >= 0:
                 return self._next_opening_time(dt)
             else:
@@ -860,13 +874,13 @@ def apply(self, other):
 
             # adjust other to reduce number of cases to handle
             if n >= 0:
-                if other.time() in self.end or not self._onOffset(other):
+                if other.time() in self.end or not self._is_on_offset(other):
                     other = self._next_opening_time(other)
             else:
                 if other.time() in self.start:
                     # adjustment to move to previous business day
                     other = other - timedelta(seconds=1)
-                if not self._onOffset(other):
+                if not self._is_on_offset(other):
                     other = self._next_opening_time(other)
                     other = self._get_closing_time(other)
 
@@ -882,9 +896,17 @@ def apply(self, other):
 
             # adjust by business days first
             if bd != 0:
-                skip_bd = BusinessDay(n=bd)
+                if isinstance(self, _CustomMixin):  # GH 30593
+                    skip_bd = CustomBusinessDay(
+                        n=bd,
+                        weekmask=self.weekmask,
+                        holidays=self.holidays,
+                        calendar=self.calendar,
+                    )
+                else:
+                    skip_bd = BusinessDay(n=bd)
                 # midnight business hour may not on BusinessDay
-                if not self.next_bday.onOffset(other):
+                if not self.next_bday.is_on_offset(other):
                     prev_open = self._prev_opening_time(other)
                     remain = other - prev_open
                     other = prev_open + skip_bd + remain
@@ -933,7 +955,7 @@ def apply(self, other):
         else:
             raise ApplyTypeError("Only know how to combine business hour with datetime")
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt):
         if self.normalize and not _is_normalized(dt):
             return False
 
@@ -943,9 +965,9 @@ def onOffset(self, dt):
             )
         # Valid BH can be on the different BusinessDay during midnight
         # Distinguish by the time spent from previous opening time
-        return self._onOffset(dt)
+        return self._is_on_offset(dt)
 
-    def _onOffset(self, dt):
+    def _is_on_offset(self, dt):
         """
         Slight speedups using calculated values.
         """
@@ -970,10 +992,10 @@ def _onOffset(self, dt):
     def _repr_attrs(self):
         out = super()._repr_attrs()
         hours = ",".join(
-            "{}-{}".format(st.strftime("%H:%M"), en.strftime("%H:%M"))
+            f'{st.strftime("%H:%M")}-{en.strftime("%H:%M")}'
             for st, en in zip(self.start, self.end)
         )
-        attrs = ["{prefix}={hours}".format(prefix=self._prefix, hours=hours)]
+        attrs = [f"{self._prefix}={hours}"]
         out += ": " + ", ".join(attrs)
         return out
 
@@ -981,8 +1003,6 @@ def _repr_attrs(self):
 class BusinessHour(BusinessHourMixin, SingleConstructorOffset):
     """
     DateOffset subclass representing possibly n business hours.
-
-    .. versionadded:: 0.16.1
     """
 
     _prefix = "BH"
@@ -1005,12 +1025,12 @@ class CustomBusinessDay(_CustomMixin, BusinessDay):
     ----------
     n : int, default 1
     normalize : bool, default False
-        Normalize start/end dates to midnight before generating date range
+        Normalize start/end dates to midnight before generating date range.
     weekmask : str, Default 'Mon Tue Wed Thu Fri'
-        weekmask of valid business days, passed to ``numpy.busdaycalendar``
+        Weekmask of valid business days, passed to ``numpy.busdaycalendar``.
     holidays : list
-        list/array of dates to exclude from the set of valid business days,
-        passed to ``numpy.busdaycalendar``
+        List/array of dates to exclude from the set of valid business days,
+        passed to ``numpy.busdaycalendar``.
     calendar : pd.HolidayCalendar or np.busdaycalendar
     offset : timedelta, default timedelta(0)
     """
@@ -1067,10 +1087,10 @@ def apply(self, other):
     def apply_index(self, i):
         raise NotImplementedError
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
-        day64 = _to_dt64(dt, "datetime64[D]")
+        day64 = _to_dt64D(dt)
         return np.is_busday(day64, busdaycal=self.calendar)
 
 
@@ -1114,14 +1134,14 @@ class MonthOffset(SingleConstructorOffset):
     __init__ = BaseOffset.__init__
 
     @property
-    def name(self):
-        if self.isAnchored:
+    def name(self) -> str:
+        if self.is_anchored:
             return self.rule_code
         else:
             month = ccalendar.MONTH_ALIASES[self.n]
-            return "{code}-{month}".format(code=self.rule_code, month=month)
+            return f"{self.code_rule}-{month}"
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         return dt.day == self._get_offset_day(dt)
@@ -1203,7 +1223,7 @@ class _CustomBusinessMonth(_CustomMixin, BusinessMixin, MonthOffset):
         ["n", "normalize", "weekmask", "holidays", "calendar", "offset"]
     )
 
-    onOffset = DateOffset.onOffset  # override MonthOffset method
+    is_on_offset = DateOffset.is_on_offset  # override MonthOffset method
     apply_index = DateOffset.apply_index  # override MonthOffset method
 
     def __init__(
@@ -1302,9 +1322,10 @@ def __init__(self, n=1, normalize=False, day_of_month=None):
         else:
             object.__setattr__(self, "day_of_month", int(day_of_month))
         if not self._min_day_of_month <= self.day_of_month <= 27:
-            msg = "day_of_month must be {min}<=day_of_month<=27, got {day}"
             raise ValueError(
-                msg.format(min=self._min_day_of_month, day=self.day_of_month)
+                "day_of_month must be "
+                f"{self._min_day_of_month}<=day_of_month<=27, "
+                f"got {self.day_of_month}"
             )
 
     @classmethod
@@ -1312,8 +1333,8 @@ def _from_name(cls, suffix=None):
         return cls(day_of_month=suffix)
 
     @property
-    def rule_code(self):
-        suffix = "-{day_of_month}".format(day_of_month=self.day_of_month)
+    def rule_code(self) -> str:
+        suffix = f"-{self.day_of_month}"
         return self._prefix + suffix
 
     @apply_wraps
@@ -1408,7 +1429,7 @@ class SemiMonthEnd(SemiMonthOffset):
     _prefix = "SM"
     _min_day_of_month = 1
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         days_in_month = ccalendar.get_days_in_month(dt.year, dt.month)
@@ -1466,7 +1487,7 @@ class SemiMonthBegin(SemiMonthOffset):
 
     _prefix = "SMS"
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         return dt.day in (1, self.day_of_month)
@@ -1519,7 +1540,7 @@ class Week(DateOffset):
     Parameters
     ----------
     weekday : int, default None
-        Always generate specific day of week. 0 for Monday
+        Always generate specific day of week. 0 for Monday.
     """
 
     _adjust_dst = True
@@ -1533,11 +1554,9 @@ def __init__(self, n=1, normalize=False, weekday=None):
 
         if self.weekday is not None:
             if self.weekday < 0 or self.weekday > 6:
-                raise ValueError(
-                    "Day must be 0<=day<=6, got {day}".format(day=self.weekday)
-                )
+                raise ValueError(f"Day must be 0<=day<=6, got {self.weekday}")
 
-    def isAnchored(self):
+    def is_anchored(self) -> bool:
         return self.n == 1 and self.weekday is not None
 
     @apply_wraps
@@ -1545,6 +1564,11 @@ def apply(self, other):
         if self.weekday is None:
             return other + self.n * self._inc
 
+        if not isinstance(other, datetime):
+            raise TypeError(
+                f"Cannot add {type(other).__name__} to {type(self).__name__}"
+            )
+
         k = self.n
         otherDay = other.weekday()
         if otherDay != self.weekday:
@@ -1608,7 +1632,7 @@ def _end_apply_index(self, dtindex):
 
         return base + off + Timedelta(1, "ns") - Timedelta(1, "D")
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         elif self.weekday is None:
@@ -1616,11 +1640,11 @@ def onOffset(self, dt):
         return dt.weekday() == self.weekday
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         suffix = ""
         if self.weekday is not None:
             weekday = ccalendar.int_to_weekday[self.weekday]
-            suffix = "-{weekday}".format(weekday=weekday)
+            suffix = f"-{weekday}"
         return self._prefix + suffix
 
     @classmethod
@@ -1651,7 +1675,7 @@ def apply(self, other):
         to_day = self._get_offset_day(shifted)
         return liboffsets.shift_day(shifted, to_day - shifted.day)
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt):
         if self.normalize and not _is_normalized(dt):
             return False
         return dt.day == self._get_offset_day(dt)
@@ -1664,16 +1688,19 @@ class WeekOfMonth(_WeekOfMonthMixin, DateOffset):
     Parameters
     ----------
     n : int
-    week : {0, 1, 2, 3, ...}, default 0
-        0 is 1st week of month, 1 2nd week, etc.
-    weekday : {0, 1, ..., 6}, default 0
-        0: Mondays
-        1: Tuesdays
-        2: Wednesdays
-        3: Thursdays
-        4: Fridays
-        5: Saturdays
-        6: Sundays
+    week : int {0, 1, 2, 3, ...}, default 0
+        A specific integer for the week of the month.
+        e.g. 0 is 1st week of month, 1 is the 2nd week, etc.
+    weekday : int {0, 1, ..., 6}, default 0
+        A specific integer for the day of the week.
+
+        - 0 is Monday
+        - 1 is Tuesday
+        - 2 is Wednesday
+        - 3 is Thursday
+        - 4 is Friday
+        - 5 is Saturday
+        - 6 is Sunday.
     """
 
     _prefix = "WOM"
@@ -1686,15 +1713,11 @@ def __init__(self, n=1, normalize=False, week=0, weekday=0):
         object.__setattr__(self, "week", week)
 
         if self.weekday < 0 or self.weekday > 6:
-            raise ValueError(
-                "Day must be 0<=day<=6, got {day}".format(day=self.weekday)
-            )
+            raise ValueError(f"Day must be 0<=day<=6, got {self.weekday}")
         if self.week < 0 or self.week > 3:
-            raise ValueError(
-                "Week must be 0<=week<=3, got {week}".format(week=self.week)
-            )
+            raise ValueError(f"Week must be 0<=week<=3, got {self.week}")
 
-    def _get_offset_day(self, other):
+    def _get_offset_day(self, other: datetime) -> int:
         """
         Find the day in the same month as other that has the same
         weekday as self.weekday and is the self.week'th such day in the month.
@@ -1713,18 +1736,14 @@ def _get_offset_day(self, other):
         return 1 + shift_days + self.week * 7
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         weekday = ccalendar.int_to_weekday.get(self.weekday, "")
-        return "{prefix}-{week}{weekday}".format(
-            prefix=self._prefix, week=self.week + 1, weekday=weekday
-        )
+        return f"{self._prefix}-{self.week + 1}{weekday}"
 
     @classmethod
     def _from_name(cls, suffix=None):
         if not suffix:
-            raise ValueError(
-                "Prefix {prefix!r} requires a suffix.".format(prefix=cls._prefix)
-            )
+            raise ValueError(f"Prefix {repr(cls._prefix)} requires a suffix.")
         # TODO: handle n here...
         # only one digit weeks (1 --> week 0, 2 --> week 1, etc.)
         week = int(suffix[0]) - 1
@@ -1740,14 +1759,16 @@ class LastWeekOfMonth(_WeekOfMonthMixin, DateOffset):
     Parameters
     ----------
     n : int, default 1
-    weekday : {0, 1, ..., 6}, default 0
-        0: Mondays
-        1: Tuesdays
-        2: Wednesdays
-        3: Thursdays
-        4: Fridays
-        5: Saturdays
-        6: Sundays
+    weekday : int {0, 1, ..., 6}, default 0
+        A specific integer for the day of the week.
+
+        - 0 is Monday
+        - 1 is Tuesday
+        - 2 is Wednesday
+        - 3 is Thursday
+        - 4 is Friday
+        - 5 is Saturday
+        - 6 is Sunday.
     """
 
     _prefix = "LWOM"
@@ -1762,11 +1783,9 @@ def __init__(self, n=1, normalize=False, weekday=0):
             raise ValueError("N cannot be 0")
 
         if self.weekday < 0 or self.weekday > 6:
-            raise ValueError(
-                "Day must be 0<=day<=6, got {day}".format(day=self.weekday)
-            )
+            raise ValueError(f"Day must be 0<=day<=6, got {self.weekday}")
 
-    def _get_offset_day(self, other):
+    def _get_offset_day(self, other: datetime) -> int:
         """
         Find the day in the same month as other that has the same
         weekday as self.weekday and is the last such day in the month.
@@ -1786,16 +1805,14 @@ def _get_offset_day(self, other):
         return dim - shift_days
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         weekday = ccalendar.int_to_weekday.get(self.weekday, "")
-        return "{prefix}-{weekday}".format(prefix=self._prefix, weekday=weekday)
+        return f"{self._prefix}-{weekday}"
 
     @classmethod
     def _from_name(cls, suffix=None):
         if not suffix:
-            raise ValueError(
-                "Prefix {prefix!r} requires a suffix.".format(prefix=cls._prefix)
-            )
+            raise ValueError(f"Prefix {repr(cls._prefix)} requires a suffix.")
         # TODO: handle n here...
         weekday = ccalendar.weekday_to_int[suffix]
         return cls(weekday=weekday)
@@ -1810,12 +1827,12 @@ class QuarterOffset(DateOffset):
     Quarter representation - doesn't call super.
     """
 
-    _default_startingMonth = None  # type: Optional[int]
-    _from_name_startingMonth = None  # type: Optional[int]
+    _default_startingMonth: Optional[int] = None
+    _from_name_startingMonth: Optional[int] = None
     _adjust_dst = True
     _attributes = frozenset(["n", "normalize", "startingMonth"])
     # TODO: Consider combining QuarterOffset and YearOffset __init__ at some
-    #       point.  Also apply_index, onOffset, rule_code if
+    #       point.  Also apply_index, is_on_offset, rule_code if
     #       startingMonth vs month attr names are resolved
 
     def __init__(self, n=1, normalize=False, startingMonth=None):
@@ -1825,7 +1842,7 @@ def __init__(self, n=1, normalize=False, startingMonth=None):
             startingMonth = self._default_startingMonth
         object.__setattr__(self, "startingMonth", startingMonth)
 
-    def isAnchored(self):
+    def is_anchored(self) -> bool:
         return self.n == 1 and self.startingMonth is not None
 
     @classmethod
@@ -1839,15 +1856,15 @@ def _from_name(cls, suffix=None):
         return cls(**kwargs)
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         month = ccalendar.MONTH_ALIASES[self.startingMonth]
-        return "{prefix}-{month}".format(prefix=self._prefix, month=month)
+        return f"{self._prefix}-{month}"
 
     @apply_wraps
     def apply(self, other):
         # months_since: find the calendar quarter containing other.month,
         # e.g. if other.month == 8, the calendar quarter is [Jul, Aug, Sep].
-        # Then find the month in that quarter containing an onOffset date for
+        # Then find the month in that quarter containing an is_on_offset date for
         # self.  `months_since` is the number of months to shift other.month
         # to get to this on-offset month.
         months_since = other.month % 3 - self.startingMonth % 3
@@ -1857,7 +1874,7 @@ def apply(self, other):
         months = qtrs * 3 - months_since
         return shift_month(other, months, self._day_opt)
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         mod_month = (dt.month - self.startingMonth) % 3
@@ -1936,7 +1953,7 @@ class YearOffset(DateOffset):
     _adjust_dst = True
     _attributes = frozenset(["n", "normalize", "month"])
 
-    def _get_offset_day(self, other):
+    def _get_offset_day(self, other: datetime) -> int:
         # override BaseOffset method to use self.month instead of other.month
         # TODO: there may be a more performant way to do this
         return liboffsets.get_day_of_month(
@@ -1960,7 +1977,7 @@ def apply_index(self, dtindex):
             shifted, freq=dtindex.freq, dtype=dtindex.dtype
         )
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         return dt.month == self.month and dt.day == self._get_offset_day(dt)
@@ -1982,9 +1999,9 @@ def _from_name(cls, suffix=None):
         return cls(**kwargs)
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         month = ccalendar.MONTH_ALIASES[self.month]
-        return "{prefix}-{month}".format(prefix=self._prefix, month=month)
+        return f"{self._prefix}-{month}"
 
 
 class BYearEnd(YearOffset):
@@ -2045,9 +2062,10 @@ class FY5253(DateOffset):
     such as retail, manufacturing and parking industry.
 
     For more information see:
-    http://en.wikipedia.org/wiki/4-4-5_calendar
+    https://en.wikipedia.org/wiki/4-4-5_calendar
 
     The year may either:
+
     - end on the last X day of the Y month.
     - end on the last X day closest to the last day of the Y month.
 
@@ -2057,17 +2075,27 @@ class FY5253(DateOffset):
     Parameters
     ----------
     n : int
-    weekday : {0, 1, ..., 6}
-        0: Mondays
-        1: Tuesdays
-        2: Wednesdays
-        3: Thursdays
-        4: Fridays
-        5: Saturdays
-        6: Sundays
-    startingMonth : The month in which fiscal years end. {1, 2, ... 12}
-    variation : str
-        {"nearest", "last"} for "LastOfMonth" or "NearestEndMonth"
+    weekday : int {0, 1, ..., 6}, default 0
+        A specific integer for the day of the week.
+
+        - 0 is Monday
+        - 1 is Tuesday
+        - 2 is Wednesday
+        - 3 is Thursday
+        - 4 is Friday
+        - 5 is Saturday
+        - 6 is Sunday.
+
+    startingMonth : int {1, 2, ... 12}, default 1
+        The month in which the fiscal year ends.
+
+    variation : str, default "nearest"
+        Method of employing 4-4-5 calendar.
+
+        There are two options:
+
+        - "nearest" means year end is **weekday** closest to last day of month in year.
+        - "last" means year end is final **weekday** of the final month in fiscal year.
     """
 
     _prefix = "RE"
@@ -2087,16 +2115,14 @@ def __init__(
             raise ValueError("N cannot be 0")
 
         if self.variation not in ["nearest", "last"]:
-            raise ValueError(
-                "{variation} is not a valid variation".format(variation=self.variation)
-            )
+            raise ValueError(f"{self.variation} is not a valid variation")
 
-    def isAnchored(self):
+    def is_anchored(self) -> bool:
         return (
             self.n == 1 and self.startingMonth is not None and self.weekday is not None
         )
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         dt = datetime(dt.year, dt.month, dt.day)
@@ -2191,24 +2217,22 @@ def get_year_end(self, dt):
                 return target_date + timedelta(days_forward - 7)
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         prefix = self._prefix
         suffix = self.get_rule_code_suffix()
-        return "{prefix}-{suffix}".format(prefix=prefix, suffix=suffix)
+        return f"{prefix}-{suffix}"
 
-    def _get_suffix_prefix(self):
+    def _get_suffix_prefix(self) -> str:
         if self.variation == "nearest":
             return "N"
         else:
             return "L"
 
-    def get_rule_code_suffix(self):
+    def get_rule_code_suffix(self) -> str:
         prefix = self._get_suffix_prefix()
         month = ccalendar.MONTH_ALIASES[self.startingMonth]
         weekday = ccalendar.int_to_weekday[self.weekday]
-        return "{prefix}-{month}-{weekday}".format(
-            prefix=prefix, month=month, weekday=weekday
-        )
+        return f"{prefix}-{month}-{weekday}"
 
     @classmethod
     def _parse_suffix(cls, varion_code, startingMonth_code, weekday_code):
@@ -2217,9 +2241,7 @@ def _parse_suffix(cls, varion_code, startingMonth_code, weekday_code):
         elif varion_code == "L":
             variation = "last"
         else:
-            raise ValueError(
-                "Unable to parse varion_code: " "{code}".format(code=varion_code)
-            )
+            raise ValueError(f"Unable to parse varion_code: {varion_code}")
 
         startingMonth = ccalendar.MONTH_TO_CAL_NUM[startingMonth_code]
         weekday = ccalendar.weekday_to_int[weekday_code]
@@ -2248,9 +2270,10 @@ class FY5253Quarter(DateOffset):
     such as retail, manufacturing and parking industry.
 
     For more information see:
-    http://en.wikipedia.org/wiki/4-4-5_calendar
+    https://en.wikipedia.org/wiki/4-4-5_calendar
 
     The year may either:
+
     - end on the last X day of the Y month.
     - end on the last X day closest to the last day of the Y month.
 
@@ -2264,19 +2287,30 @@ class FY5253Quarter(DateOffset):
     Parameters
     ----------
     n : int
-    weekday : {0, 1, ..., 6}
-        0: Mondays
-        1: Tuesdays
-        2: Wednesdays
-        3: Thursdays
-        4: Fridays
-        5: Saturdays
-        6: Sundays
-    startingMonth : The month in which fiscal years end. {1, 2, ... 12}
-    qtr_with_extra_week : The quarter number that has the leap
-        or 14 week when needed. {1,2,3,4}
-    variation : str
-        {"nearest", "last"} for "LastOfMonth" or "NearestEndMonth"
+    weekday : int {0, 1, ..., 6}, default 0
+        A specific integer for the day of the week.
+
+        - 0 is Monday
+        - 1 is Tuesday
+        - 2 is Wednesday
+        - 3 is Thursday
+        - 4 is Friday
+        - 5 is Saturday
+        - 6 is Sunday.
+
+    startingMonth : int {1, 2, ..., 12}, default 1
+        The month in which fiscal years end.
+
+    qtr_with_extra_week : int {1, 2, 3, 4}, default 1
+        The quarter number that has the leap or 14 week when needed.
+
+    variation : str, default "nearest"
+        Method of employing 4-4-5 calendar.
+
+        There are two options:
+
+        - "nearest" means year end is **weekday** closest to last day of month in year.
+        - "last" means year end is final **weekday** of the final month in fiscal year.
     """
 
     _prefix = "REQ"
@@ -2312,8 +2346,8 @@ def _offset(self):
             variation=self.variation,
         )
 
-    def isAnchored(self):
-        return self.n == 1 and self._offset.isAnchored()
+    def is_anchored(self) -> bool:
+        return self.n == 1 and self._offset.is_anchored()
 
     def _rollback_to_year(self, other):
         """
@@ -2339,7 +2373,7 @@ def _rollback_to_year(self, other):
 
         norm = Timestamp(other).tz_localize(None)
         start = self._offset.rollback(norm)
-        # Note: start <= norm and self._offset.onOffset(start)
+        # Note: start <= norm and self._offset.is_on_offset(start)
 
         if start < norm:
             # roll adjustment
@@ -2347,7 +2381,7 @@ def _rollback_to_year(self, other):
 
             # check thet qtr_lens is consistent with self._offset addition
             end = liboffsets.shift_day(start, days=7 * sum(qtr_lens))
-            assert self._offset.onOffset(end), (start, end, qtr_lens)
+            assert self._offset.is_on_offset(end), (start, end, qtr_lens)
 
             tdelta = norm - start
             for qlen in qtr_lens:
@@ -2400,7 +2434,7 @@ def get_weeks(self, dt):
 
         return ret
 
-    def year_has_extra_week(self, dt):
+    def year_has_extra_week(self, dt: datetime) -> bool:
         # Avoid round-down errors --> normalize to get
         # e.g. '370D' instead of '360D23H'
         norm = Timestamp(dt).normalize().tz_localize(None)
@@ -2411,10 +2445,10 @@ def year_has_extra_week(self, dt):
         assert weeks_in_year in [52, 53], weeks_in_year
         return weeks_in_year == 53
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
-        if self._offset.onOffset(dt):
+        if self._offset.is_on_offset(dt):
             return True
 
         next_year_end = dt - self._offset
@@ -2429,12 +2463,10 @@ def onOffset(self, dt):
         return False
 
     @property
-    def rule_code(self):
+    def rule_code(self) -> str:
         suffix = self._offset.get_rule_code_suffix()
         qtr = self.qtr_with_extra_week
-        return "{prefix}-{suffix}-{qtr}".format(
-            prefix=self._prefix, suffix=suffix, qtr=qtr
-        )
+        return f"{self._prefix}-{suffix}-{qtr}"
 
     @classmethod
     def _from_name(cls, *args):
@@ -2484,7 +2516,7 @@ def apply(self, other):
         )
         return new
 
-    def onOffset(self, dt):
+    def is_on_offset(self, dt: datetime) -> bool:
         if self.normalize and not _is_normalized(dt):
             return False
         return date(dt.year, dt.month, dt.day) == easter(dt.year)
@@ -2503,12 +2535,11 @@ def f(self, other):
         except AttributeError:
             # comparing with a non-Tick object
             raise TypeError(
-                "Invalid comparison between {cls} and {typ}".format(
-                    cls=type(self).__name__, typ=type(other).__name__
-                )
+                f"Invalid comparison between {type(self).__name__} "
+                f"and {type(other).__name__}"
             )
 
-    f.__name__ = "__{opname}__".format(opname=op.__name__)
+    f.__name__ = f"__{op.__name__}__"
     return f
 
 
@@ -2521,7 +2552,7 @@ def __init__(self, n=1, normalize=False):
         BaseOffset.__init__(self, n, normalize)
         if normalize:
             raise ValueError(
-                "Tick offset with `normalize=True` are not " "allowed."
+                "Tick offset with `normalize=True` are not allowed."
             )  # GH#21427
 
     __gt__ = _tick_comp(operator.gt)
@@ -2543,11 +2574,10 @@ def __add__(self, other):
             return NotImplemented
         except OverflowError:
             raise OverflowError(
-                "the add operation between {self} and {other} "
-                "will overflow".format(self=self, other=other)
+                f"the add operation between {self} and {other} will overflow"
             )
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             from pandas.tseries.frequencies import to_offset
 
@@ -2566,7 +2596,7 @@ def __eq__(self, other):
 
     # This is identical to DateOffset.__hash__, but has to be redefined here
     # for Python 3, because we've redefined __eq__.
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self._params)
 
     def __ne__(self, other):
@@ -2587,7 +2617,7 @@ def __ne__(self, other):
             return True
 
     @property
-    def delta(self):
+    def delta(self) -> Timedelta:
         return self.n * self._inc
 
     @property
@@ -2616,15 +2646,13 @@ def apply(self, other):
         elif isinstance(other, type(self)):
             return type(self)(self.n + other.n)
 
-        raise ApplyTypeError(
-            "Unhandled type: {type_str}".format(type_str=type(other).__name__)
-        )
+        raise ApplyTypeError(f"Unhandled type: {type(other).__name__}")
 
-    def isAnchored(self):
+    def is_anchored(self) -> bool:
         return False
 
 
-def _delta_to_tick(delta):
+def _delta_to_tick(delta: timedelta) -> Tick:
     if delta.microseconds == 0 and getattr(delta, "nanoseconds", 0) == 0:
         # nanoseconds only for pd.Timedelta
         if delta.seconds == 0:
@@ -2639,8 +2667,8 @@ def _delta_to_tick(delta):
                 return Second(seconds)
     else:
         nanos = delta_to_nanoseconds(delta)
-        if nanos % 1000000 == 0:
-            return Milli(nanos // 1000000)
+        if nanos % 1_000_000 == 0:
+            return Milli(nanos // 1_000_000)
         elif nanos % 1000 == 0:
             return Micro(nanos // 1000)
         else:  # pragma: no cover
@@ -2700,8 +2728,8 @@ def generate_range(start=None, end=None, periods=None, offset=BDay()):
 
     Parameters
     ----------
-    start : datetime (default None)
-    end : datetime (default None)
+    start : datetime, (default None)
+    end : datetime, (default None)
     periods : int, (default None)
     offset : DateOffset, (default BDay())
 
@@ -2720,13 +2748,15 @@ def generate_range(start=None, end=None, periods=None, offset=BDay()):
 
     offset = to_offset(offset)
 
-    start = to_datetime(start)
-    end = to_datetime(end)
+    start = Timestamp(start)
+    start = start if start is not NaT else None
+    end = Timestamp(end)
+    end = end if end is not NaT else None
 
-    if start and not offset.onOffset(start):
+    if start and not offset.is_on_offset(start):
         start = offset.rollforward(start)
 
-    elif end and not offset.onOffset(end):
+    elif end and not offset.is_on_offset(end):
         end = offset.rollback(end)
 
     if periods is None and end < start and offset.n >= 0:
@@ -2752,9 +2782,7 @@ def generate_range(start=None, end=None, periods=None, offset=BDay()):
             # faster than cur + offset
             next_date = offset.apply(cur)
             if next_date <= cur:
-                raise ValueError(
-                    "Offset {offset} did not increment date".format(offset=offset)
-                )
+                raise ValueError(f"Offset {offset} did not increment date")
             cur = next_date
     else:
         while cur >= end:
@@ -2768,9 +2796,7 @@ def generate_range(start=None, end=None, periods=None, offset=BDay()):
             # faster than cur + offset
             next_date = offset.apply(cur)
             if next_date >= cur:
-                raise ValueError(
-                    "Offset {offset} did not decrement date".format(offset=offset)
-                )
+                raise ValueError(f"Offset {offset} did not decrement date")
             cur = next_date
 
 
diff --git a/pandas/tseries/plotting.py b/pandas/tseries/plotting.py
deleted file mode 100644
index df41b4b5b40d9..0000000000000
--- a/pandas/tseries/plotting.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# flake8: noqa
-
-from pandas.plotting._matplotlib.timeseries import tsplot
diff --git a/pandas/util/__init__.py b/pandas/util/__init__.py
index d906c0371d207..b5271dbc0443e 100644
--- a/pandas/util/__init__.py
+++ b/pandas/util/__init__.py
@@ -1,3 +1,30 @@
 from pandas.util._decorators import Appender, Substitution, cache_readonly  # noqa
 
+from pandas import compat
 from pandas.core.util.hashing import hash_array, hash_pandas_object  # noqa
+
+# compatibility for import pandas; pandas.util.testing
+
+if compat.PY37:
+
+    def __getattr__(name):
+        if name == "testing":
+            import pandas.util.testing
+
+            return pandas.util.testing
+        else:
+            raise AttributeError(f"module 'pandas.util' has no attribute '{name}'")
+
+
+else:
+
+    class _testing:
+        def __getattr__(self, item):
+            import pandas.util.testing
+
+            return getattr(pandas.util.testing, item)
+
+    testing = _testing()
+
+
+del compat
diff --git a/pandas/util/_decorators.py b/pandas/util/_decorators.py
index 8a25e511b5fc4..0aab5a9c4113d 100644
--- a/pandas/util/_decorators.py
+++ b/pandas/util/_decorators.py
@@ -4,8 +4,8 @@
 from typing import (
     Any,
     Callable,
-    Dict,
     List,
+    Mapping,
     Optional,
     Tuple,
     Type,
@@ -58,7 +58,7 @@ def deprecate(
 
     alt_name = alt_name or alternative.__name__
     klass = klass or FutureWarning
-    warning_msg = msg or "{} is deprecated, use {} instead".format(name, alt_name)
+    warning_msg = msg or f"{name} is deprecated, use {alt_name} instead"
 
     @wraps(alternative)
     def wrapper(*args, **kwargs) -> Callable[..., Any]:
@@ -66,12 +66,12 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
         return alternative(*args, **kwargs)
 
     # adding deprecated directive to the docstring
-    msg = msg or "Use `{alt_name}` instead.".format(alt_name=alt_name)
+    msg = msg or f"Use `{alt_name}` instead."
     doc_error_msg = (
         "deprecate needs a correctly formatted docstring in "
         "the target function (should have a one liner short "
         "summary, and opening quotes should be in their own "
-        "line). Found:\n{}".format(alternative.__doc__)
+        f"line). Found:\n{alternative.__doc__}"
     )
 
     # when python is running in optimized mode (i.e. `-OO`), docstrings are
@@ -84,18 +84,13 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
         if empty1 or empty2 and not summary:
             raise AssertionError(doc_error_msg)
         wrapper.__doc__ = dedent(
-            """
-        {summary}
-
-        .. deprecated:: {depr_version}
-            {depr_msg}
-
-        {rest_of_docstring}"""
-        ).format(
-            summary=summary.strip(),
-            depr_version=version,
-            depr_msg=msg,
-            rest_of_docstring=dedent(doc),
+            f"""
+        {summary.strip()}
+
+        .. deprecated:: {version}
+            {msg}
+
+        {dedent(doc)}"""
         )
 
     return wrapper
@@ -104,7 +99,7 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
 def deprecate_kwarg(
     old_arg_name: str,
     new_arg_name: Optional[str],
-    mapping: Optional[Union[Dict[Any, Any], Callable[[Any], Any]]] = None,
+    mapping: Optional[Union[Mapping[Any, Any], Callable[[Any], Any]]] = None,
     stacklevel: int = 2,
 ) -> Callable[..., Any]:
     """
@@ -171,7 +166,7 @@ def deprecate_kwarg(
 
     if mapping is not None and not hasattr(mapping, "get") and not callable(mapping):
         raise TypeError(
-            "mapping from old to new argument values " "must be dict or callable!"
+            "mapping from old to new argument values must be dict or callable!"
         )
 
     def _deprecate_kwarg(func: F) -> F:
@@ -182,10 +177,10 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
             if old_arg_value is not None:
                 if new_arg_name is None:
                     msg = (
-                        "the '{old_name}' keyword is deprecated and will be "
-                        "removed in a future version. "
-                        "Please take steps to stop the use of '{old_name}'"
-                    ).format(old_name=old_arg_name)
+                        f"the {repr(old_arg_name)} keyword is deprecated and "
+                        "will be removed in a future version. Please take "
+                        f"steps to stop the use of {repr(old_arg_name)}"
+                    )
                     warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
                     kwargs[old_arg_name] = old_arg_value
                     return func(*args, **kwargs)
@@ -196,26 +191,23 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
                     else:
                         new_arg_value = mapping.get(old_arg_value, old_arg_value)
                     msg = (
-                        "the {old_name}={old_val!r} keyword is deprecated, "
-                        "use {new_name}={new_val!r} instead"
-                    ).format(
-                        old_name=old_arg_name,
-                        old_val=old_arg_value,
-                        new_name=new_arg_name,
-                        new_val=new_arg_value,
+                        f"the {old_arg_name}={repr(old_arg_value)} keyword is "
+                        "deprecated, use "
+                        f"{new_arg_name}={repr(new_arg_value)} instead"
                     )
                 else:
                     new_arg_value = old_arg_value
                     msg = (
-                        "the '{old_name}' keyword is deprecated, "
-                        "use '{new_name}' instead"
-                    ).format(old_name=old_arg_name, new_name=new_arg_name)
+                        f"the {repr(old_arg_name)}' keyword is deprecated, "
+                        f"use {repr(new_arg_name)} instead"
+                    )
 
                 warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
                 if kwargs.get(new_arg_name) is not None:
                     msg = (
-                        "Can only specify '{old_name}' or '{new_name}', " "not both"
-                    ).format(old_name=old_arg_name, new_name=new_arg_name)
+                        f"Can only specify {repr(old_arg_name)} "
+                        f"or {repr(new_arg_name)}, not both"
+                    )
                     raise TypeError(msg)
                 else:
                     kwargs[new_arg_name] = new_arg_value
@@ -256,7 +248,7 @@ def wrapper(*args, **kwargs) -> Callable[..., Any]:
 
 
 # Substitution and Appender are derived from matplotlib.docstring (1.1.0)
-# module http://matplotlib.org/users/license.html
+# module https://matplotlib.org/users/license.html
 
 
 class Substitution:
@@ -302,7 +294,6 @@ def update(self, *args, **kwargs) -> None:
         """
         Update self.params with supplied args.
         """
-
         if isinstance(self.params, dict):
             self.params.update(*args, **kwargs)
 
@@ -327,9 +318,11 @@ def my_dog(has='fleas'):
         pass
     """
 
+    addendum: Optional[str]
+
     def __init__(self, addendum: Optional[str], join: str = "", indents: int = 0):
         if indents > 0:
-            self.addendum = indent(addendum, indents=indents)  # type: Optional[str]
+            self.addendum = indent(addendum, indents=indents)
         else:
             self.addendum = addendum
         self.join = join
diff --git a/pandas/util/_depr_module.py b/pandas/util/_depr_module.py
index 54f090ede3fc4..5694ca24aab57 100644
--- a/pandas/util/_depr_module.py
+++ b/pandas/util/_depr_module.py
@@ -4,11 +4,13 @@
 """
 
 import importlib
+from typing import Iterable
 import warnings
 
 
 class _DeprecatedModule:
-    """ Class for mocking deprecated modules.
+    """
+    Class for mocking deprecated modules.
 
     Parameters
     ----------
@@ -32,19 +34,19 @@ def __init__(self, deprmod, deprmodto=None, removals=None, moved=None):
         self.moved = moved
 
         # For introspection purposes.
-        self.self_dir = frozenset(dir(self.__class__))
+        self.self_dir = frozenset(dir(type(self)))
 
-    def __dir__(self):
+    def __dir__(self) -> Iterable[str]:
         deprmodule = self._import_deprmod()
         return dir(deprmodule)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         deprmodule = self._import_deprmod()
         return repr(deprmodule)
 
     __str__ = __repr__
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str):
         if name in self.self_dir:
             return object.__getattribute__(self, name)
 
@@ -61,17 +63,15 @@ def __getattr__(self, name):
 
         if self.removals is not None and name in self.removals:
             warnings.warn(
-                "{deprmod}.{name} is deprecated and will be removed in "
-                "a future version.".format(deprmod=self.deprmod, name=name),
+                f"{self.deprmod}.{name} is deprecated and will be removed in "
+                "a future version.",
                 FutureWarning,
                 stacklevel=2,
             )
         elif self.moved is not None and name in self.moved:
             warnings.warn(
-                "{deprmod} is deprecated and will be removed in "
-                "a future version.\nYou can access {name} as {moved}".format(
-                    deprmod=self.deprmod, name=name, moved=self.moved[name]
-                ),
+                f"{self.deprmod} is deprecated and will be removed in "
+                f"a future version.\nYou can access {name} as {self.moved[name]}",
                 FutureWarning,
                 stacklevel=2,
             )
@@ -79,8 +79,8 @@ def __getattr__(self, name):
             deprmodto = self.deprmodto
             if deprmodto is False:
                 warnings.warn(
-                    "{deprmod}.{name} is deprecated and will be removed in "
-                    "a future version.".format(deprmod=self.deprmod, name=name),
+                    f"{self.deprmod}.{name} is deprecated and will be removed in "
+                    "a future version.",
                     FutureWarning,
                     stacklevel=2,
                 )
@@ -89,10 +89,8 @@ def __getattr__(self, name):
                     deprmodto = obj.__module__
                 # The object is actually located in another module.
                 warnings.warn(
-                    "{deprmod}.{name} is deprecated. Please use "
-                    "{deprmodto}.{name} instead.".format(
-                        deprmod=self.deprmod, name=name, deprmodto=deprmodto
-                    ),
+                    f"{self.deprmod}.{name} is deprecated. Please use "
+                    f"{deprmodto}.{name} instead.",
                     FutureWarning,
                     stacklevel=2,
                 )
diff --git a/pandas/util/_doctools.py b/pandas/util/_doctools.py
index 11156bc972857..8fd4566d7763b 100644
--- a/pandas/util/_doctools.py
+++ b/pandas/util/_doctools.py
@@ -1,3 +1,5 @@
+from typing import Optional, Tuple
+
 import numpy as np
 
 import pandas as pd
@@ -9,24 +11,27 @@ class TablePlotter:
     Used in merging.rst
     """
 
-    def __init__(self, cell_width=0.37, cell_height=0.25, font_size=7.5):
+    def __init__(
+        self,
+        cell_width: float = 0.37,
+        cell_height: float = 0.25,
+        font_size: float = 7.5,
+    ):
         self.cell_width = cell_width
         self.cell_height = cell_height
         self.font_size = font_size
 
-    def _shape(self, df):
+    def _shape(self, df: pd.DataFrame) -> Tuple[int, int]:
         """
         Calculate table chape considering index levels.
         """
-
         row, col = df.shape
         return row + df.columns.nlevels, col + df.index.nlevels
 
-    def _get_cells(self, left, right, vertical):
+    def _get_cells(self, left, right, vertical) -> Tuple[int, int]:
         """
         Calculate appropriate figure size based on left and right data.
         """
-
         if vertical:
             # calculate required number of cells
             vcells = max(sum(self._shape(l)[0] for l in left), self._shape(right)[0])
@@ -36,7 +41,7 @@ def _get_cells(self, left, right, vertical):
             hcells = sum([self._shape(l)[1] for l in left] + [self._shape(right)[1]])
         return hcells, vcells
 
-    def plot(self, left, right, labels=None, vertical=True):
+    def plot(self, left, right, labels=None, vertical: bool = True):
         """
         Plot left / right DataFrames in specified layout.
 
@@ -45,7 +50,7 @@ def plot(self, left, right, labels=None, vertical=True):
         left : list of DataFrames before operation is applied
         right : DataFrame of operation result
         labels : list of str to be drawn as titles of left DataFrames
-        vertical : bool
+        vertical : bool, default True
             If True, use vertical layout. If False, use horizontal layout.
         """
         import matplotlib.pyplot as plt
@@ -96,7 +101,9 @@ def plot(self, left, right, labels=None, vertical=True):
         return fig
 
     def _conv(self, data):
-        """Convert each input to appropriate for table outplot"""
+        """
+        Convert each input to appropriate for table outplot.
+        """
         if isinstance(data, pd.Series):
             if data.name is None:
                 data = data.to_frame(name="")
@@ -113,7 +120,7 @@ def _insert_index(self, data):
             data.insert(0, "Index", data.index)
         else:
             for i in range(idx_nlevels):
-                data.insert(i, "Index{0}".format(i), data.index._get_level_values(i))
+                data.insert(i, f"Index{i}", data.index._get_level_values(i))
 
         col_nlevels = data.columns.nlevels
         if col_nlevels > 1:
@@ -127,7 +134,7 @@ def _insert_index(self, data):
             data.columns = col
         return data
 
-    def _make_table(self, ax, df, title, height=None):
+    def _make_table(self, ax, df, title: str, height: Optional[float] = None):
         if df is None:
             ax.set_visible(False)
             return
diff --git a/pandas/util/_exceptions.py b/pandas/util/_exceptions.py
index 953c8a43a21b8..0723a37b1ba82 100644
--- a/pandas/util/_exceptions.py
+++ b/pandas/util/_exceptions.py
@@ -1,16 +1,19 @@
 import contextlib
+from typing import Tuple
 
 
 @contextlib.contextmanager
-def rewrite_exception(old_name, new_name):
-    """Rewrite the message of an exception."""
+def rewrite_exception(old_name: str, new_name: str):
+    """
+    Rewrite the message of an exception.
+    """
     try:
         yield
-    except Exception as e:
-        msg = e.args[0]
+    except Exception as err:
+        msg = err.args[0]
         msg = msg.replace(old_name, new_name)
-        args = (msg,)
-        if len(e.args) > 1:
-            args = args + e.args[1:]
-        e.args = args
+        args: Tuple[str, ...] = (msg,)
+        if len(err.args) > 1:
+            args = args + err.args[1:]
+        err.args = args
         raise
diff --git a/pandas/util/_print_versions.py b/pandas/util/_print_versions.py
index 21d09c06940ca..fdfa436ce6536 100644
--- a/pandas/util/_print_versions.py
+++ b/pandas/util/_print_versions.py
@@ -1,18 +1,21 @@
 import codecs
+import json
 import locale
 import os
 import platform
 import struct
 import subprocess
 import sys
+from typing import List, Optional, Tuple, Union
 
 from pandas.compat._optional import VERSIONS, _get_version, import_optional_dependency
 
 
-def get_sys_info():
-    "Returns system information as a dict"
-
-    blob = []
+def get_sys_info() -> List[Tuple[str, Optional[Union[str, int]]]]:
+    """
+    Returns system information as a list
+    """
+    blob: List[Tuple[str, Optional[Union[str, int]]]] = []
 
     # get full commit hash
     commit = None
@@ -28,12 +31,7 @@ def get_sys_info():
             pass
         else:
             if pipe.returncode == 0:
-                commit = so
-                try:
-                    commit = so.decode("utf-8")
-                except ValueError:
-                    pass
-                commit = commit.strip().strip('"')
+                commit = so.decode("utf-8").strip().strip('"')
 
     blob.append(("commit", commit))
 
@@ -43,14 +41,15 @@ def get_sys_info():
             [
                 ("python", ".".join(map(str, sys.version_info))),
                 ("python-bits", struct.calcsize("P") * 8),
-                ("OS", "{sysname}".format(sysname=sysname)),
-                ("OS-release", "{release}".format(release=release)),
-                # ("Version", "{version}".format(version=version)),
-                ("machine", "{machine}".format(machine=machine)),
-                ("processor", "{processor}".format(processor=processor)),
-                ("byteorder", "{byteorder}".format(byteorder=sys.byteorder)),
-                ("LC_ALL", "{lc}".format(lc=os.environ.get("LC_ALL", "None"))),
-                ("LANG", "{lang}".format(lang=os.environ.get("LANG", "None"))),
+                ("OS", f"{sysname}"),
+                ("OS-release", f"{release}"),
+                # FIXME: dont leave commented-out
+                # ("Version", f"{version}"),
+                ("machine", f"{machine}"),
+                ("processor", f"{processor}"),
+                ("byteorder", f"{sys.byteorder}"),
+                ("LC_ALL", f"{os.environ.get('LC_ALL', 'None')}"),
+                ("LANG", f"{os.environ.get('LANG', 'None')}"),
                 ("LOCALE", ".".join(map(str, locale.getlocale()))),
             ]
         )
@@ -98,6 +97,7 @@ def show_versions(as_json=False):
         mod = import_optional_dependency(
             modname, raise_on_missing=False, on_version="ignore"
         )
+        ver: Optional[str]
         if mod:
             ver = _get_version(mod)
         else:
@@ -105,11 +105,6 @@ def show_versions(as_json=False):
         deps_blob.append((modname, ver))
 
     if as_json:
-        try:
-            import json
-        except ImportError:
-            import simplejson as json
-
         j = dict(system=dict(sys_info), dependencies=dict(deps_blob))
 
         if as_json is True:
@@ -120,17 +115,16 @@ def show_versions(as_json=False):
 
     else:
         maxlen = max(len(x) for x in deps)
-        tpl = "{{k:<{maxlen}}}: {{stat}}".format(maxlen=maxlen)
         print("\nINSTALLED VERSIONS")
         print("------------------")
         for k, stat in sys_info:
-            print(tpl.format(k=k, stat=stat))
+            print(f"{{k:<{maxlen}}}: {{stat}}")
         print("")
         for k, stat in deps_blob:
-            print(tpl.format(k=k, stat=stat))
+            print(f"{{k:<{maxlen}}}: {{stat}}")
 
 
-def main():
+def main() -> int:
     from optparse import OptionParser
 
     parser = OptionParser()
@@ -139,7 +133,7 @@ def main():
         "--json",
         metavar="FILE",
         nargs=1,
-        help="Save output as JSON into file, pass in " "'-' to output to stdout",
+        help="Save output as JSON into file, pass in '-' to output to stdout",
     )
 
     (options, args) = parser.parse_args()
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 0e07b9f5fe9f7..cd7fdd55a4d2c 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -24,18 +24,21 @@ def test_foo():
 For more information, refer to the ``pytest`` documentation on ``skipif``.
 """
 from distutils.version import LooseVersion
+from functools import wraps
 import locale
 from typing import Callable, Optional
 
+import numpy as np
 import pytest
 
 from pandas.compat import is_platform_32bit, is_platform_windows
+from pandas.compat._optional import import_optional_dependency
 from pandas.compat.numpy import _np_version
 
 from pandas.core.computation.expressions import _NUMEXPR_INSTALLED, _USE_NUMEXPR
 
 
-def safe_import(mod_name, min_version=None):
+def safe_import(mod_name: str, min_version: Optional[str] = None):
     """
     Parameters:
     -----------
@@ -73,6 +76,21 @@ def safe_import(mod_name, min_version=None):
     return False
 
 
+# TODO:
+# remove when gh-24839 is fixed.
+# this affects numpy 1.16 and pytables 3.4.4
+tables = safe_import("tables")
+xfail_non_writeable = pytest.mark.xfail(
+    tables
+    and LooseVersion(np.__version__) >= LooseVersion("1.16")
+    and LooseVersion(tables.__version__) < LooseVersion("3.5.1"),
+    reason=(
+        "gh-25511, gh-24839. pytables needs a "
+        "release beyond 3.4.4 to support numpy 1.16.x"
+    ),
+)
+
+
 def _skip_if_no_mpl():
     mod = safe_import("matplotlib")
     if mod:
@@ -93,7 +111,7 @@ def _skip_if_not_us_locale():
         return True
 
 
-def _skip_if_no_scipy():
+def _skip_if_no_scipy() -> bool:
     return not (
         safe_import("scipy.stats")
         and safe_import("scipy.sparse")
@@ -112,7 +130,7 @@ def skip_if_installed(package: str) -> Callable:
         The name of the package.
     """
     return pytest.mark.skipif(
-        safe_import(package), reason="Skipping because {} is installed.".format(package)
+        safe_import(package), reason=f"Skipping because {package} is installed."
     )
 
 
@@ -146,9 +164,9 @@ def skip_if_no(package: str, min_version: Optional[str] = None) -> Callable:
         a pytest.mark.skipif to use as either a test decorator or a
         parametrization mark.
     """
-    msg = "Could not import '{}'".format(package)
+    msg = f"Could not import '{package}'"
     if min_version:
-        msg += " satisfying a min_version of {}".format(min_version)
+        msg += f" satisfying a min_version of {min_version}"
     return pytest.mark.skipif(
         not safe_import(package, min_version=min_version), reason=msg
     )
@@ -164,26 +182,25 @@ def skip_if_no(package: str, min_version: Optional[str] = None) -> Callable:
     is_platform_windows(), reason="not used on win32"
 )
 skip_if_has_locale = pytest.mark.skipif(
-    _skip_if_has_locale(),
-    reason="Specific locale is set {lang}".format(lang=locale.getlocale()[0]),
+    _skip_if_has_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}",
 )
 skip_if_not_us_locale = pytest.mark.skipif(
-    _skip_if_not_us_locale(),
-    reason="Specific locale is set " "{lang}".format(lang=locale.getlocale()[0]),
+    _skip_if_not_us_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}",
 )
 skip_if_no_scipy = pytest.mark.skipif(
     _skip_if_no_scipy(), reason="Missing SciPy requirement"
 )
 skip_if_no_ne = pytest.mark.skipif(
     not _USE_NUMEXPR,
-    reason="numexpr enabled->{enabled}, "
-    "installed->{installed}".format(enabled=_USE_NUMEXPR, installed=_NUMEXPR_INSTALLED),
+    reason=f"numexpr enabled->{_USE_NUMEXPR}, installed->{_NUMEXPR_INSTALLED}",
 )
 
 
-def skip_if_np_lt(ver_str, reason=None, *args, **kwds):
+def skip_if_np_lt(
+    ver_str: str, reason: Optional[str] = None, *args, **kwds
+) -> Callable:
     if reason is None:
-        reason = "NumPy %s or greater required" % ver_str
+        reason = f"NumPy {ver_str} or greater required"
     return pytest.mark.skipif(
         _np_version < LooseVersion(ver_str), reason=reason, *args, **kwds
     )
@@ -197,14 +214,14 @@ def parametrize_fixture_doc(*args):
     initial fixture docstring by replacing placeholders {0}, {1} etc
     with parameters passed as arguments.
 
-    Parameters:
+    Parameters
     ----------
-        args: iterable
-            Positional arguments for docstring.
+    args: iterable
+        Positional arguments for docstring.
 
-    Returns:
+    Returns
     -------
-    documented_fixture: function
+    function
         The decorated function wrapped within a pytest
         ``parametrize_fixture_doc`` mark
     """
@@ -214,3 +231,34 @@ def documented_fixture(fixture):
         return fixture
 
     return documented_fixture
+
+
+def check_file_leaks(func) -> Callable:
+    """
+    Decorate a test function tot check that we are not leaking file descriptors.
+    """
+    psutil = safe_import("psutil")
+    if not psutil:
+        return func
+
+    @wraps(func)
+    def new_func(*args, **kwargs):
+        proc = psutil.Process()
+        flist = proc.open_files()
+
+        func(*args, **kwargs)
+
+        flist2 = proc.open_files()
+        assert flist2 == flist
+
+    return new_func
+
+
+def async_mark():
+    try:
+        import_optional_dependency("pytest_asyncio")
+        async_mark = pytest.mark.asyncio
+    except ImportError:
+        async_mark = pytest.mark.skip(reason="Missing dependency pytest-asyncio")
+
+    return async_mark
diff --git a/pandas/util/_tester.py b/pandas/util/_tester.py
index 0f5324c8d02ba..b299f3790ab22 100644
--- a/pandas/util/_tester.py
+++ b/pandas/util/_tester.py
@@ -1,5 +1,5 @@
 """
-Entrypoint for testing from the top-level namespace
+Entrypoint for testing from the top-level namespace.
 """
 import os
 import sys
@@ -11,7 +11,7 @@ def test(extra_args=None):
     try:
         import pytest
     except ImportError:
-        raise ImportError("Need pytest>=4.0.2 to run tests")
+        raise ImportError("Need pytest>=5.0.1 to run tests")
     try:
         import hypothesis  # noqa
     except ImportError:
@@ -22,7 +22,8 @@ def test(extra_args=None):
             extra_args = [extra_args]
         cmd = extra_args
     cmd += [PKG]
-    print("running: pytest {}".format(" ".join(cmd)))
+    joined = " ".join(cmd)
+    print(f"running: pytest {joined}")
     sys.exit(pytest.main(cmd))
 
 
diff --git a/pandas/util/_validators.py b/pandas/util/_validators.py
index 8d5f9f7749682..a715094e65e98 100644
--- a/pandas/util/_validators.py
+++ b/pandas/util/_validators.py
@@ -2,8 +2,11 @@
 Module that contains many useful utilities
 for validating data or function arguments
 """
+from typing import Iterable, Union
 import warnings
 
+import numpy as np
+
 from pandas.core.dtypes.common import is_bool
 
 
@@ -12,7 +15,6 @@ def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
     Checks whether 'args' has length of at most 'compat_args'. Raises
     a TypeError if that is not the case, similar to in Python when a
     function is called with too many arguments.
-
     """
     if max_fname_arg_count < 0:
         raise ValueError("'max_fname_arg_count' must be non-negative")
@@ -23,13 +25,8 @@ def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
         argument = "argument" if max_arg_count == 1 else "arguments"
 
         raise TypeError(
-            "{fname}() takes at most {max_arg} {argument} "
-            "({given_arg} given)".format(
-                fname=fname,
-                max_arg=max_arg_count,
-                argument=argument,
-                given_arg=actual_arg_count,
-            )
+            f"{fname}() takes at most {max_arg_count} {argument} "
+            f"({actual_arg_count} given)"
         )
 
 
@@ -40,7 +37,6 @@ def _check_for_default_values(fname, arg_val_dict, compat_args):
 
     Note that this function is to be called only when it has been
     checked that arg_val_dict.keys() is a subset of compat_args
-
     """
     for key in arg_val_dict:
         # try checking equality directly with '=' operator,
@@ -67,11 +63,8 @@ def _check_for_default_values(fname, arg_val_dict, compat_args):
 
         if not match:
             raise ValueError(
-                (
-                    "the '{arg}' parameter is not "
-                    "supported in the pandas "
-                    "implementation of {fname}()".format(fname=fname, arg=key)
-                )
+                f"the '{key}' parameter is not supported in "
+                f"the pandas implementation of {fname}()"
             )
 
 
@@ -81,32 +74,30 @@ def validate_args(fname, args, max_fname_arg_count, compat_args):
     has at most `len(compat_args)` arguments and whether or not all of these
     elements in `args` are set to their default values.
 
-    fname: str
+    Parameters
+    ----------
+    fname : str
         The name of the function being passed the `*args` parameter
-
-    args: tuple
+    args : tuple
         The `*args` parameter passed into a function
-
-    max_fname_arg_count: int
+    max_fname_arg_count : int
         The maximum number of arguments that the function `fname`
         can accept, excluding those in `args`. Used for displaying
         appropriate error messages. Must be non-negative.
-
-    compat_args: OrderedDict
-        A ordered dictionary of keys and their associated default values.
+    compat_args : dict
+        A dictionary of keys and their associated default values.
         In order to accommodate buggy behaviour in some versions of `numpy`,
         where a signature displayed keyword arguments but then passed those
         arguments **positionally** internally when calling downstream
-        implementations, an ordered dictionary ensures that the original
-        order of the keyword arguments is enforced. Note that if there is
-        only one key, a generic dict can be passed in as well.
-
+        implementations, a dict ensures that the original
+        order of the keyword arguments is enforced.
     Raises
     ------
-    TypeError if `args` contains more values than there are `compat_args`
-    ValueError if `args` contains values that do not correspond to those
-    of the default values specified in `compat_args`
-
+    TypeError
+        If `args` contains more values than there are `compat_args`
+    ValueError
+        If `args` contains values that do not correspond to those
+        of the default values specified in `compat_args`
     """
     _check_arg_length(fname, args, max_fname_arg_count, compat_args)
 
@@ -121,19 +112,13 @@ def _check_for_invalid_keys(fname, kwargs, compat_args):
     """
     Checks whether 'kwargs' contains any keys that are not
     in 'compat_args' and raises a TypeError if there is one.
-
     """
     # set(dict) --> set of the dictionary's keys
     diff = set(kwargs) - set(compat_args)
 
     if diff:
         bad_arg = list(diff)[0]
-        raise TypeError(
-            (
-                "{fname}() got an unexpected "
-                "keyword argument '{arg}'".format(fname=fname, arg=bad_arg)
-            )
-        )
+        raise TypeError(f"{fname}() got an unexpected keyword argument '{bad_arg}'")
 
 
 def validate_kwargs(fname, kwargs, compat_args):
@@ -144,12 +129,10 @@ def validate_kwargs(fname, kwargs, compat_args):
 
     Parameters
     ----------
-    fname: str
+    fname : str
         The name of the function being passed the `**kwargs` parameter
-
-    kwargs: dict
+    kwargs : dict
         The `**kwargs` parameter passed into `fname`
-
     compat_args: dict
         A dictionary of keys that `kwargs` is allowed to have and their
         associated default values
@@ -159,7 +142,6 @@ def validate_kwargs(fname, kwargs, compat_args):
     TypeError if `kwargs` contains keys not in `compat_args`
     ValueError if `kwargs` contains keys in `compat_args` that do not
     map to the default values specified in `compat_args`
-
     """
     kwds = kwargs.copy()
     _check_for_invalid_keys(fname, kwargs, compat_args)
@@ -176,22 +158,17 @@ def validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, compat_ar
     ----------
     fname: str
         The name of the function being passed the `**kwargs` parameter
-
     args: tuple
         The `*args` parameter passed into a function
-
     kwargs: dict
         The `**kwargs` parameter passed into `fname`
-
     max_fname_arg_count: int
         The minimum number of arguments that the function `fname`
         requires, excluding those in `args`. Used for displaying
         appropriate error messages. Must be non-negative.
-
-    compat_args: OrderedDict
-        A ordered dictionary of keys that `kwargs` is allowed to
-        have and their associated default values. Note that if there
-        is only one key, a generic dict can be passed in as well.
+    compat_args: dict
+        A dictionary of keys that `kwargs` is allowed to
+        have and their associated default values.
 
     Raises
     ------
@@ -220,8 +197,7 @@ def validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, compat_ar
     for key in args_dict:
         if key in kwargs:
             raise TypeError(
-                "{fname}() got multiple values for keyword "
-                "argument '{arg}'".format(fname=fname, arg=key)
+                f"{fname}() got multiple values for keyword argument '{key}'"
             )
 
     kwargs.update(args_dict)
@@ -232,8 +208,8 @@ def validate_bool_kwarg(value, arg_name):
     """ Ensures that argument passed in arg_name is of type bool. """
     if not (is_bool(value) or value is None):
         raise ValueError(
-            'For argument "{arg}" expected type bool, received '
-            "type {typ}.".format(arg=arg_name, typ=type(value).__name__)
+            f'For argument "{arg_name}" expected type bool, received '
+            f"type {type(value).__name__}."
         )
     return value
 
@@ -286,9 +262,7 @@ def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
     # First fill with explicit values provided by the user...
     if arg_name in kwargs:
         if args:
-            msg = "{} got multiple values for argument " "'{}'".format(
-                method_name, arg_name
-            )
+            msg = f"{method_name} got multiple values for argument '{arg_name}'"
             raise TypeError(msg)
 
         axis = data._get_axis_name(kwargs.get("axis", 0))
@@ -315,7 +289,7 @@ def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
     elif len(args) == 2:
         if "axis" in kwargs:
             # Unambiguously wrong
-            msg = "Cannot specify both 'axis' and any of 'index' " "or 'columns'"
+            msg = "Cannot specify both 'axis' and any of 'index' or 'columns'"
             raise TypeError(msg)
 
         msg = (
@@ -323,14 +297,14 @@ def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
             "\n\t'.{method_name}(index=a, columns=b)'.\nUse named "
             "arguments to remove any ambiguity. In the future, using "
             "positional arguments for 'index' or 'columns' will raise "
-            " a 'TypeError'."
+            "a 'TypeError'."
         )
         warnings.warn(msg.format(method_name=method_name), FutureWarning, stacklevel=4)
         out[data._AXIS_NAMES[0]] = args[0]
         out[data._AXIS_NAMES[1]] = args[1]
     else:
-        msg = "Cannot specify all of '{}', 'index', 'columns'."
-        raise TypeError(msg.format(arg_name))
+        msg = f"Cannot specify all of '{arg_name}', 'index', 'columns'."
+        raise TypeError(msg)
     return out
 
 
@@ -363,10 +337,42 @@ def validate_fillna_kwargs(value, method, validate_scalar_dict_value=True):
         if validate_scalar_dict_value and isinstance(value, (list, tuple)):
             raise TypeError(
                 '"value" parameter must be a scalar or dict, but '
-                'you passed a "{0}"'.format(type(value).__name__)
+                f'you passed a "{type(value).__name__}"'
             )
 
     elif value is not None and method is not None:
         raise ValueError("Cannot specify both 'value' and 'method'.")
 
     return value, method
+
+
+def validate_percentile(q: Union[float, Iterable[float]]) -> np.ndarray:
+    """
+    Validate percentiles (used by describe and quantile).
+
+    This function checks if the given float oriterable of floats is a valid percentile
+    otherwise raises a ValueError.
+
+    Parameters
+    ----------
+    q: float or iterable of floats
+        A single percentile or an iterable of percentiles.
+
+    Returns
+    -------
+    ndarray
+        An ndarray of the percentiles if valid.
+
+    Raises
+    ------
+    ValueError if percentiles are not in given interval([0, 1]).
+    """
+    msg = "percentiles should all be in the interval [0, 1]. Try {0} instead."
+    q_arr = np.asarray(q)
+    if q_arr.ndim == 0:
+        if not 0 <= q_arr <= 1:
+            raise ValueError(msg.format(q_arr / 100.0))
+    else:
+        if not all(0 <= qs <= 1 for qs in q_arr):
+            raise ValueError(msg.format(q_arr / 100.0))
+    return q_arr
diff --git a/pandas/util/move.c b/pandas/util/move.c
deleted file mode 100644
index 1c29a4c214909..0000000000000
--- a/pandas/util/move.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-Copyright (c) 2019, PyData Development Team
-All rights reserved.
-
-Distributed under the terms of the BSD Simplified License.
-
-The full license is in the LICENSE file, distributed with this software.
-*/
-
-#define PY_SSIZE_T_CLEAN
-#include <Python.h>
-
-#ifndef Py_TPFLAGS_HAVE_GETCHARBUFFER
-#define Py_TPFLAGS_HAVE_GETCHARBUFFER 0
-#endif  // Py_TPFLAGS_HAVE_GETCHARBUFFER
-
-#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
-#define Py_TPFLAGS_HAVE_NEWBUFFER 0
-#endif  // Py_TPFLAGS_HAVE_NEWBUFFER
-
-static PyObject *badmove;  /* bad move exception class */
-
-typedef struct {
-    PyObject_HEAD
-    /* the bytes that own the buffer we are mutating */
-    PyObject *invalid_bytes;
-} stolenbufobject;
-
-static PyTypeObject stolenbuf_type;  /* forward declare type */
-
-static void
-stolenbuf_dealloc(stolenbufobject *self) {
-    Py_DECREF(self->invalid_bytes);
-    PyObject_Del(self);
-}
-
-static int
-stolenbuf_getbuffer(stolenbufobject *self, Py_buffer *view, int flags) {
-    return PyBuffer_FillInfo(view,
-                             (PyObject*) self,
-                             (void*) PyBytes_AS_STRING(self->invalid_bytes),
-                             PyBytes_GET_SIZE(self->invalid_bytes),
-                             0,  /* not readonly */
-                             flags);
-}
-
-static PyBufferProcs stolenbuf_as_buffer = {
-    (getbufferproc) stolenbuf_getbuffer,
-    NULL,
-};
-
-PyDoc_STRVAR(stolenbuf_doc,
-             "A buffer that is wrapping a stolen bytes object's buffer.");
-
-static PyTypeObject stolenbuf_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "pandas.util._move.stolenbuf",              /* tp_name */
-    sizeof(stolenbufobject),                    /* tp_basicsize */
-    0,                                          /* tp_itemsize */
-    (destructor) stolenbuf_dealloc,             /* tp_dealloc */
-    0,                                          /* tp_print */
-    0,                                          /* tp_getattr */
-    0,                                          /* tp_setattr */
-    0,                                          /* tp_reserved */
-    0,                                          /* tp_repr */
-    0,                                          /* tp_as_number */
-    0,                                          /* tp_as_sequence */
-    0,                                          /* tp_as_mapping */
-    0,                                          /* tp_hash */
-    0,                                          /* tp_call */
-    0,                                          /* tp_str */
-    0,                                          /* tp_getattro */
-    0,                                          /* tp_setattro */
-    &stolenbuf_as_buffer,                       /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT |
-    Py_TPFLAGS_HAVE_NEWBUFFER |
-    Py_TPFLAGS_HAVE_GETCHARBUFFER,              /* tp_flags */
-    stolenbuf_doc,                              /* tp_doc */
-};
-
-PyDoc_STRVAR(
-    move_into_mutable_buffer_doc,
-    "Moves a bytes object that is about to be destroyed into a mutable buffer\n"
-    "without copying the data.\n"
-    "\n"
-    "Parameters\n"
-    "----------\n"
-    "bytes_rvalue : bytes with 1 refcount.\n"
-    "    The bytes object that you want to move into a mutable buffer. This\n"
-    "    cannot be a named object. It must only have a single reference.\n"
-    "\n"
-    "Returns\n"
-    "-------\n"
-    "buf : stolenbuf\n"
-    "    An object that supports the buffer protocol which can give a mutable\n"
-    "    view of the data that was previously owned by ``bytes_rvalue``.\n"
-    "\n"
-    "Raises\n"
-    "------\n"
-    "BadMove\n"
-    "    Raised when a move is attempted on an object with more than one\n"
-    "    reference.\n"
-    "\n"
-    "Notes\n"
-    "-----\n"
-    "If you want to use this function you are probably wrong.\n"
-    "\n"
-    "Warning: Do not call this function through *unpacking. This can\n"
-    "potentially trick the reference checks which may allow you to get a\n"
-    "mutable reference to a shared string!\n"
-    "\n");
-
-/* This is implemented as a standalone function instead of the ``tp_new`` of
-   ``stolenbuf`` because we need to create a function using the METH_O flag
-   to support Python 3.6. In python 3.6, PyCFunction calls from python code now
-   count the reference owned by the argument tuple. This would cause the object
-   to have 2 references if used with a direct call like: ``stolenbuf(a)``;
-   however, if called through *unpacking like ``stolenbuf(*(a,))`` it would
-   only have the one reference (the tuple). */
-static PyObject*
-move_into_mutable_buffer(PyObject *self, PyObject *bytes_rvalue) {
-    stolenbufobject *ret;
-
-    if (!PyBytes_CheckExact(bytes_rvalue)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "stolenbuf can only steal from bytes objects");
-        return NULL;
-    }
-
-    if (Py_REFCNT(bytes_rvalue) != 1) {
-        // there is a reference other than the caller's stack
-        PyErr_SetObject(badmove, bytes_rvalue);
-        return NULL;
-    }
-
-    if (!(ret = PyObject_New(stolenbufobject, &stolenbuf_type))) {
-        return NULL;
-    }
-
-    /* store the original bytes object in a field that is not
-       exposed to python */
-    Py_INCREF(bytes_rvalue);
-    ret->invalid_bytes = bytes_rvalue;
-    return (PyObject*) ret;
-}
-
-static PyMethodDef methods[] = {
-    {"move_into_mutable_buffer",
-     (PyCFunction) move_into_mutable_buffer,
-     METH_O,
-     move_into_mutable_buffer_doc},
-    {NULL},
-};
-
-#define MODULE_NAME "pandas.util._move"
-
-static PyModuleDef move_module = {
-    PyModuleDef_HEAD_INIT,
-    MODULE_NAME,
-    NULL,
-    -1,
-    methods,
-};
-
-PyDoc_STRVAR(
-    badmove_doc,
-    "Exception used to indicate that a move was attempted on a value with\n"
-    "more than a single reference.\n"
-    "\n"
-    "Parameters\n"
-    "----------\n"
-    "data : any\n"
-    "    The data which was passed to ``move_into_mutable_buffer``.\n"
-    "\n"
-    "See Also\n"
-    "--------\n"
-    "pandas.util._move.move_into_mutable_buffer\n");
-
-PyMODINIT_FUNC
-#define ERROR_RETURN NULL
-PyInit__move(void) {
-    PyObject *m;
-
-    if (!(badmove = PyErr_NewExceptionWithDoc("pandas.util._move.BadMove",
-                                              badmove_doc,
-                                              NULL,
-                                              NULL))) {
-        return ERROR_RETURN;
-    }
-
-    if (PyType_Ready(&stolenbuf_type)) {
-        return ERROR_RETURN;
-    }
-
-    if (!(m = PyModule_Create(&move_module))) {
-        return ERROR_RETURN;
-    }
-
-    if (PyModule_AddObject(m,
-                           "stolenbuf",
-                           (PyObject*) &stolenbuf_type)) {
-        Py_DECREF(m);
-        return ERROR_RETURN;
-    }
-
-    if (PyModule_AddObject(m, "BadMove", badmove)) {
-        Py_DECREF(m);
-        return ERROR_RETURN;
-    }
-
-    return m;
-}
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index c54dab046f57e..af9fe4846b27d 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -1,3001 +1,12 @@
-import bz2
-from collections import Counter
-from contextlib import contextmanager
-from datetime import datetime
-from functools import wraps
-import gzip
-import os
-import re
-from shutil import rmtree
-import string
-import tempfile
-import traceback
-from typing import Union, cast
 import warnings
-import zipfile
 
-import numpy as np
-from numpy.random import rand, randn
+from pandas._testing import *  # noqa
 
-from pandas._config.localization import (  # noqa:F401
-    can_set_locale,
-    get_locales,
-    set_locale,
+warnings.warn(
+    (
+        "pandas.util.testing is deprecated. Use the functions in the "
+        "public API at pandas.testing instead."
+    ),
+    FutureWarning,
+    stacklevel=2,
 )
-
-import pandas._libs.testing as _testing
-from pandas.compat import _get_lzma_file, _import_lzma, raise_with_traceback
-
-from pandas.core.dtypes.common import (
-    is_bool,
-    is_categorical_dtype,
-    is_datetime64_dtype,
-    is_datetime64tz_dtype,
-    is_extension_array_dtype,
-    is_interval_dtype,
-    is_list_like,
-    is_number,
-    is_period_dtype,
-    is_sequence,
-    is_timedelta64_dtype,
-    needs_i8_conversion,
-)
-from pandas.core.dtypes.missing import array_equivalent
-
-import pandas as pd
-from pandas import (
-    Categorical,
-    CategoricalIndex,
-    DataFrame,
-    DatetimeIndex,
-    Index,
-    IntervalIndex,
-    MultiIndex,
-    RangeIndex,
-    Series,
-    bdate_range,
-)
-from pandas.core.algorithms import take_1d
-from pandas.core.arrays import (
-    DatetimeArray,
-    ExtensionArray,
-    IntervalArray,
-    PeriodArray,
-    TimedeltaArray,
-    period_array,
-)
-
-from pandas.io.common import urlopen
-from pandas.io.formats.printing import pprint_thing
-
-lzma = _import_lzma()
-
-N = 30
-K = 4
-_RAISE_NETWORK_ERROR_DEFAULT = False
-
-# set testing_mode
-_testing_mode_warnings = (DeprecationWarning, ResourceWarning)
-
-
-def set_testing_mode():
-    # set the testing mode filters
-    testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
-    if "deprecate" in testing_mode:
-        warnings.simplefilter("always", _testing_mode_warnings)
-
-
-def reset_testing_mode():
-    # reset the testing mode filters
-    testing_mode = os.environ.get("PANDAS_TESTING_MODE", "None")
-    if "deprecate" in testing_mode:
-        warnings.simplefilter("ignore", _testing_mode_warnings)
-
-
-set_testing_mode()
-
-
-def reset_display_options():
-    """
-    Reset the display options for printing and representing objects.
-    """
-
-    pd.reset_option("^display.", silent=True)
-
-
-def round_trip_pickle(obj, path=None):
-    """
-    Pickle an object and then read it again.
-
-    Parameters
-    ----------
-    obj : pandas object
-        The object to pickle and then re-read.
-    path : str, default None
-        The path where the pickled object is written and then read.
-
-    Returns
-    -------
-    round_trip_pickled_object : pandas object
-        The original object that was pickled and then re-read.
-    """
-
-    if path is None:
-        path = "__{random_bytes}__.pickle".format(random_bytes=rands(10))
-    with ensure_clean(path) as path:
-        pd.to_pickle(obj, path)
-        return pd.read_pickle(path)
-
-
-def round_trip_pathlib(writer, reader, path=None):
-    """
-    Write an object to file specified by a pathlib.Path and read it back
-
-    Parameters
-    ----------
-    writer : callable bound to pandas object
-        IO writing function (e.g. DataFrame.to_csv )
-    reader : callable
-        IO reading function (e.g. pd.read_csv )
-    path : str, default None
-        The path where the object is written and then read.
-
-    Returns
-    -------
-    round_trip_object : pandas object
-        The original object that was serialized and then re-read.
-    """
-
-    import pytest
-
-    Path = pytest.importorskip("pathlib").Path
-    if path is None:
-        path = "___pathlib___"
-    with ensure_clean(path) as path:
-        writer(Path(path))
-        obj = reader(Path(path))
-    return obj
-
-
-def round_trip_localpath(writer, reader, path=None):
-    """
-    Write an object to file specified by a py.path LocalPath and read it back
-
-    Parameters
-    ----------
-    writer : callable bound to pandas object
-        IO writing function (e.g. DataFrame.to_csv )
-    reader : callable
-        IO reading function (e.g. pd.read_csv )
-    path : str, default None
-        The path where the object is written and then read.
-
-    Returns
-    -------
-    round_trip_object : pandas object
-        The original object that was serialized and then re-read.
-    """
-    import pytest
-
-    LocalPath = pytest.importorskip("py.path").local
-    if path is None:
-        path = "___localpath___"
-    with ensure_clean(path) as path:
-        writer(LocalPath(path))
-        obj = reader(LocalPath(path))
-    return obj
-
-
-@contextmanager
-def decompress_file(path, compression):
-    """
-    Open a compressed file and return a file object
-
-    Parameters
-    ----------
-    path : str
-        The path where the file is read from
-
-    compression : {'gzip', 'bz2', 'zip', 'xz', None}
-        Name of the decompression to use
-
-    Returns
-    -------
-    f : file object
-    """
-
-    if compression is None:
-        f = open(path, "rb")
-    elif compression == "gzip":
-        f = gzip.open(path, "rb")
-    elif compression == "bz2":
-        f = bz2.BZ2File(path, "rb")
-    elif compression == "xz":
-        f = _get_lzma_file(lzma)(path, "rb")
-    elif compression == "zip":
-        zip_file = zipfile.ZipFile(path)
-        zip_names = zip_file.namelist()
-        if len(zip_names) == 1:
-            f = zip_file.open(zip_names.pop())
-        else:
-            raise ValueError("ZIP file {} error. Only one file per ZIP.".format(path))
-    else:
-        msg = "Unrecognized compression type: {}".format(compression)
-        raise ValueError(msg)
-
-    try:
-        yield f
-    finally:
-        f.close()
-        if compression == "zip":
-            zip_file.close()
-
-
-def write_to_compressed(compression, path, data, dest="test"):
-    """
-    Write data to a compressed file.
-
-    Parameters
-    ----------
-    compression : {'gzip', 'bz2', 'zip', 'xz'}
-        The compression type to use.
-    path : str
-        The file path to write the data.
-    data : str
-        The data to write.
-    dest : str, default "test"
-        The destination file (for ZIP only)
-
-    Raises
-    ------
-    ValueError : An invalid compression value was passed in.
-    """
-
-    if compression == "zip":
-        import zipfile
-
-        compress_method = zipfile.ZipFile
-    elif compression == "gzip":
-        import gzip
-
-        compress_method = gzip.GzipFile
-    elif compression == "bz2":
-        import bz2
-
-        compress_method = bz2.BZ2File
-    elif compression == "xz":
-        compress_method = _get_lzma_file(lzma)
-    else:
-        msg = "Unrecognized compression type: {}".format(compression)
-        raise ValueError(msg)
-
-    if compression == "zip":
-        mode = "w"
-        args = (dest, data)
-        method = "writestr"
-    else:
-        mode = "wb"
-        args = (data,)
-        method = "write"
-
-    with compress_method(path, mode=mode) as f:
-        getattr(f, method)(*args)
-
-
-def assert_almost_equal(
-    left, right, check_dtype="equiv", check_less_precise=False, **kwargs
-):
-    """
-    Check that the left and right objects are approximately equal.
-
-    By approximately equal, we refer to objects that are numbers or that
-    contain numbers which may be equivalent to specific levels of precision.
-
-    Parameters
-    ----------
-    left : object
-    right : object
-    check_dtype : bool / string {'equiv'}, default 'equiv'
-        Check dtype if both a and b are the same type. If 'equiv' is passed in,
-        then `RangeIndex` and `Int64Index` are also considered equivalent
-        when doing type checking.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. 5 digits (False) or 3 digits (True)
-        after decimal points are compared. If int, then specify the number
-        of digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-    """
-
-    if isinstance(left, pd.Index):
-        assert_index_equal(
-            left,
-            right,
-            check_exact=False,
-            exact=check_dtype,
-            check_less_precise=check_less_precise,
-            **kwargs
-        )
-
-    elif isinstance(left, pd.Series):
-        assert_series_equal(
-            left,
-            right,
-            check_exact=False,
-            check_dtype=check_dtype,
-            check_less_precise=check_less_precise,
-            **kwargs
-        )
-
-    elif isinstance(left, pd.DataFrame):
-        assert_frame_equal(
-            left,
-            right,
-            check_exact=False,
-            check_dtype=check_dtype,
-            check_less_precise=check_less_precise,
-            **kwargs
-        )
-
-    else:
-        # Other sequences.
-        if check_dtype:
-            if is_number(left) and is_number(right):
-                # Do not compare numeric classes, like np.float64 and float.
-                pass
-            elif is_bool(left) and is_bool(right):
-                # Do not compare bool classes, like np.bool_ and bool.
-                pass
-            else:
-                if isinstance(left, np.ndarray) or isinstance(right, np.ndarray):
-                    obj = "numpy array"
-                else:
-                    obj = "Input"
-                assert_class_equal(left, right, obj=obj)
-        _testing.assert_almost_equal(
-            left,
-            right,
-            check_dtype=check_dtype,
-            check_less_precise=check_less_precise,
-            **kwargs
-        )
-
-
-def _check_isinstance(left, right, cls):
-    """
-    Helper method for our assert_* methods that ensures that
-    the two objects being compared have the right type before
-    proceeding with the comparison.
-
-    Parameters
-    ----------
-    left : The first object being compared.
-    right : The second object being compared.
-    cls : The class type to check against.
-
-    Raises
-    ------
-    AssertionError : Either `left` or `right` is not an instance of `cls`.
-    """
-
-    err_msg = "{name} Expected type {exp_type}, found {act_type} instead"
-    cls_name = cls.__name__
-
-    if not isinstance(left, cls):
-        raise AssertionError(
-            err_msg.format(name=cls_name, exp_type=cls, act_type=type(left))
-        )
-    if not isinstance(right, cls):
-        raise AssertionError(
-            err_msg.format(name=cls_name, exp_type=cls, act_type=type(right))
-        )
-
-
-def assert_dict_equal(left, right, compare_keys=True):
-
-    _check_isinstance(left, right, dict)
-    _testing.assert_dict_equal(left, right, compare_keys=compare_keys)
-
-
-def randbool(size=(), p=0.5):
-    return rand(*size) <= p
-
-
-RANDS_CHARS = np.array(list(string.ascii_letters + string.digits), dtype=(np.str_, 1))
-RANDU_CHARS = np.array(
-    list("".join(map(chr, range(1488, 1488 + 26))) + string.digits),
-    dtype=(np.unicode_, 1),
-)
-
-
-def rands_array(nchars, size, dtype="O"):
-    """Generate an array of byte strings."""
-    retval = (
-        np.random.choice(RANDS_CHARS, size=nchars * np.prod(size))
-        .view((np.str_, nchars))
-        .reshape(size)
-    )
-    if dtype is None:
-        return retval
-    else:
-        return retval.astype(dtype)
-
-
-def randu_array(nchars, size, dtype="O"):
-    """Generate an array of unicode strings."""
-    retval = (
-        np.random.choice(RANDU_CHARS, size=nchars * np.prod(size))
-        .view((np.unicode_, nchars))
-        .reshape(size)
-    )
-    if dtype is None:
-        return retval
-    else:
-        return retval.astype(dtype)
-
-
-def rands(nchars):
-    """
-    Generate one random byte string.
-
-    See `rands_array` if you want to create an array of random strings.
-
-    """
-    return "".join(np.random.choice(RANDS_CHARS, nchars))
-
-
-def randu(nchars):
-    """
-    Generate one random unicode string.
-
-    See `randu_array` if you want to create an array of random unicode strings.
-
-    """
-    return "".join(np.random.choice(RANDU_CHARS, nchars))
-
-
-def close(fignum=None):
-    from matplotlib.pyplot import get_fignums, close as _close
-
-    if fignum is None:
-        for fignum in get_fignums():
-            _close(fignum)
-    else:
-        _close(fignum)
-
-
-# -----------------------------------------------------------------------------
-# contextmanager to ensure the file cleanup
-
-
-@contextmanager
-def ensure_clean(filename=None, return_filelike=False):
-    """Gets a temporary path and agrees to remove on close.
-
-    Parameters
-    ----------
-    filename : str (optional)
-        if None, creates a temporary file which is then removed when out of
-        scope. if passed, creates temporary file with filename as ending.
-    return_filelike : bool (default False)
-        if True, returns a file-like which is *always* cleaned. Necessary for
-        savefig and other functions which want to append extensions.
-    """
-    filename = filename or ""
-    fd = None
-
-    if return_filelike:
-        f = tempfile.TemporaryFile(suffix=filename)
-        try:
-            yield f
-        finally:
-            f.close()
-    else:
-        # don't generate tempfile if using a path with directory specified
-        if len(os.path.dirname(filename)):
-            raise ValueError("Can't pass a qualified name to ensure_clean()")
-
-        try:
-            fd, filename = tempfile.mkstemp(suffix=filename)
-        except UnicodeEncodeError:
-            import pytest
-
-            pytest.skip("no unicode file names on this system")
-
-        try:
-            yield filename
-        finally:
-            try:
-                os.close(fd)
-            except Exception:
-                print(
-                    "Couldn't close file descriptor: {fdesc} (file: {fname})".format(
-                        fdesc=fd, fname=filename
-                    )
-                )
-            try:
-                if os.path.exists(filename):
-                    os.remove(filename)
-            except Exception as e:
-                print("Exception on removing file: {error}".format(error=e))
-
-
-@contextmanager
-def ensure_clean_dir():
-    """
-    Get a temporary directory path and agrees to remove on close.
-
-    Yields
-    ------
-    Temporary directory path
-    """
-    directory_name = tempfile.mkdtemp(suffix="")
-    try:
-        yield directory_name
-    finally:
-        try:
-            rmtree(directory_name)
-        except Exception:
-            pass
-
-
-@contextmanager
-def ensure_safe_environment_variables():
-    """
-    Get a context manager to safely set environment variables
-
-    All changes will be undone on close, hence environment variables set
-    within this contextmanager will neither persist nor change global state.
-    """
-    saved_environ = dict(os.environ)
-    try:
-        yield
-    finally:
-        os.environ.clear()
-        os.environ.update(saved_environ)
-
-
-# -----------------------------------------------------------------------------
-# Comparators
-
-
-def equalContents(arr1, arr2):
-    """Checks if the set of unique elements of arr1 and arr2 are equivalent.
-    """
-    return frozenset(arr1) == frozenset(arr2)
-
-
-def assert_index_equal(
-    left: Index,
-    right: Index,
-    exact: Union[bool, str] = "equiv",
-    check_names: bool = True,
-    check_less_precise: Union[bool, int] = False,
-    check_exact: bool = True,
-    check_categorical: bool = True,
-    obj: str = "Index",
-) -> None:
-    """
-    Check that left and right Index are equal.
-
-    Parameters
-    ----------
-    left : Index
-    right : Index
-    exact : bool / string {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical. If 'equiv', then RangeIndex can be substituted for
-        Int64Index as well.
-    check_names : bool, default True
-        Whether to check the names attribute.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare
-    check_exact : bool, default True
-        Whether to compare number exactly.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    obj : str, default 'Index'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    __tracebackhide__ = True
-
-    def _check_types(l, r, obj="Index"):
-        if exact:
-            assert_class_equal(l, r, exact=exact, obj=obj)
-
-            # Skip exact dtype checking when `check_categorical` is False
-            if check_categorical:
-                assert_attr_equal("dtype", l, r, obj=obj)
-
-            # allow string-like to have different inferred_types
-            if l.inferred_type in ("string", "unicode"):
-                assert r.inferred_type in ("string", "unicode")
-            else:
-                assert_attr_equal("inferred_type", l, r, obj=obj)
-
-    def _get_ilevel_values(index, level):
-        # accept level number only
-        unique = index.levels[level]
-        labels = index.codes[level]
-        filled = take_1d(unique.values, labels, fill_value=unique._na_value)
-        values = unique._shallow_copy(filled, name=index.names[level])
-        return values
-
-    # instance validation
-    _check_isinstance(left, right, Index)
-
-    # class / dtype comparison
-    _check_types(left, right, obj=obj)
-
-    # level comparison
-    if left.nlevels != right.nlevels:
-        msg1 = "{obj} levels are different".format(obj=obj)
-        msg2 = "{nlevels}, {left}".format(nlevels=left.nlevels, left=left)
-        msg3 = "{nlevels}, {right}".format(nlevels=right.nlevels, right=right)
-        raise_assert_detail(obj, msg1, msg2, msg3)
-
-    # length comparison
-    if len(left) != len(right):
-        msg1 = "{obj} length are different".format(obj=obj)
-        msg2 = "{length}, {left}".format(length=len(left), left=left)
-        msg3 = "{length}, {right}".format(length=len(right), right=right)
-        raise_assert_detail(obj, msg1, msg2, msg3)
-
-    # MultiIndex special comparison for little-friendly error messages
-    if left.nlevels > 1:
-        left = cast(MultiIndex, left)
-        right = cast(MultiIndex, right)
-
-        for level in range(left.nlevels):
-            # cannot use get_level_values here because it can change dtype
-            llevel = _get_ilevel_values(left, level)
-            rlevel = _get_ilevel_values(right, level)
-
-            lobj = "MultiIndex level [{level}]".format(level=level)
-            assert_index_equal(
-                llevel,
-                rlevel,
-                exact=exact,
-                check_names=check_names,
-                check_less_precise=check_less_precise,
-                check_exact=check_exact,
-                obj=lobj,
-            )
-            # get_level_values may change dtype
-            _check_types(left.levels[level], right.levels[level], obj=obj)
-
-    # skip exact index checking when `check_categorical` is False
-    if check_exact and check_categorical:
-        if not left.equals(right):
-            diff = np.sum((left.values != right.values).astype(int)) * 100.0 / len(left)
-            msg = "{obj} values are different ({pct} %)".format(
-                obj=obj, pct=np.round(diff, 5)
-            )
-            raise_assert_detail(obj, msg, left, right)
-    else:
-        _testing.assert_almost_equal(
-            left.values,
-            right.values,
-            check_less_precise=check_less_precise,
-            check_dtype=exact,
-            obj=obj,
-            lobj=left,
-            robj=right,
-        )
-
-    # metadata comparison
-    if check_names:
-        assert_attr_equal("names", left, right, obj=obj)
-    if isinstance(left, pd.PeriodIndex) or isinstance(right, pd.PeriodIndex):
-        assert_attr_equal("freq", left, right, obj=obj)
-    if isinstance(left, pd.IntervalIndex) or isinstance(right, pd.IntervalIndex):
-        assert_interval_array_equal(left.values, right.values)
-
-    if check_categorical:
-        if is_categorical_dtype(left) or is_categorical_dtype(right):
-            assert_categorical_equal(
-                left.values, right.values, obj="{obj} category".format(obj=obj)
-            )
-
-
-def assert_class_equal(left, right, exact=True, obj="Input"):
-    """checks classes are equal."""
-    __tracebackhide__ = True
-
-    def repr_class(x):
-        if isinstance(x, Index):
-            # return Index as it is to include values in the error message
-            return x
-
-        try:
-            return x.__class__.__name__
-        except AttributeError:
-            return repr(type(x))
-
-    if exact == "equiv":
-        if type(left) != type(right):
-            # allow equivalence of Int64Index/RangeIndex
-            types = {type(left).__name__, type(right).__name__}
-            if len(types - {"Int64Index", "RangeIndex"}):
-                msg = "{obj} classes are not equivalent".format(obj=obj)
-                raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
-    elif exact:
-        if type(left) != type(right):
-            msg = "{obj} classes are different".format(obj=obj)
-            raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
-
-
-def assert_attr_equal(attr, left, right, obj="Attributes"):
-    """checks attributes are equal. Both objects must have attribute.
-
-    Parameters
-    ----------
-    attr : str
-        Attribute name being compared.
-    left : object
-    right : object
-    obj : str, default 'Attributes'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    __tracebackhide__ = True
-
-    left_attr = getattr(left, attr)
-    right_attr = getattr(right, attr)
-
-    if left_attr is right_attr:
-        return True
-    elif (
-        is_number(left_attr)
-        and np.isnan(left_attr)
-        and is_number(right_attr)
-        and np.isnan(right_attr)
-    ):
-        # np.nan
-        return True
-
-    try:
-        result = left_attr == right_attr
-    except TypeError:
-        # datetimetz on rhs may raise TypeError
-        result = False
-    if not isinstance(result, bool):
-        result = result.all()
-
-    if result:
-        return True
-    else:
-        msg = 'Attribute "{attr}" are different'.format(attr=attr)
-        raise_assert_detail(obj, msg, left_attr, right_attr)
-
-
-def assert_is_valid_plot_return_object(objs):
-    import matplotlib.pyplot as plt
-
-    if isinstance(objs, (pd.Series, np.ndarray)):
-        for el in objs.ravel():
-            msg = (
-                "one of 'objs' is not a matplotlib Axes instance, type "
-                "encountered {name!r}"
-            ).format(name=el.__class__.__name__)
-            assert isinstance(el, (plt.Axes, dict)), msg
-    else:
-        assert isinstance(objs, (plt.Artist, tuple, dict)), (
-            "objs is neither an ndarray of Artist instances nor a "
-            'single Artist instance, tuple, or dict, "objs" is a {name!r}'.format(
-                name=objs.__class__.__name__
-            )
-        )
-
-
-def isiterable(obj):
-    return hasattr(obj, "__iter__")
-
-
-def assert_is_sorted(seq):
-    """Assert that the sequence is sorted."""
-    if isinstance(seq, (Index, Series)):
-        seq = seq.values
-    # sorting does not change precisions
-    assert_numpy_array_equal(seq, np.sort(np.array(seq)))
-
-
-def assert_categorical_equal(
-    left, right, check_dtype=True, check_category_order=True, obj="Categorical"
-):
-    """Test that Categoricals are equivalent.
-
-    Parameters
-    ----------
-    left : Categorical
-    right : Categorical
-    check_dtype : bool, default True
-        Check that integer dtype of the codes are the same
-    check_category_order : bool, default True
-        Whether the order of the categories should be compared, which
-        implies identical integer codes.  If False, only the resulting
-        values are compared.  The ordered attribute is
-        checked regardless.
-    obj : str, default 'Categorical'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    _check_isinstance(left, right, Categorical)
-
-    if check_category_order:
-        assert_index_equal(
-            left.categories, right.categories, obj="{obj}.categories".format(obj=obj)
-        )
-        assert_numpy_array_equal(
-            left.codes,
-            right.codes,
-            check_dtype=check_dtype,
-            obj="{obj}.codes".format(obj=obj),
-        )
-    else:
-        assert_index_equal(
-            left.categories.sort_values(),
-            right.categories.sort_values(),
-            obj="{obj}.categories".format(obj=obj),
-        )
-        assert_index_equal(
-            left.categories.take(left.codes),
-            right.categories.take(right.codes),
-            obj="{obj}.values".format(obj=obj),
-        )
-
-    assert_attr_equal("ordered", left, right, obj=obj)
-
-
-def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray"):
-    """Test that two IntervalArrays are equivalent.
-
-    Parameters
-    ----------
-    left, right : IntervalArray
-        The IntervalArrays to compare.
-    exact : bool / string {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical. If 'equiv', then RangeIndex can be substituted for
-        Int64Index as well.
-    obj : str, default 'IntervalArray'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    _check_isinstance(left, right, IntervalArray)
-
-    assert_index_equal(
-        left.left, right.left, exact=exact, obj="{obj}.left".format(obj=obj)
-    )
-    assert_index_equal(
-        left.right, right.right, exact=exact, obj="{obj}.left".format(obj=obj)
-    )
-    assert_attr_equal("closed", left, right, obj=obj)
-
-
-def assert_period_array_equal(left, right, obj="PeriodArray"):
-    _check_isinstance(left, right, PeriodArray)
-
-    assert_numpy_array_equal(
-        left._data, right._data, obj="{obj}.values".format(obj=obj)
-    )
-    assert_attr_equal("freq", left, right, obj=obj)
-
-
-def assert_datetime_array_equal(left, right, obj="DatetimeArray"):
-    __tracebackhide__ = True
-    _check_isinstance(left, right, DatetimeArray)
-
-    assert_numpy_array_equal(left._data, right._data, obj="{obj}._data".format(obj=obj))
-    assert_attr_equal("freq", left, right, obj=obj)
-    assert_attr_equal("tz", left, right, obj=obj)
-
-
-def assert_timedelta_array_equal(left, right, obj="TimedeltaArray"):
-    __tracebackhide__ = True
-    _check_isinstance(left, right, TimedeltaArray)
-    assert_numpy_array_equal(left._data, right._data, obj="{obj}._data".format(obj=obj))
-    assert_attr_equal("freq", left, right, obj=obj)
-
-
-def raise_assert_detail(obj, message, left, right, diff=None):
-    __tracebackhide__ = True
-
-    if isinstance(left, np.ndarray):
-        left = pprint_thing(left)
-    elif is_categorical_dtype(left):
-        left = repr(left)
-
-    if isinstance(right, np.ndarray):
-        right = pprint_thing(right)
-    elif is_categorical_dtype(right):
-        right = repr(right)
-
-    msg = """{obj} are different
-
-{message}
-[left]:  {left}
-[right]: {right}""".format(
-        obj=obj, message=message, left=left, right=right
-    )
-
-    if diff is not None:
-        msg += "\n[diff]: {diff}".format(diff=diff)
-
-    raise AssertionError(msg)
-
-
-def assert_numpy_array_equal(
-    left,
-    right,
-    strict_nan=False,
-    check_dtype=True,
-    err_msg=None,
-    check_same=None,
-    obj="numpy array",
-):
-    """ Checks that 'np.ndarray' is equivalent
-
-    Parameters
-    ----------
-    left : np.ndarray or iterable
-    right : np.ndarray or iterable
-    strict_nan : bool, default False
-        If True, consider NaN and None to be different.
-    check_dtype: bool, default True
-        check dtype if both a and b are np.ndarray
-    err_msg : str, default None
-        If provided, used as assertion message
-    check_same : None|'copy'|'same', default None
-        Ensure left and right refer/do not refer to the same memory area
-    obj : str, default 'numpy array'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    __tracebackhide__ = True
-
-    # instance validation
-    # Show a detailed error message when classes are different
-    assert_class_equal(left, right, obj=obj)
-    # both classes must be an np.ndarray
-    _check_isinstance(left, right, np.ndarray)
-
-    def _get_base(obj):
-        return obj.base if getattr(obj, "base", None) is not None else obj
-
-    left_base = _get_base(left)
-    right_base = _get_base(right)
-
-    if check_same == "same":
-        if left_base is not right_base:
-            msg = "{left!r} is not {right!r}".format(left=left_base, right=right_base)
-            raise AssertionError(msg)
-    elif check_same == "copy":
-        if left_base is right_base:
-            msg = "{left!r} is {right!r}".format(left=left_base, right=right_base)
-            raise AssertionError(msg)
-
-    def _raise(left, right, err_msg):
-        if err_msg is None:
-            if left.shape != right.shape:
-                raise_assert_detail(
-                    obj,
-                    "{obj} shapes are different".format(obj=obj),
-                    left.shape,
-                    right.shape,
-                )
-
-            diff = 0
-            for l, r in zip(left, right):
-                # count up differences
-                if not array_equivalent(l, r, strict_nan=strict_nan):
-                    diff += 1
-
-            diff = diff * 100.0 / left.size
-            msg = "{obj} values are different ({pct} %)".format(
-                obj=obj, pct=np.round(diff, 5)
-            )
-            raise_assert_detail(obj, msg, left, right)
-
-        raise AssertionError(err_msg)
-
-    # compare shape and values
-    if not array_equivalent(left, right, strict_nan=strict_nan):
-        _raise(left, right, err_msg)
-
-    if check_dtype:
-        if isinstance(left, np.ndarray) and isinstance(right, np.ndarray):
-            assert_attr_equal("dtype", left, right, obj=obj)
-
-
-def assert_extension_array_equal(
-    left, right, check_dtype=True, check_less_precise=False, check_exact=False
-):
-    """Check that left and right ExtensionArrays are equal.
-
-    Parameters
-    ----------
-    left, right : ExtensionArray
-        The two arrays to compare
-    check_dtype : bool, default True
-        Whether to check if the ExtensionArray dtypes are identical.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-
-    Notes
-    -----
-    Missing values are checked separately from valid values.
-    A mask of missing values is computed for each and checked to match.
-    The remaining all-valid values are cast to object dtype and checked.
-    """
-    assert isinstance(left, ExtensionArray), "left is not an ExtensionArray"
-    assert isinstance(right, ExtensionArray), "right is not an ExtensionArray"
-    if check_dtype:
-        assert_attr_equal("dtype", left, right, obj="ExtensionArray")
-
-    if hasattr(left, "asi8") and type(right) == type(left):
-        # Avoid slow object-dtype comparisons
-        assert_numpy_array_equal(left.asi8, right.asi8)
-        return
-
-    left_na = np.asarray(left.isna())
-    right_na = np.asarray(right.isna())
-    assert_numpy_array_equal(left_na, right_na, obj="ExtensionArray NA mask")
-
-    left_valid = np.asarray(left[~left_na].astype(object))
-    right_valid = np.asarray(right[~right_na].astype(object))
-    if check_exact:
-        assert_numpy_array_equal(left_valid, right_valid, obj="ExtensionArray")
-    else:
-        _testing.assert_almost_equal(
-            left_valid,
-            right_valid,
-            check_dtype=check_dtype,
-            check_less_precise=check_less_precise,
-            obj="ExtensionArray",
-        )
-
-
-# This could be refactored to use the NDFrame.equals method
-def assert_series_equal(
-    left,
-    right,
-    check_dtype=True,
-    check_index_type="equiv",
-    check_series_type=True,
-    check_less_precise=False,
-    check_names=True,
-    check_exact=False,
-    check_datetimelike_compat=False,
-    check_categorical=True,
-    obj="Series",
-):
-    """
-    Check that left and right Series are equal.
-
-    Parameters
-    ----------
-    left : Series
-    right : Series
-    check_dtype : bool, default True
-        Whether to check the Series dtype is identical.
-    check_index_type : bool / string {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical.
-    check_series_type : bool, default True
-        Whether to check the Series class is identical.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-    check_names : bool, default True
-        Whether to check the Series and Index names attribute.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-    check_datetimelike_compat : bool, default False
-        Compare datetime-like which is comparable ignoring dtype.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    obj : str, default 'Series'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-    """
-    __tracebackhide__ = True
-
-    # instance validation
-    _check_isinstance(left, right, Series)
-
-    if check_series_type:
-        # ToDo: There are some tests using rhs is sparse
-        # lhs is dense. Should use assert_class_equal in future
-        assert isinstance(left, type(right))
-        # assert_class_equal(left, right, obj=obj)
-
-    # length comparison
-    if len(left) != len(right):
-        msg1 = "{len}, {left}".format(len=len(left), left=left.index)
-        msg2 = "{len}, {right}".format(len=len(right), right=right.index)
-        raise_assert_detail(obj, "Series length are different", msg1, msg2)
-
-    # index comparison
-    assert_index_equal(
-        left.index,
-        right.index,
-        exact=check_index_type,
-        check_names=check_names,
-        check_less_precise=check_less_precise,
-        check_exact=check_exact,
-        check_categorical=check_categorical,
-        obj="{obj}.index".format(obj=obj),
-    )
-
-    if check_dtype:
-        # We want to skip exact dtype checking when `check_categorical`
-        # is False. We'll still raise if only one is a `Categorical`,
-        # regardless of `check_categorical`
-        if (
-            is_categorical_dtype(left)
-            and is_categorical_dtype(right)
-            and not check_categorical
-        ):
-            pass
-        else:
-            assert_attr_equal("dtype", left, right)
-
-    if check_exact:
-        assert_numpy_array_equal(
-            left._internal_get_values(),
-            right._internal_get_values(),
-            check_dtype=check_dtype,
-            obj="{obj}".format(obj=obj),
-        )
-    elif check_datetimelike_compat:
-        # we want to check only if we have compat dtypes
-        # e.g. integer and M|m are NOT compat, but we can simply check
-        # the values in that case
-        if needs_i8_conversion(left) or needs_i8_conversion(right):
-
-            # datetimelike may have different objects (e.g. datetime.datetime
-            # vs Timestamp) but will compare equal
-            if not Index(left.values).equals(Index(right.values)):
-                msg = (
-                    "[datetimelike_compat=True] {left} is not equal to " "{right}."
-                ).format(left=left.values, right=right.values)
-                raise AssertionError(msg)
-        else:
-            assert_numpy_array_equal(
-                left._internal_get_values(),
-                right._internal_get_values(),
-                check_dtype=check_dtype,
-            )
-    elif is_interval_dtype(left) or is_interval_dtype(right):
-        assert_interval_array_equal(left.array, right.array)
-    elif is_extension_array_dtype(left.dtype) and is_datetime64tz_dtype(left.dtype):
-        # .values is an ndarray, but ._values is the ExtensionArray.
-        # TODO: Use .array
-        assert is_extension_array_dtype(right.dtype)
-        assert_extension_array_equal(left._values, right._values)
-    elif (
-        is_extension_array_dtype(left)
-        and not is_categorical_dtype(left)
-        and is_extension_array_dtype(right)
-        and not is_categorical_dtype(right)
-    ):
-        assert_extension_array_equal(left.array, right.array)
-    else:
-        _testing.assert_almost_equal(
-            left._internal_get_values(),
-            right._internal_get_values(),
-            check_less_precise=check_less_precise,
-            check_dtype=check_dtype,
-            obj="{obj}".format(obj=obj),
-        )
-
-    # metadata comparison
-    if check_names:
-        assert_attr_equal("name", left, right, obj=obj)
-
-    if check_categorical:
-        if is_categorical_dtype(left) or is_categorical_dtype(right):
-            assert_categorical_equal(
-                left.values, right.values, obj="{obj} category".format(obj=obj)
-            )
-
-
-# This could be refactored to use the NDFrame.equals method
-def assert_frame_equal(
-    left,
-    right,
-    check_dtype=True,
-    check_index_type="equiv",
-    check_column_type="equiv",
-    check_frame_type=True,
-    check_less_precise=False,
-    check_names=True,
-    by_blocks=False,
-    check_exact=False,
-    check_datetimelike_compat=False,
-    check_categorical=True,
-    check_like=False,
-    obj="DataFrame",
-):
-    """
-    Check that left and right DataFrame are equal.
-
-    This function is intended to compare two DataFrames and output any
-    differences. Is is mostly intended for use in unit tests.
-    Additional parameters allow varying the strictness of the
-    equality checks performed.
-
-    Parameters
-    ----------
-    left : DataFrame
-        First DataFrame to compare.
-    right : DataFrame
-        Second DataFrame to compare.
-    check_dtype : bool, default True
-        Whether to check the DataFrame dtype is identical.
-    check_index_type : bool / string {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical.
-    check_column_type : bool / string {'equiv'}, default 'equiv'
-        Whether to check the columns class, dtype and inferred_type
-        are identical. Is passed as the ``exact`` argument of
-        :func:`assert_index_equal`.
-    check_frame_type : bool, default True
-        Whether to check the DataFrame class is identical.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-    check_names : bool, default True
-        Whether to check that the `names` attribute for both the `index`
-        and `column` attributes of the DataFrame is identical, i.e.
-
-        * left.index.names == right.index.names
-        * left.columns.names == right.columns.names
-    by_blocks : bool, default False
-        Specify how to compare internal data. If False, compare by columns.
-        If True, compare by blocks.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-    check_datetimelike_compat : bool, default False
-        Compare datetime-like which is comparable ignoring dtype.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    check_like : bool, default False
-        If True, ignore the order of index & columns.
-        Note: index labels must match their respective rows
-        (same as in columns) - same labels must be with the same data.
-    obj : str, default 'DataFrame'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-
-    See Also
-    --------
-    assert_series_equal : Equivalent method for asserting Series equality.
-    DataFrame.equals : Check DataFrame equality.
-
-    Examples
-    --------
-    This example shows comparing two DataFrames that are equal
-    but with columns of differing dtypes.
-
-    >>> from pandas.util.testing import assert_frame_equal
-    >>> df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
-    >>> df2 = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0]})
-
-    df1 equals itself.
-
-    >>> assert_frame_equal(df1, df1)
-
-    df1 differs from df2 as column 'b' is of a different type.
-
-    >>> assert_frame_equal(df1, df2)
-    Traceback (most recent call last):
-    AssertionError: Attributes are different
-    ...
-    Attribute "dtype" are different
-    [left]:  int64
-    [right]: float64
-
-    Ignore differing dtypes in columns with check_dtype.
-
-    >>> assert_frame_equal(df1, df2, check_dtype=False)
-    """
-    __tracebackhide__ = True
-
-    # instance validation
-    _check_isinstance(left, right, DataFrame)
-
-    if check_frame_type:
-        # ToDo: There are some tests using rhs is SparseDataFrame
-        # lhs is DataFrame. Should use assert_class_equal in future
-        assert isinstance(left, type(right))
-        # assert_class_equal(left, right, obj=obj)
-
-    # shape comparison
-    if left.shape != right.shape:
-        raise_assert_detail(
-            obj,
-            "{obj} shape mismatch".format(obj=obj),
-            "{shape!r}".format(shape=left.shape),
-            "{shape!r}".format(shape=right.shape),
-        )
-
-    if check_like:
-        left, right = left.reindex_like(right), right
-
-    # index comparison
-    assert_index_equal(
-        left.index,
-        right.index,
-        exact=check_index_type,
-        check_names=check_names,
-        check_less_precise=check_less_precise,
-        check_exact=check_exact,
-        check_categorical=check_categorical,
-        obj="{obj}.index".format(obj=obj),
-    )
-
-    # column comparison
-    assert_index_equal(
-        left.columns,
-        right.columns,
-        exact=check_column_type,
-        check_names=check_names,
-        check_less_precise=check_less_precise,
-        check_exact=check_exact,
-        check_categorical=check_categorical,
-        obj="{obj}.columns".format(obj=obj),
-    )
-
-    # compare by blocks
-    if by_blocks:
-        rblocks = right._to_dict_of_blocks()
-        lblocks = left._to_dict_of_blocks()
-        for dtype in list(set(list(lblocks.keys()) + list(rblocks.keys()))):
-            assert dtype in lblocks
-            assert dtype in rblocks
-            assert_frame_equal(
-                lblocks[dtype], rblocks[dtype], check_dtype=check_dtype, obj=obj
-            )
-
-    # compare by columns
-    else:
-        for i, col in enumerate(left.columns):
-            assert col in right
-            lcol = left.iloc[:, i]
-            rcol = right.iloc[:, i]
-            assert_series_equal(
-                lcol,
-                rcol,
-                check_dtype=check_dtype,
-                check_index_type=check_index_type,
-                check_less_precise=check_less_precise,
-                check_exact=check_exact,
-                check_names=check_names,
-                check_datetimelike_compat=check_datetimelike_compat,
-                check_categorical=check_categorical,
-                obj="{obj}.iloc[:, {idx}]".format(obj=obj, idx=i),
-            )
-
-
-def assert_equal(left, right, **kwargs):
-    """
-    Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
-
-    Parameters
-    ----------
-    left : Index, Series, DataFrame, ExtensionArray, or np.ndarray
-    right : Index, Series, DataFrame, ExtensionArray, or np.ndarray
-    **kwargs
-    """
-    __tracebackhide__ = True
-
-    if isinstance(left, pd.Index):
-        assert_index_equal(left, right, **kwargs)
-    elif isinstance(left, pd.Series):
-        assert_series_equal(left, right, **kwargs)
-    elif isinstance(left, pd.DataFrame):
-        assert_frame_equal(left, right, **kwargs)
-    elif isinstance(left, IntervalArray):
-        assert_interval_array_equal(left, right, **kwargs)
-    elif isinstance(left, PeriodArray):
-        assert_period_array_equal(left, right, **kwargs)
-    elif isinstance(left, DatetimeArray):
-        assert_datetime_array_equal(left, right, **kwargs)
-    elif isinstance(left, TimedeltaArray):
-        assert_timedelta_array_equal(left, right, **kwargs)
-    elif isinstance(left, ExtensionArray):
-        assert_extension_array_equal(left, right, **kwargs)
-    elif isinstance(left, np.ndarray):
-        assert_numpy_array_equal(left, right, **kwargs)
-    else:
-        raise NotImplementedError(type(left))
-
-
-def box_expected(expected, box_cls, transpose=True):
-    """
-    Helper function to wrap the expected output of a test in a given box_class.
-
-    Parameters
-    ----------
-    expected : np.ndarray, Index, Series
-    box_cls : {Index, Series, DataFrame}
-
-    Returns
-    -------
-    subclass of box_cls
-    """
-    if box_cls is pd.Index:
-        expected = pd.Index(expected)
-    elif box_cls is pd.Series:
-        expected = pd.Series(expected)
-    elif box_cls is pd.DataFrame:
-        expected = pd.Series(expected).to_frame()
-        if transpose:
-            # for vector operations, we we need a DataFrame to be a single-row,
-            #  not a single-column, in order to operate against non-DataFrame
-            #  vectors of the same length.
-            expected = expected.T
-    elif box_cls is PeriodArray:
-        # the PeriodArray constructor is not as flexible as period_array
-        expected = period_array(expected)
-    elif box_cls is DatetimeArray:
-        expected = DatetimeArray(expected)
-    elif box_cls is TimedeltaArray:
-        expected = TimedeltaArray(expected)
-    elif box_cls is np.ndarray:
-        expected = np.array(expected)
-    elif box_cls is to_array:
-        expected = to_array(expected)
-    else:
-        raise NotImplementedError(box_cls)
-    return expected
-
-
-def to_array(obj):
-    # temporary implementation until we get pd.array in place
-    if is_period_dtype(obj):
-        return period_array(obj)
-    elif is_datetime64_dtype(obj) or is_datetime64tz_dtype(obj):
-        return DatetimeArray._from_sequence(obj)
-    elif is_timedelta64_dtype(obj):
-        return TimedeltaArray._from_sequence(obj)
-    else:
-        return np.array(obj)
-
-
-# -----------------------------------------------------------------------------
-# Sparse
-
-
-def assert_sp_array_equal(
-    left,
-    right,
-    check_dtype=True,
-    check_kind=True,
-    check_fill_value=True,
-    consolidate_block_indices=False,
-):
-    """Check that the left and right SparseArray are equal.
-
-    Parameters
-    ----------
-    left : SparseArray
-    right : SparseArray
-    check_dtype : bool, default True
-        Whether to check the data dtype is identical.
-    check_kind : bool, default True
-        Whether to just the kind of the sparse index for each column.
-    check_fill_value : bool, default True
-        Whether to check that left.fill_value matches right.fill_value
-    consolidate_block_indices : bool, default False
-        Whether to consolidate contiguous blocks for sparse arrays with
-        a BlockIndex. Some operations, e.g. concat, will end up with
-        block indices that could be consolidated. Setting this to true will
-        create a new BlockIndex for that array, with consolidated
-        block indices.
-    """
-
-    _check_isinstance(left, right, pd.SparseArray)
-
-    assert_numpy_array_equal(left.sp_values, right.sp_values, check_dtype=check_dtype)
-
-    # SparseIndex comparison
-    assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
-    assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
-
-    if not check_kind:
-        left_index = left.sp_index.to_block_index()
-        right_index = right.sp_index.to_block_index()
-    else:
-        left_index = left.sp_index
-        right_index = right.sp_index
-
-    if consolidate_block_indices and left.kind == "block":
-        # we'll probably remove this hack...
-        left_index = left_index.to_int_index().to_block_index()
-        right_index = right_index.to_int_index().to_block_index()
-
-    if not left_index.equals(right_index):
-        raise_assert_detail(
-            "SparseArray.index", "index are not equal", left_index, right_index
-        )
-    else:
-        # Just ensure a
-        pass
-
-    if check_fill_value:
-        assert_attr_equal("fill_value", left, right)
-    if check_dtype:
-        assert_attr_equal("dtype", left, right)
-    assert_numpy_array_equal(left.to_dense(), right.to_dense(), check_dtype=check_dtype)
-
-
-def assert_sp_series_equal(
-    left,
-    right,
-    check_dtype=True,
-    exact_indices=True,
-    check_series_type=True,
-    check_names=True,
-    check_kind=True,
-    check_fill_value=True,
-    consolidate_block_indices=False,
-    obj="SparseSeries",
-):
-    """Check that the left and right SparseSeries are equal.
-
-    Parameters
-    ----------
-    left : SparseSeries
-    right : SparseSeries
-    check_dtype : bool, default True
-        Whether to check the Series dtype is identical.
-    exact_indices : bool, default True
-    check_series_type : bool, default True
-        Whether to check the SparseSeries class is identical.
-    check_names : bool, default True
-        Whether to check the SparseSeries name attribute.
-    check_kind : bool, default True
-        Whether to just the kind of the sparse index for each column.
-    check_fill_value : bool, default True
-        Whether to check that left.fill_value matches right.fill_value
-    consolidate_block_indices : bool, default False
-        Whether to consolidate contiguous blocks for sparse arrays with
-        a BlockIndex. Some operations, e.g. concat, will end up with
-        block indices that could be consolidated. Setting this to true will
-        create a new BlockIndex for that array, with consolidated
-        block indices.
-    obj : str, default 'SparseSeries'
-        Specify the object name being compared, internally used to show
-        the appropriate assertion message.
-    """
-    _check_isinstance(left, right, pd.SparseSeries)
-
-    if check_series_type:
-        assert_class_equal(left, right, obj=obj)
-
-    assert_index_equal(left.index, right.index, obj="{obj}.index".format(obj=obj))
-
-    assert_sp_array_equal(
-        left.values,
-        right.values,
-        check_kind=check_kind,
-        check_fill_value=check_fill_value,
-        consolidate_block_indices=consolidate_block_indices,
-    )
-
-    if check_names:
-        assert_attr_equal("name", left, right)
-    if check_dtype:
-        assert_attr_equal("dtype", left, right)
-
-    assert_numpy_array_equal(np.asarray(left.values), np.asarray(right.values))
-
-
-def assert_sp_frame_equal(
-    left,
-    right,
-    check_dtype=True,
-    exact_indices=True,
-    check_frame_type=True,
-    check_kind=True,
-    check_fill_value=True,
-    consolidate_block_indices=False,
-    obj="SparseDataFrame",
-):
-    """Check that the left and right SparseDataFrame are equal.
-
-    Parameters
-    ----------
-    left : SparseDataFrame
-    right : SparseDataFrame
-    check_dtype : bool, default True
-        Whether to check the Series dtype is identical.
-    exact_indices : bool, default True
-        SparseSeries SparseIndex objects must be exactly the same,
-        otherwise just compare dense representations.
-    check_frame_type : bool, default True
-        Whether to check the SparseDataFrame class is identical.
-    check_kind : bool, default True
-        Whether to just the kind of the sparse index for each column.
-    check_fill_value : bool, default True
-        Whether to check that left.fill_value matches right.fill_value
-    consolidate_block_indices : bool, default False
-        Whether to consolidate contiguous blocks for sparse arrays with
-        a BlockIndex. Some operations, e.g. concat, will end up with
-        block indices that could be consolidated. Setting this to true will
-        create a new BlockIndex for that array, with consolidated
-        block indices.
-    obj : str, default 'SparseDataFrame'
-        Specify the object name being compared, internally used to show
-        the appropriate assertion message.
-    """
-    _check_isinstance(left, right, pd.SparseDataFrame)
-
-    if check_frame_type:
-        assert_class_equal(left, right, obj=obj)
-
-    assert_index_equal(left.index, right.index, obj="{obj}.index".format(obj=obj))
-    assert_index_equal(left.columns, right.columns, obj="{obj}.columns".format(obj=obj))
-
-    if check_fill_value:
-        assert_attr_equal("default_fill_value", left, right, obj=obj)
-
-    for col, series in left.items():
-        assert col in right
-        # trade-off?
-
-        if exact_indices:
-            assert_sp_series_equal(
-                series,
-                right[col],
-                check_dtype=check_dtype,
-                check_kind=check_kind,
-                check_fill_value=check_fill_value,
-                consolidate_block_indices=consolidate_block_indices,
-            )
-        else:
-            assert_series_equal(
-                series.to_dense(), right[col].to_dense(), check_dtype=check_dtype
-            )
-
-    # do I care?
-    # assert(left.default_kind == right.default_kind)
-
-    for col in right:
-        assert col in left
-
-
-# -----------------------------------------------------------------------------
-# Others
-
-
-def assert_contains_all(iterable, dic):
-    for k in iterable:
-        assert k in dic, "Did not contain item: '{key!r}'".format(key=k)
-
-
-def assert_copy(iter1, iter2, **eql_kwargs):
-    """
-    iter1, iter2: iterables that produce elements
-    comparable with assert_almost_equal
-
-    Checks that the elements are equal, but not
-    the same object. (Does not check that items
-    in sequences are also not the same object)
-    """
-    for elem1, elem2 in zip(iter1, iter2):
-        assert_almost_equal(elem1, elem2, **eql_kwargs)
-        msg = (
-            "Expected object {obj1!r} and object {obj2!r} to be "
-            "different objects, but they were the same object."
-        ).format(obj1=type(elem1), obj2=type(elem2))
-        assert elem1 is not elem2, msg
-
-
-def getCols(k):
-    return string.ascii_uppercase[:k]
-
-
-# make index
-def makeStringIndex(k=10, name=None):
-    return Index(rands_array(nchars=10, size=k), name=name)
-
-
-def makeUnicodeIndex(k=10, name=None):
-    return Index(randu_array(nchars=10, size=k), name=name)
-
-
-def makeCategoricalIndex(k=10, n=3, name=None, **kwargs):
-    """ make a length k index or n categories """
-    x = rands_array(nchars=4, size=n)
-    return CategoricalIndex(np.random.choice(x, k), name=name, **kwargs)
-
-
-def makeIntervalIndex(k=10, name=None, **kwargs):
-    """ make a length k IntervalIndex """
-    x = np.linspace(0, 100, num=(k + 1))
-    return IntervalIndex.from_breaks(x, name=name, **kwargs)
-
-
-def makeBoolIndex(k=10, name=None):
-    if k == 1:
-        return Index([True], name=name)
-    elif k == 2:
-        return Index([False, True], name=name)
-    return Index([False, True] + [False] * (k - 2), name=name)
-
-
-def makeIntIndex(k=10, name=None):
-    return Index(list(range(k)), name=name)
-
-
-def makeUIntIndex(k=10, name=None):
-    return Index([2 ** 63 + i for i in range(k)], name=name)
-
-
-def makeRangeIndex(k=10, name=None, **kwargs):
-    return RangeIndex(0, k, 1, name=name, **kwargs)
-
-
-def makeFloatIndex(k=10, name=None):
-    values = sorted(np.random.random_sample(k)) - np.random.random_sample(1)
-    return Index(values * (10 ** np.random.randint(0, 9)), name=name)
-
-
-def makeDateIndex(k=10, freq="B", name=None, **kwargs):
-    dt = datetime(2000, 1, 1)
-    dr = bdate_range(dt, periods=k, freq=freq, name=name)
-    return DatetimeIndex(dr, name=name, **kwargs)
-
-
-def makeTimedeltaIndex(k=10, freq="D", name=None, **kwargs):
-    return pd.timedelta_range(start="1 day", periods=k, freq=freq, name=name, **kwargs)
-
-
-def makePeriodIndex(k=10, name=None, **kwargs):
-    dt = datetime(2000, 1, 1)
-    dr = pd.period_range(start=dt, periods=k, freq="B", name=name, **kwargs)
-    return dr
-
-
-def makeMultiIndex(k=10, names=None, **kwargs):
-    return MultiIndex.from_product((("foo", "bar"), (1, 2)), names=names, **kwargs)
-
-
-def all_index_generator(k=10):
-    """Generator which can be iterated over to get instances of all the various
-    index classes.
-
-    Parameters
-    ----------
-    k: length of each of the index instances
-    """
-    all_make_index_funcs = [
-        makeIntIndex,
-        makeFloatIndex,
-        makeStringIndex,
-        makeUnicodeIndex,
-        makeDateIndex,
-        makePeriodIndex,
-        makeTimedeltaIndex,
-        makeBoolIndex,
-        makeRangeIndex,
-        makeIntervalIndex,
-        makeCategoricalIndex,
-    ]
-    for make_index_func in all_make_index_funcs:
-        yield make_index_func(k=k)
-
-
-def index_subclass_makers_generator():
-    make_index_funcs = [
-        makeDateIndex,
-        makePeriodIndex,
-        makeTimedeltaIndex,
-        makeRangeIndex,
-        makeIntervalIndex,
-        makeCategoricalIndex,
-        makeMultiIndex,
-    ]
-    for make_index_func in make_index_funcs:
-        yield make_index_func
-
-
-def all_timeseries_index_generator(k=10):
-    """Generator which can be iterated over to get instances of all the classes
-    which represent time-series.
-
-    Parameters
-    ----------
-    k: length of each of the index instances
-    """
-    make_index_funcs = [makeDateIndex, makePeriodIndex, makeTimedeltaIndex]
-    for make_index_func in make_index_funcs:
-        yield make_index_func(k=k)
-
-
-# make series
-def makeFloatSeries(name=None):
-    index = makeStringIndex(N)
-    return Series(randn(N), index=index, name=name)
-
-
-def makeStringSeries(name=None):
-    index = makeStringIndex(N)
-    return Series(randn(N), index=index, name=name)
-
-
-def makeObjectSeries(name=None):
-    dateIndex = makeDateIndex(N)
-    dateIndex = Index(dateIndex, dtype=object)
-    index = makeStringIndex(N)
-    return Series(dateIndex, index=index, name=name)
-
-
-def getSeriesData():
-    index = makeStringIndex(N)
-    return {c: Series(randn(N), index=index) for c in getCols(K)}
-
-
-def makeTimeSeries(nper=None, freq="B", name=None):
-    if nper is None:
-        nper = N
-    return Series(randn(nper), index=makeDateIndex(nper, freq=freq), name=name)
-
-
-def makePeriodSeries(nper=None, name=None):
-    if nper is None:
-        nper = N
-    return Series(randn(nper), index=makePeriodIndex(nper), name=name)
-
-
-def getTimeSeriesData(nper=None, freq="B"):
-    return {c: makeTimeSeries(nper, freq) for c in getCols(K)}
-
-
-def getPeriodData(nper=None):
-    return {c: makePeriodSeries(nper) for c in getCols(K)}
-
-
-# make frame
-def makeTimeDataFrame(nper=None, freq="B"):
-    data = getTimeSeriesData(nper, freq)
-    return DataFrame(data)
-
-
-def makeDataFrame():
-    data = getSeriesData()
-    return DataFrame(data)
-
-
-def getMixedTypeDict():
-    index = Index(["a", "b", "c", "d", "e"])
-
-    data = {
-        "A": [0.0, 1.0, 2.0, 3.0, 4.0],
-        "B": [0.0, 1.0, 0.0, 1.0, 0.0],
-        "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
-        "D": bdate_range("1/1/2009", periods=5),
-    }
-
-    return index, data
-
-
-def makeMixedDataFrame():
-    return DataFrame(getMixedTypeDict()[1])
-
-
-def makePeriodFrame(nper=None):
-    data = getPeriodData(nper)
-    return DataFrame(data)
-
-
-def makeCustomIndex(
-    nentries, nlevels, prefix="#", names=False, ndupe_l=None, idx_type=None
-):
-    """Create an index/multindex with given dimensions, levels, names, etc'
-
-    nentries - number of entries in index
-    nlevels - number of levels (> 1 produces multindex)
-    prefix - a string prefix for labels
-    names - (Optional), bool or list of strings. if True will use default
-       names, if false will use no names, if a list is given, the name of
-       each level in the index will be taken from the list.
-    ndupe_l - (Optional), list of ints, the number of rows for which the
-       label will repeated at the corresponding level, you can specify just
-       the first few, the rest will use the default ndupe_l of 1.
-       len(ndupe_l) <= nlevels.
-    idx_type - "i"/"f"/"s"/"u"/"dt"/"p"/"td".
-       If idx_type is not None, `idx_nlevels` must be 1.
-       "i"/"f" creates an integer/float index,
-       "s"/"u" creates a string/unicode index
-       "dt" create a datetime index.
-       "td" create a datetime index.
-
-        if unspecified, string labels will be generated.
-    """
-
-    if ndupe_l is None:
-        ndupe_l = [1] * nlevels
-    assert is_sequence(ndupe_l) and len(ndupe_l) <= nlevels
-    assert names is None or names is False or names is True or len(names) is nlevels
-    assert idx_type is None or (
-        idx_type in ("i", "f", "s", "u", "dt", "p", "td") and nlevels == 1
-    )
-
-    if names is True:
-        # build default names
-        names = [prefix + str(i) for i in range(nlevels)]
-    if names is False:
-        # pass None to index constructor for no name
-        names = None
-
-    # make singleton case uniform
-    if isinstance(names, str) and nlevels == 1:
-        names = [names]
-
-    # specific 1D index type requested?
-    idx_func = dict(
-        i=makeIntIndex,
-        f=makeFloatIndex,
-        s=makeStringIndex,
-        u=makeUnicodeIndex,
-        dt=makeDateIndex,
-        td=makeTimedeltaIndex,
-        p=makePeriodIndex,
-    ).get(idx_type)
-    if idx_func:
-        idx = idx_func(nentries)
-        # but we need to fill in the name
-        if names:
-            idx.name = names[0]
-        return idx
-    elif idx_type is not None:
-        raise ValueError(
-            '"{idx_type}" is not a legal value for `idx_type`, '
-            'use  "i"/"f"/"s"/"u"/"dt/"p"/"td".'.format(idx_type=idx_type)
-        )
-
-    if len(ndupe_l) < nlevels:
-        ndupe_l.extend([1] * (nlevels - len(ndupe_l)))
-    assert len(ndupe_l) == nlevels
-
-    assert all(x > 0 for x in ndupe_l)
-
-    tuples = []
-    for i in range(nlevels):
-
-        def keyfunc(x):
-            import re
-
-            numeric_tuple = re.sub(r"[^\d_]_?", "", x).split("_")
-            return [int(num) for num in numeric_tuple]
-
-        # build a list of lists to create the index from
-        div_factor = nentries // ndupe_l[i] + 1
-        cnt = Counter()
-        for j in range(div_factor):
-            label = "{prefix}_l{i}_g{j}".format(prefix=prefix, i=i, j=j)
-            cnt[label] = ndupe_l[i]
-        # cute Counter trick
-        result = list(sorted(cnt.elements(), key=keyfunc))[:nentries]
-        tuples.append(result)
-
-    tuples = list(zip(*tuples))
-
-    # convert tuples to index
-    if nentries == 1:
-        # we have a single level of tuples, i.e. a regular Index
-        index = Index(tuples[0], name=names[0])
-    elif nlevels == 1:
-        name = None if names is None else names[0]
-        index = Index((x[0] for x in tuples), name=name)
-    else:
-        index = MultiIndex.from_tuples(tuples, names=names)
-    return index
-
-
-def makeCustomDataframe(
-    nrows,
-    ncols,
-    c_idx_names=True,
-    r_idx_names=True,
-    c_idx_nlevels=1,
-    r_idx_nlevels=1,
-    data_gen_f=None,
-    c_ndupe_l=None,
-    r_ndupe_l=None,
-    dtype=None,
-    c_idx_type=None,
-    r_idx_type=None,
-):
-    """
-   nrows,  ncols - number of data rows/cols
-   c_idx_names, idx_names  - False/True/list of strings,  yields No names ,
-        default names or uses the provided names for the levels of the
-        corresponding index. You can provide a single string when
-        c_idx_nlevels ==1.
-   c_idx_nlevels - number of levels in columns index. > 1 will yield MultiIndex
-   r_idx_nlevels - number of levels in rows index. > 1 will yield MultiIndex
-   data_gen_f - a function f(row,col) which return the data value
-        at that position, the default generator used yields values of the form
-        "RxCy" based on position.
-   c_ndupe_l, r_ndupe_l - list of integers, determines the number
-        of duplicates for each label at a given level of the corresponding
-        index. The default `None` value produces a multiplicity of 1 across
-        all levels, i.e. a unique index. Will accept a partial list of length
-        N < idx_nlevels, for just the first N levels. If ndupe doesn't divide
-        nrows/ncol, the last label might have lower multiplicity.
-   dtype - passed to the DataFrame constructor as is, in case you wish to
-        have more control in conjunction with a custom `data_gen_f`
-   r_idx_type, c_idx_type -  "i"/"f"/"s"/"u"/"dt"/"td".
-       If idx_type is not None, `idx_nlevels` must be 1.
-       "i"/"f" creates an integer/float index,
-       "s"/"u" creates a string/unicode index
-       "dt" create a datetime index.
-       "td" create a timedelta index.
-
-        if unspecified, string labels will be generated.
-
-    Examples:
-
-    # 5 row, 3 columns, default names on both, single index on both axis
-    >> makeCustomDataframe(5,3)
-
-    # make the data a random int between 1 and 100
-    >> mkdf(5,3,data_gen_f=lambda r,c:randint(1,100))
-
-    # 2-level multiindex on rows with each label duplicated
-    # twice on first level, default names on both axis, single
-    # index on both axis
-    >> a=makeCustomDataframe(5,3,r_idx_nlevels=2,r_ndupe_l=[2])
-
-    # DatetimeIndex on row, index with unicode labels on columns
-    # no names on either axis
-    >> a=makeCustomDataframe(5,3,c_idx_names=False,r_idx_names=False,
-                             r_idx_type="dt",c_idx_type="u")
-
-    # 4-level multindex on rows with names provided, 2-level multindex
-    # on columns with default labels and default names.
-    >> a=makeCustomDataframe(5,3,r_idx_nlevels=4,
-                             r_idx_names=["FEE","FI","FO","FAM"],
-                             c_idx_nlevels=2)
-
-    >> a=mkdf(5,3,r_idx_nlevels=2,c_idx_nlevels=4)
-    """
-
-    assert c_idx_nlevels > 0
-    assert r_idx_nlevels > 0
-    assert r_idx_type is None or (
-        r_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and r_idx_nlevels == 1
-    )
-    assert c_idx_type is None or (
-        c_idx_type in ("i", "f", "s", "u", "dt", "p", "td") and c_idx_nlevels == 1
-    )
-
-    columns = makeCustomIndex(
-        ncols,
-        nlevels=c_idx_nlevels,
-        prefix="C",
-        names=c_idx_names,
-        ndupe_l=c_ndupe_l,
-        idx_type=c_idx_type,
-    )
-    index = makeCustomIndex(
-        nrows,
-        nlevels=r_idx_nlevels,
-        prefix="R",
-        names=r_idx_names,
-        ndupe_l=r_ndupe_l,
-        idx_type=r_idx_type,
-    )
-
-    # by default, generate data based on location
-    if data_gen_f is None:
-        data_gen_f = lambda r, c: "R{rows}C{cols}".format(rows=r, cols=c)
-
-    data = [[data_gen_f(r, c) for c in range(ncols)] for r in range(nrows)]
-
-    return DataFrame(data, index, columns, dtype=dtype)
-
-
-def _create_missing_idx(nrows, ncols, density, random_state=None):
-    if random_state is None:
-        random_state = np.random
-    else:
-        random_state = np.random.RandomState(random_state)
-
-    # below is cribbed from scipy.sparse
-    size = int(np.round((1 - density) * nrows * ncols))
-    # generate a few more to ensure unique values
-    min_rows = 5
-    fac = 1.02
-    extra_size = min(size + min_rows, fac * size)
-
-    def _gen_unique_rand(rng, _extra_size):
-        ind = rng.rand(int(_extra_size))
-        return np.unique(np.floor(ind * nrows * ncols))[:size]
-
-    ind = _gen_unique_rand(random_state, extra_size)
-    while ind.size < size:
-        extra_size *= 1.05
-        ind = _gen_unique_rand(random_state, extra_size)
-
-    j = np.floor(ind * 1.0 / nrows).astype(int)
-    i = (ind - j * nrows).astype(int)
-    return i.tolist(), j.tolist()
-
-
-def makeMissingCustomDataframe(
-    nrows,
-    ncols,
-    density=0.9,
-    random_state=None,
-    c_idx_names=True,
-    r_idx_names=True,
-    c_idx_nlevels=1,
-    r_idx_nlevels=1,
-    data_gen_f=None,
-    c_ndupe_l=None,
-    r_ndupe_l=None,
-    dtype=None,
-    c_idx_type=None,
-    r_idx_type=None,
-):
-    """
-    Parameters
-    ----------
-    Density : float, optional
-        Float in (0, 1) that gives the percentage of non-missing numbers in
-        the DataFrame.
-    random_state : {np.random.RandomState, int}, optional
-        Random number generator or random seed.
-
-    See makeCustomDataframe for descriptions of the rest of the parameters.
-    """
-    df = makeCustomDataframe(
-        nrows,
-        ncols,
-        c_idx_names=c_idx_names,
-        r_idx_names=r_idx_names,
-        c_idx_nlevels=c_idx_nlevels,
-        r_idx_nlevels=r_idx_nlevels,
-        data_gen_f=data_gen_f,
-        c_ndupe_l=c_ndupe_l,
-        r_ndupe_l=r_ndupe_l,
-        dtype=dtype,
-        c_idx_type=c_idx_type,
-        r_idx_type=r_idx_type,
-    )
-
-    i, j = _create_missing_idx(nrows, ncols, density, random_state)
-    df.values[i, j] = np.nan
-    return df
-
-
-def makeMissingDataframe(density=0.9, random_state=None):
-    df = makeDataFrame()
-    i, j = _create_missing_idx(*df.shape, density=density, random_state=random_state)
-    df.values[i, j] = np.nan
-    return df
-
-
-class TestSubDict(dict):
-    def __init__(self, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
-
-
-def optional_args(decorator):
-    """allows a decorator to take optional positional and keyword arguments.
-    Assumes that taking a single, callable, positional argument means that
-    it is decorating a function, i.e. something like this::
-
-        @my_decorator
-        def function(): pass
-
-    Calls decorator with decorator(f, *args, **kwargs)"""
-
-    @wraps(decorator)
-    def wrapper(*args, **kwargs):
-        def dec(f):
-            return decorator(f, *args, **kwargs)
-
-        is_decorating = not kwargs and len(args) == 1 and callable(args[0])
-        if is_decorating:
-            f = args[0]
-            args = []
-            return dec(f)
-        else:
-            return dec
-
-    return wrapper
-
-
-# skip tests on exceptions with this message
-_network_error_messages = (
-    # 'urlopen error timed out',
-    # 'timeout: timed out',
-    # 'socket.timeout: timed out',
-    "timed out",
-    "Server Hangup",
-    "HTTP Error 503: Service Unavailable",
-    "502: Proxy Error",
-    "HTTP Error 502: internal error",
-    "HTTP Error 502",
-    "HTTP Error 503",
-    "HTTP Error 403",
-    "HTTP Error 400",
-    "Temporary failure in name resolution",
-    "Name or service not known",
-    "Connection refused",
-    "certificate verify",
-)
-
-# or this e.errno/e.reason.errno
-_network_errno_vals = (
-    101,  # Network is unreachable
-    111,  # Connection refused
-    110,  # Connection timed out
-    104,  # Connection reset Error
-    54,  # Connection reset by peer
-    60,  # urllib.error.URLError: [Errno 60] Connection timed out
-)
-
-# Both of the above shouldn't mask real issues such as 404's
-# or refused connections (changed DNS).
-# But some tests (test_data yahoo) contact incredibly flakey
-# servers.
-
-# and conditionally raise on exception types in _get_default_network_errors
-
-
-def _get_default_network_errors():
-    # Lazy import for http.client because it imports many things from the stdlib
-    import http.client
-
-    return (IOError, http.client.HTTPException, TimeoutError)
-
-
-def can_connect(url, error_classes=None):
-    """Try to connect to the given url. True if succeeds, False if IOError
-    raised
-
-    Parameters
-    ----------
-    url : basestring
-        The URL to try to connect to
-
-    Returns
-    -------
-    connectable : bool
-        Return True if no IOError (unable to connect) or URLError (bad url) was
-        raised
-    """
-
-    if error_classes is None:
-        error_classes = _get_default_network_errors()
-
-    try:
-        with urlopen(url):
-            pass
-    except error_classes:
-        return False
-    else:
-        return True
-
-
-@optional_args
-def network(
-    t,
-    url="http://www.google.com",
-    raise_on_error=_RAISE_NETWORK_ERROR_DEFAULT,
-    check_before_test=False,
-    error_classes=None,
-    skip_errnos=_network_errno_vals,
-    _skip_on_messages=_network_error_messages,
-):
-    """
-    Label a test as requiring network connection and, if an error is
-    encountered, only raise if it does not find a network connection.
-
-    In comparison to ``network``, this assumes an added contract to your test:
-    you must assert that, under normal conditions, your test will ONLY fail if
-    it does not have network connectivity.
-
-    You can call this in 3 ways: as a standard decorator, with keyword
-    arguments, or with a positional argument that is the url to check.
-
-    Parameters
-    ----------
-    t : callable
-        The test requiring network connectivity.
-    url : path
-        The url to test via ``pandas.io.common.urlopen`` to check
-        for connectivity. Defaults to 'http://www.google.com'.
-    raise_on_error : bool
-        If True, never catches errors.
-    check_before_test : bool
-        If True, checks connectivity before running the test case.
-    error_classes : tuple or Exception
-        error classes to ignore. If not in ``error_classes``, raises the error.
-        defaults to IOError. Be careful about changing the error classes here.
-    skip_errnos : iterable of int
-        Any exception that has .errno or .reason.erno set to one
-        of these values will be skipped with an appropriate
-        message.
-    _skip_on_messages: iterable of string
-        any exception e for which one of the strings is
-        a substring of str(e) will be skipped with an appropriate
-        message. Intended to suppress errors where an errno isn't available.
-
-    Notes
-    -----
-    * ``raise_on_error`` supercedes ``check_before_test``
-
-    Returns
-    -------
-    t : callable
-        The decorated test ``t``, with checks for connectivity errors.
-
-    Example
-    -------
-
-    Tests decorated with @network will fail if it's possible to make a network
-    connection to another URL (defaults to google.com)::
-
-      >>> from pandas.util.testing import network
-      >>> from pandas.io.common import urlopen
-      >>> @network
-      ... def test_network():
-      ...     with urlopen("rabbit://bonanza.com"):
-      ...         pass
-      Traceback
-         ...
-      URLError: <urlopen error unknown url type: rabit>
-
-      You can specify alternative URLs::
-
-        >>> @network("http://www.yahoo.com")
-        ... def test_something_with_yahoo():
-        ...    raise IOError("Failure Message")
-        >>> test_something_with_yahoo()
-        Traceback (most recent call last):
-            ...
-        IOError: Failure Message
-
-    If you set check_before_test, it will check the url first and not run the
-    test on failure::
-
-        >>> @network("failing://url.blaher", check_before_test=True)
-        ... def test_something():
-        ...     print("I ran!")
-        ...     raise ValueError("Failure")
-        >>> test_something()
-        Traceback (most recent call last):
-            ...
-
-    Errors not related to networking will always be raised.
-    """
-    from pytest import skip
-
-    if error_classes is None:
-        error_classes = _get_default_network_errors()
-
-    t.network = True
-
-    @wraps(t)
-    def wrapper(*args, **kwargs):
-        if check_before_test and not raise_on_error:
-            if not can_connect(url, error_classes):
-                skip()
-        try:
-            return t(*args, **kwargs)
-        except Exception as e:
-            errno = getattr(e, "errno", None)
-            if not errno and hasattr(errno, "reason"):
-                errno = getattr(e.reason, "errno", None)
-
-            if errno in skip_errnos:
-                skip(
-                    "Skipping test due to known errno"
-                    " and error {error}".format(error=e)
-                )
-
-            try:
-                e_str = traceback.format_exc(e)
-            except Exception:
-                e_str = str(e)
-
-            if any(m.lower() in e_str.lower() for m in _skip_on_messages):
-                skip(
-                    "Skipping test because exception "
-                    "message is known and error {error}".format(error=e)
-                )
-
-            if not isinstance(e, error_classes):
-                raise
-
-            if raise_on_error or can_connect(url, error_classes):
-                raise
-            else:
-                skip(
-                    "Skipping test due to lack of connectivity"
-                    " and error {error}".format(error=e)
-                )
-
-    return wrapper
-
-
-with_connectivity_check = network
-
-
-def assert_raises_regex(_exception, _regexp, _callable=None, *args, **kwargs):
-    r"""
-    Check that the specified Exception is raised and that the error message
-    matches a given regular expression pattern. This may be a regular
-    expression object or a string containing a regular expression suitable
-    for use by `re.search()`. This is a port of the `assertRaisesRegexp`
-    function from unittest in Python 2.7.
-
-    .. deprecated:: 0.24.0
-        Use `pytest.raises` instead.
-
-    Examples
-    --------
-    >>> assert_raises_regex(ValueError, 'invalid literal for.*XYZ', int, 'XYZ')
-    >>> import re
-    >>> assert_raises_regex(ValueError, re.compile('literal'), int, 'XYZ')
-
-    If an exception of a different type is raised, it bubbles up.
-
-    >>> assert_raises_regex(TypeError, 'literal', int, 'XYZ')
-    Traceback (most recent call last):
-        ...
-    ValueError: invalid literal for int() with base 10: 'XYZ'
-    >>> dct = dict()
-    >>> assert_raises_regex(KeyError, 'pear', dct.__getitem__, 'apple')
-    Traceback (most recent call last):
-        ...
-    AssertionError: "pear" does not match "'apple'"
-
-    You can also use this in a with statement.
-
-    >>> with assert_raises_regex(TypeError, r'unsupported operand type\(s\)'):
-    ...     1 + {}
-    >>> with assert_raises_regex(TypeError, 'banana'):
-    ...     'apple'[0] = 'b'
-    Traceback (most recent call last):
-        ...
-    AssertionError: "banana" does not match "'str' object does not support \
-item assignment"
-    """
-    warnings.warn(
-        (
-            "assert_raises_regex has been deprecated and will "
-            "be removed in the next release. Please use "
-            "`pytest.raises` instead."
-        ),
-        FutureWarning,
-        stacklevel=2,
-    )
-
-    manager = _AssertRaisesContextmanager(exception=_exception, regexp=_regexp)
-    if _callable is not None:
-        with manager:
-            _callable(*args, **kwargs)
-    else:
-        return manager
-
-
-class _AssertRaisesContextmanager:
-    """
-    Context manager behind `assert_raises_regex`.
-    """
-
-    def __init__(self, exception, regexp=None):
-        """
-        Initialize an _AssertRaisesContextManager instance.
-
-        Parameters
-        ----------
-        exception : class
-            The expected Exception class.
-        regexp : str, default None
-            The regex to compare against the Exception message.
-        """
-
-        self.exception = exception
-
-        if regexp is not None and not hasattr(regexp, "search"):
-            regexp = re.compile(regexp, re.DOTALL)
-
-        self.regexp = regexp
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, trace_back):
-        expected = self.exception
-
-        if not exc_type:
-            exp_name = getattr(expected, "__name__", str(expected))
-            raise AssertionError("{name} not raised.".format(name=exp_name))
-
-        return self.exception_matches(exc_type, exc_value, trace_back)
-
-    def exception_matches(self, exc_type, exc_value, trace_back):
-        """
-        Check that the Exception raised matches the expected Exception
-        and expected error message regular expression.
-
-        Parameters
-        ----------
-        exc_type : class
-            The type of Exception raised.
-        exc_value : Exception
-            The instance of `exc_type` raised.
-        trace_back : stack trace object
-            The traceback object associated with `exc_value`.
-
-        Returns
-        -------
-        is_matched : bool
-            Whether or not the Exception raised matches the expected
-            Exception class and expected error message regular expression.
-
-        Raises
-        ------
-        AssertionError : The error message provided does not match
-                         the expected error message regular expression.
-        """
-
-        if issubclass(exc_type, self.exception):
-            if self.regexp is not None:
-                val = str(exc_value)
-
-                if not self.regexp.search(val):
-                    msg = '"{pat}" does not match "{val}"'.format(
-                        pat=self.regexp.pattern, val=val
-                    )
-                    e = AssertionError(msg)
-                    raise_with_traceback(e, trace_back)
-
-            return True
-        else:
-            # Failed, so allow Exception to bubble up.
-            return False
-
-
-@contextmanager
-def assert_produces_warning(
-    expected_warning=Warning,
-    filter_level="always",
-    clear=None,
-    check_stacklevel=True,
-    raise_on_extra_warnings=True,
-):
-    """
-    Context manager for running code expected to either raise a specific
-    warning, or not raise any warnings. Verifies that the code raises the
-    expected warning, and that it does not raise any other unexpected
-    warnings. It is basically a wrapper around ``warnings.catch_warnings``.
-
-    Parameters
-    ----------
-    expected_warning : {Warning, False, None}, default Warning
-        The type of Exception raised. ``exception.Warning`` is the base
-        class for all warnings. To check that no warning is returned,
-        specify ``False`` or ``None``.
-    filter_level : str or None, default "always"
-        Specifies whether warnings are ignored, displayed, or turned
-        into errors.
-        Valid values are:
-
-        * "error" - turns matching warnings into exceptions
-        * "ignore" - discard the warning
-        * "always" - always emit a warning
-        * "default" - print the warning the first time it is generated
-          from each location
-        * "module" - print the warning the first time it is generated
-          from each module
-        * "once" - print the warning the first time it is generated
-
-    clear : str, default None
-        If not ``None`` then remove any previously raised warnings from
-        the ``__warningsregistry__`` to ensure that no warning messages are
-        suppressed by this context manager. If ``None`` is specified,
-        the ``__warningsregistry__`` keeps track of which warnings have been
-        shown, and does not show them again.
-    check_stacklevel : bool, default True
-        If True, displays the line that called the function containing
-        the warning to show were the function is called. Otherwise, the
-        line that implements the function is displayed.
-    raise_on_extra_warnings : bool, default True
-        Whether extra warnings not of the type `expected_warning` should
-        cause the test to fail.
-
-    Examples
-    --------
-    >>> import warnings
-    >>> with assert_produces_warning():
-    ...     warnings.warn(UserWarning())
-    ...
-    >>> with assert_produces_warning(False):
-    ...     warnings.warn(RuntimeWarning())
-    ...
-    Traceback (most recent call last):
-        ...
-    AssertionError: Caused unexpected warning(s): ['RuntimeWarning'].
-    >>> with assert_produces_warning(UserWarning):
-    ...     warnings.warn(RuntimeWarning())
-    Traceback (most recent call last):
-        ...
-    AssertionError: Did not see expected warning of class 'UserWarning'.
-
-    ..warn:: This is *not* thread-safe.
-    """
-    __tracebackhide__ = True
-
-    with warnings.catch_warnings(record=True) as w:
-
-        if clear is not None:
-            # make sure that we are clearing these warnings
-            # if they have happened before
-            # to guarantee that we will catch them
-            if not is_list_like(clear):
-                clear = [clear]
-            for m in clear:
-                try:
-                    m.__warningregistry__.clear()
-                except Exception:
-                    pass
-
-        saw_warning = False
-        warnings.simplefilter(filter_level)
-        yield w
-        extra_warnings = []
-
-        for actual_warning in w:
-            if expected_warning and issubclass(
-                actual_warning.category, expected_warning
-            ):
-                saw_warning = True
-
-                if check_stacklevel and issubclass(
-                    actual_warning.category, (FutureWarning, DeprecationWarning)
-                ):
-                    from inspect import getframeinfo, stack
-
-                    caller = getframeinfo(stack()[2][0])
-                    msg = (
-                        "Warning not set with correct stacklevel. "
-                        "File where warning is raised: {actual} != "
-                        "{caller}. Warning message: {message}"
-                    ).format(
-                        actual=actual_warning.filename,
-                        caller=caller.filename,
-                        message=actual_warning.message,
-                    )
-                    assert actual_warning.filename == caller.filename, msg
-            else:
-                extra_warnings.append(
-                    (
-                        actual_warning.category.__name__,
-                        actual_warning.message,
-                        actual_warning.filename,
-                        actual_warning.lineno,
-                    )
-                )
-        if expected_warning:
-            msg = "Did not see expected warning of class {name!r}.".format(
-                name=expected_warning.__name__
-            )
-            assert saw_warning, msg
-        if raise_on_extra_warnings and extra_warnings:
-            raise AssertionError(
-                "Caused unexpected warning(s): {!r}.".format(extra_warnings)
-            )
-
-
-class RNGContext:
-    """
-    Context manager to set the numpy random number generator speed. Returns
-    to the original value upon exiting the context manager.
-
-    Parameters
-    ----------
-    seed : int
-        Seed for numpy.random.seed
-
-    Examples
-    --------
-
-    with RNGContext(42):
-        np.random.randn()
-    """
-
-    def __init__(self, seed):
-        self.seed = seed
-
-    def __enter__(self):
-
-        self.start_state = np.random.get_state()
-        np.random.seed(self.seed)
-
-    def __exit__(self, exc_type, exc_value, traceback):
-
-        np.random.set_state(self.start_state)
-
-
-@contextmanager
-def with_csv_dialect(name, **kwargs):
-    """
-    Context manager to temporarily register a CSV dialect for parsing CSV.
-
-    Parameters
-    ----------
-    name : str
-        The name of the dialect.
-    kwargs : mapping
-        The parameters for the dialect.
-
-    Raises
-    ------
-    ValueError : the name of the dialect conflicts with a builtin one.
-
-    See Also
-    --------
-    csv : Python's CSV library.
-    """
-    import csv
-
-    _BUILTIN_DIALECTS = {"excel", "excel-tab", "unix"}
-
-    if name in _BUILTIN_DIALECTS:
-        raise ValueError("Cannot override builtin dialect.")
-
-    csv.register_dialect(name, **kwargs)
-    yield
-    csv.unregister_dialect(name)
-
-
-@contextmanager
-def use_numexpr(use, min_elements=None):
-    from pandas.core.computation import expressions as expr
-
-    if min_elements is None:
-        min_elements = expr._MIN_ELEMENTS
-
-    olduse = expr._USE_NUMEXPR
-    oldmin = expr._MIN_ELEMENTS
-    expr.set_use_numexpr(use)
-    expr._MIN_ELEMENTS = min_elements
-    yield
-    expr._MIN_ELEMENTS = oldmin
-    expr.set_use_numexpr(olduse)
-
-
-def test_parallel(num_threads=2, kwargs_list=None):
-    """Decorator to run the same function multiple times in parallel.
-
-    Parameters
-    ----------
-    num_threads : int, optional
-        The number of times the function is run in parallel.
-    kwargs_list : list of dicts, optional
-        The list of kwargs to update original
-        function kwargs on different threads.
-    Notes
-    -----
-    This decorator does not pass the return value of the decorated function.
-
-    Original from scikit-image:
-
-    https://github.com/scikit-image/scikit-image/pull/1519
-
-    """
-
-    assert num_threads > 0
-    has_kwargs_list = kwargs_list is not None
-    if has_kwargs_list:
-        assert len(kwargs_list) == num_threads
-    import threading
-
-    def wrapper(func):
-        @wraps(func)
-        def inner(*args, **kwargs):
-            if has_kwargs_list:
-                update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
-            else:
-                update_kwargs = lambda i: kwargs
-            threads = []
-            for i in range(num_threads):
-                updated_kwargs = update_kwargs(i)
-                thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
-                threads.append(thread)
-            for thread in threads:
-                thread.start()
-            for thread in threads:
-                thread.join()
-
-        return inner
-
-    return wrapper
-
-
-class SubclassedSeries(Series):
-    _metadata = ["testattr", "name"]
-
-    @property
-    def _constructor(self):
-        return SubclassedSeries
-
-    @property
-    def _constructor_expanddim(self):
-        return SubclassedDataFrame
-
-
-class SubclassedDataFrame(DataFrame):
-    _metadata = ["testattr"]
-
-    @property
-    def _constructor(self):
-        return SubclassedDataFrame
-
-    @property
-    def _constructor_sliced(self):
-        return SubclassedSeries
-
-
-class SubclassedSparseSeries(pd.SparseSeries):
-    _metadata = ["testattr"]
-
-    @property
-    def _constructor(self):
-        return SubclassedSparseSeries
-
-    @property
-    def _constructor_expanddim(self):
-        return SubclassedSparseDataFrame
-
-
-class SubclassedSparseDataFrame(pd.SparseDataFrame):
-    _metadata = ["testattr"]
-
-    @property
-    def _constructor(self):
-        return SubclassedSparseDataFrame
-
-    @property
-    def _constructor_sliced(self):
-        return SubclassedSparseSeries
-
-
-class SubclassedCategorical(Categorical):
-    @property
-    def _constructor(self):
-        return SubclassedCategorical
-
-
-@contextmanager
-def set_timezone(tz):
-    """Context manager for temporarily setting a timezone.
-
-    Parameters
-    ----------
-    tz : str
-        A string representing a valid timezone.
-
-    Examples
-    --------
-
-    >>> from datetime import datetime
-    >>> from dateutil.tz import tzlocal
-    >>> tzlocal().tzname(datetime.now())
-    'IST'
-
-    >>> with set_timezone('US/Eastern'):
-    ...     tzlocal().tzname(datetime.now())
-    ...
-    'EDT'
-    """
-
-    import os
-    import time
-
-    def setTZ(tz):
-        if tz is None:
-            try:
-                del os.environ["TZ"]
-            except KeyError:
-                pass
-        else:
-            os.environ["TZ"] = tz
-            time.tzset()
-
-    orig_tz = os.environ.get("TZ")
-    setTZ(tz)
-    try:
-        yield
-    finally:
-        setTZ(orig_tz)
-
-
-def _make_skipna_wrapper(alternative, skipna_alternative=None):
-    """Create a function for calling on an array.
-
-    Parameters
-    ----------
-    alternative : function
-        The function to be called on the array with no NaNs.
-        Only used when 'skipna_alternative' is None.
-    skipna_alternative : function
-        The function to be called on the original array
-
-    Returns
-    -------
-    skipna_wrapper : function
-    """
-    if skipna_alternative:
-
-        def skipna_wrapper(x):
-            return skipna_alternative(x.values)
-
-    else:
-
-        def skipna_wrapper(x):
-            nona = x.dropna()
-            if len(nona) == 0:
-                return np.nan
-            return alternative(nona)
-
-    return skipna_wrapper
-
-
-def convert_rows_list_to_csv_str(rows_list):
-    """
-    Convert list of CSV rows to single CSV-formatted string for current OS.
-
-    This method is used for creating expected value of to_csv() method.
-
-    Parameters
-    ----------
-    rows_list : list
-        The list of string. Each element represents the row of csv.
-
-    Returns
-    -------
-    expected : string
-        Expected output of to_csv() in current OS
-    """
-    sep = os.linesep
-    expected = sep.join(rows_list) + sep
-    return expected
diff --git a/pyproject.toml b/pyproject.toml
index 2ec4739c2f7f8..28d7c3d55c919 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,10 +5,28 @@ requires = [
     "setuptools",
     "wheel",
     "Cython>=0.29.13",  # Note: sync with setup.py
-    "numpy==1.13.3; python_version=='3.5' and platform_system!='AIX'",
     "numpy==1.13.3; python_version=='3.6' and platform_system!='AIX'",
     "numpy==1.14.5; python_version>='3.7' and platform_system!='AIX'",
-    "numpy==1.16.0; python_version=='3.5' and platform_system=='AIX'",
     "numpy==1.16.0; python_version=='3.6' and platform_system=='AIX'",
     "numpy==1.16.0; python_version>='3.7' and platform_system=='AIX'",
 ]
+
+[tool.black]
+target-version = ['py36', 'py37', 'py38']
+exclude = '''
+(
+    asv_bench/env
+  | \.egg
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.nox
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+  | setup.py
+)
+'''
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 3f4636043dbac..08cbef2c7fc6b 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,30 +1,41 @@
+# This file is auto-generated from environment.yml, do not modify.
+# See that file for comments about the need/usage of each dependency.
+
 numpy>=1.15
 python-dateutil>=2.6.1
 pytz
 asv
 cython>=0.29.13
-black
+black==19.10b0
 cpplint
 flake8
-flake8-comprehensions
+flake8-comprehensions>=3.1.0
 flake8-rst>=0.6.0,<=0.7.0
 isort
-mypy
+mypy==0.730
 pycodestyle
 gitpython
-sphinx==1.8.5
-numpydoc>=0.9.0
+sphinx
 nbconvert>=5.4.1
 nbsphinx
 pandoc
+dask
+toolz>=0.7.3
+fsspec>=0.5.1
+partd>=0.3.10
+cloudpickle>=0.2.1
+markdown
+feedparser
+pyyaml
+requests
 boto3
 botocore>=1.11
 hypothesis>=3.82
 moto
-pytest>=4.0.2
+pytest>=5.0.1
 pytest-cov
-pytest-mock
-pytest-xdist
+pytest-xdist>=1.21
+pytest-asyncio
 seaborn
 statsmodels
 ipywidgets
@@ -34,25 +45,29 @@ pip
 blosc
 bottleneck>=1.2.1
 ipykernel
-ipython>=5.6.0
+ipython>=7.11.1
 jinja2
 matplotlib>=2.2.2
 numexpr>=2.6.8
 scipy>=1.1
+numba>=0.46.0
 beautifulsoup4>=4.6.0
-fastparquet>=0.2.1
 html5lib
 lxml
-openpyxl
-pyarrow>=0.9.0
+openpyxl<=3.0.1
+xlrd
+xlsxwriter
+xlwt
+odfpy
+fastparquet>=0.3.2
+pyarrow>=0.13.1
+python-snappy
 pyqt5>=5.9.2
 tables>=3.4.2
-python-snappy
 s3fs
 sqlalchemy
 xarray
-xlrd
-xlsxwriter
-xlwt
-odfpy
-pyreadstat
\ No newline at end of file
+pyreadstat
+tabulate>=0.8.3
+git+https://github.com/pandas-dev/pandas-sphinx-theme.git@master
+git+https://github.com/numpy/numpydoc
\ No newline at end of file
diff --git a/scripts/build_dist.sh b/scripts/build_dist.sh
deleted file mode 100755
index c3f849ce7a6eb..0000000000000
--- a/scripts/build_dist.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/bash
-
-# build the distribution
-LAST=`git tag --sort version:refname | grep -v rc | tail -1`
-
-echo "Building distribution for: $LAST"
-git checkout $LAST
-
-read -p "Ok to continue (y/n)? " answer
-case ${answer:0:1} in
-    y|Y )
-        echo "Building distribution"
-        ./build_dist_for_release.sh
-    ;;
-    * )
-        echo "Not building distribution"
-    ;;
-esac
diff --git a/scripts/build_dist_for_release.sh b/scripts/build_dist_for_release.sh
deleted file mode 100755
index bee0f23a68ec2..0000000000000
--- a/scripts/build_dist_for_release.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-
-# this requires cython to be installed
-
-# this builds the release cleanly & is building on the current checkout
-rm -rf dist
-git clean -xfd
-python setup.py clean --quiet
-python setup.py cython --quiet
-python setup.py sdist --formats=gztar --quiet
diff --git a/scripts/download_wheels.py b/scripts/download_wheels.py
deleted file mode 100644
index 4ca1354321134..0000000000000
--- a/scripts/download_wheels.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-"""Fetch wheels from wheels.scipy.org for a pandas version."""
-import argparse
-import pathlib
-import sys
-import urllib.parse
-import urllib.request
-
-from lxml import html
-
-
-def parse_args(args=None):
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("version", type=str, help="Pandas version (0.23.0)")
-    return parser.parse_args(args)
-
-
-def fetch(version):
-    base = "http://wheels.scipy.org"
-    tree = html.parse(base)
-    root = tree.getroot()
-
-    dest = pathlib.Path("dist")
-    dest.mkdir(exist_ok=True)
-
-    files = [
-        x
-        for x in root.xpath("//a/text()")
-        if x.startswith("pandas-{}".format(version)) and not dest.joinpath(x).exists()
-    ]
-
-    N = len(files)
-
-    for i, filename in enumerate(files, 1):
-        out = str(dest.joinpath(filename))
-        link = urllib.request.urljoin(base, filename)
-        urllib.request.urlretrieve(link, out)
-        print(
-            "Downloaded {link} to {out} [{i}/{N}]".format(link=link, out=out, i=i, N=N)
-        )
-
-
-def main(args=None):
-    args = parse_args(args)
-    fetch(args.version)
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/scripts/find_commits_touching_func.py b/scripts/find_commits_touching_func.py
index 95a892b822cff..85675cb6df42b 100755
--- a/scripts/find_commits_touching_func.py
+++ b/scripts/find_commits_touching_func.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # copyright 2013, y-p @ github
 """
 Search the git history for all commits touching a named method
@@ -46,14 +46,14 @@
     "--dir-masks",
     metavar="d_re(,d_re)*",
     default=[],
-    help="comma separated list of regexes to match base " "path against",
+    help="comma separated list of regexes to match base path against",
 )
 argparser.add_argument(
     "-p",
     "--path-masks",
     metavar="p_re(,p_re)*",
     default=[],
-    help="comma separated list of regexes to match full " "file path against",
+    help="comma separated list of regexes to match full file path against",
 )
 argparser.add_argument(
     "-y",
@@ -195,7 +195,7 @@ def sorter(i):
         return hits[i].path, d
 
     print(
-        ("\nThese commits touched the %s method in these files " "on these dates:\n")
+        ("\nThese commits touched the %s method in these files on these dates:\n")
         % args.funcname
     )
     for i in sorted(range(len(hits)), key=sorter):
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index 29fe8bf84c12b..b0a06416ce443 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
 Convert the conda environment.yml to the pip requirements-dev.txt,
 or check that they have the same packages (for the CI)
@@ -19,8 +19,8 @@
 
 import yaml
 
-EXCLUDE = {"python=3"}
-RENAME = {"pytables": "tables", "pyqt": "pyqt5"}
+EXCLUDE = {"python"}
+RENAME = {"pytables": "tables", "pyqt": "pyqt5", "dask-core": "dask"}
 
 
 def conda_package_to_pip(package):
@@ -33,21 +33,24 @@ def conda_package_to_pip(package):
     - A package requiring a specific version, in conda is defined with a single
       equal (e.g. ``pandas=1.0``) and in pip with two (e.g. ``pandas==1.0``)
     """
-    if package in EXCLUDE:
-        return
-
     package = re.sub("(?<=[^<>])=", "==", package).strip()
+
     for compare in ("<=", ">=", "=="):
         if compare not in package:
             continue
 
         pkg, version = package.split(compare)
+        if pkg in EXCLUDE:
+            return
 
         if pkg in RENAME:
             return "".join((RENAME[pkg], compare, version))
 
         break
 
+    if package in RENAME:
+        return RENAME[package]
+
     return package
 
 
@@ -84,9 +87,14 @@ def main(conda_fname, pip_fname, compare=False):
         elif isinstance(dep, dict) and len(dep) == 1 and "pip" in dep:
             pip_deps += dep["pip"]
         else:
-            raise ValueError("Unexpected dependency {}".format(dep))
+            raise ValueError(f"Unexpected dependency {dep}")
 
-    pip_content = "\n".join(pip_deps)
+    fname = os.path.split(conda_fname)[1]
+    header = (
+        f"# This file is auto-generated from {fname}, do not modify.\n"
+        "# See that file for comments about the need/usage of each dependency.\n\n"
+    )
+    pip_content = header + "\n".join(pip_deps)
 
     if compare:
         with open(pip_fname) as pip_fd:
@@ -119,13 +127,12 @@ def main(conda_fname, pip_fname, compare=False):
     )
     if res:
         msg = (
-            "`requirements-dev.txt` has to be generated with `{}` after "
-            "`environment.yml` is modified.\n".format(sys.argv[0])
+            f"`requirements-dev.txt` has to be generated with `{sys.argv[0]}` after "
+            "`environment.yml` is modified.\n"
         )
         if args.azure:
             msg = (
-                "##vso[task.logissue type=error;"
-                "sourcepath=requirements-dev.txt]{}".format(msg)
+                f"##vso[task.logissue type=error;sourcepath=requirements-dev.txt]{msg}"
             )
         sys.stderr.write(msg)
     sys.exit(res)
diff --git a/scripts/list_future_warnings.sh b/scripts/list_future_warnings.sh
index 0c4046bbb5f49..121f4f5a92abb 100755
--- a/scripts/list_future_warnings.sh
+++ b/scripts/list_future_warnings.sh
@@ -25,7 +25,7 @@
 EXCLUDE="^pandas/tests/|"  # tests validate that FutureWarnings are raised
 EXCLUDE+="^pandas/util/_decorators.py$|"  # generic deprecate function that raises warning
 EXCLUDE+="^pandas/util/_depr_module.py$|"  # generic deprecate module that raises warnings
-EXCLUDE+="^pandas/util/testing.py$|" # contains function to evaluate if warning is raised
+EXCLUDE+="^pandas._testing.py$|" # contains function to evaluate if warning is raised
 EXCLUDE+="^pandas/io/parsers.py$"  # implements generic deprecation system in io reading
 
 BASE_DIR="$(dirname $0)/.."
diff --git a/scripts/merge-pr.py b/scripts/merge-pr.py
deleted file mode 100755
index 300cb149f387f..0000000000000
--- a/scripts/merge-pr.py
+++ /dev/null
@@ -1,337 +0,0 @@
-#!/usr/bin/env python
-
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# Utility for creating well-formed pull request merges and pushing them to
-# Apache.
-#   usage: ./apache-pr-merge.py    (see config env vars below)
-#
-# Lightly modified from version of this script in incubator-parquet-format
-
-import os
-from subprocess import check_output
-import sys
-import textwrap
-
-import requests
-from requests.auth import HTTPBasicAuth
-
-PANDAS_HOME = "."
-PROJECT_NAME = "pandas"
-print("PANDAS_HOME = " + PANDAS_HOME)
-
-# Remote name with the PR
-PR_REMOTE_NAME = os.environ.get("PR_REMOTE_NAME", "upstream")
-
-# Remote name where results pushed
-PUSH_REMOTE_NAME = os.environ.get("PUSH_REMOTE_NAME", "upstream")
-
-GITHUB_BASE = "https://github.com/pandas-dev/" + PROJECT_NAME + "/pull"
-GITHUB_API_BASE = "https://api.github.com/repos/pandas-dev/" + PROJECT_NAME
-
-# Prefix added to temporary branches
-BRANCH_PREFIX = "PR_TOOL"
-
-os.chdir(PANDAS_HOME)
-
-auth_required = False
-
-if auth_required:
-    GITHUB_USERNAME = os.environ["GITHUB_USER"]
-    import getpass
-
-    GITHUB_PASSWORD = getpass.getpass(
-        "Enter github.com password for %s:" % GITHUB_USERNAME
-    )
-
-    def get_json_auth(url):
-        auth = HTTPBasicAuth(GITHUB_USERNAME, GITHUB_PASSWORD)
-        req = requests.get(url, auth=auth)
-        return req.json()
-
-    get_json = get_json_auth
-else:
-
-    def get_json_no_auth(url):
-        req = requests.get(url)
-        return req.json()
-
-    get_json = get_json_no_auth
-
-
-def fail(msg):
-    print(msg)
-    clean_up()
-    sys.exit(-1)
-
-
-def run_cmd(cmd):
-    if isinstance(cmd, str):
-        cmd = cmd.split(" ")
-
-    output = check_output(cmd)
-
-    if isinstance(output, bytes):
-        output = output.decode("utf-8")
-    return output
-
-
-def continue_maybe(prompt):
-    result = input("\n%s (y/n): " % prompt)
-    if result.lower() != "y":
-        fail("Okay, exiting")
-
-
-def continue_maybe2(prompt):
-    result = input("\n%s (y/n): " % prompt)
-    if result.lower() != "y":
-        return False
-    else:
-        return True
-
-
-original_head = run_cmd("git rev-parse HEAD")[:8]
-
-
-def clean_up():
-    print("Restoring head pointer to %s" % original_head)
-    run_cmd("git checkout %s" % original_head)
-
-    branches = run_cmd("git branch").replace(" ", "").split("\n")
-
-    for branch in [b for b in branches if b.startswith(BRANCH_PREFIX)]:
-        print("Deleting local branch %s" % branch)
-        run_cmd("git branch -D %s" % branch)
-
-
-# Merge the requested PR and return the merge hash
-def merge_pr(pr_num, target_ref):
-
-    pr_branch_name = "%s_MERGE_PR_%s" % (BRANCH_PREFIX, pr_num)
-    target_branch_name = "%s_MERGE_PR_%s_%s" % (
-        BRANCH_PREFIX,
-        pr_num,
-        target_ref.upper(),
-    )
-    run_cmd("git fetch %s pull/%s/head:%s" % (PR_REMOTE_NAME, pr_num, pr_branch_name))
-    run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, target_ref, target_branch_name))
-    run_cmd("git checkout %s" % target_branch_name)
-
-    had_conflicts = False
-    try:
-        run_cmd(["git", "merge", pr_branch_name, "--squash"])
-    except Exception as e:
-        msg = "Error merging: %s\nWould you like to manually fix-up " "this merge?" % e
-        continue_maybe(msg)
-        msg = (
-            "Okay, please fix any conflicts and 'git add' "
-            "conflicting files... Finished?"
-        )
-        continue_maybe(msg)
-        had_conflicts = True
-
-    commit_authors = run_cmd(
-        ["git", "log", "HEAD..%s" % pr_branch_name, "--pretty=format:%an <%ae>"]
-    ).split("\n")
-    distinct_authors = sorted(
-        set(commit_authors), key=lambda x: commit_authors.count(x), reverse=True
-    )
-    primary_author = distinct_authors[0]
-    commits = run_cmd(
-        ["git", "log", "HEAD..%s" % pr_branch_name, "--pretty=format:%h [%an] %s"]
-    ).split("\n\n")
-
-    merge_message_flags = []
-
-    merge_message_flags += ["-m", title]
-    if body is not None:
-        merge_message_flags += ["-m", "\n".join(textwrap.wrap(body))]
-
-    authors = "\n".join("Author: %s" % a for a in distinct_authors)
-
-    merge_message_flags += ["-m", authors]
-
-    if had_conflicts:
-        committer_name = run_cmd("git config --get user.name").strip()
-        committer_email = run_cmd("git config --get user.email").strip()
-        message = (
-            "This patch had conflicts when merged, "
-            "resolved by\nCommitter: %s <%s>" % (committer_name, committer_email)
-        )
-        merge_message_flags += ["-m", message]
-
-    # The string "Closes #%s" string is required for GitHub to correctly close
-    # the PR
-    merge_message_flags += [
-        "-m",
-        "Closes #%s from %s and squashes the following commits:"
-        % (pr_num, pr_repo_desc),
-    ]
-    for c in commits:
-        merge_message_flags += ["-m", c]
-
-    run_cmd(["git", "commit", '--author="%s"' % primary_author] + merge_message_flags)
-
-    continue_maybe(
-        "Merge complete (local ref %s). Push to %s?"
-        % (target_branch_name, PUSH_REMOTE_NAME)
-    )
-
-    try:
-        run_cmd(
-            "git push %s %s:%s" % (PUSH_REMOTE_NAME, target_branch_name, target_ref)
-        )
-    except Exception as e:
-        clean_up()
-        fail("Exception while pushing: %s" % e)
-
-    merge_hash = run_cmd("git rev-parse %s" % target_branch_name)[:8]
-    clean_up()
-    print("Pull request #%s merged!" % pr_num)
-    print("Merge hash: %s" % merge_hash)
-    return merge_hash
-
-
-def update_pr(pr_num, user_login, base_ref):
-
-    pr_branch_name = "%s_MERGE_PR_%s" % (BRANCH_PREFIX, pr_num)
-
-    run_cmd("git fetch %s pull/%s/head:%s" % (PR_REMOTE_NAME, pr_num, pr_branch_name))
-    run_cmd("git checkout %s" % pr_branch_name)
-
-    continue_maybe(
-        "Update ready (local ref %s)? Push to %s/%s?"
-        % (pr_branch_name, user_login, base_ref)
-    )
-
-    push_user_remote = "https://github.com/%s/pandas.git" % user_login
-
-    try:
-        run_cmd("git push %s %s:%s" % (push_user_remote, pr_branch_name, base_ref))
-    except Exception as e:
-
-        if continue_maybe2("Force push?"):
-            try:
-                run_cmd(
-                    "git push -f %s %s:%s"
-                    % (push_user_remote, pr_branch_name, base_ref)
-                )
-            except Exception as e:
-                fail("Exception while pushing: %s" % e)
-                clean_up()
-        else:
-            fail("Exception while pushing: %s" % e)
-            clean_up()
-
-    clean_up()
-    print("Pull request #%s updated!" % pr_num)
-
-
-def cherry_pick(pr_num, merge_hash, default_branch):
-    pick_ref = input("Enter a branch name [%s]: " % default_branch)
-    if pick_ref == "":
-        pick_ref = default_branch
-
-    pick_branch_name = "%s_PICK_PR_%s_%s" % (BRANCH_PREFIX, pr_num, pick_ref.upper())
-
-    run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, pick_ref, pick_branch_name))
-    run_cmd("git checkout %s" % pick_branch_name)
-    run_cmd("git cherry-pick -sx %s" % merge_hash)
-
-    continue_maybe(
-        "Pick complete (local ref %s). Push to %s?"
-        % (pick_branch_name, PUSH_REMOTE_NAME)
-    )
-
-    try:
-        run_cmd("git push %s %s:%s" % (PUSH_REMOTE_NAME, pick_branch_name, pick_ref))
-    except Exception as e:
-        clean_up()
-        fail("Exception while pushing: %s" % e)
-
-    pick_hash = run_cmd("git rev-parse %s" % pick_branch_name)[:8]
-    clean_up()
-
-    print("Pull request #%s picked into %s!" % (pr_num, pick_ref))
-    print("Pick hash: %s" % pick_hash)
-    return pick_ref
-
-
-def fix_version_from_branch(branch, versions):
-    #  Note: Assumes this is a sorted (newest->oldest) list of un-released
-    #  versions
-    if branch == "master":
-        return versions[0]
-    else:
-        branch_ver = branch.replace("branch-", "")
-        return filter(lambda x: x.name.startswith(branch_ver), versions)[-1]
-
-
-pr_num = input("Which pull request would you like to merge? (e.g. 34): ")
-pr = get_json("%s/pulls/%s" % (GITHUB_API_BASE, pr_num))
-
-url = pr["url"]
-title = pr["title"]
-body = pr["body"]
-target_ref = pr["base"]["ref"]
-user_login = pr["user"]["login"]
-base_ref = pr["head"]["ref"]
-pr_repo_desc = "%s/%s" % (user_login, base_ref)
-
-if pr["merged"] is True:
-    print(
-        "Pull request {0} has already been merged, please backport manually".format(
-            pr_num
-        )
-    )
-    sys.exit(0)
-
-if not bool(pr["mergeable"]):
-    msg = (
-        "Pull request {0} is not mergeable in its current form.\n"
-        "Continue? (experts only!)".format(pr_num)
-    )
-    continue_maybe(msg)
-
-print("\n=== Pull Request #%s ===" % pr_num)
-
-# we may have un-printable unicode in our title
-try:
-    title = title.encode("raw_unicode_escape")
-except Exception:
-    pass
-
-print(
-    "title\t{title}\nsource\t{source}\ntarget\t{target}\nurl\t{url}".format(
-        title=title, source=pr_repo_desc, target=target_ref, url=url
-    )
-)
-
-
-merged_refs = [target_ref]
-
-print("\nProceed with updating or merging pull request #%s?" % pr_num)
-update = input(
-    "Update PR and push to remote (r), merge locally (l), " "or do nothing (n) ?"
-)
-update = update.lower()
-
-if update == "r":
-    merge_hash = update_pr(pr_num, user_login, base_ref)
-elif update == "l":
-    merge_hash = merge_pr(pr_num, target_ref)
diff --git a/scripts/tests/test_validate_docstrings.py b/scripts/tests/test_validate_docstrings.py
index 85e5bf239cbfa..b11de0c4ad860 100644
--- a/scripts/tests/test_validate_docstrings.py
+++ b/scripts/tests/test_validate_docstrings.py
@@ -1,387 +1,35 @@
 import io
-import random
-import string
 import textwrap
 
-import numpy as np
 import pytest
 import validate_docstrings
 
-import pandas as pd
 
-validate_one = validate_docstrings.validate_one
-
-
-class GoodDocStrings:
-    """
-    Collection of good doc strings.
-
-    This class contains a lot of docstrings that should pass the validation
-    script without any errors.
+class BadDocstrings:
+    """Everything here has a bad docstring
     """
 
-    def plot(self, kind, color="blue", **kwargs):
-        """
-        Generate a plot.
-
-        Render the data in the Series as a matplotlib plot of the
-        specified kind.
-
-        Parameters
-        ----------
-        kind : str
-            Kind of matplotlib plot.
-        color : str, default 'blue'
-            Color name or rgb code.
-        **kwargs
-            These parameters will be passed to the matplotlib plotting
-            function.
-        """
-        pass
-
-    def sample(self):
-        """
-        Generate and return a random number.
-
-        The value is sampled from a continuous uniform distribution between
-        0 and 1.
-
-        Returns
-        -------
-        float
-            Random number generated.
-        """
-        return random.random()
-
-    def random_letters(self):
-        """
-        Generate and return a sequence of random letters.
-
-        The length of the returned string is also random, and is also
-        returned.
-
-        Returns
-        -------
-        length : int
-            Length of the returned string.
-        letters : str
-            String of random letters.
-        """
-        length = random.randint(1, 10)
-        letters = "".join(random.sample(string.ascii_lowercase, length))
-        return length, letters
-
-    def sample_values(self):
-        """
-        Generate an infinite sequence of random numbers.
-
-        The values are sampled from a continuous uniform distribution between
-        0 and 1.
-
-        Yields
-        ------
-        float
-            Random number generated.
-        """
-        while True:
-            yield random.random()
-
-    def head(self):
+    def private_classes(self):
         """
-        Return the first 5 elements of the Series.
-
-        This function is mainly useful to preview the values of the
-        Series without displaying the whole of it.
-
-        Returns
-        -------
-        Series
-            Subset of the original series with the 5 first values.
-
-        See Also
-        --------
-        Series.tail : Return the last 5 elements of the Series.
-        Series.iloc : Return a slice of the elements in the Series,
-            which can also be used to return the first or last n.
+        This mentions NDFrame, which is not correct.
         """
-        return self.iloc[:5]
 
-    def head1(self, n=5):
+    def prefix_pandas(self):
         """
-        Return the first elements of the Series.
-
-        This function is mainly useful to preview the values of the
-        Series without displaying the whole of it.
-
-        Parameters
-        ----------
-        n : int
-            Number of values to return.
-
-        Returns
-        -------
-        Series
-            Subset of the original series with the n first values.
+        Have `pandas` prefix in See Also section.
 
         See Also
         --------
-        tail : Return the last n elements of the Series.
-
-        Examples
-        --------
-        >>> s = pd.Series(['Ant', 'Bear', 'Cow', 'Dog', 'Falcon'])
-        >>> s.head()
-        0   Ant
-        1   Bear
-        2   Cow
-        3   Dog
-        4   Falcon
-        dtype: object
-
-        With the `n` parameter, we can change the number of returned rows:
-
-        >>> s.head(n=3)
-        0   Ant
-        1   Bear
-        2   Cow
-        dtype: object
-        """
-        return self.iloc[:n]
-
-    def contains(self, pat, case=True, na=np.nan):
-        """
-        Return whether each value contains `pat`.
-
-        In this case, we are illustrating how to use sections, even
-        if the example is simple enough and does not require them.
-
-        Parameters
-        ----------
-        pat : str
-            Pattern to check for within each element.
-        case : bool, default True
-            Whether check should be done with case sensitivity.
-        na : object, default np.nan
-            Fill value for missing data.
-
-        Examples
-        --------
-        >>> s = pd.Series(['Antelope', 'Lion', 'Zebra', np.nan])
-        >>> s.str.contains(pat='a')
-        0    False
-        1    False
-        2     True
-        3      NaN
-        dtype: object
-
-        **Case sensitivity**
-
-        With `case_sensitive` set to `False` we can match `a` with both
-        `a` and `A`:
-
-        >>> s.str.contains(pat='a', case=False)
-        0     True
-        1    False
-        2     True
-        3      NaN
-        dtype: object
-
-        **Missing values**
-
-        We can fill missing values in the output using the `na` parameter:
-
-        >>> s.str.contains(pat='a', na=False)
-        0    False
-        1    False
-        2     True
-        3    False
-        dtype: bool
-        """
-        pass
-
-    def mode(self, axis, numeric_only):
-        """
-        Ensure reST directives don't affect checks for leading periods.
-
-        Parameters
-        ----------
-        axis : str
-            Sentence ending in period, followed by single directive.
-
-            .. versionchanged:: 0.1.2
-
-        numeric_only : bool
-            Sentence ending in period, followed by multiple directives.
-
-            .. versionadded:: 0.1.2
-            .. deprecated:: 0.00.0
-                A multiline description,
-                which spans another line.
-        """
-        pass
-
-    def good_imports(self):
-        """
-        Ensure import other than numpy and pandas are fine.
-
-        Examples
-        --------
-        This example does not import pandas or import numpy.
-        >>> import datetime
-        >>> datetime.MAXYEAR
-        9999
-        """
-        pass
-
-    def no_returns(self):
-        """
-        Say hello and have no returns.
-        """
-        pass
-
-    def empty_returns(self):
-        """
-        Say hello and always return None.
-
-        Since this function never returns a value, this
-        docstring doesn't need a return section.
-        """
-
-        def say_hello():
-            return "Hello World!"
-
-        say_hello()
-        if True:
-            return
-        else:
-            return None
-
-
-class BadGenericDocStrings:
-    """Everything here has a bad docstring
-    """
-
-    def func(self):
-
-        """Some function.
-
-        With several mistakes in the docstring.
-
-        It has a blank like after the signature `def func():`.
-
-        The text 'Some function' should go in the line after the
-        opening quotes of the docstring, not in the same line.
-
-        There is a blank line between the docstring and the first line
-        of code `foo = 1`.
-
-        The closing quotes should be in the next line, not in this one."""
-
-        foo = 1
-        bar = 2
-        return foo + bar
-
-    def astype(self, dtype):
-        """
-        Casts Series type.
-
-        Verb in third-person of the present simple, should be infinitive.
-        """
-        pass
-
-    def astype1(self, dtype):
-        """
-        Method to cast Series type.
-
-        Does not start with verb.
-        """
-        pass
-
-    def astype2(self, dtype):
-        """
-        Cast Series type
-
-        Missing dot at the end.
-        """
-        pass
-
-    def astype3(self, dtype):
-        """
-        Cast Series type from its current type to the new type defined in
-        the parameter dtype.
-
-        Summary is too verbose and doesn't fit in a single line.
-        """
-        pass
-
-    def two_linebreaks_between_sections(self, foo):
-        """
-        Test linebreaks message GL03.
-
-        Note 2 blank lines before parameters section.
-
-
-        Parameters
-        ----------
-        foo : str
-            Description of foo parameter.
-        """
-        pass
-
-    def linebreak_at_end_of_docstring(self, foo):
-        """
-        Test linebreaks message GL03.
-
-        Note extra blank line at end of docstring.
-
-        Parameters
-        ----------
-        foo : str
-            Description of foo parameter.
-
-        """
-        pass
-
-    def plot(self, kind, **kwargs):
-        """
-        Generate a plot.
-
-        Render the data in the Series as a matplotlib plot of the
-        specified kind.
-
-        Note the blank line between the parameters title and the first
-        parameter. Also, note that after the name of the parameter `kind`
-        and before the colon, a space is missing.
-
-        Also, note that the parameter descriptions do not start with a
-        capital letter, and do not finish with a dot.
-
-        Finally, the `**kwargs` parameter is missing.
-
-        Parameters
-        ----------
-
-        kind: str
-            kind of matplotlib plot
+        pandas.Series.rename : Alter Series index labels or name.
+        DataFrame.head : The first `n` rows of the caller object.
         """
         pass
 
-    def method(self, foo=None, bar=None):
+    def redundant_import(self, foo=None, bar=None):
         """
         A sample DataFrame method.
 
-        Do not import numpy and pandas.
-
-        Try to use meaningful data, when it makes the example easier
-        to understand.
-
-        Try to avoid positional arguments like in `df.method(1)`. They
-        can be alright if previously defined with a meaningful name,
-        like in `present_value(interest_rate)`, but avoid them otherwise.
-
-        When presenting the behavior with different parameters, do not place
-        all the calls one next to the other. Instead, add a short sentence
-        explaining what the example shows.
+        Should not import numpy and pandas.
 
         Examples
         --------
@@ -399,362 +47,6 @@ def method(self, foo=None, bar=None):
         """
         pass
 
-    def private_classes(self):
-        """
-        This mentions NDFrame, which is not correct.
-        """
-
-    def unknown_section(self):
-        """
-        This section has an unknown section title.
-
-        Unknown Section
-        ---------------
-        This should raise an error in the validation.
-        """
-
-    def sections_in_wrong_order(self):
-        """
-        This docstring has the sections in the wrong order.
-
-        Parameters
-        ----------
-        name : str
-            This section is in the right position.
-
-        Examples
-        --------
-        >>> print('So far Examples is good, as it goes before Parameters')
-        So far Examples is good, as it goes before Parameters
-
-        See Also
-        --------
-        function : This should generate an error, as See Also needs to go
-            before Examples.
-        """
-
-    def deprecation_in_wrong_order(self):
-        """
-        This docstring has the deprecation warning in the wrong order.
-
-        This is the extended summary. The correct order should be
-        summary, deprecation warning, extended summary.
-
-        .. deprecated:: 1.0
-            This should generate an error as it needs to go before
-            extended summary.
-        """
-
-    def method_wo_docstrings(self):
-        pass
-
-    def directives_without_two_colons(self, first, second):
-        """
-        Ensure reST directives have trailing colons.
-
-        Parameters
-        ----------
-        first : str
-            Sentence ending in period, followed by single directive w/o colons.
-
-            .. versionchanged 0.1.2
-
-        second : bool
-            Sentence ending in period, followed by multiple directives w/o
-            colons.
-
-            .. versionadded 0.1.2
-            .. deprecated 0.00.0
-
-        """
-        pass
-
-
-class BadSummaries:
-    def wrong_line(self):
-        """Exists on the wrong line"""
-        pass
-
-    def no_punctuation(self):
-        """
-        Has the right line but forgets punctuation
-        """
-        pass
-
-    def no_capitalization(self):
-        """
-        provides a lowercase summary.
-        """
-        pass
-
-    def no_infinitive(self):
-        """
-        Started with a verb that is not infinitive.
-        """
-
-    def multi_line(self):
-        """
-        Extends beyond one line
-        which is not correct.
-        """
-
-    def two_paragraph_multi_line(self):
-        """
-        Extends beyond one line
-        which is not correct.
-
-        Extends beyond one line, which in itself is correct but the
-        previous short summary should still be an issue.
-        """
-
-
-class BadParameters:
-    """
-    Everything here has a problem with its Parameters section.
-    """
-
-    def missing_params(self, kind, **kwargs):
-        """
-        Lacks kwargs in Parameters.
-
-        Parameters
-        ----------
-        kind : str
-            Foo bar baz.
-        """
-
-    def bad_colon_spacing(self, kind):
-        """
-        Has bad spacing in the type line.
-
-        Parameters
-        ----------
-        kind: str
-            Needs a space after kind.
-        """
-
-    def no_description_period(self, kind):
-        """
-        Forgets to add a period to the description.
-
-        Parameters
-        ----------
-        kind : str
-           Doesn't end with a dot
-        """
-
-    def no_description_period_with_directive(self, kind):
-        """
-        Forgets to add a period, and also includes a directive.
-
-        Parameters
-        ----------
-        kind : str
-           Doesn't end with a dot
-
-           .. versionadded:: 0.00.0
-        """
-
-    def no_description_period_with_directives(self, kind):
-        """
-        Forgets to add a period, and also includes multiple directives.
-
-        Parameters
-        ----------
-        kind : str
-           Doesn't end with a dot
-
-           .. versionchanged:: 0.00.0
-           .. deprecated:: 0.00.0
-        """
-
-    def parameter_capitalization(self, kind):
-        """
-        Forgets to capitalize the description.
-
-        Parameters
-        ----------
-        kind : str
-           this is not capitalized.
-        """
-
-    def blank_lines(self, kind):
-        """
-        Adds a blank line after the section header.
-
-        Parameters
-        ----------
-
-        kind : str
-            Foo bar baz.
-        """
-        pass
-
-    def integer_parameter(self, kind):
-        """
-        Uses integer instead of int.
-
-        Parameters
-        ----------
-        kind : integer
-            Foo bar baz.
-        """
-        pass
-
-    def string_parameter(self, kind):
-        """
-        Uses string instead of str.
-
-        Parameters
-        ----------
-        kind : string
-            Foo bar baz.
-        """
-        pass
-
-    def boolean_parameter(self, kind):
-        """
-        Uses boolean instead of bool.
-
-        Parameters
-        ----------
-        kind : boolean
-            Foo bar baz.
-        """
-        pass
-
-    def list_incorrect_parameter_type(self, kind):
-        """
-        Uses list of boolean instead of list of bool.
-
-        Parameters
-        ----------
-        kind : list of boolean, integer, float or string
-            Foo bar baz.
-        """
-        pass
-
-
-class BadReturns:
-    def return_not_documented(self):
-        """
-        Lacks section for Returns
-        """
-        return "Hello world!"
-
-    def yield_not_documented(self):
-        """
-        Lacks section for Yields
-        """
-        yield "Hello world!"
-
-    def no_type(self):
-        """
-        Returns documented but without type.
-
-        Returns
-        -------
-        Some value.
-        """
-        return "Hello world!"
-
-    def no_description(self):
-        """
-        Provides type but no descrption.
-
-        Returns
-        -------
-        str
-        """
-        return "Hello world!"
-
-    def no_punctuation(self):
-        """
-        Provides type and description but no period.
-
-        Returns
-        -------
-        str
-           A nice greeting
-        """
-        return "Hello world!"
-
-    def named_single_return(self):
-        """
-        Provides name but returns only one value.
-
-        Returns
-        -------
-        s : str
-           A nice greeting.
-        """
-        return "Hello world!"
-
-    def no_capitalization(self):
-        """
-        Forgets capitalization in return values description.
-
-        Returns
-        -------
-        foo : str
-           The first returned string.
-        bar : str
-           the second returned string.
-        """
-        return "Hello", "World!"
-
-    def no_period_multi(self):
-        """
-        Forgets period in return values description.
-
-        Returns
-        -------
-        foo : str
-           The first returned string
-        bar : str
-           The second returned string.
-        """
-        return "Hello", "World!"
-
-
-class BadSeeAlso:
-    def desc_no_period(self):
-        """
-        Return the first 5 elements of the Series.
-
-        See Also
-        --------
-        Series.tail : Return the last 5 elements of the Series.
-        Series.iloc : Return a slice of the elements in the Series,
-            which can also be used to return the first or last n
-        """
-        pass
-
-    def desc_first_letter_lowercase(self):
-        """
-        Return the first 5 elements of the Series.
-
-        See Also
-        --------
-        Series.tail : return the last 5 elements of the Series.
-        Series.iloc : Return a slice of the elements in the Series,
-            which can also be used to return the first or last n.
-        """
-        pass
-
-    def prefix_pandas(self):
-        """
-        Have `pandas` prefix in See Also section.
-
-        See Also
-        --------
-        pandas.Series.rename : Alter Series index labels or name.
-        DataFrame.head : The first `n` rows of the caller object.
-        """
-        pass
-
-
-class BadExamples:
     def unused_import(self):
         """
         Examples
@@ -818,56 +110,9 @@ def _import_path(self, klass=None, func=None):
 
         return base_path
 
-    def test_good_class(self, capsys):
-        errors = validate_one(self._import_path(klass="GoodDocStrings"))["errors"]
-        assert isinstance(errors, list)
-        assert not errors
-
-    @pytest.mark.parametrize(
-        "func",
-        [
-            "plot",
-            "sample",
-            "random_letters",
-            "sample_values",
-            "head",
-            "head1",
-            "contains",
-            "mode",
-            "good_imports",
-            "no_returns",
-            "empty_returns",
-        ],
-    )
-    def test_good_functions(self, capsys, func):
-        errors = validate_one(self._import_path(klass="GoodDocStrings", func=func))[
-            "errors"
-        ]
-        assert isinstance(errors, list)
-        assert not errors
-
     def test_bad_class(self, capsys):
-        errors = validate_one(self._import_path(klass="BadGenericDocStrings"))["errors"]
-        assert isinstance(errors, list)
-        assert errors
-
-    @pytest.mark.parametrize(
-        "func",
-        [
-            "func",
-            "astype",
-            "astype1",
-            "astype2",
-            "astype3",
-            "plot",
-            "method",
-            "private_classes",
-            "directives_without_two_colons",
-        ],
-    )
-    def test_bad_generic_functions(self, capsys, func):
-        errors = validate_one(
-            self._import_path(klass="BadGenericDocStrings", func=func)  # noqa:F821
+        errors = validate_docstrings.pandas_validate(
+            self._import_path(klass="BadDocstrings")
         )["errors"]
         assert isinstance(errors, list)
         assert errors
@@ -875,9 +120,8 @@ def test_bad_generic_functions(self, capsys, func):
     @pytest.mark.parametrize(
         "klass,func,msgs",
         [
-            # See Also tests
             (
-                "BadGenericDocStrings",
+                "BadDocstrings",
                 "private_classes",
                 (
                     "Private classes (NDFrame) should not be mentioned in public "
@@ -885,195 +129,31 @@ def test_bad_generic_functions(self, capsys, func):
                 ),
             ),
             (
-                "BadGenericDocStrings",
-                "unknown_section",
-                ('Found unknown section "Unknown Section".',),
-            ),
-            (
-                "BadGenericDocStrings",
-                "sections_in_wrong_order",
-                (
-                    "Sections are in the wrong order. Correct order is: Parameters, "
-                    "See Also, Examples",
-                ),
-            ),
-            (
-                "BadGenericDocStrings",
-                "deprecation_in_wrong_order",
-                ("Deprecation warning should precede extended summary",),
-            ),
-            (
-                "BadGenericDocStrings",
-                "directives_without_two_colons",
-                (
-                    "reST directives ['versionchanged', 'versionadded', "
-                    "'deprecated'] must be followed by two colons",
-                ),
-            ),
-            (
-                "BadSeeAlso",
-                "desc_no_period",
-                ('Missing period at end of description for See Also "Series.iloc"',),
-            ),
-            (
-                "BadSeeAlso",
-                "desc_first_letter_lowercase",
-                ('should be capitalized for See Also "Series.tail"',),
-            ),
-            # Summary tests
-            (
-                "BadSummaries",
-                "wrong_line",
-                ("should start in the line immediately after the opening quotes",),
-            ),
-            ("BadSummaries", "no_punctuation", ("Summary does not end with a period",)),
-            (
-                "BadSummaries",
-                "no_capitalization",
-                ("Summary does not start with a capital letter",),
-            ),
-            (
-                "BadSummaries",
-                "no_capitalization",
-                ("Summary must start with infinitive verb",),
-            ),
-            ("BadSummaries", "multi_line", ("Summary should fit in a single line",)),
-            (
-                "BadSummaries",
-                "two_paragraph_multi_line",
-                ("Summary should fit in a single line",),
-            ),
-            # Parameters tests
-            (
-                "BadParameters",
-                "missing_params",
-                ("Parameters {**kwargs} not documented",),
-            ),
-            (
-                "BadParameters",
-                "bad_colon_spacing",
-                (
-                    'Parameter "kind" requires a space before the colon '
-                    "separating the parameter name and type",
-                ),
-            ),
-            (
-                "BadParameters",
-                "no_description_period",
-                ('Parameter "kind" description should finish with "."',),
-            ),
-            (
-                "BadParameters",
-                "no_description_period_with_directive",
-                ('Parameter "kind" description should finish with "."',),
-            ),
-            (
-                "BadParameters",
-                "parameter_capitalization",
-                ('Parameter "kind" description should start with a capital letter',),
-            ),
-            (
-                "BadParameters",
-                "integer_parameter",
-                ('Parameter "kind" type should use "int" instead of "integer"',),
-            ),
-            (
-                "BadParameters",
-                "string_parameter",
-                ('Parameter "kind" type should use "str" instead of "string"',),
-            ),
-            (
-                "BadParameters",
-                "boolean_parameter",
-                ('Parameter "kind" type should use "bool" instead of "boolean"',),
-            ),
-            (
-                "BadParameters",
-                "list_incorrect_parameter_type",
-                ('Parameter "kind" type should use "bool" instead of "boolean"',),
-            ),
-            (
-                "BadParameters",
-                "list_incorrect_parameter_type",
-                ('Parameter "kind" type should use "int" instead of "integer"',),
-            ),
-            (
-                "BadParameters",
-                "list_incorrect_parameter_type",
-                ('Parameter "kind" type should use "str" instead of "string"',),
-            ),
-            pytest.param(
-                "BadParameters",
-                "blank_lines",
-                ("No error yet?",),
-                marks=pytest.mark.xfail,
-            ),
-            # Returns tests
-            ("BadReturns", "return_not_documented", ("No Returns section found",)),
-            ("BadReturns", "yield_not_documented", ("No Yields section found",)),
-            pytest.param("BadReturns", "no_type", ("foo",), marks=pytest.mark.xfail),
-            ("BadReturns", "no_description", ("Return value has no description",)),
-            (
-                "BadReturns",
-                "no_punctuation",
-                ('Return value description should finish with "."',),
-            ),
-            (
-                "BadReturns",
-                "named_single_return",
+                "BadDocstrings",
+                "prefix_pandas",
                 (
-                    "The first line of the Returns section should contain only the "
-                    "type, unless multiple values are being returned",
+                    "pandas.Series.rename in `See Also` section "
+                    "does not need `pandas` prefix",
                 ),
             ),
-            (
-                "BadReturns",
-                "no_capitalization",
-                ("Return value description should start with a capital " "letter",),
-            ),
-            (
-                "BadReturns",
-                "no_period_multi",
-                ('Return value description should finish with "."',),
-            ),
             # Examples tests
             (
-                "BadGenericDocStrings",
-                "method",
+                "BadDocstrings",
+                "redundant_import",
                 ("Do not import numpy, as it is imported automatically",),
             ),
             (
-                "BadGenericDocStrings",
-                "method",
+                "BadDocstrings",
+                "redundant_import",
                 ("Do not import pandas, as it is imported automatically",),
             ),
             (
-                "BadGenericDocStrings",
-                "method_wo_docstrings",
-                ("The object does not have a docstring",),
-            ),
-            # See Also tests
-            (
-                "BadSeeAlso",
-                "prefix_pandas",
-                (
-                    "pandas.Series.rename in `See Also` section "
-                    "does not need `pandas` prefix",
-                ),
-            ),
-            # Examples tests
-            (
-                "BadExamples",
+                "BadDocstrings",
                 "unused_import",
                 ("flake8 error: F401 'pandas as pdf' imported but unused",),
             ),
             (
-                "BadExamples",
-                "indentation_is_not_a_multiple_of_four",
-                ("flake8 error: E111 indentation is not a multiple of four",),
-            ),
-            (
-                "BadExamples",
+                "BadDocstrings",
                 "missing_whitespace_around_arithmetic_operator",
                 (
                     "flake8 error: "
@@ -1081,39 +161,28 @@ def test_bad_generic_functions(self, capsys, func):
                 ),
             ),
             (
-                "BadExamples",
-                "missing_whitespace_after_comma",
-                ("flake8 error: E231 missing whitespace after ',' (3 times)",),
-            ),
-            (
-                "BadGenericDocStrings",
-                "two_linebreaks_between_sections",
-                (
-                    "Double line break found; please use only one blank line to "
-                    "separate sections or paragraphs, and do not leave blank lines "
-                    "at the end of docstrings",
-                ),
+                "BadDocstrings",
+                "indentation_is_not_a_multiple_of_four",
+                ("flake8 error: E111 indentation is not a multiple of four",),
             ),
             (
-                "BadGenericDocStrings",
-                "linebreak_at_end_of_docstring",
-                (
-                    "Double line break found; please use only one blank line to "
-                    "separate sections or paragraphs, and do not leave blank lines "
-                    "at the end of docstrings",
-                ),
+                "BadDocstrings",
+                "missing_whitespace_after_comma",
+                ("flake8 error: E231 missing whitespace after ',' (3 times)",),
             ),
         ],
     )
     def test_bad_docstrings(self, capsys, klass, func, msgs):
-        result = validate_one(self._import_path(klass=klass, func=func))
+        result = validate_docstrings.pandas_validate(
+            self._import_path(klass=klass, func=func)
+        )
         for msg in msgs:
             assert msg in " ".join(err[1] for err in result["errors"])
 
     def test_validate_all_ignore_deprecated(self, monkeypatch):
         monkeypatch.setattr(
             validate_docstrings,
-            "validate_one",
+            "pandas_validate",
             lambda func_name: {
                 "docstring": "docstring1",
                 "errors": [
@@ -1218,50 +287,22 @@ def test_item_subsection(self, idx, subsection):
         assert result[idx][3] == subsection
 
 
-class TestDocstringClass:
-    @pytest.mark.parametrize(
-        "name, expected_obj",
-        [
-            ("pandas.isnull", pd.isnull),
-            ("pandas.DataFrame", pd.DataFrame),
-            ("pandas.Series.sum", pd.Series.sum),
-        ],
-    )
-    def test_resolves_class_name(self, name, expected_obj):
-        d = validate_docstrings.Docstring(name)
-        assert d.obj is expected_obj
-
-    @pytest.mark.parametrize("invalid_name", ["panda", "panda.DataFrame"])
-    def test_raises_for_invalid_module_name(self, invalid_name):
-        msg = 'No module can be imported from "{}"'.format(invalid_name)
-        with pytest.raises(ImportError, match=msg):
-            validate_docstrings.Docstring(invalid_name)
-
-    @pytest.mark.parametrize(
-        "invalid_name", ["pandas.BadClassName", "pandas.Series.bad_method_name"]
-    )
-    def test_raises_for_invalid_attribute_name(self, invalid_name):
-        name_components = invalid_name.split(".")
-        obj_name, invalid_attr_name = name_components[-2], name_components[-1]
-        msg = "'{}' has no attribute '{}'".format(obj_name, invalid_attr_name)
-        with pytest.raises(AttributeError, match=msg):
-            validate_docstrings.Docstring(invalid_name)
-
+class TestPandasDocstringClass:
     @pytest.mark.parametrize(
         "name", ["pandas.Series.str.isdecimal", "pandas.Series.str.islower"]
     )
     def test_encode_content_write_to_file(self, name):
         # GH25466
-        docstr = validate_docstrings.Docstring(name).validate_pep8()
+        docstr = validate_docstrings.PandasDocstring(name).validate_pep8()
         # the list of pep8 errors should be empty
         assert not list(docstr)
 
 
 class TestMainFunction:
-    def test_exit_status_for_validate_one(self, monkeypatch):
+    def test_exit_status_for_main(self, monkeypatch):
         monkeypatch.setattr(
             validate_docstrings,
-            "validate_one",
+            "pandas_validate",
             lambda func_name: {
                 "docstring": "docstring1",
                 "errors": [
@@ -1269,8 +310,7 @@ def test_exit_status_for_validate_one(self, monkeypatch):
                     ("ER02", "err desc"),
                     ("ER03", "err desc"),
                 ],
-                "warnings": [],
-                "examples_errors": "",
+                "examples_errs": "",
             },
         )
         exit_status = validate_docstrings.main(
diff --git a/scripts/validate_docstrings.py b/scripts/validate_docstrings.py
index 401eaf8ff5ed5..d43086756769a 100755
--- a/scripts/validate_docstrings.py
+++ b/scripts/validate_docstrings.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
 Analyze docstrings to detect errors.
 
@@ -14,20 +14,14 @@
     $ ./validate_docstrings.py pandas.DataFrame.head
 """
 import argparse
-import ast
-import collections
 import doctest
-import functools
 import glob
 import importlib
-import inspect
 import json
 import os
-import pydoc
-import re
 import sys
 import tempfile
-import textwrap
+from typing import List, Optional
 
 import flake8.main.application
 
@@ -53,87 +47,15 @@
 import pandas  # noqa: E402 isort:skip
 
 sys.path.insert(1, os.path.join(BASE_PATH, "doc", "sphinxext"))
-from numpydoc.docscrape import NumpyDocString  # noqa: E402 isort:skip
-from pandas.io.formats.printing import pprint_thing  # noqa: E402 isort:skip
+from numpydoc.validate import validate, Docstring  # noqa: E402 isort:skip
 
 
 PRIVATE_CLASSES = ["NDFrame", "IndexOpsMixin"]
-DIRECTIVES = ["versionadded", "versionchanged", "deprecated"]
-DIRECTIVE_PATTERN = re.compile(rf"^\s*\.\. ({'|'.join(DIRECTIVES)})(?!::)", re.I | re.M)
-ALLOWED_SECTIONS = [
-    "Parameters",
-    "Attributes",
-    "Methods",
-    "Returns",
-    "Yields",
-    "Other Parameters",
-    "Raises",
-    "Warns",
-    "See Also",
-    "Notes",
-    "References",
-    "Examples",
-]
 ERROR_MSGS = {
-    "GL01": "Docstring text (summary) should start in the line immediately "
-    "after the opening quotes (not in the same line, or leaving a "
-    "blank line in between)",
-    "GL02": "Closing quotes should be placed in the line after the last text "
-    "in the docstring (do not close the quotes in the same line as "
-    "the text, or leave a blank line between the last text and the "
-    "quotes)",
-    "GL03": "Double line break found; please use only one blank line to "
-    "separate sections or paragraphs, and do not leave blank lines "
-    "at the end of docstrings",
     "GL04": "Private classes ({mentioned_private_classes}) should not be "
     "mentioned in public docstrings",
-    "GL05": 'Tabs found at the start of line "{line_with_tabs}", please use '
-    "whitespace only",
-    "GL06": 'Found unknown section "{section}". Allowed sections are: '
-    "{allowed_sections}",
-    "GL07": "Sections are in the wrong order. Correct order is: " "{correct_sections}",
-    "GL08": "The object does not have a docstring",
-    "GL09": "Deprecation warning should precede extended summary",
-    "GL10": "reST directives {directives} must be followed by two colons",
-    "SS01": "No summary found (a short summary in a single line should be "
-    "present at the beginning of the docstring)",
-    "SS02": "Summary does not start with a capital letter",
-    "SS03": "Summary does not end with a period",
-    "SS04": "Summary contains heading whitespaces",
-    "SS05": "Summary must start with infinitive verb, not third person "
-    '(e.g. use "Generate" instead of "Generates")',
-    "SS06": "Summary should fit in a single line",
-    "ES01": "No extended summary found",
-    "PR01": "Parameters {missing_params} not documented",
-    "PR02": "Unknown parameters {unknown_params}",
-    "PR03": "Wrong parameters order. Actual: {actual_params}. "
-    "Documented: {documented_params}",
-    "PR04": 'Parameter "{param_name}" has no type',
-    "PR05": 'Parameter "{param_name}" type should not finish with "."',
-    "PR06": 'Parameter "{param_name}" type should use "{right_type}" instead '
-    'of "{wrong_type}"',
-    "PR07": 'Parameter "{param_name}" has no description',
-    "PR08": 'Parameter "{param_name}" description should start with a '
-    "capital letter",
-    "PR09": 'Parameter "{param_name}" description should finish with "."',
-    "PR10": 'Parameter "{param_name}" requires a space before the colon '
-    "separating the parameter name and type",
-    "RT01": "No Returns section found",
-    "RT02": "The first line of the Returns section should contain only the "
-    "type, unless multiple values are being returned",
-    "RT03": "Return value has no description",
-    "RT04": "Return value description should start with a capital letter",
-    "RT05": 'Return value description should finish with "."',
-    "YD01": "No Yields section found",
-    "SA01": "See Also section not found",
-    "SA02": "Missing period at end of description for See Also "
-    '"{reference_name}" reference',
-    "SA03": "Description should be capitalized for See Also "
-    '"{reference_name}" reference',
-    "SA04": 'Missing description for See Also "{reference_name}" reference',
     "SA05": "{reference_name} in `See Also` section does not need `pandas` "
     "prefix, use {right_reference} instead.",
-    "EX01": "No examples section found",
     "EX02": "Examples do not pass tests:\n{doctest_log}",
     "EX03": "flake8 error: {error_code} {error_message}{times_happening}",
     "EX04": "Do not import {imported_library}, as it is imported "
@@ -141,29 +63,10 @@
 }
 
 
-def error(code, **kwargs):
+def pandas_error(code, **kwargs):
     """
-    Return a tuple with the error code and the message with variables replaced.
-
-    This is syntactic sugar so instead of:
-    - `('EX02', ERROR_MSGS['EX02'].format(doctest_log=log))`
-
-    We can simply use:
-    - `error('EX02', doctest_log=log)`
-
-    Parameters
-    ----------
-    code : str
-        Error code.
-    **kwargs
-        Values for the variables in the error messages
-
-    Returns
-    -------
-    code : str
-        Error code.
-    message : str
-        Error message with variables replaced.
+    Copy of the numpydoc error function, since ERROR_MSGS can't be updated
+    with our custom errors yet.
     """
     return (code, ERROR_MSGS[code].format(**kwargs))
 
@@ -240,336 +143,7 @@ def get_api_items(api_doc_fd):
         previous_line = line
 
 
-class Docstring:
-    def __init__(self, name):
-        self.name = name
-        obj = self._load_obj(name)
-        self.obj = obj
-        self.code_obj = self._to_original_callable(obj)
-        self.raw_doc = obj.__doc__ or ""
-        self.clean_doc = pydoc.getdoc(obj)
-        self.doc = NumpyDocString(self.clean_doc)
-
-    def __len__(self):
-        return len(self.raw_doc)
-
-    @staticmethod
-    def _load_obj(name):
-        """
-        Import Python object from its name as string.
-
-        Parameters
-        ----------
-        name : str
-            Object name to import (e.g. pandas.Series.str.upper)
-
-        Returns
-        -------
-        object
-            Python object that can be a class, method, function...
-
-        Examples
-        --------
-        >>> Docstring._load_obj('pandas.Series')
-        <class 'pandas.core.series.Series'>
-        """
-        for maxsplit in range(1, name.count(".") + 1):
-            # TODO when py3 only replace by: module, *func_parts = ...
-            func_name_split = name.rsplit(".", maxsplit)
-            module = func_name_split[0]
-            func_parts = func_name_split[1:]
-            try:
-                obj = importlib.import_module(module)
-            except ImportError:
-                pass
-            else:
-                continue
-
-        if "obj" not in locals():
-            raise ImportError("No module can be imported " 'from "{}"'.format(name))
-
-        for part in func_parts:
-            obj = getattr(obj, part)
-        return obj
-
-    @staticmethod
-    def _to_original_callable(obj):
-        """
-        Find the Python object that contains the source code of the object.
-
-        This is useful to find the place in the source code (file and line
-        number) where a docstring is defined. It does not currently work for
-        all cases, but it should help find some (properties...).
-        """
-        while True:
-            if inspect.isfunction(obj) or inspect.isclass(obj):
-                f = inspect.getfile(obj)
-                if f.startswith("<") and f.endswith(">"):
-                    return None
-                return obj
-            if inspect.ismethod(obj):
-                obj = obj.__func__
-            elif isinstance(obj, functools.partial):
-                obj = obj.func
-            elif isinstance(obj, property):
-                obj = obj.fget
-            else:
-                return None
-
-    @property
-    def type(self):
-        return type(self.obj).__name__
-
-    @property
-    def is_function_or_method(self):
-        # TODO(py27): remove ismethod
-        return inspect.isfunction(self.obj) or inspect.ismethod(self.obj)
-
-    @property
-    def source_file_name(self):
-        """
-        File name where the object is implemented (e.g. pandas/core/frame.py).
-        """
-        try:
-            fname = inspect.getsourcefile(self.code_obj)
-        except TypeError:
-            # In some cases the object is something complex like a cython
-            # object that can't be easily introspected. An it's better to
-            # return the source code file of the object as None, than crash
-            pass
-        else:
-            if fname:
-                fname = os.path.relpath(fname, BASE_PATH)
-                return fname
-
-    @property
-    def source_file_def_line(self):
-        """
-        Number of line where the object is defined in its file.
-        """
-        try:
-            return inspect.getsourcelines(self.code_obj)[-1]
-        except (OSError, TypeError):
-            # In some cases the object is something complex like a cython
-            # object that can't be easily introspected. An it's better to
-            # return the line number as None, than crash
-            pass
-
-    @property
-    def github_url(self):
-        url = "https://github.com/pandas-dev/pandas/blob/master/"
-        url += "{}#L{}".format(self.source_file_name, self.source_file_def_line)
-        return url
-
-    @property
-    def start_blank_lines(self):
-        i = None
-        if self.raw_doc:
-            for i, row in enumerate(self.raw_doc.split("\n")):
-                if row.strip():
-                    break
-        return i
-
-    @property
-    def end_blank_lines(self):
-        i = None
-        if self.raw_doc:
-            for i, row in enumerate(reversed(self.raw_doc.split("\n"))):
-                if row.strip():
-                    break
-        return i
-
-    @property
-    def double_blank_lines(self):
-        prev = True
-        for row in self.raw_doc.split("\n"):
-            if not prev and not row.strip():
-                return True
-            prev = row.strip()
-        return False
-
-    @property
-    def section_titles(self):
-        sections = []
-        self.doc._doc.reset()
-        while not self.doc._doc.eof():
-            content = self.doc._read_to_next_section()
-            if (
-                len(content) > 1
-                and len(content[0]) == len(content[1])
-                and set(content[1]) == {"-"}
-            ):
-                sections.append(content[0])
-        return sections
-
-    @property
-    def summary(self):
-        return " ".join(self.doc["Summary"])
-
-    @property
-    def num_summary_lines(self):
-        return len(self.doc["Summary"])
-
-    @property
-    def extended_summary(self):
-        if not self.doc["Extended Summary"] and len(self.doc["Summary"]) > 1:
-            return " ".join(self.doc["Summary"])
-        return " ".join(self.doc["Extended Summary"])
-
-    @property
-    def needs_summary(self):
-        return not (bool(self.summary) and bool(self.extended_summary))
-
-    @property
-    def doc_parameters(self):
-        return collections.OrderedDict(
-            (name, (type_, "".join(desc)))
-            for name, type_, desc in self.doc["Parameters"]
-        )
-
-    @property
-    def signature_parameters(self):
-        if inspect.isclass(self.obj):
-            if hasattr(self.obj, "_accessors") and (
-                self.name.split(".")[-1] in self.obj._accessors
-            ):
-                # accessor classes have a signature but don't want to show this
-                return tuple()
-        try:
-            sig = inspect.getfullargspec(self.obj)
-        except (TypeError, ValueError):
-            # Some objects, mainly in C extensions do not support introspection
-            # of the signature
-            return tuple()
-        params = sig.args
-        if sig.varargs:
-            params.append("*" + sig.varargs)
-        if sig.varkw:
-            params.append("**" + sig.varkw)
-        params = tuple(params)
-        if params and params[0] in ("self", "cls"):
-            return params[1:]
-        return params
-
-    @property
-    def parameter_mismatches(self):
-        errs = []
-        signature_params = self.signature_parameters
-        doc_params = tuple(self.doc_parameters)
-        missing = set(signature_params) - set(doc_params)
-        if missing:
-            errs.append(error("PR01", missing_params=pprint_thing(missing)))
-        extra = set(doc_params) - set(signature_params)
-        if extra:
-            errs.append(error("PR02", unknown_params=pprint_thing(extra)))
-        if (
-            not missing
-            and not extra
-            and signature_params != doc_params
-            and not (not signature_params and not doc_params)
-        ):
-            errs.append(
-                error(
-                    "PR03", actual_params=signature_params, documented_params=doc_params
-                )
-            )
-
-        return errs
-
-    @property
-    def correct_parameters(self):
-        return not bool(self.parameter_mismatches)
-
-    @property
-    def directives_without_two_colons(self):
-        return DIRECTIVE_PATTERN.findall(self.raw_doc)
-
-    def parameter_type(self, param):
-        return self.doc_parameters[param][0]
-
-    def parameter_desc(self, param):
-        desc = self.doc_parameters[param][1]
-        # Find and strip out any sphinx directives
-        for directive in DIRECTIVES:
-            full_directive = ".. {}".format(directive)
-            if full_directive in desc:
-                # Only retain any description before the directive
-                desc = desc[: desc.index(full_directive)]
-        return desc
-
-    @property
-    def see_also(self):
-        result = collections.OrderedDict()
-        for funcs, desc in self.doc["See Also"]:
-            for func, _ in funcs:
-                result[func] = "".join(desc)
-
-        return result
-
-    @property
-    def examples(self):
-        return self.doc["Examples"]
-
-    @property
-    def returns(self):
-        return self.doc["Returns"]
-
-    @property
-    def yields(self):
-        return self.doc["Yields"]
-
-    @property
-    def method_source(self):
-        try:
-            source = inspect.getsource(self.obj)
-        except TypeError:
-            return ""
-        return textwrap.dedent(source)
-
-    @property
-    def method_returns_something(self):
-        """
-        Check if the docstrings method can return something.
-
-        Bare returns, returns valued None and returns from nested functions are
-        disconsidered.
-
-        Returns
-        -------
-        bool
-            Whether the docstrings method can return something.
-        """
-
-        def get_returns_not_on_nested_functions(node):
-            returns = [node] if isinstance(node, ast.Return) else []
-            for child in ast.iter_child_nodes(node):
-                # Ignore nested functions and its subtrees.
-                if not isinstance(child, ast.FunctionDef):
-                    child_returns = get_returns_not_on_nested_functions(child)
-                    returns.extend(child_returns)
-            return returns
-
-        tree = ast.parse(self.method_source).body
-        if tree:
-            returns = get_returns_not_on_nested_functions(tree[0])
-            return_values = [r.value for r in returns]
-            # Replace NameConstant nodes valued None for None.
-            for i, v in enumerate(return_values):
-                if isinstance(v, ast.NameConstant) and v.value is None:
-                    return_values[i] = None
-            return any(return_values)
-        else:
-            return False
-
-    @property
-    def first_line_ends_in_dot(self):
-        if self.doc:
-            return self.doc.split("\n")[0][-1] == "."
-
-    @property
-    def deprecated(self):
-        return ".. deprecated:: " in (self.summary + self.extended_summary)
-
+class PandasDocstring(Docstring):
     @property
     def mentioned_private_classes(self):
         return [klass for klass in PRIVATE_CLASSES if klass in self.raw_doc]
@@ -622,196 +196,50 @@ def validate_pep8(self):
         yield from application.guide.stats.statistics_for("")
 
 
-def get_validation_data(doc):
+def pandas_validate(func_name: str):
     """
-    Validate the docstring.
+    Call the numpydoc validation, and add the errors specific to pandas.
 
     Parameters
     ----------
-    doc : Docstring
-        A Docstring object with the given function name.
+    func_name : str
+        Name of the object of the docstring to validate.
 
     Returns
     -------
-    tuple
-        errors : list of tuple
-            Errors occurred during validation.
-        warnings : list of tuple
-            Warnings occurred during validation.
-        examples_errs : str
-            Examples usage displayed along the error, otherwise empty string.
-
-    Notes
-    -----
-    The errors codes are defined as:
-    - First two characters: Section where the error happens:
-       * GL: Global (no section, like section ordering errors)
-       * SS: Short summary
-       * ES: Extended summary
-       * PR: Parameters
-       * RT: Returns
-       * YD: Yields
-       * RS: Raises
-       * WN: Warns
-       * SA: See Also
-       * NT: Notes
-       * RF: References
-       * EX: Examples
-    - Last two characters: Numeric error code inside the section
-
-    For example, EX02 is the second codified error in the Examples section
-    (which in this case is assigned to examples that do not pass the tests).
-
-    The error codes, their corresponding error messages, and the details on how
-    they are validated, are not documented more than in the source code of this
-    function.
+    dict
+        Information about the docstring and the errors found.
     """
+    doc = PandasDocstring(func_name)
+    result = validate(func_name)
 
-    errs = []
-    wrns = []
-    if not doc.raw_doc:
-        errs.append(error("GL08"))
-        return errs, wrns, ""
-
-    if doc.start_blank_lines != 1:
-        errs.append(error("GL01"))
-    if doc.end_blank_lines != 1:
-        errs.append(error("GL02"))
-    if doc.double_blank_lines:
-        errs.append(error("GL03"))
     mentioned_errs = doc.mentioned_private_classes
     if mentioned_errs:
-        errs.append(error("GL04", mentioned_private_classes=", ".join(mentioned_errs)))
-    for line in doc.raw_doc.splitlines():
-        if re.match("^ *\t", line):
-            errs.append(error("GL05", line_with_tabs=line.lstrip()))
-
-    unexpected_sections = [
-        section for section in doc.section_titles if section not in ALLOWED_SECTIONS
-    ]
-    for section in unexpected_sections:
-        errs.append(
-            error("GL06", section=section, allowed_sections=", ".join(ALLOWED_SECTIONS))
+        result["errors"].append(
+            pandas_error("GL04", mentioned_private_classes=", ".join(mentioned_errs))
         )
 
-    correct_order = [
-        section for section in ALLOWED_SECTIONS if section in doc.section_titles
-    ]
-    if correct_order != doc.section_titles:
-        errs.append(error("GL07", correct_sections=", ".join(correct_order)))
-
-    if doc.deprecated and not doc.extended_summary.startswith(".. deprecated:: "):
-        errs.append(error("GL09"))
-
-    directives_without_two_colons = doc.directives_without_two_colons
-    if directives_without_two_colons:
-        errs.append(error("GL10", directives=directives_without_two_colons))
-
-    if not doc.summary:
-        errs.append(error("SS01"))
-    else:
-        if not doc.summary[0].isupper():
-            errs.append(error("SS02"))
-        if doc.summary[-1] != ".":
-            errs.append(error("SS03"))
-        if doc.summary != doc.summary.lstrip():
-            errs.append(error("SS04"))
-        elif doc.is_function_or_method and doc.summary.split(" ")[0][-1] == "s":
-            errs.append(error("SS05"))
-        if doc.num_summary_lines > 1:
-            errs.append(error("SS06"))
-
-    if not doc.extended_summary:
-        wrns.append(("ES01", "No extended summary found"))
-
-    # PR01: Parameters not documented
-    # PR02: Unknown parameters
-    # PR03: Wrong parameters order
-    errs += doc.parameter_mismatches
-
-    for param in doc.doc_parameters:
-        if not param.startswith("*"):  # Check can ignore var / kwargs
-            if not doc.parameter_type(param):
-                if ":" in param:
-                    errs.append(error("PR10", param_name=param.split(":")[0]))
-                else:
-                    errs.append(error("PR04", param_name=param))
-            else:
-                if doc.parameter_type(param)[-1] == ".":
-                    errs.append(error("PR05", param_name=param))
-                common_type_errors = [
-                    ("integer", "int"),
-                    ("boolean", "bool"),
-                    ("string", "str"),
-                ]
-                for wrong_type, right_type in common_type_errors:
-                    if wrong_type in doc.parameter_type(param):
-                        errs.append(
-                            error(
-                                "PR06",
-                                param_name=param,
-                                right_type=right_type,
-                                wrong_type=wrong_type,
-                            )
-                        )
-        if not doc.parameter_desc(param):
-            errs.append(error("PR07", param_name=param))
-        else:
-            if not doc.parameter_desc(param)[0].isupper():
-                errs.append(error("PR08", param_name=param))
-            if doc.parameter_desc(param)[-1] != ".":
-                errs.append(error("PR09", param_name=param))
-
-    if doc.is_function_or_method:
-        if not doc.returns:
-            if doc.method_returns_something:
-                errs.append(error("RT01"))
-        else:
-            if len(doc.returns) == 1 and doc.returns[0].name:
-                errs.append(error("RT02"))
-            for name_or_type, type_, desc in doc.returns:
-                if not desc:
-                    errs.append(error("RT03"))
-                else:
-                    desc = " ".join(desc)
-                    if not desc[0].isupper():
-                        errs.append(error("RT04"))
-                    if not desc.endswith("."):
-                        errs.append(error("RT05"))
-
-        if not doc.yields and "yield" in doc.method_source:
-            errs.append(error("YD01"))
-
-    if not doc.see_also:
-        wrns.append(error("SA01"))
-    else:
+    if doc.see_also:
         for rel_name, rel_desc in doc.see_also.items():
-            if rel_desc:
-                if not rel_desc.endswith("."):
-                    errs.append(error("SA02", reference_name=rel_name))
-                if not rel_desc[0].isupper():
-                    errs.append(error("SA03", reference_name=rel_name))
-            else:
-                errs.append(error("SA04", reference_name=rel_name))
             if rel_name.startswith("pandas."):
-                errs.append(
-                    error(
+                result["errors"].append(
+                    pandas_error(
                         "SA05",
                         reference_name=rel_name,
                         right_reference=rel_name[len("pandas.") :],
                     )
                 )
 
-    examples_errs = ""
-    if not doc.examples:
-        wrns.append(error("EX01"))
-    else:
-        examples_errs = doc.examples_errors
-        if examples_errs:
-            errs.append(error("EX02", doctest_log=examples_errs))
+    result["examples_errs"] = ""
+    if doc.examples:
+        result["examples_errs"] = doc.examples_errors
+        if result["examples_errs"]:
+            result["errors"].append(
+                pandas_error("EX02", doctest_log=result["examples_errs"])
+            )
         for err in doc.validate_pep8():
-            errs.append(
-                error(
+            result["errors"].append(
+                pandas_error(
                     "EX03",
                     error_code=err.error_code,
                     error_message=err.message,
@@ -823,38 +251,11 @@ def get_validation_data(doc):
         examples_source_code = "".join(doc.examples_source_code)
         for wrong_import in ("numpy", "pandas"):
             if "import {}".format(wrong_import) in examples_source_code:
-                errs.append(error("EX04", imported_library=wrong_import))
-    return errs, wrns, examples_errs
-
-
-def validate_one(func_name):
-    """
-    Validate the docstring for the given func_name
-
-    Parameters
-    ----------
-    func_name : function
-        Function whose docstring will be evaluated (e.g. pandas.read_csv).
+                result["errors"].append(
+                    pandas_error("EX04", imported_library=wrong_import)
+                )
 
-    Returns
-    -------
-    dict
-        A dictionary containing all the information obtained from validating
-        the docstring.
-    """
-    doc = Docstring(func_name)
-    errs, wrns, examples_errs = get_validation_data(doc)
-    return {
-        "type": doc.type,
-        "docstring": doc.clean_doc,
-        "deprecated": doc.deprecated,
-        "file": doc.source_file_name,
-        "file_line": doc.source_file_def_line,
-        "github_link": doc.github_url,
-        "errors": errs,
-        "warnings": wrns,
-        "examples_errors": examples_errs,
-    }
+    return result
 
 
 def validate_all(prefix, ignore_deprecated=False):
@@ -879,16 +280,16 @@ def validate_all(prefix, ignore_deprecated=False):
     result = {}
     seen = {}
 
-    # functions from the API docs
     api_doc_fnames = os.path.join(BASE_PATH, "doc", "source", "reference", "*.rst")
     api_items = []
     for api_doc_fname in glob.glob(api_doc_fnames):
         with open(api_doc_fname) as f:
             api_items += list(get_api_items(f))
+
     for func_name, func_obj, section, subsection in api_items:
         if prefix and not func_name.startswith(prefix):
             continue
-        doc_info = validate_one(func_name)
+        doc_info = pandas_validate(func_name)
         if ignore_deprecated and doc_info["deprecated"]:
             continue
         result[func_name] = doc_info
@@ -906,24 +307,40 @@ def validate_all(prefix, ignore_deprecated=False):
 
         seen[shared_code_key] = func_name
 
-    # functions from introspecting Series and DataFrame
-    api_item_names = set(list(zip(*api_items))[0])
-    for class_ in (pandas.Series, pandas.DataFrame):
-        for member in inspect.getmembers(class_):
-            func_name = "pandas.{}.{}".format(class_.__name__, member[0])
-            if not member[0].startswith("_") and func_name not in api_item_names:
-                if prefix and not func_name.startswith(prefix):
-                    continue
-                doc_info = validate_one(func_name)
-                if ignore_deprecated and doc_info["deprecated"]:
-                    continue
-                result[func_name] = doc_info
-                result[func_name]["in_api"] = False
-
     return result
 
 
-def main(func_name, prefix, errors, output_format, ignore_deprecated):
+def print_validate_all_results(
+    prefix: str,
+    errors: Optional[List[str]],
+    output_format: str,
+    ignore_deprecated: bool,
+):
+    if output_format not in ("default", "json", "actions"):
+        raise ValueError(f'Unknown output_format "{output_format}"')
+
+    result = validate_all(prefix, ignore_deprecated)
+
+    if output_format == "json":
+        sys.stdout.write(json.dumps(result))
+        return 0
+
+    prefix = "##[error]" if output_format == "actions" else ""
+    exit_status = 0
+    for name, res in result.items():
+        for err_code, err_desc in res["errors"]:
+            if errors and err_code not in errors:
+                continue
+            sys.stdout.write(
+                f'{prefix}{res["file"]}:{res["file_line"]}:'
+                f"{err_code}:{name}:{err_desc}\n"
+            )
+            exit_status += 1
+
+    return exit_status
+
+
+def print_validate_one_results(func_name: str):
     def header(title, width=80, char="#"):
         full_line = char * width
         side_len = (width - len(title) - 2) // 2
@@ -932,79 +349,44 @@ def header(title, width=80, char="#"):
             side=char * side_len, title=title, adj=adj
         )
 
-        return "\n{full_line}\n{title_line}\n{full_line}\n\n".format(
-            full_line=full_line, title_line=title_line
-        )
+        return f"\n{full_line}\n{title_line}\n{full_line}\n\n"
 
-    exit_status = 0
-    if func_name is None:
-        result = validate_all(prefix, ignore_deprecated)
-
-        if output_format == "json":
-            output = json.dumps(result)
-        else:
-            if output_format == "default":
-                output_format = "{text}\n"
-            elif output_format == "azure":
-                output_format = (
-                    "##vso[task.logissue type=error;"
-                    "sourcepath={path};"
-                    "linenumber={row};"
-                    "code={code};"
-                    "]{text}\n"
-                )
-            else:
-                raise ValueError('Unknown output_format "{}"'.format(output_format))
-
-            output = ""
-            for name, res in result.items():
-                for err_code, err_desc in res["errors"]:
-                    # The script would be faster if instead of filtering the
-                    # errors after validating them, it didn't validate them
-                    # initially. But that would complicate the code too much
-                    if errors and err_code not in errors:
-                        continue
-                    exit_status += 1
-                    output += output_format.format(
-                        name=name,
-                        path=res["file"],
-                        row=res["file_line"],
-                        code=err_code,
-                        text="{}: {}".format(name, err_desc),
-                    )
+    result = pandas_validate(func_name)
 
-        sys.stdout.write(output)
+    sys.stderr.write(header(f"Docstring ({func_name})"))
+    sys.stderr.write(f"{result['docstring']}\n")
 
-    else:
-        result = validate_one(func_name)
-        sys.stderr.write(header("Docstring ({})".format(func_name)))
-        sys.stderr.write("{}\n".format(result["docstring"]))
-        sys.stderr.write(header("Validation"))
-        if result["errors"]:
-            sys.stderr.write("{} Errors found:\n".format(len(result["errors"])))
-            for err_code, err_desc in result["errors"]:
-                # Failing examples are printed at the end
-                if err_code == "EX02":
-                    sys.stderr.write("\tExamples do not pass tests\n")
-                    continue
-                sys.stderr.write("\t{}\n".format(err_desc))
-        if result["warnings"]:
-            sys.stderr.write("{} Warnings found:\n".format(len(result["warnings"])))
-            for wrn_code, wrn_desc in result["warnings"]:
-                sys.stderr.write("\t{}\n".format(wrn_desc))
-
-        if not result["errors"]:
-            sys.stderr.write('Docstring for "{}" correct. :)\n'.format(func_name))
-
-        if result["examples_errors"]:
-            sys.stderr.write(header("Doctests"))
-            sys.stderr.write(result["examples_errors"])
+    sys.stderr.write(header("Validation"))
+    if result["errors"]:
+        sys.stderr.write(f'{len(result["errors"])} Errors found:\n')
+        for err_code, err_desc in result["errors"]:
+            if err_code == "EX02":  # Failing examples are printed at the end
+                sys.stderr.write("\tExamples do not pass tests\n")
+                continue
+            sys.stderr.write(f"\t{err_desc}\n")
+    elif result["errors"]:
+        sys.stderr.write(f'Docstring for "{func_name}" correct. :)\n')
 
-    return exit_status
+    if result["examples_errs"]:
+        sys.stderr.write(header("Doctests"))
+        sys.stderr.write(result["examples_errs"])
+
+
+def main(func_name, prefix, errors, output_format, ignore_deprecated):
+    """
+    Main entry point. Call the validation for one or for all docstrings.
+    """
+    if func_name is None:
+        return print_validate_all_results(
+            prefix, errors, output_format, ignore_deprecated
+        )
+    else:
+        print_validate_one_results(func_name)
+        return 0
 
 
 if __name__ == "__main__":
-    format_opts = "default", "json", "azure"
+    format_opts = "default", "json", "actions"
     func_help = (
         "function or method to validate (e.g. pandas.DataFrame.head) "
         "if not provided, all docstrings are validated and returned "
@@ -1017,16 +399,16 @@ def header(title, width=80, char="#"):
         default="default",
         choices=format_opts,
         help="format of the output when validating "
-        "multiple docstrings (ignored when validating one)."
-        "It can be {}".format(str(format_opts)[1:-1]),
+        "multiple docstrings (ignored when validating one). "
+        "It can be {str(format_opts)[1:-1]}",
     )
     argparser.add_argument(
         "--prefix",
         default=None,
         help="pattern for the "
         "docstring names, in order to decide which ones "
-        'will be validated. A prefix "pandas.Series.str.'
-        "will make the script validate all the docstrings"
+        'will be validated. A prefix "pandas.Series.str."'
+        "will make the script validate all the docstrings "
         "of methods starting by this pattern. It is "
         "ignored if parameter function is provided",
     )
diff --git a/scripts/validate_string_concatenation.py b/scripts/validate_string_concatenation.py
new file mode 100755
index 0000000000000..fbf3bb5cfccf2
--- /dev/null
+++ b/scripts/validate_string_concatenation.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+GH #30454
+
+Check where there is a string that needs to be concatenated.
+
+This is necessary after black formating,
+where for example black transforms this:
+
+>>> foo = (
+...         "bar "
+...         "baz"
+...     )
+
+into this:
+
+>>> foo = ("bar " "baz")
+
+Black is not considering this as an
+issue (see issue https://github.com/psf/black/issues/1051),
+so we are checking it here.
+"""
+
+import argparse
+import os
+import sys
+import token
+import tokenize
+from typing import Generator, List, Tuple
+
+FILE_EXTENSIONS_TO_CHECK = (".py", ".pyx", ".pyx.ini", ".pxd")
+
+
+def main(source_path: str, output_format: str) -> bool:
+    """
+    Main entry point of the script.
+
+    Parameters
+    ----------
+    source_path : str
+        Source path representing path to a file/directory.
+    output_format : str
+        Output format of the script.
+
+    Returns
+    -------
+    bool
+        True if found any strings that needs to be concatenated.
+
+    Raises
+    ------
+    ValueError
+        If the `source_path` is not pointing to existing file/directory.
+    """
+    if not os.path.exists(source_path):
+        raise ValueError(
+            "Please enter a valid path, pointing to a valid file/directory."
+        )
+
+    is_failed: bool = False
+
+    msg = "String unnecessarily split in two by black. Please merge them manually."
+
+    if os.path.isfile(source_path):
+        for source_path, line_number in strings_to_concatenate(source_path):
+            is_failed = True
+            print(
+                output_format.format(
+                    source_path=source_path, line_number=line_number, msg=msg
+                )
+            )
+
+    for subdir, _, files in os.walk(source_path):
+        for file_name in files:
+            if any(
+                file_name.endswith(extension) for extension in FILE_EXTENSIONS_TO_CHECK
+            ):
+                for source_path, line_number in strings_to_concatenate(
+                    os.path.join(subdir, file_name)
+                ):
+                    is_failed = True
+                    print(
+                        output_format.format(
+                            source_path=source_path, line_number=line_number, msg=msg
+                        )
+                    )
+    return is_failed
+
+
+def strings_to_concatenate(source_path: str) -> Generator[Tuple[str, int], None, None]:
+    """
+    Yielding the strings that needs to be concatenated in a given file.
+
+    Parameters
+    ----------
+    source_path : str
+        File path pointing to a single file.
+
+    Yields
+    ------
+    source_path : str
+        Source file path.
+    line_number : int
+        Line number of unconcatenated string.
+    """
+    with open(source_path, "r") as file_name:
+        tokens: List = list(tokenize.generate_tokens(file_name.readline))
+
+    for current_token, next_token in zip(tokens, tokens[1:]):
+        if current_token[0] == next_token[0] == token.STRING:
+            yield source_path, current_token[2][0]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Validate concatenated strings")
+
+    parser.add_argument(
+        "path", nargs="?", default=".", help="Source path of file/directory to check."
+    )
+    parser.add_argument(
+        "--format",
+        "-f",
+        default="{source_path}:{line_number}:{msg}",
+        help="Output format of the unconcatenated strings.",
+    )
+
+    args = parser.parse_args()
+
+    sys.exit(main(source_path=args.path, output_format=args.format))
diff --git a/setup.cfg b/setup.cfg
index 43dbac15f5cfe..4a900e581c353 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -47,16 +47,8 @@ ignore = E402,  # module level import not at top of file
          E711,  # comparison to none should be 'if cond is none:'
 
 exclude =
-    doc/source/getting_started/basics.rst
     doc/source/development/contributing_docstring.rst
 
-
-[yapf]
-based_on_style = pep8
-split_before_named_assigns = false
-split_penalty_after_opening_bracket = 1000000
-split_penalty_logical_operator = 30
-
 [tool:pytest]
 # sync minversion with setup.cfg & install.rst
 minversion = 4.0.2
@@ -74,12 +66,14 @@ xfail_strict = True
 filterwarnings =
     error:Sparse:FutureWarning
     error:The SparseArray:FutureWarning
+junit_family=xunit2
 
 [coverage:run]
 branch = False
 omit =
      */tests/*
      pandas/_typing.py
+     pandas/_version.py
 plugins = Cython.Coverage
 
 [coverage:report]
@@ -111,12 +105,12 @@ directory = coverage_html_report
 # To be kept consistent with "Import Formatting" section in contributing.rst
 [isort]
 known_pre_libs = pandas._config
-known_pre_core = pandas._libs,pandas.util._*,pandas.compat,pandas.errors
+known_pre_core = pandas._libs,pandas._typing,pandas.util._*,pandas.compat,pandas.errors
 known_dtypes = pandas.core.dtypes
 known_post_core = pandas.tseries,pandas.io,pandas.plotting
 sections = FUTURE,STDLIB,THIRDPARTY,PRE_LIBS,PRE_CORE,DTYPES,FIRSTPARTY,POST_CORE,LOCALFOLDER
 known_first_party = pandas
-known_third_party = _pytest,announce,dateutil,docutils,flake8,git,hypothesis,jinja2,lxml,matplotlib,numpy,numpydoc,pkg_resources,pyarrow,pytest,pytz,requests,scipy,setuptools,sphinx,sqlalchemy,validate_docstrings,yaml
+known_third_party = _pytest,announce,dateutil,docutils,flake8,git,hypothesis,jinja2,lxml,matplotlib,numpy,numpydoc,pkg_resources,pyarrow,pytest,pytz,requests,scipy,setuptools,sphinx,sqlalchemy,validate_docstrings,yaml,odf
 multi_line_output = 3
 include_trailing_comma = True
 force_grid_wrap = 0
@@ -129,6 +123,200 @@ skip = pandas/__init__.py,pandas/core/api.py
 [mypy]
 ignore_missing_imports=True
 no_implicit_optional=True
+check_untyped_defs=True
+strict_equality=True
+
+[mypy-pandas.tests.*]
+check_untyped_defs=False
+
+[mypy-pandas.conftest]
+ignore_errors=True
+
+[mypy-pandas.tests.arithmetic.test_datetime64]
+ignore_errors=True
+
+[mypy-pandas.tests.indexes.datetimes.test_tools]
+ignore_errors=True
 
-[mypy-pandas.conftest,pandas.tests.*]
+[mypy-pandas.tests.scalar.period.test_period]
 ignore_errors=True
+
+[mypy-pandas._testing]
+check_untyped_defs=False
+
+[mypy-pandas._version]
+check_untyped_defs=False
+
+[mypy-pandas.core.arrays.categorical]
+check_untyped_defs=False
+
+[mypy-pandas.core.arrays.interval]
+check_untyped_defs=False
+
+[mypy-pandas.core.arrays.sparse.array]
+check_untyped_defs=False
+
+[mypy-pandas.core.base]
+check_untyped_defs=False
+
+[mypy-pandas.core.computation.expr]
+check_untyped_defs=False
+
+[mypy-pandas.core.computation.expressions]
+check_untyped_defs=False
+
+[mypy-pandas.core.computation.pytables]
+check_untyped_defs=False
+
+[mypy-pandas.core.computation.scope]
+check_untyped_defs=False
+
+[mypy-pandas.core.dtypes.cast]
+check_untyped_defs=False
+
+[mypy-pandas.core.frame]
+check_untyped_defs=False
+
+[mypy-pandas.core.generic]
+check_untyped_defs=False
+
+[mypy-pandas.core.groupby.generic]
+check_untyped_defs=False
+
+[mypy-pandas.core.groupby.grouper]
+check_untyped_defs=False
+
+[mypy-pandas.core.groupby.ops]
+check_untyped_defs=False
+
+[mypy-pandas.core.indexes.base]
+check_untyped_defs=False
+
+[mypy-pandas.core.indexes.datetimes]
+check_untyped_defs=False
+
+[mypy-pandas.core.indexes.interval]
+check_untyped_defs=False
+
+[mypy-pandas.core.indexes.multi]
+check_untyped_defs=False
+
+[mypy-pandas.core.indexing]
+check_untyped_defs=False
+
+[mypy-pandas.core.internals.blocks]
+check_untyped_defs=False
+
+[mypy-pandas.core.internals.concat]
+check_untyped_defs=False
+
+[mypy-pandas.core.internals.construction]
+check_untyped_defs=False
+
+[mypy-pandas.core.internals.managers]
+check_untyped_defs=False
+
+[mypy-pandas.core.missing]
+check_untyped_defs=False
+
+[mypy-pandas.core.nanops]
+check_untyped_defs=False
+
+[mypy-pandas.core.ops.docstrings]
+check_untyped_defs=False
+
+[mypy-pandas.core.resample]
+check_untyped_defs=False
+
+[mypy-pandas.core.reshape.merge]
+check_untyped_defs=False
+
+[mypy-pandas.core.strings]
+check_untyped_defs=False
+
+[mypy-pandas.core.tools.datetimes]
+check_untyped_defs=False
+
+[mypy-pandas.core.window.common]
+check_untyped_defs=False
+
+[mypy-pandas.core.window.ewm]
+check_untyped_defs=False
+
+[mypy-pandas.core.window.expanding]
+check_untyped_defs=False
+
+[mypy-pandas.core.window.rolling]
+check_untyped_defs=False
+
+[mypy-pandas.io.clipboard]
+check_untyped_defs=False
+
+[mypy-pandas.io.excel._base]
+check_untyped_defs=False
+
+[mypy-pandas.io.excel._openpyxl]
+check_untyped_defs=False
+
+[mypy-pandas.io.excel._util]
+check_untyped_defs=False
+
+[mypy-pandas.io.excel._xlwt]
+check_untyped_defs=False
+
+[mypy-pandas.io.formats.console]
+check_untyped_defs=False
+
+[mypy-pandas.io.formats.css]
+check_untyped_defs=False
+
+[mypy-pandas.io.formats.excel]
+check_untyped_defs=False
+
+[mypy-pandas.io.formats.format]
+check_untyped_defs=False
+
+[mypy-pandas.io.formats.style]
+check_untyped_defs=False
+
+[mypy-pandas.io.html]
+check_untyped_defs=False
+
+[mypy-pandas.io.json._json]
+check_untyped_defs=False
+
+[mypy-pandas.io.json._table_schema]
+check_untyped_defs=False
+
+[mypy-pandas.io.parsers]
+check_untyped_defs=False
+
+[mypy-pandas.io.pytables]
+check_untyped_defs=False
+
+[mypy-pandas.io.sas.sas_xport]
+check_untyped_defs=False
+
+[mypy-pandas.io.sas.sas7bdat]
+check_untyped_defs=False
+
+[mypy-pandas.io.sas.sasreader]
+check_untyped_defs=False
+
+[mypy-pandas.io.stata]
+check_untyped_defs=False
+
+[mypy-pandas.plotting._matplotlib.converter]
+check_untyped_defs=False
+
+[mypy-pandas.plotting._matplotlib.core]
+check_untyped_defs=False
+
+[mypy-pandas.plotting._matplotlib.misc]
+check_untyped_defs=False
+
+[mypy-pandas.tseries.holiday]
+check_untyped_defs=False
+
+[mypy-pandas.tseries.offsets]
+check_untyped_defs=False
diff --git a/setup.py b/setup.py
index 493254e5329bf..2d49d7e1e85f2 100755
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 """
 Parts of this file were taken from the pyzmq project
@@ -6,8 +6,10 @@
 BSD license. Parts are from lxml (https://github.com/lxml/lxml)
 """
 
+import argparse
 from distutils.sysconfig import get_config_vars
 from distutils.version import LooseVersion
+import multiprocessing
 import os
 from os.path import join as pjoin
 import platform
@@ -34,61 +36,37 @@ def is_platform_mac():
 min_numpy_ver = "1.13.3"
 min_cython_ver = "0.29.13"  # note: sync with pyproject.toml
 
-setuptools_kwargs = {
-    "install_requires": [
-        "python-dateutil >= 2.6.1",
-        "pytz >= 2017.2",
-        "numpy >= {numpy_ver}".format(numpy_ver=min_numpy_ver),
-    ],
-    "setup_requires": ["numpy >= {numpy_ver}".format(numpy_ver=min_numpy_ver)],
-    "zip_safe": False,
-}
-
-
 try:
     import Cython
 
-    ver = Cython.__version__
+    _CYTHON_VERSION = Cython.__version__
     from Cython.Build import cythonize
 
-    _CYTHON_INSTALLED = ver >= LooseVersion(min_cython_ver)
+    _CYTHON_INSTALLED = _CYTHON_VERSION >= LooseVersion(min_cython_ver)
 except ImportError:
+    _CYTHON_VERSION = None
     _CYTHON_INSTALLED = False
     cythonize = lambda x, *args, **kwargs: x  # dummy func
 
 # The import of Extension must be after the import of Cython, otherwise
 # we do not get the appropriately patched class.
-# See https://cython.readthedocs.io/en/latest/src/reference/compilation.html
+# See https://cython.readthedocs.io/en/latest/src/userguide/source_files_and_compilation.html # noqa
 from distutils.extension import Extension  # noqa: E402 isort:skip
 from distutils.command.build import build  # noqa: E402 isort:skip
 
-try:
-    if not _CYTHON_INSTALLED:
-        raise ImportError("No supported version of Cython installed.")
+if _CYTHON_INSTALLED:
     from Cython.Distutils.old_build_ext import old_build_ext as _build_ext
 
     cython = True
-except ImportError:
+    from Cython import Tempita as tempita
+else:
     from distutils.command.build_ext import build_ext as _build_ext
 
     cython = False
-else:
-    try:
-        try:
-            from Cython import Tempita as tempita
-        except ImportError:
-            import tempita
-    except ImportError:
-        raise ImportError("Building pandas requires Tempita: " "pip install Tempita")
 
 
 _pxi_dep_template = {
-    "algos": [
-        "_libs/algos_common_helper.pxi.in",
-        "_libs/algos_take_helper.pxi.in",
-        "_libs/algos_rank_helper.pxi.in",
-    ],
-    "groupby": ["_libs/groupby_helper.pxi.in"],
+    "algos": ["_libs/algos_common_helper.pxi.in", "_libs/algos_take_helper.pxi.in"],
     "hashtable": [
         "_libs/hashtable_class_helper.pxi.in",
         "_libs/hashtable_func_helper.pxi.in",
@@ -134,17 +112,10 @@ def build_extensions(self):
         if cython:
             self.render_templates(_pxifiles)
 
-        numpy_incl = pkg_resources.resource_filename("numpy", "core/include")
-
-        for ext in self.extensions:
-            if hasattr(ext, "include_dirs") and numpy_incl not in ext.include_dirs:
-                ext.include_dirs.append(numpy_incl)
-        _build_ext.build_extensions(self)
+        super().build_extensions()
 
 
-DESCRIPTION = (
-    "Powerful data structures for data analysis, time series, " "and statistics"
-)
+DESCRIPTION = "Powerful data structures for data analysis, time series, and statistics"
 LONG_DESCRIPTION = """
 **pandas** is a Python package providing fast, flexible, and expressive data
 structures designed to make working with structured (tabular, multidimensional,
@@ -169,7 +140,7 @@ def build_extensions(self):
 (2-dimensional), handle the vast majority of typical use cases in finance,
 statistics, social science, and many areas of engineering. For R users,
 DataFrame provides everything that R's ``data.frame`` provides and much
-more. pandas is built on top of `NumPy <http://www.numpy.org>`__ and is
+more. pandas is built on top of `NumPy <https://www.numpy.org>`__ and is
 intended to integrate well within a scientific computing environment with many
 other 3rd party libraries.
 
@@ -198,8 +169,7 @@ def build_extensions(self):
     Excel files, databases, and saving / loading data from the ultrafast **HDF5
     format**
   - **Time series**-specific functionality: date range generation and frequency
-    conversion, moving window statistics, moving window linear regressions,
-    date shifting and lagging, etc.
+    conversion, moving window statistics, date shifting and lagging.
 
 Many of these principles are here to address the shortcomings frequently
 experienced using other languages / scientific research environments. For data
@@ -213,11 +183,11 @@ def build_extensions(self):
 LICENSE = "BSD"
 AUTHOR = "The PyData Development Team"
 EMAIL = "pydata@googlegroups.com"
-URL = "http://pandas.pydata.org"
+URL = "https://pandas.pydata.org"
 DOWNLOAD_URL = ""
 PROJECT_URLS = {
     "Bug Tracker": "https://github.com/pandas-dev/pandas/issues",
-    "Documentation": "http://pandas.pydata.org/pandas-docs/stable/",
+    "Documentation": "https://pandas.pydata.org/pandas-docs/stable/",
     "Source Code": "https://github.com/pandas-dev/pandas",
 }
 CLASSIFIERS = [
@@ -227,9 +197,9 @@ def build_extensions(self):
     "Intended Audience :: Science/Research",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.5",
     "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
     "Programming Language :: Cython",
     "Topic :: Scientific/Engineering",
 ]
@@ -260,6 +230,7 @@ def initialize_options(self):
             pjoin(ujson_python, "ujson.c"),
             pjoin(ujson_python, "objToJSON.c"),
             pjoin(ujson_python, "JSONtoObj.c"),
+            pjoin(ujson_python, "date_conversions.c"),
             pjoin(ujson_lib, "ultrajsonenc.c"),
             pjoin(ujson_lib, "ultrajsondec.c"),
             pjoin(util, "move.c"),
@@ -333,7 +304,6 @@ class CheckSDist(sdist_class):
         "pandas/_libs/missing.pyx",
         "pandas/_libs/reduction.pyx",
         "pandas/_libs/testing.pyx",
-        "pandas/_libs/skiplist.pyx",
         "pandas/_libs/sparse.pyx",
         "pandas/_libs/ops.pyx",
         "pandas/_libs/parsers.pyx",
@@ -352,14 +322,13 @@ class CheckSDist(sdist_class):
         "pandas/_libs/tslibs/resolution.pyx",
         "pandas/_libs/tslibs/parsing.pyx",
         "pandas/_libs/tslibs/tzconversion.pyx",
+        "pandas/_libs/window/indexers.pyx",
         "pandas/_libs/writers.pyx",
         "pandas/io/sas/sas.pyx",
     ]
 
     _cpp_pyxfiles = [
-        "pandas/_libs/window.pyx",
-        "pandas/io/msgpack/_packer.pyx",
-        "pandas/io/msgpack/_unpacker.pyx",
+        "pandas/_libs/window/aggregations.pyx",
     ]
 
     def initialize_options(self):
@@ -377,10 +346,8 @@ def run(self):
                 for pyxfile in pyxfiles:
                     sourcefile = pyxfile[:-3] + extension
                     msg = (
-                        "{extension}-source file '{source}' not found.\n"
-                        "Run 'setup.py cython' before sdist.".format(
-                            source=sourcefile, extension=extension
-                        )
+                        f"{extension}-source file '{sourcefile}' not found.\n"
+                        "Run 'setup.py cython' before sdist."
                     )
                     assert os.path.isfile(sourcefile), msg
         sdist_class.run(self)
@@ -395,14 +362,12 @@ def check_cython_extensions(self, extensions):
         for ext in extensions:
             for src in ext.sources:
                 if not os.path.exists(src):
-                    print("{}: -> [{}]".format(ext.name, ext.sources))
+                    print(f"{ext.name}: -> [{ext.sources}]")
                     raise Exception(
-                        """Cython-generated file '{src}' not found.
+                        f"""Cython-generated file '{src}' not found.
                 Cython is required to compile pandas from a development branch.
                 Please install Cython or download a release package of pandas.
-                """.format(
-                            src=src
-                        )
+                """
                     )
 
     def build_extensions(self):
@@ -438,15 +403,14 @@ def run(self):
 
 
 cmdclass.update({"clean": CleanCommand, "build": build})
+cmdclass["build_ext"] = CheckingBuildExt
 
 if cython:
     suffix = ".pyx"
-    cmdclass["build_ext"] = CheckingBuildExt
     cmdclass["cython"] = CythonCommand
 else:
     suffix = ".c"
     cmdclass["build_src"] = DummyBuildSrc
-    cmdclass["build_ext"] = CheckingBuildExt
 
 # ----------------------------------------------------------------------
 # Preparation of compiler arguments
@@ -470,7 +434,7 @@ def run(self):
         extra_link_args.append("/DEBUG")
 else:
     # args to ignore warnings
-    extra_compile_args = ["-Wno-unused-function"]
+    extra_compile_args = []
     extra_link_args = []
     if debugging_symbols_requested:
         extra_compile_args.append("-g")
@@ -522,14 +486,23 @@ def run(self):
 # re-compile.
 def maybe_cythonize(extensions, *args, **kwargs):
     """
-    Render tempita templates before calling cythonize
+    Render tempita templates before calling cythonize. This is skipped for
+
+    * clean
+    * sdist
     """
-    if len(sys.argv) > 1 and "clean" in sys.argv:
-        # Avoid running cythonize on `python setup.py clean`
+    if "clean" in sys.argv or "sdist" in sys.argv:
         # See https://github.com/cython/cython/issues/1495
         return extensions
-    elif "sdist" in sys.argv:
-        return extensions
+
+    elif not cython:
+        # GH#28836 raise a helfpul error message
+        if _CYTHON_VERSION:
+            raise RuntimeError(
+                f"Cannot cythonize with old Cython version ({_CYTHON_VERSION} "
+                f"installed, needs {min_cython_ver})"
+            )
+        raise RuntimeError("Cannot cythonize without Cython installed.")
 
     numpy_incl = pkg_resources.resource_filename("numpy", "core/include")
     # TODO: Is this really necessary here?
@@ -537,6 +510,19 @@ def maybe_cythonize(extensions, *args, **kwargs):
         if hasattr(ext, "include_dirs") and numpy_incl not in ext.include_dirs:
             ext.include_dirs.append(numpy_incl)
 
+    # reuse any parallel arguments provided for compilation to cythonize
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-j", type=int)
+    parser.add_argument("--parallel", type=int)
+    parsed, _ = parser.parse_known_args()
+
+    nthreads = 0
+    if parsed.parallel:
+        nthreads = parsed.parallel
+    elif parsed.j:
+        nthreads = parsed.j
+
+    kwargs["nthreads"] = nthreads
     build_ext.render_templates(_pxifiles)
     return cythonize(extensions, *args, **kwargs)
 
@@ -545,55 +531,51 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     return pjoin("pandas", subdir, name + suffix)
 
 
-common_include = ["pandas/_libs/src/klib", "pandas/_libs/src"]
-ts_include = ["pandas/_libs/tslibs/src", "pandas/_libs/tslibs"]
+lib_depends = ["pandas/_libs/src/parse_helper.h"]
 
+klib_include = ["pandas/_libs/src/klib"]
 
-lib_depends = ["pandas/_libs/src/parse_helper.h", "pandas/_libs/src/compat_helper.h"]
-
-np_datetime_headers = [
+tseries_depends = [
     "pandas/_libs/tslibs/src/datetime/np_datetime.h",
     "pandas/_libs/tslibs/src/datetime/np_datetime_strings.h",
 ]
-np_datetime_sources = [
-    "pandas/_libs/tslibs/src/datetime/np_datetime.c",
-    "pandas/_libs/tslibs/src/datetime/np_datetime_strings.c",
-]
-
-tseries_depends = np_datetime_headers
-
 
 ext_data = {
-    "_libs.algos": {"pyxfile": "_libs/algos", "depends": _pxi_dep["algos"]},
-    "_libs.groupby": {"pyxfile": "_libs/groupby", "depends": _pxi_dep["groupby"]},
-    "_libs.hashing": {"pyxfile": "_libs/hashing", "include": [], "depends": []},
+    "_libs.algos": {
+        "pyxfile": "_libs/algos",
+        "include": klib_include,
+        "depends": _pxi_dep["algos"],
+    },
+    "_libs.groupby": {"pyxfile": "_libs/groupby"},
+    "_libs.hashing": {"pyxfile": "_libs/hashing", "depends": []},
     "_libs.hashtable": {
         "pyxfile": "_libs/hashtable",
+        "include": klib_include,
         "depends": (["pandas/_libs/src/klib/khash_python.h"] + _pxi_dep["hashtable"]),
     },
     "_libs.index": {
         "pyxfile": "_libs/index",
-        "include": common_include + ts_include,
+        "include": klib_include,
         "depends": _pxi_dep["index"],
-        "sources": np_datetime_sources,
     },
     "_libs.indexing": {"pyxfile": "_libs/indexing"},
     "_libs.internals": {"pyxfile": "_libs/internals"},
-    "_libs.interval": {"pyxfile": "_libs/interval", "depends": _pxi_dep["interval"]},
-    "_libs.join": {"pyxfile": "_libs/join"},
+    "_libs.interval": {
+        "pyxfile": "_libs/interval",
+        "include": klib_include,
+        "depends": _pxi_dep["interval"],
+    },
+    "_libs.join": {"pyxfile": "_libs/join", "include": klib_include},
     "_libs.lib": {
         "pyxfile": "_libs/lib",
-        "include": common_include + ts_include,
         "depends": lib_depends + tseries_depends,
+        "include": klib_include,  # due to tokenizer import
         "sources": ["pandas/_libs/src/parser/tokenizer.c"],
     },
-    "_libs.missing": {
-        "pyxfile": "_libs/missing",
-        "include": common_include + ts_include,
-        "depends": tseries_depends,
-    },
+    "_libs.missing": {"pyxfile": "_libs/missing", "depends": tseries_depends},
     "_libs.parsers": {
         "pyxfile": "_libs/parsers",
+        "include": klib_include + ["pandas/_libs/src"],
         "depends": [
             "pandas/_libs/src/parser/tokenizer.h",
             "pandas/_libs/src/parser/io.h",
@@ -605,123 +587,81 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
     },
     "_libs.reduction": {"pyxfile": "_libs/reduction"},
     "_libs.ops": {"pyxfile": "_libs/ops"},
-    "_libs.properties": {"pyxfile": "_libs/properties", "include": []},
+    "_libs.ops_dispatch": {"pyxfile": "_libs/ops_dispatch"},
+    "_libs.properties": {"pyxfile": "_libs/properties"},
     "_libs.reshape": {"pyxfile": "_libs/reshape", "depends": []},
-    "_libs.skiplist": {
-        "pyxfile": "_libs/skiplist",
-        "depends": ["pandas/_libs/src/skiplist.h"],
-    },
     "_libs.sparse": {"pyxfile": "_libs/sparse", "depends": _pxi_dep["sparse"]},
-    "_libs.tslib": {
-        "pyxfile": "_libs/tslib",
-        "include": ts_include,
-        "depends": tseries_depends,
-        "sources": np_datetime_sources,
-    },
+    "_libs.tslib": {"pyxfile": "_libs/tslib", "depends": tseries_depends},
     "_libs.tslibs.c_timestamp": {
         "pyxfile": "_libs/tslibs/c_timestamp",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
-    "_libs.tslibs.ccalendar": {"pyxfile": "_libs/tslibs/ccalendar", "include": []},
+    "_libs.tslibs.ccalendar": {"pyxfile": "_libs/tslibs/ccalendar"},
     "_libs.tslibs.conversion": {
         "pyxfile": "_libs/tslibs/conversion",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.fields": {
         "pyxfile": "_libs/tslibs/fields",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
-    "_libs.tslibs.frequencies": {"pyxfile": "_libs/tslibs/frequencies", "include": []},
-    "_libs.tslibs.nattype": {"pyxfile": "_libs/tslibs/nattype", "include": []},
+    "_libs.tslibs.frequencies": {"pyxfile": "_libs/tslibs/frequencies"},
+    "_libs.tslibs.nattype": {"pyxfile": "_libs/tslibs/nattype"},
     "_libs.tslibs.np_datetime": {
         "pyxfile": "_libs/tslibs/np_datetime",
-        "include": ts_include,
-        "depends": np_datetime_headers,
-        "sources": np_datetime_sources,
+        "depends": tseries_depends,
+        "sources": [
+            "pandas/_libs/tslibs/src/datetime/np_datetime.c",
+            "pandas/_libs/tslibs/src/datetime/np_datetime_strings.c",
+        ],
     },
     "_libs.tslibs.offsets": {
         "pyxfile": "_libs/tslibs/offsets",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
     "_libs.tslibs.parsing": {
         "pyxfile": "_libs/tslibs/parsing",
+        "include": klib_include,
         "depends": ["pandas/_libs/src/parser/tokenizer.h"],
         "sources": ["pandas/_libs/src/parser/tokenizer.c"],
     },
     "_libs.tslibs.period": {
         "pyxfile": "_libs/tslibs/period",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
+        "sources": ["pandas/_libs/tslibs/src/datetime/np_datetime.c"],
     },
     "_libs.tslibs.resolution": {
         "pyxfile": "_libs/tslibs/resolution",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
     "_libs.tslibs.strptime": {
         "pyxfile": "_libs/tslibs/strptime",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
     "_libs.tslibs.timedeltas": {
         "pyxfile": "_libs/tslibs/timedeltas",
-        "include": ts_include,
-        "depends": np_datetime_headers,
-        "sources": np_datetime_sources,
+        "depends": tseries_depends,
     },
     "_libs.tslibs.timestamps": {
         "pyxfile": "_libs/tslibs/timestamps",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
-    "_libs.tslibs.timezones": {"pyxfile": "_libs/tslibs/timezones", "include": []},
+    "_libs.tslibs.timezones": {"pyxfile": "_libs/tslibs/timezones"},
     "_libs.tslibs.tzconversion": {
         "pyxfile": "_libs/tslibs/tzconversion",
-        "include": ts_include,
         "depends": tseries_depends,
-        "sources": np_datetime_sources,
     },
     "_libs.testing": {"pyxfile": "_libs/testing"},
-    "_libs.window": {"pyxfile": "_libs/window", "language": "c++", "suffix": ".cpp"},
-    "_libs.writers": {"pyxfile": "_libs/writers"},
-    "io.sas._sas": {"pyxfile": "io/sas/sas"},
-    "io.msgpack._packer": {
-        "macros": endian_macro + macros,
-        "depends": [
-            "pandas/_libs/src/msgpack/pack.h",
-            "pandas/_libs/src/msgpack/pack_template.h",
-        ],
-        "include": ["pandas/_libs/src/msgpack"] + common_include,
+    "_libs.window.aggregations": {
+        "pyxfile": "_libs/window/aggregations",
         "language": "c++",
         "suffix": ".cpp",
-        "pyxfile": "io/msgpack/_packer",
-        "subdir": "io/msgpack",
-    },
-    "io.msgpack._unpacker": {
-        "depends": [
-            "pandas/_libs/src/msgpack/unpack.h",
-            "pandas/_libs/src/msgpack/unpack_define.h",
-            "pandas/_libs/src/msgpack/unpack_template.h",
-        ],
-        "macros": endian_macro + macros,
-        "include": ["pandas/_libs/src/msgpack"] + common_include,
-        "language": "c++",
-        "suffix": ".cpp",
-        "pyxfile": "io/msgpack/_unpacker",
-        "subdir": "io/msgpack",
+        "depends": ["pandas/_libs/src/skiplist.h"],
     },
+    "_libs.window.indexers": {"pyxfile": "_libs/window/indexers"},
+    "_libs.writers": {"pyxfile": "_libs/writers"},
+    "io.sas._sas": {"pyxfile": "io/sas/sas"},
 }
 
 extensions = []
@@ -733,10 +673,10 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
 
     sources.extend(data.get("sources", []))
 
-    include = data.get("include", common_include)
+    include = data.get("include")
 
     obj = Extension(
-        "pandas.{name}".format(name=name),
+        f"pandas.{name}",
         sources=sources,
         depends=data.get("depends", []),
         include_dirs=include,
@@ -760,16 +700,23 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
 
 ujson_ext = Extension(
     "pandas._libs.json",
-    depends=["pandas/_libs/src/ujson/lib/ultrajson.h"],
+    depends=[
+        "pandas/_libs/src/ujson/lib/ultrajson.h",
+        "pandas/_libs/src/ujson/python/date_conversions.h",
+    ],
     sources=(
         [
             "pandas/_libs/src/ujson/python/ujson.c",
             "pandas/_libs/src/ujson/python/objToJSON.c",
+            "pandas/_libs/src/ujson/python/date_conversions.c",
             "pandas/_libs/src/ujson/python/JSONtoObj.c",
             "pandas/_libs/src/ujson/lib/ultrajsonenc.c",
             "pandas/_libs/src/ujson/lib/ultrajsondec.c",
         ]
-        + np_datetime_sources
+        + [
+            "pandas/_libs/tslibs/src/datetime/np_datetime.c",
+            "pandas/_libs/tslibs/src/datetime/np_datetime_strings.c",
+        ]
     ),
     include_dirs=[
         "pandas/_libs/src/ujson/python",
@@ -785,52 +732,53 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
 extensions.append(ujson_ext)
 
 # ----------------------------------------------------------------------
-# util
-# extension for pseudo-safely moving bytes into mutable buffers
-_move_ext = Extension(
-    "pandas.util._move",
-    depends=[],
-    sources=["pandas/util/move.c"],
-    define_macros=macros,
-    extra_compile_args=extra_compile_args,
-    extra_link_args=extra_link_args,
-)
-extensions.append(_move_ext)
 
-# ----------------------------------------------------------------------
 
+def setup_package():
+    setuptools_kwargs = {
+        "install_requires": [
+            "python-dateutil >= 2.6.1",
+            "pytz >= 2017.2",
+            f"numpy >= {min_numpy_ver}",
+        ],
+        "setup_requires": [f"numpy >= {min_numpy_ver}"],
+        "zip_safe": False,
+    }
+
+    setup(
+        name=DISTNAME,
+        maintainer=AUTHOR,
+        version=versioneer.get_version(),
+        packages=find_packages(include=["pandas", "pandas.*"]),
+        package_data={"": ["templates/*", "_libs/*.dll"]},
+        ext_modules=maybe_cythonize(extensions, compiler_directives=directives),
+        maintainer_email=EMAIL,
+        description=DESCRIPTION,
+        license=LICENSE,
+        cmdclass=cmdclass,
+        url=URL,
+        download_url=DOWNLOAD_URL,
+        project_urls=PROJECT_URLS,
+        long_description=LONG_DESCRIPTION,
+        classifiers=CLASSIFIERS,
+        platforms="any",
+        python_requires=">=3.6.1",
+        extras_require={
+            "test": [
+                # sync with setup.cfg minversion & install.rst
+                "pytest>=4.0.2",
+                "pytest-xdist",
+                "hypothesis>=3.58",
+            ]
+        },
+        entry_points={
+            "pandas_plotting_backends": ["matplotlib = pandas:plotting._matplotlib"]
+        },
+        **setuptools_kwargs,
+    )
 
-# The build cache system does string matching below this point.
-# if you change something, be careful.
-
-setup(
-    name=DISTNAME,
-    maintainer=AUTHOR,
-    version=versioneer.get_version(),
-    packages=find_packages(include=["pandas", "pandas.*"]),
-    package_data={"": ["templates/*", "_libs/*.dll"]},
-    ext_modules=maybe_cythonize(extensions, compiler_directives=directives),
-    maintainer_email=EMAIL,
-    description=DESCRIPTION,
-    license=LICENSE,
-    cmdclass=cmdclass,
-    url=URL,
-    download_url=DOWNLOAD_URL,
-    project_urls=PROJECT_URLS,
-    long_description=LONG_DESCRIPTION,
-    classifiers=CLASSIFIERS,
-    platforms="any",
-    python_requires=">=3.5.3",
-    extras_require={
-        "test": [
-            # sync with setup.cfg minversion & install.rst
-            "pytest>=4.0.2",
-            "pytest-xdist",
-            "hypothesis>=3.58",
-        ]
-    },
-    entry_points={
-        "pandas_plotting_backends": ["matplotlib = pandas:plotting._matplotlib"]
-    },
-    **setuptools_kwargs
-)
+
+if __name__ == "__main__":
+    # Freeze to support parallel compilation when using spawn instead of fork
+    multiprocessing.freeze_support()
+    setup_package()
diff --git a/versioneer.py b/versioneer.py
index 24d8105c307c0..5882349f65f0b 100644
--- a/versioneer.py
+++ b/versioneer.py
@@ -8,7 +8,6 @@
 * https://github.com/warner/python-versioneer
 * Brian Warner
 * License: Public Domain
-* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, and pypy
 * [![Latest Version]
 (https://pypip.in/version/versioneer/badge.svg?style=flat)
 ](https://pypi.org/project/versioneer/)
@@ -464,9 +463,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):
         if verbose:
             print("unable to find command, tried %s" % (commands,))
         return None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
+
+    stdout = p.communicate()[0].strip().decode()
+
     if p.returncode != 0:
         if verbose:
             print("unable to run %s (error)" % dispcmd)
@@ -561,9 +560,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False):
         if verbose:
             print("unable to find command, tried %%s" %% (commands,))
         return None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
+
+    stdout = p.communicate()[0].strip().decode()
+
     if p.returncode != 0:
         if verbose:
             print("unable to run %%s (error)" %% dispcmd)
@@ -1678,7 +1677,7 @@ def do_setup():
     except EnvironmentError:
         pass
     # That doesn't cover everything MANIFEST.in can do
-    # (http://docs.python.org/2/distutils/sourcedist.html#commands), so
+    # (https://docs.python.org/2/distutils/sourcedist.html#commands), so
     # it might give some false negatives. Appending redundant 'include'
     # lines is safe, though.
     if "versioneer.py" not in simple_includes:
diff --git a/web/README.md b/web/README.md
new file mode 100644
index 0000000000000..7396fbd0833a1
--- /dev/null
+++ b/web/README.md
@@ -0,0 +1,12 @@
+Directory containing the pandas website (hosted at https://pandas.io).
+
+The website sources are in `web/pandas/`, which also include a `config.yml` file
+containing the settings to build the website. The website is generated with the
+command `./pandas_web.py pandas`. See `./pandas_web.py --help` and the header of
+the script for more information and options.
+
+After building the website, to navigate it, it is needed to access the web using
+an http server (a not open the local files with the browser, since the links and
+the image sources are absolute to where they are served from). The easiest way
+to run an http server locally is to run `python -m http.server` from the
+`web/build/` directory.
diff --git a/web/pandas/_templates/layout.html b/web/pandas/_templates/layout.html
new file mode 100644
index 0000000000000..92126a7b5a2f2
--- /dev/null
+++ b/web/pandas/_templates/layout.html
@@ -0,0 +1,103 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <script type="text/javascript">
+            var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-27880019-2']); _gaq.push(['_trackPageview']);
+            (function() {
+                var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+                ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+                var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+            })();
+        </script>
+        <title>pandas - Python Data Analysis Library</title>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+        <link rel='shortcut icon' type='image/x-icon' href='{{ base_url }}/static/img/favicon.ico'/>
+        <link rel="stylesheet"
+              href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
+              integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm"
+              crossorigin="anonymous">
+        {% for stylesheet in static.css %}
+            <link rel="stylesheet"
+                  href="{{ base_url }}{{ stylesheet }}">
+        {% endfor %}
+        <script src="https://kit.fontawesome.com/79e5369384.js" crossorigin="anonymous"></script>
+    </head>
+    <body>
+        <header>
+            <nav class="navbar navbar-expand-md navbar-dark fixed-top bg-dark">
+                <div class="container">
+                    <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#nav-content" aria-controls="nav-content" aria-expanded="false" aria-label="Toggle navigation">
+                        <span class="navbar-toggler-icon"></span>
+                    </button>
+
+                    {% if static.logo %}<a class="navbar-brand" href="{{ base_url }}/"><img alt="" src="{{ base_url }}{{ static.logo }}"/></a>{% endif %}
+
+                    <div class="collapse navbar-collapse" id="nav-content">   
+                        <ul class="navbar-nav ml-auto">
+                            {% for item in navbar %}
+                                {% if not item.has_subitems %}
+                                    <li class="nav-item">
+                                        <a class="nav-link" href="{% if not item.target.startswith("http") %}{{ base_url }}{% endif %}{{ item.target }}">{{ item.name }}</a>
+                                    </li>
+                                {% else %}
+                                    <li class="nav-item dropdown">
+                                        <a class="nav-link dropdown-toggle"
+                                           data-toggle="dropdown"
+                                           id="{{ item.slug }}"
+                                           href="#"
+                                           role="button"
+                                           aria-haspopup="true"
+                                           aria-expanded="false">{{ item.name }}</a>
+                                        <div class="dropdown-menu" aria-labelledby="{{ item.slug }}">
+                                        {% for subitem in item.target %}
+                                            <a class="dropdown-item" href="{% if not subitem.target.startswith("http") %}{{ base_url }}{% endif %}{{ subitem.target }}">{{ subitem.name }}</a>
+                                        {% endfor %}
+                                        </div>
+                                    </li>
+                                {% endif %}
+                            {% endfor %}
+                        </ul>
+                    </div>
+                </div>
+            </nav>
+        </header>
+        <main role="main">
+            <div class="container">
+                {% block body %}{% endblock %}
+            </div>
+        </main>
+        <footer class="container pt-4 pt-md-5 border-top">
+            <ul class="list-inline social-buttons float-right">
+                <li class="list-inline-item">
+                    <a href="https://twitter.com/pandas_dev/">
+                        <i class="fab fa-twitter"></i>
+                    </a>
+                </li>
+                <li class="list-inline-item">
+                    <a href="https://github.com/pandas-dev/pandas/">
+                        <i class="fab fa-github"></i>
+                    </a>
+                </li>
+                <li class="list-inline-item">
+                    <a href="https://stackoverflow.com/questions/tagged/pandas">
+                        <i class="fab fa-stack-overflow"></i>
+                    </a>
+                </li>
+            </ul>
+            <p>
+                pandas is a fiscally sponsored project of <a href="https://numfocus.org">NumFOCUS</a>
+            </p>
+        </footer>
+                
+        <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
+                integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
+                crossorigin="anonymous"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
+                integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
+                crossorigin="anonymous"></script>
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
+                integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
+                crossorigin="anonymous"></script>
+    </body>
+</html>
diff --git a/web/pandas/about/citing.md b/web/pandas/about/citing.md
new file mode 100644
index 0000000000000..d5cb64e58f0ad
--- /dev/null
+++ b/web/pandas/about/citing.md
@@ -0,0 +1,123 @@
+# Citing and logo
+
+## Citing pandas
+
+If you use _pandas_ for a scientific publication, we would appreciate citations to one of the following papers:
+
+- [Data structures for statistical computing in python](https://conference.scipy.org/proceedings/scipy2010/pdfs/mckinney.pdf),
+   McKinney, Proceedings of the 9th Python in Science Conference, Volume 445, 2010.
+
+        @inproceedings{mckinney2010data,
+            title={Data structures for statistical computing in python},
+            author={Wes McKinney},
+            booktitle={Proceedings of the 9th Python in Science Conference},
+            volume={445},
+            pages={51--56},
+            year={2010},
+            organization={Austin, TX}
+        }
+
+
+- [pandas: a foundational Python library for data analysis and statistics](https://www.scribd.com/document/71048089/pandas-a-Foundational-Python-Library-for-Data-Analysis-and-Statistics),
+  McKinney, Python for High Performance and Scientific Computing, Volume 14, 2011.
+
+        @article{mckinney2011pandas,
+            title={pandas: a foundational Python library for data analysis and statistics},
+            author={Wes McKinney},
+            journal={Python for High Performance and Scientific Computing},
+            volume={14},
+            year={2011}
+        }
+
+## Brand and logo
+
+When using the project name _pandas_, please use it in lower case, even at the beginning of a sentence.
+
+The official logos of _pandas_ are:
+
+### Primary logo
+
+<table class="table logo">
+    <tr>
+        <td>
+            <img alt="" src="{{ base_url }}/static/img/pandas.svg"/>
+        </td>
+        <td style="background-color: #150458">
+            <img alt="" src="{{ base_url }}/static/img/pandas_white.svg"/>
+        </td>
+    </tr>
+</table>
+
+### Secondary logo
+
+<table class="table logo">
+    <tr>
+        <td>
+            <img alt="" src="{{ base_url }}/static/img/pandas_secondary.svg"/>
+        </td>
+        <td style="background-color: #150458">
+            <img alt="" src="{{ base_url }}/static/img/pandas_secondary_white.svg"/>
+        </td>
+    </tr>
+</table>
+
+### Logo mark
+
+<table class="table logo">
+    <tr>
+        <td>
+            <img alt="" src="{{ base_url }}/static/img/pandas_mark.svg"/>
+        </td>
+        <td style="background-color: #150458">
+            <img alt="" src="{{ base_url }}/static/img/pandas_mark_white.svg"/>
+        </td>
+    </tr>
+</table>
+
+### Logo usage
+
+The pandas logo is available in full color and white accent.
+The full color logo should only appear against white backgrounds.
+The white accent logo should go against contrasting color background.
+
+When using the logo, please follow the next directives:
+
+- Primary logo should never be seen under 1 inch in size for printing and 72px for web
+- The secondary logo should never be seen under 0.75 inch in size for printing and 55px for web
+- Leave enough margin around the logo (leave the height of the logo in the top, bottom and both sides)
+- Do not distort the logo by changing its proportions
+- Do not place text or other elements on top of the logo
+
+### Colors
+
+<table class="table">
+    <tr>
+        <td style="text-align: center;">
+            <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+                <circle cx="50" cy="50" r="50" fill="#150458"/>
+            </svg>
+            <br/>
+            <b style="color: #150458;">Blue</b><br/>
+            RGB: R21 G4 B88<br/>
+            HEX: #150458
+        </td>
+        <td style="text-align: center;">
+            <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+                <circle cx="50" cy="50" r="50" fill="#ffca00"/>
+            </svg>
+            <br/>
+            <b style="color: #150458;">Yellow</b><br/>
+            RGB: R255 G202 B0<br/>
+            HEX: #FFCA00
+        </td>
+        <td style="text-align: center;">
+            <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+                <circle cx="50" cy="50" r="50" fill="#e70488"/>
+            </svg>
+            <br/>
+            <b style="color: #150458;">Pink</b><br/>
+            RGB: R231 G4 B136<br/>
+            HEX: #E70488
+        </td>
+    </tr>
+</table>
diff --git a/web/pandas/about/index.md b/web/pandas/about/index.md
new file mode 100644
index 0000000000000..02caaa3b8c53c
--- /dev/null
+++ b/web/pandas/about/index.md
@@ -0,0 +1,86 @@
+# About pandas
+
+## History of development
+
+In 2008, _pandas_ development began at [AQR Capital Management](https://www.aqr.com).
+By the end of 2009 it had been [open sourced](https://en.wikipedia.org/wiki/Open_source),
+and is actively supported today by a community of like-minded individuals around the world who
+contribute their valuable time and energy to help make open source _pandas_
+possible. Thank you to [all of our contributors](team.html).
+
+Since 2015, _pandas_ is a [NumFOCUS sponsored project](https://numfocus.org/sponsored-projects).
+This will help ensure the success of development of _pandas_ as a world-class open-source project.
+
+### Timeline
+
+- **2008**:  Development of _pandas_ started
+- **2009**: _pandas_ becomes open source
+- **2012**: First edition of _Python for Data Analysis_ is published
+- **2015**: _pandas_ becomes a [NumFOCUS sponsored project](https://numfocus.org/sponsored-projects)
+- **2018**: First in-person core developer sprint
+
+## Library Highlights
+
+- A fast and efficient **DataFrame** object for data manipulation with
+  integrated indexing;
+
+- Tools for **reading and writing data** between in-memory data structures and
+  different formats: CSV and text files, Microsoft Excel, SQL databases, and
+  the fast HDF5 format;
+
+- Intelligent **data alignment** and integrated handling of **missing data**:
+  gain automatic label-based alignment in computations and easily manipulate
+  messy data into an orderly form;
+
+- Flexible **reshaping** and pivoting of data sets;
+
+- Intelligent label-based **slicing**, **fancy indexing**, and **subsetting**
+  of large data sets;
+
+- Columns can be inserted and deleted from data structures for **size
+  mutability**;
+
+- Aggregating or transforming data with a powerful **group by** engine
+  allowing split-apply-combine operations on data sets;
+
+- High performance **merging and joining** of data sets;
+
+- **Hierarchical axis indexing** provides an intuitive way of working with
+  high-dimensional data in a lower-dimensional data structure;
+
+- **Time series**-functionality: date range generation and frequency
+  conversion, moving window statistics, date shifting and lagging.
+  Even create domain-specific time offsets and join time
+  series without losing data;
+
+- Highly **optimized for performance**, with critical code paths written in
+  [Cython](http://www.cython.org/) or C.
+
+- Python with *pandas* is in use in a wide variety of **academic and
+  commercial** domains, including Finance, Neuroscience, Economics,
+  Statistics, Advertising, Web Analytics, and more.
+
+## Mission
+
+_pandas_ aims to be the fundamental high-level building block for doing practical,
+real world data analysis in Python.
+Additionally, it has the broader goal of becoming the most powerful and flexible
+open source data analysis / manipulation tool available in any language.
+
+## Vision
+
+A world where data analytics and manipulation software is:
+
+- Accessible to everyone
+- Free for users to use and modify
+- Flexible
+- Powerful
+- Easy to use
+- Fast
+
+## Values
+
+Is in the core of _pandas_ to be respectful and welcoming with everybody,
+users, contributors and the broader community. Regardless of level of experience,
+gender, gender identity and expression, sexual orientation, disability,
+personal appearance, body size, race, ethnicity, age, religion, or nationality.
diff --git a/web/pandas/about/roadmap.md b/web/pandas/about/roadmap.md
new file mode 100644
index 0000000000000..35a6b3361f32e
--- /dev/null
+++ b/web/pandas/about/roadmap.md
@@ -0,0 +1,182 @@
+# Roadmap
+
+This page provides an overview of the major themes in pandas'
+development. Each of these items requires a relatively large amount of
+effort to implement. These may be achieved more quickly with dedicated
+funding or interest from contributors.
+
+An item being on the roadmap does not mean that it will *necessarily*
+happen, even with unlimited funding. During the implementation period we
+may discover issues preventing the adoption of the feature.
+
+Additionally, an item *not* being on the roadmap does not exclude it
+from inclusion in pandas. The roadmap is intended for larger,
+fundamental changes to the project that are likely to take months or
+years of developer time. Smaller-scoped items will continue to be
+tracked on our [issue tracker](https://github.com/pandas-dev/pandas/issues).
+
+See [Roadmap evolution](#roadmap-evolution) for proposing
+changes to this document.
+
+## Extensibility
+
+Pandas `extending.extension-types` allow
+for extending NumPy types with custom data types and array storage.
+Pandas uses extension types internally, and provides an interface for
+3rd-party libraries to define their own custom data types.
+
+Many parts of pandas still unintentionally convert data to a NumPy
+array. These problems are especially pronounced for nested data.
+
+We'd like to improve the handling of extension arrays throughout the
+library, making their behavior more consistent with the handling of
+NumPy arrays. We'll do this by cleaning up pandas' internals and
+adding new methods to the extension array interface.
+
+## String data type
+
+Currently, pandas stores text data in an `object` -dtype NumPy array.
+The current implementation has two primary drawbacks: First, `object`
+-dtype is not specific to strings: any Python object can be stored in an
+`object` -dtype array, not just strings. Second: this is not efficient.
+The NumPy memory model isn't especially well-suited to variable width
+text data.
+
+To solve the first issue, we propose a new extension type for string
+data. This will initially be opt-in, with users explicitly requesting
+`dtype="string"`. The array backing this string dtype may initially be
+the current implementation: an `object` -dtype NumPy array of Python
+strings.
+
+To solve the second issue (performance), we'll explore alternative
+in-memory array libraries (for example, Apache Arrow). As part of the
+work, we may need to implement certain operations expected by pandas
+users (for example the algorithm used in, `Series.str.upper`). That work
+may be done outside of pandas.
+
+## Apache Arrow interoperability
+
+[Apache Arrow](https://arrow.apache.org) is a cross-language development
+platform for in-memory data. The Arrow logical types are closely aligned
+with typical pandas use cases.
+
+We'd like to provide better-integrated support for Arrow memory and
+data types within pandas. This will let us take advantage of its I/O
+capabilities and provide for better interoperability with other
+languages and libraries using Arrow.
+
+## Block manager rewrite
+
+We'd like to replace pandas current internal data structures (a
+collection of 1 or 2-D arrays) with a simpler collection of 1-D arrays.
+
+Pandas internal data model is quite complex. A DataFrame is made up of
+one or more 2-dimensional "blocks", with one or more blocks per dtype.
+This collection of 2-D arrays is managed by the BlockManager.
+
+The primary benefit of the BlockManager is improved performance on
+certain operations (construction from a 2D array, binary operations,
+reductions across the columns), especially for wide DataFrames. However,
+the BlockManager substantially increases the complexity and maintenance
+burden of pandas.
+
+By replacing the BlockManager we hope to achieve
+
+-   Substantially simpler code
+-   Easier extensibility with new logical types
+-   Better user control over memory use and layout
+-   Improved micro-performance
+-   Option to provide a C / Cython API to pandas' internals
+
+See [these design
+documents](https://dev.pandas.io/pandas2/internal-architecture.html#removal-of-blockmanager-new-dataframe-internals)
+for more.
+
+## Decoupling of indexing and internals
+
+The code for getting and setting values in pandas' data structures
+needs refactoring. In particular, we must clearly separate code that
+converts keys (e.g., the argument to `DataFrame.loc`) to positions from
+code that uses these positions to get or set values. This is related to
+the proposed BlockManager rewrite. Currently, the BlockManager sometimes
+uses label-based, rather than position-based, indexing. We propose that
+it should only work with positional indexing, and the translation of
+keys to positions should be entirely done at a higher level.
+
+Indexing is a complicated API with many subtleties. This refactor will
+require care and attention. More details are discussed at
+<https://github.com/pandas-dev/pandas/wiki/(Tentative)-rules-for-restructuring-indexing-code>
+
+## Numba-accelerated operations
+
+[Numba](https://numba.pydata.org) is a JIT compiler for Python code.
+We'd like to provide ways for users to apply their own Numba-jitted
+functions where pandas accepts user-defined functions (for example,
+`Series.apply`,
+`DataFrame.apply`,
+`DataFrame.applymap`, and in groupby and
+window contexts). This will improve the performance of
+user-defined-functions in these operations by staying within compiled
+code.
+
+## Documentation improvements
+
+We'd like to improve the content, structure, and presentation of the
+pandas documentation. Some specific goals include
+
+-   Overhaul the HTML theme with a modern, responsive design
+    (`15556`)
+-   Improve the "Getting Started" documentation, designing and writing
+    learning paths for users different backgrounds (e.g. brand new to
+    programming, familiar with other languages like R, already familiar
+    with Python).
+-   Improve the overall organization of the documentation and specific
+    subsections of the documentation to make navigation and finding
+    content easier.
+
+## Performance monitoring
+
+Pandas uses [airspeed velocity](https://asv.readthedocs.io/en/stable/)
+to monitor for performance regressions. ASV itself is a fabulous tool,
+but requires some additional work to be integrated into an open source
+project's workflow.
+
+The [asv-runner](https://github.com/asv-runner) organization, currently
+made up of pandas maintainers, provides tools built on top of ASV. We
+have a physical machine for running a number of project's benchmarks,
+and tools managing the benchmark runs and reporting on results.
+
+We'd like to fund improvements and maintenance of these tools to
+
+-   Be more stable. Currently, they're maintained on the nights and
+    weekends when a maintainer has free time.
+-   Tune the system for benchmarks to improve stability, following
+    <https://pyperf.readthedocs.io/en/latest/system.html>
+-   Build a GitHub bot to request ASV runs *before* a PR is merged.
+    Currently, the benchmarks are only run nightly.
+
+## Roadmap Evolution
+
+Pandas continues to evolve. The direction is primarily determined by
+community interest. Everyone is welcome to review existing items on the
+roadmap and to propose a new item.
+
+Each item on the roadmap should be a short summary of a larger design
+proposal. The proposal should include
+
+1.  Short summary of the changes, which would be appropriate for
+    inclusion in the roadmap if accepted.
+2.  Motivation for the changes.
+3.  An explanation of why the change is in scope for pandas.
+4.  Detailed design: Preferably with example-usage (even if not
+    implemented yet) and API documentation
+5.  API Change: Any API changes that may result from the proposal.
+
+That proposal may then be submitted as a GitHub issue, where the pandas
+maintainers can review and comment on the design. The [pandas mailing
+list](https://mail.python.org/mailman/listinfo/pandas-dev) should be
+notified of the proposal.
+
+When there's agreement that an implementation would be welcome, the
+roadmap should be updated to include the summary and a link to the
+discussion issue.
diff --git a/web/pandas/about/sponsors.md b/web/pandas/about/sponsors.md
new file mode 100644
index 0000000000000..4473a16cfd590
--- /dev/null
+++ b/web/pandas/about/sponsors.md
@@ -0,0 +1,60 @@
+# Sponsors
+
+## NumFOCUS
+
+![](https://numfocus.org/wp-content/uploads/2018/01/optNumFocus_LRG.png)
+
+_pandas_ is a Sponsored Project of [NumFOCUS](https://numfocus.org/), a 501(c)(3) nonprofit charity in the United States.
+NumFOCUS provides _pandas_ with fiscal, legal, and administrative support to help ensure the
+health and sustainability of the project. Visit numfocus.org for more information.
+
+Donations to _pandas_ are managed by NumFOCUS. For donors in the United States, your gift is tax-deductible
+to the extent provided by law. As with any donation, you should consult with your tax adviser about your particular tax situation.
+
+## Become a sponsor
+
+As a free and open source project, _pandas_ relies on the support of the community of users for its development.
+If you work for an organization that uses and benefits from _pandas_, please consider supporting pandas. There
+are different ways, such as employing people to work on pandas, funding the project, or becoming a
+[NumFOCUS sponsor](https://numfocus.org/sponsors) to support the broader ecosystem. Please contact us at
+[admin@numfocus.org](mailto:admin@numfocus.org) to discuss.
+
+## Institutional partners
+
+Institutional partners are companies and universities that support the project by employing contributors.
+Current institutional partners include:
+
+<ul>
+    {% for company in sponsors.active if company.kind == "partner" %}
+        <li><a href="{{ company.url }}">{{ company.name }}</a>: {{ company.description }}</li>
+    {% endfor %}
+</ul>
+
+## Sponsors
+
+Sponsors are organizations that provide funding for pandas. Current sponsors include:
+
+<ul>
+    {% for company in sponsors.active if company.kind == "regular" %}
+        <li><a href="{{ company.url }}">{{ company.name }}</a>: {{ company.description }}</li>
+    {% endfor %}
+</ul>
+
+## In-kind sponsors
+
+In-kind sponsors are organizations that support pandas development with goods or services.
+Current in-kind sponsors include:
+
+<ul>
+    {% for company in sponsors.inkind %}
+        <li><a href="{{ company.url }}">{{ company.name }}</a>: {{ company.description }}</li>
+    {% endfor %}
+</ul>
+
+## Past institutional partners
+
+<ul>
+    {% for company in sponsors.past if company.kind == "partner" %}
+        <li><a href="{{ company.url }}">{{ company.name }}</a></li>
+    {% endfor %}
+</ul>
diff --git a/web/pandas/about/team.md b/web/pandas/about/team.md
new file mode 100644
index 0000000000000..8eb2edebec817
--- /dev/null
+++ b/web/pandas/about/team.md
@@ -0,0 +1,77 @@
+# Team
+
+## Contributors
+
+_pandas_ is made with love by more than [1,500 volunteer contributors](https://github.com/pandas-dev/pandas/graphs/contributors).
+
+If you want to support pandas development, you can find information in the [donations page](../donate.html).
+
+## Maintainers
+
+<div class="row maintainers">
+    {% for row in maintainers.people | batch(6, "") %}
+        <div class="card-group maintainers">
+            {% for person in row %}
+                {% if person %}
+                    <div class="card">
+                        <img class="card-img-top" alt="" src="{{ person.avatar_url }}"/>
+                        <div class="card-body">
+                            <h6 class="card-title">
+                                {% if person.blog %}
+                                    <a href="{{ person.blog }}">
+                                        {{ person.name or person.login }}
+                                    </a>
+                                {% else %}
+                                    {{ person.name or person.login }}
+                                {% endif %}
+                            </h6>
+                            <p class="card-text small"><a href="{{ person.html_url }}">{{ person.login }}</a></p>
+                        </div>
+                    </div>
+                {% else %}
+                    <div class="card border-0"></div>
+                {% endif %}
+            {% endfor %}
+        </div>
+    {% endfor %}
+</div>
+
+## Diversity and Inclusion
+
+> _pandas_ expressly welcomes and encourages contributions from anyone who faces under-representation, discrimination in the technology industry
+> or anyone willing to increase the diversity of our team.
+> We have identified visible gaps and obstacles in sustaining diversity and inclusion in the open-source communities and we are proactive in increasing
+> the diversity of our team.
+> We have a [code of conduct]({base_url}/community/coc.html) to ensure a friendly and welcoming environment.
+> Please send an email to [pandas-code-of-conduct-committee](mailto:pandas-coc@googlegroups.com), if you think we can do a
+> better job at achieving this goal.
+
+## Governance
+
+Wes McKinney is the Benevolent Dictator for Life (BDFL).
+
+The project governance is available in the [project governance documents](https://github.com/pandas-dev/pandas-governance).
+
+## Code of conduct committee
+
+<ul>
+    {% for person in maintainers.coc %}
+        <li>{{ person }}</li>
+    {% endfor %}
+</ul>
+
+## NumFOCUS committee
+
+<ul>
+    {% for person in maintainers.numfocus %}
+        <li>{{ person }}</li>
+    {% endfor %}
+</ul>
+
+## Emeritus maintainers
+
+<ul>
+    {% for person in maintainers.emeritus %}
+        <li>{{ person }}</li>
+    {% endfor %}
+</ul>
diff --git a/web/pandas/community/blog.html b/web/pandas/community/blog.html
new file mode 100644
index 0000000000000..627aaa450893b
--- /dev/null
+++ b/web/pandas/community/blog.html
@@ -0,0 +1,14 @@
+{% extends "layout.html" %}
+
+{% block body %}
+    {% for post in blog.posts %}
+        <div class="card">
+            <div class="card-body">
+                <h5 class="card-title"><a href="{{post.link }}" target="_blank">{{ post.title }}</a></h5>
+                <h6 class="card-subtitle text-muted small mb-4">Source: {{ post.feed }} | Author: {{ post.author }} | Published: {{ post.published.strftime("%b %d, %Y") }}</h6>
+                <div class="card-text mb-2">{{ post.summary }}</div>
+                <a class="card-link small" href="{{post.link }}" target="_blank">Read more</a>
+            </div>
+        </div>
+    {% endfor %}
+{% endblock %}
diff --git a/web/pandas/community/coc.md b/web/pandas/community/coc.md
new file mode 100644
index 0000000000000..bf62f4e00f847
--- /dev/null
+++ b/web/pandas/community/coc.md
@@ -0,0 +1,63 @@
+# Code of conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+A working group of community members is committed to promptly addressing any
+reported issues. The working group is made up of pandas contributors and users.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the working group by e-mail (pandas-coc@googlegroups.com).
+Messages sent to this e-mail address will not be publicly visible but only to
+the working group members. The working group currently includes
+
+<ul>
+    {% for person in maintainers.coc %}
+    <li>{{ person }}</li>
+    {% endfor %}
+</ul>
+
+All complaints will be reviewed and investigated and will result in a response
+that is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[https://www.contributor-covenant.org/version/1/3/0/][version],
+and the [Swift Code of Conduct][swift].
+
+[homepage]: https://www.contributor-covenant.org
+[version]: https://www.contributor-covenant.org/version/1/3/0/
+[swift]: https://swift.org/community/#code-of-conduct
+
diff --git a/web/pandas/community/ecosystem.md b/web/pandas/community/ecosystem.md
new file mode 100644
index 0000000000000..715a84c1babc6
--- /dev/null
+++ b/web/pandas/community/ecosystem.md
@@ -0,0 +1,365 @@
+# Ecosystem
+
+Increasingly, packages are being built on top of pandas to address
+specific needs in data preparation, analysis and visualization. This is
+encouraging because it means pandas is not only helping users to handle
+their data tasks but also that it provides a better starting point for
+developers to build powerful and more focused data tools. The creation
+of libraries that complement pandas' functionality also allows pandas
+development to remain focused around it's original requirements.
+
+This is an inexhaustive list of projects that build on pandas in order
+to provide tools in the PyData space. For a list of projects that depend
+on pandas, see the [libraries.io usage page for
+pandas](https://libraries.io/pypi/pandas/usage) or [search pypi for
+pandas](https://pypi.org/search/?q=pandas).
+
+We'd like to make it easier for users to find these projects, if you
+know of other substantial projects that you feel should be on this list,
+please let us know.
+
+## Statistics and machine learning
+
+### [Statsmodels](https://www.statsmodels.org/)
+
+Statsmodels is the prominent Python "statistics and econometrics
+library" and it has a long-standing special relationship with pandas.
+Statsmodels provides powerful statistics, econometrics, analysis and
+modeling functionality that is out of pandas' scope. Statsmodels
+leverages pandas objects as the underlying data container for
+computation.
+
+### [sklearn-pandas](https://github.com/paulgb/sklearn-pandas)
+
+Use pandas DataFrames in your [scikit-learn](https://scikit-learn.org/)
+ML pipeline.
+
+### [Featuretools](https://github.com/featuretools/featuretools/)
+
+Featuretools is a Python library for automated feature engineering built
+on top of pandas. It excels at transforming temporal and relational
+datasets into feature matrices for machine learning using reusable
+feature engineering "primitives". Users can contribute their own
+primitives in Python and share them with the rest of the community.
+
+## Visualization
+
+### [Altair](https://altair-viz.github.io/)
+
+Altair is a declarative statistical visualization library for Python.
+With Altair, you can spend more time understanding your data and its
+meaning. Altair's API is simple, friendly and consistent and built on
+top of the powerful Vega-Lite JSON specification. This elegant
+simplicity produces beautiful and effective visualizations with a
+minimal amount of code. Altair works with Pandas DataFrames.
+
+### [Bokeh](https://bokeh.pydata.org)
+
+Bokeh is a Python interactive visualization library for large datasets
+that natively uses the latest web technologies. Its goal is to provide
+elegant, concise construction of novel graphics in the style of
+Protovis/D3, while delivering high-performance interactivity over large
+data to thin clients.
+
+[Pandas-Bokeh](https://github.com/PatrikHlobil/Pandas-Bokeh) provides a
+high level API for Bokeh that can be loaded as a native Pandas plotting
+backend via
+
+```
+pd.set_option("plotting.backend", "pandas_bokeh")
+```
+
+It is very similar to the matplotlib plotting backend, but provides
+interactive web-based charts and maps.
+
+### [seaborn](https://seaborn.pydata.org)
+
+Seaborn is a Python visualization library based on
+[matplotlib](https://matplotlib.org). It provides a high-level,
+dataset-oriented interface for creating attractive statistical graphics.
+The plotting functions in seaborn understand pandas objects and leverage
+pandas grouping operations internally to support concise specification
+of complex visualizations. Seaborn also goes beyond matplotlib and
+pandas with the option to perform statistical estimation while plotting,
+aggregating across observations and visualizing the fit of statistical
+models to emphasize patterns in a dataset.
+
+### [plotnine](https://github.com/has2k1/plotnine/)
+
+Hadley Wickham's [ggplot2](https://ggplot2.tidyverse.org/) is a
+foundational exploratory visualization package for the R language. Based
+on ["The Grammar of
+Graphics"](https://www.cs.uic.edu/~wilkinson/TheGrammarOfGraphics/GOG.html)
+it provides a powerful, declarative and extremely general way to
+generate bespoke plots of any kind of data.
+Various implementations to other languages are available.
+A good implementation for Python users is [has2k1/plotnine](https://github.com/has2k1/plotnine/).
+
+### [IPython Vega](https://github.com/vega/ipyvega)
+
+[IPython Vega](https://github.com/vega/ipyvega) leverages [Vega](https://github.com/vega/vega) to create plots within Jupyter Notebook.
+
+### [Plotly](https://plot.ly/python)
+
+[Plotly's](https://plot.ly/) [Python API](https://plot.ly/python/)
+enables interactive figures and web shareability. Maps, 2D, 3D, and
+live-streaming graphs are rendered with WebGL and
+[D3.js](https://d3js.org/). The library supports plotting directly from
+a pandas DataFrame and cloud-based collaboration. Users of [matplotlib,
+ggplot for Python, and
+Seaborn](https://plot.ly/python/matplotlib-to-plotly-tutorial/) can
+convert figures into interactive web-based plots. Plots can be drawn in
+[IPython Notebooks](https://plot.ly/ipython-notebooks/) , edited with R
+or MATLAB, modified in a GUI, or embedded in apps and dashboards. Plotly
+is free for unlimited sharing, and has
+[cloud](https://plot.ly/product/plans/),
+[offline](https://plot.ly/python/offline/), or
+[on-premise](https://plot.ly/product/enterprise/) accounts for private
+use.
+
+### [QtPandas](https://github.com/draperjames/qtpandas)
+
+Spun off from the main pandas library, the
+[qtpandas](https://github.com/draperjames/qtpandas) library enables
+DataFrame visualization and manipulation in PyQt4 and PySide
+applications.
+
+## IDE
+
+### [IPython](https://ipython.org/documentation.html)
+
+IPython is an interactive command shell and distributed computing
+environment. IPython tab completion works with Pandas methods and also
+attributes like DataFrame columns.
+
+### [Jupyter Notebook / Jupyter Lab](https://jupyter.org)
+
+Jupyter Notebook is a web application for creating Jupyter notebooks. A
+Jupyter notebook is a JSON document containing an ordered list of
+input/output cells which can contain code, text, mathematics, plots and
+rich media. Jupyter notebooks can be converted to a number of open
+standard output formats (HTML, HTML presentation slides, LaTeX, PDF,
+ReStructuredText, Markdown, Python) through 'Download As' in the web
+interface and `jupyter convert` in a shell.
+
+Pandas DataFrames implement `_repr_html_`and `_repr_latex` methods which
+are utilized by Jupyter Notebook for displaying (abbreviated) HTML or
+LaTeX tables. LaTeX output is properly escaped. (Note: HTML tables may
+or may not be compatible with non-HTML Jupyter output formats.)
+
+See `Options and Settings <options>` and
+`Available Options <options.available>`
+for pandas `display.` settings.
+
+### [quantopian/qgrid](https://github.com/quantopian/qgrid)
+
+qgrid is "an interactive grid for sorting and filtering DataFrames in
+IPython Notebook" built with SlickGrid.
+
+### [Spyder](https://www.spyder-ide.org/)
+
+Spyder is a cross-platform PyQt-based IDE combining the editing,
+analysis, debugging and profiling functionality of a software
+development tool with the data exploration, interactive execution, deep
+inspection and rich visualization capabilities of a scientific
+environment like MATLAB or Rstudio.
+
+Its [Variable
+Explorer](https://docs.spyder-ide.org/variableexplorer.html) allows
+users to view, manipulate and edit pandas `Index`, `Series`, and
+`DataFrame` objects like a "spreadsheet", including copying and
+modifying values, sorting, displaying a "heatmap", converting data
+types and more. Pandas objects can also be renamed, duplicated, new
+columns added, copyed/pasted to/from the clipboard (as TSV), and
+saved/loaded to/from a file. Spyder can also import data from a variety
+of plain text and binary files or the clipboard into a new pandas
+DataFrame via a sophisticated import wizard.
+
+Most pandas classes, methods and data attributes can be autocompleted in
+Spyder's [Editor](https://docs.spyder-ide.org/editor.html) and [IPython
+Console](https://docs.spyder-ide.org/ipythonconsole.html), and Spyder's
+[Help pane](https://docs.spyder-ide.org/help.html) can retrieve and
+render Numpydoc documentation on pandas objects in rich text with Sphinx
+both automatically and on-demand.
+
+## API
+
+### [pandas-datareader](https://github.com/pydata/pandas-datareader)
+
+`pandas-datareader` is a remote data access library for pandas
+(PyPI:`pandas-datareader`). It is based on functionality that was
+located in `pandas.io.data` and `pandas.io.wb` but was split off in
+v0.19. See more in the [pandas-datareader
+docs](https://pandas-datareader.readthedocs.io/en/latest/):
+
+The following data feeds are available:
+
+- Google Finance
+- Tiingo
+- Morningstar
+- IEX
+- Robinhood
+- Enigma
+- Quandl
+- FRED
+- Fama/French
+- World Bank
+- OECD
+- Eurostat
+- TSP Fund Data
+- Nasdaq Trader Symbol Definitions
+- Stooq Index Data
+- MOEX Data
+
+### [quandl/Python](https://github.com/quandl/Python)
+
+Quandl API for Python wraps the Quandl REST API to return Pandas
+DataFrames with timeseries indexes.
+
+### [pydatastream](https://github.com/vfilimonov/pydatastream)
+
+PyDatastream is a Python interface to the [Thomson Dataworks Enterprise
+(DWE/Datastream)](http://dataworks.thomson.com/Dataworks/Enterprise/1.0/)
+SOAP API to return indexed Pandas DataFrames with financial data. This
+package requires valid credentials for this API (non free).
+
+### [pandaSDMX](https://pandasdmx.readthedocs.io)
+
+pandaSDMX is a library to retrieve and acquire statistical data and
+metadata disseminated in [SDMX](https://www.sdmx.org) 2.1, an
+ISO-standard widely used by institutions such as statistics offices,
+central banks, and international organisations. pandaSDMX can expose
+datasets and related structural metadata including data flows,
+code-lists, and data structure definitions as pandas Series or
+MultiIndexed DataFrames.
+
+### [fredapi](https://github.com/mortada/fredapi)
+
+fredapi is a Python interface to the [Federal Reserve Economic Data
+(FRED)](https://fred.stlouisfed.org/) provided by the Federal Reserve
+Bank of St. Louis. It works with both the FRED database and ALFRED
+database that contains point-in-time data (i.e. historic data
+revisions). fredapi provides a wrapper in Python to the FRED HTTP API,
+and also provides several convenient methods for parsing and analyzing
+point-in-time data from ALFRED. fredapi makes use of pandas and returns
+data in a Series or DataFrame. This module requires a FRED API key that
+you can obtain for free on the FRED website.
+
+## Domain specific
+
+### [Geopandas](https://github.com/kjordahl/geopandas)
+
+Geopandas extends pandas data objects to include geographic information
+which support geometric operations. If your work entails maps and
+geographical coordinates, and you love pandas, you should take a close
+look at Geopandas.
+
+### [xarray](https://github.com/pydata/xarray)
+
+xarray brings the labeled data power of pandas to the physical sciences
+by providing N-dimensional variants of the core pandas data structures.
+It aims to provide a pandas-like and pandas-compatible toolkit for
+analytics on multi-dimensional arrays, rather than the tabular data for
+which pandas excels.
+
+## Out-of-core
+
+### [Blaze](https://blaze.pydata.org/)
+
+Blaze provides a standard API for doing computations with various
+in-memory and on-disk backends: NumPy, Pandas, SQLAlchemy, MongoDB,
+PyTables, PySpark.
+
+### [Dask](https://dask.readthedocs.io/en/latest/)
+
+Dask is a flexible parallel computing library for analytics. Dask
+provides a familiar `DataFrame` interface for out-of-core, parallel and
+distributed computing.
+
+### [Dask-ML](https://dask-ml.readthedocs.io/en/latest/)
+
+Dask-ML enables parallel and distributed machine learning using Dask
+alongside existing machine learning libraries like Scikit-Learn,
+XGBoost, and TensorFlow.
+
+### [Koalas](https://koalas.readthedocs.io/en/latest/)
+
+Koalas provides a familiar pandas DataFrame interface on top of Apache
+Spark. It enables users to leverage multi-cores on one machine or a
+cluster of machines to speed up or scale their DataFrame code.
+
+### [Odo](http://odo.pydata.org)
+
+Odo provides a uniform API for moving data between different formats. It
+uses pandas own `read_csv` for CSV IO and leverages many existing
+packages such as PyTables, h5py, and pymongo to move data between non
+pandas formats. Its graph based approach is also extensible by end users
+for custom formats that may be too specific for the core of odo.
+
+### [Ray](https://ray.readthedocs.io/en/latest/pandas_on_ray.html)
+
+Pandas on Ray is an early stage DataFrame library that wraps Pandas and
+transparently distributes the data and computation. The user does not
+need to know how many cores their system has, nor do they need to
+specify how to distribute the data. In fact, users can continue using
+their previous Pandas notebooks while experiencing a considerable
+speedup from Pandas on Ray, even on a single machine. Only a
+modification of the import statement is needed, as we demonstrate below.
+Once you've changed your import statement, you're ready to use Pandas on
+Ray just like you would Pandas.
+
+```
+# import pandas as pd
+import ray.dataframe as pd
+```
+
+### [Vaex](https://docs.vaex.io/)
+
+Increasingly, packages are being built on top of pandas to address
+specific needs in data preparation, analysis and visualization. Vaex is
+a python library for Out-of-Core DataFrames (similar to Pandas), to
+visualize and explore big tabular datasets. It can calculate statistics
+such as mean, sum, count, standard deviation etc, on an N-dimensional
+grid up to a billion (10^9^) objects/rows per second. Visualization is
+done using histograms, density plots and 3d volume rendering, allowing
+interactive exploration of big data. Vaex uses memory mapping, zero
+memory copy policy and lazy computations for best performance (no memory
+wasted).
+
+- ``vaex.from_pandas``
+- ``vaex.to_pandas_df``
+
+## Data cleaning and validation
+
+### [pyjanitor](https://github.com/ericmjl/pyjanitor/)
+
+Pyjanitor provides a clean API for cleaning data, using method chaining.
+
+### [Engarde](https://engarde.readthedocs.io/en/latest/)
+
+Engarde is a lightweight library used to explicitly state your
+assumptions about your datasets and check that they're *actually* true.
+
+## Extension data types
+
+Pandas provides an interface for defining
+`extension types <extending.extension-types>` to extend NumPy's type system. The following libraries
+implement that interface to provide types not found in NumPy or pandas,
+which work well with pandas' data containers.
+
+### [cyberpandas](https://cyberpandas.readthedocs.io/en/latest)
+
+Cyberpandas provides an extension type for storing arrays of IP
+Addresses. These arrays can be stored inside pandas' Series and
+DataFrame.
+
+## Accessors
+
+A directory of projects providing
+`extension accessors <extending.register-accessors>`. This is for users to discover new accessors and for library
+authors to coordinate on the namespace.
+
+  | Library                                                     | Accessor |  Classes              |
+  | ------------------------------------------------------------|----------|-----------------------|
+  | [cyberpandas](https://cyberpandas.readthedocs.io/en/latest) | `ip`     | `Series`              |
+  | [pdvega](https://altair-viz.github.io/pdvega/)              | `vgplot` | `Series`, `DataFrame` |
diff --git a/web/pandas/config.yml b/web/pandas/config.yml
new file mode 100644
index 0000000000000..83eb152c9d944
--- /dev/null
+++ b/web/pandas/config.yml
@@ -0,0 +1,141 @@
+main:
+  templates_path: _templates
+  base_template: "layout.html"
+  ignore:
+  - _templates/layout.html
+  - config.yml
+  - try.md  # the binder page will be added later
+  github_repo_url: pandas-dev/pandas
+  context_preprocessors:
+  - pandas_web.Preprocessors.navbar_add_info
+  - pandas_web.Preprocessors.blog_add_posts
+  - pandas_web.Preprocessors.maintainers_add_info
+  - pandas_web.Preprocessors.home_add_releases
+  markdown_extensions:
+  - toc
+  - tables
+  - fenced_code
+static:
+  logo: /static/img/pandas_white.svg
+  css:
+  - /static/css/pandas.css
+navbar:
+  - name: "About us"
+    target:
+    - name: "About pandas"
+      target: /about/index.html
+    - name: "Project roadmap"
+      target: /about/roadmap.html
+    - name: "Team"
+      target: /about/team.html
+    - name: "Sponsors"
+      target: /about/sponsors.html
+    - name: "Citing and logo"
+      target: /about/citing.html
+  - name: "Getting started"
+    target: /getting_started.html
+  - name: "Documentation"
+    target: /docs/
+  - name: "Community"
+    target:
+    - name: "Blog"
+      target: /community/blog.html
+    - name: "Ask a question (StackOverflow)"
+      target: https://stackoverflow.com/questions/tagged/pandas
+    - name: "Code of conduct"
+      target: /community/coc.html
+    - name: "Ecosystem"
+      target: /community/ecosystem.html
+  - name: "Contribute"
+    target: /contribute.html
+blog:
+  num_posts: 8
+  feed:
+  - https://dev.pandas.io/pandas-blog/feeds/all.atom.xml
+  - https://wesmckinney.com/feeds/pandas.atom.xml
+  - https://tomaugspurger.github.io/feed
+  - https://jorisvandenbossche.github.io/feeds/all.atom.xml
+  - https://datapythonista.github.io/blog/feeds/pandas.atom.xml
+  - https://numfocus.org/tag/pandas/feed/
+maintainers:
+  active:
+  - wesm
+  - jorisvandenbossche
+  - TomAugspurger
+  - shoyer
+  - jreback
+  - chris-b1
+  - sinhrks
+  - cpcloud
+  - gfyoung
+  - toobaz
+  - WillAyd
+  - mroeschke
+  - jschendel
+  - jbrockmendel
+  - datapythonista
+  - simonjayhawkins
+  - topper-123
+  emeritus:
+  - Wouter Overmeire
+  - Skipper Seabold
+  - Jeff Tratner
+  coc:
+  - Safia Abdalla
+  - Tom Augspurger
+  - Joris Van den Bossche
+  - Camille Scott
+  - Nathaniel Smith
+  numfocus:
+  - Phillip Cloud
+  - Stephan Hoyer
+  - Wes McKinney
+  - Jeff Reback
+  - Joris Van den Bossche
+sponsors:
+  active:
+  - name: "NumFOCUS"
+    url: https://numfocus.org/
+    logo: /static/img/partners/numfocus.svg
+    kind: numfocus
+  - name: "Anaconda"
+    url: https://www.anaconda.com/
+    logo: /static/img/partners/anaconda.svg
+    kind: partner
+    description: "Tom Augspurger, Brock Mendel"
+  - name: "Two Sigma"
+    url: https://www.twosigma.com/
+    logo: /static/img/partners/two_sigma.svg
+    kind: partner
+    description: "Phillip Cloud, Jeff Reback"
+  - name: "RStudio"
+    url: https://www.rstudio.com/
+    logo: /static/img/partners/r_studio.svg
+    kind: partner
+    description: "Wes McKinney"
+  - name: "Ursa Labs"
+    url: https://ursalabs.org/
+    logo: /static/img/partners/ursa_labs.svg
+    kind: partner
+    description: "Wes McKinney, Joris Van den Bossche"
+  - name: "Tidelift"
+    url: https://tidelift.com
+    logo: /static/img/partners/tidelift.svg
+    kind: regular
+    description: "<i>pandas</i> is part of the <a href=\"https://tidelift.com/subscription/pkg/pypi-pandas?utm_source=pypi-pandas&utm_medium=referral&utm_campaign=readme\">Tidelift subscription</a>. You can support pandas by becoming a Tidelift subscriber."
+  - name: "Chan Zuckerberg Initiative"
+    url: https://chanzuckerberg.com/
+    logo: /static/img/partners/czi.svg
+    kind: regular
+    description: "<i>pandas</i> is funded by the Essential Open Source Software for Science program of the Chan Zuckerberg Initiative. The funding is used for general maintainance, improve extension types, and a efficient string type."
+  inkind:  # not included in active so they don't appear in the home page
+  - name: "OVH"
+    url: https://us.ovhcloud.com/
+    description: "Website and documentation hosting."
+  - name: "Indeed"
+    url: https://opensource.indeedeng.io/
+    description: "<i>pandas</i> logo design"
+  past:
+  - name: "Paris-Saclay Center for Data Science"
+    url: https://www.datascience-paris-saclay.fr/
+    kind: partner
diff --git a/web/pandas/contribute.md b/web/pandas/contribute.md
new file mode 100644
index 0000000000000..9f4ebaf97598c
--- /dev/null
+++ b/web/pandas/contribute.md
@@ -0,0 +1,55 @@
+# Contribute to pandas
+
+_pandas_ is and will always be **free**. To make the development sustainable, we need _pandas_ users, corporate
+and individual, to support the development by providing their time and money.
+
+You can find more information about current developers in the [team page](about/team.html),
+and about current sponsors in the [sponsors page](about/sponsors.html).
+
+<section>
+    <div class="container mt-5">
+      <div class="row text-center">
+        <div class="col-md-4">
+          <span class="fa-stack fa-4x">
+            <i class="fas fa-circle fa-stack-2x pink"></i>
+            <i class="fas fa-building fa-stack-1x fa-inverse"></i>
+          </span>
+          <h4 class="service-heading mt-3 font-weight-bold blue">Corporate support</h4>
+          <p class="text-muted">
+            pandas depends on companies and institutions using the software to support its development. Hiring
+            people to work on pandas, or letting existing employees to contribute to the
+            software. Or sponsoring pandas with funds, so the project can hire people to
+            progress on the <a href="about/roadmap.html">pandas roadmap</a>.
+          </p>
+          <p>More information in the <a href="about/sponsors.html">sponsors page</a></p>
+        </div>
+        <div class="col-md-4">
+          <span class="fa-stack fa-4x">
+            <i class="fas fa-circle fa-stack-2x pink"></i>
+            <i class="fas fa-users fa-stack-1x fa-inverse"></i>
+          </span>
+          <h4 class="service-heading mt-3 font-weight-bold blue">Individual contributors</h4>
+          <p class="text-muted">
+            pandas is mostly developed by volunteers. All kind of contributions are welcome,
+            such as contributions to the code, to the website (including graphical designers),
+            to the documentation (including translators) and others. There are tasks for all
+            levels, including beginners.
+          </p>
+          <p>More information in the <a href="{{ base_url }}/docs/development/index.html">contributing page</a></p>
+        </div>
+        <div class="col-md-4">
+          <span class="fa-stack fa-4x">
+            <i class="fas fa-circle fa-stack-2x pink"></i>
+            <i class="fas fa-dollar-sign fa-stack-1x fa-inverse"></i>
+          </span>
+          <h4 class="service-heading mt-3 font-weight-bold blue">Donations</h4>
+          <p class="text-muted">
+            Individual donations are appreciated, and are used for things like the project
+            infrastructure, travel expenses for our volunteer contributors to attend
+            the in-person sprints, or to give small grants to develop features.
+          </p>
+          <p>Make your donation in the <a href="donate.html">donate page</a></p>
+        </div>
+      </div>
+    </div>
+</section>
diff --git a/web/pandas/donate.md b/web/pandas/donate.md
new file mode 100644
index 0000000000000..69db7e4648e77
--- /dev/null
+++ b/web/pandas/donate.md
@@ -0,0 +1,14 @@
+# Donate to pandas
+
+<div id="salsalabs-donate-container">
+</div>
+<script type="text/javascript"
+        src="https://default.salsalabs.org/api/widget/template/4ba4e328-1855-47c8-9a89-63e4757d2151/?tId=salsalabs-donate-container">
+</script>
+
+_pandas_ is a Sponsored Project of [NumFOCUS](https://numfocus.org/), a 501(c)(3) nonprofit charity in the United States.
+NumFOCUS provides _pandas_ with fiscal, legal, and administrative support to help ensure the
+health and sustainability of the project. Visit numfocus.org for more information.
+
+Donations to _pandas_ are managed by NumFOCUS. For donors in the United States, your gift is tax-deductible
+to the extent provided by law. As with any donation, you should consult with your tax adviser about your particular tax situation.
diff --git a/web/pandas/getting_started.md b/web/pandas/getting_started.md
new file mode 100644
index 0000000000000..4195cc00b2419
--- /dev/null
+++ b/web/pandas/getting_started.md
@@ -0,0 +1,51 @@
+# Getting started
+
+## Installation instructions
+
+The next steps provides the easiest and recommended way to set up your
+environment to use pandas. Other installation options can be found in
+the [advanced installation page]({{ base_url}}/docs/getting_started/install.html).
+
+1. Download [Anaconda](https://www.anaconda.com/distribution/) for your operating system and
+   the latest Python version, run the installer, and follow the steps. Detailed instructions
+   on how to install Anaconda can be found in the
+   [Anaconda documentation](https://docs.anaconda.com/anaconda/install/).
+
+2. In the Anaconda prompt (or terminal in Linux or MacOS), start JupyterLab:
+
+    <img class="img-fluid" alt="" src="{{ base_url }}/static/img/install/anaconda_prompt.png"/>
+
+3. In JupyterLab, create a new (Python 3) notebook:
+
+    <img class="img-fluid" alt="" src="{{ base_url }}/static/img/install/jupyterlab_home.png"/>
+
+4. In the first cell of the notebook, you can import pandas and check the version with:
+
+    <img class="img-fluid" alt="" src="{{ base_url }}/static/img/install/pandas_import_and_version.png"/>
+
+5. Now you are ready to use pandas, and you can write your code in the next cells.
+
+## Tutorials
+
+You can learn more about pandas in the [tutorials](#), and more about JupyterLab
+in the [JupyterLab documentation](https://jupyterlab.readthedocs.io/en/stable/user/interface.html).
+
+## Books
+
+The book we recommend to learn pandas is [Python for Data Analysis](https://amzn.to/2KI5JJw),
+by [Wes McKinney](https://wesmckinney.com/), creator of pandas.
+
+<a href="https://amzn.to/2KI5JJw">
+    <img alt="Python for Data Analysis" src="{{ base_url }}/static/img/pydata_book.gif"/>
+</a>
+
+## Videos
+
+<iframe width="560" height="315" frameborder="0"
+src="https://www.youtube.com/embed/_T8LGqJtuGc"
+allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture"
+allowfullscreen></iframe>
+
+## Cheat sheet
+
+[pandas cheat sheet](https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf)
diff --git a/web/pandas/index.html b/web/pandas/index.html
new file mode 100644
index 0000000000000..83d0f48197033
--- /dev/null
+++ b/web/pandas/index.html
@@ -0,0 +1,119 @@
+{% extends "layout.html" %}
+{% block body %}
+    <div class="container">
+        <div class="row">
+            <div class="col-md-9">
+                <section class="jumbotron text-center">
+                    <h1>pandas</h1>
+                    <p>
+                        <strong>pandas</strong> is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool,<br/>
+                        built on top of the <a href="https://www.python.org">Python</a> programming language.
+                    </p>
+                    <p>
+                        <a class="btn btn-primary" href="{{ base_url }}/getting_started.html">Install pandas now!</a>
+                    </p>
+                </section>
+
+                <div class="row">
+                    <div class="col-md-4">
+                        <h5>Getting started</h5>
+                        <ul>
+                            <!-- <li><a href="{{ base_url }}/try.html">Try pandas online</a></li> -->
+                            <li><a href="{{ base_url }}/getting_started.html">Install pandas</a></li>
+                            <li><a href="{{ base_url }}/docs/getting_started/index.html">Getting started</a></li>
+                        </ul>
+                    </div>
+                    <div class="col-md-4">
+                        <h5>Documentation</h5>
+                        <ul>
+                            <li><a href="{{ base_url }}/docs/user_guide/index.html">User guide</a></li>
+                            <li><a href="{{ base_url }}/docs/reference/index.html">API reference</a></li>
+                            <li><a href="{{ base_url }}/docs/development/index.html">Contributing to pandas</a></li>
+                            <li><a href="{{ base_url }}/docs/whatsnew/index.html">Release notes</a></li>
+                        </ul>
+                    </div>
+                    <div class="col-md-4">
+                        <h5>Community</h5>
+                        <ul>
+                            <li><a href="{{ base_url }}/about/index.html">About pandas</a></li>
+                            <li><a href="https://stackoverflow.com/questions/tagged/pandas">Ask a question</a></li>
+                            <li><a href="{{ base_url }}/community/ecosystem.html">Ecosystem</a></li>
+                        </ul>
+                    </div>
+                </div>
+                <section>
+                    <h5>With the support of:</h5>
+                    {% for row in sponsors.active | batch(6, "") %}
+                        <div class="row h-100">
+                            {% for company in row %}
+                                <div class="col-sm-6 col-md-2 my-auto">
+                                    {% if company %}
+                                        <a href="{{ company.url }}" target="_blank">
+                                            <img class="img-fluid" alt="{{ company.name }}" src="{{ base_url }}{{ company.logo }}"/>
+                                        </a>
+                                    {% endif %}
+                                </div>
+                            {% endfor %}
+                        </div>
+                    {% endfor %}
+                    <p class="mt-4">The full list of companies supporting <i>pandas</i> is available in the <a href="{{ base_url }}/about/sponsors.html">sponsors page</a>.
+                </section>
+            </div>
+            <div class="col-md-3">
+                {% if releases %}
+                    <h4>Latest version: {{ releases[0].name }}</h4>
+                    <ul>
+                        <li><a href="docs/whatsnew/v1.0.0.html">What's new in {{ releases[0].name }}</a></li>
+                        <li>Release date:<br/>{{ releases[0].published.strftime("%b %d, %Y") }}</li>
+                        <li><a href="{{ base_url}}/docs/">Documentation (web)</a></li>
+                        <li><a href="{{ base_url }}/docs/pandas.pdf">Documentation (pdf)</a></li>
+                        <li><a href="{{ releases[0].url }}">Download source code</a></li>
+                    </ul>
+                {% endif %}
+                <h4>Follow us</h4>
+                <div class="text-center">
+                    <p>
+                        <a href="https://twitter.com/pandas_dev?ref_src=twsrc%5Etfw" class="twitter-follow-button" data-show-count="false">Follow @pandas_dev</a><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
+                    </p>
+                </div>
+				<h4>Get the book</h4>
+				<p class="book">
+					<a href="https://amzn.to/2KI5JJw">
+						<img class="img-fluid" alt="Python for Data Analysis" src="{{ base_url }}/static/img/pydata_book.gif"/>
+					</a>
+				</p>
+                {% if releases[1:5] %}
+                    <h4>Previous versions</h4>
+                    <ul>
+                        {% for release in releases[1:5] %}
+                            <li class="small">
+                                {{ release.name }} ({{ release.published.strftime("%b %d, %Y") }})<br/>
+                                <a href="https://pandas.pydata.org/pandas-docs/stable/whatsnew/{{ release.tag }}.html">changelog</a> |
+                                <a href="https://pandas.pydata.org/pandas-docs/version/{{ release.name }}/">docs</a> |
+                                <a href="https://pandas.pydata.org/pandas-docs/version/{{ release.name }}/pandas.pdf">pdf</a> |
+                                <a href="{{ release.url }}">code</a>
+                            </li>
+                        {% endfor %}
+                    </ul>
+                {% endif %}
+                {% if releases[5:] %}
+                    <p class="text-center">
+                        <a data-toggle="collapse" href="#show-more-releases" role="button" aria-expanded="false" aria-controls="show-more-releases">Show more</a>
+                    </p>
+                    <ul id="show-more-releases" class="collapse">
+                        {% for release in releases[5:] %}
+                            <li class="small">
+                                {{ release.name }} ({{ release.published.strftime("%Y-%m-%d") }})<br/>
+                                <a href="https://pandas.pydata.org/pandas-docs/stable/whatsnew/{{ release.tag }}.html">changelog</a> |
+                                <a href="https://pandas.pydata.org/pandas-docs/version/{{ release.name }}/">docs</a> |
+                                <a href="https://pandas.pydata.org/pandas-docs/version/{{ release.name }}/pandas.pdf">pdf</a> |
+                                <a href="{{ release.url }}">code</a>
+                            </li>
+                        {% endfor %}
+                    </ul>
+                {% endif %}
+            </div>
+        </div>
+    </div>
+
+{% endblock %}
diff --git a/web/pandas/static/css/pandas.css b/web/pandas/static/css/pandas.css
new file mode 100644
index 0000000000000..b27ec6d42cc11
--- /dev/null
+++ b/web/pandas/static/css/pandas.css
@@ -0,0 +1,66 @@
+body {
+    padding-top: 5em;
+    color: #444;
+}
+h1 {
+    font-size: 2.4rem;
+    font-weight: 700;
+    color: #130654;
+}
+h2 {
+    font-size: 1.45rem;
+    font-weight: 700;
+    color: black;
+}
+h3 {
+    font-size: 1.3rem;
+    font-weight: 600;
+    color: black;
+}
+a {
+    color: #130654;
+}
+code {
+    white-space: pre;
+}
+.blue {
+    color: #150458;
+}
+.pink {
+    color: #e70488;
+}
+.fab {
+    font-size: 1.2rem;
+    color: #666;
+}
+.fab:hover {
+    color: #130654;
+}
+a.navbar-brand img {
+    height: 3rem;
+}
+div.card {
+    margin: 0 0 .2em .2em !important;
+}
+div.card .card-title {
+    font-weight: 500;
+    color: #130654;
+}
+.book {
+    padding: 0 20%;
+}
+.bg-dark {
+    background-color: #130654 !important;
+}
+.navbar-dark .navbar-nav .nav-link {
+    color: rgba(255, 255, 255, .9);
+}
+.navbar-dark .navbar-nav .nav-link:hover {
+    color: white;
+}
+table.logo td {
+    text-align: center;
+}
+table.logo img {
+    height: 4rem;
+}
diff --git a/web/pandas/static/img/favicon.ico b/web/pandas/static/img/favicon.ico
new file mode 100644
index 0000000000000..0af2443dcaa3e
Binary files /dev/null and b/web/pandas/static/img/favicon.ico differ
diff --git a/web/pandas/static/img/install/anaconda_prompt.png b/web/pandas/static/img/install/anaconda_prompt.png
new file mode 100644
index 0000000000000..7b547e4ebb02a
Binary files /dev/null and b/web/pandas/static/img/install/anaconda_prompt.png differ
diff --git a/web/pandas/static/img/install/jupyterlab_home.png b/web/pandas/static/img/install/jupyterlab_home.png
new file mode 100644
index 0000000000000..c62d33a5e0fc6
Binary files /dev/null and b/web/pandas/static/img/install/jupyterlab_home.png differ
diff --git a/web/pandas/static/img/install/pandas_import_and_version.png b/web/pandas/static/img/install/pandas_import_and_version.png
new file mode 100644
index 0000000000000..64c1303ac495c
Binary files /dev/null and b/web/pandas/static/img/install/pandas_import_and_version.png differ
diff --git a/web/pandas/static/img/pandas.svg b/web/pandas/static/img/pandas.svg
new file mode 100644
index 0000000000000..a7af4e4d2d401
--- /dev/null
+++ b/web/pandas/static/img/pandas.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 818.63 331.21"><defs><style>.cls-1{fill:#130754;}.cls-2{fill:#ffca00;}.cls-3{fill:#e70488;}</style></defs><title>Artboard 63</title><path class="cls-1" d="M290.85,199.21c-10.27,0-20.73-4.25-27.28-12.58v45H243l0-111.09h18.6l.71,12.22c6.38-9.39,17.71-14.35,28.52-14.35,20.73,0,36,17.37,36,40.4S311.58,199.22,290.85,199.21Zm-6.37-65.55c-12.05,0-21.79,9.39-21.79,25.16S272.43,184,284.48,184s21.79-9.39,21.79-25.16S296.53,133.66,284.48,133.66Z"/><path class="cls-1" d="M404.36,197.1l-.71-12.22c-6.38,9.39-17.72,14.35-28.53,14.34-20.73,0-36-17.36-36-40.39s15.24-40.4,36-40.39c10.81,0,22.15,5,28.53,14.35l.71-12.22H423V197.1Zm-22.85-63.43c-12.05,0-21.79,9.39-21.8,25.16S369.45,184,381.5,184s21.8-9.39,21.8-25.16S393.56,133.67,381.51,133.67Z"/><path class="cls-1" d="M494.87,197.11V154.77c0-14.88-5.13-19.84-14.52-19.84-9.75,0-20.38,8.85-20.38,19.48v42.7H439.41V120.57H458.2l.89,14.18c5.14-9.75,16.65-16.3,28.35-16.3,20.37,0,28,14.18,28,33.13v45.54Z"/><path class="cls-1" d="M590.77,197.13l-.71-12.23c-6.38,9.39-17.72,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.39,36-40.39c10.27,0,20.72,4.26,27.28,12.58V90.83h20.56l0,106.3ZM567.92,133.7c-12,0-21.79,9.39-21.79,25.15S555.87,184,567.92,184s21.79-9.38,21.79-25.15S580,133.7,567.92,133.7Z"/><path class="cls-1" d="M686.6,197.14l-.71-12.22c-6.38,9.39-17.72,14.34-28.53,14.34-20.73,0-36-17.36-36-40.4s15.24-40.39,36-40.39c10.81,0,22.15,5,28.53,14.36l.71-12.23h18.6v76.53Zm-22.85-63.43c-12,0-21.79,9.39-21.8,25.16S651.7,184,663.74,184s21.8-9.39,21.8-25.16S675.8,133.71,663.75,133.71Z"/><path class="cls-1" d="M750.73,199.63a60.16,60.16,0,0,1-30.65-8.69l3.37-14.17c6.2,3.72,15.59,8.51,26.93,8.51,8.15,0,13.82-2.48,13.82-8.86,0-5.49-5.85-7.44-16.3-9.92-18.78-4.08-25.51-14-25.51-24.81,0-12.05,9.39-23.38,30.12-23.38,12.58,0,23.57,5.49,26,6.91l-3.37,13.47A44.59,44.59,0,0,0,753,132.31c-8.32,0-12.4,2.83-12.4,7.44,0,5.13,5.32,7.44,13.46,9.39,20.2,4.25,28.35,13.64,28.35,23.92C782.45,189.53,770.4,199.63,750.73,199.63Z"/><rect class="cls-1" x="74.88" y="68.42" width="24.09" height="50.02"/><rect class="cls-1" x="74.88" y="171.17" width="24.09" height="50.02"/><rect class="cls-2" x="74.88" y="133.04" width="24.09" height="23.6"/><rect class="cls-1" x="36.19" y="109.55" width="24.09" height="166.27"/><rect class="cls-1" x="112.78" y="212.44" width="24.09" height="50.02"/><rect class="cls-1" x="112.78" y="109.61" width="24.09" height="50.02"/><rect class="cls-3" x="112.78" y="174.23" width="24.09" height="23.6"/><rect class="cls-1" x="150.67" y="55.39" width="24.09" height="166.27"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/pandas_mark.svg b/web/pandas/static/img/pandas_mark.svg
new file mode 100644
index 0000000000000..1451f57de198e
--- /dev/null
+++ b/web/pandas/static/img/pandas_mark.svg
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="Layer_1"
+   data-name="Layer 1"
+   viewBox="0 0 210.21 280.43"
+   version="1.1"
+   sodipodi:docname="pandas_mark.svg"
+   inkscape:version="0.92.4 (unknown)">
+  <metadata
+     id="metadata27">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1131"
+     inkscape:window-height="921"
+     id="namedview25"
+     showgrid="false"
+     inkscape:zoom="0.84156476"
+     inkscape:cx="107.48153"
+     inkscape:cy="140.215"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="Layer_1" />
+  <defs
+     id="defs4">
+    <style
+       id="style2">.cls-1{fill:#130754;}.cls-2{fill:#48e5ac;}.cls-3{fill:#e70488;}</style>
+  </defs>
+  <title
+     id="title6">Artboard 61</title>
+  <rect
+     class="cls-1"
+     x="74.51"
+     y="43.03"
+     width="24.09"
+     height="50.02"
+     id="rect8" />
+  <rect
+     class="cls-1"
+     x="74.51"
+     y="145.78"
+     width="24.09"
+     height="50.02"
+     id="rect10" />
+  <rect
+     class="cls-2"
+     x="74.51"
+     y="107.65"
+     width="24.09"
+     height="23.6"
+     id="rect12"
+     style="fill:#ffca00;fill-opacity:1" />
+  <rect
+     class="cls-1"
+     x="35.81"
+     y="84.15"
+     width="24.09"
+     height="166.27"
+     id="rect14" />
+  <rect
+     class="cls-1"
+     x="112.41"
+     y="187.05"
+     width="24.09"
+     height="50.02"
+     id="rect16" />
+  <rect
+     class="cls-1"
+     x="112.41"
+     y="84.21"
+     width="24.09"
+     height="50.02"
+     id="rect18" />
+  <rect
+     class="cls-3"
+     x="112.41"
+     y="148.84"
+     width="24.09"
+     height="23.6"
+     id="rect20" />
+  <rect
+     class="cls-1"
+     x="150.3"
+     y="30"
+     width="24.09"
+     height="166.27"
+     id="rect22" />
+</svg>
diff --git a/web/pandas/static/img/pandas_mark_white.svg b/web/pandas/static/img/pandas_mark_white.svg
new file mode 100644
index 0000000000000..ae50bf5430c3a
--- /dev/null
+++ b/web/pandas/static/img/pandas_mark_white.svg
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="Layer_1"
+   data-name="Layer 1"
+   viewBox="0 0 210.21 280.43"
+   version="1.1"
+   sodipodi:docname="pandas_mark_white.svg"
+   inkscape:version="0.92.4 (unknown)">
+  <metadata
+     id="metadata27">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="761"
+     inkscape:window-height="480"
+     id="namedview25"
+     showgrid="false"
+     inkscape:zoom="0.84156476"
+     inkscape:cx="105.105"
+     inkscape:cy="140.215"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="Layer_1" />
+  <defs
+     id="defs4">
+    <style
+       id="style2">.cls-1{fill:#fff;}.cls-2{fill:#48e5ac;}.cls-3{fill:#e70488;}</style>
+  </defs>
+  <title
+     id="title6">Artboard 61 copy</title>
+  <rect
+     class="cls-1"
+     x="74.51"
+     y="43.03"
+     width="24.09"
+     height="50.02"
+     id="rect8" />
+  <rect
+     class="cls-1"
+     x="74.51"
+     y="145.78"
+     width="24.09"
+     height="50.02"
+     id="rect10" />
+  <rect
+     class="cls-2"
+     x="74.51"
+     y="107.65"
+     width="24.09"
+     height="23.6"
+     id="rect12"
+     style="fill:#ffca00;fill-opacity:1" />
+  <rect
+     class="cls-1"
+     x="35.81"
+     y="84.15"
+     width="24.09"
+     height="166.27"
+     id="rect14" />
+  <rect
+     class="cls-1"
+     x="112.41"
+     y="187.05"
+     width="24.09"
+     height="50.02"
+     id="rect16" />
+  <rect
+     class="cls-1"
+     x="112.41"
+     y="84.21"
+     width="24.09"
+     height="50.02"
+     id="rect18" />
+  <rect
+     class="cls-3"
+     x="112.41"
+     y="148.84"
+     width="24.09"
+     height="23.6"
+     id="rect20" />
+  <rect
+     class="cls-1"
+     x="150.3"
+     y="30"
+     width="24.09"
+     height="166.27"
+     id="rect22" />
+</svg>
diff --git a/web/pandas/static/img/pandas_secondary.svg b/web/pandas/static/img/pandas_secondary.svg
new file mode 100644
index 0000000000000..e74404842e5b6
--- /dev/null
+++ b/web/pandas/static/img/pandas_secondary.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 664.97 470.93"><defs><style>.cls-1{fill:#130754;}.cls-2{fill:#ffca00;}.cls-3{fill:#e70488;}</style></defs><title>Artboard 57</title><path class="cls-1" d="M110.61,397.48c-10.28,0-20.73-4.25-27.29-12.58v45H62.76l0-111.08h18.6L82.09,331c6.38-9.39,17.72-14.35,28.53-14.34,20.72,0,36,17.36,36,40.4S131.33,397.49,110.61,397.48Zm-6.37-65.55c-12,0-21.8,9.39-21.8,25.16s9.74,25.16,21.79,25.16S126,372.86,126,357.09,116.28,331.93,104.24,331.93Z"/><path class="cls-1" d="M224.11,395.37l-.71-12.22c-6.38,9.39-17.72,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.4,36-40.39c10.8,0,22.14,5,28.52,14.35l.71-12.22h18.6v76.54Zm-22.85-63.43c-12,0-21.79,9.39-21.79,25.16s9.74,25.16,21.79,25.16,21.79-9.39,21.79-25.15S213.31,332,201.26,331.94Z"/><path class="cls-1" d="M314.62,395.39V353c0-14.88-5.14-19.84-14.53-19.84-9.74,0-20.37,8.85-20.38,19.48v42.7H259.17V318.84H278l.88,14.18c5.14-9.75,16.66-16.3,28.35-16.3,20.37,0,28,14.18,28,33.14v45.53Z"/><path class="cls-1" d="M410.52,395.4l-.71-12.23c-6.37,9.39-17.71,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.39,36-40.39c10.27,0,20.73,4.26,27.28,12.59V289.1h20.55l0,106.3ZM387.68,332c-12.05,0-21.8,9.39-21.8,25.16s9.74,25.15,21.79,25.16,21.79-9.39,21.79-25.16S399.72,332,387.68,332Z"/><path class="cls-1" d="M506.35,395.41l-.71-12.22c-6.38,9.39-17.72,14.35-28.52,14.34-20.73,0-36-17.36-36-40.39s15.24-40.4,36-40.39c10.8,0,22.14,5,28.52,14.35l.71-12.22H525v76.53ZM483.5,332c-12.05,0-21.79,9.39-21.79,25.16s9.74,25.16,21.79,25.16,21.79-9.39,21.79-25.16S495.55,332,483.5,332Z"/><path class="cls-1" d="M570.49,397.9a60.15,60.15,0,0,1-30.65-8.68L543.2,375c6.2,3.72,15.59,8.51,26.93,8.51,8.15,0,13.82-2.48,13.82-8.86,0-5.49-5.84-7.44-16.3-9.92-18.77-4.08-25.51-14-25.5-24.81,0-12,9.39-23.38,30.12-23.38,12.58,0,23.56,5.5,26,6.91L594.94,337a44.52,44.52,0,0,0-22.14-6.38c-8.33,0-12.41,2.83-12.41,7.44,0,5.13,5.32,7.44,13.47,9.39,20.19,4.25,28.34,13.64,28.34,23.92C602.2,387.81,590.15,397.9,570.49,397.9Z"/><rect class="cls-1" x="301.89" y="54.05" width="24.09" height="50.02"/><rect class="cls-1" x="301.89" y="156.8" width="24.09" height="50.02"/><rect class="cls-2" x="301.89" y="118.68" width="24.09" height="23.6"/><rect class="cls-1" x="263.19" y="95.18" width="24.09" height="166.27"/><rect class="cls-1" x="339.79" y="198.07" width="24.09" height="50.02"/><rect class="cls-1" x="339.79" y="95.24" width="24.09" height="50.02"/><rect class="cls-3" x="339.79" y="159.86" width="24.09" height="23.6"/><rect class="cls-1" x="377.68" y="41.03" width="24.09" height="166.27"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/pandas_secondary_white.svg b/web/pandas/static/img/pandas_secondary_white.svg
new file mode 100644
index 0000000000000..86bcca57a031e
--- /dev/null
+++ b/web/pandas/static/img/pandas_secondary_white.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 664.97 470.93"><defs><style>.cls-1{fill:#fff;}.cls-2{fill:#ffca00;}.cls-3{fill:#e70488;}</style></defs><title>Artboard 57 copy</title><path class="cls-1" d="M110.61,397.48c-10.28,0-20.73-4.25-27.29-12.58v45H62.76l0-111.08h18.6L82.09,331c6.38-9.39,17.72-14.35,28.53-14.34,20.72,0,36,17.36,36,40.4S131.33,397.49,110.61,397.48Zm-6.37-65.55c-12,0-21.8,9.39-21.8,25.16s9.74,25.16,21.79,25.16S126,372.86,126,357.09,116.28,331.93,104.24,331.93Z"/><path class="cls-1" d="M224.11,395.37l-.71-12.22c-6.38,9.39-17.72,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.4,36-40.39c10.8,0,22.14,5,28.52,14.35l.71-12.22h18.6v76.54Zm-22.85-63.43c-12,0-21.79,9.39-21.79,25.16s9.74,25.16,21.79,25.16,21.79-9.39,21.79-25.15S213.31,332,201.26,331.94Z"/><path class="cls-1" d="M314.62,395.39V353c0-14.88-5.14-19.84-14.53-19.84-9.74,0-20.37,8.85-20.38,19.48v42.7H259.17V318.84H278l.88,14.18c5.14-9.75,16.66-16.3,28.35-16.3,20.37,0,28,14.18,28,33.14v45.53Z"/><path class="cls-1" d="M410.52,395.4l-.71-12.23c-6.37,9.39-17.71,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.39,36-40.39c10.27,0,20.73,4.26,27.28,12.59V289.1h20.55l0,106.3ZM387.68,332c-12.05,0-21.8,9.39-21.8,25.16s9.74,25.15,21.79,25.16,21.79-9.39,21.79-25.16S399.72,332,387.68,332Z"/><path class="cls-1" d="M506.35,395.41l-.71-12.22c-6.38,9.39-17.72,14.35-28.52,14.34-20.73,0-36-17.36-36-40.39s15.24-40.4,36-40.39c10.8,0,22.14,5,28.52,14.35l.71-12.22H525v76.53ZM483.5,332c-12.05,0-21.79,9.39-21.79,25.16s9.74,25.16,21.79,25.16,21.79-9.39,21.79-25.16S495.55,332,483.5,332Z"/><path class="cls-1" d="M570.49,397.9a60.15,60.15,0,0,1-30.65-8.68L543.2,375c6.2,3.72,15.59,8.51,26.93,8.51,8.15,0,13.82-2.48,13.82-8.86,0-5.49-5.84-7.44-16.3-9.92-18.77-4.08-25.51-14-25.5-24.81,0-12,9.39-23.38,30.12-23.38,12.58,0,23.56,5.5,26,6.91L594.94,337a44.52,44.52,0,0,0-22.14-6.38c-8.33,0-12.41,2.83-12.41,7.44,0,5.13,5.32,7.44,13.47,9.39,20.19,4.25,28.34,13.64,28.34,23.92C602.2,387.81,590.15,397.9,570.49,397.9Z"/><rect class="cls-1" x="301.89" y="54.05" width="24.09" height="50.02"/><rect class="cls-1" x="301.89" y="156.8" width="24.09" height="50.02"/><rect class="cls-2" x="301.89" y="118.68" width="24.09" height="23.6"/><rect class="cls-1" x="263.19" y="95.18" width="24.09" height="166.27"/><rect class="cls-1" x="339.79" y="198.07" width="24.09" height="50.02"/><rect class="cls-1" x="339.79" y="95.24" width="24.09" height="50.02"/><rect class="cls-3" x="339.79" y="159.86" width="24.09" height="23.6"/><rect class="cls-1" x="377.68" y="41.03" width="24.09" height="166.27"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/pandas_white.svg b/web/pandas/static/img/pandas_white.svg
new file mode 100644
index 0000000000000..bc7c41651182d
--- /dev/null
+++ b/web/pandas/static/img/pandas_white.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 818.63 331.21"><defs><style>.cls-1{fill:#fff;}.cls-2{fill:#ffca00;}.cls-3{fill:#e70488;}</style></defs><title>Artboard 63 copy 2</title><path class="cls-1" d="M290.85,199.21c-10.27,0-20.73-4.25-27.28-12.58v45H243l0-111.09h18.6l.71,12.22c6.38-9.39,17.71-14.35,28.52-14.35,20.73,0,36,17.37,36,40.4S311.58,199.22,290.85,199.21Zm-6.37-65.55c-12.05,0-21.79,9.39-21.79,25.16S272.43,184,284.48,184s21.79-9.39,21.79-25.16S296.53,133.66,284.48,133.66Z"/><path class="cls-1" d="M404.36,197.1l-.71-12.22c-6.38,9.39-17.72,14.35-28.53,14.34-20.73,0-36-17.36-36-40.39s15.24-40.4,36-40.39c10.81,0,22.15,5,28.53,14.35l.71-12.22H423V197.1Zm-22.85-63.43c-12.05,0-21.79,9.39-21.8,25.16S369.45,184,381.5,184s21.8-9.39,21.8-25.16S393.56,133.67,381.51,133.67Z"/><path class="cls-1" d="M494.87,197.11V154.77c0-14.88-5.13-19.84-14.52-19.84-9.75,0-20.38,8.85-20.38,19.48v42.7H439.41V120.57H458.2l.89,14.18c5.14-9.75,16.65-16.3,28.35-16.3,20.37,0,28,14.18,28,33.13v45.54Z"/><path class="cls-1" d="M590.77,197.13l-.71-12.23c-6.38,9.39-17.72,14.35-28.52,14.35-20.73,0-36-17.37-36-40.4s15.24-40.39,36-40.39c10.27,0,20.72,4.26,27.28,12.58V90.83h20.56l0,106.3ZM567.92,133.7c-12,0-21.79,9.39-21.79,25.15S555.87,184,567.92,184s21.79-9.38,21.79-25.15S580,133.7,567.92,133.7Z"/><path class="cls-1" d="M686.6,197.14l-.71-12.22c-6.38,9.39-17.72,14.34-28.53,14.34-20.73,0-36-17.36-36-40.4s15.24-40.39,36-40.39c10.81,0,22.15,5,28.53,14.36l.71-12.23h18.6v76.53Zm-22.85-63.43c-12,0-21.79,9.39-21.8,25.16S651.7,184,663.74,184s21.8-9.39,21.8-25.16S675.8,133.71,663.75,133.71Z"/><path class="cls-1" d="M750.73,199.63a60.16,60.16,0,0,1-30.65-8.69l3.37-14.17c6.2,3.72,15.59,8.51,26.93,8.51,8.15,0,13.82-2.48,13.82-8.86,0-5.49-5.85-7.44-16.3-9.92-18.78-4.08-25.51-14-25.51-24.81,0-12.05,9.39-23.38,30.12-23.38,12.58,0,23.57,5.49,26,6.91l-3.37,13.47A44.59,44.59,0,0,0,753,132.31c-8.32,0-12.4,2.83-12.4,7.44,0,5.13,5.32,7.44,13.46,9.39,20.2,4.25,28.35,13.64,28.35,23.92C782.45,189.53,770.4,199.63,750.73,199.63Z"/><rect class="cls-1" x="74.88" y="68.42" width="24.09" height="50.02"/><rect class="cls-1" x="74.88" y="171.17" width="24.09" height="50.02"/><rect class="cls-2" x="74.88" y="133.04" width="24.09" height="23.6"/><rect class="cls-1" x="36.19" y="109.55" width="24.09" height="166.27"/><rect class="cls-1" x="112.78" y="212.44" width="24.09" height="50.02"/><rect class="cls-1" x="112.78" y="109.61" width="24.09" height="50.02"/><rect class="cls-3" x="112.78" y="174.23" width="24.09" height="23.6"/><rect class="cls-1" x="150.67" y="55.39" width="24.09" height="166.27"/></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/anaconda.svg b/web/pandas/static/img/partners/anaconda.svg
new file mode 100644
index 0000000000000..fcddf72ebaa28
--- /dev/null
+++ b/web/pandas/static/img/partners/anaconda.svg
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   viewBox="0 0 530.44 90.053329"
+   height="90.053329"
+   width="530.44"
+   xml:space="preserve"
+   id="svg2"
+   version="1.1"><metadata
+     id="metadata8"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /></cc:Work></rdf:RDF></metadata><defs
+     id="defs6" /><g
+     transform="matrix(1.3333333,0,0,-1.3333333,0,90.053333)"
+     id="g10"><g
+       transform="scale(0.1)"
+       id="g12"><path
+         id="path14"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 958.313,274.5 53.637,120.406 h 1.64 L 1068.32,274.5 Z m 67.867,251.754 c -1.65,3.285 -3.83,6.027 -9.31,6.027 h -5.47 c -4.93,0 -7.66,-2.742 -9.31,-6.027 L 831.887,157.93 c -3.282,-7.117 1.097,-14.231 9.304,-14.231 h 47.618 c 8.754,0 13.679,5.473 15.867,10.942 l 26.82,59.113 h 163.644 l 26.81,-59.113 c 3.83,-7.657 7.66,-10.942 15.88,-10.942 h 47.61 c 8.21,0 12.59,7.114 9.3,14.231 l -168.56,368.324" /><path
+         id="path16"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 1547.94,526.801 h -50.35 c -6.03,0 -10.4,-4.922 -10.4,-10.395 V 290.371 h -0.55 l -227.67,241.91 h -13.68 c -5.48,0 -10.4,-4.383 -10.4,-9.855 V 154.102 c 0,-5.481 4.92,-10.403 10.4,-10.403 h 49.8 c 6.02,0 10.4,4.922 10.4,10.403 v 235.332 h 0.54 L 1534.8,138.227 h 13.14 c 5.47,0 10.4,4.378 10.4,9.847 v 368.332 c 0,5.473 -4.93,10.395 -10.4,10.395" /><path
+         id="path18"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 1725.97,274.5 53.64,120.406 h 1.64 L 1835.98,274.5 Z m 67.87,251.754 c -1.64,3.285 -3.83,6.027 -9.31,6.027 h -5.47 c -4.93,0 -7.66,-2.742 -9.31,-6.027 L 1599.55,157.93 c -3.29,-7.117 1.09,-14.231 9.3,-14.231 h 47.62 c 8.75,0 13.68,5.473 15.87,10.942 l 26.82,59.113 h 163.64 l 26.81,-59.113 c 3.83,-7.657 7.67,-10.942 15.88,-10.942 h 47.61 c 8.21,0 12.59,7.114 9.3,14.231 l -168.56,368.324" /><path
+         id="path20"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 2261.6,241.117 c -3.29,3.285 -9.31,3.836 -13.69,0 -22.98,-18.605 -50.9,-31.191 -83.73,-31.191 -70.06,0 -122.6,58.008 -122.6,126.418 0,68.965 51.99,127.519 122.05,127.519 30.64,0 61.3,-12.039 84.28,-32.285 4.38,-4.379 9.85,-4.379 13.69,0 l 33.38,34.477 c 4.38,4.375 4.38,10.941 -0.55,15.328 -37.21,33.383 -77.17,50.898 -132.45,50.898 -109.45,0 -197.57,-88.117 -197.57,-197.574 0,-109.465 88.12,-196.48 197.57,-196.48 48.72,0 95.78,16.964 133,53.086 3.83,3.835 4.92,10.949 0.55,14.777 l -33.93,35.027" /><path
+         id="path22"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 2520.21,209.379 c -68.95,0 -125.33,56.371 -125.33,125.328 0,68.957 56.38,126.426 125.33,126.426 68.96,0 125.88,-57.469 125.88,-126.426 0,-68.957 -56.92,-125.328 -125.88,-125.328 z m 0,322.902 c -109.46,0 -196.48,-88.117 -196.48,-197.574 0,-109.465 87.02,-196.48 196.48,-196.48 109.46,0 197.03,87.015 197.03,196.48 0,109.457 -87.57,197.574 -197.03,197.574" /><path
+         id="path24"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 3090.17,526.801 h -50.35 c -6.02,0 -10.4,-4.922 -10.4,-10.395 V 290.371 h -0.54 l -227.68,241.91 h -13.68 c -5.47,0 -10.4,-4.383 -10.4,-9.855 V 154.102 c 0,-5.481 4.93,-10.403 10.4,-10.403 h 49.8 c 6.02,0 10.4,4.922 10.4,10.403 v 235.332 h 0.55 l 228.77,-251.207 h 13.13 c 5.47,0 10.4,4.378 10.4,9.847 v 368.332 c 0,5.473 -4.93,10.395 -10.4,10.395" /><path
+         id="path26"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 3303.16,210.465 h -62.39 v 250.121 h 62.39 c 71.15,0 123.14,-53.641 123.14,-124.785 0,-71.696 -51.99,-125.336 -123.14,-125.336 z m 6.57,316.336 h -129.71 c -5.47,0 -9.85,-4.922 -9.85,-10.395 V 154.102 c 0,-5.481 4.38,-10.403 9.85,-10.403 h 129.71 c 105.63,0 192.1,85.926 192.1,192.102 0,105.082 -86.47,191 -192.1,191" /><path
+         id="path28"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 3631.32,274.5 53.64,120.406 h 1.64 L 3741.33,274.5 Z m 236.43,-116.57 -168.57,368.324 c -1.64,3.285 -3.82,6.027 -9.29,6.027 h -5.48 c -4.93,0 -7.67,-2.742 -9.3,-6.027 L 3504.9,157.93 c -3.29,-7.117 1.09,-14.231 9.3,-14.231 h 47.62 c 8.76,0 13.68,5.473 15.87,10.942 l 26.82,59.113 h 163.63 l 26.83,-59.113 c 3.82,-7.657 7.66,-10.942 15.86,-10.942 h 47.62 c 8.21,0 12.59,7.114 9.3,14.231" /><path
+         id="path30"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 3940.9,176.27 h 7.99 c 2.7,0 4.5,-1.793 4.5,-4.403 0,-2.422 -1.8,-4.394 -4.5,-4.394 h -7.99 z m -4.85,-26.582 h 3.33 c 0.99,0 1.7,0.808 1.7,1.707 v 10.148 h 5.57 l 4.49,-10.598 c 0.27,-0.629 0.9,-1.257 1.62,-1.257 h 4.04 c 1.26,0 2.16,1.257 1.53,2.425 -1.53,3.235 -3.15,6.645 -4.76,9.969 2.69,0.984 6.82,3.5 6.82,9.879 0,6.824 -5.48,10.594 -11.04,10.594 h -13.3 c -0.98,0 -1.7,-0.809 -1.7,-1.703 v -29.457 c 0,-0.899 0.72,-1.707 1.7,-1.707" /><path
+         id="path32"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 3945.93,192.078 c 14.46,0 26.05,-11.586 26.05,-26.043 0,-14.371 -11.59,-26.047 -26.05,-26.047 -14.37,0 -26.04,11.676 -26.04,26.047 0,14.457 11.67,26.043 26.04,26.043 z m 0,-58.285 c 17.79,0 32.33,14.461 32.33,32.242 0,17.781 -14.54,32.328 -32.33,32.328 -17.78,0 -32.24,-14.547 -32.24,-32.328 0,-17.781 14.46,-32.242 32.24,-32.242" /><path
+         id="path34"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 125.527,158.422 0.051,2.484 c 0.414,19.649 1.977,39.149 4.684,57.961 l 0.254,1.77 -1.668,0.679 c -17.871,7.305 -35.4574,15.782 -52.2699,25.219 l -2.1172,1.184 -1.0742,-2.16 C 62.3164,223.238 52.9844,199.707 45.6836,175.602 l -0.7031,-2.254 2.2812,-0.629 C 72.0234,165.91 97.5195,161.184 123.051,158.66 l 2.476,-0.238" /><path
+         id="path36"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 177.781,500.941 c 0.032,0.196 0.063,0.395 0.094,0.59 -14.668,-0.258 -29.324,-1.265 -43.926,-2.965 1.891,-14.777 4.481,-29.437 7.828,-43.925 10.02,16.949 22.121,32.511 36.004,46.3" /><path
+         id="path38"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 125.527,140.855 -0.039,2.051 -2.043,0.199 c -21.406,2.02 -43.2223,5.661 -64.8278,10.821 l -5.668,1.355 3.211,-4.855 C 75.5742,121.098 99.3125,95.0195 126.73,72.9258 l 4.43,-3.5899 -0.719,5.668 c -2.906,22.6719 -4.554,44.8321 -4.914,65.8511" /><path
+         id="path40"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 230.566,657.227 c -26.32,-9.008 -51.164,-21.161 -74.101,-36.036 17.359,-3.07 34.469,-7.097 51.273,-12.027 6.696,16.375 14.297,32.426 22.828,48.063" /><path
+         id="path42"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 339.918,675.43 c -13.023,0 -25.848,-0.813 -38.488,-2.25 17.925,-12.489 35.066,-26.145 51.238,-41.051 l 13.43,-12.391 -13.168,-12.672 c -10.899,-10.488 -21.559,-21.898 -31.688,-33.918 l -0.512,-0.585 c -0.117,-0.125 -2.003,-2.219 -5.152,-6.055 8,0.84 16.117,1.293 24.34,1.293 127.07,0 230.086,-103.016 230.086,-230.086 0,-127.074 -103.016,-230.086 -230.086,-230.086 -44.094,0 -85.277,12.426 -120.277,33.934 -17.27,-1.918 -34.629,-2.922 -52.012,-2.922 -8.074,0 -16.152,0.211 -24.227,0.629 0.524,-26.172 3.016,-53.3052 7.477,-81.438 C 204.82,21.3242 269.879,0 339.918,0 c 186.516,0 337.715,151.199 337.715,337.715 0,186.512 -151.199,337.715 -337.715,337.715" /><path
+         id="path44"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 295.145,595.602 c 6.726,7.968 13.671,15.695 20.765,23.101 -15.824,13.469 -32.531,25.758 -50.004,36.856 -10.742,-18.161 -20.09,-36.977 -28.093,-56.282 15.195,-5.574 30.066,-11.953 44.589,-19.031 6.711,8.617 11.399,13.883 12.743,15.356" /><path
+         id="path46"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 65.9219,402.934 1.289,-2.09 2.0118,1.433 c 15.6289,11.235 32.0823,21.594 48.9103,30.789 l 1.582,0.864 -0.449,1.738 c -5.028,19.227 -8.868,39.055 -11.414,58.941 l -0.305,2.399 -2.387,-0.434 C 80.168,492.027 55.4609,485.344 31.7383,476.703 l -2.2227,-0.816 0.8789,-2.188 c 9.7422,-24.562 21.6914,-48.363 35.5274,-70.765" /><path
+         id="path48"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="M 62.0469,370.18 60.125,368.629 C 41.9492,353.844 24.7266,337.414 8.93359,319.797 L 7.375,318.066 9.13281,316.531 C 26.6641,301.188 45.5547,287.094 65.2734,274.645 l 2.0274,-1.293 1.2031,2.097 c 8.8828,15.781 18.8945,31.356 29.7695,46.278 l 1.0938,1.503 -1.2383,1.383 c -12.3281,13.746 -23.9883,28.395 -34.668,43.547 l -1.414,2.02" /><path
+         id="path50"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 194.48,157.273 5.868,0.348 -4.559,3.723 c -17.976,14.715 -33.625,32.09 -46.453,51.656 l -0.106,0.621 -3.75,1.649 -0.433,-3.184 c -2.262,-16.856 -3.586,-34.566 -3.945,-52.625 l -0.039,-2.215 2.207,-0.129 c 8.003,-0.429 16.078,-0.644 24.171,-0.644 9.004,0 18.032,0.269 27.039,0.8" /><path
+         id="path52"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 183.219,530.238 c 3.633,16.649 8.109,33.121 13.511,49.317 -21.125,6.078 -42.769,10.617 -64.789,13.523 -1.867,-22.047 -2.082,-44.082 -0.707,-65.941 17.278,1.988 34.629,3.011 51.985,3.101" /><path
+         id="path54"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 215.813,531.414 c 14.707,9.441 30.539,17.266 47.281,23.195 -11.875,5.59 -24,10.661 -36.348,15.184 -4.219,-12.633 -7.863,-25.441 -10.933,-38.379" /><path
+         id="path56"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 58.6914,257.121 -1.7773,1.113 C 39.4922,269.16 22.6055,281.363 6.74609,294.496 l -4.51953,3.742 0.76953,-5.812 C 7.30078,260.039 16.2734,228.496 29.6406,198.684 l 2.3672,-5.278 1.9024,5.465 c 6.6406,19.125 14.6601,38.102 23.8281,56.387 l 0.9531,1.863" /><path
+         id="path58"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="M 102.133,577.48 C 81.9766,557.492 64.3555,534.969 49.7266,510.445 c 17.4804,5.215 35.1836,9.371 53.0194,12.528 -1.23,18.082 -1.465,36.273 -0.613,54.507" /><path
+         id="path60"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 112.121,340.762 0.234,5.824 c 0.79,20.598 4.309,40.855 10.461,60.195 l 1.793,5.653 -5.129,-2.961 c -13.152,-7.59 -26.1792,-16.012 -38.7222,-25.047 l -1.8281,-1.328 1.293,-1.86 c 8.6992,-12.406 18.1562,-24.535 28.0973,-36.062 l 3.801,-4.414" /><path
+         id="path62"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 114.383,305.906 -0.805,5.707 -3.34,-4.691 C 100.836,293.727 92.082,279.945 84.2227,265.961 l -1.1133,-1.992 1.9922,-1.133 c 14.1562,-7.984 29.0114,-15.305 44.1564,-21.762 l 5.402,-2.316 -2.406,5.363 c -8.863,19.668 -14.875,40.453 -17.871,61.785" /><path
+         id="path64"
+         style="fill:#43b53b;fill-opacity:1;fill-rule:nonzero;stroke:none"
+         d="m 48.6602,386.676 1.5976,1.273 -1.0781,1.735 c -10.5859,16.918 -20.1836,34.707 -28.5469,52.867 l -2.457,5.355 -1.8125,-5.605 C 6.51172,411.789 1.05859,379.887 0.160156,347.473 L 0,341.523 4.10938,345.82 c 14.01172,14.598 28.99612,28.34 44.55082,40.856" /></g></g></svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/czi.svg b/web/pandas/static/img/partners/czi.svg
new file mode 100644
index 0000000000000..b0ad9eb80580b
--- /dev/null
+++ b/web/pandas/static/img/partners/czi.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="112px" height="62px" viewBox="0 0 112 62" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: Sketch 52.2 (67145) - http://www.bohemiancoding.com/sketch -->
+    <title>Group</title>
+    <desc>Created with Sketch.</desc>
+    <g id="Symbols" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="nav-elements-/-czi_logo_nav_dark" transform="translate(-48.000000, -17.000000)">
+            <g id="Group" transform="translate(48.000000, 17.000000)">
+                <path d="M13.118,16.05056 C11.6721111,16.69381 10.2262222,17.047985 8.20166667,17.047985 C3.64077778,17.047985 0.370222222,14.43236 0.370222222,9.79941 C0.370222222,5.565585 3.64077778,2.26176 8.15733333,2.26176 C9.38077778,2.26176 10.6928889,2.550835 11.627,2.949185 L12.3837778,2.195885 L13.0293333,2.195885 L13.2961111,7.62631 L12.4724444,7.67126 C11.0047778,4.545685 9.73622222,3.34831 7.93411111,3.34831 C5.70966667,3.34831 4.04133333,5.410585 4.04133333,9.466935 C4.04133333,13.678285 6.11022222,15.851385 8.869,15.851385 C9.44688889,15.851385 9.80311111,15.784735 10.3366667,15.60726 L12.9624444,12.260035 L13.5628889,12.348385 L13.118,16.05056 Z" id="Fill-1" fill="#231F20"/>
+                <path d="M21.1942889,8.26987 C20.3931778,8.26987 19.9039556,8.469045 19.1254,8.890645 L19.1254,15.585095 L20.3262889,16.07257 L20.3262889,16.715045 L14.7869556,16.715045 L14.7869556,16.07257 L16.2110667,15.585095 L16.2110667,2.83867 L14.6757333,1.907895 L14.6757333,1.331295 L18.7022889,0.289695 L19.1254,0.533045 L19.1254,7.959095 L19.3696222,8.00327 C20.3931778,7.09497 21.5948444,6.36337 22.9746222,6.36337 C24.8428444,6.36337 25.8220667,7.582445 25.8220667,9.39982 L25.8220667,15.585095 L27.2454,16.07257 L27.2454,16.715045 L21.7060667,16.715045 L21.7060667,16.07257 L22.9077333,15.585095 L22.9077333,10.375545 C22.9077333,9.08982 22.4402889,8.26987 21.1942889,8.26987" id="Fill-3" fill="#231F20"/>
+                <path d="M33.6751333,11.7944925 C31.2943556,11.8828425 30.4271333,12.7035675 30.4271333,13.8118175 C30.4271333,14.8309425 31.0058,15.3858425 32.0285778,15.3858425 C32.4742444,15.3858425 33.0746889,15.1858925 33.6751333,14.8092425 L33.6751333,11.7944925 Z M36.4339111,14.6092925 C36.4339111,15.3633675 36.7675778,15.8291425 38.0579111,15.8508425 L38.1022444,16.4274425 C37.4574667,16.6707925 36.4782444,16.9373925 35.6110222,16.9373925 C34.5874667,16.9373925 34.0088,16.5157925 33.8306889,15.4741925 L33.5639111,15.4300175 C32.5629111,16.3607925 31.6062444,16.9149175 30.4271333,16.9149175 C28.8256889,16.9149175 27.7126889,16.0507925 27.7126889,14.5209425 C27.7126889,12.6369175 29.6711333,11.3511925 33.6751333,11.0628925 L33.6751333,9.8438175 C33.6751333,8.1806675 33.0078,7.6265425 31.3394667,7.6265425 C30.8945778,7.6265425 30.4940222,7.7156675 30.2046889,7.8264925 C30.6052444,8.1589675 30.8276889,8.5356175 30.8276889,9.0230925 C30.8276889,9.7322175 30.3376889,10.2871175 29.4930222,10.2871175 C28.6919111,10.2871175 28.0914667,9.6663425 28.0914667,8.9347425 C28.0914667,7.4048925 30.5383556,6.3632925 32.8740222,6.3632925 C35.2991333,6.3632925 36.4339111,7.2723675 36.4339111,9.4446925 L36.4339111,14.6092925 Z" id="Fill-5" fill="#231F20"/>
+                <path d="M49.1152667,15.585095 L50.5168222,16.07257 L50.5168222,16.715045 L44.9992667,16.715045 L44.9992667,16.07257 L46.2009333,15.585095 L46.2009333,10.375545 C46.2009333,9.067345 45.7334889,8.26987 44.5100444,8.26987 C43.7532667,8.26987 43.2640444,8.49152 42.5080444,8.890645 L42.5080444,15.585095 L43.6871556,16.07257 L43.6871556,16.715045 L38.1696,16.715045 L38.1696,16.07257 L39.5937111,15.585095 L39.5937111,8.690695 L38.1921556,7.75992 L38.1921556,7.18332 L41.9962667,6.29672 L42.4186,6.562545 L42.2630444,8.15827 L42.5298222,8.20322 C43.8870444,6.96167 45.0443778,6.36337 46.2678222,6.36337 C48.0917111,6.36337 49.1152667,7.515795 49.1152667,9.400595 L49.1152667,15.585095 Z" id="Fill-7" fill="#231F20"/>
+                <path d="M12.5395667,38.507425 L0.148011111,38.507425 L0.0593444444,37.9533 L8.9579,25.583525 L5.55434444,25.6277 C4.33012222,25.6277 3.77401111,26.026825 2.81734444,27.268375 L1.39323333,29.041575 L0.8379,28.90905 L1.26023333,24.386925 L12.8957889,24.386925 L12.9844556,24.94105 L4.15201111,37.332525 L8.37923333,37.28835 C9.53656667,37.28835 10.0926778,36.822575 10.8261222,35.7585 L12.4726778,33.364525 L12.9844556,33.45365 L12.5395667,38.507425 Z" id="Fill-9" fill="#231F20"/>
+                <path d="M25.5768333,37.4432725 L25.5768333,37.9973975 L21.7501667,38.8839975 L21.3278333,38.6398725 L21.4833889,37.0441475 L21.2166111,36.9999725 C19.8593889,38.2415225 18.7689444,38.8398225 17.4786111,38.8398225 C15.6103889,38.8398225 14.6311667,37.5757975 14.6311667,35.7801225 L14.6311667,30.4163475 L13.2521667,29.5072725 L13.2521667,28.9756225 L17.1449444,28.0882475 L17.5455,28.3540725 L17.5455,34.7826975 C17.5455,36.1575475 18.0347222,36.9108475 19.2363889,36.9108475 C19.9923889,36.9108475 20.4823889,36.7116725 21.2383889,36.3125475 L21.2383889,30.4163475 L19.8368333,29.5072725 L19.8368333,28.9756225 L23.7303889,28.0882475 L24.1527222,28.3540725 L24.1527222,36.6233225 L25.5768333,37.4432725 Z" id="Fill-11" fill="#231F20"/>
+                <path d="M34.0978556,32.12313 C33.0968556,32.12313 32.5181889,31.39153 32.5181889,30.394105 C32.5181889,29.972505 32.6068556,29.57338 32.7631889,29.219205 C32.6294111,29.19673 32.5181889,29.17503 32.3626333,29.17503 C30.7160778,29.240905 29.2701889,30.65993 29.2701889,33.342205 C29.2701889,35.80283 30.7829667,37.088555 32.8075222,37.088555 C33.7198556,37.088555 34.3428556,36.888605 35.3881889,36.490255 L35.6106333,37.021905 C34.3646333,38.28593 32.9630778,38.861755 31.4277444,38.861755 C28.5585222,38.861755 26.2671889,36.800255 26.2671889,33.74133 C26.2671889,30.637455 28.6915222,28.15513 32.0071889,28.15513 C34.2090778,28.15513 35.5888556,29.219205 35.5888556,30.52663 C35.5888556,31.435705 34.9658556,32.12313 34.0978556,32.12313" id="Fill-13" fill="#231F20"/>
+                <polygon id="Fill-15" fill="#231F20" points="46.8457111 37.39902 47.9136 37.864795 47.9136 38.50727 42.9303778 38.50727 42.9303778 37.931445 43.7532667 37.509845 41.1726 34.00762 40.3940444 34.00762 40.3940444 37.376545 41.5062667 37.864795 41.5062667 38.50727 36.0556 38.50727 36.0556 37.864795 37.4797111 37.376545 37.4797111 24.63012 35.9443778 23.699345 35.9443778 23.122745 39.9717111 22.081145 40.3940444 22.324495 40.3940444 32.831945 41.2394889 32.831945 43.9539333 29.795495 42.7297111 29.04142 42.7297111 28.487295 47.4461556 28.487295 47.4461556 29.152245 46.0671556 29.68467 42.9972667 32.41112"/>
+                <path d="M54.8996,32.38911 C54.8778222,30.12766 54.2991556,29.063585 53.0531556,29.063585 C51.8297111,29.063585 50.9617111,30.371785 50.8730444,32.588285 L54.8996,32.38911 Z M50.8504889,33.386535 C50.8730444,35.802985 51.9183778,37.15536 54.1653778,37.15536 C55.1889333,37.15536 56.0787111,36.95541 57.3916,36.467935 L57.6366,36.977885 C56.2568222,38.107835 54.6102667,38.86191 53.1418222,38.86191 C49.9607111,38.86191 47.9361556,36.77871 47.9361556,33.696535 C47.9361556,30.50431 50.4499333,28.155285 53.2312667,28.155285 C56.5687111,28.155285 57.8582667,30.57096 57.7470444,33.386535 L50.8504889,33.386535 Z" id="Fill-17" fill="#231F20"/>
+                <path d="M66.0904222,31.657665 C65.2224222,31.657665 64.6888667,31.014415 64.5776444,30.261115 C63.8659778,30.416115 63.3090889,30.88189 62.8198667,31.524365 L62.8198667,37.37639 L64.3995333,37.86464 L64.3995333,38.507115 L58.4822,38.507115 L58.4822,37.86464 L59.9055333,37.37639 L59.9055333,30.482765 L58.5039778,29.55199 L58.5039778,28.97539 L62.3088667,28.08879 L62.7312,28.354615 L62.4862,30.482765 L62.7529778,30.549415 C63.6653111,29.04204 64.5776444,28.132965 65.8905333,28.132965 C66.9358667,28.132965 67.6926444,28.82039 67.6926444,29.88369 C67.6926444,30.90359 67.0027556,31.657665 66.0904222,31.657665" id="Fill-19" fill="#231F20"/>
+                <path d="M73.4766667,30.0172225 C72.9205556,30.0172225 72.4087778,30.1722225 71.9413333,30.3496975 L71.9413333,36.7783225 C72.4974444,37.4874475 73.1204444,37.8423975 73.9884444,37.8423975 C75.1675556,37.8423975 76.2128889,36.7116725 76.2128889,33.8960975 C76.2128889,31.2587725 75.2118889,30.0172225 73.4766667,30.0172225 M73.4097778,38.8622975 C72.1194444,38.8622975 70.3624444,38.5739975 69.027,38.1531725 L69.027,24.6301975 L67.4698889,23.6994225 L67.4698889,23.1228225 L71.519,22.0812225 L71.9413333,22.3245725 L71.9413333,29.4630975 L72.2088889,29.5072725 C73.1204444,28.6873225 74.0327778,28.1548975 75.3005556,28.1548975 C77.392,28.1548975 79.2827778,30.0830975 79.2827778,33.2094475 C79.2827778,36.1800225 77.0583333,38.8622975 73.4097778,38.8622975" id="Fill-21" fill="#231F20"/>
+                <path d="M87.4482,32.38911 C87.4256444,30.12766 86.8477556,29.063585 85.6009778,29.063585 C84.3783111,29.063585 83.5103111,30.371785 83.4216444,32.588285 L87.4482,32.38911 Z M83.3990889,33.386535 C83.4216444,35.802985 84.4669778,37.15536 86.7139778,37.15536 C87.7375333,37.15536 88.6273111,36.95541 89.9394222,36.467935 L90.1844222,36.977885 C88.8054222,38.107835 87.1588667,38.86191 85.6904222,38.86191 C82.5093111,38.86191 80.4847556,36.77871 80.4847556,33.696535 C80.4847556,30.50431 82.9985333,28.155285 85.7790889,28.155285 C89.1165333,28.155285 90.4068667,30.57096 90.2956444,33.386535 L83.3990889,33.386535 Z" id="Fill-23" fill="#231F20"/>
+                <path d="M98.6386333,31.657665 C97.7714111,31.657665 97.2370778,31.014415 97.1258556,30.261115 C96.4141889,30.416115 95.8580778,30.88189 95.3680778,31.524365 L95.3680778,37.37639 L96.9477444,37.86464 L96.9477444,38.507115 L91.0304111,38.507115 L91.0304111,37.86464 L92.4537444,37.37639 L92.4537444,30.482765 L91.0529667,29.55199 L91.0529667,28.97539 L94.8570778,28.08879 L95.2794111,28.354615 L95.0344111,30.482765 L95.3011889,30.549415 C96.2135222,29.04204 97.1258556,28.132965 98.4387444,28.132965 C99.4840778,28.132965 100.240856,28.82039 100.240856,29.88369 C100.240856,30.90359 99.5509667,31.657665 98.6386333,31.657665" id="Fill-25" fill="#231F20"/>
+                <path d="M105.268333,28.93075 C104.267333,28.93075 103.555667,29.574 103.555667,31.5022 C103.555667,33.519525 104.245556,34.07365 105.379556,34.07365 C106.380556,34.07365 107.026111,33.164575 107.026111,31.41385 C107.026111,29.773175 106.403111,28.93075 105.268333,28.93075 M106.580444,38.8399 L102.999556,38.795725 C102.710222,39.172375 102.509556,39.65985 102.509556,40.258925 C102.509556,41.41135 103.466222,42.2096 105.757556,42.2096 C107.604,42.2096 109.050667,41.300525 109.050667,40.23645 C109.050667,39.2615 108.293889,38.8616 106.580444,38.8399 M105.335222,34.849425 C104.578444,34.849425 104.111778,34.782775 103.711222,34.65025 C103.488778,34.937775 103.288889,35.337675 103.288889,35.6252 C103.288889,36.1801 103.688667,36.445925 104.756556,36.467625 L107.492778,36.5118 C109.806667,36.55675 111.008333,37.44335 111.008333,39.105725 C111.008333,41.27805 108.627556,43.1179 104.979,43.1179 C101.642333,43.1179 100.107,42.14295 100.107,40.857225 C100.107,40.037275 100.796889,39.2832 102.265333,38.729075 L102.242778,38.507425 C101.353,38.219125 100.952444,37.665 100.952444,37.044225 C100.952444,36.312625 101.575444,35.51515 102.887556,34.49525 L102.887556,34.36195 C101.709222,33.78535 100.885556,32.76545 100.885556,31.5022 C100.885556,29.4407 102.843222,28.154975 105.379556,28.154975 C106.870556,28.154975 107.804667,28.5541 108.583222,29.108225 L110.295889,28.154975 L111.564444,28.154975 L111.564444,30.083175 L111.119556,30.083175 L109.273111,29.729 L109.228,29.906475 C109.495556,30.371475 109.695444,30.859725 109.695444,31.56885 C109.695444,33.452875 108.027111,34.849425 105.335222,34.849425" id="Fill-27" fill="#231F20"/>
+                <polygon id="Fill-29" fill="#231F20" points="7.8232 59.5675075 7.8232 60.2991075 0.236755556 60.2991075 0.236755556 59.5675075 2.37253333 59.0800325 2.37253333 47.3976825 0.236755556 46.9094325 0.236755556 46.1786075 7.8232 46.1786075 7.8232 46.9094325 5.70997778 47.3976825 5.70997778 59.0800325"/>
+                <path d="M19.7256889,59.168615 L21.1272444,59.65609 L21.1272444,60.298565 L15.6096889,60.298565 L15.6096889,59.65609 L16.8113556,59.168615 L16.8113556,53.959065 C16.8113556,52.650865 16.3439111,51.85339 15.1204667,51.85339 C14.3636889,51.85339 13.8752444,52.07504 13.1184667,52.47339 L13.1184667,59.168615 L14.2975778,59.65609 L14.2975778,60.298565 L8.78002222,60.298565 L8.78002222,59.65609 L10.2041333,59.168615 L10.2041333,52.274215 L8.80257778,51.34344 L8.80257778,50.76684 L12.6066889,49.88024 L13.0298,50.146065 L12.8734667,51.74179 L13.1410222,51.78674 C14.4974667,50.54519 15.6548,49.94689 16.8782444,49.94689 C18.7021333,49.94689 19.7256889,51.099315 19.7256889,52.984115 L19.7256889,59.168615 Z" id="Fill-31" fill="#231F20"/>
+                <path d="M24.3088222,44.1832925 C25.3767111,44.1832925 26.1334889,44.9590675 26.1334889,45.9789675 C26.1334889,46.9763925 25.3323778,47.8846925 24.2201556,47.8846925 C23.1966,47.8846925 22.4180444,47.1313925 22.4180444,46.1114925 C22.4180444,45.1140675 23.2191556,44.1832925 24.3088222,44.1832925 Z M21.4388222,51.3435175 L21.4388222,50.7669175 L25.3767111,49.8803175 L25.7547111,50.1019675 L25.7547111,59.1686925 L27.1344889,59.6561675 L27.1344889,60.2986425 L21.3727111,60.2986425 L21.3727111,59.6561675 L22.8403778,59.1686925 L22.8403778,52.2742925 L21.4388222,51.3435175 Z" id="Fill-33" fill="#231F20"/>
+                <path d="M31.5837667,60.58733 C29.8259889,60.58733 28.9362111,59.744905 28.9362111,57.94923 L28.9362111,51.720555 L27.2235444,51.720555 L27.2235444,51.12148 L29.3811,49.63658 L31.0276556,47.13178 L31.8505444,47.13178 L31.8505444,50.23488 L35.2323222,50.23488 L35.2323222,51.720555 L31.8505444,51.720555 L31.8505444,56.906855 C31.8505444,57.838405 31.9843222,58.326655 32.4292111,58.636655 C32.8297667,58.90248 33.2521,58.96913 33.9863222,58.96913 C34.3425444,58.96913 34.8092111,58.946655 35.2766556,58.90248 L35.2992111,59.589905 C34.4755444,60.099855 32.8958778,60.58733 31.5837667,60.58733" id="Fill-35" fill="#231F20"/>
+                <path d="M38.4804778,44.1832925 C39.5483667,44.1832925 40.3051444,44.9590675 40.3051444,45.9789675 C40.3051444,46.9763925 39.5040333,47.8846925 38.3918111,47.8846925 C37.3682556,47.8846925 36.5897,47.1313925 36.5897,46.1114925 C36.5897,45.1140675 37.3908111,44.1832925 38.4804778,44.1832925 Z M35.6104778,51.3435175 L35.6104778,50.7669175 L39.5483667,49.8803175 L39.9263667,50.1019675 L39.9263667,59.1686925 L41.3061444,59.6561675 L41.3061444,60.2986425 L35.5443667,60.2986425 L35.5443667,59.6561675 L37.0120333,59.1686925 L37.0120333,52.2742925 L35.6104778,51.3435175 Z" id="Fill-37" fill="#231F20"/>
+                <path d="M47.9577,55.3780125 C45.5769222,55.4663625 44.7097,56.2863125 44.7097,57.3953375 C44.7097,58.4144625 45.2883667,58.9693625 46.3111444,58.9693625 C46.7568111,58.9693625 47.3572556,58.7694125 47.9577,58.3927625 L47.9577,55.3780125 Z M50.7164778,58.1928125 C50.7164778,58.9468875 51.0501444,59.4126625 52.3404778,59.4343625 L52.3848111,60.0109625 C51.7400333,60.2543125 50.7608111,60.5209125 49.8935889,60.5209125 C48.8700333,60.5209125 48.2913667,60.0993125 48.1132556,59.0577125 L47.8464778,59.0135375 C46.8454778,59.9443125 45.8888111,60.4984375 44.7097,60.4984375 C43.1082556,60.4984375 41.9952556,59.6343125 41.9952556,58.1044625 C41.9952556,56.2204375 43.9537,54.9347125 47.9577,54.6464125 L47.9577,53.4273375 C47.9577,51.7641875 47.2903667,51.2100625 45.6220333,51.2100625 C45.1771444,51.2100625 44.7765889,51.2991875 44.4872556,51.4100125 C44.8878111,51.7424875 45.1102556,52.1191375 45.1102556,52.6066125 C45.1102556,53.3157375 44.6202556,53.8706375 43.7755889,53.8706375 C42.9744778,53.8706375 42.3740333,53.2498625 42.3740333,52.5182625 C42.3740333,50.9884125 44.8209222,49.9468125 47.1565889,49.9468125 C49.5817,49.9468125 50.7164778,50.8558875 50.7164778,53.0282125 L50.7164778,58.1928125 Z" id="Fill-39" fill="#231F20"/>
+                <path d="M56.4567111,60.58733 C54.6989333,60.58733 53.8091556,59.744905 53.8091556,57.94923 L53.8091556,51.720555 L52.0964889,51.720555 L52.0964889,51.12148 L54.2540444,49.63658 L55.9006,47.13178 L56.7234889,47.13178 L56.7234889,50.23488 L60.1052667,50.23488 L60.1052667,51.720555 L56.7234889,51.720555 L56.7234889,56.906855 C56.7234889,57.838405 56.8572667,58.326655 57.3021556,58.636655 C57.7027111,58.90248 58.1250444,58.96913 58.8592667,58.96913 C59.2154889,58.96913 59.6821556,58.946655 60.1496,58.90248 L60.1721556,59.589905 C59.3484889,60.099855 57.7688222,60.58733 56.4567111,60.58733" id="Fill-41" fill="#231F20"/>
+                <path d="M63.3534222,44.1832925 C64.4213111,44.1832925 65.1780889,44.9590675 65.1780889,45.9789675 C65.1780889,46.9763925 64.3769778,47.8846925 63.2647556,47.8846925 C62.2412,47.8846925 61.4626444,47.1313925 61.4626444,46.1114925 C61.4626444,45.1140675 62.2637556,44.1832925 63.3534222,44.1832925 Z M60.4834222,51.3435175 L60.4834222,50.7669175 L64.4213111,49.8803175 L64.7993111,50.1019675 L64.7993111,59.1686925 L66.1790889,59.6561675 L66.1790889,60.2986425 L60.4173111,60.2986425 L60.4173111,59.6561675 L61.8849778,59.1686925 L61.8849778,52.2742925 L60.4834222,51.3435175 Z" id="Fill-43" fill="#231F20"/>
+                <polygon id="Fill-45" fill="#231F20" points="72.8530444 57.3727075 72.9860444 57.3727075 74.0096 54.7570825 75.0774889 51.5873325 73.7871556 50.8999075 73.7871556 50.2791325 78.1924889 50.2791325 78.1924889 50.9448575 76.7014889 51.6756825 72.8748222 60.5432325 71.2290444 60.5432325 67.3129333 51.4765075 65.9564889 50.9448575 65.9564889 50.2791325 71.9407111 50.2791325 71.9407111 50.8999075 70.5617111 51.4315575"/>
+                <path d="M85.2226667,54.180715 C85.2001111,51.92004 84.6222222,50.85519 83.3762222,50.85519 C82.1527778,50.85519 81.2847778,52.16339 81.1961111,54.37989 L85.2226667,54.180715 Z M81.1735556,55.17814 C81.1961111,57.59459 82.2414444,58.946965 84.4884444,58.946965 C85.512,58.946965 86.4017778,58.74779 87.7146667,58.25954 L87.9588889,58.76949 C86.5798889,59.900215 84.9333333,60.65429 83.4648889,60.65429 C80.2837778,60.65429 78.2592222,58.570315 78.2592222,55.48814 C78.2592222,52.29669 80.773,49.94689 83.5535556,49.94689 C86.891,49.94689 88.1813333,52.36334 88.0701111,55.17814 L81.1735556,55.17814 Z" id="Fill-47" fill="#231F20"/>
+                <path d="M99.2454556,53.522275 C98.7523444,53.86405 98.1752333,54.07795 97.3725667,54.095 C96.4065667,54.11515 95.6809,53.4781 95.6140111,52.53725 C95.5782333,52.037375 95.7462333,51.5592 96.0876778,51.1934 C96.4299,50.826825 96.8957889,50.62145 97.3990111,50.617575 C97.6541222,50.61525 97.9232333,50.667175 98.1542333,50.766375 C98.1542333,50.766375 98.0912333,51.291825 98.0702333,51.5282 L98.8651222,51.53285 L99.0074556,50.3502 L98.7842333,50.20915 C98.3665667,49.9534 97.8851222,49.81855 97.3920111,49.8232 C96.6741222,49.8294 95.9842333,50.13165 95.4973444,50.653225 C95.0034556,51.18255 94.7600111,51.87075 94.8121222,52.592275 C94.8572333,53.232425 95.1341222,53.816775 95.5899,54.2376 C96.0511222,54.664625 96.6725667,54.894025 97.3445667,54.887825 C97.3609,54.887825 97.3772333,54.887825 97.3943444,54.88705 C97.8011222,54.876975 98.2600111,54.799475 98.7647889,54.6003 L99.3380111,53.491275 C99.3380111,53.491275 99.3263444,53.4657 99.2454556,53.522275" id="Fill-49" fill="#FF414C"/>
+                <path d="M101.945278,56.363425 L101.848833,57.4523 L101.847278,57.4647 C101.808389,57.877 101.5875,58.226525 101.256167,58.4009 C100.993278,58.539625 100.7055,58.53885 100.4465,58.398575 C100.177389,58.252875 100.049056,58.03355 100.000833,57.756875 C99.9253889,57.318225 100.175833,56.860975 100.517278,56.630025 L105.846611,53.175075 C105.887056,53.468025 105.908056,53.7664 105.908056,54.069425 C105.908056,57.645275 102.991389,60.55385 99.4058333,60.55385 C95.8202778,60.55385 92.9028333,57.645275 92.9028333,54.069425 C92.9028333,50.49435 95.8202778,47.585 99.4058333,47.585 C102.086833,47.585 104.392944,49.2125 105.386167,51.5282 L106.036389,51.107375 C104.897722,48.5863 102.355167,46.8255 99.4058333,46.8255 C95.3971667,46.8255 92.1359444,50.075075 92.1359444,54.069425 C92.1359444,58.063775 95.3971667,61.31335 99.4058333,61.31335 C103.4145,61.31335 106.675722,58.063775 106.675722,54.069425 C106.675722,53.6083 106.631389,53.15725 106.548167,52.72015 C106.498389,52.434175 106.388722,52.054425 106.370056,51.9932 L104.8565,52.936375 L102.852167,54.201175 C102.781389,53.93535 102.619611,53.666425 102.277389,53.511425 C101.872167,53.32775 101.215722,53.469575 100.7335,53.742375 C100.7335,53.742375 102.053389,51.19805 102.271944,50.780325 C102.285944,50.752425 102.2665,50.72065 102.235389,50.72065 L102.1545,50.721425 L102.155278,50.719875 L99.7682778,50.719875 L99.6687222,51.54215 L100.042056,51.5406 L101.005722,51.5406 L99.1165,55.145125 C99.0799444,55.21565 99.1561667,55.290825 99.2269444,55.2544 L100.235722,54.720425 C100.721833,54.47165 101.532278,53.960925 101.932833,54.2562 C101.991167,54.298825 102.065833,54.41275 102.0705,54.531325 C102.072833,54.577825 102.0495,54.621225 102.010611,54.647575 L100.000056,56.0015 C99.3459444,56.4665 99.0908333,57.15935 99.1515,57.8119 C99.2020556,58.361375 99.5450556,58.834125 100.053722,59.110025 C100.321278,59.254175 100.609833,59.322375 100.897611,59.314625 C101.151167,59.30765 101.403944,59.241775 101.640389,59.117 C102.214389,58.815525 102.5955,58.228075 102.662389,57.546075 L102.824167,55.7132 L101.945278,56.363425 Z" id="Fill-51" fill="#FF414C"/>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/numfocus.svg b/web/pandas/static/img/partners/numfocus.svg
new file mode 100644
index 0000000000000..fcdd87b41e475
--- /dev/null
+++ b/web/pandas/static/img/partners/numfocus.svg
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generator: Adobe Illustrator 19.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 432 135.7" style="enable-background:new 0 0 432 135.7;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#F1563F;}
+	.st1{fill:#008896;}
+</style>
+<g>
+	<g>
+		<g>
+			<path class="st0" d="M97.9,12.2v51.9c0,12.7-6.8,19.7-19.1,19.7c-12.2,0-19-7-19-19.7V12.2h5v51.9c0,9.8,4.8,14.9,14,14.9     c9.2,0,14.1-5.2,14.1-14.9V12.2H97.9z"/>
+		</g>
+		<g>
+			<path class="st1" d="M329.8,29.8c0-0.3,0.1-0.7,0.1-1c0-8.3-6.9-16.7-20.1-16.7c-13.1,0-20.6,7.7-20.6,21.2v29.5     c0,13.5,7.4,21.2,20.3,21.2c13.4,0,20.4-8.4,20.4-16.7c0-0.3,0-0.8-0.1-1.4l-7.8,0c-0.7,4.6-1.7,10.4-12,10.4     c-9,0-13-4.1-13-13.4V33.3c0-9.2,4-13.4,12.7-13.4c7.7,0,11.8,3.4,12.2,10.1L329.8,29.8z"/>
+		</g>
+		<g>
+			<path class="st1" d="M376.2,12.4v50.3c0,13.6-7.3,21.2-20.5,21.2c-13.2,0-20.4-7.5-20.4-21.2V12.4h7.9v50.3     c0,9,4.1,13.4,12.5,13.4c8.4,0,12.6-4.5,12.6-13.4V12.4H376.2z"/>
+		</g>
+		<g>
+			<path class="st1" d="M414.9,22.6c-2-1-6-2.9-11.3-2.9c-8.4,0-12.6,3.4-12.6,10c0,7.1,4.8,9.1,12.5,11.8     c8.3,2.9,18.6,6.5,18.6,21.9c0,13-7.5,20.5-20.6,20.5c-8.2,0-14.2-2.7-17.3-6c-1.2-1.3-0.5-0.6-1.2-1.6l5.3-5.1     c1.9,2.2,5,5,12.8,5c8.7,0,13.2-4.1,13.2-12.3c0-9.9-6.6-12.3-14.3-15.1C392,46,383,42.8,383,30.1c0-11.3,7.7-18.1,20.6-18.1     c5.5,0,12.5,1.3,15.4,4.1L414.9,22.6z"/>
+		</g>
+		<g>
+			<path class="st1" d="M283.5,47.2c0-21.2-17.2-38.5-38.5-38.5c-21.2,0-38.5,17.2-38.5,38.5c0,21.2,17.2,38.5,38.5,38.5     C266.2,85.6,283.5,68.4,283.5,47.2z M213.1,47.2c0-17.6,14.3-31.9,31.9-31.9c17.6,0,31.9,14.3,31.9,31.9     c0,17.6-14.3,31.9-31.9,31.9C227.4,79.1,213.1,64.8,213.1,47.2z"/>
+		</g>
+		<g>
+			<path class="st0" d="M233.9,32.3c1.2,0,2.1-1,2.1-2.3c0-1.3-0.9-2.3-2.1-2.3h-7.3c-1.3,0-2.3,1-2.3,2.2v34.5c0,1.2,1,2.2,2.3,2.2     h7.3c1.2,0,2.1-1,2.1-2.3c0-1.3-1-2.3-2.1-2.3h-4.9V32.3H233.9z"/>
+		</g>
+		<g>
+			<path class="st0" d="M256.1,62c-1.2,0-2.2,1-2.2,2.3c0,1.3,1,2.3,2.2,2.3h7.3c1.3,0,2.3-1,2.3-2.2V29.9c0-1.2-1-2.2-2.3-2.2h-7.3     c-1.2,0-2.2,1-2.2,2.3c0,1.3,1,2.3,2.2,2.3h4.9V62H256.1z"/>
+		</g>
+		<polygon class="st1" points="208.7,19.8 208.7,12.1 171.8,12.1 171.8,83.7 179.7,83.7 179.7,51.5 196.2,51.5 196.2,43.9     179.7,43.9 179.7,19.8   "/>
+		<polygon class="st0" points="156.6,12.2 152.3,12.2 133.2,51.9 113.9,12.2 109.7,12.2 109.7,83.7 114.6,83.7 114.6,24.3     133.1,61.9 151.6,24.4 151.6,83.7 156.6,83.7   "/>
+		<polygon class="st0" points="44.6,83.7 48.1,83.7 48.1,12.1 43.1,12.1 43.2,70.5 14.2,12.2 10.1,12.2 10.1,83.7 15.1,83.7     14.9,23.1   "/>
+	</g>
+	<g id="XMLID_3_">
+		<path class="st1" d="M34.9,125.3c-1.2,0-2.3-0.2-3.2-0.5c-0.9-0.3-1.6-0.8-2.1-1.5c-0.5-0.7-0.9-1.4-1.1-2.3    c-0.2-0.9-0.4-1.9-0.4-3v-8.5c0-2.3,0.5-4.1,1.6-5.3c1.1-1.2,2.8-1.8,5.2-1.8c2.4,0,4.1,0.6,5.2,1.8c1.1,1.2,1.6,3,1.6,5.3v8.5    c0,2.3-0.5,4.1-1.6,5.4C39.1,124.7,37.3,125.3,34.9,125.3z M33.3,122.5c0.4,0.2,1,0.3,1.7,0.3c0.7,0,1.2-0.1,1.7-0.3    c0.4-0.2,0.8-0.5,1-0.9c0.2-0.4,0.4-0.8,0.5-1.3c0.1-0.5,0.1-1,0.1-1.7v-9.9c0-0.7,0-1.2-0.1-1.7c-0.1-0.5-0.2-0.9-0.5-1.2    c-0.2-0.4-0.6-0.7-1-0.8c-0.4-0.2-1-0.3-1.7-0.3c-0.7,0-1.2,0.1-1.7,0.3c-0.4,0.2-0.8,0.5-1,0.8c-0.2,0.4-0.4,0.8-0.5,1.2    c-0.1,0.5-0.1,1-0.1,1.7v9.9c0,0.7,0,1.3,0.1,1.7c0.1,0.5,0.2,0.9,0.5,1.3C32.5,122.1,32.8,122.4,33.3,122.5z"/>
+		<path class="st1" d="M46.7,125v-22.5h6.2c2.2,0,3.7,0.5,4.7,1.6c1,1.1,1.5,2.6,1.5,4.6c0,1.8-0.5,3.3-1.6,4.3    c-1,1-2.6,1.5-4.6,1.5h-2.7V125H46.7z M50.2,112.3h1.6c1.5,0,2.6-0.2,3.1-0.7c0.6-0.5,0.9-1.4,0.9-2.8c0-0.6,0-1,0-1.4    c0-0.4-0.1-0.7-0.2-1c-0.1-0.3-0.2-0.6-0.4-0.8c-0.2-0.2-0.4-0.3-0.7-0.5c-0.3-0.1-0.7-0.2-1.1-0.3c-0.4,0-0.9-0.1-1.5-0.1h-1.6    V112.3z"/>
+		<path class="st1" d="M63,125v-22.5h9.6v2.3h-6.2v7.4h5v2.2h-5v8.3h6.2v2.3H63z"/>
+		<path class="st1" d="M77.1,125v-22.5h2.4l7.1,15v-15h2.9V125h-2.2L80,109.7V125H77.1z"/>
+		<path class="st1" d="M109.6,125.3c-1,0-1.9-0.1-2.7-0.4c-0.8-0.3-1.4-0.6-1.9-1c-0.5-0.4-0.9-1-1.2-1.6c-0.3-0.6-0.5-1.3-0.7-2    c-0.1-0.7-0.2-1.5-0.2-2.4v-8c0-1,0.1-1.8,0.2-2.5c0.1-0.7,0.3-1.4,0.7-2.1c0.3-0.6,0.7-1.2,1.2-1.6c0.5-0.4,1.1-0.7,1.9-1    c0.8-0.2,1.7-0.4,2.7-0.4c2.2,0,3.8,0.5,4.8,1.6c1,1.1,1.5,2.7,1.5,4.8v1.8h-3.3V109c0-0.3,0-0.6,0-0.8c0-0.2,0-0.4,0-0.7    c0-0.3,0-0.5-0.1-0.7c0-0.2-0.1-0.4-0.2-0.6c-0.1-0.2-0.1-0.4-0.2-0.5c-0.1-0.1-0.2-0.3-0.4-0.4c-0.1-0.1-0.3-0.2-0.5-0.3    c-0.2-0.1-0.4-0.1-0.7-0.2c-0.3,0-0.6-0.1-0.9-0.1c-0.5,0-0.9,0-1.3,0.1c-0.4,0.1-0.7,0.2-0.9,0.4c-0.2,0.2-0.4,0.4-0.6,0.7    c-0.1,0.2-0.3,0.6-0.3,0.9c-0.1,0.4-0.1,0.8-0.1,1.1s0,0.8,0,1.3v8.9c0,1.7,0.2,2.9,0.7,3.5c0.5,0.7,1.3,1,2.5,1    c0.5,0,0.9,0,1.2-0.1c0.3-0.1,0.6-0.2,0.8-0.4c0.2-0.2,0.4-0.4,0.5-0.7c0.1-0.2,0.2-0.5,0.3-0.9c0.1-0.4,0.1-0.7,0.1-1.1    c0-0.3,0-0.8,0-1.3v-1.7h3.3v1.7c0,0.9-0.1,1.6-0.2,2.3c-0.1,0.7-0.3,1.3-0.6,1.9c-0.3,0.6-0.7,1.1-1.1,1.5    c-0.5,0.4-1.1,0.7-1.8,0.9C111.4,125.2,110.6,125.3,109.6,125.3z"/>
+		<path class="st1" d="M127.1,125.3c-1.2,0-2.3-0.2-3.2-0.5c-0.9-0.3-1.6-0.8-2.1-1.5c-0.5-0.7-0.9-1.4-1.1-2.3    c-0.2-0.9-0.4-1.9-0.4-3v-8.5c0-2.3,0.5-4.1,1.6-5.3c1.1-1.2,2.8-1.8,5.2-1.8c2.4,0,4.1,0.6,5.2,1.8c1.1,1.2,1.6,3,1.6,5.3v8.5    c0,2.3-0.5,4.1-1.6,5.4C131.2,124.7,129.5,125.3,127.1,125.3z M125.4,122.5c0.4,0.2,1,0.3,1.7,0.3c0.7,0,1.2-0.1,1.7-0.3    c0.4-0.2,0.8-0.5,1-0.9c0.2-0.4,0.4-0.8,0.5-1.3c0.1-0.5,0.1-1,0.1-1.7v-9.9c0-0.7,0-1.2-0.1-1.7c-0.1-0.5-0.2-0.9-0.5-1.2    c-0.2-0.4-0.6-0.7-1-0.8c-0.4-0.2-1-0.3-1.7-0.3c-0.7,0-1.2,0.1-1.7,0.3c-0.4,0.2-0.8,0.5-1,0.8c-0.2,0.4-0.4,0.8-0.5,1.2    c-0.1,0.5-0.1,1-0.1,1.7v9.9c0,0.7,0,1.3,0.1,1.7c0.1,0.5,0.2,0.9,0.5,1.3C124.6,122.1,125,122.4,125.4,122.5z"/>
+		<path class="st1" d="M138.9,125v-22.5h5.4c2.7,0,4.6,0.6,5.7,1.7c1.1,1.1,1.7,2.8,1.7,5.2v8.3c0,2.5-0.5,4.3-1.6,5.5    c-1.1,1.2-2.9,1.8-5.5,1.8H138.9z M142.3,122.8h2c0.5,0,1,0,1.4-0.1c0.4-0.1,0.7-0.2,1-0.3c0.3-0.1,0.5-0.3,0.7-0.6    c0.2-0.3,0.3-0.6,0.4-0.8c0.1-0.2,0.2-0.6,0.2-1.1c0-0.5,0.1-0.9,0.1-1.2c0-0.3,0-0.8,0-1.5v-7.3c0-0.5,0-1,0-1.4    c0-0.4-0.1-0.7-0.1-1.1c-0.1-0.4-0.2-0.7-0.3-0.9c-0.1-0.2-0.3-0.5-0.5-0.7c-0.2-0.2-0.4-0.4-0.7-0.5c-0.3-0.1-0.6-0.2-1-0.3    c-0.4-0.1-0.8-0.1-1.3-0.1h-1.9V122.8z"/>
+		<path class="st1" d="M156.6,125v-22.5h9.6v2.3h-6.2v7.4h5v2.2h-5v8.3h6.2v2.3H156.6z"/>
+		<path class="st1" d="M178.9,112.4v-2.3h9.4v2.3H178.9z M178.9,117.3v-2.3h9.4v2.3H178.9z"/>
+		<path class="st1" d="M202.1,125v-22.5h5.7c2.3,0,3.9,0.5,5,1.4c1.1,0.9,1.6,2.3,1.6,4.3c0,2.9-1.2,4.5-3.6,4.8    c1.5,0.3,2.5,1,3.2,1.9c0.7,0.9,1,2.2,1,3.8c0,2-0.5,3.6-1.6,4.7c-1,1.1-2.7,1.7-4.8,1.7H202.1z M205.6,111.9h2    c1.4,0,2.4-0.3,3-0.9c0.6-0.6,0.8-1.5,0.8-2.9c0-0.4,0-0.8-0.1-1.2s-0.2-0.6-0.3-0.8c-0.1-0.2-0.3-0.4-0.5-0.6    c-0.2-0.2-0.5-0.3-0.7-0.4c-0.2-0.1-0.5-0.2-0.9-0.2c-0.4,0-0.8-0.1-1.1-0.1c-0.4,0-0.8,0-1.4,0h-0.8V111.9z M205.6,122.8h2.3    c1.5,0,2.5-0.3,3.1-1c0.6-0.6,0.8-1.7,0.8-3.2c0-1.4-0.3-2.5-1-3.2c-0.7-0.7-1.7-1.1-3.2-1.1h-2.1V122.8z"/>
+		<path class="st1" d="M219.7,125v-22.5h9.6v2.3h-6.2v7.4h5v2.2h-5v8.3h6.2v2.3H219.7z"/>
+		<path class="st1" d="M236.4,125v-20.2h-4.6v-2.3h12.4v2.3h-4.4V125H236.4z"/>
+		<path class="st1" d="M250.2,125v-20.2h-4.6v-2.3h12.4v2.3h-4.4V125H250.2z"/>
+		<path class="st1" d="M261.5,125v-22.5h9.6v2.3H265v7.4h5v2.2h-5v8.3h6.2v2.3H261.5z"/>
+		<path class="st1" d="M275.6,125v-22.5h5c2.5,0,4.4,0.5,5.5,1.4c1.2,0.9,1.8,2.5,1.8,4.6c0,2.9-1,4.7-3.1,5.3l3.6,11.3H285    l-3.3-10.6H279V125H275.6z M279,112.2h1.3c1.5,0,2.6-0.3,3.2-0.8c0.6-0.5,1-1.5,1-2.9c0-1.4-0.3-2.3-0.8-2.9    c-0.6-0.6-1.6-0.8-3.1-0.8H279V112.2z"/>
+		<path class="st1" d="M307.5,125.3c-2.1,0-3.7-0.6-4.8-1.8c-1.1-1.2-1.7-2.8-1.8-4.8l3.1-0.8c0.2,3.2,1.4,4.8,3.5,4.8    c0.9,0,1.6-0.2,2-0.7c0.5-0.4,0.7-1.1,0.7-2c0-0.5-0.1-0.9-0.2-1.3c-0.1-0.4-0.3-0.8-0.6-1.1c-0.3-0.4-0.6-0.7-0.8-0.9    c-0.3-0.2-0.6-0.6-1.1-1l-4.2-3.4c-0.8-0.7-1.5-1.4-1.8-2.2c-0.4-0.8-0.6-1.7-0.6-2.8c0-1.6,0.5-2.9,1.6-3.8    c1-0.9,2.5-1.4,4.3-1.4c2,0,3.5,0.4,4.5,1.4c1,1,1.6,2.4,1.8,4.4l-2.9,0.7c0-0.5-0.1-0.9-0.2-1.3c-0.1-0.4-0.2-0.8-0.3-1.1    c-0.2-0.4-0.4-0.7-0.6-0.9c-0.2-0.2-0.5-0.4-0.9-0.6c-0.4-0.1-0.8-0.2-1.3-0.2c-1.8,0.1-2.7,0.9-2.7,2.5c0,0.7,0.1,1.2,0.4,1.7    c0.3,0.4,0.7,0.9,1.3,1.4l4.2,3.4c1.1,0.9,2,1.8,2.6,2.9c0.6,1,1,2.2,1,3.5c0,1.6-0.5,3-1.7,3.9    C310.7,124.8,309.3,125.3,307.5,125.3z"/>
+		<path class="st1" d="M323.9,125.3c-1,0-1.9-0.1-2.7-0.4c-0.8-0.3-1.4-0.6-1.9-1c-0.5-0.4-0.9-1-1.2-1.6c-0.3-0.6-0.5-1.3-0.7-2    c-0.1-0.7-0.2-1.5-0.2-2.4v-8c0-1,0.1-1.8,0.2-2.5c0.1-0.7,0.3-1.4,0.7-2.1c0.3-0.6,0.7-1.2,1.2-1.6c0.5-0.4,1.1-0.7,1.9-1    c0.8-0.2,1.7-0.4,2.7-0.4c2.2,0,3.9,0.5,4.8,1.6c1,1.1,1.5,2.7,1.5,4.8v1.8h-3.3V109c0-0.3,0-0.6,0-0.8c0-0.2,0-0.4,0-0.7    c0-0.3,0-0.5-0.1-0.7c0-0.2-0.1-0.4-0.2-0.6c-0.1-0.2-0.1-0.4-0.2-0.5c-0.1-0.1-0.2-0.3-0.4-0.4c-0.1-0.1-0.3-0.2-0.5-0.3    c-0.2-0.1-0.4-0.1-0.7-0.2c-0.3,0-0.5-0.1-0.9-0.1c-0.5,0-0.9,0-1.3,0.1c-0.4,0.1-0.7,0.2-0.9,0.4c-0.2,0.2-0.4,0.4-0.6,0.7    c-0.1,0.2-0.3,0.6-0.3,0.9c-0.1,0.4-0.1,0.8-0.1,1.1c0,0.4,0,0.8,0,1.3v8.9c0,1.7,0.2,2.9,0.7,3.5c0.5,0.7,1.3,1,2.5,1    c0.5,0,0.9,0,1.2-0.1c0.3-0.1,0.6-0.2,0.8-0.4c0.2-0.2,0.4-0.4,0.5-0.7c0.1-0.2,0.2-0.5,0.3-0.9c0.1-0.4,0.1-0.7,0.1-1.1    c0-0.3,0-0.8,0-1.3v-1.7h3.3v1.7c0,0.9-0.1,1.6-0.2,2.3c-0.1,0.7-0.3,1.3-0.6,1.9c-0.3,0.6-0.7,1.1-1.1,1.5    c-0.5,0.4-1.1,0.7-1.8,0.9C325.7,125.2,324.9,125.3,323.9,125.3z"/>
+		<path class="st1" d="M335.2,125v-22.5h3.4V125H335.2z"/>
+		<path class="st1" d="M344.2,125v-22.5h9.6v2.3h-6.2v7.4h5v2.2h-5v8.3h6.2v2.3H344.2z"/>
+		<path class="st1" d="M358.3,125v-22.5h2.4l7.1,15v-15h2.9V125h-2.2l-7.2-15.4V125H358.3z"/>
+		<path class="st1" d="M382.3,125.3c-1,0-1.9-0.1-2.7-0.4c-0.8-0.3-1.4-0.6-1.9-1c-0.5-0.4-0.9-1-1.2-1.6c-0.3-0.6-0.5-1.3-0.7-2    c-0.1-0.7-0.2-1.5-0.2-2.4v-8c0-1,0.1-1.8,0.2-2.5c0.1-0.7,0.3-1.4,0.7-2.1c0.3-0.6,0.7-1.2,1.2-1.6c0.5-0.4,1.1-0.7,1.9-1    c0.8-0.2,1.7-0.4,2.7-0.4c2.2,0,3.9,0.5,4.8,1.6c1,1.1,1.5,2.7,1.5,4.8v1.8h-3.3V109c0-0.3,0-0.6,0-0.8c0-0.2,0-0.4,0-0.7    c0-0.3,0-0.5-0.1-0.7c0-0.2-0.1-0.4-0.2-0.6c-0.1-0.2-0.1-0.4-0.2-0.5c-0.1-0.1-0.2-0.3-0.4-0.4c-0.1-0.1-0.3-0.2-0.5-0.3    c-0.2-0.1-0.4-0.1-0.7-0.2c-0.3,0-0.5-0.1-0.9-0.1c-0.5,0-0.9,0-1.3,0.1c-0.4,0.1-0.7,0.2-0.9,0.4c-0.2,0.2-0.4,0.4-0.6,0.7    c-0.1,0.2-0.3,0.6-0.3,0.9c-0.1,0.4-0.1,0.8-0.1,1.1c0,0.4,0,0.8,0,1.3v8.9c0,1.7,0.2,2.9,0.7,3.5c0.5,0.7,1.3,1,2.5,1    c0.5,0,0.9,0,1.2-0.1c0.3-0.1,0.6-0.2,0.8-0.4c0.2-0.2,0.4-0.4,0.5-0.7c0.1-0.2,0.2-0.5,0.3-0.9c0.1-0.4,0.1-0.7,0.1-1.1    c0-0.3,0-0.8,0-1.3v-1.7h3.3v1.7c0,0.9-0.1,1.6-0.2,2.3c-0.1,0.7-0.3,1.3-0.6,1.9c-0.3,0.6-0.7,1.1-1.1,1.5    c-0.5,0.4-1.1,0.7-1.8,0.9C384.1,125.2,383.2,125.3,382.3,125.3z"/>
+		<path class="st1" d="M393.4,125v-22.5h9.6v2.3h-6.2v7.4h5v2.2h-5v8.3h6.2v2.3H393.4z"/>
+	</g>
+</g>
+</svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/r_studio.svg b/web/pandas/static/img/partners/r_studio.svg
new file mode 100644
index 0000000000000..15a1d2a30ff30
--- /dev/null
+++ b/web/pandas/static/img/partners/r_studio.svg
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generator: Adobe Illustrator 22.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 1784.1 625.9" style="enable-background:new 0 0 1784.1 625.9;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#75AADB;}
+	.st1{fill:#4D4D4D;}
+	.st2{fill:#FFFFFF;}
+	.st3{fill:url(#SVGID_1_);}
+	.st4{fill:url(#SVGID_2_);}
+	.st5{fill:url(#SVGID_3_);}
+	.st6{fill:url(#SVGID_4_);}
+	.st7{fill:url(#SVGID_5_);}
+	.st8{fill:url(#SVGID_6_);}
+	.st9{fill:url(#SVGID_7_);}
+	.st10{fill:url(#SVGID_8_);}
+	.st11{fill:url(#SVGID_9_);}
+	.st12{fill:url(#SVGID_10_);}
+	.st13{opacity:0.18;fill:url(#SVGID_11_);}
+	.st14{opacity:0.3;}
+</style>
+<g id="Gray_Logo">
+</g>
+<g id="Black_Letters">
+</g>
+<g id="Blue_Gradient_Letters">
+	<g>
+		
+			<ellipse transform="matrix(0.7071 -0.7071 0.7071 0.7071 -127.9265 317.0317)" class="st0" cx="318.7" cy="312.9" rx="309.8" ry="309.8"/>
+		<g>
+			<path class="st1" d="M694.4,404.8c16.1,10.3,39.1,18.1,63.9,18.1c36.7,0,58.1-19.4,58.1-47.4c0-25.5-14.8-40.8-52.3-54.8     c-45.3-16.5-73.3-40.4-73.3-79.1c0-43.3,35.8-75.4,89.8-75.4c28,0,49,6.6,61,13.6l-9.9,29.3c-8.7-5.4-27.2-13.2-52.3-13.2     c-37.9,0-52.3,22.7-52.3,41.6c0,26,16.9,38.7,55.2,53.6c47,18.1,70.5,40.8,70.5,81.6c0,42.8-31.3,80.3-96.8,80.3     c-26.8,0-56-8.2-70.9-18.1L694.4,404.8z"/>
+			<path class="st1" d="M943.3,201.3v47.8h51.9v27.6h-51.9v107.5c0,24.7,7,38.7,27.2,38.7c9.9,0,15.7-0.8,21-2.5l1.6,27.6     c-7,2.5-18.1,4.9-32.1,4.9c-16.9,0-30.5-5.8-39.1-15.2c-9.9-11.1-14-28.8-14-52.3V276.7h-30.9v-27.6h30.9V212L943.3,201.3z"/>
+			<path class="st1" d="M1202.8,393.7c0,21,0.4,39.1,1.6,54.8h-32.1l-2.1-32.5h-0.8c-9.1,16.1-30.5,37.1-65.9,37.1     c-31.3,0-68.8-17.7-68.8-87.3V249.1h36.3v110c0,37.9,11.9,63.9,44.5,63.9c24.3,0,41.2-16.9,47.8-33.4c2.1-4.9,3.3-11.5,3.3-18.5     v-122h36.3V393.7z"/>
+			<path class="st1" d="M1434.8,156v241c0,17.7,0.8,37.9,1.6,51.5h-32.1l-1.6-34.6h-1.2c-10.7,22.2-34.6,39.1-67.2,39.1     c-48.2,0-85.7-40.8-85.7-101.4c-0.4-66.3,41.2-106.7,89.4-106.7c30.9,0,51.1,14.4,60.2,30.1h0.8V156H1434.8z M1398.9,330.2     c0-4.5-0.4-10.7-1.6-15.2c-5.4-22.7-25.1-41.6-52.3-41.6c-37.5,0-59.7,33-59.7,76.6c0,40.4,20.2,73.8,58.9,73.8     c24.3,0,46.6-16.5,53.1-43.3c1.2-4.9,1.6-9.9,1.6-15.7V330.2z"/>
+			<path class="st1" d="M1535.7,193c0,12.4-8.7,22.2-23.1,22.2c-13.2,0-21.8-9.9-21.8-22.2c0-12.4,9.1-22.7,22.7-22.7     C1526.6,170.4,1535.7,180.3,1535.7,193z M1495.3,448.5V249.1h36.3v199.4H1495.3z"/>
+			<path class="st1" d="M1772.2,347.1c0,73.7-51.5,105.9-99.3,105.9c-53.6,0-95.6-39.6-95.6-102.6c0-66.3,44.1-105.5,98.9-105.5     C1733.5,245,1772.2,286.6,1772.2,347.1z M1614.4,349.2c0,43.7,24.7,76.6,60.2,76.6c34.6,0,60.6-32.5,60.6-77.5     c0-33.8-16.9-76.2-59.7-76.2C1632.9,272.1,1614.4,311.7,1614.4,349.2z"/>
+		</g>
+		<g>
+			<path class="st2" d="M424.7,411.8h33.6v26.1h-51.3L322,310.5h-45.3v101.3h44.3v26.1H209.5v-26.1h38.3V187.3l-38.3-4.7v-24.7     c14.5,3.3,27.1,5.6,42.9,5.6c23.8,0,48.1-5.6,71.9-5.6c46.2,0,89.1,21,89.1,72.3c0,39.7-23.8,64.9-60.7,75.6L424.7,411.8z      M276.7,285.3l24.3,0.5c59.3,0.9,82.1-21.9,82.1-52.3c0-35.5-25.7-49.5-58.3-49.5c-15.4,0-31.3,1.4-48.1,3.3V285.3z"/>
+		</g>
+		<g>
+			<path class="st1" d="M1751.8,170.4c-12.9,0-23.4,10.5-23.4,23.4c0,12.9,10.5,23.4,23.4,23.4c12.9,0,23.4-10.5,23.4-23.4     C1775.2,180.9,1764.7,170.4,1751.8,170.4z M1771.4,193.8c0,10.8-8.8,19.5-19.5,19.5c-10.8,0-19.5-8.8-19.5-19.5     c0-10.8,8.8-19.5,19.5-19.5C1762.6,174.2,1771.4,183,1771.4,193.8z"/>
+			<path class="st1" d="M1760.1,203.3l-5.8-8.5c3.3-1.2,5-3.6,5-7c0-5.1-4.3-6.9-8.4-6.9c-1.1,0-2.2,0.1-3.2,0.3     c-1,0.1-2.1,0.2-3.1,0.2c-1.4,0-2.5-0.2-3.7-0.5l-0.6-0.1v3.3l3.4,0.4v18.8h-3.4v3.4h10.9v-3.4h-3.9v-7.9h3.2l7.3,11l0.2,0.2h5.3     v-3.4H1760.1z M1755.6,188.1c0,1.2-0.5,2.2-1.4,2.9c-1.1,0.8-2.8,1.2-5,1.2l-1.9,0v-7.7c1.4-0.1,2.6-0.2,3.7-0.2     C1753.1,184.3,1755.6,185,1755.6,188.1z"/>
+		</g>
+	</g>
+</g>
+<g id="White_Letters">
+</g>
+<g id="R_Ball">
+</g>
+</svg>
\ No newline at end of file
diff --git a/web/pandas/static/img/partners/tidelift.svg b/web/pandas/static/img/partners/tidelift.svg
new file mode 100644
index 0000000000000..af12d68417235
--- /dev/null
+++ b/web/pandas/static/img/partners/tidelift.svg
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Artwork" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 190.1 33" style="enable-background:new 0 0 190.1 33;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#4B5168;}
+	.st1{fill:#F6914D;}
+</style>
+<g>
+	<path class="st0" d="M33.4,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3
+		C33.4,29.9,33.4,29.9,33.4,27.7z"/>
+	<path class="st0" d="M45,26.4V6.6c0-3.6,0-3.6,3.6-3.6h5.8c7.8,0,12.5,3.9,13,10.2c0.2,2.2,0.2,3.4,0,5.5
+		c-0.5,6.3-5.3,11.2-13,11.2h-5.8C45,29.9,45,29.9,45,26.4z M54.3,25.4c5.3,0,8-3,8.3-7.1c0.1-1.8,0.1-2.8,0-4.6
+		c-0.3-4.2-3-6.1-8.3-6.1h-4.5v17.8H54.3z"/>
+	<path class="st0" d="M73.8,26.4V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2H78.6v6.9h11
+		c2.2,0,2.2,0,2.2,2.1c0,2.1,0,2.1-2.2,2.1h-11v6.9h12.3c2.3,0,2.3,0,2.3,2.2c0,2.3,0,2.3-2.3,2.3H77.4
+		C73.8,29.9,73.8,29.9,73.8,26.4z"/>
+	<path class="st0" d="M100,26.4v-21c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v20.2h11.9c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2
+		h-13.1C100,29.9,100,29.9,100,26.4z"/>
+	<path class="st0" d="M125.8,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3
+		C125.8,29.9,125.8,29.9,125.8,27.7z"/>
+	<path class="st0" d="M137.4,27.7V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-12.2v7.2h11.3
+		c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-11.3v8.6c0,2.3,0,2.3-2.4,2.3S137.4,29.9,137.4,27.7z"/>
+	<path class="st0" d="M24.2,3.1H5.5c-2.4,0-2.4,0-2.4,2.2c0,2.2,0,2.2,2.4,2.2h7v4.7v3.2l4.8-3.7v-1.1V7.5h7c2.4,0,2.4,0,2.4-2.2
+		C26.6,3.1,26.6,3.1,24.2,3.1z"/>
+	<path class="st1" d="M12.5,20v7.6c0,2.3,0,2.3,2.4,2.3c2.4,0,2.4,0,2.4-2.3V16.3L12.5,20z"/>
+	<g>
+		<path class="st0" d="M165.9,3.1h18.7c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2h-7v4.7v3.2l-4.8-3.7v-1.1V7.5h-7
+			c-2.4,0-2.4,0-2.4-2.2C163.5,3.1,163.5,3.1,165.9,3.1z"/>
+		<path class="st1" d="M177.6,20v7.6c0,2.3,0,2.3-2.4,2.3c-2.4,0-2.4,0-2.4-2.3V16.3L177.6,20z"/>
+	</g>
+</g>
+</svg>
diff --git a/web/pandas/static/img/partners/two_sigma.svg b/web/pandas/static/img/partners/two_sigma.svg
new file mode 100644
index 0000000000000..d38df12766ed6
--- /dev/null
+++ b/web/pandas/static/img/partners/two_sigma.svg
@@ -0,0 +1 @@
+<svg width="230" height="42" viewBox="0 0 230 42" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><title>Logo</title><defs><path id="a" d="M19.436 21.668V1.025H0v20.643h19.435z"></path></defs><g fill="none" fill-rule="evenodd"><path fill="#2D2D2D" d="M59.06 13.464h-7.137v-3.155h17.811v3.155H62.6V30.95h-3.54zm14.01-3.155h3.745l4.747 15.66h.06l4.483-15.66h3.301l4.454 15.66h.059l4.777-15.66h3.716L95.895 30.95H92.09l-4.335-15.127h-.059L83.361 30.95h-3.804zm41.214-.355c5.986 0 10.527 4.158 10.527 10.556 0 6.55-4.541 10.794-10.527 10.794-5.985 0-10.558-4.245-10.558-10.794 0-6.398 4.573-10.556 10.558-10.556m0 18.285c3.892 0 6.93-2.89 6.93-7.729 0-4.658-3.007-7.518-6.93-7.518-3.922 0-6.93 2.86-6.93 7.518 0 4.839 3.038 7.73 6.93 7.73m40.846-17.931h3.539V30.95h-3.54V19.41zm18.744-.355c2.832 0 5.222.885 7.313 2.33 0 0-2.026 2.374-2.128 2.311-1.56-1-3.21-1.574-5.096-1.574-4.247 0-7.048 3.068-7.048 7.433 0 4.746 2.624 7.785 7.048 7.785 1.534 0 3.067-.385 4.13-1.003v-4.897h-5.19v-2.623h8.462v9.347c-2.007 1.416-4.63 2.24-7.49 2.24-6.46 0-10.587-4.363-10.587-10.85 0-6.075 4.187-10.499 10.586-10.499m12.506.355h3.57l6.812 9.701 6.811-9.701h3.541V30.95h-3.421V15.558l-6.962 9.73-6.958-9.73V30.95h-3.392z"></path><g transform="translate(210.418 9.283)"><mask id="b" fill="#fff"><use xlink:href="#a"></use></mask><path d="M7.639 1.025h4.158l7.64 20.643H15.63l-1.561-4.454H5.368l-1.533 4.454H0L7.639 1.025zM6.34 14.354h6.725L9.734 4.74h-.06L6.34 14.354z" fill="#2D2D2D" mask="url(#b)"></path></g><path d="M136.826 26.498c1.861 1.007 3.618 1.68 5.887 1.68 2.715 0 4.069-1.18 4.069-2.83 0-4.66-11.616-1.594-11.616-9.466 0-3.303 2.74-5.928 7.37-5.928 2.714 0 5.443.653 7.579 1.902l-2.314 2.361c-1.68-.72-3.11-1.137-5.146-1.137-2.389 0-3.806 1.21-3.806 2.744 0 4.63 11.62 1.473 11.62 9.494 0 3.393-2.567 5.985-7.756 5.985-3.035 0-6.33-1.076-8.273-2.419l2.386-2.386z" fill="#2D2D2D"></path><path fill="#009AA6" d="M20.625 0L0 20.63l20.625 20.628 20.63-20.628z"></path><path d="M9.748 26.478c-.16-6.605 7.789-5.746 7.789-9.13 0-1.1-.863-2.041-2.784-2.041-1.401 0-2.743.701-3.724 1.602l-1.46-1.463c1.259-1.18 3.223-2.14 5.284-2.14 3.304 0 4.986 1.842 4.986 4.003 0 4.986-7.728 4.104-7.728 8.27h7.607v1.98h-9.95l-.02-1.081zm15.937-.5c-1.521 0-2.423-.98-2.423-2.862 0-2.404 1.602-4.566 3.525-4.566 1.5 0 2.402.981 2.402 2.883 0 2.401-1.582 4.545-3.504 4.545zm9.713-9.25h-8.444v.003c-3.437.005-6.033 2.745-6.033 6.403 0 2.905 1.881 4.666 4.544 4.666 3.464 0 6.067-2.743 6.067-6.386 0-1.182-.313-2.173-.856-2.935h2.947l1.775-1.75z" fill="#FFF"></path></g></svg>
diff --git a/web/pandas/static/img/partners/ursa_labs.svg b/web/pandas/static/img/partners/ursa_labs.svg
new file mode 100644
index 0000000000000..cacc80e337d25
--- /dev/null
+++ b/web/pandas/static/img/partners/ursa_labs.svg
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 23.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 359 270" style="enable-background:new 0 0 359 270;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:#404040;}
+	.st1{filter:url(#Adobe_OpacityMaskFilter);}
+	.st2{fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFFF;}
+	.st3{mask:url(#mask-2_1_);}
+</style>
+<title>HOME 1 Copy 8</title>
+<desc>Created with Sketch.</desc>
+<g id="HOME-1-Copy-8">
+	<g id="Group" transform="translate(20.000000, 20.000000)">
+		<path id="URSA-LABS-Copy" class="st0" d="M0,158.4h9.1V214c0,0.3,0,0.7,0.1,1.1c0,0.3,0,0.9,0.1,1.6s0.2,1.5,0.6,2.3
+			c0.3,0.8,0.9,1.5,1.6,2.1c0.7,0.6,1.8,0.9,3.3,0.9c0.3,0,0.9,0,1.6-0.1c0.7-0.1,1.4-0.4,2.1-0.9c1-0.9,1.6-2,1.8-3.3
+			s0.3-3.2,0.4-5.5v-53.8h9.2v54.4c0,0.6,0,1.3-0.1,2.1c-0.1,0.8-0.2,1.7-0.3,2.6s-0.3,1.8-0.5,2.6c-0.7,2.3-1.7,4.1-3,5.4
+			c-1.3,1.3-2.7,2.3-4.2,2.9c-1.5,0.7-2.9,1.1-4.2,1.2c-1.3,0.1-2.3,0.2-3,0.2c-0.6,0-1.5-0.1-2.7-0.2c-1.2-0.1-2.5-0.5-3.8-1
+			s-2.6-1.4-3.8-2.5c-1.2-1.1-2.2-2.7-3-4.6c-0.4-1-0.7-2.1-0.9-3.3c-0.2-1.2-0.3-2.9-0.4-5V158.4z M44,158.4h17
+			c0.6,0,1.2,0,1.7,0.1c0.6,0.1,1.3,0.2,2.2,0.3c0.9,0.1,1.7,0.4,2.6,0.8c0.8,0.4,1.6,1.1,2.3,2c0.7,0.9,1.2,2.1,1.6,3.7
+			c0.4,1.8,0.6,5.1,0.6,10.1c0,1.3,0,2.7-0.1,4.1c0,1.4-0.1,2.8-0.2,4.2c-0.1,0.9-0.3,1.9-0.4,2.9s-0.4,1.9-0.7,2.7
+			c-0.4,0.9-0.9,1.6-1.6,2.1s-1.3,0.8-2,1c-0.7,0.2-1.3,0.3-1.9,0.3H64v0.5c1.3,0.1,2.4,0.3,3.3,0.6c0.9,0.3,1.8,1,2.5,2.1
+			c0.8,1.3,1.3,2.7,1.5,4.3c0.2,1.6,0.3,3.9,0.3,6.8v7.7c0,2,0,3.6,0.1,4.9c0.1,1.3,0.2,2.4,0.3,3.3c0.1,0.9,0.3,1.8,0.5,2.7
+			c0.2,0.9,0.6,1.8,1,2.9h-9.7c-0.3-1.7-0.6-3-0.8-4.1s-0.3-2.2-0.4-3.2c-0.1-1-0.2-2.1-0.2-3.2c0-1.1-0.1-2.5-0.1-4.2v-5
+			c-0.1-1.2-0.1-2.4-0.2-3.6c0-1.2-0.1-2.4-0.3-3.6c-0.1-0.9-0.3-1.7-0.5-2.5c-0.2-0.8-0.6-1.5-1.2-2c-0.5-0.3-1-0.5-1.5-0.6
+			s-1-0.2-1.6-0.2h-3.8v32.4H44V158.4z M53.4,166.9v21.7h4.4c1.2,0,2.2-0.2,2.9-0.6c0.7-0.4,1.2-1.2,1.6-2.5
+			c0.2-0.9,0.3-2.3,0.4-4.2s0.1-4.1,0.1-6.6c0-0.7,0-1.5-0.1-2.2c0-0.8-0.1-1.5-0.2-2.2c-0.1-1.4-0.4-2.3-1-2.8
+			c-0.3-0.3-0.8-0.5-1.3-0.5c-0.5,0-1.2,0-2.2,0H53.4z M110.6,169.1v12.4h-8.5v-12.4c0-0.2,0-0.6-0.1-1.1c0-0.5-0.2-1.1-0.4-1.6
+			c-0.2-0.5-0.6-1-1.1-1.4s-1.3-0.6-2.3-0.6c-1.1,0-2,0.2-2.6,0.6c-0.6,0.4-1.1,1-1.4,1.7c-0.3,0.7-0.5,1.5-0.6,2.3
+			c-0.1,0.9-0.1,1.7-0.1,2.5c0,1.5,0.1,2.8,0.3,4c0.2,1.2,0.5,2.3,0.9,3.4s0.9,2.2,1.5,3.2s1.3,2.2,2.1,3.4c0.7,1.1,1.3,2.1,2,3.1
+			c0.7,1,1.4,2,2.1,3.1c1,1.4,2,2.9,3.1,4.6c1.2,1.9,2.2,3.7,2.9,5.3c0.7,1.6,1.3,3.1,1.7,4.5c0.4,1.4,0.7,2.7,0.8,3.9
+			c0.1,1.2,0.2,2.3,0.2,3.3c0,0.4,0,1.3-0.1,2.6c-0.1,1.3-0.4,2.8-0.9,4.4c-0.5,1.6-1.3,3.3-2.3,4.9c-1,1.6-2.6,2.9-4.6,3.7
+			c-0.6,0.3-1.4,0.5-2.4,0.7c-1,0.2-2.3,0.3-3.8,0.3c-2.9,0-5.1-0.5-6.8-1.4s-2.8-1.9-3.6-2.8c-1.5-1.7-2.3-3.4-2.6-5.3
+			s-0.4-3.8-0.5-5.9V203h8.6v12.8c0,1.7,0.2,3,0.5,3.8c0.3,0.8,0.8,1.5,1.6,2c0.2,0.1,0.5,0.3,1,0.5c0.5,0.2,1.1,0.3,1.8,0.3
+			c1.1,0,2-0.3,2.7-0.8c0.6-0.6,1.1-1.3,1.4-2.1c0.3-0.8,0.4-1.7,0.5-2.7c0-1,0.1-1.8,0.1-2.6c0-2.5-0.3-4.6-0.8-6.4
+			c-0.5-1.7-1.4-3.7-2.7-5.9c-1.3-2.3-2.8-4.5-4.3-6.6s-2.9-4.3-4.3-6.5c-0.4-0.6-0.9-1.4-1.5-2.4c-0.6-1-1.2-2.2-1.8-3.6
+			c-0.6-1.4-1.1-3-1.5-4.7s-0.7-3.7-0.7-5.7c0-3.9,0.7-6.9,2.1-9s2.8-3.7,4.3-4.5c0.7-0.5,1.8-0.9,3.1-1.3c1.3-0.4,3-0.6,5-0.6
+			c0.5,0,1.2,0,2.3,0.1c1,0.1,2.1,0.3,3.3,0.7c1.1,0.4,2.2,1.1,3.3,2c1.1,0.9,1.9,2.3,2.4,4c0.2,0.7,0.4,1.4,0.5,2.1
+			C110.5,166.6,110.5,167.7,110.6,169.1z M140.1,158.4l10.9,70.3h-9.1l-1.8-12.9h-10.6l-1.6,12.9h-9.1l10-70.3H140.1z M133.5,183
+			l-3,24.2h8.4l-3.5-24.4c-0.1-0.6-0.2-1.2-0.3-1.8c0-0.6-0.1-1.2-0.2-1.8c-0.1-1.3-0.1-2.6-0.1-3.8c0-1.3,0-2.5-0.1-3.8H134
+			c-0.1,1.9-0.1,3.8-0.2,5.7C133.7,179.2,133.6,181.1,133.5,183z M190.2,158.4V220h15.4v8.7h-24.7v-70.3H190.2z M232,158.4
+			l10.9,70.3h-9.1l-1.8-12.9h-10.6l-1.6,12.9h-9.1l10-70.3H232z M225.4,183l-3,24.2h8.4l-3.5-24.4c-0.1-0.6-0.2-1.2-0.3-1.8
+			c0-0.6-0.1-1.2-0.2-1.8c-0.1-1.3-0.1-2.6-0.1-3.8c0-1.3,0-2.5-0.1-3.8h-0.8c-0.1,1.9-0.1,3.8-0.2,5.7
+			C225.6,179.2,225.5,181.1,225.4,183z M251.9,158.4h16.5c1.5,0,2.9,0.1,4.4,0.2s2.8,0.8,3.9,1.8c1.3,1.2,2,2.7,2.2,4.5
+			c0.2,1.8,0.3,4.3,0.4,7.4c0,0.6,0,1.2,0.1,1.8c0,0.6,0.1,1.2,0.1,1.8c0,1.1,0,2.2-0.1,3.3c0,1.1-0.1,2.2-0.2,3.3
+			c0,0.2,0,0.9-0.1,2.1c-0.1,1.2-0.3,2.3-0.8,3.3c-0.4,0.7-1,1.3-1.7,1.8c-0.7,0.5-1.4,0.8-2.2,1c-0.4,0.1-0.8,0.2-1.3,0.2
+			c-0.5,0-0.8,0-0.9,0.1v0.5c1.3,0.1,2.4,0.4,3.5,0.7c1,0.4,1.9,1.1,2.6,2.2c0.5,1,0.8,2.2,0.9,3.7c0.1,1.5,0.1,3.4,0.1,5.9
+			c0.1,0.9,0.1,1.9,0.1,2.8v7c0,1.4-0.1,2.8-0.2,4.3c0,0.2,0,0.6-0.1,1.2c0,0.6-0.2,1.3-0.4,2.1c-0.2,0.8-0.5,1.6-0.9,2.5
+			s-1,1.6-1.7,2.3c-1.4,1.1-3,1.8-4.9,1.9s-3.6,0.2-5.3,0.2h-14.2V158.4z M260.9,166.8v21.1h3.6c1.5-0.1,2.7-0.2,3.7-0.5
+			c1-0.3,1.6-1.3,1.8-3c0.2-1.4,0.3-3.8,0.3-7.1c0-2.2-0.1-4.4-0.3-6.6c-0.1-1.7-0.4-2.8-1-3.3c-0.3-0.3-0.8-0.5-1.3-0.5
+			c-0.5,0-1.2,0-2.1,0H260.9z M260.9,195.5V220h4.8c0.5,0,1,0,1.5,0c0.5,0,0.9-0.1,1.3-0.2c0.4-0.1,0.7-0.3,1-0.6
+			c0.3-0.3,0.5-0.8,0.6-1.4c0-0.3,0-0.7,0.1-1.4c0-0.7,0.1-1.5,0.1-2.4c0-0.9,0.1-1.9,0.1-2.9c0-1.1,0.1-2.1,0.1-3.1
+			c0-1.2,0-2.4-0.1-3.5c0-1.2-0.1-2.3-0.2-3.5c-0.1-0.7-0.2-1.4-0.3-2.3c-0.1-0.9-0.4-1.6-1-2.1c-0.4-0.3-0.9-0.5-1.4-0.6
+			s-1-0.1-1.5-0.1H260.9z M318.4,169.1v12.4h-8.5v-12.4c0-0.2,0-0.6-0.1-1.1c0-0.5-0.2-1.1-0.4-1.6c-0.2-0.5-0.6-1-1.1-1.4
+			c-0.5-0.4-1.3-0.6-2.3-0.6c-1.1,0-2,0.2-2.6,0.6s-1.1,1-1.4,1.7s-0.5,1.5-0.6,2.3c-0.1,0.9-0.1,1.7-0.1,2.5c0,1.5,0.1,2.8,0.3,4
+			s0.5,2.3,0.9,3.4s0.9,2.2,1.5,3.2c0.6,1.1,1.3,2.2,2.1,3.4c0.7,1.1,1.3,2.1,2,3.1c0.7,1,1.4,2,2.1,3.1c1,1.4,2,2.9,3.1,4.6
+			c1.2,1.9,2.2,3.7,2.9,5.3c0.7,1.6,1.3,3.1,1.7,4.5c0.4,1.4,0.7,2.7,0.8,3.9c0.1,1.2,0.2,2.3,0.2,3.3c0,0.4,0,1.3-0.1,2.6
+			c-0.1,1.3-0.4,2.8-0.9,4.4c-0.5,1.6-1.3,3.3-2.3,4.9c-1,1.6-2.6,2.9-4.6,3.7c-0.6,0.3-1.4,0.5-2.4,0.7c-1,0.2-2.3,0.3-3.8,0.3
+			c-2.9,0-5.1-0.5-6.8-1.4c-1.6-0.9-2.8-1.9-3.6-2.8c-1.5-1.7-2.3-3.4-2.6-5.3c-0.3-1.9-0.4-3.8-0.5-5.9V203h8.6v12.8
+			c0,1.7,0.2,3,0.5,3.8c0.3,0.8,0.8,1.5,1.6,2c0.2,0.1,0.5,0.3,1,0.5c0.5,0.2,1.1,0.3,1.8,0.3c1.1,0,2-0.3,2.7-0.8
+			c0.6-0.6,1.1-1.3,1.4-2.1c0.3-0.8,0.4-1.7,0.5-2.7c0-1,0.1-1.8,0.1-2.6c0-2.5-0.3-4.6-0.8-6.4c-0.5-1.7-1.4-3.7-2.7-5.9
+			c-1.3-2.3-2.8-4.5-4.3-6.6c-1.5-2.1-2.9-4.3-4.3-6.5c-0.4-0.6-0.9-1.4-1.5-2.4c-0.6-1-1.2-2.2-1.8-3.6c-0.6-1.4-1.1-3-1.5-4.7
+			c-0.4-1.8-0.7-3.7-0.7-5.7c0-3.9,0.7-6.9,2.1-9s2.8-3.7,4.3-4.5c0.7-0.5,1.8-0.9,3.1-1.3c1.3-0.4,3-0.6,5-0.6c0.5,0,1.2,0,2.3,0.1
+			c1,0.1,2.1,0.3,3.3,0.7s2.2,1.1,3.3,2s1.9,2.3,2.4,4c0.2,0.7,0.4,1.4,0.5,2.1C318.2,166.6,318.3,167.7,318.4,169.1z"/>
+		<g id="Group-3-Copy" transform="translate(47.000000, 0.000000)">
+			<g id="Clip-2">
+			</g>
+			<defs>
+				<filter id="Adobe_OpacityMaskFilter" filterUnits="userSpaceOnUse" x="0" y="0" width="225.8" height="123.9">
+					<feColorMatrix  type="matrix" values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 1 0"/>
+				</filter>
+			</defs>
+			<mask maskUnits="userSpaceOnUse" x="0" y="0" width="225.8" height="123.9" id="mask-2_1_">
+				<g class="st1">
+					<polygon id="path-1_1_" class="st2" points="0,0 225.9,0 225.9,123.9 0,123.9 					"/>
+				</g>
+			</mask>
+			<g id="Page-1" class="st3">
+				<g id="Mask">
+					<path class="st0" d="M177.2,54.3c6.1,21.2,19.4,48.5,24,54.7c5.3-1.2,9.1,1.2,12.4,5.1c-1.2,0.9-2.7,1.5-3.4,2.6
+						c-2.7,4.4-6.9,3-10.7,3.2c-2.8,0.2-5.6,0.3-8.4,0.3c-0.9,0-1.8-0.3-2.7-0.5c-1-0.3-1.9-1-2.8-1c-2.5,0.1-4.7,0-7.1-1.1
+						c-1-0.5-2.6,0.9-3.6-0.8c-1.1-1.8-2.2-3.6-3.4-5.5c-1.2,0.2-2.2,0.4-3.4,0.6c-2.4-3-3.4-14.8-6.1-17.7
+						c-0.6-0.7-2.1-2.2-3.8-2.7c-0.3-0.9-5.4-7.2-5.9-8.7c-0.2-0.5-0.3-1.2-0.7-1.4c-3.1-2-4.2-4.9-4-8.5c0-0.4-0.2-0.7-0.4-1.7
+						c-1.2,2.7-2.2,4.8-3.2,7.1c-0.6,1.4-1,2.9-1.8,4.3c-0.5,0.9-1.3,1.6-2,2.3c-2.4,2.2-1.8,0.9-3.2,3.6c-1.1,2-2,4-3,6.1
+						c-0.5,1.1-0.9,2.2-1.1,3.3c-0.7,4.1-3.2,7.6-1.5,11.2c3,0.6,6.3,0.5,8.6,2c2.2,1.5,3.5,4.5,5,6.7c-3.1,0.5-5.9,1.2-8.7,1.4
+						c-3.8,0.3-7.6,0.2-11.3,0.2c-5,0-10.1-0.1-15.1-0.1c-2.6,0-3.9-1.5-5.4-3.7c-2.1-3.1-1.1-6-0.8-9.1c0.1-0.8,0-3.3-0.1-4.2
+						c-0.1-0.9-0.1-1.9,0-2.9c0.2-1.3,0.8-2.6,0.9-3.9c0.1-1.5-0.4-3-0.4-4.5c0-1.5,0.1-3.1,0.5-4.6c0.7-2.7-0.1,0,0.7-2.7
+						c0.1-0.2,0-0.7,0-0.8c-0.9-3.6,1.8-6,2.8-8.8c0-0.1,0-0.1-0.1-0.5c-1.8,1.8-4.1,0.8-6.1,1.2c-2.9,0.6-5.7,2.1-8,3
+						c-1.4-0.1-2.5-0.4-3.5-0.2c-2,0.5-3.9,1.1-6.2,0.9c-2.5-0.2-5.1,0.6-7.7,0.8c-2.2,0.2-4.8,0.9-6.5,0c-1.5-0.7-2.8-0.9-4.4-1
+						c-1.6-0.1-2.4,0.7-2.6,2.1c-1.1,6.3-2.3,12.7-3.1,19.1c-0.4,3.3-0.2,6.6-0.2,9.9c0,1.5,0.6,2.5,1.9,3.5
+						c1.5,1.1,2.6,2.7,3.6,4.3c0.8,1.3,0.6,2.6-1.5,2.7c-7.3,0.2-14.6,0.5-21.9,0.4c-2.1,0-4.2-1.5-6.2-2.5
+						c-0.3-0.2-0.4-1.1-0.4-1.7c0-4.4,0-13.5,0-18.4c-1,0.6-1.3,0.8-1.6,1c-2.5,2.3-4.9,4.1-7.3,6.4c-1.9,1.8-1.6,3.3,0.2,5.4
+						c2.4,2.7,4.4,5.7,4.4,9.5c0,2.5-2.2,3.2-3.8,3.3c-5.7,0.4-11.5,0.4-17.2,0.4c-2.8,0-3.8-1.5-4.4-4.2
+						c-1.2-5.4-2.2-10.8-4.3-16.1c-1.6-4.1-2-8.9,1.5-13c5.1-5.9,9.5-12.3,12.8-19.5c1-2.2,1.4-3.8,0.4-6.1c-4.9-1-7.1-3.7-8.2-8.7
+						c-1-4.6-0.2-8.9,1-13.2c2.3-7.8,4.1-11,8.4-18c5.6-9,13.4-15.5,22.8-20.2c11.3-5.6,23.3-5.5,35.3-4.2
+						c16.2,1.6,32.4,3.6,48.6,5.3c1.3,0.1,2.9-0.2,4.1-0.8c7.7-3.9,15.5-4.2,23.6-1.4c5.6,1.9,11.4,3.6,17.1,5.2
+						c2,0.6,4.1,0.8,6.2,1.1c5.7,0.9,11.5,1.8,17.3,2.4c2.9,0.3,5.9,0.1,8.8,0.3c0.7,0,1.5,0.3,2.1,0.7c2.6,1.8,5.1,3.7,7.5,5.6
+						c1.6,1.2,3.2,2.3,4.5,3.8c0.6,0.7,0.7,1.9,0.9,2.9c0.3,1.1,0.3,2.6,0.9,3.4c2.6,3.1,5.3,6,8.1,8.9c0.9,1,1.1,1.7,0.3,2.9
+						c-1.2,1.6-1.8,3.7-3.3,4.8c-3.1,2.2-6.3,4.3-10.7,3.2c-2.5-0.6-5.5,0.5-8.2,0.8c-2.1,0.3-4.3,0.2-6.2,0.9
+						c-4.1,1.6-8.5,1.1-12.5,2.3c-1.5,0.4-2.8,1.2-4.3,1.6C179.2,54.8,178.3,54.5,177.2,54.3"/>
+				</g>
+			</g>
+		</g>
+	</g>
+</g>
+</svg>
diff --git a/web/pandas/static/img/pydata_book.gif b/web/pandas/static/img/pydata_book.gif
new file mode 100644
index 0000000000000..db05c209704a2
Binary files /dev/null and b/web/pandas/static/img/pydata_book.gif differ
diff --git a/web/pandas/try.md b/web/pandas/try.md
new file mode 100644
index 0000000000000..20e119759df6f
--- /dev/null
+++ b/web/pandas/try.md
@@ -0,0 +1,21 @@
+# Try pandas online
+
+<section>
+    <pre data-executable>
+import pandas
+fibonacci = pandas.Series([1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
+fibonacci.sum()
+    </pre>
+    <script src="https://combinatronics.com/ines/juniper/v0.1.0/dist/juniper.min.js"></script>
+    <script>new Juniper({ repo: 'datapythonista/pandas-web' })</script>
+</section>
+
+## Interactive tutorials
+
+You can also try _pandas_ on [Binder](https://mybinder.org/) for one of the next topics:
+
+- Exploratory analysis of US presidents
+- Preprocessing the Titanic dataset to train a machine learning model
+- Forecasting the stock market
+
+_(links will be added soon)_
diff --git a/web/pandas_web.py b/web/pandas_web.py
new file mode 100755
index 0000000000000..a34a31feabce0
--- /dev/null
+++ b/web/pandas_web.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""
+Simple static site generator for the pandas web.
+
+pandas_web.py takes a directory as parameter, and copies all the files into the
+target directory after converting markdown files into html and rendering both
+markdown and html files with a context. The context is obtained by parsing
+the file ``config.yml`` in the root of the source directory.
+
+The file should contain:
+```
+main:
+  template_path: <path_to_the_jinja2_templates_directory>
+  base_template: <template_file_all_other_files_will_extend>
+  ignore:
+  - <list_of_files_in_the_source_that_will_not_be_copied>
+  github_repo_url: <organization/repo-name>
+  context_preprocessors:
+  - <list_of_functions_that_will_enrich_the_context_parsed_in_this_file>
+  markdown_extensions:
+  - <list_of_markdown_extensions_that_will_be_loaded>
+```
+
+The rest of the items in the file will be added directly to the context.
+"""
+import argparse
+import datetime
+import importlib
+import operator
+import os
+import re
+import shutil
+import sys
+import time
+import typing
+
+import feedparser
+import jinja2
+import markdown
+import requests
+import yaml
+
+
+class Preprocessors:
+    """
+    Built-in context preprocessors.
+
+    Context preprocessors are functions that receive the context used to
+    render the templates, and enriches it with additional information.
+
+    The original context is obtained by parsing ``config.yml``, and
+    anything else needed just be added with context preprocessors.
+    """
+
+    @staticmethod
+    def navbar_add_info(context):
+        """
+        Items in the main navigation bar can be direct links, or dropdowns with
+        subitems. This context preprocessor adds a boolean field
+        ``has_subitems`` that tells which one of them every element is. It
+        also adds a ``slug`` field to be used as a CSS id.
+        """
+        for i, item in enumerate(context["navbar"]):
+            context["navbar"][i] = dict(
+                item,
+                has_subitems=isinstance(item["target"], list),
+                slug=(item["name"].replace(" ", "-").lower()),
+            )
+        return context
+
+    @staticmethod
+    def blog_add_posts(context):
+        """
+        Given the blog feed defined in the configuration yaml, this context
+        preprocessor fetches the posts in the feeds, and returns the relevant
+        information for them (sorted from newest to oldest).
+        """
+        tag_expr = re.compile("<.*?>")
+        posts = []
+        for feed_url in context["blog"]["feed"]:
+            feed_data = feedparser.parse(feed_url)
+            for entry in feed_data.entries:
+                published = datetime.datetime.fromtimestamp(
+                    time.mktime(entry.published_parsed)
+                )
+                summary = re.sub(tag_expr, "", entry.summary)
+                posts.append(
+                    {
+                        "title": entry.title,
+                        "author": entry.author,
+                        "published": published,
+                        "feed": feed_data["feed"]["title"],
+                        "link": entry.link,
+                        "description": entry.description,
+                        "summary": summary,
+                    }
+                )
+        posts.sort(key=operator.itemgetter("published"), reverse=True)
+        context["blog"]["posts"] = posts[: context["blog"]["num_posts"]]
+        return context
+
+    @staticmethod
+    def maintainers_add_info(context):
+        """
+        Given the active maintainers defined in the yaml file, it fetches
+        the GitHub user information for them.
+        """
+        context["maintainers"]["people"] = []
+        for user in context["maintainers"]["active"]:
+            resp = requests.get(f"https://api.github.com/users/{user}")
+            if context["ignore_io_errors"] and resp.status_code == 403:
+                return context
+            resp.raise_for_status()
+            context["maintainers"]["people"].append(resp.json())
+        return context
+
+    @staticmethod
+    def home_add_releases(context):
+        context["releases"] = []
+
+        github_repo_url = context["main"]["github_repo_url"]
+        resp = requests.get(f"https://api.github.com/repos/{github_repo_url}/releases")
+        if context["ignore_io_errors"] and resp.status_code == 403:
+            return context
+        resp.raise_for_status()
+
+        for release in resp.json():
+            if release["prerelease"]:
+                continue
+            published = datetime.datetime.strptime(
+                release["published_at"], "%Y-%m-%dT%H:%M:%SZ"
+            )
+            context["releases"].append(
+                {
+                    "name": release["tag_name"].lstrip("v"),
+                    "tag": release["tag_name"],
+                    "published": published,
+                    "url": (
+                        release["assets"][0]["browser_download_url"]
+                        if release["assets"]
+                        else ""
+                    ),
+                }
+            )
+        return context
+
+
+def get_callable(obj_as_str: str) -> object:
+    """
+    Get a Python object from its string representation.
+
+    For example, for ``sys.stdout.write`` would import the module ``sys``
+    and return the ``write`` function.
+    """
+    components = obj_as_str.split(".")
+    attrs = []
+    while components:
+        try:
+            obj = importlib.import_module(".".join(components))
+        except ImportError:
+            attrs.insert(0, components.pop())
+        else:
+            break
+
+    if not obj:
+        raise ImportError(f'Could not import "{obj_as_str}"')
+
+    for attr in attrs:
+        obj = getattr(obj, attr)
+
+    return obj
+
+
+def get_context(config_fname: str, ignore_io_errors: bool, **kwargs):
+    """
+    Load the config yaml as the base context, and enrich it with the
+    information added by the context preprocessors defined in the file.
+    """
+    with open(config_fname) as f:
+        context = yaml.safe_load(f)
+
+    context["ignore_io_errors"] = ignore_io_errors
+    context.update(kwargs)
+
+    preprocessors = (
+        get_callable(context_prep)
+        for context_prep in context["main"]["context_preprocessors"]
+    )
+    for preprocessor in preprocessors:
+        context = preprocessor(context)
+        msg = f"{preprocessor.__name__} is missing the return statement"
+        assert context is not None, msg
+
+    return context
+
+
+def get_source_files(source_path: str) -> typing.Generator[str, None, None]:
+    """
+    Generate the list of files present in the source directory.
+    """
+    for root, dirs, fnames in os.walk(source_path):
+        root = os.path.relpath(root, source_path)
+        for fname in fnames:
+            yield os.path.join(root, fname)
+
+
+def extend_base_template(content: str, base_template: str) -> str:
+    """
+    Wrap document to extend the base template, before it is rendered with
+    Jinja2.
+    """
+    result = '{% extends "' + base_template + '" %}'
+    result += "{% block body %}"
+    result += content
+    result += "{% endblock %}"
+    return result
+
+
+def main(
+    source_path: str, target_path: str, base_url: str, ignore_io_errors: bool
+) -> int:
+    """
+    Copy every file in the source directory to the target directory.
+
+    For ``.md`` and ``.html`` files, render them with the context
+    before copyings them. ``.md`` files are transformed to HTML.
+    """
+    config_fname = os.path.join(source_path, "config.yml")
+
+    shutil.rmtree(target_path, ignore_errors=True)
+    os.makedirs(target_path, exist_ok=True)
+
+    sys.stderr.write("Generating context...\n")
+    context = get_context(config_fname, ignore_io_errors, base_url=base_url)
+    sys.stderr.write("Context generated\n")
+
+    templates_path = os.path.join(source_path, context["main"]["templates_path"])
+    jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_path))
+
+    for fname in get_source_files(source_path):
+        if os.path.normpath(fname) in context["main"]["ignore"]:
+            continue
+
+        sys.stderr.write(f"Processing {fname}\n")
+        dirname = os.path.dirname(fname)
+        os.makedirs(os.path.join(target_path, dirname), exist_ok=True)
+
+        extension = os.path.splitext(fname)[-1]
+        if extension in (".html", ".md"):
+            with open(os.path.join(source_path, fname)) as f:
+                content = f.read()
+            if extension == ".md":
+                body = markdown.markdown(
+                    content, extensions=context["main"]["markdown_extensions"]
+                )
+                content = extend_base_template(body, context["main"]["base_template"])
+            content = jinja_env.from_string(content).render(**context)
+            fname = os.path.splitext(fname)[0] + ".html"
+            with open(os.path.join(target_path, fname), "w") as f:
+                f.write(content)
+        else:
+            shutil.copy(
+                os.path.join(source_path, fname), os.path.join(target_path, dirname)
+            )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Documentation builder.")
+    parser.add_argument(
+        "source_path", help="path to the source directory (must contain config.yml)"
+    )
+    parser.add_argument(
+        "--target-path", default="build", help="directory where to write the output"
+    )
+    parser.add_argument(
+        "--base-url", default="", help="base url where the website is served from"
+    )
+    parser.add_argument(
+        "--ignore-io-errors",
+        action="store_true",
+        help="do not fail if errors happen when fetching "
+        "data from http sources, and those fail "
+        "(mostly useful to allow github quota errors "
+        "when running the script locally)",
+    )
+    args = parser.parse_args()
+    sys.exit(
+        main(args.source_path, args.target_path, args.base_url, args.ignore_io_errors)
+    )